2 Copyright (C) 2008-2016 EDF R&D
4 This file is part of SALOME ADAO module.
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.
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.
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
20 See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
24 .. index:: single: 3DVAR
25 .. _section_ref_algorithm_3DVAR:
27 Algorithme de calcul "*3DVAR*"
28 ------------------------------
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
37 .. math:: J(\mathbf{x})=(\mathbf{x}-\mathbf{x}^b)^T.\mathbf{B}^{-1}.(\mathbf{x}-\mathbf{x}^b)+(\mathbf{y}^o-H(\mathbf{x}))^T.\mathbf{R}^{-1}.(\mathbf{y}^o-H(\mathbf{x}))
39 qui est usuellement désignée comme la fonctionnelle "*3D-VAR*" (voir par exemple
42 Commandes requises et optionnelles
43 ++++++++++++++++++++++++++++++++++
45 .. index:: single: AlgorithmParameters
46 .. index:: single: Background
47 .. index:: single: BackgroundError
48 .. index:: single: Observation
49 .. index:: single: ObservationError
50 .. index:: single: ObservationOperator
51 .. index:: single: Minimizer
52 .. index:: single: Bounds
53 .. index:: single: MaximumNumberOfSteps
54 .. index:: single: CostDecrementTolerance
55 .. index:: single: ProjectedGradientTolerance
56 .. index:: single: GradientNormTolerance
57 .. index:: single: StoreSupplementaryCalculations
58 .. index:: single: Quantiles
59 .. index:: single: SetSeed
60 .. index:: single: NumberOfSamplesForQuantiles
61 .. index:: single: SimulationForQuantiles
63 Les commandes requises générales, disponibles dans l'interface en édition, sont
67 *Commande obligatoire*. Elle définit le vecteur d'ébauche ou
68 d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est
69 définie comme un objet de type "*Vector*" ou de type "*VectorSerie*".
72 *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
73 d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie
74 comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
75 type "*DiagonalSparseMatrix*".
78 *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en
79 assimilation de données ou en optimisation, et noté précédemment
80 :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*"
81 ou de type "*VectorSerie*".
84 *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
85 d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie
86 comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
87 type "*DiagonalSparseMatrix*".
90 *Commande obligatoire*. Elle indique l'opérateur d'observation, noté
91 précédemment :math:`H`, qui transforme les paramètres d'entrée
92 :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux
93 observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de
94 type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
95 différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
96 la section :ref:`section_ref_operator_requirements`. Si un contrôle
97 :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être
98 appliqué à une paire :math:`(X,U)`.
100 Les commandes optionnelles générales, disponibles dans l'interface en édition,
101 sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les
102 paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les
103 options particulières, décrites ci-après, de l'algorithme. On se reportera à la
104 :ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette
107 Les options de l'algorithme sont les suivantes:
110 Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par
111 défaut est "LBFGSB", et les choix possibles sont "LBFGSB" (minimisation non
112 linéaire sous contraintes, voir [Byrd95]_, [Morales11]_ et [Zhu97]_), "TNC"
113 (minimisation non linéaire sous contraintes), "CG" (minimisation non
114 linéaire sans contraintes), "BFGS" (minimisation non linéaire sans
115 contraintes), "NCG" (minimisation de type gradient conjugué de Newton). Il
116 est fortement conseillé de conserver la valeur par défaut.
118 Exemple : ``{"Minimizer":"LBFGSB"}``
121 Cette clé permet de définir des bornes supérieure et inférieure pour chaque
122 variable d'état optimisée. Les bornes doivent être données par une liste de
123 liste de paires de bornes inférieure/supérieure pour chaque variable, avec
124 une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes peuvent
125 toujours être spécifiées, mais seuls les optimiseurs sous contraintes les
128 Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}``
131 Cette clé indique le nombre maximum d'itérations possibles en optimisation
132 itérative. Le défaut est 15000, qui est très similaire à une absence de
133 limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre
134 aux besoins pour des problèmes réels. Pour certains optimiseurs, le nombre
135 de pas effectif d'arrêt peut être légèrement différent de la limite à cause
136 d'exigences de contrôle interne de l'algorithme.
138 Exemple : ``{"MaximumNumberOfSteps":100}``
140 CostDecrementTolerance
141 Cette clé indique une valeur limite, conduisant à arrêter le processus
142 itératif d'optimisation lorsque la fonction coût décroît moins que cette
143 tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé
144 de l'adapter aux besoins pour des problèmes réels.
146 Exemple : ``{"CostDecrementTolerance":1.e-7}``
148 ProjectedGradientTolerance
149 Cette clé indique une valeur limite, conduisant à arrêter le processus
150 itératif d'optimisation lorsque toutes les composantes du gradient projeté
151 sont en-dessous de cette limite. C'est utilisé uniquement par les
152 optimiseurs sous contraintes. Le défaut est -1, qui désigne le défaut
153 interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé
156 Exemple : ``{"ProjectedGradientTolerance":-1}``
158 GradientNormTolerance
159 Cette clé indique une valeur limite, conduisant à arrêter le processus
160 itératif d'optimisation lorsque la norme du gradient est en dessous de cette
161 limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le
162 défaut est 1.e-5 et il n'est pas recommandé de le changer.
164 Exemple : ``{"GradientNormTolerance":1.e-5}``
166 StoreSupplementaryCalculations
167 Cette liste indique les noms des variables supplémentaires qui peuvent être
168 disponibles à la fin de l'algorithme. Cela implique potentiellement des
169 calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
170 aucune de ces variables n'étant calculée et stockée par défaut. Les noms
171 possibles sont dans la liste suivante : ["APosterioriCorrelations",
172 "APosterioriCovariance", "APosterioriStandardDeviations",
173 "APosterioriVariances", "BMA", "CostFunctionJ",
174 "CostFunctionJAtCurrentOptimum", "CurrentOptimum", "CurrentState",
175 "IndexOfOptimum", "Innovation", "InnovationAtCurrentState",
176 "MahalanobisConsistency", "OMA", "OMB", "SigmaObs2",
177 "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentOptimum",
178 "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum",
179 "SimulationQuantiles"].
181 Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
184 Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par
185 simulation autour de l'état optimal. L'échantillonnage utilise des tirages
186 aléatoires gaussiens multivariés, dirigés par la matrice de covariance a
187 posteriori. Cette option n'est utile que si le calcul supplémentaire
188 "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide.
190 Exemple : ``{"Quantiles":[0.1,0.9]}``
193 Cette clé permet de donner un nombre entier pour fixer la graine du
194 générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est
195 par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
196 utilise ainsi l'initialisation par défaut de l'ordinateur.
198 Exemple : ``{"SetSeed":1000}``
200 NumberOfSamplesForQuantiles
201 Cette clé indique le nombre de simulations effectuées pour estimer les
202 quantiles. Cette option n'est utile que si le calcul supplémentaire
203 "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent
204 pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%.
206 Exemple : ``{"NumberOfSamplesForQuantiles":100}``
208 SimulationForQuantiles
209 Cette clé indique le type de simulation, linéaire (avec l'opérateur
210 d'observation tangent appliqué sur des incréments de perturbations autour de
211 l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard
212 appliqué aux états perturbés), que l'on veut faire pour chaque perturbation.
213 Cela change essentiellement le temps de chaque simulation élémentaire,
214 usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est
215 utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La
216 valeur par défaut est "Linear", et les choix possibles sont "Linear" et
219 Exemple : ``{"SimulationForQuantiles":"Linear"}``
221 Informations et variables disponibles à la fin de l'algorithme
222 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
224 En sortie, après exécution de l'algorithme, on dispose d'informations et de
225 variables issues du calcul. La description des
226 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
227 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
228 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
229 l'écriture des procédures de post-processing, sont décrites dans
230 l':ref:`subsection_r_o_v_Inventaire`.
232 Les sorties non conditionnelles de l'algorithme sont les suivantes:
235 *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
236 en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
239 Exemple : ``Xa = ADD.get("Analysis")[-1]``
242 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
245 Exemple : ``J = ADD.get("CostFunctionJ")[:]``
248 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
249 :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
251 Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
254 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
255 :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
257 Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
259 Les sorties conditionnelles de l'algorithme sont les suivantes:
261 APosterioriCorrelations
262 *Liste de matrices*. Chaque élément est une matrice de corrélations des
263 erreurs *a posteriori* de l'état optimal, issue de la matrice
264 :math:`\mathbf{A}*` des covariances.
266 Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]``
268 APosterioriCovariance
269 *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de
270 covariances des erreurs *a posteriori* de l'état optimal.
272 Exemple : ``A = ADD.get("APosterioriCovariance")[-1]``
274 APosterioriStandardDeviations
275 *Liste de matrices*. Chaque élément est une matrice diagonale d'écarts-types
276 des erreurs *a posteriori* de l'état optimal, issue de la matrice
277 :math:`\mathbf{A}*` des covariances.
279 Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]``
282 *Liste de matrices*. Chaque élément est une matrice diagonale de variances
283 des erreurs *a posteriori* de l'état optimal, issue de la matrice
284 :math:`\mathbf{A}*` des covariances.
286 Exemple : ``V = ADD.get("APosterioriVariances")[-1]``
289 *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
290 l'ébauche et l'état optimal.
292 Exemple : ``bma = ADD.get("BMA")[-1]``
294 CostFunctionJAtCurrentOptimum
295 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
296 :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis
299 Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]``
301 CostFunctionJbAtCurrentOptimum
302 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
303 :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la
304 valeur correspond à l'état optimal trouvé depuis le début.
306 Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]``
308 CostFunctionJoAtCurrentOptimum
309 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
310 :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas,
311 la valeur correspond à l'état optimal trouvé depuis le début.
313 Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]``
316 *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de
317 temps courant au cours du déroulement de l'algorithme d'optimisation. Ce
318 n'est pas nécessairement le dernier état.
320 Exemple : ``Xo = ADD.get("CurrentOptimum")[:]``
323 *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
324 au cours du déroulement de l'algorithme d'optimisation.
326 Exemple : ``Xs = ADD.get("CurrentState")[:]``
329 *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum
330 obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas
331 nécessairement le numéro de la dernière itération.
333 Exemple : ``i = ADD.get("IndexOfOptimum")[-1]``
336 *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
337 en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
340 Exemple : ``d = ADD.get("Innovation")[-1]``
342 InnovationAtCurrentState
343 *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
346 Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
348 MahalanobisConsistency
349 *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
350 qualité de Mahalanobis.
352 Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
355 *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
356 l'observation et l'état optimal dans l'espace des observations.
358 Exemple : ``oma = ADD.get("OMA")[-1]``
361 *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
362 l'observation et l'état d'ébauche dans l'espace des observations.
364 Exemple : ``omb = ADD.get("OMB")[-1]``
367 *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
368 qualité :math:`(\sigma^o)^2` de la partie observation.
370 Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
372 SimulatedObservationAtBackground
373 *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
374 partir de l'ébauche :math:`\mathbf{x}^b`.
376 Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
378 SimulatedObservationAtCurrentOptimum
379 *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
380 partir de l'état optimal au pas de temps courant au cours du déroulement de
381 l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations.
383 Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]``
385 SimulatedObservationAtCurrentState
386 *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
387 partir de l'état courant, c'est-à-dire dans l'espace des observations.
389 Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
391 SimulatedObservationAtOptimum
392 *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
393 partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
395 Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
398 *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état
399 observé qui réalise le quantile demandé, dans le même ordre que les
400 quantiles requis par l'utilisateur.
402 Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]``
407 Références vers d'autres sections :
408 - :ref:`section_ref_algorithm_Blue`
409 - :ref:`section_ref_algorithm_ExtendedBlue`
410 - :ref:`section_ref_algorithm_LinearityTest`
412 Références bibliographiques :