doc/fr/ref_algorithm_3DVAR.rst

   1 ..
   2    Copyright (C) 2008-2015 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 peuvent
 125     toujours être spécifiées, mais seuls les optimiseurs sous contraintes les
 126     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",
 174     "CostFunctionJAtCurrentOptimum", "CurrentOptimum", "CurrentState",
 175     "IndexOfOptimum", "Innovation", "InnovationAtCurrentState",
 176     "MahalanobisConsistency", "OMA", "OMB", "SigmaObs2",
 177     "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentOptimum",
 178     "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum",
 179     "SimulationQuantiles"].
 180
 181     Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
 182
 183   Quantiles
 184     Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par
 185     simulation autour de l'état optimal. L'échantillonnage utilise des tirages
 186     aléatoires gaussiens multivariés, dirigés par la matrice de covariance a
 187     posteriori. Cette option n'est utile que si le calcul supplémentaire
 188     "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide.
 189
 190     Exemple : ``{"Quantiles":[0.1,0.9]}``
 191
 192   SetSeed
 193     Cette clé permet de donner un nombre entier pour fixer la graine du
 194     générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est
 195     par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
 196     utilise ainsi l'initialisation par défaut de l'ordinateur.
 197
 198     Exemple : ``{"SetSeed":1000}``
 199
 200   NumberOfSamplesForQuantiles
 201     Cette clé indique le nombre de simulations effectuées pour estimer les
 202     quantiles. Cette option n'est utile que si le calcul supplémentaire
 203     "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent
 204     pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%.
 205
 206     Exemple : ``{"NumberOfSamplesForQuantiles":100}``
 207
 208   SimulationForQuantiles
 209     Cette clé indique le type de simulation, linéaire (avec l'opérateur
 210     d'observation tangent appliqué sur des incréments de perturbations autour de
 211     l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard
 212     appliqué aux états perturbés), que l'on veut faire pour chaque perturbation.
 213     Cela change essentiellement le temps de chaque simulation élémentaire,
 214     usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est
 215     utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La
 216     valeur par défaut est "Linear", et les choix possibles sont "Linear" et
 217     "NonLinear".
 218
 219     Exemple : ``{"SimulationForQuantiles":"Linear"}``
 220
 221 Informations et variables disponibles à la fin de l'algorithme
 222 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 223
 224 En sortie, après exécution de l'algorithme, on dispose d'informations et de
 225 variables issues du calcul. La description des
 226 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
 227 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
 228 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
 229 l'écriture des procédures de post-processing, sont décrites dans
 230 l':ref:`subsection_r_o_v_Inventaire`.
 231
 232 Les sorties non conditionnelles de l'algorithme sont les suivantes:
 233
 234   Analysis
 235     *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
 236     en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
 237     données.
 238
 239     Exemple : ``Xa = ADD.get("Analysis")[-1]``
 240
 241   CostFunctionJ
 242     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 243     :math:`J`.
 244
 245     Exemple : ``J = ADD.get("CostFunctionJ")[:]``
 246
 247   CostFunctionJb
 248     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 249     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
 250
 251     Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
 252
 253   CostFunctionJo
 254     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 255     :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
 256
 257     Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
 258
 259 Les sorties conditionnelles de l'algorithme sont les suivantes:
 260
 261   APosterioriCorrelations
 262     *Liste de matrices*. Chaque élément est une matrice de corrélations des
 263     erreurs *a posteriori* de l'état optimal, issue de la matrice
 264     :math:`\mathbf{A}*` des covariances.
 265
 266     Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]``
 267
 268   APosterioriCovariance
 269     *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de
 270     covariances des erreurs *a posteriori* de l'état optimal.
 271
 272     Exemple : ``A = ADD.get("APosterioriCovariance")[-1]``
 273
 274   APosterioriStandardDeviations
 275     *Liste de matrices*. Chaque élément est une matrice diagonale d'écarts-types
 276     des erreurs *a posteriori* de l'état optimal, issue de la matrice
 277     :math:`\mathbf{A}*` des covariances.
 278
 279     Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]``
 280
 281   APosterioriVariances
 282     *Liste de matrices*. Chaque élément est une matrice diagonale de variances
 283     des erreurs *a posteriori* de l'état optimal, issue de la matrice
 284     :math:`\mathbf{A}*` des covariances.
 285
 286     Exemple : ``V = ADD.get("APosterioriVariances")[-1]``
 287
 288   BMA
 289     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 290     l'ébauche et l'état optimal.
 291
 292     Exemple : ``bma = ADD.get("BMA")[-1]``
 293
 294   CostFunctionJAtCurrentOptimum
 295     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 296     :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis
 297     le début.
 298
 299     Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]``
 300
 301   CostFunctionJbAtCurrentOptimum
 302     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 303     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la
 304     valeur correspond à l'état optimal trouvé depuis le début.
 305
 306     Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]``
 307
 308   CostFunctionJoAtCurrentOptimum
 309     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 310     :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas,
 311     la valeur correspond à l'état optimal trouvé depuis le début.
 312
 313     Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]``
 314
 315   CurrentOptimum
 316     *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de
 317     temps courant au cours du déroulement de l'algorithme d'optimisation. Ce
 318     n'est pas nécessairement le dernier état.
 319
 320     Exemple : ``Xo = ADD.get("CurrentOptimum")[:]``
 321
 322   CurrentState
 323     *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
 324     au cours du déroulement de l'algorithme d'optimisation.
 325
 326     Exemple : ``Xs = ADD.get("CurrentState")[:]``
 327
 328   IndexOfOptimum
 329     *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum
 330     obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas
 331     nécessairement le numéro de la dernière itération.
 332
 333     Exemple : ``i = ADD.get("IndexOfOptimum")[-1]``
 334
 335   Innovation
 336     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
 337     en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
 338     d'évolution.
 339
 340     Exemple : ``d = ADD.get("Innovation")[-1]``
 341
 342   InnovationAtCurrentState
 343     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
 344     courant.
 345
 346     Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
 347
 348   MahalanobisConsistency
 349     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 350     qualité de Mahalanobis.
 351
 352     Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
 353
 354   OMA
 355     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 356     l'observation et l'état optimal dans l'espace des observations.
 357
 358     Exemple : ``oma = ADD.get("OMA")[-1]``
 359
 360   OMB
 361     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 362     l'observation et l'état d'ébauche dans l'espace des observations.
 363
 364     Exemple : ``omb = ADD.get("OMB")[-1]``
 365
 366   SigmaObs2
 367     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 368     qualité :math:`(\sigma^o)^2` de la partie observation.
 369
 370     Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
 371
 372   SimulatedObservationAtBackground
 373     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 374     partir de l'ébauche :math:`\mathbf{x}^b`.
 375
 376     Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
 377
 378   SimulatedObservationAtCurrentOptimum
 379     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 380     partir de l'état optimal au pas de temps courant au cours du déroulement de
 381     l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations.
 382
 383     Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]``
 384
 385   SimulatedObservationAtCurrentState
 386     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 387     partir de l'état courant, c'est-à-dire dans l'espace des observations.
 388
 389     Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
 390
 391   SimulatedObservationAtOptimum
 392     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 393     partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
 394
 395     Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
 396
 397   SimulationQuantiles
 398     *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état
 399     observé qui réalise le quantile demandé, dans le même ordre que les
 400     quantiles requis par l'utilisateur.
 401
 402     Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]``
 403
 404 Voir aussi
 405 ++++++++++
 406
 407 Références vers d'autres sections :
 408   - :ref:`section_ref_algorithm_Blue`
 409   - :ref:`section_ref_algorithm_ExtendedBlue`
 410   - :ref:`section_ref_algorithm_LinearityTest`
 411
 412 Références bibliographiques :
 413   - [Byrd95]_
 414   - [Morales11]_
 415   - [Talagrand97]_