doc/en/tui_create_case.rst

   1 .. _tui_create_case:
   2
   3 The case
   4 ########
   5 .. index:: single: cas
   6 .. index:: single: type of conformity
   7 .. index:: single: mesh;initial
   8
   9 The variables are described in :ref:`gui_create_case`.
  10
  11 Methods of the class homard
  12 ***************************
  13
  14 Creation of a case
  15 ==================
  16
  17 +---------------------------------------------------------------+
  18 +---------------------------------------------------------------+
  19 | .. module:: CreateCase                                        |
  20 |                                                               |
  21 | **CreateCase(case_name, mesh_name, mesh_file)**               |
  22 |     Returns an instance of the class ``cas`` after its        |
  23 |     creation                                                  |
  24 |                                                               |
  25 |     - ``case_name``: the name of the case                     |
  26 |     - ``mesh_name``: the name of the initial mesh             |
  27 |     - ``mesh_file``: the name of the MED file of this mesh    |
  28 |                                                               |
  29 | Default:                                                      |
  30 |                                                               |
  31 |  * the directory for the results is ``/tmp``                  |
  32 |  * the adaptation is conformal                                |
  33 +---------------------------------------------------------------+
  34 | .. module:: GetCase                                           |
  35 |                                                               |
  36 | **GetCase(case_name)**                                        |
  37 |     Returns an instance of the class ``cas`` known by its name|
  38 |                                                               |
  39 |     - ``case_name``: the name of the case                     |
  40 +---------------------------------------------------------------+
  41 | .. module:: GetAllCasesName                                   |
  42 |                                                               |
  43 | **GetAllCasesName()**                                         |
  44 |     Returns the liste of the name of all the existing cases   |
  45 |                                                               |
  46 +---------------------------------------------------------------+
  47
  48 Creation of a case by pursuit of a computed iteration
  49 =====================================================
  50
  51 +---------------------------------------------------------------+
  52 +---------------------------------------------------------------+
  53 | .. module:: CreateCaseFromIteration                           |
  54 |                                                               |
  55 | **CreateCaseFromIteration(case_name, dir_name)**              |
  56 |     Returns an instance of the class ``cas`` after its        |
  57 |     creation                                                  |
  58 |                                                               |
  59 |     - ``case_name``: the name of the case                     |
  60 |     - ``dir_name``: the name of the directory that contains   |
  61 |       the iteration                                           |
  62 |                                                               |
  63 +---------------------------------------------------------------+
  64 | .. module:: CreateCaseFromCaseLastIteration                   |
  65 |                                                               |
  66 | **CreateCaseFromCaseLastIteration(case_name, dir_name)**      |
  67 |     Returns an instance of the class ``cas`` after its        |
  68 |     creation                                                  |
  69 |                                                               |
  70 |     - ``case_name``: the name of the case                     |
  71 |     - ``dir_name``: the name of the directory that contains   |
  72 |       the case                                                |
  73 |                                                               |
  74 +---------------------------------------------------------------+
  75 | .. module:: CreateCaseFromCaseIteration                       |
  76 |                                                               |
  77 | **CreateCaseFromCaseIteration(case_name, dir_name, number)**  |
  78 |     Returns an instance of the class ``cas`` after its        |
  79 |     creation                                                  |
  80 |                                                               |
  81 |     - ``case_name``: the name of the case                     |
  82 |     - ``dir_name``: the name of the directory that contains   |
  83 |       the case                                                |
  84 |     - ``number``: the number of the iteration of the case     |
  85 |                                                               |
  86 +---------------------------------------------------------------+
  87
  88
  89
  90 Methods of the class cas
  91 ************************
  92 .. index:: single: yacs
  93
  94 +---------------------------------------------------------------+
  95 +---------------------------------------------------------------+
  96 | .. module:: GetName                                           |
  97 |                                                               |
  98 | **GetName()**                                                 |
  99 |     Returns the name of the case                              |
 100 +---------------------------------------------------------------+
 101 | .. module:: SetDirName                                        |
 102 |                                                               |
 103 | **SetDirName(dirname)**                                       |
 104 |     Gives a directory for the results of the case. It can be  |
 105 |     done only after the creation of the case and before the   |
 106 |     first computation.                                        |
 107 |                                                               |
 108 |     - ``dirname``: the name of the directory of the results   |
 109 +---------------------------------------------------------------+
 110 | .. module:: GetDirName                                        |
 111 |                                                               |
 112 | **GetDirName()**                                              |
 113 |     Returns the name of the directory of the results of the   |
 114 |     case                                                      |
 115 +---------------------------------------------------------------+
 116 | .. module:: SetConfType                                       |
 117 |                                                               |
 118 | **SetConfType(conf_type)**                                    |
 119 |     Defines the type of conformity for the case               |
 120 |                                                               |
 121 |     - ``conf_type``: integer as follows:                      |
 122 |                                                               |
 123 |         * 1: conformal                                        |
 124 |         * 2: non conformal with one hanging node per element  |
 125 |         * 3: non conformal with one hanging node per edge of  |
 126 |           element                                             |
 127 |         * 4: non conformal without any constraint             |
 128 +---------------------------------------------------------------+
 129 | .. module:: GetConfType                                       |
 130 |                                                               |
 131 | **GetConfType()**                                             |
 132 |     Returns the type of conformity                            |
 133 +---------------------------------------------------------------+
 134 | .. module:: GetIter0                                          |
 135 |                                                               |
 136 | **GetIter0()**                                                |
 137 |     Returns the iteration linked to the initial mesh.         |
 138 |     This iteration is automatically created by the module     |
 139 |     HOMARD. It is used to connect the iterations. It is       |
 140 |     connected to an initial mesh or to the iteration of a     |
 141 |     previous case.                                            |
 142 +---------------------------------------------------------------+
 143 | .. module:: AddBoundaryGroup                                  |
 144 |                                                               |
 145 | **AddBoundaryGroup(boundary, group)**                         |
 146 |     Add a boundary to the definition of a case                |
 147 |                                                               |
 148 |     - ``boundary``: name of the curved boundary               |
 149 |                                                               |
 150 |     Discrete boundary:                                        |
 151 |                                                               |
 152 |     . if all the curved lines are involved, the second        |
 153 |     argument is an empty string.                              |
 154 |     . if only some curved lines are involved, ``group`` is    |
 155 |     the name of the group of segments                         |
 156 |                                                               |
 157 |     Analytical boundary:                                      |
 158 |                                                               |
 159 |     - ``group``: name of the group of faces located on the    |
 160 |       boundary                                                |
 161 +---------------------------------------------------------------+
 162 | .. module:: Delete                                            |
 163 |                                                               |
 164 | **Delete(option)**                                            |
 165 |     Deletes the case and all the connected iterations. The MED|
 166 |     file of the first mesh is kept.                           |
 167 |                                                               |
 168 |     - ``option``: an integer to define what to do with the    |
 169 |       MED file of the associated meshes                       |
 170 |                                                               |
 171 |         * 0: the files are kept                               |
 172 |         * 1: the files are removed                            |
 173 |                                                               |
 174 |     Returns an integer:                                       |
 175 |         * 0: the destruction is done                          |
 176 |         * other value: problem                                |
 177 +---------------------------------------------------------------+
 178 | .. module:: GetState                                          |
 179 |                                                               |
 180 | **GetState()**                                                |
 181 |     Returns the state of the case:                            |
 182 |         * 0: corresponds to an initial mesh                   |
 183 |         * other value: pursuit of an iteration with number n  |
 184 +---------------------------------------------------------------+
 185 | .. module:: WriteYACSSchema                                   |
 186 |                                                               |
 187 | **WriteYACSSchema(ScriptFile, DirName, MeshFile)**            |
 188 |     Writes a schema YACS relative to the case.                |
 189 |                                                               |
 190 |     - ``ScriptFile`` : name of the file that contains the     |
 191 |       script to launch the computation                        |
 192 |     - ``DirName`` : the directory for the computation         |
 193 |     - ``MeshFile`` : name of the file that contains the mesh  |
 194 |       for the very first computation                          |
 195 +---------------------------------------------------------------+
 196
 197 Advanced options
 198 ****************
 199
 200 +---------------------------------------------------------------+
 201 +---------------------------------------------------------------+
 202 | .. module:: SetPyram                                          |
 203 |                                                               |
 204 | **SetPyram(option)**                                          |
 205 |     Defines the status of the pyramids in this case           |
 206 |                                                               |
 207 |     - ``option``: integer that defines the status of the      |
 208 |       pyramids that could belongs to the initial mesh         |
 209 |                                                               |
 210 |         * 0: rejected pyramids (default)                      |
 211 |         * 1: authorized pyramids                              |
 212 +---------------------------------------------------------------+
 213 | .. module:: GetPyram                                          |
 214 |                                                               |
 215 | **GetPyram()**                                                |
 216 |     Returns the status of the pyramids in this case           |
 217 +---------------------------------------------------------------+
 218
 219 Informations for the initial mesh
 220 *********************************
 221
 222 +---------------------------------------------------------------+
 223 +---------------------------------------------------------------+
 224 | .. module:: MeshInfo                                          |
 225 |                                                               |
 226 | **MeshInfo(Qual, Diam, Conn, Tail, Inte)**                    |
 227 |     Gives information about the current mesh. For every       |
 228 |     option, the choice #0 corresponds to 'no action', while   |
 229 |     the choice #1 launches the option.                        |
 230 |                                                               |
 231 |     - ``Qual``: quality of the elements                       |
 232 |     - ``Diam``: diametre of the elements                      |
 233 |     - ``Conn``: connexity of the domain; a single block, how  |
 234 |       many holes, etc.                                        |
 235 |     - ``Tail``: size of the parts of the domain, group by     |
 236 |       group                                                   |
 237 |     - ``Inte``: staggered elements, by dimension              |
 238 +---------------------------------------------------------------+
 239
 240
 241 Example
 242 *******
 243 The creation of the object case_1 is done as follows:
 244
 245 ::
 246
 247     case_name = "CAS_1"
 248     mesh_name = "MAILL"
 249     mesh_file = "/scratch/Salome/Adapt/m0.med"
 250     case_1 = homard.CreateCase(case_name, mesh_name, mesh_file)
 251     dirname = "/scratch/Salome/Adapt/resu"
 252     case_1.SetDirName(dirname)
 253     case_1.SetConfType(1)
 254     case_1.AddBoundaryGroup( 'intersection', '' )
 255     case_1.AddBoundaryGroup( 'cyl_1', 'T1_EXT' )
 256     case_1.AddBoundaryGroup( 'cyl_1', 'T2_EXT' )
 257     case_1.AddBoundaryGroup( 'cyl_2', 'T_INT' )
 258
 259
 260
 261 Similar graphical input
 262 ***********************
 263 Look at :ref:`gui_create_case`
 264
 265