doc/fr/ref_algorithm_Blue.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: Blue
  25 .. _section_ref_algorithm_Blue:
  26
  27 Algorithme de calcul "*Blue*"
  28 -----------------------------
  29
  30 Description
  31 +++++++++++
  32
  33 Cet algorithme réalise une estimation de type BLUE (Best Linear Unbiased
  34 Estimator) de l'état d'un système. De manière précise, c'est un estimateur
  35 d'Aitken.
  36
  37 Cet algorithme est toujours le plus rapide de l'ensemble des algorithmes
  38 d'assimilation d'ADAO. Il est théoriquement réservé aux cas d'opérateurs
  39 d'observation linéaires, même s'il fonctionne parfois dans les cas "faiblement"
  40 non-linéaires. On peut vérifier la linéarité de l'opérateur d'observation à
  41 l'aide de l':ref:`section_ref_algorithm_LinearityTest`.
  42
  43 En cas de non-linéarité, même peu marquée, on lui préférera aisément
  44 l':ref:`section_ref_algorithm_ExtendedBlue` ou
  45 l':ref:`section_ref_algorithm_3DVAR`.
  46
  47 Commandes requises et optionnelles
  48 ++++++++++++++++++++++++++++++++++
  49
  50 .. index:: single: AlgorithmParameters
  51 .. index:: single: Background
  52 .. index:: single: BackgroundError
  53 .. index:: single: Observation
  54 .. index:: single: ObservationError
  55 .. index:: single: ObservationOperator
  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`. De plus, les
 101 paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les
 102 options particulières, décrites ci-après, de l'algorithme. On se reportera à la
 103 :ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette
 104 commande.
 105
 106 Les options de l'algorithme sont les suivantes:
 107
 108   StoreSupplementaryCalculations
 109     Cette liste indique les noms des variables supplémentaires qui peuvent être
 110     disponibles à la fin de l'algorithme. Cela implique potentiellement des
 111     calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
 112     aucune de ces variables n'étant calculée et stockée par défaut. Les noms
 113     possibles sont dans la liste suivante : ["APosterioriCorrelations",
 114     "APosterioriCovariance", "APosterioriStandardDeviations",
 115     "APosterioriVariances", "BMA", "OMA", "OMB", "CurrentState",
 116     "CostFunctionJ", "Innovation", "SigmaBck2", "SigmaObs2",
 117     "MahalanobisConsistency", "SimulationQuantiles",
 118     "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState",
 119     "SimulatedObservationAtOptimum"].
 120
 121     Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
 122
 123   Quantiles
 124     Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par
 125     simulation autour de l'état optimal. L'échantillonnage utilise des tirages
 126     aléatoires gaussiens multivariés, dirigés par la matrice de covariance a
 127     posteriori. Cette option n'est utile que si le calcul supplémentaire
 128     "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide.
 129
 130     Exemple : ``{"Quantiles":[0.1,0.9]}``
 131
 132   SetSeed
 133     Cette clé permet de donner un nombre entier pour fixer la graine du
 134     générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est
 135     par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
 136     utilise ainsi l'initialisation par défaut de l'ordinateur.
 137
 138     Exemple : ``{"SetSeed":1000}``
 139
 140   NumberOfSamplesForQuantiles
 141     Cette clé indique le nombre de simulations effectuées pour estimer les
 142     quantiles. Cette option n'est utile que si le calcul supplémentaire
 143     "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent
 144     pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%.
 145
 146     Exemple : ``{"NumberOfSamplesForQuantiles":100}``
 147
 148   SimulationForQuantiles
 149     Cette clé indique le type de simulation, linéaire (avec l'opérateur
 150     d'observation tangent appliqué sur des incréments de perturbations autour de
 151     l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard
 152     appliqué aux états perturbés), que l'on veut faire pour chaque perturbation.
 153     Cela change essentiellement le temps de chaque simulation élémentaire,
 154     usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est
 155     utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La
 156     valeur par défaut est "Linear", et les choix possibles sont "Linear" et
 157     "NonLinear".
 158
 159     Exemple : ``{"SimulationForQuantiles":"Linear"}``
 160
 161 Informations et variables disponibles à la fin de l'algorithme
 162 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 163
 164 En sortie, après exécution de l'algorithme, on dispose d'informations et de
 165 variables issues du calcul. La description des
 166 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
 167 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
 168 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
 169 l'écriture des procédures de post-processing, sont décrites dans
 170 l':ref:`subsection_r_o_v_Inventaire`.
 171
 172 Les sorties non conditionnelles de l'algorithme sont les suivantes:
 173
 174   Analysis
 175     *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
 176     en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
 177     données.
 178
 179     Exemple : ``Xa = ADD.get("Analysis")[-1]``
 180
 181 Les sorties conditionnelles de l'algorithme sont les suivantes:
 182
 183   APosterioriCorrelations
 184     *Liste de matrices*. Chaque élément est une matrice de corrélation des
 185     erreurs *a posteriori* de l'état optimal.
 186
 187     Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]``
 188
 189   APosterioriCovariance
 190     *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de
 191     covariances des erreurs *a posteriori* de l'état optimal.
 192
 193     Exemple : ``A = ADD.get("APosterioriCovariance")[-1]``
 194
 195   APosterioriStandardDeviations
 196     *Liste de matrices*. Chaque élément est une matrice d'écart-types des
 197     erreurs *a posteriori* de l'état optimal.
 198
 199     Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]``
 200
 201   APosterioriVariances
 202     *Liste de matrices*. Chaque élément est une matrice de variances des erreurs
 203     *a posteriori* de l'état optimal.
 204
 205     Exemple : ``V = ADD.get("APosterioriVariances")[-1]``
 206
 207   BMA
 208     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 209     l'ébauche et l'état optimal.
 210
 211     Exemple : ``bma = ADD.get("BMA")[-1]``
 212
 213   CostFunctionJ
 214     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 215     :math:`J`.
 216
 217     Exemple : ``J = ADD.get("CostFunctionJ")[:]``
 218
 219   CostFunctionJb
 220     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 221     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
 222
 223     Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
 224
 225   CostFunctionJo
 226     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 227     :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
 228
 229     Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
 230
 231   Innovation
 232     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
 233     en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
 234     d'évolution.
 235
 236     Exemple : ``d = ADD.get("Innovation")[-1]``
 237
 238   MahalanobisConsistency
 239     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 240     qualité de Mahalanobis.
 241
 242     Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
 243
 244   OMA
 245     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 246     l'observation et l'état optimal dans l'espace des observations.
 247
 248     Exemple : ``oma = ADD.get("OMA")[-1]``
 249
 250   OMB
 251     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 252     l'observation et l'état d'ébauche dans l'espace des observations.
 253
 254     Exemple : ``omb = ADD.get("OMB")[-1]``
 255
 256   SigmaBck2
 257     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 258     qualité :math:`(\sigma^b)^2` de la partie ébauche.
 259
 260     Exemple : ``sb2 = ADD.get("SigmaBck")[-1]``
 261
 262   SigmaObs2
 263     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 264     qualité :math:`(\sigma^o)^2` de la partie observation.
 265
 266     Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
 267
 268   SimulatedObservationAtBackground
 269     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 270     partir de l'ébauche :math:`\mathbf{x}^b`.
 271
 272     Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
 273
 274   SimulatedObservationAtOptimum
 275     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 276     partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
 277
 278     Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
 279
 280   SimulationQuantiles
 281     *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état
 282     observé qui réalise le quantile demandé, dans le même ordre que les
 283     quantiles requis par l'utilisateur.
 284
 285     Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]``
 286
 287 Voir aussi
 288 ++++++++++
 289
 290 Références vers d'autres sections :
 291   - :ref:`section_ref_algorithm_ExtendedBlue`
 292   - :ref:`section_ref_algorithm_3DVAR`
 293   - :ref:`section_ref_algorithm_LinearityTest`
 294
 295 Références bibliographiques :
 296   - [Bouttier99]_