doc/tutorials.rst

   1 Exemples
   2 ========
   3 .. index:: single: exemple
   4 .. index:: single: python
   5
   6 On trouvera ici les instructions python pour quelques configurations caractéristiques. Les fichiers de données associés sont téléchargeables. Il faut penser à adapter la valeur de la variable ``data_dir`` : c'est le répertoire dans lequel les fichiers med auront été enregistrés.
   7 C'est dans le répertoire ``dircase`` que seront écrits les fichiers résultant des adaptations successives. Ce répertoire est créé par défaut dans ``/tmp``.
   8
   9 Raffinement uniforme
  10 """"""""""""""""""""
  11 .. index:: single: raffinement;uniforme
  12
  13 On fera ici trois raffinements uniformes successifs du maillage contenu dans le fichier ``tutorial_1.00.med``. Quelques remarques :
  14   * la même hypothèse est utilisée à chaque itération
  15   * le maillage produit porte toujours le même nom. Cela ne pose pas de problème car il est stocké dans des fichiers différents.
  16
  17  ::
  18
  19   #
  20   # Hypothesis "Hypo_0"
  21   # ===================
  22   Hypo_0 = homard.CreateHypothesis('Hypo_0')
  23   Hypo_0.SetAdapRefinUnRef(-1, 1, 0)
  24   #
  25   # Case "Case_1"
  26   # =============
  27   Case_1 = homard.CreateCase('Case_1', 'MAILL', data_dir+'/tutorial_1.00.med')
  28   Case_1.SetDirName(dircase)
  29   Case_1.SetConfType(1)
  30   #
  31   # Iterations
  32   # ==========
  33   # Iteration "Iter_0"
  34   Iter_0 = Case_1.NextIteration('Iter_0')
  35   Iter_0.SetMeshName('MESH')
  36   Iter_0.SetMeshFile(dircase+'/maill.01.med')
  37   Iter_0.AssociateHypo('Hypo_0')
  38   codret = Iter_0.Compute(1, 2)
  39
  40   # Iteration "Iter_1"
  41   Iter_1 = Iter_0.NextIteration('Iter_1')
  42   Iter_1.SetMeshName('MESH')
  43   Iter_1.SetMeshFile(dircase+'/maill.02.med')
  44   Iter_1.AssociateHypo('Hypo_0')
  45   codret = Iter_1.Compute(1, 2)
  46
  47   # Iteration "Iter_2"
  48   Iter_2 = Iter_1.NextIteration('Iter_2')
  49   Iter_2.SetMeshName('MESH')
  50   Iter_2.SetMeshFile(dircase+'/maill.03.med')
  51   Iter_2.AssociateHypo('Hypo_0')
  52   codret = Iter_2.Compute(1, 2)
  53
  54 .. note::
  55   Téléchargement des fichiers
  56
  57   * :download:`maillage initial<files/tutorial_1.00.med.gz>`
  58   * :download:`commandes python<files/tutorial_1.py>`
  59
  60
  61 Raffinement par des zones
  62 """""""""""""""""""""""""
  63 .. index:: single: zone
  64
  65 On procède ici au raffinement selon des zones. Pour passer du maillage initial au maillage 'M_1', on utilise une boîte encadrant le plan z=1 et une sphère centrée sur l'origine de rayon 1.05. Puis pour passer du maillage 'M_1' au maillage 'M_2', on remplace la sphère par une boîte encadrant le cube de côté 0.5, pointant sur l'origine. On notera que le type de raffinement n'a pas été précisé ; par défaut, il sera donc conforme.
  66 ::
  67
  68   #
  69   # Creation of the zones
  70   # =====================
  71   # Box "Zone_0"
  72   Zone_0 = homard.CreateZoneBox('Zone_0', -0.1, 1.1, -0.1, 1.1, 0.9, 1.1)
  73   #
  74   # Sphere "Zone_1"
  75   Zone_1 = homard.CreateZoneSphere('Zone_1', 0., 0., 0., 1.05)
  76   #
  77   # Box "Zone_2"
  78   Zone_2 = homard.CreateZoneBox('Zone_2', -0.1, 0.51, -0.1, 0.51, -0.1, 0.51)
  79   #
  80   # Hypothesis "Hypo_0"
  81   # ===================
  82   Hypo_0 = homard.CreateHypothesis('Hypo_0')
  83   Hypo_0.SetAdapRefinUnRef(0, 1, 0)
  84   Hypo_0.AddZone('Zone_1', 1)
  85   Hypo_0.AddZone('Zone_0', 1)
  86   #
  87   # Hypothesis "Hypo_1"
  88   # ===================
  89   Hypo_1 = homard.CreateHypothesis('Hypo_1')
  90   Hypo_1.SetAdapRefinUnRef(0, 1, 0)
  91   Hypo_1.AddZone('Zone_0', 1)
  92   Hypo_1.AddZone('Zone_2', 1)
  93   #
  94   # Case "Case_1"
  95   # =============
  96   Case_1 = homard.CreateCase('Case_1', 'MZERO', data_dir+'/tutorial_2.00.med')
  97   Case_1.SetDirName(dircase)
  98   #
  99   # Iteration "Iter_0"
 100   # ==================
 101   Iter_0 = Case_1.NextIteration('Iter_0')
 102   Iter_0.SetMeshName('M_1')
 103   Iter_0.SetMeshFile(dircase+'/maill.01.med')
 104   Iter_0.AssociateHypo('Hypo_0')
 105   codret = Iter_0.Compute(1, 2)
 106   #
 107   # Iteration "Iter_1"
 108   # ==================
 109   Iter_1 = Iter_0.NextIteration('Iter_1')
 110   Iter_1.SetMeshName('M_2')
 111   Iter_1.SetMeshFile(dircase+'/maill.02.med')
 112   Iter_1.AssociateHypo('Hypo_1')
 113   codret = Iter_1.Compute(1, 2)
 114
 115 .. note::
 116   Téléchargement des fichiers
 117
 118   * :download:`maillage initial<files/tutorial_2.00.med.gz>`
 119   * :download:`commandes python<files/tutorial_2.py>`
 120
 121
 122 Raffinement selon un champ
 123 """"""""""""""""""""""""""
 124 .. index:: single: champ
 125
 126 On procède ici au raffinement selon un champ. Les hypothèses servent à définir le nom du champ et les seuils de raffinement/déraffinement. La donnée du fichier et des instants est faite dans l'itération. Des champs sur les noeuds ou sur les mailles sont interpolés.
 127 Pour adapter le maillage H_1 issu de l'itération Iter_1, deux variantes sont appliquées. Dans la première, Iter_2, le champ est un champ scalaire d'indicateurs d'erreur et on découpe les 1.5% de mailles où l'erreur est la plus grande. Dans la seconde variante, Iter_2_bis, on se base sur un champ vectoriel et on examine le saut de ce vecteur entre une maille et ses voisines : on découpera là où la norme infinie de ce saut est supérieure au seuil absolu de 0.0001.
 128 ::
 129
 130   #
 131   # Hypothesis "Hypo_0vers1"
 132   # ========================
 133   Hypo_0vers1 = homard.CreateHypothesis('Hypo_0vers1')
 134   Hypo_0vers1.SetAdapRefinUnRef(1, 1, 0)
 135   # Characterization of the field
 136   Hypo_0vers1.SetField('SOLU_0__QIRE_ELEM_SIGM__________')
 137   Hypo_0vers1.SetUseComp(0)
 138   Hypo_0vers1.AddComp('ERREST          ')
 139   Hypo_0vers1.SetRefinThr(3, 1.0)
 140   Hypo_0vers1.SetTypeFieldInterp(2)
 141   Hypo_0vers1.AddFieldInterp('SOLU_0__DEPL____________________')
 142   Hypo_0vers1.AddFieldInterp('SOLU_0__ERRE_ELEM_SIGM__________')
 143   #
 144   # Hypothesis "Hypo_1vers2"
 145   # ========================
 146   Hypo_1vers2 = homard.CreateHypothesis('Hypo_1vers2')
 147   Hypo_1vers2.SetAdapRefinUnRef(1, 1, 1)
 148   # Characterization of the field
 149   Hypo_1vers2.SetField('SOLU_1__QIRE_ELEM_SIGM__________')
 150   Hypo_1vers2.SetUseComp(0)
 151   Hypo_1vers2.AddComp('ERREST          ')
 152   Hypo_1vers2.SetRefinThr(3, 1.5)
 153   Hypo_1vers2.SetUnRefThr(3, 6.)
 154   Hypo_1vers2.SetTypeFieldInterp(2)
 155   Hypo_1vers2.AddFieldInterp('SOLU_1__DEPL____________________')
 156   Hypo_1vers2.AddFieldInterp('SOLU_1__QIRE_ELEM_SIGM__________')
 157   #
 158   # Hypothesis "Hypo_1vers2_bis"
 159   # ============================
 160   Hypo_1vers2_bis = homard.CreateHypothesis('Hypo_1vers2_bis')
 161   Hypo_1vers2_bis.SetAdapRefinUnRef(1, 1, 1)
 162   # Characterization of the field
 163   Hypo_1vers2_bis.SetField('SOLU_1__DEPL____________________')
 164   Hypo_1vers2_bis.SetUseComp(1)
 165   Hypo_1vers2_bis.AddComp('DX')
 166   Hypo_1vers2_bis.AddComp('DY')
 167   Hypo_1vers2_bis.AddComp('DZ')
 168   Hypo_1vers2_bis.SetRefinThr(1, 0.0001)
 169   Hypo_1vers2_bis.SetUnRefThr(1, 0.000001)
 170   Hypo_1vers2_bis.SetTypeFieldInterp(0)
 171   #
 172   # Case "Case_1"
 173   # =============
 174   Case_1 = homard.CreateCase('Case_1', 'G_0', data_dir+'/tutorial_3.00.med')
 175   Case_1.SetDirName(dircase)
 176   #
 177   # Iteration "Iter_1"
 178   # ==================
 179   Iter_1 = Case_1.NextIteration('Iter_1')
 180   Iter_1.SetMeshName('H_1')
 181   Iter_1.SetMeshFile(dircase+'/maill.01.med')
 182   Iter_1.SetFieldFile(data_dir+'/tutorial_3.00.med')
 183   Iter_1.SetTimeStepRank( 1, 1)
 184   Iter_1.AssociateHypo('Hypo_0vers1')
 185   codret = Iter_1.Compute(1, 2)
 186   #
 187   # Iteration "Iter_2"
 188   # ==================
 189   Iter_2 = Iter_1.NextIteration('Iter_2')
 190   Iter_2.SetMeshName('H_2')
 191   Iter_2.SetMeshFile(dircase+'/maill.02.med')
 192   Iter_2.SetFieldFile(data_dir+'/tutorial_3.01.med')
 193   Iter_2.SetTimeStepRank(1, 1)
 194   Iter_2.AssociateHypo('Hypo_1vers2')
 195   codret = Iter_2.Compute(1, 2)
 196   #
 197   # Iteration "Iter_2_bis"
 198   # ======================
 199   Iter_2_bis = Iter_1.NextIteration('Iter_2_bis')
 200   Iter_2_bis.SetMeshName('H_2_bis')
 201   Iter_2_bis.SetMeshFile(dircase+'/maill.02.bis.med')
 202   Iter_2_bis.SetFieldFile(data_dir+'/tutorial_3.01.med')
 203   Iter_2_bis.SetTimeStepRank(1, 1)
 204   Iter_2_bis.AssociateHypo('Hypo_1vers2_bis')
 205   codret = Iter_2_bis.Compute(1, 2)
 206
 207 .. note::
 208   Téléchargement des fichiers
 209
 210   * :download:`maillage et champ étape 0<files/tutorial_3.00.med.gz>`
 211   * :download:`maillage et champ étape 1<files/tutorial_3.01.med.gz>`
 212   * :download:`commandes python<files/tutorial_3.py>`
 213
 214
 215 Suivi de frontières courbes
 216 """""""""""""""""""""""""""
 217 .. index:: single: champ
 218
 219 On teste ici le suivi des frontières courbes : des frontières analytiques pour décrire les différentes surfaces des tuyaux et une frontière discrète pour décrire les lignes d'intersection des deux tuyaux. Le pilotage du raffinement est le suivant : raffinement uniforme de toutes les mailles contenues dans des groupes désignés. On commence par raffiner les faces internes aux tuyaux ; ensuite, on raffine deux fois de suite les faces externes aux tuyaux.
 220 Le schéma YACS réalisant cette adaptation est téléchargeable.
 221 ::
 222
 223   #
 224   # Creation of the boundaries
 225   # ==========================
 226   Boundary_1 = homard.CreateBoundaryDi('intersection', 'PIQUAGE', data_dir+'/tutorial_4.fr.med')
 227   #
 228   Boundary_2 = homard.CreateBoundaryCylinder('cyl_1_ext', 0.0, 25., -25., 25., 50., 75., 100.)
 229   #
 230   Boundary_3 = homard.CreateBoundaryCylinder('cyl_2_ext', 17.5, -2.5, -12.5, -100., -75., -25., 50.)
 231   #
 232   Boundary_4 = homard.CreateBoundaryCylinder('cyl_1_int', 0.0, 25., -25., 25., 50., 75., 75.)
 233   #
 234   Boundary_5 = homard.CreateBoundaryCylinder('cyl_2_int', 17.5, -2.5, -12.5, -100., -75., -25., 25.)
 235   #
 236   # Hypothesis "Hypo"
 237   # ===================
 238   # Creation of the hypothesis Hypo_1
 239   Hypo_1 = homard.CreateHypothesis('Hypo_1')
 240   Hypo_1.SetAdapRefinUnRef(-1, 1, 0)
 241   Hypo_1.AddGroup('T1_INT_I')
 242   Hypo_1.AddGroup('T1_INT_O')
 243   Hypo_1.AddGroup('T2_INT')
 244   # Creation of the hypothesis Hypo_2
 245   Hypo_2 = homard.CreateHypothesis('Hypo_2')
 246   Hypo_2.SetAdapRefinUnRef(-1, 1, 0)
 247   Hypo_2.AddGroup('T1_EXT_I')
 248   Hypo_2.AddGroup('T1_EXT_O')
 249   Hypo_2.AddGroup('T2_EXT')
 250   #
 251   # Case "Case"
 252   # =============
 253   Case = homard.CreateCase('Case', 'PIQUAGE', data_dir+'/tutorial_4.00.med')
 254   Case.SetDirName(dircase)
 255   Case.AddBoundaryGroup( 'intersection', '' )
 256   Case.AddBoundaryGroup( 'cyl_1_ext', 'T1_EXT_I' )
 257   Case.AddBoundaryGroup( 'cyl_1_ext', 'T1_EXT_O' )
 258   Case.AddBoundaryGroup( 'cyl_2_ext', 'T2_EXT' )
 259   Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT_I' )
 260   Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT_O' )
 261   Case.AddBoundaryGroup( 'cyl_2_int', 'T2_INT' )
 262   #
 263   # Creation of the iterations
 264   # ==========================
 265   # Creation of the iteration Iter_1 : raffinement selon les faces internes
 266   Iter_1 = Case.NextIteration('Iter_1')
 267   Iter_1.SetMeshName('PIQUAGE_1')
 268   Iter_1.SetMeshFile(dircase+'/maill.01.med')
 269   Iter_1.AssociateHypo('Hypo_1')
 270   codret = Iter_1.Compute(1, 2)
 271   # Creation of the iteration Iter_2 : raffinement selon les faces externes
 272   Iter_2 = Iter_1.NextIteration('Iter_2')
 273   Iter_2.SetMeshName('PIQUAGE_2')
 274   Iter_2.SetMeshFile(dircase+'/maill.02.med')
 275   Iter_2.AssociateHypo('Hypo_2')
 276   codret = Iter_2.Compute(1, 2)
 277   # Creation of the iteration Iter_3 : second raffinement selon les faces externes
 278   Iter_3 = Iter_2.NextIteration('Iter_3')
 279   Iter_3.SetMeshName('PIQUAGE_3')
 280   Iter_3.SetMeshFile(dircase+'/maill.03.med')
 281   Iter_3.AssociateHypo('Hypo_2')
 282   codret = Iter_3.Compute(1, 2)
 283
 284 .. note::
 285   Téléchargement des fichiers
 286
 287   * :download:`maillage initial<files/tutorial_4.00.med.gz>`
 288   * :download:`maillage de la frontière discrète<files/tutorial_4.fr.med.gz>`
 289   * :download:`commandes python<files/tutorial_4.py>`
 290   * :download:`schéma YACS<files/tutorial_4.xml>`
 291
 292
 293 Instructions spécifiques au 2D
 294 """"""""""""""""""""""""""""""
 295 .. index:: single: 2D
 296
 297 Les instructions pour adapter un maillage 2D sont exactement identiques à celles nécessaires à l'adaptation d'un maillage 3D. La seule exception concerne le raffinement selon des zones géométriques : des fonctions différentes sont utilisées pour pouvoir définir des zones 2D. On donne alors les coordonnées 2D des zones, en précisant l'orientation du plan du maillage.
 298 Dans le cas présenté ici, on raffine une première fois toutes les mailles contenues dans un disque percé, puis dans une seconde itération, toutes les mailles contenues dans un rectangle. On notera l'utilisation du suivi des frontières circulaires du domaine.
 299 ::
 300
 301   #
 302   # Creation of the boundaries
 303   # ==========================
 304   # Creation of the discrete boundary Boun_1
 305   Boun_1 = homard.CreateBoundaryDi('Boun_1', 'MAIL_EXT', data_dir+'/tutorial_5.fr.med')
 306   #
 307   # Creation of the zones
 308   # =====================
 309   # Creation of the disk with hole enveloppe
 310   enveloppe = homard.CreateZoneDiskWithHole( 'enveloppe', 0., 0., 250., 193., 1 )
 311   # Creation of the rectangle quart_sup
 312   quart_sup = homard.CreateZoneBox2D( 'quart_sup', 0., 250., 0., 250., 1 )
 313   #
 314   # Hypothesis
 315   # ==========
 316   # Creation of the hypothesis Hypo_1
 317   Hypo_1 = homard.CreateHypothesis('Hypo_1')
 318   Hypo_1.SetAdapRefinUnRef(0, 1, 0)
 319   Hypo_1.AddZone('enveloppe', 1)
 320   # Creation of the hypothesis Hypo_2
 321   Hypo_2 = homard.CreateHypothesis('Hypo_2')
 322   Hypo_2.SetAdapRefinUnRef(0, 1, 0)
 323   Hypo_2.AddZone('quart_sup', 1)
 324   #
 325   # Case "Case_1"
 326   # =============
 327   Case_1 = homard.CreateCase('Case_1', 'COEUR_2D', data_dir+'/tutorial_5.00.med')
 328   Case_1.SetDirName(dircase)
 329   Case_1.SetConfType(3)
 330   Case_1.AddBoundaryGroup('Boun_1', '')
 331   #
 332   # Iteration "Iter_1"
 333   # ==================
 334   Iter_1 = Case_1.NextIteration('Iter_1')
 335   Iter_1.SetMeshName('COEUR_2D_01')
 336   Iter_1.SetMeshFile(dircase+'/maill.01.med')
 337   Iter_1.AssociateHypo('Hypo_1')
 338   codret = Iter_1.Compute(1, 2)
 339   #
 340   # Iteration "Iter_2"
 341   # ==================
 342   Iter_2 = Iter_1.NextIteration('Iter_2')
 343   Iter_2.SetMeshName('COEUR_2D_02')
 344   Iter_2.SetMeshFile(dircase+'/maill.02.med')
 345   Iter_2.AssociateHypo('Hypo_2')
 346   codret = Iter_2.Compute(1, 2)
 347
 348 .. note::
 349   Téléchargement des fichiers
 350
 351   * :download:`maillage initial<files/tutorial_5.00.med.gz>`
 352   * :download:`maillage de la frontière discrète<files/tutorial_5.fr.med.gz>`
 353   * :download:`commandes python<files/tutorial_5.py>`
 354
 355
 356 .. toctree::
 357    :maxdepth: 2