From: Jean-Philippe ARGAUD Date: Sat, 11 Apr 2015 15:54:51 +0000 (+0200) Subject: Minor documentation and source improvements X-Git-Tag: V7_6_0~20 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=3e3652e1a0c5470f8d58fa5e5c2c0ab7fce8f1b2;p=modules%2Fadao.git Minor documentation and source improvements --- diff --git a/doc/en/advanced.rst b/doc/en/advanced.rst index 3671f88..f936836 100644 --- a/doc/en/advanced.rst +++ b/doc/en/advanced.rst @@ -33,42 +33,100 @@ interface (GUI). It requires to know how to find files or commands included 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 ````) 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 ```` 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 ```` 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 ```` in the template, and it is converted to YACS as an -````. After that, it can be executed in console mode using -the standard YACS console command (see YACS documentation for more information). +```` 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 ```` 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= - SALOMEDIR= + USERDIR="" + SALOMEDIR="" $SALOMEDIR/salome start -k -t - $SALOMEDIR/salome shell -- "python $SALOMEDIR/bin/salome/AdaoYacsSchemaCreator.py $USERDIR/ $USERDIR/" $SALOMEDIR/salome shell -- "driver $USERDIR/" $SALOMEDIR/salome shell killSalome.py - rm -f $USERDIR/ -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 ````, one needs only to save the +following Shell script:: + + #!/bin/bash + if (test $# != 1) + then + echo -e "\nUsage: $0 \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="" + $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 ```` +because it is a generated file. For that, after having carefully replaced the +text ````, one needs only to save the +following Shell script:: + + #!/bin/bash + if (test $# != 1) + then + echo -e "\nUsage: $0 \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="" + $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 ---------------------------------------------------------------- @@ -130,12 +188,11 @@ Getting information on special variables during the ADAO calculation in YACS ----------------------------------------------------------------------------- .. 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 @@ -155,7 +212,7 @@ Stored in a Python file, this script can be associated to each variable 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 @@ -231,7 +288,7 @@ the following ones: #. 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 diff --git a/doc/en/using.rst b/doc/en/using.rst index 6daef08..ce822c6 100644 --- a/doc/en/using.rst +++ b/doc/en/using.rst @@ -233,8 +233,8 @@ using breakpoints, etc. 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 @@ -246,7 +246,7 @@ of the following form:: 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. diff --git a/doc/fr/advanced.rst b/doc/fr/advanced.rst index 9ee07d1..28ff5ff 100644 --- a/doc/fr/advanced.rst +++ b/doc/fr/advanced.rst @@ -33,46 +33,107 @@ l'interface graphique (GUI). Cela n 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 ````) 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é ```` 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é ```` 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é ```` dans le modèle "type", et il est converti vers YACS comme un ````. 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 -```` 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= - SALOMEDIR= + USERDIR="" + SALOMEDIR="" $SALOMEDIR/salome start -k -t - $SALOMEDIR/salome shell -- "python $SALOMEDIR/bin/salome/AdaoYacsSchemaCreator.py $USERDIR/ $USERDIR/" $SALOMEDIR/salome shell -- "driver $USERDIR/" $SALOMEDIR/salome shell killSalome.py - rm -f $USERDIR/ -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 ````, il suffit d'enregistrer le script de commandes Shell suivant:: + + #!/bin/bash + if (test $# != 1) + then + echo -e "\nUsage: $0 \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="" + $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 ```` car c'est un fichier généré. Pour cela, en ayant +bien pris soin de remplacer le texte ````, il suffit d'enregistrer le script de commandes Shell suivant:: + + #!/bin/bash + if (test $# != 1) + then + echo -e "\nUsage: $0 \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="" + $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) ------------------------------------------------------------------------------ @@ -136,13 +197,12 @@ Obtenir des informations sur des variables sp -------------------------------------------------------------------------------------- .. 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 @@ -154,7 +214,7 @@ l' 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] @@ -163,7 +223,7 @@ Stock 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 @@ -244,7 +304,7 @@ op #. 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 diff --git a/doc/fr/tui.rst b/doc/fr/tui.rst index 55fa8a5..41b3a93 100644 --- a/doc/fr/tui.rst +++ b/doc/fr/tui.rst @@ -42,7 +42,8 @@ l'interface graphique (GUI). Dans le cas o 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: @@ -59,7 +60,7 @@ de cas de calcul ADAO. Toutes les donn 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' ) @@ -71,9 +72,9 @@ suivant:: 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] @@ -88,13 +89,13 @@ L'initialisation et la cr 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 @@ -102,9 +103,10 @@ suffit que les concepts requis par l'algorithme utilis 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' ) # @@ -115,7 +117,8 @@ enfin l'observation :math:`\mathbf{y}^o` et sa covariance d'erreurs 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 @@ -126,14 +129,20 @@ suivante pour un op 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 @@ -144,11 +153,11 @@ l'enregistre dans le cas ADAO:: ) 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" ) @@ -198,7 +207,7 @@ de mani 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. @@ -208,10 +217,10 @@ le nombre d'it 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 @@ -559,6 +568,7 @@ observations par simulation pour se placer dans un cas d'exp 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") @@ -584,7 +594,8 @@ Le jeu de commandes que l'on peut utiliser est le suivant:: # TUI ADAO # -------- case = adaoBuilder.New() - case.set( 'AlgorithmParameters', + case.set( + 'AlgorithmParameters', Algorithm = '3DVAR', Parameters = { "Bounds":Bounds, @@ -600,7 +611,8 @@ Le jeu de commandes que l'on peut utiliser est le suivant:: 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}, ) diff --git a/doc/fr/using.rst b/doc/fr/using.rst index a93e5e2..c82cb5d 100644 --- a/doc/fr/using.rst +++ b/doc/fr/using.rst @@ -259,7 +259,7 @@ simple ci-dessus est de la forme suivante:: 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. diff --git a/src/daSalome/adaoBuilder.py b/src/daSalome/adaoBuilder.py index abbb130..c96bb86 100644 --- a/src/daSalome/adaoBuilder.py +++ b/src/daSalome/adaoBuilder.py @@ -31,10 +31,10 @@ from daCore import AssimilationStudy 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) # ----------------------------------------------------------- @@ -550,36 +550,33 @@ class New(object): 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] @@ -591,14 +588,14 @@ class _DumpLogger(object): 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): """