doc/fr/tui_create_iteration.rst

   1 .. _tui_create_iteration:
   2
   3 L'itération
   4 ###########
   5
   6 .. index:: single: itération
   7 .. index:: single: hypothèse
   8 .. index:: single: zone
   9
  10 Les variables sont décrites dans :doc:`gui_create_iteration`.
  11
  12 Méthodes de la classe homard
  13 ****************************
  14
  15 +---------------------------------------------------------------+
  16 +---------------------------------------------------------------+
  17 | .. module:: GetIteration                                      |
  18 |                                                               |
  19 | **GetIteration(iter_name)**                                   |
  20 |     Retourne l'instance de la classe ``iteration`` connue par |
  21 |     son nom                                                   |
  22 |                                                               |
  23 |     - ``iter_name`` : le nom de l'itération                   |
  24 +---------------------------------------------------------------+
  25 | .. module:: GetAllIterationsName                              |
  26 |                                                               |
  27 | **GetAllIterationsName()**                                    |
  28 |     Retourne la liste des noms de toutes les itérations créées|
  29 |                                                               |
  30 +---------------------------------------------------------------+
  31
  32 Méthodes communes aux classes cas et iteration
  33 **********************************************
  34 Voir également dans :doc:`tui_create_case`.
  35
  36 +---------------------------------------------------------------+
  37 +---------------------------------------------------------------+
  38 | .. module:: NextIteration                                     |
  39 |                                                               |
  40 | **NextIteration(iter_name)**                                  |
  41 |     Retourne une instance de la classe ``iteration`` après    |
  42 |     sa création. Elle suit immédiatement :                    |
  43 |                                                               |
  44 |     - pour un cas : l'itération initiale, correspondant au    |
  45 |       maillage définissant le cas                             |
  46 |     - pour une itération : l'itération courante               |
  47 |                                                               |
  48 | Par défaut, le maillage produit a le même nom que l'itération |
  49 |                                                               |
  50 |     - ``iter_name`` : le nom à donner à la nouvelle itération |
  51 +---------------------------------------------------------------+
  52 | .. module:: LastIteration                                     |
  53 |                                                               |
  54 | **LastIteration()**                                           |
  55 |     Retourne une instance de la classe ``iteration``. C'est   |
  56 |     la dernière créée dans la descendance de :                |
  57 |                                                               |
  58 |     - pour un cas : l'itération initiale du cas               |
  59 |     - pour une itération : l'itération courante               |
  60 |                                                               |
  61 |     C'est celle qui est sans fille. Il y a erreur s'il existe |
  62 |     plus d'une branche dans la descendance.                   |
  63 |                                                               |
  64 +---------------------------------------------------------------+
  65
  66 Méthodes de la classe iteration
  67 *******************************
  68
  69 Généralités
  70 ===========
  71
  72 +---------------------------------------------------------------+
  73 +---------------------------------------------------------------+
  74 | .. module:: Compute                                           |
  75 |                                                               |
  76 | **Compute(option1, option2)**                                 |
  77 |     Calcule le maillage correspondant à l'itération           |
  78 |                                                               |
  79 |     - ``option1`` : un entier précisant ce qui se passe quand |
  80 |       des fichiers de résultats existent déjà                 |
  81 |                                                               |
  82 |         * 0 : arrêt en erreur                                 |
  83 |         * 1 : écrasement des anciens fichiers                 |
  84 |                                                               |
  85 |     - ``option2`` : un entier précisant ce qui est fait des   |
  86 |       résultats                                               |
  87 |                                                               |
  88 |         * 1 : aucune action particulière                      |
  89 |         * 2 : publication dans le module SMESH                |
  90 |                                                               |
  91 |     Retourne un entier :                                      |
  92 |         * 0 : adaptation réussie                              |
  93 |         * autre valeur : problème                             |
  94 +---------------------------------------------------------------+
  95 | .. module:: GetName                                           |
  96 |                                                               |
  97 | **GetName()**                                                 |
  98 |     Retourne le nom de l'itération                            |
  99 +---------------------------------------------------------------+
 100 | .. module:: GetNumber                                         |
 101 |                                                               |
 102 | **GetNumber()**                                               |
 103 |     Retourne le numéro de l'itération.                        |
 104 |                                                               |
 105 |     L'itération 0 est celle associée au maillage initial.     |
 106 |     Ensuite, une itération de numéro N est issue de           |
 107 |     l'adaptation d'une itération de numéro N-1.               |
 108 +---------------------------------------------------------------+
 109 | .. module:: GetIterParent                                     |
 110 |                                                               |
 111 | **GetIterParent()**                                           |
 112 |     Retourne l'itération mère                                 |
 113 +---------------------------------------------------------------+
 114 | .. module:: AssociateHypo                                     |
 115 |                                                               |
 116 | **AssociateHypo(hypo_name)**                                  |
 117 |     Associe une hypothèse à l'itération                       |
 118 |                                                               |
 119 |     - ``hypo_name`` : le nom de l'hypothèse à associer        |
 120 +---------------------------------------------------------------+
 121 | .. module:: GetHypoName                                       |
 122 |                                                               |
 123 | **GetHypoName()**                                             |
 124 |     Retourne le nom de l'hypothèse associée                   |
 125 +---------------------------------------------------------------+
 126 | .. module:: GetCaseName                                       |
 127 |                                                               |
 128 | **GetCaseName()**                                             |
 129 |     Retourne le nom du cas associé                            |
 130 +---------------------------------------------------------------+
 131 | .. module:: GetState                                          |
 132 |                                                               |
 133 | **GetState()**                                                |
 134 |     Retourne l'état de l'itération                            |
 135 |                                                               |
 136 |     - ``2`` : itération calculée correctement                 |
 137 |     - ``1`` : itération non calculée                          |
 138 |     - ``<=0`` : itération initiale à ne pas calculer, de      |
 139 |       numéro valant la valeur absolue de l'état               |
 140 +---------------------------------------------------------------+
 141 | .. module:: GetLogFile                                        |
 142 |                                                               |
 143 | **GetLogFile()**                                              |
 144 |     Retourne le nom du fichier retraçant le déroulement de    |
 145 |     l'exécution de HOMARD                                     |
 146 +---------------------------------------------------------------+
 147 | .. module:: GetFileInfo                                       |
 148 |                                                               |
 149 | **GetFileInfo()**                                             |
 150 |     Retourne le nom du fichier contenant l'analyse du maillage|
 151 +---------------------------------------------------------------+
 152 | .. module:: GetDirName                                        |
 153 |                                                               |
 154 | **GetDirName()**                                              |
 155 |     Retourne le nom du répertoire des résutats associé à      |
 156 |     l'itération                                               |
 157 +---------------------------------------------------------------+
 158 | .. module:: Delete                                            |
 159 |                                                               |
 160 | **Delete(option)**                                            |
 161 |     Detruit l'itération et toutes ses filles éventuelles.     |
 162 |                                                               |
 163 |     - ``option`` : un entier précisant ce qui est fait des    |
 164 |       fichiers de maillage associés                           |
 165 |                                                               |
 166 |         * 0 : les fichiers sont conservés                     |
 167 |         * 1 : les fichiers sont détruits                      |
 168 |                                                               |
 169 |     Retourne un entier :                                      |
 170 |         * 0 : destruction réussie                             |
 171 |         * autre valeur : problème                             |
 172 +---------------------------------------------------------------+
 173
 174 Informations sur les maillages
 175 ==============================
 176
 177 +---------------------------------------------------------------+
 178 +---------------------------------------------------------------+
 179 | .. module:: SetMeshName                                       |
 180 |                                                               |
 181 | **SetMeshName(mesh_name)**                                    |
 182 |     Définit le nom du maillage produit                        |
 183 |                                                               |
 184 |     - ``mesh_name`` : le nom du maillage produit              |
 185 +---------------------------------------------------------------+
 186 | .. module:: GetMeshName                                       |
 187 |                                                               |
 188 | **GetMeshName()**                                             |
 189 |     Retourne le nom du maillage produit                       |
 190 +---------------------------------------------------------------+
 191 | .. module:: SetMeshFile                                       |
 192 |                                                               |
 193 | **SetMeshFile(mesh_file)**                                    |
 194 |     Définit le fichier MED du maillage produit                |
 195 |                                                               |
 196 |     - ``mesh_file`` : le nom du fichier MED qui contiendra    |
 197 |       le maillage produit                                     |
 198 +---------------------------------------------------------------+
 199 | .. module:: GetMeshFile                                       |
 200 |                                                               |
 201 | **GetMeshFile()**                                             |
 202 |     Retourne le nom du fichier MED du maillage produit        |
 203 +---------------------------------------------------------------+
 204 | .. module:: MeshInfo                                          |
 205 |                                                               |
 206 | **MeshInfo(Qual, Diam, Conn, Tail, Inte)**                    |
 207 |     Donne des informations sur le maillage. Pour chaque       |
 208 |     option, le choix 0 correspond à ne rien faire, alors que  |
 209 |     le choix 1 active l'option.                               |
 210 |                                                               |
 211 |     - ``Qual`` : qualité des mailles                          |
 212 |     - ``Diam`` : diamètre des mailles                         |
 213 |     - ``Conn`` : connexité du domaine ; en un seul morceau,   |
 214 |       combien de trous, etc.                                  |
 215 |     - ``Tail`` : tailles des constituants du domaine, groupe  |
 216 |       par groupe                                              |
 217 |     - ``Inte`` : interpénétration des mailles, par dimension  |
 218 +---------------------------------------------------------------+
 219
 220 Informations sur les champs
 221 ===========================
 222
 223 Le fichier des champs
 224 ---------------------
 225
 226 +---------------------------------------------------------------+
 227 +---------------------------------------------------------------+
 228 | .. module:: SetFieldFile                                      |
 229 |                                                               |
 230 | **SetFieldFile(field_file)**                                  |
 231 |     Définit le fichier MED des champs utiles                  |
 232 |                                                               |
 233 |     - ``field_file`` : le nom du fichier MED contenant les    |
 234 |       champs : champ de pilotage de l'adaptation ou champs    |
 235 |       à interpoler                                            |
 236 +---------------------------------------------------------------+
 237 | .. module:: GetFieldFileName                                  |
 238 |                                                               |
 239 | **GetFieldFileName()**                                        |
 240 |     Retourne le nom du fichier MED des champs                 |
 241 +---------------------------------------------------------------+
 242
 243 Les instants pour le champ de pilotage
 244 --------------------------------------
 245 Si une seule occurence du champ de pilotage de l'adaptation est présente dans le fichier des champs, il est inutile de préciser le pas de temps. Sinon, il faut préciser quel pas de temps est retenu.
 246
 247 +---------------------------------------------------------------+
 248 +---------------------------------------------------------------+
 249 | .. module:: SetTimeStep                                       |
 250 |                                                               |
 251 | **SetTimeStep(TimeStep)**                                     |
 252 |     Définit l'instant pour le champ de pilotage. Le numéro    |
 253 |     d'ordre sera ignoré.                                      |
 254 |                                                               |
 255 |     - ``TimeStep`` : l'instant où est pris le champ           |
 256 +---------------------------------------------------------------+
 257 | .. module:: SetTimeStepRank                                   |
 258 |                                                               |
 259 | **SetTimeStepRank(TimeStep, Rank)**                           |
 260 |     Définit l'instant et le numéro d'ordre pour le champ de   |
 261 |     pilotage                                                  |
 262 |                                                               |
 263 |     - ``TimeStep`` : l'instant où est pris le champ           |
 264 |     - ``Rank`` : le numéro d'ordre où est pris le champ       |
 265 +---------------------------------------------------------------+
 266 | .. module:: SetTimeStepRankLast                               |
 267 |                                                               |
 268 | **SetTimeStepRankLast()**                                     |
 269 |     Précise que le dernier instant enregistré pour le champ   |
 270 |     de pilotage est utilisé                                   |
 271 +---------------------------------------------------------------+
 272 | .. module:: GetTimeStep                                       |
 273 |                                                               |
 274 | **GetTimeStep()**                                             |
 275 |     Retourne l'instant où est pris le champ de pilotage       |
 276 +---------------------------------------------------------------+
 277 | .. module:: GetRank                                           |
 278 |                                                               |
 279 | **GetRank()**                                                 |
 280 |     Retourne le numéro d'ordre où est pris le champ de        |
 281 |     pilotage                                                  |
 282 +---------------------------------------------------------------+
 283
 284 Les instants pour les champs à interpoler
 285 -----------------------------------------
 286
 287 Les champs à interpoler sont définis dans l'hypothèse (voir :doc:`tui_create_hypothese`).
 288 Pour un champ donné, si aucune mention de pas de temps n'est précisé, tous les pas de temps seront pris en compte.
 289 Si on souhaite limiter l'interpolation à un ou plusieurs pas de temps, il faut le préciser ici.
 290
 291 +---------------------------------------------------------------+
 292 +---------------------------------------------------------------+
 293 | .. module:: SetFieldInterpTimeStep                            |
 294 |                                                               |
 295 | **SetFieldInterpTimeStep(FieldName, TimeStep)**               |
 296 |     Définit un instant pour le champ à interpoler. Le numéro  |
 297 |     d'ordre sera ignoré.                                      |
 298 |                                                               |
 299 |     - ``FieldName`` : le nom du champ à interpoler            |
 300 |     - ``TimeStep`` : l'instant où est pris le champ           |
 301 +---------------------------------------------------------------+
 302 | .. module:: SetFieldInterpTimeStepRank                        |
 303 |                                                               |
 304 | **SetFieldInterpTimeStepRank(FieldName, TimeStep)**           |
 305 |     Définit l'instant et le numéro d'ordre pour le champ à    |
 306 |     interpoler.                                               |
 307 |                                                               |
 308 |     - ``FieldName`` : le nom du champ à interpoler            |
 309 |     - ``TimeStep`` : l'instant où est pris le champ           |
 310 |     - ``Rank`` : le numéro d'ordre où est pris le champ       |
 311 +---------------------------------------------------------------+
 312 | .. module:: GetFieldInterpsTimeStepRank                       |
 313 |                                                               |
 314 | **GetFieldInterpsTimeStepRank()**                             |
 315 |     Retourne l'ensemble des triplets (nom du champ, pas de    |
 316 |     temps, numéro d'ordre)                                    |
 317 |                                                               |
 318 |     Attention : l'usage est stocké sous forme de chaîne de    |
 319 |     caractères et non pas d'entier dans la liste.             |
 320 |                                                               |
 321 |     Exemple : ['DEPL', '1', '1', 'DEPL', '2', '1', 'Masse',   |
 322 |     '2', '0', 'Masse', '3', '0']                              |
 323 +---------------------------------------------------------------+
 324
 325 Divers
 326 ======
 327
 328 +---------------------------------------------------------------+
 329 +---------------------------------------------------------------+
 330 | .. module:: SetInfoCompute                                    |
 331 |                                                               |
 332 | **SetInfoCompute(MessInfo)**                                  |
 333 |     Précise des options d'informations sur le déroulement du  |
 334 |     calcul de l'itération                                     |
 335 |                                                               |
 336 |     - ``MessInfo`` : entier pilotant des écritures, sous la   |
 337 |       forme d'un entier multiple de 2, 3 et 5                 |
 338 |                                                               |
 339 |         * 1 : aucune écriture (défaut)                        |
 340 |         * 2x : temps de calcul                                |
 341 |         * 3x : fichiers MED                                   |
 342 |         * 5x : mémoire                                        |
 343 +---------------------------------------------------------------+
 344 | .. module:: GetInfoCompute                                    |
 345 |                                                               |
 346 | **GetInfoCompute()**                                          |
 347 |     Retourne les options d'informations sur le déroulement du |
 348 |     calcul de l'itération                                     |
 349 +---------------------------------------------------------------+
 350
 351
 352 Exemple
 353 *******
 354 .. index:: single: maillage;initial
 355
 356 Pour la création de la première itération, on part de celle qui correspond au maillage initial. C'est celle contenue dans le cas.
 357 ::
 358
 359     iter_name = "Iteration_1"
 360     iter_1 = case_1.NextIteration(iter_name)
 361     iter_1.SetField(field_file)
 362     iter_1.SetTimeStepRank( 0, 0)
 363     iter_1.SetMeshName("maill_01")
 364     iter_1.SetMeshFile("/local00/M.01.med")
 365     iter_1.AssociateHypo("HypoField")
 366     codret = iter_1.Compute(1, 2)
 367
 368 Ensuite, on crée une itération suivante à l'itération parent de laquelle on part.
 369 ::
 370
 371     iter_name = "Iteration_2"
 372     iter_2 = iter_1.NextIteration(iter_name)
 373     iter_2.SetField(field_file)
 374     iter_2.SetTimeStepRank( 1, 1)
 375     iter_2.SetMeshName("maill_02")
 376     iter_2.SetMeshFile("/local00/M.02.med")
 377     iter_2.AssociateHypo("HypoField")
 378     codret = iter_2.Compute(1, 2)
 379
 380
 381 Saisie graphique correspondante
 382 *******************************
 383 Consulter :doc:`gui_create_iteration`