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: Background
  46 .. index:: single: BackgroundError
  47 .. index:: single: Observation
  48 .. index:: single: ObservationError
  49 .. index:: single: ObservationOperator
  50 .. index:: single: Minimizer
  51 .. index:: single: Bounds
  52 .. index:: single: MaximumNumberOfSteps
  53 .. index:: single: CostDecrementTolerance
  54 .. index:: single: ProjectedGradientTolerance
  55 .. index:: single: GradientNormTolerance
  56 .. index:: single: StoreSupplementaryCalculations
  57 .. index:: single: Quantiles
  58 .. index:: single: SetSeed
  59 .. index:: single: NumberOfSamplesForQuantiles
  60 .. index:: single: SimulationForQuantiles
  61
  62 Les commandes requises générales, disponibles dans l'interface en édition, sont
  63 les suivantes:
  64
  65   Background
  66     *Commande obligatoire*. Elle définit le vecteur d'ébauche ou
  67     d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est
  68     définie comme un objet de type "*Vector*" ou de type "*VectorSerie*".
  69
  70   BackgroundError
  71     *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
  72     d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie
  73     comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
  74     type "*DiagonalSparseMatrix*".
  75
  76   Observation
  77     *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en
  78     assimilation de données ou en optimisation, et noté précédemment
  79     :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*"
  80     ou de type "*VectorSerie*".
  81
  82   ObservationError
  83     *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
  84     d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie
  85     comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
  86     type "*DiagonalSparseMatrix*".
  87
  88   ObservationOperator
  89     *Commande obligatoire*. Elle indique l'opérateur d'observation, noté
  90     précédemment :math:`H`, qui transforme les paramètres d'entrée
  91     :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux
  92     observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de
  93     type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
  94     différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
  95     la section :ref:`section_ref_operator_requirements`. Si un contrôle
  96     :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être
  97     appliqué à une paire :math:`(X,U)`.
  98
  99 Les commandes optionnelles générales, disponibles dans l'interface en édition,
 100 sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier,
 101 la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options
 102 particulières, décrites ci-après, de l'algorithme. On se reportera à la
 103 :ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette
 104 commande.
 105
 106 Les options de l'algorithme sont les suivantes:
 107
 108   Minimizer
 109     Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par
 110     défaut est "LBFGSB", et les choix possibles sont "LBFGSB" (minimisation non
 111     linéaire sous contraintes, voir [Byrd95]_, [Morales11]_ et [Zhu97]_), "TNC"
 112     (minimisation non linéaire sous contraintes), "CG" (minimisation non
 113     linéaire sans contraintes), "BFGS" (minimisation non linéaire sans
 114     contraintes), "NCG" (minimisation de type gradient conjugué de Newton). Il
 115     est fortement conseillé de conserver la valeur par défaut.
 116
 117     Exemple : ``{"Minimizer":"LBFGSB"}``
 118
 119   Bounds
 120     Cette clé permet de définir des bornes supérieure et inférieure pour chaque
 121     variable d'état optimisée. Les bornes doivent être données par une liste de
 122     liste de paires de bornes inférieure/supérieure pour chaque variable, avec
 123     une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes peuvent
 124     toujours être spécifiées, mais seuls les optimiseurs sous contraintes les
 125     prennent en compte.
 126
 127     Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}``
 128
 129   MaximumNumberOfSteps
 130     Cette clé indique le nombre maximum d'itérations possibles en optimisation
 131     itérative. Le défaut est 15000, qui est très similaire à une absence de
 132     limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre
 133     aux besoins pour des problèmes réels. Pour certains optimiseurs, le nombre
 134     de pas effectif d'arrêt peut être légèrement différent de la limite à cause
 135     d'exigences de contrôle interne de l'algorithme.
 136
 137     Exemple : ``{"MaximumNumberOfSteps":100}``
 138
 139   CostDecrementTolerance
 140     Cette clé indique une valeur limite, conduisant à arrêter le processus
 141     itératif d'optimisation lorsque la fonction coût décroît moins que cette
 142     tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé
 143     de l'adapter aux besoins pour des problèmes réels.
 144
 145     Exemple : ``{"CostDecrementTolerance":1.e-7}``
 146
 147   ProjectedGradientTolerance
 148     Cette clé indique une valeur limite, conduisant à arrêter le processus
 149     itératif d'optimisation lorsque toutes les composantes du gradient projeté
 150     sont en-dessous de cette limite. C'est utilisé uniquement par les
 151     optimiseurs sous contraintes. Le défaut est -1, qui désigne le défaut
 152     interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé
 153     de le changer.
 154
 155     Exemple : ``{"ProjectedGradientTolerance":-1}``
 156
 157   GradientNormTolerance
 158     Cette clé indique une valeur limite, conduisant à arrêter le processus
 159     itératif d'optimisation lorsque la norme du gradient est en dessous de cette
 160     limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le
 161     défaut est 1.e-5 et il n'est pas recommandé de le changer.
 162
 163     Exemple : ``{"GradientNormTolerance":1.e-5}``
 164
 165   StoreSupplementaryCalculations
 166     Cette liste indique les noms des variables supplémentaires qui peuvent être
 167     disponibles à la fin de l'algorithme. Cela implique potentiellement des
 168     calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
 169     aucune de ces variables n'étant calculée et stockée par défaut. Les noms
 170     possibles sont dans la liste suivante : ["APosterioriCovariance", "BMA",
 171     "CostFunctionJ", "CurrentState", "OMA", "OMB", "Innovation", "SigmaObs2",
 172     "MahalanobisConsistency", "SimulatedObservationAtBackground",
 173     "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum",
 174     "SimulationQuantiles"].
 175
 176     Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}``
 177
 178   Quantiles
 179     Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par
 180     simulation autour de l'état optimal. L'échantillonnage utilise des tirages
 181     aléatoires gaussiens multivariés, dirigés par la matrice de covariance a
 182     posteriori. Cette option n'est utile que si le calcul supplémentaire
 183     "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide.
 184
 185     Exemple : ``{"Quantiles":[0.1,0.9]}``
 186
 187   SetSeed
 188     Cette clé permet de donner un nombre entier pour fixer la graine du
 189     générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est
 190     par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
 191     utilise ainsi l'initialisation par défaut de l'ordinateur.
 192
 193     Exemple : ``{"SetSeed":1000}``
 194
 195   NumberOfSamplesForQuantiles
 196     Cette clé indique le nombre de simulations effectuées pour estimer les
 197     quantiles. Cette option n'est utile que si le calcul supplémentaire
 198     "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent
 199     pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%.
 200
 201     Exemple : ``{"NumberOfSamplesForQuantiles":100}``
 202
 203   SimulationForQuantiles
 204     Cette clé indique le type de simulation, linéaire (avec l'opérateur
 205     d'observation tangent appliqué sur des incréments de perturbations autour de
 206     l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard
 207     appliqué aux états perturbés), que l'on veut faire pour chaque perturbation.
 208     Cela change essentiellement le temps de chaque simulation élémentaire,
 209     usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est
 210     utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La
 211     valeur par défaut est "Linear", et les choix possibles sont "Linear" et
 212     "NonLinear".
 213
 214     Exemple : ``{"SimulationForQuantiles":"Linear"}``
 215
 216 Informations et variables disponibles à la fin de l'algorithme
 217 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 218
 219 En sortie, après exécution de l'algorithme, on dispose d'informations et de
 220 variables issues du calcul. La description des
 221 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
 222 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
 223 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
 224 l'écriture des procédures de post-processing, sont décrites dans
 225 l':ref:`subsection_r_o_v_Inventaire`.
 226
 227 Les sorties non conditionnelles de l'algorithme sont les suivantes:
 228
 229   Analysis
 230     *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
 231     en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
 232     données.
 233
 234     Exemple : ``Xa = ADD.get("Analysis")[-1]``
 235
 236   CostFunctionJ
 237     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 238     :math:`J`.
 239
 240     Exemple : ``J = ADD.get("CostFunctionJ")[:]``
 241
 242   CostFunctionJb
 243     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 244     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
 245
 246     Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
 247
 248   CostFunctionJo
 249     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 250     :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
 251
 252     Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
 253
 254 Les sorties conditionnelles de l'algorithme sont les suivantes:
 255
 256   APosterioriCovariance
 257     *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de
 258     covariances des erreurs *a posteriori* de l'état optimal.
 259
 260     Exemple : ``A = ADD.get("APosterioriCovariance")[-1]``
 261
 262   BMA
 263     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 264     l'ébauche et l'état optimal.
 265
 266     Exemple : ``bma = ADD.get("BMA")[-1]``
 267
 268   CurrentState
 269     *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
 270     au cours du déroulement de l'algorithme d'optimisation.
 271
 272     Exemple : ``Xs = ADD.get("CurrentState")[:]``
 273
 274   Innovation
 275     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
 276     en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
 277     d'évolution.
 278
 279     Exemple : ``d = ADD.get("Innovation")[-1]``
 280
 281   MahalanobisConsistency
 282     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 283     qualité de Mahalanobis.
 284
 285     Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
 286
 287   OMA
 288     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 289     l'observation et l'état optimal dans l'espace des observations.
 290
 291     Exemple : ``oma = ADD.get("OMA")[-1]``
 292
 293   OMB
 294     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 295     l'observation et l'état d'ébauche dans l'espace des observations.
 296
 297     Exemple : ``omb = ADD.get("OMB")[-1]``
 298
 299   SigmaObs2
 300     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 301     qualité :math:`(\sigma^o)^2` de la partie observation.
 302
 303     Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
 304
 305   SimulatedObservationAtBackground
 306     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 307     partir de l'ébauche :math:`\mathbf{x}^b`.
 308
 309     Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
 310
 311   SimulatedObservationAtCurrentState
 312     *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant,
 313     c'est-à-dire dans l'espace des observations.
 314
 315     Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]``
 316
 317   SimulatedObservationAtOptimum
 318     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 319     partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
 320
 321     Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
 322
 323   SimulationQuantiles
 324     *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état
 325     observé qui réalise le quantile demandé, dans le même ordre que les
 326     quantiles requis par l'utilisateur.
 327
 328     Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]``
 329
 330 Voir aussi
 331 ++++++++++
 332
 333 Références vers d'autres sections :
 334   - :ref:`section_ref_algorithm_Blue`
 335   - :ref:`section_ref_algorithm_ExtendedBlue`
 336   - :ref:`section_ref_algorithm_LinearityTest`
 337
 338 Références bibliographiques :
 339   - [Byrd95]_
 340   - [Morales11]_
 341   - [Talagrand97]_