doc/fr/ref_algorithm_3DVAR.rst

   1 ..
   2    Copyright (C) 2008-2017 EDF R&D
   3
   4    This file is part of SALOME ADAO module.
   5
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    This library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with this library; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19
  20    See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21
  22    Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  23
  24 .. index:: single: 3DVAR
  25 .. _section_ref_algorithm_3DVAR:
  26
  27 Algorithme de calcul "*3DVAR*"
  28 ------------------------------
  29
  30 Description
  31 +++++++++++
  32
  33 Cet algorithme réalise une estimation d'état par minimisation variationnelle de
  34 la fonctionnelle :math:`J` d'écart classique en assimilation de données
  35 statique:
  36
  37 .. math:: J(\mathbf{x})=(\mathbf{x}-\mathbf{x}^b)^T.\mathbf{B}^{-1}.(\mathbf{x}-\mathbf{x}^b)+(\mathbf{y}^o-H(\mathbf{x}))^T.\mathbf{R}^{-1}.(\mathbf{y}^o-H(\mathbf{x}))
  38
  39 qui est usuellement désignée comme la fonctionnelle "*3D-VAR*" (voir par exemple
  40 [Talagrand97]_).
  41
  42 Commandes requises et optionnelles
  43 ++++++++++++++++++++++++++++++++++
  44
  45 .. index:: single: AlgorithmParameters
  46 .. index:: single: Background
  47 .. index:: single: BackgroundError
  48 .. index:: single: Observation
  49 .. index:: single: ObservationError
  50 .. index:: single: ObservationOperator
  51 .. index:: single: Minimizer
  52 .. index:: single: Bounds
  53 .. index:: single: MaximumNumberOfSteps
  54 .. index:: single: CostDecrementTolerance
  55 .. index:: single: ProjectedGradientTolerance
  56 .. index:: single: GradientNormTolerance
  57 .. index:: single: StoreSupplementaryCalculations
  58 .. index:: single: Quantiles
  59 .. index:: single: SetSeed
  60 .. index:: single: NumberOfSamplesForQuantiles
  61 .. index:: single: SimulationForQuantiles
  62
  63 Les commandes requises générales, disponibles dans l'interface en édition, sont
  64 les suivantes:
  65
  66   Background
  67     *Commande obligatoire*. Elle définit le vecteur d'ébauche ou
  68     d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est
  69     définie comme un objet de type "*Vector*" ou de type "*VectorSerie*".
  70
  71   BackgroundError
  72     *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
  73     d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie
  74     comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
  75     type "*DiagonalSparseMatrix*".
  76
  77   Observation
  78     *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en
  79     assimilation de données ou en optimisation, et noté précédemment
  80     :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*"
  81     ou de type "*VectorSerie*".
  82
  83   ObservationError
  84     *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
  85     d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie
  86     comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
  87     type "*DiagonalSparseMatrix*".
  88
  89   ObservationOperator
  90     *Commande obligatoire*. Elle indique l'opérateur d'observation, noté
  91     précédemment :math:`H`, qui transforme les paramètres d'entrée
  92     :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux
  93     observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de
  94     type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
  95     différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
  96     la section :ref:`section_ref_operator_requirements`. Si un contrôle
  97     :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être
  98     appliqué à une paire :math:`(X,U)`.
  99
 100 Les commandes optionnelles générales, disponibles dans l'interface en édition,
 101 sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les
 102 paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les
 103 options particulières, décrites ci-après, de l'algorithme. On se reportera à la
 104 :ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette
 105 commande.
 106
 107 Les options de l'algorithme sont les suivantes:
 108
 109   Minimizer
 110     Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par
 111     défaut est "LBFGSB", et les choix possibles sont "LBFGSB" (minimisation non
 112     linéaire sous contraintes, voir [Byrd95]_, [Morales11]_ et [Zhu97]_), "TNC"
 113     (minimisation non linéaire sous contraintes), "CG" (minimisation non
 114     linéaire sans contraintes), "BFGS" (minimisation non linéaire sans
 115     contraintes), "NCG" (minimisation de type gradient conjugué de Newton). Il
 116     est fortement conseillé de conserver la valeur par défaut.
 117
 118     Exemple : ``{"Minimizer":"LBFGSB"}``
 119
 120   Bounds
 121     Cette clé permet de définir des bornes supérieure et inférieure pour chaque
 122     variable d'état optimisée. Les bornes doivent être données par une liste de
 123     liste de paires de bornes inférieure/supérieure pour chaque variable, avec
 124     une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes
 125     peuvent toujours être spécifiées, mais seuls les optimiseurs sous
 126     contraintes les prennent en compte.
 127
 128     Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}``
 129
 130   MaximumNumberOfSteps
 131     Cette clé indique le nombre maximum d'itérations possibles en optimisation
 132     itérative. Le défaut est 15000, qui est très similaire à une absence de
 133     limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre
 134     aux besoins pour des problèmes réels. Pour certains optimiseurs, le nombre
 135     de pas effectif d'arrêt peut être légèrement différent de la limite à cause
 136     d'exigences de contrôle interne de l'algorithme.
 137
 138     Exemple : ``{"MaximumNumberOfSteps":100}``
 139
 140   CostDecrementTolerance
 141     Cette clé indique une valeur limite, conduisant à arrêter le processus
 142     itératif d'optimisation lorsque la fonction coût décroît moins que cette
 143     tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé
 144     de l'adapter aux besoins pour des problèmes réels.
 145
 146     Exemple : ``{"CostDecrementTolerance":1.e-7}``
 147
 148   ProjectedGradientTolerance
 149     Cette clé indique une valeur limite, conduisant à arrêter le processus
 150     itératif d'optimisation lorsque toutes les composantes du gradient projeté
 151     sont en-dessous de cette limite. C'est utilisé uniquement par les
 152     optimiseurs sous contraintes. Le défaut est -1, qui désigne le défaut
 153     interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé
 154     de le changer.
 155
 156     Exemple : ``{"ProjectedGradientTolerance":-1}``
 157
 158   GradientNormTolerance
 159     Cette clé indique une valeur limite, conduisant à arrêter le processus
 160     itératif d'optimisation lorsque la norme du gradient est en dessous de cette
 161     limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le
 162     défaut est 1.e-5 et il n'est pas recommandé de le changer.
 163
 164     Exemple : ``{"GradientNormTolerance":1.e-5}``
 165
 166   StoreSupplementaryCalculations
 167     Cette liste indique les noms des variables supplémentaires qui peuvent être
 168     disponibles à la fin de l'algorithme. Cela implique potentiellement des
 169     calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
 170     aucune de ces variables n'étant calculée et stockée par défaut. Les noms
 171     possibles sont dans la liste suivante : ["APosterioriCorrelations",
 172     "APosterioriCovariance", "APosterioriStandardDeviations",
 173     "APosterioriVariances", "BMA", "CostFunctionJ", "CostFunctionJb",
 174     "CostFunctionJo", "CostFunctionJAtCurrentOptimum",
 175     "CostFunctionJbAtCurrentOptimum", "CostFunctionJoAtCurrentOptimum",
 176     "CurrentOptimum", "CurrentState", "IndexOfOptimum", "Innovation",
 177     "InnovationAtCurrentState", "MahalanobisConsistency", "OMA", "OMB",
 178     "SigmaObs2", "SimulatedObservationAtBackground",
 179     "SimulatedObservationAtCurrentOptimum",
 180     "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum",
 181     "SimulationQuantiles"].
 182
 183     Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
 184
 185   Quantiles
 186     Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par
 187     simulation autour de l'état optimal. L'échantillonnage utilise des tirages
 188     aléatoires gaussiens multivariés, dirigés par la matrice de covariance a
 189     posteriori. Cette option n'est utile que si le calcul supplémentaire
 190     "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide.
 191
 192     Exemple : ``{"Quantiles":[0.1,0.9]}``
 193
 194   SetSeed
 195     Cette clé permet de donner un nombre entier pour fixer la graine du
 196     générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est
 197     par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
 198     utilise ainsi l'initialisation par défaut de l'ordinateur.
 199
 200     Exemple : ``{"SetSeed":1000}``
 201
 202   NumberOfSamplesForQuantiles
 203     Cette clé indique le nombre de simulations effectuées pour estimer les
 204     quantiles. Cette option n'est utile que si le calcul supplémentaire
 205     "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent
 206     pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%.
 207
 208     Exemple : ``{"NumberOfSamplesForQuantiles":100}``
 209
 210   SimulationForQuantiles
 211     Cette clé indique le type de simulation, linéaire (avec l'opérateur
 212     d'observation tangent appliqué sur des incréments de perturbations autour de
 213     l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard
 214     appliqué aux états perturbés), que l'on veut faire pour chaque perturbation.
 215     Cela change essentiellement le temps de chaque simulation élémentaire,
 216     usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est
 217     utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La
 218     valeur par défaut est "Linear", et les choix possibles sont "Linear" et
 219     "NonLinear".
 220
 221     Exemple : ``{"SimulationForQuantiles":"Linear"}``
 222
 223 Informations et variables disponibles à la fin de l'algorithme
 224 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 225
 226 En sortie, après exécution de l'algorithme, on dispose d'informations et de
 227 variables issues du calcul. La description des
 228 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
 229 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
 230 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
 231 l'écriture des procédures de post-processing, sont décrites dans
 232 l':ref:`subsection_r_o_v_Inventaire`.
 233
 234 Les sorties non conditionnelles de l'algorithme sont les suivantes:
 235
 236   Analysis
 237     *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
 238     en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
 239     données.
 240
 241     Exemple : ``Xa = ADD.get("Analysis")[-1]``
 242
 243   CostFunctionJ
 244     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 245     :math:`J`.
 246
 247     Exemple : ``J = ADD.get("CostFunctionJ")[:]``
 248
 249   CostFunctionJb
 250     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 251     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
 252
 253     Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
 254
 255   CostFunctionJo
 256     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 257     :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
 258
 259     Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
 260
 261 Les sorties conditionnelles de l'algorithme sont les suivantes:
 262
 263   APosterioriCorrelations
 264     *Liste de matrices*. Chaque élément est une matrice de corrélations des
 265     erreurs *a posteriori* de l'état optimal, issue de la matrice
 266     :math:`\mathbf{A}*` des covariances.
 267
 268     Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]``
 269
 270   APosterioriCovariance
 271     *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de
 272     covariances des erreurs *a posteriori* de l'état optimal.
 273
 274     Exemple : ``A = ADD.get("APosterioriCovariance")[-1]``
 275
 276   APosterioriStandardDeviations
 277     *Liste de matrices*. Chaque élément est une matrice diagonale d'écarts-types
 278     des erreurs *a posteriori* de l'état optimal, issue de la matrice
 279     :math:`\mathbf{A}*` des covariances.
 280
 281     Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]``
 282
 283   APosterioriVariances
 284     *Liste de matrices*. Chaque élément est une matrice diagonale de variances
 285     des erreurs *a posteriori* de l'état optimal, issue de la matrice
 286     :math:`\mathbf{A}*` des covariances.
 287
 288     Exemple : ``V = ADD.get("APosterioriVariances")[-1]``
 289
 290   BMA
 291     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 292     l'ébauche et l'état optimal.
 293
 294     Exemple : ``bma = ADD.get("BMA")[-1]``
 295
 296   CostFunctionJAtCurrentOptimum
 297     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 298     :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis
 299     le début.
 300
 301     Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]``
 302
 303   CostFunctionJbAtCurrentOptimum
 304     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 305     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la
 306     valeur correspond à l'état optimal trouvé depuis le début.
 307
 308     Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]``
 309
 310   CostFunctionJoAtCurrentOptimum
 311     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 312     :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas,
 313     la valeur correspond à l'état optimal trouvé depuis le début.
 314
 315     Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]``
 316
 317   CurrentOptimum
 318     *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de
 319     temps courant au cours du déroulement de l'algorithme d'optimisation. Ce
 320     n'est pas nécessairement le dernier état.
 321
 322     Exemple : ``Xo = ADD.get("CurrentOptimum")[:]``
 323
 324   CurrentState
 325     *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
 326     au cours du déroulement de l'algorithme d'optimisation.
 327
 328     Exemple : ``Xs = ADD.get("CurrentState")[:]``
 329
 330   IndexOfOptimum
 331     *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum
 332     obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas
 333     nécessairement le numéro de la dernière itération.
 334
 335     Exemple : ``i = ADD.get("IndexOfOptimum")[-1]``
 336
 337   Innovation
 338     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
 339     en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
 340     d'évolution.
 341
 342     Exemple : ``d = ADD.get("Innovation")[-1]``
 343
 344   InnovationAtCurrentState
 345     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
 346     courant.
 347
 348     Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
 349
 350   MahalanobisConsistency
 351     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 352     qualité de Mahalanobis.
 353
 354     Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
 355
 356   OMA
 357     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 358     l'observation et l'état optimal dans l'espace des observations.
 359
 360     Exemple : ``oma = ADD.get("OMA")[-1]``
 361
 362   OMB
 363     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 364     l'observation et l'état d'ébauche dans l'espace des observations.
 365
 366     Exemple : ``omb = ADD.get("OMB")[-1]``
 367
 368   SigmaObs2
 369     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 370     qualité :math:`(\sigma^o)^2` de la partie observation.
 371
 372     Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
 373
 374   SimulatedObservationAtBackground
 375     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 376     partir de l'ébauche :math:`\mathbf{x}^b`.
 377
 378     Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
 379
 380   SimulatedObservationAtCurrentOptimum
 381     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 382     partir de l'état optimal au pas de temps courant au cours du déroulement de
 383     l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations.
 384
 385     Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]``
 386
 387   SimulatedObservationAtCurrentState
 388     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 389     partir de l'état courant, c'est-à-dire dans l'espace des observations.
 390
 391     Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
 392
 393   SimulatedObservationAtOptimum
 394     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 395     partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
 396
 397     Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
 398
 399   SimulationQuantiles
 400     *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état
 401     observé qui réalise le quantile demandé, dans le même ordre que les
 402     quantiles requis par l'utilisateur.
 403
 404     Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]``
 405
 406 Voir aussi
 407 ++++++++++
 408
 409 Références vers d'autres sections :
 410   - :ref:`section_ref_algorithm_Blue`
 411   - :ref:`section_ref_algorithm_ExtendedBlue`
 412   - :ref:`section_ref_algorithm_LinearityTest`
 413
 414 Références bibliographiques :
 415   - [Byrd95]_
 416   - [Morales11]_
 417   - [Talagrand97]_
 418   - [Zhu97]_