.. index:: single: start
.. index:: single: example
-The options to drive HOMARD in SALOME are described into :ref:`gui_usage`. Here are the basic instructions to discover how to use HOMARD from a very simple example.
+The options to drive HOMARD in SALOME are described into :doc:`gui_usage`. Here are the basic instructions to discover how to use HOMARD from a very simple example.
Let's imagine that a calculation of a thermal problem has been done with a given mesh. An output MED file was produced; it contains the mesh and the field of the temperatures over the nodes. We'd like to adapt the mesh to decrease the variation of the temperature from one node to another below a threshold.
Corresponding python functions
******************************
-Look :ref:`tui_create_boundary`
+Look :doc:`tui_create_boundary`
.. image:: images/create_case_5.png
:align: center
-The definition of the boundaries is described in :ref:`gui_create_boundary`.
+The definition of the boundaries is described in :doc:`gui_create_boundary`.
.. index:: single: pyramid
Corresponding python functions
******************************
-Look :ref:`tui_create_case`
+Look :doc:`tui_create_case`
*********************
.. note::
- To be able to adapt the mesh according to a field it is beforehand necessary to have indicated the file med containing the field. It is made in the window of construction of the iteration (see :ref:`gui_create_iteration`). The name of the file which was selected is shown without possible modification here:
+ To be able to adapt the mesh according to a field it is beforehand necessary to have indicated the file med containing the field. It is made in the window of construction of the iteration (see :doc:`gui_create_iteration`). The name of the file which was selected is shown without possible modification here:
.. image:: images/create_hypothese_ch_1.png
:align: center
********************
.. index:: single: zone
-In the starting up, it is necessary to create a first zone by activation of the button "*New*" (see :ref:`gui_create_zone`) :
+In the starting up, it is necessary to create a first zone by activation of the button "*New*" (see :doc:`gui_create_zone`) :
.. image:: images/create_hypothese_zo_1.png
:align: center
.. index:: single: interpolation
.. note::
- To be able to interpolate a field from the former towards the new mesh, it is beforehand necessary to have indicated the file med containing the field. It is made in the window of construction of the iteration (see :ref:`gui_create_iteration`).
+ To be able to interpolate a field from the former towards the new mesh, it is beforehand necessary to have indicated the file med containing the field. It is made in the window of construction of the iteration (see :doc:`gui_create_iteration`).
By default, no field is interpolated. On the contrary, we can ask for the interpolation of all the present fields in the supplied file:
Corresponding python functions
******************************
-Look :ref:`tui_create_hypothese`
+Look :doc:`tui_create_hypothese`
**************
The iteration in progress will control the adaptation by HOMARD according to a scenario defined on an hypothesis. This one is selected in the list of the existing hypotheses.
-With starting, it is necessary to create a first hypothesis by activation of the button "*New*" (see: :ref:`gui_create_hypothese`) :
+With starting, it is necessary to create a first hypothesis by activation of the button "*New*" (see: :doc:`gui_create_hypothese`) :
.. image:: images/create_iteration_4.png
:align: center
Corresponding python functions
******************************
-Look :ref:`tui_create_iteration`
+Look :doc:`tui_create_iteration`
The object YACS contains every definition that allows the creation of a schema. This schema will drive the alternation of the computation of a physical modelization over a mesh and the adaptation of the mesh for the computation. This alternation is driven by some criteria for the convergence.
.. note::
- To read an exhaustive description of any part of the schema, see :ref:`yacs`
+ To read an exhaustive description of any part of the schema, see :doc:`yacs`
Procedure
*********
The automatic creation of the schema is going to be made in three phases.
- At first, it is necessary to have done a calculation on the very first mesh. This calculation will have produced the results in a MED file.
-- Then, a case is created in the module HOMARD, as described in :ref:`gui_create_case`. In this case, we create the following iteration of the mesh by defining a hypothesis of adaptation ; see :ref:`gui_create_iteration`.
+- Then, a case is created in the module HOMARD, as described in :doc:`gui_create_case`. In this case, we create the following iteration of the mesh by defining a hypothesis of adaptation ; see :doc:`gui_create_iteration`.
- Last, from this case, a schema will be created, based on the hypothesis for the adaptation.
Corresponding python functions
******************************
-Look :ref:`tui_create_yacs`
+Look :doc:`tui_create_yacs`
How to use the schema
#####################
By default, the maximal number of iterations is equal to 5 and the test for the convergence is satisfied if the variable varies less than one per a thousand in a relative value, between two successive iterations. These tests can be modified.
-These tests ares done into the node "Analyse" of the schema, as described in :ref:`yacs`.
+These tests ares done into the node "Analyse" of the schema, as described in :doc:`yacs`.
The maximal number of iterations is given by the variable `NbCalcMax`:
########
.. index:: single: Code_Aster
-A user's guide for schemas with *Code_Aster* is available here: :ref:`gui_create_yacs_aster`.
+A user's guide for schemas with *Code_Aster* is available here: :doc:`gui_create_yacs_aster`.
Corresponding python functions
******************************
-Look :ref:`tui_create_zone`
+Look :doc:`tui_create_zone`
Corresponding python functions
******************************
-Look :ref:`tui_create_iteration`
+Look :doc:`tui_create_iteration`
Corresponding python functions
******************************
-Look :ref:`tui_create_case` and :ref:`tui_create_iteration`
+Look :doc:`tui_create_case` and :doc:`tui_create_iteration`
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 successive 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`.
+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 :doc:`gui_create_case`). From this case, the successive iterations are defined (see :doc:`gui_create_iteration`) with hypotheses (see :doc:`gui_create_hypothese`). The adaptations are launched as described in :doc:`gui_homard`.
User's guide of the graphical interface
.. index:: single: YACS
.. note::
- This alternation (computation/adaptation) suits in the :ref:`yacs` schemes.
+ This alternation (computation/adaptation) suits in the :doc:`yacs` schemes.
Methods for splitting the elements
.. index:: single: cylinder
.. index:: single: sphere
-The variables are described in :ref:`gui_create_boundary`.
+The variables are described in :doc:`gui_create_boundary`.
Methods of the class homard
***************************
Methods of the class cas
************************
-See also in :ref:`tui_create_case`.
+See also in :doc:`tui_create_case`.
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Similar graphical input
***********************
-Look at :ref:`gui_create_boundary`
+Look at :doc:`gui_create_boundary`
.. index:: single: hypothesis
.. index:: single: zone
-The variables are described in :ref:`gui_create_hypothese`.
+The variables are described in :doc:`gui_create_hypothese`.
Methods of the class homard
***************************
+---------------------------------------------------------------+
.. note::
- The file and the time steps for the fiels are defined with the iteration; see :ref:`tui_create_iteration`.
+ The file and the time steps for the fiels are defined with the iteration; see :doc:`tui_create_iteration`.
Advanced options
================
Similar graphical input
***********************
-Look at :ref:`gui_create_hypothese`
+Look at :doc:`gui_create_hypothese`
.. warning::
With the graphical input mode, if an hypothesis is edited and if one of the characteristic is modified, the value of the threshold for the refinement for example, all the iterations that were computed with this hypothesis are unvalidated. In python mode, that is not true: the iterations stay as they are.
.. index:: single: hypothesis
.. index:: single: zone
-The variables are described in :ref:`gui_create_iteration`.
+The variables are described in :doc:`gui_create_iteration`.
Methods of the class homard
***************************
Methods of both classes cas and iteration
****************************************"
-See also in :ref:`tui_create_case`.
+See also in :doc:`tui_create_case`.
+---------------------------------------------------------------+
+---------------------------------------------------------------+
The time steps for the fields to interpolate
--------------------------------------------
-The choice of the fields to interpolated are defined in the hypothesis (see :ref:`tui_create_hypothese`).
+The choice of the fields to interpolated are defined in the hypothesis (see :doc:`tui_create_hypothese`).
For a given field, if nothing is declared, every single time step will be considered.
If some time steps are wanted, they must be defined as follows.
Similar graphical input
***********************
-Look at :ref:`gui_create_iteration`
+Look at :doc:`gui_create_iteration`
.. index:: single: YACS
-The variables are described in :ref:`gui_create_yacs`.
+The variables are described in :doc:`gui_create_yacs`.
Méthodes de la classe cas
*************************
-See also in :ref:`tui_create_case`.
+See also in :doc:`tui_create_case`.
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Similar graphical input
***********************
-Look at :ref:`gui_create_yacs`
+Look at :doc:`gui_create_yacs`
.. index:: single: disk with a hole
.. index:: single: 2D
-The variables are described in :ref:`gui_create_zone`.
+The variables are described in :doc:`gui_create_zone`.
Methods of the class homard
***************************
Similar graphical input
***********************
-Look at :ref:`gui_create_zone`
+Look at :doc:`gui_create_zone`
.. warning::
With the graphical input mode, if a zone is edited and if one of the dimensions is modified, all the iterations that were computed with this zone are unvalidated. In python mode, that is not true: the iterations stay as they are.
Corresponding graphical interface
*********************************
-Look at :ref:`gui_homard`
+Look at :doc:`gui_homard`
####
.. index:: single: YACS
-Using a YACS scheme allows the coupling between a computation and an adaptation as described into :ref:`intro`. This coupling can be repeated inside a loop as long as a criteria for the convergence is reached for instance. Many ways are available to program a YACS scheme. The solution that is shown here is correct but many others are too!
+Using a YACS scheme allows the coupling between a computation and an adaptation as described into :doc:`intro`. This coupling can be repeated inside a loop as long as a criteria for the convergence is reached for instance. Many ways are available to program a YACS scheme. The solution that is shown here is correct but many others are too!
In this part, an extensive description of a schema YACS is available.
.. note::
- The module HOMARD proposes an automatic creation of a schema YASC starting from a defined case. To do that, see :ref:`gui_create_yacs`
+ The module HOMARD proposes an automatic creation of a schema YASC starting from a defined case. To do that, see :doc:`gui_create_yacs`
Introduction
************
.. literalinclude:: ../files/yacs_01.en.xml
:lines: 483-486
-The options of this case must be now given. It is made by the node python CaseOptions. It is imperative to give the directory of calculation. We shall look at the description of the functions in :ref:`tui_create_case`. In output, we get back the instance of the iteration corresponding to the initial state of the case.
+The options of this case must be now given. It is made by the node python CaseOptions. It is imperative to give the directory of calculation. We shall look at the description of the functions in :doc:`tui_create_case`. In output, we get back the instance of the iteration corresponding to the initial state of the case.
.. literalinclude:: ../files/yacs_01.en.xml
:lines: 216-228
.. literalinclude:: ../files/yacs_01.en.xml
:lines: 325-333
-The hypothesis transmitted in input parameter characterized (look :ref:`tui_create_hypothese`) :
+The hypothesis transmitted in input parameter characterized (look :doc:`tui_create_hypothese`) :
.. literalinclude:: ../files/yacs_01.en.xml
:lines: 254-278
.. literalinclude:: ../files/yacs_01.en.xml
:lines: 280-290
-The iteration is supplemented : hypothesis, future mesh, field (look :ref:`tui_create_iteration`) :
+The iteration is supplemented : hypothesis, future mesh, field (look :doc:`tui_create_iteration`) :
.. literalinclude:: ../files/yacs_01.en.xml
:lines: 292-311
For the following passing in the block of adaptation, it is necessary to recover:
-- the last created iteration: service LastIteration (look :ref:`tui_create_iteration`)
-- the created hypothesis: service GetHypothesis (look :ref:`tui_create_hypothese`)
+- the last created iteration: service LastIteration (look :doc:`tui_create_iteration`)
+- the created hypothesis: service GetHypothesis (look :doc:`tui_create_hypothese`)
One passes then in the Homard_Exec node to calculate the new mesh.
.. index:: single: démarrage
.. index:: single: exemple
-L'ensemble des options de pilotage du module HOMARD dans SALOME est décrit dans le :ref:`gui_usage`. Mais on trouvera ici le B.A. BA pour découvrir l'utilisation de HOMARD à partir d'un exemple simple.
+L'ensemble des options de pilotage du module HOMARD dans SALOME est décrit dans le :doc:`gui_usage`. 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.
Méthodes python correspondantes
*******************************
-Consulter : :ref:`tui_create_boundary`
+Consulter : :doc:`tui_create_boundary`
.. image:: images/create_case_5.png
:align: center
-La définition des frontières est décrite dans :ref:`gui_create_boundary`.
+La définition des frontières est décrite dans :doc:`gui_create_boundary`.
.. index:: single: pyramide
Méthodes python correspondantes
*******************************
-Consulter :ref:`tui_create_case`
+Consulter :doc:`tui_create_case`
*************************
.. note::
- Pour pouvoir adapter le maillage selon un champ il faut avoir au préalable désigné le fichier med contenant le champ. Cela se fait dans la fenêtre de construction de l'itération (voir :ref:`gui_create_iteration`). Le nom du fichier qui a été sélectionné est affiché sans modification possible ici :
+ Pour pouvoir adapter le maillage selon un champ il faut avoir au préalable désigné le fichier med contenant le champ. Cela se fait dans la fenêtre de construction de l'itération (voir :doc:`gui_create_iteration`). Le nom du fichier qui a été sélectionné est affiché sans modification possible ici :
.. image:: images/create_hypothese_ch_1.png
:align: center
*************************
.. index:: single: zone
-Au démarrage, il faut créer une première zone par activation du bouton "*Nouveau*" (voir :ref:`gui_create_zone`) :
+Au démarrage, il faut créer une première zone par activation du bouton "*Nouveau*" (voir :doc:`gui_create_zone`) :
.. image:: images/create_hypothese_zo_1.png
:align: center
.. index:: single: interpolation
.. note::
- Pour pouvoir interpoler un champ de l'ancien vers le nouveau maillage, il faut avoir au préalable désigné le fichier med contenant le champ. Cela se fait dans la fenêtre de construction de l'itération (voir :ref:`gui_create_iteration`).
+ Pour pouvoir interpoler un champ de l'ancien vers le nouveau maillage, il faut avoir au préalable désigné le fichier med contenant le champ. Cela se fait dans la fenêtre de construction de l'itération (voir :doc:`gui_create_iteration`).
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 :
Méthodes python correspondantes
*******************************
-Consulter :ref:`tui_create_hypothese`
+Consulter :doc:`tui_create_hypothese`
********************
L'itération en cours pilotera l'adaptation par HOMARD selon un scénario défini dans une hypothèse. Celle-ci est choisie dans la liste des hypothèses existantes.
-Au démarrage, il faut créer une première hypothèse par activation du bouton "*Nouveau*" (voir :ref:`gui_create_hypothese`) :
+Au démarrage, il faut créer une première hypothèse par activation du bouton "*Nouveau*" (voir :doc:`gui_create_hypothese`) :
.. image:: images/create_iteration_4.png
:align: center
Méthodes python correspondantes
*******************************
-Consulter :ref:`tui_create_iteration`
+Consulter :doc:`tui_create_iteration`
L'objet YACS contient toutes les définitions permettant de créer un schéma. Ce schéma va piloter l'alternance d'un calcul représentant une modélisation physique sur un maillage et l'adaptation de ce maillage de calcul. Cette alternance est piloté par des critères de convergence.
.. note::
- Pour avoir une description détaillée de chacune des rubriques formant le schéma, consulter :ref:`yacs`
+ Pour avoir une description détaillée de chacune des rubriques formant le schéma, consulter :doc:`yacs`
Procédure à employer
********************
La création automatique du schéma va se faire en trois phases :
- Au départ, il faut avoir fait un calcul sur un tout premier maillage. Ce calcul aura produit des résultats dans un fichier MED.
-- Ensuite, on crée un cas dans le module HOMARD, tel qu'il est décrit dans :ref:`gui_create_case`. Dans ce cas, on crée une itération suivante du maillage en définissant une hypothèse d'adaptation ; voir :ref:`gui_create_iteration`.
+- Ensuite, on crée un cas dans le module HOMARD, tel qu'il est décrit dans :doc:`gui_create_case`. Dans ce cas, on crée une itération suivante du maillage en définissant une hypothèse d'adaptation ; voir :doc:`gui_create_iteration`.
- Enfin, de ce cas, on va créer le schéma qui se basera sur l'hypothèse d'adapation définie.
Méthodes python correspondantes
*******************************
-Consulter :ref:`tui_create_yacs`
+Consulter :doc:`tui_create_yacs`
Utilisation du schéma
#####################
Par défaut le nombre maximal d'itérations est fixé à 5 et le test de convergence est satisfait si la variable bouge de moins de 1 pour mille en valeur relative entre deux itérations successives. On peut évidemment modifier ces tests.
-Ces tests sont réalisés dans le noeud python "Analyse" du schéma, comme décrit dans :ref:`yacs`.
+Ces tests sont réalisés dans le noeud python "Analyse" du schéma, comme décrit dans :doc:`yacs`.
Le nombre maximal d'itérations est modifiable par la variable `NbCalcMax` :
########
.. index:: single: Code_Aster
-Un mode d'emploi associé à la création de schéma avec *Code_Aster* est disponible en consultant : :ref:`gui_create_yacs_aster`.
+Un mode d'emploi associé à la création de schéma avec *Code_Aster* est disponible en consultant : :doc:`gui_create_yacs_aster`.
Méthodes python correspondantes
*******************************
-Consulter :ref:`tui_create_zone`
+Consulter :doc:`tui_create_zone`
Méthodes python correspondantes
*******************************
-Consulter :ref:`tui_create_iteration`
+Consulter :doc:`tui_create_iteration`
Méthodes python correspondantes
*******************************
-Consulter :ref:`tui_create_case` et :ref:`tui_create_iteration`
+Consulter :doc:`tui_create_case` et :doc:`tui_create_iteration`
Définir une adaptation
**********************
-Une fois que HOMARD a été activé, la permière action consiste à créer un cas. Il s'agit de sélectionner le maillage initial de la suite d'adaptations envisagée (voir :ref:`gui_create_case`). A partir de ce cas, on définira les itérations successives (voir :ref:`gui_create_iteration`) à partir des hypothèses (voir :ref:`gui_create_hypothese`). Les adaptations sont lancées tel que décrit dans :ref:`gui_homard`.
+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 :doc:`gui_create_case`). A partir de ce cas, on définira les itérations successives (voir :doc:`gui_create_iteration`) à partir des hypothèses (voir :doc:`gui_create_hypothese`). Les adaptations sont lancées tel que décrit dans :doc:`gui_homard`.
Mode d'emploi de la saisie des données
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 avoir 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 :ref:`options_avancees` de la création du cas.
+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 :doc:`options_avancees` de la création du cas.
Plusieurs motivations apparaissent pour adapter un maillage :
.. index:: single: YACS
.. note::
- Cet alternance de calculs et d'adaptions est très appropriée à la mise place de schémas :ref:`yacs`.
+ Cet alternance de calculs et d'adaptions est très appropriée à la mise place de schémas :doc:`yacs`.
Mode de découpage des mailles
*****************************
.. index:: single: cylindre
.. index:: single: sphere
-Les variables sont décrites dans :ref:`gui_create_boundary`.
+Les variables sont décrites dans :doc:`gui_create_boundary`.
Méthodes de la classe homard
****************************
Méthodes de la classe cas
*************************
-Voir également dans :ref:`tui_create_case`.
+Voir également dans :doc:`tui_create_case`.
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Saisie graphique correspondante
*******************************
-Consulter :ref:`gui_create_boundary`
+Consulter :doc:`gui_create_boundary`
.. index:: single: type de conformité
.. index:: single: maillage;initial
-Les variables sont décrites dans :ref:`gui_create_case`.
+Les variables sont décrites dans :doc:`gui_create_case`.
Méthodes de la classe homard
****************************
| |
| - ``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 |
+| * 0 : conforme |
+| * 1 : non conforme avec au minimum 2 aretes coupees |
+| * 2 : non conforme avec 1 noeud par arete de maille |
+| * 3 : non conforme quelconque |
+| * -1 : conforme avec des boites (pas d'escalier) |
+| * -2 : non-conforme avec des boites (pas d'escalier) |
+---------------------------------------------------------------+
| .. module:: GetConfType |
| |
Saisie graphique correspondante
*******************************
-Consulter :ref:`gui_create_case`
+Consulter :doc:`gui_create_case`
.. index:: single: hypothèse
.. index:: single: zone
-Les variables sont décrites dans :ref:`gui_create_hypothese`.
+Les variables sont décrites dans :doc:`gui_create_hypothese`.
Méthodes de la classe homard
****************************
+---------------------------------------------------------------+
.. note::
- Le fichier et les instants où sont pris les champs sont définis dans l'itération ; voir :ref:`tui_create_iteration`.
+ Le fichier et les instants où sont pris les champs sont définis dans l'itération ; voir :doc:`tui_create_iteration`.
Les options avancées
====================
Saisie graphique correspondante
*******************************
-Consulter :ref:`gui_create_hypothese`
+Consulter :doc:`gui_create_hypothese`
.. 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.
.. index:: single: hypothèse
.. index:: single: zone
-Les variables sont décrites dans :ref:`gui_create_iteration`.
+Les variables sont décrites dans :doc:`gui_create_iteration`.
Méthodes de la classe homard
****************************
Méthodes communes aux classes cas et iteration
**********************************************
-Voir également dans :ref:`tui_create_case`.
+Voir également dans :doc:`tui_create_case`.
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Les instants pour les champs à interpoler
-----------------------------------------
-Les champs à interpoler sont définis dans l'hypothèse (voir :ref:`tui_create_hypothese`).
+Les champs à interpoler sont définis dans l'hypothèse (voir :doc:`tui_create_hypothese`).
Pour un champ donné, si aucune mention de pas de temps n'est précisé, tous les pas de temps seront pris en compte.
Si on souhaite limiter l'interpolation à un ou plusieurs pas de temps, il faut le préciser ici.
Saisie graphique correspondante
*******************************
-Consulter :ref:`gui_create_iteration`
+Consulter :doc:`gui_create_iteration`
.. index:: single: disque avec trou
.. index:: single: 2D
-Les variables sont décrites dans :ref:`gui_create_zone`.
+Les variables sont décrites dans :doc:`gui_create_zone`.
Méthodes de la classe homard
****************************
Saisie graphique correspondante
*******************************
-Consulter :ref:`gui_create_zone`
+Consulter :doc:`gui_create_zone`
.. 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.
Saisie graphique correspondante
*******************************
-Consulter :ref:`gui_homard`
+Consulter :doc:`gui_homard`
####
.. index:: single: YACS
-L'utilisation de schémas YACS va permettre de coupler un calcul et une adaptation comme il est décrit dans :ref:`intro`. Ce couplage peut être répété au sein d'une boucle jusqu'à l'obtention d'un critère de convergence par exemple. Il existe de nombreuses façons de programmer un schéma YACS. La solution proposée ici fonctionne mais on peut très bien faire autrement !
+L'utilisation de schémas YACS va permettre de coupler un calcul et une adaptation comme il est décrit dans :doc:`intro`. Ce couplage peut être répété au sein d'une boucle jusqu'à l'obtention d'un critère de convergence par exemple. Il existe de nombreuses façons de programmer un schéma YACS. La solution proposée ici fonctionne mais on peut très bien faire autrement !
On trouvera ici la description exhaustive d'un schéma YACS.
.. note::
- Le module HOMARD propose une création automatique de schéma YASC à partir d'un cas précédemment créé. Pour la mettre en oeuvre, consulter :ref:`gui_create_yacs`
+ Le module HOMARD propose une création automatique de schéma YASC à partir d'un cas précédemment créé. Pour la mettre en oeuvre, consulter :doc:`gui_create_yacs`
Présentation générale
*********************
.. literalinclude:: ../files/yacs_01.fr.xml
:lines: 483-486
-Les options de ce cas doivent maintenant être renseignées. C'est fait par le noeud python CaseOptions. Il est impératif de renseigner le répertoire de calcul. On regardera la description des fonctions dans :ref:`tui_create_case`. En sortie, on récupère l'instance de l'itération correspondant à l'état initial du cas.
+Les options de ce cas doivent maintenant être renseignées. C'est fait par le noeud python CaseOptions. Il est impératif de renseigner le répertoire de calcul. On regardera la description des fonctions dans :doc:`tui_create_case`. En sortie, on récupère l'instance de l'itération correspondant à l'état initial du cas.
.. literalinclude:: ../files/yacs_01.fr.xml
:lines: 216-228
.. literalinclude:: ../files/yacs_01.fr.xml
:lines: 325-333
-L'hypothèse transmise en paramètre d'entrée est caractérisée (voir :ref:`tui_create_hypothese`) :
+L'hypothèse transmise en paramètre d'entrée est caractérisée (voir :doc:`tui_create_hypothese`) :
.. literalinclude:: ../files/yacs_01.fr.xml
:lines: 254-278
.. literalinclude:: ../files/yacs_01.fr.xml
:lines: 280-290
-L'itération est complétée : hypothèse, futur maillage, champ (voir :ref:`tui_create_iteration`) :
+L'itération est complétée : hypothèse, futur maillage, champ (voir :doc:`tui_create_iteration`) :
.. literalinclude:: ../files/yacs_01.fr.xml
:lines: 292-311
Aux passages suivants dans le bloc d'adaptation, il faut récupérer :
-- la dernière itération créée pour la poursuivre : service LastIteration (voir :ref:`tui_create_iteration`)
-- l'hypothèse créée : service GetHypothesis (voir :ref:`tui_create_hypothese`)
+- la dernière itération créée pour la poursuivre : service LastIteration (voir :doc:`tui_create_iteration`)
+- l'hypothèse créée : service GetHypothesis (voir :doc:`tui_create_hypothese`)
On passe ensuite dans le noeud Homard_Exec pour calculer le nouveau maillage.
