From: Jean-Philippe ARGAUD <jean-philippe.argaud@edf.fr>
Date: Tue, 22 Sep 2015 13:28:17 +0000 (+0200)
Subject: Detailed documentation of the observers
X-Git-Tag: V7_7_0rc1~11
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=39ccbf36b0fe83331bcda2fb31b5d28004a51bb3;p=modules%2Fadao.git

Detailed documentation of the observers
---

diff --git a/.gitignore b/.gitignore
index bc7f17e..73e8713 100644
--- a/.gitignore
+++ b/.gitignore
@@ -48,7 +48,7 @@ src/Makefile.in
 switch.log
 
 # YAMM specific
-git_diff.log
-git_fetch.log
+diff.log
+fetch.log
 update.log
 binary_archive.log
diff --git a/doc/en/advanced.rst b/doc/en/advanced.rst
index fca7105..5d2b0ed 100644
--- a/doc/en/advanced.rst
+++ b/doc/en/advanced.rst
@@ -191,29 +191,17 @@ Getting information on special variables during the ADAO calculation in YACS
 .. 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,
+monitored during the ADAO calculation. These variables can be printed,
 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
-way as for the final ADD object, that is as a list/tuple object.
+each associated with one variable.
 
 Some templates are available when editing the ADAO case in graphical editor.
 These simple scripts can be customized by the user, either at the embedded
 edition stage, or at the edition stage before execution, to improve the tuning
 of the ADAO calculation.
 
-As an example, here is one very simple script (similar to the "*ValuePrinter*"
-template) used to print the value of one monitored variable::
-
-    print "    --->",info," Value =",var[-1]
-
-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 "*observer*" can embed plotting capabilities, storage, complex
-printing, statistical treatment, etc.
+To implement these "*observer*" efficiently, one can look to the 
+:ref:`ref_observers_requirements`.
 
 Getting more information when running a calculation
 ---------------------------------------------------
diff --git a/doc/en/images/eficas_observer_nodetype.png b/doc/en/images/eficas_observer_nodetype.png
new file mode 100644
index 0000000..a604eb5
Binary files /dev/null and b/doc/en/images/eficas_observer_nodetype.png differ
diff --git a/doc/en/ref_covariance_requirements.rst b/doc/en/ref_covariance_requirements.rst
index a6b33bc..8b83325 100644
--- a/doc/en/ref_covariance_requirements.rst
+++ b/doc/en/ref_covariance_requirements.rst
@@ -26,11 +26,25 @@
 Requirements to describe covariance matrices
 --------------------------------------------
 
-Multiple covariance matrices are required to implement the data assimilation or
+.. index:: single: covariance matrix
+.. index:: single: background error covariances
+.. index:: single: observation error covariances
+.. index:: single: covariances
+
+In general, a covariance matrix (or a variance-covariance matrix) has to be
+squared, symetric, semi-definite positive. Each of its terms describes the
+covariance of the two random variables corresponding to its position in the
+matrix. The normalized form of the covariance is the linear correlation. One can
+express the following relation, between a covariance matrix :math:`\mathbf{M}`
+and its corresponding correlation matrix :math:`\mathbf{C}` (full matrix) and
+standard deviation matrix :math:`\mathbf{\Sigma}` (diagonal matrix):
+
+.. math:: \mathbf{M} = \mathbf{\Sigma} * \mathbf{C} * \mathbf{\Sigma}
+
+Various covariance matrices are required to implement the data assimilation or
 optimization procedures. The main ones are the background error covariance
 matrix, noted as :math:`\mathbf{B}`, and the observation error covariance matrix,
-noted as :math:`\mathbf{R}`. Such a matrix is required to be a squared symmetric
-semi-definite positive matrix.
+noted as :math:`\mathbf{R}`.
 
 There are 3 practical methods for the user to provide a covariance matrix. The
 method is chosen by the "*INPUT_TYPE*" keyword of each defined covariance
diff --git a/doc/en/ref_observers_requirements.rst b/doc/en/ref_observers_requirements.rst
index 2bd7338..77ce681 100644
--- a/doc/en/ref_observers_requirements.rst
+++ b/doc/en/ref_observers_requirements.rst
@@ -25,3 +25,343 @@
 
 Requirements for functions describing an "*observer*"
 -----------------------------------------------------
+
+.. index:: single: Observer
+.. index:: single: Observer Template
+
+Some special variables, internal to the optimization process, used inside
+calculation, can be monitored during an ADAO calculation. These variables can be
+printed, plotted, saved, etc. It can be done using some "*observer*", sometimes
+also called "callback". They are Python scripts, each one associated to a given
+variable. They are activated for each variable modification.
+
+There are 3 practical methods to provide an "*observer*" in an ADAO case. The
+method is chosen with the "*NodeType*" keyword of each "*observer*" entry type, as
+shown in the following figure:
+
+  .. eficas_observer_nodetype:
+  .. image:: images/eficas_observer_nodetype.png
+    :align: center
+    :width: 100%
+  .. centered::
+    **Choosing for an "*observer*" its entry type**
+
+The "*observer*" can be given as a explicit script (entry of type "*String*"),
+as a script in an external file (entry of type "*Script*"), or by using a
+template or pattern (entry of type"*Template*") available by default in ADAO
+when using the graphical editor. These templates are simple scripts that can be
+tuned by the user, either in the integrated edtition stage of the case, or in
+the edition stage of the schema before execution, to improve the ADAO case
+performance in the SALOME execution supervisor.
+
+General form of a script to define an *observer*
+++++++++++++++++++++++++++++++++++++++++++++++++
+
+To use this capability, the user must have or build scripts that have on
+standard input (that is, in the naming space) the variables ``var`` and
+``info``. The variable ``var`` is to be used as an object of list/tuple type,
+that contains the variable of interest indexed by the updating step.
+
+As an example, here is a very simple script (similar to the model
+"*ValuePrinter*"), that can be used to print the value of the monitored
+variable::
+
+    print "    --->",info," Value =",var[-1]
+
+Stored as a Python file or as an explicit string, these script lines can be
+associated to each variable found in the keyword "*SELECTION*" of the
+"*Observers*" command of the ADAO case: "*Analysis*", "*CurrentState*",
+"*CostFunction*"... The current value of the variable will be printed at each
+step of the optimization or data assimilation algorithm. The "*observer*" can
+include graphical output, storage capacities, complex treatment, statistical
+analysis, etc.
+
+Hereinafter we give the identifier and the contents of each model available.
+
+Inventory of available *observer* models ("*Template*")
++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+.. index:: single: ValueGnuPlotter (Observer)
+
+Template **ValueGnuPlotter** :
+..............................
+
+::
+
+    import numpy, Gnuplot
+    v=numpy.array(var[-1], ndmin=1)
+    global ifig, gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueMean (Observer)
+
+Template **ValueMean** :
+........................
+
+::
+
+    import numpy
+    print info, numpy.nanmean(var[-1])
+
+.. index:: single: ValuePrinter (Observer)
+
+Template **ValuePrinter** :
+...........................
+
+Print on standard output the current value of the variable.
+
+::
+
+    print info, var[-1]
+
+.. index:: single: ValuePrinterAndGnuPlotter (Observer)
+
+Template **ValuePrinterAndGnuPlotter** :
+........................................
+
+::
+
+    print info, var[-1]
+    import numpy, Gnuplot
+    v=numpy.array(var[-1], ndmin=1)
+    global ifig,gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValuePrinterAndSaver (Observer)
+
+Template **ValuePrinterAndSaver** :
+...................................
+
+::
+
+    import numpy, re
+    v=numpy.array(var[-1], ndmin=1)
+    print info,v
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+
+.. index:: single: ValuePrinterSaverAndGnuPlotter (Observer)
+
+Template **ValuePrinterSaverAndGnuPlotter** :
+.............................................
+
+::
+
+    print info, var[-1]
+    import numpy, re
+    v=numpy.array(var[-1], ndmin=1)
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+    import Gnuplot
+    global ifig,gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueRMS (Observer)
+
+Template **ValueRMS** :
+.......................
+
+::
+
+    import numpy
+    v = numpy.matrix( numpy.ravel( var[-1] ) )
+    print info, float( numpy.sqrt((1./v.size)*(v*v.T)) )
+
+.. index:: single: ValueSaver (Observer)
+
+Template **ValueSaver** :
+.........................
+
+::
+
+    import numpy, re
+    v=numpy.array(var[-1], ndmin=1)
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+
+.. index:: single: ValueSerieGnuPlotter (Observer)
+
+Template **ValueSerieGnuPlotter** :
+...................................
+
+::
+
+    import numpy, Gnuplot
+    v=numpy.array(var[:],  ndmin=1)
+    global ifig, gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueSeriePrinter (Observer)
+
+Template **ValueSeriePrinter** :
+................................
+
+Print on standard output the value serie of the variable.
+
+::
+
+    print info, var[:]
+
+.. index:: single: ValueSeriePrinterAndGnuPlotter (Observer)
+
+Template **ValueSeriePrinterAndGnuPlotter** :
+.............................................
+
+::
+
+    print info, var[:] 
+    import numpy, Gnuplot
+    v=numpy.array(var[:],  ndmin=1)
+    global ifig,gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueSeriePrinterAndSaver (Observer)
+
+Template **ValueSeriePrinterAndSaver** :
+........................................
+
+::
+
+    import numpy, re
+    v=numpy.array(var[:],  ndmin=1)
+    print info,v
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+
+.. index:: single: ValueSeriePrinterSaverAndGnuPlotter (Observer)
+
+Template **ValueSeriePrinterSaverAndGnuPlotter** :
+..................................................
+
+::
+
+    print info, var[:] 
+    import numpy, re
+    v=numpy.array(var[:],  ndmin=1)
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+    import Gnuplot
+    global ifig,gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueSerieSaver (Observer)
+
+Template **ValueSerieSaver** :
+..............................
+
+::
+
+    import numpy, re
+    v=numpy.array(var[:],  ndmin=1)
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+
+.. index:: single: ValueStandardError (Observer)
+
+Template **ValueStandardError** :
+.................................
+
+::
+
+    import numpy
+    print info, numpy.nanstd(var[-1])
+
+.. index:: single: ValueVariance (Observer)
+
+Template **ValueVariance** :
+............................
+
+::
+
+    import numpy
+    print info, numpy.nanvar(var[-1])
diff --git a/doc/fr/advanced.rst b/doc/fr/advanced.rst
index 085a8c3..b4f32ff 100644
--- a/doc/fr/advanced.rst
+++ b/doc/fr/advanced.rst
@@ -200,14 +200,9 @@ Obtenir des informations sur des variables sp
 .. 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 "*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
-de la même manière que l'objet final ADD, c'est-à-dire comme un objet de type
-liste/tuple.
+calculs, peuvent être surveillées durant un calcul ADAO. Ces variables peuvent
+être affichées, tracées, enregistrées, etc. C'est réalisable en utilisant des
+"*observer*", qui sont des scripts, chacun associé à une variable.
 
 Des modèles ("templates") sont disponibles lors de l'édition le cas ADAO dans
 l'éditeur graphique. Ces scripts simples peuvent être adaptés par l'utilisateur,
@@ -215,17 +210,8 @@ soit dans l'
 l'exécution, pour améliorer l'adaptation du calcul ADAO dans le superviseur
 d'exécution de SALOME.
 
-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]
-
-Stocké comme un fichier Python, ce script peut être associé à chaque variable
-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 "*observer*" peuvent inclure des capacités d'affichage
-graphique, de stockage, d'affichage complexe, de traitement statistique, etc.
+Pour mettre en oeuvre ces "*observer*" de manière efficace, on se reportera aux
+:ref:`ref_observers_requirements`.
 
 Obtenir plus d'information lors du déroulement d'un calcul
 ----------------------------------------------------------
diff --git a/doc/fr/images/eficas_observer_nodetype.png b/doc/fr/images/eficas_observer_nodetype.png
new file mode 100644
index 0000000..a604eb5
Binary files /dev/null and b/doc/fr/images/eficas_observer_nodetype.png differ
diff --git a/doc/fr/ref_covariance_requirements.rst b/doc/fr/ref_covariance_requirements.rst
index 639c061..372046a 100644
--- a/doc/fr/ref_covariance_requirements.rst
+++ b/doc/fr/ref_covariance_requirements.rst
@@ -26,11 +26,26 @@
 Exigences pour décrire les matrices de covariance
 -------------------------------------------------
 
