*Tips for this algorithm:*
- Because *"ObservationOperator"* is a required command for ALL checking
- algorithms in the graphical interface, you have to provide a value for it,
+ Because *"ObservationOperator"*, in the graphical interface, is a required
+ command for ALL checking algorithms, you have to provide a value for it,
despite the fact that this command is not required for this test, and will
not be used. The easiest way is to give "1" as a STRING,
- *"ObservationOperator"* having to be of type *Matrix*.
+ *"ObservationOperator"* having to be of type sparse *Matrix*.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo03Chck.rst
.. include:: snippets/Header2Algo01.rst
This algorithm allows to verify an external function, given by the user, used as
-an *observer*. This external function can be applied to every of the variables
+an *observer*. This external function can be applied to each of the variables
that can be potentially observed. It is activated only on those who are
-explicitly associated with the *observer* in the interface.
+explicitly associated with the *observer* in its declaration.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
*Tips for this algorithm:*
- Because *"CheckingPoint"* and *"ObservationOperator"* are required commands
- for ALL checking algorithms in the interface, you have to provide a value
- for them, despite the fact that these commands are not required for this
- test, and will not be used. The easiest way is to give "1" as a STRING for
- both, *"ObservationOperator"* having to be of type *Matrix*.
+ Because *"CheckingPoint"* and *"ObservationOperator"*, in the graphical
+ interface, are required commands for ALL checking algorithms, you have to
+ provide a value for them, despite the fact that these commands are not
+ required for this test, and will not be used. The easiest way is to give
+ "1" as a STRING for both, *"ObservationOperator"* having to be of type
+ sparse *Matrix*.
Simple description of the data assimilation methodological framework
--------------------------------------------------------------------
+.. index:: single: analysis
.. index:: single: background
.. index:: single: background error covariances
.. index:: single: observation error covariances
The optimal estimation of the true parameters :math:`\mathbf{x}^t`, given the
background :math:`\mathbf{x}^b` and the observations :math:`\mathbf{y}^o`, is
-then the "*analysis*" :math:`\mathbf{x}^a` and comes from the minimisation of an
-error function, explicit in variational assimilation, or from the filtering
-correction in assimilation by filtering.
+then called an "*analysis*", noted as :math:`\mathbf{x}^a`, and comes from the
+minimisation of an error function, explicit in variational assimilation, or
+from the filtering correction in assimilation by filtering.
In **variational assimilation**, in a static case, one classically attempts to
minimize the following function :math:`J`:
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Pour construire un cas en utilisant l'éditeur intégré, on doit passer par une
-série de sous-étapes, en choisissant, à chaque étape, un mot-clé puis en
+série de sous-étapes, en choisissant, à chaque sous-étape, un mot-clé puis en
remplissant ses valeurs. On note que c'est dans cette étape qu'il faut, entre
-autres, définir l'**appel au code de simulation** utilisé dans les opérateurs
+autres, définir un **appel au code de simulation** utilisé dans les opérateurs
d'observation ou d'évolution décrivant le problème [#]_.
L'éditeur structuré indique des types hiérarchiques, des valeurs ou des
*Astuce pour cet algorithme :*
- Comme la commande *"ObservationOperator"* est requise pour TOUS les
- algorithmes de vérification dans l'interface graphique, vous devez fournir
- une valeur, malgré le fait que cette commandes ne soit pas nécessaires pour
- cet test, et ne soit donc pas utilisée. La manière la plus simple est de
- donner "1" comme un STRING, l'*"ObservationOperator"* devant être de type
- *Matrix*.
+ Comme la commande *"ObservationOperator"*, dans l'interface graphique, est
+ requise pour TOUS les algorithmes de vérification, il faut fournir une
+ valeur, malgré le fait que cette commandes ne soit pas nécessaires pour cet
+ test (et sa valeur n'est donc pas utilisée). La manière la plus simple est
+ de donner "1" comme un STRING, pour un *"ObservationOperator"* devant être
+ de type *Matrix* creuse.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo03Chck.rst
Cet algorithme permet de vérifier une fonction externe et fournie par
l'utilisateur, utilisée comme un *observer*. Cette fonction externe peut être
-appliquée à chacune des variables potentiellement observables. Elle n'est
-activée que sur celles qui sont explicitement associées avec l'*observer* dans
-l'interface.
+appliquée pour chacune des variables potentiellement observables. Elle n'est
+activée que sur celles qui sont explicitement associées avec cet *observer*
+dans sa déclaration.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
*Astuce pour cet algorithme :*
- Comme les commandes *"CheckingPoint"* et *"ObservationOperator"* sont
- requises pour TOUS les algorithmes de vérification dans l'interface, vous
- devez fournir une valeur, malgré le fait que ces commandes ne soient pas
- nécessaires pour ce test, et ne sont donc pas utilisées. La manière la plus
- simple est de donner "1" comme un STRING pour les deux,
- l'*"ObservationOperator"* devant être de type *Matrix*.
+ Comme les commandes *"CheckingPoint"* et *"ObservationOperator"*, dans
+ l'interface graphique, sont requises pour TOUS les algorithmes de
+ vérification, il faut fournir une valeur, malgré le fait que ces commandes
+ ne soient pas nécessaires pour ce test (et que leurs valeurs ne sont donc
+ pas utilisées). La manière la plus simple est de donner "1" comme un STRING
+ pour les deux, avec un *"ObservationOperator"* devant être de type *Matrix*
+ creuse.
inventaire commun des commandes.
Le jeu de commandes pour un cas d'assimilation de données ou d'optimisation est
-lié à la description d'un cas de calcul, qui est une procédure d'*Assimilation
-de Données*, de *Méthodes avec Réduction* ou de méthodes *Optimisation*.
+lié à la description d'un cas de calcul, qui est une procédure en *Assimilation
+de Données*, en *Méthodes avec Réduction* ou en méthodes *Optimisation*.
Le premier terme décrit le choix entre un calcul ou une vérification. Dans
l'interface graphique, chacun des trois types de calculs, individuellement
L'inflation peut être appliquée de diverses manières, selon les options
suivantes : multiplicative ou additive du facteur d'inflation spécifié,
appliquée sur l'ébauche ou sur l'analyse, appliquée sur les covariances ou
- sur les anomalies. L'*inflation multiplicative sur les anomalies*, qui sont
+ sur les anomalies. Une *inflation multiplicative sur les anomalies*, qui sont
obtenues en retranchant la moyenne d'ensemble, est effectuée en multipliant
ces anomalies par le facteur d'inflation, puis en reconstituant les membres
de l'ensemble par ajout de la moyenne préalablement calculée. Un seul type
Description simple du cadre méthodologique de l'assimilation de données
-----------------------------------------------------------------------
+.. index:: single: analyse
.. index:: single: ebauche
.. index:: single: covariances d'erreurs d'ébauche
.. index:: single: covariances d'erreurs d'observation
L'estimation optimale des paramètres vrais :math:`\mathbf{x}^t`, étant donné
l'ébauche :math:`\mathbf{x}^b` et les observations :math:`\mathbf{y}^o`, est
-ainsi "l'*analyse*" :math:`\mathbf{x}^a` et provient de la minimisation d'une
-fonction d'erreur, explicite en assimilation variationnelle, ou d'une correction
-de filtrage en assimilation par filtrage.
+ainsi appelée une "*analyse*", notée :math:`\mathbf{x}^a`, et provient de la
+minimisation d'une fonction d'erreur, explicite en assimilation variationnelle,
+ou d'une correction de filtrage en assimilation par filtrage.
En **assimilation variationnelle**, dans un cas statique, on cherche
classiquement à minimiser la fonction :math:`J` suivante :
estimations d'états, et fréquemment aucune garantie de convergence en temps
fini. Ici, on ne mentionne que quelques méthodes disponibles dans ADAO :
-- l'*optimisation sans dérivées (Derivative Free Optimization ou DFO)* (voir :ref:`section_ref_algorithm_DerivativeFreeOptimization`),
-- l'*optimisation par essaim de particules (Particle Swarm Optimization ou PSO)* (voir :ref:`section_ref_algorithm_ParticleSwarmOptimization`),
-- l'*évolution différentielle (Differential Evolution ou DE)* (voir :ref:`section_ref_algorithm_DifferentialEvolution`),
-- la *régression de quantile (Quantile Regression ou QR)* (voir :ref:`section_ref_algorithm_QuantileRegression`).
+- *optimisation sans dérivées (Derivative Free Optimization ou DFO)* (voir :ref:`section_ref_algorithm_DerivativeFreeOptimization`),
+- *optimisation par essaim de particules (Particle Swarm Optimization ou PSO)* (voir :ref:`section_ref_algorithm_ParticleSwarmOptimization`),
+- *évolution différentielle (Differential Evolution ou DE)* (voir :ref:`section_ref_algorithm_DifferentialEvolution`),
+- *régression de quantile (Quantile Regression ou QR)* (voir :ref:`section_ref_algorithm_QuantileRegression`).
En second lieu, les méthodes d'optimisation cherchent usuellement à minimiser
des mesures quadratiques d'erreurs, car les propriétés naturelles de ces
d'états, et pas de garantie de convergence en temps fini. Ici encore, on ne
mentionne que quelques méthodes qui sont disponibles dans ADAO :
-- l'*optimisation sans dérivées (Derivative Free Optimization ou DFO)* (voir :ref:`section_ref_algorithm_DerivativeFreeOptimization`),
-- l'*optimisation par essaim de particules (Particle Swarm Optimization ou PSO)* (voir :ref:`section_ref_algorithm_ParticleSwarmOptimization`),
-- l'*évolution différentielle (Differential Evolution ou DE)* (voir :ref:`section_ref_algorithm_DifferentialEvolution`).
+- *optimisation sans dérivées (Derivative Free Optimization ou DFO)* (voir :ref:`section_ref_algorithm_DerivativeFreeOptimization`),
+- *optimisation par essaim de particules (Particle Swarm Optimization ou PSO)* (voir :ref:`section_ref_algorithm_ParticleSwarmOptimization`),
+- *évolution différentielle (Differential Evolution ou DE)* (voir :ref:`section_ref_algorithm_DifferentialEvolution`).
Le lecteur intéressé par le sujet de l'optimisation pourra utilement commencer
sa recherche grâce au point d'entrée [WikipediaMO]_.
finale du calcul. On se reportera à la description des
:ref:`section_ref_observers_requirements` pour avoir leur liste et leur
format, et à la :ref:`section_reference` pour savoir quelles sont les
- quantités observables. On définit comme un "*String*" le corps de
- l'*observer*, en utilisant une chaîne de caractères incluant si nécessaire
- des sauts de lignes. On recommande d'utiliser les patrons disponibles par
- l'argument "*Template*". Dans le cas d'une définition par "*Script*", le
- fichier indiqué doit contenir uniquement le corps de la fonction, comme
- décrit dans les :ref:`section_ref_observers_requirements`. La variable
- "*Info*" contient une chaîne de caractère d'information ou une chaine vide.
+ quantités observables. On définit comme un "*String*" le corps de la
+ fonction d'un *observer*, en utilisant une chaîne de caractères incluant si
+ nécessaire des sauts de lignes. On recommande d'utiliser les patrons
+ disponibles par l'argument "*Template*". Dans le cas d'une définition par
+ "*Script*", le fichier indiqué doit contenir uniquement le corps de la
+ fonction, comme décrit dans les :ref:`section_ref_observers_requirements`.
+ La variable "*Info*" contient une chaîne de caractère d'information ou une
+ chaine vide.
.. index:: single: UserPostAnalysis
.. index:: single: UserPostAnalysis Template
-# Modification de la version 1.1.0
+# Modification de la version 1.4.1
"""
Functions
---------
import numpy as np
from numpy import array, asarray, float64, int32, zeros
from scipy.optimize import _lbfgsb
-from scipy.optimize.optimize import (approx_fprime, MemoizeJac, OptimizeResult,
+from scipy.optimize.optimize import (MemoizeJac, OptimizeResult,
_check_unknown_options, wrap_function,
_approx_fprime_helper)
from scipy.sparse.linalg import LinearOperator
Options
-------
- disp : bool
- Set to True to print convergence messages.
+ disp : None or int
+ If `disp is None` (the default), then the supplied version of `iprint`
+ is used. If `disp is not None`, then it overrides the supplied version
+ of `iprint` with the behaviour you outlined.
maxcor : int
The maximum number of variable metric corrections used to
define the limited memory matrix. (The limited memory BFGS
projected gradient.
eps : float
Step size used for numerical approximation of the jacobian.
- disp : int
- Set to True to print convergence messages.
maxfun : int
Maximum number of function evaluations.
maxiter : int
Maximum number of iterations.
+ iprint : int, optional
+ Controls the frequency of output. ``iprint < 0`` means no output;
+ ``iprint = 0`` print only one line at the last iteration;
+ ``0 < iprint < 99`` print also f and ``|proj g|`` every iprint iterations;
+ ``iprint = 99`` print details of every iteration except n-vectors;
+ ``iprint = 100`` print also the changes of active set and final x;
+ ``iprint > 100`` print details of every iteration including x and g.
+ callback : callable, optional
+ Called after each iteration, as ``callback(xk)``, where ``xk`` is the
+ current parameter vector.
maxls : int, optional
Maximum number of line search steps (per iteration). Default is 20.
