doc/fr/ref_algorithm_ExtendedBlue.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: 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: Background
  48 .. index:: single: BackgroundError
  49 .. index:: single: Observation
  50 .. index:: single: ObservationError
  51 .. index:: single: ObservationOperator
  52 .. index:: single: StoreInternalVariables
  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`. En particulier,
  98 la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options
  99 particulières, décrites ci-après, de l'algorithme. On se reportera à la
 100 :ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette
 101 commande.
 102
 103 Les options de l'algorithme sont les suivantes:
 104
 105   StoreInternalVariables
 106     Cette clé booléenne permet de stocker les variables internes par défaut,
 107     principalement l'état courant lors d'un processus itératif. Attention, cela
 108     peut être un choix numériquement coûteux dans certains cas de calculs. La
 109     valeur par défaut est "False".
 110
 111     Exemple : ``{"StoreInternalVariables":True}``
 112
 113   StoreSupplementaryCalculations
 114     Cette liste indique les noms des variables supplémentaires qui peuvent être
 115     disponibles à la fin de l'algorithme. Cela implique potentiellement des
 116     calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
 117     aucune de ces variables n'étant calculée et stockée par défaut. Les noms
 118     possibles sont dans la liste suivante : ["APosterioriCovariance", "BMA",
 119     "OMA", "OMB", "Innovation", "SigmaBck2", "SigmaObs2",
 120     "MahalanobisConsistency", "SimulationQuantiles"].
 121
 122     Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}``
 123
 124   Quantiles
 125     Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par
 126     simulation autour de l'état optimal. L'échantillonnage utilise des tirages
 127     aléatoires gaussiens multivariés, dirigés par la matrice de covariance a
 128     posteriori. Cette option n'est utile que si le calcul supplémentaire
 129     "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide.
 130
 131     Exemple : ``{"Quantiles":[0.1,0.9]}``
 132
 133   SetSeed
 134     Cette clé permet de donner un nombre entier pour fixer la graine du
 135     générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est
 136     par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
 137     utilise ainsi l'initialisation par défaut de l'ordinateur.
 138
 139     Exemple : ``{"SetSeed":1000}``
 140
 141   NumberOfSamplesForQuantiles
 142     Cette clé indique le nombre de simulations effectuées pour estimer les
 143     quantiles. Cette option n'est utile que si le calcul supplémentaire
 144     "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent
 145     pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%.
 146
 147     Exemple : ``{"NumberOfSamplesForQuantiles":100}``
 148
 149   SimulationForQuantiles
 150     Cette clé indique le type de simulation, linéaire (avec l'opérateur
 151     d'observation tangent appliqué sur des incréments de perturbations autour de
 152     l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard
 153     appliqué aux états perturbés), que l'on veut faire pour chaque perturbation.
 154     Cela change essentiellement le temps de chaque simulation élémentaire,
 155     usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est
 156     utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La
 157     valeur par défaut est "Linear", et les choix possibles sont "Linear" et
 158     "NonLinear".
 159
 160     Exemple : ``{"SimulationForQuantiles":"Linear"}``
 161
 162 Informations et variables disponibles à la fin de l'algorithme
 163 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 164
 165 En sortie, après exécution de l'algorithme, on dispose d'informations et de
 166 variables issues du calcul. La description des
 167 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
 168 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
 169 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
 170 l'écriture des procédures de post-processing, sont décrites dans
 171 l':ref:`subsection_r_o_v_Inventaire`.
 172
 173 Les sorties non conditionnelles de l'algorithme sont les suivantes:
 174
 175   Analysis
 176     *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
 177     en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
 178     données.
 179
 180     Exemple : ``Xa = ADD.get("Analysis")[-1]``
 181
 182 Les sorties conditionnelles de l'algorithme sont les suivantes:
 183
 184   APosterioriCovariance
 185     *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de
 186     covariances des erreurs *a posteriori* de l'état optimal.
 187
 188     Exemple : ``A = ADD.get("APosterioriCovariance")[-1]``
 189
 190   BMA
 191     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 192     l'ébauche et l'état optimal.
 193
 194     Exemple : ``bma = ADD.get("BMA")[-1]``
 195
 196   CostFunctionJ
 197     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 198     :math:`J`.
 199
 200     Exemple : ``J = ADD.get("CostFunctionJ")[:]``
 201
 202   CostFunctionJb
 203     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 204     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
 205
 206     Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
 207
 208   CostFunctionJo
 209     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 210     :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
 211
 212     Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
 213
 214   Innovation
 215     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
 216     en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
 217     d'évolution.
 218
 219     Exemple : ``d = ADD.get("Innovation")[-1]``
 220
 221   MahalanobisConsistency
 222     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 223     qualité de Mahalanobis.
 224
 225     Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
 226
 227   OMA
 228     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 229     l'observation et l'état optimal dans l'espace des observations.
 230
 231     Exemple : ``oma = ADD.get("OMA")[-1]``
 232
 233   OMB
 234     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 235     l'observation et l'état d'ébauche dans l'espace des observations.
 236
 237     Exemple : ``omb = ADD.get("OMB")[-1]``
 238
 239   SigmaBck2
 240     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 241     qualité :math:`(\sigma^b)^2` de la partie ébauche.
 242
 243     Exemple : ``sb2 = ADD.get("SigmaBck")[-1]``
 244
 245   SigmaObs2
 246     *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
 247     qualité :math:`(\sigma^o)^2` de la partie observation.
 248
 249     Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
 250
 251   SimulatedObservationAtBackground
 252     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 253     partir de l'ébauche :math:`\mathbf{x}^b`.
 254
 255     Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
 256
 257   SimulatedObservationAtOptimum
 258     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 259     partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
 260
 261     Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
 262
 263   SimulationQuantiles
 264     *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état
 265     observé qui réalise le quantile demandé, dans le même ordre que les
 266     quantiles requis par l'utilisateur.
 267
 268     Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]``
 269
 270 Voir aussi
 271 ++++++++++
 272
 273 Références vers d'autres sections :
 274   - :ref:`section_ref_algorithm_Blue`
 275   - :ref:`section_ref_algorithm_3DVAR`
 276   - :ref:`section_ref_algorithm_LinearityTest`