-De multiples matrices de covariance sont nécessaires pour mettre en oeuvre des
+.. index:: single: matrice de covariance
+.. index:: single: covariances d'erreurs d'ébauche
+.. index:: single: covariances d'erreurs d'observation
+.. index:: single: covariances
+
+De manière générale, une matrice de covariance (ou une matrice de
+variance-covariance) doit être carrée, symétrique, semi-définie positive. Chacun
+de ses termes décrit la covariance des deux variables aléatoires correspondantes
+à sa position dans la matrice. La forme normalisée de la covariance est la
+corrélation linéaire. On peut écrire la relation suivante, entre une matrice de
+covariance :math:`\mathbf{M}` et ses matrices correspondantes de corrélation
+:math:`\mathbf{C}` (matrice pleine) et d'écart-type :math:`\mathbf{\Sigma}`
+(matrice diagonale):
+
+.. math:: \mathbf{M} = \mathbf{\Sigma} * \mathbf{C} * \mathbf{\Sigma}
+
+Diverses matrices de covariance sont nécessaires pour mettre en oeuvre des
 procédures d'assimilation de données ou d'optimisation. Les principales sont la
 matrice de covariance des erreurs d'ébauche, notée :math:`\mathbf{B}`, et la
-matrice de covariance des erreurs d'observation, notée :math:`\mathbf{R}`. Une
-telle matrice doit être une matrice carré symétrique semi-définie positive.
+matrice de covariance des erreurs d'observation, notée :math:`\mathbf{R}`.
 
 Il y a 3 méthodes pratiques pour l'utilisateur pour fournir une matrice de
 covariance. La méthode est choisie à l'aide du mot-clé "*INPUT_TYPE*" de chaque
@@ -51,10 +66,10 @@ Premi
 .. index:: single: EvolutionError
 .. index:: single: ObservationError
 
-La première forme est le défaut et la plus générale. La matrice de covariance
-:math:`\mathbf{M}` doit être entièrement spécifiée. Même si la matrice est
-symétrique par nature, la totalité de la matrice :math:`\mathbf{M}` doit être
-donnée.
+La première forme est le défaut, et c'est la plus générale. La matrice de
+covariance :math:`\mathbf{M}` doit être entièrement spécifiée. Même si la
+matrice est symétrique par nature, la totalité de la matrice :math:`\mathbf{M}`
+doit être donnée.
 
 .. math:: \mathbf{M} =  \begin{pmatrix}
     m_{11} & m_{12} & \cdots   & m_{1n} \\
@@ -83,9 +98,9 @@ Seconde forme matricielle : utiliser la repr
 .. index:: single: ObservationError
 
 Au contraire, la seconde forme matricielle est une méthode très simplifiée pour
-définir une matrice. La matrice de covariance :math:`\mathbf{M}` est supposée
-être un multiple positif de la matrice identité. Cette matrice peut alors être
-spécifiée de manière unique par le multiplicateur :math:`m`:
+définir une matrice. La matrice de covariance :math:`\mathbf{M}` est ici
+supposée être un multiple positif de la matrice identité. Cette matrice peut
+alors être spécifiée de manière unique par le multiplicateur :math:`m`:
 
 .. math:: \mathbf{M} =  m \times \begin{pmatrix}
     1       & 0      & \cdots   & 0      \\
@@ -114,10 +129,10 @@ Troisi
 
 La troisième forme est aussi une méthode simplifiée pour fournir la matrice,
 mais un peu plus puissante que la seconde. La matrice de covariance
-:math:`\mathbf{M}` est toujours considérée comme diagonale, mais l'utilisateur
-doit spécifier toutes les valeurs positives situées sur la diagonale. La matrice
-peut alors être définie uniquement par un vecteur :math:`\mathbf{V}` qui se
-retrouve ensuite sur la diagonale:
+:math:`\mathbf{M}` est ici toujours considérée comme diagonale, mais
+l'utilisateur doit spécifier toutes les valeurs positives situées sur la
+diagonale. La matrice peut alors être définie uniquement par un vecteur
+:math:`\mathbf{V}` qui se retrouve ensuite sur la diagonale:
 
 .. math:: \mathbf{M} =  \begin{pmatrix}
     v_{1}  & 0      & \cdots   & 0      \\
diff --git a/doc/fr/ref_observers_requirements.rst b/doc/fr/ref_observers_requirements.rst
index df804f2..db0a9a3 100644
--- a/doc/fr/ref_observers_requirements.rst
+++ b/doc/fr/ref_observers_requirements.rst
@@ -26,3 +26,341 @@
 Exigences pour les fonctions décrivant un "*observer*"
 ------------------------------------------------------
 
