executed in the same way, and they give the same result as in the standard
Python interface.
+.. _section_advanced_execution_mode:
+
+Change the default execution mode of nodes in YACS
+--------------------------------------------------
+
+.. index:: single: YACS
+
+Various reasons may lead to want to change the default mode of node execution
+in YACS (see [#]_ for the correct use of these possibilities). This may be for
+performance reasons, or for example for reasons of resource conflicts.
+
+One may want to use this change in execution mode to extend the use of local
+computing resources or to set remote calculations for a node that requires it.
+This is particularly the case for a node that should use a simulation resource
+available on a cluster, for example.
+
+In addition, the various calculations that are carried out (user-provided
+operators, results retrieval functions, etc.) may also present conflicts if
+they are performed in a single process, and in particular in the main process
+of SALOME. This is the default YACS operating mode for performance and
+simplicity reasons. However, it is recommended to change this functioning when
+encountering execution instabilities or error messages in the graphical
+interface.
+
+In any case, in the YACS schema being edited, it is sufficient to change the
+execution mode of the node(s) that require it. They have to be executed in a
+new container created for the occasion (it is not enough to use the default
+container, it is explicitly necessary to create a new one) and whose properties
+are adapted to the intended use. The procedure is therefore as follows:
+
+#. Create a new YACS container, using the context menu in the tree view of the YACS schema (usually on the left),
+#. Adapt the characteristics of the container, for example by selecting a "*type*" property with the value "*multi*" for a truly parallel execution, or by choosing a remote computing resource defined by the "*Resource*" property, or by using advanced parameters,
+#. Graphically select in the central view the node whose execution mode you want to change,
+#. In the panel to the right of the node entries, unfold the execution choices (named "*Execution Mode*"), check the "*Container*" box instead of the "*YACS*" default, and choose the newly created container (it is usually named "*container0*"),
+#. Save the modified schema
+
+This can be repeated for each node that requires it, by reusing the same new
+container for all nodes, or by creating a new container for each node.
+
+.. warning::
+
+ this change in execution mode is extremely powerful and flexible. It is
+ therefore recommended that the user both use it, and at the same time be
+ attentive to the interaction of the different choices he makes, to avoid, for
+ example, an unintended performance deterioration, or computer conflicts that
+ are complicated to diagnose.
+
.. _section_advanced_observer:
-Getting information on special variables during the ADAO calculation in YACS
------------------------------------------------------------------------------
+Getting information on special variables during the ADAO calculation
+--------------------------------------------------------------------
.. index:: single: Observer
.. index:: single: Observer Template
names are "*DirectOperator*", "*TangentOperator*" and "*AdjointOperator*", as
described in the last subsection of the chapter :ref:`section_reference`. The
operator script files has to be modified.
+
+.. [#] For more information on YACS, see the *YACS module* and its integrated help available from the main menu *Help* of the SALOME platform.
ê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_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
"*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.
**Schéma YACS généré à partir du cas ADAO**
Après ce point, toutes les modifications, exécutions et post-processing du
-schéma d'assimilation de données seront effectués dans le module YACS. De
-manière à vérifier les résultats d'une manière simple, on utilise le noeud
+schéma d'assimilation de données seront effectués dans le module YACS. De façon
+à vérifier les résultats d'une manière simple, on utilise le noeud
"*UserPostAnalysis*" (ou on crée ici un nouveau noeud YACS par le sous-menu
"*Noeud de script in-line*" dans la vue graphique de YACS).
YACS pour la tester, et ensuite entièrement enregistrée dans un script Python
qui peut être intégré au cas ADAO en utilisant le mot-clé "*UserPostAnalysis*".
-Ensuite, de manière classique dans YACS, le schéma doit être compilé, et ensuite
-être exécuté. Après la fin de l'exécution, les affichages sur la sortie standard
+Ensuite, de manière classique dans YACS, le schéma doit être compilé, et être
+exécuté. Après la fin de l'exécution, les affichages sur la sortie standard
sont disponibles dans la fenêtre "*fenêtre de sortie de YACS*" (ou "*YACS
Container Log*"), obtenue par clic droit à l'aide du menu contextuel de la
fenêtre "*proc*" du schéma YACS comme montré ci-dessous:
