doc/fr/tui_create_case.rst

   1 .. _tui_create_case:
   2
   3 Le cas
   4 ######
   5 .. index:: single: cas
   6 .. index:: single: type de conformité
   7 .. index:: single: maillage;initial
   8
   9 Les variables sont décrites dans :doc:`gui_create_case`.
  10
  11 Méthodes de la classe homard
  12 ****************************
  13
  14 Création d'un cas
  15 =================
  16
  17 +---------------------------------------------------------------+
  18 +---------------------------------------------------------------+
  19 | .. module:: CreateCase                                        |
  20 |                                                               |
  21 | **CreateCase(case_name, mesh_name, mesh_file)**               |
  22 |     Retourne une instance de la classe ``cas`` après sa       |
  23 |     création                                                  |
  24 |                                                               |
  25 |     - ``case_name`` : le nom du cas                           |
  26 |     - ``mesh_name`` : le nom du maillage initial              |
  27 |     - ``mesh_file`` : le nom du fichier MED contenant ce      |
  28 |       ce maillage                                             |
  29 |                                                               |
  30 | Par défaut :                                                  |
  31 |                                                               |
  32 |  * le répertoire des résultats est ``/tmp``                   |
  33 |  * l'adaptation est conforme                                  |
  34 +---------------------------------------------------------------+
  35 | .. module:: GetCase                                           |
  36 |                                                               |
  37 | **GetCase(case_name)**                                        |
  38 |     Retourne l'instance de la classe ``cas`` connue par       |
  39 |     son nom                                                   |
  40 |                                                               |
  41 |     - ``case_name`` : le nom du cas                           |
  42 +---------------------------------------------------------------+
  43 | .. module:: GetAllCasesName                                   |
  44 |                                                               |
  45 | **GetAllCasesName()**                                         |
  46 |     Retourne la liste des noms de tous les cas existant       |
  47 |                                                               |
  48 +---------------------------------------------------------------+
  49
  50 Création d'un cas par poursuite d'une itération calculée
  51 ========================================================
  52
  53 +---------------------------------------------------------------+
  54 +---------------------------------------------------------------+
  55 | .. module:: CreateCaseFromIteration                           |
  56 |                                                               |
  57 | **CreateCaseFromIteration(case_name, dir_name)**              |
  58 |     Retourne une instance de la classe ``cas`` après sa       |
  59 |     création                                                  |
  60 |                                                               |
  61 |     - ``case_name`` : le nom du cas                           |
  62 |     - ``dir_name``  : le nom du répertoire contenant          |
  63 |       l'itération à poursuivre                                |
  64 |                                                               |
  65 +---------------------------------------------------------------+
  66 | .. module:: CreateCaseFromCaseLastIteration                   |
  67 |                                                               |
  68 | **CreateCaseFromCaseLastIteration(case_name, dir_name)**      |
  69 |     Retourne une instance de la classe ``cas`` après sa       |
  70 |     création                                                  |
  71 |                                                               |
  72 |     - ``case_name`` : le nom du cas                           |
  73 |     - ``dir_name``  : le nom du répertoire contenant          |
  74 |       le cas à poursuivre                                     |
  75 |                                                               |
  76 +---------------------------------------------------------------+
  77 | .. module:: CreateCaseFromCaseIteration                       |
  78 |                                                               |
  79 | **CreateCaseFromCaseIteration(case_name, dir_name, number)**  |
  80 |     Retourne une instance de la classe ``cas`` après sa       |
  81 |     création                                                  |
  82 |                                                               |
  83 |     - ``case_name`` : le nom du cas                           |
  84 |     - ``dir_name``  : le nom du répertoire contenant          |
  85 |       le cas à poursuivre                                     |
  86 |     - ``number`` : le numéro de l'itération du cas            |
  87 |                                                               |
  88 +---------------------------------------------------------------+
  89
  90
  91
  92 Méthodes de la classe cas
  93 *************************
  94 .. index:: single: YACS
  95
  96 +---------------------------------------------------------------+
  97 +---------------------------------------------------------------+
  98 | .. module:: GetName                                           |
  99 |                                                               |
 100 | **GetName()**                                                 |
 101 |     Retourne le nom du cas                                    |
 102 +---------------------------------------------------------------+
 103 | .. module:: SetDirName                                        |
 104 |                                                               |
 105 | **SetDirName(dirname)**                                       |
 106 |     Affecte le répertoire des résultats associé au cas. Cela  |
 107 |     ne peut se faire qu'après la création du cas et avant le  |
 108 |     premier calcul.                                           |
 109 |                                                               |
 110 |     - ``dirname`` : le nom du répertoire des résultats        |
 111 +---------------------------------------------------------------+
 112 | .. module:: GetDirName                                        |
 113 |                                                               |
 114 | **GetDirName()**                                              |
 115 |     Retourne le nom du répertoire des résultats associé au cas|
 116 +---------------------------------------------------------------+
 117 | .. module:: SetConfType                                       |
 118 |                                                               |
 119 | **SetConfType(conf_type)**                                    |
 120 |     Définit le mode de conformité associé au cas              |
 121 |                                                               |
 122 |     - ``conf_type`` : entier précisant le mode de conformité  |
 123 |                                                               |
 124 |         * 0 : conforme (défaut)                               |
 125 |         * 1 : non conforme avec au minimum 2 aretes coupees   |
 126 |         * 2 : non conforme avec 1 noeud par arete de maille   |
 127 |         * 3 : non conforme quelconque                         |
 128 |         * -1 : conforme avec des boites (pas d'escalier)      |
 129 |         * -2 : non-conforme avec des boites (pas d'escalier)  |
 130 +---------------------------------------------------------------+
 131 | .. module:: GetConfType                                       |
 132 |                                                               |
 133 | **GetConfType()**                                             |
 134 |     Retourne le type de conformité                            |
 135 +---------------------------------------------------------------+
 136 | .. module:: SetExtType                                        |
 137 |                                                               |
 138 | **SetExtType(ext_type)**                                      |
 139 |     Définit le type externe associé au cas                    |
 140 |                                                               |
 141 |     - ``ext_type`` : entier précisant le type externe         |
 142 |                                                               |
 143 |         * 0 : MED standard (défaut)                           |
 144 |         * 1 : Saturne MED                                     |
 145 |         * 2 : Saturne 2D MED                                  |
 146 +---------------------------------------------------------------+
 147 | .. module:: GetExtType                                        |
 148 |                                                               |
 149 | **GetExtType()**                                              |
 150 |     Retourne le type externe associé au cas                   |
 151 +---------------------------------------------------------------+
 152 | .. module:: GetIter0                                          |
 153 |                                                               |
 154 | **GetIter0()**                                                |
 155 |     Retourne l'itération associée au maillage initial.        |
 156 |     Cette itération est créée automatiquement par le module   |
 157 |     HOMARD et est utilisée pour enchaîner les adaptations.    |
 158 |     Elle correspond à un maillage initial ou à une itération  |
 159 |     de poursuite d'un cas précédent.                          |
 160 +---------------------------------------------------------------+
 161 | .. module:: AddBoundary                                       |
 162 |                                                               |
 163 | **AddBoundary(boundary)**                                     |
 164 |     Ajoute une frontière à la définition du cas               |
 165 |                                                               |
 166 |     - ``boundary`` : nom d'une frontière courbe à suivre      |
 167 +---------------------------------------------------------------+
 168 | .. module:: AddBoundaryGroup                                  |
 169 |                                                               |
 170 | **AddBoundaryGroup(boundary, group)**                         |
 171 |     Ajoute une frontière à la définition du cas               |
 172 |                                                               |
 173 |     - ``boundary`` : nom d'une frontière courbe à suivre      |
 174 |                                                               |
 175 |     Pour une frontière discrète :                             |
 176 |                                                               |
 177 |     . si toutes les lignes courbes sont suivies, le second    |
 178 |       argument est une chaîne vide.                           |
 179 |     . si seulement certaines lignes courbes sont suivies,     |
 180 |       ``group`` est le nom d'un groupe de segments à suivre.  |
 181 |                                                               |
 182 |     Pour une frontière analytique :                           |
 183 |                                                               |
 184 |     - ``group`` : nom d'un groupe de faces placées sur la     |
 185 |       frontière                                               |
 186 +---------------------------------------------------------------+
 187 | .. module:: Delete                                            |
 188 |                                                               |
 189 | **Delete(option)**                                            |
 190 |     Detruit le cas et toutes les itérations associées. Le     |
 191 |     fichier du maillage initial associé est conservé.         |
 192 |                                                               |
 193 |     - ``option`` : un entier précisant ce qui est fait des    |
 194 |       fichiers de maillage associés                           |
 195 |                                                               |
 196 |         * 0 : les fichiers sont conservés                     |
 197 |         * 1 : les fichiers sont supprimés                     |
 198 |                                                               |
 199 |     Retourne un entier :                                      |
 200 |         * 0 : destruction réussie                             |
 201 |         * autre valeur : problème                             |
 202 +---------------------------------------------------------------+
 203 | .. module:: GetState                                          |
 204 |                                                               |
 205 | **GetState()**                                                |
 206 |     Retourne l'état du cas :                                  |
 207 |         * 0 : correspond à un maillage initial                |
 208 |         * autre valeur : poursuite d'une itération de numéro n|
 209 +---------------------------------------------------------------+
 210 | .. module:: CreateYACSSchema                                  |
 211 |                                                               |
 212 | **CreateYACSSchema(yacs_name, ScriptFile, DirName, MeshFile)**|
 213 |     Retourne une instance de la classe ``yacs`` après sa      |
 214 |     création                                                  |
 215 |                                                               |
 216 |     - ``yacs_name`` : le nom du schéma                        |
 217 |     - ``ScriptFile`` : le fichier du script python qui permet |
 218 |       de lancer le calcul à coupler avec l'adaptation de      |
 219 |       maillage                                                |
 220 |     - ``DirName`` : le répertoire où a lieu le calcul         |
 221 |     - ``MeshFile`` : le fichier MED contenant le tout premier |
 222 |       maillage de calcul                                      |
 223 +---------------------------------------------------------------+
 224
 225 Les options avancées
 226 ====================
 227
 228 +---------------------------------------------------------------+
 229 +---------------------------------------------------------------+
 230 | .. module:: SetPyram                                          |
 231 |                                                               |
 232 | **SetPyram(option)**                                          |
 233 |     Définit le statut des pyramides pour le cas               |
 234 |                                                               |
 235 |     - ``option`` : entier précisant le statut des pyramides   |
 236 |       éventuellement présentes dans le maillage initial       |
 237 |                                                               |
 238 |         * 0 : pyramides refusées (défaut)                     |
 239 |         * 1 : pyramides autorisées                            |
 240 +---------------------------------------------------------------+
 241 | .. module:: GetPyram                                          |
 242 |                                                               |
 243 | **GetPyram()**                                                |
 244 |     Retourne le statut accordé aux pyramides éventuellement   |
 245 |     présentes dans le maillage initial                        |
 246 +---------------------------------------------------------------+
 247
 248 Informations sur le maillage initial
 249 ====================================
 250
 251 +---------------------------------------------------------------+
 252 +---------------------------------------------------------------+
 253 | .. module:: MeshInfo                                          |
 254 |                                                               |
 255 | **MeshInfo(Qual, Diam, Conn, Tail, Inte)**                    |
 256 |     Donne des informations sur le maillage. Pour chaque       |
 257 |     option, le choix 0 correspond à ne rien faire, alors que  |
 258 |     le choix 1 active l'option.                               |
 259 |                                                               |
 260 |     - ``Qual`` : qualité des mailles                          |
 261 |     - ``Diam`` : diamètre des mailles                         |
 262 |     - ``Conn`` : connexité du domaine ; en un seul morceau,   |
 263 |       combien de trous, etc.                                  |
 264 |     - ``Tail`` : tailles des constituants du domaine, groupe  |
 265 |       par groupe                                              |
 266 |     - ``Inte`` : interpénétration des mailles, par dimension  |
 267 +---------------------------------------------------------------+
 268
 269
 270 Exemple
 271 *******
 272 La création de l'objet case_1 se fait ainsi : ::
 273
 274     case_name = "CAS_1"
 275     mesh_name = "MAILL"
 276     mesh_file = "/home/A1789/Adapt/m0.med"
 277     case_1 = homard.CreateCase(case_name, mesh_name, mesh_file)
 278     dirname = "/home/A1789/Adapt/resu"
 279     case_1.SetDirName(dirname)
 280     case_1.SetConfType(1)
 281     case_1.SetExtType(0)
 282     case_1.AddBoundaryGroup( 'intersection', '' )
 283     case_1.AddBoundaryGroup( 'cyl_1', 'T1_EXT' )
 284     case_1.AddBoundaryGroup( 'cyl_1', 'T2_EXT' )
 285     case_1.AddBoundaryGroup( 'cyl_2', 'T_INT' )
 286
 287
 288
 289 Saisie graphique correspondante
 290 *******************************
 291 Consulter :doc:`gui_create_case`
 292
 293