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( 'Observation', Vector=array([0.5, 1.5, 2.5]) )
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.
+On remarque que l'on peut donner, en entrée des quantités vectorielles ou
+matricielles, des objets de type ``str``, ``list`` ou``tuple`` de Python, ou de
+type ``array`` ou ``matrix`` de Numpy. Dans ces deux derniers cas, il faut
+simplement importer le module 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 (qui réalise
-ici le même opérateur linéaire que ci-dessus) et l'enregistre dans le cas ADAO::
-
- def fonction(x):
- import numpy
+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):
+ "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
#
case.set( 'ObservationOperator',
- DirectFunction = fonction,
- Parameters = {"useApproximatedDerivatives":True},
+ OneFunction = simulation,
+ Parameters = {"DifferentialIncrement":0.01},
)
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
-manière d':ref:`section_advanced_observer`, et à la :ref:`section_reference`
+ajouter des "*observer*", qui permettent d'associer l'exécution d'un script à
+une variable intermédiaire 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" )
Au final, on obtient le script très compact proposé précédemment dans
:ref:`subsection_tui_example`.
-Fournir des données de calcul plus complexes
-++++++++++++++++++++++++++++++++++++++++++++
+Fournir des données ou informations de calcul plus complexes
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Une telle interface s'écrivant en Python, il est possible d'utiliser toute la
puissance du langage pour entrer des données plus complexes qu'une déclaration
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
-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.
+l'optimisation ou de l'assimilation de données, 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.
A titre d'exemple, on donne quelques lignes de script qui permettent d'obtenir
le nombre d'itérations de l'optimisation et la valeur optimale ainsi que sa
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
de calcul TUI ADAO proposé dans :ref:`subsection_tui_example`.
De même que pour l'entrée des données, la simplicité de récupération des
-résultats permet d'envisager aisément des post-traitements enchaînés, pour
-utiliser par exemple de la visualisation avec MatPlotLib ou PARAVIS [PARAVIS]_,
-de l'adaptation de maillage avec HOMARD [HOMARD]_, ou pour d'autres calculs.
+résultats permet d'envisager aisément des post-traitements enchaînés dans
+SALOME, pour utiliser par exemple de la visualisation avec MatPlotLib ou PARAVIS
+[PARAVIS]_, de l'adaptation de maillage avec HOMARD [HOMARD]_, ou pour d'autres
+calculs.
.. _subsection_tui_commands:
.. index:: single: setBackground
-**setBackground** (*Vector , VectorSerie , Stored*)
+**setBackground** (*Vector, VectorSerie, Script, Stored*)
Cette commande permet de définir l'ébauche :math:`\mathbf{x}^b`. Selon les
- algorithmes, on peut définir un vecteur simple par "*Vector*", ou une liste
- de vecteurs par "*VectorSerie*".
+ algorithmes, on peut le définir comme un vecteur simple par "*Vector*", ou
+ comme une liste de vecteurs par "*VectorSerie*". Si on le définit par un
+ script dans "*Script*", le vecteur est de type "*Vector*" (par défaut) ou
+ "*VectorSerie*" selon que l'une de ces variables est placée à "*True*".
.. index:: single: setBackgroundError
-**setBackgroundError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Stored*)
+**setBackgroundError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Script, Stored*)
Cette commande permet de définir la matrice :math:`\mathbf{B}` des
covariance des erreurs d'ébauche. La matrice peut être définie de manière
complète par "*Matrix*", ou de manière parcimonieuse comme une matrice
diagonale dont on donne la variance unique sur la diagonale par
"*ScalarSparseMatrix*", ou comme une matrice diagonale dont on donne le
vecteur des variances situé sur la diagonale par "*DiagonalSparseMatrix*".
+ Si on la définit par un script dans "*Script*", la matrice est de type
+ "*Matrix*" (par défaut), "*ScalarSparseMatrix*" ou "*DiagonalSparseMatrix*"
+ selon que l'une de ces variables est placée à "*True*".
.. index:: single: setCheckingPoint
-**setCheckingPoint** (*Vector, VectorSerie, Stored*)
+**setCheckingPoint** (*Vector, VectorSerie, Script, Stored*)
Cette commande permet de définir un point courant :math:`\mathbf{x}` utilisé
- pour un algorithme de vérification. Selon les algorithmes, on peut définir
- un vecteur simple par "Vector", ou une liste de vecteurs par "VectorSerie".
+ pour un algorithme de vérification. Selon les algorithmes, on peut le
+ définir comme un vecteur simple par "*Vector*", ou comme une liste de
+ vecteurs par "*VectorSerie*". Si on le définit par un script dans
+ "*Script*", le vecteur est de type "*Vector*" (par défaut) ou
+ "*VectorSerie*" selon que l'une de ces variables est placée à "*True*".
.. index:: single: setControlModel
-**setControlModel** (*Matrix, DirectFunction, ThreeFunctions, Parameters, Stored*)
+**setControlModel** (*Matrix, OneFunction, ThreeFunctions, Parameters, Script, Stored*)
Cette commande permet de définir l'opérateur de contrôle :math:`O`, qui
décrit un contrôle d'entrée linéaire externe de l'opérateur d'évolution ou
d'observation. On se reportera :ref:`section_ref_operator_control`. Sa
valeur est définie comme un objet de type fonction ou de type "*Matrix*".
Dans le cas d'une fonction, différentes formes fonctionnelles peuvent être
utilisées, comme décrit dans la section
- :ref:`section_ref_operator_requirements`, et entrées par "*DirectFunction*"
- ou "*ThreeFunctions*". Les paramètres de contrôle de l'approximation
- numérique de l'opérateur adjoint, dans le cas "*DirectFunction*", peuvent
- être renseignés par un dictionnaire dans "*Parameters*". Les entrées
- potentielles de ce dictionnaire de paramètres sont
- "*DifferentialIncrement*", "*CenteredFiniteDifference*",
- "*EnableMultiProcessing*", "*NumberOfProcesses*" (similaires à celles de
- l'interface graphique).
+ :ref:`section_ref_operator_requirements`, et entrées par "*OneFunction*" ou
+ "*ThreeFunctions*". Dans le cas d'une définition par "*Script*", l'opérateur
+ est de type "*Matrix*", "*OneFunction*" ou "*ThreeFunctions*" selon que
+ l'une de ces variables est placée à "*True*". Les paramètres de contrôle de
+ l'approximation numérique de l'opérateur adjoint, dans le cas
+ "*OneFunction*", peuvent être renseignés par un dictionnaire dans
+ "*Parameters*". Les entrées potentielles de ce dictionnaire de paramètres
+ sont "*DifferentialIncrement*", "*CenteredFiniteDifference*" (similaires à
+ celles de l'interface graphique).
.. index:: single: setControlInput
-**setControlInput** (*Vector, VectorSerie, Stored*)
+**setControlInput** (*Vector, VectorSerie, Script, Stored*)
Cette commande permet de définir le vecteur de contrôle :math:`\mathbf{u}`.
- Selon les algorithmes, on peut définir un vecteur simple par "Vector", ou
- une liste de vecteurs par "VectorSerie".
+ Selon les algorithmes, on peut le définir comme un vecteur simple par
+ "*Vector*", ou comme une liste de vecteurs par "*VectorSerie*". Si on le
+ définit par un script dans "*Script*", le vecteur est de type "*Vector*"
+ (par défaut) ou "*VectorSerie*" selon que l'une de ces variables est placée
+ à "*True*".
.. index:: single: setEvolutionError
-**setEvolutionError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Stored*)
+**setEvolutionError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Script, Stored*)
Cette commande permet de définir la matrice :math:`\mathbf{Q}` des
covariance des erreurs d'évolution. La matrice peut être définie de manière
complète par "*Matrix*", ou de manière parcimonieuse comme une matrice
diagonale dont on donne la variance unique sur la diagonale par
"*ScalarSparseMatrix*", ou comme une matrice diagonale dont on donne le
vecteur des variances situé sur la diagonale par "*DiagonalSparseMatrix*".
+ Si on la définit par un script dans "*Script*", la matrice est de type
+ "*Matrix*" (par défaut), "*ScalarSparseMatrix*" ou "*DiagonalSparseMatrix*"
+ selon que l'une de ces variables est placée à "*True*".
.. index:: single: setEvolutionModel
-**setEvolutionModel** (*Matrix, DirectFunction, ThreeFunctions, Parameters, Stored*)
+**setEvolutionModel** (*Matrix, OneFunction, ThreeFunctions, Parameters, Script, Stored*)
Cette commande permet de définir l'opérateur d'evolution :math:`M`, qui
décrit un pas élémentaire d'évolution. Sa valeur est définie comme un objet
de type fonction ou de type "*Matrix*". Dans le cas d'une fonction,
différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
la section :ref:`section_ref_operator_requirements`, et entrées par
- "*DirectFunction*" ou "*ThreeFunctions*". Les paramètres de contrôle de
- l'approximation numérique de l'opérateur adjoint, dans le cas
- "*DirectFunction*", peuvent être renseignés par un dictionnaire dans
- "*Parameters*". Les entrées potentielles de ce dictionnaire de paramètres
- sont "*DifferentialIncrement*", "*CenteredFiniteDifference*",
- "*EnableMultiProcessing*", "*NumberOfProcesses*" (similaires à celles de
- l'interface graphique).
+ "*OneFunction*" ou "*ThreeFunctions*". Dans le cas d'une définition par
+ "*Script*", l'opérateur est de type "*Matrix*", "*OneFunction*" ou
+ "*ThreeFunctions*" selon que l'une de ces variables est placée à "*True*".
+ Les paramètres de contrôle de l'approximation numérique de l'opérateur
+ adjoint, dans le cas "*OneFunction*", peuvent être renseignés par un
+ dictionnaire dans "*Parameters*". Les entrées potentielles de ce
+ dictionnaire de paramètres sont "*DifferentialIncrement*",
+ "*CenteredFiniteDifference*", "*EnableMultiProcessing*",
+ "*NumberOfProcesses*" (similaires à celles de l'interface graphique).
.. index:: single: setObservation
-**setObservation** (*Vector, VectorSerie, Stored*)
+**setObservation** (*Vector, VectorSerie, Script, Stored*)
Cette commande permet de définir le vecteur d'observation
- :math:`\mathbf{y}^o`. Selon les cas, on peut définir un vecteur simple par
- "Vector", ou une liste de vecteurs par "VectorSerie".
+ :math:`\mathbf{y}^o`. Selon les algorithmes, on peut le définir comme un
+ vecteur simple par "*Vector*", ou comme une liste de vecteurs par
+ "*VectorSerie*". Si on le définit par un script dans "*Script*", le vecteur
+ est de type "*Vector*" (par défaut) ou "*VectorSerie*" selon que l'une de
+ ces variables est placée à "*True*".
.. index:: single: setObservationError
-**setObservationError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Stored*)
+**setObservationError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Script, Stored*)
Cette commande permet de définir la matrice :math:`\mathbf{R}` des
covariance des erreurs d'observation. La matrice peut être définie de
manière complète par "*Matrix*", ou de manière parcimonieuse comme une
matrice diagonale dont on donne la variance unique sur la diagonale par
"*ScalarSparseMatrix*", ou comme une matrice diagonale dont on donne le
vecteur des variances situé sur la diagonale par "*DiagonalSparseMatrix*".
+ Si on la définit par un script dans "*Script*", la matrice est de type
+ "*Matrix*" (par défaut), "*ScalarSparseMatrix*" ou "*DiagonalSparseMatrix*"
+ selon que l'une de ces variables est placée à "*True*".
.. index:: single: setObservationOperator
-**setObservationOperator** (*Matrix, DirectFunction, ThreeFunctions, Parameters, Stored*)
+**setObservationOperator** (*Matrix, OneFunction, ThreeFunctions, Parameters, Script, Stored*)
Cette commande permet de définir l'opérateur d'observation :math:`H`, qui
transforme les paramètres d'entrée :math:`\mathbf{x}` en résultats
:math:`\mathbf{y}` qui sont à comparer aux observations
:math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type fonction
ou de type "*Matrix*". Dans le cas d'une fonction, différentes formes
fonctionnelles peuvent être utilisées, comme décrit dans la section
- :ref:`section_ref_operator_requirements`, et entrées par "*DirectFunction*"
- ou "*ThreeFunctions*". Les paramètres de contrôle de l'approximation
- numérique de l'opérateur adjoint, dans le cas "*DirectFunction*", peuvent
- être renseignés par un dictionnaire dans "*Parameters*". Les entrées
- potentielles de ce dictionnaire de paramètres sont "*DifferentialIncrement*",
- "*CenteredFiniteDifference*", "*EnableMultiProcessing*",
- "*NumberOfProcesses*" (similaires à celles de l'interface graphique).
+ :ref:`section_ref_operator_requirements`, et entrées par "*OneFunction*" ou
+ "*ThreeFunctions*". Dans le cas d'une définition par "*Script*", l'opérateur
+ est de type "*Matrix*", "*OneFunction*" ou "*ThreeFunctions*" selon que
+ l'une de ces variables est placée à "*True*". Les paramètres de contrôle de
+ l'approximation numérique de l'opérateur adjoint, dans le cas
+ "*OneFunction*", peuvent être renseignés par un dictionnaire dans
+ "*Parameters*". Les entrées potentielles de ce dictionnaire de paramètres
+ sont "*DifferentialIncrement*", "*CenteredFiniteDifference*",
+ "*EnableMultiProcessing*", "*NumberOfProcesses*" (similaires à celles de
+ l'interface graphique).
.. index:: single: set
commandes de ce paragraphe. Son premier argument est le nom du concept à
définir (par exemple "*Background*" ou "*ObservationOperator*"), sur lequel
s'applique ensuite les arguments qui suivent, qui sont les mêmes que dans
- les commandes individuelles ci-dessus.
+ les commandes individuelles précédentes. Lors de l'usage de cette commande,
+ il est indispensable de nommer les arguments (par exemple "*Vector=...*").
Paramétrer le calcul, les sorties, etc.
+++++++++++++++++++++++++++++++++++++++
.. index:: single: setAlgorithmParameters
-**setAlgorithmParameters** (*Algorithm, Parameters*)
+**setAlgorithmParameters** (*Algorithm, Parameters, Script*)
Cette commande permet de choisir l'algorithme de calcul ou de vérification
par l'argument "*Algorithm*" sous la forme d'un nom d'algorithme (on se
reportera utilement aux listes des :ref:`section_reference_assimilation` et
des :ref:`section_reference_checking`), et de définir les paramètres de
- calcul par l'argument "*Parameters*".
+ calcul par l'argument "*Parameters*". Dans le cas d'une définition par
+ "*Script*", le fichier indiqué doit contenir les deux variables
+ "*Algorithm*" et "*Parameters*" (ou "*AlgorithmParameters*" de manière
+ équivalente).
.. index:: single: setDebug
.. index:: single: setObserver
-**setObserver** (*Variable, Template, String, Info*)
+**setObserver** (*Variable, Template, String, Script, Info*)
Cette commande permet de définir un observer sur une variable courante ou
finale du calcul. On se reportera à la description de la manière
d':ref:`section_advanced_observer`, et à la :ref:`section_reference` pour
"*ValuePrinter*", "*ValueSeriePrinter*", "*ValueSaver*",
"*ValueSerieSaver*", "*ValuePrinterAndSaver*",
"*ValueSeriePrinterAndSaver*", "*ValueGnuPlotter*",
- "*ValueSerieGnuPlotter*".
+ "*ValueSerieGnuPlotter*". Dans le cas d'une définition par "*Script*", le
+ fichier indiqué doit contenir uniquement le corps de la fonction, comme
+ décrit dans la manière d':ref:`section_advanced_observer`.
Effectuer le calcul
+++++++++++++++++++
nécessaire du parallélisme interne des algorithmes dans ADAO et du
parallélisme interne du ou des codes de simulation utilisé.
-.. index:: single: generateYACSscheme
-
-**executeYACSScheme** (*File*)
- Cete commande génère le schéma YACS [YACS]_ du cas de calcul dans le fichier
- requis "*File*", et en lance l'exécution dans l'interpréteur YACS, comme on
- peut le réaliser en utilisant l'éditeur standard de cas ADAO. Les sorties
- standard et d'erreur sont celles de l'interpréteur YACS. On dispose si
- nécessaire du parallélisme de noeuds et blocs dans YACS, du parallélisme
- interne des algorithmes dans ADAO et du parallélisme interne du ou des codes
- de simulation utilisé.
+.. .. index:: single: generateYACSscheme
+..
+.. **executeYACSScheme** (*File*)
+.. Cete commande génère le schéma YACS [YACS]_ du cas de calcul dans le fichier
+.. requis "*File*", et en lance l'exécution dans l'interpréteur YACS, comme on
+.. peut le réaliser en utilisant l'éditeur standard de cas ADAO. Les sorties
+.. standard et d'erreur sont celles de l'interpréteur YACS. On dispose si
+.. nécessaire du parallélisme de noeuds et blocs dans YACS, du parallélisme
+.. interne des algorithmes dans ADAO et du parallélisme interne du ou des codes
+.. de simulation utilisé.
.. index:: single: execute
fois aux :ref:`section_ref_output_variables` et aux documentations
individuelles des algorithmes.
-.. Exemples plus avancés de cas de calcul TUI ADAO
-.. -----------------------------------------------
+Exemples plus avancés de cas de calcul TUI ADAO
+-----------------------------------------------
+
+On propose ici des exemples plus complets de cas de calcul TUI ADAO, en donnant
+l'objectif de l'exemple et un jeu de commandes qui permet de parvenir à cet
+objectif.
+
+Exploitation indépendante des résultats d'un cas de calcul
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+L'objectif est d'effectuer en TUI la mise en données d'un cas de calcul ADAO,
+son exécution, puis la récupération des résultats pour ensuite enchaîner sur une
+exploitation indépendante de ces résultats (cette dernière n'étant pas décrite
+ici, puisque dépendante de l'utilisateur).
+
+Les hypothèses du cas utilisateur sont les suivantes. On suppose :
+
+#. que l'on veut recaler 3 paramètres ``alpha``, ``beta`` et ``gamma`` dans un domaine borné,
+#. que l'on dispose d'observations nommées ``observations``,
+#. que l'utilisateur dispose en Python d'une fonction de simulation physique appellée ``simulation`` préalablement testée, qui transforme les 3 paramètres en résultats similaires aux observations,
+#. que l'exploitation indépendante, que l'utilisateur veut faire, est représentée ici par l'affichage simple de l'état initial, de l'état optimal, de la simulation en ce point, des états intermédiaires et du nombre d'itérations d'optimisation.
+
+Pour effectuer de manière simple cet essai de cas de calcul TUI, on se donne par
+exemple les entrées suivantes, parfaitement arbitraires, en construisant les
+observations par simulation pour se placer dans un cas d'expériences jumelles::
+
+ #
+ # Construction artificielle d'un exemple de données utilisateur
+ # -------------------------------------------------------------
+ alpha = 5.
+ beta = 7
+ gamma = 9.0
+ #
+ alphamin, alphamax = 0., 10.
+ betamin, betamax = 3, 13
+ 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")
+ return __H * __x
+ #
+ # Observations obtenues par simulation
+ # ------------------------------------
+ observations = simulation((2, 3, 4))
+
+Le jeu de commandes que l'on peut utiliser est le suivant::
+
+ import numpy
+ import adaoBuilder
+ #
+ # Mise en forme des entrées
+ # -------------------------
+ Xb = (alpha, beta, gamma)
+ Bounds = (
+ (alphamin, alphamax),
+ (betamin, betamax ),
+ (gammamin, gammamax))
+ #
+ # TUI ADAO
+ # --------
+ case = adaoBuilder.New()
+ case.set(
+ 'AlgorithmParameters',
+ Algorithm = '3DVAR',
+ Parameters = {
+ "Bounds":Bounds,
+ "MaximumNumberOfSteps":100,
+ "StoreSupplementaryCalculations":[
+ "CostFunctionJ",
+ "CurrentState",
+ "SimulatedObservationAtOptimum",
+ ],
+ }
+ )
+ case.set( 'Background', Vector = numpy.array(Xb), Stored = True )
+ case.set( 'Observation', Vector = numpy.array(observations) )
+ case.set( 'BackgroundError', ScalarSparseMatrix = 1.0e10 )
+ case.set( 'ObservationError', ScalarSparseMatrix = 1.0 )
+ case.set(
+ 'ObservationOperator',
+ OneFunction = simulation,
+ Parameters = {"DifferentialIncrement":0.0001},
+ )
+ case.set( 'Observer', Variable="CurrentState", Template="ValuePrinter" )
+ case.execute()
+ #
+ # Exploitation indépendante
+ # -------------------------
+ Xbackground = case.get("Background")
+ Xoptimum = case.get("Analysis")[-1]
+ FX_at_optimum = case.get("SimulatedObservationAtOptimum")[-1]
+ J_values = case.get("CostFunctionJ")[:]
+ print
+ print "Nombre d'itérations internes...: %i"%len(J_values)
+ print "Etat initial...................:",numpy.ravel(Xbackground)
+ print "Etat optimal...................:",numpy.ravel(Xoptimum)
+ print "Simulation à l'état optimal....:",numpy.ravel(FX_at_optimum)
+ print
+
+L'exécution de jeu de commandes donne le résultat suivant::
+
+ CurrentState [ 5. 7. 9.]
+ CurrentState [ 0. 3. 1.5]
+ CurrentState [ 1.40006418 3.86705307 3.7061137 ]
+ CurrentState [ 1.42580231 3.68474804 3.81008738]
+ CurrentState [ 1.60220353 3.0677108 4.06146069]
+ CurrentState [ 1.72517855 3.03296953 4.04915706]
+ CurrentState [ 2.00010755 3. 4.00055409]
+ CurrentState [ 1.99995528 3. 3.99996367]
+ CurrentState [ 2.00000007 3. 4.00000011]
+ CurrentState [ 2. 3. 4.]
+
+ Nombre d'itérations internes...: 10
+ Etat initial...................: [ 5. 7. 9.]
+ Etat optimal...................: [ 2. 3. 4.]
+ Simulation à l'état optimal....: [ 2. 6. 12. 20.]
+
+Comme il se doit en expériences jumelles, on constate que l'on retouve bien les
+paramètres qui ont servi à construire artificiellement les observations.
+
+.. Réconciliation de courbes à l'aide de MedCoupling
+.. +++++++++++++++++++++++++++++++++++++++++++++++++
+
+.. Utilisation de fonctions de surveillance de type "observer"
+.. +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+.. Suivre d'un recalage à l'aide de MatPlotLib
+.. +++++++++++++++++++++++++++++++++++++++++++
.. Equivalences entre l'interface graphique (GUI) et l'interface textuelle (TUI)
.. -----------------------------------------------------------------------------
