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. C'est dans ce répertoire ``dircase`` que seront écrits les fichiers résultant des adaptations successives.
   7
   8 Raffinement uniforme
   9 """"""""""""""""""""
  10 .. index:: single: raffinement;uniforme
  11
  12 On fera ici trois raffinements uniformes successifs du maillage contenu dans le fichier ``tutorial_1.00.med``. Quelques remarques :
  13   * la même hypothèse est utilisée à chaque itération
  14   * 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.
  15
  16  ::
  17
  18   #
  19   # Hypothesis "Hypo_0"
  20   # ===================
  21   Hypo_0 = homard.CreateHypothesis('Hypo_0')
  22   Hypo_0.SetAdapRefinUnRef(-1, 1, 0)
  23   #
  24   # Case "Case_1"
  25   # =============
  26   Case_1 = homard.CreateCase('Case_1', 'MAILL', data_dir+'/tutorial_1.00.med')
  27   Case_1.SetDirName(dircase)
  28   Case_1.SetConfType(1)
  29   #
  30   # Iterations
  31   # ==========
  32   # Iteration "Iter_0"
  33   Iter_0 = Case_1.NextIteration('Iter_0')
  34   Iter_0.SetMeshName('MESH')
  35   Iter_0.SetMeshFile(dircase+'/maill.01.med')
  36   Iter_0.AssociateHypo('Hypo_0')
  37   codret = Iter_0.Compute(1)
  38
  39   # Iteration "Iter_1"
  40   Iter_1 = Iter_0.NextIteration('Iter_1')
  41   Iter_1.SetMeshName('MESH')
  42   Iter_1.SetMeshFile(dircase+'/maill.02.med')
  43   Iter_1.AssociateHypo('Hypo_0')
  44   codret = Iter_1.Compute(1)
  45
  46   # Iteration "Iter_2"
  47   Iter_2 = Iter_1.NextIteration('Iter_2')
  48   Iter_2.SetMeshName('MESH')
  49   Iter_2.SetMeshFile(dircase+'/maill.03.med')
  50   Iter_2.AssociateHypo('Hypo_0')
  51   codret = Iter_2.Compute(1)
  52
  53 .. note::
  54   Téléchargement des fichiers
  55
  56   * :download:`maillage initial<files/tutorial_1.00.med.gz>`
  57   * :download:`commandes python<files/tutorial_1.py>`
  58
  59
  60 Raffinement par des zones
  61 """""""""""""""""""""""""
  62 .. index:: single: zone
  63
  64 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.
  65 ::
  66
  67   #
  68   # Creation of the zones
  69   # =====================
  70   # Box "Zone_0"
  71   Zone_0 = homard.CreateZoneBox('Zone_0', -0.1, 1.1, -0.1, 1.1, 0.9, 1.1)
  72   #
  73   # Sphere "Zone_1"
  74   Zone_1 = homard.CreateZoneSphere('Zone_1', 0., 0., 0., 1.05)
  75   #
  76   # Box "Zone_2"
  77   Zone_2 = homard.CreateZoneBox('Zone_2', -0.1, 0.51, -0.1, 0.51, -0.1, 0.51)
  78   #
  79   # Hypothesis "Hypo_0"
  80   # ===================
  81   Hypo_0 = homard.CreateHypothesis('Hypo_0')
  82   Hypo_0.SetAdapRefinUnRef(0, 1, 0)
  83   Hypo_0.AddZone('Zone_1', 1)
  84   Hypo_0.AddZone('Zone_0', 1)
  85   #
  86   # Hypothesis "Hypo_1"
  87   # ===================
  88   Hypo_1 = homard.CreateHypothesis('Hypo_1')
  89   Hypo_1.SetAdapRefinUnRef(0, 1, 0)
  90   Hypo_1.AddZone('Zone_0', 1)
  91   Hypo_1.AddZone('Zone_2', 1)
  92   #
  93   # Case "Case_1"
  94   # =============
  95   Case_1 = homard.CreateCase('Case_1', 'MZERO', data_dir+'/tutorial_2.00.med')
  96   Case_1.SetDirName(dircase)
  97   #
  98   # Iteration "Iter_0"
  99   # ==================
 100   Iter_0 = Case_1.NextIteration('Iter_0')
 101   Iter_0.SetMeshName('M_1')
 102   Iter_0.SetMeshFile(dircase+'/maill.01.med')
 103   Iter_0.AssociateHypo('Hypo_0')
 104   codret = Iter_0.Compute(1)
 105   #
 106   # Iteration "Iter_1"
 107   # ==================
 108   Iter_1 = Iter_0.NextIteration('Iter_1')
 109   Iter_1.SetMeshName('M_2')
 110   Iter_1.SetMeshFile(dircase+'/maill.02.med')
 111   Iter_1.AssociateHypo('Hypo_1')
 112   codret = Iter_1.Compute(1)
 113
 114 .. note::
 115   Téléchargement des fichiers
 116
 117   * :download:`maillage initial<files/tutorial_2.00.med.gz>`
 118   * :download:`commandes python<files/tutorial_2.py>`
 119
 120
 121 Raffinement selon un champ
 122 """"""""""""""""""""""""""
 123 .. index:: single: champ
 124
 125 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.
 126 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.
 127 ::
 128
 129   #
 130   # Hypothesis "Hypo_0vers1"
 131   # ========================
 132   Hypo_0vers1 = homard.CreateHypothesis('Hypo_0vers1')
 133   Hypo_0vers1.SetAdapRefinUnRef(1, 1, 0)
 134   # Characterization of the field
 135   Hypo_0vers1.SetField('SOLU_0__QIRE_ELEM_SIGM__________')
 136   Hypo_0vers1.SetUseComp(0)
 137   Hypo_0vers1.AddComp('ERREST          ')
 138   Hypo_0vers1.SetRefinThr(3, 1.0)
 139   Hypo_0vers1.SetTypeFieldInterp(2)
 140   Hypo_0vers1.AddFieldInterp('SOLU_0__DEPL____________________')
 141   Hypo_0vers1.AddFieldInterp('SOLU_0__ERRE_ELEM_SIGM__________')
 142   #
 143   # Hypothesis "Hypo_1vers2"
 144   # ========================
 145   Hypo_1vers2 = homard.CreateHypothesis('Hypo_1vers2')
 146   Hypo_1vers2.SetAdapRefinUnRef(1, 1, 1)
 147   # Characterization of the field
 148   Hypo_1vers2.SetField('SOLU_1__QIRE_ELEM_SIGM__________')
 149   Hypo_1vers2.SetUseComp(0)
 150   Hypo_1vers2.AddComp('ERREST          ')
 151   Hypo_1vers2.SetRefinThr(3, 1.5)
 152   Hypo_1vers2.SetUnRefThr(3, 6.)
 153   Hypo_1vers2.SetTypeFieldInterp(2)
 154   Hypo_1vers2.AddFieldInterp('SOLU_1__DEPL____________________')
 155   Hypo_1vers2.AddFieldInterp('SOLU_1__QIRE_ELEM_SIGM__________')
 156   #
 157   # Hypothesis "Hypo_1vers2_bis"
 158   # ============================
 159   Hypo_1vers2_bis = homard.CreateHypothesis('Hypo_1vers2_bis')
 160   Hypo_1vers2_bis.SetAdapRefinUnRef(1, 1, 1)
 161   # Characterization of the field
 162   Hypo_1vers2_bis.SetField('SOLU_1__DEPL____________________')
 163   Hypo_1vers2_bis.SetUseComp(1)
 164   Hypo_1vers2_bis.AddComp('DX')
 165   Hypo_1vers2_bis.AddComp('DY')
 166   Hypo_1vers2_bis.AddComp('DZ')
 167   Hypo_1vers2_bis.SetRefinThr(1, 0.0001)
 168   Hypo_1vers2_bis.SetUnRefThr(1, 0.000001)
 169   Hypo_1vers2_bis.SetTypeFieldInterp(0)
 170   #
 171   # Case "Case_1"
 172   # =============
 173   Case_1 = homard.CreateCase('Case_1', 'G_0', data_dir+'/tutorial_3.00.med')
 174   Case_1.SetDirName(dircase)
 175   #
 176   # Iteration "Iter_1"
 177   # ==================
 178   Iter_1 = Case_1.NextIteration('Iter_1')
 179   Iter_1.SetMeshName('H_1')
 180   Iter_1.SetMeshFile(dircase+'/maill.01.med')
 181   Iter_1.SetFieldFile(data_dir+'/tutorial_3.00.med')
 182   Iter_1.SetTimeStepRank( 1, 1)
 183   Iter_1.AssociateHypo('Hypo_0vers1')
 184   codret = Iter_1.Compute(1)
 185   #
 186   # Iteration "Iter_2"
 187   # ==================
 188   Iter_2 = Iter_1.NextIteration('Iter_2')
 189   Iter_2.SetMeshName('H_2')
 190   Iter_2.SetMeshFile(dircase+'/maill.02.med')
 191   Iter_2.SetFieldFile(data_dir+'/tutorial_3.01.med')
 192   Iter_2.SetTimeStepRank(1, 1)
 193   Iter_2.AssociateHypo('Hypo_1vers2')
 194   codret = Iter_2.Compute(1)
 195   #
 196   # Iteration "Iter_2_bis"
 197   # ======================
 198   Iter_2_bis = Iter_1.NextIteration('Iter_2_bis')
 199   Iter_2_bis.SetMeshName('H_2_bis')
 200   Iter_2_bis.SetMeshFile(dircase+'/maill.02.bis.med')
 201   Iter_2_bis.SetFieldFile(data_dir+'/tutorial_3.01.med')
 202   Iter_2_bis.SetTimeStepRank(1, 1)
 203   Iter_2_bis.AssociateHypo('Hypo_1vers2_bis')
 204   codret = Iter_2_bis.Compute(1)
 205
 206 .. note::
 207   Téléchargement des fichiers
 208
 209   * :download:`maillage et champ étape 0<files/tutorial_3.00.med.gz>`
 210   * :download:`maillage et champ étape 1<files/tutorial_3.01.med.gz>`
 211   * :download:`commandes python<files/tutorial_3.py>`
 212
 213
 214 Suivi de frontières courbes
 215 """""""""""""""""""""""""""
 216 .. index:: single: champ
 217
 218 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.
 219 ::
 220
 221   #
 222   # Creation of the boundaries
 223   # ==========================
 224   Boundary_1 = homard.CreateBoundaryDi('intersection', 'PIQUAGE', data_dir+'/tutorial_4.fr.med')
 225   #
 226   Boundary_2 = homard.CreateBoundaryCylinder('cyl_1_ext', 0.0, 25., -25., 25., 50., 75., 100.)
 227   #
 228   Boundary_3 = homard.CreateBoundaryCylinder('cyl_2_ext', 17.5, -2.5, -12.5, -100., -75., -25., 50.)
 229   #
 230   Boundary_4 = homard.CreateBoundaryCylinder('cyl_1_int', 0.0, 25., -25., 25., 50., 75., 75.)
 231   #
 232   Boundary_5 = homard.CreateBoundaryCylinder('cyl_2_int', 17.5, -2.5, -12.5, -100., -75., -25., 25.)
 233   #
 234   # Hypothesis "Hypo"
 235   # ===================
 236   # Creation of the hypothesis Hypo_1
 237   Hypo_1 = homard.CreateHypothesis('Hypo_1')
 238   Hypo_1.SetAdapRefinUnRef(-1, 1, 0)
 239   Hypo_1.AddGroup('T1_INT_I')
 240   Hypo_1.AddGroup('T1_INT_O')
 241   Hypo_1.AddGroup('T2_INT')
 242   # Creation of the hypothesis Hypo_2
 243   Hypo_2 = homard.CreateHypothesis('Hypo_2')
 244   Hypo_2.SetAdapRefinUnRef(-1, 1, 0)
 245   Hypo_2.AddGroup('T1_EXT_I')
 246   Hypo_2.AddGroup('T1_EXT_O')
 247   Hypo_2.AddGroup('T2_EXT')
 248   #
 249   # Case "Case"
 250   # =============
 251   Case = homard.CreateCase('Case', 'PIQUAGE', data_dir+'/tutorial_4.00.med')
 252   Case.SetDirName(dircase)
 253   Case.AddBoundaryGroup( 'intersection', '' )
 254   Case.AddBoundaryGroup( 'cyl_1_ext', 'T1_EXT_I' )
 255   Case.AddBoundaryGroup( 'cyl_1_ext', 'T1_EXT_O' )
 256   Case.AddBoundaryGroup( 'cyl_2_ext', 'T2_EXT' )
 257   Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT_I' )
 258   Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT_O' )
 259   Case.AddBoundaryGroup( 'cyl_2_int', 'T2_INT' )
 260   #
 261   # Creation of the iterations
 262   # ==========================
 263   # Creation of the iteration Iter_1
 264   Iter_1 = Case.NextIteration('Iter_1')
 265   Iter_1.SetMeshName('PIQUAGE_1')
 266   Iter_1.SetMeshFile(dircase+'/maill.01.med')
 267   Iter_1.AssociateHypo('Hypo_1')
 268   codret = Iter_1.Compute(1)
 269   # Creation of the iteration Iter_2
 270   Iter_2 = Iter_1.NextIteration('Iter_2')
 271   Iter_2.SetMeshName('PIQUAGE_2')
 272   Iter_2.SetMeshFile(dircase+'/maill.02.med')
 273   Iter_2.AssociateHypo('Hypo_2')
 274   codret = Iter_2.Compute(1)
 275
 276 .. note::
 277   Téléchargement des fichiers
 278
 279   * :download:`maillage initial<files/tutorial_4.00.med.gz>`
 280   * :download:`maillage de la frontière discrète<files/tutorial_4.fr.med.gz>`
 281   * :download:`commandes python<files/tutorial_4.py>`
 282
 283
 284 Instructions spécifiques au 2D
 285 """"""""""""""""""""""""""""""
 286 .. index:: single: 2D
 287
 288 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.
 289 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.
 290 ::
 291
 292   #
 293   # Creation of the boundaries
 294   # ==========================
 295   # Creation of the discrete boundary Boun_1
 296   Boun_1 = homard.CreateBoundaryDi('Boun_1', 'MAIL_EXT', data_dir+'/tutorial_5.fr.med')
 297   #
 298   # Creation of the zones
 299   # =====================
 300   # Creation of the disk with hole enveloppe
 301   enveloppe = homard.CreateZoneDiskWithHole( 'enveloppe', 0., 0., 250., 193., 1 )
 302   # Creation of the rectangle quart_sup
 303   quart_sup = homard.CreateZoneBox2D( 'quart_sup', 0., 250., 0., 250., 1 )
 304   #
 305   # Hypothesis
 306   # ==========
 307   # Creation of the hypothesis Hypo_1
 308   Hypo_1 = homard.CreateHypothesis('Hypo_1')
 309   Hypo_1.SetAdapRefinUnRef(0, 1, 0)
 310   Hypo_1.AddZone('enveloppe', 1)
 311   # Creation of the hypothesis Hypo_2
 312   Hypo_2 = homard.CreateHypothesis('Hypo_2')
 313   Hypo_2.SetAdapRefinUnRef(0, 1, 0)
 314   Hypo_2.AddZone('quart_sup', 1)
 315   #
 316   # Case "Case_1"
 317   # =============
 318   Case_1 = homard.CreateCase('Case_1', 'COEUR_2D', data_dir+'/tutorial_5.00.med')
 319   Case_1.SetDirName(dircase)
 320   Case_1.SetConfType(3)
 321   Case_1.AddBoundaryGroup('Boun_1', '')
 322   #
 323   # Iteration "Iter_1"
 324   # ==================
 325   Iter_1 = Case_1.NextIteration('Iter_1')
 326   Iter_1.SetMeshName('COEUR_2D_01')
 327   Iter_1.SetMeshFile(dircase+'/maill.01.med')
 328   Iter_1.AssociateHypo('Hypo_1')
 329   codret = Iter_1.Compute(1)
 330   #
 331   # Iteration "Iter_2"
 332   # ==================
 333   Iter_2 = Iter_1.NextIteration('Iter_2')
 334   Iter_2.SetMeshName('COEUR_2D_02')
 335   Iter_2.SetMeshFile(dircase+'/maill.02.med')
 336   Iter_2.AssociateHypo('Hypo_2')
 337   codret = Iter_2.Compute(1)
 338
 339 .. note::
 340   Téléchargement des fichiers
 341
 342   * :download:`maillage initial<files/tutorial_5.00.med.gz>`
 343   * :download:`maillage de la frontière discrète<files/tutorial_5.fr.med.gz>`
 344   * :download:`commandes python<files/tutorial_5.py>`
 345
 346
 347 .. toctree::
 348    :maxdepth: 2