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