+.. index:: single: Observer
+.. 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 "*observer*", qui sont des scripts, chacun associé à une
+variable, qui sont activés à chaque modification de la variable.
+
+Il y a 3 méthodes pratiques pour intégrer un "*observer*" dans un cas ADAO. La
+méthode est choisie à l'aide du mot-clé "*NodeType*" de chaque entrée de type
+*observer*, comme montré dans la figure qui suit :
+
+  .. eficas_observer_nodetype:
+  .. image:: images/eficas_observer_nodetype.png
+    :align: center
+    :width: 100%
+  .. centered::
+    **Choisir le type d'entrée**
+
+L'"*observer*" peut être fourni sous la forme d'un script explicite (entrée de
+type "*String*"), d'un script contenu dans un fichier externe (entrée de type
+"*Script*"), ou en utilisant un modèle (entrée de type "*Template*") fourni par
+défaut dans ADAO lors de l'édition dans l'éditeur graphique. Ces derniers sont
+des scripts simples qui peuvent être adaptés par l'utilisateur, soit dans
+l'étape d'édition intégrée, soit dans l'étape d'édition avant l'exécution, pour
+améliorer l'adaptation du calcul ADAO dans le superviseur d'exécution de SALOME.
+
+Forme générale d'un script permettant de définir un  *observer*
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+Pour pouvoir utiliser cette capacité, l'utilisateur doit disposer ou construire
+des scripts utilisant en entrée standard (i.e. disponible dans l'espace de
+nommage) des variables ``var`` et ``info``. La variable ``var`` est à utiliser
+comme un objet de type liste/tuple, contenant la variable d'intérêt indicée par
+l'étape de mise à jour.
+
+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]
+
+Stocké comme un fichier Python, ce script peut être associé à chaque variable
+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 "*observer*" peuvent inclure des capacités d'affichage
+graphique, de stockage, d'affichage complexe, de traitement statistique, etc.
+
+On donne ci-aprés l'identifiant et le contenu de chaque modèle disponible.
+
+Inventaire des modèles d'*observer* disponibles ("*Template*")
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+.. index:: single: ValueGnuPlotter (Observer)
+
+Modèle **ValueGnuPlotter** :
+............................
+
+::
+
+    import numpy, Gnuplot
+    v=numpy.array(var[-1], ndmin=1)
+    global ifig, gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueMean (Observer)
+
+Modèle **ValueMean** :
+......................
+
+::
+
+    import numpy
+    print info, numpy.nanmean(var[-1])
+
+.. index:: single: ValuePrinter (Observer)
+
+Modèle **ValuePrinter** :
+.........................
+
+Imprime sur la sortie standard la valeur courante de la variable.
+
+::
+
+    print info, var[-1]
+
+.. index:: single: ValuePrinterAndGnuPlotter (Observer)
+
+Modèle **ValuePrinterAndGnuPlotter** :
+......................................
+
+::
+
+    print info, var[-1]
+    import numpy, Gnuplot
+    v=numpy.array(var[-1], ndmin=1)
+    global ifig,gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValuePrinterAndSaver (Observer)
+
+Modèle **ValuePrinterAndSaver** :
+.................................
+
+::
+
+    import numpy, re
+    v=numpy.array(var[-1], ndmin=1)
+    print info,v
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+
+.. index:: single: ValuePrinterSaverAndGnuPlotter (Observer)
+
+Modèle **ValuePrinterSaverAndGnuPlotter** :
+...........................................
+
+::
+
+    print info, var[-1]
+    import numpy, re
+    v=numpy.array(var[-1], ndmin=1)
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+    import Gnuplot
+    global ifig,gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueRMS (Observer)
+
+Modèle **ValueRMS** :
+.....................
+
+::
+
+    import numpy
+    v = numpy.matrix( numpy.ravel( var[-1] ) )
+    print info, float( numpy.sqrt((1./v.size)*(v*v.T)) )
+
+.. index:: single: ValueSaver (Observer)
+
+Modèle **ValueSaver** :
+.......................
+
+::
+
+    import numpy, re
+    v=numpy.array(var[-1], ndmin=1)
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+
+.. index:: single: ValueSerieGnuPlotter (Observer)
+
+Modèle **ValueSerieGnuPlotter** :
+.................................
+
+::
+
+    import numpy, Gnuplot
+    v=numpy.array(var[:],  ndmin=1)
+    global ifig, gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueSeriePrinter (Observer)
+
+Modèle **ValueSeriePrinter** :
+..............................
+
+Imprime sur la sortie standard la série des valeurs de la variable.
+
+::
+
+    print info, var[:]
+
+.. index:: single: ValueSeriePrinterAndGnuPlotter (Observer)
+
+Modèle **ValueSeriePrinterAndGnuPlotter** :
+...........................................
+
+::
+
+    print info, var[:] 
+    import numpy, Gnuplot
+    v=numpy.array(var[:],  ndmin=1)
+    global ifig,gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueSeriePrinterAndSaver (Observer)
+
+Modèle **ValueSeriePrinterAndSaver** :
+......................................
+
+::
+
+    import numpy, re
+    v=numpy.array(var[:],  ndmin=1)
+    print info,v
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+
+.. index:: single: ValueSeriePrinterSaverAndGnuPlotter (Observer)
+
+Modèle **ValueSeriePrinterSaverAndGnuPlotter** :
+................................................
+
+::
+
+    print info, var[:] 
+    import numpy, re
+    v=numpy.array(var[:],  ndmin=1)
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+    import Gnuplot
+    global ifig,gp
+    try:
+        ifig += 1
+        gp('set style data lines')
+    except:
+        ifig = 0
+        gp = Gnuplot.Gnuplot(persist=1)
+        gp('set style data lines')
+    gp('set title  "%s (Figure %i)"'%(info,ifig))
+    gp.plot( Gnuplot.Data( v, with_='lines lw 2' ) )
+
+.. index:: single: ValueSerieSaver (Observer)
+
+Modèle **ValueSerieSaver** :
+............................
+
+::
+
+    import numpy, re
+    v=numpy.array(var[:],  ndmin=1)
+    global istep
+    try:
+        istep += 1
+    except:
+        istep = 0
+    f='/tmp/value_%s_%05i.txt'%(info,istep)
+    f=re.sub('\s','_',f)
+    print 'Value saved in "%s"'%f
+    numpy.savetxt(f,v)
+
+.. index:: single: ValueStandardError (Observer)
+
+Modèle **ValueStandardError** :
+...............................
+
+::
+
+    import numpy
+    print info, numpy.nanstd(var[-1])
+
+.. index:: single: ValueVariance (Observer)
+
+Modèle **ValueVariance** :
+..........................
+
+::
+
+    import numpy
+    print info, numpy.nanvar(var[-1])
diff --git a/src/daComposant/daCore/BasicObjects.py b/src/daComposant/daCore/BasicObjects.py
index 57d4e41..25c49ec 100644
--- a/src/daComposant/daCore/BasicObjects.py
+++ b/src/daComposant/daCore/BasicObjects.py
@@ -772,6 +772,40 @@ class Covariance:
     def __len__(self):
         return self.shape[0]
 
