From: Jean-Philippe ARGAUD Date: Sun, 1 Mar 2015 21:07:37 +0000 (+0100) Subject: Completing EFICAS tree modification and its documentation X-Git-Tag: V7_6_0~30 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=82d74025c6951b429304212577fa78bc48d26e42;p=modules%2Fadao.git Completing EFICAS tree modification and its documentation --- diff --git a/bin/AdaoCatalogGenerator.py b/bin/AdaoCatalogGenerator.py index 7131540..55ca12c 100644 --- a/bin/AdaoCatalogGenerator.py +++ b/bin/AdaoCatalogGenerator.py @@ -192,7 +192,7 @@ def F_Observers(statut) : return FACT( """ algo_choices = """ -def F_AlgorithmChoices(statut,algos_names) : return FACT( +def F_AlgorithmParameters(statut,algos_names) : return FACT( statut = statut, Algorithm = SIMP(statut="o", typ = "TXM", into = algos_names ), Parameters = SIMP(statut="f", typ = "TXM", into=("Defaults", "Dict") ), @@ -222,7 +222,7 @@ ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY", StudyName = SIMP(statut="o", typ = "TXM", defaut="ADAO Calculation Case"), StudyRepertory = SIMP(statut="f", typ = "Repertoire", min=1, max=1), Debug = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0), - AlgorithmChoices = F_AlgorithmChoices("o",(${algos_names})), + AlgorithmParameters = F_AlgorithmParameters("o",(${algos_names})), Background = F_Background("o"), BackgroundError = F_BackgroundError("o"), Observation = F_Observation("o"), @@ -244,7 +244,7 @@ CHECKING_STUDY = PROC(nom="CHECKING_STUDY", StudyName = SIMP(statut="o", typ = "TXM", defaut="ADAO Checking Case"), StudyRepertory = SIMP(statut="f", typ = "Repertoire", min=1, max=1), Debug = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0), - AlgorithmChoices = F_AlgorithmChoices("o",(${check_names})), + AlgorithmParameters = F_AlgorithmParameters("o",(${check_names})), CheckingPoint = F_CheckingPoint("o"), BackgroundError = F_BackgroundError("f"), Observation = F_Observation("f"), diff --git a/doc/en/examples.rst b/doc/en/examples.rst index c215ac7..a02f4ca 100644 --- a/doc/en/examples.rst +++ b/doc/en/examples.rst @@ -309,11 +309,12 @@ Adding parameters to control the data assimilation algorithm ------------------------------------------------------------ One can add some optional parameters to control the data assimilation algorithm -calculation. This is done by using the "*AlgorithmParameters*" keyword in the -definition of the ADAO case, which is an keyword of the "*ASSIMILATION_STUDY*" -general command. This keyword requires a Python dictionary, containing some -key/value pairs. The list of possible optional parameters are given in the -subsection :ref:`section_reference`. +calculation. This is done by using optional parameters in the +"*AlgorithmParameters*" command of the ADAO case definition, which is a keyword of +the "*ASSIMILATION_STUDY*" general command. This keyword requires an explicit +definition of the values or a Python dictionary, containing some key/value +pairs. The list of possible optional parameters are given in the section +:ref:`section_reference` and its subsections. This dictionary has to be defined, for example, in an external Python script file, using the mandatory variable name "*AlgorithmParameters*" for the diff --git a/doc/en/images/adao_algopar_defaults.png b/doc/en/images/adao_algopar_defaults.png index 181972b..2ad7368 100644 Binary files a/doc/en/images/adao_algopar_defaults.png and b/doc/en/images/adao_algopar_defaults.png differ diff --git a/doc/en/images/adao_algopar_script.png b/doc/en/images/adao_algopar_script.png index fb00575..14db2c7 100644 Binary files a/doc/en/images/adao_algopar_script.png and b/doc/en/images/adao_algopar_script.png differ diff --git a/doc/en/images/adao_algopar_string.png b/doc/en/images/adao_algopar_string.png index 5d4f862..b6ce2de 100644 Binary files a/doc/en/images/adao_algopar_string.png and b/doc/en/images/adao_algopar_string.png differ diff --git a/doc/en/ref_algorithm_3DVAR.rst b/doc/en/ref_algorithm_3DVAR.rst index d25dd6b..d2f442b 100644 --- a/doc/en/ref_algorithm_3DVAR.rst +++ b/doc/en/ref_algorithm_3DVAR.rst @@ -41,6 +41,7 @@ which is usually designed as the "*3D-VAR*" function (see for example Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -95,10 +96,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_AdjointTest.rst b/doc/en/ref_algorithm_AdjointTest.rst index be09ba9..3f67d8d 100644 --- a/doc/en/ref_algorithm_AdjointTest.rst +++ b/doc/en/ref_algorithm_AdjointTest.rst @@ -47,6 +47,7 @@ take :math:`\mathbf{y} = F(\mathbf{x})`. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: AmplitudeOfInitialDirection @@ -74,10 +75,11 @@ following: pair :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allow to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_Blue.rst b/doc/en/ref_algorithm_Blue.rst index 248a37b..8fb5bc2 100644 --- a/doc/en/ref_algorithm_Blue.rst +++ b/doc/en/ref_algorithm_Blue.rst @@ -46,6 +46,7 @@ In case of non-linearity, even slightly marked, it will be easily prefered the Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -94,10 +95,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_EnsembleBlue.rst b/doc/en/ref_algorithm_EnsembleBlue.rst index 6130ede..b7ff885 100644 --- a/doc/en/ref_algorithm_EnsembleBlue.rst +++ b/doc/en/ref_algorithm_EnsembleBlue.rst @@ -43,6 +43,7 @@ linearity of the observation operator with the help of the Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -87,10 +88,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_ExtendedBlue.rst b/doc/en/ref_algorithm_ExtendedBlue.rst index 14b629b..9768399 100644 --- a/doc/en/ref_algorithm_ExtendedBlue.rst +++ b/doc/en/ref_algorithm_ExtendedBlue.rst @@ -44,6 +44,7 @@ without being entirely equivalent. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -92,10 +93,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst index d313387..5726f1f 100644 --- a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst @@ -36,6 +36,7 @@ extended Kalman Filter, using a non-linear calculation of the state. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -83,10 +84,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_FunctionTest.rst b/doc/en/ref_algorithm_FunctionTest.rst index 1b74e3b..c16fbf9 100644 --- a/doc/en/ref_algorithm_FunctionTest.rst +++ b/doc/en/ref_algorithm_FunctionTest.rst @@ -43,6 +43,7 @@ of operator. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: NumberOfPrintedDigits @@ -69,10 +70,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allow to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_GradientTest.rst b/doc/en/ref_algorithm_GradientTest.rst index e588a06..de57cbe 100644 --- a/doc/en/ref_algorithm_GradientTest.rst +++ b/doc/en/ref_algorithm_GradientTest.rst @@ -63,6 +63,7 @@ which has to remain stable until the calculation precision is reached. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: AmplitudeOfInitialDirection @@ -91,10 +92,11 @@ following: pair :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allow to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_KalmanFilter.rst b/doc/en/ref_algorithm_KalmanFilter.rst index dcd35f8..e1d51ab 100644 --- a/doc/en/ref_algorithm_KalmanFilter.rst +++ b/doc/en/ref_algorithm_KalmanFilter.rst @@ -45,6 +45,7 @@ In case of non-linearity, even slightly marked, it will be preferred the Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -90,10 +91,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_LinearLeastSquares.rst b/doc/en/ref_algorithm_LinearLeastSquares.rst index dad7414..29e186d 100644 --- a/doc/en/ref_algorithm_LinearLeastSquares.rst +++ b/doc/en/ref_algorithm_LinearLeastSquares.rst @@ -48,6 +48,7 @@ In all cases, it is recommanded to prefer at least the Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Observation .. index:: single: ObservationError .. index:: single: ObservationOperator @@ -79,10 +80,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_LinearityTest.rst b/doc/en/ref_algorithm_LinearityTest.rst index ab7657e..1716c27 100644 --- a/doc/en/ref_algorithm_LinearityTest.rst +++ b/doc/en/ref_algorithm_LinearityTest.rst @@ -112,6 +112,7 @@ If it is equal to 0 only on part of the variation domain of increment Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: AmplitudeOfInitialDirection @@ -140,10 +141,11 @@ following: pair :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allow to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_NonLinearLeastSquares.rst b/doc/en/ref_algorithm_NonLinearLeastSquares.rst index 19905f2..29d930d 100644 --- a/doc/en/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/en/ref_algorithm_NonLinearLeastSquares.rst @@ -45,6 +45,7 @@ for its stability as for its behaviour during optimization. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: Observation .. index:: single: ObservationError @@ -88,10 +89,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_ObserverTest.rst b/doc/en/ref_algorithm_ObserverTest.rst index b840a97..3c201fb 100644 --- a/doc/en/ref_algorithm_ObserverTest.rst +++ b/doc/en/ref_algorithm_ObserverTest.rst @@ -38,6 +38,7 @@ explicitly associated with the *observer* in the interface. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: Observers diff --git a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst index 843b6b4..e1eca53 100644 --- a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst @@ -41,6 +41,7 @@ least squares function, classicaly used in data assimilation. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -92,10 +93,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_QuantileRegression.rst b/doc/en/ref_algorithm_QuantileRegression.rst index c09e979..c8a417d 100644 --- a/doc/en/ref_algorithm_QuantileRegression.rst +++ b/doc/en/ref_algorithm_QuantileRegression.rst @@ -38,6 +38,7 @@ the model parameters that satisfy to the quantiles conditions. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: Observation .. index:: single: ObservationOperator @@ -72,10 +73,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_SamplingTest.rst b/doc/en/ref_algorithm_SamplingTest.rst index a2aa2d1..baf16fa 100644 --- a/doc/en/ref_algorithm_SamplingTest.rst +++ b/doc/en/ref_algorithm_SamplingTest.rst @@ -51,6 +51,7 @@ SALOME : PARAMETRIC or OPENTURNS. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: BackgroundError .. index:: single: Observation @@ -102,10 +103,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allow to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_TangentTest.rst b/doc/en/ref_algorithm_TangentTest.rst index db6f79f..7b8460d 100644 --- a/doc/en/ref_algorithm_TangentTest.rst +++ b/doc/en/ref_algorithm_TangentTest.rst @@ -55,6 +55,7 @@ One take :math:`\mathbf{dx}_0=Normal(0,\mathbf{x})` and Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: AmplitudeOfInitialDirection @@ -82,10 +83,11 @@ following: pair :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allow to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst index 8f135dc..b628f2d 100644 --- a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst @@ -38,6 +38,7 @@ extended Kalman filter. Optional and required commands ++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -89,10 +90,11 @@ following: :math:`(X,U)`. The general optional commands, available in the editing user interface, are -indicated in :ref:`section_ref_assimilation_keywords`. In particular, the -optional command "*AlgorithmParameters*" allows to choose the specific options, +indicated in :ref:`section_ref_assimilation_keywords`. Moreover, the parameters +of the command "*AlgorithmParameters*" allows to choose the specific options, described hereafter, of the algorithm. See -:ref:`section_ref_options_AlgorithmParameters` for the good use of this command. +:ref:`section_ref_options_Algorithm_Parameters` for the good use of this +command. The options of the algorithm are the following: diff --git a/doc/en/ref_assimilation_keywords.rst b/doc/en/ref_assimilation_keywords.rst index 1c04988..0d4e684 100644 --- a/doc/en/ref_assimilation_keywords.rst +++ b/doc/en/ref_assimilation_keywords.rst @@ -61,18 +61,16 @@ The different commands are the following: assimilation or optimization case. It hierarchically contains all the other commands. - Algorithm - *Required command*. This is a string to indicate the data assimilation or - optimization algorithm chosen. The choices are limited and available through - the GUI. There exists for example "3DVAR", "Blue"... See below the list of - algorithms and associated parameters, each described by a subsection. - AlgorithmParameters - *Optional command*. This command allows to add some optional parameters to - control the data assimilation or optimization algorithm. Its value is - defined as a "*Dict*" type object. See the section - :ref:`section_ref_options_AlgorithmParameters` for for the correct use of - this command. + *Required command*. This indicates the data assimilation or optimization + algorithm chosen by the keyword "*Algorithm*", and its potential optional + parameters. The algorithm choices are available through the GUI. There + exists for example "3DVAR", "Blue"... Each algorithm is defined, below, by a + specific subsection. Optionaly, the command allows also to add some + parameters to control the algorithm. Their values are defined either + explicitly or in a "*Dict*" type object. See the + :ref:`section_ref_options_Algorithm_Parameters` for the detailed use of this + command part. Background *Required command*. This indicates the background or initial vector used, diff --git a/doc/en/ref_checking_keywords.rst b/doc/en/ref_checking_keywords.rst index 63126aa..878c0f5 100644 --- a/doc/en/ref_checking_keywords.rst +++ b/doc/en/ref_checking_keywords.rst @@ -53,18 +53,16 @@ The different commands are the following: *Required command*. This is the general command describing the checking case. It hierarchically contains all the other commands. - Algorithm - *Required command*. This is a string to indicate the checking algorithm chosen. - The choices are limited and available through the GUI. There exists for - example "FunctionTest", "AdjointTest"... See below the list of algorithms - and associated parameters, each described by a subsection. - AlgorithmParameters - *Optional command*. This command allows to add some optional parameters to - control the data assimilation or optimization algorithm. Its value is - defined as a "*Dict*" type object. See the section - :ref:`section_ref_options_AlgorithmParameters` for for the correct use of - this command. + *Required command*. This indicates the checking algorithm chosen by the + keyword "*Algorithm*", and its potential optional parameters. The algorithm + choices are available through the GUI. There exists for example + "FunctionTest", "GradientTest"... Each algorithm is defined, below, by a + specific subsection. Optionaly, the command allows also to add some + parameters to control the algorithm. Their values are defined either + explicitly or in a "*Dict*" type object. See the + :ref:`section_ref_options_Algorithm_Parameters` for the detailed use of this + command part. CheckingPoint *Required command*. This indicates the vector used as the state around which diff --git a/doc/en/ref_options_AlgorithmParameters.rst b/doc/en/ref_options_AlgorithmParameters.rst index b40d046..4261e19 100644 --- a/doc/en/ref_options_AlgorithmParameters.rst +++ b/doc/en/ref_options_AlgorithmParameters.rst @@ -22,29 +22,60 @@ Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D .. index:: single: AlgorithmParameters -.. _section_ref_options_AlgorithmParameters: +.. index:: single: Parameters +.. index:: single: Defaults +.. _section_ref_options_Algorithm_Parameters: -Description of options of an algorithm by "*AlgorithmParameters*" ------------------------------------------------------------------ +Description of options of an algorithm in "*AlgorithmParameters*" +-------------------------------------------------------------- -Each algorithm can be controlled using some specific options, given through the -"*AlgorithmParameters*" optional command. +Each algorithm can be controlled using some specific options or parameters. They +are given through the "*Parameters*" optional command included in the mandatory +command "*AlgorithmParameters*". -There are 2 practical methods for the user to provide these options. The -method is chosen by the keyword "*FROM*", included in the entry -"*AlgorithmParameters*" in EFICAS. +There are 3 practical methods for the user to provide these options. The method +is determined as follows in EFICAS: -If an option is specified by the user for an algorithm that doesn't support it, -the option is simply left unused and don't stop the treatment. The meaning of -the acronyms or particular names can be found in the :ref:`genindex` or the -:ref:`section_glossary`. +#. firstly using the "*Parameters*" keyword in the "*AlgorithmParameters*" command, which allows to choose between "*Defaults*" (use of explicit pre-filled keywords by default parameters values) and "*Dict*" (use of a dictionary to fill the necessary keywords), +#. then secondly, only in the "*Dict*" case of "*Parameters*", by the included keyword "*FROM*" which allows to choose between a string entry and a Python script file entry. -First method : using a string in EFICAS -+++++++++++++++++++++++++++++++++++++++ +If an option or a parameter is specified by the user for an algorithm that +doesn't support it, the option is simply left unused and don't stop the +treatment. The meaning of the acronyms or particular names can be found in the +:ref:`genindex` or the :ref:`section_glossary`. -To give the values for the command "*AlgorithmParameters*" as a string, directly -in the EFICAS graphical interface, the user selects this type in the keyword -"*FROM*", as shown in the following figure: +First method : using explicit pre-filled keywords ++++++++++++++++++++++++++++++++++++++++++++++++++ + +To give the parameters values by explicit pre-filled keywords, directly in the +EFICAS graphical interface, the user selects the type "*Defaults*" in the +keyword "*Parameters*", then the keywords in the given "*Parameters[Algo]*" list +which appears, linked with the chosen algorithm, as shown in the following +figure: + + .. adao_algopar_defaults: + .. image:: images/adao_algopar_defaults.png + :align: center + :width: 100% + .. centered:: + **Using explicit pre-filled keywords for algorithmic parameters** + +Each parameter is optional, and it is presented with its default value when it +is selected by the user. One can then modify its value, or fill it in list cases +for example. + +It is the recommended way to modify only some algorithmic parameters in a safe +way. This method allows only to define authorized paramters for a given +algorithm, and the defined values are not keeped if the user changes the +algorithm. + +Second method : using a string in EFICAS +++++++++++++++++++++++++++++++++++++++++ + +To give the parameters values as a string, directly in the EFICAS graphical +interface, the user selects the type "*Dict*" in the keyword "*Parameters*", +then the type "*String*" in the keyword "*FROM*" of the "*Dict*" command which +appears, as shown in the following figure: .. :adao_algopar_string .. image:: images/adao_algopar_string.png @@ -58,13 +89,17 @@ quotes, as for example:: '{"MaximumNumberOfSteps":25,"SetSeed":1000}' -It is the recommended way to define algorithmic parameters. +It is the recommended way to define algorithmic parameters. This method allows +in particular to keep options or parameters for other algorithms than the +currently used one. It is then easier to change of algorithm or to keep default +values different of the standard defaults. -Second method : using an external Python script file -++++++++++++++++++++++++++++++++++++++++++++++++++++ +Third method : using an external Python script file +++++++++++++++++++++++++++++++++++++++++++++++++++ -To give the values for the command "*AlgorithmParameters*" in an external Python -script file, the user selects in EFICAS this type in the keyword "*FROM*", as +To give the parameters values as an external Python script file, the user +selects in EFICAS the type "*Dict*" in the keyword "*Parameters*", then the type +"*Script*" in the keyword "*FROM*" of the "*Dict*" command which appears, as shown in the following figure: .. :adao_algopar_script @@ -82,4 +117,6 @@ name "*AlgorithmParameters*", as in the following example:: "StoreSupplementaryCalculations" : ["APosterioriCovariance","OMA"], } -The file can also contain other Python commands. +The file can also contain other Python commands. This method also allows, as the +previous one, to keep options or parameters for other algorithms than the +currently used one. diff --git a/doc/en/ref_output_variables.rst b/doc/en/ref_output_variables.rst index f45c147..f7f0079 100644 --- a/doc/en/ref_output_variables.rst +++ b/doc/en/ref_output_variables.rst @@ -146,9 +146,9 @@ 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 the optional control "*AlgorithmParameters*" -of ADAO case. Reference will be made to the -:ref:`section_ref_options_AlgorithmParameters` for the proper use of this +preparation of its ADAO case, using the optional control "*AlgorithmParameters*" of +ADAO case. Reference will be made to the +:ref:`section_ref_options_Algorithm_Parameters` 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. diff --git a/doc/en/using.rst b/doc/en/using.rst index bfbfe2d..6daef08 100644 --- a/doc/en/using.rst +++ b/doc/en/using.rst @@ -119,8 +119,8 @@ A new case is set up with the minimal list of commands. All the mandatory commands or keywords are already present, none of them can be suppressed. Optional keywords can be added by choosing them in a list of suggestions of allowed ones for the main command, for example the "*ASSIMILATION_STUDY*" -command. As an example, one can add an "*AlgorithmParameters*" keyword, as -described in the last part of the section :ref:`section_examples`. +command. As an example, one can add parameters in the "*AlgorithmParameters*" +keyword, as described in the last part of the section :ref:`section_examples`. At the end, when all fields or keywords have been correctly defined, each line of the commands tree must have a green flag. This indicates that the whole case diff --git a/doc/fr/examples.rst b/doc/fr/examples.rst index 7207efb..91ed950 100644 --- a/doc/fr/examples.rst +++ b/doc/fr/examples.rst @@ -328,11 +328,12 @@ Ajout de param ------------------------------------------------------------------------- On peut ajouter des paramètres optionnels pour contrôler le calcul de -l'algorithme d'assimilation de données. Ceci se fait en utilisant le mot-clé -"*AlgorithmParameters*" dans la définition du cas ADAO, qui est un mot-clé de la -commande générale "*ASSIMILATION_STUDY*". Ce mot-clé nécessite un dictionnaire -Python, contenant des paires clé/valeur. La liste des paramètres optionnels -possibles sont donnés dans la section :ref:`section_reference`. +l'algorithme d'assimilation de données. Ceci se fait en utilisant les paramètres +optionnels dans la commande "*AlgorithmParameters*" de la définition du cas ADAO, +qui est un mot-clé de la commande générale "*ASSIMILATION_STUDY*". Ce mot-clé +nécessite une définition explicite des valeurs ou un dictionnaire Python, +contenant des paires clé/valeur. La liste des paramètres optionnels possibles +sont donnés dans la section :ref:`section_reference` et ses sous-sections. Le dictionnaire doit être défini, par exemple, dans un fichiers externe de script Python, en utilisant le nom obligatoire de variable diff --git a/doc/fr/images/adao_algopar_defaults.png b/doc/fr/images/adao_algopar_defaults.png index 05a6272..c3e2dd4 100644 Binary files a/doc/fr/images/adao_algopar_defaults.png and b/doc/fr/images/adao_algopar_defaults.png differ diff --git a/doc/fr/images/adao_algopar_script.png b/doc/fr/images/adao_algopar_script.png index ecc4c4e..dbbb7f8 100644 Binary files a/doc/fr/images/adao_algopar_script.png and b/doc/fr/images/adao_algopar_script.png differ diff --git a/doc/fr/images/adao_algopar_string.png b/doc/fr/images/adao_algopar_string.png index bef0aa8..361ad80 100644 Binary files a/doc/fr/images/adao_algopar_string.png and b/doc/fr/images/adao_algopar_string.png differ diff --git a/doc/fr/ref_algorithm_3DVAR.rst b/doc/fr/ref_algorithm_3DVAR.rst index be8dc6e..abea537 100644 --- a/doc/fr/ref_algorithm_3DVAR.rst +++ b/doc/fr/ref_algorithm_3DVAR.rst @@ -42,6 +42,7 @@ qui est usuellement d Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -97,10 +98,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_AdjointTest.rst b/doc/fr/ref_algorithm_AdjointTest.rst index 6abff76..a8b0acf 100644 --- a/doc/fr/ref_algorithm_AdjointTest.rst +++ b/doc/fr/ref_algorithm_AdjointTest.rst @@ -46,6 +46,7 @@ prend :math:`\mathbf{y} = F(\mathbf{x})`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: AmplitudeOfInitialDirection @@ -74,10 +75,10 @@ les suivantes: paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_checking_keywords`. En particulier, la -commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_Blue.rst b/doc/fr/ref_algorithm_Blue.rst index ae1205a..a748630 100644 --- a/doc/fr/ref_algorithm_Blue.rst +++ b/doc/fr/ref_algorithm_Blue.rst @@ -47,6 +47,7 @@ l':ref:`section_ref_algorithm_3DVAR`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -96,10 +97,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_EnsembleBlue.rst b/doc/fr/ref_algorithm_EnsembleBlue.rst index b146e74..d8add0d 100644 --- a/doc/fr/ref_algorithm_EnsembleBlue.rst +++ b/doc/fr/ref_algorithm_EnsembleBlue.rst @@ -43,6 +43,7 @@ l':ref:`section_ref_algorithm_LinearityTest`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -88,10 +89,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_ExtendedBlue.rst b/doc/fr/ref_algorithm_ExtendedBlue.rst index 5a9ff1b..6b0b152 100644 --- a/doc/fr/ref_algorithm_ExtendedBlue.rst +++ b/doc/fr/ref_algorithm_ExtendedBlue.rst @@ -44,6 +44,7 @@ lui Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -93,10 +94,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst index a3ffabb..ced362f 100644 --- a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst @@ -37,6 +37,7 @@ incr Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -85,10 +86,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_FunctionTest.rst b/doc/fr/ref_algorithm_FunctionTest.rst index 7e42b2b..587ba40 100644 --- a/doc/fr/ref_algorithm_FunctionTest.rst +++ b/doc/fr/ref_algorithm_FunctionTest.rst @@ -45,6 +45,7 @@ d'op Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: NumberOfPrintedDigits @@ -72,10 +73,10 @@ les suivantes: paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_checking_keywords`. En particulier, la -commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_GradientTest.rst b/doc/fr/ref_algorithm_GradientTest.rst index 5a555ec..61bd4fe 100644 --- a/doc/fr/ref_algorithm_GradientTest.rst +++ b/doc/fr/ref_algorithm_GradientTest.rst @@ -67,6 +67,7 @@ qui doit rester constant jusqu' Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: AmplitudeOfInitialDirection @@ -96,10 +97,10 @@ les suivantes: paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_checking_keywords`. En particulier, la -commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_KalmanFilter.rst b/doc/fr/ref_algorithm_KalmanFilter.rst index 195f99c..e159698 100644 --- a/doc/fr/ref_algorithm_KalmanFilter.rst +++ b/doc/fr/ref_algorithm_KalmanFilter.rst @@ -45,6 +45,7 @@ l':ref:`section_ref_algorithm_UnscentedKalmanFilter`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -91,10 +92,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_LinearLeastSquares.rst b/doc/fr/ref_algorithm_LinearLeastSquares.rst index 10bc9ce..89669b1 100644 --- a/doc/fr/ref_algorithm_LinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_LinearLeastSquares.rst @@ -48,6 +48,7 @@ l':ref:`section_ref_algorithm_3DVAR`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Observation .. index:: single: ObservationError .. index:: single: ObservationOperator @@ -80,10 +81,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_LinearityTest.rst b/doc/fr/ref_algorithm_LinearityTest.rst index e399dce..3a9cb4b 100644 --- a/doc/fr/ref_algorithm_LinearityTest.rst +++ b/doc/fr/ref_algorithm_LinearityTest.rst @@ -111,6 +111,7 @@ de F est v Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: AmplitudeOfInitialDirection @@ -140,10 +141,10 @@ les suivantes: paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_checking_keywords`. En particulier, la -commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst index 8a57523..bceef23 100644 --- a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst @@ -46,6 +46,7 @@ comportement lors de l'optimisation. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: Observation .. index:: single: ObservationError @@ -90,10 +91,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_ObserverTest.rst b/doc/fr/ref_algorithm_ObserverTest.rst index dd9873c..73ce4f4 100644 --- a/doc/fr/ref_algorithm_ObserverTest.rst +++ b/doc/fr/ref_algorithm_ObserverTest.rst @@ -39,6 +39,7 @@ l'interface. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: Observers diff --git a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst index ff6fcb6..a7320c4 100644 --- a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst @@ -42,6 +42,7 @@ en assimilation de donn Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -94,10 +95,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_QuantileRegression.rst b/doc/fr/ref_algorithm_QuantileRegression.rst index be80ca4..dd6fe00 100644 --- a/doc/fr/ref_algorithm_QuantileRegression.rst +++ b/doc/fr/ref_algorithm_QuantileRegression.rst @@ -38,6 +38,7 @@ d Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: Observation .. index:: single: ObservationOperator @@ -73,10 +74,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_SamplingTest.rst b/doc/fr/ref_algorithm_SamplingTest.rst index b4f689e..e16b997 100644 --- a/doc/fr/ref_algorithm_SamplingTest.rst +++ b/doc/fr/ref_algorithm_SamplingTest.rst @@ -52,6 +52,7 @@ modules disponibles dans SALOME : PARAMETRIC ou OPENTURNS. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: BackgroundError .. index:: single: Observation @@ -105,10 +106,10 @@ les suivantes: paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_checking_keywords`. En particulier, la -commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_TangentTest.rst b/doc/fr/ref_algorithm_TangentTest.rst index f421120..2058572 100644 --- a/doc/fr/ref_algorithm_TangentTest.rst +++ b/doc/fr/ref_algorithm_TangentTest.rst @@ -56,6 +56,7 @@ On prend :math:`\mathbf{dx}_0=Normal(0,\mathbf{x})` et Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: CheckingPoint .. index:: single: ObservationOperator .. index:: single: AmplitudeOfInitialDirection @@ -84,10 +85,10 @@ les suivantes: paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_checking_keywords`. En particulier, la -commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst index d8d13d3..50dc661 100644 --- a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst @@ -38,6 +38,7 @@ comme dans les filtres de Kalman simple ou Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ +.. index:: single: AlgorithmParameters .. index:: single: Background .. index:: single: BackgroundError .. index:: single: Observation @@ -90,10 +91,10 @@ les suivantes: appliqué à une paire :math:`(X,U)`. Les commandes optionnelles générales, disponibles dans l'interface en édition, -sont indiquées dans la :ref:`section_ref_assimilation_keywords`. En particulier, -la commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options +sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les +paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les options particulières, décrites ci-après, de l'algorithme. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette commande. Les options de l'algorithme sont les suivantes: diff --git a/doc/fr/ref_assimilation_keywords.rst b/doc/fr/ref_assimilation_keywords.rst index b0a0656..067ea5b 100644 --- a/doc/fr/ref_assimilation_keywords.rst +++ b/doc/fr/ref_assimilation_keywords.rst @@ -61,19 +61,17 @@ Les diff d'assimilation de données ou d'optimisation. Elle contient hiérarchiquement toutes les autres commandes. - Algorithm - *Commande obligatoire*. C'est une chaîne de caractère qui indique - l'algorithme d'assimilation de données ou d'optimisation choisi. Les choix - sont limités et disponibles à travers l'interface graphique. Il existe par - exemple le "3DVAR", le "Blue"... Voir plus loin la liste des algorithmes et - des paramètres associés, chacun décrit par une sous-section. - AlgorithmParameters - *Commande optionnelle*. Elle permet d'ajouter des paramètres optionnels pour - contrôler l'algorithme d'assimilation de données ou d'optimisation. Sa - valeur est définie comme un objet de type "*Dict*". Voir la - :ref:`section_ref_options_AlgorithmParameters` pour l'usage correct de cette - commande. + *Commande obligatoire*. Elle définit l'algorithme d'assimilation de données + ou d'optimisation choisi par le mot-clé "*Algorithm*", et ses éventuels + paramètres optionnels. Les choix d'algorithmes sont disponibles à travers + l'interface graphique. Il existe par exemple le "3DVAR", le "Blue"... Chaque + algorithme est défini, plus loin, par une sous-section spécifique. De + manière facultative, la commande permet aussi d'ajouter des paramètres pour + contrôler l'algorithme. Leurs valeurs sont définies explicitement ou dans un + objet de type "*Dict*". On se reportera à la + :ref:`section_ref_options_Algorithm_Parameters` pour l'usage détaillé de + cette partie de la commande. Background *Commande obligatoire*. Elle définit le vecteur d'ébauche ou diff --git a/doc/fr/ref_checking_keywords.rst b/doc/fr/ref_checking_keywords.rst index 147092f..cf6840d 100644 --- a/doc/fr/ref_checking_keywords.rst +++ b/doc/fr/ref_checking_keywords.rst @@ -53,19 +53,17 @@ Les diff *Commande obligatoire*. C'est la commande générale qui décrit le cas de vérification. Elle contient hiérarchiquement toutes les autres commandes. - Algorithm - *Commande obligatoire*. C'est une chaîne de caractère qui indique - l'algorithme de test choisi. Les choix sont limités et disponibles à travers - l'interface graphique. Il existe par exemple "FunctionTest", - "AdjointTest"... Voir plus loin la liste des algorithmes et des paramètres - associés, chacun décrit par une sous-section. - AlgorithmParameters - *Commande optionnelle*. Elle permet d'ajouter des paramètres optionnels pour - contrôler l'algorithme d'assimilation de données ou d'optimisation. Sa - valeur est définie comme un objet de type "*Dict*". Voir la - :ref:`section_ref_options_AlgorithmParameters` pour l'usage correct de cette - commande. + *Commande obligatoire*. Elle définit l'algorithme de test choisi par le + mot-clé "*Algorithm*", et ses éventuels paramètres optionnels. Les choix + d'algorithmes sont disponibles à travers l'interface graphique. Il existe + par exemple le "FunctionTest", le "GradientTest"... Chaque algorithme est + défini, plus loin, par une sous-section spécifique. De manière facultative, + la commande permet aussi d'ajouter des paramètres pour contrôler + l'algorithme. Leurs valeurs sont définies explicitement ou dans un objet de + type "*Dict*". On se reportera à la + :ref:`section_ref_options_Algorithm_Parameters` pour l'usage détaillé de + cette partie de la commande. CheckingPoint *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour diff --git a/doc/fr/ref_options_AlgorithmParameters.rst b/doc/fr/ref_options_AlgorithmParameters.rst index 2c347e5..875ec16 100644 --- a/doc/fr/ref_options_AlgorithmParameters.rst +++ b/doc/fr/ref_options_AlgorithmParameters.rst @@ -22,30 +22,61 @@ Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D .. index:: single: AlgorithmParameters -.. _section_ref_options_AlgorithmParameters: +.. index:: single: Parameters +.. index:: single: Defaults +.. _section_ref_options_Algorithm_Parameters: -Description des options d'un algorithme par "*AlgorithmParameters*" -------------------------------------------------------------------- +Description des options d'un algorithme dans "*AlgorithmParameters*" +----------------------------------------------------------------- -Chaque algorithme peut être contrôlé en utilisant des options particulières, -données à travers la commande optionnelle "*AlgorithmParameters*". +Chaque algorithme peut être contrôlé en utilisant des options ou des paramètres +particuliers. Ils sont donnés à travers la commande optionnelle "*Parameters*" +incluse dans la commande obligatoire "*AlgorithmParameters*". -Il y a 2 méthodes pratiques pour l'utilisateur pour fournir ces options. La -méthode est choisie à l'aide du mot-clé "*FROM*", inclus dans l'entrée -"*AlgorithmParameters*" dans EFICAS. +Il y a 3 méthodes pratiques pour l'utilisateur pour fournir ces options. La +méthode est déterminée de la manière suivante dans EFICAS : -Si une option est spécifiée par l'utilisateur pour un algorithme qui ne la -supporte pas, cette option est simplement laissée inutilisée et ne bloque pas le -traitement. La signification des acronymes ou des noms particuliers peut être -trouvée dans l':ref:`genindex` ou dans le :ref:`section_glossary`. +#. premièrement à l'aide du mot-clé "*Parameters*" dans la commande "*AlgorithmParameters*", qui permet de choisir entre "*Defaults*" (utilisation de mots-clés explicites pré-remplis par les valeurs par défaut des paramètres) et "*Dict*" (utilisation d'un dictionnaire pour renseigner les mots-clés nécessaires), +#. puis deuxièmement, uniquement dans le cas "*Dict*" de "*Parameters*", par le mot-clé "*FROM*" inclus qui permet de choisir entre une entrée par chaîne de caractères ou une entrée par fichier de script Python. -Première méthode : utiliser une chaîne de caractères dans EFICAS +Si une option ou un paramètre est spécifié par l'utilisateur pour un algorithme +qui ne la supporte pas, cette option est simplement laissée inutilisée et ne +bloque pas le traitement. La signification des acronymes ou des noms +particuliers peut être trouvée dans l':ref:`genindex` ou dans le +:ref:`section_glossary`. + +Première méthode : utiliser les mots-clés explicites pré-remplis ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -Pour donner les valeurs de la commande "*AlgorithmParameters*" par une chaîne de -caractères, directement dans l'interface graphique EFICAS, l'utilisateur -sélectionne ce type dans le mot-clé "*FROM*", comme montré dans la figure qui -suit : +Pour donner les valeurs des paramètres par les mots-clés explicites pré-remplis, +directement dans l'interface graphique EFICAS, l'utilisateur sélectionne le type +"*Defaults*" dans le mot-clé "*Parameters*", puis les mots-clés dans la liste +prévue "*Parameters[Algo]*" qui apparaît, associée à l'algorithme choisi, comme +montré dans la figure qui suit : + + .. adao_algopar_defaults: + .. image:: images/adao_algopar_defaults.png + :align: center + :width: 100% + .. centered:: + **Utiliser les mots-clés explicites pré-remplis pour les paramètres algorithmiques** + +Chaque paramètre est optionnel, et il présente sa valeur par défaut lorsqu'il +est sélectionné par l'utilisateur. On peut alors modifier sa valeur, ou la +renseigner dans le cas de listes par exemple. + +C'est la manière recommandée pour modifier uniquement une partie des paramètres +algorithmiques de manière sûre. Cette méthode ne permet de définir que les +paramètres autorisés pour un algorithme donné, et les valeurs définies ne sont +pas conservées si l'utilisateur change d'algorithme. + +Seconde méthode : utiliser une chaîne de caractères dans EFICAS ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Pour donner les valeurs des paramètres par une chaîne de caractères, directement +dans l'interface graphique EFICAS, l'utilisateur sélectionne le type "*Dict*" +dans le mot-clé "*Parameters*", puis le type "*String*" dans le mot-clé "*FROM*" +de la commande "*Dict*" qui apparaît, comme montré dans la figure qui suit : .. adao_algopar_string: .. image:: images/adao_algopar_string.png @@ -59,14 +90,19 @@ d '{"MaximumNumberOfSteps":25,"SetSeed":1000}' -C'est la manière recommandée pour définir des paramètres algorithmiques. +C'est la manière recommandée pour définir des paramètres algorithmiques. Cette +méthode permet en particulier de conserver des options ou des paramètres pour +d'autres algorithmes que celui que l'on utilise au moment présent. Cela facilite +le changement d'algorithme ou la conservation de valeurs par défaut différentes +des défauts standards. -Seconde méthode : utiliser un fichier de script Python externe -++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +Troisième méthode : utiliser un fichier de script Python externe +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -Pour donner les valeurs de la commande "*AlgorithmParameters*" par un fichier de -script Python externe, l'utilisateur sélectionne dans EFICAS ce type dans le -mot-clé "*FROM*", comme montré dans la figure qui suit : +Pour donner les valeurs des paramètres par un fichier de script Python externe, +l'utilisateur sélectionne dans EFICAS le type "*Dict*" dans le mot-clé +"*Parameters*", puis le type "*Script*" dans le mot-clé "*FROM*" de la commande +"*Dict*" qui apparaît, comme montré dans la figure qui suit : .. :adao_algopar_script .. image:: images/adao_algopar_script.png @@ -83,4 +119,6 @@ Ce fichier script Python externe doit d "StoreSupplementaryCalculations" : ["APosterioriCovariance","OMA"], } -Le fichier peut aussi contenir d'autres commandes Python. +Le fichier peut aussi contenir d'autres commandes Python. Cette méthode permet +aussi, comme la précédente, de conserver des options ou des paramètres pour +d'autres algorithmes que celui que l'on utilise. diff --git a/doc/fr/ref_output_variables.rst b/doc/fr/ref_output_variables.rst index 7565fbe..1f7e64a 100644 --- a/doc/fr/ref_output_variables.rst +++ b/doc/fr/ref_output_variables.rst @@ -152,7 +152,7 @@ et/ou que si elles ont On rappelle que l'utilisateur peut réclamer des informations supplémentaires lors de l'établissement de son cas ADAO, en utilisant la commande optionnelle "*AlgorithmParameters*" du cas ADAO. On se reportera à la -:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette +:ref:`section_ref_options_Algorithm_Parameters` 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é diff --git a/doc/fr/using.rst b/doc/fr/using.rst index 1c4cbf8..a93e5e2 100644 --- a/doc/fr/using.rst +++ b/doc/fr/using.rst @@ -124,8 +124,8 @@ commandes ou les mots-cl être supprimé. Des mots-clés optionnels peuvent être ajoutés en les choisissant dans une liste de suggestions de ceux autorisés pour la commande principale, par exemple la commande "*ASSIMILATION_STUDY*". À titre d'exemple, on peut ajouter -un mot-clé "*AlgorithmParameters*", comme décrit dans la dernière partie de la -section :ref:`section_examples`. +des paramètres dans le mot-clé "*AlgorithmParameters*", comme décrit dans la +dernière partie de la section :ref:`section_examples`. A la fin de ces actions, lorsque tous les champs ou les mots-clés ont été correctement définis, chaque ligne de l'arborescence des commandes doit diff --git a/examples/daSalome/test001_ADAO_JDC_using_strings.comm b/examples/daSalome/test001_ADAO_JDC_using_strings.comm index 26c4d74..e2db6ef 100644 --- a/examples/daSalome/test001_ADAO_JDC_using_strings.comm +++ b/examples/daSalome/test001_ADAO_JDC_using_strings.comm @@ -1,7 +1,7 @@ ASSIMILATION_STUDY(StudyName='Test', Debug=0, - AlgorithmChoices=_F(Algorithm='Blue',), + AlgorithmParameters=_F(Algorithm='Blue',), Background=_F(Stored=0, INPUT_TYPE='Vector', data=_F(FROM='String', @@ -29,4 +29,4 @@ ASSIMILATION_STUDY(StudyName='Test', xa=numpy.ravel(ADD.get('Analysis')[-1]) print 'Analysis:',xa""",),); #VERSION_CATALOGUE:V7_6_0:FIN VERSION_CATALOGUE -#CHECKSUM:05cc41b743bfb035b9bcc0bba13f31f8 -:FIN CHECKSUM \ No newline at end of file + diff --git a/examples/daSalome/test002_ADAO_JDC_using_strings.comm b/examples/daSalome/test002_ADAO_JDC_using_strings.comm index 407d76e..8ded8ca 100644 --- a/examples/daSalome/test002_ADAO_JDC_using_strings.comm +++ b/examples/daSalome/test002_ADAO_JDC_using_strings.comm @@ -1,7 +1,7 @@ ASSIMILATION_STUDY(StudyName='Test', Debug=0, - AlgorithmChoices=_F(Algorithm='3DVAR',), + AlgorithmParameters=_F(Algorithm='3DVAR',), Background=_F(Stored=0, INPUT_TYPE='Vector', data=_F(FROM='String', @@ -29,4 +29,4 @@ ASSIMILATION_STUDY(StudyName='Test', xa=numpy.ravel(ADD.get('Analysis')[-1]) print 'Analysis:',xa""",),); #VERSION_CATALOGUE:V7_6_0:FIN VERSION_CATALOGUE -#CHECKSUM:58b5740b60d070b936a5b8952002fa5b -:FIN CHECKSUM \ No newline at end of file + diff --git a/examples/daSalome/test003_ADAO_JDC_using_scripts.comm.in b/examples/daSalome/test003_ADAO_JDC_using_scripts.comm.in index 744b878..5f5bc0b 100644 --- a/examples/daSalome/test003_ADAO_JDC_using_scripts.comm.in +++ b/examples/daSalome/test003_ADAO_JDC_using_scripts.comm.in @@ -1,7 +1,7 @@ ASSIMILATION_STUDY(StudyName='Test', StudyRepertory='@prefix@/share/salome/adao_examples/daSalome', - AlgorithmChoices=_F(Algorithm='3DVAR',), + AlgorithmParameters=_F(Algorithm='3DVAR',), Background=_F(Stored=0, INPUT_TYPE='Vector', data=_F(FROM='Script', diff --git a/examples/daSalome/test003_bis_ADAO_JDC_using_user_data_init.comm.in b/examples/daSalome/test003_bis_ADAO_JDC_using_user_data_init.comm.in index b0f3868..2dc3ce7 100644 --- a/examples/daSalome/test003_bis_ADAO_JDC_using_user_data_init.comm.in +++ b/examples/daSalome/test003_bis_ADAO_JDC_using_user_data_init.comm.in @@ -1,7 +1,7 @@ ASSIMILATION_STUDY(StudyName='Test', StudyRepertory='@prefix@/share/salome/adao_examples/daSalome', - AlgorithmChoices=_F(Algorithm='3DVAR',), + AlgorithmParameters=_F(Algorithm='3DVAR',), Background=_F(Stored=0, INPUT_TYPE='Vector', data=_F(FROM='Script', diff --git a/examples/daSalome/test004_ADAO_JDC_using_scripts.comm.in b/examples/daSalome/test004_ADAO_JDC_using_scripts.comm.in index 35a6feb..d29e26a 100644 --- a/examples/daSalome/test004_ADAO_JDC_using_scripts.comm.in +++ b/examples/daSalome/test004_ADAO_JDC_using_scripts.comm.in @@ -1,7 +1,7 @@ ASSIMILATION_STUDY(StudyName='Test', StudyRepertory='@prefix@/share/salome/adao_examples/daSalome', - AlgorithmChoices=_F(Algorithm='Blue',), + AlgorithmParameters=_F(Algorithm='Blue',), Background=_F(Stored=0, INPUT_TYPE='Vector', data=_F(FROM='Script', diff --git a/examples/daSalome/test005_ADAO_Operators.comm.in b/examples/daSalome/test005_ADAO_Operators.comm.in index d2f71c6..a2985ed 100644 --- a/examples/daSalome/test005_ADAO_Operators.comm.in +++ b/examples/daSalome/test005_ADAO_Operators.comm.in @@ -1,7 +1,7 @@ ASSIMILATION_STUDY(StudyName='Test', StudyRepertory='@prefix@/share/salome/adao_examples/daSalome', - AlgorithmChoices=_F(Algorithm='3DVAR',), + AlgorithmParameters=_F(Algorithm='3DVAR',), Background=_F(Stored=0, INPUT_TYPE='Vector', data=_F(FROM='String', diff --git a/examples/daSalome/test006_Observers.comm.in b/examples/daSalome/test006_Observers.comm.in index 62df329..6b18f69 100644 --- a/examples/daSalome/test006_Observers.comm.in +++ b/examples/daSalome/test006_Observers.comm.in @@ -1,10 +1,10 @@ ASSIMILATION_STUDY(StudyName='test_observers', StudyRepertory='@prefix@/share/salome/adao_examples/daSalome', - AlgorithmChoices=_F(Algorithm='3DVAR', - Parameters='Dict', - data=_F(FROM='Script', - SCRIPT_FILE='test006_Observers_var.py',),), + AlgorithmParameters=_F(Algorithm='3DVAR', + Parameters='Dict', + data=_F(FROM='Script', + SCRIPT_FILE='test006_Observers_var.py',),), Background=_F(Stored=0, INPUT_TYPE='Vector', data=_F(FROM='Script', @@ -23,10 +23,12 @@ ASSIMILATION_STUDY(StudyName='test_observers', SCRIPT_FILE='test006_Observers_var.py',),), ObservationOperator=_F(Stored=0, INPUT_TYPE='Function', - data=_F(FROM='FunctionDict', - FUNCTIONDICT_FILE='test006_Observers_Observation_Operator.py',),), + data=_F(FROM='ScriptWithSwitch', + SCRIPTWITHSWITCH_FILE='test006_Observers_Observation_Operator.py',),), UserDataInit=_F(INIT_FILE='test006_Observers_init.py', - TARGET_LIST=('Background','BackgroundError','Observation','ObservationError',),), + TARGET_LIST= + ('Background','BackgroundError','Observation', + 'ObservationError','AlgorithmParameters',),), UserPostAnalysis=_F(FROM='Template', Template='AnalysisPrinter', ValueTemplate= diff --git a/examples/daSalome/test006_Observers.py.in b/examples/daSalome/test006_Observers.py.in index 16b717e..6886326 100644 --- a/examples/daSalome/test006_Observers.py.in +++ b/examples/daSalome/test006_Observers.py.in @@ -33,16 +33,16 @@ ObservationError_config['From'] = 'Script' ObservationError_config['Data'] = 'test006_Observers_var.py' ObservationError_config['Stored'] = '0' study_config['ObservationError'] = ObservationError_config -ObservationOperator_FunctionDict = {} -ObservationOperator_FunctionDict['Function'] = ['Direct', 'Tangent', 'Adjoint'] -ObservationOperator_FunctionDict['Script'] = {} -ObservationOperator_FunctionDict['Script']['Direct'] = 'test006_Observers_Observation_Operator.py' -ObservationOperator_FunctionDict['Script']['Tangent'] = 'test006_Observers_Observation_Operator.py' -ObservationOperator_FunctionDict['Script']['Adjoint'] = 'test006_Observers_Observation_Operator.py' +ObservationOperator_ScriptWithSwitch = {} +ObservationOperator_ScriptWithSwitch['Function'] = ['Direct', 'Tangent', 'Adjoint'] +ObservationOperator_ScriptWithSwitch['Script'] = {} +ObservationOperator_ScriptWithSwitch['Script']['Direct'] = 'test006_Observers_Observation_Operator.py' +ObservationOperator_ScriptWithSwitch['Script']['Tangent'] = 'test006_Observers_Observation_Operator.py' +ObservationOperator_ScriptWithSwitch['Script']['Adjoint'] = 'test006_Observers_Observation_Operator.py' ObservationOperator_config = {} ObservationOperator_config['Type'] = 'Function' -ObservationOperator_config['From'] = 'FunctionDict' -ObservationOperator_config['Data'] = ObservationOperator_FunctionDict +ObservationOperator_config['From'] = 'ScriptWithSwitch' +ObservationOperator_config['Data'] = ObservationOperator_ScriptWithSwitch study_config['ObservationOperator'] = ObservationOperator_config inputvariables_config = {} inputvariables_config['Order'] =['adao_default'] @@ -63,7 +63,7 @@ Init_config = {} Init_config['Type'] = 'Dict' Init_config['From'] = 'Script' Init_config['Data'] = 'test006_Observers_init.py' -Init_config['Target'] = ['Background','BackgroundError','Observation','ObservationError',] +Init_config['Target'] = ['Background','BackgroundError','Observation','ObservationError','AlgorithmParameters',] study_config['UserDataInit'] = Init_config observers = {} observers["CostFunctionJ"] = {} diff --git a/examples/daSalome/test008_ADAO_Elementary_GradientTest.comm b/examples/daSalome/test008_ADAO_Elementary_GradientTest.comm index cef9bdf..71142d8 100644 --- a/examples/daSalome/test008_ADAO_Elementary_GradientTest.comm +++ b/examples/daSalome/test008_ADAO_Elementary_GradientTest.comm @@ -1,6 +1,6 @@ CHECKING_STUDY(StudyName='Elementary gradient test', - AlgorithmChoices=_F(Algorithm='GradientTest', + AlgorithmParameters=_F(Algorithm='GradientTest', Parameters='Dict', data=_F(FROM='String', STRING='{ "SetSeed" : 1000 }',),), @@ -13,4 +13,4 @@ CHECKING_STUDY(StudyName='Elementary gradient test', data=_F(FROM='String', STRING='1 0 0 ; 0 1 0 ; 0 0 1',),),); #VERSION_CATALOGUE:V7_6_0:FIN VERSION_CATALOGUE -#CHECKSUM:1b2edbf93b6252687f4a9dc33dc25dc0 -:FIN CHECKSUM \ No newline at end of file + diff --git a/examples/daSalome/test009_ADAO_Simple_GradientTest.comm b/examples/daSalome/test009_ADAO_Simple_GradientTest.comm index e1746e5..eebe77c 100644 --- a/examples/daSalome/test009_ADAO_Simple_GradientTest.comm +++ b/examples/daSalome/test009_ADAO_Simple_GradientTest.comm @@ -1,6 +1,6 @@ CHECKING_STUDY(StudyName='Test', - AlgorithmChoices=_F(Algorithm='GradientTest', + AlgorithmParameters=_F(Algorithm='GradientTest', Parameters='Dict', data=_F(FROM='String', STRING='{ "SetSeed" : 1000 }',),), @@ -13,4 +13,4 @@ CHECKING_STUDY(StudyName='Test', data=_F(FROM='String', STRING='1 0 0 ; 0 1 0 ; 0 0 1 ; 1 0 0 ; 0 1 0 ; 0 0 1',),),); #VERSION_CATALOGUE:V7_6_0:FIN VERSION_CATALOGUE -#CHECKSUM:102c824e97113ec0e22b72312a5fc0d0 -:FIN CHECKSUM \ No newline at end of file + diff --git a/examples/daSalome/test010_ADAO_Simple_AdjointTest.comm b/examples/daSalome/test010_ADAO_Simple_AdjointTest.comm index 35415c2..c8eda93 100644 --- a/examples/daSalome/test010_ADAO_Simple_AdjointTest.comm +++ b/examples/daSalome/test010_ADAO_Simple_AdjointTest.comm @@ -1,6 +1,6 @@ CHECKING_STUDY(StudyName='Test', - AlgorithmChoices=_F(Algorithm='AdjointTest', + AlgorithmParameters=_F(Algorithm='AdjointTest', Parameters='Dict', data=_F(FROM='String', STRING='{ "SetSeed" : 1000 }',),), @@ -13,4 +13,4 @@ CHECKING_STUDY(StudyName='Test', data=_F(FROM='String', STRING='1 0 0 ; 0 1 0 ; 0 0 1 ; 1 0 0 ; 0 1 0 ; 0 0 1',),),); #VERSION_CATALOGUE:V7_6_0:FIN VERSION_CATALOGUE -#CHECKSUM:4aeff874ab3d45fc7f39ed6798e33b13 -:FIN CHECKSUM \ No newline at end of file + diff --git a/src/daEficas/generator_adao.py b/src/daEficas/generator_adao.py index 0a321bd..ef5e48e 100644 --- a/src/daEficas/generator_adao.py +++ b/src/daEficas/generator_adao.py @@ -113,9 +113,9 @@ class AdaoGenerator(PythonGenerator): self.text_da += "study_config['Debug'] = '0'\n" # Extraction de Algorithm et de ses parametres - if "__"+self.type_of_study+"__AlgorithmChoices__Algorithm" in self.dictMCVal.keys(): - self.text_da += "study_config['Algorithm'] = '" + self.dictMCVal["__"+self.type_of_study+"__AlgorithmChoices__Algorithm"] + "'\n" - self.add_AlgorithmChoices() + if "__"+self.type_of_study+"__AlgorithmParameters__Algorithm" in self.dictMCVal.keys(): + self.text_da += "study_config['Algorithm'] = '" + self.dictMCVal["__"+self.type_of_study+"__AlgorithmParameters__Algorithm"] + "'\n" + self.add_AlgorithmParameters() elif "__"+self.type_of_study+"__Algorithm" in self.dictMCVal.keys(): self.text_da += "study_config['Algorithm'] = '" + self.dictMCVal["__"+self.type_of_study+"__Algorithm"] + "'\n" @@ -144,9 +144,6 @@ class AdaoGenerator(PythonGenerator): # Extraction du StudyRepertory if "__"+self.type_of_study+"__StudyRepertory" in self.dictMCVal.keys(): self.text_da += "study_config['Repertory'] = '" + self.dictMCVal["__"+self.type_of_study+"__StudyRepertory"] + "'\n" - # Extraction de AlgorithmParameters - if "__"+self.type_of_study+"__AlgorithmParameters__INPUT_TYPE" in self.dictMCVal.keys(): - self.add_algorithm_parameters() # Extraction de UserPostAnalysis if "__"+self.type_of_study+"__UserPostAnalysis__FROM" in self.dictMCVal.keys(): self.add_UserPostAnalysis() @@ -243,28 +240,6 @@ class AdaoGenerator(PythonGenerator): self.text_da += data_name + "_config['Data'] = " + data_name + "_FunctionDict\n" self.text_da += "study_config['" + data_name + "'] = " + data_name + "_config\n" - def add_algorithm_parameters(self): - - data_name = "AlgorithmParameters" - data_type = "Dict" - from_type = self.dictMCVal["__"+self.type_of_study+"__AlgorithmParameters__Dict__data__FROM"] - - if from_type == "Script": - data = self.dictMCVal["__"+self.type_of_study+"__AlgorithmParameters__Dict__data__SCRIPT_DATA__SCRIPT_FILE"] - self.text_da += data_name + "_config = {} \n" - self.text_da += data_name + "_config['Type'] = '" + data_type + "'\n" - self.text_da += data_name + "_config['From'] = '" + from_type + "'\n" - self.text_da += data_name + "_config['Data'] = '" + data + "'\n" - self.text_da += "study_config['" + data_name + "'] = " + data_name + "_config\n" - - if from_type == "String": - data = self.dictMCVal["__"+self.type_of_study+"__AlgorithmParameters__Dict__data__STRING_DATA__STRING"] - self.text_da += data_name + "_config = {} \n" - self.text_da += data_name + "_config['Type'] = '" + data_type + "'\n" - self.text_da += data_name + "_config['From'] = '" + from_type + "'\n" - self.text_da += data_name + "_config['Data'] = '" + data + "'\n" - self.text_da += "study_config['" + data_name + "'] = " + data_name + "_config\n" - def add_init(self): init_file_data = self.dictMCVal["__"+self.type_of_study+"__UserDataInit__INIT_FILE"] @@ -309,34 +284,34 @@ class AdaoGenerator(PythonGenerator): else: raise Exception('From Type unknown', from_type) - def add_AlgorithmChoices(self): + def add_AlgorithmParameters(self): - if not self.dictMCVal.has_key("__"+self.type_of_study+"__AlgorithmChoices__Parameters"): return + if not self.dictMCVal.has_key("__"+self.type_of_study+"__AlgorithmParameters__Parameters"): return data_name = "AlgorithmParameters" data_type = "Dict" - para_type = self.dictMCVal["__"+self.type_of_study+"__AlgorithmChoices__Parameters"] + para_type = self.dictMCVal["__"+self.type_of_study+"__AlgorithmParameters__Parameters"] if para_type == "Defaults": from_type = para_type elif para_type == "Dict": - from_type = self.dictMCVal["__"+self.type_of_study+"__AlgorithmChoices__Dict__data__FROM"] + from_type = self.dictMCVal["__"+self.type_of_study+"__AlgorithmParameters__Dict__data__FROM"] if from_type == "Script": - data = self.dictMCVal["__"+self.type_of_study+"__AlgorithmChoices__Dict__data__SCRIPT_DATA__SCRIPT_FILE"] + data = self.dictMCVal["__"+self.type_of_study+"__AlgorithmParameters__Dict__data__SCRIPT_DATA__SCRIPT_FILE"] self.text_da += data_name + "_config = {} \n" self.text_da += data_name + "_config['Type'] = '" + data_type + "'\n" self.text_da += data_name + "_config['From'] = '" + from_type + "'\n" self.text_da += data_name + "_config['Data'] = '" + data + "'\n" self.text_da += "study_config['" + data_name + "'] = " + data_name + "_config\n" elif from_type == "String": - data = self.dictMCVal["__"+self.type_of_study+"__AlgorithmChoices__Dict__data__STRING_DATA__STRING"] + data = self.dictMCVal["__"+self.type_of_study+"__AlgorithmParameters__Dict__data__STRING_DATA__STRING"] self.text_da += data_name + "_config = {} \n" self.text_da += data_name + "_config['Type'] = '" + data_type + "'\n" self.text_da += data_name + "_config['From'] = '" + from_type + "'\n" self.text_da += data_name + "_config['Data'] = '" + data + "'\n" self.text_da += "study_config['" + data_name + "'] = " + data_name + "_config\n" elif from_type == "Defaults": - base = "__"+self.type_of_study+"__AlgorithmChoices__Parameters" + base = "__"+self.type_of_study+"__AlgorithmParameters__Parameters" keys = [k for k in self.dictMCVal.keys() if base in k] keys.remove(base) keys = [k.replace(base,'') for k in keys] diff --git a/src/daEficas/traduitADAOV7_4_0ToV7_6_0.py b/src/daEficas/traduitADAOV7_4_0ToV7_6_0.py index 1c88139..aab742e 100644 --- a/src/daEficas/traduitADAOV7_4_0ToV7_6_0.py +++ b/src/daEficas/traduitADAOV7_4_0ToV7_6_0.py @@ -70,13 +70,12 @@ def traduc(infile=None,outfile=None,texte=None,flog=None): # ========================================================================== for command in atraiter: - # Renomme le MC ou en insere un nouveau s'il n'existe pas ensuite - renameMotCle(jdc, command, "AlgorithmParameters", "AlgorithmChoices") - chercheOperInsereFacteurSiRegle(jdc, command, "AlgorithmChoices",((("AlgorithmChoices",),"nexistepasMCFParmi"),)) + # Insere le MC s'il n'existe pas + chercheOperInsereFacteurSiRegle(jdc, command, "AlgorithmParameters",((("AlgorithmParameters",),"nexistepasMCFParmi"),)) # Deplace le MC - moveMotClefInOperToFact(jdc, command, "Algorithm", "AlgorithmChoices") + moveMotClefInOperToFact(jdc, command, "Algorithm", "AlgorithmParameters") # Renomme le MC - renameMotCleInFact(jdc, command, "AlgorithmChoices", "INPUT_TYPE", "Parameters") + renameMotCleInFact(jdc, command, "AlgorithmParameters", "INPUT_TYPE", "Parameters") # Renomme le MC renameMotCle(jdc, command, "Study_name", "StudyName") renameMotCle(jdc, command, "Study_repertory", "StudyRepertory") diff --git a/src/daEficas/traduitADAOV7_5_0ToV7_6_0.py b/src/daEficas/traduitADAOV7_5_0ToV7_6_0.py index 1c88139..aab742e 100644 --- a/src/daEficas/traduitADAOV7_5_0ToV7_6_0.py +++ b/src/daEficas/traduitADAOV7_5_0ToV7_6_0.py @@ -70,13 +70,12 @@ def traduc(infile=None,outfile=None,texte=None,flog=None): # ========================================================================== for command in atraiter: - # Renomme le MC ou en insere un nouveau s'il n'existe pas ensuite - renameMotCle(jdc, command, "AlgorithmParameters", "AlgorithmChoices") - chercheOperInsereFacteurSiRegle(jdc, command, "AlgorithmChoices",((("AlgorithmChoices",),"nexistepasMCFParmi"),)) + # Insere le MC s'il n'existe pas + chercheOperInsereFacteurSiRegle(jdc, command, "AlgorithmParameters",((("AlgorithmParameters",),"nexistepasMCFParmi"),)) # Deplace le MC - moveMotClefInOperToFact(jdc, command, "Algorithm", "AlgorithmChoices") + moveMotClefInOperToFact(jdc, command, "Algorithm", "AlgorithmParameters") # Renomme le MC - renameMotCleInFact(jdc, command, "AlgorithmChoices", "INPUT_TYPE", "Parameters") + renameMotCleInFact(jdc, command, "AlgorithmParameters", "INPUT_TYPE", "Parameters") # Renomme le MC renameMotCle(jdc, command, "Study_name", "StudyName") renameMotCle(jdc, command, "Study_repertory", "StudyRepertory") diff --git a/src/daEficas/traduitADAOV7_5_1ToV7_6_0.py b/src/daEficas/traduitADAOV7_5_1ToV7_6_0.py index 1c88139..aab742e 100644 --- a/src/daEficas/traduitADAOV7_5_1ToV7_6_0.py +++ b/src/daEficas/traduitADAOV7_5_1ToV7_6_0.py @@ -70,13 +70,12 @@ def traduc(infile=None,outfile=None,texte=None,flog=None): # ========================================================================== for command in atraiter: - # Renomme le MC ou en insere un nouveau s'il n'existe pas ensuite - renameMotCle(jdc, command, "AlgorithmParameters", "AlgorithmChoices") - chercheOperInsereFacteurSiRegle(jdc, command, "AlgorithmChoices",((("AlgorithmChoices",),"nexistepasMCFParmi"),)) + # Insere le MC s'il n'existe pas + chercheOperInsereFacteurSiRegle(jdc, command, "AlgorithmParameters",((("AlgorithmParameters",),"nexistepasMCFParmi"),)) # Deplace le MC - moveMotClefInOperToFact(jdc, command, "Algorithm", "AlgorithmChoices") + moveMotClefInOperToFact(jdc, command, "Algorithm", "AlgorithmParameters") # Renomme le MC - renameMotCleInFact(jdc, command, "AlgorithmChoices", "INPUT_TYPE", "Parameters") + renameMotCleInFact(jdc, command, "AlgorithmParameters", "INPUT_TYPE", "Parameters") # Renomme le MC renameMotCle(jdc, command, "Study_name", "StudyName") renameMotCle(jdc, command, "Study_repertory", "StudyRepertory")