.. _d7.01.01-operateur:

Écriture de l'opérateur Fortran
===============================

Il s'agit de la routine Fortran principale de la commande, celle dont on a choisi
le nom lors de l'écriture du :ref:`d7.01.01-catalog`.
Lors de l'ajout d'une nouvelle commande, il est nécessaire de déclarer l'*op* associé
dans la routine d'aiguillage ``ex0000.F90`` (fourni).
Chaque routine fortran est complétée par un fichier d'entête à inclure dans chaque
appelant de manière à vérifier les arguments lors de la compilation.
Il s'agit ici de ``bibfor/include/asterfort/op0190.h``.

Le squelette à compléter de la routine est ``bibfor/op/op0190.F90`` :

.. code-block:: fortran

    subroutine op0190()
        implicit none

    #include "asterc/getfac.h"
    #include "asterc/getres.h"
    #include "asterfort/as_allocate.h"
    #include "asterfort/as_deallocate.h"
    #include "asterfort/assert.h"
    #include "asterfort/dismoi.h"
    #include "asterfort/getvid.h"
    #include "asterfort/getvr8.h"
    #include "asterfort/jedema.h"
    #include "asterfort/jemarq.h"
    #include "asterfort/jeveuo.h"

        character(len=8) :: mesh, result
        character(len=16) :: concep, nomcmd
        character(len=19) :: chcoord
        character(len=24) :: vect_coord
        integer :: i, j, iret, dim, nbocc, nbnodes
        real(kind=8), pointer :: vect(:) => null()
        real(kind=8) :: transl(3)
        real(kind=8), pointer :: coord(:) => null()

        call jemarq()

    !   read the input mesh name: maillage_sdaster, see d6.03.01, §2.1.1
        call getvid(..., nbret=iret)
        ASSERT(iret == 1)

    !   read the mesh result (must be identical to the input), see d6.03.01, §2.1.5
        call getres(...)
        ASSERT(result == mesh)

    !   check that TRANSLATION exists, see d6.03.01, §2.1.6
        call getfac('TRANSLATION', nbocc)
        ASSERT(nbocc == 1)

    !   get the size of the translation vector for a dynamic allocation, see d6.03.01, §2.1.1
        call getvr8(..., nbval=0, nbret=dim)
        dim = -dim
        ASSERT(2 <= dim .and. dim <= 3)
    !   allocate the vector of size 'dim'
        AS_ALLOCATE(...)
    !   read the translation vector values
        call getvr8(..., nbval=dim, vect=vect)

    !   name of the jeveux vector containing the coordinates of the mesh
    !   see d4.06.01 for the COORDO object and d4.06.05 for its VALE vector
        chcoord = ...
        vect_coord = ...

    !   get the address and the size of this vector
        call jeveuo(...)
        call dismoi(...)

    !   loop on the nodes
        ...

        call jedema()
    end subroutine


Description détaillé
--------------------

Voir les :ref:`d7.01.01-regles`.

On débute par l'inclusion des fichiers d'interface, puis la déclaration des
variables nécessaires.
Quand la routine a des arguments, on les déclare en premier. La déclaration doit
être identique à celle du fichier d'interface.
On doit préciser si l'argument est en entrée (``integer, intent(in) :: size``),
en sortie (``real(kind=8), intent(out) :: residual``) ou modifié ``inout``.
Un argument peut être optionnel et doit être déclaré comme tel (``optional``).

Toute routine utilisant des objets Jeveux doivent être encadrée par
``call jemarq()``/``call jedema()``. Ceci permet de libérer automatiquement et
au bon moment les objets non utilisés.

Il est recommandé de lire les valeurs des mots-clés dans un endroit unique,
pas au fond de la programmation, éventuellement dans une routine dédiée à la commande
si celle-ci est conséquente.
On utilise les interfaces entre Fortran et le fichier de commandes : routines ``getvxx``,
``getres``, ``getfac``...

``ASSERT`` permet de vérifier qu'il n'y a pas d'erreur de programmation.
Par exemple, on attend un maillage et un seul. Cela est normalement imposé par le
catalogue de commande. Si ``iret`` est différent de 1, c'est une erreur de programmation,
pas d'utilisation.

``AS_ALLOCATE`` permet de faire de l'allocation dynamique (dont la taille n'est pas fixée).
C'est simplement ``allocate`` de Fortran qui est enrobé pour détecter l'oubli de la libération.

Pour accéder aux valeurs des coordonnées, il faut trouver dans la documentation
le nom de l'objet du maillage qui les contient, et dans cet objet, le nom du vecteur
qui contient les valeurs.

On récupère l'adresse du vecteur avec ``jeveuo`` (chercher un exemple d'utilisation
dans le code).

On appelle l'utilitaire ``dismoi`` pour récupérer le nombre de noeuds du maillage
(chercher la documentation de cet utilitaire).


Complétez le squelette et testez votre code : :ref:`d7.01.01-build-dev`.