doc/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 +---------------------------------------------------------------+
  38
  39 Méthodes de la classe hypothese
  40 """""""""""""""""""""""""""""""
  41
  42 Généralités
  43 ^^^^^^^^^^^
  44
  45 +---------------------------------------------------------------+
  46 +---------------------------------------------------------------+
  47 | .. module:: GetName                                           |
  48 |                                                               |
  49 | **GetName()**                                                 |
  50 |     Retourne le nom de l'hypothèse                            |
  51 +---------------------------------------------------------------+
  52 | .. module:: SetAdapRefinUnRef                                 |
  53 |                                                               |
  54 | **SetAdapRefinUnRef(Adap, Refin, UnRef)**                     |
  55 |     Affecte le mode d'adaptation associé à l'hypothèse        |
  56 |                                                               |
  57 |     - ``Adap`` : entier précisant le type d'adaptation        |
  58 |                                                               |
  59 |         * -1 : uniforme                                       |
  60 |         * 0 : selon des zones                                 |
  61 |         * 1 : selon un champ                                  |
  62 |                                                               |
  63 |     - ``Refin`` : entier précisant si le raffinement est actif|
  64 |                                                               |
  65 |         * 0 : inactif                                         |
  66 |         * 1 : actif                                           |
  67 |                                                               |
  68 |     - ``UnRef`` : entier précisant si déraffinement est actif |
  69 |                                                               |
  70 |         * 0 : inactif                                         |
  71 |         * 1 : actif                                           |
  72 |                                                               |
  73 +---------------------------------------------------------------+
  74 | .. module:: GetAdapType                                       |
  75 |                                                               |
  76 | **GetAdapType()**                                             |
  77 |     Retourne le type d'adaptation                             |
  78 +---------------------------------------------------------------+
  79 | .. module:: GetRefinType                                      |
  80 |                                                               |
  81 | **GetRefinType()**                                            |
  82 |     Retourne le type de raffinement                           |
  83 +---------------------------------------------------------------+
  84 | .. module:: GetUnRefType                                      |
  85 |                                                               |
  86 | **GetUnRefType()**                                            |
  87 |     Retourne le type de déraffinement                         |
  88 +---------------------------------------------------------------+
  89 | .. module:: Delete                                            |
  90 |                                                               |
  91 | **Delete()**                                                  |
  92 |     Detruit l'hypothèse                                       |
  93 |                                                               |
  94 |     Retourne un entier :                                      |
  95 |         * 0 : destruction réussie                             |
  96 |         * autre valeur : problème                             |
  97 +---------------------------------------------------------------+
  98
  99 Le champ et les seuils
 100 ^^^^^^^^^^^^^^^^^^^^^^
 101
 102 +---------------------------------------------------------------+
 103 +---------------------------------------------------------------+
 104 | .. module:: SetField                                          |
 105 |                                                               |
 106 | **SetField(field_name)**                                      |
 107 |     Attribue un nom de champ à l'hypothèse                    |
 108 |                                                               |
 109 |     - ``field_name`` : le nom du champ                        |
 110 +---------------------------------------------------------------+
 111 | .. module:: GetFieldName                                      |
 112 |                                                               |
 113 | **GetFieldName()**                                            |
 114 |     Retourne le nom du champ                                  |
 115 +---------------------------------------------------------------+
 116 | .. module:: SetUseField                                       |
 117 |                                                               |
 118 | **SetUseField(use_field)**                                    |
 119 |     Attribue un mode d'usage du champ à l'hypothèse           |
 120 |                                                               |
 121 |     - ``use_field`` : entier précisant l'usage du champ       |
 122 |                                                               |
 123 |        * 0 : valeur par élément (défaut)                      |
 124 |        * 1 : saut entre un élément et ses voisins             |
 125 +---------------------------------------------------------------+
 126 | .. module:: SetRefinThr                                       |
 127 |                                                               |
 128 | **SetRefinThr(type_thres, threshold)**                        |
 129 |     Définit les seuils en raffinement                         |
 130 |                                                               |
 131 |     - ``type_thres`` : entier précisant le type de seuil en   |
 132 |       raffinement                                             |
 133 |                                                               |
 134 |        * 1 : valeur absolue                                   |
 135 |        * 2 : valeur relative en %                             |
 136 |        * 3 : fraction des mailles en %                        |
 137 |        * 4 : moyenne + n fois l'écart-type                    |
 138 |                                                               |
 139 |     - ``threshold`` : valeur numérique entrant dans la        |
 140 |                       définition du seuil                     |
 141 +---------------------------------------------------------------+
 142 | .. module:: GetRefinThrType                                   |
 143 |                                                               |
 144 | **GetRefinThrType()**                                         |
 145 |     Retourne le type de seuil de raffinement                  |
 146 +---------------------------------------------------------------+
 147 | .. module:: SetUnRefThr                                       |
 148 |                                                               |
 149 | **SetUnRefThr(type_thres, threshold)**                        |
 150 |     Définit les seuils en déraffinement                       |
 151 |                                                               |
 152 |     - ``type_thres`` : entier précisant le type de seuil en   |
 153 |       déraffinement                                           |
 154 |                                                               |
 155 |        * 1 : valeur absolue                                   |
 156 |        * 2 : valeur relative en %                             |
 157 |        * 3 : fraction des mailles en %                        |
 158 |        * 4 : moyenne - n fois l'écart-type                    |
 159 |                                                               |
 160 |     - ``threshold`` : valeur du seuil                         |
 161 +---------------------------------------------------------------+
 162 | .. module:: GetUnRefThrType                                   |
 163 |                                                               |
 164 | **GetUnRefThrType()**                                         |
 165 |     Retourne le type de seuil de déraffinement                |
 166 +---------------------------------------------------------------+
 167
 168
 169 Les composantes du champ
 170 ^^^^^^^^^^^^^^^^^^^^^^^^
 171
 172 +---------------------------------------------------------------+
 173 +---------------------------------------------------------------+
 174 | .. module:: AddComp                                           |
 175 |                                                               |
 176 | **AddComp(comp_name)**                                        |
 177 |     Ajoute une composante du champ à considérer               |
 178 |                                                               |
 179 |     - ``comp_name`` : nom d'une composante à prendre en       |
 180 |       compte                                                  |
 181 +---------------------------------------------------------------+
 182 | .. module:: SetUseComp                                        |
 183 |                                                               |
 184 | **SetUseComp(use_comp)**                                      |
 185 |     Définit l'usage des composantes                           |
 186 |                                                               |
 187 |     - ``use_comp`` : entier précisant l'usage des composantes |
 188 |                                                               |
 189 |        * 0 : norme L2 (défaut)                                |
 190 |        * 1 : norme infinie                                    |
 191 |        * 2 : valeur relative, si une seule composante         |
 192 +---------------------------------------------------------------+
 193 | .. module:: GetListComp                                       |
 194 |                                                               |
 195 | **GetListComp()**                                             |
 196 |     Retourne la liste des composantes utilisées               |
 197 +---------------------------------------------------------------+
 198
 199
 200 Les zones
 201 ^^^^^^^^^
 202
 203 +---------------------------------------------------------------+
 204 +---------------------------------------------------------------+
 205 | .. module:: AddZone                                           |
 206 |                                                               |
 207 | **AddZone(zone_name, type_use)**                              |
 208 |                                                               |
 209 |     - ``zone_name`` : le nom de la zone à ajouter             |
 210 |     - ``type_use``  : entier précisant l'usage de la zone     |
 211 |                                                               |
 212 |         * 1 : raffinement                                     |
 213 |         * -1 : déraffinement                                  |
 214 +---------------------------------------------------------------+
 215
 216
 217 Le filtrage par les groupes
 218 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 219
 220 +---------------------------------------------------------------+
 221 +---------------------------------------------------------------+
 222 | .. module:: AddGroup                                          |
 223 |                                                               |
 224 | **AddGroup(group_name)**                                      |
 225 |     Ajoute un groupe au filtrage                              |
 226 |                                                               |
 227 |     - ``group_name`` : nom du groupe à prendre en compte      |
 228 +---------------------------------------------------------------+
 229 | .. module:: GetGroups                                         |
 230 |                                                               |
 231 | **GetGroups()**                                               |
 232 |     Retourne la liste des groupes utilisés pour le filtrage   |
 233 +---------------------------------------------------------------+
 234
 235 Les options avancées
 236 ^^^^^^^^^^^^^^^^^^^^
 237
 238 +---------------------------------------------------------------+
 239 +---------------------------------------------------------------+
 240 | .. module:: SetNivMax                                         |
 241 |                                                               |
 242 | **SetNivMax(nivmax)**                                         |
 243 |     Définit le niveau maximal de raffinement                  |
 244 |                                                               |
 245 |     - ``nivmax`` : niveau de raffinement à ne pas dépasser    |
 246 +---------------------------------------------------------------+
 247 | .. module:: GetNivMax                                         |
 248 |                                                               |
 249 | **GetNivMax()**                                               |
 250 |     Retourne le niveau maximal de raffinement                 |
 251 +---------------------------------------------------------------+
 252 | .. module:: SetDiamMin                                        |
 253 |                                                               |
 254 | **SetDiamMin(diammin)**                                       |
 255 |     Définit le diamètre minimal des futures mailles           |
 256 |                                                               |
 257 |     - ``diammin`` : diamètre minimal voulu pour une maille    |
 258 +---------------------------------------------------------------+
 259 | .. module:: GetDiamMin                                        |
 260 |                                                               |
 261 | **GetDiamMin()**                                              |
 262 |     Retourne le diamètre minimal voulu                        |
 263 +---------------------------------------------------------------+
 264 | .. module:: SetAdapInit                                       |
 265 |                                                               |
 266 | **SetAdapInit(option)**                                       |
 267 |     Définit le traitement à appliquer aux mailles où          |
 268 |     le champ de pilotage du raffinement n'est pas défini      |
 269 |                                                               |
 270 |     - ``option`` : entier précisant le choix retenu           |
 271 |                                                               |
 272 |         *  0 : aucun effet (défaut)                           |
 273 |         *  1 : les mailles sans indicateurs sont raffinées    |
 274 |         * -1 : les mailles sans indicateurs sont déraffinées  |
 275 +---------------------------------------------------------------+
 276 | .. module:: GetAdapInit                                       |
 277 |                                                               |
 278 | **GetAdapInit()**                                             |
 279 |     Retourne le type de traitement à appliquer aux mailles où |
 280 |     le champ de pilotage du raffinement n'est pas défini      |
 281 +---------------------------------------------------------------+
 282 | .. module:: SetLevelOutput                                    |
 283 |                                                               |
 284 | **SetLevelOutput(option)**                                    |
 285 |     Précise si on veut récupérer le niveau de raffinement des |
 286 |     mailles sous la forme d'un champ                          |
 287 |                                                               |
 288 |     - ``option`` : entier précisant le choix retenu           |
 289 |                                                               |
 290 |         *  0 : aucun effet (défaut)                           |
 291 |         *  1 : le champ est produit                           |
 292 +---------------------------------------------------------------+
 293 | .. module:: GetLevelOutput                                    |
 294 |                                                               |
 295 | **GetLevelOutput()**                                          |
 296 |     Retourne le choix retenu pour la récupération du niveau   |
 297 |     de raffinement                                            |
 298 +---------------------------------------------------------------+
 299
 300
 301 Exemple
 302 """""""
 303 La création de l'objet hypo_1 se fait ainsi : ::
 304
 305     hypo_1 = homard.CreateHypothesis("HypoField")
 306     hypo_1.SetAdapRefinUnRef(1, 1, 0)
 307     hypo_1.SetField("INDICATEUR")
 308     hypo_1.AddComp("INDX")
 309     hypo_1.AddComp("INDZ")
 310     hypo_1.SetRefinThr(1, 80.)
 311
 312
 313 Saisie graphique correspondante
 314 """""""""""""""""""""""""""""""
 315 Consulter :ref:`gui_create_hypothese`
 316
 317 .. warning::
 318   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.