if SPHINX_IS_OK
-homarddoc_DATA=html/index.html
+homarddoc_DATA=html/index.html html/index_en.html
html/index.html:$(RSTFILES)
make htm
make latex
+html/index_en.html:$(RSTFILES_EN)
+ make htm
+ make latex
endif
@echo "Go into latex and apply twice : pdflatex HOMARD.tex to produce HOMARD.pdf"
RSTFILES= \
+index.rst \
glossaire.rst \
gui_create_boundary.rst \
gui_create_case.rst \
gui_homard.rst \
gui_usage.rst \
gui_mesh_info.rst \
-index.rst \
intro.rst \
tui_create_boundary.rst \
tui_create_case.rst \
tui_usage.rst \
tutorials.rst
+RSTFILES_EN= \
+index_en.rst \
+glossaire_en.rst \
+gui_create_boundary_en.rst \
+gui_create_case_en.rst \
+gui_create_hypothese_en.rst \
+gui_create_iteration_en.rst \
+gui_create_zone_en.rst \
+gui_homard_en.rst \
+gui_usage_en.rst \
+gui_mesh_info_en.rst \
+intro_en.rst \
+tui_create_boundary_en.rst \
+tui_create_case_en.rst \
+tui_create_hypothese_en.rst \
+tui_create_iteration_en.rst \
+tui_create_zone_en.rst \
+tui_homard_en.rst \
+tui_usage_en.rst \
+tutorials_en.rst
+
EXTRA_DIST+= $(RSTFILES) images files
-usr_docs:
+usr_docs:
make install-data-local
docs: usr_docs
--- /dev/null
+.. _glossaire_en:
+
+Glossary
+========
+
+.. glossary::
+ :sorted:
+
+ raffinement
+ Le raffinement est une opération consistant à découper les mailles sélectionnées.
+
+ niveau
+ Le niveau d'une maille est le nombre de découpages qu'il a fallu pour l'obtenir. Les mailles du maillage initial sont du niveau 0 par convention.
+
+ déraffinement
+ Le déraffinement est une opération consistant à supprimer des mailles. Il s'agit en fait d'annuler un précédent découpage : on ne reviendra jamais 'plus haut' que le maillage initial.
+
+ zone
+ Une zone est une région qui définit un pilotage de raffinement : toutes les mailles dont au moins une arête est dans une zone seront raffinées.
+
+ cas
+ Un cas est défini par un maillage initial et une succession d'adaptations.
+
+ itération
+ Une itération est le processus qui permet de passer d'un maillage à un autre au sein d'un cas. Une itération met en oeuvre du raffinement et/ou du déraffinement selon l'hypothèse qui lui est attachée.
+
+ hypothèse
+ Une hypothèse décrit les conditions de passage d'un maillage à un autre : raffinement et/ou déraffinement, mode de pilotage, etc. Une hypothèse est référencée par une ou plusieurs itérations.
+
+ champ
+ Un champ est exprimé sur un maillage, par noeud ou par maille, avec une ou plusieurs composantes. La valeur de ce champ pilote l'adaptation.
+
+ MED
+ C'est le format d'échange des maillages et des champs pour Salome.
.. index:: single: arbre d'étude
-Ue cône
+Un cône
"""""""
.. index:: single: cone
--- /dev/null
+.. _gui_create_boundary_en:
+
+The boundary
+============
+.. index:: single: boundary
+.. index:: single: frontière
+
+L'objet frontière contient toutes les définitions géométriques permettant de décrire une frontière courbe à suivre.
+
+Il existe deux modes de description d'une frontière :
+
+ - Discrète : ce mode est utilisé pour décrire une courbe 1D
+ - Analytique : ce mode est utilisé pour décrire une surface
+
+
+Discrete boundary
+=================
+
+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 "*Nouveau*" :
+
+.. image:: images/create_boundary_di_1.png
+ :align: center
+
+La fenêtre proposée invite au choix d'un fichier de maillage. Ce maillage est celui de toutes les lignes constituant la frontière. Un nom de frontière est proposé automatiquement : Boun_1, Boun_2, etc. Ce nom peut être modifié. Il ne doit pas avoir déjà été utilisé pour une autre frontière.
+
+.. image:: images/create_boundary_di_2.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 "*Nouveau*", comme expliqué précédemment.
+
+.. image:: images/create_boundary_di_3.png
+ :align: center
+
+
+
+Analytical boundary
+===================
+Au démarrage, Salome affiche un tableau avec un seule colonne. Cette colonne contient la liste de tous les groupes du maillage initial définissant le cas.
+
+.. image:: images/create_boundary_an_1.png
+ :align: center
+
+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
+
+Il faut maintenant établir le lien entre le maillage définissant le cas et cette frontière décrite analytiquement. Cela se fait en cochant les groupes des faces qui doivent se trouver sur la frontière.
+
+.. image:: images/create_boundary_an_3.png
+ :align: center
+
+Cette opération est répétée autant de fois que l'on souhaite placer des faces du maillages sur une surface courbe :
+
+.. image:: images/create_boundary_an_4.png
+ :align: center
+
+.. note::
+
+ Un groupe peut très bien ne jamais être coché : cela signifie que les mailles qu'il définit n'appartiennent à aucune des frontières décrites.
+
+ Un groupe ne peut être coché qu'une seule fois. En effet, des mailles surfaciques ne peuvent pas appartenir à plus d'une surface.
+
+ Plusieurs groupes peuvent être cochés pour une même frontière. Cela arrive quand le maillage initial de la zone a été subdivisé en plusieurs groupes : toutes les mailles surfaciques appartiennent à cette surface mais ont été réparties en plusieurs groupes.
+
+ Inversement, une frontière peut très bien n'être retenue par aucun groupe. Cela arrive si elle a été définie pour un cas précédent et qu'elle est sans objet pour le cas en cours de définition.
+
+
+Il existe trois types de frontière analytique :
+
+ - Cylindre
+ - Sphère
+ - Cône, décrit par un axe et un angle ou par deux rayons
+
+.. note::
+ Les valeurs numériques proposées par défaut tiennent compte de la géométrie du maillage.
+
+
+Cylindre
+""""""""
+.. index:: single: cylindre
+
+Le cylindre est défini par un point de l'axe, son axe et son rayon. L'axe est défini par un vecteur. La norme de ce vecteur n'est pas nécessairement égale à 1 ; de même, son orientation n'a aucune importance. Un nom de frontière est proposé automatiquement : Boun_1, Boun_2, etc. Ce nom peut être modifié. Il ne doit pas avoir déjà été utilisé pour une autre frontière.
+
+.. image:: images/create_boundary_an_cy.png
+ :align: center
+
+Sphere
+""""""
+.. index:: single: sphere
+
+La sphère est définie par son centre et son rayon. Un nom de frontière est proposé automatiquement : Boun_1, Boun_2, etc. Ce nom peut être modifié. Il ne doit pas avoir déjà été utilisé pour une autre frontière.
+
+.. image:: images/create_boundary_an_sp.png
+ :align: center
+
+Cone
+""""
+.. index:: single: cone
+
+Un cône est défini de deux manières différentes : le centre, l'axe et l'angle d'ouverture en degré ou par deux points centrés sur l'axe et le rayon associé. Un nom de frontière est proposé automatiquement : Boun_1, Boun_2, etc. Ce nom peut être modifié. Il ne doit pas avoir déjà été utilisé pour une autre frontière.
+
+Création par une origine, un axe et un angle d'ouverture :
+
+.. image:: images/create_boundary_an_co_1.png
+ :align: center
+
+Création par deux points centrés sur l'axe et le rayon associé :
+
+.. image:: images/create_boundary_an_co_2.png
+ :align: center
+
+.. index:: single: object browser
+
+Object browser
+""""""""""""""
+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.
+
+.. image:: images/create_boundary_1.png
+ :align: center
+
+Corresponding python functions
+""""""""""""""""""""""""""""""
+Look :ref:`tui_create_boundary_en`
+
+
+
--- /dev/null
+.. _gui_create_case_en:
+
+The creation of a case
+======================
+.. index:: single: case
+
+La définition du cas se fait par la donnée des informations suivantes :
+
+ - Un nom
+ - Un répertoire
+ - Le fichier du maillage initial
+ - Le type de conformité pour la série d'adaptations envisagées
+ - Les éventuelles frontières courbes à respecter
+
+.. image:: images/create_case_1.png
+ :align: center
+
+
+Name of the case
+""""""""""""""""
+Un nom de cas est proposé automatiquement : Case_1, Case_2, etc. Ce nom peut être modifié. Il ne doit pas avoir déjà été utilisé pour un autre cas.
+
+The directory
+"""""""""""""
+Le répertoire est celui qui contiendra les fichiers produits par les adaptations successives. Par défaut, rien n'est proposé. Le choix est fait, soit en tapant le nom dans la zone de texte, soit en activant la fonction de recherche. C'est dans ce répertoire que seront exportés les maillages au format MED, dans des fichiers de nom ``maill.xx.med``, où ``xx`` est un numéro d'ordre créé automatiquement. Ces fichiers seront visibles dans l'arbre d'études.
+
+.. image:: images/create_case_2.png
+ :align: center
+
+.. index:: single: mesh;initial
+.. index:: single: MED
+
+The initial mesh
+""""""""""""""""
+Le maillage initial doit se trouver dans un fichier au format MED. Classiquement, il aura été produit par le logiciel de calcul avec lequel on travaille. Mais il peut également avoir été créé avec le module SMESH et exporté au format MED. 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_case_3.png
+ :align: center
+
+.. note::
+ Le fichier ne doit contenir qu'un seul maillage.
+
+.. warning::
+ Le maillage ne doit pas être lui-même le produit d'une adaptation de maillage par HOMARD, sous peine de perdre la cohérence entre les différents niveaux de raffinement/déraffinement
+
+.. index:: single: conformity
+
+Type of conformity
+""""""""""""""""""
+Les itérations qui seront calculées pour ce cas devront toutes respecter le même comportement vis-à-vis de la conformité.
+
+L'option par défaut, 'conforme', implique que les maillages produits par HOMARD seront conformes au sens des éléments finis. C'est le choix classique de la plupart des logiciels de simulation par éléments finis.
+
+Néanmoins, si le calcul est possible avec des maillages non conformes, on a le choix entre 3 possibilités :
+
+.. image:: images/create_case_4.png
+ :align: center
+
+* 1 noeud par maille : une maille ne peut posséder qu'un seul noeud de non conformité avec ses voisines.
+* 1 noeud par arête : chaque arête d'une maille peut être découpée sans que la maille voisine par cette arête ne le soit.
+* quelconque : aucune limitation sur les raccords de conformité d'une maille à l'autre.
+
+.. index:: single: boundary
+
+The boundaries
+""""""""""""""
+Quand le bord du domaine est courbe, HOMARD sait placer les nouveaux noeuds sur ces frontières pour éviter des singularités artificielles. Cette technique est aussi applicable à une courbure intérieure à un domaine.
+
+Deux cas de figure sont présents :
+
+* courbe 1D : cette courbe peut être définie dans un plan, par exemple pour un calcul 2D. Elle peut également être définie dans l'espace 3D, par exemple pour l'intersection de deux surfaces. Une ligne à suivre est décrite de manière discrète.
+* surface : une surface à suivre est décrite de manière analytique.
+
+On cochera le ou les boutons voulus :
+
+.. image:: images/create_case_5.png
+ :align: center
+
+La définition des frontières est décrite dans :ref:`gui_create_boundary_en`.
+
+.. index:: single: pyramid
+
+Advanced options
+""""""""""""""""
+Par défaut, aucune option avancée n'est active.
+
+Néanmoins, on peut définir une oprion avancée :
+
+.. image:: images/create_case_7.png
+ :align: center
+
+Par défaut, HOMARD sait traiter des maillages en 2 ou 3 dimensions et comportant les mailles suivantes :
+ - mailles-points
+ - segments
+ - triangles
+ - quadrangles
+ - tétraèdres
+ - hexaèdres
+ - prismes
+
+Si le maillage initial comporte des pyramides, il y a arrêt en erreur. Toutefois, si on est certain que les raffinements ultérieurs ne toucheront aucune des arêtes des pyramides, on cochera la case "Pyramides autorisées". Les adaptations se dérouleront normalement et les pyramides seront restituées telles quelles dans le maillage final.
+
+
+The pursuit of a case
+=====================
+.. index:: single: pursuit
+.. index:: single: yacs
+
+La poursuite d'un cas correspond à la situation suivante :
+Une série d'adaptations ont été conduites sur un cas puis Salome est fermé. On a gardé les répertoires de travail de ces itérations. On souhaite ensuite reprendre ces itérations pour les poursuivre là où on s'est arrêté. Cette fonctionnalité est particulièrement utile dans le cas de schémas YACS pour lesquels on scinde en plusieurs parties une longue série d'adaptations.
+
+La condition pour reprendre une itération est d'avoir conservé dans un même répertoire deux fichiers :
+ - le fichier de configuration qui a servi de données au module exécutable de HOMARD ; ce fichier se présente sous la forme ``HOMARD.Configuration.(n).vers.(n+1)``
+ - le fichier au format MED qui conserve l'historique des adaptations réalisées ; ce fichier se présente sous la forme ``maill.(n).hom.med``
+
+On peut choisir de partir d'une itération archivée désignée explicitement par son répertoire ou d'une itération repérée dans le répertoire archivant un cas.
+
+Pour poursuivre une itération connue par son répertoire d'archive, la définition du cas se fait par la donnée des informations suivantes :
+
+ - Un nom
+ - Un répertoire
+ - Le répertoire qui contient les archives
+
+.. image:: images/pursue_case_1.png
+ :align: center
+
+On peut choisir de partir d'un cas déjà calculé ; par défaut, le nouveau cas sera créé en partant de la dernière itération précédemment calculée.
+
+.. image:: images/pursue_case_2.png
+ :align: center
+
+Si on souhaite partir d'une itération qui ne soit pas la dernière, il suffit de le préciser :
+
+.. image:: images/pursue_case_3.png
+ :align: center
+
+.. note::
+ Les paramétrages du cas ainsi créé sont ceux de l'itération poursuivie : mode de conformité identique par exemple.
+
+
+Object browser
+""""""""""""""
+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
+ :align: center
+
+
+
+Corresponding python functions
+""""""""""""""""""""""""""""""
+Look :ref:`tui_create_case_en`
+
--- /dev/null
+.. _gui_create_hypothese_en:
+
+The hypothesis
+==============
+.. index:: single: hypothesis
+
+L'hypothesis contient toutes les paramètres de pilotage d'une adaptation d'un maillage. Cette opération permet de réaliser l'itération à laquelle elle est attachée.
+
+Il existe trois classes d'hypotheses :
+
+ - Uniforme sur tout le maillage,
+ - Selon un champ,
+ - En fonction de zone géométrique.
+
+.. image:: images/create_hypothese_1.png
+ :align: center
+
+
+Name of the hypothesis
+""""""""""""""""""""""
+Un nom de l'hypothesis est proposé automatiquement : Hypo_1, Hypo_2, etc. Ce nom peut être modifié. Il ne doit pas asee été utilisé pour une hypothesis précédente.
+
+Uniform adaptation
+""""""""""""""""""
+Par défaut on propose un raffinement uniforme. Quand on part d'un maillage qui a déjà été raffiné, l'option de déraffinement supprimera les mailles produites.
+
+Adaptation by a field
+"""""""""""""""""""""
+
+.. note::
+ Pour pousee adapter le maillage selon un champ il faut asee au préalable désigné le fichier med contenant le champ. Cela se fait dans la fenêtre de construction de l'itération (see :ref:`gui_create_iteration_en`). Le nom du fichier qui a été sélectionné est affiché sans modification possible ici :
+
+.. image:: images/create_hypothese_ch_1.png
+ :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 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 lesquelles l'indicateur est supérieur à ce critère seront raffinées.
+Pour le choix du critère, quatre 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.
+ - selon une valeur relative du champ, nombre compris entre 0 et 100 ; HOMARD raffinera les mailles où le champ est supérieur à x% de l'intervalle [mini,maxi].
+ - au dela d'une valeur absolue ; toutes les mailles avec une valeur de champ supérieure à cette valeur seront raffinées.
+ - au dela d'une valeur absolue valant la moyenne de la répartition du champ augmentée de n fois son écart-type ; toutes les mailles avec une valeur de champ supérieure à cette valeur seront raffinées.
+
+La même convention s'applique au déraffinement, en remplaçant supérieur par inférieur. On peut inactiver une des fonctions (raffinement ou déraffinement) en cochant le bouton ad_hoc.
+
+.. image:: images/create_hypothese_ch_3.png
+ :align: center
+
+
+Adaptation by a zone
+""""""""""""""""""""
+.. index:: single: zone
+
+Au démarrage, il faut créer une première zone par activation du bouton "*Nouveau*" (see :ref:`gui_create_zone_en`) :
+
+.. 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. On doit alors préciser si une zone est utilisée pour raffiner toutes les mailles dont une arête est contenue dans la zone, ou si la zone est utilisée pour déraffiner les mailles intérieures à la zone. Si aucun choix n'est fait, la zone est ignorée dans cette hypothesis.
+
+.. image:: images/create_hypothese_zo_2.png
+ :align: center
+
+
+Filtering by the groups
+"""""""""""""""""""""""
+.. index:: single: group
+
+On peut restreindre l'application de l'hypothesis 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
+
+La liste des groupes de mailles présents dans le maillage est affichée. Il suffit de cocher ceux voulus pour restreindre l'hypothesis d'adaptation.
+
+.. image:: images/create_hypothese_gr_2.png
+ :align: center
+
+
+Interpolation of fields
+"""""""""""""""""""""""
+.. index:: single: interpolation
+
+.. note::
+ Pour pousee interpoler un champ de l'ancien vers le nouveau maillage, il faut asee au préalable désigné le fichier med contenant le champ. Cela se fait dans la fenêtre de construction de l'itération (see :ref:`gui_create_iteration_en`).
+
+Par défaut, aucun champ n'est interpolé. A contrario, on peut demander l'interpolation de tous les champs présents dans le fichier fourni :
+
+.. image:: images/create_hypothese_ch_4.png
+ :align: center
+
+Si on veut choisir les champs à interpoler, il faut les cocher dans la liste de tous les champs présents dans le fichier fourni :
+
+.. image:: images/create_hypothese_ch_5.png
+ :align: center
+
+
+Advanced options
+""""""""""""""""
+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.
+
+Une première série d'options 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.
+
+La deuxième série d'options n'a d'intérêt que dans le cas où l'adaptation est piloté par un champ et que ce champ n'est pas défini partout dans le maillage. Cela arrive par exemple quand on construit un champ basé sur une distance dans un plan alors que le domaine est 3D : le champ ne sera pas défini sur les noeuds hors du plan. Pour de tels champs, cette option permet de préciser le comportement que l'on souhaite dans les régions où le champ n'est pas défini. Par défaut, il ne se passe rien : les mailles sont gardées telles quelles. On peut choisir les deux autres variantes : raffiner, toutes les mailles seront a priori coupées, ou déraffiner, toutes les mailles seront candidates au déraffinement.
+
+Le dernier choix porte sur une sortie supplémentaire de l'adaptation. Si la case est cochée, le fichier MED en sortie contiendra un champ contenant le niveau de raffinement de chaque maille. La convention est celle de HOMARD : une maille du maillage initial est de niveau 0, une maille issue d'un raffinement d'une maille initiale porte le niveau 1, etc. Les mailles de transition qui sont produites entre deux mailles de niveau différents, n et n+1, sont affectées du demi-niveau n+0,5. Par défaut, la case n'est pas cochée et le champ n'est pas produit.
+
+.. image:: images/create_hypothese_av_1.png
+ :align: center
+
+Object browser
+""""""""""""""
+.. index:: single: object browser
+
+L'arbre d'études contient les hypotheses créées et les itérations qui les utilisent. La description des zones qui leur sont éventuellement attachées est présente.
+
+.. image:: images/create_hypothese_2.png
+ :align: center
+
+
+
+Corresponding python functions
+""""""""""""""""""""""""""""""
+Look :ref:`tui_create_hypothese_en`
--- /dev/null
+.. _gui_create_iteration_en:
+
+The iteration
+=============
+.. index:: single: iteration
+
+La définition d'une iteration se fait par la donnée des informations suivantes :
+
+ - L'iteration précédente
+ - Le nom du maillage résultat
+ - L'hypothesis utilisée
+ - Eventuellement, le fichier du champ d'indicateurs d'erreur
+
+.. image:: images/create_iteration_1.png
+ :align: center
+
+Name of the iteration
+"""""""""""""""""""""
+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 iteration précédente.
+
+The previous iteration
+""""""""""""""""""""""
+L'iteration précédente est choisie dans l'arbre d'étude. Le nom du maillage correspondant sera affiché.
+
+.. index:: single: mesh;result
+
+The name of the resulting mesh
+""""""""""""""""""""""""""""""
+L'iteration 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'iteration précédente.
+
+.. index:: single: field
+.. index:: single: MED
+
+The field
+"""""""""
+Pour créer ou utiliser une hypothesis 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
+
+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). Ces valeurs dépendent de la logique qui a été retenue par le logiciel qui a écrit le fichier. Souvent ces deux valeurs sont identiques mais il arrive que l'on disjoigne les pas de temps et les intervalles d'archivage.
+
+.. image:: images/create_iteration_3.png
+ :align: center
+
+.. index:: single: hypothesis
+
+The hypothesis
+""""""""""""""
+L'iteration en cours pilotera l'adaptation par HOMARD selon un scénario défini dans une hypothesis. Celle-ci est choisie dans la liste des hypothesiss existantes.
+
+Au démarrage, il faut créer une première hypothesis par activation du bouton "*Nouveau*" (voir :ref:`gui_create_hypothese_en`) :
+
+.. image:: images/create_iteration_4.png
+ :align: center
+
+Ensuite, si une hypothesis précédemment définie convient, il suffit de la sélectionner dans la liste proposée. Sinon, il faut créer une nouvelle hypothesis par activation du bouton "*Nouveau*", puis la sélectionner dans la liste proposée :
+
+.. image:: images/create_iteration_5.png
+ :align: center
+
+
+.. note::
+ 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 hypothesis.
+
+.. index:: single: object browser
+
+Object browser
+""""""""""""""
+A l'issue de cette création d'iteration, l'arbre d'études a été enrichi. On y trouve l'iteration initiale, identifiée par le nom du maillage qui a été lu dans le fichier fourni, l'iteration courante, identifiée par son nom. On trouve aussi l'hypothesis qui lui est attachée. L'icône en regard de l'iteration permet de différencier les iterations calculées ou non.
+
+.. image:: images/create_iteration_6.png
+ :align: center
+
+Quand plusieurs iterations s'enchaînent, leur hypothesis est visible dans l'arbre d'étude. On remarquera dans la figure ci-après que deux iterations peuvent partager la même hypothesis.
+
+.. image:: images/create_iteration_7.png
+ :align: center
+
+Corresponding python functions
+""""""""""""""""""""""""""""""
+Look :ref:`tui_create_iteration_en`
--- /dev/null
+.. _gui_create_zone_en:
+
+The 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.
+
+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.
+
+Name of the 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.
+
+Box
+"""
+.. index:: single: box
+
+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
+
+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
+
+Pipe
+""""
+.. index:: single: pipe
+
+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
+
+Sphere
+""""""
+.. index:: single: sphere
+
+La sphère est définie par son centre et son rayon.
+
+.. image:: images/create_zone_4.png
+ :align: center
+
+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
+
+Disk
+""""
+.. index:: single: disk
+
+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
+
+Disk with a hole
+""""""""""""""""
+.. index:: single: disk with a hole
+
+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
+
+
+
+Corresponding python functions
+""""""""""""""""""""""""""""""
+Look :ref:`tui_create_zone_en`
--- /dev/null
+.. _gui_homard_en:
+
+The computation
+===============
+.. index:: single: iteration
+.. index:: single: computation
+
+To cumpute an iteration
+"""""""""""""""""""""""
+Lancer une adaptation s'obtient en sélectionnant l'iteration à 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: object browser
+
+Object browser
+""""""""""""""
+
+A l'issue de ce calcul, l'arbre d'études a été enrichi. L'icone devant l'iteration est validée. Sous l'iteration, 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).log
+ - *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).log 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 obtenu.
+
+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
+
+To consult the result of an adaptation
+""""""""""""""""""""""""""""""""""""""
+Les deux fichiers de texte, Liste.n.vers.(n+1).log 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
+
+
+.. note::
+ Par défaut, le calcul est lancé avec l'exécutable de HOMARD installé avec Salome. Si on souhaite utiliser une version privée de HOMARD, pour tester une évolution par exemple, il faut préciser où le nouvel exécutable est disponible. Pour cela, il faut renseigner deux variables d'environnement.
+ "*HOMARD_REP_EXE_PRIVATE*" définit le répertoire dans lequel se trouve l'exécutable voulu.
+ "*HOMARD_EXE_PRIVATE*" définit le nom de l'exécutable dans ce répertoire, si ce nom est différent de "*homard*".
+
+Corresponding python functions
+""""""""""""""""""""""""""""""
+Look :ref:`tui_create_iteration_en`
+
--- /dev/null
+.. _gui_mesh_info_en:
+
+Mesh analysis
+=============
+.. index:: single: analysis
+.. index:: single: information
+
+La demande d'analysis d'un maillage se fait par la donnée des informations suivantes :
+
+ - Un répertoire
+ - Le fichier du maillage
+
+Si le maillage fait partie d'un cas enregistré, son analysis est faite à partir de son itération dans l'arbre d'études. Voir plus loin.
+
+
+Importation of the mesh
+"""""""""""""""""""""""
+La sélection de la fonction d'analysis est faite par le menu de la barre supérieure de la fenêtre :
+
+.. image:: images/mesh_info_1.png
+ :align: center
+
+La fenêtre de choix s'affiche.
+
+.. image:: images/mesh_info_2.png
+ :align: center
+
+Name of the case
+----------------
+Un nom de cas est proposé automatiquement : Case_1, Case_2, etc. Ce nom peut être modifié. Il ne doit pas avoir déjà été utilisé pour un autre cas.
+
+The directory
+-------------
+Le répertoire est celui qui contiendra les fichiers produits par l'information. Par défaut, rien n'est proposé. Le choix est fait, soit en tapant le nom dans la zone de texte, soit en activant la fonction de recherche. C'est dans ce répertoire que seront exportés les fichiers d'information de nom ``Liste.log`` et ``info_av.00.bilan``. Ces fichiers seront visibles dans l'arbre d'études.
+
+.. image:: images/create_case_2.png
+ :align: center
+
+.. index:: single: mesh;initial
+.. index:: single: MED
+
+Mesh to be analysed
+-------------------
+Le maillage à analysisr doit se trouver dans un fichier au format MED. 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_case_3.png
+ :align: center
+
+.. note::
+ Le fichier ne doit contenir qu'un seul maillage.
+
+.. warning::
+ Le maillage ne doit pas être lui-même le produit d'une adaptation de maillage par HOMARD, sous peine de perdre l'analysis des différents niveaux de raffinement/déraffinement
+
+Options for the analysis
+------------------------
+L'analysis est faite selon les options cochées.
+ - qualité des mailles
+ - diamètre des mailles
+ - connexité du domaine ; en un seul morceau, combien de trous, etc.
+ - tailles des constituants du domaine, groupe par groupe
+ - interpénétration des mailles, par dimension
+
+Le résultat de l'analysis est contenu dans le fichier ``info_av.00.bilan`` ; ce fichier est à consulter en l'affichant après sa désignation avec "*Afficher le fichier*" dans le menu HOMARD ou à la souris.
+
+Object browser
+--------------
+A l'issue de cette demande d'information, 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, et les deux fichiers d'information de nom ``Liste.log`` et ``info_av.00.bilan``.
+
+.. image:: images/mesh_info_3.png
+ :align: center
+
+
+Computed iteration
+""""""""""""""""""
+
+Pour analysisr le maillage produit par une itération d'adaptation de maillage, on désigne à la souris cette itération dans l'arbre d'études et on lance l'analysis. On retrouve le menu similaire au cas initial :
+
+.. image:: images/mesh_info_4.png
+ :align: center
+
+Comme pour un maillage importé, l'arbre d'études a été enrichi avec les deux fichiers d'information de nom ``Liste.log`` et ``info_ap.xx.bilan``, où xx est le numéro de l'itération dans le cas.
+
+.. image:: images/mesh_info_5.png
+ :align: center
+
+
+
+Corresponding python functions
+""""""""""""""""""""""""""""""
+Look :ref:`tui_create_case` and :ref:`tui_create_iteration_en`
+
--- /dev/null
+.. _gui_usage_en:
+
+User's guide of the graphical interface
+=======================================
+.. index:: single: case
+.. index:: single: iteration
+
+Activation of the module HOMARD
+"""""""""""""""""""""""""""""""
+Pour utiliser le module HOMARD, deux façons existent :
+
+#. 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, selon le principe qui a été retenu pour tous les autres modules de Salome.
+
+.. image:: images/homard_1.png
+ :align: center
+
+Definition of an 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_en`). A partir de ce cas, on définira les itérations successives (voir :ref:`gui_create_iteration_en`) à partir des hypothèses (voir :ref:`gui_create_hypothese_en`). Les adaptations sont lancées tel que décrit dans :ref:`gui_homard_en`.
+
+
+User's guide of the graphical interface
+"""""""""""""""""""""""""""""""""""""""
+
+.. toctree::
+ :maxdepth: 2
+
+ gui_create_case_en
+ gui_create_iteration_en
+ gui_create_hypothese_en
+ gui_create_zone_en
+ gui_create_boundary_en
+ gui_homard_en
+ gui_mesh_info_en
+
Documentation du composant HOMARD |logo|
----------------------------------------
-
HOMARD est le composant qui permet l'adaptation de maillage au sein de la plateforme Salome.
*HOMARD est une marque déposée d'EDF.*
tui_usage
tutorials
+Licence
+"""""""
+.. index:: single: Licence
+
+La licence pour ce module est la GNU Lesser General Public License (Lesser GPL), tel qu'il est déclaré ici et dans les fichiers source.
+
+.. literalinclude:: licence.txt
+
+En complément, nous souhaitons que toute publication décrivant un travail utilisant ce module, ou tout produit commercial l'utilisant, cite au moins l'une des références ci-dessous :
+
+ * *HOMARD, a SALOME module for Mesh Adaptation*,
+ http://www.salome-platform.org/
+
+ * *SALOME The Open Source Integration Platform for Numerical Simulation*,
+ http://www.salome-platform.org/
+
+ * G. Nicolas and T. Fouquet, Adaptive Mesh Refinement for Conformal Hexahedral Meshes, *Finite
+ Elements in Analysis and Design*, Vol. 67, pp. 1-12, 2013, doi:10.1016/j.finel.2012.11.008
+
+La documentation de ce module est aussi couverte par la licence et l'obligation de citation.
Index et tables
"""""""""""""""
* :ref:`modindex`
* :ref:`search`
* :ref:`glossaire`
+
--- /dev/null
+.. HOMARD documentation master file, created by
+ sphinx-quickstart on Tue Jan 5 08:51:14 2010.
+ You can adapt this file completely to your liking, but it should at least
+ contain the root `toctree` directive.
+
+.. |logo| image:: images/HOMARD.png
+
+Documentation of the component HOMARD |logo|
+--------------------------------------------
+The component HOMARD drives the mesh adaptation inside of the SALOME plateform.
+
+*HOMARD is a trade mark of EDF.*
+
+Table of contents of this User's guide
+""""""""""""""""""""""""""""""""""""""
+
+.. toctree::
+ :maxdepth: 2
+
+ intro_en
+ gui_usage_en
+ tui_usage_en
+ tutorials_en
+
+Licence
+"""""""
+.. index:: single: Licence
+
+The licence for this module is the GNU Lesser General Public License (Lesser GPL), as stated here and in the source files.
+
+.. literalinclude:: licence.txt
+
+In addition, we expect that all publications describing work using this software, or all commercial products using it, quote at least one of the references given below:
+
+ * *HOMARD, a SALOME module for Mesh Adaptation*,
+ http://www.salome-platform.org/
+
+ * *SALOME The Open Source Integration Platform for Numerical Simulation*,
+ http://www.salome-platform.org/
+
+ * G. Nicolas and T. Fouquet, Adaptive Mesh Refinement for Conformal Hexahedral Meshes, *Finite
+ Elements in Analysis and Design*, Vol. 67, pp. 1-12, 2013, doi:10.1016/j.finel.2012.11.008
+
+The documentation of the module is also covered by the licence and the requirement of quoting.
+
+Index and tables
+""""""""""""""""
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+* :ref:`glossaire_en`
+
.. note::
Pour une référence à HOMARD, utiliser :
- G. Nicolas and T. Fouquet, Adaptive Mesh Refinement for Conformal Hexahedral Meshes, Finite Elements in Analysis and Design, Vol. 67, pp. 1-12, 2013, doi:10.1016/j.finel.2012.11.008
- `Acessible en cliquant ici <http://dx.doi.org/10.1016/j.finel.2012.11.008>`.
+
+ G. Nicolas and T. Fouquet, Adaptive Mesh Refinement for Conformal Hexahedral Meshes, "*Finite Elements in Analysis and Design*", Vol. 67, pp. 1-12, 2013, doi:10.1016/j.finel.2012.11.008
+
+ `Accessible en cliquant ici <http://dx.doi.org/10.1016/j.finel.2012.11.008>`_
Quelques illustrations de maillage adaptés
--- /dev/null
+.. _gui_intro_en:
+
+Introduction
+============
+
+General presentation
+""""""""""""""""""""
+Le logiciel HOMARD est destiné à adapter les maillages dans le cadre des codes de calculs par éléments ou volumes finis. Ce logiciel, réalisé par EDF R&D, procède par raffinement et déraffinement des maillages bidimensionnels ou tridimensionnels. Il est conçu pour être utilisé indépendamment du code de calcul auquel il est couplé.
+
+Raffiner le maillage signifie découper des mailles désignées selon des indications founies par l'utilisateur. Déraffiner le maillage signifie revenir en arrière sur des découpages précédemment réalisés : ainsi, en aucun cas HOMARD ne peut simplifier un maillage existant qui aura été créé trop fin. Le déraffinement prend toute son importance dans les calculs quand la zone d'intérêt se déplace au cours du calcul pour ne plus tenir compte de raffinements précédemment réalisés et qui deviennent inutiles. On en trouvera une illustration au bas de cette page.
+
+HOMARD sait traiter des maillages en 2 ou 3 dimensions et comportant les mailles suivantes :
+ - mailles-points
+ - segments
+ - triangles
+ - quadrangles
+ - tétraèdres
+ - hexaèdres
+ - prismes
+
+Ces mailles peuvent être présentes simultanément. Par exemple, HOMARD saura adapter un maillage comportant des triangles et des quadrangles.
+Les noeuds acceptés sont évidemment les noeuds qui sont les sommets des mailles, ce qui correspond à la description classique « en degré 1 » . Si les éléments sont décrits « en degré 2 », les noeuds complémentaires sont gérés. En revanche, il ne peut pas y asee cohabitation de mailles décrites en degré 1 et d'autres décrites en degré 2. Enfin, HOMARD sait prendre en compte des noeuds isolés, qui n'appartiendraient à aucune définition de mailles : ils ressortiront tels quels du processus d'adaptation.
+
+Le cas des pyramides est à part. Pour un maillage comportant des hexaèdres ou des prismes, la mise en conformité du maillage issu du raffinement crée des pyramides pour assurer la liaison entre deux régions de niveaux de raffinement différents. Ces pyramides sont gérées comme toutes les mailles de transition et ne sont pas redécoupées par la suite. En revanche, si le maillage initial contient des pyramides, HOMARD ne saura pas l'adapter et émettra un message d'erreur. Dans certains cas particuliers, on pourra néanmoins traiter un tel maillage, comme il est décrit dans la rubrique 'Options avancées' de :ref:`gui_create_case_en`).
+
+Plusieurs motivations apparaissent pour adapter un maillage :
+
+ - on veut simplifier la réalisation du maillage d'une géométrie complexe : on part d'un maillage grossier et on confie à un processus automatique la charge de le raffiner.
+ - on veut s'assurer de la convergence de la solution numérique : plutôt que de réaliser à la main des maillages de plus en plus fins, on laisse le logiciel chercher lui-même les endroits où il faudrait affiner le maillage pour augmenter la précision du résultat.
+ - les conditions du calcul changent au cours de son déroulement : les zones qui doivent être maillées finement se déplacent. Si on maille fin partout dès le début, le maillage est trop gros. En adaptant au fur et à mesure, le maillage ne sera fin qu'aux endroits nécessaires : sa taille sera réduite et la qualité de la solution sera bonne.
+
+Dans tous les cas, le principe de l'adaptation de maillage reste le même. Sur le maillage de départ, on réalise le calcul standard. Avec une analyse de la solution numérique obtenue, on estime l'erreur qui a été commise par rapport à la solution réelle. Cette estimation se représente par une valeur d'indicateur d'erreur dans chaque maille du calcul. A partir de là, on applique le principe suivant : les mailles où l'indicateur d'erreur est fort devraient être plus petites et, réciproquement, les mailles où l'indicateur d'erreur est faible pourraient être plus grandes. Avec cette information, on alimente HOMARD qui va modifier le maillage en conséquence. Sur le nouveau maillage, on recommencera alors le calcul.
+Schématiquement, une itération d'adaptation de maillage se présente ainsi. Le logiciel calcule la solution numérique sur le maillage n°k, puis en déduit les valeurs de l'indicateur d'erreur sur tout le maillage. A partir de la connaissance du maillage n°k et de l'indicateur n°k, HOMARD crée le nouveau maillage n°k+1.
+
+.. image:: images/intro_1.png
+ :align: center
+
+Au final, la chaîne complète part du maillage initial produit par un mailleur. Elle comprend des maillons successifs (calcul d'indicateur / adaptation) comme sur la figure ci-après.
+
+.. image:: images/intro_2.png
+ :align: center
+
+Des variantes de ce schéma de base sont possibles. Si aucun calcul d'erreur n'est disponible dans le logiciel couplé, on peut utiliser un champ pour piloter l'adaptation. Un champ de contraintes en mécaniques peut être utilisé : raffiner là où les contraintes sont importantes est souvent efficace pour améliorer la qualité de la simulation. On peut également adapter en fonction du saut d'une variable d'une maille à sa voisine ou dans une zone connue a priori. Grâce à ses nombreuses options, HOMARD permet d'envisager de multiples scénarios d'adaptation de maillage.
+
+.. note::
+ Pour une description plus complète, see :download:`Description générale de HOMARD <files/HOMARD_0.pdf>`.
+
+.. note::
+ Pour une référence à HOMARD, utiliser :
+
+ G. Nicolas and T. Fouquet, Adaptive Mesh Refinement for Conformal Hexahedral Meshes, "*Finite Elements in Analysis and Design*", Vol. 67, pp. 1-12, 2013, doi:10.1016/j.finel.2012.11.008
+
+ `Accessible en cliquant ici <http://dx.doi.org/10.1016/j.finel.2012.11.008>`_
+
+
+Some illustrations of adapted meshes
+""""""""""""""""""""""""""""""""""""
+.. index:: single: illustration
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| |
+| .. image:: images/intro_3.png |
+| :align: center |
+| |
++---------------------------------------------------------------+
+| |
+| .. image:: images/intro_4.png |
+| :align: center |
+| |
++---------------------------------------------------------------+
+| |
+| .. image:: images/intro_5.png |
+| :align: center |
+| |
++---------------------------------------------------------------+
+| |
+| .. image:: images/intro_6.png |
+| :align: center |
+| |
++---------------------------------------------------------------+
+| |
+| .. image:: images/intro_7.png |
+| :align: center |
+| |
++---------------------------------------------------------------+
+| |
+| .. image:: images/intro_8.gif |
+| :align: center |
+| |
++---------------------------------------------------------------+
+
+Quick start
+"""""""""""
+.. index:: single: start
+.. index:: single: example
+
+L'ensemble des options de pilotage du module HOMARD dans Salome est décrit dans le :ref:`gui_usage_en`. Mais on trouvera ici le B.A. BA pour découvrir l'utilisation de HOMARD à partir d'un exemple simple. Imaginons que l'on a effectué un calcul de thermique sur un maillage donné. On a récupéré en sortie de ce calcul un fichier au format MED, contenant le maillage et le champ des températures aux noeuds. On aimerait adapter le maillage de telle sorte que l'écart de température entre deux noeuds voisins soit inférieur à une valeur donnée.
+
+La première action nécessite de lancer le module HOMARD, en créant une nouvelle étude, selon le principe qui a été retenu pour tous les autres modules de Salome.
+
+.. image:: images/homard_1.png
+ :align: center
+
+Une fois le module HOMARD activé, on crée un cas par le choix "*Nouveau cas*" dans le menu HOMARD.
+
+.. image:: images/homard_2.png
+ :align: center
+
+La fenêtre suivante apparaît :
+
+.. image:: images/intro_31.png
+ :align: center
+
+Il faut fournir deux informations : le répertoire qui contiendra les fichiers produits par les adaptations successives et le fichier issu du calcul que l'on vient de faire. On valide par "Appliquer et fermer".
+
+.. image:: images/intro_32.png
+ :align: center
+
+L'arbre d'études est enrichi de ce cas. On déplie le cas jusqu'à afficher le maillage correspondant à l'itération 0. On désigne cette itération initiale et on demande une nouvelle itération par "*Nouvelle itération*" dans le menu HOMARD ou à la souris.
+
+.. image:: images/intro_331.png
+ :align: center
+
+La fenêtre suivante apparaît :
+
+.. image:: images/intro_33.png
+ :align: center
+
+On désigne le fichier issu du calcul que l'on vient de faire et qui contient le champ de température. C'est le même que celui qui a été donné dans la définition du cas.
+
+.. image:: images/intro_34.png
+ :align: center
+
+On clique sur "Nouveau" dans la rubrique hypothèse. La fenêtre suivante apparaît :
+
+.. image:: images/intro_35.png
+ :align: center
+
+On modifie les options par défaut pour correspondre à notre choix de pilotage de l'adaptation. La sélection d'un pilotage par les saut entre éléments et d'un seuil absolu de 4.0 va demander le découpage de chaque arête de maille où le température varie de plus de 4.0 degrés entre les deux extrémités de l'arête.
+
+.. image:: images/intro_36.png
+ :align: center
+
+On valide par "Appliquer et fermer" cette création d'hypothése, puis la création de la nouvelle itération. On se retrouve avec un arbre d'études enrichi avec la description de l'hypothèse créée et de l'itération à calculer, repérée par une icone "en attente".
+
+Lancer l'adaptation s'obtient en sélectionnant l'itération à calculer. On choisit ensuite "*Calculer*" dans le menu HOMARD ou à la souris. L'arbre d'études s'enrichit de fichiers d'informations et du nom du fichier au format MED qui contient le nouveau maillage, ``maill.01.med``. On remarque qu'il est placé dans le répertoire qui a été désigné à la création du cas.
+
+.. image:: images/intro_37.png
+ :align: center
+
+A ce stade, on va utiliser ce nouveau maillage pour un deuxième calcul, dans les mêmes conditions que le premier. Une fois que ce nouveau calcul est achevé, on peut décider de poursuivre le processus d'adaptation. Pour cela on revient dans Salome et on active le module HOMARD. On désigne l'itération que l'avait calculée précédemment "*Iter_1*" et on demande une nouvelle itération. La fenêtre suivante apparaît :
+
+.. image:: images/intro_38.png
+ :align: center
+
+Comme on continue l'adaptation avec le même critère de saut de température entre noeuds voisins, on garde l'hypothèse "*Hypo_1*". Il suffit de désigner le fichier issu du calcul que l'on vient de faire et qui contient le nouveau champ de température.
+
+.. image:: images/intro_39.png
+ :align: center
+
+Comme précédemment, on lance l'adaptation et on récupère les résultats dans le répertoire du cas, dont le maillage ``maill.02.med``.
+
+.. image:: images/intro_40.png
+ :align: center
+
+On peut alors lancer un nouveau calcul sur ce nouveau maillage et poursuiver cette alternance calcul/adaptation jusqu'à l'obtention du résultat attendu.
+
+
+Evolutions of the module
+""""""""""""""""""""""""
+.. index:: single: evolution
+
+Here are the main evolutions de HOMARD from the first release in SALOME 6.5.
+
+SALOME RELEASE 6.6 :
+ - Interface with med 3.0.6
+ - Default values for the time steps
+ - New element types: TRIA7 and QUAD9
+ - Optional output into the MED file of the level of refinement of every element
+
+SALOME RELEASE 7.1 :
+ - Correction of a bug in the filtering of the refinement by groups
+ - Driving of the adaptation by a threshold that is based upon the mean and the standard deviation (see :ref:`tui_create_hypothese_en`)
+ - TUI: the last time step for the driving instant can be selected by SetTimeStepRankLast (see :ref:`tui_create_iteration_en`)
+ - The destruction of the objects is available (GUI and TUI)
+ - The TUI functions are modified: they act onto the objects and no more by the names:
+ ``homard.AssociateIterHypo(iter_name,hypo_name)`` becomes ``iter.AssociateHypo(hypo_name)``, ``homard.AssociateHypoZone(hypo_name,zone_name,type_use)`` becomes ``hypo.AddZone(zone_name,type_use)``, ``homard.CreateIteration(iter_name,iter_parent_name)`` becomes ``case.NextIteration(iter_name)`` ou ``iter.NextIteration(iter_name)``
+ - Addition of a function:
+ ``cas.LastIteration()`` : returns the last iteration of the case (see :ref:`tui_create_iteration_en`)
+ - Mesh analysis (see :ref:`gui_mesh_info_en`)
+
+SALOME RELEASE 7.2 :
+ - A cone can be used as a support for a 2D boundary (see :ref:`tui_create_boundary_en`)
+ - The result can be published or not published in SMESH (see :ref:`tui_create_iteration_en`)
+ ``iter.Compute(option)`` becomes ``iter.Compute(option1, option2)``
+ - A serie of iterations that is stored in a directory can be followed (see :ref:`gui_create_case_en`)
+
+
+
+
+
+
--- /dev/null
+ <HOMARD, a SALOME module for Mesh Adaptation>
+
+ Copyright (C) 1996-2013 EDF R&D
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
| .. module:: GetAllBoundarysName |
| |
| **GetAllBoundarysName()** |
-| Retourne la liste des noms de toutes les frontières créées|
+| Retourne la liste des noms de toutes les frontières |
+| existantes |
| |
+---------------------------------------------------------------+
--- /dev/null
+.. _tui_create_boundary_en:
+
+The boundary
+============
+
+.. index:: single: boundary
+.. index:: single: cylindre
+.. index:: single: sphere
+
+The variables are described in :ref:`gui_create_boundary_en`.
+
+Methods of the class homard
+"""""""""""""""""""""""""""
+These methods returns an instance of the class boundary.
+
++----------------------------------------------------------------------------------------+
++----------------------------------------------------------------------------------------+
+| .. module:: CreateBoundaryDi |
+| |
+| **CreateBoundaryDi(boundary_name, mesh_name, mesh_file)** |
+| Returns an instance of the class ``boundary``, type discrete after its creation |
+| |
+| - ``boundary_name``: the name of the discrete boundary |
+| - ``mesh_name``: the name of the mesh of the boundary |
+| - ``mesh_file``: the name of the file for this mesh |
++----------------------------------------------------------------------------------------+
+| .. module:: CreateBoundaryCylinder |
+| |
+| **CreateBoundaryCylinder(boundary_name, Xcen, Ycen, Zcen, Xaxe, Yaxe, Zaxe, R)** |
+| Returns an instance of the class ``boundary`` analytical type cylindrical |
+| after its creation |
+| |
+| - ``boundary_name``: the name of the analytical boundary based on a cylinder |
+| - ``Xcen``, ``Ycen``, ``Zcen``: coordinates of a point on the axis of the cylinder |
+| - ``Xaxe``, ``Yaxe``, ``Zaxe``: vector of the axis |
+| - ``R``: radius of the cylinder |
++----------------------------------------------------------------------------------------+
+| .. module:: CreateBoundarySphere |
+| |
+| **CreateBoundarySphere(boundary_name, Xcen, Ycen, Zcen, R)** |
+| Returns an instance of the class ``boundary`` analytical type spherical |
+| after its creation |
+| |
+| - ``boundary_name``: the name of the boundary analytique based on a sphere |
+| - ``Xcen``, ``Ycen``, ``Zcen``: coordinates of the centre of the sphere |
+| - ``R``: radius of the sphere |
++----------------------------------------------------------------------------------------+
+| .. module:: CreateBoundaryConeA |
+| |
+| **CreateBoundaryConeA(boundary_name, Xaxe, Yaxe, Zaxe, Angle, Xcen, Ycen, Zcen)** |
+| Returns an instance of the class ``boundary`` analytical type conical |
+| after its creation |
+| |
+| - ``boundary_name``: the name of the boundary analytique based on a cone |
+| - ``Xaxe``, ``Yaxe``, ``Zaxe``: vector of the axis |
+| - ``Angle``: opening angle of the cone in degree (between 0 and 90) |
+| - ``Xcen``, ``Ycen``, ``Zcen``: coordinates of the centre of the cone |
++----------------------------------------------------------------------------------------+
+| .. module:: CreateBoundaryConeR |
+| |
+| **CreateBoundaryConeR(boundary_name, Xc1, Yc1, Zc1, R1, Xc2, Yc2, Zc2, R2)** |
+| Returns an instance of the class ``boundary`` analytical type conical |
+| after its creation |
+| |
+| - ``boundary_name``: the name of the boundary analytique based on a cone |
+| - ``Xc1``, ``Yc1``, ``Zc1``: coordinates of the first centre of the cone |
+| - ``R1``: radius of the cone at the first centre of the cone |
+| - ``Xc2``, ``Yc2``, ``Zc2``: coordinates of the second centre of the cone |
+| - ``R2``: radius of the cone at the second centre of the cone |
++----------------------------------------------------------------------------------------+
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetBoundary |
+| |
+| **GetBoundary(boundary_name)** |
+| Returns the instance of the class classe ``boundary`` |
+| known by its name |
+| |
+| - ``boundary_name``: the name of the boundary |
++---------------------------------------------------------------+
+| .. module:: GetAllBoundarysName |
+| |
+| **GetAllBoundarysName()** |
+| Returns the list of the names of all the existing |
+| boundaries |
+| |
++---------------------------------------------------------------+
+
+Methods of the class cas
+"""""""""""""""""""""""""
+See also in :ref:`tui_create_case_en`.
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: AddBoundaryGroup |
+| |
+| **AddBoundaryGroup(boundary, group)** |
+| Add a boundary to the definition of a case |
+| |
+| - ``boundary``: nom d'une frontière courbe à suivre |
+| |
+| Pour une frontière discrete: |
+| |
+| . si toutes les lignes courbes sont suivies, le second |
+| argument est une chaîne vide. |
+| . si seulement certaines lignes courbes sont suivies, |
+| ``group`` est the name d'un groupe de segments à suivre |
+| |
+| Pour une frontière analytique: |
+| |
+| - ``group``: nom d'un groupe de faces placées sur la |
+| frontière |
++---------------------------------------------------------------+
+
+Methods of the class boundary
+""""""""""""""""""""""""""""""
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetName |
+| |
+| **GetName()** |
+| Retourne the name of the boundary |
++---------------------------------------------------------------+
+| .. module:: GetType |
+| |
+| **GetType()** |
+| Retourne le type de la frontière: |
+| |
+| * 0: discrete |
+| * 1: cylindre |
+| * 2: sphere |
+| * 3: cône défini par un axe et un angle |
+| * 4: cône défini par deux rayons |
++---------------------------------------------------------------+
+| .. module:: GetCoords |
+| |
+| **GetCoords()** |
+| Retourne un tableau contenant les coordinates de la |
+| frontière dans l'ordre d'entrée dans le CreateBoundaryXXXX|
+| associé |
++---------------------------------------------------------------+
+| .. module:: Delete |
+| |
+| **Delete()** |
+| Detruit la frontière. |
+| Pour une frontière discrete, le fichier du maillage |
+| associé est conservé. |
+| |
+| Retourne un entier: |
+| * 0: destruction réussie |
+| * autre valeur: problème |
++---------------------------------------------------------------+
+
+
+Exemple
+"""""""
+Création d'une frontière discrete, d'une frontière sphèrique, puis d'une frontière cylindrique: ::
+
+ 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_en`
| |
| - ``case_name`` : le nom du cas |
| - ``dir_name`` : le nom du répertoire contenant |
-| l'itération à poursuivre |
+| le cas à poursuivre |
| |
+---------------------------------------------------------------+
| .. module:: CreateCaseFromCaseIteration |
| |
| - ``case_name`` : le nom du cas |
| - ``dir_name`` : le nom du répertoire contenant |
-| l'itération à poursuivre |
+| le cas à poursuivre |
| - ``number`` : le numéro de l'itération du cas |
| |
+---------------------------------------------------------------+
--- /dev/null
+.. _tui_create_case_en:
+
+Le cas
+======
+.. index:: single: cas
+.. index:: single: type de conformité
+.. index:: single: maillage;initial
+
+The variables are described in :ref:`gui_create_case_en`.
+
+Methods of the class homard
+""""""""""""""""""""""""""""
+
+Création d'un cas
+^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: CreateCase |
+| |
+| **CreateCase(case_name, mesh_name, mesh_file)** |
+| Returns an instance of the class ``cas`` après sa |
+| création |
+| |
+| - ``case_name``: le nom du cas |
+| - ``mesh_name``: le nom du maillage initial |
+| - ``mesh_file``: le nom du fichier contenant ce maillage |
+| |
+| Par défaut: |
+| |
+| * le répertoire des résultats est ``/tmp`` |
+| * l'adaptation est conforme |
++---------------------------------------------------------------+
+| .. module:: GetCase |
+| |
+| **GetCase(case_name)** |
+| Returns an instance of the class classe ``cas`` connue par|
+| son nom |
+| |
+| - ``case_name``: le nom du cas |
++---------------------------------------------------------------+
+| .. module:: GetAllCasesName |
+| |
+| **GetAllCasesName()** |
+| Retourne la liste des noms de tous les cas créés |
+| |
++---------------------------------------------------------------+
+
+Création d'un cas par poursuite d'une itération calculée
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: CreateCaseFromIteration |
+| |
+| **CreateCaseFromIteration(case_name, dir_name)** |
+| Returns an instance of the class ``cas`` après sa |
+| création |
+| |
+| - ``case_name``: le nom du cas |
+| - ``dir_name`` : le nom du répertoire contenant |
+| l'itération à poursuivre |
+| |
++---------------------------------------------------------------+
+| .. module:: CreateCaseFromCaseLastIteration |
+| |
+| **CreateCaseFromCaseLastIteration(case_name, dir_name)** |
+| Returns an instance of the class ``cas`` après sa |
+| création |
+| |
+| - ``case_name``: le nom du cas |
+| - ``dir_name`` : le nom du répertoire contenant |
+| le cas à poursuivre |
+| |
++---------------------------------------------------------------+
+| .. module:: CreateCaseFromCaseIteration |
+| |
+| **CreateCaseFromCaseIteration(case_name, dir_name, number)** |
+| Returns an instance of the class ``cas`` après sa |
+| création |
+| |
+| - ``case_name``: le nom du cas |
+| - ``dir_name`` : le nom du répertoire contenant |
+| le cas à poursuivre |
+| - ``number``: le numéro de l'itération du cas |
+| |
++---------------------------------------------------------------+
+
+
+
+Methods of the class cas
+"""""""""""""""""""""""""
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetName |
+| |
+| **GetName()** |
+| Retourne le nom du cas |
++---------------------------------------------------------------+
+| .. module:: SetDirName |
+| |
+| **SetDirName(dirname)** |
+| Affecte le répertoire des résutats associé au cas. Cela ne|
+| peut se faire qu'après la création du cas et avant le |
+| premier calcul. |
+| |
+| - ``dirname``: le nom du répertoire des résutats |
++---------------------------------------------------------------+
+| .. module:: GetDirName |
+| |
+| **GetDirName()** |
+| Retourne le nom du répertoire des résutats associé au cas |
++---------------------------------------------------------------+
+| .. module:: SetConfType |
+| |
+| **SetConfType(conf_type)** |
+| Définit le mode de conformité associé au cas |
+| |
+| - ``conf_type``: entier précisant le mode de conformité |
+| |
+| * 1: conforme |
+| * 2: non conforme avec 1 noeud par maille |
+| * 3: non conforme avec 1 noeud par arete de maille |
+| * 4: non conforme quelconque |
++---------------------------------------------------------------+
+| .. module:: GetConfType |
+| |
+| **GetConfType()** |
+| Retourne le type de conformité |
++---------------------------------------------------------------+
+| .. module:: GetIter0 |
+| |
+| **GetIter0()** |
+| Retourne l'itération associée au maillage initial. |
+| Cette itération est créée automatiquement par le module |
+| HOMARD et est utilisée pour enchaîner les adaptations. |
+| Elle correspond à un maillage initial ou à une itération |
+| de poursuite d'un cas précédent. |
++---------------------------------------------------------------+
+| .. module:: AddBoundaryGroup |
+| |
+| **AddBoundaryGroup(boundary, group)** |
+| Ajoute une frontière à la définition du cas |
+| |
+| - ``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:: Delete |
+| |
+| **Delete(option)** |
+| Detruit le cas et toutes les itérations associées. Le |
+| fichier du maillage initial associé est conservé. |
+| |
+| - ``option``: un entier précisant ce qui est fait des |
+| fichiers de maillage associés |
+| |
+| * 0: les fichiers sont conservés |
+| * 1: les fichiers sont détruits |
+| |
+| Retourne un entier: |
+| * 0: destruction réussie |
+| * autre valeur: problème |
++---------------------------------------------------------------+
+| .. module:: GetState |
+| |
+| **GetState()** |
+| Retourne l'état du cas: |
+| * 0: correspond à un maillage initial |
+| * autre valeur: poursuite d'une itération de numéro n |
++---------------------------------------------------------------+
+
+Les options avancées
+^^^^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: SetPyram |
+| |
+| **SetPyram(option)** |
+| Définit le statut des pyramides pour le cas |
+| |
+| - ``option``: entier précisant le statut des pyramides |
+| éventuellement présentes dans le maillage initial |
+| |
+| * 0: pyramides refusées (défaut) |
+| * 1: pyramides autorisées |
++---------------------------------------------------------------+
+| .. module:: GetPyram |
+| |
+| **GetPyram()** |
+| Retourne le statut accordé aux pyramides éventuellement |
+| présentes dans le maillage initial |
++---------------------------------------------------------------+
+
+Informations sur le maillage initial
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: MeshInfo |
+| |
+| **MeshInfo(Qual, Diam, Conn, Tail, Inte)** |
+| Donne des informations sur le maillage. Pour chaque |
+| option, le choix 0 correspond à ne rien faire, alors que |
+| le choix 1 active l'option. |
+| |
+| - ``Qual``: qualité des mailles |
+| - ``Diam``: diamètre des mailles |
+| - ``Conn``: connexité du domaine ; en un seul morceau, |
+| combien de trous, etc. |
+| - ``Tail``: tailles des constituants du domaine, groupe |
+| par groupe |
+| - ``Inte``: interpénétration des mailles, par dimension |
++---------------------------------------------------------------+
+
+
+Exemple
+"""""""
+La création de l'objet case_1 se fait ainsi: ::
+
+ case_name = "CAS_1"
+ mesh_name = "MAILL"
+ mesh_file = "/local00/Salome/Adapt/m0.med"
+ case_1 = homard.CreateCase(case_name, mesh_name, mesh_file)
+ dirname = "/local00/Salome/Adapt/resu"
+ case_1.SetDirName(dirname)
+ case_1.SetConfType(1)
+ case_1.AddBoundaryGroup( 'intersection', '' )
+ case_1.AddBoundaryGroup( 'cyl_1', 'T1_EXT' )
+ case_1.AddBoundaryGroup( 'cyl_1', 'T2_EXT' )
+ case_1.AddBoundaryGroup( 'cyl_2', 'T_INT' )
+
+
+
+Saisie graphique correspondante
+"""""""""""""""""""""""""""""""
+Consulter :ref:`gui_create_case_en`
+
+
--- /dev/null
+.. _tui_create_hypothese_en:
+
+L'hypothèse
+===========
+
+.. index:: single: itération
+.. index:: single: hypothèse
+.. index:: single: zone
+
+The variables are described in :ref:`gui_create_hypothese_en`.
+
+Methods of the class homard
+""""""""""""""""""""""""""""
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: CreateHypothesis |
+| |
+| **CreateHypothesis(hypo_name)** |
+| Returns an instance of the class ``hypothese`` |
+| |
+| - ``hypo_name``: le nom de l'hypothèse |
++---------------------------------------------------------------+
+| .. module:: GetHypothesis |
+| |
+| **GetHypothesis(hypo_name)** |
+| Returns an instance of the class classe ``hypothese`` |
+| son nom |
+| |
+| - ``hypo_name``: le nom de l'hypothèse |
++---------------------------------------------------------------+
+| .. module:: GetAllHypothesesName |
+| |
+| **GetAllHypothesesName()** |
+| Retourne la liste des noms de toutes les hypothèses créées|
+| |
++---------------------------------------------------------------+
+
+Methods of the class hypothese
+"""""""""""""""""""""""""""""""
+
+Généralités
+^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetName |
+| |
+| **GetName()** |
+| Retourne le nom de l'hypothèse |
++---------------------------------------------------------------+
+| .. module:: SetAdapRefinUnRef |
+| |
+| **SetAdapRefinUnRef(Adap, Refin, UnRef)** |
+| Affecte le mode d'adaptation associé à l'hypothèse |
+| |
+| - ``Adap``: entier précisant le type d'adaptation |
+| |
+| * -1: uniforme |
+| * 0: selon des zones |
+| * 1: selon un champ |
+| |
+| - ``Refin``: entier précisant si le raffinement est a ctif|
+| |
+| * 0: inactif |
+| * 1: actif |
+| |
+| - ``UnRef``: entier précisant si déraffinement est actif |
+| |
+| * 0: inactif |
+| * 1: actif |
+| |
++---------------------------------------------------------------+
+| .. module:: GetAdapType |
+| |
+| **GetAdapType()** |
+| Retourne le type d'adaptation |
++---------------------------------------------------------------+
+| .. module:: GetRefinType |
+| |
+| **GetRefinType()** |
+| Retourne le type de raffinement |
++---------------------------------------------------------------+
+| .. module:: GetUnRefType |
+| |
+| **GetUnRefType()** |
+| Retourne le type de déraffinement |
++---------------------------------------------------------------+
+| .. module:: Delete |
+| |
+| **Delete()** |
+| Detruit l'hypothèse |
+| |
+| Retourne un entier: |
+| * 0: destruction réussie |
+| * autre valeur: problème |
++---------------------------------------------------------------+
+
+Le champ et les seuils
+^^^^^^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: SetField |
+| |
+| **SetField(field_name)** |
+| Attribue un nom de champ à l'hypothèse |
+| |
+| - ``field_name``: le nom du champ |
++---------------------------------------------------------------+
+| .. module:: GetFieldName |
+| |
+| **GetFieldName()** |
+| Retourne le nom du champ |
++---------------------------------------------------------------+
+| .. module:: SetUseField |
+| |
+| **SetUseField(use_field)** |
+| Attribue un mode d'usage du champ à l'hypothèse |
+| |
+| - ``use_field``: entier précisant l'usage du champ |
+| |
+| * 0: valeur par élément (défaut) |
+| * 1: saut entre un élément et ses voisins |
++---------------------------------------------------------------+
+| .. module:: SetRefinThr |
+| |
+| **SetRefinThr(type_thres, threshold)** |
+| Définit les seuils en raffinement |
+| |
+| - ``type_thres``: entier précisant le type de seuil en |
+| raffinement |
+| |
+| * 1: valeur absolue |
+| * 2: valeur relative en % |
+| * 3: fraction des mailles en % |
+| * 4: moyenne + n fois l'écart-type |
+| |
+| - ``threshold``: valeur numérique entrant dans la |
+| définition du seuil |
++---------------------------------------------------------------+
+| .. module:: GetRefinThrType |
+| |
+| **GetRefinThrType()** |
+| Retourne le type de seuil de raffinement |
++---------------------------------------------------------------+
+| .. module:: SetUnRefThr |
+| |
+| **SetUnRefThr(type_thres, threshold)** |
+| Définit les seuils en déraffinement |
+| |
+| - ``type_thres``: entier précisant le type de seuil en |
+| déraffinement |
+| |
+| * 1: valeur absolue |
+| * 2: valeur relative en % |
+| * 3: fraction des mailles en % |
+| * 4: moyenne - n fois l'écart-type |
+| |
+| - ``threshold``: valeur du seuil |
++---------------------------------------------------------------+
+| .. module:: GetUnRefThrType |
+| |
+| **GetUnRefThrType()** |
+| Retourne le type de seuil de déraffinement |
++---------------------------------------------------------------+
+
+
+Les composantes du champ
+^^^^^^^^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: AddComp |
+| |
+| **AddComp(comp_name)** |
+| Ajoute une composante du champ à considérer |
+| |
+| - ``comp_name``: nom d'une composante à prendre en |
+| compte |
++---------------------------------------------------------------+
+| .. module:: SetUseComp |
+| |
+| **SetUseComp(use_comp)** |
+| Définit l'usage des composantes |
+| |
+| - ``use_comp``: entier précisant l'usage des composantes |
+| |
+| * 0: norme L2 (défaut) |
+| * 1: norme infinie |
+| * 2: valeur relative, si une seule composante |
++---------------------------------------------------------------+
+| .. module:: GetListComp |
+| |
+| **GetListComp()** |
+| Retourne la liste des composantes utilisées |
++---------------------------------------------------------------+
+
+
+Les zones
+^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: AddZone |
+| |
+| **AddZone(zone_name, type_use)** |
+| |
+| - ``zone_name``: le nom de la zone à ajouter |
+| - ``type_use``: entier précisant l'usage de la zone |
+| |
+| * 1: raffinement |
+| * -1: déraffinement |
++---------------------------------------------------------------+
+
+
+Le filtrage par les groupes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: AddGroup |
+| |
+| **AddGroup(group_name)** |
+| Ajoute un groupe au filtrage |
+| |
+| - ``group_name``: nom du groupe à prendre en compte |
++---------------------------------------------------------------+
+| .. module:: GetGroups |
+| |
+| **GetGroups()** |
+| Retourne la liste des groupes utilisés pour le filtrage |
++---------------------------------------------------------------+
+
+Les options avancées
+^^^^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: SetNivMax |
+| |
+| **SetNivMax(nivmax)** |
+| Définit le niveau maximal de raffinement |
+| |
+| - ``nivmax``: niveau de raffinement à ne pas dépasser |
++---------------------------------------------------------------+
+| .. module:: GetNivMax |
+| |
+| **GetNivMax()** |
+| Retourne le niveau maximal de raffinement |
++---------------------------------------------------------------+
+| .. module:: SetDiamMin |
+| |
+| **SetDiamMin(diammin)** |
+| Définit le diamètre minimal des futures mailles |
+| |
+| - ``diammin``: diamètre minimal voulu pour une maille |
++---------------------------------------------------------------+
+| .. module:: GetDiamMin |
+| |
+| **GetDiamMin()** |
+| Retourne le diamètre minimal voulu |
++---------------------------------------------------------------+
+| .. module:: SetAdapInit |
+| |
+| **SetAdapInit(option)** |
+| Définit le traitement à appliquer aux mailles où |
+| le champ de pilotage du raffinement n'est pas défini |
+| |
+| - ``option``: entier précisant le choix retenu |
+| |
+| * 0: aucun effet (défaut) |
+| * 1: les mailles sans indicateurs sont raffinées |
+| * -1: les mailles sans indicateurs sont déraffinées |
++---------------------------------------------------------------+
+| .. module:: GetAdapInit |
+| |
+| **GetAdapInit()** |
+| Retourne le type de traitement à appliquer aux mailles où |
+| le champ de pilotage du raffinement n'est pas défini |
++---------------------------------------------------------------+
+| .. module:: SetLevelOutput |
+| |
+| **SetLevelOutput(option)** |
+| Précise si on veut récupérer le niveau de raffinement des |
+| mailles sous la forme d'un champ |
+| |
+| - ``option``: entier précisant le choix retenu |
+| |
+| * 0: aucun effet (défaut) |
+| * 1: le champ est produit |
++---------------------------------------------------------------+
+| .. module:: GetLevelOutput |
+| |
+| **GetLevelOutput()** |
+| Retourne le choix retenu pour la récupération du niveau |
+| de raffinement |
++---------------------------------------------------------------+
+
+
+Exemple
+"""""""
+La création de l'objet hypo_1 se fait ainsi: ::
+
+ hypo_1 = homard.CreateHypothesis("HypoField")
+ hypo_1.SetAdapRefinUnRef(1, 1, 0)
+ hypo_1.SetField("INDICATEUR")
+ hypo_1.AddComp("INDX")
+ hypo_1.AddComp("INDZ")
+ hypo_1.SetRefinThr(1, 80.)
+
+
+Saisie graphique correspondante
+"""""""""""""""""""""""""""""""
+Consulter :ref:`gui_create_hypothese_en`
+
+.. warning::
+ En mode graphique, si on édite une hypothèse et que l'on modifie une de ses caractéristiques, par exemple le seuil de raffinement, toutes les itérations qui ont été calculées précédemment avec cette hypothèse sont invalidées. En mode python, cela n'est plus vrai : les itérations restent telles quelles.
--- /dev/null
+.. _tui_create_iteration_en:
+
+L'itération
+===========
+
+.. index:: single: itération
+.. index:: single: hypothèse
+.. index:: single: zone
+
+The variables are described in :ref:`gui_create_iteration_en`.
+
+Methods of the class homard
+""""""""""""""""""""""""""""
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetIteration |
+| |
+| **GetIteration(iter_name)** |
+| Returns an instance of the class classe ``iteration`` |
+| son nom |
+| |
+| - ``iter_name``: le nom de l'itération |
++---------------------------------------------------------------+
+| .. module:: GetAllIterationsName |
+| |
+| **GetAllIterationsName()** |
+| Retourne la liste des noms de toutes les itérations créées|
+| |
++---------------------------------------------------------------+
+
+Methods of the class cas
+"""""""""""""""""""""""""
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: NextIteration |
+| |
+| **NextIteration(iter_name)** |
+| Returns an instance of the class ``iteration`` après |
+| sa création: elle suit immédiatement l'itération |
+| initiale, correspondant au maillage définissant le cas |
+| |
+| - ``iter_name``: le nom à donner à la nouvelle itération |
+| |
+| Par défaut: |
+| |
+| * le maillage produit a le même nom que l'itération |
++---------------------------------------------------------------+
+| .. module:: LastIteration |
+| |
+| **LastIteration()** |
+| Returns an instance of the class ``iteration``: la |
+| dernière créée dans la descendance de l'itération initiale|
+| du cas. C'est celle qui est sans fille. Il y a erreur s'il|
+| existe plus d'une branche dans la descendance. |
+| |
++---------------------------------------------------------------+
+
+Methods of the class iteration
+"""""""""""""""""""""""""""""""
+
+Généralités
+^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: NextIteration |
+| |
+| **NextIteration(iter_name)** |
+| Returns an instance of the class ``iteration`` qui suit |
+| l'itération courante |
+| |
+| - ``iter_name``: le nom à donner à la nouvelle itération |
+| |
+| Par défaut: |
+| |
+| * le maillage produit a le même nom que l'itération |
++---------------------------------------------------------------+
+| .. module:: Compute |
+| |
+| **Compute(option1, option2)** |
+| Calcule le maillage correspondant à l'itération |
+| |
+| - ``option1``: un entier précisant ce qui se passe quand |
+| des fichiers de résultats existent déjà |
+| |
+| * 0: arrêt en erreur |
+| * 1: écrasement des anciens fichiers |
+| |
+| - ``option2``: un entier précisant ce qui est fait des |
+| résultats |
+| |
+| * 1: aucune action particulière |
+| * 2 : publication dans le module SMESH |
+| |
+| Retourne un entier : |
+| * 0 : adaptation réussie |
+| * autre valeur : problème |
++---------------------------------------------------------------+
+| .. module:: GetName |
+| |
+| **GetName()** |
+| Retourne le nom de l'itération |
++---------------------------------------------------------------+
+| .. module:: GetNumber |
+| |
+| **GetNumber()** |
+| Retourne le numéro de l'itération. |
+| |
+| L'itération 0 est celle associée au maillage initial. |
+| Ensuite, une itération de numéro N est issue de |
+| l'adaptation d'une itération de numéro N-1. |
++---------------------------------------------------------------+
+| .. module:: GetIterParent |
+| |
+| **GetIterParent()** |
+| Retourne l'itération mère |
++---------------------------------------------------------------+
+| .. module:: LastIteration |
+| |
+| **LastIteration()** |
+| Returns an instance of the class ``iteration`` : la |
+| dernière créée dans la descendance de l'itération. C'est |
+| celle qui est sans fille. Il y a erreur s'il existe plus |
+| d'une branche dans la descendance. |
++---------------------------------------------------------------+
+| .. module:: AssociateHypo |
+| |
+| **AssociateHypo(hypo_name)** |
+| Associe une hypothèse à l'itération |
+| |
+| - ``hypo_name`` : le nom de l'hypothèse à associer |
++---------------------------------------------------------------+
+| .. module:: GetHypoName |
+| |
+| **GetHypoName()** |
+| Retourne le nom de l'hypothèse associée |
++---------------------------------------------------------------+
+| .. module:: GetCaseName |
+| |
+| **GetCaseName()** |
+| Retourne le nom du cas associé |
++---------------------------------------------------------------+
+| .. module:: GetState |
+| |
+| **GetState()** |
+| Retourne l'état de l'itération |
+| |
+| - ``2`` : itération calculée correctement |
+| - ``1`` : itération non calculée |
+| - ``<=0`` : itération initiale à ne pas calculer, de |
+| numéro valant la valeur absolue de l'état |
++---------------------------------------------------------------+
+| .. module:: GetLogFile |
+| |
+| **GetLogFile()** |
+| Retourne le nom du fichier retraçant le déroulement de |
+| l'exécution de HOMARD |
++---------------------------------------------------------------+
+| .. module:: GetFileInfo |
+| |
+| **GetFileInfo()** |
+| Retourne le nom du fichier contenant l'analyse du maillage|
++---------------------------------------------------------------+
+| .. module:: GetDirName |
+| |
+| **GetDirName()** |
+| Retourne le nom du répertoire des résutats associé à |
+| l'itération |
++---------------------------------------------------------------+
+| .. module:: Delete |
+| |
+| **Delete(option)** |
+| Detruit l'itération et toutes ses filles éventuelles. |
+| |
+| - ``option`` : un entier précisant ce qui est fait des |
+| fichiers de maillage associés |
+| |
+| * 0 : les fichiers sont conservés |
+| * 1 : les fichiers sont détruits |
+| |
+| Retourne un entier : |
+| * 0 : destruction réussie |
+| * autre valeur : problème |
++---------------------------------------------------------------+
+
+Informations sur les maillages
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: SetMeshName |
+| |
+| **SetMeshName(mesh_name)** |
+| Définit le nom du maillage produit |
+| |
+| - ``mesh_name`` : le nom du maillage produit |
++---------------------------------------------------------------+
+| .. module:: GetMeshName |
+| |
+| **GetMeshName()** |
+| Retourne le nom du maillage produit |
++---------------------------------------------------------------+
+| .. module:: SetMeshFile |
+| |
+| **SetMeshFile(mesh_file)** |
+| Définit le fichier du maillage produit |
+| |
+| - ``mesh_file`` : le nom du fichier qui contiendra |
+| le maillage produit |
++---------------------------------------------------------------+
+| .. module:: GetMeshFile |
+| |
+| **GetMeshFile()** |
+| Retourne le nom du fichier du maillage produit |
++---------------------------------------------------------------+
+| .. module:: MeshInfo |
+| |
+| **MeshInfo(Qual, Diam, Conn, Tail, Inte)** |
+| Donne des informations sur le maillage. Pour chaque |
+| option, le choix 0 correspond à ne rien faire, alors que |
+| le choix 1 active l'option. |
+| |
+| - ``Qual`` : qualité des mailles |
+| - ``Diam`` : diamètre des mailles |
+| - ``Conn`` : connexité du domaine ; en un seul morceau, |
+| combien de trous, etc. |
+| - ``Tail`` : tailles des constituants du domaine, groupe |
+| par groupe |
+| - ``Inte`` : interpénétration des mailles, par dimension |
++---------------------------------------------------------------+
+
+Informations sur le champ
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: SetFieldFile |
+| |
+| **SetFieldFile(field_file)** |
+| Définit le fichier des champs utiles |
+| |
+| - ``field_file`` : le nom du fichier contenant le champ |
++---------------------------------------------------------------+
+| .. module:: SetTimeStepRank |
+| |
+| **SetTimeStepRank(TimeStep, Rank)** |
+| Définit les instants pour le champ |
+| |
+| Si un seul instant est défini pour le champ, il est pris |
+| par défaut. |
+| |
+| Inutile si aucun instant n'est défini pour le champ |
+| |
+| - ``TimeStep`` : l'instant où est pris le champ |
+| - ``Rank`` : le numéro d'ordre où est pris le champ |
++---------------------------------------------------------------+
+| .. module:: SetTimeStepRankLast |
+| |
+| **SetTimeStepRankLast()** |
+| Précise que le dernier instant enregistré pour le champ |
+| est utilisé |
++---------------------------------------------------------------+
+| .. module:: GetFieldFileName |
+| |
+| **GetFieldFileName()** |
+| Retourne le nom du fichier du champ |
++---------------------------------------------------------------+
+| .. module:: GetTimeStep |
+| |
+| **GetTimeStep()** |
+| Retourne l'instant où est pris le champ |
++---------------------------------------------------------------+
+| .. module:: GetRank |
+| |
+| **GetRank()** |
+| Retourne le numéro d'ordre où est pris le champ |
++---------------------------------------------------------------+
+
+Exemple
+"""""""
+.. index:: single: maillage;initial
+
+Pour la création de la première itération, on part de celle qui correspond au maillage initial. C'est celle contenue dans le cas. ::
+
+ iter_name = "Iteration_1"
+ iter_1 = case_1.NextIteration(iter_name)
+ iter_1.SetField(field_file)
+ iter_1.SetTimeStepRank( 0, 0)
+ iter_1.SetMeshName("maill_01")
+ iter_1.SetMeshFile("/local00/M.01.med")
+ iter_1.AssociateHypo("HypoField")
+ codret = iter_1.Compute(1, 2)
+
+Ensuite, on crée une itération suivante à l'itération parent de laquelle on part. ::
+
+ iter_name = "Iteration_2"
+ iter_2 = iter_1.NextIteration(iter_name)
+ iter_2.SetField(field_file)
+ iter_2.SetTimeStepRank( 1, 1)
+ iter_2.SetMeshName("maill_02")
+ iter_2.SetMeshFile("/local00/M.02.med")
+ iter_2.AssociateHypo("HypoField")
+ codret = iter_2.Compute(1, 2)
+
+
+Saisie graphique correspondante
+"""""""""""""""""""""""""""""""
+Consulter :ref:`gui_create_iteration_en`
--- /dev/null
+.. _tui_create_zone_en:
+
+La zone
+=======
+
+.. 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
+
+The variables are described in :ref:`gui_create_zone_en`.
+
+Methods of the class homard
+""""""""""""""""""""""""""""
+
+These methods returns an instance of the class zone.
+
++----------------------------------------------------------------------------------+
++----------------------------------------------------------------------------------+
+| .. module:: CreateZoneBox |
+| |
+| **CreateZoneBox(zone_name, Xmin, Xmax, Ymin, Ymax, Zmin, Zmax)** |
+| Returns an instance of the class ``zone`` de type parallélépipèdique |
+| après sa création |
+| |
+| - ``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)** |
+| Returns an instance of the class ``zone`` de type cylindrique |
+| après sa création |
+| |
+| - ``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)** |
+| Returns an instance of the class ``zone`` de type tuyau |
+| après sa création |
+| |
+| - ``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)** |
+| Returns an instance of the class ``zone`` de type sphérique |
+| après sa création |
+| |
+| - ``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)** |
+| Returns an instance of the class ``zone`` de type rectangulaire |
+| après sa création |
+| |
+| - ``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)** |
+| Returns an instance of the class ``zone`` de type disque |
+| après sa création |
+| |
+| - ``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)** |
+| Returns an instance of the class ``zone`` de type disque troué |
+| après sa création |
+| |
+| - ``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 |
++----------------------------------------------------------------------------------+
+
+
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| La convention d'orientation du plan est la même que celle |
+| utilisée dans les autres modules de Salome, en particulier |
+| GEOM : |
+| |
+| 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.
+
+
+
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetZone |
+| |
+| **GetZone(zone_name)** |
+| Returns an instance of the class classe ``zone`` connue |
+| son nom |
+| |
+| - ``zone_name`` : le nom de la zone |
++---------------------------------------------------------------+
+| .. module:: GetAllZonesName |
+| |
+| **GetAllZonesName()** |
+| Retourne la liste des noms de toutes les zones créées |
+| |
++---------------------------------------------------------------+
+
+
+Methods of the class zone
+""""""""""""""""""""""""""
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetName |
+| |
+| **GetName()** |
+| Retourne le nom de la zone |
++---------------------------------------------------------------+
+| .. module:: GetType |
+| |
+| **GetType()** |
+| Retourne le type de la zone |
+| |
+| * 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:: GetCoords |
+| |
+| **GetCoords()** |
+| Retourne un tableau contenant les coordonnées de la zone |
+| dans l'ordre d'entrée dans le CreateZoneXXXX associé |
++---------------------------------------------------------------+
+| .. module:: Delete |
+| |
+| **Delete()** |
+| Detruit la zone |
+| |
+| Retourne un entier : |
+| * 0 : destruction réussie |
+| * autre valeur : problème |
++---------------------------------------------------------------+
+
+
+Exemple
+"""""""
+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_en`
+
+.. warning::
+ En mode graphique, si on édite une zone et que l'on modifie une des dimensions, toutes les itérations qui ont été calculées précédemment avec cette zone sont invalidées. En mode python, cela n'est plus vrai : les itérations restent telles quelles.
+
+
+
--- /dev/null
+.. _tui_homard_en:
+
+The computation
+===============
+
+Methods of the class homard
+"""""""""""""""""""""""""""
+
+
+Example
+"""""""
+
+
+Corresponding graphical interface
+"""""""""""""""""""""""""""""""""
+Look at :ref:`gui_homard_en`
--- /dev/null
+User's guide of the TUI
+=======================
+The functionnalities of the module HOMARD are available by python instructions. We shall find here the description of each of the functions.
+
+.. toctree::
+ :maxdepth: 2
+
+ tui_create_case_en
+ tui_create_iteration_en
+ tui_create_hypothese_en
+ tui_create_zone_en
+ tui_create_boundary_en
+ tui_homard_en
* la même hypothèse est utilisée à chaque itération
* 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.
- ::
-
- #
- # Hypothesis "Hypo_0"
- # ===================
- Hypo_0 = homard.CreateHypothesis('Hypo_0')
- Hypo_0.SetAdapRefinUnRef(-1, 1, 0)
- #
- # Case "Case_1"
- # =============
- Case_1 = homard.CreateCase('Case_1', 'MAILL', data_dir+'/tutorial_1.00.med')
- Case_1.SetDirName(dircase)
- Case_1.SetConfType(1)
- #
- # Iterations
- # ==========
- # Iteration "Iter_0"
- Iter_0 = Case_1.NextIteration('Iter_0')
- Iter_0.SetMeshName('MESH')
- Iter_0.SetMeshFile(dircase+'/maill.01.med')
- Iter_0.AssociateHypo('Hypo_0')
- codret = Iter_0.Compute(1, 2)
-
- # Iteration "Iter_1"
- Iter_1 = Iter_0.NextIteration('Iter_1')
- Iter_1.SetMeshName('MESH')
- Iter_1.SetMeshFile(dircase+'/maill.02.med')
- Iter_1.AssociateHypo('Hypo_0')
- codret = Iter_1.Compute(1, 2)
-
- # Iteration "Iter_2"
- Iter_2 = Iter_1.NextIteration('Iter_2')
- Iter_2.SetMeshName('MESH')
- Iter_2.SetMeshFile(dircase+'/maill.03.med')
- Iter_2.AssociateHypo('Hypo_0')
- codret = Iter_2.Compute(1, 2)
+.. literalinclude:: files/tutorial_1.py
+ :lines: 53-86
.. note::
Téléchargement des fichiers
.. index:: single: zone
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.
-::
-
- #
- # Creation of the zones
- # =====================
- # Box "Zone_0"
- Zone_0 = homard.CreateZoneBox('Zone_0', -0.1, 1.1, -0.1, 1.1, 0.9, 1.1)
- #
- # Sphere "Zone_1"
- Zone_1 = homard.CreateZoneSphere('Zone_1', 0., 0., 0., 1.05)
- #
- # Box "Zone_2"
- Zone_2 = homard.CreateZoneBox('Zone_2', -0.1, 0.51, -0.1, 0.51, -0.1, 0.51)
- #
- # Hypothesis "Hypo_0"
- # ===================
- Hypo_0 = homard.CreateHypothesis('Hypo_0')
- Hypo_0.SetAdapRefinUnRef(0, 1, 0)
- Hypo_0.AddZone('Zone_1', 1)
- Hypo_0.AddZone('Zone_0', 1)
- #
- # Hypothesis "Hypo_1"
- # ===================
- Hypo_1 = homard.CreateHypothesis('Hypo_1')
- Hypo_1.SetAdapRefinUnRef(0, 1, 0)
- Hypo_1.AddZone('Zone_0', 1)
- Hypo_1.AddZone('Zone_2', 1)
- #
- # Case "Case_1"
- # =============
- Case_1 = homard.CreateCase('Case_1', 'MZERO', data_dir+'/tutorial_2.00.med')
- Case_1.SetDirName(dircase)
- #
- # Iteration "Iter_0"
- # ==================
- Iter_0 = Case_1.NextIteration('Iter_0')
- Iter_0.SetMeshName('M_1')
- Iter_0.SetMeshFile(dircase+'/maill.01.med')
- Iter_0.AssociateHypo('Hypo_0')
- codret = Iter_0.Compute(1, 2)
- #
- # Iteration "Iter_1"
- # ==================
- Iter_1 = Iter_0.NextIteration('Iter_1')
- Iter_1.SetMeshName('M_2')
- Iter_1.SetMeshFile(dircase+'/maill.02.med')
- Iter_1.AssociateHypo('Hypo_1')
- codret = Iter_1.Compute(1, 2)
+
+.. literalinclude:: files/tutorial_2.py
+ :lines: 53-98
.. note::
Téléchargement des fichiers
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.
-::
-
- #
- # Hypothesis "Hypo_0vers1"
- # ========================
- Hypo_0vers1 = homard.CreateHypothesis('Hypo_0vers1')
- Hypo_0vers1.SetAdapRefinUnRef(1, 1, 0)
- # Characterization of the field
- 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_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__________')
- #
- # 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', data_dir+'/tutorial_3.00.med')
- Case_1.SetDirName(dircase)
- #
- # Iteration "Iter_1"
- # ==================
- Iter_1 = Case_1.NextIteration('Iter_1')
- Iter_1.SetMeshName('H_1')
- Iter_1.SetMeshFile(dircase+'/maill.01.med')
- Iter_1.SetFieldFile(data_dir+'/tutorial_3.00.med')
- Iter_1.SetTimeStepRank( 1, 1)
- Iter_1.AssociateHypo('Hypo_0vers1')
- codret = Iter_1.Compute(1, 2)
- #
- # Iteration "Iter_2"
- # ==================
- Iter_2 = Iter_1.NextIteration('Iter_2')
- Iter_2.SetMeshName('H_2')
- Iter_2.SetMeshFile(dircase+'/maill.02.med')
- Iter_2.SetFieldFile(data_dir+'/tutorial_3.01.med')
- Iter_2.SetTimeStepRank(1, 1)
- Iter_2.AssociateHypo('Hypo_1vers2')
- codret = Iter_2.Compute(1, 2)
- #
- # Iteration "Iter_2_bis"
- # ======================
- Iter_2_bis = Iter_1.NextIteration('Iter_2_bis')
- Iter_2_bis.SetMeshName('H_2_bis')
- Iter_2_bis.SetMeshFile(dircase+'/maill.02.bis.med')
- Iter_2_bis.SetFieldFile(data_dir+'/tutorial_3.01.med')
- Iter_2_bis.SetTimeStepRank(1, 1)
- Iter_2_bis.AssociateHypo('Hypo_1vers2_bis')
- codret = Iter_2_bis.Compute(1, 2)
+
+.. literalinclude:: files/tutorial_3.py
+ :lines: 53-128
.. 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. On commence par raffiner les faces internes aux tuyaux ; ensuite, on raffine deux fois de suite les faces externes aux tuyaux.
Le schéma YACS réalisant cette adaptation est téléchargeable.
-::
-
- #
- # Creation of the boundaries
- # ==========================
- Boundary_1 = homard.CreateBoundaryDi('intersection', 'PIQUAGE', data_dir+'/tutorial_4.fr.med')
- #
- Boundary_2 = homard.CreateBoundaryCylinder('cyl_1_ext', 0.0, 25., -25., 25., 50., 75., 100.)
- #
- Boundary_3 = homard.CreateBoundaryCylinder('cyl_2_ext', 17.5, -2.5, -12.5, -100., -75., -25., 50.)
- #
- Boundary_4 = homard.CreateBoundaryCylinder('cyl_1_int', 0.0, 25., -25., 25., 50., 75., 75.)
- #
- 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_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_I')
- Hypo_2.AddGroup('T1_EXT_O')
- Hypo_2.AddGroup('T2_EXT')
- #
- # Case "Case"
- # =============
- Case = homard.CreateCase('Case', 'PIQUAGE', data_dir+'/tutorial_4.00.med')
- Case.SetDirName(dircase)
- Case.AddBoundaryGroup( 'intersection', '' )
- 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_I' )
- Case.AddBoundaryGroup( 'cyl_1_int', 'T1_INT_O' )
- Case.AddBoundaryGroup( 'cyl_2_int', 'T2_INT' )
- #
- # Creation of the iterations
- # ==========================
- # Creation of the iteration Iter_1 : raffinement selon les faces internes
- Iter_1 = Case.NextIteration('Iter_1')
- Iter_1.SetMeshName('PIQUAGE_1')
- Iter_1.SetMeshFile(dircase+'/maill.01.med')
- Iter_1.AssociateHypo('Hypo_1')
- codret = Iter_1.Compute(1, 2)
- # Creation of the iteration Iter_2 : raffinement selon les faces externes
- Iter_2 = Iter_1.NextIteration('Iter_2')
- Iter_2.SetMeshName('PIQUAGE_2')
- Iter_2.SetMeshFile(dircase+'/maill.02.med')
- Iter_2.AssociateHypo('Hypo_2')
- codret = Iter_2.Compute(1, 2)
- # Creation of the iteration Iter_3 : second raffinement selon les faces externes
- Iter_3 = Iter_2.NextIteration('Iter_3')
- Iter_3.SetMeshName('PIQUAGE_3')
- Iter_3.SetMeshFile(dircase+'/maill.03.med')
- Iter_3.AssociateHypo('Hypo_2')
- codret = Iter_3.Compute(1, 2)
+
+.. literalinclude:: files/tutorial_4.py
+ :lines: 53-112
.. note::
Téléchargement des fichiers
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.
-::
-
- #
- # Creation of the boundaries
- # ==========================
- # Creation of the discrete boundary Boun_1
- Boun_1 = homard.CreateBoundaryDi('Boun_1', 'MAIL_EXT', data_dir+'/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)
- Hypo_1.AddZone('enveloppe', 1)
- # Creation of the hypothesis Hypo_2
- Hypo_2 = homard.CreateHypothesis('Hypo_2')
- Hypo_2.SetAdapRefinUnRef(0, 1, 0)
- Hypo_2.AddZone('quart_sup', 1)
- #
- # Case "Case_1"
- # =============
- Case_1 = homard.CreateCase('Case_1', 'COEUR_2D', data_dir+'/tutorial_5.00.med')
- Case_1.SetDirName(dircase)
- Case_1.SetConfType(3)
- Case_1.AddBoundaryGroup('Boun_1', '')
- #
- # Iteration "Iter_1"
- # ==================
- Iter_1 = Case_1.NextIteration('Iter_1')
- Iter_1.SetMeshName('COEUR_2D_01')
- Iter_1.SetMeshFile(dircase+'/maill.01.med')
- Iter_1.AssociateHypo('Hypo_1')
- codret = Iter_1.Compute(1, 2)
- #
- # Iteration "Iter_2"
- # ==================
- Iter_2 = Iter_1.NextIteration('Iter_2')
- Iter_2.SetMeshName('COEUR_2D_02')
- Iter_2.SetMeshFile(dircase+'/maill.02.med')
- Iter_2.AssociateHypo('Hypo_2')
- codret = Iter_2.Compute(1, 2)
+
+.. literalinclude:: files/tutorial_5.py
+ :lines: 53-98
.. note::
Téléchargement des fichiers
--- /dev/null
+Examples
+========
+.. index:: single: example
+.. 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 à 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 le répertoire ``dircase`` que seront écrits les fichiers résultant des adaptations successives. Ce répertoire est créé par défaut dans ``/tmp``.
+
+Loading of the module HOMARD
+""""""""""""""""""""""""""""
+.. index:: single: yacs
+
+Le chargement du module HOMARD se fait de manière analogue aux autres modules.
+
+ ::
+
+ import HOMARD
+ homard = salome.lcc.FindOrLoadComponent('FactoryServer','HOMARD')
+ homard.SetCurrentStudy(salome.myStudy)
+
+Pour utiliser le module HOMARD au sein d'un schéma YACS distribué, le chargement se fait ainsi :
+
+ ::
+
+ import HOMARD
+ my_container.load_component_Library('HOMARD')
+ homard = my_container.create_component_instance('HOMARD',0)
+ homard.SetCurrentStudy(salome.myStudy)
+
+Uniform refinement
+""""""""""""""""""
+.. index:: single: refinement;uniform
+
+On fera ici trois raffinements uniformes successifs du maillage contenu dans le fichier ``tutorial_1.00.med``. Quelques remarques :
+ * la même hypothèse est utilisée à chaque itération
+ * 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.
+
+.. literalinclude:: files/tutorial_1.py
+ :lines: 53-86
+
+.. note::
+ Download the files
+
+ * :download:`maillage initial<files/tutorial_1.00.med.gz>`
+ * :download:`commandes python<files/tutorial_1.py>`
+
+
+Refinement by zones
+"""""""""""""""""""
+.. index:: single: zone
+
+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.
+
+.. literalinclude:: files/tutorial_2.py
+ :lines: 53-98
+
+.. note::
+ Download the files
+
+ * :download:`maillage initial<files/tutorial_2.00.med.gz>`
+ * :download:`commandes python<files/tutorial_2.py>`
+
+
+Refinement driven by a field
+""""""""""""""""""""""""""""
+.. index:: single: field
+
+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.
+
+.. literalinclude:: files/tutorial_3.py
+ :lines: 53-128
+
+.. note::
+ Download the files
+
+ * :download:`maillage et champ étape 0<files/tutorial_3.00.med.gz>`
+ * :download:`maillage et champ étape 1<files/tutorial_3.01.med.gz>`
+ * :download:`commandes python<files/tutorial_3.py>`
+
+
+Non plane boundaries
+""""""""""""""""""""
+.. index:: single: field
+.. index:: single: yacs
+
+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.
+Le schéma YACS réalisant cette adaptation est téléchargeable.
+
+.. literalinclude:: files/tutorial_4.py
+ :lines: 53-112
+
+.. note::
+ Download the files
+
+ * :download:`maillage initial<files/tutorial_4.00.med.gz>`
+ * :download:`maillage de la frontière discrète<files/tutorial_4.fr.med.gz>`
+ * :download:`commandes python<files/tutorial_4.py>`
+ * :download:`schéma YACS<files/tutorial_4.xml>`
+
+
+Specific instructions for a 2D mesh
+"""""""""""""""""""""""""""""""""""
+.. 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.
+
+.. literalinclude:: files/tutorial_5.py
+ :lines: 53-98
+
+.. note::
+ Download the files
+
+ * :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
long Compute (in string IterName, in long CleanOption, in long modeHOMARD, in long Option1, in long Option2)
raises (SALOME::SALOME_Exception);
- boolean VerifieDir (in string IterName) raises (SALOME::SALOME_Exception);
+//
+ string CreateDirNameIter(in string NomDir, in long option )
+ raises (SALOME::SALOME_Exception);
+ boolean VerifieDir (in string IterName) raises (SALOME::SALOME_Exception);
+
+//
void PublishFileUnderIteration(in string IterName, in string FileName, in string Comment)
raises (SALOME::SALOME_Exception);
void PublishBoundaryUnderCase(in string CaseName, in string BoundaryName);
cylinderpointvector.png \
cylinderpointvector_2.png \
delete.png \
+ drapeau_en.gif \
+ drapeau_fr.gif \
disk.png \
disk_2.png \
diskwithhole.png \
See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-->
-
+
<document>
<section name="HOMARD">
<!-- Major module parameters -->
<parameter name="icon" value="HOMARD.png"/>
<parameter name="version" value="@VERSION@"/>
<parameter name="documentation" value="homard_help"/>
+ <!-- Other module preferences -->
+<!-- <parameter name="use_precision" value="false" /> -->
+ <!-- Input field precisions -->
+<!-- <parameter name="def_precision" value="3" /> -->
</section>
<section name="homard_help" >
<parameter name="sub_menu" value="%1 module"/>
- <parameter name="User's Guide" value="%HOMARD_ROOT_DIR%/share/doc/salome/gui/HOMARD/index.html"/>
+ <parameter name="Mode d'emploi" value="%HOMARD_ROOT_DIR%/share/doc/salome/gui/HOMARD/index.html"/>
+ <parameter name="User's Guide" value="%HOMARD_ROOT_DIR%/share/doc/salome/gui/HOMARD/index_en.html"/>
</section>
<section name="resources">
<!-- Module resources -->
MESSAGE("SetDirName, NomDir : "<<NomDir);
MESSAGE("SetDirName, _NomDir : "<<_NomDir);
int erreur = 0 ;
- // On vérifie qu'aucun calcul n'a eu lieu
+ // On vérifie qu'aucun calcul n'a eu lieu pour ce cas
MESSAGE("SetDirName, _ListIter.size() : "<<_ListIter.size());
if ( _ListIter.size() > 1 ) { erreur = 1 ; }
// Creation
#include "utilities.h"
#include <vector>
+#include <sys/stat.h>
//=============================================================================
/*!
{
ASSERT( myHomardCas );
int codret ;
- // A. Changement/creation du repertoire
+ // A. recuperation du nom ; on ne fait rien si c'est le meme
char* oldrep = GetDirName() ;
+ MESSAGE ( "SetDirName : passage de oldrep = "<< oldrep << " a NomDir = "<<NomDir);
+ if ( oldrep == NomDir ) { return ; }
+ // B. Changement/creation du repertoire
codret = myHomardCas->SetDirName( NomDir );
if ( codret != 0 )
{
es.text = CORBA::string_dup(text.c_str());
throw SALOME::SALOME_Exception(es);
}
- // B. En cas de reprise, deplacement du point de depart
+ // C. En cas de reprise, deplacement du point de depart
if ( GetState() != 0 )
{
MESSAGE ( "etat : " << GetState() ) ;
- char* Iter0Name = GetIter0Name() ;
- HOMARD::HOMARD_Iteration_ptr Iter = _gen_i->GetIteration(Iter0Name) ;
+ // C.1. Nom local du repertoire de l'iteration de depart dans le repertoire actuel du cas
+ HOMARD::HOMARD_Iteration_ptr Iter = GetIter0() ;
char* DirNameIter = Iter->GetDirNameLoc() ;
- std::string commande = "mv " + std::string(oldrep) + "/" + std::string(DirNameIter) + " " + std::string(NomDir) ;
+ MESSAGE ( "SetDirName : nom actuel pour le repertoire de l iteration, DirNameIter = "<< DirNameIter);
+ // C.2. Recherche d'un nom local pour l'iteration de depart dans le futur repertoire du cas
+ char* nomDirIter = _gen_i->CreateDirNameIter(NomDir, 0 );
+ MESSAGE ( "SetDirName : nom futur pour le repertoire de l iteration, nomDirIter = "<< nomDirIter);
+ // C.3. Creation du futur repertoire local pour l'iteration de depart
+ std::string nomDirIterTotal ;
+ nomDirIterTotal = std::string(NomDir) + "/" + std::string(nomDirIter) ;
+ if (mkdir(nomDirIterTotal.c_str(), S_IRWXU|S_IRGRP|S_IXGRP) != 0)
+ {
+ MESSAGE ( "nomDirIterTotal : " << nomDirIterTotal ) ;
+ SALOME::ExceptionStruct es;
+ es.type = SALOME::BAD_PARAM;
+ std::string text = "The directory for the starting iteration cannot be created." ;
+ es.text = CORBA::string_dup(text.c_str());
+ throw SALOME::SALOME_Exception(es);
+ }
+ // C.4. Deplacement du contenu du repertoire
+ std::string oldnomDirIterTotal ;
+ oldnomDirIterTotal = std::string(oldrep) + "/" + std::string(DirNameIter) ;
+ std::string commande = "mv " + std::string(oldnomDirIterTotal) + "/*" + " " + std::string(nomDirIterTotal) ;
codret = system(commande.c_str()) ;
if ( codret != 0 )
{
es.text = CORBA::string_dup(text.c_str());
throw SALOME::SALOME_Exception(es);
}
+ commande = "rm -rf " + std::string(oldnomDirIterTotal) ;
+ codret = system(commande.c_str()) ;
+ if ( codret != 0 )
+ {
+ SALOME::ExceptionStruct es;
+ es.type = SALOME::BAD_PARAM;
+ std::string text = "The starting point for the case cannot be deleted." ;
+ es.text = CORBA::string_dup(text.c_str());
+ throw SALOME::SALOME_Exception(es);
+ }
+ // C.5. Memorisation du nom du repertoire de l'iteration
+ Iter->SetDirNameLoc(nomDirIter) ;
}
return ;
}
