.. _demarrage_rapide:
Quick start
-===========
+###########
.. index:: single: start
.. index:: single: example
.. _gui_divers:
Miscellaneous
-=============
+#############
References
-""""""""""
+**********
.. index:: single: reference
The HOMARD software was subject of publications techniques in the course of conferences these last years. References of main documents are presented here.
Main reference
-^^^^^^^^^^^^^^
+==============
For a reference to HOMARD, use:
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
`Available here <http://dx.doi.org/10.1016/j.finel.2012.11.008>`_
Splitting meshing
-^^^^^^^^^^^^^^^^^
+=================
* G. Nicolas, T. Fouquet, Conformal hexaedral meshes and adaptive mesh refinement, VI International Conference on Adaptive Modeling and Siumulation, "*ADMOS 2013*", J.P. Moitinho de Almeida, P. Diez, C. Tiago and N. Pares (Eds), Lisbonne, pp. 515-526, 2013
* G. Nicolas, T. Fouquet, Hexaedral mesh adaptation for finite volume methods, III International Conference on Adaptive Modeling and Siumulation, "*ADMOS 2007*", K. Runesson, P. Diez (Eds), Goteborg, pp. 174-177, 2007
* G. Nicolas, F. Arnoux-Guisse, O. Bonnin, Un logiciel d'adaptation de maillage en 2D et 3D, 27ème Congrès d'Analyse Numérique, Super-Besse, France, May 29-June 2, 1995.
Error estimators
-^^^^^^^^^^^^^^^^
+================
* A. Ern, S. Meunier, A posteriori error analysis of Euler-Galerkin approximations to coupled elliptic-parabolic problems", ESAIM: M2AN 43 (2009) 353-375.
* J. Delmas, Stratégies de controle d'erreur en calcul de structures industrielles., PhD of the Université de Picardie, France, April 2008
* O. Bonnin, B. Métivet, G. Nicolas, F. Arnoux-Guisse, L. Léal de Sousa, Adaptive Meshing for N3S Fluid Mechanics Code, "*Computational Fluid Dynamics '94*", ECCOMAS Stuttgart, Allemagne, pp. 201-208, Wiley 1994.
Applications
-^^^^^^^^^^^^
+============
+
* S. Meunier, R. Fernandes, Mesh Adaptation for Coupled Hydro-Mechanical Industrial Studies, V International Conference on Adaptive Modeling and Siumulation, "*ADMOS 2011*", D. Aubry, P. Diez, B. Tie and N. Pares (Eds), Paris, pp. 337-338, 2011
* O. Hartmann, O. Bonnin, D. Gasser, An Adaptive Meshing for Turbomachinery Geometries, "*Computational Fluid Dynamics '98*", ECCOMAS Athènes, Greece, Wiley 1998.
Evolutions of the module
-""""""""""""""""""""""""
+************************
.. index:: single: evolution
Here are the main evolutions de HOMARD from the first release in SALOME 6.5.
.. _glossaire:
Glossary
-========
+########
.. glossary::
:sorted:
.. _gui_create_boundary:
The boundary
-============
+############
.. index:: single: boundary
.. index:: single: frontière
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.
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
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.
: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.
: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.
.. 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`
.. _gui_create_case:
The creation of a case
-======================
+######################
.. index:: single: case
The definition of a case is done with the following data:
Name of the case
-""""""""""""""""
+****************
A name is automatically suggested for the case: Case_1, Case_2, etc. This name can be modified. It must be a new name.
The directory
-"""""""""""""
+*************
The directory will countain all the files producted by the successive adaptations. By default, nothing is suggested. The choice is made either by giving a name into the text zone or by a selection through the search window. In this directory, the MED files for the adapted mesh will be stored, with name ``maill.xx.med``, where ``xx`` is a rank number automatically created. These files can be seen into the object browser.
.. image:: images/create_case_2.png
.. index:: single: MED
The initial mesh
-""""""""""""""""
+****************
The initial mesh must be stored into a MED file. Usually, it is produced by the software that solves the physical problem. But it also can be created by the module SMESH and exported with the MED format. The name of the file is choosen either by giving a name into the text zone or by a selection through the search window.
.. index:: single: conformity
Type of conformity
-""""""""""""""""""
+******************
The future iterations for this case must respect the the same behaviour regarding the type of conformity.
The default option, 'conformal', implies that the meshes produced by HOMARD will be conformal, as expected in the finite element method. This is a classical choice for most of the simulation software with the finite element method.
.. index:: single: boundary
The boundaries
-""""""""""""""
+**************
If the limit of the domain is curved, HOMARD can put the new nodes onto these curved limits to avoid some artificial singularities. This technique is effective for external limits as well for internal limits.
Two situations:
.. 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 :
The pursuit of a case
-=====================
+*********************
.. index:: single: pursuit
.. index:: single: yacs
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
Corresponding python functions
-""""""""""""""""""""""""""""""
+******************************
Look :ref:`tui_create_case`
.. _gui_create_hypothese:
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.
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`). Le nom du fichier qui a été sélectionné est affiché sans modification possible ici :
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`) :
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.
Interpolation of fields
-"""""""""""""""""""""""
+***********************
.. index:: single: interpolation
.. note::
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.
: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.
Corresponding python functions
-""""""""""""""""""""""""""""""
+******************************
Look :ref:`tui_create_hypothese`
.. _gui_create_iteration:
The iteration
-=============
+#############
.. index:: single: iteration
La définition d'une iteration se fait par la donnée des informations suivantes :
: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.
.. 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`) :
.. 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
Corresponding python functions
-""""""""""""""""""""""""""""""
+******************************
Look :ref:`tui_create_iteration`
.. _gui_create_zone:
The zone
-========
+########
.. index:: single: zone
.. index:: single: 2D
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.
: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.
: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.
:align: center
Sphere
-""""""
+******
.. index:: single: sphere
La sphère est définie par son centre et son rayon.
: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.
: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.
: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.
Corresponding python functions
-""""""""""""""""""""""""""""""
+******************************
Look :ref:`tui_create_zone`
.. _gui_homard:
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
.. 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 :
: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
"*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`
.. _gui_mesh_info:
Mesh analysis
-=============
+#############
.. index:: single: analysis
.. index:: single: information
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
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
.. 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
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
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
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 :
Corresponding python functions
-""""""""""""""""""""""""""""""
+******************************
Look :ref:`tui_create_case` and :ref:`tui_create_iteration`
.. _gui_usage:
User's guide of the graphical interface
-=======================================
+#######################################
.. index:: single: case
.. index:: single: iteration
Activation of the module HOMARD
-"""""""""""""""""""""""""""""""
+*******************************
Two ways can be used to launch the module HOMARD:
#. by activating the tab HOMARD into the list of the modules
:align: center
Definition of an adaptation
-"""""""""""""""""""""""""""
+***************************
Once the activation of the module HOMARD is done, a case is created. The initial mesh of the series of adapted meshes is selected (see :ref:`gui_create_case`). From this case, the successives iterations are defined (see :ref:`gui_create_iteration`) with hypotheses (see :ref:`gui_create_hypothese`). The adaptations are launched as described in :ref:`gui_homard`.
User's guide of the graphical interface
-"""""""""""""""""""""""""""""""""""""""
+***************************************
.. toctree::
:maxdepth: 2
.. |flag| image:: ./images/drapeau_en.gif
Documentation of the component HOMARD |logo|
---------------------------------------------
+############################################
The component HOMARD drives the mesh adaptation inside of the SALOME plateform.
User's guide
-""""""""""""
+************
.. toctree::
:maxdepth: 1
tutorials
General presentation
-""""""""""""""""""""
+********************
.. toctree::
:maxdepth: 1
intro
+ regles
applications
divers
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.
The documentation of the module is also covered by the licence and the requirement of quoting.
Index and tables
-""""""""""""""""
+****************
* :ref:`genindex`
* :ref:`modindex`
.. _gui_intro:
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.
- 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.
+
+
+Broadly speaking, an iteration for meshing adaptation is as shown on the figure below. The finite element software calculates the numerical solution on meshing Mk, then, from that, deduces the values for the error indicator over the whole meshing. Based on the knowledge of meshing #k and indicator #k, HOMARD generates a new meshing #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.
+The complete chain starts from the initial meshing, then incorporates successive links (calculation of indicator / adaptation).
.. 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.
+Some variations may exist. If no error indicator is available, another filed can be used to drive the adaptation. A stress field in mechanics can be used: the refinement of the elements where the stress is high is often efficient to improve the quality of the results. It is also possible to drive the adaptation according the variation of a filed from one element to its neighbours. The refinement can be filtered by zones or groups of elements.
.. note::
For a extensive description of HOMARD, see :download:`Description générale de HOMARD <../files/HOMARD_0.pdf>`.
`Available here <http://dx.doi.org/10.1016/j.finel.2012.11.008>`_
+Methods for splitting the elements
+**********************************
+.. index:: single: splitting
+.. index:: single: conformity
+
+All in all, the process of meshing adaptation by splitting element is a two-tier process. First, all element specified by the error indicator are split. The resulting meshing is uncorrect : nodes are pending at the junction between areas to be refined, and an area to be retained. The second stage aims at solving all of these conformity problems.
+
+There are different splitting methods for the two phases. During the first phase, all of the element are split in the same manner ; this is the so-called standard splitting. During the second phase, some of the meshing conformity conflicts in the junction area are settled by the same standard splitting of element, while others are settled by special splitting.
+
+The various splitting modes have been choosen to preserve the mesh quality, all along the adaptive process.
+
+Standard splitting
+==================
+Standard element splitting is carried out with a view to restricting the number of cases. Thus, edges are split into two equal sections.
+
+To split a triangle, the three edges are split into two sections each, thus producing four similar triangles. They retain the same quality.
+
+.. image:: ../images/dec_tria_1.gif
+ :align: center
+ :alt: Découpage standard d'un triangle
+ :width: 399
+ :height: 88
+
+To split a quadrangle, the four edges are split into two sections each, thus producing four non-similar quadrangles with different quality.
+
+.. image:: ../images/dec_quad_1.png
+ :align: center
+ :alt: Découpage standard d'un quadrangle
+ :width: 399
+
+Tetrahedrons are split in eight. First, each of the triangular faces is split into 4 similar triangular faces.
+
+.. image:: ../images/dec_tetr_1.gif
+ :align: center
+ :alt: Découpage standard d'un tétraèdre - 1
+ :width: 328
+ :height: 115
+
+Face splitting produces four tetrahedrons at the angles of the initial tetrahedron. It should be noted that the four new tetrahedrons are homothetic to the initial tetrahedron. Therefore, they retain the same qualities.
+
+.. image:: ../images/dec_tetr_2.gif
+ :align: center
+ :alt: Découpage standard d'un tétraèdre - 2
+ :width: 201
+ :height: 159
+
+At the core of the tetrahedron, there remains a block shaped like two pyramids joined at their bases. An edge is generated using one of the three possible diagonals, then the four faces containing the edge, and two external edges.
+
+.. image:: ../images/dec_tetr_3.gif
+ :align: center
+ :alt: Découpage standard d'un tétraèdre - 3
+ :width: 244
+ :height: 74
+
+This, in turn, creates 4 new tetrahedrons. It should be noted that they are similar two by two but that they can never be similar to the initial tetrahedron. They can therefore never have the same quality as the initial tetrahedron. However, different results are obtained, depending on the diagonal selected for splitting the internal pyramidal block. Where quality is concerned, it is always best to select the smallest of the three possible diagonals.
+
+.. image:: ../images/dec_tetr_4.gif
+ :align: center
+ :alt: Découpage standard d'un tétraèdre - 4
+ :width: 229
+ :height: 116
+
+Hexaedrons are split in eight. Each of the quadrangular faces is split into 4 quadrangular faces. Edges are created connecting each centre of opposite faces. This generates a new point located at the centre of the hexaedron.
+
+.. image:: ../images/dec_hex.png
+ :align: center
+ :alt: Découpage standard d'un hexaèdre
+ :scale: 70
+
+Pentaedrons are split in eight. Each of the quadrangular faces is split into 4 quadrangular faces and the two triangles are split into 4. Edges are created connecting each centre of quadrangular faces. Those 3 edges create 4 triangles at the centre of the pentaedron. Six quandrangular faces are created to complete the construction of the height pentaedrons.
+
+.. image:: ../images/dec.pent.png
+ :align: center
+ :alt: Découpage standard d'un pentaèdre
+ :scale: 20
+
+Splitting for the conformity
+============================
+
+Splitting for conformity is applicable to the elements at the interface between two different levels of refinement. Such splitting may produce element of lower quality compared to the initial element, and in the general algorithm, one sees how this drawback is reckoned with to reduce its consequences.
+
+For triangles, one of the three edges is split in two. Its middle is joined to the opposite vertex to form two additional triangles.
+
+.. image:: ../images/dec_tria_2.gif
+ :align: center
+ :alt: Découpage de conformité d'un triangle
+ :width: 399
+ :height: 88
+
+For quadrangles, one of the four edges is split in two. Its middle is joined to the opposite vertex to form three triangles. The mesh obtained is then mixed.
+
+.. image:: ../images/dec_quad_2.png
+ :align: center
+ :alt: Découpage de conformité d'un quadrangle
+ :width: 399
+
+For a tetrahedron with three split edges, this is possible only if the edges are concurrent. Therefore, one of the four faces is split in four. The middles of the split edges are joined to the opposite vertexes. The three other faces are thus split in two, and four tetrahedrons are created.
+
+.. image:: ../images/dec_tetr_5.gif
+ :align: center
+ :alt: Découpage de conformité d'un tétraèdre - 1
+ :width: 116
+ :height: 116
+
+For a tetrahedron with two split edges, this is possible only if the edges are opposite. All the middles of these edges are joined to the other apexes, as well as the edge middles. The four faces are split in two, and four tetrahedrons are created.
+
+.. image:: ../images/dec_tetr_6.gif
+ :align: center
+ :alt: Découpage de conformité d'un tétraèdre - 2
+ :width: 116
+ :height: 116
+
+For a tetrahedron with one split edge, the middle of the split edge is joined to the opposite apex, and two tetrahedrons are created.
+
+.. image:: ../images/dec_tetr_6.gif
+ :align: center
+ :alt: Découpage de conformité d'un tétraèdre - 3
+ :width: 116
+ :height: 116
+
+The conformal strategy for the hexaedrons is based on tetraedrons and pyramids. The situation depends on the number of non conformities.
+
+For an hexaedron with one face cut, we create 4 edges, 4 tetraedrons and 5 pyramids.
+
+.. image:: ../images/hexaface.png
+ :align: center
+ :alt: Découpage de conformité d'un hexaèdre - 1 face
+ :width: 384
+ :height: 101
+
+For an hexaedron with only one edge cut, we create deux internal edges and four pyramids.
+
+.. image:: ../images/hexa1arete.png
+ :align: center
+ :alt: Découpage de conformité d'un hexaèdre - 1 arête
+ :width: 384
+ :height: 101
+
+For an hexaedron with two edges cut, we create one central point 10 edges, 12 tetraedrons and 2 pyramids.
+
+.. image:: ../images/hexa2aretes.png
+ :align: center
+ :alt: Découpage de conformité d'un hexaèdre - 2 arêtes
+ :width: 384
+ :height: 101
+
+For an hexaedron with three edges cut, we create one central point, 11 edges and 18 tetraedrons.
+
+.. image:: ../images/hexa3aretes.png
+ :align: center
+ :alt: Découpage de conformité d'un hexaèdre - 3 arêtes
+ :width: 384
+ :height: 101
+
+
+
+Algorithm
+*********
+.. index:: single: algorithm
+
+The strategy adopted for the algorithm in HOMARD consists in forcing splitting in four for all faces with two hanging nodes. Eventually, only the faces with non conformity points are faces where one and only edge is split. The simplest possible solution is thus used for conformity as seen before. The latter stage of conformity introduces element of modified quality compared to that of the element it originated from. This drawback remains under control as we have chosen to grant a temporary status to the conformity element: they exist to produce a meshing acceptable by the calculation softwares, but they disappear if they are required to be further split. As a consequence, quality loss does not propagate along iterations of meshing adaptation, and remains restricted in value as well as in number of element concerned.
+
+The algorithm is:
+
+ * Transfer of refining or coarsening indications over element into decisions to split or group edges, triangles and quadrangles.
+ * Removal of temporary compliance element.
+ * By considering all triangles and quadrangles from the lowest splitting level to the highest splitting level, conflict solving on coarsening using the basic rules.
+ * By considering all triangles and quadrangles from the lowest splitting level to the highest splitting level, conflict solving on refining using the basic rules.
+ * Effective generation of new meshing : standard splitting, compliance tracking.
+
Some illustrations of adapted meshes
-""""""""""""""""""""""""""""""""""""
+************************************
.. index:: single: illustration
+Some examples of use case can be found into :ref:`applications` .
+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
| |
--- /dev/null
+.. _rules:
+
+Rules
+#####
+
+Whatever method of use is selected, general rules are to be complied with in setting up the data.
+
+The initial mesh
+*******************
+.. index:: single: mesh;initial
+
+Mesh includes nodes, point-meshes, segments, triangles, quadrangles, tetrahedrons, hexahedrons and/or prisms. It may be of degree 1 or 2. It may be made up of several pieces.
+Meshes mixing volume meshed areas and surface meshed areas can definitely be processed. These areas may be adjacent or not.
+During the refining process there is no mesh adjustment. Therefore, the initial mesh should be as smooth as possible. Poor initial mesh would result in poor split meshes. Conversely, the initial mesh may be coarse. It merely needs to comply with the minimum initial conditions.
+Lastly, it would be desirable to have - from the very onset - proper representation of any curving borders. As border element splitting is carried out based on border approximation by the initial mesh, fine tracking of marked curves may not occur systematically. To remedy this, a specific module for 2D-border tracking is available.
+
+Boundary conditions on limits and sources
+*****************************************
+.. index:: single: conditions on limits
+.. index:: single: boundary conditions
+
+Defining where boundary conditions or source operands are enforced has to be carried out on entities of dimensions similar to that of the phenomenon being represented. In other words, a one-off loading should be defined on a node. For 2D calculation, the definition of behaviors on the boundary is obtained through boundary edge characterizations rather than through boundary nodes. Also, in 3D, the behaviors on the outer walls of the area to be modeled are based on the triangles or the quadrangles making up the boundary. In so doing, one is sure to properly propagate the definitions as mesh is refined.
+
+One should absolutely not use definitions of boundary conditions by nodes for this would make it impossible to properly represent the borders after adaptation. This is demonstrated in the example below.
+
+.. image:: ../images/cl_0.gif
+ :align: center
+ :width: 201
+ :height: 110
+
+A case of fluid mechanics is to be modeled here, where a flow enters then exits a cavity. This is a 2D model, and boundary conditions are defined classically, through node characterization. On the zoom drawn below, red nodes are for walls and blue nodes for inlet, while black nodes are for free nodes.
+
+.. image:: ../images/cl_1.gif
+ :align: center
+ :width: 372
+ :height: 119
+
+If the element needs to be split around the inlet area, new nodes are generated. The problem here is to find out to which category a new node located between a wall node or an inlet node belongs to. If -- left-hand side case -- the wall gets priority, everything is fine. Conversely, if -- right-hand side case -- it is the inlet that gets priority, there is a problem: this results in artificially expanding the inlet, therefore distorting the calculation!
+
+.. image:: ../images/cl_2.gif
+ :align: left
+ :width: 244
+ :height: 129
+
+
+.. image:: ../images/cl_3.gif
+ :align: right
+ :width: 244
+ :height: 128
+
+The management of priorities between data soon becomes impossible : exclusive conventions for all HOMARD-related calculation softwares would have to be set up, while dealing with a combination of many possibilities. Moreover, in 3D, this technique for managing priorities leads to a deadlock. Try and imagine updating characterizations for nodes resulting from the splitting of tetrahedrons in the angle of the domain. Very quickly, it becomes impossible to choose between blue, red and green.
+
+.. image:: ../images/cl_4.gif
+ :align: center
+ :width: 470
+ :height: 201
+
+The only viable solution consists in defining boundary conditions on boundary elements. Going back to our 2D example for fluid mechanics, the wall or inclet characteristics are assigned to the boundary edges. In the calculation software, the program can very easily transfer information on edges towards border summits.
+
+.. image:: ../images/cl_5.gif
+ :align: center
+ :width: 372
+ :height: 119
+
+If the mesh refinement is carried out as previously, the new edges take on the same characterization as those out of which they arise : one split wall edge results in two wall edges, and one split inlet edge results in two inlet edges. Consequently, the calculation software has no difficulty setting up the right data on border nodes.
+
+.. image:: ../images/cl_6.gif
+ :align: center
+ :width: 244
+ :height: 129
+
+The strategy for the adaptation
+*******************************
+
+There is a choice between several types of refinement and unrefinement :
+
+ * by filtering error indications through a given threshold : all of the elements involving an error superior to the high threshold are split and all of those involving an error lower than the low threshold are unrefined. Then, splitting occurs again until mesh does not contain hanging nodes.
+ * by filtering error indications through thresholds that depends on the error : all of the elements involving an error superior to the mean of the error with a shift are split. Then, splitting occurs again until mesh does not contain hanging nodes.
+ * by filtering with percentage of elements. The x% of the elements with the highest error are split and the y% with the lowest errors are unrefined.
+ * by only using the refinement process, filtering with an high threshold.
+ * vice versa by only using the unrefinement process, filtering with a low threshold.
+ * uniform; no error indicator is taken into account, and mesh is entirely split : every triangle is split into 4 sections, every quadrangle is split into 4 sections, every tetrahedron is split into 8 sections, every prism is split into 8 sections, and every hexahedron is split into 8 sections. Beware! The resulting mesh volume may be huge.
+
+The error indicator
+*******************
+.. index:: single: error indicator
+
+Most of the time, the error indicator is a real-value field defined by element. It is one of the results of the calculation software. The selection of the elements to be split is carried out by comparing the value of the indicator to a given threshold.
+HOMARD accommodates two extensions to this standard: an error indicator expressed on node and/or error indicator under integer form. Whenever the indicator is provided over a node, HOMARD assigns the highest error value encountered on the element nodes to each element. Whenever the indicator is under integer form, the convention is that 1 is for refinement requests and 0 for no action.
+There is no requirement to provide a value for each and every element: if no value is assigned to an element, HOMARD treats this element according to the preferences of the case.
+
+The interpolation of the fields
+*******************************
+.. index:: single: interpolation
+.. index:: single: field
+
+HOMARD is able to update fields which are expressed over the mesh. Two cases are available :
+
+ * If the field is expressed by nodes, HOMARD will produce a new field by node, following this method. When a node is active in both meshes, before and after adaptation, the field value is kept. If the node is new, the value of the field is obtained interpolating the field from its values over neighbours, according to the mesh degree.
+ * If the field is expressed as a constant by element, HOMARD will produce a new field by element, following this method. When the element is active in both meshes, before and after adaptation, the field value is kept. If the element is produced by element cutting, the field value is the one of the parent element. If the element is produced by mesh coarsening, the field value is the mean value over the previous child element.
+
+These updating techniques are based on scalar fields. If a vector field is transmitted to HOMARD through the MED files, each component is considered as a independent scalar field. Then, the new vector field is built, gathering all the new scalar components.
+
+
+
+
+
.. _tui_create_boundary:
The boundary
-============
+############
.. index:: single: boundary
.. index:: single: cylinder
The variables are described in :ref:`gui_create_boundary`.
Methods of the class homard
-"""""""""""""""""""""""""""
+***************************
These methods returns an instance of the class boundary.
+----------------------------------------------------------------------------------------+
+---------------------------------------------------------------+
Methods of the class cas
-"""""""""""""""""""""""""
+************************
See also in :ref:`tui_create_case`.
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Methods of the class boundary
-""""""""""""""""""""""""""""""
+*****************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Example
-"""""""
+*******
Creation of a discrete boundary, a spherical boundary, and a cylindrical boundary:
::
Similar graphical input
-"""""""""""""""""""""""
+***********************
Look at :ref:`gui_create_boundary`
.. _tui_create_case:
The case
-========
+########
.. index:: single: cas
.. index:: single: type of conformity
.. index:: single: mesh;initial
The variables are described in :ref:`gui_create_case`.
Methods of the class homard
-""""""""""""""""""""""""""""
+***************************
Creation of a case
-^^^^^^^^^^^^^^^^^^
+==================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Creation of a case by pursuit of a computed iteration
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+=====================================================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Methods of the class cas
-""""""""""""""""""""""""
+************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Advanced options
-^^^^^^^^^^^^^^^^
+****************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Informations for the initial mesh
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+*********************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Example
-"""""""
+*******
The creation of the object case_1 is done as follows:
::
Similar graphical input
-"""""""""""""""""""""""
+***********************
Look at :ref:`gui_create_case`
.. _tui_create_hypothese:
The hypothesis
-==============
+##############
.. index:: single: iteration
.. index:: single: hypothesis
The variables are described in :ref:`gui_create_hypothese`.
Methods of the class homard
-""""""""""""""""""""""""""""
+***************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Methods of the class hypothese
-"""""""""""""""""""""""""""""""
+******************************
General methods
-^^^^^^^^^^^^^^^
+===============
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
The field and the thresholds
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+============================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
The components of the field
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
+===========================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
The zones
-^^^^^^^^^
+=========
+---------------------------------------------------------------+
+---------------------------------------------------------------+
The filtering by the groups
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
+===========================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Advanced options
-^^^^^^^^^^^^^^^^
+================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Example
-"""""""
+*******
The creation of the object hypo_1 is done as follows:
::
Similar graphical input
-"""""""""""""""""""""""
+***********************
Look at :ref:`gui_create_hypothese`
.. warning::
.. _tui_create_iteration:
The iteration
-=============
+#############
.. index:: single: iteration
.. index:: single: hypothesis
The variables are described in :ref:`gui_create_iteration`.
Methods of the class homard
-""""""""""""""""""""""""""""
+***************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Methods of both classes cas and iteration
-"""""""""""""""""""""""""""""""""""""""""
+*****************************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Methods of the class iteration
-""""""""""""""""""""""""""""""
+******************************
General methods
-^^^^^^^^^^^^^^^
+===============
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Information about the meshes
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+============================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Information about the field
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
+===========================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Example
-"""""""
+*******
.. index:: single: mesh;initial
To create the first iteration, the starting point is the iteration associated to the initial mesh. It is the one that defines the case.
Similar graphical input
-"""""""""""""""""""""""
+***********************
Look at :ref:`gui_create_iteration`
.. _tui_create_zone:
The zone
-========
+########
.. index:: single: zone
.. index:: single: box
The variables are described in :ref:`gui_create_zone`.
Methods of the class homard
-""""""""""""""""""""""""""""
+***************************
These methods returns an instance of the class zone.
Methods of the class zone
-"""""""""""""""""""""""""
+*************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Example
-"""""""
+*******
The creation of a 3D box is done as follows:
::
Similar graphical input
-"""""""""""""""""""""""
+***********************
Look at :ref:`gui_create_zone`
.. warning::
.. _tui_homard:
The computation
-===============
+###############
Methods of the class homard
-"""""""""""""""""""""""""""
+***************************
Example
-"""""""
+*******
Corresponding graphical interface
-"""""""""""""""""""""""""""""""""
+*********************************
Look at :ref:`gui_homard`
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::
Examples
-========
+########
.. index:: single: example
.. index:: single: python
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.
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 :
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.
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.
Non plane boundaries
-""""""""""""""""""""
+********************
.. index:: single: field
.. index:: single: yacs
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.
Frontière discrète
-==================
+******************
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.
Frontière analytique
-====================
+********************
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
.. index:: single: arbre d'étude
L'arbre d'étude
-===============
+***************
A l'issue de cette création de frontières, l'arbre d'études a été enrichi. On y trouve toutes les frontières créées, identifiées par leur nom, avec la possibilité de les éditer.
.. image:: images/create_boundary_1.png
Méthodes python correspondantes
-===============================
+*******************************
Consulter : :ref:`tui_create_boundary`
:maxdepth: 1
intro
+ regles
applications
divers
--- /dev/null
+.. _regles:
+
+Règles
+######
+
+Quel que soit le mode d'utilisation retenu, des règles générales sont à suivre dans la constitution des données. Elles sont détaillées ici.
+
+Le maillage initial
+*******************
+.. index:: single: maillage;initial
+
+Le maillage comporte des noeuds, des mailles-points, des segments, des triangles, des quadrangles, des tétraèdres, des hexaèdres et/ou des pentaèdres. Il peut être de degré 1 ou 2. Il peut être en plusieurs morceaux, non connexe.
+On peut tout à fait traiter des maillages qui mêlent des zones maillées en volume, et des zones maillées en surfaces. Ces zones peuvent être adjacentes ou non.
+Au cours du processus de raffinement, il n'y a pas de régularisation du maillage. Il faut donc veiller à ce que le maillage initial soit le plus régulier possible. Un mauvais maillage initial produira de mauvais maillages découpés. En revanche, ce maillage initial peut être grossier. Il suffit qu'il respecte a minima les conditions initiales.
+Enfin, il est souhaitable de posséder dès le départ une bonne représentation des frontières courbes. Le découpage des mailles de bord se faisant sur l'approximation de la frontière par le maillage initial, il n'y aura pas toujours un suivi très fin de courbes accentuées. Néanmoins, pour remédier à cela, un module spécifique de suivi de frontières 1D ou 2D est disponible.
+
+Les conditions aux limites et les sources
+*****************************************
+.. index:: single: conditions aux limites
+
+La définition des endroits où s'appliquent des conditions aux limites ou des termes source doit être faite sur des entités de même dimension que le phénomène représenté. En clair, cela signifie qu'un chargement ponctuel sera défini sur un noeud. Dans un calcul 2D, la définition des comportements sur les bords se fera par des caractérisations des segments de bord et non pas par les noeuds de bords. De même en 3D, les comportements sur les parois externes du domaine à modéliser sont établis sur les triangles ou les quadrangles qui constituent ce bord. En procédant ainsi, on est sûr de propager correctement ces définitions au fil des raffinements de maillage.
+
+Il ne faut surtout pas définir les conditions aux limites par les noeuds, sinon il est impossible de représenter correctement les frontières après adaptation. Cela va être démontré sur l'exemple suivant.
+
+.. image:: ../images/cl_0.gif
+ :align: center
+ :width: 201
+ :height: 110
+
+On veut modéliser ici un cas de mécanique des fluides pour lequel un écoulement entre puis sort d'une cavité. Le modèle est bidimensionnel et, classiquement, on définit les conditions aux limites par des caractérisation des noeuds. Sur le zoom dessiné ci-dessous, on a les noeuds rouges pour la paroi et les noeuds bleus pour l'entrée, les noeuds noirs étant des noeuds libres.
+
+.. image:: ../images/cl_1.gif
+ :align: center
+ :width: 372
+ :height: 119
+
+S'il s'avère que le maillage a besoin de découpage autour de la zone d'entrée, il va y avoir création de nouveaux noeuds. Tout le problème va consister à savoir à quelle catégorie appartient un nouveau noeud situé entre un noeud de paroi ou un noeud d'entrée. Si, comme sur le schéma de gauche, on privilégie la paroi, tout va bien. En revanche si, comme sur le schéma de droite, on privilégie l'entrée, il y a un problème : cela revient à agrandir artificiellement l'entrée ... et donc à fausser le calcul !
+
+.. image:: ../images/cl_2.gif
+ :align: left
+ :width: 244
+ :height: 129
+
+
+.. image:: ../images/cl_3.gif
+ :align: right
+ :width: 244
+ :height: 128
+
+Gérer les priorités entre les informations devient très rapidement impossible : il faudrait établir des conventions uniques pour tous les logiciels de calcul associés à HOMARD et traiter une combinaison importante de possibilités. Qui plus est, en 3D, cette technique de gestion de priorités aboutit à des impasses. Essayez d'imaginer la mise à jour des caractérisations des noeuds issus du découpage des tétraèdres dans l'angle de ce domaine. Très rapidement, il devient impossible de trancher entre le bleu, le rouge ou le vert.
+
+.. image:: ../images/cl_4.gif
+ :align: center
+ :width: 470
+ :height: 201
+
+La seule solution viable consiste à définir les conditions aux limites sur les mailles de bord. Pour reprendre notre exemple 2D en mécanique des fluides, on donne les caractéristiques paroi ou entrée aux arêtes de bord. Dans le logiciel de calcul, le programme saura transférer très facilement des arêtes vers les sommets frontaliers.
+
+.. image:: ../images/cl_5.gif
+ :align: center
+ :width: 372
+ :height: 119
+
+Si le raffinement du maillage a lieu comme précédemment, les nouvelles arêtes prennent la même caractérisation que celles dont elles sont issues : une arête de paroi découpée donne naissance à deux arêtes de paroi et une arête d'entrée découpée donne naissance à deux arêtes d'entrée. De ce fait, le logiciel de calcul n'a aucune difficulté à établir les bonnes informations sur les noeuds frontaliers.
+
+.. image:: ../images/cl_6.gif
+ :align: center
+ :width: 244
+ :height: 129
+
+La stratégie d'adaptation
+*************************
+
+On a le choix entre plusieurs types de raffinement et de déraffinement :
+
+ * en filtrant les indications d'erreur par des seuils prédéfinis : toutes les mailles qui portent une erreur supérieure à un seuil haut sont découpées et toutes celles pour lesquelles l'erreur est inférieure à un seuil bas sont déraffinées. Ensuite, d'autres découpages interviennent jusqu'à ce que le maillage soit conforme.
+ * en filtrant les indications d'erreur par des seuils dépendant de la répartition de l'erreur : toutes les mailles qui portent une erreur supérieure à un décalage par rapport à la moyenne sont raffinées. Ensuite, d'autres découpages interviennent jusqu'à ce que le maillage soit conforme.
+ * en filtrant avec des pourcentages de mailles : on découpe les x% de mailles à la plus forte erreur et on déraffine les y% à la plus faible erreur.
+ * en n'utilisant que la fonction de raffinement, avec filtrage par rapport à un seuil haut.
+ * inversement, en n'utilisant que la fonction de déraffinement, avec filtrage par rapport à un seuil bas.
+ * raffinement uniforme ; on ne tient compte d'aucun indicateur d'erreur et le maillage est découpé intégralement : chaque triangle est découpé en 4, chaque quadrangle est découpé en 4, chaque tétraèdre est découpé en 8, chaque pentaèdre est découpé en 8 et chaque hexaèdre est découpé en 8. Attention, le volume du maillage résultat peut être énorme ...
+
+L'indicateur d'erreur
+*********************
+.. index:: single: indicateur d'erreur
+
+La plupart du temps, l'indicateur d'erreur est un champ de valeurs réelles définis par maille. C'est un des résultats du logiciel de calcul. La sélection des mailles à découper se fait par comparaison de la valeur de l'indicateur et d'un seuil donné.
+Par rapport à ce standard, HOMARD accepte deux extensions : un indicateur d'erreur exprimé par noeud et/ou un indicateur d'erreur sous forme entière. Quand l'indicateur est fourni par noeud, HOMARD attribue à chaque maille la plus grande valeur d'erreur trouvée sur les noeuds de la maille. Quand l'indicateur est sous forme entière, la convention retenue est que 1 correspond à une demande de raffinement, -1 correspond à une demande de déraffinement et 0 correspond à ne rien faire.
+On n'est pas obligé de fournir une valeur sur chaque maille : si des mailles ne sont associées à aucune valeur, HOMARD leur attribuera une décision par défaut selon les préférences retenues.
+
+L'interpolation des champs
+**************************
+.. index:: single: interpolation
+.. index:: single: champ
+
+HOMARD sait mettre à jour des champs exprimés sur le maillage. Deux cas de figure sont possibles :
+
+ * Si le champ se présente sous la forme d'un champ aux noeuds, HOMARD produira un nouveau champ aux noeuds avec la méthode suivante. Pour un noeud présent dans les deux maillages, avant et après adaptation, la valeur du champ est gardée telle quelle. Pour un nouveau noeud, la valeur du champ est obtenue par interpolation P1 ou P2 selon le degré du maillage en fonction des valeurs sur les noeuds les plus proches.
+ * Si le champ se présente sous la forme d'un champ constant par maille, HOMARD produira un nouveau champ constant par maille, avec la méthode suivante. Pour une maille présente dans les deux maillages, avant et après adaptation, la valeur du champ est gardée telle quelle. Pour une maille issue d'un découpage, la valeur du champ est celle du champ sur la maille mère. Pour une maille issue d'un regroupement après déraffinement, la valeur du champ est la moyenne des valeurs du champ sur les anciennes mailles filles.
+
+Ces techniques de mise à jour sont basées sur des champs scalaires. Si un champ vectoriel est transmis à HOMARD par les fichiers MED, chaque composante sera traitée comme un scalaire indépendant. Ensuite, le nouveau vecteur est reconstruit en rassemblant toutes ses composantes.
+
+
+
+
+
