From d75440af0fe5a5e2291bae6f85942048fa468898 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Tue, 13 Jan 2015 21:14:57 +0100 Subject: [PATCH] Documentation corrections and improvements --- bin/AdaoCatalogGenerator.py | 6 +- doc/en/ref_algorithm_3DVAR.rst | 94 ++++++++ doc/en/ref_algorithm_Blue.rst | 94 ++++++++ doc/en/ref_algorithm_EnsembleBlue.rst | 32 +++ doc/en/ref_algorithm_ExtendedBlue.rst | 94 ++++++++ doc/en/ref_algorithm_ExtendedKalmanFilter.rst | 61 +++++ doc/en/ref_algorithm_KalmanFilter.rst | 61 +++++ doc/en/ref_algorithm_LinearLeastSquares.rst | 44 ++++ .../ref_algorithm_NonLinearLeastSquares.rst | 69 ++++++ ...ef_algorithm_ParticleSwarmOptimization.rst | 69 ++++++ doc/en/ref_algorithm_QuantileRegression.rst | 69 ++++++ .../ref_algorithm_UnscentedKalmanFilter.rst | 63 ++++++ doc/en/ref_output_variables.rst | 207 ++++++++++++++++- doc/fr/ref_algorithm_3DVAR.rst | 96 ++++++++ doc/fr/ref_algorithm_Blue.rst | 96 ++++++++ doc/fr/ref_algorithm_EnsembleBlue.rst | 33 +++ doc/fr/ref_algorithm_ExtendedBlue.rst | 96 ++++++++ doc/fr/ref_algorithm_ExtendedKalmanFilter.rst | 65 ++++++ doc/fr/ref_algorithm_KalmanFilter.rst | 65 ++++++ doc/fr/ref_algorithm_LinearLeastSquares.rst | 46 ++++ .../ref_algorithm_NonLinearLeastSquares.rst | 71 ++++++ ...ef_algorithm_ParticleSwarmOptimization.rst | 71 ++++++ doc/fr/ref_algorithm_QuantileRegression.rst | 71 ++++++ .../ref_algorithm_UnscentedKalmanFilter.rst | 65 ++++++ doc/fr/ref_output_variables.rst | 208 ++++++++++++++++++ 25 files changed, 1941 insertions(+), 5 deletions(-) diff --git a/bin/AdaoCatalogGenerator.py b/bin/AdaoCatalogGenerator.py index 10cc3ab..008438d 100644 --- a/bin/AdaoCatalogGenerator.py +++ b/bin/AdaoCatalogGenerator.py @@ -56,7 +56,7 @@ def F_${data_name}(statut) : return FACT(statut = statut, ), STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ", - STRING = SIMP(statut = "o", typ = "TXM", ${ms_default} fr="En attente d'une chaine de caractères entre guillements. Pour construire un vecteur ou une matrice, ce doit être une suite de nombres, utilisant un espace ou une virgule pour séparer deux éléments et un point-virgule pour séparer deux lignes", ang="Waiting for a string in quotes. To build a vector or a matrix, it has to be a float serie, using a space or comma to separate two elements in a line, a semi-colon to separate rows"), + STRING = SIMP(statut = "o", typ = "TXM",${ms_default} fr="En attente d'une chaine de caractères entre guillements. Pour construire un vecteur ou une matrice, ce doit être une suite de nombres, utilisant un espace ou une virgule pour séparer deux éléments et un point-virgule pour séparer deux lignes", ang="Waiting for a string in quotes. To build a vector or a matrix, it has to be a float serie, using a space or comma to separate two elements in a line, a semi-colon to separate rows"), ), SCRIPTWITHFUNCTIONS_DATA = BLOC ( condition = " FROM in ( 'ScriptWithFunctions', ) ", @@ -289,7 +289,7 @@ for data_input_name in infos.DataTypeDict.keys(): # On choisit le default data_default = "\"" + infos.DataTypeDefaultDict[data_input_name] + "\"" if infos.DataSValueDefaultDict.has_key(data_input_name): - ms_default = "defaut=\"" + infos.DataSValueDefaultDict[data_input_name] + "\"," + ms_default = " defaut=\"" + infos.DataSValueDefaultDict[data_input_name] + "\"," mem_file.write(data_method.substitute(data_name = data_name, data_into = data_into, @@ -334,7 +334,7 @@ for opt_name in infos.OptDict.keys(): # On choisit le default data_default = "\"" + infos.OptDefaultDict[opt_name] + "\"" if infos.DataSValueDefaultDict.has_key(opt_name): - ms_default = "defaut=\"" + infos.DataSValueDefaultDict[opt_name] + "\"," + ms_default = " defaut=\"" + infos.DataSValueDefaultDict[opt_name] + "\"," mem_file.write(data_method.substitute(data_name = data_name, data_into = data_into, diff --git a/doc/en/ref_algorithm_3DVAR.rst b/doc/en/ref_algorithm_3DVAR.rst index 7703fb2..22ae3b4 100644 --- a/doc/en/ref_algorithm_3DVAR.rst +++ b/doc/en/ref_algorithm_3DVAR.rst @@ -213,6 +213,100 @@ The options of the algorithm are the following: Example : ``{"SimulationForQuantiles":"Linear"}`` +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + APosterioriCovariance + *List of matrices*. Each element is an *a posteriori* error covariance + matrix :math:`\mathbf{A}*` of the optimal state. + + Example : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + CurrentState + *List of vectors*. Each element is a usual state vector used during the + optimization algorithm procedure. + + Example : ``Xs = ADD.get("CurrentState")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + + Example : ``d = ADD.get("Innovation")[-1]`` + + MahalanobisConsistency + *List of values*. Each element is a value of the Mahalanobis quality + indicator. + + Example : ``m = ADD.get("MahalanobisConsistency")[-1]`` + + OMA + *List of vectors*. Each element is a vector of difference between the + observation and the optimal state in the observation space. + + Example : ``oma = ADD.get("OMA")[-1]`` + + OMB + *List of vectors*. Each element is a vector of difference between the + observation and the background state in the observation space. + + Example : ``omb = ADD.get("OMB")[-1]`` + + SigmaObs2 + *List of values*. Each element is a value of the quality indicator + :math:`(\sigma^o)^2` of the observation part. + + Example : ``so2 = ADD.get("SigmaObs")[-1]`` + + SimulationQuantiles + *List of vectors*. Each element is a vector corresponding to the observed + state which realize the required quantile, in the same order than the + quantiles required by the user. + + Example : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_Blue.rst b/doc/en/ref_algorithm_Blue.rst index 3e9baf2..169ddd6 100644 --- a/doc/en/ref_algorithm_Blue.rst +++ b/doc/en/ref_algorithm_Blue.rst @@ -159,6 +159,100 @@ The options of the algorithm are the following: Example : ``{"SimulationForQuantiles":"Linear"}`` +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + +The conditional outputs of the algorithm are the following: + + APosterioriCovariance + *List of matrices*. Each element is an *a posteriori* error covariance + matrix :math:`\mathbf{A}*` of the optimal state. + + Example : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + + Example : ``d = ADD.get("Innovation")[-1]`` + + MahalanobisConsistency + *List of values*. Each element is a value of the Mahalanobis quality + indicator. + + Example : ``m = ADD.get("MahalanobisConsistency")[-1]`` + + OMA + *List of vectors*. Each element is a vector of difference between the + observation and the optimal state in the observation space. + + Example : ``oma = ADD.get("OMA")[-1]`` + + OMB + *List of vectors*. Each element is a vector of difference between the + observation and the background state in the observation space. + + Example : ``omb = ADD.get("OMB")[-1]`` + + SigmaBck2 + *List of values*. Each element is a value of the quality indicator + :math:`(\sigma^b)^2` of the background part. + + Example : ``sb2 = ADD.get("SigmaBck")[-1]`` + + SigmaObs2 + *List of values*. Each element is a value of the quality indicator + :math:`(\sigma^o)^2` of the observation part. + + Example : ``so2 = ADD.get("SigmaObs")[-1]`` + + SimulationQuantiles + *List of vectors*. Each element is a vector corresponding to the observed + state which realize the required quantile, in the same order than the + quantiles required by the user. + + Example : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_EnsembleBlue.rst b/doc/en/ref_algorithm_EnsembleBlue.rst index 51e9dbb..6130ede 100644 --- a/doc/en/ref_algorithm_EnsembleBlue.rst +++ b/doc/en/ref_algorithm_EnsembleBlue.rst @@ -102,6 +102,38 @@ The options of the algorithm are the following: Example : ``{"SetSeed":1000}`` +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + + CurrentState + *List of vectors*. Each element is a usual state vector used during the + optimization algorithm procedure. + + Example : ``Xs = ADD.get("CurrentState")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + + Example : ``d = ADD.get("Innovation")[-1]`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_ExtendedBlue.rst b/doc/en/ref_algorithm_ExtendedBlue.rst index ad5bf76..1ceb984 100644 --- a/doc/en/ref_algorithm_ExtendedBlue.rst +++ b/doc/en/ref_algorithm_ExtendedBlue.rst @@ -157,6 +157,100 @@ The options of the algorithm are the following: Example : ``{"SimulationForQuantiles":"Linear"}`` +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + +The conditional outputs of the algorithm are the following: + + APosterioriCovariance + *List of matrices*. Each element is an *a posteriori* error covariance + matrix :math:`\mathbf{A}*` of the optimal state. + + Example : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + + Example : ``d = ADD.get("Innovation")[-1]`` + + MahalanobisConsistency + *List of values*. Each element is a value of the Mahalanobis quality + indicator. + + Example : ``m = ADD.get("MahalanobisConsistency")[-1]`` + + OMA + *List of vectors*. Each element is a vector of difference between the + observation and the optimal state in the observation space. + + Example : ``oma = ADD.get("OMA")[-1]`` + + OMB + *List of vectors*. Each element is a vector of difference between the + observation and the background state in the observation space. + + Example : ``omb = ADD.get("OMB")[-1]`` + + SigmaBck2 + *List of values*. Each element is a value of the quality indicator + :math:`(\sigma^b)^2` of the background part. + + Example : ``sb2 = ADD.get("SigmaBck")[-1]`` + + SigmaObs2 + *List of values*. Each element is a value of the quality indicator + :math:`(\sigma^o)^2` of the observation part. + + Example : ``so2 = ADD.get("SigmaObs")[-1]`` + + SimulationQuantiles + *List of vectors*. Each element is a vector corresponding to the observed + state which realize the required quantile, in the same order than the + quantiles required by the user. + + Example : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst index 98a1705..16e68a3 100644 --- a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst @@ -123,6 +123,67 @@ The options of the algorithm are the following: Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + +The conditional outputs of the algorithm are the following: + + APosterioriCovariance + *List of matrices*. Each element is an *a posteriori* error covariance + matrix :math:`\mathbf{A}*` of the optimal state. + + Example : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + CurrentState + *List of vectors*. Each element is a usual state vector used during the + optimization algorithm procedure. + + Example : ``Xs = ADD.get("CurrentState")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + See also ++++++++ diff --git a/doc/en/ref_algorithm_KalmanFilter.rst b/doc/en/ref_algorithm_KalmanFilter.rst index a936a96..64bbc30 100644 --- a/doc/en/ref_algorithm_KalmanFilter.rst +++ b/doc/en/ref_algorithm_KalmanFilter.rst @@ -122,6 +122,67 @@ The options of the algorithm are the following: Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + +The conditional outputs of the algorithm are the following: + + APosterioriCovariance + *List of matrices*. Each element is an *a posteriori* error covariance + matrix :math:`\mathbf{A}*` of the optimal state. + + Example : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + CurrentState + *List of vectors*. Each element is a usual state vector used during the + optimization algorithm procedure. + + Example : ``Xs = ADD.get("CurrentState")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + See also ++++++++ diff --git a/doc/en/ref_algorithm_LinearLeastSquares.rst b/doc/en/ref_algorithm_LinearLeastSquares.rst index 27be406..b6049da 100644 --- a/doc/en/ref_algorithm_LinearLeastSquares.rst +++ b/doc/en/ref_algorithm_LinearLeastSquares.rst @@ -111,6 +111,50 @@ The options of the algorithm are the following: even if these commands are not required for this algorithm, and will not be used. The simplest way is to give "1" as a STRING for both. +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + OMA + *List of vectors*. Each element is a vector of difference between the + observation and the optimal state in the observation space. + + Example : ``oma = ADD.get("OMA")[-1]`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_NonLinearLeastSquares.rst b/doc/en/ref_algorithm_NonLinearLeastSquares.rst index 8b89cc0..52aa00a 100644 --- a/doc/en/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/en/ref_algorithm_NonLinearLeastSquares.rst @@ -173,6 +173,75 @@ The options of the algorithm are the following: command is not required for this algorithm, and will not be used. The simplest way is to give "1" as a STRING. +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + CurrentState + *List of vectors*. Each element is a usual state vector used during the + optimization algorithm procedure. + + Example : ``Xs = ADD.get("CurrentState")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + + Example : ``d = ADD.get("Innovation")[-1]`` + + OMA + *List of vectors*. Each element is a vector of difference between the + observation and the optimal state in the observation space. + + Example : ``oma = ADD.get("OMA")[-1]`` + + OMB + *List of vectors*. Each element is a vector of difference between the + observation and the background state in the observation space. + + Example : ``omb = ADD.get("OMB")[-1]`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst index bfb6389..5ebca5c 100644 --- a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst @@ -171,6 +171,75 @@ The options of the algorithm are the following: Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + CurrentState + *List of vectors*. Each element is a usual state vector used during the + optimization algorithm procedure. + + Example : ``Xs = ADD.get("CurrentState")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + + Example : ``d = ADD.get("Innovation")[-1]`` + + OMA + *List of vectors*. Each element is a vector of difference between the + observation and the optimal state in the observation space. + + Example : ``oma = ADD.get("OMA")[-1]`` + + OMB + *List of vectors*. Each element is a vector of difference between the + observation and the background state in the observation space. + + Example : ``omb = ADD.get("OMB")[-1]`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_QuantileRegression.rst b/doc/en/ref_algorithm_QuantileRegression.rst index 8876d57..3abc14c 100644 --- a/doc/en/ref_algorithm_QuantileRegression.rst +++ b/doc/en/ref_algorithm_QuantileRegression.rst @@ -126,6 +126,75 @@ The options of the algorithm are the following: value, even if these commands are not required for this algorithm, and will not be used. The simplest way is to give "1" as a STRING for both. +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + CurrentState + *List of vectors*. Each element is a usual state vector used during the + optimization algorithm procedure. + + Example : ``Xs = ADD.get("CurrentState")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + + Example : ``d = ADD.get("Innovation")[-1]`` + + OMA + *List of vectors*. Each element is a vector of difference between the + observation and the optimal state in the observation space. + + Example : ``oma = ADD.get("OMA")[-1]`` + + OMB + *List of vectors*. Each element is a vector of difference between the + observation and the background state in the observation space. + + Example : ``omb = ADD.get("OMB")[-1]`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst index d032968..cf3b45b 100644 --- a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst @@ -138,6 +138,69 @@ The options of the algorithm are the following: Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` +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: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + +The conditional outputs of the algorithm are the following: + + APosterioriCovariance + *List of matrices*. Each element is an *a posteriori* error covariance + matrix :math:`\mathbf{A}*` of the optimal state. + + Example : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + CurrentState + *List of vectors*. Each element is a usual state vector used during the + optimization algorithm procedure. + + Example : ``Xs = ADD.get("CurrentState")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + + Example : ``d = ADD.get("Innovation")[-1]`` + See also ++++++++ diff --git a/doc/en/ref_output_variables.rst b/doc/en/ref_output_variables.rst index 2f42cbf..f27b735 100644 --- a/doc/en/ref_output_variables.rst +++ b/doc/en/ref_output_variables.rst @@ -23,6 +23,209 @@ .. _section_ref_output_variables: -Variables and informations available in output ----------------------------------------------- +Variables and informations available at the output +-------------------------------------------------- +How to obtain information available at the output ++++++++++++++++++++++++++++++++++++++++++++++++++ + +.. index:: single: UserPostAnalysis +.. index:: single: algoResults +.. index:: single: get + +At the output, after executing data assimilation, optimization or checking +study, there are variables and information originating from the calculation. The +obtaining of this information is then carried out in a standardized way using +the post-processing step of calculation. + +The step is easily identified by the user into its ADAO definition case (by the +keyword "*UserPostAnalysis*") or in its YACS execution scheme (by nodes or +blocks located after the calculation block, and graphically connected to the +output port "*algoResults*" of the calculation block): + +#. In the case where the user defines the post-processing in his ADAO case, it uses an external script file or commands in the field type "*String*" or "*Template*". The script it provides has a fixed variable "*ADD*" in the namespace. +#. In the case where the user defines the post-processing in its YACS scheme by a Python node located after the block of calculation, it should add a input port of type "*pyobj*" named for example "*Study*", graphically connected to the output port "*algoResults*" of the calculation block. The Python post-processing node must then start with ``ADD = Study.getResults()``. + + +In all cases, the post-processing of the user has in the namespace a variable +whose name is "*ADD*", and whose only available method is named ``get``. The +arguments of this method are an output information name, as described in the +:ref:`subsection_r_o_v_Inventaire`. + +For example, to have the optimal state after a data assimilation or optimization +calculation, one use the following call:: + + ADD.get("Analysis") + +This call returns a list of values of the requested notion (or, in the case of +input variables that are by nature only a unique specimen, the value itself). +One can then request a particular item in the list by the standard list commands +(especially ``[-1]`` for the last, and ``[:]`` for all items). + +Cross compliance of the information available at the output ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +.. index:: single: StoreInternalVariables +.. index:: single: AlgorithmParameters +.. index:: single: Stored + +The availability of information after the calculation is conditioned by the fact +that they have been calculated or requested. + +Each algorithm does not necessarily provide the same information, and not +necessarily for example uses the same intermediate quantities. Thus, there is +information that are always present such as the optimal state resulting from the +calculation. The other information are only present for certain algorithms +and/or if they have been requested before the execution of the calculation. + +It is recalled that the user can request additional information during the +preparation of its ADAO case, using option "*StoreInternalVariables*" each +algorithm through the optional control "*AlgorithmParameters*" of ADAO case. +Reference will be made to the :ref:`section_ref_options_AlgorithmParameters` for +the proper use of this command, and to the description of each algorithm for +the information available by algorithm. One can also ask to keep some input +information by changing the boolean "* * Stored" associated with it in the +edition of the ADAO case. + +.. _subsection_r_o_v_Inventaire: + +Inventory of potentially available information at the output +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +The set of potentially available information at the output is listed here +regardless of algorithms, for inventory. + +The optimal state is an information that is always naturally available after an +optimization or a data assimilation calculation. It is indicated by the +following keywords: + + Analysis + *List of vectors*. Each element is an optimal state :math:`\mathbf{x}*` in + optimization or an analysis :math:`\mathbf{x}^a` in data assimilation. + + Example : ``Xa = ADD.get("Analysis")[-1]`` + +The following variables are input variables. They are made available to the +user at the output in order to facilitate the writing of post-processing +procedures, and are conditioned by a user request using a boolean "*Stored*" +at the input. + + Background + *Vector*, whose availability is conditioned by "*Stored*" at the input. It + is the background vector :math:`\mathbf{x}^b`. + + Example : ``Xb = ADD.get("Background")`` + + BackgroundError + *Matrix*, whose availability is conditioned by "*Stored*" at the input. It + is the matrix :math:`\mathbf{B}` of *a priori* background errors + covariances. + + Example : ``B = ADD.get("BackgroundError")`` + + EvolutionError + *Matrix*, whose availability is conditioned by "*Stored*" at the input. It + is the matrix :math:`\mathbf{M}` of *a priori* evolution errors covariances. + + Example : ``M = ADD.get("EvolutionError")`` + + Observation + *Vector*, whose availability is conditioned by "*Stored*" at the input. It + is the observation vector :math:`\mathbf{y}^o`. + + Example : ``Yo = ADD.get("Observation")`` + + ObservationError + *Matrix*, whose availability is conditioned by "*Stored*" at the input. It + is the matrix :math:`\mathbf{R}` of *a priori* observation errors + covariances. + + Example : ``R = ADD.get("ObservationError")`` + +All other information are conditioned by the algorithm and/or the user requests +of availability. They are the following, in alphabetical order: + + APosterioriCovariance + *List of matrices*. Each element is an *a posteriori* error covariance + matrix :math:`\mathbf{A}*` of the optimal state. + + Example : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *List of vectors*. Each element is a vector of difference between the + background and the optimal state. + + Example : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + CurrentState + *List of vectors*. Each element is a usual state vector used during the + optimization algorithm procedure. + + Example : ``Xs = ADD.get("CurrentState")[:]`` + + Innovation + *List of vectors*. Each element is an innovation vector, which is in static + the difference between the optimal and the background, and in dynamic the + evolution increment. + + Example : ``d = ADD.get("Innovation")[-1]`` + + MahalanobisConsistency + *List of values*. Each element is a value of the Mahalanobis quality + indicator. + + Example : ``m = ADD.get("MahalanobisConsistency")[-1]`` + + ObservedState + *List of vectors*. Each element is an observed state vector, that is, in the + observation space. + + Example : ``Ys = ADD.get("ObservedState")[-1]`` + + OMA + *List of vectors*. Each element is a vector of difference between the + observation and the optimal state in the observation space. + + Example : ``oma = ADD.get("OMA")[-1]`` + + OMB + *List of vectors*. Each element is a vector of difference between the + observation and the background state in the observation space. + + Example : ``omb = ADD.get("OMB")[-1]`` + + SigmaBck2 + *List of values*. Each element is a value of the quality indicator + :math:`(\sigma^b)^2` of the background part. + + Example : ``sb2 = ADD.get("SigmaBck")[-1]`` + + SigmaObs2 + *List of values*. Each element is a value of the quality indicator + :math:`(\sigma^o)^2` of the observation part. + + Example : ``so2 = ADD.get("SigmaObs")[-1]`` + + SimulationQuantiles + *List of vectors*. Each element is a vector corresponding to the observed + state which realize the required quantile, in the same order than the + quantiles required by the user. + + Example : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` diff --git a/doc/fr/ref_algorithm_3DVAR.rst b/doc/fr/ref_algorithm_3DVAR.rst index 0f56081..387b31a 100644 --- a/doc/fr/ref_algorithm_3DVAR.rst +++ b/doc/fr/ref_algorithm_3DVAR.rst @@ -220,6 +220,102 @@ Les options de l'algorithme sont les suivantes: Exemple : ``{"SimulationForQuantiles":"Linear"}`` +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + APosterioriCovariance + *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de + covariances des erreurs *a posteriori* de l'état optimal. + + Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + + MahalanobisConsistency + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité de Mahalanobis. + + Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]`` + + OMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état optimal dans l'espace des observations. + + Exemple : ``oma = ADD.get("OMA")[-1]`` + + OMB + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état d'ébauche dans l'espace des observations. + + Exemple : ``omb = ADD.get("OMB")[-1]`` + + SigmaObs2 + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité :math:`(\sigma^o)^2` de la partie observation. + + Exemple : ``so2 = ADD.get("SigmaObs")[-1]`` + + SimulationQuantiles + *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état + observé qui réalise le quantile demandé, dans le même ordre que les + quantiles requis par l'utilisateur. + + Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_Blue.rst b/doc/fr/ref_algorithm_Blue.rst index 6a7b0d3..53219ba 100644 --- a/doc/fr/ref_algorithm_Blue.rst +++ b/doc/fr/ref_algorithm_Blue.rst @@ -162,6 +162,102 @@ Les options de l'algorithme sont les suivantes: Exemple : ``{"SimulationForQuantiles":"Linear"}`` +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + +Les sorties conditionnelles de l'algorithme sont les suivantes: + + APosterioriCovariance + *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de + covariances des erreurs *a posteriori* de l'état optimal. + + Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + + MahalanobisConsistency + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité de Mahalanobis. + + Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]`` + + OMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état optimal dans l'espace des observations. + + Exemple : ``oma = ADD.get("OMA")[-1]`` + + OMB + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état d'ébauche dans l'espace des observations. + + Exemple : ``omb = ADD.get("OMB")[-1]`` + + SigmaBck2 + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité :math:`(\sigma^b)^2` de la partie ébauche. + + Exemple : ``sb2 = ADD.get("SigmaBck")[-1]`` + + SigmaObs2 + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité :math:`(\sigma^o)^2` de la partie observation. + + Exemple : ``so2 = ADD.get("SigmaObs")[-1]`` + + SimulationQuantiles + *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état + observé qui réalise le quantile demandé, dans le même ordre que les + quantiles requis par l'utilisateur. + + Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_EnsembleBlue.rst b/doc/fr/ref_algorithm_EnsembleBlue.rst index c1130ce..b146e74 100644 --- a/doc/fr/ref_algorithm_EnsembleBlue.rst +++ b/doc/fr/ref_algorithm_EnsembleBlue.rst @@ -104,6 +104,39 @@ Les options de l'algorithme sont les suivantes: Exemple : ``{"SetSeed":1000}`` +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_ExtendedBlue.rst b/doc/fr/ref_algorithm_ExtendedBlue.rst index 33a4109..d06696f 100644 --- a/doc/fr/ref_algorithm_ExtendedBlue.rst +++ b/doc/fr/ref_algorithm_ExtendedBlue.rst @@ -159,6 +159,102 @@ Les options de l'algorithme sont les suivantes: Exemple : ``{"SimulationForQuantiles":"Linear"}`` +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + +Les sorties conditionnelles de l'algorithme sont les suivantes: + + APosterioriCovariance + *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de + covariances des erreurs *a posteriori* de l'état optimal. + + Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + + MahalanobisConsistency + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité de Mahalanobis. + + Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]`` + + OMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état optimal dans l'espace des observations. + + Exemple : ``oma = ADD.get("OMA")[-1]`` + + OMB + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état d'ébauche dans l'espace des observations. + + Exemple : ``omb = ADD.get("OMB")[-1]`` + + SigmaBck2 + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité :math:`(\sigma^b)^2` de la partie ébauche. + + Exemple : ``sb2 = ADD.get("SigmaBck")[-1]`` + + SigmaObs2 + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité :math:`(\sigma^o)^2` de la partie observation. + + Exemple : ``so2 = ADD.get("SigmaObs")[-1]`` + + SimulationQuantiles + *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état + observé qui réalise le quantile demandé, dans le même ordre que les + quantiles requis par l'utilisateur. + + Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst index aac32ed..38700a8 100644 --- a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst @@ -128,6 +128,71 @@ Les options de l'algorithme sont les suivantes: Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + +Les sorties conditionnelles de l'algorithme sont les suivantes: + + APosterioriCovariance + *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de + covariances des erreurs *a posteriori* de l'état optimal. + + Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_KalmanFilter.rst b/doc/fr/ref_algorithm_KalmanFilter.rst index c124450..c5ae736 100644 --- a/doc/fr/ref_algorithm_KalmanFilter.rst +++ b/doc/fr/ref_algorithm_KalmanFilter.rst @@ -125,6 +125,71 @@ Les options de l'algorithme sont les suivantes: Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + +Les sorties conditionnelles de l'algorithme sont les suivantes: + + APosterioriCovariance + *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de + covariances des erreurs *a posteriori* de l'état optimal. + + Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_LinearLeastSquares.rst b/doc/fr/ref_algorithm_LinearLeastSquares.rst index ee2183b..c817a5e 100644 --- a/doc/fr/ref_algorithm_LinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_LinearLeastSquares.rst @@ -114,6 +114,52 @@ Les options de l'algorithme sont les suivantes: cet algorithme, et ne seront pas utilisées. La manière la plus simple est de donner "1" comme un STRING pour les deux. +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + OMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état optimal dans l'espace des observations. + + Exemple : ``oma = ADD.get("OMA")[-1]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst index 81f8561..6b9a817 100644 --- a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst @@ -182,6 +182,77 @@ Les options de l'algorithme sont les suivantes: que cette commande n'est pas requise pour cet algorithme, et ne sera pas utilisée. La manière la plus simple est de donner "1" comme un STRING. +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + + OMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état optimal dans l'espace des observations. + + Exemple : ``oma = ADD.get("OMA")[-1]`` + + OMB + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état d'ébauche dans l'espace des observations. + + Exemple : ``omb = ADD.get("OMB")[-1]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst index ba7901c..b5ebfd6 100644 --- a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst @@ -176,6 +176,77 @@ Les options de l'algorithme sont les suivantes: Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + + OMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état optimal dans l'espace des observations. + + Exemple : ``oma = ADD.get("OMA")[-1]`` + + OMB + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état d'ébauche dans l'espace des observations. + + Exemple : ``omb = ADD.get("OMB")[-1]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_QuantileRegression.rst b/doc/fr/ref_algorithm_QuantileRegression.rst index 39b1199..4cc7d2b 100644 --- a/doc/fr/ref_algorithm_QuantileRegression.rst +++ b/doc/fr/ref_algorithm_QuantileRegression.rst @@ -129,6 +129,77 @@ Les options de l'algorithme sont les suivantes: pour cet algorithme, et ne seront pas utilisées. La manière la plus simple est de donner "1" comme un STRING pour les deux. +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + + 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: + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + + OMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état optimal dans l'espace des observations. + + Exemple : ``oma = ADD.get("OMA")[-1]`` + + OMB + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état d'ébauche dans l'espace des observations. + + Exemple : ``omb = ADD.get("OMB")[-1]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst index f3ab792..b7f3930 100644 --- a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst @@ -143,6 +143,71 @@ Les options de l'algorithme sont les suivantes: Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` +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: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + +Les sorties conditionnelles de l'algorithme sont les suivantes: + + APosterioriCovariance + *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de + covariances des erreurs *a posteriori* de l'état optimal. + + Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_output_variables.rst b/doc/fr/ref_output_variables.rst index 2e58182..a8760d8 100644 --- a/doc/fr/ref_output_variables.rst +++ b/doc/fr/ref_output_variables.rst @@ -26,3 +26,211 @@ Variables et informations disponibles en sortie ----------------------------------------------- +Comment obtenir des informations disponibles en sortie +++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +.. index:: single: UserPostAnalysis +.. index:: single: algoResults +.. index:: single: get + +En sortie, après exécution d'une assimilation de données, d'une optimisation +ou d'une vérification, on dispose de variables et d'informations issues du +calcul. L'obtention de ces informations se fait ensuite de manière standardisée +à l'aide de l'étape de post-processing du calcul. + +L'étape est aisément identifiée par l'utilisateur dans son cas ADAO de +définition (par la mot-clé "*UserPostAnalysis*") ou dans son schéma YACS +d'exécution (par des noeuds ou blocs situés après le bloc de calcul, et reliés +graphiquement au port de sortie "*algoResults*" du bloc de calcul): + +#. Dans le cas où l'utilisateur définit le post-processing dans son cas ADAO, il utilise un fichier script externe ou des commandes dans le champ de type "*String*" ou "*Template*". Le script qu'il fournit dispose d'une variable fixe "*ADD*" dans l'espace de noms. +#. Dans le cas où l'utilisateur définit le post-processing dans son schéma YACS par un noeud Python situé après le bloc de calcul, il doit ajouter un port d'entrée de type "*pyobj*" nommé par exemple "*Study*", relié graphiquement au port de sortie "*algoResults*" du bloc de calcul. Le noeud Python de post-processing doit ensuite débuter par ``ADD = Study.getResults()``. + +Dans tous les cas, le post-processing de l'utilisateur dispose dans l'espace de +noms d'une variable dont le nom est "*ADD*", et dont l'unique méthode utilisable +est nommée ``get``. Les arguments de cette méthode sont un nom d'information de +sortie, comme décrit dans l':ref:`subsection_r_o_v_Inventaire`. + +Par exemple, pour avoir l'état optimal après un calcul d'assimilation de données +ou d'optimisation, on utilise l'appel suivant:: + + ADD.get("Analysis") + +Cet appel renvoie une liste de valeurs de la notion demandée (ou, dans le cas +de variables d'entrées qui ne sont par nature qu'en un unique exemplaire, la +valeur elle-même). On peut alors demander un élément particulier de la liste par +les commandes standards de liste (en particulier ``[-1]`` pour le dernier, et +``[:]`` pour tous les éléments). + +Conditionnalité des informations disponibles en sortie +++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +.. index:: single: StoreInternalVariables +.. index:: single: AlgorithmParameters +.. index:: single: Stored + +La disponibilité des informations après le calcul est conditionnée par le fait +qu'elles aient été calculées ou demandées. + +Chaque algorithme ne fournit pas obligatoirement les mêmes informations, et +n'utilise par exemple pas nécessairement les mêmes quantités intermédiaires. Il +y a donc des informations toujours présentes comme l'état optimal résultant du +calcul. Les autres informations ne sont présentes que pour certains algorithmes +et/ou que si elles ont été réclamées avant l'exécution du calcul. + +On rappelle que l'utilisateur peut réclamer des informations supplémentaires +lors de l'établissement de son cas ADAO, en utilisant l'option +"*StoreInternalVariables*" de chaque algorithme à travers la commande +optionnelle "*AlgorithmParameters*" du cas ADAO. On se reportera à la +:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +commande, et à la description de chaque algorithme pour les informations +disponibles par algorithme. On peut aussi demander à conserver certaines +informations en entrée en changeant le booléen "*Stored*" qui lui est associé +dans l'édition du cas ADAO. + +.. _subsection_r_o_v_Inventaire: + +Inventaire des informations potentiellement disponibles en sortie ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +L'ensemble des informations potentiellement disponibles en sortie est indiqué +ici indépendamment des algorithmes, pour inventaire. + +L'état optimal est une information qui est toujours naturellement disponible +après un calcul d'assimilation de données ou d'optimisation. Il désigné par le +mot-clé suivant: + + Analysis + *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` + en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de + données. + + Exemple : ``Xa = ADD.get("Analysis")[-1]`` + +Les variables suivantes sont des variables d'entrée. Elles sont mises à +disposition de l'utilisateur en sortie pour faciliter l'écriture des procédures +de post-processing, et sont conditionnées par une demande utilisateur à l'aide +d'un booléen "*Stored*" en entrée. + + Background + *Vecteur*, dont la disponibilité est conditionnée par "*Stored*" en entrée. + C'est le vecteur d'ébauche :math:`\mathbf{x}^b`. + + Exemple : ``Xb = ADD.get("Background")`` + + BackgroundError + *Matrice*, dont la disponibilité est conditionnée par "*Stored*" en entrée. + C'est la matrice :math:`\mathbf{B}` de covariances des erreurs *a priori* + de l'ébauche. + + Exemple : ``B = ADD.get("BackgroundError")`` + + EvolutionError + *Matrice*, dont la disponibilité est conditionnée par "*Stored*" en entrée. + C'est la matrice :math:`\mathbf{M}` de covariances des erreurs *a priori* + de l'évolution. + + Exemple : ``M = ADD.get("EvolutionError")`` + + Observation + *Vecteur*, dont la disponibilité est conditionnée par "*Stored*" en entrée. + C'est le vecteur d'observation :math:`\mathbf{y}^o`. + + Exemple : ``Yo = ADD.get("Observation")`` + + ObservationError + *Matrice*, dont la disponibilité est conditionnée par "*Stored*" en entrée. + C'est la matrice :math:`\mathbf{R}` de covariances des erreurs *a priori* + de l'observation. + + Exemple : ``R = ADD.get("ObservationError")`` + +Toutes les autres informations sont conditionnées par l'algorithme et/ou par la +demande utilisateur de disponibilité. Ce sont les suivantes, par ordre +alphabétique: + + APosterioriCovariance + *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de + covariances des erreurs *a posteriori* de l'état optimal. + + Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` + + BMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'ébauche et l'état optimal. + + Exemple : ``bma = ADD.get("BMA")[-1]`` + + 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")[:]`` + + 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")[:]`` + + Innovation + *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est + en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément + d'évolution. + + Exemple : ``d = ADD.get("Innovation")[-1]`` + + MahalanobisConsistency + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité de Mahalanobis. + + Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]`` + + ObservedState + *Liste de vecteurs*. Chaque élément est un vecteur d'état observé, + c'est-à-dire dans l'espace des observations. + + Exemple : ``Ys = ADD.get("ObservedState")[-1]`` + + OMA + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état optimal dans l'espace des observations. + + Exemple : ``oma = ADD.get("OMA")[-1]`` + + OMB + *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre + l'observation et l'état d'ébauche dans l'espace des observations. + + Exemple : ``omb = ADD.get("OMB")[-1]`` + + SigmaBck2 + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité :math:`(\sigma^b)^2` de la partie ébauche. + + Exemple : ``sb2 = ADD.get("SigmaBck")[-1]`` + + SigmaObs2 + *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de + qualité :math:`(\sigma^o)^2` de la partie observation. + + Exemple : ``so2 = ADD.get("SigmaObs")[-1]`` + + SimulationQuantiles + *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état + observé qui réalise le quantile demandé, dans le même ordre que les + quantiles requis par l'utilisateur. + + Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` -- 2.39.2