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