..
- Copyright (C) 2008-2018 EDF R&D
+ Copyright (C) 2008-2021 EDF R&D
This file is part of SALOME ADAO module.
du fichier JDC ADAO>``) automatiquement en utilisant un script de commandes
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
+terminal standard, 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
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::
+Shell suivant :
+::
#!/bin/bash
USERDIR="<Répertoire du fichier JDC ADAO>"
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
+Un exemple un 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::
+SALOME>``, il suffit d'enregistrer le script de commandes Shell suivant :
+::
#!/bin/bash
if (test $# != 1)
(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::
+SALOME>``, il suffit d'enregistrer le script de commandes Shell suivant :
+::
#!/bin/bash
if (test $# != 1)
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 -- "python $SALOMEDIR/bin/AdaoYacsSchemaCreator.py $USERFILE.py $USERFILE.xml"
$SALOMEDIR/salome shell -- "driver $USERFILE.xml"
$SALOMEDIR/salome shell killSalome.py
rm -f $USERFILE.xml
un schéma XML peut être chargé en python. On donne ici une séquence complète de
commandes pour tester la validité du schéma avant de l'exécuter, ajoutant des
lignes supplémentaires initiales pour charger de manière explicite le catalogue
-de types pour éviter d'obscures difficultés::
+de types pour éviter d'obscures difficultés :
+::
#-*- coding: utf-8 -*-
import pilot
try:
p = xmlLoader.load("<Schéma xml YACS ADAO>")
except IOError,ex:
- print "IO exception:",ex
+ print("IO exception:",ex)
logger = p.getLogger("parser")
if not logger.isEmpty():
- print "The imported file has errors :"
- print logger.getStr()
+ print("The imported file has errors :")
+ print(logger.getStr())
if not p.isValid():
- print "Le schéma n'est pas valide et ne peut pas être exécuté"
- print p.getErrorReport()
+ print("Le schéma n'est pas valide et ne peut pas être exécuté")
+ print(p.getErrorReport())
info=pilot.LinkInfo(pilot.LinkInfo.ALL_DONT_STOP)
p.checkConsistency(info)
if info.areWarningsOrErrors():
- print "Le schéma n'est pas cohérent et ne peut pas être exécuté"
- print info.getGlobalRepr()
+ print("Le schéma n'est pas cohérent et ne peut pas être exécuté")
+ print(info.getGlobalRepr())
e = pilot.ExecutorSwig()
e.RunW(p)
if p.getEffectiveState() != pilot.DONE:
- print p.getErrorReport()
+ print(p.getErrorReport())
Cette démarche permet par exemple d'éditer le schéma YACS XML en mode texte TUI,
ou de rassembler les résultats pour un usage ultérieur.
détails). Ce dernier est disponible dans SALOME en lançant l'interpréteur R dans
le shell "``salome shell``". Il faut de plus disposer, en R, du package
"*rPython*", qui peut si nécessaire être installé par l'utilisateur à l'aide de
-la commande R suivante::
+la commande R suivante :
+::
#-*- coding: utf-8 -*-
#
utilisant des données et des informations depuis R. La démarche est illustrée
sur :ref:`subsection_tui_example`, proposé dans la description de l'interface
API/TUI. Dans l'interpréteur R, on peut exécuter les commandes suivantes,
-directement issues de l'exemple simple::
+directement issues de l'exemple simple :
+::
#-*- coding: utf-8 -*-
#
library(rPython)
python.exec("
from numpy import array
- import adaoBuilder
+ from adao import adaoBuilder
case = adaoBuilder.New()
case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
case.set( 'Background', Vector=[0, 1, 2] )
case.execute()
")
-dont le résultat est::
+dont le résultat est :
+::
Analysis [ 0.25000264 0.79999797 0.94999939]
oeuvre. On peut transformer l'exemple ci-dessus pour utiliser des données
provenant de R pour alimenter les trois variables d'ébauche, d'observation et
d'opérateur d'observation. On récupère à la fin l'état optimal dans une variable
-R aussi. Les autres lignes sont identiques. L'exemple devient ainsi::
+R aussi. Les autres lignes sont identiques. L'exemple devient ainsi :
+::
#-*- coding: utf-8 -*-
#
python.assign( "h", h )
python.exec("
from numpy import array
- import adaoBuilder
+ from adao import adaoBuilder
case = adaoBuilder.New()
case.set( 'AlgorithmParameters', Algorithm='3DVAR' )
case.set( 'Background', Vector=xb )
être exécutés de la même manière, et ils donnent le même résultat que dans
l'interface API/TUI en Python standard.
+.. _section_advanced_eficas_gui:
+
+Utiliser l'interface graphique EFICAS d'ADAO comme une commande TUI d'ADAO
+--------------------------------------------------------------------------
+
+Pour faciliter l'édition rapide avec EFICAS d'ADAO d'un fichier de commandes
+ADAO (JDC, ou paire de fichiers ".comm/.py", qui se trouvent ensemble dans un
+répertoire d'étude de l'utilisateur), on peut lancer l'interface graphique
+directement depuis l'interpréteur Python. Pour cela, dans un interpréteur
+Python obtenu depuis le "SALOME shell", on utilise les commandes suivantes :
+::
+
+ from adao import adaoBuilder
+ adaoBuilder.Gui()
+
+Si nécessaire, des messages explicites permettent d'identifier les variables
+d'environnement requises qui seraient absentes. Cette commande ne doit
+néanmoins pas être lancée dans la console Python de SALOME (car dans ce cas il
+suffit d'activer le module puisque l'on est déjà dans l'interface
+graphique...), mais elle peut l'être dans une session "SALOME shell" obtenue
+depuis le menu "Outils/Extensions" de SALOME. Pour mémoire, le moyen le plus
+simple d'obtenir un interpréteur Python inclu dans une session "SALOME shell"
+est de lancer la commande suivante dans un terminal :
+::
+
+ $SALOMEDIR/salome shell -- python
+
+avec ``SALOMEDIR`` le ``<Répertoire principal d'installation de SALOME>``.
+
+.. _section_advanced_execution_mode:
+
+Changer le mode par défaut d'exécution de noeuds dans YACS
+----------------------------------------------------------
+
+.. index:: single: YACS
+
+Diverses raisons peuvent conduire à vouloir modifier le mode par défaut
+d'exécution de noeuds dans YACS (voir [#]_ pour le bon usage de ces
+possibilités). Cela peut être pour des raisons de performances, ou par exemple
+pour des raisons de conflits de ressources.
+
+On peut vouloir utiliser ce changement de mode d'exécution pour étendre l'usage
+des ressources de calcul locales ou pour déporter les calculs d'un noeud qui le
+nécessite. C'est en particulier le cas d'un noeud qui devrait utiliser une
+ressource de simulation disponible sur un cluster par exemple.
+
+Par ailleurs, les divers calculs qui sont menés (opérateurs fournis par
+l'utilisateur, fonctions de restitution des résultats, etc.) peuvent aussi
+présenter des conflits s'ils sont exécutés dans un processus unique, et en
+particulier dans le processus principal de SALOME. C'est le fonctionnement par
+défaut de YACS pour des raisons de performances et de simplicité. Il est
+néanmoins recommandé de changer ce fonctionnement lorsque l'on rencontre des
+instabilités d'exécution ou des messages d'erreur au niveau de l'interface
+graphique.
+
+Dans tous les cas, dans le schéma YACS en édition, il suffit de changer le mode
+d'exécution du ou des noeuds qui le nécessitent. Il faut les exécuter dans un
+nouveau conteneur créé pour l'occasion (il ne suffit pas d'utiliser le
+conteneur par défaut, il faut explicitement en créer un nouveau) et dont les
+caractéristiques sont adaptées à l'usage visé. La démarche est donc la suivante
+:
+
+#. Créer un nouveau conteneur YACS, par utilisation du menu contextuel des "*Containers*" dans la vue arborescente du schéma YACS (usuellement à gauche),
+#. Adapter les caractéristiques du conteneur, en sélectionnant par exemple une propriété de "*type*" valant "*multi*" pour une exécution véritablement parallèle, ou en choisissant une ressource distante de calcul définie par la propriété de "*Resource*", ou en utilisant les paramètres avancés,
+#. Sélectionner graphiquement dans la vue centrale le noeud dont on veut changer le mode d'exécution,
+#. Dans le panneau à droite des entrées du noeud, déplier les choix d'exécution (nommés "*Execution Mode"*), cocher la case "*Container*" à la place du défaut "*YACS*", et choisir le conteneur nouvellement créé (il porte usuellement le nom "*container0*"),
+#. Enregistrer le schéma YACS modifié.
+
+On peut répéter cette démarche pour chaque noeud qui le nécessite, en
+réutilisant le même nouveau conteneur pour tous les noeuds, ou en créant un
+nouveau conteneur pour chaque noeud.
+
+.. warning::
+
+ ce changement de mode d'exécution est extrêmement puissant et souple. Il est
+ donc recommandé à l'utilisateur à la fois de l'utiliser, et en même temps
+ d'être attentif à l'interaction des différents choix qu'il effectue, pour
+ éviter par exemple une dégradation involontaire des performances, ou des
+ conflits informatiques compliqués à diagnostiquer.
+
.. _section_advanced_observer:
-Obtenir des informations sur des variables spéciales au cours d'un calcul ADAO en YACS
---------------------------------------------------------------------------------------
+Obtenir des informations sur des variables spéciales au cours d'un calcul ADAO
+------------------------------------------------------------------------------
.. index:: single: Observer
.. index:: single: Observer Template
d'exécution de SALOME.
Pour mettre en oeuvre ces "*observer*" de manière efficace, on se reportera aux
-:ref:`ref_observers_requirements`.
+:ref:`section_ref_observers_requirements`.
+
+.. _section_advanced_logging:
Obtenir plus d'information lors du déroulement d'un calcul
----------------------------------------------------------
"*ERROR*", "*CRITICAL*". Toutes les informations associées à un niveau sont
affichées à tous les niveaux au-dessus de celui-ci (inclut). La méthode la plus
facile consiste à changer le niveau de surveillance en utilisant les lignes
-Python suivantes::
+Python suivantes :
+::
import logging
logging.getLogger().setLevel(logging.DEBUG)
Lors de la définition d'un opérateur, comme décrit dans le chapitre des
:ref:`section_ref_operator_requirements`, l'utilisateur peut choisir la forme
fonctionnelle "*ScriptWithOneFunction*". Cette forme conduit explicitement à
-approximer les opérateurs tangent et adjoint par un calcul par différences
-finies. Il requiert de nombreux appels à l'opérateur direct (fonction définie
-par l'utilisateur), au moins autant de fois que la dimension du vecteur d'état.
-Ce sont ces appels qui peuvent être potentiellement exécutés en parallèle.
-
-Sous certaines conditions, il est alors possible d'accélérer les calculs de
-dérivées numériques en utilisant un mode parallèle pour l'approximation par
-différences finies. Lors de la définition d'un cas ADAO, c'est effectué en
-ajoutant le mot-clé optionnel "*EnableMultiProcessing*", mis à "1", de la
-commande "*SCRIPTWITHONEFUNCTION*" dans la définition de l'opérateur. Le mode
-parallèle utilise uniquement des ressources locales (à la fois multi-coeurs ou
-multi-processeurs) de l'ordinateur sur lequel SALOME est en train de tourner,
-demandant autant de ressources que disponible. Si nécessaire, on peut réduire
-les ressources disponibles en limitant le nombre possible de processus
-parallèles grâce au mot-clé optionnel "*NumberOfProcesses*", que l'on met au
-maximum souhaité (ou à "0" pour le contrôle automatique, qui est la valeur par
-défaut). Par défaut, ce mode parallèle est désactivé
-("*EnableMultiProcessing=0*").
+approximer les opérateurs tangent et adjoint (s'ils sont nécessaires) par un
+calcul par différences finies. Cela requiert de nombreux appels à l'opérateur
+direct (qui est la fonction définie par l'utilisateur), au moins autant de fois
+que la dimension du vecteur d'état. Ce sont ces appels qui peuvent être
+potentiellement exécutés en parallèle.
+
+Sous certaines conditions (décrites juste après), il est possible d'accélérer
+les calculs de dérivées numériques en utilisant un mode parallèle pour
+l'approximation par différences finies. Lors de la définition d'un cas ADAO,
+c'est effectué en ajoutant le mot-clé optionnel "*EnableMultiProcessing*", mis
+à "*1*" ou à "*True*". Ce mot-clé est inclus à la commande
+"*SCRIPTWITHONEFUNCTION*" dans la définition de l'opérateur par interface
+graphique, ou aux "*Parameters*" accompagnant la commande "*OneFunction*" par
+interface textuelle. Par défaut, ce mode parallèle est désactivé
+("*EnableMultiProcessing=0*"). Le mode parallèle utilise uniquement des
+ressources locales (à la fois multi-coeurs ou multi-processeurs) de
+l'ordinateur sur lequel l'exécution est en train de se dérouler, demandant par
+défaut autant de ressources que disponible. Si nécessaire, on peut réduire les
+ressources disponibles en limitant le nombre possible de processus parallèles
+grâce au mot-clé optionnel "*NumberOfProcesses*", que l'on met au nombre
+maximal souhaité (ou à "*0*" pour le contrôle automatique, qui est la valeur
+par défaut).
Les principales conditions pour réaliser ces calculs parallèles viennent de la
fonction définie par l'utilisateur, qui représente l'opérateur direct. Cette
"*multi*" pour le lancement du schéma, pour permettre une exécution
véritablement parallèle.
+.. _subsection_new_adao_version:
+
Passer d'une version d'ADAO à une nouvelle
------------------------------------------
version ne peut pas être lu par une précédente version mineure ou majeure du
module ADAO.
+Passer de la version 9.x à la 9.y avec y > x
+++++++++++++++++++++++++++++++++++++++++++++
+
+Il n'y a pas d'incompatibilité connue pour les fichiers de cas ADAO. La
+procédure de montée en version consiste à lire l'ancien fichier de cas ADAO
+avec le nouveau module SALOME/ADAO, et à l'enregistrer avec un nouveau nom.
+
Passer de la version 8.5 à la 9.2
+++++++++++++++++++++++++++++++++
ce cas, il est suggéré de corriger la syntaxe des fichiers utilisateurs dans
l'environnement 8 avant de passer en environnement 9.
-Passer de la version 8.x à la 8.y avec x < y
+Passer de la version 8.x à la 8.y avec y > x
++++++++++++++++++++++++++++++++++++++++++++
Il n'y a pas d'incompatibilité connue pour les fichiers de cas ADAO. La
ce que vos fichiers scripts utilisateurs utilisent une syntaxe compatible avec
Python 2 et avec Python 3. En particulier, on recommande d'utiliser la syntaxe
fonctionnelle pour les "*print*" et non pas la syntaxe "*commande*", comme par
-exemple::
+exemple :
+::
# Python 2 & 3
x, unit = 1., "cm"
print( "x = %s %s"%(str(x),str(unit)) )
-ou::
+ou :
+::
# Python 2 & 3
x, unit = 1., "cm"
print( "x = {0} {1}".format(str(x),str(unit)) )
-plutôt que::
+plutôt que :
+::
# Python 2 uniquement
x, unit = 1., "cm"
procédure de montée en version consiste à lire l'ancien fichier de cas ADAO
avec le nouveau module SALOME/ADAO, et à l'enregistrer avec un nouveau nom.
-Passer de la version 7.x à la 7.y avec x < y
+Passer de la version 7.x à la 7.y avec y > x
++++++++++++++++++++++++++++++++++++++++++++
Il n'y a pas d'incompatibilité connue pour les fichiers de cas ADAO. La
Il y a une incompatibilité introduite dans les fichiers de script de
post-processing ou d'observers. L'ancienne syntaxe pour interroger un objet
résultat, comme celui d'analyse "*Analysis*" (fourni dans un script à travers le
-mot-clé "*UserPostAnalysis*"), était par exemple::
+mot-clé "*UserPostAnalysis*"), était par exemple :
+::
Analysis = ADD.get("Analysis").valueserie(-1)
Analysis = ADD.get("Analysis").valueserie()
La nouvelle syntaxe est entièrement compatible avec celle (classique) pour les
-objets de type liste ou tuple::
+objets de type liste ou tuple :
+::
Analysis = ADD.get("Analysis")[-1]
Analysis = ADD.get("Analysis")[:]
Les scripts de post-processing doivent être modifiés.
-Passer de la version 6.x à la 6.y avec x < y
+Passer de la version 6.x à la 6.y avec y > x
++++++++++++++++++++++++++++++++++++++++++++
Il n'y a pas d'incompatibilité connue pour les fichiers de cas ADAO. La
"*TangentOperator*" et "*AdjointOperator*", comme décrit dans la quatrième
partie du chapitre :ref:`section_reference`. Les fichiers de script d'opérateur
doivent être modifiés.
+
+.. [#] Pour de plus amples informations sur YACS, voir le *module YACS* et son aide intégrée disponible dans le menu principal *Aide* de l'environnement SALOME.
