gui_create_hypothese.rst \
gui_create_iteration.rst \
gui_create_zone.rst \
+gui_homard.rst \
gui_usage.rst \
index.rst \
intro.rst \
Exemple de couplage HOMARD-Salome
Copyright EDF-R&D 1996, 2010
"""
-__revision__ = "V1.1"
+__revision__ = "V1.2"
#
# ==================================
# Repertoire a personnaliser
# Creation of the zones
# =====================
# Box "Zone_0"
-Zone_0 = homard.CreateZone('Zone_0', 2)
-Zone_0.SetBox(-0.1, 1.1, -0.1, 1.1, 0.9, 1.1)
+Zone_0 = homard.CreateZoneBox ('Zone_0', -0.1, 1.1, -0.1, 1.1, 0.9, 1.1)
#
# Sphere "Zone_1"
-Zone_1 = homard.CreateZone('Zone_1', 4)
-Zone_1.SetSphere(0., 0., 0., 1.05)
+Zone_1 = homard.CreateZoneSphere ('Zone_1', 0., 0., 0., 1.05)
#
# Box "Zone_2"
-Zone_2 = homard.CreateZone('Zone_2', 2)
-Zone_2.SetBox(-0.1, 0.51, -0.1, 0.51, -0.1, 0.51)
+Zone_2 = homard.CreateZoneBox ('Zone_2', -0.1, 0.51, -0.1, 0.51, -0.1, 0.51)
#
# Hypothesis "Hypo_0"
# ===================
Exemple de couplage HOMARD-Salome
Copyright EDF-R&D 1996, 2010
"""
-__revision__ = "V1.1"
+__revision__ = "V1.2"
#
# ==================================
# Repertoire a personnaliser
study_main = salome.myStudyManager.NewStudy("HOMARD")
homard.SetCurrentStudy(salome.myStudy)
#
-# Hypothesis "Hypo_0"
-# ===================
-Hypo_0 = homard.CreateHypothesis('Hypo_0')
-Hypo_0.SetAdapRefinUnRef(1, 1, 0)
+# Hypothesis "Hypo_0vers1"
+# ========================
+Hypo_0vers1 = homard.CreateHypothesis('Hypo_0vers1')
+Hypo_0vers1.SetAdapRefinUnRef(1, 1, 0)
# Characterization of the field
-Hypo_0.SetField('SOLU_0__QIRE_ELEM_SIGM__________')
-Hypo_0.SetUseComp(0)
-Hypo_0.AddComp('ERREST ')
-Hypo_0.SetRefinThr(3, 1.0)
-Hypo_0.SetTypeFieldInterp(2)
-Hypo_0.AddFieldInterp('SOLU_0__DEPL____________________')
-Hypo_0.AddFieldInterp('SOLU_0__ERRE_ELEM_SIGM__________')
-#
-# Hypothesis "Hypo_1"
-# ===================
-Hypo_1 = homard.CreateHypothesis('Hypo_1')
-Hypo_1.SetAdapRefinUnRef(1, 1, 1)
+Hypo_0vers1.SetField('SOLU_0__QIRE_ELEM_SIGM__________')
+Hypo_0vers1.SetUseComp(0)
+Hypo_0vers1.AddComp('ERREST ')
+Hypo_0vers1.SetRefinThr(3, 1.0)
+Hypo_0vers1.SetTypeFieldInterp(2)
+Hypo_0vers1.AddFieldInterp('SOLU_0__DEPL____________________')
+Hypo_0vers1.AddFieldInterp('SOLU_0__ERRE_ELEM_SIGM__________')
+#
+# Hypothesis "Hypo_1vers2"
+# ========================
+Hypo_1vers2 = homard.CreateHypothesis('Hypo_1vers2')
+Hypo_1vers2.SetAdapRefinUnRef(1, 1, 1)
# Characterization of the field
-Hypo_1.SetField('SOLU_1__QIRE_ELEM_SIGM__________')
-Hypo_1.SetUseComp(0)
-Hypo_1.AddComp('ERREST ')
-Hypo_1.SetRefinThr(3, 1.5)
-Hypo_1.SetUnRefThr(3, 6.)
-Hypo_1.SetTypeFieldInterp(2)
-Hypo_1.AddFieldInterp('SOLU_1__DEPL____________________')
-Hypo_1.AddFieldInterp('SOLU_1__QIRE_ELEM_SIGM__________')
-#
-# Case "Case_0"
-# =============
-Case_0 = homard.CreateCase('Case_0', 'G_0', dircase+'/tutorial_3.00.med')
-Case_0.SetDirName(dircase)
+Hypo_1vers2.SetField('SOLU_1__QIRE_ELEM_SIGM__________')
+Hypo_1vers2.SetUseComp(0)
+Hypo_1vers2.AddComp('ERREST ')
+Hypo_1vers2.SetRefinThr(3, 1.5)
+Hypo_1vers2.SetUnRefThr(3, 6.)
+Hypo_1vers2.SetTypeFieldInterp(2)
+Hypo_1vers2.AddFieldInterp('SOLU_1__DEPL____________________')
+Hypo_1vers2.AddFieldInterp('SOLU_1__QIRE_ELEM_SIGM__________')
#
-# Iteration "Iter_0"
-# ==================
-Iter_0 = homard.CreateIteration('Iter_0', Case_0.GetIter0Name())
-Iter_0.SetMeshName('H_1')
-Iter_0.SetMeshFile(dircase+'/maill.01.med')
-Iter_0.SetFieldFile(dircase+'/tutorial_3.00.med')
-Iter_0.SetTimeStepRank( 1, 1)
-homard.AssociateIterHypo('Iter_0', 'Hypo_0')
-codret = homard.Compute('Iter_0', 1)
+# Hypothesis "Hypo_1vers2_bis"
+# ============================
+Hypo_1vers2_bis = homard.CreateHypothesis('Hypo_1vers2_bis')
+Hypo_1vers2_bis.SetAdapRefinUnRef(1, 1, 1)
+# Characterization of the field
+Hypo_1vers2_bis.SetField('SOLU_1__DEPL____________________')
+Hypo_1vers2_bis.SetUseComp(1)
+Hypo_1vers2_bis.AddComp('DX')
+Hypo_1vers2_bis.AddComp('DY')
+Hypo_1vers2_bis.AddComp('DZ')
+Hypo_1vers2_bis.SetRefinThr(1, 0.0001)
+Hypo_1vers2_bis.SetUnRefThr(1, 0.000001)
+Hypo_1vers2_bis.SetTypeFieldInterp(0)
+#
+# Case "Case_1"
+# =============
+Case_1 = homard.CreateCase('Case_1', 'G_0', dircase+'/tutorial_3.00.med')
+Case_1.SetDirName(dircase)
#
# Iteration "Iter_1"
# ==================
-Iter_1 = homard.CreateIteration('Iter_1', 'Iter_0')
-Iter_1.SetMeshName('H_2')
-Iter_1.SetMeshFile(dircase+'/maill.02.med')
-Iter_1.SetFieldFile(dircase+'/tutorial_3.01.med')
-Iter_1.SetTimeStepRank(1, 1)
-homard.AssociateIterHypo('Iter_1', 'Hypo_1')
+Iter_1 = homard.CreateIteration('Iter_1', Case_1.GetIter0Name())
+Iter_1.SetMeshName('H_1')
+Iter_1.SetMeshFile(dircase+'/maill.01.med')
+Iter_1.SetFieldFile(dircase+'/tutorial_3.00.med')
+Iter_1.SetTimeStepRank( 1, 1)
+homard.AssociateIterHypo('Iter_1', 'Hypo_0vers1')
codret = homard.Compute('Iter_1', 1)
-
+#
+# Iteration "Iter_2"
+# ==================
+Iter_2 = homard.CreateIteration('Iter_2', 'Iter_1')
+Iter_2.SetMeshName('H_2')
+Iter_2.SetMeshFile(dircase+'/maill.02.med')
+Iter_2.SetFieldFile(dircase+'/tutorial_3.01.med')
+Iter_2.SetTimeStepRank(1, 1)
+homard.AssociateIterHypo('Iter_2', 'Hypo_1vers2')
+codret = homard.Compute('Iter_2', 1)
+#
+# Iteration "Iter_2_bis"
+# ======================
+Iter_2_bis = homard.CreateIteration('Iter_2_bis', 'Iter_1')
+Iter_2_bis.SetMeshName('H_2_bis')
+Iter_2_bis.SetMeshFile(dircase+'/maill.02.bis.med')
+Iter_2_bis.SetFieldFile(dircase+'/tutorial_3.01.med')
+Iter_2_bis.SetTimeStepRank(1, 1)
+homard.AssociateIterHypo('Iter_2_bis', 'Hypo_1vers2_bis')
+codret = homard.Compute('Iter_2_bis', 1)
+#
if salome.sg.hasDesktop():
salome.sg.updateObjBrowser(1)
Exemple de couplage HOMARD-Salome
Copyright EDF-R&D 1996, 2011
"""
-__revision__ = "V1.1"
+__revision__ = "V1.2"
#
# ==================================
# Repertoire a personnaliser
#
# Creation of the boundaries
# ==========================
-Boundary_1 = homard.CreateBoundary('intersection', 0)
-Boundary_1.SetMeshFile(dircase+'/tutorial_4.fr.med')
-Boundary_1.SetMeshName('PIQUAGE')
+Boundary_1 = homard.CreateBoundaryDi('intersection', 'PIQUAGE', dircase+'/tutorial_4.fr.med')
#
-Boundary_2 = homard.CreateBoundary('cyl_1_ext', 1)
-Boundary_2.SetCylinder(0.0, 25., -25., 25., 50., 75., 100.)
+Boundary_2 = homard.CreateBoundaryCylinder('cyl_1_ext', 0.0, 25., -25., 25., 50., 75., 100.)
#
-Boundary_3 = homard.CreateBoundary('cyl_2_ext', 1)
-Boundary_3.SetCylinder(17.5, -2.5, -12.5, -100., -75., -25., 50.)
+Boundary_3 = homard.CreateBoundaryCylinder('cyl_2_ext', 17.5, -2.5, -12.5, -100., -75., -25., 50.)
#
-Boundary_4 = homard.CreateBoundary('cyl_1_int', 1)
-Boundary_4.SetCylinder(0.0, 25., -25., 25., 50., 75., 75.)
+Boundary_4 = homard.CreateBoundaryCylinder('cyl_1_int', 0.0, 25., -25., 25., 50., 75., 75.)
#
-Boundary_5 = homard.CreateBoundary('cyl_2_int', 1)
-Boundary_5.SetCylinder(17.5, -2.5, -12.5, -100., -75., -25., 25.)
+Boundary_5 = homard.CreateBoundaryCylinder('cyl_2_int', 17.5, -2.5, -12.5, -100., -75., -25., 25.)
#
-# Hypothesis "Hypo"
-# ===================
+# Hypothesis
+# ==========
# Creation of the hypothesis Hypo_1
Hypo_1 = homard.CreateHypothesis('Hypo_1')
Hypo_1.SetAdapRefinUnRef(-1, 1, 0)
-Hypo_1.AddGroup('T1_INT')
+Hypo_1.AddGroup('T1_INT_I')
+Hypo_1.AddGroup('T1_INT_O')
Hypo_1.AddGroup('T2_INT')
# Creation of the hypothesis Hypo_2
Hypo_2 = homard.CreateHypothesis('Hypo_2')
Hypo_2.SetAdapRefinUnRef(-1, 1, 0)
-Hypo_2.AddGroup('T1_EXT')
+Hypo_2.AddGroup('T1_EXT_I')
+Hypo_2.AddGroup('T1_EXT_O')
Hypo_2.AddGroup('T2_EXT')
#
# Case "Case"
Le suivi d'une frontière discrète se fera en sélectionnant une frontière choisie dans la liste des frontières discrètes existantes.
-Au démarrage, la liste est vide. Il faut créer une première frontière discrète par activation du bouton 'New' :
+Au démarrage, la liste est vide. Il faut créer une première frontière discrète par activation du bouton "*Nouveau*" :
.. image:: images/create_boundary_di_1.png
:align: center
.. note::
Le fichier ne doit contenir qu'un seul maillage.
-Si des frontières discrètes ont déjà été définies pour un autre cas, on peut sélectionner l'une d'elles. On peut également créer une nouvelle frontière discrète par activation du bouton 'New', comme expliqué précédemment.
+Si des frontières discrètes ont déjà été définies pour un autre cas, on peut sélectionner l'une d'elles. On peut également créer une nouvelle frontière discrète par activation du bouton "*Nouveau*", comme expliqué précédemment.
.. image:: images/create_boundary_di_3.png
:align: center
.. image:: images/create_boundary_an_1.png
:align: center
-Il faut créer une première frontière analytique par activation du bouton 'New'. On aura le choix entre cylindre ou sphère. Une fois que la frontière sera validée, son nom figurera en en-tête d'une deuxième colonne.
+Il faut créer une première frontière analytique par activation du bouton "*Nouveau*". On aura le choix entre cylindre ou sphère. Une fois que la frontière sera validée, son nom figurera en en-tête d'une deuxième colonne.
.. image:: images/create_boundary_an_2.png
:align: center
:align: center
.. index:: single: arbre d'étude
+
L'arbre d'étude
"""""""""""""""
A l'issue de cette création de frontières, l'arbre d'études a été enrichi. On y trouve toutes les frontières créées, identifiées par leur nom, avec la possibilité de les éditer.
:align: center
+Méthodes python correspondantes
+"""""""""""""""""""""""""""""""
+Consulter : :ref:`tui_create_boundary`
+
+
La définition des frontières est décrite dans :ref:`gui_create_boundary`.
+Les options avancées
+""""""""""""""""""""
+Si la case "Options avancées" n'est pas cochée, aucune contrainte supplémentaire n'est définie.
+
+Si la case est cochée, on définira les options avancées qui portent sur la finesse maximale de maillage que l'on ne veut pas dépasser. Deux directives sont possibles, séparément ou ensemble.
+
+On peut imposer une taille de maille minimale : une maille dont le diamètre est inférieur à cette limite ne sera plus découpée. Par défaut, on propose un diamètre minimal nul, ce qui revient à ne rien imposer.
+
+On peut imposer un niveau de raffinement maximal. Par défaut, le maximum est à 99, ce qui équivaut en général à ne rien imposer.
+
+.. image:: images/create_case_6.png
+ :align: center
+
.. index:: single: arbre d'étude
L'arbre d'étude
"""""""""""""""
A l'issue de cette création de cas, l'arbre d'études a été enrichi de ce nouveau cas. On y trouve l'itération initiale, identifiée par le nom du maillage qui a été lu dans le fichier fourni.
-.. image:: images/create_case_6.png
+.. image:: images/create_case_7.png
:align: center
+
+Méthodes python correspondantes
+"""""""""""""""""""""""""""""""
+Consulter :ref:`tui_create_case`
+
Nom de l'hypothèse
""""""""""""""""""
-Un nom de l'hypothèse est proposé automatiquement : Hypo_0, Hypo_1, etc. Ce nom peut être modifié. Il ne doit pas avoir été utilisé pour une hypothèse précédente.
+Un nom de l'hypothèse est proposé automatiquement : Hypo_1, Hypo_2, etc. Ce nom peut être modifié. Il ne doit pas avoir été utilisé pour une hypothèse précédente.
Adaptation uniforme
"""""""""""""""""""
:align: center
Le champ voulu est à choisir dans la liste des champs contenus dans le fichier.
-Une fois ce champ choisi, la liste des ses composantes s'affiche. Il suffit de désigner la (ou les) composantes désirées. Si l'on choisi une seule composante, par défaut, c'est sa valeur absolue qui sera utilisée, mais il est possible d'utiliser la valeur relative. Dans le cas de plusieurs composantes, par défaut HOMARD utilisera la norme L2 (euclidienne). On peut toutefois choisir d'utiliser la norme infinie (le max des valeurs absolues des composantes).
+Une fois ce champ choisi, la liste des ses composantes s'affiche. Il suffit de désigner la (ou les) composantes désirées.
+
+Si l'on choisit une seule composante, par défaut, c'est sa valeur absolue qui sera utilisée, mais il est possible d'utiliser la valeur relative. Dans le cas de plusieurs composantes, par défaut HOMARD utilisera la norme L2 (euclidienne). On peut toutefois choisir d'utiliser la norme infinie (le max des valeurs absolues des composantes).
+
+On peut choisir de ne pas utiliser directement le champ, mais sa variation d'un élément à ses voisins. Pour cela, on activera le bouton "*Saut entre éléments*".
.. image:: images/create_hypothese_ch_2.png
:align: center
-Le raffinement se fait selon un seuil qui définit un critère haut de raffinement. Toutes les mailles pour lesqules l'indicateur est supérieur à ce critère seront raffinées.
+Le raffinement se fait selon un seuil qui définit un critère haut de raffinement. Toutes les mailles pour lesquelles l'indicateur est supérieur à ce critère seront raffinées.
Pour le choix du critère, trois variantes sont possible :
- selon un pourcentage de mailles à raffiner, nombre réel compris entre 0 et 100 ; HOMARD raffinera les x% des mailles qui ont la plus grande valeur du champ.
"""""""""""""""""""""""""
.. index:: single: zone
-Au démarrage, il faut créer une première zone par activation du bouton 'New' (voir :ref:`gui_create_zone`) :
+Au démarrage, il faut créer une première zone par activation du bouton "*Nouveau*" (voir :ref:`gui_create_zone`) :
.. image:: images/create_hypothese_zo_1.png
:align: center
-Lorsque des zones ont déjà été créées, la liste apparaît dans la fenêtre ce qui permet de sélectionner les zones voulues.
+Lorsque des zones ont déjà été créées, la liste apparaît dans la fenêtre, ce qui permet de sélectionner les zones voulues.
.. image:: images/create_hypothese_zo_2.png
:align: center
""""""""""""""""""""""""
.. index:: single: groupe
-On peut restreindre l'application de l'hypothèse d'adaptation à des groupes. On coche le bouton associé :
+On peut restreindre l'application de l'hypothèse d'adaptation à des groupes. Ainsi les mailles n'appartenant pas à ces groupes ne seront pas modidiées, sauf par contamination ultérieure du raffinement pour assurer la conformité du maillage final.
+On coche le bouton associé :
.. image:: images/create_hypothese_gr_1.png
:align: center
:align: center
+
+Méthodes python correspondantes
+"""""""""""""""""""""""""""""""
+Consulter :ref:`tui_create_hypothese`
L'itération
===========
.. index:: single: itération
+
La définition d'une itération se fait par la donnée des informations suivantes :
- L'itération précédente
.. image:: images/create_iteration_1.png
:align: center
-
Le nom de l'itération
"""""""""""""""""""""
-Un nom de cas est proposé automatiquement : Iter_0, Iter_1, etc. Ce nom peut être modifié. Il ne doit pas avoir été utilisé pour une itération précédente.
+Un nom de cas est proposé automatiquement : Iter_1, Iter_2, etc. Ce nom peut être modifié. Il ne doit pas avoir été utilisé pour une itération précédente.
L'itération précédente
""""""""""""""""""""""
L'itération précédente est choisie dans l'arbre d'étude. Le nom du maillage correspondant sera affiché.
.. index:: single: maillage;résultat
+
Le nom du maillage résultat
"""""""""""""""""""""""""""
L'itération en cours de création produira un maillage. Ce maillage sera connu sous un nom. Ce nom est fourni en le tapant dans la zone de texte. Par défaut, on propose un nom identique à celui de l'itération précédente.
.. index:: single: champ
.. index:: single: MED
+
Le champ
""""""""
Pour créer ou utiliser une hypothèse d'adaptation basée sur un champ exprimé sur le maillage, on doit fournir le fichier où se trouve le champ. C'est également le cas si on veut interpoler des champs du maillage n au maillage n+1. Ce fichier est au format MED. Classiquement, il aura été produit par le logiciel de calcul avec lequel on travaille. Le nom du fichier peut être fourni, soit en tapant le nom dans la zone de texte, soit en activant la fonction de recherche.
.. image:: images/create_iteration_2.png
:align: center
-Dasn le cas où des pas de temps ont été définis, une solution simple consiste à traiter les champs au dernier pas de temps enregistré dans le fichier. Si on veut définir un autre pas de temps, on coche le bouton "Choosen time step" ; les valeurs de 'Time Step' et de 'Rank' sont celles correspondant à la convention MED.
+Dans le cas où des pas de temps ont été définis, une solution simple consiste à traiter les champs au dernier pas de temps enregistré dans le fichier. Si on veut définir un autre pas de temps, on coche le bouton "*Pas de temps choisi*" ; les valeurs de 'Pas de temps' et de 'Numéro d'ordre' sont celles correspondant à la convention MED (time step / rank).
.. image:: images/create_iteration_3.png
:align: center
.. index:: single: hypothèse
+
L'hypothèse utilisée
""""""""""""""""""""
-L'itération en cours pilotera l'adaptation par HOMARD selon un scénario défini dans une hypothèse. Celle-ci est choisi dans la liste des hypothèses existantes.
+L'itération en cours pilotera l'adaptation par HOMARD selon un scénario défini dans une hypothèse. Celle-ci est choisie dans la liste des hypothèses existantes.
-Au démarrage, il faut créer une première hypothèse par activation du bouton 'New' (voir :ref:`gui_create_hypothese`) :
+Au démarrage, il faut créer une première hypothèse par activation du bouton "*Nouveau*" (voir :ref:`gui_create_hypothese`) :
.. image:: images/create_iteration_4.png
:align: center
-Ensuite, il faut éventuellement créer une nouvelle hypothèse par activation du bouton 'New', puis sélectionner celle voulue dans la liste proposée :
+Ensuite, si une hypothèse précédemment définie convient, il suffit de la sélectionner dans la liste proposée. Sinon, il faut créer une nouvelle hypothèse par activation du bouton "*Nouveau*", puis la sélectionner dans la liste proposée :
.. image:: images/create_iteration_5.png
:align: center
Si on envisage une adaptation selon les valeurs d'un champ sur le maillage, il faut avoir renseigné les informations sur ce champ avant de créer une nouvelle hypothèse.
.. index:: single: arbre d'étude
+
L'arbre d'étude
"""""""""""""""
-A l'issue de cette création d'itération, l'arbre d'études a été enrichi. On y trouve l'itération initiale, identifiée par le nom du maillage qui a été lu dans le fichier fourni, l'itération courante, identifiée par son nom. On trouve aussi l'hypothèse qui lui est attachée.
+A l'issue de cette création d'itération, l'arbre d'études a été enrichi. On y trouve l'itération initiale, identifiée par le nom du maillage qui a été lu dans le fichier fourni, l'itération courante, identifiée par son nom. On trouve aussi l'hypothèse qui lui est attachée. L'icône en regard de l'itération permet de différencier les itérations calculées ou non.
.. image:: images/create_iteration_6.png
:align: center
.. image:: images/create_iteration_7.png
:align: center
-
-
+Méthodes python correspondantes
+"""""""""""""""""""""""""""""""
+Consulter :ref:`tui_create_iteration`
La zone
=======
.. index:: single: zone
+.. index:: single: 2D
L'objet zone contient toutes les définitions géométriques permettant de décrire une zone à raffiner.
-Il existe deux types de zone :
+En 3D, il existe quatre types de zone :
- Parallélépipède
+ - Cylindre
+ - Tuyau
- Sphère
+Leurs analogues en 2D sont :
+
+ - Rectangle
+ - Disque
+ - Disque percé
+
+Le principe du raffinement selon des zones est le suivant. Chaque arête de maille dont les deux extrémités
+sont incluses dans une même zone sera coupée. Ensuite HOMARD applique l'algorithme de traitement de la
+conformité pour produire un maillage correct.
+
+.. note::
+ Les valeurs proposées par défaut pour les dimensions des zones tiennent compte de la géométrie du maillage.
+
Nom de la zone
""""""""""""""
Un nom de zone est proposé automatiquement : Zone_1, Zone_2, etc. Ce nom peut être modifié. Il ne doit pas avoir été déjà utilisé pour une autre zone.
""""""""""""""""""
.. index:: single: boite
-Le parallélépipède est forcément parallèle aux axes de coordonnées. Il est défini par ses extrêmes dans chaque direction.
+Le parallélépipède est obligatoirement parallèle aux axes de coordonnées. Il est défini par ses extrêmes dans chaque direction.
.. image:: images/create_zone_1.png
:align: center
+Un cylindre
+"""""""""""
+.. index:: single: cylindre
+
+Le cylindre est défini par son axe, un point de base positionné sur l'axe, sa hauteur et son rayon. L'axe est défini par un vecteur qui doit être correctement orienté : on retiendra le volume partant de la base dans la direction du vecteur jusqu'à la hauteur retenue. La norme de ce vecteur n'est pas nécessairement égale à 1.
+
+.. image:: images/create_zone_2.png
+ :align: center
+
+Un tuyau
+""""""""
+.. index:: single: tuyau
+
+Le cylindre est défini par son axe, un point de base positionné sur l'axe, sa hauteur et ses rayons interne et externe. L'axe est défini par un vecteur qui doit être correctement orienté : on retiendra le volume partant de la base dans la direction du vecteur jusqu'à la hauteur retenue. La norme de ce vecteur n'est pas nécessairement égale à 1.
+
+.. image:: images/create_zone_3.png
+ :align: center
+
Une sphère
""""""""""
.. index:: single: sphere
La sphère est définie par son centre et son rayon.
-.. image:: images/create_zone_2.png
+.. image:: images/create_zone_4.png
:align: center
-.. note::
- Les valeurs proposées par défaut tiennent compte de la géométrie du maillage.
+Un rectangle
+""""""""""""
+.. index:: single: rectangle
+
+Le rectangle est obligatoirement parallèle aux axes de coordonnées. Il est défini par ses extrêmes dans chacune des directions valides. La coordonnée constante est affichée pour information, mais n'est pas modifiable.
+
+.. image:: images/create_zone_21.png
+ :align: center
+
+Un disque
+"""""""""
+.. index:: single: disque
+
+Le disque est obligatoirement dans le plan des axes de coordonnées. Il est défini par son centre et son rayon. La coordonnée constante est affichée pour information, mais n'est pas modifiable.
+
+.. image:: images/create_zone_22.png
+ :align: center
+
+Un disque avec trou
+"""""""""""""""""""
+.. index:: single: disque avec trou
+
+Le disque avec trou est obligatoirement dans le plan des axes de coordonnées. Il est défini par son centre et ses rayons externe et interne. La coordonnée constante est affichée pour information, mais n'est pas modifiable.
+
+.. image:: images/create_zone_23.png
+ :align: center
+Méthodes python correspondantes
+"""""""""""""""""""""""""""""""
+Consulter :ref:`tui_create_zone`
--- /dev/null
+.. _gui_homard:
+
+Le calcul
+=========
+.. index:: single: itération
+.. index:: single: calcul
+
+Lancer une adaptation
+"""""""""""""""""""""
+Lancer une adaptation s'obtient en sélectionnant l'itération à calculer. Elle est repérée par une icone "en attente". On choisit ensuite "*Calculer*" dans le menu HOMARD ou à la souris.
+
+.. image:: images/lancement_1.png
+ :align: center
+
+
+.. index:: single: arbre d'étude
+
+L'arbre d'étude
+"""""""""""""""
+
+A l'issue de ce calcul, l'arbre d'études a été enrichi. L'icone devant l'itération est validée. Sous l'itération, on trouve la référence aux fichiers de résultats créés, identifiés par leur nom dans le répertoire *rep* qui a été défini à la création du cas :
+
+ - *rep*/I(n+1)/Liste.n.vers.(n+1)
+ - *rep*/I(n+1)/apad.n.vers.(n+1).bilan
+ - *rep*/maill.(n+1).med
+
+Les deux premiers fichiers sont des fichiers de texte, éditables. Liste.n.vers.(n+1) contient des informations sur le déroulement de l'adaptation : récapitulatif du mode d'adaptation, pourcentage de mailles concernées, etc. Le fichier apad.n.vers.(n+1).bilan est un résumé des caractéristiques du maillage obtenus.
+Le fichier maill.(n+1).med est celui qui contient le maillage produit au format MED. On retrouve ce maillage dans la section de l'arbre d'études du module SMESH. Il est alors visible dans ce module et utilisable ensuite comme tout autre maillage.
+
+
+.. image:: images/lancement_2.png
+ :align: center
+
+Consulter le résultat d'une adaptation
+""""""""""""""""""""""""""""""""""""""
+Les deux fichiers de texte, Liste.n.vers.(n+1) et apad.n.vers.(n+1).bilan, sont visibles en les sélectionnant. On choisit ensuite "*Afficher le fichier*" dans le menu HOMARD ou à la souris.
+
+.. image:: images/lancement_3.png
+ :align: center
+
+Méthodes python correspondantes
+"""""""""""""""""""""""""""""""
+Consulter :ref:`tui_homard`
+
#. en activant l'onglet HOMARD dans la liste des modules,
#. en cliquant sur le bouton HOMARD dans la barre d'outils.
-L'utilisateur a alors le choix entre créer une nouvelle étude ou en ouvrir une qui a été précédemment enregistrée.
+L'utilisateur a alors le choix entre créer une nouvelle étude ou en ouvrir une qui a été précédemment enregistrée, selon le principe qui a été retenu pour tous les autres modules de Salome.
+
+.. image:: images/homard_1.png
+ :align: center
Définir une adaptation
""""""""""""""""""""""
-Une fois que HOMARD a été activé, la permière action consiste à créer un cas. Il s'agit de sélectionner le maillage initial de la suite d'adaptations envisagée (voir :ref:`gui_create_case`). A partir de ce cas, on définira les itérations successives (voir :ref:`gui_create_iteration`) à partir des hypothèses (voir :ref:`gui_create_hypothese`).
-
-Récupérer le résultat d'une adaptation
-""""""""""""""""""""""""""""""""""""""
-Le résultat d'une adaptation s'obtient en sélectionnant l'itération à calculer. On sélectionne ensuite *Lancement* dans le menu HOMARD.
-
-.. image:: images/lancement_1.png
- :align: center
+Une fois que HOMARD a été activé, la permière action consiste à créer un cas. Il s'agit de sélectionner le maillage initial de la suite d'adaptations envisagée (voir :ref:`gui_create_case`). A partir de ce cas, on définira les itérations successives (voir :ref:`gui_create_iteration`) à partir des hypothèses (voir :ref:`gui_create_hypothese`). Les adaptations sont lancées tel que décrit dans :ref:`gui_homard`.
-Le fichier contenant le maillage produit est visible dans l'arbre d'études.
Mode d'emploi de la saisie des données
""""""""""""""""""""""""""""""""""""""
gui_create_iteration
gui_create_hypothese
gui_create_zone
+ gui_create_boundary
+ gui_homard
Méthodes de la classe homard
""""""""""""""""""""""""""""
+Ces méthodes retournent une instance de la classe boundary.
-+----------------------------------------------------------------+
-+================================================================+
-| .. module:: CreateBoundary |
-| |
-| **CreateBoundary(boundary_name, boundary_type)** |
-| |
-| - ``boundary_name`` : le nom de la zone |
-| - ``boundary_type`` : entier précisant le type de frontière|
-| |
-| * 1 : cylindre |
-| * 2 : sphère |
-+----------------------------------------------------------------+
++----------------------------------------------------------------------------------------+
++----------------------------------------------------------------------------------------+
+| .. module:: CreateBoundaryDi |
+| |
+| **CreateBoundaryDi(boundary_name, mesh_name, mesh_file)** |
+| |
+| - ``boundary_name`` : le nom de la frontière discrète |
+| - ``mesh_name`` : le nom du maillage de la frontière |
+| - ``mesh_file`` : le nom du fichier contenant ce maillage |
++----------------------------------------------------------------------------------------+
+| .. module:: CreateBoundaryCylinder |
+| |
+| **CreateBoundaryCylinder(boundary_name, Xcen, Ycen, Zcen, Xaxe, Yaxe, Zaxe, R)** |
+| |
+| - ``boundary_name`` : le nom de la frontière analytique basée sur un cylindre |
+| - ``Xcen``, ``Ycen``, ``Zcen`` : coordonnées d'un point sur l'axe du cylindre |
+| - ``Xaxe``, ``Yaxe``, ``Zaxe`` : vecteur de l'axe |
+| - ``R`` : rayon du cylindre |
++----------------------------------------------------------------------------------------+
+| .. module:: CreateBoundarySphere |
+| |
+| **CreateBoundarySphere(boundary_name, Xcen, Ycen, Zcen, R)** |
+| |
+| - ``boundary_name`` : le nom de la frontière analytique basée sur une sphere |
+| - ``Xcen``, ``Ycen``, ``Zcen`` : coordonnées du centre de la sphère |
+| - ``R`` : rayon de la sphère |
++----------------------------------------------------------------------------------------+
Méthodes de la classe boundary
""""""""""""""""""""""""""""""
-+---------------------------------------------------------------+
-+===============================================================+
-| .. module:: GetName |
-| |
-| **GetName()** |
-| Retourne le nom de la frontière |
-+---------------------------------------------------------------+
-| .. module:: GetBoundaryType |
-| |
-| **GetBoundaryType()** |
-| Retourne le type de la frontière |
-+---------------------------------------------------------------+
-| .. module:: SetCylinder |
-| |
-| **SetCylinder(Xcen, Ycen, Zcen, Xaxe, Yaxe, Zaxe, R)** |
-| |
-| - ``Xcen``, ``Ycen``, ``Zcen`` : coordonnées d'un point |
-| sur l'axe du cylindre |
-| - ``Xaxe``, ``Yaxe``, ``Zaxe`` : vecteur de l'axe |
-| - ``R`` : rayon du cylindre |
-+---------------------------------------------------------------+
-| .. module:: SetSphere |
-| |
-| **SetSphere(Xcen, Ycen, Zcen, R)** |
-| |
-| - ``Xcen`` : X du centre |
-| - ``Ycen`` : Y du centre |
-| - ``Zcen`` : Z du centre |
-| - ``R`` : rayon de la sphère |
-+---------------------------------------------------------------+
++-------------------------------------------------------------------+
++-------------------------------------------------------------------+
+| .. module:: GetName |
+| |
+| **GetName()** |
+| Retourne le nom de la frontière |
++-------------------------------------------------------------------+
+| .. module:: GetBoundaryType |
+| |
+| **GetBoundaryType()** |
+| Retourne le type de la frontière : |
+| |
+| * 0 : discrète |
+| * 1 : cylindre |
+| * 2 : sphère |
++-------------------------------------------------------------------+
+| .. module:: GetCoords |
+| |
+| **GetCoords()** |
+| Retourne un tableau contenant les coordonnées de la frontière |
+| dans l'ordre d'entrée dans le CreateBoundaryXXXX associé |
++-------------------------------------------------------------------+
Exemple
"""""""
-Création d'une frontière sphérique, puis d'une frontière cylindrique : ::
+Création d'une frontière discrète, d'une frontière sphérique, puis d'une frontière cylindrique : ::
- fron_1 = homard.CreateBoundary("FRON_1", 2)
- fron_1.SetSphere(12.3, 3.4, .56, 6.5)
- fron_2 = homard.CreateBoundary('CYL_1', 1)
- fron_2.SetCylinder(0.0, 25., -25., 25., 50., 75., 100.)
+ inter = homard.CreateBoundaryDi("INTERSECTION", 'PIQUAGE', dircase+'/tutorial_4.fr.med')
+ fron_1 = homard.CreateBoundarySphere("FRON_1", 12.3, 3.4, .56, 6.5)
+ fron_2 = homard.CreateBoundaryCylinder('CYL_1', 0.0, 25., -25., 25., 50., 75., 100.)
+Saisie graphique correspondante
+"""""""""""""""""""""""""""""""
+Consulter :ref:`gui_create_boundary`
| **AddBoundaryGroup(boundary, group)** |
| |
| - ``boundary`` : nom d'une frontière courbe à suivre |
+| |
| Pour une frontière discrète : |
| |
| . si toutes les lignes courbes sont suivies, le second |
| argument est une chaîne vide. |
| . si seulement certaines lignes courbes sont suivies, |
| ``group`` est le nom d'un groupe de segments à suivre. |
+| |
| Pour une frontière analytique : |
| |
| - ``group`` : nom d'un groupe de faces placées sur la |
| frontière |
+---------------------------------------------------------------+
+| .. module:: SetNivMax |
+| |
+| **SetNivMax(nivmax)** |
+| |
+| - ``nivmax`` : niveau de raffinement à ne pas dépasser |
++---------------------------------------------------------------+
+| .. module:: GetNivMax |
+| |
+| **GetNivMax()** |
+| Retourne le niveau maximal de raffinement |
++---------------------------------------------------------------+
+| .. module:: SetDiamMin |
+| |
+| **SetDiamMin(diammin)** |
+| |
+| - ``diammin`` : diamètre minimal voulu pour une maille |
++---------------------------------------------------------------+
+| .. module:: GetDiamMin |
+| |
+| **GetDiamMin()** |
+| Retourne le diamètre minimal voulu |
++---------------------------------------------------------------+
Exemple
+Saisie graphique correspondante
+"""""""""""""""""""""""""""""""
+Consulter :ref:`gui_create_case`
+
""""""""""""""""""""""""""""
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: CreateHypothesis |
| |
| **CreateHypothesis(hypo_name)** |
^^^^^^^^^^^
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: GetName |
| |
| **GetName()** |
^^^^^^^^^^^^^^^^^^^^^^
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: SetField |
| |
| **SetField(field_name)** |
| |
| - ``use_field`` : entier précisant l'usage du champ |
| |
-| 0. valeur par maille (défaut) |
-| 1. saut entre une maille et ses voisines |
+| 0. valeur par élément (défaut) |
+| 1. saut entre un élément et ses voisins |
+---------------------------------------------------------------+
| .. module:: SetRefinThr |
| |
^^^^^^^^^^^^^^^^^^^^^^^^
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: AddComp |
| |
| **AddComp(comp_name)** |
^^^^^^^^^^^^^^^^^^^^^^^^^^^
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: AddGroup |
| |
| **AddGroup(group_name)** |
hypo_1.SetRefinThr(1, 80.)
+
+Saisie graphique correspondante
+"""""""""""""""""""""""""""""""
+Consulter :ref:`gui_create_hypothese`
""""""""""""""""""""""""""""
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: CreateIteration |
| |
| **CreateIteration(iter_name, iter_parent_name)** |
^^^^^^^^^^^
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: GetName |
| |
| **GetName()** |
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: GetMeshName |
| |
| **GetMeshName()** |
^^^^^^^^^^^^^^^^^^^^^^^^^
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: SetFieldFile |
| |
| **SetFieldFile(field_file)** |
iter_1.SetMeshFile("/local00/M.02.med")
homard.AssociateIterHypo(iter_name, "HypoField")
+
+Saisie graphique correspondante
+"""""""""""""""""""""""""""""""
+Consulter :ref:`gui_create_iteration`
.. index:: single: zone
.. index:: single: boite
.. index:: single: sphere
+.. index:: single: cylindre
+.. index:: single: tuyau
+.. index:: single: disque
+.. index:: single: disque avec trou
+.. index:: single: 2D
Les variables sont décrites dans :ref:`gui_create_zone`.
Méthodes de la classe homard
""""""""""""""""""""""""""""
+Ces méthodes retournent une instance de la classe zone.
+
++----------------------------------------------------------------------------------+
++----------------------------------------------------------------------------------+
+| .. module:: CreateZoneBox |
+| |
+| **CreateZoneBox(zone_name, Xmin, Xmax, Ymin, Ymax, Zmin, Zmax)** |
+| |
+| - ``zone_name`` : le nom de la zone basée sur un parallélépipède |
+| - ``Xmin``, ``Xmax`` : coordonnées extrêmes selon X |
+| - ``Ymin``, ``Ymax`` : coordonnées extrêmes selon Y |
+| - ``Zmin``, ``Zmax`` : coordonnées extrêmes selon Z |
++----------------------------------------------------------------------------------+
+| .. module:: CreateZoneCylinder |
+| |
+| **CreateZoneCylinder(zone_name, Xbase, Ybase, Zbase, Xaxe, Yaxe, Zaxe, R, H)** |
+| |
+| - ``zone_name`` : le nom de la zone basée sur un cylindre |
+| - ``Xbase``, ``Ybase``, ``Zbase`` : coordonnées d'un point de base |
+| positionné sur l'axe |
+| - ``Xaxe``, ``Yaxe``, ``Zaxe`` : vecteur de l'axe |
+| - ``R`` : rayon du cylindre |
+| - ``H`` : hauteur du cylindre |
++----------------------------------------------------------------------------------+
+| .. module:: CreateZonePipe |
+| |
+| **CreateZonePipe(zone_name, Xbase, Ybase, Zbase, Xaxe, Yaxe, Zaxe, R, H, Rint)** |
+| |
+| - ``zone_name`` : le nom de la zone basée sur un tuyau |
+| - ``Xbase``, ``Ybase``, ``Zbase`` : coordonnées d'un point de base |
+| positionné sur l'axe |
+| - ``Xaxe``, ``Yaxe``, ``Zaxe`` : vecteur de l'axe |
+| - ``R`` : rayon externe du tuyau |
+| - ``H`` : hauteur du tuyau |
+| - ``R`` : rayon interne du tuyau |
++----------------------------------------------------------------------------------+
+| .. module:: CreateZoneSphere |
+| |
+| **CreateZoneSphere(zone_name, Xcen, Ycen, Zcen, R)** |
+| |
+| - ``zone_name`` : le nom de la zone basée sur une sphère |
+| - ``Xcen``, ``Ycen``, ``Zcen`` : coordonnées du centre de la sphère |
+| - ``R`` : rayon de la sphère |
++----------------------------------------------------------------------------------+
+| .. module:: CreateZoneBox2D |
+| |
+| **CreateZoneBox2D(zone_name, Umin, Umax, Vmin, Vmax, Orient)** |
+| |
+| - ``zone_name`` : le nom de la zone basée sur un rectangle |
+| - ``Umin``, ``Umax`` : coordonnées extrêmes pour la 1ère dimension |
+| - ``Vmin``, ``Vmax`` : coordonnées extrêmes pour la 2nde dimension |
+| - ``Orient`` : entier précisant la convention d'orientation du plan |
++----------------------------------------------------------------------------------+
+| .. module:: CreateZoneDisk |
+| |
+| **CreateZoneDisk(zone_name, Ucen, Vcen, R, Orient)** |
+| |
+| - ``zone_name`` : le nom de la zone basée sur un disque plein |
+| - ``Ucen``, ``Vcen`` : coordonnées du centre du disque |
+| - ``R`` : rayon du disque |
+| - ``Orient`` : entier précisant la convention d'orientation du plan |
++----------------------------------------------------------------------------------+
+| .. module:: CreateZoneDiskWithHole |
+| |
+| **CreateZoneDiskWithHole(zone_name, Ucen, Vcen, R, Rint, Orient)** |
+| |
+| - ``zone_name`` : le nom de la zone basée sur un disque troué |
+| - ``Ucen``, ``Vcen`` : coordonnées du centre du disque |
+| - ``R`` : rayon externe du disque |
+| - ``Rint`` : rayon interne du disque |
+| - ``Orient`` : entier précisant la convention d'orientation du plan |
++----------------------------------------------------------------------------------+
+
+
+
+---------------------------------------------------------------+
-+===============================================================+
-| .. module:: CreateZone |
-| |
-| **CreateZone(zone_name, zone_type)** |
-| |
-| - ``zone_name`` : le nom de la zone |
-| - ``zone_type`` : entier précisant le type de zone |
++---------------------------------------------------------------+
+| La convention d'orientation du plan est la même que celle |
+| utilisée dans les autres modules de Salome, en particulier |
+| GEOM : |
| |
-| * 2 : parallélépipède |
-| * 4 : sphère |
+| 1. plan XY ; U <==> X et V <==> Y |
+| 2. plan YZ ; U <==> Y et V <==> Z |
+| 3. plan ZX ; U <==> Z et V <==> X |
+---------------------------------------------------------------+
+
+.. note::
+ Les fonctions définissant des zones 2D ne doivent être utilisées que si l'intégralité du
+ maillage est 2D, dans un des plans de coordonnées.
+
+
Méthodes de la classe zone
""""""""""""""""""""""""""
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. module:: GetName |
| |
| **GetName()** |
| |
| **GetZoneType()** |
| Retourne le type de la zone |
-+---------------------------------------------------------------+
-| .. module:: SetBox |
| |
-| **SetBox(Xmin, Xmax, Ymin, Ymax, Zmin, Zmax)** |
-| |
-| - ``Xmin``, ``Xmax`` : X mini, X maxi |
-| - etc. |
+| * 2 : parallélépipède |
+| * 3 : sphère |
+| * 5 : cylindre |
+| * 7 : tuyau |
+| * 11, 12, 13 : rectangle et orientation 1, 2 ou 3 |
+| * 31, 32, 33 : disque et orientation 1, 2 ou 3 |
+| * 61, 62, 63 : disque percé et orientation 1, 2 ou 3 |
+---------------------------------------------------------------+
-| .. module:: SetSphere |
+| .. module:: GetCoords |
| |
-| **SetSphere(Xcen, Ycen, Zcen, R)** |
-| |
-| - ``Xcen`` : X du centre |
-| - ``Ycen`` : Y du centre |
-| - ``Zcen`` : Z du centre |
-| - ``R`` : rayon de la sphère |
+| **GetCoords()** |
+| Retourne un tableau contenant les coordonnées de la zone |
+| dans l'ordre d'entrée dans le CreateZoneXXXX associé |
+---------------------------------------------------------------+
Exemple
"""""""
-La création de l'objet zone_1 se fait ainsi : ::
+La création d'une boîte 3D ou d'un disque dans le plan XY se fait ainsi : ::
+
+ zone_1 = homard.CreateZoneBox ("BLOC", -1., 1., -30., 40., 10.5, 20.8)
+ zone_2 = homard.CreateZoneDisk ("disque", 1., 3., 43.25, 1)
+
+
+Saisie graphique correspondante
+"""""""""""""""""""""""""""""""
+Consulter :ref:`gui_create_zone`
- zone_1 = homard.CreateZone("Zone_2", 4)
- zone_1.SetSphere(12.3, 3.4, .56, 6.5)
.. _tui_homard:
-L'adaptation
-============
-
+Le calcul
+=========
.. index:: single: itération
.. index:: single: calcul
""""""""""""""""""""""""""""
+---------------------------------------------------------------+
-+===============================================================+
++---------------------------------------------------------------+
| .. index:: single: Compute |
| |
| **Compute(iter_name, option)** |
| |
| - ``iter_name`` : le nom de l'itération |
| - ``option`` : un entier précisant ce qui se passe quand |
-| des fichiers de résultats existent déjà |
+| des fichiers de résultats existent déjà |
+| |
| * 0 : arrêt en erreur |
| * 1 : écrasement des anciens fichiers |
| |
iter_name = "Iteration_1"
codret = homard.Compute(iter_name, 1)
+
+Saisie graphique correspondante
+"""""""""""""""""""""""""""""""
+Consulter :ref:`gui_homard`
========
.. index:: single: exemple
.. index:: single: python
+
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 à modifier le contenu de la variable ``dircase`` : c'est le répertoire dans lequel les fichiers med auront été enregistrés. C'est dans ce répertoire que seront écrits les fichiers résultant des adaptations successives.
Raffinement uniforme
# Creation of the zones
# =====================
# Box "Zone_0"
- Zone_0 = homard.CreateZone('Zone_0', 2)
- Zone_0.SetBox(-0.1, 1.1, -0.1, 1.1, 0.9, 1.1)
+ Zone_0 = homard.CreateZoneBox('Zone_0', -0.1, 1.1, -0.1, 1.1, 0.9, 1.1)
#
# Sphere "Zone_1"
- Zone_1 = homard.CreateZone('Zone_1', 4)
- Zone_1.SetSphere(0., 0., 0., 1.05)
+ Zone_1 = homard.CreateZoneSphere('Zone_1', 0., 0., 0., 1.05)
#
# Box "Zone_2"
- Zone_2 = homard.CreateZone('Zone_2', 2)
- Zone_2.SetBox(-0.1, 0.51, -0.1, 0.51, -0.1, 0.51)
+ Zone_2 = homard.CreateZoneBox('Zone_2', -0.1, 0.51, -0.1, 0.51, -0.1, 0.51)
#
# Hypothesis "Hypo_0"
# ===================
.. index:: single: champ
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.
+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.
::
dircase = "/tmp"
#
- # Hypothesis "Hypo_0"
- # ===================
- Hypo_0 = homard.CreateHypothesis('Hypo_0')
- Hypo_0.SetAdapRefinUnRef(1, 1, 0)
+ # Hypothesis "Hypo_0vers1"
+ # ========================
+ Hypo_0vers1 = homard.CreateHypothesis('Hypo_0vers1')
+ Hypo_0vers1.SetAdapRefinUnRef(1, 1, 0)
# Characterization of the field
- Hypo_0.SetField('SOLU_0__QIRE_ELEM_SIGM__________')
- Hypo_0.SetUseComp(0)
- Hypo_0.AddComp('ERREST ')
- Hypo_0.SetRefinThr(3, 1.0)
- Hypo_0.SetTypeFieldInterp(2)
- Hypo_0.AddFieldInterp('SOLU_0__DEPL____________________')
- Hypo_0.AddFieldInterp('SOLU_0__ERRE_ELEM_SIGM__________')
+ Hypo_0vers1.SetField('SOLU_0__QIRE_ELEM_SIGM__________')
+ Hypo_0vers1.SetUseComp(0)
+ Hypo_0vers1.AddComp('ERREST ')
+ Hypo_0vers1.SetRefinThr(3, 1.0)
+ Hypo_0vers1.SetTypeFieldInterp(2)
+ Hypo_0vers1.AddFieldInterp('SOLU_0__DEPL____________________')
+ Hypo_0vers1.AddFieldInterp('SOLU_0__ERRE_ELEM_SIGM__________')
#
- # Hypothesis "Hypo_1"
- # ===================
- Hypo_1 = homard.CreateHypothesis('Hypo_1')
- Hypo_1.SetAdapRefinUnRef(1, 1, 1)
+ # Hypothesis "Hypo_1vers2"
+ # ========================
+ Hypo_1vers2 = homard.CreateHypothesis('Hypo_1vers2')
+ Hypo_1vers2.SetAdapRefinUnRef(1, 1, 1)
# Characterization of the field
- Hypo_1.SetField('SOLU_1__QIRE_ELEM_SIGM__________')
- Hypo_1.SetUseComp(0)
- Hypo_1.AddComp('ERREST ')
- Hypo_1.SetRefinThr(3, 1.5)
- Hypo_1.SetUnRefThr(3, 6.)
- Hypo_1.SetTypeFieldInterp(2)
- Hypo_1.AddFieldInterp('SOLU_1__DEPL____________________')
- Hypo_1.AddFieldInterp('SOLU_1__QIRE_ELEM_SIGM__________')
+ Hypo_1vers2.SetField('SOLU_1__QIRE_ELEM_SIGM__________')
+ Hypo_1vers2.SetUseComp(0)
+ Hypo_1vers2.AddComp('ERREST ')
+ Hypo_1vers2.SetRefinThr(3, 1.5)
+ Hypo_1vers2.SetUnRefThr(3, 6.)
+ Hypo_1vers2.SetTypeFieldInterp(2)
+ Hypo_1vers2.AddFieldInterp('SOLU_1__DEPL____________________')
+ Hypo_1vers2.AddFieldInterp('SOLU_1__QIRE_ELEM_SIGM__________')
#
- # Case "Case_0"
- # =============
- Case_0 = homard.CreateCase('Case_0', 'G_0', dircase+'/tutorial_3.00.med')
- Case_0.SetDirName(dircase)
+ # Hypothesis "Hypo_1vers2_bis"
+ # ============================
+ Hypo_1vers2_bis = homard.CreateHypothesis('Hypo_1vers2_bis')
+ Hypo_1vers2_bis.SetAdapRefinUnRef(1, 1, 1)
+ # Characterization of the field
+ Hypo_1vers2_bis.SetField('SOLU_1__DEPL____________________')
+ Hypo_1vers2_bis.SetUseComp(1)
+ Hypo_1vers2_bis.AddComp('DX')
+ Hypo_1vers2_bis.AddComp('DY')
+ Hypo_1vers2_bis.AddComp('DZ')
+ Hypo_1vers2_bis.SetRefinThr(1, 0.0001)
+ Hypo_1vers2_bis.SetUnRefThr(1, 0.000001)
+ Hypo_1vers2_bis.SetTypeFieldInterp(0)
#
- # Iteration "Iter_0"
- # ==================
- Iter_0 = homard.CreateIteration('Iter_0', Case_0.GetIter0Name())
- Iter_0.SetMeshName('H_1')
- Iter_0.SetMeshFile(dircase+'/maill.01.med')
- Iter_0.SetFieldFile(dircase+'/tutorial_3.00.med')
- Iter_0.SetTimeStepRank( 1, 1)
- homard.AssociateIterHypo('Iter_0', 'Hypo_0')
- codret = homard.Compute('Iter_0', 1)
+ # Case "Case_1"
+ # =============
+ Case_1 = homard.CreateCase('Case_1', 'G_0', dircase+'/tutorial_3.00.med')
+ Case_1.SetDirName(dircase)
#
# Iteration "Iter_1"
# ==================
- Iter_1 = homard.CreateIteration('Iter_1', 'Iter_0')
- Iter_1.SetMeshName('H_2')
- Iter_1.SetMeshFile(dircase+'/maill.02.med')
- Iter_1.SetFieldFile(dircase+'/tutorial_3.01.med')
- Iter_1.SetTimeStepRank(1, 1)
- homard.AssociateIterHypo('Iter_1', 'Hypo_1')
+ Iter_1 = homard.CreateIteration('Iter_1', Case_1.GetIter0Name())
+ Iter_1.SetMeshName('H_1')
+ Iter_1.SetMeshFile(dircase+'/maill.01.med')
+ Iter_1.SetFieldFile(dircase+'/tutorial_3.00.med')
+ Iter_1.SetTimeStepRank( 1, 1)
+ homard.AssociateIterHypo('Iter_1', 'Hypo_0vers1')
codret = homard.Compute('Iter_1', 1)
+ #
+ # Iteration "Iter_2"
+ # ==================
+ Iter_2 = homard.CreateIteration('Iter_2', 'Iter_1')
+ Iter_2.SetMeshName('H_2')
+ Iter_2.SetMeshFile(dircase+'/maill.02.med')
+ Iter_2.SetFieldFile(dircase+'/tutorial_3.01.med')
+ Iter_2.SetTimeStepRank(1, 1)
+ homard.AssociateIterHypo('Iter_2', 'Hypo_1vers2')
+ codret = homard.Compute('Iter_2', 1)
+ #
+ # Iteration "Iter_2_bis"
+ # ======================
+ Iter_2_bis = homard.CreateIteration('Iter_2_bis', 'Iter_1')
+ Iter_2_bis.SetMeshName('H_2_bis')
+ Iter_2_bis.SetMeshFile(dircase+'/maill.02.bis.med')
+ Iter_2_bis.SetFieldFile(dircase+'/tutorial_3.01.med')
+ Iter_2_bis.SetTimeStepRank(1, 1)
+ homard.AssociateIterHypo('Iter_2_bis', 'Hypo_1vers2_bis')
+ codret = homard.Compute('Iter_2_bis', 1)
.. note::
Téléchargement des fichiers
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.
::
+
dircase = "/tmp"
#
# Creation of the boundaries
# ==========================
- Boundary_1 = homard.CreateBoundary('intersection', 0)
- Boundary_1.SetMeshFile(dircase+'/tutorial_4.fr.med')
- Boundary_1.SetMeshName('PIQUAGE')
+ Boundary_1 = homard.CreateBoundaryDi('intersection', 'PIQUAGE', dircase+'/tutorial_4.fr.med')
#
- Boundary_2 = homard.CreateBoundary('cyl_1_ext', 1)
- Boundary_2.SetCylinder(0.0, 25., -25., 25., 50., 75., 100.)
+ Boundary_2 = homard.CreateBoundaryCylinder('cyl_1_ext', 0.0, 25., -25., 25., 50., 75., 100.)
#
- Boundary_3 = homard.CreateBoundary('cyl_2_ext', 1)
- Boundary_3.SetCylinder(17.5, -2.5, -12.5, -100., -75., -25., 50.)
+ Boundary_3 = homard.CreateBoundaryCylinder('cyl_2_ext', 17.5, -2.5, -12.5, -100., -75., -25., 50.)
#
- Boundary_4 = homard.CreateBoundary('cyl_1_int', 1)
- Boundary_4.SetCylinder(0.0, 25., -25., 25., 50., 75., 75.)
+ Boundary_4 = homard.CreateBoundaryCylinder('cyl_1_int', 0.0, 25., -25., 25., 50., 75., 75.)
#
- Boundary_5 = homard.CreateBoundary('cyl_2_int', 1)
- Boundary_5.SetCylinder(17.5, -2.5, -12.5, -100., -75., -25., 25.)
+ Boundary_5 = homard.CreateBoundaryCylinder('cyl_2_int', 17.5, -2.5, -12.5, -100., -75., -25., 25.)
#
# Hypothesis "Hypo"
# ===================
# Creation of the hypothesis Hypo_1
Hypo_1 = homard.CreateHypothesis('Hypo_1')
Hypo_1.SetAdapRefinUnRef(-1, 1, 0)
- Hypo_1.AddGroup('T1_INT')
+ Hypo_1.AddGroup('T1_INT_I')
+ Hypo_1.AddGroup('T1_INT_O')
Hypo_1.AddGroup('T2_INT')
# Creation of the hypothesis Hypo_2
Hypo_2 = homard.CreateHypothesis('Hypo_2')
Hypo_2.SetAdapRefinUnRef(-1, 1, 0)
- Hypo_2.AddGroup('T1_EXT')
+ Hypo_2.AddGroup('T1_EXT_I')
+ Hypo_2.AddGroup('T1_EXT_O')
Hypo_2.AddGroup('T2_EXT')
#
# Case "Case"
Case = homard.CreateCase('Case', 'PIQUAGE', dircase+'/tutorial_4.00.med')
Case.SetDirName(dircase)
Case.AddBoundaryGroup( 'intersection', '' )
- Case.AddBoundaryGroup( 'cyl_1_ext', 'T1_EXT' )
+ Case.AddBoundaryGroup( 'cyl_1_ext', 'T1_EXT_I' )
+ Case.AddBoundaryGroup( 'cyl_1_ext', 'T1_EXT_O' )
Case.AddBoundaryGroup( 'cyl_2_ext', 'T2_EXT' )
- Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT' )
+ Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT_I' )
+ Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT_O' )
Case.AddBoundaryGroup( 'cyl_2_int', 'T2_INT' )
#
# Creation of the iterations
* :download:`commandes python<files/tutorial_4.py>`
+Instructions spécifiques au 2D
+""""""""""""""""""""""""""""""
+.. index:: single: 2D
+
+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.
+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.
+::
+
+ dircase = "/tmp"
+ #
+ # Creation of the boundaries
+ # ==========================
+ # Creation of the discrete boundary Boun_1
+ Boun_1 = homard.CreateBoundaryDi('Boun_1', 'MAIL_EXT', dircase+'/tutorial_5.fr.med')
+ #
+ # Creation of the zones
+ # =====================
+ # Creation of the disk with hole enveloppe
+ enveloppe = homard.CreateZoneDiskWithHole( 'enveloppe', 0., 0., 250., 193., 1 )
+ # Creation of the rectangle quart_sup
+ quart_sup = homard.CreateZoneBox2D( 'quart_sup', 0., 250., 0., 250., 1 )
+ #
+ # Hypothesis
+ # ==========
+ # Creation of the hypothesis Hypo_1
+ Hypo_1 = homard.CreateHypothesis('Hypo_1')
+ Hypo_1.SetAdapRefinUnRef(0, 1, 0)
+ homard.AssociateHypoZone('enveloppe', 'Hypo_1')
+ # Creation of the hypothesis Hypo_2
+ Hypo_2 = homard.CreateHypothesis('Hypo_2')
+ Hypo_2.SetAdapRefinUnRef(0, 1, 0)
+ homard.AssociateHypoZone('quart_sup', 'Hypo_2')
+ #
+ # Case "Case_1"
+ # =============
+ Case_1 = homard.CreateCase('Case_1', 'COEUR_2D', dircase+'/tutorial_5.00.med')
+ Case_1.SetDirName(dircase)
+ Case_1.SetConfType(3)
+ Case_1.AddBoundaryGroup('Boun_1', '')
+ #
+ # Iteration "Iter_1"
+ # ==================
+ Iter_1 = homard.CreateIteration('Iter_1', Case_1.GetIter0Name())
+ Iter_1.SetMeshName('COEUR_2D_01')
+ Iter_1.SetMeshFile(dircase+'/maill.01.med')
+ homard.AssociateIterHypo('Iter_1', 'Hypo_1')
+ codret = homard.Compute('Iter_1', 1)
+ #
+ # Iteration "Iter_2"
+ # ==================
+ Iter_2 = homard.CreateIteration('Iter_2', 'Iter_1')
+ Iter_2.SetMeshName('COEUR_2D_02')
+ Iter_2.SetMeshFile(dircase+'/maill.02.med')
+ homard.AssociateIterHypo('Iter_2', 'Hypo_2')
+ result = homard.Compute('Iter_2', 1)
+
+.. note::
+ Téléchargement des fichiers
+
+ * :download:`maillage initial<files/tutorial_5.00.med.gz>`
+ * :download:`maillage de la frontière discrète<files/tutorial_5.fr.med.gz>`
+ * :download:`commandes python<files/tutorial_5.py>`
+
+
.. toctree::
:maxdepth: 2
