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 :ref:`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 :ref:`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 le champ
 221 =========================
 222
 223 +---------------------------------------------------------------+
 224 +---------------------------------------------------------------+
 225 | .. module:: SetFieldFile                                      |
 226 |                                                               |
 227 | **SetFieldFile(field_file)**                                  |
 228 |     Définit le fichier MED des champs utiles                  |
 229 |                                                               |
 230 |     - ``field_file`` : le nom du fichier MED contenant le     |
 231 |       champ                                                   |
 232 +---------------------------------------------------------------+
 233 | .. module:: SetTimeStepRank                                   |
 234 |                                                               |
 235 | **SetTimeStepRank(TimeStep, Rank)**                           |
 236 |     Définit les instants pour le champ                        |
 237 |                                                               |
 238 |     Inutile si aucun instant n'est défini pour le champ       |
 239 |                                                               |
 240 |     Si un seul instant est défini pour le champ, il est pris  |
 241 |     par défaut.                                               |
 242 |                                                               |
 243 |     - ``TimeStep`` : l'instant où est pris le champ           |
 244 |     - ``Rank`` : le numéro d'ordre où est pris le champ       |
 245 +---------------------------------------------------------------+
 246 | .. module:: SetTimeStepRankLast                               |
 247 |                                                               |
 248 | **SetTimeStepRankLast()**                                     |
 249 |     Précise que le dernier instant enregistré pour le champ   |
 250 |     est utilisé                                               |
 251 +---------------------------------------------------------------+
 252 | .. module:: GetFieldFileName                                  |
 253 |                                                               |
 254 | **GetFieldFileName()**                                        |
 255 |     Retourne le nom du fichier MED du champ                   |
 256 +---------------------------------------------------------------+
 257 | .. module:: GetTimeStep                                       |
 258 |                                                               |
 259 | **GetTimeStep()**                                             |
 260 |     Retourne l'instant où est pris le champ                   |
 261 +---------------------------------------------------------------+
 262 | .. module:: GetRank                                           |
 263 |                                                               |
 264 | **GetRank()**                                                 |
 265 |     Retourne le numéro d'ordre où est pris le champ           |
 266 +---------------------------------------------------------------+
 267
 268 Divers
 269 ======
 270
 271 +---------------------------------------------------------------+
 272 +---------------------------------------------------------------+
 273 | .. module:: SetInfoCompute                                    |
 274 |                                                               |
 275 | **SetInfoCompute(MessInfo)**                                  |
 276 |     Précise des options d'informations sur le déroulement du  |
 277 |     calcul de l'itération                                     |
 278 |                                                               |
 279 |     - ``MessInfo`` : entier pilotant des écritures, sous la   |
 280 |       forme d'un entier multiple de 2, 3 et 5                 |
 281 |                                                               |
 282 |         * 1 : aucune écriture (défaut)                        |
 283 |         * 2x : temps de calcul                                |
 284 |         * 3x : fichiers MED                                   |
 285 |         * 5x : mémoire                                        |
 286 +---------------------------------------------------------------+
 287 | .. module:: GetInfoCompute                                    |
 288 |                                                               |
 289 | **GetInfoCompute()**                                          |
 290 |     Retourne les options d'informations sur le déroulement du |
 291 |     calcul de l'itération                                     |
 292 +---------------------------------------------------------------+
 293
 294
 295 Exemple
 296 *******
 297 .. index:: single: maillage;initial
 298
 299 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.
 300 ::
 301
 302     iter_name = "Iteration_1"
 303     iter_1 = case_1.NextIteration(iter_name)
 304     iter_1.SetField(field_file)
 305     iter_1.SetTimeStepRank( 0, 0)
 306     iter_1.SetMeshName("maill_01")
 307     iter_1.SetMeshFile("/local00/M.01.med")
 308     iter_1.AssociateHypo("HypoField")
 309     codret = iter_1.Compute(1, 2)
 310
 311 Ensuite, on crée une itération suivante à l'itération parent de laquelle on part.
 312 ::
 313
 314     iter_name = "Iteration_2"
 315     iter_2 = iter_1.NextIteration(iter_name)
 316     iter_2.SetField(field_file)
 317     iter_2.SetTimeStepRank( 1, 1)
 318     iter_2.SetMeshName("maill_02")
 319     iter_2.SetMeshFile("/local00/M.02.med")
 320     iter_2.AssociateHypo("HypoField")
 321     codret = iter_2.Compute(1, 2)
 322
 323
 324 Saisie graphique correspondante
 325 *******************************
 326 Consulter :ref:`gui_create_iteration`