doc/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:: CreateIteration                                   |
  18 |                                                               |
  19 | **CreateIteration(iter_name, iter_parent_name)**              |
  20 |     Retourne une instance de la classe ``iteration`` après    |
  21 |     sa création                                               |
  22 |                                                               |
  23 |     - ``iter_name`` : le nom de l'itération                   |
  24 |     - ``iter_parent_name`` : le nom de l'itération mère       |
  25 |                                                               |
  26 | Par défaut :                                                  |
  27 |                                                               |
  28 |  * le maillage produit a le même nom que l'itération          |
  29 +---------------------------------------------------------------+
  30 | .. module:: AssociateIterHypo                                 |
  31 |                                                               |
  32 | **AssociateIterHypo(iter_name, hypo_name)**                   |
  33 |     Associe une hypothèse à une itération                     |
  34 |                                                               |
  35 |     - ``iter_name`` : le nom de l'itération                   |
  36 |     - ``hypo_name`` : le nom de l'hypothèse à associer        |
  37 +---------------------------------------------------------------+
  38 | .. module:: GetIteration                                      |
  39 |                                                               |
  40 | **GetIteration(iter_name)**                                   |
  41 |     Retourne l'instance de la classe ``iteration`` connue par |
  42 |     son nom                                                   |
  43 |                                                               |
  44 |     - ``iter_name`` : le nom de l'itération                   |
  45 +---------------------------------------------------------------+
  46 | .. module:: GetAllIterations                                  |
  47 |                                                               |
  48 | **GetAllIterations()**                                        |
  49 |     Retourne la liste des noms de toutes les itérations créées|
  50 |                                                               |
  51 +---------------------------------------------------------------+
  52
  53 Méthodes de la classe iteration
  54 """""""""""""""""""""""""""""""
  55
  56 Généralités
  57 ^^^^^^^^^^^
  58
  59 +---------------------------------------------------------------+
  60 +---------------------------------------------------------------+
  61 | .. index:: single: Compute                                    |
  62 |                                                               |
  63 | **Compute(option)**                                           |
  64 |     Calcule le maillage correspondant à l'itération           |
  65 |                                                               |
  66 |     - ``option`` : un entier précisant ce qui se passe quand  |
  67 |       des fichiers de résultats existent déjà                 |
  68 |                                                               |
  69 |         * 0 : arrêt en erreur                                 |
  70 |         * 1 : écrasement des anciens fichiers                 |
  71 |                                                               |
  72 |     Retourne un entier :                                      |
  73 |         * 0 : adaptation réussie                              |
  74 |         * autre valeur : problème                             |
  75 +---------------------------------------------------------------+
  76 | .. module:: GetName                                           |
  77 |                                                               |
  78 | **GetName()**                                                 |
  79 |     Retourne le nom de l'itération                            |
  80 +---------------------------------------------------------------+
  81 | .. module:: GetNumber                                         |
  82 |                                                               |
  83 | **GetNumber()**                                               |
  84 |     Retourne le numéro de l'itération.                        |
  85 |                                                               |
  86 |     L'itération 0 est celle associée au maillage initial.     |
  87 |     Ensuite, une itération de numéro N est issue de           |
  88 |     l'adaptation d'une itération de numéro N-1.               |
  89 +---------------------------------------------------------------+
  90 | .. module:: GetIterParent                                     |
  91 |                                                               |
  92 | **GetIterParent()**                                           |
  93 |     Retourne le nom de l'itération mère                       |
  94 +---------------------------------------------------------------+
  95 | .. module:: GetHypoName                                       |
  96 |                                                               |
  97 | **GetHypoName()**                                             |
  98 |     Retourne le nom de l'hypothèse associée                   |
  99 +---------------------------------------------------------------+
 100 | .. module:: GetCaseName                                       |
 101 |                                                               |
 102 | **GetCaseName()**                                             |
 103 |     Retourne le nom du cas associé                            |
 104 +---------------------------------------------------------------+
 105 | .. module:: GetState                                          |
 106 |                                                               |
 107 | **GetState()**                                                |
 108 |     Retourne l'état de l'itération                            |
 109 |                                                               |
 110 |     - ``0`` : itération non calculée                          |
 111 |     - ``1`` : itération calculée correctement                 |
 112 +---------------------------------------------------------------+
 113
 114 Informations sur les maillages
 115 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 116
 117 +---------------------------------------------------------------+
 118 +---------------------------------------------------------------+
 119 | .. module:: GetMeshName                                       |
 120 |                                                               |
 121 | **GetMeshName()**                                             |
 122 |     Retourne le nom du maillage produit                       |
 123 +---------------------------------------------------------------+
 124 | .. module:: SetMeshFile                                       |
 125 |                                                               |
 126 | **SetMeshFile(mesh_file)**                                    |
 127 |     Définit le fichier du maillage produit                    |
 128 |                                                               |
 129 |     - ``mesh_file`` : le nom du fichier qui contiendra        |
 130 |       le maillage produit                                     |
 131 +---------------------------------------------------------------+
 132 | .. module:: GetMeshFile                                       |
 133 |                                                               |
 134 | **GetMeshFile()**                                             |
 135 |     Retourne le nom du fichier du maillage produit            |
 136 +---------------------------------------------------------------+
 137
 138 Informations sur le champ
 139 ^^^^^^^^^^^^^^^^^^^^^^^^^
 140
 141 +---------------------------------------------------------------+
 142 +---------------------------------------------------------------+
 143 | .. module:: SetFieldFile                                      |
 144 |                                                               |
 145 | **SetFieldFile(field_file)**                                  |
 146 |     Définit le fichier des champs utiles                      |
 147 |                                                               |
 148 |     - ``field_file`` : le nom du fichier contenant le champ   |
 149 +---------------------------------------------------------------+
 150 | .. module:: SetTimeStepRank                                   |
 151 |                                                               |
 152 | **SetTimeStepRank(TimeStep, Rank)**                           |
 153 |     Définit les instants pour le champ                        |
 154 |                                                               |
 155 |     Inutile si aucun instant n'est défini pour le champ       |
 156 |                                                               |
 157 |     - ``TimeStep`` : l'instant où est pris le champ           |
 158 |     - ``Rank`` : le numéro d'ordre où est pris le champ       |
 159 +---------------------------------------------------------------+
 160 | .. module:: GetFieldFileName                                  |
 161 |                                                               |
 162 | **GetFieldFileName()**                                        |
 163 |     Retourne le nom du fichier du champ                       |
 164 +---------------------------------------------------------------+
 165 | .. module:: GetTimeStep                                       |
 166 |                                                               |
 167 | **GetTimeStep()**                                             |
 168 |     Retourne l'instant où est pris le champ                   |
 169 +---------------------------------------------------------------+
 170 | .. module:: GetRank                                           |
 171 |                                                               |
 172 | **GetRank()**                                                 |
 173 |     Retourne le numéro d'ordre où est pris le champ           |
 174 +---------------------------------------------------------------+
 175
 176 Exemple
 177 """""""
 178 .. index:: single: maillage;initial
 179
 180 Pour la création de la première itération, il faut récupérer le nom qui a été donné à celle qui correspond au maillage initial. Ce nom s'obtient avec la méthode ``GetIter0Name`` appliquée au cas. ::
 181
 182     iter_name = "Iteration_1"
 183     iter_1 = homard.CreateIteration(iter_name, case_1.GetIter0Name())
 184     iter_1.SetField(field_file)
 185     iter_1.SetTimeStepRank( 0, 0)
 186     iter_1.SetMeshName("maill_01")
 187     iter_1.SetMeshFile("/local00/M.01.med")
 188     homard.AssociateIterHypo(iter_name, "HypoField")
 189     codret = iter_1.Compute(1)
 190
 191 Pour la création d'une itération suivante, on donnera le nom de l'itération parent de laquelle on part. ::
 192
 193     iter_name = "Iteration_2"
 194     iter_2 = homard.CreateIteration(iter_name, "Iteration_1")
 195     iter_2.SetField(field_file)
 196     iter_2.SetTimeStepRank( 1, 1)
 197     iter_2.SetMeshName("maill_02")
 198     iter_2.SetMeshFile("/local00/M.02.med")
 199     homard.AssociateIterHypo(iter_name, "HypoField")
 200     codret = iter_2.Compute(1)
 201
 202
 203 Saisie graphique correspondante
 204 """""""""""""""""""""""""""""""
 205 Consulter :ref:`gui_create_iteration`