(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.
+each physical model, making the method not robust. For these reasons, this
+method is not proposed nor recommended.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This algorithm allows to verify that a given operator :math:`F`, in particular
-the observation one, is working correctly and that its call is compatible with
-its usage in ADAO algorithms. In practice, it allows to call one or several
-times the operator, activating or not the "debug" mode during execution. The
-:math:`F` operator is considered to depend on a state vector variable
-:math:`\mathbf{x}` and on a control vector variable :math:`\mathbf{u}`, the two
-not necessarily being of the same size.
-
-Statistics on input and output vectors for each execution of operator are
-given, and an another global statistic is given at the end of the checking
-algorithm. The precision of printed outputs can be controlled to facilitate
-automatic tests of operator. It may also be useful to check the entries
-themselves beforehand with the intended test
+This verification algorithm allows to analyze in a simple way the stability of
+an operator :math:`F` during its execution. The operator is any operator, so it
+can be the observation operator :math:`\mathcal{H}` as well as the evolution
+operator :math:`\mathcal{D}`, as long as it is provided in each case according
+to the :ref:`section_ref_operator_requirements`. The operator :math:`F` is
+considered as depending on a vector variable :math:`\mathbf{x}` and on a
+control vector variable :math:`\mathbf{u}`, the two not necessarily being of
+the same size, and returning another vector variable :math:`\mathbf{y}`.
+
+The algorithm verifies that the operator is working correctly and that its call
+is compatible with its usage in ADAO algorithms. In practice, it allows to call
+one or several times the operator, activating or not the "debug" mode during
+execution.
+
+Statistics on :math:`\mathbf{x}` input and :math:`\mathbf{y}` output vectors
+are given for each execution of operator, and an another global statistic is
+given at the end. The precision of printed outputs can be controlled to
+facilitate automatic tests of operator. It may also be useful to check the
+entries themselves beforehand with the intended test
:ref:`section_ref_algorithm_InputValuesTest`.
.. ------------------------------------ ..
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This algorithm allows to verify that a given operator :math:`F`, in particular
-the observation one, is working correctly and that its call is compatible with
-its usage in ADAO algorithms. In practice, it allows to call one or several
-times the operator, activating or not the "debug" mode during execution. The
-:math:`F` operator is considered to depend on the vector variable
-:math:`\mathbf{x}`.
-
-Statistics on input and output vectors for each execution of operator are
-given, and an another global statistic is given at the end of the checking
-algorithm. The precision of printed outputs can be controlled to facilitate
-automatic tests of operator. It may also be useful to check the entries
-themselves beforehand with the intended test
+This verification algorithm allows to analyze in a simple way the stability of
+an operator :math:`F` during its execution. The operator is any operator, so it
+can be the observation operator :math:`\mathcal{H}` as well as the evolution
+operator :math:`\mathcal{D}`, as long as it is provided in each case according
+to the :ref:`section_ref_operator_requirements`. The operator :math:`F` is
+considered as depending on a vector variable :math:`\mathbf{x}` and returning
+another vector variable :math:`\mathbf{y}`.
+
+The algorithm verifies that the operator is working correctly and that its call
+is compatible with its usage in ADAO algorithms. In practice, it allows to call
+one or several times the operator, activating or not the "debug" mode during
+execution.
+
+Statistics on :math:`\mathbf{x}` input and :math:`\mathbf{y}` output vectors
+are given for each execution of operator, and an another global statistic is
+given at the end. The precision of printed outputs can be controlled to
+facilitate automatic tests of operator. It may also be useful to check the
+entries themselves beforehand with the intended test
:ref:`section_ref_algorithm_InputValuesTest`.
.. ------------------------------------ ..
- :ref:`section_ref_algorithm_ControledFunctionTest`
- :ref:`section_ref_algorithm_ParallelFunctionTest`
- :ref:`section_ref_algorithm_EnsembleOfSimulationGenerationTask`
+- :ref:`section_ref_algorithm_ObservationSimulationComparisonTest`
--- /dev/null
+..
+ Copyright (C) 2008-2023 EDF R&D
+
+ This file is part of SALOME ADAO module.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+ Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
+
+.. index:: single: ObservationSimulationComparisonTest
+.. _section_ref_algorithm_ObservationSimulationComparisonTest:
+
+Checking algorithm "*ObservationSimulationComparisonTest*"
+----------------------------------------------------------
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo01.rst
+
+This verification algorithm allows to analyze in a simple way the stability of
+the difference between measures and an operator :math:`F` during its execution.
+The operator is any operator, so it can be the observation operator
+:math:`\mathcal{H}` as well as the evolution operator :math:`\mathcal{D}`, as
+long as it is provided in each case according to the
+:ref:`section_ref_operator_requirements`. The operator :math:`F` is considered
+as depending on a vector variable :math:`\mathbf{x}` and returning another
+vector variable :math:`\mathbf{y}`.
+
+The algorithm verifies that the difference is stable, that the operator is
+working correctly and that its call is compatible with its usage in ADAO
+algorithms. In practice, it allows to call one or several times the operator,
+activating or not the "debug" mode during execution. It is very similar in its
+current behavior to a :ref:`section_ref_algorithm_FunctionTest` but it tests
+the stability of the measurement-calculation difference.
+
+Statistics on :math:`\mathbf{x}` input and :math:`\mathbf{y}` output vectors,
+and potentially on the classical data assimilation error function :math:`J`,
+are given for each execution of operator, and an another global statistic is
+given at the end. The precision of printed outputs can be controlled to
+facilitate automatic tests of operator. It may also be useful to check the
+entries themselves beforehand with the intended test
+:ref:`section_ref_algorithm_InputValuesTest`.
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo02.rst
+
+.. include:: snippets/CheckingPoint.rst
+
+.. include:: snippets/BackgroundError.rst
+
+.. include:: snippets/Observation.rst
+
+.. include:: snippets/ObservationError.rst
+
+.. include:: snippets/ObservationOperator.rst
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo03Chck.rst
+
+.. include:: snippets/NumberOfPrintedDigits.rst
+
+.. include:: snippets/NumberOfRepetition.rst
+
+.. include:: snippets/SetDebug.rst
+
+.. include:: snippets/ShowElementarySummary.rst
+
+StoreSupplementaryCalculations
+ .. index:: single: StoreSupplementaryCalculations
+
+ *List of names*. This list indicates the names of the supplementary
+ variables, that can be available during or at the end of the algorithm, if
+ they are initially required by the user. Their avalability involves,
+ potentially, costly calculations or memory consumptions. The default is then
+ a void list, none of these variables being calculated and stored by default
+ (excepted the unconditionnal variables). The possible names are in the
+ following list (the detailed description of each named variable is given in
+ the following part of this specific algorithmic documentation, in the
+ sub-section "*Information and variables available at the end of the
+ algorithm*"): [
+ "CostFunctionJ",
+ "CostFunctionJb",
+ "CostFunctionJo",
+ "CurrentState",
+ "Innovation",
+ "InnovationAtCurrentState",
+ "SimulatedObservationAtCurrentState",
+ ].
+
+ Example :
+ ``{"StoreSupplementaryCalculations":["CurrentState", "Residu"]}``
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo04.rst
+
+.. include:: snippets/NoUnconditionalOutput.rst
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo05.rst
+
+.. include:: snippets/CostFunctionJ.rst
+
+.. include:: snippets/CostFunctionJb.rst
+
+.. include:: snippets/CostFunctionJo.rst
+
+.. include:: snippets/CurrentState.rst
+
+.. include:: snippets/Innovation.rst
+
+.. include:: snippets/InnovationAtCurrentState.rst
+
+.. include:: snippets/SimulatedObservationAtCurrentState.rst
+
+.. ------------------------------------ ..
+.. _section_ref_algorithm_ObservationSimulationComparisonTest_examples:
+
+.. include:: snippets/Header2Algo06.rst
+
+- :ref:`section_ref_algorithm_FunctionTest`
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This algorithm allows to verify that an operator, in particular the
-observation one, is working correctly in parallel and that its call is
-compatible with its usage in ADAO algorithms. In practice, it allows to
-call one or several times the operator in parallel, activating or not
-the "debug" mode during execution.
-
-Statistics on input and output vectors for each execution of operator are
-given, and an another global statistic is given at the end of the checking
-algorithm. The precision of printed outputs can be controlled to facilitate
-automatic tests of operator. It may also be useful to check the entries
-themselves beforehand with the intended test
+This verification algorithm allows to analyze in a simple way the stability of
+an operator :math:`F` during its execution in parallel. The operator is any
+operator, so it can be the observation operator :math:`\mathcal{H}` as well as
+the evolution operator :math:`\mathcal{D}`, as long as it is provided in each
+case according to the :ref:`section_ref_operator_requirements`. The operator
+:math:`F` is considered as depending on a vector variable :math:`\mathbf{x}`
+and returning another vector variable :math:`\mathbf{y}`.
+
+The algorithm verifies that the operator is working correctly and that its call
+is compatible with its usage in ADAO algorithms. In practice, it allows to call
+one or several times the operator, activating or not the "debug" mode during
+execution.
+
+Statistics on :math:`\mathbf{x}` input and :math:`\mathbf{y}` output vectors
+are given for each execution of operator, and an another global statistic is
+given at the end. The precision of printed outputs can be controlled to
+facilitate automatic tests of operator. It may also be useful to check the
+entries themselves beforehand with the intended test
:ref:`section_ref_algorithm_InputValuesTest`.
.. ------------------------------------ ..
ref_algorithm_InputValuesTest
ref_algorithm_LinearityTest
ref_algorithm_LocalSensitivityTest
+ ref_algorithm_ObservationSimulationComparisonTest
ref_algorithm_ObserverTest
ref_algorithm_ParallelFunctionTest
ref_algorithm_SamplingTest
systematically performed on all intermediate versions. For all tested versions,
the ADAO module behaves identically (to the extent of modifications depending
on the support tools). It is strongly discouraged (or impossible) to use ADAO
-with a version lower than the minimum version, and there is no limitation to
-the use of the ADAO module beyond the reached version (but this remains without
-guarantee).
+with a version lower than the minimum version, and there is no explicit
+limitation to the use of the ADAO module beyond the reached version but this
+remains without guarantee. If an unusual error is encountered for previously
+running calculations, it is strongly recommended to revert to supporting tool
+versions within the range described below.
.. csv-table:: Support tool verification intervals for ADAO
:header: "Tool", "Minimal version", "Reached version"
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
-la méthode à chaque modèle physique. Pour ces raisons, cette méthode n'est donc
-pas proposée.
+la méthode à chaque modèle physique, la rendant non robuste. Pour ces raisons,
+cette méthode n'est donc pas proposée.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme permet de vérifier qu'un opérateur :math:`F` quelconque, dont en
-particulier celui d'observation, fonctionne correctement et que son appel se
-déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De
-manière pratique, il permet d'appeler une ou plusieurs fois l'opérateur, en
-activant ou non le mode "debug" lors de l'exécution. L'opérateur :math:`F` est
+Cet algorithme de vérification permet d'analyser de manière simple la stabilité
+d'un opérateur :math:`F` lors de son exécution. L'opérateur est quelconque, et
+il peut donc être celui d'observation :math:`\mathcal{H}` comme celui
+d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon
+les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est
considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et d'un
contrôle :math:`\mathbf{u}`, les deux n'étant pas nécessairement de la même
-taille.
-
-Une statistique sur les vecteurs en entrée et en sortie de chaque exécution de
-l'opérateur est indiquée, et une autre globale est fournie de manière
-récapitulative à la fin de l'algorithme de vérification. La précision
-d'affichage est contrôlable pour permettre l'automatisation des tests
-d'opérateur. Il peut être aussi utile de vérifier préalablement les entrées
-elles-mêmes avec le test prévu :ref:`section_ref_algorithm_InputValuesTest`.
+taille, et restituant une autre variable vectorielle :math:`\mathbf{y}`.
+
+L'algorithme vérifie que l'opérateur fonctionne correctement et que son appel
+se déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De
+manière pratique, il permet d'appeler une ou plusieurs fois l'opérateur, en
+activant ou non le mode "debug" lors de l'exécution.
+
+Une statistique sur les vecteurs :math:`\mathbf{x}` en entrée et
+:math:`\mathbf{y}` en sortie est indiquée lors de chaque exécution de
+l'opérateur, et une autre statistique globale est fournie de manière
+récapitulative à la fin. La précision d'affichage est contrôlable pour
+permettre l'automatisation des tests d'opérateur. Il peut être aussi utile de
+vérifier préalablement les entrées elles-mêmes avec le test prévu
+:ref:`section_ref_algorithm_InputValuesTest`.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme permet de vérifier qu'un opérateur :math:`F` quelconque, dont en
-particulier celui d'observation, fonctionne correctement et que son appel se
-déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De
+Cet algorithme de vérification permet d'analyser de manière simple la stabilité
+d'un opérateur :math:`F` lors de son exécution. L'opérateur est quelconque, et
+il peut donc être celui d'observation :math:`\mathcal{H}` comme celui
+d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon
+les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est
+considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et
+restituant une autre variable vectorielle :math:`\mathbf{y}`.
+
+L'algorithme vérifie que l'opérateur fonctionne correctement et que son appel
+se déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De
manière pratique, il permet d'appeler une ou plusieurs fois l'opérateur, en
-activant ou non le mode "debug" lors de l'exécution. L'opérateur :math:`F` est
-considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}`.
+activant ou non le mode "debug" lors de l'exécution.
-Une statistique sur les vecteurs en entrée et en sortie de chaque exécution de
-l'opérateur est indiquée, et une autre globale est fournie de manière
-récapitulative à la fin de l'algorithme de vérification. La précision
-d'affichage est contrôlable pour permettre l'automatisation des tests
-d'opérateur. Il peut être aussi utile de vérifier préalablement les entrées
-elles-mêmes avec le test prévu :ref:`section_ref_algorithm_InputValuesTest`.
+Une statistique sur les vecteurs :math:`\mathbf{x}` en entrée et
+:math:`\mathbf{y}` en sortie est indiquée lors de chaque exécution de
+l'opérateur, et une autre statistique globale est fournie de manière
+récapitulative à la fin. La précision d'affichage est contrôlable pour
+permettre l'automatisation des tests d'opérateur. Il peut être aussi utile de
+vérifier préalablement les entrées elles-mêmes avec le test prévu
+:ref:`section_ref_algorithm_InputValuesTest`.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
- :ref:`section_ref_algorithm_ControledFunctionTest`
- :ref:`section_ref_algorithm_ParallelFunctionTest`
- :ref:`section_ref_algorithm_EnsembleOfSimulationGenerationTask`
+- :ref:`section_ref_algorithm_ObservationSimulationComparisonTest`
--- /dev/null
+..
+ Copyright (C) 2008-2023 EDF R&D
+
+ This file is part of SALOME ADAO module.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+ Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
+
+.. index:: single: ObservationSimulationComparisonTest
+.. _section_ref_algorithm_ObservationSimulationComparisonTest:
+
+Algorithme de vérification "*ObservationSimulationComparisonTest*"
+------------------------------------------------------------------
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo01.rst
+
+Cet algorithme de vérification permet d'analyser de manière simple la stabilité
+de l'écart entre des mesures et le calcul d'un opérateur :math:`F`, lors de son
+exécution. L'opérateur est quelconque, et il peut donc être celui d'observation
+:math:`\mathcal{H}` comme celui d'évolution :math:`\mathcal{D}`, pourvu qu'il
+soit fourni dans chaque cas selon les :ref:`section_ref_operator_requirements`.
+L'opérateur :math:`F` est considéré comme dépendant d'une variable vectorielle
+:math:`\mathbf{x}` et restituant une autre variable vectorielle
+:math:`\mathbf{y}`.
+
+L'algorithme vérifie que l'écart est stable, que l'opérateur fonctionne
+correctement et que son appel se déroule de manière compatible avec son usage
+dans les algorithmes d'ADAO. De manière pratique, il permet d'appeler une ou
+plusieurs fois l'opérateur, en activant ou non le mode "debug" lors de
+l'exécution. Il est très similaire dans son fonctionnement courant à un
+:ref:`section_ref_algorithm_FunctionTest` mais il teste la stabilité de l'écart
+mesures-calculs.
+
+Une statistique sur les vecteurs :math:`\mathbf{x}` en entrée et
+:math:`\mathbf{y}` en sortie, et potentiellement sur la fonctionnelle d'erreur
+standard d'assimilation de données :math:`J`, est indiquée lors de chaque
+exécution de l'opérateur, et une autre statistique globale est fournie de
+manière récapitulative à la fin. La précision d'affichage est contrôlable pour
+permettre l'automatisation des tests d'opérateur. Il peut être aussi utile de
+vérifier préalablement les entrées elles-mêmes avec le test prévu
+:ref:`section_ref_algorithm_InputValuesTest`.
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo02.rst
+
+.. include:: snippets/CheckingPoint.rst
+
+.. include:: snippets/BackgroundError.rst
+
+.. include:: snippets/Observation.rst
+
+.. include:: snippets/ObservationError.rst
+
+.. include:: snippets/ObservationOperator.rst
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo03Chck.rst
+
+.. include:: snippets/NumberOfPrintedDigits.rst
+
+.. include:: snippets/NumberOfRepetition.rst
+
+.. include:: snippets/SetDebug.rst
+
+.. include:: snippets/ShowElementarySummary.rst
+
+StoreSupplementaryCalculations
+ .. index:: single: StoreSupplementaryCalculations
+
+ *Liste de noms*. Cette liste indique les noms des variables supplémentaires,
+ qui peuvent être disponibles au cours du déroulement ou à la fin de
+ l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur
+ disponibilité implique, potentiellement, des calculs ou du stockage coûteux.
+ La valeur par défaut est donc une liste vide, aucune de ces variables n'étant
+ calculée et stockée par défaut (sauf les variables inconditionnelles). Les
+ noms possibles pour les variables supplémentaires sont dans la liste suivante
+ (la description détaillée de chaque variable nommée est donnée dans la suite
+ de cette documentation par algorithme spécifique, dans la sous-partie
+ "*Informations et variables disponibles à la fin de l'algorithme*") : [
+ "CostFunctionJ",
+ "CostFunctionJb",
+ "CostFunctionJo",
+ "CurrentState",
+ "Innovation",
+ "InnovationAtCurrentState",
+ "SimulatedObservationAtCurrentState",
+ ].
+
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["CurrentState", "Residu"]}``
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo04.rst
+
+.. include:: snippets/NoUnconditionalOutput.rst
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo05.rst
+
+.. include:: snippets/CostFunctionJ.rst
+
+.. include:: snippets/CostFunctionJb.rst
+
+.. include:: snippets/CostFunctionJo.rst
+
+.. include:: snippets/CurrentState.rst
+
+.. include:: snippets/Innovation.rst
+
+.. include:: snippets/InnovationAtCurrentState.rst
+
+.. include:: snippets/SimulatedObservationAtCurrentState.rst
+
+.. ------------------------------------ ..
+.. _section_ref_algorithm_ObservationSimulationComparisonTest_examples:
+
+.. include:: snippets/Header2Algo06.rst
+
+- :ref:`section_ref_algorithm_FunctionTest`
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme permet de vérifier qu'un opérateur :math:`F` quelconque, dont en
-particulier celui d'observation, fonctionne correctement en parallèle et que
-son appel se déroule de manière compatible avec son usage dans les algorithmes
-d'ADAO. De manière pratique, il permet d'appeler une ou plusieurs fois
-l'opérateur en parallèle, en activant ou non le mode "debug" lors de
-l'exécution.
-
-Une statistique sur les vecteurs en entrée et en sortie de chaque exécution de
-l'opérateur est indiquée, et une autre globale est fournie de manière
-récapitulative à la fin de l'algorithme de vérification. La précision
-d'affichage est contrôlable pour permettre l'automatisation des tests
-d'opérateur. Il peut être aussi utile de vérifier préalablement les entrées
-elles-mêmes avec le test prévu :ref:`section_ref_algorithm_InputValuesTest`.
+Cet algorithme de vérification permet d'analyser de manière simple la stabilité
+d'un opérateur :math:`F` lors de son exécution en parallèle. L'opérateur est
+quelconque, et il peut donc être celui d'observation :math:`\mathcal{H}` comme
+celui d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas
+selon les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est
+considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et
+restituant une autre variable vectorielle :math:`\mathbf{y}`.
+
+L'algorithme vérifie que l'opérateur fonctionne correctement et que son appel
+se déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De
+manière pratique, il permet d'appeler une ou plusieurs fois l'opérateur, en
+activant ou non le mode "debug" lors de l'exécution.
+
+Une statistique sur les vecteurs :math:`\mathbf{x}` en entrée et
+:math:`\mathbf{y}` en sortie est indiquée lors de chaque exécution de
+l'opérateur, et une autre statistique globale est fournie de manière
+récapitulative à la fin. La précision d'affichage est contrôlable pour
+permettre l'automatisation des tests d'opérateur. Il peut être aussi utile de
+vérifier préalablement les entrées elles-mêmes avec le test prévu
+:ref:`section_ref_algorithm_InputValuesTest`.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
ref_algorithm_InputValuesTest
ref_algorithm_LinearityTest
ref_algorithm_LocalSensitivityTest
+ ref_algorithm_ObservationSimulationComparisonTest
ref_algorithm_ObserverTest
ref_algorithm_ParallelFunctionTest
ref_algorithm_SamplingTest
testées, le module ADAO se comporte de manière identique (dans la mesure de
modifications dépendant des outils support). Il est fortement déconseillé (ou
impossible) d'utiliser ADAO avec une version inférieure à la version minimale,
-et il n'y a pas de limitation à l'utilisation du module ADAO au-delà au-delà de
-la version atteinte (mais cela reste sans garantie).
+et il n'y a pas de limitation explicite à l'utilisation du module ADAO au-delà
+au-delà de la version atteinte mais cela reste sans garantie. Si une erreur
+inhabituelle est rencontrée pour des calculs fonctionnant précédemment, il est
+fortement conseillé de revenir à des versions d'outils supports comprises dans
+l'étendue décrite ci-dessous.
.. csv-table:: Intervalles de vérification des outils support pour ADAO
:header: "Outil", "Version minimale", "Version atteinte"
Js.append( J )
msgs += ("\n")
msgs += (__marge + " Cost function J....: %."+str(__p)+"e\n")%J
- msgs += (__marge + " Cost function Jb=0.: %."+str(__p)+"e\n")%Jb
+ msgs += (__marge + " Cost function Jb...: %."+str(__p)+"e\n")%Jb
msgs += (__marge + " Cost function Jo...: %."+str(__p)+"e\n")%Jo
print(msgs) # 2-2
if self._toStore("SimulatedObservationAtCurrentState"):
msgs += (__marge + "%s\n\n"%("-"*75,))
msgs += (__marge + "Number of evaluations...........................: %i\n")%len( Js )
msgs += ("\n")
- msgs += (__marge + "Characteristics of the whole set of cost function J values:\n")
+ msgs += (__marge + "Characteristics of the whole set of data assimilation cost function J values:\n")
msgs += (__marge + " Minimum value of the whole set of J...........: %."+str(__p)+"e\n")%numpy.min( Jj )
msgs += (__marge + " Maximum value of the whole set of J...........: %."+str(__p)+"e\n")%numpy.max( Jj )
msgs += (__marge + " Mean of vector of the whole set of J..........: %."+str(__p)+"e\n")%numpy.mean( Jj, dtype=mfp )
msgs += (__marge + " Standard error of the whole set of J..........: %."+str(__p)+"e\n")%numpy.std( Jj, dtype=mfp )
+ msgs += (__marge + " (Remark: variations of the cost function J only come from the observation part Jo of J)\n")
msgs += ("\n")
msgs += (__marge + "%s\n"%("-"*75,))
#
