"3DVAR-Incr" algorithms (and not the others) explicitly allow the modification
of the initial point of their minimization, even if it is not recommended.
+This algorithm is naturally written for a single estimate, without any dynamic
+or iterative notion (there is no need in this case for an incremental evolution
+operator, nor for an evolution error covariance). In ADAO, it can also be used
+on a succession of observations, placing the estimate in a recursive framework
+partly similar to a :ref:`section_ref_algorithm_KalmanFilter`. A standard
+estimate is made at each observation step on the state predicted by the
+incremental evolution model, knowing that the state error covariance remains
+the background covariance initially provided by the user. To be explicit,
+unlike Kalman-type filters, the state error covariance is not updated.
+
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
This algorithm realizes a BLUE (Best Linear Unbiased Estimator) type estimation
of the state of a system. It is a linear, unbiased and optimal estimation.
-Technically, it is an Aitken estimator.
-
-This algorithm is always the fastest of all the assimilation algorithms of ADAO.
+Technically, it is here an Aitken estimator. It performs the best linear
+estimate of the state using the initial background state and the observations.
It is theoretically reserved for observation operator cases which are linear,
even if it sometimes works in "slightly" non-linear cases. One can verify the
linearity of the observation operator with the help of the
-:ref:`section_ref_algorithm_LinearityTest`.
-
-In case of non-linearity, even slightly marked, it will be easily preferred the
-:ref:`section_ref_algorithm_ExtendedBlue` or the
+:ref:`section_ref_algorithm_LinearityTest`. This algorithm is always the
+fastest of all the assimilation algorithms of ADAO.
+
+This algorithm is naturally written for a single estimate, without any dynamic
+or iterative notion (there is no need in this case for an incremental evolution
+operator, nor for an evolution error covariance). In ADAO, it can also be used
+on a succession of observations, placing the estimate in a recursive framework
+partly similar to a :ref:`section_ref_algorithm_KalmanFilter`. A standard
+estimate is made at each observation step on the state predicted by the
+incremental evolution model, knowing that the state error covariance remains
+the background covariance initially provided by the user. To be explicit,
+unlike Kalman-type filters, the state error covariance is not updated.
+
+In case of non-linearity, even slightly marked, it will be easily preferred a
+:ref:`section_ref_algorithm_ExtendedBlue` or a
:ref:`section_ref_algorithm_3DVAR`.
.. index:: single: Optimal Interpolation
.. index:: single: OI
-Additional remark: an algebraic simplification of the BLUE leads to the optimal
-interpolation method, named "*Optimal Interpolation*" or "*OI*". It is a very
-simple and inexpensive method, especially adapted to very (very) large
-problems, but whose disadvantage is to provide a globally sub-optimal and noisy
-analysis result, even inconsistent. The way to avoid these disadvantages is to
-adapt very precisely the elements of the method to each physical model. For
-these reasons, this method is not proposed nor recommended.
+Additional remark: an algebraic simplification of the BLUE leads to the
+so-called optimal interpolation method, named "*Optimal Interpolation*" or
+"*OI*". It is a very simple and inexpensive method, especially adapted to very
+(very) large problems, but whose disadvantage is to provide a globally
+sub-optimal and noisy analysis result, even inconsistent. The way to avoid
+these disadvantages is to adapt very precisely the elements of the method to
+each physical model. For these reasons, this method is not proposed nor
+recommended.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
This algorithm realizes an extended BLUE (Best Linear Unbiased Estimator) type
estimation of the state of a system.
-This algorithm is a partially non-linear generalization of the
+This algorithm is a partially non-linear generalization of a
:ref:`section_ref_algorithm_Blue`. It is equivalent for a linear observation
-operator. One can verify the linearity of the observation operator with the help
-of the :ref:`section_ref_algorithm_LinearityTest`.
-
-In case of non-linearity, it is close to the :ref:`section_ref_algorithm_3DVAR`,
-without being entirely equivalent.
+operator. One can verify the linearity of the observation operator with the
+help of a :ref:`section_ref_algorithm_LinearityTest`.
+
+In case of non-linearity, its results are close to a
+:ref:`section_ref_algorithm_3DVAR`, without being entirely equivalent.
+
+This algorithm is naturally written for a single estimate, without any dynamic
+or iterative notion (there is no need in this case for an incremental evolution
+operator, nor for an evolution error covariance). In ADAO, it can also be used
+on a succession of observations, placing the estimate in a recursive framework
+partly similar to a :ref:`section_ref_algorithm_KalmanFilter`. A standard
+estimate is made at each observation step on the state predicted by the
+incremental evolution model, knowing that the state error covariance remains
+the background covariance initially provided by the user. To be explicit,
+unlike Kalman-type filters, the state error covariance is not updated.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
.. include:: snippets/Header2Algo01.rst
This algorithm realizes an estimation of the state of a dynamic system by a
-extended Kalman Filter, using a non-linear calculation of the state and the
-incremental evolution (process).
+extended Kalman Filter, using a non-linear calculation of the state observation
+and incremental evolution (process). Technically, the estimation of the state
+is performed by the classical Kalman filter equations, using at each step the
+Jacobian obtained by linearization of the observation and the evolution to
+evaluate the state error covariance. This algorithm is therefore more expensive
+than the linear Kalman Filter, but it is by nature better adapted as soon as
+the operators are non-linear, being by principle universally recommended in
+this case.
Conceptually, we can represent the temporal pattern of action of the evolution
and observation operators in this algorithm in the following way, with **x**
-the state and **P** the state error covariance :
+the state, **P** the state error covariance, *t* the discrete iterative time :
.. _schema_temporel_KF:
.. image:: images/schema_temporel_KF.png
.. centered::
**Timeline of steps in extended Kalman filter data assimilation**
-We notice that there is no analysis performed at the initial time step
-(numbered 0 in the time indexing) because there is no forecast at this time
-(the background is stored as a pseudo analysis at the initial time step). If
-the observations are provided in series by the user, the first one is therefore
-not used.
-
-In case of really non-linear operators, one can easily use the
-:ref:`section_ref_algorithm_EnsembleKalmanFilter` or the
+In this scheme, the analysis **(x,P)** is obtained by means of the
+"*correction*" by observing the "*prediction*" of the previous state. We notice
+that there is no analysis performed at the initial time step (numbered 0 in the
+time indexing) because there is no forecast at this time (the background is
+stored as a pseudo analysis at the initial time step). If the observations are
+provided in series by the user, the first one is therefore not used.
+
+This filter can also be used to estimate (jointly or solely) parameters and not
+the state, in which case neither the time nor the evolution have any meaning.
+The iteration steps are then linked to the insertion of a new observation in
+the recursive estimation. One should consult the section
+:ref:`section_theory_dynamique` for the implementation concepts.
+
+In case of more pronounced non-linear operators, one can easily use a
+:ref:`section_ref_algorithm_EnsembleKalmanFilter` or a
:ref:`section_ref_algorithm_UnscentedKalmanFilter`, which are often far more
-adapted to non-linear behavior but more costly. One can verify the linearity of
-the operators with the help of the :ref:`section_ref_algorithm_LinearityTest`.
+adapted to non-linear behavior but sometimes costly. One can verify the
+linearity of the operators with the help of a
+:ref:`section_ref_algorithm_LinearityTest`.
.. index::
pair: Variant ; EKF
pair: Variant ; CEKF
-A difference is made between the extended Kalman filter taking into account
-bounds on the states (the variant named "CEKF", which is recommended and used
-by default), and the extended Kalman filter conducted without any constraint
-(the variant named "EKF", which is not recommended).
+The extended Kalman filter can take into account bounds on the states (the
+variant is named "CEKF", it is recommended and is used by default), or
+conducted without any constraint (the variant is named "EKF", and it is not
+recommended).
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
.. include:: snippets/Header2Algo01.rst
This algorithm realizes an estimation of the state of a dynamic system by a
-Kalman Filter.
-
-It is theoretically reserved for observation and incremental evolution operators
-cases which are linear, even if it sometimes works in "slightly" non-linear
-cases. One can verify the linearity of the operators with the help of
-the :ref:`section_ref_algorithm_LinearityTest`.
+Kalman Filter. In discrete form, it is an iterative (or recursive) estimator of
+the current state using the previous state and the current observations. The
+time (or pseudo-time) between two steps is the time between successive
+observations. Each iteration step is composed of two successive phases,
+classically called "*prediction*" and "*correction*". The prediction step uses
+an incremental evolution operator to establish an estimate of the current state
+from the state estimated at the previous step. The correction (or *update*)
+step uses the current observations to improve the estimate by correcting the
+predicted state.
+
+It is theoretically reserved for observation and incremental evolution
+operators cases which are linear, even if it sometimes works in "slightly"
+non-linear cases. One can verify the linearity of the operators with the help
+of a :ref:`section_ref_algorithm_LinearityTest`.
Conceptually, we can represent the temporal pattern of action of the evolution
and observation operators in this algorithm in the following way, with **x**
-the state and **P** the state error covariance :
+the state, **P** the state error covariance, *t* the discrete iterative time :
.. _schema_temporel_KF:
.. image:: images/schema_temporel_KF.png
.. centered::
**Timeline of steps in Kalman filter data assimilation**
-We notice that there is no analysis performed at the initial time step
-(numbered 0 in the time indexing) because there is no forecast at this time
-(the background is stored as a pseudo analysis at the initial time step). If
-the observations are provided in series by the user, the first one is therefore
-not used.
-
-In case of non-linearity, even slightly marked, it will be preferred the
-:ref:`section_ref_algorithm_ExtendedKalmanFilter`, or the
-:ref:`section_ref_algorithm_UnscentedKalmanFilter` and the
+In this scheme, the analysis **(x,P)** is obtained by means of the
+"*correction*" by observing the "*prediction*" of the previous state. We notice
+that there is no analysis performed at the initial time step (numbered 0 in the
+time indexing) because there is no forecast at this time (the background is
+stored as a pseudo analysis at the initial time step). If the observations are
+provided in series by the user, the first one is therefore not used.
+
+This filter can also be used to estimate (jointly or solely) parameters and not
+the state, in which case neither the time nor the evolution have any meaning.
+The iteration steps are then linked to the insertion of a new observation in
+the recursive estimation. One should consult the section
+:ref:`section_theory_dynamique` for the implementation concepts.
+
+In case of non-linearity of the operators, even slightly marked, it will be
+preferred a :ref:`section_ref_algorithm_ExtendedKalmanFilter`, or a
+:ref:`section_ref_algorithm_UnscentedKalmanFilter` and a
:ref:`section_ref_algorithm_UnscentedKalmanFilter` that are more powerful. One
-can verify the linearity of the operators
-with the help of the :ref:`section_ref_algorithm_LinearityTest`.
+can verify the linearity of the operators with the help of a
+:ref:`section_ref_algorithm_LinearityTest`.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
.. include:: snippets/Header2Algo01.rst
This algorithm realizes a "Least Squares" linear type estimation of the state of
-a system. It is similar to the :ref:`section_ref_algorithm_Blue`, without its
+a system. It is similar to a :ref:`section_ref_algorithm_Blue`, without its
background part.
This algorithm is always the fastest of all the optimization algorithms of
ADAO. It is theoretically reserved for observation operator cases which are
explicitly linear, even if it sometimes works in "slightly" non-linear cases.
-One can verify the linearity of the observation operator with the help of the
+One can verify the linearity of the observation operator with the help of a
:ref:`section_ref_algorithm_LinearityTest`.
-In all cases, it is recommanded to prefer at least the
-:ref:`section_ref_algorithm_Blue`, or the
-:ref:`section_ref_algorithm_ExtendedBlue` or the
+This algorithm is naturally written for a single estimate, without any dynamic
+or iterative notion (there is no need in this case for an incremental evolution
+operator, nor for an evolution error covariance). In ADAO, it can also be used
+on a succession of observations, placing the estimate in a recursive framework
+partly similar to a Kalman Filter. A standard estimate is made at each
+observation step on the state predicted by the incremental evolution model.
+
+In all cases, it is recommanded to prefer at least a
+:ref:`section_ref_algorithm_Blue`, or a
+:ref:`section_ref_algorithm_ExtendedBlue` or a
:ref:`section_ref_algorithm_3DVAR`.
.. ------------------------------------ ..
.. math:: J(\mathbf{x})=(\mathbf{y}^o-\mathbf{H}.\mathbf{x})^T.\mathbf{R}^{-1}.(\mathbf{y}^o-\mathbf{H}.\mathbf{x})
-It is similar to the :ref:`section_ref_algorithm_3DVAR`, without its background
+It is similar to a :ref:`section_ref_algorithm_3DVAR`, without its background
part. The background, required in the interface, is only used as an initial
point for the variational minimization.
-In all cases, it is recommended to prefer the :ref:`section_ref_algorithm_3DVAR`
+This algorithm is naturally written for a single estimate, without any dynamic
+or iterative notion (there is no need in this case for an incremental evolution
+operator, nor for an evolution error covariance). In ADAO, it can also be used
+on a succession of observations, placing the estimate in a recursive framework
+partly similar to a Kalman Filter. A standard estimate is made at each
+observation step on the state predicted by the incremental evolution model.
+
+In all cases, it is recommended to prefer a :ref:`section_ref_algorithm_3DVAR`
for its stability as for its behavior during optimization.
.. ------------------------------------ ..
The reader interested in the subject of optimization can look at [WikipediaMO]_
as a general entry point.
+.. _section_theory_dynamique:
+
Going further in data assimilation for dynamics
-----------------------------------------------
where :math:`\mathbf{w}_{n}=[\mathbf{x}_n~~\mathbf{a}_n]^T`. The incremental
evolution and observation operators are therefore respectively the augmented
-operators :math:`\tilde{M}` and :math:`\tilde{H}`, and are directly usable in
-data assimilation with ADAO.
+operators :math:`\tilde{M}` and :math:`\tilde{H}`, and are directly suitable
+for study cases with ADAO.
Conceptual scheme for data assimilation in dynamics
+++++++++++++++++++++++++++++++++++++++++++++++++++
To complete the description, we can represent the data assimilation process in
a dynamics specific way using a temporal scheme, which describes the action of
the evolution (:math:`M` or :math:`\tilde{M}`) and observation (:math:`H` or
-:math:`\tilde{H}`) operators during the discrete simulation. A possible
-representation is as follows:
+:math:`\tilde{H}`) operators during the discrete simulation and the recursive
+estimation of the state (:math:`\mathbf{x}`). A possible representation is as
+follows, particularly appropriate for iterative Kalman filtering algorithms:
.. _schema_d_AD_temporel:
.. image:: images/schema_temporel_KF.png
.. centered::
**Timeline of steps for data assimilation operators in dynamics**
-The concepts described in this diagram can be directly and simply used in ADAO.
+with **P** the state error covariance and *t* the discrete iterative time. In
+this scheme, the analysis **(x,P)** is obtained by means of the "*correction*"
+by observing the "*prediction*" of the previous state. The concepts described
+in this diagram can be directly and simply used in ADAO to elaborate study
+cases, and are included in the description of some algorithms.
modification du point initial de leur minimisation, même si ce n'est pas
recommandé.
+Cet algorithme est naturellement écrit pour une estimation unique, sans notion
+dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur
+d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO,
+il peut aussi être utilisé sur une succession d'observations, plaçant alors
+l'estimation dans un cadre récursif en partie similaire à un
+:ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard est
+effectuée à chaque pas d'observation sur l'état prévu par le modèle d'évolution
+incrémentale, sachant que la covariance d'erreur d'état reste la covariance
+d'ébauche initialement fournie par l'utilisateur. Pour être explicite,
+contrairement aux filtres de type Kalman, la covariance d'erreurs sur les états
+n'est pas remise à jour.
+
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
Cet algorithme réalise une estimation de type BLUE (Best Linear Unbiased
Estimator) de l'état d'un système. C'est une estimation linéaire, sans biais et
-optimale. De manière technique, c'est un estimateur d'Aitken.
-
-Cet algorithme est toujours le plus rapide de l'ensemble des algorithmes
-d'assimilation d'ADAO. Il est théoriquement réservé aux cas d'opérateurs
+optimale. De manière technique, c'est ici un estimateur d'Aitken. Il réalise la
+meilleure estimation linéaire de l'état à l'aide de l'état d'ébauche initial et
+des observations. Il est théoriquement réservé aux cas d'opérateurs
d'observation linéaires, même s'il fonctionne parfois dans les cas "faiblement"
non-linéaires. On peut vérifier la linéarité de l'opérateur 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 aisément
-l':ref:`section_ref_algorithm_ExtendedBlue` ou
-l':ref:`section_ref_algorithm_3DVAR`.
+l'aide d'un :ref:`section_ref_algorithm_LinearityTest`. Cet algorithme est
+toujours le plus rapide de l'ensemble des algorithmes d'assimilation d'ADAO.
+
+Cet algorithme est naturellement écrit pour une estimation unique, sans notion
+dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur
+d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO,
+il peut aussi être utilisé sur une succession d'observations, plaçant alors
+l'estimation dans un cadre récursif en partie similaire à un
+:ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard est
+effectuée à chaque pas d'observation sur l'état prévu par le modèle d'évolution
+incrémentale, sachant que la covariance d'erreur d'état reste la covariance
+d'ébauche initialement fournie par l'utilisateur. Pour être explicite,
+contrairement aux filtres de type Kalman, la covariance d'erreurs sur les états
+n'est pas remise à jour.
+
+En cas de non-linéarité, même peu marquée, on lui préférera aisément un
+:ref:`section_ref_algorithm_ExtendedBlue` ou un
+:ref:`section_ref_algorithm_3DVAR`.
.. index:: single: Optimal Interpolation
.. index:: single: OI
Remarque complémentaire : une simplification algébrique du BLUE conduit à la
-méthode d'interpolation optimale, nommée "*Optimal Interpolation*" ou "*OI*".
-C'est une méthode très simple et peu coûteuse, spécialement adaptée aux
+méthode d'interpolation dite optimale nommée "*Optimal Interpolation*" ou
+"*OI*". C'est une méthode très simple et peu coûteuse, spécialement adaptée aux
problèmes de très (très) grande taille, mais dont l'inconvénient est de fournir
un résultat d'analyse globalement sous-optimal et bruité, voire incohérent. Le
moyen d'éviter ces désavantages est d'adapter très précisément les éléments de
Cet algorithme réalise une estimation de type BLUE étendu (Best Linear Unbiased
Estimator, étendu) de l'état d'un système.
-Cet algorithme est une généralisation partiellement non-linéaire de
-l':ref:`section_ref_algorithm_Blue`. Il lui est équivalent pour un opérateur
+Cet algorithme est une généralisation partiellement non-linéaire d'un
+:ref:`section_ref_algorithm_Blue`. Il lui est équivalent pour un opérateur
d'observation linéaire. On peut vérifier la linéarité de l'opérateur
-d'observation à l'aide de l':ref:`section_ref_algorithm_LinearityTest`.
-
-En non-linéaire, il se rapproche de l':ref:`section_ref_algorithm_3DVAR`, sans
-lui être entièrement équivalent.
+d'observation à l'aide d'un :ref:`section_ref_algorithm_LinearityTest`.
+
+En non-linéaire, ses résultats se rapprochent d'un
+:ref:`section_ref_algorithm_3DVAR`, sans lui être entièrement équivalent.
+
+Cet algorithme est naturellement écrit pour une estimation unique, sans notion
+dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur
+d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO,
+il peut aussi être utilisé sur une succession d'observations, plaçant alors
+l'estimation dans un cadre récursif en partie similaire à un
+:ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard est
+effectuée à chaque pas d'observation sur l'état prévu par le modèle d'évolution
+incrémentale, sachant que la covariance d'erreur d'état reste la covariance
+d'ébauche initialement fournie par l'utilisateur. Pour être explicite,
+contrairement aux filtres de type Kalman, la covariance d'erreurs sur les états
+n'est pas remise à jour.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
.. include:: snippets/Header2Algo01.rst
Cet algorithme réalise une estimation de l'état d'un système dynamique par un
-filtre de Kalman étendu, utilisant un calcul non linéaire de l'état et de
-l'évolution incrémentale (processus).
+filtre de Kalman étendu, utilisant un calcul non linéaire de l'observation
+d'état et de l'évolution incrémentale (processus). Techniquement, l'estimation
+de l'état est réalisée par les équations classiques du filtre de Kalman, en
+utilisant à chaque pas la jacobienne obtenue par linéarisation de l'observation
+et de l'évolution pour évaluer la covariance d'erreur d'état. Cet algorithme
+est donc plus coûteux que le Filtre de Kalman linéaire, mais il est par nature
+mieux adapté dès que les opérateurs sont non linéaires, étant par principe
+universellement recommandé dans ce cas.
Conceptuellement, on peut représenter le schéma temporel d'action des
opérateurs d'évolution et d'observation dans cet algorithme de la manière
-suivante, avec **x** l'état et **P** la covariance d'erreur d'état :
+suivante, avec **x** l'état, **P** la covariance d'erreur d'état, *t* le temps
+itératif discret :
.. _schema_temporel_KF:
.. image:: images/schema_temporel_KF.png
.. centered::
**Schéma temporel des étapes en assimilation de données par filtre de Kalman étendu**
-On remarque qu'il n'y a pas d'analyse effectuée au pas de temps initial
-(numéroté 0 dans l'indexage temporel) car il n'y a pas de prévision à cet
-instant (l'ébauche est stockée comme pseudo-analyse au pas initial). Si les
-observations sont fournies en série par l'utilisateur, la première n'est donc
-pas utilisée.
-
-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`.
+Dans ce schéma, l'analyse **(x,P)** est obtenue à travers la "*correction*" par
+l'observation de la "*prévision*" de l'état précédent. On remarque qu'il n'y a
+pas d'analyse effectuée au pas de temps initial (numéroté 0 dans l'indexage
+temporel) car il n'y a pas de prévision à cet instant (l'ébauche est stockée
+comme pseudo-analyse au pas initial). Si les observations sont fournies en
+série par l'utilisateur, la première n'est donc pas utilisée.
+
+Ce filtre peut aussi être utilisé pour estimer (conjointement ou uniquement)
+des paramètres et non pas l'état, auquel cas ni le temps ni l'évolution n'ont
+plus de signification. Les pas d'itération sont alors liés à l'insertion d'une
+nouvelle observation dans l'estimation récursive. On consultera la section
+:ref:`section_theory_dynamique` pour les concepts de mise en oeuvre.
+
+Dans le cas d'opérateurs plus fortement non-linéaires, on peut utiliser un
+:ref:`section_ref_algorithm_EnsembleKalmanFilter` ou un
+:ref:`section_ref_algorithm_UnscentedKalmanFilter`, qui sont largement plus
+adaptés aux comportements non-linéaires même si parfois plus coûteux. On peut
+vérifier la linéarité des opérateurs à l'aide d'un
+:ref:`section_ref_algorithm_LinearityTest`.
.. index::
pair: Variant ; EKF
pair: Variant ; CEKF
-On fait une différence entre le filtre de Kalman étendu tenant compte de
-bornes sur les états (la variante nommée "CEKF", qui est recommandée et qui est
-utilisée par défaut), et le filtre de Kalman étendu conduit sans
-aucune contrainte (la variante nommée "EKF", qui n'est pas recommandée).
+Le filtre de Kalman étendu peut tenir compte de bornes sur les états (la
+variante est nommée "CEKF", elle est recommandée et elle est utilisée par
+défaut), ou être conduit sans aucune contrainte (cette variante est nommée
+"EKF", et elle n'est pas recommandée).
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
.. include:: snippets/Header2Algo01.rst
Cet algorithme réalise une estimation de l'état d'un système dynamique par un
-filtre de Kalman.
+filtre de Kalman. Sous forme discrète, c'est un estimateur itératif (ou
+récursif) de l'état courant à l'aide de l'état précédent et des observations
+actuelles. Le temps (ou pseudo-temps) entre deux pas est celui qui sépare les
+observations successives. Chaque pas d'itération est composé de deux étapes
+successives dites classiquement de "*prédiction*" puis de "*correction*".
+L'étape de prédiction utilise un opérateur d'évolution incrémentale pour
+établir une estimation de l'état courant à partir de l'état estimé au pas
+précédent. L'étape de correction (ou de *mise à jour*) utilise les observations
+courantes pour améliorer l'estimation en corrigeant l'état prédit.
Il est théoriquement réservé aux cas d'opérateurs d'observation et d'évolution
incrémentale (processus) linéaires, même s'il fonctionne parfois dans les cas
"faiblement" non-linéaire. On peut vérifier la linéarité de l'opérateur
-d'observation à l'aide de l':ref:`section_ref_algorithm_LinearityTest`.
+d'observation à l'aide d'un :ref:`section_ref_algorithm_LinearityTest`.
Conceptuellement, on peut représenter le schéma temporel d'action des
opérateurs d'évolution et d'observation dans cet algorithme de la manière
-suivante, avec **x** l'état et **P** la covariance d'erreur d'état :
+suivante, avec **x** l'état, **P** la covariance d'erreur d'état, *t* le temps
+itératif discret :
.. _schema_temporel_KF:
.. image:: images/schema_temporel_KF.png
.. centered::
**Schéma temporel des étapes en assimilation de données par filtre de Kalman**
-On remarque qu'il n'y a pas d'analyse effectuée au pas de temps initial
-(numéroté 0 dans l'indexage temporel) car il n'y a pas de prévision à cet
-instant (l'ébauche est stockée comme pseudo-analyse au pas initial). Si les
-observations sont fournies en série par l'utilisateur, la première n'est donc
-pas utilisée.
-
-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_EnsembleKalmanFilter` et
-l':ref:`section_ref_algorithm_UnscentedKalmanFilter` qui sont plus puissants.
-On peut vérifier la linéarité des opérateurs à l'aide de
-l':ref:`section_ref_algorithm_LinearityTest`.
+Dans ce schéma, l'analyse **(x,P)** est obtenue à travers la "*correction*" par
+l'observation de la "*prévision*" de l'état précédent. On remarque qu'il n'y a
+pas d'analyse effectuée au pas de temps initial (numéroté 0 dans l'indexage
+temporel) car il n'y a pas de prévision à cet instant (l'ébauche est stockée
+comme pseudo-analyse au pas initial). Si les observations sont fournies en
+série par l'utilisateur, la première n'est donc pas utilisée.
+
+Ce filtre peut aussi être utilisé pour estimer (conjointement ou uniquement)
+des paramètres et non pas l'état, auquel cas ni le temps ni l'évolution n'ont
+plus de signification. Les pas d'itération sont alors liés à l'insertion d'une
+nouvelle observation dans l'estimation récursive. On consultera la section
+:ref:`section_theory_dynamique` pour les concepts de mise en oeuvre.
+
+En cas de non-linéarité des opérateurs, même peu marquée, on lui préférera un
+:ref:`section_ref_algorithm_ExtendedKalmanFilter`, ou un
+:ref:`section_ref_algorithm_EnsembleKalmanFilter` et un
+:ref:`section_ref_algorithm_UnscentedKalmanFilter` qui sont plus stables,
+supportent des bornes sur l'état, etc. On peut vérifier la linéarité des
+opérateurs à l'aide d'un :ref:`section_ref_algorithm_LinearityTest`.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
d'optimisation d'ADAO. Il est théoriquement réservé aux cas d'opérateurs
d'observation explicitement linéaires, même s'il fonctionne parfois dans les
cas "faiblement" non-linéaire. On peut vérifier la linéarité de l'opérateur
-d'observation à l'aide de l':ref:`section_ref_algorithm_LinearityTest`.
-
-Dans tous les cas, il est recommandé de lui préférer au minimum
-l':ref:`section_ref_algorithm_Blue`, voire
-l':ref:`section_ref_algorithm_ExtendedBlue` ou
-l':ref:`section_ref_algorithm_3DVAR`.
+d'observation à l'aide d'un :ref:`section_ref_algorithm_LinearityTest`.
+
+Cet algorithme est naturellement écrit pour une estimation unique, sans notion
+dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur
+d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO,
+il peut aussi être utilisé sur une succession d'observations, plaçant alors
+l'estimation dans un cadre récursif en partie similaire à un filtre de Kalman.
+Une estimation standard est effectuée à chaque pas d'observation sur l'état
+prévu par le modèle d'évolution incrémentale.
+
+Dans tous les cas, il est recommandé de lui préférer au minimum un
+:ref:`section_ref_algorithm_Blue`, voire un
+:ref:`section_ref_algorithm_ExtendedBlue` ou un
+:ref:`section_ref_algorithm_3DVAR`.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
.. math:: J(\mathbf{x})=(\mathbf{y}^o-\mathbf{H}.\mathbf{x})^T.\mathbf{R}^{-1}.(\mathbf{y}^o-\mathbf{H}.\mathbf{x})
-Il est similaire à l':ref:`section_ref_algorithm_3DVAR` privé de sa partie
+Il est similaire à un :ref:`section_ref_algorithm_3DVAR` privé de sa partie
ébauche. L'ébauche, requise dans l'interface, ne sert que de point initial pour
la minimisation variationnelle.
-Dans tous les cas, il est recommandé de lui préférer
-l':ref:`section_ref_algorithm_3DVAR` pour sa stabilité comme pour son
+Cet algorithme est naturellement écrit pour une estimation unique, sans notion
+dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur
+d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO,
+il peut aussi être utilisé sur une succession d'observations, plaçant alors
+l'estimation dans un cadre récursif en partie similaire à un filtre de Kalman.
+Une estimation standard est effectuée à chaque pas d'observation sur l'état
+prévu par le modèle d'évolution incrémentale.
+
+Dans tous les cas, il est recommandé de lui préférer un
+:ref:`section_ref_algorithm_3DVAR` pour sa stabilité comme pour son
comportement lors de l'optimisation.
.. ------------------------------------ ..
Le lecteur intéressé par le sujet de l'optimisation pourra utilement commencer
sa recherche grâce au point d'entrée [WikipediaMO]_.
+.. _section_theory_dynamique:
+
Approfondir l'assimilation de données pour la dynamique
-------------------------------------------------------
avec :math:`\mathbf{w}_{n}=[\mathbf{x}_n~~\mathbf{a}_n]^T`. Les opérateurs
d'évolution incrémentale et d'observation sont donc respectivement les
opérateurs augmentés :math:`\tilde{M}` et :math:`\tilde{H}`, et sont
-directement utilisables en assimilation de données avec ADAO.
+directement utilisables dans les cas d'études avec ADAO.
Schéma conceptuel pour l'assimilation de données en dynamique
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Pour compléter la description, on peut représenter la démarche d'assimilation
de données de manière spécifiquement dynamique à l'aide d'un schéma temporel,
qui décrit l'action des opérateurs d'évolution (:math:`M` ou :math:`\tilde{M}`)
-et d'observation (:math:`H` ou :math:`\tilde{H}`) lors de la simulation
-discrète. Une représentation possible est la suivante :
+et d'observation (:math:`H` ou :math:`\tilde{H}`) lors de la simulation et
+l'estimation récursive discrète de l'état (:math:`\mathbf{x}`). Une
+représentation simple est la suivante, particulièrement adaptée aux algorithmes
+itératifs de filtrage de type Kalman :
.. _schema_d_AD_temporel:
.. image:: images/schema_temporel_KF.png
.. centered::
**Schéma d'action des opérateurs pour l'assimilation de données en dynamique**
-Les concepts décrits dans ce schéma peuvent directement et simplement être
-utilisés dans ADAO.
+avec **P** la covariance d'erreur d'état et *t* le temps itératif discret. Dans
+ce schéma, l'analyse **(x,P)** est obtenue à travers la "*correction*" par
+l'observation de la "*prévision*" de l'état précédent. Les concepts décrits
+dans ce schéma peuvent directement et simplement être utilisés dans ADAO pour
+construire des cas d'études, et sont repris dans la description de certains
+algorithmes.
