From c00df269eaf30b2bb7b5d6a79c22480ec07bed76 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Mon, 8 Nov 2021 13:30:18 +0100 Subject: [PATCH] Minor documentation review corrections (2) --- doc/en/ref_algorithm_3DVAR.rst | 16 +++++++++------ doc/en/ref_algorithm_4DVAR.rst | 16 +++++++++------ doc/en/ref_algorithm_AdjointTest.rst | 16 +++++++++------ doc/en/ref_algorithm_Blue.rst | 16 +++++++++------ ...f_algorithm_DerivativeFreeOptimization.rst | 16 +++++++++------ .../ref_algorithm_DifferentialEvolution.rst | 16 +++++++++------ doc/en/ref_algorithm_EnsembleBlue.rst | 16 +++++++++------ doc/en/ref_algorithm_EnsembleKalmanFilter.rst | 16 +++++++++------ doc/en/ref_algorithm_ExtendedBlue.rst | 16 +++++++++------ doc/en/ref_algorithm_ExtendedKalmanFilter.rst | 16 +++++++++------ doc/en/ref_algorithm_FunctionTest.rst | 16 +++++++++------ doc/en/ref_algorithm_GradientTest.rst | 16 +++++++++------ doc/en/ref_algorithm_KalmanFilter.rst | 16 +++++++++------ doc/en/ref_algorithm_LinearLeastSquares.rst | 16 +++++++++------ doc/en/ref_algorithm_LinearityTest.rst | 16 +++++++++------ doc/en/ref_algorithm_LocalSensitivityTest.rst | 16 +++++++++------ .../ref_algorithm_NonLinearLeastSquares.rst | 16 +++++++++------ doc/en/ref_algorithm_ParallelFunctionTest.rst | 16 +++++++++------ ...ef_algorithm_ParticleSwarmOptimization.rst | 16 +++++++++------ doc/en/ref_algorithm_QuantileRegression.rst | 16 +++++++++------ doc/en/ref_algorithm_SamplingTest.rst | 16 +++++++++------ doc/en/ref_algorithm_TabuSearch.rst | 16 +++++++++------ doc/en/ref_algorithm_TangentTest.rst | 16 +++++++++------ .../ref_algorithm_UnscentedKalmanFilter.rst | 16 +++++++++------ doc/en/ref_assimilation_keywords.rst | 20 +++++++++++-------- doc/fr/ref_algorithm_3DVAR.rst | 15 ++++++++------ doc/fr/ref_algorithm_4DVAR.rst | 15 ++++++++------ doc/fr/ref_algorithm_AdjointTest.rst | 15 ++++++++------ doc/fr/ref_algorithm_Blue.rst | 15 ++++++++------ ...f_algorithm_DerivativeFreeOptimization.rst | 15 ++++++++------ .../ref_algorithm_DifferentialEvolution.rst | 15 ++++++++------ doc/fr/ref_algorithm_EnsembleBlue.rst | 15 ++++++++------ doc/fr/ref_algorithm_EnsembleKalmanFilter.rst | 15 ++++++++------ doc/fr/ref_algorithm_ExtendedBlue.rst | 15 ++++++++------ doc/fr/ref_algorithm_ExtendedKalmanFilter.rst | 15 ++++++++------ doc/fr/ref_algorithm_FunctionTest.rst | 15 ++++++++------ doc/fr/ref_algorithm_GradientTest.rst | 15 ++++++++------ doc/fr/ref_algorithm_KalmanFilter.rst | 15 ++++++++------ doc/fr/ref_algorithm_LinearLeastSquares.rst | 15 ++++++++------ doc/fr/ref_algorithm_LinearityTest.rst | 15 ++++++++------ doc/fr/ref_algorithm_LocalSensitivityTest.rst | 15 ++++++++------ .../ref_algorithm_NonLinearLeastSquares.rst | 15 ++++++++------ doc/fr/ref_algorithm_ParallelFunctionTest.rst | 15 ++++++++------ ...ef_algorithm_ParticleSwarmOptimization.rst | 15 ++++++++------ doc/fr/ref_algorithm_QuantileRegression.rst | 15 ++++++++------ doc/fr/ref_algorithm_SamplingTest.rst | 15 ++++++++------ doc/fr/ref_algorithm_TabuSearch.rst | 15 ++++++++------ doc/fr/ref_algorithm_TangentTest.rst | 15 ++++++++------ .../ref_algorithm_UnscentedKalmanFilter.rst | 15 ++++++++------ doc/fr/ref_assimilation_keywords.rst | 15 +++++++++----- 50 files changed, 478 insertions(+), 301 deletions(-) diff --git a/doc/en/ref_algorithm_3DVAR.rst b/doc/en/ref_algorithm_3DVAR.rst index 55f77e3..1020f38 100644 --- a/doc/en/ref_algorithm_3DVAR.rst +++ b/doc/en/ref_algorithm_3DVAR.rst @@ -102,12 +102,16 @@ initialization point for the minimization, but it is not recommended. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/en/ref_algorithm_4DVAR.rst b/doc/en/ref_algorithm_4DVAR.rst index 95b70ed..514998b 100644 --- a/doc/en/ref_algorithm_4DVAR.rst +++ b/doc/en/ref_algorithm_4DVAR.rst @@ -88,12 +88,16 @@ its application domain is similar to the one of Kalman filters, specially the StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/en/ref_algorithm_AdjointTest.rst b/doc/en/ref_algorithm_AdjointTest.rst index 46a7002..94abd45 100644 --- a/doc/en/ref_algorithm_AdjointTest.rst +++ b/doc/en/ref_algorithm_AdjointTest.rst @@ -65,12 +65,16 @@ take :math:`\mathbf{y} = F(\mathbf{x})`. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "CurrentState", "Residu", "SimulatedObservationAtCurrentState", diff --git a/doc/en/ref_algorithm_Blue.rst b/doc/en/ref_algorithm_Blue.rst index 55d4fe7..17e48ef 100644 --- a/doc/en/ref_algorithm_Blue.rst +++ b/doc/en/ref_algorithm_Blue.rst @@ -84,12 +84,16 @@ these reasons, this method is not proposed nor recommended. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/en/ref_algorithm_DerivativeFreeOptimization.rst b/doc/en/ref_algorithm_DerivativeFreeOptimization.rst index c627bf1..c5bec19 100644 --- a/doc/en/ref_algorithm_DerivativeFreeOptimization.rst +++ b/doc/en/ref_algorithm_DerivativeFreeOptimization.rst @@ -75,12 +75,16 @@ least squares function, classically used in data assimilation. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/en/ref_algorithm_DifferentialEvolution.rst b/doc/en/ref_algorithm_DifferentialEvolution.rst index f7c2cc8..fff7ac6 100644 --- a/doc/en/ref_algorithm_DifferentialEvolution.rst +++ b/doc/en/ref_algorithm_DifferentialEvolution.rst @@ -83,12 +83,16 @@ least squares function, classically used in data assimilation. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/en/ref_algorithm_EnsembleBlue.rst b/doc/en/ref_algorithm_EnsembleBlue.rst index 463f3e3..f2e373e 100644 --- a/doc/en/ref_algorithm_EnsembleBlue.rst +++ b/doc/en/ref_algorithm_EnsembleBlue.rst @@ -61,12 +61,16 @@ linearity of the observation operator with the help of the StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "CurrentState", "Innovation", diff --git a/doc/en/ref_algorithm_EnsembleKalmanFilter.rst b/doc/en/ref_algorithm_EnsembleKalmanFilter.rst index ad8eaf3..6fec56d 100644 --- a/doc/en/ref_algorithm_EnsembleKalmanFilter.rst +++ b/doc/en/ref_algorithm_EnsembleKalmanFilter.rst @@ -111,12 +111,16 @@ obtain less costly data assimilation with hopefully the same quality. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/en/ref_algorithm_ExtendedBlue.rst b/doc/en/ref_algorithm_ExtendedBlue.rst index 7e78238..683baa6 100644 --- a/doc/en/ref_algorithm_ExtendedBlue.rst +++ b/doc/en/ref_algorithm_ExtendedBlue.rst @@ -70,12 +70,16 @@ without being entirely equivalent. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst index 5521a0c..01fb24e 100644 --- a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst @@ -95,12 +95,16 @@ by default), and the extended Kalman filter conducted without any constraint StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/en/ref_algorithm_FunctionTest.rst b/doc/en/ref_algorithm_FunctionTest.rst index 6999539..dbafebd 100644 --- a/doc/en/ref_algorithm_FunctionTest.rst +++ b/doc/en/ref_algorithm_FunctionTest.rst @@ -61,12 +61,16 @@ themselves beforehand with the intended test StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "CurrentState", "SimulatedObservationAtCurrentState", ]. diff --git a/doc/en/ref_algorithm_GradientTest.rst b/doc/en/ref_algorithm_GradientTest.rst index a3798f2..ef19619 100644 --- a/doc/en/ref_algorithm_GradientTest.rst +++ b/doc/en/ref_algorithm_GradientTest.rst @@ -125,12 +125,16 @@ ResiduFormula StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "CurrentState", "Residu", "SimulatedObservationAtCurrentState", diff --git a/doc/en/ref_algorithm_KalmanFilter.rst b/doc/en/ref_algorithm_KalmanFilter.rst index 10eb7bb..212dce3 100644 --- a/doc/en/ref_algorithm_KalmanFilter.rst +++ b/doc/en/ref_algorithm_KalmanFilter.rst @@ -87,12 +87,16 @@ with the help of the :ref:`section_ref_algorithm_LinearityTest`. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/en/ref_algorithm_LinearLeastSquares.rst b/doc/en/ref_algorithm_LinearLeastSquares.rst index 25626ad..b541133 100644 --- a/doc/en/ref_algorithm_LinearLeastSquares.rst +++ b/doc/en/ref_algorithm_LinearLeastSquares.rst @@ -60,12 +60,16 @@ In all cases, it is recommanded to prefer at least the StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "CostFunctionJ", "CostFunctionJAtCurrentOptimum", diff --git a/doc/en/ref_algorithm_LinearityTest.rst b/doc/en/ref_algorithm_LinearityTest.rst index 0bbf477..15ff9f4 100644 --- a/doc/en/ref_algorithm_LinearityTest.rst +++ b/doc/en/ref_algorithm_LinearityTest.rst @@ -147,12 +147,16 @@ ResiduFormula StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "CurrentState", "Residu", "SimulatedObservationAtCurrentState", diff --git a/doc/en/ref_algorithm_LocalSensitivityTest.rst b/doc/en/ref_algorithm_LocalSensitivityTest.rst index 313fd32..61536da 100644 --- a/doc/en/ref_algorithm_LocalSensitivityTest.rst +++ b/doc/en/ref_algorithm_LocalSensitivityTest.rst @@ -64,12 +64,16 @@ Example :* ``numpy.ones()`` StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "CurrentState", "JacobianMatrixAtCurrentState", "SimulatedObservationAtCurrentState", diff --git a/doc/en/ref_algorithm_NonLinearLeastSquares.rst b/doc/en/ref_algorithm_NonLinearLeastSquares.rst index dc96fda..e4f9d2b 100644 --- a/doc/en/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/en/ref_algorithm_NonLinearLeastSquares.rst @@ -74,12 +74,16 @@ for its stability as for its behavior during optimization. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/en/ref_algorithm_ParallelFunctionTest.rst b/doc/en/ref_algorithm_ParallelFunctionTest.rst index def075b..9926fb5 100644 --- a/doc/en/ref_algorithm_ParallelFunctionTest.rst +++ b/doc/en/ref_algorithm_ParallelFunctionTest.rst @@ -61,12 +61,16 @@ themselves beforehand with the intended test StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "CurrentState", "SimulatedObservationAtCurrentState", ]. diff --git a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst index 36a7da5..47a5a85 100644 --- a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst @@ -78,12 +78,16 @@ least squares function, classically used in data assimilation. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/en/ref_algorithm_QuantileRegression.rst b/doc/en/ref_algorithm_QuantileRegression.rst index 9555467..23dfed7 100644 --- a/doc/en/ref_algorithm_QuantileRegression.rst +++ b/doc/en/ref_algorithm_QuantileRegression.rst @@ -60,12 +60,16 @@ the model parameters that satisfy to the quantiles conditions. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/en/ref_algorithm_SamplingTest.rst b/doc/en/ref_algorithm_SamplingTest.rst index 5743cfb..3c6d24d 100644 --- a/doc/en/ref_algorithm_SamplingTest.rst +++ b/doc/en/ref_algorithm_SamplingTest.rst @@ -85,12 +85,16 @@ in SALOME. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "CostFunctionJ", "CostFunctionJb", "CostFunctionJo", diff --git a/doc/en/ref_algorithm_TabuSearch.rst b/doc/en/ref_algorithm_TabuSearch.rst index 48b5530..bb5c138 100644 --- a/doc/en/ref_algorithm_TabuSearch.rst +++ b/doc/en/ref_algorithm_TabuSearch.rst @@ -85,12 +85,16 @@ Positions already explored are kept in a list of finite length. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/en/ref_algorithm_TangentTest.rst b/doc/en/ref_algorithm_TangentTest.rst index 6d1915c..7a3618f 100644 --- a/doc/en/ref_algorithm_TangentTest.rst +++ b/doc/en/ref_algorithm_TangentTest.rst @@ -73,12 +73,16 @@ One take :math:`\mathbf{dx}_0=Normal(0,\mathbf{x})` and StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "CurrentState", "Residu", "SimulatedObservationAtCurrentState", diff --git a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst index 207f5ce..04bc09b 100644 --- a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst @@ -92,12 +92,16 @@ by default), and the "unscented" Kalman filter conducted without any constraint StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *List of names*. This list indicates the names of the supplementary variables - that can be available during or at the end of the algorithm, if they are - initially required by the user. It involves potentially costly calculations - or memory consumptions. The default is a void list, none of these variables - being calculated and stored by default excepted the unconditionnal variables. - The possible names are in the following list: [ + *List of names*. This list indicates the names of the supplementary + variables, that can be available during or at the end of the algorithm, if + they are initially required by the user. Their avalability involves, + potentially, costly calculations or memory consumptions. The default is then + a void list, none of these variables being calculated and stored by default + (excepted the unconditionnal variables). The possible names are in the + following list (the detailed description of each named variable is given in + the following part of this specific algorithmic documentation, in the + sub-section "*Information and variables available at the end of the + algorithm*"): [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/en/ref_assimilation_keywords.rst b/doc/en/ref_assimilation_keywords.rst index 0c03804..acfa0b2 100644 --- a/doc/en/ref_assimilation_keywords.rst +++ b/doc/en/ref_assimilation_keywords.rst @@ -23,11 +23,16 @@ .. _section_ref_assimilation_keywords: -List of commands and keywords for an ADAO calculation case ----------------------------------------------------------- +List of commands and keywords for data assimilation or optimisation case +------------------------------------------------------------------------ -This set of commands is related to the description of a calculation case, -that is a *Data Assimilation* procedure or an *Optimization* procedure. +We summarize here all the commands available to describe a calculation case by +avoiding the particularities of each algorithm. It is therefore a common +inventory of commands. + +The set of commands for an data assimilation or optimisation case is related to +the description of a calculation case, that is a *Data Assimilation* procedure +or an *Optimization* procedure. The first term describes the choice between calculation or checking. In the graphical interface, each of the three types of calculation, individually more @@ -41,10 +46,9 @@ imperatively indicated by one of these commands: .. include:: snippets/REDUCTION_STUDY.rst -The other terms are ordered in alphabetical order. The different commands are -the following: - -.. include:: snippets/ASSIMILATION_STUDY.rst +The other nested terms are listed in alphabetical order. They are not +necessarily required for all algorithms. The different commands are the +following: .. include:: snippets/AlgorithmParameters.rst diff --git a/doc/fr/ref_algorithm_3DVAR.rst b/doc/fr/ref_algorithm_3DVAR.rst index 85acf76..065f5e5 100644 --- a/doc/fr/ref_algorithm_3DVAR.rst +++ b/doc/fr/ref_algorithm_3DVAR.rst @@ -104,13 +104,16 @@ initial de leur minimisation, mais ce n'est pas recommandé. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/fr/ref_algorithm_4DVAR.rst b/doc/fr/ref_algorithm_4DVAR.rst index 6058ccb..96fad52 100644 --- a/doc/fr/ref_algorithm_4DVAR.rst +++ b/doc/fr/ref_algorithm_4DVAR.rst @@ -89,13 +89,16 @@ l':ref:`section_ref_algorithm_UnscentedKalmanFilter`. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/fr/ref_algorithm_AdjointTest.rst b/doc/fr/ref_algorithm_AdjointTest.rst index ee1c2ab..977914c 100644 --- a/doc/fr/ref_algorithm_AdjointTest.rst +++ b/doc/fr/ref_algorithm_AdjointTest.rst @@ -64,13 +64,16 @@ on prend :math:`\mathbf{y} = F(\mathbf{x})`. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "CurrentState", "Residu", "SimulatedObservationAtCurrentState", diff --git a/doc/fr/ref_algorithm_Blue.rst b/doc/fr/ref_algorithm_Blue.rst index 308d8dd..5c7cf7d 100644 --- a/doc/fr/ref_algorithm_Blue.rst +++ b/doc/fr/ref_algorithm_Blue.rst @@ -85,13 +85,16 @@ pas proposée. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst b/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst index 682ac4e..0be1934 100644 --- a/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst +++ b/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst @@ -77,13 +77,16 @@ en assimilation de données. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/fr/ref_algorithm_DifferentialEvolution.rst b/doc/fr/ref_algorithm_DifferentialEvolution.rst index c2444c6..8d40c1e 100644 --- a/doc/fr/ref_algorithm_DifferentialEvolution.rst +++ b/doc/fr/ref_algorithm_DifferentialEvolution.rst @@ -84,13 +84,16 @@ en assimilation de données. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/fr/ref_algorithm_EnsembleBlue.rst b/doc/fr/ref_algorithm_EnsembleBlue.rst index aa65d88..71e1f64 100644 --- a/doc/fr/ref_algorithm_EnsembleBlue.rst +++ b/doc/fr/ref_algorithm_EnsembleBlue.rst @@ -61,13 +61,16 @@ l':ref:`section_ref_algorithm_LinearityTest`. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "CurrentState", "Innovation", diff --git a/doc/fr/ref_algorithm_EnsembleKalmanFilter.rst b/doc/fr/ref_algorithm_EnsembleKalmanFilter.rst index e622fcb..fd3c3cb 100644 --- a/doc/fr/ref_algorithm_EnsembleKalmanFilter.rst +++ b/doc/fr/ref_algorithm_EnsembleKalmanFilter.rst @@ -113,13 +113,16 @@ obtenir une assimilation de données plus économique et de qualité StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/fr/ref_algorithm_ExtendedBlue.rst b/doc/fr/ref_algorithm_ExtendedBlue.rst index 0d76628..7495c73 100644 --- a/doc/fr/ref_algorithm_ExtendedBlue.rst +++ b/doc/fr/ref_algorithm_ExtendedBlue.rst @@ -70,13 +70,16 @@ lui être entièrement équivalent. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst index bd43ae0..afec386 100644 --- a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst @@ -96,13 +96,16 @@ aucune contrainte (la variante nommée "EKF", qui n'est pas recommandée). StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/fr/ref_algorithm_FunctionTest.rst b/doc/fr/ref_algorithm_FunctionTest.rst index 69bd046..ea27e64 100644 --- a/doc/fr/ref_algorithm_FunctionTest.rst +++ b/doc/fr/ref_algorithm_FunctionTest.rst @@ -62,13 +62,16 @@ elles-mêmes avec le test prévu :ref:`section_ref_algorithm_InputValuesTest`. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "CurrentState", "SimulatedObservationAtCurrentState", ]. diff --git a/doc/fr/ref_algorithm_GradientTest.rst b/doc/fr/ref_algorithm_GradientTest.rst index 2610d02..6ef1d35 100644 --- a/doc/fr/ref_algorithm_GradientTest.rst +++ b/doc/fr/ref_algorithm_GradientTest.rst @@ -123,13 +123,16 @@ ResiduFormula StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "CurrentState", "Residu", "SimulatedObservationAtCurrentState", diff --git a/doc/fr/ref_algorithm_KalmanFilter.rst b/doc/fr/ref_algorithm_KalmanFilter.rst index 408c158..d5ef409 100644 --- a/doc/fr/ref_algorithm_KalmanFilter.rst +++ b/doc/fr/ref_algorithm_KalmanFilter.rst @@ -87,13 +87,16 @@ l':ref:`section_ref_algorithm_LinearityTest`. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/fr/ref_algorithm_LinearLeastSquares.rst b/doc/fr/ref_algorithm_LinearLeastSquares.rst index 3261c47..b1d8d5b 100644 --- a/doc/fr/ref_algorithm_LinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_LinearLeastSquares.rst @@ -60,13 +60,16 @@ l':ref:`section_ref_algorithm_3DVAR`. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "CostFunctionJ", "CostFunctionJAtCurrentOptimum", diff --git a/doc/fr/ref_algorithm_LinearityTest.rst b/doc/fr/ref_algorithm_LinearityTest.rst index f3db0aa..cbd8915 100644 --- a/doc/fr/ref_algorithm_LinearityTest.rst +++ b/doc/fr/ref_algorithm_LinearityTest.rst @@ -147,13 +147,16 @@ ResiduFormula StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "CurrentState", "Residu", "SimulatedObservationAtCurrentState", diff --git a/doc/fr/ref_algorithm_LocalSensitivityTest.rst b/doc/fr/ref_algorithm_LocalSensitivityTest.rst index fbcae29..7f80127 100644 --- a/doc/fr/ref_algorithm_LocalSensitivityTest.rst +++ b/doc/fr/ref_algorithm_LocalSensitivityTest.rst @@ -65,13 +65,16 @@ Exemple :* ``numpy.ones()`` StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "CurrentState", "JacobianMatrixAtCurrentState", "SimulatedObservationAtCurrentState", diff --git a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst index 39b305b..2b545ab 100644 --- a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst @@ -75,13 +75,16 @@ comportement lors de l'optimisation. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/fr/ref_algorithm_ParallelFunctionTest.rst b/doc/fr/ref_algorithm_ParallelFunctionTest.rst index b39918b..2141413 100644 --- a/doc/fr/ref_algorithm_ParallelFunctionTest.rst +++ b/doc/fr/ref_algorithm_ParallelFunctionTest.rst @@ -62,13 +62,16 @@ elles-mêmes avec le test prévu :ref:`section_ref_algorithm_InputValuesTest`. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "CurrentState", "SimulatedObservationAtCurrentState", ]. diff --git a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst index 4e1c2a5..e568d29 100644 --- a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst @@ -79,13 +79,16 @@ en assimilation de données. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/fr/ref_algorithm_QuantileRegression.rst b/doc/fr/ref_algorithm_QuantileRegression.rst index eb7ccc3..0edd71f 100644 --- a/doc/fr/ref_algorithm_QuantileRegression.rst +++ b/doc/fr/ref_algorithm_QuantileRegression.rst @@ -60,13 +60,16 @@ déterminer les paramètres de modèles satisfaisant aux conditions de quantiles StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/fr/ref_algorithm_SamplingTest.rst b/doc/fr/ref_algorithm_SamplingTest.rst index e491bb0..40c65f4 100644 --- a/doc/fr/ref_algorithm_SamplingTest.rst +++ b/doc/fr/ref_algorithm_SamplingTest.rst @@ -87,13 +87,16 @@ OPENTURNS disponible dans SALOME. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "CostFunctionJ", "CostFunctionJb", "CostFunctionJo", diff --git a/doc/fr/ref_algorithm_TabuSearch.rst b/doc/fr/ref_algorithm_TabuSearch.rst index b42e8a0..fa1ea2d 100644 --- a/doc/fr/ref_algorithm_TabuSearch.rst +++ b/doc/fr/ref_algorithm_TabuSearch.rst @@ -87,13 +87,16 @@ liste de longueur finie. StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "BMA", "CostFunctionJ", diff --git a/doc/fr/ref_algorithm_TangentTest.rst b/doc/fr/ref_algorithm_TangentTest.rst index 07ec1cc..ab82576 100644 --- a/doc/fr/ref_algorithm_TangentTest.rst +++ b/doc/fr/ref_algorithm_TangentTest.rst @@ -74,13 +74,16 @@ On prend :math:`\mathbf{dx}_0=Normal(0,\mathbf{x})` et StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "CurrentState", "Residu", "SimulatedObservationAtCurrentState", diff --git a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst index 15e6881..4954f62 100644 --- a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst @@ -93,13 +93,16 @@ aucune contrainte (la variante nommée "UKF", qui n'est pas recommandée). StoreSupplementaryCalculations .. index:: single: StoreSupplementaryCalculations - *Liste de noms*. Cette liste indique les noms des variables supplémentaires + *Liste de noms*. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de - l'algorithme, si elles sont initialement demandées par l'utilisateur. 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 sauf les variables inconditionnelles. Les noms possibles - sont dans la liste suivante : [ + l'algorithme, si elles sont initialement demandées par l'utilisateur. Leur + disponibilité implique, potentiellement, des calculs ou du stockage coûteux. + La valeur par défaut est donc une liste vide, aucune de ces variables n'étant + calculée et stockée par défaut (sauf les variables inconditionnelles). Les + noms possibles pour les variables supplémentaires sont dans la liste suivante + (la description détaillée de chaque variable nommée est donnée dans la suite + de cette documentation par algorithme spécifique, dans la sous-partie + "*Informations et variables disponibles à la fin de l'algorithme*") : [ "Analysis", "APosterioriCorrelations", "APosterioriCovariance", diff --git a/doc/fr/ref_assimilation_keywords.rst b/doc/fr/ref_assimilation_keywords.rst index 8d18515..8aea3fa 100644 --- a/doc/fr/ref_assimilation_keywords.rst +++ b/doc/fr/ref_assimilation_keywords.rst @@ -26,9 +26,13 @@ Liste des commandes et mots-clés pour un cas d'assimilation de données ou d'optimisation ---------------------------------------------------------------------------------------- -Ce jeu de commandes est lié à la description d'un cas de calcul, qui est une -procédure d'*Assimilation de Données*, de *Méthodes avec Réduction* ou de -méthodes *Optimisation*. +On résume ici l'ensemble des commandes disponibles pour décrire un cas de +calcul en évitant les particularités de chaque algorithme. C'est donc un +inventaire commun des commandes. + +Le jeu de commandes pour un cas d'assimilation de données ou d'optimisation est +lié à la description d'un cas de calcul, qui est une procédure d'*Assimilation +de Données*, de *Méthodes avec Réduction* ou de méthodes *Optimisation*. Le premier terme décrit le choix entre un calcul ou une vérification. Dans l'interface graphique, chacun des trois types de calculs, individuellement @@ -42,8 +46,9 @@ plusieurs catégories), est impérativement désigné par l'une ces commandes: .. include:: snippets/REDUCTION_STUDY.rst -Les autres termes sont classés par ordre alphabétique. Les différentes -commandes sont les suivantes: +Les autres termes imbriqués sont classés par ordre alphabétique. Ils ne sont +pas obligatoirement requis pour tous les algorithmes. Les différentes commandes +sont les suivantes: .. include:: snippets/AlgorithmParameters.rst -- 2.39.2