.. index:: single: EpsilonMinimumExponent
.. index:: single: InitialDirection
.. index:: single: SetSeed
+.. index:: single: StoreSupplementaryCalculations
The general required commands, available in the editing user interface, are the
following:
Example : ``{"SetSeed":1000}``
+ StoreSupplementaryCalculations
+ This list indicates the names of the supplementary variables that can be
+ available at the end of the algorithm. It involves potentially costly
+ calculations or memory consumptions. The default is a void list, none of
+ these variables being calculated and stored by default. The possible names
+ are in the following list: ["CurrentState", "Residu",
+ "SimulatedObservationAtCurrentState"].
+
+ Example : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Information and variables available at the end of the algorithm
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+At the output, after executing the algorithm, there are variables and
+information originating from the calculation. The description of
+:ref:`section_ref_output_variables` show the way to obtain them by the method
+named ``get`` of the variable "*ADD*" of the post-processing. The input
+variables, available to the user at the output in order to facilitate the
+writing of post-processing procedures, are described in the
+:ref:`subsection_r_o_v_Inventaire`.
+
+The unconditional outputs of the algorithm are the following:
+
+ Residu
+ *List of values*. Each element is the value of the particular residu
+ verified during a checking algorithm, in the order of the tests.
+
+ Example : ``r = ADD.get("Residu")[:]``
+
+The conditional outputs of the algorithm are the following:
+
+ CurrentState
+ *List of vectors*. Each element is a usual state vector used during the
+ optimization algorithm procedure.
+
+ Example : ``Xs = ADD.get("CurrentState")[:]``
+
+ SimulatedObservationAtCurrentState
+ *List of vectors*. Each element is an observed vector at the current state,
+ that is, in the observation space.
+
+ Example : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
See also
++++++++
References to other sections:
- :ref:`section_ref_algorithm_FunctionTest`
+ - :ref:`section_ref_algorithm_LinearityTest`
- :ref:`section_ref_algorithm_TangentTest`
- :ref:`section_ref_algorithm_GradientTest`
.. index:: single: NumberOfPrintedDigits
.. index:: single: NumberOfRepetition
.. index:: single: SetDebug
+.. index:: single: StoreSupplementaryCalculations
The general required commands, available in the editing user interface, are the
following:
Example : ``{"SetDebug":False}``
+ StoreSupplementaryCalculations
+ This list indicates the names of the supplementary variables that can be
+ available at the end of the algorithm. It involves potentially costly
+ calculations or memory consumptions. The default is a void list, none of
+ these variables being calculated and stored by default. The possible names
+ are in the following list: ["CurrentState",
+ "SimulatedObservationAtCurrentState"].
+
+ Example : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Information and variables available at the end of the algorithm
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+At the output, after executing the algorithm, there are variables and
+information originating from the calculation. The description of
+:ref:`section_ref_output_variables` show the way to obtain them by the method
+named ``get`` of the variable "*ADD*" of the post-processing. The input
+variables, available to the user at the output in order to facilitate the
+writing of post-processing procedures, are described in the
+:ref:`subsection_r_o_v_Inventaire`.
+
+The conditional outputs of the algorithm are the following:
+
+ CurrentState
+ *List of vectors*. Each element is a usual state vector used during the
+ optimization algorithm procedure.
+
+ Example : ``Xs = ADD.get("CurrentState")[:]``
+
+ SimulatedObservationAtCurrentState
+ *List of vectors*. Each element is an observed vector at the current state,
+ that is, in the observation space.
+
+ Example : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
See also
++++++++
.. index:: single: InitialDirection
.. index:: single: ResiduFormula
.. index:: single: SetSeed
+.. index:: single: StoreSupplementaryCalculations
The general required commands, available in the editing user interface, are the
following:
Example : ``{"SetSeed":1000}``
+ StoreSupplementaryCalculations
+ This list indicates the names of the supplementary variables that can be
+ available at the end of the algorithm. It involves potentially costly
+ calculations or memory consumptions. The default is a void list, none of
+ these variables being calculated and stored by default. The possible names
+ are in the following list: ["CurrentState", "Residu",
+ "SimulatedObservationAtCurrentState"].
+
+ Example : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Information and variables available at the end of the algorithm
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+At the output, after executing the algorithm, there are variables and
+information originating from the calculation. The description of
+:ref:`section_ref_output_variables` show the way to obtain them by the method
+named ``get`` of the variable "*ADD*" of the post-processing. The input
+variables, available to the user at the output in order to facilitate the
+writing of post-processing procedures, are described in the
+:ref:`subsection_r_o_v_Inventaire`.
+
+The unconditional outputs of the algorithm are the following:
+
+ Residu
+ *List of values*. Each element is the value of the particular residu
+ verified during a checking algorithm, in the order of the tests.
+
+ Example : ``r = ADD.get("Residu")[:]``
+
+The conditional outputs of the algorithm are the following:
+
+ CurrentState
+ *List of vectors*. Each element is a usual state vector used during the
+ optimization algorithm procedure.
+
+ Example : ``Xs = ADD.get("CurrentState")[:]``
+
+ SimulatedObservationAtCurrentState
+ *List of vectors*. Each element is an observed vector at the current state,
+ that is, in the observation space.
+
+ Example : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
See also
++++++++
References to other sections:
- :ref:`section_ref_algorithm_FunctionTest`
+ - :ref:`section_ref_algorithm_LinearityTest`
- :ref:`section_ref_algorithm_TangentTest`
- :ref:`section_ref_algorithm_AdjointTest`
.. index:: single: InitialDirection
.. index:: single: ResiduFormula
.. index:: single: SetSeed
+.. index:: single: StoreSupplementaryCalculations
The general required commands, available in the editing user interface, are the
following:
Example : ``{"SetSeed":1000}``
+ StoreSupplementaryCalculations
+ This list indicates the names of the supplementary variables that can be
+ available at the end of the algorithm. It involves potentially costly
+ calculations or memory consumptions. The default is a void list, none of
+ these variables being calculated and stored by default. The possible names
+ are in the following list: ["CurrentState", "Residu",
+ "SimulatedObservationAtCurrentState"].
+
+ Example : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Information and variables available at the end of the algorithm
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+At the output, after executing the algorithm, there are variables and
+information originating from the calculation. The description of
+:ref:`section_ref_output_variables` show the way to obtain them by the method
+named ``get`` of the variable "*ADD*" of the post-processing. The input
+variables, available to the user at the output in order to facilitate the
+writing of post-processing procedures, are described in the
+:ref:`subsection_r_o_v_Inventaire`.
+
+The unconditional outputs of the algorithm are the following:
+
+ Residu
+ *List of values*. Each element is the value of the particular residu
+ verified during a checking algorithm, in the order of the tests.
+
+ Example : ``r = ADD.get("Residu")[:]``
+
+The conditional outputs of the algorithm are the following:
+
+ CurrentState
+ *List of vectors*. Each element is a usual state vector used during the
+ optimization algorithm procedure.
+
+ Example : ``Xs = ADD.get("CurrentState")[:]``
+
+ SimulatedObservationAtCurrentState
+ *List of vectors*. Each element is an observed vector at the current state,
+ that is, in the observation space.
+
+ Example : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
See also
++++++++
available at the end of the algorithm. It involves potentially costly
calculations or memory consumptions. The default is a void list, none of
these variables being calculated and stored by default. The possible names
- are in the following list: ["CostFunctionJ", "CurrentState", "Innovation",
- "SimulatedObservationAtCurrentState"].
+ are in the following list: ["CostFunctionJ", "CurrentState",
+ "InnovationAtCurrentState", "SimulatedObservationAtCurrentState"].
Example : ``{"StoreSupplementaryCalculations":["CostFunctionJ", "SimulatedObservationAtCurrentState"]}``
+Information and variables available at the end of the algorithm
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+At the output, after executing the algorithm, there are variables and
+information originating from the calculation. The description of
+:ref:`section_ref_output_variables` show the way to obtain them by the method
+named ``get`` of the variable "*ADD*" of the post-processing. The input
+variables, available to the user at the output in order to facilitate the
+writing of post-processing procedures, are described in the
+:ref:`subsection_r_o_v_Inventaire`.
+
+The unconditional outputs of the algorithm are the following:
+
+ CostFunctionJ
+ *List of values*. Each element is a value of the error function :math:`J`.
+
+ Example : ``J = ADD.get("CostFunctionJ")[:]``
+
+ CostFunctionJb
+ *List of values*. Each element is a value of the error function :math:`J^b`,
+ that is of the background difference part.
+
+ Example : ``Jb = ADD.get("CostFunctionJb")[:]``
+
+ CostFunctionJo
+ *List of values*. Each element is a value of the error function :math:`J^o`,
+ that is of the observation difference part.
+
+ Example : ``Jo = ADD.get("CostFunctionJo")[:]``
+
+The conditional outputs of the algorithm are the following:
+
+ CurrentState
+ *List of vectors*. Each element is a usual state vector used during the
+ optimization algorithm procedure.
+
+ Example : ``Xs = ADD.get("CurrentState")[:]``
+
+ InnovationAtCurrentState
+ *List of vectors*. Each element is an innovation vector at current state.
+
+ Example : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
+
+ SimulatedObservationAtCurrentState
+ *List of vectors*. Each element is an observed vector at the current state,
+ that is, in the observation space.
+
+ Example : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
See also
++++++++
.. index:: single: EpsilonMinimumExponent
.. index:: single: InitialDirection
.. index:: single: SetSeed
+.. index:: single: StoreSupplementaryCalculations
The general required commands, available in the editing user interface, are the
following:
Example : ``{"SetSeed":1000}``
+ StoreSupplementaryCalculations
+ This list indicates the names of the supplementary variables that can be
+ available at the end of the algorithm. It involves potentially costly
+ calculations or memory consumptions. The default is a void list, none of
+ these variables being calculated and stored by default. The possible names
+ are in the following list: ["CurrentState", "Residu",
+ "SimulatedObservationAtCurrentState"].
+
+ Example : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Information and variables available at the end of the algorithm
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+At the output, after executing the algorithm, there are variables and
+information originating from the calculation. The description of
+:ref:`section_ref_output_variables` show the way to obtain them by the method
+named ``get`` of the variable "*ADD*" of the post-processing. The input
+variables, available to the user at the output in order to facilitate the
+writing of post-processing procedures, are described in the
+:ref:`subsection_r_o_v_Inventaire`.
+
+The unconditional outputs of the algorithm are the following:
+
+ Residu
+ *List of values*. Each element is the value of the particular residu
+ verified during a checking algorithm, in the order of the tests.
+
+ Example : ``r = ADD.get("Residu")[:]``
+
+The conditional outputs of the algorithm are the following:
+
+ CurrentState
+ *List of vectors*. Each element is a usual state vector used during the
+ optimization algorithm procedure.
+
+ Example : ``Xs = ADD.get("CurrentState")[:]``
+
+ SimulatedObservationAtCurrentState
+ *List of vectors*. Each element is an observed vector at the current state,
+ that is, in the observation space.
+
+ Example : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
See also
++++++++
References to other sections:
- :ref:`section_ref_algorithm_FunctionTest`
+ - :ref:`section_ref_algorithm_LinearityTest`
- :ref:`section_ref_algorithm_AdjointTest`
- :ref:`section_ref_algorithm_GradientTest`
Example : ``omb = ADD.get("OMB")[-1]``
+ Residu
+ *List of values*. Each element is the value of the particular residu
+ verified during a checking algorithm, in the order of the tests.
+
+ Example : ``r = ADD.get("Residu")[:]``
+
SigmaBck2
*List of values*. Each element is a value of the quality indicator
:math:`(\sigma^b)^2` of the background part.
.. 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:
Exemple : ``{"SetSeed":1000}``
+ 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,
+ aucune de ces variables n'étant calculée et stockée par défaut. Les noms
+ possibles sont dans la liste suivante : ["CurrentState", "Residu",
+ "SimulatedObservationAtCurrentState"].
+
+ Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Informations et variables disponibles à la fin de l'algorithme
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+En sortie, après exécution de l'algorithme, on dispose d'informations et de
+variables issues du calcul. La description des
+:ref:`section_ref_output_variables` indique la manière de les obtenir par la
+méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
+d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
+l'écriture des procédures de post-processing, sont décrites dans
+l':ref:`subsection_r_o_v_Inventaire`.
+
+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")[:]``
+
+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.
+
+ Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
Voir aussi
++++++++++
Références vers d'autres sections :
- :ref:`section_ref_algorithm_FunctionTest`
+ - :ref:`section_ref_algorithm_LinearityTest`
- :ref:`section_ref_algorithm_TangentTest`
- :ref:`section_ref_algorithm_GradientTest`
.. 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:
Exemple : ``{"SetDebug":False}``
+ 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,
+ aucune de ces variables n'étant calculée et stockée par défaut. Les noms
+ possibles sont dans la liste suivante : ["CurrentState",
+ "SimulatedObservationAtCurrentState"].
+
+ Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Informations et variables disponibles à la fin de l'algorithme
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+En sortie, après exécution de l'algorithme, on dispose d'informations et de
+variables issues du calcul. La description des
+:ref:`section_ref_output_variables` indique la manière de les obtenir par la
+méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
+d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
+l'écriture des procédures de post-processing, sont décrites dans
+l':ref:`subsection_r_o_v_Inventaire`.
+
+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.
+
+ Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
Voir aussi
++++++++++
.. 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:
Exemple : ``{"SetSeed":1000}``
+ 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,
+ aucune de ces variables n'étant calculée et stockée par défaut. Les noms
+ possibles sont dans la liste suivante : ["CurrentState", "Residu",
+ "SimulatedObservationAtCurrentState"].
+
+ Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Informations et variables disponibles à la fin de l'algorithme
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+En sortie, après exécution de l'algorithme, on dispose d'informations et de
+variables issues du calcul. La description des
+:ref:`section_ref_output_variables` indique la manière de les obtenir par la
+méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
+d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
+l'écriture des procédures de post-processing, sont décrites dans
+l':ref:`subsection_r_o_v_Inventaire`.
+
+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")[:]``
+
+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.
+
+ Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
Voir aussi
++++++++++
Références vers d'autres sections :
- :ref:`section_ref_algorithm_FunctionTest`
+ - :ref:`section_ref_algorithm_LinearityTest`
- :ref:`section_ref_algorithm_TangentTest`
- :ref:`section_ref_algorithm_AdjointTest`
.. 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:
Exemple : ``{"SetSeed":1000}``
+ 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,
+ aucune de ces variables n'étant calculée et stockée par défaut. Les noms
+ possibles sont dans la liste suivante : ["CurrentState", "Residu",
+ "SimulatedObservationAtCurrentState"].
+
+ Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Informations et variables disponibles à la fin de l'algorithme
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+En sortie, après exécution de l'algorithme, on dispose d'informations et de
+variables issues du calcul. La description des
+:ref:`section_ref_output_variables` indique la manière de les obtenir par la
+méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
+d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
+l'écriture des procédures de post-processing, sont décrites dans
+l':ref:`subsection_r_o_v_Inventaire`.
+
+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")[:]``
+
+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.
+
+ Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
Voir aussi
++++++++++
calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
aucune de ces variables n'étant calculée et stockée par défaut. Les noms
possibles sont dans la liste suivante : ["CostFunctionJ", "CurrentState",
- "Innovation", "SimulatedObservationAtCurrentState"].
+ "InnovationAtCurrentState", "SimulatedObservationAtCurrentState"].
Exemple : ``{"StoreSupplementaryCalculations":["CostFunctionJ", "SimulatedObservationAtCurrentState"]}``
+Informations et variables disponibles à la fin de l'algorithme
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+En sortie, après exécution de l'algorithme, on dispose d'informations et de
+variables issues du calcul. La description des
+:ref:`section_ref_output_variables` indique la manière de les obtenir par la
+méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
+d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
+l'écriture des procédures de post-processing, sont décrites dans
+l':ref:`subsection_r_o_v_Inventaire`.
+
+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")[:]``
+
+ 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")[:]``
+
+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]``
+
+ 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.
+
+ Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
Voir aussi
++++++++++
.. 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:
Exemple : ``{"SetSeed":1000}``
+ 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,
+ aucune de ces variables n'étant calculée et stockée par défaut. Les noms
+ possibles sont dans la liste suivante : ["CurrentState", "Residu",
+ "SimulatedObservationAtCurrentState"].
+
+ Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}``
+
+Informations et variables disponibles à la fin de l'algorithme
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+En sortie, après exécution de l'algorithme, on dispose d'informations et de
+variables issues du calcul. La description des
+:ref:`section_ref_output_variables` indique la manière de les obtenir par la
+méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
+d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
+l'écriture des procédures de post-processing, sont décrites dans
+l':ref:`subsection_r_o_v_Inventaire`.
+
+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")[:]``
+
+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.
+
+ Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+
Voir aussi
++++++++++
Références vers d'autres sections :
- :ref:`section_ref_algorithm_FunctionTest`
+ - :ref:`section_ref_algorithm_LinearityTest`
- :ref:`section_ref_algorithm_AdjointTest`
- :ref:`section_ref_algorithm_GradientTest`
Exemple : ``omb = ADD.get("OMB")[-1]``
+ 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")[:]``
+
SigmaBck2
*Liste de valeurs*. Chaque élément est une valeur de l'indicateur de
qualité :math:`(\sigma^b)^2` de la partie ébauche.
typecast = str,
message = "Titre du tableau et de la figure",
)
+ self.defineRequiredParameter(
+ name = "StoreSupplementaryCalculations",
+ default = [],
+ typecast = tuple,
+ message = "Liste de calculs supplémentaires à stocker et/ou effectuer",
+ listval = ["CurrentState", "Residu", "SimulatedObservationAtCurrentState"]
+ )
def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
self._pre_run()
Y = numpy.asmatrix(numpy.ravel( Hm( X ) )).T
Y = numpy.asmatrix(numpy.ravel( Y )).T
NormeY = numpy.linalg.norm( Y )
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(X) )
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(Y) )
#
if len(self._parameters["InitialDirection"]) == 0:
dX0 = []
msg = " %2i %5.0e %9.3e %9.3e %9.3e | %9.3e"%(i,amplitude,NormeX,NormeY,NormedX,Residu)
msgs += "\n" + __marge + msg
#
- self.StoredVariables["CostFunctionJ"].store( Residu )
+ self.StoredVariables["Residu"].store( Residu )
#
msgs += "\n" + __marge + "-"*__nbtirets
msgs += "\n"
typecast = bool,
message = "Activation du mode debug lors de l'exécution",
)
+ self.defineRequiredParameter(
+ name = "StoreSupplementaryCalculations",
+ default = [],
+ typecast = tuple,
+ message = "Liste de calculs supplémentaires à stocker et/ou effectuer",
+ listval = ["CurrentState", "SimulatedObservationAtCurrentState"]
+ )
def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
self._pre_run()
msg += " ====" + "="*len(self._parameters["ResultTitle"]) + "====\n"
print("%s"%msg)
#
- msg = "===> Information before launching:\n"
- msg += " -----------------------------\n"
- msg += " Characteristics of input vector X, internally converted:\n"
- msg += " Type...............: %s\n"%type( Xn )
- msg += " Lenght of vector...: %i\n"%max(numpy.matrix( Xn ).shape)
+ msg = ("===> Information before launching:\n")
+ msg += (" -----------------------------\n")
+ msg += (" Characteristics of input vector X, internally converted:\n")
+ msg += (" Type...............: %s\n")%type( Xn )
+ msg += (" Lenght of vector...: %i\n")%max(numpy.matrix( Xn ).shape)
msg += (" Minimum value......: %."+str(_p)+"e\n")%numpy.min( Xn )
msg += (" Maximum value......: %."+str(_p)+"e\n")%numpy.max( Xn )
msg += (" Mean of vector.....: %."+str(_p)+"e\n")%numpy.mean( Xn )
# ----------
Ys = []
for i in range(self._parameters["NumberOfRepetition"]):
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn) )
print(" %s\n"%("-"*75,))
if self._parameters["NumberOfRepetition"] > 1:
print("===> Repetition step number %i on a total of %i\n"%(i+1,self._parameters["NumberOfRepetition"]))
msg += (" Standard error.....: %."+str(_p)+"e\n")%numpy.std( Yn )
msg += (" L2 norm of vector..: %."+str(_p)+"e\n")%numpy.linalg.norm( Yn )
print(msg)
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(Yn) )
#
Ys.append( copy.copy( numpy.ravel(
Yn
typecast = str,
message = "Label de la courbe tracée dans la figure",
)
+ self.defineRequiredParameter(
+ name = "StoreSupplementaryCalculations",
+ default = [],
+ typecast = tuple,
+ message = "Liste de calculs supplémentaires à stocker et/ou effectuer",
+ listval = ["CurrentState", "Residu", "SimulatedObservationAtCurrentState"]
+ )
def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
self._pre_run()
FX = numpy.asmatrix(numpy.ravel( Hm( X ) )).T
NormeX = numpy.linalg.norm( X )
NormeFX = numpy.linalg.norm( FX )
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn) )
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX) )
#
if len(self._parameters["InitialDirection"]) == 0:
dX0 = []
FX_plus_dX = Hm( X + dX )
FX_plus_dX = numpy.asmatrix(numpy.ravel( FX_plus_dX )).T
#
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(X + dX) )
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX_plus_dX) )
+ #
NormedX = numpy.linalg.norm( dX )
NormeFXdX = numpy.linalg.norm( FX_plus_dX )
NormedFX = numpy.linalg.norm( FX_plus_dX - FX )
msg = " %2i %5.0e %9.3e %9.3e %9.3e %9.3e %9.3e | %9.3e | %9.3e %4.0f"%(i,amplitude,NormeX,NormeFX,NormeFXdX,NormedX,NormedFX,NormedFXsdX,Residu,math.log10(max(1.e-99,Residu)))
msgs += "\n" + __marge + msg
#
- self.StoredVariables["CostFunctionJ"].store( Residu )
+ self.StoredVariables["Residu"].store( Residu )
#
msgs += "\n" + __marge + "-"*__nbtirets
msgs += "\n"
f.write(msgs)
f.close()
#
- Residus = self.StoredVariables["CostFunctionJ"][-len(Perturbations):]
+ Residus = self.StoredVariables["Residu"][-len(Perturbations):]
if self._parameters["ResiduFormula"] in ["Taylor", "TaylorOnNorm"]:
PerturbationsCarre = [ 10**(2*i) for i in xrange(-len(NormesdFXGdX)+1,1) ]
PerturbationsCarre.reverse()
typecast = str,
message = "Titre du tableau et de la figure",
)
+ self.defineRequiredParameter(
+ name = "StoreSupplementaryCalculations",
+ default = [],
+ typecast = tuple,
+ message = "Liste de calculs supplémentaires à stocker et/ou effectuer",
+ listval = ["CurrentState", "Residu", "SimulatedObservationAtCurrentState"]
+ )
def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
self._pre_run()
FX = numpy.asmatrix(numpy.ravel( Hm( Xn ) )).T
NormeX = numpy.linalg.norm( Xn )
NormeFX = numpy.linalg.norm( FX )
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn) )
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX) )
#
# Fabrication de la direction de l'incrément dX
# ----------------------------------------------
dX = amplitude * dX0
#
if self._parameters["ResiduFormula"] == "CenteredDL":
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn + dX) )
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn - dX) )
+ #
FX_plus_dX = numpy.asmatrix(numpy.ravel( Hm( Xn + dX ) )).T
FX_moins_dX = numpy.asmatrix(numpy.ravel( Hm( Xn - dX ) )).T
#
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX_plus_dX) )
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX_moins_dX) )
+ #
Residu = numpy.linalg.norm( FX_plus_dX + FX_moins_dX - 2 * FX ) / NormeFX
#
- self.StoredVariables["CostFunctionJ"].store( Residu )
+ self.StoredVariables["Residu"].store( Residu )
msg = " %2i %5.0e %9.3e %9.3e | %9.3e %4.0f"%(i,amplitude,NormeX,NormeFX,Residu,math.log10(max(1.e-99,Residu)))
msgs += "\n" + __marge + msg
#
if self._parameters["ResiduFormula"] == "Taylor":
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn + dX) )
+ #
FX_plus_dX = numpy.asmatrix(numpy.ravel( Hm( Xn + dX ) )).T
#
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX_plus_dX) )
+ #
Residu = numpy.linalg.norm( FX_plus_dX - FX - amplitude * GradFxdX ) / NormeFX
#
- self.StoredVariables["CostFunctionJ"].store( Residu )
+ self.StoredVariables["Residu"].store( Residu )
msg = " %2i %5.0e %9.3e %9.3e | %9.3e %4.0f"%(i,amplitude,NormeX,NormeFX,Residu,math.log10(max(1.e-99,Residu)))
msgs += "\n" + __marge + msg
#
if self._parameters["ResiduFormula"] == "NominalTaylor":
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn + dX) )
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn - dX) )
+ self.StoredVariables["CurrentState"].store( numpy.ravel(dX) )
+ #
FX_plus_dX = numpy.asmatrix(numpy.ravel( Hm( Xn + dX ) )).T
FX_moins_dX = numpy.asmatrix(numpy.ravel( Hm( Xn - dX ) )).T
FdX = numpy.asmatrix(numpy.ravel( Hm( dX ) )).T
#
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX_plus_dX) )
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX_moins_dX) )
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FdX) )
+ #
Residu = max(
numpy.linalg.norm( FX_plus_dX - amplitude * FdX ) / NormeFX,
numpy.linalg.norm( FX_moins_dX + amplitude * FdX ) / NormeFX,
)
#
- self.StoredVariables["CostFunctionJ"].store( Residu )
+ self.StoredVariables["Residu"].store( Residu )
msg = " %2i %5.0e %9.3e %9.3e | %9.3e %5i %s"%(i,amplitude,NormeX,NormeFX,Residu,100.*abs(Residu-1.),"%")
msgs += "\n" + __marge + msg
#
if self._parameters["ResiduFormula"] == "NominalTaylorRMS":
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn + dX) )
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn - dX) )
+ self.StoredVariables["CurrentState"].store( numpy.ravel(dX) )
+ #
FX_plus_dX = numpy.asmatrix(numpy.ravel( Hm( Xn + dX ) )).T
FX_moins_dX = numpy.asmatrix(numpy.ravel( Hm( Xn - dX ) )).T
FdX = numpy.asmatrix(numpy.ravel( Hm( dX ) )).T
#
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX_plus_dX) )
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX_moins_dX) )
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FdX) )
+ #
Residu = max(
RMS( FX, FX_plus_dX - amplitude * FdX ) / NormeFX,
RMS( FX, FX_moins_dX + amplitude * FdX ) / NormeFX,
)
#
- self.StoredVariables["CostFunctionJ"].store( Residu )
+ self.StoredVariables["Residu"].store( Residu )
msg = " %2i %5.0e %9.3e %9.3e | %9.3e %5i %s"%(i,amplitude,NormeX,NormeFX,Residu,100.*Residu,"%")
msgs += "\n" + __marge + msg
#
default = [],
typecast = tuple,
message = "Liste de calculs supplémentaires à stocker et/ou effectuer",
- listval = ["CostFunctionJ","CurrentState","Innovation","SimulatedObservationAtCurrentState"]
+ listval = ["CostFunctionJ","CurrentState","InnovationAtCurrentState","SimulatedObservationAtCurrentState"]
)
self.defineRequiredParameter(
name = "SetSeed",
J = float( Jb ) + float( Jo )
if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
self.StoredVariables["CurrentState"].store( _X )
- if "Innovation" in self._parameters["StoreSupplementaryCalculations"]:
- self.StoredVariables["Innovation"].store( Y - _HX )
+ if "InnovationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["InnovationAtCurrentState"].store( Y - _HX )
if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
self.StoredVariables["SimulatedObservationAtCurrentState"].store( _HX )
self.StoredVariables["CostFunctionJb"].store( Jb )
typecast = str,
message = "Titre du tableau et de la figure",
)
+ self.defineRequiredParameter(
+ name = "StoreSupplementaryCalculations",
+ default = [],
+ typecast = tuple,
+ message = "Liste de calculs supplémentaires à stocker et/ou effectuer",
+ listval = ["CurrentState", "Residu", "SimulatedObservationAtCurrentState"]
+ )
def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
self._pre_run()
FX = numpy.asmatrix(numpy.ravel( Hm( Xn ) )).T
NormeX = numpy.linalg.norm( Xn )
NormeFX = numpy.linalg.norm( FX )
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( numpy.ravel(Xn) )
+ if "SimulatedObservationAtCurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["SimulatedObservationAtCurrentState"].store( numpy.ravel(FX) )
#
# Fabrication de la direction de l'incrément dX
# ----------------------------------------------
#
Residu = numpy.linalg.norm( FX_plus_dX - FX ) / (amplitude * NormeGX)
#
- self.StoredVariables["CostFunctionJ"].store( Residu )
+ self.StoredVariables["Residu"].store( Residu )
msg = " %2i %5.0e %9.3e %9.3e | %11.5e %5.1e"%(i,amplitude,NormeX,NormeFX,Residu,abs(Residu-1.)/amplitude)
msgs += "\n" + __marge + msg
#
- APosterioriVariances : variances de la matrice A
- APosterioriStandardDeviations : écart-types de la matrice A
- APosterioriCorrelations : correlations de la matrice A
+ - Residu : dans le cas des algorithmes de vérification
On peut rajouter des variables à stocker dans l'initialisation de
l'algorithme élémentaire qui va hériter de cette classe
"""
self.StoredVariables["APosterioriStandardDeviations"] = Persistence.OneVector(name = "APosterioriStandardDeviations")
self.StoredVariables["APosterioriCorrelations"] = Persistence.OneMatrix(name = "APosterioriCorrelations")
self.StoredVariables["SimulationQuantiles"] = Persistence.OneMatrix(name = "SimulationQuantiles")
+ self.StoredVariables["Residu"] = Persistence.OneScalar(name = "Residu")
def _pre_run(self):
"Pré-calcul"
"APosterioriCovariance",
"APosterioriStandardDeviations",
"APosterioriVariances",
+ "Residu",
]
