2 Copyright (C) 2008-2018 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
125 peuvent toujours être spécifiées, mais seuls les optimiseurs sous
126 contraintes les prennent en compte.
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", "CostFunctionJb",
174 "CostFunctionJo", "CostFunctionJAtCurrentOptimum",
175 "CostFunctionJbAtCurrentOptimum", "CostFunctionJoAtCurrentOptimum",
176 "CurrentOptimum", "CurrentState", "IndexOfOptimum", "Innovation",
177 "InnovationAtCurrentState", "MahalanobisConsistency", "OMA", "OMB",
178 "SigmaObs2", "SimulatedObservationAtBackground",
179 "SimulatedObservationAtCurrentOptimum",
180 "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum",
181 "SimulationQuantiles"].
183 Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
186 Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par
187 simulation autour de l'état optimal. L'échantillonnage utilise des tirages
188 aléatoires gaussiens multivariés, dirigés par la matrice de covariance a
189 posteriori. Cette option n'est utile que si le calcul supplémentaire
190 "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide.
192 Exemple : ``{"Quantiles":[0.1,0.9]}``
195 Cette clé permet de donner un nombre entier pour fixer la graine du
196 générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est
197 par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
198 utilise ainsi l'initialisation par défaut de l'ordinateur.
200 Exemple : ``{"SetSeed":1000}``
202 NumberOfSamplesForQuantiles
203 Cette clé indique le nombre de simulations effectuées pour estimer les
204 quantiles. Cette option n'est utile que si le calcul supplémentaire
205 "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent
206 pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%.
208 Exemple : ``{"NumberOfSamplesForQuantiles":100}``
210 SimulationForQuantiles
211 Cette clé indique le type de simulation, linéaire (avec l'opérateur
212 d'observation tangent appliqué sur des incréments de perturbations autour de
213 l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard
214 appliqué aux états perturbés), que l'on veut faire pour chaque perturbation.
215 Cela change essentiellement le temps de chaque simulation élémentaire,
216 usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est
217 utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La
218 valeur par défaut est "Linear", et les choix possibles sont "Linear" et
221 Exemple : ``{"SimulationForQuantiles":"Linear"}``
223 Informations et variables disponibles à la fin de l'algorithme
224 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
226 En sortie, après exécution de l'algorithme, on dispose d'informations et de
227 variables issues du calcul. La description des
228 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
229 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
230 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
231 l'écriture des procédures de post-processing, sont décrites dans
232 l':ref:`subsection_r_o_v_Inventaire`.
234 Les sorties non conditionnelles de l'algorithme sont les suivantes:
237 *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
238 en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
241 Exemple : ``Xa = ADD.get("Analysis")[-1]``
244 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
247 Exemple : ``J = ADD.get("CostFunctionJ")[:]``
250 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
251 :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
253 Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
256 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
257 :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
259 Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
261 Les sorties conditionnelles de l'algorithme sont les suivantes:
263 APosterioriCorrelations
264 *Liste de matrices*. Chaque élément est une matrice de corrélations des
265 erreurs *a posteriori* de l'état optimal, issue de la matrice
266 :math:`\mathbf{A}*` des covariances.
268 Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]``
270 APosterioriCovariance
271 *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de
272 covariances des erreurs *a posteriori* de l'état optimal.
274 Exemple : ``A = ADD.get("APosterioriCovariance")[-1]``
276 APosterioriStandardDeviations
277 *Liste de matrices*. Chaque élément est une matrice diagonale d'écarts-types
278 des erreurs *a posteriori* de l'état optimal, issue de la matrice
279 :math:`\mathbf{A}*` des covariances.
281 Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]``
284 *Liste de matrices*. Chaque élément est une matrice diagonale de variances
285 des erreurs *a posteriori* de l'état optimal, issue de la matrice
286 :math:`\mathbf{A}*` des covariances.
288 Exemple : ``V = ADD.get("APosterioriVariances")[-1]``
291 *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
292 l'ébauche et l'état optimal.
294 Exemple : ``bma = ADD.get("BMA")[-1]``
296 CostFunctionJAtCurrentOptimum
297 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
298 :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis
301 Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]``
303 CostFunctionJbAtCurrentOptimum
304 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
305 :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la
306 valeur correspond à l'état optimal trouvé depuis le début.
308 Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]``
310 CostFunctionJoAtCurrentOptimum
311 *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
312 :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas,
313 la valeur correspond à l'état optimal trouvé depuis le début.
315 Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]``
318 *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de
319 temps courant au cours du déroulement de l'algorithme d'optimisation. Ce
320 n'est pas nécessairement le dernier état.
322 Exemple : ``Xo = ADD.get("CurrentOptimum")[:]``
325 *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
326 au cours du déroulement de l'algorithme d'optimisation.
328 Exemple : ``Xs = ADD.get("CurrentState")[:]``
331 *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum
332 obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas
333 nécessairement le numéro de la dernière itération.
335 Exemple : ``i = ADD.get("IndexOfOptimum")[-1]``
338 *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
339 en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
342 Exemple : ``d = ADD.get("Innovation")[-1]``
344 InnovationAtCurrentState
345 *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
348 Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
350 MahalanobisConsistency
351 *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
352 qualité de Mahalanobis.
354 Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
357 *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
358 l'observation et l'état optimal dans l'espace des observations.
360 Exemple : ``oma = ADD.get("OMA")[-1]``
363 *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
364 l'observation et l'état d'ébauche dans l'espace des observations.
366 Exemple : ``omb = ADD.get("OMB")[-1]``
369 *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
370 qualité :math:`(\sigma^o)^2` de la partie observation.
372 Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
374 SimulatedObservationAtBackground
375 *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
376 partir de l'ébauche :math:`\mathbf{x}^b`.
378 Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
380 SimulatedObservationAtCurrentOptimum
381 *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
382 partir de l'état optimal au pas de temps courant au cours du déroulement de
383 l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations.
385 Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]``
387 SimulatedObservationAtCurrentState
388 *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
389 partir de l'état courant, c'est-à-dire dans l'espace des observations.
391 Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
393 SimulatedObservationAtOptimum
394 *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
395 partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
397 Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
400 *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état
401 observé qui réalise le quantile demandé, dans le même ordre que les
402 quantiles requis par l'utilisateur.
404 Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]``
409 Références vers d'autres sections :
410 - :ref:`section_ref_algorithm_Blue`
411 - :ref:`section_ref_algorithm_ExtendedBlue`
412 - :ref:`section_ref_algorithm_LinearityTest`
414 Références bibliographiques :