From: Jean-Philippe ARGAUD Date: Fri, 20 Mar 2020 17:22:12 +0000 (+0100) Subject: Minor documentation improvements X-Git-Tag: V9_5_0a2 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=490b82a7e1216496d8369d91a8bfc02e1ff4f69f;p=modules%2Fadao.git Minor documentation improvements --- diff --git a/doc/en/ref_algorithm_EnsembleKalmanFilter.rst b/doc/en/ref_algorithm_EnsembleKalmanFilter.rst index f496720..8d9b951 100644 --- a/doc/en/ref_algorithm_EnsembleKalmanFilter.rst +++ b/doc/en/ref_algorithm_EnsembleKalmanFilter.rst @@ -40,6 +40,12 @@ operators with excellent robustness and performance qualities. It can be 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 diff --git a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst index 1ce1918..57d4f20 100644 --- a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst @@ -35,8 +35,9 @@ extended Kalman Filter, using a non-linear calculation of the state and the 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 @@ -45,6 +46,12 @@ and **M** the evolution operator : .. 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 diff --git a/doc/en/ref_algorithm_KalmanFilter.rst b/doc/en/ref_algorithm_KalmanFilter.rst index 895d37b..baa281f 100644 --- a/doc/en/ref_algorithm_KalmanFilter.rst +++ b/doc/en/ref_algorithm_KalmanFilter.rst @@ -39,8 +39,9 @@ cases. One can verify the linearity of the operators with the help of 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 @@ -49,10 +50,18 @@ and **M** the evolution operator : .. 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 diff --git a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst index 7f2c803..7d386c6 100644 --- a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst @@ -40,6 +40,12 @@ operators with excellent robustness and performance qualities. It can be 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 diff --git a/doc/en/snippets/Header2Algo09.rst b/doc/en/snippets/Header2Algo09.rst new file mode 100644 index 0000000..ca18551 --- /dev/null +++ b/doc/en/snippets/Header2Algo09.rst @@ -0,0 +1,4 @@ +Python (TUI) use example +++++++++++++++++++++++++ + +Here is a very simple use of the algorithm, written in :ref:`section_tui`. diff --git a/doc/en/snippets/Header2Algo10.rst b/doc/en/snippets/Header2Algo10.rst new file mode 100644 index 0000000..f356c43 --- /dev/null +++ b/doc/en/snippets/Header2Algo10.rst @@ -0,0 +1 @@ +The execution result is the following: diff --git a/doc/fr/ref_algorithm_EnsembleKalmanFilter.rst b/doc/fr/ref_algorithm_EnsembleKalmanFilter.rst index 6228fe3..61cd540 100644 --- a/doc/fr/ref_algorithm_EnsembleKalmanFilter.rst +++ b/doc/fr/ref_algorithm_EnsembleKalmanFilter.rst @@ -37,10 +37,16 @@ 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é à +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 diff --git a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst index 1d43ec2..38accd4 100644 --- a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst @@ -35,8 +35,9 @@ filtre de Kalman étendu, utilisant un calcul non linéaire de l'état et de 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 @@ -45,6 +46,12 @@ d'observation et **M** l'opérateur d'évolution : .. 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 diff --git a/doc/fr/ref_algorithm_KalmanFilter.rst b/doc/fr/ref_algorithm_KalmanFilter.rst index 024e3bc..55e48e6 100644 --- a/doc/fr/ref_algorithm_KalmanFilter.rst +++ b/doc/fr/ref_algorithm_KalmanFilter.rst @@ -39,8 +39,9 @@ incrémentale (processus) linéaires, même s'il fonctionne parfois dans les cas 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 @@ -49,10 +50,18 @@ d'observation et **M** l'opérateur d'évolution : .. 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 diff --git a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst index 1c28efe..bf87d6d 100644 --- a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst @@ -37,10 +37,16 @@ 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é à +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 diff --git a/doc/fr/snippets/Header2Algo09.rst b/doc/fr/snippets/Header2Algo09.rst new file mode 100644 index 0000000..5a8efd2 --- /dev/null +++ b/doc/fr/snippets/Header2Algo09.rst @@ -0,0 +1,5 @@ +Exemple d'utilisation en Python (TUI) ++++++++++++++++++++++++++++++++++++++ + +Voici un exemple très simple d'usage de l'algorithme, écrit en +:ref:`section_tui`. diff --git a/doc/fr/snippets/Header2Algo10.rst b/doc/fr/snippets/Header2Algo10.rst new file mode 100644 index 0000000..fa2e468 --- /dev/null +++ b/doc/fr/snippets/Header2Algo10.rst @@ -0,0 +1 @@ +Le résultat de son exécution est le suivant :