doc/fr/tui_create_hypothese.rst

   1 .. _tui_create_hypothese:
   2
   3 L'hypothèse
   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_hypothese`.
  11
  12 Méthodes de la classe homard
  13 ****************************
  14
  15 +---------------------------------------------------------------+
  16 +---------------------------------------------------------------+
  17 | .. module:: CreateHypothesis                                  |
  18 |                                                               |
  19 | **CreateHypothesis(hypo_name)**                               |
  20 |     Retourne une instance de la classe ``hypothese``          |
  21 |                                                               |
  22 |     - ``hypo_name`` : le nom de l'hypothèse                   |
  23 +---------------------------------------------------------------+
  24 | .. module:: GetHypothesis                                     |
  25 |                                                               |
  26 | **GetHypothesis(hypo_name)**                                  |
  27 |     Retourne l'instance de la classe ``hypothese`` connue par |
  28 |     son nom                                                   |
  29 |                                                               |
  30 |     - ``hypo_name`` : le nom de l'hypothèse                   |
  31 +---------------------------------------------------------------+
  32 | .. module:: GetAllHypothesesName                              |
  33 |                                                               |
  34 | **GetAllHypothesesName()**                                    |
  35 |     Retourne la liste des noms de toutes les hypothèses créées|
  36 +---------------------------------------------------------------+
  37 | .. module:: GetZone                                           |
  38 |                                                               |
  39 | **GetZone(zone_name)**                                        |
  40 |     Retourne l'instance de la classe ``zone`` connue par      |
  41 |     son nom                                                   |
  42 |                                                               |
  43 |     - ``zone_name`` : le nom de la zone                       |
  44 +---------------------------------------------------------------+
  45
  46 Méthodes de la classe hypothese
  47 *******************************
  48
  49 Généralités
  50 ===========
  51
  52 +---------------------------------------------------------------+
  53 +---------------------------------------------------------------+
  54 | .. module:: GetName                                           |
  55 |                                                               |
  56 | **GetName()**                                                 |
  57 |     Retourne le nom de l'hypothèse                            |
  58 +---------------------------------------------------------------+
  59 | .. module:: GetAdapType                                       |
  60 |                                                               |
  61 | **GetAdapType()**                                             |
  62 |     Retourne le type d'adaptation                             |
  63 |                                                               |
  64 |         * -1 : uniforme                                       |
  65 |         * 0 : selon des zones                                 |
  66 |         * 1 : selon un champ                                  |
  67 +---------------------------------------------------------------+
  68 | .. module:: GetRefinType                                      |
  69 |                                                               |
  70 | **GetRefinType()**                                            |
  71 |     Retourne le type de raffinement                           |
  72 |                                                               |
  73 |         * 0 : inactif                                         |
  74 |         * 1 : actif                                           |
  75 +---------------------------------------------------------------+
  76 | .. module:: GetUnRefType                                      |
  77 |                                                               |
  78 | **GetUnRefType()**                                            |
  79 |     Retourne le type de déraffinement                         |
  80 |                                                               |
  81 |         * 0 : inactif                                         |
  82 |         * 1 : actif                                           |
  83 +---------------------------------------------------------------+
  84 | .. module:: Delete                                            |
  85 |                                                               |
  86 | **Delete()**                                                  |
  87 |     Detruit l'hypothèse                                       |
  88 |                                                               |
  89 |     Retourne un entier :                                      |
  90 |         * 0 : destruction réussie                             |
  91 |         * autre valeur : problème                             |
  92 +---------------------------------------------------------------+
  93
  94 Adaptation uniforme
  95 ===================
  96
  97 +---------------------------------------------------------------+
  98 +---------------------------------------------------------------+
  99 | .. module:: SetUnifRefinUnRef                                 |
 100 |                                                               |
 101 | **SetUnifRefinUnRef(RefinUnRef)**                             |
 102 |     Définit un mode d'adaptation uniforme à tout le maillage  |
 103 |                                                               |
 104 |     - ``RefinUnRef`` : entier précisant le type d'adaptation  |
 105 |                                                               |
 106 |         * 1 : raffinement                                     |
 107 |         * -1 : déraffinement                                  |
 108 +---------------------------------------------------------------+
 109
 110 Adaptation selon un champ
 111 =========================
 112
 113 Le champ de pilotage de l'adaptation et les seuils
 114 --------------------------------------------------
 115
 116 +---------------------------------------------------------------+
 117 +---------------------------------------------------------------+
 118 | .. module:: SetField                                          |
 119 |                                                               |
 120 | **SetField(FieldName)**                                       |
 121 |     Attribue un nom de champ de pilotage à l'hypothèse        |
 122 |                                                               |
 123 |     - ``FieldName`` : le nom du champ  de pilotage            |
 124 +---------------------------------------------------------------+
 125 | .. module:: GetFieldName                                      |
 126 |                                                               |
 127 | **GetFieldName()**                                            |
 128 |     Retourne le nom du champ de pilotage                      |
 129 +---------------------------------------------------------------+
 130 | .. module:: SetUseField                                       |
 131 |                                                               |
 132 | **SetUseField(use_field)**                                    |
 133 |     Attribue un mode d'usage du champ de pilotage             |
 134 |                                                               |
 135 |     - ``use_field`` : entier précisant l'usage du champ       |
 136 |                                                               |
 137 |        * 0 : valeur par élément (défaut)                      |
 138 |        * 1 : saut entre un élément et ses voisins             |
 139 +---------------------------------------------------------------+
 140 | .. module:: SetRefinThr                                       |
 141 |                                                               |
 142 | **SetRefinThr(type_thres, threshold)**                        |
 143 |     Définit les seuils en raffinement                         |
 144 |                                                               |
 145 |     - ``type_thres`` : entier précisant le type de seuil en   |
 146 |       raffinement                                             |
 147 |                                                               |
 148 |        * 1 : valeur absolue                                   |
 149 |        * 2 : valeur relative en %                             |
 150 |        * 3 : fraction des mailles en %                        |
 151 |        * 4 : moyenne + n fois l'écart-type                    |
 152 |                                                               |
 153 |     - ``threshold`` : valeur numérique entrant dans la        |
 154 |                       définition du seuil                     |
 155 +---------------------------------------------------------------+
 156 | .. module:: GetRefinThrType                                   |
 157 |                                                               |
 158 | **GetRefinThrType()**                                         |
 159 |     Retourne le type de seuil de raffinement                  |
 160 +---------------------------------------------------------------+
 161 | .. module:: SetUnRefThr                                       |
 162 |                                                               |
 163 | **SetUnRefThr(type_thres, threshold)**                        |
 164 |     Définit les seuils en déraffinement                       |
 165 |                                                               |
 166 |     - ``type_thres`` : entier précisant le type de seuil en   |
 167 |       déraffinement                                           |
 168 |                                                               |
 169 |        * 1 : valeur absolue                                   |
 170 |        * 2 : valeur relative en %                             |
 171 |        * 3 : fraction des mailles en %                        |
 172 |        * 4 : moyenne - n fois l'écart-type                    |
 173 |                                                               |
 174 |     - ``threshold`` : valeur du seuil                         |
 175 +---------------------------------------------------------------+
 176 | .. module:: GetUnRefThrType                                   |
 177 |                                                               |
 178 | **GetUnRefThrType()**                                         |
 179 |     Retourne le type de seuil de déraffinement                |
 180 +---------------------------------------------------------------+
 181
 182
 183 Les composantes du champ de pilotage
 184 ------------------------------------
 185
 186 +---------------------------------------------------------------+
 187 +---------------------------------------------------------------+
 188 | .. module:: AddComp                                           |
 189 |                                                               |
 190 | **AddComp(comp_name)**                                        |
 191 |     Ajoute une composante du champ de pilotage à considérer   |
 192 |                                                               |
 193 |     - ``comp_name`` : nom d'une composante à prendre en       |
 194 |       compte                                                  |
 195 |                                                               |
 196 |     Remarque : si cette méthode n'est pas appelée, par défaut |
 197 |     toutes les composantes seront retenues.                   |
 198 +---------------------------------------------------------------+
 199 | .. module:: SetUseComp                                        |
 200 |                                                               |
 201 | **SetUseComp(use_comp)**                                      |
 202 |     Définit l'usage des composantes                           |
 203 |                                                               |
 204 |     - ``use_comp`` : entier précisant l'usage des composantes |
 205 |                                                               |
 206 |        * 0 : norme L2 (défaut)                                |
 207 |        * 1 : norme infinie                                    |
 208 |        * 2 : valeur relative, si une seule composante         |
 209 +---------------------------------------------------------------+
 210 | .. module:: GetComps                                          |
 211 |                                                               |
 212 | **GetComps()**                                                |
 213 |     Retourne la liste des composantes utilisées               |
 214 +---------------------------------------------------------------+
 215 | .. module:: SupprComp                                         |
 216 |                                                               |
 217 | **SupprComp(comp_name)**                                      |
 218 |     Supprime une composante du champ à considérer             |
 219 |                                                               |
 220 |     - ``comp_name`` : nom de la composante à supprimer        |
 221 +---------------------------------------------------------------+
 222 | .. module:: SupprComps                                        |
 223 |                                                               |
 224 | **SupprComps()**                                              |
 225 |     Supprime toutes les composantes du champ à considérer     |
 226 +---------------------------------------------------------------+
 227
 228
 229 Adaptation selon des zones
 230 ==========================
 231
 232 +---------------------------------------------------------------+
 233 +---------------------------------------------------------------+
 234 | .. module:: AddZone                                           |
 235 |                                                               |
 236 | **AddZone(zone_name, type_use)**                              |
 237 |                                                               |
 238 |     - ``zone_name`` : le nom de la zone à ajouter             |
 239 |     - ``type_use``  : entier précisant l'usage de la zone     |
 240 |                                                               |
 241 |         * 1 : raffinement                                     |
 242 |         * -1 : déraffinement                                  |
 243 +---------------------------------------------------------------+
 244 | .. module:: GetZones                                          |
 245 |                                                               |
 246 | **GetZones()**                                                |
 247 |     Retourne la liste des zones utilisées avec leur usage.    |
 248 |                                                               |
 249 |     Attention : l'usage est stocké sous forme de chaîne de    |
 250 |     caractères et non pas d'entier dans la liste.             |
 251 |                                                               |
 252 |     Exemple : ['Zone_A', '1', 'Zone_B', '1', 'Zone_C', '1']   |
 253 +---------------------------------------------------------------+
 254 | .. module:: SupprZone                                         |
 255 |                                                               |
 256 | **SupprZone(zone_name)**                                      |
 257 |     Supprime une zone de l'hypothèse                          |
 258 |                                                               |
 259 |     - ``zone_name`` : nom de la zone à supprimer              |
 260 +---------------------------------------------------------------+
 261 | .. module:: SupprZones                                        |
 262 |                                                               |
 263 | **SupprZones()**                                              |
 264 |     Supprime toutes les zones de l'hypothèse                  |
 265 +---------------------------------------------------------------+
 266
 267
 268 Le filtrage par les groupes
 269 ===========================
 270
 271 +---------------------------------------------------------------+
 272 +---------------------------------------------------------------+
 273 | .. module:: AddGroup                                          |
 274 |                                                               |
 275 | **AddGroup(group_name)**                                      |
 276 |     Ajoute un groupe au filtrage                              |
 277 |                                                               |
 278 |     - ``group_name`` : nom du groupe à prendre en compte      |
 279 +---------------------------------------------------------------+
 280 | .. module:: GetGroups                                         |
 281 |                                                               |
 282 | **GetGroups()**                                               |
 283 |     Retourne la liste des groupes utilisés pour le filtrage   |
 284 +---------------------------------------------------------------+
 285
 286
 287 Les champs à interpoler
 288 =======================
 289
 290 +---------------------------------------------------------------+
 291 +---------------------------------------------------------------+
 292 | .. module:: SetTypeFieldInterp                                |
 293 |                                                               |
 294 | **SetTypeFieldInterp(typefieldinterp)**                       |
 295 |                                                               |
 296 |     - ``typefieldinterp`` : entier précisant si des champs    |
 297 |       sont a interpoler                                       |
 298 |                                                               |
 299 |         * 0 : aucun champ n'est à interpoler (défaut)         |
 300 |         * 1 : tous les champs sont interpolés                 |
 301 |         * 2 : certains champs sont interpolés ; implicitement |
 302 |           affecté après usage de AddFieldInterp ou            |
 303 |           AddFieldInterpType                                  |
 304 +---------------------------------------------------------------+
 305 | .. module:: GetTypeFieldInterp                                |
 306 |                                                               |
 307 | **GetTypeFieldInterp()**                                      |
 308 |     Retourne l'entier précisant si des champs sont à          |
 309 |     interpoler                                                |
 310 +---------------------------------------------------------------+
 311 | .. module:: AddFieldInterp                                    |
 312 |                                                               |
 313 | **AddFieldInterp(FieldName)**                                 |
 314 |                                                               |
 315 |     - ``FieldName`` : le nom du champ à interpoler            |
 316 |                                                               |
 317 |     Le mode d'interpolation sera choisi automatiquement par   |
 318 |     HOMARD ; cela correspond au mode 0 de AddFieldInterpType  |
 319 +---------------------------------------------------------------+
 320 | .. module:: AddFieldInterpType                                |
 321 |                                                               |
 322 | **AddFieldInterpType(FieldName, type_interp)**                |
 323 |                                                               |
 324 |     - ``FieldName`` : le nom du champ à interpoler            |
 325 |     - ``type_interp`` : entier précisant le type              |
 326 |       d'interpolation du champ                                |
 327 |                                                               |
 328 |     Pour un champ aux noeuds :                                |
 329 |                                                               |
 330 |         * 0 : le champ sera interpolé en degré 1 ou 2 selon   |
 331 |           son support.                                        |
 332 |         * 1 : interpolation en degré 1                        |
 333 |         * 2 : interpolation en degré 2                        |
 334 |         * 3 : interpolation iso-P2                            |
 335 |                                                               |
 336 |     Pour un champ aux éléments :                              |
 337 |                                                               |
 338 |         * 0 : le champ sera interpolé en le considérant comme |
 339 |           une variable intensive.                             |
 340 |         * 1 : le champ sera interpolé en le considérant comme |
 341 |           une variable extensive.                             |
 342 +---------------------------------------------------------------+
 343 | .. module:: GetFieldInterps                                   |
 344 |                                                               |
 345 | **GetFieldInterps()**                                         |
 346 |     Retourne la liste des champs à interoler avec leur usage. |
 347 |                                                               |
 348 |     Attention : l'usage est stocké sous forme de chaîne de    |
 349 |     caractères et non pas d'entier dans la liste.             |
 350 |                                                               |
 351 |     Exemple : ['DEPL', '0', 'Masse', '1', 'Densite', '0']     |
 352 +---------------------------------------------------------------+
 353 | .. module:: SupprFieldInterp                                  |
 354 |                                                               |
 355 | **SupprFieldInterp(FieldName)**                               |
 356 |     Supprime un champ à interpoler de l'hypothèse             |
 357 |                                                               |
 358 |     - ``FieldName`` : nom du champ à supprimer                |
 359 +---------------------------------------------------------------+
 360 | .. module:: SupprFieldInterps                                 |
 361 |                                                               |
 362 | **SupprFieldInterps()**                                       |
 363 |     Supprime tous les champs à interpoler de l'hypothèse      |
 364 +---------------------------------------------------------------+
 365
 366 .. note::
 367   Le fichier et les instants où sont pris les champs sont définis dans l'itération ; voir :ref:`tui_create_iteration`.
 368
 369 Les options avancées
 370 ====================
 371
 372 +---------------------------------------------------------------+
 373 +---------------------------------------------------------------+
 374 | .. module:: SetNivMax                                         |
 375 |                                                               |
 376 | **SetNivMax(nivmax)**                                         |
 377 |     Définit le niveau maximal de raffinement                  |
 378 |                                                               |
 379 |     - ``nivmax`` : niveau de raffinement à ne pas dépasser    |
 380 +---------------------------------------------------------------+
 381 | .. module:: GetNivMax                                         |
 382 |                                                               |
 383 | **GetNivMax()**                                               |
 384 |     Retourne le niveau maximal de raffinement                 |
 385 +---------------------------------------------------------------+
 386 | .. module:: SetDiamMin                                        |
 387 |                                                               |
 388 | **SetDiamMin(diammin)**                                       |
 389 |     Définit le diamètre minimal des futures mailles           |
 390 |                                                               |
 391 |     - ``diammin`` : diamètre minimal voulu pour une maille    |
 392 +---------------------------------------------------------------+
 393 | .. module:: GetDiamMin                                        |
 394 |                                                               |
 395 | **GetDiamMin()**                                              |
 396 |     Retourne le diamètre minimal voulu                        |
 397 +---------------------------------------------------------------+
 398 | .. module:: SetAdapInit                                       |
 399 |                                                               |
 400 | **SetAdapInit(option)**                                       |
 401 |     Définit le traitement à appliquer aux mailles où          |
 402 |     le champ de pilotage de l'adaptation n'est pas défini     |
 403 |                                                               |
 404 |     - ``option`` : entier précisant le choix retenu           |
 405 |                                                               |
 406 |         *  0 : aucun effet (défaut)                           |
 407 |         *  1 : les mailles sans indicateurs sont raffinées    |
 408 |         * -1 : les mailles sans indicateurs sont déraffinées  |
 409 +---------------------------------------------------------------+
 410 | .. module:: GetAdapInit                                       |
 411 |                                                               |
 412 | **GetAdapInit()**                                             |
 413 |     Retourne le type de traitement à appliquer aux mailles où |
 414 |     le champ de pilotage de l'adaptation n'est pas défini     |
 415 +---------------------------------------------------------------+
 416 | .. module:: SetExtraOutput                                    |
 417 |                                                               |
 418 | **SetExtraOutput(option)**                                    |
 419 |     Précise quelles sorties supplémentaires sur les mailles on|
 420 |     veut récupérer dans le fichier MED de sortie. C'est un    |
 421 |     entier multiple ou non de 2, 3, 5.                        |
 422 |                                                               |
 423 |     - ``option`` : entier précisant le choix retenu           |
 424 |                                                               |
 425 |         *  1 : aucun effet (défaut)                           |
 426 |         *  2x : le niveau de raffinement de chaque maille     |
 427 |         *  3x : la qualité de chaque maille                   |
 428 |         *  5x : le diamètre de chaque maille                  |
 429 +---------------------------------------------------------------+
 430 | .. module:: GetExtraOutput                                    |
 431 |                                                               |
 432 | **GetExtraOutput()**                                          |
 433 |     Retourne le choix retenu pour la récupération des sorties |
 434 |     supplémentaires                                           |
 435 +---------------------------------------------------------------+
 436
 437
 438 Exemple
 439 *******
 440 La création de l'objet hypo_1 se fait ainsi : ::
 441
 442     hypo_1 = homard.CreateHypothesis("HypoField")
 443     hypo_1.SetField("INDICATEUR")
 444     hypo_1.AddComp("INDX")
 445     hypo_1.AddComp("INDZ")
 446     hypo_1.SetRefinThr(1, 80.)
 447     hypo_1.AddFieldInterp("DEPL")
 448     hypo_1.AddFieldInterpType("MASSE", 1)
 449
 450
 451 Saisie graphique correspondante
 452 *******************************
 453 Consulter :ref:`gui_create_hypothese`
 454
 455 .. warning::
 456   En mode graphique, si on édite une hypothèse et que l'on modifie une de ses caractéristiques, par exemple le seuil de raffinement, toutes les itérations qui ont été calculées précédemment avec cette hypothèse sont invalidées. En mode python, cela n'est plus vrai : les itérations restent telles quelles.