From: Jean-Philippe ARGAUD Date: Sat, 3 Oct 2015 13:19:17 +0000 (+0200) Subject: Documentation and source observer improvements for checking algorithms X-Git-Tag: V7_7_0rc1~4 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=8cfc2fb75b3099fd631b9d6be46956cf6b15b153;p=modules%2Fadao.git Documentation and source observer improvements for checking algorithms --- diff --git a/doc/en/ref_algorithm_AdjointTest.rst b/doc/en/ref_algorithm_AdjointTest.rst index 3f67d8d..cb7f76f 100644 --- a/doc/en/ref_algorithm_AdjointTest.rst +++ b/doc/en/ref_algorithm_AdjointTest.rst @@ -54,6 +54,7 @@ Optional and required commands .. 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: @@ -115,10 +116,54 @@ The options of the algorithm 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` diff --git a/doc/en/ref_algorithm_FunctionTest.rst b/doc/en/ref_algorithm_FunctionTest.rst index e8724be..b5e4f7f 100644 --- a/doc/en/ref_algorithm_FunctionTest.rst +++ b/doc/en/ref_algorithm_FunctionTest.rst @@ -49,6 +49,7 @@ Optional and required commands .. 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: @@ -97,6 +98,41 @@ The options of the algorithm 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 ++++++++ diff --git a/doc/en/ref_algorithm_GradientTest.rst b/doc/en/ref_algorithm_GradientTest.rst index c325802..5bb80f4 100644 --- a/doc/en/ref_algorithm_GradientTest.rst +++ b/doc/en/ref_algorithm_GradientTest.rst @@ -97,6 +97,7 @@ Optional and required commands .. 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: @@ -170,10 +171,54 @@ The options of the algorithm 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` diff --git a/doc/en/ref_algorithm_LinearityTest.rst b/doc/en/ref_algorithm_LinearityTest.rst index 1716c27..0dc591e 100644 --- a/doc/en/ref_algorithm_LinearityTest.rst +++ b/doc/en/ref_algorithm_LinearityTest.rst @@ -120,6 +120,7 @@ Optional and required commands .. 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: @@ -195,6 +196,49 @@ The options of the algorithm 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 ++++++++ diff --git a/doc/en/ref_algorithm_SamplingTest.rst b/doc/en/ref_algorithm_SamplingTest.rst index 10dd6b0..eb465c0 100644 --- a/doc/en/ref_algorithm_SamplingTest.rst +++ b/doc/en/ref_algorithm_SamplingTest.rst @@ -178,11 +178,60 @@ The options of the algorithm are the following: 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 ++++++++ diff --git a/doc/en/ref_algorithm_TangentTest.rst b/doc/en/ref_algorithm_TangentTest.rst index 7b8460d..04d0676 100644 --- a/doc/en/ref_algorithm_TangentTest.rst +++ b/doc/en/ref_algorithm_TangentTest.rst @@ -62,6 +62,7 @@ Optional and required commands .. 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: @@ -123,10 +124,54 @@ The options of the algorithm 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` diff --git a/doc/en/ref_output_variables.rst b/doc/en/ref_output_variables.rst index 0373510..d8713c5 100644 --- a/doc/en/ref_output_variables.rst +++ b/doc/en/ref_output_variables.rst @@ -313,6 +313,12 @@ of availability. They are the following, in alphabetical order: 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. diff --git a/doc/fr/ref_algorithm_AdjointTest.rst b/doc/fr/ref_algorithm_AdjointTest.rst index 118e1ae..93a5160 100644 --- a/doc/fr/ref_algorithm_AdjointTest.rst +++ b/doc/fr/ref_algorithm_AdjointTest.rst @@ -53,6 +53,7 @@ Commandes requises et optionnelles .. 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: @@ -117,10 +118,55 @@ Les options de l'algorithme 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` diff --git a/doc/fr/ref_algorithm_FunctionTest.rst b/doc/fr/ref_algorithm_FunctionTest.rst index ac11448..775ca3a 100644 --- a/doc/fr/ref_algorithm_FunctionTest.rst +++ b/doc/fr/ref_algorithm_FunctionTest.rst @@ -51,6 +51,7 @@ Commandes requises et optionnelles .. 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: @@ -100,6 +101,41 @@ Les options de l'algorithme 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 ++++++++++ diff --git a/doc/fr/ref_algorithm_GradientTest.rst b/doc/fr/ref_algorithm_GradientTest.rst index 83ae79c..3cf57ab 100644 --- a/doc/fr/ref_algorithm_GradientTest.rst +++ b/doc/fr/ref_algorithm_GradientTest.rst @@ -96,6 +96,7 @@ Commandes requises et optionnelles .. 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: @@ -172,10 +173,55 @@ Les options de l'algorithme 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` diff --git a/doc/fr/ref_algorithm_LinearityTest.rst b/doc/fr/ref_algorithm_LinearityTest.rst index f9d0077..e81d45f 100644 --- a/doc/fr/ref_algorithm_LinearityTest.rst +++ b/doc/fr/ref_algorithm_LinearityTest.rst @@ -119,6 +119,7 @@ Commandes requises et optionnelles .. 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: @@ -198,6 +199,50 @@ Les options de l'algorithme 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 ++++++++++ diff --git a/doc/fr/ref_algorithm_SamplingTest.rst b/doc/fr/ref_algorithm_SamplingTest.rst index 0ae57f9..b1f2c62 100644 --- a/doc/fr/ref_algorithm_SamplingTest.rst +++ b/doc/fr/ref_algorithm_SamplingTest.rst @@ -186,10 +186,61 @@ Les options de l'algorithme sont les suivantes: 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 ++++++++++ diff --git a/doc/fr/ref_algorithm_TangentTest.rst b/doc/fr/ref_algorithm_TangentTest.rst index fd36480..9455b9d 100644 --- a/doc/fr/ref_algorithm_TangentTest.rst +++ b/doc/fr/ref_algorithm_TangentTest.rst @@ -63,6 +63,7 @@ Commandes requises et optionnelles .. 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: @@ -127,10 +128,55 @@ Les options de l'algorithme 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` diff --git a/doc/fr/ref_output_variables.rst b/doc/fr/ref_output_variables.rst index 9fbeeee..16576e3 100644 --- a/doc/fr/ref_output_variables.rst +++ b/doc/fr/ref_output_variables.rst @@ -325,6 +325,13 @@ alphab 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. diff --git a/src/daComposant/daAlgorithms/AdjointTest.py b/src/daComposant/daAlgorithms/AdjointTest.py index dd80339..827c8c0 100644 --- a/src/daComposant/daAlgorithms/AdjointTest.py +++ b/src/daComposant/daAlgorithms/AdjointTest.py @@ -66,6 +66,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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() @@ -86,6 +93,10 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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 = [] @@ -143,7 +154,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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" diff --git a/src/daComposant/daAlgorithms/FunctionTest.py b/src/daComposant/daAlgorithms/FunctionTest.py index 0daf286..4718cf9 100644 --- a/src/daComposant/daAlgorithms/FunctionTest.py +++ b/src/daComposant/daAlgorithms/FunctionTest.py @@ -54,6 +54,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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() @@ -72,11 +79,11 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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 ) @@ -96,6 +103,8 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # ---------- 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"])) @@ -115,6 +124,8 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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 diff --git a/src/daComposant/daAlgorithms/GradientTest.py b/src/daComposant/daAlgorithms/GradientTest.py index fbe3000..8e48495 100644 --- a/src/daComposant/daAlgorithms/GradientTest.py +++ b/src/daComposant/daAlgorithms/GradientTest.py @@ -92,6 +92,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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() @@ -110,6 +117,10 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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 = [] @@ -222,6 +233,11 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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 ) @@ -254,7 +270,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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" @@ -269,7 +285,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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() diff --git a/src/daComposant/daAlgorithms/LinearityTest.py b/src/daComposant/daAlgorithms/LinearityTest.py index d3b3b81..75ec372 100644 --- a/src/daComposant/daAlgorithms/LinearityTest.py +++ b/src/daComposant/daAlgorithms/LinearityTest.py @@ -74,6 +74,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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() @@ -103,6 +110,10 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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 # ---------------------------------------------- @@ -238,49 +249,83 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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 # diff --git a/src/daComposant/daAlgorithms/SamplingTest.py b/src/daComposant/daAlgorithms/SamplingTest.py index b4cbeb7..26a0401 100644 --- a/src/daComposant/daAlgorithms/SamplingTest.py +++ b/src/daComposant/daAlgorithms/SamplingTest.py @@ -74,7 +74,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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", @@ -155,8 +155,8 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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 ) diff --git a/src/daComposant/daAlgorithms/TangentTest.py b/src/daComposant/daAlgorithms/TangentTest.py index 1a4a90f..f52750b 100644 --- a/src/daComposant/daAlgorithms/TangentTest.py +++ b/src/daComposant/daAlgorithms/TangentTest.py @@ -74,6 +74,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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() @@ -98,6 +105,10 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): 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 # ---------------------------------------------- @@ -173,7 +184,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # 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 # diff --git a/src/daComposant/daCore/BasicObjects.py b/src/daComposant/daCore/BasicObjects.py index d970634..78934f7 100644 --- a/src/daComposant/daCore/BasicObjects.py +++ b/src/daComposant/daCore/BasicObjects.py @@ -307,6 +307,7 @@ class Algorithm(object): - 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 """ @@ -345,6 +346,7 @@ class Algorithm(object): 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" diff --git a/src/daSalome/daYacsSchemaCreator/infos_daComposant.py b/src/daSalome/daYacsSchemaCreator/infos_daComposant.py index 0968c91..1c66cf0 100644 --- a/src/daSalome/daYacsSchemaCreator/infos_daComposant.py +++ b/src/daSalome/daYacsSchemaCreator/infos_daComposant.py @@ -283,4 +283,5 @@ ObserversList = [ "APosterioriCovariance", "APosterioriStandardDeviations", "APosterioriVariances", + "Residu", ]