doc/fr/ref_algorithm_4DVAR.rst

   1 ..
   2    Copyright (C) 2008-2016 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: 4DVAR
  25 .. _section_ref_algorithm_4DVAR:
  26
  27 Algorithme de calcul "*4DVAR*"
  28 ------------------------------
  29
  30 .. warning::
  31
  32   dans sa présente version, cet algorithme est expérimental, et reste donc
  33   susceptible de changements dans les prochaines versions.
  34
  35 Description
  36 +++++++++++
  37
  38 Cet algorithme réalise une estimation de l'état d'un système dynamique, par une
  39 méthode de minimisation variationnelle de la fonctionnelle :math:`J` d'écart
  40 classique en assimilation de données :
  41
  42 .. math:: J(\mathbf{x})=(\mathbf{x}-\mathbf{x}^b)^T.\mathbf{B}^{-1}.(\mathbf{x}-\mathbf{x}^b)+\sum_{t\in T}(\mathbf{y^o}(t)-H(\mathbf{x},t))^T.\mathbf{R}^{-1}.(\mathbf{y^o}(t)-H(\mathbf{x},t))
  43
  44 qui est usuellement désignée comme la fonctionnelle "*4D-VAR*" (voir par exemple
  45 [Talagrand97]_). Il est bien adapté aux cas d'opérateurs d'observation et
  46 d'évolution non-linéaires, son domaine d'application est comparable aux
  47 algorithmes de filtrage de Kalman et en particulier
  48 l':ref:`section_ref_algorithm_ExtendedKalmanFilter` ou
  49 l':ref:`section_ref_algorithm_UnscentedKalmanFilter`.
  50
  51 Commandes requises et optionnelles
  52 ++++++++++++++++++++++++++++++++++
  53
  54 .. index:: single: AlgorithmParameters
  55 .. index:: single: Background
  56 .. index:: single: BackgroundError
  57 .. index:: single: Observation
  58 .. index:: single: ObservationError
  59 .. index:: single: ObservationOperator
  60 .. index:: single: Bounds
  61 .. index:: single: ConstrainedBy
  62 .. index:: single: EstimationOf
  63 .. index:: single: MaximumNumberOfSteps
  64 .. index:: single: CostDecrementTolerance
  65 .. index:: single: ProjectedGradientTolerance
  66 .. index:: single: GradientNormTolerance
  67 .. index:: single: StoreSupplementaryCalculations
  68
  69 Les commandes requises générales, disponibles dans l'interface en édition, sont
  70 les suivantes:
  71
  72   Background
  73     *Commande obligatoire*. Elle définit le vecteur d'ébauche ou
  74     d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est
  75     définie comme un objet de type "*Vector*" ou de type "*VectorSerie*".
  76
  77   BackgroundError
  78     *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
  79     d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie
  80     comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
  81     type "*DiagonalSparseMatrix*".
  82
  83   Observation
  84     *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en
  85     assimilation de données ou en optimisation, et noté précédemment
  86     :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*"
  87     ou de type "*VectorSerie*".
  88
  89   ObservationError
  90     *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
  91     d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie
  92     comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
  93     type "*DiagonalSparseMatrix*".
  94
  95   ObservationOperator
  96     *Commande obligatoire*. Elle indique l'opérateur d'observation, noté
  97     précédemment :math:`H`, qui transforme les paramètres d'entrée
  98     :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux
  99     observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de
 100     type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
 101     différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
 102     la section :ref:`section_ref_operator_requirements`. Si un contrôle
 103     :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être
 104     appliqué à une paire :math:`(X,U)`.
 105
 106 Les commandes optionnelles générales, disponibles dans l'interface en édition,
 107 sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les
 108 paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les
 109 options particulières, décrites ci-après, de l'algorithme. On se reportera à la
 110 :ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette
 111 commande.
 112
 113 Les options de l'algorithme sont les suivantes:
 114
 115   Minimizer
 116     Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par
 117     défaut est "LBFGSB", et les choix possibles sont "LBFGSB" (minimisation non
 118     linéaire sous contraintes, voir [Byrd95]_, [Morales11]_ et [Zhu97]_), "TNC"
 119     (minimisation non linéaire sous contraintes), "CG" (minimisation non
 120     linéaire sans contraintes), "BFGS" (minimisation non linéaire sans
 121     contraintes), "NCG" (minimisation de type gradient conjugué de Newton). Il
 122     est fortement conseillé de conserver la valeur par défaut.
 123
 124     Exemple : ``{"Minimizer":"LBFGSB"}``
 125
 126   Bounds
 127     Cette clé permet de définir des bornes supérieure et inférieure pour chaque
 128     variable d'état optimisée. Les bornes doivent être données par une liste de
 129     liste de paires de bornes inférieure/supérieure pour chaque variable, avec
 130     une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes peuvent
 131     toujours être spécifiées, mais seuls les optimiseurs sous contraintes les
 132     prennent en compte.
 133
 134     Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}``
 135
 136   ConstrainedBy
 137     Cette clé permet d'indiquer la méthode de prise en compte des contraintes de
 138     bornes. La seule disponible est "EstimateProjection", qui projete
 139     l'estimation de l'état courant sur les contraintes de bornes.
 140
 141     Exemple : ``{"ConstrainedBy":"EstimateProjection"}``
 142
 143   MaximumNumberOfSteps
 144     Cette clé indique le nombre maximum d'itérations possibles en optimisation
 145     itérative. Le défaut est 15000, qui est très similaire à une absence de
 146     limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre
 147     aux besoins pour des problèmes réels. Pour certains optimiseurs, le nombre
 148     de pas effectif d'arrêt peut être légèrement différent de la limite à cause
 149     d'exigences de contrôle interne de l'algorithme.
 150
 151     Exemple : ``{"MaximumNumberOfSteps":100}``
 152
 153   CostDecrementTolerance
 154     Cette clé indique une valeur limite, conduisant à arrêter le processus
 155     itératif d'optimisation lorsque la fonction coût décroît moins que cette
 156     tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé
 157     de l'adapter aux besoins pour des problèmes réels.
 158
 159     Exemple : ``{"CostDecrementTolerance":1.e-7}``
 160
 161   EstimationOf
 162     Cette clé permet de choisir le type d'estimation à réaliser. Cela peut être
 163     soit une estimation de l'état, avec la valeur "State", ou une estimation de
 164     paramètres, avec la valeur "Parameters". Le choix par défaut est "State".
 165
 166     Exemple : ``{"EstimationOf":"Parameters"}``
 167
 168   ProjectedGradientTolerance
 169     Cette clé indique une valeur limite, conduisant à arrêter le processus
 170     itératif d'optimisation lorsque toutes les composantes du gradient projeté
 171     sont en-dessous de cette limite. C'est utilisé uniquement par les
 172     optimiseurs sous contraintes. Le défaut est -1, qui désigne le défaut
 173     interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé
 174     de le changer.
 175
 176     Exemple : ``{"ProjectedGradientTolerance":-1}``
 177
 178   GradientNormTolerance
 179     Cette clé indique une valeur limite, conduisant à arrêter le processus
 180     itératif d'optimisation lorsque la norme du gradient est en dessous de cette
 181     limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le
 182     défaut est 1.e-5 et il n'est pas recommandé de le changer.
 183
 184     Exemple : ``{"GradientNormTolerance":1.e-5}``
 185
 186   StoreSupplementaryCalculations
 187     Cette liste indique les noms des variables supplémentaires qui peuvent être
 188     disponibles à la fin de l'algorithme. Cela implique potentiellement des
 189     calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
 190     aucune de ces variables n'étant calculée et stockée par défaut. Les noms
 191     possibles sont dans la liste suivante : ["BMA", "CostFunctionJ",
 192     "CostFunctionJAtCurrentOptimum", "CurrentOptimum", "CurrentState",
 193     "IndexOfOptimum"].
 194
 195     Exemple : ``{"StoreSupplementaryCalculations":["BMA", "CurrentState"]}``
 196
 197 Informations et variables disponibles à la fin de l'algorithme
 198 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 199
 200 En sortie, après exécution de l'algorithme, on dispose d'informations et de
 201 variables issues du calcul. La description des
 202 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
 203 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
 204 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
 205 l'écriture des procédures de post-processing, sont décrites dans
 206 l':ref:`subsection_r_o_v_Inventaire`.
 207
 208 Les sorties non conditionnelles de l'algorithme sont les suivantes:
 209
 210   Analysis
 211     *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
 212     en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
 213     données.
 214
 215     Exemple : ``Xa = ADD.get("Analysis")[-1]``
 216
 217   CostFunctionJ
 218     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 219     :math:`J`.
 220
 221     Exemple : ``J = ADD.get("CostFunctionJ")[:]``
 222
 223   CostFunctionJb
 224     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 225     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
 226
 227     Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
 228
 229   CostFunctionJo
 230     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 231     :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
 232
 233     Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
 234
 235 Les sorties conditionnelles de l'algorithme sont les suivantes:
 236
 237   BMA
 238     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 239     l'ébauche et l'état optimal.
 240
 241     Exemple : ``bma = ADD.get("BMA")[-1]``
 242
 243   CostFunctionJAtCurrentOptimum
 244     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 245     :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis
 246     le début.
 247
 248     Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]``
 249
 250   CostFunctionJbAtCurrentOptimum
 251     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 252     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la
 253     valeur correspond à l'état optimal trouvé depuis le début.
 254
 255     Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]``
 256
 257   CostFunctionJoAtCurrentOptimum
 258     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 259     :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas,
 260     la valeur correspond à l'état optimal trouvé depuis le début.
 261
 262     Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]``
 263
 264   CurrentOptimum
 265     *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de
 266     temps courant au cours du déroulement de l'algorithme d'optimisation. Ce
 267     n'est pas nécessairement le dernier état.
 268
 269     Exemple : ``Xo = ADD.get("CurrentOptimum")[:]``
 270
 271   CurrentState
 272     *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
 273     au cours du déroulement de l'algorithme d'optimisation.
 274
 275     Exemple : ``Xs = ADD.get("CurrentState")[:]``
 276
 277   IndexOfOptimum
 278     *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum
 279     obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas
 280     nécessairement le numéro de la dernière itération.
 281
 282     Exemple : ``i = ADD.get("IndexOfOptimum")[-1]``
 283
 284 Voir aussi
 285 ++++++++++
 286
 287 Références vers d'autres sections :
 288   - :ref:`section_ref_algorithm_3DVAR`
 289   - :ref:`section_ref_algorithm_KalmanFilter`
 290   - :ref:`section_ref_algorithm_ExtendedKalmanFilter`
 291
 292 Références bibliographiques :
 293   - [Byrd95]_
 294   - [Morales11]_
 295   - [Talagrand97]_
 296   - [Zhu97]_