doc/fr/yacs.rst

   1 .. _yacs:
   2
   3 YACS
   4 ####
   5 .. index:: single: yacs
   6
   7 Introduction
   8 ************
   9
  10 L'utilisation de schémas YACS va permettre de coupler un calcul et une adaptation comme il est décrit dans :ref:`intro`. Ce couplage peut être répété au sein d'une boucle jusqu'à l'obtention d'un critère de convergence par exemple. Il existe de nombreuses façons de programmer un schéma YACS. La solution proposée ici fonctionne mais on peut très bien faire autrement !
  11
  12 On va décrire ici un schéma s'appliquant à un calcul pour lequel on cherche à stabiliser une valeur. Le calcul démarre sur un maillage initial puis HOMARD enchaîne avec une adaptation. On refait un calcul sur ce nouveau maillage et son résultat est analysé. En fonction de cette analyse, le couplage continue ou non. L'allure générale du schéma est la suivante :
  13
  14 .. image:: ../images/yacs_01.png
  15    :align: center
  16    :alt: yacs - allure générale
  17    :width: 535
  18    :height: 362
  19
  20 .. note::
  21   Parmi l'ensemble des données manipulées, certaines sont immuables : le nom du répertoire de calcul, le nom du cas, le nom de l'hypothèse d'adaptation, etc. Il a été choisi de les imposer 'en dur' dans les différents paramètres de service ou au sein des scripts python. On pourrait également les définir a priori dans un noeud PresetNode et ensuite les transmettre par des liens. Nous n'avons pas retenu cette solution car elle augmente fortement le nombre de paramètres et de liens attachés à chaque noeud. Cela est très pénalisant pour la lisibilité du schéma. Les seules données qui vont circuler sont celles imposées par la description du service et celles qui évoluent au cours de l'exécution du schéma.
  22
  23 Les boîtes
  24 **********
  25
  26 Les boîtes principales sont :
  27
  28 - DataInit : initialisation du maillage initial
  29 - Etude_Initialisation : lancement du module HOMARD dans SALOME
  30 - Tant_que_le_calcul_n_a_pas_converge : gestion de la boucle d'alternance calcul/adaptation
  31 - Bilan : affichage final
  32
  33 DataInit
  34 ========
  35 .. image:: ../images/yacs_a_01.png
  36    :align: center
  37    :alt: DataInit
  38    :width: 158
  39    :height: 61
  40
  41 Cette boîte est un noeud élémentaire de type PresetNode. Sa seule fonction est d'initialiser la variable MeshFile qui contient le nom du fichier du maillage initial.
  42
  43 .. literalinclude:: ../files/yacs_01.xml
  44    :lines: 38-42
  45
  46 Etude_Initialisation
  47 ====================
  48 La boîte Etude_Initialisation lance le composant HOMARD dans SALOME. C'est un bloc composé de deux parties, qui sont invariables quelle que soit l'application envisagée :
  49
  50 - StudyCreation : noeud python
  51 - SetCurrentStudy : service du composant HOMARD
  52
  53 .. image:: ../images/yacs_b_01.png
  54    :align: center
  55    :alt: Etude_Initialisation
  56    :width: 323
  57    :height: 97
  58
  59 Le noeud python StudyCreation sert à initialiser l'étude SALOME qui est fournie en sortie :
  60
  61 .. literalinclude:: ../files/yacs_01.xml
  62    :lines: 44-62
  63
  64 Le service SetCurrentStudy affecte cette étude à une instance de HOMARD.
  65
  66 .. literalinclude:: ../files/yacs_01.xml
  67    :lines: 63-68
  68
  69
  70 Tant_que_le_calcul_n_a_pas_converge
  71 ===================================
  72 La boîte Tant_que_le_calcul_n_a_pas_converge est une boucle de type WhileLoop. La condition est initialisée à 1 : le bloc interne Alternance_Calcul_HOMARD est exécuté. Au sein de ce bloc, on calcule et on adapte le maillage ; quand le processus doit s'arrêter soit par suite d'erreur, soit par convergence, la condition passe à 0. La boucle s'achève et on passe à la boîte suivante, Bilan.
  73
  74 .. image:: ../images/yacs_c_01.png
  75    :align: center
  76    :alt: Boucle
  77    :width: 195
  78    :height: 142
  79
  80 Bilan
  81 =====
  82 .. image:: ../images/yacs_d_01.png
  83    :align: center
  84    :alt: Bilan
  85    :width: 158
  86    :height: 63
  87
  88 Cette boîte est un noeud python qui prend en entrée une chaîne de caractères, MessInfo. Si tout s'est bien passé, ce message est vide. Une fenêtre QT apparaît pour confirmer la convergence. S'il y a eu un problème, le message contient les messages émis au cours des calculs. La fenêtre QT affiche ce message.
  89
  90 .. literalinclude:: ../files/yacs_01.xml
  91    :lines: 424-437
  92
  93
  94 La boucle de calculs
  95 ********************
  96 .. image:: ../images/yacs_c_02.png
  97    :align: center
  98    :alt: Boucle
  99    :width: 323
 100    :height: 158
 101
 102 Cette boîte est un bloc qui gère le calcul, l'adaptation et l'analyse.
 103
 104 Calcul
 105 ======
 106 .. image:: ../images/yacs_c_03.png
 107    :align: center
 108    :alt: Calcul
 109    :width: 155
 110    :height: 87
 111
 112 Cette boîte est un noeud python qui va piloter le calcul. En entrée, on trouve le numéro du calcul (0 au départ) et le nom du fichier qui contient le maillage sur lequel calculer. En sortie, on trouve un entier qui représente l'erreur sur ce calcul (0 si tout va bien) et un dictionnaire python rassemblant les résultats du calcul. Le corps du noeud est constitué par le lancement d'un script python qui active le calcul.
 113
 114 .. literalinclude:: ../files/yacs_01.xml
 115    :lines: 77-104
 116
 117 Dans cet exemple, il faut définir :
 118
 119 - rep_calc : le répertoire dans lequel sera exécuté le calcul.
 120 - rep_script : le répertoire dans lequel se trouve le python qui lancera le calcul. Ce répertoire est à ajouter au PATH. Depuis ce répertoire, on importera LanceCas depuis le fichier LanceCas.py
 121
 122 Le python LanceCas est programmé comme l'utilisateur le souhaite pour que le calcul puisse être effectué sur le maillage courant. Selon le mode de lancement du code de calcul, on peut avoir besoin d'autres informations, comme le numéro du calcul ou le répertoire du calcul par exemple. La liberté est totale. Dans notre cas, les arguments d'entrée sont le nom du fichier de maillage, le numéro du calcul et le répertoire de calcul sous la forme de la liste python ["--rep_calc=rep_calc", "--numero=numCalc", "--mesh_file=MeshFile"]
 123 ].
 124
 125 En revanche la sortie du script doit obéir à la règle suivante. On récupère un code d'erreur, un message d'erreur et un dictionnaire. Ce dictionnaire contient obligatoirement les clés suivantes :
 126
 127 - "FileName" : le nom du fichier qui contient les résultats du calcul
 128 - "MeshName" : le nom du maillage utilisé
 129 - "V00" : la valeur dont on veut tester la convergence
 130
 131 Adaptation
 132 ==========
 133 .. image:: ../images/yacs_c_04.png
 134    :align: center
 135    :alt: Adaptation
 136    :width: 672
 137    :height: 569
 138
 139 La boîte Adaptation est un noeud Switch piloté par le code d'erreur du calcul précédent. Si ce code est nul, YACS activera la boîte Adaptation_HOMARD qui lancera l'adaptation. Si le code n'est pas nul, on passe directement dans la boîte Arret_boucle.
 140
 141 Adaptation_HOMARD
 142 -----------------
 143 La première tâche à exécuter concerne l'initialisation des données nécessaires à HOMARD dans la boîte HOMARD_Initialisation. Cette boîte est un noeud switch piloté par le numéro du calcul. Au démarrage, le numéro est nul et YACS active la boîte Homard_init_au_debut.
 144
 145 Homard_init_au_debut
 146 ^^^^^^^^^^^^^^^^^^^^
 147 .. image:: ../images/yacs_c_06.png
 148    :align: center
 149    :alt: Homard_init_au_debut
 150    :width: 481
 151    :height: 150
 152
 153 Cette boîte commence par créer le cas HOMARD en appelant le service CreateCase.
 154
 155 .. literalinclude:: ../files/yacs_01.xml
 156    :lines: 220-227
 157
 158 Le nom du cas CaseName est imposé à "Calcul". Les paramètres d'entrée MeshName et FileName sont issus de la sortie du calcul précédent. Le paramètre de sortie est une instance de cas.
 159
 160 .. literalinclude:: ../files/yacs_01.xml
 161    :lines: 461-464
 162
 163 Les options de ce cas doivent maintenant être renseignées. C'est fait par le noeud python CaseOptions. Il est impératif de renseigner le répertoire de calcul. On regardera la description des fonctions dans :ref:`tui_create_case`. En sortie, on récupère l'instance de l'itération correspondant à l'état initial du cas.
 164
 165 .. literalinclude:: ../files/yacs_01.xml
 166    :lines: 228-242
 167
 168 Enfin, une hypothèse est créée en appelant le service CreateHypothèse. Le paramètre de sortie est une instance d'hypothèse.
 169
 170 Homard_Exec
 171 ^^^^^^^^^^^
 172 Une fois initialisée, l'adaptation peut être calculée. C'est le but de la boîte Homard_Exec, sous forme d'un script python.
 173
 174 .. image:: ../images/yacs_c_09.png
 175    :align: center
 176    :alt: Homard_Exec
 177    :width: 153
 178    :height: 141
 179
 180 Le répertoire de calcul est récupéré.
 181
 182 .. literalinclude:: ../files/yacs_01.xml
 183    :lines: 258-263
 184
 185 ../..
 186
 187 .. literalinclude:: ../files/yacs_01.xml
 188    :lines: 339-347
 189
 190 L'hypothèse transmise en paramètre d'entrée est caractérisée (voir :ref:`tui_create_hypothese`) :
 191
 192 .. literalinclude:: ../files/yacs_01.xml
 193    :lines: 267-291
 194
 195 Il faut établir un nom pour la future itération. Pour s'assurer que le nom n'a jamais été utilisé, on met en place un mécanisme de nommage incrémental à partir du nom de l'itération initiale. Comme ce nom initial est le nom du maillage initial, on obtient une succession de noms sous la forme : M_001, M_002, M_003, etc.
 196
 197 .. literalinclude:: ../files/yacs_01.xml
 198    :lines: 293-303
 199
 200 L'itération est complétée : hypothèse, futur maillage, champ (voir :ref:`tui_create_iteration`) :
 201
 202 .. literalinclude:: ../files/yacs_01.xml
 203    :lines: 305-325
 204
 205 L'itération est calculée. Si tout s'est bien passé, la variable OK vaut 1 : on pourra continuer l'exécution du schéma. S'il y a eu un problème, la variable OK vaut 0 pour signifier que le calcul doit s'arrêter ; on donne alors un message d'erreur.
 206
 207 .. literalinclude:: ../files/yacs_01.xml
 208    :lines: 327-338
 209
 210 Après cette exécution, le processus sort du noeud Adaptation_HOMARD, puis du noeud Adaptation. On arrive alors au noeud d'analyse.
 211
 212 Homard_init_ensuite
 213 ^^^^^^^^^^^^^^^^^^^
 214 .. image:: ../images/yacs_c_07.png
 215    :align: center
 216    :alt: Homard_init_ensuite
 217    :width: 323
 218    :height: 97
 219
 220 Aux passages suivants dans le bloc d'adaptation, il faut récupérer :
 221
 222 - la dernière itération créée pour la poursuivre : service LastIteration (voir :ref:`tui_create_iteration`)
 223 - l'hypothèse créée : service GetHypothesis (voir :ref:`tui_create_hypothese`)
 224
 225 On passe ensuite dans le noeud Homard_Exec pour calculer le nouveau maillage.
 226
 227 Arret_boucle
 228 ------------
 229 .. image:: ../images/yacs_c_08.png
 230    :align: center
 231    :alt: Arret_boucle
 232    :width: 163
 233    :height: 152
 234
 235 Le bloc Arret_boucle n'est présent que pour faire transiter des variables car les paramètres d'entrée des noeuds doivent toujours être remplis. C'est un python très simple :
 236
 237 .. literalinclude:: ../files/yacs_01.xml
 238    :lines: 185-196
 239
 240 Analyse
 241 =======
 242 .. image:: ../images/yacs_c_05.png
 243    :align: center
 244    :alt: Analyse
 245    :width: 155
 246    :height: 169
 247
 248 Le bloc Analyse est un script python qui assure le contrôle complet du processus en examinant successivement les causes d'erreur possible.
 249
 250 .. literalinclude:: ../files/yacs_01.xml
 251    :lines: 105-118
 252
 253 ../..
 254
 255 .. literalinclude:: ../files/yacs_01.xml
 256    :lines: 173-182
 257
 258 On commence par analyser le retour du code de calcul :
 259
 260 .. literalinclude:: ../files/yacs_01.xml
 261    :lines: 120-125
 262
 263 Vérification de la présence du nom du maillage dans le dictionnaire des résultats :
 264
 265 .. literalinclude:: ../files/yacs_01.xml
 266    :lines: 127-134
 267
 268 Vérification de la présence du nom du fichier de résultats dans le dictionnaire des résultats :
 269
 270 .. literalinclude:: ../files/yacs_01.xml
 271    :lines: 136-143
 272
 273 Vérification de la convergence. Cela suppose que la valeur à tester est présente dans le dictionnaire sous la clé 'V00'. Ici, on a mis en place un test sur la variation de la valeur d'un calcul à l'autre. Au premier passage, on ne teste rien. Aux passages suivants, on teste si la variation relative est inférieure à 1 millième. On aurait pu mettre en place un test absolu si on avait récupéré un niveau global d'erreur par exemple.
 274
 275 .. literalinclude:: ../files/yacs_01.xml
 276    :lines: 145-163
 277
 278 Enfin, on vérifie que l'on ne dépasse pas un nomber maximal d'adaptations :
 279
 280 .. literalinclude:: ../files/yacs_01.xml
 281    :lines: 165-170
 282
 283
 284 Utiliser ce schéma
 285 ******************
 286 Pour reproduire cet exemple, on pourra télécharger :
 287   * :download:`le schéma <../files/yacs_01.xml>`
 288   * :download:`un exemple de script python <../files/yacs_script.tgz>`
 289
 290 Il faut l'adapter à la simulation envisagée. En particulier, il faut :
 291
 292 - ajuster les noms des fichiers et des répertoires
 293 - fournir un script de lancement du calcul respectant les consignes évoquées ci-avant
 294 - choisir les hypothèses de pilotage de l'adaptation
 295 - mettre en place le test d'arrêt
 296
 297
 298