tui_create_zone.rst \
tui_homard.rst \
tui_usage.rst \
-tutorials.rst
+tutorials.rst \
+gui_create_yacs.rst \
+tui_create_yacs.rst
EXTRA_DIST += $(RSTFILES) images ../images ../files
The pursuit of a case
*********************
.. index:: single: pursuit
-.. index:: single: yacs
+.. index:: single: YACS
The pursuit of a case is interesting in the following situation. A list of adaptations was done for a case and, at the end, SALOME is closed. The directories for these iterations are kept. Then, the user wants to go on these iterations from the final point of the previous list. This function is useful with a schema YACS if a long list of adaptations is cut into small parts.
Name of the iteration
*********************
-A name of case is proposed automatically: Iter_1, Iter_2, etc This name can be modified. It must not have been used for a preceding iteration.
+A name of iteration is proposed automatically: Iter_1, Iter_2, etc This name can be modified. It must not have been used for a preceding iteration.
The preceding iteration
***********************
--- /dev/null
+.. _gui_create_yacs:
+
+The schema YACS
+###############
+.. index:: single: YACS
+.. index:: single: case
+
+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`
+
+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`.
+- Last, from this case, a schema will be created, based on the hypothesis for the adaptation.
+
+
+.. image:: images/create_yacs_01.png
+ :align: center
+ :alt: yacs - creation
+ :width: 516
+ :height: 295
+
+Name of the schema
+******************
+A name of schema is automatically proposed: YACS_1, YACS_2, etc. This name can be modified. He must not have been already used for another schema.
+
+The script
+**********
+
+The file containing the script which allows to launch the calculation connected to the physical modelling is supplied here. It is a script python who has to respect the following rules:
+
+- the name of the class which manages the calculation is ``Script``
+- to launch the calculation is made by the method``Compute()``
+- the result of the calculation is under the shape of three variables: the code of error, a message, a dictionary python.
+
+If they are necessary for the creation of the class, we can supply arguments under the shape:
+
+- ``--rep_calc=rep_calc``, where ``rep_calc`` is the directory for the computation
+- ``--num=num``, where ``num`` eis the number of calculation : 0 for the very first calculation, then 1, 2 etc.
+- ``--mesh_file=meshfile``, where ``meshfile`` is the file that contains the mesh for the computation
+- ``-v``, for the messages
+
+In return:
+
+- ``error`` : the error code, integer: 0 if it was correct, non 0 if not
+- ``message`` : a possible message of information about the calculation
+- ``dico_resu`` : a dictionary python that contains at less the two following keys: ``FileName`` is the key for the name of the MED file which contains the results of the calculation, ``V_TEST`` is the key for the real value to be tested.
+
+
+
+Example for the script:
+::
+
+ argu = ["--rep_calc=" + rep_calc)]
+ argu.append("--num=%d" % numCalc)
+ argu.append("--mesh_file=" + MeshFile)
+ Script_A = Script(argu)
+ error, message, dico_resu = Script_A.compute ()
+
+.. note::
+
+ * To drive Code_Aster : :download:`ScriptAster<../files/yacs_script.py>`
+
+The directory
+*************
+The directory will countain all the files producted by the computations. 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.
+
+The initial mesh
+****************
+The initial mesh must be stored into a MED file. It is the very first mesh that is used to solve the physical problem. The name of the file is choosen either by giving a name into the text zone or by a selection through the search window.
+
+The type of the schema
+**********************
+Two types of schemas are proposed: constant or variable.
+
+The default choice, 'constant', alternate a computation that is always the same and a mesh adaptation: from a computation to another one, the only part that is changed is the mesh. All the rest is identical. For example, in case the calculation would model a transient phenomenon, it is always the completeness of the transient phenomenon that is taken into account.
+
+The option 'variable' is inactive today.
+
+Corresponding python functions
+******************************
+Look :ref:`tui_create_yacs`
+
gui_homard
gui_mesh_info
+
+Creation of a schema YACS
+*************************
+
+An automatic creation of a schema YACS is available in the module HOMARD.
+
+.. toctree::
+ :maxdepth: 2
+
+ gui_create_yacs
+
+
`Available here <http://dx.doi.org/10.1016/j.finel.2012.11.008>`_
-.. index:: single: yacs
+.. index:: single: YACS
.. note::
This alternation (computation/adaptation) suits in the :ref:`yacs` schemes.
Methods of the class cas
************************
-.. index:: single: yacs
+.. index:: single: YACS
+---------------------------------------------------------------+
+---------------------------------------------------------------+
.. _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
-"""""""""""""""""""""""""""""""""""""""""
+****************************************"
+See also in :ref:`tui_create_case`.
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Methods of the class iteration
-""""""""""""""""""""""""""""""
+******************************
General methods
-^^^^^^^^^^^^^^^
+===============
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Information about the meshes
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+============================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Information about the field
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
+===========================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Miscellenaous
-^^^^^^^^^^^^^
+=============
+---------------------------------------------------------------+
+---------------------------------------------------------------+
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`
--- /dev/null
+.. _tui_create_yacs:
+
+The schema YACS
+###############
+
+.. index:: single: YACS
+
+The variables are described in :ref:`gui_create_yacs`.
+
+Méthodes de la classe cas
+*************************
+See also in :ref:`tui_create_case`.
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: CreateYACSSchema |
+| |
+| **CreateYACSSchema(yacs_name, ScriptFile, DirName, MeshFile)**|
+| Returns an instance of the class ``yacs``, after its |
+| creation |
+| |
+| - ``yacs_name`` : the name of the schema |
+| - ``ScriptFile`` : the file of the python script that |
+| drives the computation, coupled with the mesh adaptation|
+| - ``DirName`` : the directory for the computation |
+| - ``MeshFile`` : the MED file that contains the very first|
+| mesh for the computation |
++---------------------------------------------------------------+
+
+Methodes of the class homard
+****************************
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetYACS |
+| |
+| **GetYACS(yacs_name)** |
+| Returns the instance of the class classe ``yacs`` |
+| known by its name |
+| |
+| - ``yacs_name`` : the name of the schema |
++---------------------------------------------------------------+
+| .. module:: GetAllYACSsName |
+| |
+| **GetAllYACSsName()** |
+| Returns the list of the names of all the existing |
+| schemas |
++---------------------------------------------------------------+
+
+
+
+Methodes of the class YACS
+**************************
+
+General methods
+===============
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: Write |
+| |
+| **Write()** |
+| Writes the schema into the file ``schema.xml``, in the |
+| directory of the case |
+| |
+| Returns an integer: |
+| * 0: the writing is done |
+| * other value: problem |
++---------------------------------------------------------------+
+| .. module:: WriteOnFile |
+| |
+| **WriteOnFile(file_xml)** |
+| Writes the schema into a specified file. |
+| |
+| - ``file_xml`` : name of the xml file for the schema |
+| |
+| Returns an integer: |
+| * 0: the writing is done |
+| * other value: problem |
++---------------------------------------------------------------+
+| .. module:: Delete |
+| |
+| **Delete(option)** |
+| Deletes the schema |
+| |
+| - ``option``: an integer to define what to do with the |
+| xml file of the schema |
+| |
+| * 0: the files is kept |
+| * 1: the files is removed |
+| |
+| Returns an integer: |
+| * 0: the destruction is done |
+| * other value: problem |
++---------------------------------------------------------------+
+
+
+Informations about the schema
+=============================
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetName |
+| |
+| **GetName()** |
+| Returns the name of the schema |
++---------------------------------------------------------------+
+| .. module:: GetType |
+| |
+| **GetType()** |
+| Returns the type of the schema |
+| |
+| * 1 : static |
+| * 2 : transitory |
++---------------------------------------------------------------+
+| .. module:: SetScriptFile |
+| |
+| **SetScriptFile(script_file)** |
+| Defines the file of the script python that launches the |
+| computation |
+| |
+| - ``script_file`` : the name of the file that contains |
+| the script python |
++---------------------------------------------------------------+
+| .. module:: GetScriptFile |
+| |
+| **GetScriptFile()** |
+| Returns the name of the file that contains the script |
+| python |
++---------------------------------------------------------------+
+| .. module:: SetDirName |
+| |
+| **SetDirName(dir_name)** |
+| Defines the name of the directory for the computation |
+| |
+| - ``dir_name`` : the name of the directory for the |
+| computation |
++---------------------------------------------------------------+
+| .. module:: GetDirName |
+| |
+| **GetDirName()** |
+| Returns the name of the directory for the computation |
++---------------------------------------------------------------+
+| .. module:: SetMeshFile |
+| |
+| **SetMeshFile(mesh_file)** |
+| Defines the MED file of the very first mesh |
+| |
+| - ``mesh_file`` : the name of the MED file that contains |
+| the very first mesh for the computation |
++---------------------------------------------------------------+
+| .. module:: GetMeshFile |
+| |
+| **GetMeshFile()** |
+| Returns the name of the MED file of the very first mesh |
+| for the computation |
++---------------------------------------------------------------+
+
+
+Example
+*******
+The creation of a schema is done as follows:
+::
+
+ ScriptFile = "/scratch/D68518/Salome/HOMARD_SALOME/HOMARD_SRC/doc/files/ScriptAster.py"
+ DirName = "/scratch/D68518/computation"
+ MeshFile = "/scratch/D68518/computation/maill.00.med"
+ YACS_0 = Case.CreateYACSSchema("YACS_0", ScriptFile, DirName, MeshFile)
+
+It can be writen down in a file :
+::
+
+ YACSFile = "/scratch/D68518/computation/yacs.xml"
+ codret = YACS_0.WriteOnFile(YACSFile)
+
+Similar graphical input
+***********************
+Look at :ref:`gui_create_yacs`
+
+
+
tui_create_zone
tui_create_boundary
tui_homard
+ tui_create_yacs
Loading of the module HOMARD
****************************
-.. index:: single: yacs
+.. index:: single: YACS
The loading of the module HOMARD is done in a way similar to the other modules.
Non plane boundaries
********************
.. index:: single: field
-.. index:: single: yacs
+.. index:: single: YACS
One tests the follow-up of the curved borders here: analytical borders to describe various surfaces of the pipes and a discrete border to describe the intersecting lines of the two pipes. The driving of refinement is the following: uniform refinement of all the elements contained in indicated groups. One starts by refining the inner faces with the pipes; then, one refines continuation twice the external faces with the pipes.
Scheme YACS carrying out this adaptation is downloadable.
YACS
####
-.. index:: single: yacs
+.. 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!
+
+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`
Introduction
************
-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!
-
Here is the description of a scheme for a computation in which a value is to be stabilized. The computation starts over an initial mesh, then HOMARD makes an adaptation. A new computation is done over this new mesh and its result is analyzed. Depending on this analysis, the coupling goes on or does not. The general look of the scheme is this one:
.. image:: ../images/yacs_01.png
"""
Lancement d'un calcul ASTER
"""
-__revision__ = "V5.2"
+__revision__ = "V5.3"
#
import sys
import os
Mode d'emploi :
---------------
-Cette procedure lance un calcul Aster. Le mode de lancement est le suivant :
+Cette procedure lance un calcul Aster. Avant de lancer ce script, il faut avoir cree un repertoire pour le calcul. Dans ce repertoire, on aura mis le fichier de commandes sous le nom 'calcul.comm'. Apres un premier calcul, lance traditionnellement, on aura copie le fichier '*export' sous le nom 'calcul.ref.export' dans ce repertoire.
+
+Le mode de lancement est le suivant :
ScriptAster --rep_calc=rep_calc --num=nro --mesh_file=mesh_file [-dump] [-h|-help] [-v] [-v_max] options
Arguments obligatoires :
--rep_calc=rep_calc : le repertoire du calcul.
--num=nro : le numero du calcul, depuis 0.
---mesh_file=mesh_file : le fichier contenant le maillage sur lequel on veut calculer.
+--mesh_file=mesh_file : le fichier contenant le maillage sur lequel on veut calculer. Le nom est absolu ou relatif par rapport au repertoire de calcul.
Options supplementaires, selon les cas :
. Pour un cas transitoire :
if ( self.mesh_file[:1] == "~" ) :
self.mesh_file = os.path.join(HOME, self.mesh_file[2:])
if not os.path.isfile(self.mesh_file) :
- self.message_info += "Fichier " + self.mesh_file
- erreur = -4
- break
- else :
- aux = os.path.join(os.getcwd(),self.mesh_file)
- self.mesh_file = os.path.normpath(aux)
+ aux = os.path.join(self.rep_calc, self.mesh_file)
+ if not os.path.isfile(aux) :
+ self.message_info += "Fichier " + self.mesh_file
+ erreur = -4
+ break
+ else :
+ self.mesh_file = os.path.normpath(aux)
+ aux = os.path.join(os.getcwd(),self.mesh_file)
+ self.mesh_file = os.path.normpath(aux)
#
# 2. On en deduit le cas
#
if self.verbose_max :
print blabla
print ". erreur :", erreur
+#
+ os.remove(nomfic_donn)
#
if erreur :
message_erreur = messages_erreur[erreur]
tui_create_zone.rst \
tui_homard.rst \
tui_usage.rst \
-tutorials.rst
+tutorials.rst \
+gui_create_yacs.rst \
+tui_create_yacs.rst
EXTRA_DIST += $(RSTFILES) images ../images ../files
.. image:: images/homard_1.png
:align: center
+ :alt: HOMARD - lancement
+ :width: 565
+ :height: 154
Une fois le module HOMARD activé, on crée un cas par le choix "*Nouveau cas*" dans le menu HOMARD.
.. image:: images/homard_2.png
:align: center
+ :alt: Nouveau cas
+ :width: 378
+ :height: 120
La fenêtre suivante apparaît :
.. image:: images/intro_31.png
:align: center
+ :alt: Fenetre
+ :width: 554
+ :height: 298
Il faut fournir deux informations : le répertoire qui contiendra les fichiers produits par les adaptations successives et le fichier MED issu du calcul que l'on vient de faire. On valide par "Appliquer et fermer".
.. image:: images/intro_32.png
:align: center
+ :alt: Fenetre - 2
+ :width: 554
+ :height: 298
L'arbre d'études est enrichi de ce cas. On déplie le cas jusqu'à afficher le maillage correspondant à l'itération 0. On désigne cette itération initiale et on demande une nouvelle itération par "*Nouvelle itération*" dans le menu HOMARD ou à la souris.
.. image:: images/intro_331.png
:align: center
+ :alt: Nouvelle itération
+ :width: 324
+ :height: 282
La fenêtre suivante apparaît :
.. image:: images/intro_33.png
:align: center
+ :alt: Nouvelle itération - 2
+ :width: 649
+ :height: 372
On désigne le fichier issu du calcul que l'on vient de faire et qui contient le champ de température. C'est le même que celui qui a été donné dans la définition du cas.
.. image:: images/intro_34.png
:align: center
+ :alt: Fenetre
+ :width: 624
+ :height: 103
On clique sur "Nouveau" dans la rubrique hypothèse. La fenêtre suivante apparaît :
.. image:: images/intro_35.png
:align: center
+ :alt: Fenetre
+ :width: 769
+ :height: 775
On modifie les options par défaut pour correspondre à notre choix de pilotage de l'adaptation. La sélection d'un pilotage par les sauts entre éléments et d'un seuil absolu de 4.0 va demander le découpage de chaque arête de maille où le température varie de plus de 4.0 degrés entre les deux extrémités de l'arête.
.. image:: images/intro_36.png
:align: center
+ :alt: Fenetre
On valide par "Appliquer et fermer" cette création d'hypothése, puis la création de la nouvelle itération. On se retrouve avec un arbre d'études enrichi avec la description de l'hypothèse créée et de l'itération à calculer, repérée par une icone "en attente".
.. image:: images/intro_37.png
:align: center
+ :alt: Fenetre
A ce stade, on va utiliser ce nouveau maillage pour un deuxième calcul, dans les mêmes conditions que le premier. Une fois que ce nouveau calcul est achevé, on peut décider de poursuivre le processus d'adaptation. Pour cela on revient dans SALOME et on active le module HOMARD. On désigne l'itération que l'avait calculée précédemment "*Iter_1*" et on demande une nouvelle itération. La fenêtre suivante apparaît :
.. image:: images/intro_38.png
:align: center
+ :alt: Fenetre
Comme on continue l'adaptation avec le même critère de saut de température entre noeuds voisins, on garde l'hypothèse "*Hypo_1*". Il suffit de désigner le fichier issu du calcul que l'on vient de faire et qui contient le nouveau champ de température.
.. image:: images/intro_39.png
:align: center
+ :alt: Fenetre
Comme précédemment, on lance l'adaptation et on récupère les résultats dans le répertoire du cas, dont le maillage ``maill.02.med``.
.. image:: ../images/intro_40.png
:align: center
+ :alt: Fenetre
On peut alors lancer un nouveau calcul sur ce nouveau maillage et poursuiver cette alternance calcul/adaptation jusqu'à l'obtention du résultat attendu.
La poursuite d'un cas
*********************
.. index:: single: poursuite
-.. index:: single: yacs
+.. index:: single: YACS
La poursuite d'un cas correspond à la situation suivante :
Une série d'adaptations ont été conduites sur un cas puis SALOME est fermé. On a gardé les répertoires de travail de ces itérations. On souhaite ensuite reprendre ces itérations pour les poursuivre là où on s'est arrêté. Cette fonctionnalité est particulièrement utile dans le cas de schémas YACS pour lesquels on scinde en plusieurs parties une longue série d'adaptations.
Nom de l'hypothèse
******************
-Un nom de l'hypothèse est proposé automatiquement : Hypo_1, Hypo_2, etc. Ce nom peut être modifié. Il ne doit pas avoir été utilisé pour une hypothèse précédente.
+Un nom d'hypothèse est proposé automatiquement : Hypo_1, Hypo_2, etc. Ce nom peut être modifié. Il ne doit pas avoir été utilisé pour une hypothèse précédente.
Adaptation uniforme
*******************
Le nom de l'itération
*********************
-Un nom de cas est proposé automatiquement : Iter_1, Iter_2, etc. Ce nom peut être modifié. Il ne doit pas avoir été utilisé pour une itération précédente.
+Un nom d'iteration est proposé automatiquement : Iter_1, Iter_2, etc. Ce nom peut être modifié. Il ne doit pas avoir été utilisé pour une itération précédente.
L'itération précédente
**********************
--- /dev/null
+.. _gui_create_yacs:
+
+Le schéma YACS
+##############
+.. index:: single: YACS
+.. index:: single: cas
+
+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`
+
+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`.
+- Enfin, de ce cas, on va créer le schéma qui se basera sur l'hypothèse d'adapation définie.
+
+
+.. image:: images/create_yacs_01.png
+ :align: center
+ :alt: yacs - création
+ :width: 551
+ :height: 295
+
+Nom du schéma
+*************
+Un nom de schéma est proposé automatiquement : YACS_1, YACS_2, etc. Ce nom peut être modifié. Il ne doit pas avoir été déjà utilisé pour un autre schéma.
+
+Le script
+*********
+
+Le fichier contenant le script qui permet de lancer le calcul lié à la modélisation physique est fourni ici. C'est un script python qui doit respecter les règles suivantes :
+
+- le nom de la classe qui gère le calcul est ``Script``
+- le lancement du calcul se fait par la méthode ``Compute()``
+- le résultat du calcul est sous la forme de trois variables : le code d'erreur, un message, un dictionnaire python.
+
+S'ils sont nécessaires à la création de la classe, on peut passer des arguments sous la forme :
+
+- ``--rep_calc=rep_calc``, où ``rep_calc`` est le répertoire de calcul
+- ``--num=num``, où ``num`` est le numéro du calcul : 0 pour le tout premier, puis 1, 2 etc.
+- ``--mesh_file=meshfile``, où ``meshfile`` est le fichier contenant le maillage sur lequel calculer.
+- ``-v``, pour des messages
+
+Les arguments de retour :
+
+- ``erreur`` : le code d'erreur, entier : 0 si le calcul est correct, non nul sinon
+- ``message`` : un éventuel message d'information sur le calcul
+- ``dico_resu`` : un dictionnaire python qui comprend a minima les deux clés suivantes : ``FileName`` est la clé pour le nom du fichier MED qui contient les résultats du calcul, ``V_TEST`` est la clé pour la valeur réelle à tester.
+
+
+
+Exemple d'usage du script :
+::
+
+ argu = ["--rep_calc=" + rep_calc)]
+ argu.append("--num=%d" % numCalc)
+ argu.append("--mesh_file=" + MeshFile)
+ Script_A = Script(argu)
+ erreur, message, dico_resu = Script_A.compute ()
+
+.. note::
+
+ * Pour piloter Code_Aster : :download:`ScriptAster<../files/yacs_script.py>`
+
+Le répertoire
+*************
+Le répertoire est celui qui contiend les fichiers produits par le calcul. 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.
+
+Le maillage initial
+*******************
+Le maillage initial doit se trouver dans un fichier au format MED. C'est celui qui est le point de départ du tout premier calcul. Le nom du fichier peut être fourni, soit en tapant le nom dans la zone de texte, soit en activant la fonction de recherche.
+
+
+Le type de schéma
+*****************
+Plusieurs types de schéma sont proposés : constant ou variable.
+
+L'option par défaut, 'constant', alterne le lancement d'un calcul qui est toujours le même et une adaptation de maillage : d'un calcul à l'autre, la seule chose qui change est le maillage. Tout le reste est identique. Par exemple, dans le cas où le calcul modéliserait un transitoire, c'est toujours l'intégralité du transitoire qui est prise en compte.
+
+L'option 'variable' est inactive aujourd'hui.
+
+Méthodes python correspondantes
+*******************************
+Consulter :ref:`tui_create_yacs`
.. _gui_usage:
Mode d'emploi pour l'interface graphique
-========================================
+########################################
.. index:: single: cas
.. index:: single: itération
Activer le module HOMARD
-""""""""""""""""""""""""
+************************
Pour utiliser le module HOMARD, deux façons existent :
#. en activant l'onglet HOMARD dans la liste des modules,
:align: center
Définir une adaptation
-""""""""""""""""""""""
+**********************
Une fois que HOMARD a été activé, la permière action consiste à créer un cas. Il s'agit de sélectionner le maillage initial de la suite d'adaptations envisagée (voir :ref:`gui_create_case`). A partir de ce cas, on définira les itérations successives (voir :ref:`gui_create_iteration`) à partir des hypothèses (voir :ref:`gui_create_hypothese`). Les adaptations sont lancées tel que décrit dans :ref:`gui_homard`.
Mode d'emploi de la saisie des données
-""""""""""""""""""""""""""""""""""""""
+**************************************
.. toctree::
:maxdepth: 2
gui_homard
gui_mesh_info
+
+Création d'un schéma YACS
+*************************
+
+Le module HOMARD propose la création automatique de schémas YACS alternant un calcul et une adaptation de maillage.
+
+.. toctree::
+ :maxdepth: 2
+
+ gui_create_yacs
`Accessible en cliquant ici <http://dx.doi.org/10.1016/j.finel.2012.11.008>`_
-.. index:: single: yacs
+.. index:: single: YACS
.. note::
Cet alternance de calculs et d'adaptions est très appropriée à la mise place de schémas :ref:`yacs`.
.. _tui_create_boundary:
La frontière
-============
+############
.. index:: single: boundary
.. index:: single: frontière
Les variables sont décrites dans :ref:`gui_create_boundary`.
Méthodes de la classe homard
-""""""""""""""""""""""""""""
+****************************
Ces méthodes retournent une instance de la classe boundary.
+----------------------------------------------------------------------------------------+
+---------------------------------------------------------------+
Méthodes de la classe cas
-"""""""""""""""""""""""""
-Voir également dans dans :ref:`tui_create_case`.
+*************************
+Voir également dans :ref:`tui_create_case`.
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Méthodes de la classe boundary
-""""""""""""""""""""""""""""""
+******************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Exemple
-"""""""
+*******
Création d'une frontière discrète, d'une frontière sphèrique, puis d'une frontière cylindrique : ::
inter = homard.CreateBoundaryDi("INTERSECTION", 'PIQUAGE', dircase+'/tutorial_4.fr.med')
Saisie graphique correspondante
-"""""""""""""""""""""""""""""""
+*******************************
Consulter :ref:`gui_create_boundary`
.. _tui_create_case:
Le cas
-======
+######
.. index:: single: cas
.. index:: single: type de conformité
.. index:: single: maillage;initial
Les variables sont décrites dans :ref:`gui_create_case`.
Méthodes de la classe homard
-""""""""""""""""""""""""""""
+****************************
Création d'un cas
-^^^^^^^^^^^^^^^^^
+=================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Création d'un cas par poursuite d'une itération calculée
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+========================================================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Méthodes de la classe cas
-"""""""""""""""""""""""""
-.. index:: single: yacs
+*************************
+.. index:: single: YACS
+---------------------------------------------------------------+
+---------------------------------------------------------------+
| * 0 : correspond à un maillage initial |
| * autre valeur : poursuite d'une itération de numéro n|
+---------------------------------------------------------------+
-| .. module:: WriteYACSSchema |
+| .. module:: CreateYACSSchema |
| |
-| **WriteYACSSchema(ScriptFile, DirName, MeshFile)** |
-| Ecrit un schéma YACS correspondant au cas. |
+| **CreateYACSSchema(yacs_name, ScriptFile, DirName, MeshFile)**|
+| Retourne une instance de la classe ``yacs`` après sa |
+| création |
| |
-| - ``ScriptFile`` : nom du fichier contenant le script de |
-| lancement du calcul |
-| - ``DirName`` : le repertoire de lancement des calculs |
-| du schéma |
-| - ``MeshFile`` : nom du fichier contenant le maillage pour|
-| le premier calcul |
+| - ``yacs_name`` : le nom du schéma |
+| - ``ScriptFile`` : le fichier du script python qui permet |
+| de lancer le calcul à coupler avec l'adaptation de |
+| maillage |
+| - ``DirName`` : le répertoire où a lieu le calcul |
+| - ``MeshFile`` : le fichier MED contenant le tout premier |
+| maillage de calcul |
+---------------------------------------------------------------+
Les options avancées
-^^^^^^^^^^^^^^^^^^^^
+====================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Informations sur le maillage initial
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+====================================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Exemple
-"""""""
+*******
La création de l'objet case_1 se fait ainsi : ::
case_name = "CAS_1"
Saisie graphique correspondante
-"""""""""""""""""""""""""""""""
+*******************************
Consulter :ref:`gui_create_case`
.. _tui_create_hypothese:
L'hypothèse
-===========
+###########
.. index:: single: itération
.. index:: single: hypothèse
Les variables sont décrites dans :ref:`gui_create_hypothese`.
Méthodes de la classe homard
-""""""""""""""""""""""""""""
+****************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Méthodes de la classe hypothese
-"""""""""""""""""""""""""""""""
+*******************************
Généralités
-^^^^^^^^^^^
+===========
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Le champ et les seuils
-^^^^^^^^^^^^^^^^^^^^^^
+======================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Les composantes du champ
-^^^^^^^^^^^^^^^^^^^^^^^^
+========================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Les zones
-^^^^^^^^^
+=========
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Le filtrage par les groupes
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
+===========================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Les options avancées
-^^^^^^^^^^^^^^^^^^^^
+====================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Exemple
-"""""""
+*******
La création de l'objet hypo_1 se fait ainsi : ::
hypo_1 = homard.CreateHypothesis("HypoField")
Saisie graphique correspondante
-"""""""""""""""""""""""""""""""
+*******************************
Consulter :ref:`gui_create_hypothese`
.. warning::
.. _tui_create_iteration:
L'itération
-===========
+###########
.. index:: single: itération
.. index:: single: hypothèse
Les variables sont décrites dans :ref:`gui_create_iteration`.
Méthodes de la classe homard
-""""""""""""""""""""""""""""
+****************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Méthodes communes aux classes cas et iteration
-""""""""""""""""""""""""""""""""""""""""""""""
+**********************************************
+Voir également dans :ref:`tui_create_case`.
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Méthodes de la classe iteration
-"""""""""""""""""""""""""""""""
+*******************************
Généralités
-^^^^^^^^^^^
+===========
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Informations sur les maillages
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+==============================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Informations sur le champ
-^^^^^^^^^^^^^^^^^^^^^^^^^
+=========================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Divers
-^^^^^^
+======
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Exemple
-"""""""
+*******
.. index:: single: maillage;initial
-Pour la création de la première itération, on part de celle qui correspond au maillage initial. C'est celle contenue dans le cas. ::
+Pour la création de la première itération, on part de celle qui correspond au maillage initial. C'est celle contenue dans le cas.
+::
iter_name = "Iteration_1"
iter_1 = case_1.NextIteration(iter_name)
iter_1.AssociateHypo("HypoField")
codret = iter_1.Compute(1, 2)
-Ensuite, on crée une itération suivante à l'itération parent de laquelle on part. ::
+Ensuite, on crée une itération suivante à l'itération parent de laquelle on part.
+::
iter_name = "Iteration_2"
iter_2 = iter_1.NextIteration(iter_name)
Saisie graphique correspondante
-"""""""""""""""""""""""""""""""
+*******************************
Consulter :ref:`gui_create_iteration`
--- /dev/null
+.. _tui_create_yacs:
+
+Le schéma YACS
+##############
+
+.. index:: single: YACS
+
+Les variables sont décrites dans :ref:`gui_create_yacs`.
+
+Méthodes de la classe cas
+*************************
+Voir également dans :ref:`tui_create_case`.
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: CreateYACSSchema |
+| |
+| **CreateYACSSchema(yacs_name, ScriptFile, DirName, MeshFile)**|
+| Retourne une instance de la classe ``yacs`` après sa |
+| création |
+| |
+| - ``yacs_name`` : le nom du schéma |
+| - ``ScriptFile`` : le fichier du script python qui permet |
+| de lancer le calcul à coupler avec l'adaptation de |
+| maillage |
+| - ``DirName`` : le répertoire où a lieu le calcul |
+| - ``MeshFile`` : le fichier MED contenant le tout premier |
+| maillage de calcul |
++---------------------------------------------------------------+
+
+Méthodes de la classe homard
+****************************
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetYACS |
+| |
+| **GetYACS(yacs_name)** |
+| Retourne l'instance de la classe ``yacs`` connue par |
+| son nom |
+| |
+| - ``yacs_name`` : le nom du schéma |
++---------------------------------------------------------------+
+| .. module:: GetAllYACSsName |
+| |
+| **GetAllYACSsName()** |
+| Retourne la liste des noms de tous les schémas existant |
++---------------------------------------------------------------+
+
+
+
+Méthodes de la classe YACS
+**************************
+
+Généralités
+===========
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: Write |
+| |
+| **Write()** |
+| Ecrit le schéma dans le fichier ``schema.xml``, dans le |
+| répertoire du cas |
+| |
+| Retourne un entier : |
+| * 0 : écriture réussie |
+| * autre valeur : problème |
++---------------------------------------------------------------+
+| .. module:: WriteOnFile |
+| |
+| **WriteOnFile(file_xml)** |
+| Ecrit le schéma dans un fichier désigné. |
+| |
+| - ``file_xml`` : nom du fichier xml du schéma |
+| |
+| Retourne un entier : |
+| * 0 : écriture réussie |
+| * autre valeur : problème |
++---------------------------------------------------------------+
+| .. module:: Delete |
+| |
+| **Delete(option)** |
+| Detruit le schéma. |
+| |
+| - ``option`` : un entier précisant ce qui est fait du |
+| fichier xml du schéma |
+| |
+| * 0 : le fichier est conservé |
+| * 1 : le fichier est détruit |
+| |
+| Retourne un entier : |
+| * 0 : destruction réussie |
+| * autre valeur : problème |
++---------------------------------------------------------------+
+
+
+Informations sur le schéma
+==========================
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: GetName |
+| |
+| **GetName()** |
+| Retourne le nom du schéma |
++---------------------------------------------------------------+
+| .. module:: GetType |
+| |
+| **GetType()** |
+| Retourne le type du schéma |
+| |
+| * 1 : statique |
+| * 2 : transitoire |
++---------------------------------------------------------------+
+| .. module:: SetScriptFile |
+| |
+| **SetScriptFile(script_file)** |
+| Définit le fichier du script python de lancement du calcul|
+| |
+| - ``script_file`` : le nom du fichier qui contient le |
+| le script python |
++---------------------------------------------------------------+
+| .. module:: GetScriptFile |
+| |
+| **GetScriptFile()** |
+| Retourne le nom du fichier MED qui contient le script |
+| python |
++---------------------------------------------------------------+
+| .. module:: SetDirName |
+| |
+| **SetDirName(dir_name)** |
+| Définit le nom du répertoire de calcul |
+| |
+| - ``dir_name`` : le nom du répertoire de calcul |
++---------------------------------------------------------------+
+| .. module:: GetDirName |
+| |
+| **GetDirName()** |
+| Retourne le nom du répertoire de calcul |
++---------------------------------------------------------------+
+| .. module:: SetMeshFile |
+| |
+| **SetMeshFile(mesh_file)** |
+| Définit le fichier MED du tout premier maillage |
+| |
+| - ``mesh_file`` : le nom du fichier MED contenant le tout |
+| premier maillage de calcul |
++---------------------------------------------------------------+
+| .. module:: GetMeshFile |
+| |
+| **GetMeshFile()** |
+| Retourne le nom du fichier MED du tout premier maillage |
+| de calcul |
++---------------------------------------------------------------+
+
+
+Exemple
+*******
+La création d'un schéma se fait ainsi :
+::
+
+ ScriptFile = "/scratch/D68518/Salome/HOMARD_SALOME/HOMARD_SRC/doc/files/ScriptAster.py"
+ DirName = "/scratch/D68518/calcul"
+ MeshFile = "/scratch/D68518/calcul/maill.00.med"
+ YACS_0 = Case.CreateYACSSchema("YACS_0", ScriptFile, DirName, MeshFile)
+
+On peut ensuite l'écrire dans un fichier :
+::
+
+ YACSFile = "/scratch/D68518/calcul/yacs.xml"
+ codret = YACS_0.WriteOnFile(YACSFile)
+
+Saisie graphique correspondante
+*******************************
+Consulter :ref:`gui_create_yacs`
+
+
+
.. _tui_create_zone:
La zone
-=======
+#######
.. index:: single: zone
.. index:: single: boite
Les variables sont décrites dans :ref:`gui_create_zone`.
Méthodes de la classe homard
-""""""""""""""""""""""""""""
+****************************
Ces méthodes retournent une instance de la classe zone.
Méthodes de la classe zone
-""""""""""""""""""""""""""
+**************************
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Exemple
-"""""""
+*******
La création d'une boîte 3D se fait ainsi :
::
Saisie graphique correspondante
-"""""""""""""""""""""""""""""""
+*******************************
Consulter :ref:`gui_create_zone`
.. warning::
.. _tui_homard:
Le calcul
-=========
+#########
Méthodes de la classe homard
-""""""""""""""""""""""""""""
+****************************
Exemple
-"""""""
+*******
Saisie graphique correspondante
-"""""""""""""""""""""""""""""""
+*******************************
Consulter :ref:`gui_homard`
Mode d'emploi pour TUI
-======================
+######################
Le module HOMARD peut se lancer à partir d'instructions python. On trouvera ici la description de chacune des fonctions accessibles par l'utilisateur.
.. toctree::
tui_create_zone
tui_create_boundary
tui_homard
+ tui_create_yacs
Exemples
-========
+########
.. index:: single: exemple
.. 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``.
Chargement du module HOMARD
-"""""""""""""""""""""""""""
-.. index:: single: yacs
+***************************
+.. index:: single: YACS
Le chargement du module HOMARD se fait de manière analogue aux autres modules.
homard.SetCurrentStudy(salome.myStudy)
Raffinement uniforme
-""""""""""""""""""""
+********************
.. index:: single: raffinement;uniforme
On fera ici trois raffinements uniformes successifs du maillage contenu dans le fichier ``tutorial_1.00.med``. Quelques remarques :
Raffinement par des 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.
Raffinement selon un champ
-""""""""""""""""""""""""""
+**************************
.. index:: single: champ
On procède ici au raffinement selon un champ. Les hypothèses servent à définir le nom du champ et les seuils de raffinement/déraffinement. La donnée du fichier et des instants est faite dans l'itération. Des champs sur les noeuds ou sur les mailles sont interpolés.
Suivi de frontières courbes
-"""""""""""""""""""""""""""
+***************************
.. index:: single: champ
-.. index:: single: yacs
+.. index:: single: YACS
On teste ici le suivi des frontières courbes : des frontières analytiques pour décrire les différentes surfaces des tuyaux et une frontière discrète pour décrire les lignes d'intersection des deux tuyaux. Le pilotage du raffinement est le suivant : raffinement uniforme de toutes les mailles contenues dans des groupes désignés. On commence par raffiner les faces internes aux tuyaux ; ensuite, on raffine deux fois de suite les faces externes aux tuyaux.
Le schéma YACS réalisant cette adaptation est téléchargeable.
Instructions spécifiques au 2D
-""""""""""""""""""""""""""""""
+******************************
.. index:: single: 2D
Les instructions pour adapter un maillage 2D sont exactement identiques à celles nécessaires à l'adaptation d'un maillage 3D. La seule exception concerne le raffinement selon des zones géométriques : des fonctions différentes sont utilisées pour pouvoir définir des zones 2D. On donne alors les coordonnées 2D des zones, en précisant l'orientation du plan du maillage.
YACS
####
-.. index:: single: yacs
-
-Introduction
-************
+.. 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 !
+On trouvera ici la description exhaustive d'un schéma YACS pour un calcul statique.
+
+.. 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`
+
+Présentation générale
+*********************
+
On va décrire ici un schéma s'appliquant à un calcul pour lequel on cherche à stabiliser une valeur. Le calcul démarre sur un maillage initial puis HOMARD enchaîne avec une adaptation. On refait un calcul sur ce nouveau maillage et son résultat est analysé. En fonction de cette analyse, le couplage continue ou non. L'allure générale du schéma est la suivante :
.. image:: ../images/yacs_01.png
{
return _Type;
}
+//=============================================================================
void HOMARD_YACS::SetDirName( const char* NomDir )
{
_NomDir = std::string( NomDir );
/********************************************************************************
** Form generated from reading UI file 'CreateYACS.ui'
**
-** Created: Wed Sep 18 10:38:42 2013
+** Created: Mon Sep 23 13:29:12 2013
** by: Qt User Interface Compiler version 4.6.3
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
QLabel *MeshFile;
QPushButton *PBMeshFile;
QLineEdit *LEMeshFile;
- QRadioButton *RBStatic;
- QRadioButton *RBTransient;
+ QGroupBox *GBTypeSchema;
+ QHBoxLayout *_4;
+ QRadioButton *RBConstant;
+ QRadioButton *RBVariable;
QGroupBox *GroupButtons;
QGridLayout *gridLayout1;
QPushButton *buttonHelp;
{
if (CreateYACS->objectName().isEmpty())
CreateYACS->setObjectName(QString::fromUtf8("CreateYACS"));
- CreateYACS->resize(537, 304);
+ CreateYACS->resize(538, 340);
QSizePolicy sizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
sizePolicy.setHorizontalStretch(0);
sizePolicy.setVerticalStretch(0);
LEName->setObjectName(QString::fromUtf8("LEName"));
LEName->setMaxLength(32);
- gridLayout_2->addWidget(LEName, 0, 1, 1, 3);
+ gridLayout_2->addWidget(LEName, 0, 1, 1, 1);
gridLayout = new QGridLayout();
gridLayout->setObjectName(QString::fromUtf8("gridLayout"));
gridLayout->addWidget(LECaseName, 0, 2, 1, 1);
- gridLayout_2->addLayout(gridLayout, 1, 0, 1, 4);
+ gridLayout_2->addLayout(gridLayout, 1, 0, 1, 3);
_2 = new QHBoxLayout();
#ifndef Q_OS_MAC
_2->addWidget(LEScriptFile);
- gridLayout_2->addLayout(_2, 2, 0, 1, 4);
+ gridLayout_2->addLayout(_2, 2, 0, 1, 3);
hboxLayout = new QHBoxLayout();
#ifndef Q_OS_MAC
hboxLayout->addWidget(LEDirName);
- gridLayout_2->addLayout(hboxLayout, 3, 0, 1, 4);
+ gridLayout_2->addLayout(hboxLayout, 3, 0, 1, 3);
_3 = new QHBoxLayout();
#ifndef Q_OS_MAC
_3->addWidget(LEMeshFile);
- gridLayout_2->addLayout(_3, 4, 0, 1, 4);
+ gridLayout_2->addLayout(_3, 4, 0, 1, 3);
- RBStatic = new QRadioButton(CreateYACS);
- RBStatic->setObjectName(QString::fromUtf8("RBStatic"));
- RBStatic->setChecked(true);
+ GBTypeSchema = new QGroupBox(CreateYACS);
+ GBTypeSchema->setObjectName(QString::fromUtf8("GBTypeSchema"));
+ _4 = new QHBoxLayout(GBTypeSchema);
+#ifndef Q_OS_MAC
+ _4->setSpacing(6);
+#endif
+#ifndef Q_OS_MAC
+ _4->setContentsMargins(9, 9, 9, 9);
+#endif
+ _4->setObjectName(QString::fromUtf8("_4"));
+ RBConstant = new QRadioButton(GBTypeSchema);
+ RBConstant->setObjectName(QString::fromUtf8("RBConstant"));
+ RBConstant->setChecked(true);
+
+ _4->addWidget(RBConstant);
+
+ RBVariable = new QRadioButton(GBTypeSchema);
+ RBVariable->setObjectName(QString::fromUtf8("RBVariable"));
- gridLayout_2->addWidget(RBStatic, 5, 0, 1, 2);
+ _4->addWidget(RBVariable);
- RBTransient = new QRadioButton(CreateYACS);
- RBTransient->setObjectName(QString::fromUtf8("RBTransient"));
- gridLayout_2->addWidget(RBTransient, 5, 2, 1, 1);
+ gridLayout_2->addWidget(GBTypeSchema, 5, 0, 1, 2);
GroupButtons = new QGroupBox(CreateYACS);
GroupButtons->setObjectName(QString::fromUtf8("GroupButtons"));
gridLayout1->addWidget(buttonCancel, 0, 2, 1, 1);
- gridLayout_2->addWidget(GroupButtons, 6, 0, 1, 3);
+ gridLayout_2->addWidget(GroupButtons, 6, 0, 1, 2);
spacer_2 = new QSpacerItem(128, 25, QSizePolicy::Fixed, QSizePolicy::Minimum);
- gridLayout_2->addItem(spacer_2, 6, 3, 1, 1);
+ gridLayout_2->addItem(spacer_2, 6, 2, 1, 1);
retranslateUi(CreateYACS);
PBDir->setText(QString());
MeshFile->setText(QApplication::translate("CreateYACS", "Mesh file", 0, QApplication::UnicodeUTF8));
PBMeshFile->setText(QString());
- RBStatic->setText(QApplication::translate("CreateYACS", "Static", 0, QApplication::UnicodeUTF8));
- RBTransient->setText(QApplication::translate("CreateYACS", "Transient", 0, QApplication::UnicodeUTF8));
+ GBTypeSchema->setTitle(QApplication::translate("CreateYACS", "Type of schema", 0, QApplication::UnicodeUTF8));
+ RBConstant->setText(QApplication::translate("CreateYACS", "Constant", 0, QApplication::UnicodeUTF8));
+ RBVariable->setText(QApplication::translate("CreateYACS", "Variable", 0, QApplication::UnicodeUTF8));
GroupButtons->setTitle(QString());
buttonHelp->setText(QApplication::translate("CreateYACS", "Help", 0, QApplication::UnicodeUTF8));
buttonApply->setText(QApplication::translate("CreateYACS", "Apply", 0, QApplication::UnicodeUTF8));
<rect>
<x>0</x>
<y>0</y>
- <width>537</width>
- <height>304</height>
+ <width>538</width>
+ <height>340</height>
</rect>
</property>
<property name="sizePolicy">
</property>
</widget>
</item>
- <item row="0" column="1" colspan="3">
+ <item row="0" column="1">
<widget class="QLineEdit" name="LEName">
<property name="maxLength">
<number>32</number>
</property>
</widget>
</item>
- <item row="1" column="0" colspan="4">
+ <item row="1" column="0" colspan="3">
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QLabel" name="Case">
</item>
</layout>
</item>
- <item row="2" column="0" colspan="4">
+ <item row="2" column="0" colspan="3">
<layout class="QHBoxLayout" name="_2">
<property name="spacing">
<number>6</number>
</item>
</layout>
</item>
- <item row="3" column="0" colspan="4">
+ <item row="3" column="0" colspan="3">
<layout class="QHBoxLayout">
<property name="spacing">
<number>6</number>
</item>
</layout>
</item>
- <item row="4" column="0" colspan="4">
+ <item row="4" column="0" colspan="3">
<layout class="QHBoxLayout" name="_3">
<property name="spacing">
<number>6</number>
</layout>
</item>
<item row="5" column="0" colspan="2">
- <widget class="QRadioButton" name="RBStatic">
- <property name="text">
- <string>Static</string>
- </property>
- <property name="checked">
- <bool>true</bool>
- </property>
- </widget>
- </item>
- <item row="5" column="2">
- <widget class="QRadioButton" name="RBTransient">
- <property name="text">
- <string>Transient</string>
+ <widget class="QGroupBox" name="GBTypeSchema">
+ <property name="title">
+ <string>Type of schema</string>
</property>
+ <layout class="QHBoxLayout" name="_4">
+ <property name="spacing">
+ <number>6</number>
+ </property>
+ <property name="margin">
+ <number>9</number>
+ </property>
+ <item>
+ <widget class="QRadioButton" name="RBConstant">
+ <property name="text">
+ <string>Constant</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QRadioButton" name="RBVariable">
+ <property name="text">
+ <string>Variable</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
</widget>
</item>
- <item row="6" column="0" colspan="3">
+ <item row="6" column="0" colspan="2">
<widget class="QGroupBox" name="GroupButtons">
<property name="title">
<string/>
</layout>
</widget>
</item>
- <item row="6" column="3">
+ <item row="6" column="2">
<spacer name="spacer_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
<translation>Maillage initial</translation>
</message>
<message>
- <source>Static</source>
- <translation>Statique</translation>
+ <source>Constant</source>
+ <translation>Constant</translation>
</message>
<message>
- <source>Transient</source>
- <translation>Transitoire</translation>
+ <source>Variable</source>
+ <translation>Variable</translation>
+ </message>
+ <message>
+ <source>Type of schema</source>
+ <translation>Type de schema</translation>
</message>
<message>
<source>Edit a file</source>
<translation>Mesh File</translation>
</message>
<message>
- <source>Static</source>
- <translation>Static</translation>
+ <source>Constant</source>
+ <translation>Constant</translation>
</message>
<message>
- <source>Transient</source>
- <translation>Transient</translation>
+ <source>Variable</source>
+ <translation>Variable</translation>
+ </message>
+ <message>
+ <source>Type of schema</source>
+ <translation>Type of schema</translation>
</message>
<message>
<source>Edit a file</source>
connect( PBDir, SIGNAL(pressed()), this, SLOT(SetDirName()));
connect( PBMeshFile, SIGNAL(pressed()), this, SLOT(SetMeshFile()));
- connect( RBStatic, SIGNAL(clicked()), this, SLOT(SetType(1)));
- connect( RBTransient, SIGNAL(clicked()), this, SLOT(SetType(2)));
+ connect( RBConstant, SIGNAL(clicked()), this, SLOT(SetType(1)));
+ connect( RBVariable, SIGNAL(clicked()), this, SLOT(SetType(2)));
connect( buttonOk, SIGNAL(pressed()), this, SLOT(PushOnOK()));
connect( buttonApply, SIGNAL(pressed()), this, SLOT(PushOnApply()));
LEMeshFile->setText(aMeshFile);
int Type=aYACS->GetType();
- if(Type==1) { RBStatic->setChecked(true); }
- else { RBTransient->setChecked(true); };
- RBStatic->setEnabled(false);
- RBTransient->setEnabled(false);
+ if(Type==1) { RBConstant->setChecked(true); }
+ else { RBVariable->setChecked(true); };
+ RBConstant->setEnabled(false);
+ RBVariable->setEnabled(false);
//
adjustSize();
}
ASSERT( myHomardYACS );
return CORBA::Long( myHomardYACS->GetType() );
}
+//=============================================================================
void HOMARD_YACS_i::SetDirName( const char* NomDir )
{
ASSERT( myHomardYACS );
