.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This verification algorithm allows to analyze in a simple way the stability of
-an operator :math:`F` during its execution. The operator is any operator, so it
-can be the observation operator :math:`\mathcal{H}` as well as the evolution
-operator :math:`\mathcal{D}`, as long as it is provided in each case according
-to the :ref:`section_ref_operator_requirements`. The operator :math:`F` is
-considered as depending on a vector variable :math:`\mathbf{x}` and on a
-control vector variable :math:`\mathbf{u}`, the two not necessarily being of
-the same size, and returning another vector variable :math:`\mathbf{y}`.
+This algorithm allows to analyze in a simple way the stability of an operator
+:math:`F` during its execution. The operator is any operator, so it can be the
+observation operator :math:`\mathcal{H}` as well as the evolution operator
+:math:`\mathcal{D}`, as long as it is provided in each case according to the
+:ref:`section_ref_operator_requirements`. The operator :math:`F` is considered
+as depending on a vector variable :math:`\mathbf{x}` and on a control vector
+variable :math:`\mathbf{u}`, the two not necessarily being of the same size,
+and returning another vector variable :math:`\mathbf{y}`.
The algorithm verifies that the operator is working correctly and that its call
is compatible with its usage in ADAO algorithms. In practice, it allows to call
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This verification algorithm allows to analyze in a simple way the stability of
-an operator :math:`F` during its execution. The operator is any operator, so it
-can be the observation operator :math:`\mathcal{H}` as well as the evolution
-operator :math:`\mathcal{D}`, as long as it is provided in each case according
-to the :ref:`section_ref_operator_requirements`. The operator :math:`F` is
-considered as depending on a vector variable :math:`\mathbf{x}` and returning
-another vector variable :math:`\mathbf{y}`.
+This algorithm allows to analyze in a simple way the stability of an operator
+:math:`F` during its execution. The operator is any operator, so it can be the
+observation operator :math:`\mathcal{H}` as well as the evolution operator
+:math:`\mathcal{D}`, as long as it is provided in each case according to the
+:ref:`section_ref_operator_requirements`. The operator :math:`F` is considered
+as depending on a vector variable :math:`\mathbf{x}` and returning another
+vector variable :math:`\mathbf{y}`.
The algorithm verifies that the operator is working correctly and that its call
is compatible with its usage in ADAO algorithms. In practice, it allows to call
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This verification algorithm allows to analyze in a simple way the stability of
-the difference between measures and an operator :math:`F` during its execution.
-The operator is any operator, so it can be the observation operator
+This algorithm allows to analyze in a simple way the stability of the
+difference between measures and an operator :math:`F` during its execution. The
+operator is any operator, so it can be the observation operator
:math:`\mathcal{H}` as well as the evolution operator :math:`\mathcal{D}`, as
long as it is provided in each case according to the
:ref:`section_ref_operator_requirements`. The operator :math:`F` is considered
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This verification algorithm allows to analyze in a simple way the stability of
-an operator :math:`F` during its execution in parallel. The operator is any
-operator, so it can be the observation operator :math:`\mathcal{H}` as well as
-the evolution operator :math:`\mathcal{D}`, as long as it is provided in each
-case according to the :ref:`section_ref_operator_requirements`. The operator
-:math:`F` is considered as depending on a vector variable :math:`\mathbf{x}`
-and returning another vector variable :math:`\mathbf{y}`.
+This algorithm allows to analyze in a simple way the stability of an operator
+:math:`F` during its execution in parallel. The operator is any operator, so it
+can be the observation operator :math:`\mathcal{H}` as well as the evolution
+operator :math:`\mathcal{D}`, as long as it is provided in each case according
+to the :ref:`section_ref_operator_requirements`. The operator :math:`F` is
+considered as depending on a vector variable :math:`\mathbf{x}` and returning
+another vector variable :math:`\mathbf{y}`.
The algorithm verifies that the operator is working correctly and that its call
is compatible with its usage in ADAO algorithms. In practice, it allows to call
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This checking algorithm provides a simple analysis of the characteristics of
-the state collection from the point of view of reduction. It aims to diagnose
-the complexity of the information present in the available state collection,
-and the possibility to represent this state information in a space smaller than
-the entire state collection. Technically, based on a classical SVD (Singular
-Value Decomposition) and in the same way as a PCA (Principal Component
-Analysis), it evaluates how information decreases with the number of singular
-values, either as values or, from a statistical point of view, as remaining
-variance.
+This algorithm provides a simple analysis of the characteristics of the state
+collection from the point of view of reduction. It aims to diagnose the
+complexity of the information present in the available state collection, and
+the possibility to represent this state information in a space smaller than the
+entire state collection. Technically, based on a classical SVD (Singular Value
+Decomposition) and in the same way as a PCA (Principal Component Analysis), it
+evaluates how information decreases with the number of singular values, either
+as values or, from a statistical point of view, as remaining variance.
Once the analysis is complete, a summary is displayed and, on request, a
graphical representation of the same information is produced.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This test algorithm is used to establish the collection of values of an error
-functional :math:`J` of type :math:`L^1`, :math:`L^2` or :math:`L^{\infty}`,
-with or without weights, using the observation operator :math:`\mathcal{H}`,
-for an a priori given sample of states :math:`\mathbf{x}`. The default error
-functional is the augmented weighted least squares functional, classically used
-in data assimilation, using in addition to observations :math:`\mathbf{y}^o`.
-
-This test is useful for analyzing the sensitivity of the functional :math:`J`
-to variations in the state :math:`\mathbf{x}` in particular.
+This algorithm establishes the collection of values for any :math:`J` error
+functional of type :math:`L^1`, :math:`L^2` or :math:`L^{\infty}`, with or
+without weights, as described in the section for
+:ref:`section_theory_optimization`. Each :math:`J` calculation is conducted
+using the :math:`\mathcal{H}` observation operator and :math:`\mathbf{y}^o`
+observations for a :math:`\mathbf{x}` state. The :math:`\mathbf{x}` states come
+from a sample of states defined *a priori*. The default error functional is the
+augmented weighted least squares functional, classically used in data
+assimilation.
+
+This test is useful for explicitly analyzing the sensitivity of the functional
+:math:`J` to variations in the state :math:`\mathbf{x}`.
The sampling of the states :math:`\mathbf{x}` can be given explicitly or under
form of hypercubes, explicit or sampled according to classic distributions, or
:ref:`section_ref_sampling_requirements` for an illustration of sampling.
Beware of the size of the hypercube (and then to the number of computations)
that can be reached, it can grow quickly to be quite large. When a state is not
-observable, a *"NaN"* value is returned.
+observable, a "*NaN*" value is returned.
It is also possible to supply a set of simulations :math:`\mathbf{y}` already
established elsewhere (so there's no explicit need for an operator
desired variable, the final saving through "*UserPostAnalysis*" or the
treatment during the calculation by well suited "*observer*".
+Note: in cases where sampling is generated, it may be useful to explicitly
+obtain the collection of states :math:`\mathbf{x}` according to the definition
+*a priori* without necessarily performing time-consuming calculations for the
+functional :math:`J`. To do this, simply use this algorithm with simplified
+calculations. For example, we can define a matrix observation operator equal to
+the identity (square matrix of the state size), a draft and an observation
+equal, worth 1 (vectors of the state size). Next, we set up the ADAO case with
+this algorithm to recover the set of sampled states using the usual
+“*CurrentState*” variable.
+
.. ------------------------------------ ..
.. include:: snippets/Header2Algo12.rst
interface. It is advisable to review the syntax and arguments in the TUI
scripts at each version change. In particular, it is advisable to check that
the algorithm parameters are still adequate and active, knowing that it has
-been explicitly chosen that there is no message when a parameter becomes
-inactive (for the example, we quote the parameter "*MaximumNumberOfSteps*" as
-having changed its name to "*MaximumNumberOfIterations*", for homogeneity with
-the variables that can be displayed).
+been explicitly chosen that there is no message when an optional parameter
+becomes inactive or changes its name (for the example, we quote the parameter
+"*MaximumNumberOfSteps*" as having changed its name to
+"*MaximumNumberOfIterations*", for homogeneity with the variables that can be
+displayed) to avoid a lock.
Switching from 8.5 to 9.2
+++++++++++++++++++++++++
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme de vérification permet d'analyser de manière simple la stabilité
-d'un opérateur :math:`F` lors de son exécution. L'opérateur est quelconque, et
-il peut donc être celui d'observation :math:`\mathcal{H}` comme celui
-d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon
-les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est
-considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et d'un
-contrôle :math:`\mathbf{u}`, les deux n'étant pas nécessairement de la même
-taille, et restituant une autre variable vectorielle :math:`\mathbf{y}`.
+Cet algorithme permet d'analyser de manière simple la stabilité d'un opérateur
+:math:`F` lors de son exécution. L'opérateur est quelconque, et il peut donc
+être celui d'observation :math:`\mathcal{H}` comme celui d'évolution
+:math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon les
+:ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est considéré
+comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et d'un contrôle
+:math:`\mathbf{u}`, les deux n'étant pas nécessairement de la même taille, et
+restituant une autre variable vectorielle :math:`\mathbf{y}`.
L'algorithme vérifie que l'opérateur fonctionne correctement et que son appel
se déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme de vérification permet d'analyser de manière simple la stabilité
-d'un opérateur :math:`F` lors de son exécution. L'opérateur est quelconque, et
-il peut donc être celui d'observation :math:`\mathcal{H}` comme celui
-d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon
-les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est
-considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et
-restituant une autre variable vectorielle :math:`\mathbf{y}`.
+Cet algorithme permet d'analyser de manière simple la stabilité d'un opérateur
+:math:`F` lors de son exécution. L'opérateur est quelconque, et il peut donc
+être celui d'observation :math:`\mathcal{H}` comme celui d'évolution
+:math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon les
+:ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est considéré
+comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et restituant une
+autre variable vectorielle :math:`\mathbf{y}`.
L'algorithme vérifie que l'opérateur fonctionne correctement et que son appel
se déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme de vérification permet d'analyser de manière simple la stabilité
-de l'écart entre des mesures et le calcul d'un opérateur :math:`F`, lors de son
-exécution. L'opérateur est quelconque, et il peut donc être celui d'observation
+Cet algorithme permet d'analyser de manière simple la stabilité de l'écart
+entre des mesures et le calcul d'un opérateur :math:`F`, lors de son exécution.
+L'opérateur est quelconque, et il peut donc être celui d'observation
:math:`\mathcal{H}` comme celui d'évolution :math:`\mathcal{D}`, pourvu qu'il
soit fourni dans chaque cas selon les :ref:`section_ref_operator_requirements`.
L'opérateur :math:`F` est considéré comme dépendant d'une variable vectorielle
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme de vérification permet d'analyser de manière simple la stabilité
-d'un opérateur :math:`F` lors de son exécution en parallèle. L'opérateur est
-quelconque, et il peut donc être celui d'observation :math:`\mathcal{H}` comme
-celui d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas
-selon les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est
-considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et
-restituant une autre variable vectorielle :math:`\mathbf{y}`.
+Cet algorithme permet d'analyser de manière simple la stabilité d'un opérateur
+:math:`F` lors de son exécution en parallèle. L'opérateur est quelconque, et il
+peut donc être celui d'observation :math:`\mathcal{H}` comme celui d'évolution
+:math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon les
+:ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est considéré
+comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et restituant une
+autre variable vectorielle :math:`\mathbf{y}`.
L'algorithme vérifie que l'opérateur fonctionne correctement et que son appel
se déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme de vérification permet d'analyser de manière simple les
-caractéristiques de la collection d'états du point de vue de la réduction. Il
-vise à diagnostiquer la complexité des informations présentes dans la
-collection d'états disponible, et la possibilité de représenter ces
-informations d'état dans un espace plus réduit que l'ensemble de la collection
-d'états. Techniquement, en s'appuyant sur une décomposition classique de type
-SVD (Singular Value Decomposition) et de la même manière qu'une PCA (Principal
-Component Analysis), il évalue la manière avec laquelle l'information diminue
-avec le nombre de valeurs singulières, soit en tant que valeurs, soit, d'un
-point de vue statistique, en tant que variance restante.
+Cet algorithme permet d'analyser de manière simple les caractéristiques de la
+collection d'états du point de vue de la réduction. Il vise à diagnostiquer la
+complexité des informations présentes dans la collection d'états disponible, et
+la possibilité de représenter ces informations d'état dans un espace plus
+réduit que l'ensemble de la collection d'états. Techniquement, en s'appuyant
+sur une décomposition classique de type SVD (Singular Value Decomposition) et
+de la même manière qu'une PCA (Principal Component Analysis), il évalue la
+manière avec laquelle l'information diminue avec le nombre de valeurs
+singulières, soit en tant que valeurs, soit, d'un point de vue statistique, en
+tant que variance restante.
Une fois l'analyse terminée, un résumé est affiché et, sur demande, une
représentation graphique des mêmes informations est produite.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme de test permet d'établir la collection des valeurs d'une
-fonctionnelle d'erreur :math:`J` de type :math:`L^1`, :math:`L^2` ou
-:math:`L^{\infty}`, avec ou sans pondérations, à l'aide de l'opérateur
-d'observation :math:`\mathcal{H}`, pour un échantillon donné a priori d'états
-:math:`\mathbf{x}`. La fonctionnelle d'erreur par défaut est celle de moindres
-carrés pondérés augmentés, classiquement utilisée en assimilation de données,
-utilisant en plus des observations :math:`\mathbf{y}^o`.
-
-Ce test est utile pour analyser la sensibilité de la fonctionnelle :math:`J`
-aux variations de l'état :math:`\mathbf{x}` en particulier.
+Cet algorithme permet d'établir la collection des valeurs d'une fonctionnelle
+d'erreur :math:`J` quelconque de type :math:`L^1`, :math:`L^2` ou
+:math:`L^{\infty}`, avec ou sans pondérations, comme décrit dans la section
+pour :ref:`section_theory_optimization`. Chaque calcul de :math:`J` est conduit
+à l'aide de l'opérateur d'observation :math:`\mathcal{H}` et des observations
+:math:`\mathbf{y}^o` pour un état :math:`\mathbf{x}`. Les états
+:math:`\mathbf{x}` proviennent d'un échantillon d'états défini *a priori*. La
+fonctionnelle d'erreur par défaut est celle de moindres carrés pondérés
+augmentés, classiquement utilisée en assimilation de données.
+
+Ce test est utile pour analyser explicitement la sensibilité de la
+fonctionnelle :math:`J` aux variations de l'état :math:`\mathbf{x}`.
L'échantillonnage des états :math:`\mathbf{x}` peut être fourni explicitement
ou sous la forme d'hypercubes, explicites ou échantillonnés selon des
se reporter aux :ref:`section_ref_sampling_requirements` pour une illustration
de l'échantillonnage. Attention à la taille de l'hypercube (et donc au nombre
de calculs) qu'il est possible d'atteindre, elle peut rapidement devenir
-importante. Lorsqu'un état n'est pas observable, une valeur *"NaN"* est
+importante. Lorsqu'un état n'est pas observable, une valeur "*NaN*" est
retournée.
Il est aussi possible de fournir un ensemble de simulations :math:`\mathbf{y}`
finale à l'aide du mot-clé "*UserPostAnalysis*" ou le traitement en cours de
calcul à l'aide des "*observer*" adaptés.
+Remarque : dans les cas où l'échantillonnage est généré, il peut être utile
+d'obtenir explicitement la collection des états :math:`\mathbf{x}` selon la
+définition *a priori* sans nécessairement effectuer de long calculs pour la
+fonctionnelle :math:`J`. Pour cela, il suffit d'utiliser cet algorithme avec
+des calculs simplifiés. Par exemple, on peut définir un opérateur d'observation
+matriciel égal à l'identité (matrice carrée de la taille d'un état), une
+ébauche et une observation égales, valant 1 (vecteurs de la taille de l'état).
+Ensuite, on établit le cas ADAO avec cet algorithme pour récupérer l'ensemble
+des états échantillonnés à l'aide de la variable habituelle de
+"*CurrentState*".
+
.. ------------------------------------ ..
.. include:: snippets/Header2Algo12.rst
- Les méthodes d'optimisation proposées par cet algorithme effectuent une
**recherche non locale du minimum**, sans pour autant néanmoins assurer une
- recherche globale. C'est le cas lorsque les méthodes d'optimisation
- présentent des capacités d'éviter de rester bloquées par le premier minimum
- local trouvé. Ces capacités sont parfois heuristiques.
+ recherche globale. C'est le cas lorsque les méthodes d'optimisation de
+ recherche locale présentent de plus des capacités permettant d'éviter de
+ rester bloquées par le premier minimum local trouvé. Ces capacités sont
+ parfois heuristiques.
syntaxe et les arguments dans les scripts TUI à chaque changement de version.
En particulier, il convient de vérifier que les paramètres d'algorithme sont
toujours adéquats et actifs, sachant qu'il a été explicitement choisi qu'il n'y
-ait pas de message lorsqu'un paramètre devient inactif (pour l'exemple, on cite
-le paramètre "*MaximumNumberOfSteps*" comme ayant changé de nom pour devenir
-"*MaximumNumberOfIterations*", par homogénéité avec les variables pouvant être
-affichées).
+ait pas de message lorsqu'un paramètre optionnel devient inactif ou change de
+nom (pour l'exemple, on cite le paramètre "*MaximumNumberOfSteps*" comme ayant
+changé de nom pour devenir "*MaximumNumberOfIterations*", par homogénéité avec
+les variables pouvant être affichées) pour éviter un blocage.
Passer de la version 8.5 à la 9.2
+++++++++++++++++++++++++++++++++
#
__Parameters = {}
if (asDict is not None) and isinstance(asDict, dict):
- __Parameters.update( asDict )
+ __Parameters.update( asDict ) # Copie mémoire
# Deprecated parameters
__Parameters = self.__deprecateOpt(
collection = __Parameters,
#
# Mise à jour des paramètres internes avec le contenu de Parameters, en
# reprenant les valeurs par défauts pour toutes celles non définies
- self.__setParameters(Parameters, reset=True) # Copie
+ self.__setParameters(Parameters, reset=True) # Copie mémoire
for k, v in self.__variable_names_not_public.items():
if k not in self._parameters:
self.__setParameters( {k: v} )
