Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: Minimizer
-.. index:: single: Bounds
-.. index:: single: MaximumNumberOfSteps
-.. index:: single: CostDecrementTolerance
-.. index:: single: ProjectedGradientTolerance
-.. index:: single: GradientNormTolerance
-.. index:: single: StoreSupplementaryCalculations
-.. index:: single: Quantiles
-.. index:: single: SetSeed
-.. index:: single: NumberOfSamplesForQuantiles
-.. index:: single: SimulationForQuantiles
-
Les commandes requises générales, disponibles dans l'interface en édition, sont
les suivantes:
- Background
- *Commande obligatoire*. Elle définit le vecteur d'ébauche ou
- d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est
- définie comme un objet de type "*Vector*" ou de type "*VectorSerie*".
-
- BackgroundError
- *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
- d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie
- comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
- type "*DiagonalSparseMatrix*".
-
- Observation
- *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en
- assimilation de données ou en optimisation, et noté précédemment
- :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*"
- ou de type "*VectorSerie*".
-
- ObservationError
- *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
- d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie
- comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
- type "*DiagonalSparseMatrix*".
-
- ObservationOperator
- *Commande obligatoire*. Elle indique l'opérateur d'observation, noté
- précédemment :math:`H`, qui transforme les paramètres d'entrée
- :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux
- observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de
- type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
- différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
- la section :ref:`section_ref_operator_requirements`. Si un contrôle
- :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être
- appliqué à une paire :math:`(X,U)`.
+ .. include:: snippets/Background.rst
+
+ .. include:: snippets/BackgroundError.rst
+
+ .. include:: snippets/Observation.rst
+
+ .. include:: snippets/ObservationError.rst
+
+ .. include:: snippets/ObservationOperator.rst
Les commandes optionnelles générales, disponibles dans l'interface en édition,
sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les
Les options de l'algorithme sont les suivantes:
Minimizer
+ .. index:: single: Minimizer
+
Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par
défaut est "LBFGSB", et les choix possibles sont "LBFGSB" (minimisation non
linéaire sous contraintes, voir [Byrd95]_, [Morales11]_ et [Zhu97]_), "TNC"
contraintes), "NCG" (minimisation de type gradient conjugué de Newton). Il
est fortement conseillé de conserver la valeur par défaut.
- Exemple : ``{"Minimizer":"LBFGSB"}``
-
- Bounds
- Cette clé permet de définir des bornes supérieure et inférieure pour chaque
- variable d'état optimisée. Les bornes doivent être données par une liste de
- liste de paires de bornes inférieure/supérieure pour chaque variable, avec
- une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes
- peuvent toujours être spécifiées, mais seuls les optimiseurs sous
- contraintes les prennent en compte.
-
- Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}``
-
- MaximumNumberOfSteps
- Cette clé indique le nombre maximum d'itérations possibles en optimisation
- itérative. Le défaut est 15000, qui est très similaire à une absence de
- limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre
- aux besoins pour des problèmes réels. Pour certains optimiseurs, le nombre
- de pas effectif d'arrêt peut être légèrement différent de la limite à cause
- d'exigences de contrôle interne de l'algorithme.
-
- Exemple : ``{"MaximumNumberOfSteps":100}``
-
- CostDecrementTolerance
- Cette clé indique une valeur limite, conduisant à arrêter le processus
- itératif d'optimisation lorsque la fonction coût décroît moins que cette
- tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé
- de l'adapter aux besoins pour des problèmes réels.
+ Exemple :
+ ``{"Minimizer":"LBFGSB"}``
- Exemple : ``{"CostDecrementTolerance":1.e-7}``
+ .. include:: snippets/BoundsWithNone.rst
- ProjectedGradientTolerance
- Cette clé indique une valeur limite, conduisant à arrêter le processus
- itératif d'optimisation lorsque toutes les composantes du gradient projeté
- sont en-dessous de cette limite. C'est utilisé uniquement par les
- optimiseurs sous contraintes. Le défaut est -1, qui désigne le défaut
- interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé
- de le changer.
+ .. include:: snippets/MaximumNumberOfSteps.rst
- Exemple : ``{"ProjectedGradientTolerance":-1}``
+ .. include:: snippets/CostDecrementTolerance.rst
- GradientNormTolerance
- Cette clé indique une valeur limite, conduisant à arrêter le processus
- itératif d'optimisation lorsque la norme du gradient est en dessous de cette
- limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le
- défaut est 1.e-5 et il n'est pas recommandé de le changer.
+ .. include:: snippets/ProjectedGradientTolerance.rst
- Exemple : ``{"GradientNormTolerance":1.e-5}``
+ .. include:: snippets/GradientNormTolerance.rst
StoreSupplementaryCalculations
+ .. index:: single: StoreSupplementaryCalculations
+
Cette liste indique les noms des variables supplémentaires qui peuvent être
disponibles à la fin de l'algorithme. Cela implique potentiellement des
calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
"SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum",
"SimulationQuantiles"].
- Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
-
- Quantiles
- Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par
- simulation autour de l'état optimal. L'échantillonnage utilise des tirages
- aléatoires gaussiens multivariés, dirigés par la matrice de covariance a
- posteriori. Cette option n'est utile que si le calcul supplémentaire
- "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide.
-
- Exemple : ``{"Quantiles":[0.1,0.9]}``
-
- SetSeed
- Cette clé permet de donner un nombre entier pour fixer la graine du
- générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est
- par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
- utilise ainsi l'initialisation par défaut de l'ordinateur.
-
- Exemple : ``{"SetSeed":1000}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
- NumberOfSamplesForQuantiles
- Cette clé indique le nombre de simulations effectuées pour estimer les
- quantiles. Cette option n'est utile que si le calcul supplémentaire
- "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent
- pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%.
+ .. include:: snippets/Quantiles.rst
- Exemple : ``{"NumberOfSamplesForQuantiles":100}``
+ .. include:: snippets/SetSeed.rst
- SimulationForQuantiles
- Cette clé indique le type de simulation, linéaire (avec l'opérateur
- d'observation tangent appliqué sur des incréments de perturbations autour de
- l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard
- appliqué aux états perturbés), que l'on veut faire pour chaque perturbation.
- Cela change essentiellement le temps de chaque simulation élémentaire,
- usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est
- utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La
- valeur par défaut est "Linear", et les choix possibles sont "Linear" et
- "NonLinear".
+ .. include:: snippets/NumberOfSamplesForQuantiles.rst
- Exemple : ``{"SimulationForQuantiles":"Linear"}``
+ .. include:: snippets/SimulationForQuantiles.rst
Informations et variables disponibles à la fin de l'algorithme
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Les sorties non conditionnelles de l'algorithme sont les suivantes:
- Analysis
- *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
- en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
- données.
+ .. include:: snippets/Analysis.rst
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
+ .. include:: snippets/CostFunctionJ.rst
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
+ .. include:: snippets/CostFunctionJb.rst
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
-
- CostFunctionJb
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
-
- Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
-
- CostFunctionJo
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
-
- Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
+ .. include:: snippets/CostFunctionJo.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- APosterioriCorrelations
- *Liste de matrices*. Chaque élément est une matrice de corrélations des
- erreurs *a posteriori* de l'état optimal, issue de la matrice
- :math:`\mathbf{A}*` des covariances.
-
- Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]``
-
- APosterioriCovariance
- *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de
- covariances des erreurs *a posteriori* de l'état optimal.
-
- Exemple : ``A = ADD.get("APosterioriCovariance")[-1]``
-
- APosterioriStandardDeviations
- *Liste de matrices*. Chaque élément est une matrice diagonale d'écarts-types
- des erreurs *a posteriori* de l'état optimal, issue de la matrice
- :math:`\mathbf{A}*` des covariances.
-
- Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]``
-
- APosterioriVariances
- *Liste de matrices*. Chaque élément est une matrice diagonale de variances
- des erreurs *a posteriori* de l'état optimal, issue de la matrice
- :math:`\mathbf{A}*` des covariances.
-
- Exemple : ``V = ADD.get("APosterioriVariances")[-1]``
-
- BMA
- *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
- l'ébauche et l'état optimal.
-
- Exemple : ``bma = ADD.get("BMA")[-1]``
-
- CostFunctionJAtCurrentOptimum
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis
- le début.
-
- Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]``
-
- CostFunctionJbAtCurrentOptimum
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la
- valeur correspond à l'état optimal trouvé depuis le début.
-
- Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]``
-
- CostFunctionJoAtCurrentOptimum
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas,
- la valeur correspond à l'état optimal trouvé depuis le début.
-
- Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]``
-
- CurrentOptimum
- *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de
- temps courant au cours du déroulement de l'algorithme d'optimisation. Ce
- n'est pas nécessairement le dernier état.
-
- Exemple : ``Xo = ADD.get("CurrentOptimum")[:]``
-
- CurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
- au cours du déroulement de l'algorithme d'optimisation.
-
- Exemple : ``Xs = ADD.get("CurrentState")[:]``
-
- IndexOfOptimum
- *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum
- obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas
- nécessairement le numéro de la dernière itération.
-
- Exemple : ``i = ADD.get("IndexOfOptimum")[-1]``
-
- Innovation
- *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
- en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
- d'évolution.
+ .. include:: snippets/APosterioriCorrelations.rst
- Exemple : ``d = ADD.get("Innovation")[-1]``
+ .. include:: snippets/APosterioriCovariance.rst
- InnovationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
- courant.
+ .. include:: snippets/APosterioriStandardDeviations.rst
- Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
+ .. include:: snippets/APosterioriVariances.rst
- MahalanobisConsistency
- *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
- qualité de Mahalanobis.
+ .. include:: snippets/BMA.rst
- Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
+ .. include:: snippets/CostFunctionJAtCurrentOptimum.rst
- OMA
- *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
- l'observation et l'état optimal dans l'espace des observations.
+ .. include:: snippets/CostFunctionJbAtCurrentOptimum.rst
- Exemple : ``oma = ADD.get("OMA")[-1]``
+ .. include:: snippets/CostFunctionJoAtCurrentOptimum.rst
- OMB
- *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
- l'observation et l'état d'ébauche dans l'espace des observations.
+ .. include:: snippets/CurrentOptimum.rst
- Exemple : ``omb = ADD.get("OMB")[-1]``
+ .. include:: snippets/CurrentState.rst
- SigmaObs2
- *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
- qualité :math:`(\sigma^o)^2` de la partie observation.
+ .. include:: snippets/IndexOfOptimum.rst
- Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
+ .. include:: snippets/Innovation.rst
- SimulatedObservationAtBackground
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'ébauche :math:`\mathbf{x}^b`.
+ .. include:: snippets/InnovationAtCurrentState.rst
- Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
+ .. include:: snippets/MahalanobisConsistency.rst
- SimulatedObservationAtCurrentOptimum
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'état optimal au pas de temps courant au cours du déroulement de
- l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations.
+ .. include:: snippets/OMA.rst
- Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]``
+ .. include:: snippets/OMB.rst
- SimulatedObservationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'état courant, c'est-à-dire dans l'espace des observations.
+ .. include:: snippets/SigmaObs2.rst
- Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+ .. include:: snippets/SimulatedObservationAtBackground.rst
- SimulatedObservationAtOptimum
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
+ .. include:: snippets/SimulatedObservationAtCurrentOptimum.rst
- Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
+ .. include:: snippets/SimulatedObservationAtCurrentState.rst
- SimulationQuantiles
- *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état
- observé qui réalise le quantile demandé, dans le même ordre que les
- quantiles requis par l'utilisateur.
+ .. include:: snippets/SimulatedObservationAtOptimum.rst
- Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]``
+ .. include:: snippets/SimulationQuantiles.rst
Voir aussi
++++++++++
--- /dev/null
+.. index:: single: APosterioriCorrelations
+
+APosterioriCorrelations
+ *Liste de matrices*. Chaque élément est une matrice de corrélations des
+ erreurs *a posteriori* de l'état optimal, issue de la matrice
+ :math:`\mathbf{A}` des covariances.
+
+ Exemple :
+ ``C = ADD.get("APosterioriCorrelations")[-1]``
--- /dev/null
+.. index:: single: APosterioriCovariance
+
+APosterioriCovariance
+ *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}` de
+ covariances des erreurs *a posteriori* de l'état optimal.
+
+ Exemple :
+ ``A = ADD.get("APosterioriCovariance")[-1]``
--- /dev/null
+.. index:: single: APosterioriStandardDeviations
+
+APosterioriStandardDeviations
+ *Liste de matrices*. Chaque élément est une matrice diagonale d'écarts-types
+ des erreurs *a posteriori* de l'état optimal, issue de la matrice
+ :math:`\mathbf{A}` des covariances.
+
+ Exemple :
+ ``S = ADD.get("APosterioriStandardDeviations")[-1]``
--- /dev/null
+.. index:: single: APosterioriVariances
+
+APosterioriVariances
+ *Liste de matrices*. Chaque élément est une matrice diagonale de variances
+ des erreurs *a posteriori* de l'état optimal, issue de la matrice
+ :math:`\mathbf{A}` des covariances.
+
+ Exemple :
+ ``V = ADD.get("APosterioriVariances")[-1]``
--- /dev/null
+.. index:: single: AmplitudeOfInitialDirection
+
+AmplitudeOfInitialDirection
+ Cette clé indique la mise à l'échelle de la perturbation initiale construite
+ comme un vecteur utilisé pour la dérivée directionnelle autour du point
+ nominal de vérification. La valeur par défaut est de 1, ce qui signifie qu'il
+ n'y a aucune mise à l'échelle.
+
+ Exemple :
+ ``{"AmplitudeOfInitialDirection":0.5}``
--- /dev/null
+.. index:: single: Analysis
+
+Analysis
+ *Liste de vecteurs*. Chaque élément de cette variable est un état optimal
+ :math:`\mathbf{x}^*` en optimisation ou une analyse :math:`\mathbf{x}^a` en
+ assimilation de données.
+
+ Exemple :
+ ``Xa = ADD.get("Analysis")[-1]``
--- /dev/null
+.. index:: single: BMA
+
+BMA
+ *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
+ l'ébauche et l'état optimal.
+
+ Exemple :
+ ``bma = ADD.get("BMA")[-1]``
--- /dev/null
+.. index:: single: Background
+
+Background
+ *Vecteur*. La variable désigne le vecteur d'ébauche ou d'initialisation,
+ usuellement noté :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet
+ de type "*Vector*" ou de type "*VectorSerie*". Sa disponibilité en sortie est
+ conditionnée par le booléen "*Stored*" associé en entrée.
--- /dev/null
+.. index:: single: BackgroundError
+
+BackgroundError
+ *Matrice*. La variable désigne la matrice de covariance des erreurs
+ d'ébauche, usuellement notée :math:`\mathbf{B}`. Sa valeur est définie comme
+ un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de type
+ "*DiagonalSparseMatrix*", comme décrit en détail dans la section
+ :ref:`section_ref_covariance_requirements`. Sa disponibilité en sortie est
+ conditionnée par le booléen "*Stored*" associé en entrée.
--- /dev/null
+.. index:: single: Bounds
+
+Bounds
+ Cette clé permet de définir des bornes supérieure et inférieure pour chaque
+ variable d'état optimisée. Les bornes doivent être données par une liste de
+ liste de paires de bornes inférieure/supérieure pour chaque variable, avec
+ une valeur extrême chaque fois qu'il n'y a pas de borne (``None`` n'est pas
+ une valeur autorisée lorsqu'il n'y a pas de borne).
+
+ Exemple :
+ ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,1.e99],[-1.e99,1.e99]]}``
--- /dev/null
+.. index:: single: Bounds
+
+Bounds
+ Cette clé permet de définir des bornes supérieure et inférieure pour chaque
+ variable d'état optimisée. Les bornes doivent être données par une liste de
+ liste de paires de bornes inférieure/supérieure pour chaque variable, avec
+ une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes
+ peuvent toujours être spécifiées, mais seuls les optimiseurs sous
+ contraintes les prennent en compte.
+
+ Exemple :
+ ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}``
--- /dev/null
+.. index:: single: CheckingPoint
+
+CheckingPoint
+ *Vecteur*. La variable désigne le vecteur utilisé comme l'état autour duquel
+ réaliser le test requis, noté :math:`\mathbf{x}`, similaire à l'ébauche
+ :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type
+ "*Vector*". Sa disponibilité en sortie est conditionnée par le booléen
+ "*Stored*" associé en entrée.
--- /dev/null
+.. index:: single: ConstrainedBy
+
+ConstrainedBy
+ Cette clé permet d'indiquer la méthode de prise en compte des contraintes de
+ bornes. La seule disponible est "EstimateProjection", qui projete
+ l'estimation de l'état courant sur les contraintes de bornes.
+
+ Exemple :
+ ``{"ConstrainedBy":"EstimateProjection"}``
--- /dev/null
+.. index:: single: CostDecrementTolerance
+
+CostDecrementTolerance
+ Cette clé indique une valeur limite, conduisant à arrêter le processus
+ itératif d'optimisation lorsque la fonction coût décroît moins que cette
+ tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé
+ de l'adapter aux besoins pour des problèmes réels.
+
+ Exemple :
+ ``{"CostDecrementTolerance":1.e-7}``
--- /dev/null
+.. index:: single: CostDecrementTolerance
+
+CostDecrementTolerance
+ Cette clé indique une valeur limite, conduisant à arrêter le processus
+ itératif d'optimisation lorsque la fonction coût décroît moins que cette
+ tolérance au dernier pas. Le défaut est de 1.e-6, et il est recommandé de
+ l'adapter aux besoins pour des problèmes réels.
+
+ Exemple :
+ ``{"CostDecrementTolerance":1.e-6}``
--- /dev/null
+.. index:: single: CostFunctionJ
+
+CostFunctionJ
+ *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
+ :math:`J` choisie.
+
+ Exemple :
+ ``J = ADD.get("CostFunctionJ")[:]``
--- /dev/null
+.. index:: single: CostFunctionJAtCurrentOptimum
+
+CostFunctionJAtCurrentOptimum
+ *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
+ :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis
+ le début.
+
+ Exemple :
+ ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]``
--- /dev/null
+.. index:: single: CostFunctionJb
+
+CostFunctionJb
+ *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
+ :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. Si cette partie
+ n'existe pas dans la fonctionnelle, sa valeur est nulle.
+
+ Exemple :
+ ``Jb = ADD.get("CostFunctionJb")[:]``
--- /dev/null
+.. index:: single: CostFunctionJbAtCurrentOptimum
+
+CostFunctionJbAtCurrentOptimum
+ *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
+ :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la
+ valeur correspond à l'état optimal trouvé depuis le début. Si cette partie
+ n'existe pas dans la fonctionnelle, sa valeur est nulle.
+
+ Exemple :
+ ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]``
--- /dev/null
+.. index:: single: CostFunctionJo
+
+CostFunctionJo
+ *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
+ :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
+
+ Exemple :
+ ``Jo = ADD.get("CostFunctionJo")[:]``
--- /dev/null
+.. index:: single: CostFunctionJoAtCurrentOptimum
+
+CostFunctionJoAtCurrentOptimum
+ *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
+ :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas,
+ la valeur correspond à l'état optimal trouvé depuis le début.
+
+ Exemple :
+ ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]``
--- /dev/null
+.. index:: single: CurrentOptimum
+
+CurrentOptimum
+ *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de
+ temps courant au cours du déroulement de l'algorithme d'optimisation. Ce
+ n'est pas nécessairement le dernier état.
+
+ Exemple :
+ ``Xo = ADD.get("CurrentOptimum")[:]``
--- /dev/null
+.. index:: single: CurrentState
+
+CurrentState
+ *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
+ au cours du déroulement itératif de l'algorithme utilisé.
+
+ Exemple :
+ ``Xs = ADD.get("CurrentState")[:]``
--- /dev/null
+.. index:: single: EpsilonMinimumExponent
+
+EpsilonMinimumExponent
+ Cette clé indique la valeur de l'exposant minimal du coefficient en
+ puissance de 10 qui doit être utilisé pour faire décroître le multiplicateur
+ de l'incrément. La valeur par défaut est de -8, et elle doit être entre 0 et
+ -20. Par exemple, la valeur par défaut conduit à calculer le résidu de la
+ formule avec un incrément fixe multiplié par 1.e0 jusqu'à 1.e-8.
+
+ Exemple :
+ ``{"EpsilonMinimumExponent":-12}``
--- /dev/null
+.. index:: single: EstimationOf
+
+EstimationOf
+ Cette clé permet de choisir le type d'estimation à réaliser. Cela peut être
+ soit une estimation de l'état, avec la valeur "State", ou une estimation de
+ paramètres, avec la valeur "Parameters". Le choix par défaut est "State".
+
+ Exemple :
+ ``{"EstimationOf":"Parameters"}``
--- /dev/null
+.. index:: single: EvolutionError
+
+EvolutionError
+ *Matrice*. La variable désigne la matrice de covariance des erreurs *a
+ priori* d'évolution, usuellement notée :math:`\mathbf{Q}`. Sa valeur est
+ définie comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou
+ de type "*DiagonalSparseMatrix*", comme décrit en détail dans la section
+ :ref:`section_ref_covariance_requirements`. Sa disponibilité en sortie est
+ conditionnée par le booléen "*Stored*" associé en entrée.
--- /dev/null
+.. index:: single: EvolutionModel
+
+EvolutionModel
+ *Opérateur*. La variable désigne l'opérateur d'évolution du modèle,
+ usuellement noté :math:`M`, qui décrit un pas élémentaire d'évolution
+ dynamique ou itérative. Sa valeur est définie comme un objet de type
+ "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
+ différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
+ la section :ref:`section_ref_operator_requirements`. Si un contrôle :math:`U`
+ est inclus dans le modèle d'observation, l'opérateur doit être appliqué à une
+ paire :math:`(X,U)`.
--- /dev/null
+.. index:: single: GradientNormTolerance
+
+GradientNormTolerance
+ Cette clé indique une valeur limite, conduisant à arrêter le processus
+ itératif d'optimisation lorsque la norme du gradient est en dessous de cette
+ limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le
+ défaut est 1.e-5 et il n'est pas recommandé de le changer.
+
+ Exemple :
+ ``{"GradientNormTolerance":1.e-5}``
--- /dev/null
+.. index:: single: IndexOfOptimum
+
+IndexOfOptimum
+ *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum
+ obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas
+ nécessairement le numéro de la dernière itération.
+
+ Exemple :
+ ``i = ADD.get("IndexOfOptimum")[-1]``
--- /dev/null
+.. index:: single: InitialDirection
+
+InitialDirection
+ Cette clé indique la direction vectorielle utilisée pour la dérivée
+ directionnelle autour du point nominal de vérification. Cela doit être un
+ vecteur. Si elle n'est pas spécifiée, la direction par défaut est une
+ perturbation par défaut autour de zéro de la même taille vectorielle que le
+ point de vérification.
+
+ Exemple :
+ ``{"InitialDirection":[0.1,0.1,100.,3}``
--- /dev/null
+.. index:: single: Innovation
+
+Innovation
+ *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
+ en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
+ d'évolution.
+
+ Exemple :
+ ``d = ADD.get("Innovation")[-1]``
--- /dev/null
+.. index:: single: InnovationAtCurrentState
+
+InnovationAtCurrentState
+ *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
+ courant.
+
+ Exemple :
+ ``ds = ADD.get("InnovationAtCurrentState")[-1]``
--- /dev/null
+.. index:: single: MahalanobisConsistency
+
+MahalanobisConsistency
+ *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
+ qualité de Mahalanobis.
+
+ Exemple :
+ ``m = ADD.get("MahalanobisConsistency")[-1]``
--- /dev/null
+.. index:: single: MaximumNumberOfFunctionEvaluations
+
+MaximumNumberOfFunctionEvaluations
+ Cette clé indique le nombre maximum d'évaluations possibles de la
+ fonctionnelle à optimiser. Le défaut est de 15000, qui est une limite
+ arbitraire. Il est ainsi recommandé d'adapter ce paramètre aux besoins pour
+ des problèmes réels. Pour certains optimiseurs, le nombre effectif
+ d'évaluations à l'arrêt peut être légèrement différent de la limite à cause
+ d'exigences de déroulement interne de l'algorithme.
+
+ Exemple :
+ ``{"MaximumNumberOfFunctionEvaluations":50}``
--- /dev/null
+.. index:: single: MaximumNumberOfSteps
+
+MaximumNumberOfSteps
+ Cette clé indique le nombre maximum d'itérations possibles en optimisation
+ itérative. Le défaut est 15000, qui est très similaire à une absence de
+ limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre
+ aux besoins pour des problèmes réels. Pour certains optimiseurs, le nombre
+ de pas effectif d'arrêt peut être légèrement différent de la limite à cause
+ d'exigences de contrôle interne de l'algorithme.
+
+ Exemple :
+ ``{"MaximumNumberOfSteps":100}``
--- /dev/null
+.. index:: single: MaximumNumberOfSteps
+
+MaximumNumberOfSteps
+ Cette clé indique le nombre maximum d'itérations possibles en optimisation
+ itérative. Le défaut est 50, qui est une limite arbitraire. Il est ainsi
+ recommandé d'adapter ce paramètre aux besoins pour des problèmes réels.
+
+ Exemple :
+ ``{"MaximumNumberOfSteps":50}``
--- /dev/null
+.. index:: single: Minimizer
+
+Minimizer
+ Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par
+ défaut est "BOBYQA", et les choix possibles sont
+ "BOBYQA" (minimisation avec ou sans contraintes par approximation quadratique [Powell09]_),
+ "COBYLA" (minimisation avec ou sans contraintes par approximation linéaire [Powell94]_ [Powell98]_).
+ "NEWUOA" (minimisation avec ou sans contraintes par approximation quadratique itérative [Powell04]_),
+ "POWELL" (minimisation sans contraintes de type directions conjuguées [Powell64]_),
+ "SIMPLEX" (minimisation avec ou sans contraintes de type simplexe ou Nelder-Mead, voir [Nelder65]_),
+ "SUBPLEX" (minimisation avec ou sans contraintes de type simplexe sur une suite de sous-espaces [Rowan90]_).
+ Remarque : la méthode "POWELL" effectue une optimisation par boucles
+ imbriquées interne/externe, conduisant ainsi à un contrôle relaché du
+ nombre d'évaluations de la fonctionnelle à optimiser. Si un contrôle précis
+ du nombre d'évaluations de cette fonctionnelle est requis, il faut choisir
+ un autre minimiseur.
+
+ Exemple :
+ ``{"Minimizer":"BOBYQA"}``
--- /dev/null
+.. index:: single: NumberOfMembers
+
+NumberOfMembers
+ Cette clé indique le nombre de membres utilisés pour réaliser la méthode
+ d'ensemble. Le défaut est de 100, et il est recommandé de l'adapter aux
+ besoins pour des problèmes réels.
+
+ Exemple :
+ ``{"NumberOfMembers":100}``
--- /dev/null
+.. index:: single: NumberOfPrintedDigits
+
+NumberOfPrintedDigits
+ Cette clé indique le nombre de décimales de précision pour les affichages de
+ valeurs réelles. La valeur par défaut est 5, avec un minimum de 0.
+
+ Exemple :
+ ``{"NumberOfPrintedDigits":5}``
--- /dev/null
+.. index:: single: NumberOfRepetition
+
+NumberOfRepetition
+ Cette clé indique le nombre de fois où répéter l'évaluation de la fonction.
+ La valeur par défaut est 1.
+
+ Exemple :
+ ``{"NumberOfRepetition":3}``
--- /dev/null
+.. index:: single: NumberOfSamplesForQuantiles
+
+NumberOfSamplesForQuantiles
+ Cette clé indique le nombre de simulations effectuées pour estimer les
+ quantiles. Cette option n'est utile que si le calcul supplémentaire
+ "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent
+ pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%.
+
+ Exemple :
+ ``{"NumberOfSamplesForQuantiles":100}``
--- /dev/null
+.. index:: single: OMA
+
+OMA
+ *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
+ l'observation et l'état optimal dans l'espace des observations.
+
+ Exemple :
+ ``oma = ADD.get("OMA")[-1]``
--- /dev/null
+.. index:: single: OMB
+
+OMB
+ *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
+ l'observation et l'état d'ébauche dans l'espace des observations.
+
+ Exemple :
+ ``omb = ADD.get("OMB")[-1]``
--- /dev/null
+.. index:: single: Observation
+
+Observation
+ *Vecteur*. La variable désigne le vecteur d'observation utilisé en
+ assimilation de données ou en optimisation, et usuellement noté
+ :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*"
+ ou de type "*VectorSerie*". Sa disponibilité en sortie est conditionnée par
+ le booléen "*Stored*" associé en entrée.
--- /dev/null
+.. index:: single: ObservationError
+
+ObservationError
+ *Matrice*. La variable désigne la matrice de covariance des erreurs *a
+ priori* d'ébauche, usuellement notée :math:`\mathbf{R}`. Cette matrice est
+ définie comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou
+ de type "*DiagonalSparseMatrix*", comme décrit en détail dans la section
+ :ref:`section_ref_covariance_requirements`. Sa disponibilité en sortie est
+ conditionnée par le booléen "*Stored*" associé en entrée.
--- /dev/null
+.. index:: single: ObservationOperator
+
+ObservationOperator
+ *Opérateur*. La variable désigne l'opérateur d'observation, usuellement noté
+ :math:`H`, qui transforme les paramètres d'entrée :math:`\mathbf{x}` en
+ résultats :math:`\mathbf{y}` qui sont à comparer aux observations
+ :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type
+ "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
+ différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
+ la section :ref:`section_ref_operator_requirements`. Si un contrôle :math:`U`
+ est inclus dans le modèle d'observation, l'opérateur doit être appliqué à une
+ paire :math:`(X,U)`.
--- /dev/null
+.. index:: single: Observers
+
+Observers
+ *Liste de fonctions liées à des variables*. La variable permet de définir des
+ observateurs internes, qui sont des fonctions liées à une variable
+ particulière d'algorithme, qui sont exécutées chaque fois que cette variable
+ est modifiée. C'est une manière pratique de suivre des variables d'intérêt
+ durant le processus d'assimilation de données ou d'optimisation, en
+ l'affichant ou en la traçant, etc. Des exemples courants (squelettes) sont
+ fournis pour aider l'utilisateur ou pour faciliter l'élaboration d'un cas.
--- /dev/null
+.. index:: single: ProjectedGradientTolerance
+
+ProjectedGradientTolerance
+ Cette clé indique une valeur limite, conduisant à arrêter le processus
+ itératif d'optimisation lorsque toutes les composantes du gradient projeté
+ sont en-dessous de cette limite. C'est utilisé uniquement par les
+ optimiseurs sous contraintes. Le défaut est -1, qui désigne le défaut
+ interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé
+ de le changer.
+
+ Exemple :
+ ``{"ProjectedGradientTolerance":-1}``
--- /dev/null
+.. index:: single: QualityCriterion
+
+QualityCriterion
+ Cette clé indique le critère de qualité, qui est minimisé pour trouver
+ l'estimation optimale de l'état. Le défaut est le critère usuel de
+ l'assimilation de données nommé "DA", qui est le critère de moindres carrés
+ pondérés augmentés. Les critères possibles sont dans la liste suivante, dans
+ laquelle les noms équivalents sont indiqués par un signe "<=>" :
+ ["AugmentedWeightedLeastSquares"<=>"AWLS"<=>"DA", "WeightedLeastSquares"<=>"WLS",
+ "LeastSquares"<=>"LS"<=>"L2", "AbsoluteValue"<=>"L1", "MaximumError"<=>"ME"].
+
+ Exemple :
+ ``{"QualityCriterion":"DA"}``
--- /dev/null
+.. index:: single: Quantile
+
+Quantile
+ Cette clé permet de définir la valeur réelle du quantile recherché, entre 0
+ et 1. La valeur par défaut est 0.5, correspondant à la médiane.
+
+ Exemple :
+ ``{"Quantile":0.5}``
--- /dev/null
+.. index:: single: Quantiles
+
+Quantiles
+ Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par
+ simulation autour de l'état optimal. L'échantillonnage utilise des tirages
+ aléatoires gaussiens multivariés, dirigés par la matrice de covariance a
+ posteriori. Cette option n'est utile que si le calcul supplémentaire
+ "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide.
+
+ Exemple :
+ ``{"Quantiles":[0.1,0.9]}``
--- /dev/null
+.. index:: single: Residu
+
+Residu
+ *Liste de valeurs*. Chaque élément est la valeur du résidu particulier
+ vérifié lors d'un algorithme de vérification, selon l'ordre des tests
+ effectués.
+
+ Exemple :
+ ``r = ADD.get("Residu")[:]``
--- /dev/null
+.. index:: single: SetDebug
+
+SetDebug
+ Cette clé requiert l'activation, ou pas, du mode de débogage durant
+ l'évaluation de la fonction ou de l'opérateur. La valeur par défaut est
+ "True", les choix sont "True" ou "False".
+
+ Exemple :
+ ``{"SetDebug":False}``
--- /dev/null
+.. index:: single: SetSeed
+
+SetSeed
+ Cette clé permet de donner un nombre entier pour fixer la graine du
+ générateur aléatoire utilisé dans l'algorithme. Une valeur simple est par
+ exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
+ utilise ainsi l'initialisation par défaut de l'ordinateur, qui varie donc à
+ chaque étude. Pour assurer la reproductibilité de résultats impliquant des
+ tirages aléatoires, il est fortement conseiller d'initialiser la graine.
+
+ Exemple :
+ ``{"SetSeed":1000}``
--- /dev/null
+.. index:: single: SigmaBck2
+
+SigmaBck2
+ *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
+ qualité :math:`(\sigma^b)^2` de la partie ébauche.
+
+ Exemple :
+ ``sb2 = ADD.get("SigmaBck")[-1]``
--- /dev/null
+.. index:: single: SigmaObs2
+
+SigmaObs2
+ *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
+ qualité :math:`(\sigma^o)^2` de la partie observation.
+
+ Exemple :
+ ``so2 = ADD.get("SigmaObs")[-1]``
--- /dev/null
+.. index:: single: SimulatedObservationAtBackground
+.. index:: single: Dry
+
+SimulatedObservationAtBackground
+ *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé par
+ l'opérateur d'observation à partir de l'ébauche :math:`\mathbf{x}^b`. C'est
+ la prévision à partir de l'ébauche, elle est parfois appellée "*Dry*".
+
+ Exemple :
+ ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
--- /dev/null
+.. index:: single: SimulatedObservationAtCurrentOptimum
+
+SimulatedObservationAtCurrentOptimum
+ *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé par
+ l'opérateur d'observation à partir de l'état optimal au pas de temps courant
+ au cours du déroulement de l'algorithme d'optimisation, c'est-à-dire dans
+ l'espace des observations.
+
+ Exemple :
+ ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]``
--- /dev/null
+.. index:: single: SimulatedObservationAtCurrentState
+
+SimulatedObservationAtCurrentState
+ *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé par
+ l'opérateur d'observation à partir de l'état courant, c'est-à-dire dans
+ l'espace des observations.
+
+ Exemple :
+ ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
--- /dev/null
+.. index:: single: SimulatedObservationAtOptimum
+.. index:: single: Forecast
+
+SimulatedObservationAtOptimum
+ *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé par
+ l'opérateur d'observation à partir de l'analyse ou de l'état optimal
+ :math:`\mathbf{x}^a`. C'est la prévision à partir de l'analyse ou de l'état
+ optimal, et elle est parfois appellée "*Forecast*".
+
+ Exemple :
+ ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
--- /dev/null
+.. index:: single: SimulationForQuantiles
+
+SimulationForQuantiles
+ Cette clé indique le type de simulation, linéaire (avec l'opérateur
+ d'observation tangent appliqué sur des incréments de perturbations autour de
+ l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard
+ appliqué aux états perturbés), que l'on veut faire pour chaque perturbation.
+ Cela change essentiellement le temps de chaque simulation élémentaire,
+ usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est
+ utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La
+ valeur par défaut est "Linear", et les choix possibles sont "Linear" et
+ "NonLinear".
+
+ Exemple :
+ ``{"SimulationForQuantiles":"Linear"}``
--- /dev/null
+.. index:: single: SimulationQuantiles
+
+SimulationQuantiles
+ *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état
+ observé qui réalise le quantile demandé, dans le même ordre que les valeurs
+ de quantiles requis par l'utilisateur.
+
+ Exemple :
+ ``sQuantiles = ADD.get("SimulationQuantiles")[:]``
--- /dev/null
+.. index:: single: StateVariationTolerance
+
+StateVariationTolerance
+ Cette clé indique la variation relative maximale de l'état lors pour l'arrêt
+ par convergence sur l'état. Le défaut est de 1.e-4, et il est recommandé
+ de l'adapter aux besoins pour des problèmes réels.
+
+ Exemple :
+ ``{"StateVariationTolerance":1.e-4}``
