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