+# ==============================================================================
+class TemplateStorage(object):
+    """
+    Classe générale de stockage de type dictionnaire étendu
+    (Template)
+    """
+    def __init__( self, language = "fr_FR" ):
+        self.__preferedLanguage = "fr"
+        self.__values = {}
+
+    def store( self, name = None, content = None, fr_FR = "", en_EN = "" ):
+        if name is None or content is None:
+            raise ValueError("To be consistent, the storage of a template must provide a name and a content.")
+        self.__values[str(name)] = {
+            'content': str(content),
+            'fr_FR'  : str(fr_FR),
+            'en_EN'  : str(en_EN),
+            }
+
+    def keys(self):
+        __keys = self.__values.keys()
+        __keys.sort()
+        return __keys
+
+    def __len__(self):
+        return len(self.__values)
+
+    def __getitem__(self, name=None ):
+        return self.__values[name]['content']
+
+    def getdoc(self, name = None, lang = "fr_FR"):
+        if lang not in self.__values[name]: lang = "fr_FR"
+        return self.__values[name][lang]
+
 # ==============================================================================
 def CostFunction3D(
     _x,
diff --git a/src/daSalome/adaoBuilder.py b/src/daSalome/adaoBuilder.py
index dd4699e..ffc48c7 100644
--- a/src/daSalome/adaoBuilder.py
+++ b/src/daSalome/adaoBuilder.py
@@ -498,6 +498,7 @@ class New(object):
         if String is not None:
             __FunctionText = String
         elif Template is not None:
+            __FunctionText = ""
             if Template == "ValuePrinter":
                 __FunctionText = """print info, var[-1]"""
             if Template == "ValueSeriePrinter":