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:: AssociateHypoZone                                 |
  25 |                                                               |
  26 | **AssociateHypoZone(hypo_name, zone_name)**                   |
  27 |                                                               |
  28 |     - ``hypo_name`` : le nom de l'hypothèse                   |
  29 |     - ``zone_name`` : le nom de la zone à associer            |
  30 +---------------------------------------------------------------+
  31
  32 Méthodes de la classe hypothese
  33 """""""""""""""""""""""""""""""
  34
  35 Généralités
  36 ^^^^^^^^^^^
  37
  38 +---------------------------------------------------------------+
  39 +---------------------------------------------------------------+
  40 | .. module:: GetName                                           |
  41 |                                                               |
  42 | **GetName()**                                                 |
  43 |     Retourne le nom de l'hypothèse                            |
  44 +---------------------------------------------------------------+
  45 | .. module:: SetAdapRefinUnRef                                 |
  46 |                                                               |
  47 | **SetAdapRefinUnRef(Adap, Refin, UnRef)**                     |
  48 |                                                               |
  49 |     - ``Adap`` : entier précisant le type d'adaptation        |
  50 |                                                               |
  51 |         * -1 : uniforme                                       |
  52 |         * 0 : selon des zones                                 |
  53 |         * 1 : selon un champ                                  |
  54 |                                                               |
  55 |     - ``Refin`` : entier précisant si le raffinement est actif|
  56 |                                                               |
  57 |         0. inactif                                            |
  58 |         1. actif                                              |
  59 |                                                               |
  60 |     - ``UnRef`` : entier précisant si déraffinement est actif |
  61 |                                                               |
  62 |         0. inactif                                            |
  63 |         1. actif                                              |
  64 |                                                               |
  65 +---------------------------------------------------------------+
  66 | .. module:: GetAdapType                                       |
  67 |                                                               |
  68 | **GetAdapType()**                                             |
  69 |     Retourne le type d'adaptation                             |
  70 +---------------------------------------------------------------+
  71 | .. module:: GetRefinType                                      |
  72 |                                                               |
  73 | **GetRefinType()**                                            |
  74 |     Retourne le type de raffinement                           |
  75 +---------------------------------------------------------------+
  76 | .. module:: GetUnRefType                                      |
  77 |                                                               |
  78 | **GetUnRefType()**                                            |
  79 |     Retourne le type de déraffinement                         |
  80 +---------------------------------------------------------------+
  81
  82 Le champ et les seuils
  83 ^^^^^^^^^^^^^^^^^^^^^^
  84
  85 +---------------------------------------------------------------+
  86 +---------------------------------------------------------------+
  87 | .. module:: SetField                                          |
  88 |                                                               |
  89 | **SetField(field_name)**                                      |
  90 |                                                               |
  91 |     - ``field_name`` : le nom du champ                        |
  92 +---------------------------------------------------------------+
  93 | .. module:: GetFieldName                                      |
  94 |                                                               |
  95 | **GetFieldName()**                                            |
  96 |     Retourne le nom du champ                                  |
  97 +---------------------------------------------------------------+
  98 | .. module:: SetUseField                                       |
  99 |                                                               |
 100 | **SetUseField(use_field)**                                    |
 101 |                                                               |
 102 |     - ``use_field`` : entier précisant l'usage du champ       |
 103 |                                                               |
 104 |         0. valeur par élément (défaut)                        |
 105 |         1. saut entre un élément et ses voisins               |
 106 +---------------------------------------------------------------+
 107 | .. module:: SetRefinThr                                       |
 108 |                                                               |
 109 | **SetRefinThr(type_thres, threshold)**                        |
 110 |                                                               |
 111 |     - ``type_thres`` : entier précisant le type de seuil en   |
 112 |       raffinement                                             |
 113 |                                                               |
 114 |         1. valeur absolue                                     |
 115 |         2. valeur relative en %                               |
 116 |         3. fraction des mailles en %                          |
 117 |                                                               |
 118 |     - ``threshold`` : valeur du seuil                         |
 119 +---------------------------------------------------------------+
 120 | .. module:: GetRefinThrType                                   |
 121 |                                                               |
 122 | **GetRefinThrType()**                                         |
 123 |     Retourne le type de seuil de raffinement                  |
 124 +---------------------------------------------------------------+
 125 | .. module:: SetUnRefThr                                       |
 126 |                                                               |
 127 | **SetUnRefThr(type_thres, threshold)**                        |
 128 |                                                               |
 129 |     - ``type_thres`` : entier précisant le type de seuil en   |
 130 |       déraffinement                                           |
 131 |                                                               |
 132 |         1. valeur absolue                                     |
 133 |         2. valeur relative en %                               |
 134 |         3. fraction des mailles en %                          |
 135 |                                                               |
 136 |     - ``threshold`` : valeur du seuil                         |
 137 +---------------------------------------------------------------+
 138 | .. module:: GetUnRefThrType                                   |
 139 |                                                               |
 140 | **GetUnRefThrType()**                                         |
 141 |     Retourne le type de seuil de déraffinement                |
 142 +---------------------------------------------------------------+
 143
 144
 145 Les composantes du champ
 146 ^^^^^^^^^^^^^^^^^^^^^^^^
 147
 148 +---------------------------------------------------------------+
 149 +---------------------------------------------------------------+
 150 | .. module:: AddComp                                           |
 151 |                                                               |
 152 | **AddComp(comp_name)**                                        |
 153 |                                                               |
 154 |     - ``comp_name`` : nom d'une composante à prendre en       |
 155 |       compte                                                  |
 156 +---------------------------------------------------------------+
 157 | .. module:: SetUseComp                                        |
 158 |                                                               |
 159 | **SetUseComp(use_comp)**                                      |
 160 |                                                               |
 161 |     - ``use_comp`` : entier précisant l'usage des composantes |
 162 |                                                               |
 163 |         0. norme L2 (défaut)                                  |
 164 |         1. norme infinie                                      |
 165 |         2. valeur relative, uniquement si une seule composante|
 166 +---------------------------------------------------------------+
 167 | .. module:: GetListComp                                       |
 168 |                                                               |
 169 | **GetListComp()**                                             |
 170 |     Retourne la liste des composantes utilisées               |
 171 +---------------------------------------------------------------+
 172
 173 Le filtrage par les groupes
 174 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 175
 176 +---------------------------------------------------------------+
 177 +---------------------------------------------------------------+
 178 | .. module:: AddGroup                                          |
 179 |                                                               |
 180 | **AddGroup(group_name)**                                      |
 181 |                                                               |
 182 |     - ``group_name`` : nom du groupe à prendre en compte      |
 183 +---------------------------------------------------------------+
 184 | .. module:: GetGroups                                         |
 185 |                                                               |
 186 | **GetGroups()**                                               |
 187 |     Retourne la liste des groupes utilisés pour le filtrage   |
 188 +---------------------------------------------------------------+
 189
 190 Les options avancéess
 191 ^^^^^^^^^^^^^^^^^^^^^
 192
 193 +---------------------------------------------------------------+
 194 +---------------------------------------------------------------+
 195 | .. module:: SetNivMax                                         |
 196 |                                                               |
 197 | **SetNivMax(nivmax)**                                         |
 198 |                                                               |
 199 |     - ``nivmax`` : niveau de raffinement à ne pas dépasser    |
 200 +---------------------------------------------------------------+
 201 | .. module:: GetNivMax                                         |
 202 |                                                               |
 203 | **GetNivMax()**                                               |
 204 |     Retourne le niveau maximal de raffinement                 |
 205 +---------------------------------------------------------------+
 206 | .. module:: SetDiamMin                                        |
 207 |                                                               |
 208 | **SetDiamMin(diammin)**                                       |
 209 |                                                               |
 210 |     - ``diammin`` : diamètre minimal voulu pour une maille    |
 211 +---------------------------------------------------------------+
 212 | .. module:: GetDiamMin                                        |
 213 |                                                               |
 214 | **GetDiamMin()**                                              |
 215 |     Retourne le diamètre minimal voulu                        |
 216 +---------------------------------------------------------------+
 217
 218
 219 Exemple
 220 """""""
 221 La création de l'objet hypo_1 se fait ainsi : ::
 222
 223     hypo_1 = homard.CreateHypothesis("HypoField")
 224     hypo_1.SetAdapRefinUnRef(1, 1, 0)
 225     hypo_1.SetField("INDICATEUR")
 226     hypo_1.AddComp("INDX")
 227     hypo_1.AddComp("INDZ")
 228     hypo_1.SetRefinThr(1, 80.)
 229
 230
 231 Saisie graphique correspondante
 232 """""""""""""""""""""""""""""""
 233 Consulter :ref:`gui_create_hypothese`
 234
 235 .. warning::
 236   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.