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
-``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
)
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:
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
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.
+#. 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
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")
# TUI ADAO
# --------
case = adaoBuilder.New()
- case.set( 'AlgorithmParameters',
+ case.set(
+ 'AlgorithmParameters',
Algorithm = '3DVAR',
Parameters = {
"Bounds":Bounds,
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},
)
