inside the whole SALOME installation. All the names to be replaced by user are
indicated by the syntax ``<...>``.
-Converting and executing an ADAO command file (JDC) using a shell script
+Converting and executing an ADAO command file (JDC) using a Shell script
------------------------------------------------------------------------
It is possible to convert and execute an ADAO command file (JDC, or ".comm/.py"
files pair, which resides in ``<ADAO JDC file directory>``) automatically by
-using a template shell script containing all the required steps. The user has to
-know where are the main SALOME launching files, and in particular the
-``salome`` one. The directory in which this script resides is symbolically
-named ``<SALOME main installation dir>`` and has to be replaced by the good one
-in the shell file template.
-
-When an ADAO command file is build by the ADAO graphical editor and saved, if
-it is named for example "AdaoStudy1.comm", then a companion file named
+using a template Shell script containing all the required steps. If the SALOME
+main launching command , named ``salome``, is not available in a classical
+terminal, the user has to know where are the main SALOME launching files, and in
+particular the ``salome`` one. The directory in which this script resides is
+symbolically named ``<SALOME main installation dir>`` and has to be replaced by
+the good one in the Shell file template.
+
+When an ADAO command file is build by the ADAO graphical editor and saved, if it
+is named for example "AdaoStudy1.comm", then a companion file named
"AdaoStudy1.py" is automatically created in the same directory. It is named
``<ADAO Python file>`` in the template, and it is converted to YACS as an
-``<ADAO YACS xml scheme>``. After that, it can be executed in console mode using
-the standard YACS console command (see YACS documentation for more information).
+``<ADAO YACS xml scheme>`` as a ".xml" file named "AdaoStudy1.xml". After that,
+this last one can be executed in console mode using the standard YACS console
+command (see YACS documentation for more information).
-In the example, we choose to start and stop the SALOME application server in the
-same script, which is not necessary, but useful to avoid stalling SALOME
-sessions. We choose also to remove the ``<ADAO YACS xml scheme>`` file because
-it is a generated one. The user of this script only need to replace the text
-between these symbols ``<...>``.
+In all launching command Shell files examples, we choose to start and stop the
+SALOME application server in the same script. It is not mandatory, but it is
+useful to avoid stalling SALOME sessions.
-The template of the shell script is the following::
+The simplest example consist in only launching the given YACS sheme, which was
+previously generated by the user in the graphical interface. In this case, after
+having replaced the strings between ``<...>`` symbols, one needs only to save
+the following Shell script::
#!/bin/bash
- USERDIR=<ADAO JDC file directory>
- SALOMEDIR=<SALOME main installation directory>
+ USERDIR="<ADAO JDC file directory>"
+ SALOMEDIR="<SALOME main installation directory>"
$SALOMEDIR/salome start -k -t
- $SALOMEDIR/salome shell -- "python $SALOMEDIR/bin/salome/AdaoYacsSchemaCreator.py $USERDIR/<ADAO Python file> $USERDIR/<ADAO YACS xml scheme>"
$SALOMEDIR/salome shell -- "driver $USERDIR/<ADAO YACS xml scheme>"
$SALOMEDIR/salome shell killSalome.py
- rm -f $USERDIR/<ADAO YACS xml scheme>
-Standard output and errors come on console.
+It is then required to change it to be in executable mode.
+
+A more complete example consist in launching execution of a YACS sheme given by
+the user, having previously verified its availability. For that, replacing the
+text ``<SALOME main installation directory>``, one needs only to save the
+following Shell script::
+
+ #!/bin/bash
+ if (test $# != 1)
+ then
+ echo -e "\nUsage: $0 <ADAO YACS xml scheme>\n"
+ exit
+ else
+ USERFILE="$1"
+ fi
+ if (test ! -e $USERFILE)
+ then
+ echo -e "\nError : the XML file named $USERFILE does not exist.\n"
+ exit
+ else
+ SALOMEDIR="<SALOME main installation directory>"
+ $SALOMEDIR/salome start -k -t
+ $SALOMEDIR/salome shell -- "driver $USERFILE"
+ $SALOMEDIR/salome shell killSalome.py
+ fi
+
+An another example consist in adding the conversion of the ADAO command file
+(JDC, or ".comm/.py" files pair) in an associated YACS scheme (".xml" file). At
+the end of the script, one choose also to remove the ``<ADAO YACS xml scheme>``
+because it is a generated file. For that, after having carefully replaced the
+text ``<SALOME main installation directory>``, one needs only to save the
+following Shell script::
+
+ #!/bin/bash
+ if (test $# != 1)
+ then
+ echo -e "\nUsage: $0 <ADAO YACS xml scheme>\n"
+ exit
+ else
+ D=`dirname $1`
+ F=`basename -s .comm $1`
+ F=`basename -s .py $F`
+ USERFILE="$D/$F"
+ fi
+ if (test ! -e $USERFILE.py)
+ then
+ echo -e "\nError : the PY file named $USERFILE.py does not exist.\n"
+ exit
+ else
+ SALOMEDIR="<SALOME main installation directory>"
+ $SALOMEDIR/salome start -k -t
+ $SALOMEDIR/salome shell -- "python $SALOMEDIR/bin/salome/AdaoYacsSchemaCreator.py $USERFILE.py $USERFILE.xml"
+ $SALOMEDIR/salome shell -- "driver $USERFILE.xml"
+ $SALOMEDIR/salome shell killSalome.py
+ rm -f $USERFILE.xml
+ fi
+
+In all cases, the standard output and errors come in the launching terminal.
Running an ADAO calculation scheme in YACS using a TUI user mode
----------------------------------------------------------------
-----------------------------------------------------------------------------
.. index:: single: Observer
-.. index:: single: Observers
.. index:: single: Observer Template
Some special internal optimization variables, used during calculations, can be
monitored during the ADAO calculation in YACS. These variables can be printed,
-plotted, saved, etc. This can be done using "*observers*", that are scripts,
+plotted, saved, etc. This can be done using "*observer*", that are scripts,
each associated with one variable. In order to use this feature, the user has to
build scripts using as standard inputs (e.g. available in the namespace) the
variables ``var`` and ``info``. The variable ``var`` is to be used in the same
available in the "*SELECTION*" keyword of the "*Observers*" command:
"*Analysis*", "*CurrentState*", "*CostFunction*"... The current value of the
variable will be printed at each step of the optimization or assimilation
-algorithm. The observers can embed plotting capabilities, storage, complex
+algorithm. The "*observer*" can embed plotting capabilities, storage, complex
printing, statistical treatment, etc.
Getting more information when running a calculation
#. Unitary calculation of user defined direct function "last for long time", that is, more than few minutes.
#. The user defined direct function doesn't already use parallelism (or parallel execution is disabled in the user calculation).
#. The user defined direct function avoids read/write access to common resources, mainly stored data, output files or memory capacities.
-#. The observers added by the user avoid read/write access to common resources, such as files or memory.
+#. The "*observer*" added by the user avoid read/write access to common resources, such as files or memory.
If these conditions are satisfied, the user can choose to enable the internal
parallelism for the numerical derivative calculations. Despite the simplicity of
The standard output will be pushed into the "*YACS Container Log*", obtained
through the right click menu of the "*proc*" window in the YACS GUI. The errors
are shown either in the "*YACS Container Log*", or at the command line in the
-shell window (if SALOME has been launched by its explicit command, and not by a
-menu or a desktop icon). As an example, the output of the above simple case is
+terminal window (if SALOME has been launched by its explicit command, and not by
+a menu or a desktop icon). As an example, the output of the above simple case is
of the following form::
Entering in the assimilation study
shown in the "*YACS Container Log*".
-The execution can also be done using a shell script, as described in the section
+The execution can also be done using a Shell script, as described in the section
:ref:`section_advanced`.
.. [#] For more information on EFICAS, see the *EFICAS module* and its integrated help available from the main menu *Help* of the SALOME platform.
fichiers ou les commandes incluses dans l'installation complète de SALOME. Tous
les noms à remplacer par l'utilisateur sont indiqués par la syntaxe ``<...>``.
-Convertir et exécuter un fichier de commandes ADAO (JDC) par l'intermédiaire d'un script shell
+Convertir et exécuter un fichier de commandes ADAO (JDC) par l'intermédiaire d'un script Shell
----------------------------------------------------------------------------------------------
Il est possible de convertir et exécuter une fichier de commandes ADAO (JDC, ou
paire de fichiers ".comm/.py", qui se trouvent dans le répertoire ``<Répertoire
du fichier JDC ADAO>``) automatiquement en utilisant un script de commandes
-shell "type" contenant toutes les étapes requises. L'utilisateur doit savoir où
-se trouvent les principaux fichiers de lancement de SALOME, et en particulier le
-fichier ``salome``. Le répertoire dans lequel ce fichier réside est
-symboliquement nommé ``<Répertoire principal d'installation de SALOME>`` et doit
-être remplacé par le bon dans le modèle "type" de fichier shell.
+Shell "type" contenant toutes les étapes requises. Si la commande principale de
+lancement de SALOME, nommée ``salome``, n'est pas couramment accessible dans un
+terminal courant, l'utilisateur doit savoir où se trouvent les principaux
+fichiers de lancement de SALOME, et en particulier ce fichier ``salome``. Le
+répertoire dans lequel ce fichier réside est symboliquement nommé ``<Répertoire
+principal d'installation de SALOME>`` et doit être remplacé par le bon dans le
+modèle "type" de fichier Shell.
Lorsqu'un fichier de commande ADAO est construit par l'interface d'édition
graphique d'ADAO et est enregistré, s'il est nommé par exemple
"EtudeAdao1.comm", alors un fichier compagnon nommé "EtudeAdao1.py" est
automatiquement créé dans la même répertoire. Il est nommé ``<Fichier Python
ADAO>`` dans le modèle "type", et il est converti vers YACS comme un ``<Schéma
-xml YACS ADAO>``. Ensuite, il peut être exécuté en mode console en utilisant la
-commande standard en mode console de YACS (voir la documentation YACS pour de
-plus amples informations).
-
-Dans l'exemple, on choisit de démarrer et arrêter le serveur d'application
-SALOME dans le même script, ce qui n'est pas nécessaire, mais utile pour éviter
-des sessions SALOME en attente. On choisit aussi de supprimer le fichier de
-``<Schéma xml YACS ADAO>`` car c'est un fichier généré. L'utilisateur de ce
-script a seulement besoin de remplacer le texte contenu entre les symboles
-``<...>``
-
-Le modèle "type" de ce script de commandes shell est le suivant::
+xml YACS ADAO>`` sous la forme d'un fichier en ".xml" nommé "EtudeAdao1.xml".
+Ensuite, ce dernier peut être exécuté en mode console en utilisant l'ordre
+standard du mode console de YACS (voir la documentation YACS pour de plus amples
+informations).
+
+Dans tous les exemples de fichiers de commandes Shell de lancement, on choisit
+de démarrer et arrêter le serveur d'application SALOME dans le même script. Ce
+n'est pas indispensable, mais c'est utile pour éviter des sessions SALOME en
+attente.
+
+L'exemple le plus simple consiste uniquement à lancer l'exécution d'un schéma
+YACS donné, qui a préalablement été généré par l'utilisateur en interface
+graphique. Dans ce cas, en ayant pris soin de remplacer les textes contenus
+entre les symboles ``<...>``, il suffit d'enregistrer le script de commandes
+Shell suivant::
#!/bin/bash
- USERDIR=<Répertoire du fichier JDC ADAO>
- SALOMEDIR=<Répertoire principal d'installation de SALOME>
+ USERDIR="<Répertoire du fichier JDC ADAO>"
+ SALOMEDIR="<Répertoire principal d'installation de SALOME>"
$SALOMEDIR/salome start -k -t
- $SALOMEDIR/salome shell -- "python $SALOMEDIR/bin/salome/AdaoYacsSchemaCreator.py $USERDIR/<Fichier Python ADAO> $USERDIR/<Schéma xml YACS ADAO>"
$SALOMEDIR/salome shell -- "driver $USERDIR/<Schéma xml YACS ADAO>"
$SALOMEDIR/salome shell killSalome.py
- rm -f $USERDIR/<Schéma xml YACS ADAO>
-Les sorties standard et d'erreur se font à la console.
+Il faut ensuite le rendre exécutable pour l'exécuter.
+
+Un exemple une peu plus complet consiste à lancer l'exécution d'un schéma YACS
+indiqué par l'utilisateur, en ayant préalablement vérifié sa disponibilité. Pour
+cela, en remplaçant le texte ``<Répertoire principal d'installation de
+SALOME>``, il suffit d'enregistrer le script de commandes Shell suivant::
+
+ #!/bin/bash
+ if (test $# != 1)
+ then
+ echo -e "\nUsage: $0 <Schéma xml YACS ADAO>\n"
+ exit
+ else
+ USERFILE="$1"
+ fi
+ if (test ! -e $USERFILE)
+ then
+ echo -e "\nErreur : le fichier XML nommé $USERFILE n'existe pas.\n"
+ exit
+ else
+ SALOMEDIR="<Répertoire principal d'installation de SALOME>"
+ $SALOMEDIR/salome start -k -t
+ $SALOMEDIR/salome shell -- "driver $USERFILE"
+ $SALOMEDIR/salome shell killSalome.py
+ fi
+
+Un autre exemple de script consiste à ajouter la conversion du fichier de
+commandes ADAO (JDC, ou paire de fichiers ".comm/.py") en un schéma YACS associé
+(fichier ".xml"). A la fin du script, on choisit aussi de supprimer le fichier
+de ``<Schéma xml YACS ADAO>`` car c'est un fichier généré. Pour cela, en ayant
+bien pris soin de remplacer le texte ``<Répertoire principal d'installation de
+SALOME>``, il suffit d'enregistrer le script de commandes Shell suivant::
+
+ #!/bin/bash
+ if (test $# != 1)
+ then
+ echo -e "\nUsage: $0 <Schéma xml YACS ADAO>\n"
+ exit
+ else
+ D=`dirname $1`
+ F=`basename -s .comm $1`
+ F=`basename -s .py $F`
+ USERFILE="$D/$F"
+ fi
+ if (test ! -e $USERFILE.py)
+ then
+ echo -e "\nErreur : le fichier PY nommé $USERFILE.py n'existe pas.\n"
+ exit
+ else
+ SALOMEDIR="<Répertoire principal d'installation de SALOME>"
+ $SALOMEDIR/salome start -k -t
+ $SALOMEDIR/salome shell -- "python $SALOMEDIR/bin/salome/AdaoYacsSchemaCreator.py $USERFILE.py $USERFILE.xml"
+ $SALOMEDIR/salome shell -- "driver $USERFILE.xml"
+ $SALOMEDIR/salome shell killSalome.py
+ rm -f $USERFILE.xml
+ fi
+
+Dans tous les cas, les sorties standard et d'erreur se font dans le terminal de
+lancement.
Exécuter un schéma de calcul ADAO dans YACS en utilisant le mode "texte" (TUI)
------------------------------------------------------------------------------
--------------------------------------------------------------------------------------
.. index:: single: Observer
-.. index:: single: Observers
.. index:: single: Observer Template
Certaines variables spéciales internes à l'optimisation, utilisées au cours des
calculs, peuvent être surveillées durant un calcul ADAO en YACS. Ces variables
peuvent être affichées, tracées, enregistrées, etc. C'est réalisable en
-utilisant des "*observers*", qui sont des scripts, chacun associé à une
+utilisant des "*observer*", qui sont des scripts, chacun associé à une
variable. Pour pouvoir utiliser cette capacité, l'utilisateur doit construire
des scripts disposant en entrée standard (i.e. disponible dans l'espace de
nommage) des variables ``var`` et ``info``. La variable ``var`` est à utiliser
soit dans l'étape d'édition EFICAS, ou dans l'étape d'édition YACS, pour
améliorer l'adaptation du calcul ADAO dans YACS.
-A titre d'exemple, voici un script trés simple (similaire au modèle
+A titre d'exemple, voici un script très simple (similaire au modèle
"*ValuePrinter*") utilisable pour afficher la valeur d'une variable surveillée::
print " --->",info," Value =",var[-1]
présente dans le mot-clé "*SELECTION*" de la commande "*Observers*":
"*Analysis*", "*CurrentState*", "*CostFunction*"... La valeur courante de la
variable sera affichée à chaque étape de l'algorithme d'optimisation ou
-d'assimilation. Les "*observers*" peuvent inclure des capacités d'affichage
+d'assimilation. Les "*observer*" peuvent inclure des capacités d'affichage
graphique, de stockage, d'affichage complexe, de traitement statistique, etc.
Obtenir plus d'information lors du déroulement d'un calcul
#. Le calcul unitaire de la fonction utilisateur directe "dure un certain temps", c'est-à-dire plus que quelques minutes.
#. La fonction utilisateur directe n'utilise pas déjà du parallélisme (ou l'exécution parallèle est désactivée dans le calcul de l'utilisateur).
#. La fonction utilisateur directe n'effectue pas d'accès en lecture/écriture à des ressources communes, principalement des données stockées, des fichiers de sortie ou des espaces mémoire.
-#. Les observers ajoutés par l'utilisateur n'effectuent pas d'accès en lecture/écriture à des ressources communes, comme des fichiers ou des espaces mémoire.
+#. Les "*observer*" ajoutés par l'utilisateur n'effectuent pas d'accès en lecture/écriture à des ressources communes, comme des fichiers ou des espaces mémoire.
Si ces conditions sont satisfaites, l'utilisateur peut choisir d'activer le
parallélisme interne pour le calcul des dérivées numériques. Malgré la
cas de calcul TUI, on recommande de bien s'appuyer sur l'ensemble de la
documentation du module ADAO, et de se reporter si nécessaire à l'interface
graphique (GUI), pour disposer de l'ensemble des éléments permettant de
-renseigner correctement les commandes.
+renseigner correctement les commandes. Les notions générales et termes utilisés
+ici sont définis dans :ref:`section_theory`.
.. _subsection_tui_creating:
corps du script pour faciliter la lecture. L'ensemble des commandes est le
suivant::
- from numpy import *
+ from numpy import array
import adaoBuilder
case = adaoBuilder.New()
case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
case.execute()
-Le résultat de l'exécution de ces commandes dans SALOME (dans le shell SALOME,
-dans la console Python de l'interface, ou par le menu d'exécution d'un script)
-est le suivant::
+Le résultat de l'exécution de ces commandes dans SALOME (que ce soit par la
+commande "*shell*" de SALOME, dans la console Python de l'interface, ou par le
+menu d'exécution d'un script) est le suivant::
Analysis [ 0.25000264 0.79999797 0.94999939]
le nom ``case`` de l'objet du cas de calcul TUI ADAO étant quelconque, au choix
de l'utilisateur::
- from numpy import *
+ from numpy import array
import adaoBuilder
case = adaoBuilder.New()
-Il est recommandé d'importer par principe le module ``numpy``, sous cette forme
-particulière ``from ... import *``, pour faciliter ensuite son usage dans les
-commandes elle-mêmes.
+Il est recommandé d'importer par principe le module ``numpy`` ou ses
+constructeurs particuliers comme celui d'``array``, pour faciliter ensuite son
+usage dans les commandes elle-mêmes.
Ensuite, le cas doit être construit par une préparation et un enregistrement des
données définissant l'étude. L'ordre de ces commande n'a pas d'importance, il
reportera à :ref:`section_reference` et à ses sous-parties pour avoir le détail
des commandes par algorithme. Ici, on définit successivement l'algorithme
d'assimilation de données ou d'optimisation choisi et ses paramètres, puis
-l'ébauche :math:`\mathbf{x}^b` et sa covariance d'erreurs :math:`\mathbf{B}`, et
-enfin l'observation :math:`\mathbf{y}^o` et sa covariance d'erreurs
-:math:`\mathbf{R}`::
+l'ébauche :math:`\mathbf{x}^b` (nommée ``Background``) et sa covariance
+d'erreurs :math:`\mathbf{B}` (nommée ``BackgroundError``), et enfin
+l'observation :math:`\mathbf{y}^o` (nommée ``Observation``) et sa covariance
+d'erreurs :math:`\mathbf{R}` (nommée ``ObservationError``)::
case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
#
case.set( 'ObservationError', DiagonalSparseMatrix='1 1 1' )
On remarque que l'on peut donner en entrée des quantités vectorielles des objets
-de type ``list``, ``tuple``, ``array`` ou ``matrix`` de Numpy.
+de type ``list``, ``tuple``, ``array`` ou ``matrix`` de Numpy. Dans ces deux
+derniers cas, il faut simplement importer Numpy avant.
On doit ensuite définir les opérateurs :math:`H` d'observation et éventuellement
:math:`M` d'évolution. Dans tous les cas, linéaire ou non-linéaire, on peut les
case.ObservationOperator(Matrix = "1 0 0;0 2 0;0 0 3")
-Dans le cas beaucoup plus courant d'un opérateur non-linéaire, il doit être
-préalablement disponible sous la forme d'une fonction Python connue dans
-l'espace de nommage courant. L'exemple suivant montre une fonction
-``simulation`` (qui réalise ici le même opérateur linéaire que ci-dessus) et
-l'enregistre dans le cas ADAO::
+Dans le cas beaucoup plus courant d'un opérateur non-linéaire de
+:math:`\mathbf{R}^n` dans :math:`\mathbf{R}^p`, il doit être préalablement
+disponible sous la forme d'une fonction Python, connue dans l'espace de nommage
+courant, qui prend en entrée un vecteur ``numpy`` (ou une liste ordonnée) de
+taille :math:`n` et qui restitue en sortie un vecteur ``numpy`` de taille
+:math:`p`. Lorsque seul l'opérateur non-linéaire est défini par l'argument
+"*OneFunction*", son adjoint est directement établi de manière numérique et il
+est paramétrable par l'argument "*Parameters*". L'exemple suivant montre une
+fonction ``simulation`` (qui réalise ici le même opérateur linéaire que
+ci-dessus) et l'enregistre dans le cas ADAO::
+ import numpy
def simulation(x):
- import numpy
+ "Fonction de simulation H pour effectuer Y=H(X)"
__x = numpy.matrix(numpy.ravel(numpy.matrix(x))).T
__H = numpy.matrix("1 0 0;0 2 0;0 0 3")
return __H * __x
)
Pour connaître les résultats intermédiaire ou finaux du calcul du cas, on peut
-ajouter des observers, qui permettent d'associer l'exécution d'un script à une
-variable interne ou finale du calcul. On se reportera à la description de la
+ajouter des "*observer*", qui permettent d'associer l'exécution d'un script à
+une variable interne ou finale du calcul. On se reportera à la description de la
manière d':ref:`section_advanced_observer`, et à la :ref:`section_reference`
pour savoir quelles sont les quantités observables. Cette association
-d'observers avec une quantité existante se fait de manière similaire à la
+d'"*observer*" avec une quantité existante se fait de manière similaire à la
définition des données du calcul::
case.set( 'Observer', Variable="Analysis", Template="ValuePrinter" )
en TUI.
Les variables de résultats de calcul, ou les variables internes issues de
-l'optimisation sont disponible à travers la méthode ``get`` du cas de calcul TUI
+l'optimisation sont disponibles à travers la méthode ``get`` du cas de calcul TUI
ADAO, qui renvoie un objet de type liste de la variable demandée. On se
reportera aux :ref:`section_ref_output_variables` pour une description détaillée
sur ce sujet.
taille::
print
- print " Nombre d'iterations :",len(case.get("CostFunctionJ"))
+ print " Nombre d'iterations :", len(case.get("CostFunctionJ"))
Xa = case.get("Analysis")
- print " Analyse optimale :",Xa[-1]
- print " Taille de l'analyse :",len(Xa[-1])
+ print " Analyse optimale :", Xa[-1]
+ print " Taille de l'analyse :", len(Xa[-1])
print
Ces lignes peuvent être très simplement additionnées à l'exemple initial de cas
gammamin, gammamax = 1.5, 15.5
#
def simulation(x):
+ "Fonction de simulation H pour effectuer Y=H(X)"
import numpy
__x = numpy.matrix(numpy.ravel(numpy.matrix(x))).T
__H = numpy.matrix("1 0 0;0 2 0;0 0 3; 1 2 3")
# TUI ADAO
# --------
case = adaoBuilder.New()
- case.set( 'AlgorithmParameters',
+ case.set(
+ 'AlgorithmParameters',
Algorithm = '3DVAR',
Parameters = {
"Bounds":Bounds,
case.set( 'Observation', Vector = numpy.array(observations) )
case.set( 'BackgroundError', ScalarSparseMatrix = 1.0e10 )
case.set( 'ObservationError', ScalarSparseMatrix = 1.0 )
- case.set( 'ObservationOperator',
+ case.set(
+ 'ObservationOperator',
OneFunction = simulation,
Parameters = {"DifferentialIncrement":0.0001},
)
présentée dans la "*fenêtre de sortie de YACS*".
-L'exécution peut aussi être conduite en utilisant un script de commandes shell,
+L'exécution peut aussi être conduite en utilisant un script de commandes Shell,
comme décrit dans la section :ref:`section_advanced`.
.. [#] Pour de plus amples informations sur EFICAS, voir le *module EFICAS* et son aide intégrée disponible dans le menu principal *Aide* de l'environnement SALOME.
class New(object):
"""
- Creation TUI d'un cas ADAO sans lien avec YACS
+ Creation TUI d'un cas ADAO
"""
def __init__(self, name = ""):
- self.__adaoStudy = AssimilationStudy.AssimilationStudy( name )
+ self.__adaoStudy = AssimilationStudy.AssimilationStudy(name)
self.__dumper = _DumpLogger(name)
# -----------------------------------------------------------
self.__dumper.register("get",dir(),locals(),Concept)
return self.__adaoStudy.get(Concept)
- def dumpNormalizedCommands(self):
- "Récupération de la liste des commandes de création d'un cas"
- return self.__dumper.dump()
+ def dumpNormalizedCommands(self, filename=None):
+ "Récupération de la liste des commandes du cas"
+ return self.__dumper.dump(filename)
-# def UserPostAnalysis(self):
-# raise NotImplementedError()
-#
-# def StudyRepertory(self):
-# raise NotImplementedError()
+ def __dir__(self):
+ return ['set', 'get', 'execute', '__doc__', '__init__', '__module__']
class _DumpLogger(object):
"""
Conservation des commandes de création d'un cas
"""
- def __init__(self,__name="",__objname="case"):
+ def __init__(self, __name="", __objname="case"):
+ self.__name = str(__name)
+ self.__objname = str(__objname)
self.__logSerie = []
- # self.__logSerie.append("#-*-coding:iso-8859-1-*-\n#")
- # self.__logSerie.append("# Copyright (C) 2008-2015 EDF R&D\n#")
- self.__logSerie.append("#\n# Python script for ADAO\n#")
- self.__logSerie.append("from numpy import *")
- self.__logSerie.append("import adaoBuilder")
- self.__logSerie.append("%s = adaoBuilder.New('%s')"%(__objname,__name))
self.__switchoff = False
+ self.__logSerie.append("#\n# Python script for ADAO TUI\n#")
+ self.__logSerie.append("from numpy import array, matrix")
+ self.__logSerie.append("import adaoBuilder")
+ self.__logSerie.append("%s = adaoBuilder.New('%s')"%(self.__objname, self.__name))
def register(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
"Enregistrement d'une commande individuelle"
if __command is not None and __keys is not None and __local is not None and not self.__switchoff:
__text = ""
if __pre is not None:
__text += "%s = "%__pre
- __text += "case.%s( "%str(__command)
+ __text += "%s.%s( "%(self.__objname,str(__command))
__keys.remove("self")
for k in __keys:
__v = __local[k]
self.__switchoff = True
if not __switchoff:
self.__switchoff = False
- def dump(self,__filename=None):
+ def dump(self, __filename=None):
"Restitution de la liste des commandes de création d'un cas"
- if __filename is None:
- return "\n".join(self.__logSerie)
- else:
+ __text = "\n".join(self.__logSerie)
+ if __filename is not None:
fid = open(__filename,"w")
- fid.writelines(self.__logSerie)
+ fid.write(__text)
fid.close()
+ return __text
class _ObserverF(object):
"""
