compared to the :ref:`section_ref_algorithm_UnscentedKalmanFilter`, whose
qualities are similar for non-linear systems.
+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 linear of "slightly" non-linear operators, one can easily use the
:ref:`section_ref_algorithm_ExtendedKalmanFilter` or even the
:ref:`section_ref_algorithm_KalmanFilter`, which are often far less expensive
incremental evolution (process).
Conceptually, we can represent the temporal pattern of action of the operators
-for this algorithm in the following way, with **H** the observation operator
-and **M** the evolution operator :
+for this algorithm in the following way, with **x** the state, **P** the state
+error covariance, **H** the observation operator and **M** the evolution
+operator :
.. _schema_temporel_KF:
.. image:: images/schema_temporel_KF.png
.. centered::
**Timeline of steps in Kalman filter 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
:ref:`section_ref_algorithm_UnscentedKalmanFilter`, which are often far more
the :ref:`section_ref_algorithm_LinearityTest`.
Conceptually, we can represent the temporal pattern of action of the operators
-for this algorithm in the following way, with **H** the observation operator
-and **M** the evolution operator :
+for this algorithm in the following way, with **x** the state, **P** the state
+error covariance, **H** the observation operator and **M** the evolution
+operator :
.. _schema_temporel_KF:
.. image:: images/schema_temporel_KF.png
.. centered::
**Timeline of steps in Kalman filter 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
-:ref:`section_ref_algorithm_UnscentedKalmanFilter` that are more powerful.
+: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`.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
compared to the :ref:`section_ref_algorithm_EnsembleKalmanFilter`, whose
qualities are similar for non-linear systems.
+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 linear of "slightly" non-linear operators, one can easily use the
:ref:`section_ref_algorithm_ExtendedKalmanFilter` or even the
:ref:`section_ref_algorithm_KalmanFilter`, which are often far less expensive
--- /dev/null
+Python (TUI) use example
+++++++++++++++++++++++++
+
+Here is a very simple use of the algorithm, written in :ref:`section_tui`.
--- /dev/null
+The execution result is the following:
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é à
+de performances. Il peut être rapproché de
l':ref:`section_ref_algorithm_UnscentedKalmanFilter` dont les qualités sont
similaires pour les systèmes non-linéaires.
+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 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
l'évolution incrémentale (processus).
Conceptuellement, on peut représenter le schéma temporel d'action des
-opérateurs pour cet algorithme de la manière suivante, avec **H** l'opérateur
-d'observation et **M** l'opérateur d'évolution :
+opérateurs de cet algorithme de la manière suivante, avec **x** l'état, **P**
+la covariance d'erreur d'état, **H** l'opérateur d'observation et **M**
+l'opérateur d'évolution :
.. _schema_temporel_KF:
.. image:: images/schema_temporel_KF.png
.. centered::
**Schéma temporel des étapes en assimilation 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.
+
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
d'observation à l'aide de l':ref:`section_ref_algorithm_LinearityTest`.
Conceptuellement, on peut représenter le schéma temporel d'action des
-opérateurs pour cet algorithme de la manière suivante, avec **H** l'opérateur
-d'observation et **M** l'opérateur d'évolution :
+opérateurs de cet algorithme de la manière suivante, avec **x** l'état, **P**
+la covariance d'erreur d'état, **H** l'opérateur d'observation et **M**
+l'opérateur d'évolution :
.. _schema_temporel_KF:
.. image:: images/schema_temporel_KF.png
.. centered::
**Schéma temporel des étapes en assimilation 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`.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
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é à
+de performances. Il peut être rapproché de
l':ref:`section_ref_algorithm_EnsembleKalmanFilter`, dont les qualités sont
similaires pour les systèmes non-linéaires.
+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 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
--- /dev/null
+Exemple d'utilisation en Python (TUI)
++++++++++++++++++++++++++++++++++++++
+
+Voici un exemple très simple d'usage de l'algorithme, écrit en
+:ref:`section_tui`.
--- /dev/null
+Le résultat de son exécution est le suivant :
