"""
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") ),
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"),
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"),
------------------------------------------------------------
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
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: AmplitudeOfInitialDirection
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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: NumberOfPrintedDigits
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: AmplitudeOfInitialDirection
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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Observation
.. index:: single: ObservationError
.. index:: single: ObservationOperator
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: AmplitudeOfInitialDirection
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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: Observation
.. index:: single: ObservationError
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: Observers
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: Observation
.. index:: single: ObservationOperator
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: BackgroundError
.. index:: single: Observation
: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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: AmplitudeOfInitialDirection
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:
Optional and required commands
++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
: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:
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,
*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
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
'{"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
"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.
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.
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
-------------------------------------------------------------------------
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
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: AmplitudeOfInitialDirection
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: NumberOfPrintedDigits
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: AmplitudeOfInitialDirection
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Observation
.. index:: single: ObservationError
.. index:: single: ObservationOperator
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: AmplitudeOfInitialDirection
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: Observation
.. index:: single: ObservationError
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: Observers
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: Observation
.. index:: single: ObservationOperator
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: BackgroundError
.. index:: single: Observation
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: CheckingPoint
.. index:: single: ObservationOperator
.. index:: single: AmplitudeOfInitialDirection
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:
Commandes requises et optionnelles
++++++++++++++++++++++++++++++++++
+.. index:: single: AlgorithmParameters
.. index:: single: Background
.. index:: single: BackgroundError
.. index:: single: Observation
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:
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
*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
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
'{"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
"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.
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é
ê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
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',
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
+
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',
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
+
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',
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',
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',
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',
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',
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=
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']
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"] = {}
CHECKING_STUDY(StudyName='Elementary gradient test',
- AlgorithmChoices=_F(Algorithm='GradientTest',
+ AlgorithmParameters=_F(Algorithm='GradientTest',
Parameters='Dict',
data=_F(FROM='String',
STRING='{ "SetSeed" : 1000 }',),),
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
+
CHECKING_STUDY(StudyName='Test',
- AlgorithmChoices=_F(Algorithm='GradientTest',
+ AlgorithmParameters=_F(Algorithm='GradientTest',
Parameters='Dict',
data=_F(FROM='String',
STRING='{ "SetSeed" : 1000 }',),),
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
+
CHECKING_STUDY(StudyName='Test',
- AlgorithmChoices=_F(Algorithm='AdjointTest',
+ AlgorithmParameters=_F(Algorithm='AdjointTest',
Parameters='Dict',
data=_F(FROM='String',
STRING='{ "SetSeed" : 1000 }',),),
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
+
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"
# 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()
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"]
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]
# ==========================================================================
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")
# ==========================================================================
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")
# ==========================================================================
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")
