Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: Bounds
-.. index:: single: ConstrainedBy
-.. index:: single: EstimationOf
-.. index:: single: MaximumNumberOfSteps
-.. index:: single: CostDecrementTolerance
-.. index:: single: ProjectedGradientTolerance
-.. index:: single: GradientNormTolerance
-.. index:: single: StoreSupplementaryCalculations
-
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/EvolutionError.rst
+
+ .. include:: snippets/EvolutionModel.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]]}``
-
- 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"}``
-
- 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}``
+ Exemple :
+ ``{"Minimizer":"LBFGSB"}``
- 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.
+ .. include:: snippets/BoundsWithNone.rst
- Exemple : ``{"CostDecrementTolerance":1.e-7}``
+ .. include:: snippets/ConstrainedBy.rst
- 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".
+ .. include:: snippets/MaximumNumberOfSteps.rst
- Exemple : ``{"EstimationOf":"Parameters"}``
+ .. include:: snippets/CostDecrementTolerance.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/EstimationOf.rst
- Exemple : ``{"ProjectedGradientTolerance":-1}``
+ .. include:: snippets/ProjectedGradientTolerance.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.
-
- 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,
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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
+ .. include:: snippets/Analysis.rst
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
+ .. include:: snippets/CostFunctionJ.rst
- 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.
+ .. include:: snippets/CostFunctionJb.rst
- 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:
- 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")[:]``
+ .. include:: snippets/BMA.rst
- 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.
+ .. include:: snippets/CostFunctionJAtCurrentOptimum.rst
- Exemple : ``Xo = ADD.get("CurrentOptimum")[:]``
+ .. include:: snippets/CostFunctionJbAtCurrentOptimum.rst
- CurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
- au cours du déroulement de l'algorithme d'optimisation.
+ .. include:: snippets/CostFunctionJoAtCurrentOptimum.rst
- Exemple : ``Xs = ADD.get("CurrentState")[:]``
+ .. include:: snippets/CurrentOptimum.rst
- 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.
+ .. include:: snippets/CurrentState.rst
- Exemple : ``i = ADD.get("IndexOfOptimum")[-1]``
+ .. include:: snippets/IndexOfOptimum.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: CheckingPoint
-.. index:: single: ObservationOperator
-.. index:: single: AmplitudeOfInitialDirection
-.. index:: single: EpsilonMinimumExponent
-.. index:: single: InitialDirection
-.. index:: single: SetSeed
-.. index:: single: StoreSupplementaryCalculations
-
Les commandes requises générales, disponibles dans l'interface en édition, sont
les suivantes:
- CheckingPoint
- *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour
- duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à
- l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type
- "*Vector*".
-
- ObservationOperator
- *Commande obligatoire*. Elle indique l'opérateur d'observation, notée
- 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*". 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/CheckingPoint.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_checking_keywords`. De plus, les
Les options de l'algorithme sont les suivantes:
- 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 pas
- de mise à l'échelle.
-
- Exemple : ``{"AmplitudeOfInitialDirection":0.5}``
-
- 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}``
+ .. include:: snippets/AmplitudeOfInitialDirection.rst
- 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.
+ .. include:: snippets/EpsilonMinimumExponent.rst
- Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}``
+ .. include:: snippets/InitialDirection.rst
- 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}``
+ .. include:: snippets/SetSeed.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,
possibles sont dans la liste suivante : ["CurrentState", "Residu",
"SimulatedObservationAtCurrentState"].
- Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["CurrentState"]}``
Informations et variables disponibles à la fin de l'algorithme
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Les sorties non conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
+ .. include:: snippets/Residu.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
-
- 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/CurrentState.rst
- Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+ .. include:: snippets/SimulatedObservationAtCurrentState.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. 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:
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,
"SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState",
"SimulatedObservationAtOptimum"].
- 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 :
+ ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
- Exemple : ``{"Quantiles":[0.1,0.9]}``
+ .. include:: snippets/Quantiles.rst
- 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.
+ .. include:: snippets/SetSeed.rst
- Exemple : ``{"SetSeed":1000}``
+ .. include:: snippets/NumberOfSamplesForQuantiles.rst
- 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}``
-
- 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"}``
+ .. 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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
+ .. include:: snippets/Analysis.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- APosterioriCorrelations
- *Liste de matrices*. Chaque élément est une matrice de corrélation des
- erreurs *a posteriori* de l'état optimal.
-
- 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 d'écart-types des
- erreurs *a posteriori* de l'état optimal.
-
- Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]``
-
- APosterioriVariances
- *Liste de matrices*. Chaque élément est une matrice de variances des erreurs
- *a posteriori* de l'état optimal.
-
- 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]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
-
- 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")[:]``
-
- 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]``
+ .. include:: snippets/APosterioriCorrelations.rst
- MahalanobisConsistency
- *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
- qualité de Mahalanobis.
+ .. include:: snippets/APosterioriCovariance.rst
- Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
+ .. include:: snippets/APosterioriStandardDeviations.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/APosterioriVariances.rst
- Exemple : ``oma = ADD.get("OMA")[-1]``
+ .. include:: snippets/BMA.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/CostFunctionJ.rst
- Exemple : ``omb = ADD.get("OMB")[-1]``
+ .. include:: snippets/CostFunctionJb.rst
- SigmaBck2
- *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
- qualité :math:`(\sigma^b)^2` de la partie ébauche.
+ .. include:: snippets/CostFunctionJo.rst
- Exemple : ``sb2 = ADD.get("SigmaBck")[-1]``
+ .. include:: snippets/Innovation.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/MahalanobisConsistency.rst
- Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
+ .. include:: snippets/OMA.rst
- SimulatedObservationAtBackground
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'ébauche :math:`\mathbf{x}^b`.
+ .. include:: snippets/OMB.rst
- Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
+ .. include:: snippets/SigmaBck2.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/SigmaObs2.rst
- Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
+ .. include:: snippets/SimulatedObservationAtBackground.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
++++++++++
.. _section_ref_algorithm_DerivativeFreeOptimization:
Algorithme de calcul "*DerivativeFreeOptimization*"
-----------------------------------------------------
+---------------------------------------------------
.. warning::
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: MaximumNumberOfSteps
-.. index:: single: MaximumNumberOfFunctionEvaluations
-.. index:: single: StateVariationTolerance
-.. index:: single: CostDecrementTolerance
-.. index:: single: QualityCriterion
-.. index:: single: StoreSupplementaryCalculations
-
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
- 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"}``
-
- 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 une limite arbitraire. Il est ainsi
- fortement 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":50}``
-
- 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}``
-
- 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}``
-
- 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}``
-
- 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"}``
+ .. include:: snippets/Minimizer_DFO.rst
+
+ .. include:: snippets/BoundsWithNone.rst
+
+ .. include:: snippets/MaximumNumberOfSteps.rst
+
+ .. include:: snippets/MaximumNumberOfFunctionEvaluations.rst
+
+ .. include:: snippets/StateVariationTolerance.rst
+
+ .. include:: snippets/CostDecrementTolerance.rst
+
+ .. include:: snippets/QualityCriterion.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,
"SimulatedObservationAtBackground", "SimulatedObservationAtCurrentOptimum",
"SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"].
- Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
-
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
+ .. include:: snippets/Analysis.rst
- 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.
+ .. include:: snippets/CostFunctionJ.rst
- Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
+ .. include:: snippets/CostFunctionJb.rst
- 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.
+ .. include:: snippets/CostFunctionJo.rst
- Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
-
- 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")[:]``
+ .. include:: snippets/CurrentState.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
-
- 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]``
-
- InnovationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
- courant.
-
- Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
-
- 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/CostFunctionJAtCurrentOptimum.rst
- Exemple : ``oma = ADD.get("OMA")[-1]``
+ .. include:: snippets/CostFunctionJbAtCurrentOptimum.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/CostFunctionJoAtCurrentOptimum.rst
- Exemple : ``omb = ADD.get("OMB")[-1]``
+ .. include:: snippets/CurrentOptimum.rst
- SimulatedObservationAtBackground
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'ébauche :math:`\mathbf{x}^b`.
+ .. include:: snippets/IndexOfOptimum.rst
- Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
+ .. include:: snippets/InnovationAtCurrentState.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 observé à l'état courant,
- c'est-à-dire dans l'espace des observations.
+ .. include:: snippets/SimulatedObservationAtBackground.rst
- Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+ .. include:: snippets/SimulatedObservationAtCurrentOptimum.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/SimulatedObservationAtCurrentState.rst
- Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
+ .. include:: snippets/SimulatedObservationAtOptimum.rst
Voir aussi
++++++++++
+++++++++++
Cet algorithme réalise une estimation de type BLUE (Best Linear Unbiased
-Estimator, qui est ici un estimateur d'Aitken) de l'état d'un système par
+Estimator, qui est ici un estimateur d'Aitken) de l'état d'un système, par
méthode d'ensemble. Pour fonctionner, il faut fournir un ensemble d'ébauches,
dont le nombre déterminera la taille de l'ensemble pour l'estimation.
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: SetSeed
-
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:
+ .. include:: snippets/SetSeed.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,
"SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState",
"SimulatedObservationAtOptimum"].
- Exemple : ``{"StoreSupplementaryCalculations":["CurrentState", "Innovation"]}``
-
- 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":["CurrentState", "Innovation"]}``
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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
-
- 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")[:]``
+ .. include:: snippets/Analysis.rst
- 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/CurrentState.rst
- Exemple : ``d = ADD.get("Innovation")[-1]``
+ .. include:: snippets/Innovation.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. 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:
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,
"SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState",
"SimulatedObservationAtOptimum"].
- Exemple : ``{"StoreSupplementaryCalculations":["CurrentState", "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 :
+ ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
- Exemple : ``{"Quantiles":[0.1,0.9]}``
+ .. include:: snippets/Quantiles.rst
- 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.
+ .. include:: snippets/SetSeed.rst
- Exemple : ``{"SetSeed":1000}``
+ .. include:: snippets/NumberOfSamplesForQuantiles.rst
- 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}``
-
- 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"}``
+ .. 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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
+ .. include:: snippets/Analysis.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- APosterioriCorrelations
- *Liste de matrices*. Chaque élément est une matrice de corrélation des
- erreurs *a posteriori* de l'état optimal.
-
- 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 d'écart-types des
- erreurs *a posteriori* de l'état optimal.
-
- Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]``
-
- APosterioriVariances
- *Liste de matrices*. Chaque élément est une matrice de variances des erreurs
- *a posteriori* de l'état optimal.
-
- 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]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
-
- 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")[:]``
-
- 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]``
+ .. include:: snippets/APosterioriCorrelations.rst
- MahalanobisConsistency
- *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
- qualité de Mahalanobis.
+ .. include:: snippets/APosterioriCovariance.rst
- Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
+ .. include:: snippets/APosterioriStandardDeviations.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/APosterioriVariances.rst
- Exemple : ``oma = ADD.get("OMA")[-1]``
+ .. include:: snippets/BMA.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/CostFunctionJ.rst
- Exemple : ``omb = ADD.get("OMB")[-1]``
+ .. include:: snippets/CostFunctionJb.rst
- SigmaBck2
- *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
- qualité :math:`(\sigma^b)^2` de la partie ébauche.
+ .. include:: snippets/CostFunctionJo.rst
- Exemple : ``sb2 = ADD.get("SigmaBck")[-1]``
+ .. include:: snippets/Innovation.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/MahalanobisConsistency.rst
- Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
+ .. include:: snippets/OMA.rst
- SimulatedObservationAtBackground
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'ébauche :math:`\mathbf{x}^b`.
+ .. include:: snippets/OMB.rst
- Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
+ .. include:: snippets/SigmaBck2.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/SigmaObs2.rst
- Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
+ .. include:: snippets/SimulatedObservationAtBackground.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
++++++++++
filtre de Kalman étendu, utilisant un calcul non linéaire de l'état et de
l'évolution incrémentale (processus).
+Dans le cas d'opérateurs réellement non-linéaires, on peut aisément utiliser
+l':ref:`section_ref_algorithm_EnsembleKalmanFilter` ou
+l':ref:`section_ref_algorithm_UnscentedKalmanFilter`, qui sont souvent
+largement plus adaptés aux comportements non-linéaires mais plus coûteux. On
+peut vérifier la linéarité des opérateurs à l'aide de
+l':ref:`section_ref_algorithm_LinearityTest`.
+
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: Bounds
-.. index:: single: ConstrainedBy
-.. index:: single: EstimationOf
-.. index:: single: StoreSupplementaryCalculations
-
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/EvolutionError.rst
+
+ .. include:: snippets/EvolutionModel.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:
- 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]]}``
+ .. include:: snippets/BoundsWithExtremes.rst
- ConstrainedBy
- Cette clé permet d'indiquer la méthode de prise en compte des contraintes de
- bornes. La seule disponible est "EstimateProjection", qui projette
- l'estimation de l'état courant sur les contraintes de bornes.
+ .. include:: snippets/ConstrainedBy.rst
- Exemple : ``{"ConstrainedBy":"EstimateProjection"}``
-
- 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"}``
+ .. include:: snippets/EstimationOf.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,
"APosterioriVariances", "BMA", "CostFunctionJ", "CostFunctionJb",
"CostFunctionJo", "CurrentState", "Innovation"].
- Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
+ .. include:: snippets/Analysis.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- APosterioriCorrelations
- *Liste de matrices*. Chaque élément est une matrice de corrélation des
- erreurs *a posteriori* de l'état optimal.
-
- 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 d'écart-types des
- erreurs *a posteriori* de l'état optimal.
-
- Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]``
-
- APosterioriVariances
- *Liste de matrices*. Chaque élément est une matrice de variances des erreurs
- *a posteriori* de l'état optimal.
-
- 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]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
+ .. include:: snippets/APosterioriCorrelations.rst
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
+ .. include:: snippets/APosterioriCovariance.rst
- 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.
+ .. include:: snippets/APosterioriStandardDeviations.rst
- Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
+ .. include:: snippets/APosterioriVariances.rst
- 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.
+ .. include:: snippets/BMA.rst
- Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
+ .. include:: snippets/CostFunctionJ.rst
- CurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
- au cours du déroulement de l'algorithme d'optimisation.
+ .. include:: snippets/CostFunctionJb.rst
- Exemple : ``Xs = ADD.get("CurrentState")[:]``
+ .. include:: snippets/CostFunctionJo.rst
- 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/CurrentState.rst
- Exemple : ``d = ADD.get("Innovation")[-1]``
+ .. include:: snippets/Innovation.rst
Voir aussi
++++++++++
Références vers d'autres sections :
- :ref:`section_ref_algorithm_KalmanFilter`
+ - :ref:`section_ref_algorithm_EnsembleKalmanFilter`
- :ref:`section_ref_algorithm_UnscentedKalmanFilter`
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: CheckingPoint
-.. index:: single: ObservationOperator
-.. index:: single: NumberOfPrintedDigits
-.. index:: single: NumberOfRepetition
-.. index:: single: SetDebug
-.. index:: single: StoreSupplementaryCalculations
-
Les commandes requises générales, disponibles dans l'interface en édition, sont
les suivantes:
- CheckingPoint
- *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour
- duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à
- l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type
- "*Vector*".
-
- ObservationOperator
- *Commande obligatoire*. Elle indique l'opérateur d'observation, notée
- 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*". 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/CheckingPoint.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_checking_keywords`. De plus, les
Les options de l'algorithme sont les suivantes:
- 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}``
-
- NumberOfRepetition
- Cette clé indique le nombre de fois où répéter l'évaluation de la fonction.
- La valeur par défaut est 1.
+ .. include:: snippets/NumberOfPrintedDigits.rst
- Exemple : ``{"NumberOfRepetition":3}``
+ .. include:: snippets/NumberOfRepetition.rst
- SetDebug
- Cette clé requiert l'activation, ou pas, du mode de débogage durant
- l'évaluation de la fonction. La valeur par défaut est "False", les choix
- sont "True" ou "False".
-
- Exemple : ``{"SetDebug":False}``
+ .. include:: snippets/SetDebug.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,
possibles sont dans la liste suivante : ["CurrentState",
"SimulatedObservationAtCurrentState"].
- Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["CurrentState"]}``
Informations et variables disponibles à la fin de l'algorithme
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Les sorties conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
-
- 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/CurrentState.rst
- Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+ .. include:: snippets/SimulatedObservationAtCurrentState.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: CheckingPoint
-.. index:: single: ObservationOperator
-.. index:: single: AmplitudeOfInitialDirection
-.. index:: single: EpsilonMinimumExponent
-.. index:: single: InitialDirection
-.. index:: single: ResiduFormula
-.. index:: single: SetSeed
-.. index:: single: StoreSupplementaryCalculations
-
Les commandes requises générales, disponibles dans l'interface en édition, sont
les suivantes:
- CheckingPoint
- *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour
- duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à
- l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type
- "*Vector*".
-
- ObservationOperator
- *Commande obligatoire*. Elle indique l'opérateur d'observation, notée
- 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*". 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/CheckingPoint.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_checking_keywords`. De plus, les
Les options de l'algorithme sont les suivantes:
- 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 pas
- de mise à l'échelle.
-
- Exemple : ``{"AmplitudeOfInitialDirection":0.5}``
+ .. include:: snippets/AmplitudeOfInitialDirection.rst
- 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.
+ .. include:: snippets/EpsilonMinimumExponent.rst
- Exemple : ``{"EpsilonMinimumExponent":-12}``
+ .. include:: snippets/InitialDirection.rst
- 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}``
+ .. include:: snippets/SetSeed.rst
ResiduFormula
+ .. index:: single: ResiduFormula
+
Cette clé indique la formule de résidu qui doit être utilisée pour le test.
Le choix par défaut est "Taylor", et les choix possibles sont "Taylor"
(résidu du développement de Taylor normalisé de l'opérateur, qui doit
développement de Taylor à l'ordre 0, qui approxime le gradient, et qui doit
rester constant).
- Exemple : ``{"ResiduFormula":"Taylor"}``
-
- 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 :
+ ``{"ResiduFormula":"Taylor"}``
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,
possibles sont dans la liste suivante : ["CurrentState", "Residu",
"SimulatedObservationAtCurrentState"].
- Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["CurrentState"]}``
Informations et variables disponibles à la fin de l'algorithme
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Les sorties non conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
+ .. include:: snippets/Residu.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
-
- 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/CurrentState.rst
- Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+ .. include:: snippets/SimulatedObservationAtCurrentState.rst
Voir aussi
++++++++++
d'observation à l'aide de l':ref:`section_ref_algorithm_LinearityTest`.
En cas de non-linéarité, même peu marquée, on lui préférera
-l':ref:`section_ref_algorithm_ExtendedKalmanFilter` ou
-l':ref:`section_ref_algorithm_UnscentedKalmanFilter`.
+l':ref:`section_ref_algorithm_ExtendedKalmanFilter`, ou
+l':ref:`section_ref_algorithm_EnsembleKalmanFilter` et
+l':ref:`section_ref_algorithm_UnscentedKalmanFilter` qui sont plus puissants.
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: EstimationOf
-.. index:: single: StoreSupplementaryCalculations
-
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/EvolutionError.rst
+
+ .. include:: snippets/EvolutionModel.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:
- 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"}``
+ .. include:: snippets/EstimationOf.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,
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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
+ .. include:: snippets/Analysis.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- APosterioriCorrelations
- *Liste de matrices*. Chaque élément est une matrice de corrélation des
- erreurs *a posteriori* de l'état optimal.
-
- 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 d'écart-types des
- erreurs *a posteriori* de l'état optimal.
-
- Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]``
-
- APosterioriVariances
- *Liste de matrices*. Chaque élément est une matrice de variances des erreurs
- *a posteriori* de l'état optimal.
-
- 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]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
+ .. include:: snippets/APosterioriCorrelations.rst
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
+ .. include:: snippets/APosterioriCovariance.rst
- 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.
+ .. include:: snippets/APosterioriStandardDeviations.rst
- Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
+ .. include:: snippets/APosterioriVariances.rst
- 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.
+ .. include:: snippets/BMA.rst
- Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
+ .. include:: snippets/CostFunctionJ.rst
- CurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
- au cours du déroulement de l'algorithme d'optimisation.
+ .. include:: snippets/CostFunctionJb.rst
- Exemple : ``Xs = ADD.get("CurrentState")[:]``
+ .. include:: snippets/CostFunctionJo.rst
- 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/CurrentState.rst
- Exemple : ``d = ADD.get("Innovation")[-1]``
+ .. include:: snippets/Innovation.rst
Voir aussi
++++++++++
Références vers d'autres sections :
- :ref:`section_ref_algorithm_ExtendedKalmanFilter`
+ - :ref:`section_ref_algorithm_EnsembleKalmanFilter`
- :ref:`section_ref_algorithm_UnscentedKalmanFilter`
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: StoreSupplementaryCalculations
-
Les commandes requises générales, disponibles dans l'interface en édition, sont
les suivantes:
- 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/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:
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,
"CostFunctionJ", "CostFunctionJb", "CostFunctionJo",
"SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"].
- Exemple : ``{"StoreSupplementaryCalculations":["OMA", "CurrentState"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["OMA", "CurrentState"]}``
*Astuce pour cet algorithme :*
- Comme les commandes *"Background"* et *"BackgroundError"* sont requises pour
- TOUS les algorithmes de calcul dans l'interface, vous devez fournir une
- valeur, malgré le fait que ces commandes ne sont pas requises pour
- cet algorithme, et ne seront pas utilisées. La manière la plus simple est
- de donner "1" comme un STRING pour les deux.
+ Comme les commandes *"Background"* et *"BackgroundError"* sont requises
+ pour TOUS les algorithmes de calcul dans l'interface graphique, vous devez
+ fournir une valeur, malgré le fait que ces commandes ne sont pas requises
+ pour cet algorithme, et ne seront pas utilisées. La manière la plus simple
+ est de donner "1" comme un STRING pour les deux.
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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
+ .. include:: snippets/Analysis.rst
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
+ .. include:: snippets/CostFunctionJ.rst
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
+ .. include:: snippets/CostFunctionJb.rst
- 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:
- 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]``
-
- 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/OMA.rst
- Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
+ .. include:: snippets/SimulatedObservationAtOptimum.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: CheckingPoint
-.. index:: single: ObservationOperator
-.. index:: single: AmplitudeOfInitialDirection
-.. index:: single: EpsilonMinimumExponent
-.. index:: single: InitialDirection
-.. index:: single: ResiduFormula
-.. index:: single: SetSeed
-.. index:: single: StoreSupplementaryCalculations
-
Les commandes requises générales, disponibles dans l'interface en édition, sont
les suivantes:
- CheckingPoint
- *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour
- duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à
- l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type
- "*Vector*".
-
- ObservationOperator
- *Commande obligatoire*. Elle indique l'opérateur d'observation, notée
- 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*". 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/CheckingPoint.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_checking_keywords`. De plus, les
Les options de l'algorithme sont les suivantes:
- 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 pas
- de mise à l'échelle.
-
- Exemple : ``{"AmplitudeOfInitialDirection":0.5}``
+ .. include:: snippets/AmplitudeOfInitialDirection.rst
- 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.
+ .. include:: snippets/EpsilonMinimumExponent.rst
- Exemple : ``{"EpsilonMinimumExponent":-12}``
+ .. include:: snippets/InitialDirection.rst
- 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}``
+ .. include:: snippets/SetSeed.rst
ResiduFormula
+ .. index:: single: ResiduFormula
+
Cette clé indique la formule de résidu qui doit être utilisée pour le test.
Le choix par défaut est "CenteredDL", et les choix possibles sont
"CenteredDL" (résidu de la différence entre la fonction au point nominal et
normalisé par l'écart quadratique moyen (RMS) au point nominal, qui doit
rester proche de 0).
- Exemple : ``{"ResiduFormula":"CenteredDL"}``
-
- 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 :
+ ``{"ResiduFormula":"CenteredDL"}``
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,
possibles sont dans la liste suivante : ["CurrentState", "Residu",
"SimulatedObservationAtCurrentState"].
- Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["CurrentState"]}``
Informations et variables disponibles à la fin de l'algorithme
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Les sorties non conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
+ .. include:: snippets/Residu.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
-
- 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/CurrentState.rst
- Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+ .. include:: snippets/SimulatedObservationAtCurrentState.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. 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
-
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*".
-
- 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/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"
(minimisation non linéaire de type Levenberg-Marquard). 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 :
+ ``{"Minimizer":"LBFGSB"}``
- Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}``
+ .. include:: snippets/BoundsWithNone.rst
- 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.
+ .. include:: snippets/MaximumNumberOfSteps.rst
- Exemple : ``{"MaximumNumberOfSteps":100}``
+ .. include:: snippets/CostDecrementTolerance.rst
- 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.
+ .. include:: snippets/ProjectedGradientTolerance.rst
- Exemple : ``{"CostDecrementTolerance":1.e-7}``
-
- 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}``
-
- 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}``
+ .. 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,
"SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState",
"SimulatedObservationAtOptimum", "SimulatedObservationAtCurrentOptimum"].
- Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
*Astuce pour cet algorithme :*
Comme la commande *"BackgroundError"* est requise pour TOUS les algorithmes
- de calcul dans l'interface, vous devez fournir une valeur, malgré le fait
- que cette commande n'est pas requise pour cet algorithme, et ne sera pas
- utilisée. La manière la plus simple est de donner "1" comme un STRING.
+ de calcul dans l'interface graphique, vous devez fournir une valeur, malgré
+ le fait que cette commande n'est pas requise pour cet algorithme, et ne
+ sera pas utilisée. La manière la plus simple est de donner "1" comme un
+ STRING.
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:
- 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]``
-
- 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.
-
- Exemple : ``d = ADD.get("Innovation")[-1]``
+ .. include:: snippets/BMA.rst
- InnovationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
- courant.
+ .. include:: snippets/CostFunctionJAtCurrentOptimum.rst
- Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
+ .. include:: snippets/CostFunctionJbAtCurrentOptimum.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/CostFunctionJoAtCurrentOptimum.rst
- Exemple : ``oma = ADD.get("OMA")[-1]``
+ .. include:: snippets/CurrentOptimum.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/CurrentState.rst
- Exemple : ``omb = ADD.get("OMB")[-1]``
+ .. include:: snippets/IndexOfOptimum.rst
- SimulatedObservationAtBackground
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'ébauche :math:`\mathbf{x}^b`.
+ .. include:: snippets/Innovation.rst
- Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
+ .. include:: snippets/InnovationAtCurrentState.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/SimulatedObservationAtBackground.rst
- Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+ .. include:: snippets/SimulatedObservationAtCurrentOptimum.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/SimulatedObservationAtCurrentState.rst
- Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
+ .. include:: snippets/SimulatedObservationAtOptimum.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: CheckingPoint
-.. index:: single: ObservationOperator
-.. index:: single: Observers
-
Les commandes requises générales, disponibles dans l'interface en édition, sont
les suivantes:
- Observers
- *Commande obligatoire*. Elle permet de définir des observateurs internes,
- qui sont des fonctions liées à une variable particulière, 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.
+ .. include:: snippets/Observers.rst
Les commandes optionnelles générales, disponibles dans l'interface en édition,
sont indiquées dans la :ref:`section_ref_checking_keywords`.
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: MaximumNumberOfSteps
-.. index:: single: MaximumNumberOfFunctionEvaluations
-.. index:: single: NumberOfInsects
-.. index:: single: SwarmVelocity
-.. index:: single: GroupRecallRate
-.. index:: single: QualityCriterion
-.. index:: single: BoxBounds
-.. index:: single: SetSeed
-.. index:: single: StoreSupplementaryCalculations
-
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
commande.
Les options de l'algorithme sont les suivantes:
+.. index:: single: NumberOfInsects
+.. index:: single: SwarmVelocity
+.. index:: single: GroupRecallRate
+.. index:: single: QualityCriterion
+.. index:: single: BoxBounds
- 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":100}``
+ .. include:: snippets/MaximumNumberOfSteps_50.rst
- 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.
+ .. include:: snippets/MaximumNumberOfFunctionEvaluations.rst
- Exemple : ``{"MaximumNumberOfFunctionEvaluations":50}``
+ .. include:: snippets/QualityCriterion.rst
NumberOfInsects
Cette clé indique le nombre d'insectes ou de particules dans l'essaim. La
valeur par défaut est 100, qui est une valeur par défaut usuelle pour cet
algorithme.
- Exemple : ``{"NumberOfInsects":100}``
+ Exemple :
+ ``{"NumberOfInsects":100}``
SwarmVelocity
Cette clé indique la part de la vitesse d'insecte qui est imposée par
l'essaim. C'est une valeur réelle positive. Le défaut est de 1.
- Exemple : ``{"SwarmVelocity":1.}``
+ Exemple :
+ ``{"SwarmVelocity":1.}``
GroupRecallRate
Cette clé indique le taux de rappel vers le meilleur insecte de l'essaim.
C'est une valeur réelle comprise entre 0 et 1. Le défaut est de 0.5.
- Exemple : ``{"GroupRecallRate":0.5}``
-
- 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"}``
+ Exemple :
+ ``{"GroupRecallRate":0.5}``
BoxBounds
Cette clé permet de définir des bornes supérieure et inférieure pour chaque
valeur autorisée lorsqu'il n'y a pas de borne). Cette clé est requise et il
n'y a pas de valeurs par défaut.
- Exemple : ``{"BoxBounds":[[-0.5,0.5], [0.01,2.], [0.,1.e99], [-1.e99,1.e99]]}``
+ Exemple :
+ ``{"BoxBounds":[[-0.5,0.5], [0.01,2.], [0.,1.e99], [-1.e99,1.e99]]}``
- 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}``
+ .. include:: snippets/SetSeed.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,
"Innovation", "SimulatedObservationAtBackground",
"SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"].
- Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
-
- 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.
+ .. include:: snippets/Analysis.rst
- Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
+ .. include:: snippets/CostFunctionJ.rst
- 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.
+ .. include:: snippets/CostFunctionJb.rst
- Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
+ .. include:: snippets/CostFunctionJo.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- 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]``
-
- 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")[:]``
-
- 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]``
-
- 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]``
-
- 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/BMA.rst
- Exemple : ``omb = ADD.get("OMB")[-1]``
+ .. include:: snippets/CurrentState.rst
- SimulatedObservationAtBackground
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'ébauche :math:`\mathbf{x}^b`.
+ .. include:: snippets/Innovation.rst
- Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
+ .. include:: snippets/OMA.rst
- SimulatedObservationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant,
- c'est-à-dire dans l'espace des observations.
+ .. include:: snippets/OMB.rst
- Exemple : ``Ys = 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/SimulatedObservationAtCurrentState.rst
- Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
+ .. include:: snippets/SimulatedObservationAtOptimum.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: Observation
-.. index:: single: ObservationOperator
-.. index:: single: Quantile
-.. index:: single: Minimizer
-.. index:: single: MaximumNumberOfSteps
-.. index:: single: CostDecrementTolerance
-.. index:: single: Bounds
-.. index:: single: StoreSupplementaryCalculations
-
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*".
-
- 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*".
-
- 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/Observation.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:
- 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}``
-
- 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.
+ .. include:: snippets/Quantile.rst
- Exemple : ``{"MaximumNumberOfSteps":100}``
+ .. include:: snippets/MaximumNumberOfSteps.rst
- 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.
+ .. include:: snippets/CostDecrementTolerance_6.rst
- Exemple : ``{"CostDecrementTolerance":1.e-7}``
-
- 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]]}``
+ .. include:: snippets/BoundsWithNone.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,
"Innovation", "SimulatedObservationAtBackground",
"SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"].
- Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
*Astuce pour cet algorithme :*
Comme les commandes *"BackgroundError"* et *"ObservationError"* sont
- requises pour TOUS les algorithmes de calcul dans l'interface, vous devez
- fournir une valeur, malgré le fait que ces commandes ne sont pas requises
- pour cet algorithme, et ne seront pas utilisées. La manière la plus simple
- est de donner "1" comme un STRING pour les deux.
+ requises pour TOUS les algorithmes de calcul dans l'interface graphique,
+ vous devez fournir une valeur, malgré le fait que ces commandes ne sont pas
+ requises pour cet algorithme, et ne seront pas utilisées. La manière la
+ plus simple est de donner "1" comme un STRING pour les deux.
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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
+ .. include:: snippets/Analysis.rst
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
+ .. include:: snippets/CostFunctionJ.rst
- 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.
+ .. include:: snippets/CostFunctionJb.rst
- 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:
- 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]``
-
- 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")[:]``
-
- 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]``
-
- 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]``
-
- 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/BMA.rst
- Exemple : ``omb = ADD.get("OMB")[-1]``
+ .. include:: snippets/CurrentState.rst
- SimulatedObservationAtBackground
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'ébauche :math:`\mathbf{x}^b`.
+ .. include:: snippets/Innovation.rst
- Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
+ .. include:: snippets/OMA.rst
- SimulatedObservationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant,
- c'est-à-dire dans l'espace des observations.
+ .. include:: snippets/OMB.rst
- Exemple : ``Ys = 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/SimulatedObservationAtCurrentState.rst
- Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
+ .. include:: snippets/SimulatedObservationAtOptimum.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: CheckingPoint
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: SampleAsnUplet
-.. index:: single: SampleAsExplicitHyperCube
-.. index:: single: SampleAsMinMaxStepHyperCube
-.. index:: single: SampleAsIndependantRandomVariables
-.. index:: single: QualityCriterion
-.. index:: single: SetDebug
-.. index:: single: SetSeed
-.. index:: single: StoreSupplementaryCalculations
-
Les commandes requises générales, disponibles dans l'interface en édition, sont
les suivantes:
- CheckingPoint
- *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour
- duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à
- l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type
- "*Vector*".
-
- 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ée
- 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*". 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/CheckingPoint.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_checking_keywords`. De plus, les
commande.
Les options de l'algorithme sont les suivantes:
+.. index:: single: SampleAsnUplet
+.. index:: single: SampleAsExplicitHyperCube
+.. index:: single: SampleAsMinMaxStepHyperCube
+.. index:: single: SampleAsIndependantRandomVariables
SampleAsnUplet
Cette clé décrit les points de calcul sous la forme d'une liste de n-uplets,
chaque n-uplet étant un état.
- Exemple : ``{"SampleAsnUplet":[[0,1,2,3],[4,3,2,1],[-2,3,-4,5]]}`` pour 3 points dans un espace d'état de dimension 4
+ Exemple :
+ ``{"SampleAsnUplet":[[0,1,2,3],[4,3,2,1],[-2,3,-4,5]]}`` pour 3 points dans un espace d'état de dimension 4
SampleAsExplicitHyperCube
Cette clé décrit les points de calcul sous la forme d'un hyper-cube, dont on
triplet *[min,max,step]*. C'est donc une liste de la même taille que celle
de l'état. Les bornes sont incluses.
- Exemple : ``{"SampleAsMinMaxStepHyperCube":[[0.,1.,0.25],[-1,3,1]]}`` pour un espace d'état de dimension 2
+ Exemple :
+ ``{"SampleAsMinMaxStepHyperCube":[[0.,1.,0.25],[-1,3,1]]}`` pour un espace d'état de dimension 2
SampleAsIndependantRandomVariables
Cette clé décrit les points de calcul sous la forme d'un hyper-cube, dont
(low,high), ou 'weibull' de paramètre (shape). C'est donc une liste de la
même taille que celle de l'état.
- Exemple : ``{"SampleAsIndependantRandomVariables":[ ['normal',[0.,1.],3], ['uniform',[-2,2],4]]`` pour un espace d'état de dimension 2
-
- QualityCriterion
- Cette clé indique le critère de qualité, qui est utilisé pour trouver
- l'estimation 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"}``
+ Exemple :
+ ``{"SampleAsIndependantRandomVariables":[ ['normal',[0.,1.],3], ['uniform',[-2,2],4]]`` pour un espace d'état de dimension 2
- SetDebug
- Cette clé requiert l'activation, ou pas, du mode de débogage durant
- l'évaluation de la fonction. La valeur par défaut est "True", les choix sont
- "True" ou "False".
+ .. include:: snippets/QualityCriterion.rst
- Exemple : ``{"SetDebug":False}``
+ .. include:: snippets/SetDebug.rst
- 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}``
+ .. include:: snippets/SetSeed.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,
"CostFunctionJo", "CurrentState", "InnovationAtCurrentState",
"SimulatedObservationAtCurrentState"].
- Exemple : ``{"StoreSupplementaryCalculations":["CostFunctionJ", "SimulatedObservationAtCurrentState"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["CostFunctionJ", "SimulatedObservationAtCurrentState"]}``
Informations et variables disponibles à la fin de l'algorithme
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Les sorties non conditionnelles de l'algorithme sont les suivantes:
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
-
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
+ .. include:: snippets/CostFunctionJ.rst
- 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.
+ .. include:: snippets/CostFunctionJb.rst
- 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:
- 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")[:]``
-
- InnovationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
- courant.
-
- Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
+ .. include:: snippets/CurrentState.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/InnovationAtCurrentState.rst
- Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+ .. include:: snippets/SimulatedObservationAtCurrentState.rst
Voir aussi
++++++++++
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: CheckingPoint
-.. index:: single: ObservationOperator
-.. index:: single: AmplitudeOfInitialDirection
-.. index:: single: EpsilonMinimumExponent
-.. index:: single: InitialDirection
-.. index:: single: SetSeed
-.. index:: single: StoreSupplementaryCalculations
-
Les commandes requises générales, disponibles dans l'interface en édition, sont
les suivantes:
- CheckingPoint
- *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour
- duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à
- l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type
- "*Vector*".
-
- ObservationOperator
- *Commande obligatoire*. Elle indique l'opérateur d'observation, notée
- 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*". 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/CheckingPoint.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_checking_keywords`. De plus, les
Les options de l'algorithme sont les suivantes:
- 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 pas
- de mise à l'échelle.
-
- Exemple : ``{"AmplitudeOfInitialDirection":0.5}``
-
- 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}``
+ .. include:: snippets/AmplitudeOfInitialDirection.rst
- 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.
+ .. include:: snippets/EpsilonMinimumExponent.rst
- Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}``
+ .. include:: snippets/InitialDirection.rst
- 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}``
+ .. include:: snippets/SetSeed.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,
possibles sont dans la liste suivante : ["CurrentState", "Residu",
"SimulatedObservationAtCurrentState"].
- Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["CurrentState"]}``
Informations et variables disponibles à la fin de l'algorithme
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Les sorties non conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
+ .. include:: snippets/Residu.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- 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")[:]``
-
- 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/CurrentState.rst
- Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+ .. include:: snippets/SimulatedObservationAtCurrentState.rst
Voir aussi
++++++++++
opérateurs tangent ou adjoint pour les opérateurs d'observation ou d'évolution,
comme dans les filtres de Kalman simple ou étendu.
+Il s'applique aux cas d'opérateurs d'observation et d'évolution incrémentale
+(processus) non-linéaires et présente d'excellentes qualités de robustesse et
+de performances. Il peut être comparé à
+l':ref:`section_ref_algorithm_EnsembleKalmanFilter`, dont les qualités sont
+similaires pour les systèmes non-linéaires.
+
+Dans le cas d'opérateurs linéaires ou "faiblement" non-linéaire, on peut
+aisément utiliser l':ref:`section_ref_algorithm_ExtendedKalmanFilter` ou même
+l':ref:`section_ref_algorithm_KalmanFilter`, qui sont souvent largement moins
+coûteux en évaluation sur de petits systèmes. On peut vérifier la linéarité des
+opérateurs à l'aide de l':ref:`section_ref_algorithm_LinearityTest`.
+
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: Bounds
-.. index:: single: ConstrainedBy
-.. index:: single: EstimationOf
-.. index:: single: Alpha
-.. index:: single: Beta
-.. index:: single: Kappa
-.. index:: single: Reconditioner
-.. index:: single: StoreSupplementaryCalculations
-
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/EvolutionError.rst
+
+ .. include:: snippets/EvolutionModel.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:
- 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]]}``
-
- ConstrainedBy
- Cette clé permet d'indiquer la méthode de prise en compte des contraintes de
- bornes. La seule disponible est "EstimateProjection", qui projette
- l'estimation de l'état courant sur les contraintes de bornes.
+ .. include:: snippets/BoundsWithExtremes.rst
- Exemple : ``{"ConstrainedBy":"EstimateProjection"}``
+ .. include:: snippets/ConstrainedBy.rst
- 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"}``
+ .. include:: snippets/EstimationOf.rst
Alpha, Beta, Kappa, Reconditioner
+ .. index:: single: Alpha
+ .. index:: single: Beta
+ .. index:: single: Kappa
+ .. index:: single: Reconditioner
+
Ces clés sont des paramètres de mise à l'échelle interne. "Alpha" requiert
une valeur comprise entre 1.e-4 et 1. "Beta" a une valeur optimale de 2 pour
une distribution *a priori* gaussienne. "Kappa" requiert une valeur entière,
"Reconditioner" requiert une valeur comprise entre 1.e-3 et 10, son défaut
étant 1.
- Exemple : ``{"Alpha":1,"Beta":2,"Kappa":0,"Reconditioner":1}``
+ Exemple :
+ ``{"Alpha":1,"Beta":2,"Kappa":0,"Reconditioner":1}``
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,
"APosterioriVariances", "BMA", "CostFunctionJ", "CostFunctionJb",
"CostFunctionJo", "CurrentState", "Innovation"].
- Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
+ .. include:: snippets/Analysis.rst
Les sorties conditionnelles de l'algorithme sont les suivantes:
- APosterioriCorrelations
- *Liste de matrices*. Chaque élément est une matrice de corrélation des
- erreurs *a posteriori* de l'état optimal.
-
- 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 d'écart-types des
- erreurs *a posteriori* de l'état optimal.
-
- Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]``
-
- APosterioriVariances
- *Liste de matrices*. Chaque élément est une matrice de variances des erreurs
- *a posteriori* de l'état optimal.
-
- 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]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
+ .. include:: snippets/APosterioriCorrelations.rst
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
+ .. include:: snippets/APosterioriCovariance.rst
- 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.
+ .. include:: snippets/APosterioriStandardDeviations.rst
- Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
+ .. include:: snippets/APosterioriVariances.rst
- 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.
+ .. include:: snippets/BMA.rst
- Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
+ .. include:: snippets/CostFunctionJ.rst
- CurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
- au cours du déroulement de l'algorithme d'optimisation.
+ .. include:: snippets/CostFunctionJb.rst
- Exemple : ``Xs = ADD.get("CurrentState")[:]``
+ .. include:: snippets/CostFunctionJo.rst
- 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/CurrentState.rst
- Exemple : ``d = ADD.get("Innovation")[-1]``
+ .. include:: snippets/Innovation.rst
Voir aussi
++++++++++
Références vers d'autres sections :
- :ref:`section_ref_algorithm_KalmanFilter`
- :ref:`section_ref_algorithm_ExtendedKalmanFilter`
+ - :ref:`section_ref_algorithm_EnsembleKalmanFilter`
Références bibliographiques :
- [WikipediaUKF]_
.. index:: single: Algorithm
.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
.. index:: single: ControlInput
.. index:: single: Debug
-.. index:: single: EvolutionError
-.. index:: single: EvolutionModel
.. index:: single: InputVariables
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
.. index:: single: Observer
.. index:: single: Observers
.. index:: single: Observer Template
:ref:`section_ref_options_Algorithm_Parameters` pour l'usage détaillé de
cette partie de la commande.
- 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*".
+ .. include:: snippets/Background.rst
- 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*".
+ .. include:: snippets/BackgroundError.rst
ControlInput
*Commande optionnelle*. Elle indique le vecteur de contrôle utilisé pour
intermédiaires de débogage. Les choix sont limités entre 0 (pour False) et
1 (pour True).
- EvolutionError
- *Commande optionnelle*. Elle définit la matrice de covariance des erreurs
- 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*".
-
- EvolutionModel
- *Commande optionnelle*. Elle indique l'opérateur d'évolution du modèle,
- usuellement noté :math:`M`, qui décrit un pas élémentaire d'évolution. 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'évolution, l'opérateur doit être appliqué à une
- paire :math:`(X,U)`.
+ .. include:: snippets/EvolutionError.rst
+
+ .. include:: snippets/EvolutionModel.rst
InputVariables
*Commande optionnelle*. Elle permet d'indiquer le nom et la taille des
information est destinée à être utilisée dans le traitement algorithmique
interne des données.
- 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/Observation.rst
+
+ .. include:: snippets/ObservationError.rst
+
+ .. include:: snippets/ObservationOperator.rst
Observers
*Commande optionnelle*. Elle permet de définir des observateurs internes,
.. index:: single: Algorithm
.. index:: single: AlgorithmParameters
-.. index:: single: CheckingPoint
-.. index:: single: BackgroundError
.. index:: single: Debug
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
.. index:: single: Observer
.. index:: single: Observers
.. index:: single: Observer Template
:ref:`section_ref_options_Algorithm_Parameters` pour l'usage détaillé de
cette partie de la commande.
- CheckingPoint
- *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour
- duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à
- l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type
- "*Vector*".
+ .. include:: snippets/CheckingPoint.rst
- 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*".
+ .. include:: snippets/BackgroundError.rst
Debug
*Commande optionnelle*. Elle définit le niveau de sorties et d'informations
intermédiaires de débogage. Les choix sont limités entre 0 (pour False) et
1 (pour True).
- 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/Observation.rst
+
+ .. include:: snippets/ObservationError.rst
+
+ .. include:: snippets/ObservationOperator.rst
Observers
*Commande optionnelle*. Elle permet de définir des observateurs internes,
Inventaire des informations potentiellement disponibles en sortie
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-.. index:: single: Dry
-.. index:: single: Forecast
-
-L'ensemble des informations potentiellement disponibles en sortie est indiqué
-ici indépendamment des algorithmes, pour inventaire.
+Les principales informations potentiellement disponibles en sortie sont
+indiquées ici indépendamment des algorithmes, pour inventaire. On se reportera
+directement aux détails des algorithmes pour avoir l'inventaire exhaustif.
L'état optimal est une information qui est toujours naturellement disponible
après un calcul d'assimilation de données ou d'optimisation. Il désigné par le
mot-clé suivant:
- 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.
-
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
-
-Les variables suivantes sont des variables d'entrée. Elles sont mises à
-disposition de l'utilisateur en sortie pour faciliter l'écriture des procédures
-de post-processing, et sont conditionnées par une demande utilisateur à l'aide
-d'un booléen "*Stored*" en entrée.
-
- Background
- *Vecteur*, dont la disponibilité est conditionnée par "*Stored*" en entrée.
- C'est le vecteur d'ébauche :math:`\mathbf{x}^b`.
-
- Exemple : ``Xb = ADD.get("Background")``
+ .. include:: snippets/Analysis.rst
- BackgroundError
- *Matrice*, dont la disponibilité est conditionnée par "*Stored*" en entrée.
- C'est la matrice :math:`\mathbf{B}` de covariances des erreurs *a priori*
- de l'ébauche.
+Les variables suivantes sont des variables d'entrée que l'on peut aussi obtenir
+en sortie. Elles sont mises à disposition de l'utilisateur en sortie pour
+faciliter l'écriture des procédures de post-processing, et sont conditionnées
+par une demande utilisateur explicite à l'aide d'un booléen "*Stored*" en
+entrée. Toutes ces variables d'entrée restituées sont obtenables par la
+commande standard ".get(...)", qui s'applique à refournir l'unique objet donné
+en entrée.
- Exemple : ``B = ADD.get("BackgroundError")``
+ .. include:: snippets/Background.rst
- EvolutionError
- *Matrice*, dont la disponibilité est conditionnée par "*Stored*" en entrée.
- C'est la matrice :math:`\mathbf{M}` de covariances des erreurs *a priori*
- de l'évolution.
+ .. include:: snippets/BackgroundError.rst
- Exemple : ``M = ADD.get("EvolutionError")``
+ .. include:: snippets/EvolutionError.rst
- Observation
- *Vecteur*, dont la disponibilité est conditionnée par "*Stored*" en entrée.
- C'est le vecteur d'observation :math:`\mathbf{y}^o`.
+ .. include:: snippets/Observation.rst
- Exemple : ``Yo = ADD.get("Observation")``
-
- ObservationError
- *Matrice*, dont la disponibilité est conditionnée par "*Stored*" en entrée.
- C'est la matrice :math:`\mathbf{R}` de covariances des erreurs *a priori*
- de l'observation.
-
- Exemple : ``R = ADD.get("ObservationError")``
+ .. include:: snippets/ObservationError.rst
Toutes les autres informations sont conditionnées par l'algorithme et/ou par la
-demande utilisateur de disponibilité. Ce sont les suivantes, par ordre
-alphabétique:
-
- 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]``
-
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
-
- 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")[:]``
-
- 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.
-
- Exemple : ``d = ADD.get("Innovation")[-1]``
+demande utilisateur de disponibilité. Les principales sont les suivantes, par
+ordre alphabétique:
- InnovationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
- courant.
+ .. include:: snippets/APosterioriCorrelations.rst
- Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
+ .. include:: snippets/APosterioriCovariance.rst
- MahalanobisConsistency
- *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
- qualité de Mahalanobis.
+ .. include:: snippets/APosterioriStandardDeviations.rst
- Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]``
+ .. include:: snippets/APosterioriVariances.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/BMA.rst
- Exemple : ``oma = ADD.get("OMA")[-1]``
+ .. include:: snippets/CostFunctionJ.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/CostFunctionJb.rst
- Exemple : ``omb = ADD.get("OMB")[-1]``
+ .. include:: snippets/CostFunctionJo.rst
- 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.
+ .. include:: snippets/CostFunctionJAtCurrentOptimum.rst
- Exemple : ``r = ADD.get("Residu")[:]``
+ .. include:: snippets/CostFunctionJbAtCurrentOptimum.rst
- SigmaBck2
- *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
- qualité :math:`(\sigma^b)^2` de la partie ébauche.
+ .. include:: snippets/CostFunctionJoAtCurrentOptimum.rst
- Exemple : ``sb2 = ADD.get("SigmaBck")[-1]``
+ .. include:: snippets/CurrentOptimum.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/CurrentState.rst
- Exemple : ``so2 = ADD.get("SigmaObs")[-1]``
+ .. include:: snippets/IndexOfOptimum.rst
- SimulatedObservationAtBackground
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'ébauche :math:`\mathbf{x}^b`. C'est la prévision à partir de
- l'ébauche, et elle est parfois appellée "*Dry*".
+ .. include:: snippets/Innovation.rst
- Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
+ .. include:: snippets/InnovationAtCurrentState.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/Residu.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`. C'est la
- prévision à partir de l'analyse ou de l'état optimal, et elle est parfois
- appellée "*Forecast*".
+ .. 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
.. [#] Pour de plus amples informations sur PARAVIS, voir le *module PARAVIS* et son aide intégrée disponible dans le menu principal *Aide* de l'environnement SALOME.
