From 90a0e50577c3df6366b00d03fdb3d0285f46bf6e Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Sat, 20 Jan 2018 22:22:10 +0100 Subject: [PATCH] Documentation corrections and modular evolution (2 FR) --- doc/fr/ref_algorithm_4DVAR.rst | 200 +++----------- doc/fr/ref_algorithm_AdjointTest.rst | 86 +----- doc/fr/ref_algorithm_Blue.rst | 208 +++----------- ...f_algorithm_DerivativeFreeOptimization.rst | 257 +++--------------- doc/fr/ref_algorithm_EnsembleBlue.rst | 87 ++---- doc/fr/ref_algorithm_ExtendedBlue.rst | 208 +++----------- doc/fr/ref_algorithm_ExtendedKalmanFilter.rst | 161 +++-------- doc/fr/ref_algorithm_FunctionTest.rst | 63 +---- doc/fr/ref_algorithm_GradientTest.rst | 92 ++----- doc/fr/ref_algorithm_KalmanFilter.rst | 138 +++------- doc/fr/ref_algorithm_LinearLeastSquares.rst | 85 ++---- doc/fr/ref_algorithm_LinearityTest.rst | 92 ++----- .../ref_algorithm_NonLinearLeastSquares.rst | 204 +++----------- doc/fr/ref_algorithm_ObserverTest.rst | 14 +- ...ef_algorithm_ParticleSwarmOptimization.rst | 190 +++---------- doc/fr/ref_algorithm_QuantileRegression.rst | 156 ++--------- doc/fr/ref_algorithm_SamplingTest.rst | 138 +++------- doc/fr/ref_algorithm_TangentTest.rst | 86 +----- .../ref_algorithm_UnscentedKalmanFilter.rst | 178 ++++-------- doc/fr/ref_assimilation_keywords.rst | 63 +---- doc/fr/ref_checking_keywords.rst | 44 +-- doc/fr/ref_output_variables.rst | 240 +++------------- 22 files changed, 593 insertions(+), 2397 deletions(-) diff --git a/doc/fr/ref_algorithm_4DVAR.rst b/doc/fr/ref_algorithm_4DVAR.rst index f177a8b..04e6e60 100644 --- a/doc/fr/ref_algorithm_4DVAR.rst +++ b/doc/fr/ref_algorithm_4DVAR.rst @@ -51,57 +51,22 @@ l':ref:`section_ref_algorithm_UnscentedKalmanFilter`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: Bounds -.. index:: single: ConstrainedBy -.. index:: single: EstimationOf -.. index:: single: MaximumNumberOfSteps -.. index:: single: CostDecrementTolerance -.. index:: single: ProjectedGradientTolerance -.. index:: single: GradientNormTolerance -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/EvolutionError.rst + + .. include:: snippets/EvolutionModel.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -113,6 +78,8 @@ commande. Les options de l'algorithme sont les suivantes: Minimizer + .. index:: single: Minimizer + Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par défaut est "LBFGSB", et les choix possibles sont "LBFGSB" (minimisation non linéaire sous contraintes, voir [Byrd95]_, [Morales11]_ et [Zhu97]_), "TNC" @@ -121,69 +88,26 @@ Les options de l'algorithme sont les suivantes: contraintes), "NCG" (minimisation de type gradient conjugué de Newton). Il est fortement conseillé de conserver la valeur par défaut. - Exemple : ``{"Minimizer":"LBFGSB"}`` - - Bounds - Cette clé permet de définir des bornes supérieure et inférieure pour chaque - variable d'état optimisée. Les bornes doivent être données par une liste de - liste de paires de bornes inférieure/supérieure pour chaque variable, avec - une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes peuvent - toujours être spécifiées, mais seuls les optimiseurs sous contraintes les - prennent en compte. - - Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}`` - - ConstrainedBy - Cette clé permet d'indiquer la méthode de prise en compte des contraintes de - bornes. La seule disponible est "EstimateProjection", qui projete - l'estimation de l'état courant sur les contraintes de bornes. - - Exemple : ``{"ConstrainedBy":"EstimateProjection"}`` - - MaximumNumberOfSteps - Cette clé indique le nombre maximum d'itérations possibles en optimisation - itérative. Le défaut est 15000, qui est très similaire à une absence de - limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre - aux besoins pour des problèmes réels. Pour certains optimiseurs, le nombre - de pas effectif d'arrêt peut être légèrement différent de la limite à cause - d'exigences de contrôle interne de l'algorithme. - - Exemple : ``{"MaximumNumberOfSteps":100}`` + Exemple : + ``{"Minimizer":"LBFGSB"}`` - CostDecrementTolerance - Cette clé indique une valeur limite, conduisant à arrêter le processus - itératif d'optimisation lorsque la fonction coût décroît moins que cette - tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé - de l'adapter aux besoins pour des problèmes réels. + .. include:: snippets/BoundsWithNone.rst - Exemple : ``{"CostDecrementTolerance":1.e-7}`` + .. include:: snippets/ConstrainedBy.rst - EstimationOf - Cette clé permet de choisir le type d'estimation à réaliser. Cela peut être - soit une estimation de l'état, avec la valeur "State", ou une estimation de - paramètres, avec la valeur "Parameters". Le choix par défaut est "State". + .. include:: snippets/MaximumNumberOfSteps.rst - Exemple : ``{"EstimationOf":"Parameters"}`` + .. include:: snippets/CostDecrementTolerance.rst - ProjectedGradientTolerance - Cette clé indique une valeur limite, conduisant à arrêter le processus - itératif d'optimisation lorsque toutes les composantes du gradient projeté - sont en-dessous de cette limite. C'est utilisé uniquement par les - optimiseurs sous contraintes. Le défaut est -1, qui désigne le défaut - interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé - de le changer. + .. include:: snippets/EstimationOf.rst - Exemple : ``{"ProjectedGradientTolerance":-1}`` + .. include:: snippets/ProjectedGradientTolerance.rst - GradientNormTolerance - Cette clé indique une valeur limite, conduisant à arrêter le processus - itératif d'optimisation lorsque la norme du gradient est en dessous de cette - limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le - défaut est 1.e-5 et il n'est pas recommandé de le changer. - - Exemple : ``{"GradientNormTolerance":1.e-5}`` + .. include:: snippets/GradientNormTolerance.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -208,79 +132,29 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. + .. include:: snippets/Analysis.rst - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` + .. include:: snippets/CostFunctionJ.rst - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. + .. include:: snippets/CostFunctionJb.rst - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` - - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. - - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + .. include:: snippets/CostFunctionJo.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CostFunctionJAtCurrentOptimum - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis - le début. - - Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]`` - - CostFunctionJbAtCurrentOptimum - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la - valeur correspond à l'état optimal trouvé depuis le début. - - Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]`` - - CostFunctionJoAtCurrentOptimum - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas, - la valeur correspond à l'état optimal trouvé depuis le début. - - Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]`` + .. include:: snippets/BMA.rst - CurrentOptimum - *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de - temps courant au cours du déroulement de l'algorithme d'optimisation. Ce - n'est pas nécessairement le dernier état. + .. include:: snippets/CostFunctionJAtCurrentOptimum.rst - Exemple : ``Xo = ADD.get("CurrentOptimum")[:]`` + .. include:: snippets/CostFunctionJbAtCurrentOptimum.rst - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. + .. include:: snippets/CostFunctionJoAtCurrentOptimum.rst - Exemple : ``Xs = ADD.get("CurrentState")[:]`` + .. include:: snippets/CurrentOptimum.rst - IndexOfOptimum - *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum - obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas - nécessairement le numéro de la dernière itération. + .. include:: snippets/CurrentState.rst - Exemple : ``i = ADD.get("IndexOfOptimum")[-1]`` + .. include:: snippets/IndexOfOptimum.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_AdjointTest.rst b/doc/fr/ref_algorithm_AdjointTest.rst index f4044ec..08ebce4 100644 --- a/doc/fr/ref_algorithm_AdjointTest.rst +++ b/doc/fr/ref_algorithm_AdjointTest.rst @@ -46,34 +46,12 @@ prend :math:`\mathbf{y} = F(\mathbf{x})`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: CheckingPoint -.. index:: single: ObservationOperator -.. index:: single: AmplitudeOfInitialDirection -.. index:: single: EpsilonMinimumExponent -.. index:: single: InitialDirection -.. index:: single: SetSeed -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - CheckingPoint - *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour - duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à - l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type - "*Vector*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, notée - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*". Différentes formes fonctionnelles peuvent être - utilisées, comme décrit dans la section - :ref:`section_ref_operator_requirements`. Si un contrôle :math:`U` est - inclus dans le modèle d'observation, l'opérateur doit être appliqué à une - paire :math:`(X,U)`. + .. include:: snippets/CheckingPoint.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les @@ -84,41 +62,17 @@ commande. Les options de l'algorithme sont les suivantes: - AmplitudeOfInitialDirection - Cette clé indique la mise à l'échelle de la perturbation initiale construite - comme un vecteur utilisé pour la dérivée directionnelle autour du point - nominal de vérification. La valeur par défaut est de 1, ce qui signifie pas - de mise à l'échelle. - - Exemple : ``{"AmplitudeOfInitialDirection":0.5}`` - - EpsilonMinimumExponent - Cette clé indique la valeur de l'exposant minimal du coefficient en - puissance de 10 qui doit être utilisé pour faire décroître le multiplicateur - de l'incrément. La valeur par défaut est de -8, et elle doit être entre 0 et - -20. Par exemple, la valeur par défaut conduit à calculer le résidu de la - formule avec un incrément fixe multiplié par 1.e0 jusqu'à 1.e-8. - - Exemple : ``{"EpsilonMinimumExponent":-12}`` + .. include:: snippets/AmplitudeOfInitialDirection.rst - InitialDirection - Cette clé indique la direction vectorielle utilisée pour la dérivée - directionnelle autour du point nominal de vérification. Cela doit être un - vecteur. Si elle n'est pas spécifiée, la direction par défaut est une - perturbation par défaut autour de zéro de la même taille vectorielle que le - point de vérification. + .. include:: snippets/EpsilonMinimumExponent.rst - Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}`` + .. include:: snippets/InitialDirection.rst - SetSeed - Cette clé permet de donner un nombre entier pour fixer la graine du - générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est - par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation par défaut de l'ordinateur. - - Exemple : ``{"SetSeed":1000}`` + .. include:: snippets/SetSeed.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -126,7 +80,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["CurrentState", "Residu", "SimulatedObservationAtCurrentState"]. - Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["CurrentState"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -141,26 +96,13 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Residu - *Liste de valeurs*. Chaque élément est la valeur du résidu particulier - vérifié lors d'un algorithme de vérification, selon l'ordre des tests - effectués. - - Exemple : ``r = ADD.get("Residu")[:]`` + .. include:: snippets/Residu.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état courant, c'est-à-dire dans l'espace des observations. + .. include:: snippets/CurrentState.rst - Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtCurrentState.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_Blue.rst b/doc/fr/ref_algorithm_Blue.rst index 0f43f85..5c940c3 100644 --- a/doc/fr/ref_algorithm_Blue.rst +++ b/doc/fr/ref_algorithm_Blue.rst @@ -47,54 +47,18 @@ l':ref:`section_ref_algorithm_3DVAR`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: StoreSupplementaryCalculations -.. index:: single: Quantiles -.. index:: single: SetSeed -.. index:: single: NumberOfSamplesForQuantiles -.. index:: single: SimulationForQuantiles - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -106,6 +70,8 @@ commande. Les options de l'algorithme sont les suivantes: StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -118,45 +84,16 @@ Les options de l'algorithme sont les suivantes: "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"]. - Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` - - Quantiles - Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par - simulation autour de l'état optimal. L'échantillonnage utilise des tirages - aléatoires gaussiens multivariés, dirigés par la matrice de covariance a - posteriori. Cette option n'est utile que si le calcul supplémentaire - "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide. + Exemple : + ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` - Exemple : ``{"Quantiles":[0.1,0.9]}`` + .. include:: snippets/Quantiles.rst - SetSeed - Cette clé permet de donner un nombre entier pour fixer la graine du - générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est - par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation par défaut de l'ordinateur. + .. include:: snippets/SetSeed.rst - Exemple : ``{"SetSeed":1000}`` + .. include:: snippets/NumberOfSamplesForQuantiles.rst - NumberOfSamplesForQuantiles - Cette clé indique le nombre de simulations effectuées pour estimer les - quantiles. Cette option n'est utile que si le calcul supplémentaire - "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent - pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%. - - Exemple : ``{"NumberOfSamplesForQuantiles":100}`` - - SimulationForQuantiles - Cette clé indique le type de simulation, linéaire (avec l'opérateur - d'observation tangent appliqué sur des incréments de perturbations autour de - l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard - appliqué aux états perturbés), que l'on veut faire pour chaque perturbation. - Cela change essentiellement le temps de chaque simulation élémentaire, - usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est - utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La - valeur par défaut est "Linear", et les choix possibles sont "Linear" et - "NonLinear". - - Exemple : ``{"SimulationForQuantiles":"Linear"}`` + .. include:: snippets/SimulationForQuantiles.rst Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -171,118 +108,43 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` + .. include:: snippets/Analysis.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - APosterioriCorrelations - *Liste de matrices*. Chaque élément est une matrice de corrélation des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]`` - - APosterioriCovariance - *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de - covariances des erreurs *a posteriori* de l'état optimal. - - Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` - - APosterioriStandardDeviations - *Liste de matrices*. Chaque élément est une matrice d'écart-types des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]`` - - APosterioriVariances - *Liste de matrices*. Chaque élément est une matrice de variances des erreurs - *a posteriori* de l'état optimal. - - Exemple : ``V = ADD.get("APosterioriVariances")[-1]`` - - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. - - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` - - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. - - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` - - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. - - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` - - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. - - Exemple : ``d = ADD.get("Innovation")[-1]`` + .. include:: snippets/APosterioriCorrelations.rst - MahalanobisConsistency - *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de - qualité de Mahalanobis. + .. include:: snippets/APosterioriCovariance.rst - Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]`` + .. include:: snippets/APosterioriStandardDeviations.rst - OMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état optimal dans l'espace des observations. + .. include:: snippets/APosterioriVariances.rst - Exemple : ``oma = ADD.get("OMA")[-1]`` + .. include:: snippets/BMA.rst - OMB - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état d'ébauche dans l'espace des observations. + .. include:: snippets/CostFunctionJ.rst - Exemple : ``omb = ADD.get("OMB")[-1]`` + .. include:: snippets/CostFunctionJb.rst - SigmaBck2 - *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de - qualité :math:`(\sigma^b)^2` de la partie ébauche. + .. include:: snippets/CostFunctionJo.rst - Exemple : ``sb2 = ADD.get("SigmaBck")[-1]`` + .. include:: snippets/Innovation.rst - SigmaObs2 - *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de - qualité :math:`(\sigma^o)^2` de la partie observation. + .. include:: snippets/MahalanobisConsistency.rst - Exemple : ``so2 = ADD.get("SigmaObs")[-1]`` + .. include:: snippets/OMA.rst - SimulatedObservationAtBackground - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'ébauche :math:`\mathbf{x}^b`. + .. include:: snippets/OMB.rst - Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + .. include:: snippets/SigmaBck2.rst - SimulatedObservationAtOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`. + .. include:: snippets/SigmaObs2.rst - Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]`` + .. include:: snippets/SimulatedObservationAtBackground.rst - SimulationQuantiles - *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état - observé qui réalise le quantile demandé, dans le même ordre que les - quantiles requis par l'utilisateur. + .. include:: snippets/SimulatedObservationAtOptimum.rst - Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` + .. include:: snippets/SimulationQuantiles.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst b/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst index 840fdbc..97bd2d2 100644 --- a/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst +++ b/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst @@ -25,7 +25,7 @@ .. _section_ref_algorithm_DerivativeFreeOptimization: Algorithme de calcul "*DerivativeFreeOptimization*" ----------------------------------------------------- +--------------------------------------------------- .. warning:: @@ -49,56 +49,18 @@ en assimilation de données. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: Minimizer -.. index:: single: MaximumNumberOfSteps -.. index:: single: MaximumNumberOfFunctionEvaluations -.. index:: single: StateVariationTolerance -.. index:: single: CostDecrementTolerance -.. index:: single: QualityCriterion -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -109,80 +71,23 @@ commande. Les options de l'algorithme sont les suivantes: - Minimizer - Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par - défaut est "BOBYQA", et les choix possibles sont - "BOBYQA" (minimisation avec ou sans contraintes par approximation quadratique [Powell09]_), - "COBYLA" (minimisation avec ou sans contraintes par approximation linéaire [Powell94]_ [Powell98]_). - "NEWUOA" (minimisation avec ou sans contraintes par approximation quadratique itérative [Powell04]_), - "POWELL" (minimisation sans contraintes de type directions conjuguées [Powell64]_), - "SIMPLEX" (minimisation avec ou sans contraintes de type simplexe ou Nelder-Mead, voir [Nelder65]_), - "SUBPLEX" (minimisation avec ou sans contraintes de type simplexe sur une suite de sous-espaces [Rowan90]_). - Remarque : la méthode "POWELL" effectue une optimisation par boucles - imbriquées interne/externe, conduisant ainsi à un contrôle relaché du - nombre d'évaluations de la fonctionnelle à optimiser. Si un contrôle précis - du nombre d'évaluations de cette fonctionnelle est requis, il faut choisir - un autre minimiseur. - - Exemple : ``{"Minimizer":"BOBYQA"}`` - - Bounds - Cette clé permet de définir des bornes supérieure et inférieure pour chaque - variable d'état optimisée. Les bornes doivent être données par une liste de - liste de paires de bornes inférieure/supérieure pour chaque variable, avec - une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes peuvent - toujours être spécifiées, mais seuls les optimiseurs sous contraintes les - prennent en compte. - - Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}`` - - MaximumNumberOfSteps - Cette clé indique le nombre maximum d'itérations possibles en optimisation - itérative. Le défaut est 15000, qui est une limite arbitraire. Il est ainsi - fortement recommandé d'adapter ce paramètre aux besoins pour des problèmes - réels. Pour certains optimiseurs, le nombre de pas effectif d'arrêt peut - être légèrement différent de la limite à cause d'exigences de contrôle - interne de l'algorithme. - - Exemple : ``{"MaximumNumberOfSteps":50}`` - - MaximumNumberOfFunctionEvaluations - Cette clé indique le nombre maximum d'évaluations possibles de la - fonctionnelle à optimiser. Le défaut est de 15000, qui est une limite - arbitraire. Il est ainsi recommandé d'adapter ce paramètre aux besoins pour - des problèmes réels. Pour certains optimiseurs, le nombre effectif - d'évaluations à l'arrêt peut être légèrement différent de la limite à cause - d'exigences de déroulement interne de l'algorithme. - - Exemple : ``{"MaximumNumberOfFunctionEvaluations":50}`` - - StateVariationTolerance - Cette clé indique la variation relative maximale de l'état lors pour l'arrêt - par convergence sur l'état. Le défaut est de 1.e-4, et il est recommandé - de l'adapter aux besoins pour des problèmes réels. - - Exemple : ``{"StateVariationTolerance":1.e-4}`` - - CostDecrementTolerance - Cette clé indique une valeur limite, conduisant à arrêter le processus - itératif d'optimisation lorsque la fonction coût décroît moins que cette - tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé - de l'adapter aux besoins pour des problèmes réels. - - Exemple : ``{"CostDecrementTolerance":1.e-7}`` - - QualityCriterion - Cette clé indique le critère de qualité, qui est minimisé pour trouver - l'estimation optimale de l'état. Le défaut est le critère usuel de - l'assimilation de données nommé "DA", qui est le critère de moindres carrés - pondérés augmentés. Les critères possibles sont dans la liste suivante, dans - laquelle les noms équivalents sont indiqués par un signe "=" : - ["AugmentedWeightedLeastSquares"="AWLS"="DA", "WeightedLeastSquares"="WLS", - "LeastSquares"="LS"="L2", "AbsoluteValue"="L1", "MaximumError"="ME"]. - - Exemple : ``{"QualityCriterion":"DA"}`` + .. include:: snippets/Minimizer_DFO.rst + + .. include:: snippets/BoundsWithNone.rst + + .. include:: snippets/MaximumNumberOfSteps.rst + + .. include:: snippets/MaximumNumberOfFunctionEvaluations.rst + + .. include:: snippets/StateVariationTolerance.rst + + .. include:: snippets/CostDecrementTolerance.rst + + .. include:: snippets/QualityCriterion.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -195,7 +100,8 @@ Les options de l'algorithme sont les suivantes: "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentOptimum", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"]. - Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -210,116 +116,41 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. - - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` + .. include:: snippets/Analysis.rst - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. + .. include:: snippets/CostFunctionJ.rst - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` + .. include:: snippets/CostFunctionJb.rst - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. + .. include:: snippets/CostFunctionJo.rst - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` - - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` + .. include:: snippets/CurrentState.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - CostFunctionJAtCurrentOptimum - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis - le début. - - Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]`` - - CostFunctionJbAtCurrentOptimum - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la - valeur correspond à l'état optimal trouvé depuis le début. - - Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]`` - - CostFunctionJoAtCurrentOptimum - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas, - la valeur correspond à l'état optimal trouvé depuis le début. - - Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]`` - - CurrentOptimum - *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de - temps courant au cours du déroulement de l'algorithme d'optimisation. Ce - n'est pas nécessairement le dernier état. - - Exemple : ``Xo = ADD.get("CurrentOptimum")[:]`` - - IndexOfOptimum - *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum - obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas - nécessairement le numéro de la dernière itération. - - Exemple : ``i = ADD.get("IndexOfOptimum")[-1]`` - - InnovationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état - courant. - - Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]`` - - OMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état optimal dans l'espace des observations. + .. include:: snippets/CostFunctionJAtCurrentOptimum.rst - Exemple : ``oma = ADD.get("OMA")[-1]`` + .. include:: snippets/CostFunctionJbAtCurrentOptimum.rst - OMB - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état d'ébauche dans l'espace des observations. + .. include:: snippets/CostFunctionJoAtCurrentOptimum.rst - Exemple : ``omb = ADD.get("OMB")[-1]`` + .. include:: snippets/CurrentOptimum.rst - SimulatedObservationAtBackground - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'ébauche :math:`\mathbf{x}^b`. + .. include:: snippets/IndexOfOptimum.rst - Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + .. include:: snippets/InnovationAtCurrentState.rst - SimulatedObservationAtCurrentOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état optimal au pas de temps courant au cours du déroulement de - l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations. + .. include:: snippets/OMA.rst - Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]`` + .. include:: snippets/OMB.rst - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant, - c'est-à-dire dans l'espace des observations. + .. include:: snippets/SimulatedObservationAtBackground.rst - Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtCurrentOptimum.rst - SimulatedObservationAtOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`. + .. include:: snippets/SimulatedObservationAtCurrentState.rst - Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]`` + .. include:: snippets/SimulatedObservationAtOptimum.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_EnsembleBlue.rst b/doc/fr/ref_algorithm_EnsembleBlue.rst index 4a22b20..cc4f2c7 100644 --- a/doc/fr/ref_algorithm_EnsembleBlue.rst +++ b/doc/fr/ref_algorithm_EnsembleBlue.rst @@ -31,7 +31,7 @@ Description +++++++++++ Cet algorithme réalise une estimation de type BLUE (Best Linear Unbiased -Estimator, qui est ici un estimateur d'Aitken) de l'état d'un système par +Estimator, qui est ici un estimateur d'Aitken) de l'état d'un système, par méthode d'ensemble. Pour fonctionner, il faut fournir un ensemble d'ébauches, dont le nombre déterminera la taille de l'ensemble pour l'estimation. @@ -43,50 +43,18 @@ l':ref:`section_ref_algorithm_LinearityTest`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: SetSeed - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -97,7 +65,11 @@ commande. Les options de l'algorithme sont les suivantes: + .. include:: snippets/SetSeed.rst + StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -106,15 +78,8 @@ Les options de l'algorithme sont les suivantes: "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"]. - Exemple : ``{"StoreSupplementaryCalculations":["CurrentState", "Innovation"]}`` - - SetSeed - Cette clé permet de donner un nombre entier pour fixer la graine du - générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est - par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation par défaut de l'ordinateur. - - Exemple : ``{"SetSeed":1000}`` + Exemple : + ``{"StoreSupplementaryCalculations":["CurrentState", "Innovation"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -129,25 +94,11 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` - - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` + .. include:: snippets/Analysis.rst - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. + .. include:: snippets/CurrentState.rst - Exemple : ``d = ADD.get("Innovation")[-1]`` + .. include:: snippets/Innovation.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_ExtendedBlue.rst b/doc/fr/ref_algorithm_ExtendedBlue.rst index c8af228..9aa6eda 100644 --- a/doc/fr/ref_algorithm_ExtendedBlue.rst +++ b/doc/fr/ref_algorithm_ExtendedBlue.rst @@ -44,54 +44,18 @@ lui être entièrement équivalent. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: StoreSupplementaryCalculations -.. index:: single: Quantiles -.. index:: single: SetSeed -.. index:: single: NumberOfSamplesForQuantiles -.. index:: single: SimulationForQuantiles - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -103,6 +67,8 @@ commande. Les options de l'algorithme sont les suivantes: StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -115,45 +81,16 @@ Les options de l'algorithme sont les suivantes: "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"]. - Exemple : ``{"StoreSupplementaryCalculations":["CurrentState", "Innovation"]}`` - - Quantiles - Cette liste indique les valeurs de quantile, entre 0 et 1, à estimer par - simulation autour de l'état optimal. L'échantillonnage utilise des tirages - aléatoires gaussiens multivariés, dirigés par la matrice de covariance a - posteriori. Cette option n'est utile que si le calcul supplémentaire - "SimulationQuantiles" a été choisi. La valeur par défaut est une liste vide. + Exemple : + ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` - Exemple : ``{"Quantiles":[0.1,0.9]}`` + .. include:: snippets/Quantiles.rst - SetSeed - Cette clé permet de donner un nombre entier pour fixer la graine du - générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est - par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation par défaut de l'ordinateur. + .. include:: snippets/SetSeed.rst - Exemple : ``{"SetSeed":1000}`` + .. include:: snippets/NumberOfSamplesForQuantiles.rst - NumberOfSamplesForQuantiles - Cette clé indique le nombre de simulations effectuées pour estimer les - quantiles. Cette option n'est utile que si le calcul supplémentaire - "SimulationQuantiles" a été choisi. Le défaut est 100, ce qui suffit souvent - pour une estimation correcte de quantiles courants à 5%, 10%, 90% ou 95%. - - Exemple : ``{"NumberOfSamplesForQuantiles":100}`` - - SimulationForQuantiles - Cette clé indique le type de simulation, linéaire (avec l'opérateur - d'observation tangent appliqué sur des incréments de perturbations autour de - l'état optimal) ou non-linéaire (avec l'opérateur d'observation standard - appliqué aux états perturbés), que l'on veut faire pour chaque perturbation. - Cela change essentiellement le temps de chaque simulation élémentaire, - usuellement plus long en non-linéaire qu'en linéaire. Cette option n'est - utile que si le calcul supplémentaire "SimulationQuantiles" a été choisi. La - valeur par défaut est "Linear", et les choix possibles sont "Linear" et - "NonLinear". - - Exemple : ``{"SimulationForQuantiles":"Linear"}`` + .. include:: snippets/SimulationForQuantiles.rst Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -168,118 +105,43 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` + .. include:: snippets/Analysis.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - APosterioriCorrelations - *Liste de matrices*. Chaque élément est une matrice de corrélation des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]`` - - APosterioriCovariance - *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de - covariances des erreurs *a posteriori* de l'état optimal. - - Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` - - APosterioriStandardDeviations - *Liste de matrices*. Chaque élément est une matrice d'écart-types des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]`` - - APosterioriVariances - *Liste de matrices*. Chaque élément est une matrice de variances des erreurs - *a posteriori* de l'état optimal. - - Exemple : ``V = ADD.get("APosterioriVariances")[-1]`` - - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. - - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` - - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. - - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` - - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. - - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` - - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. - - Exemple : ``d = ADD.get("Innovation")[-1]`` + .. include:: snippets/APosterioriCorrelations.rst - MahalanobisConsistency - *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de - qualité de Mahalanobis. + .. include:: snippets/APosterioriCovariance.rst - Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]`` + .. include:: snippets/APosterioriStandardDeviations.rst - OMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état optimal dans l'espace des observations. + .. include:: snippets/APosterioriVariances.rst - Exemple : ``oma = ADD.get("OMA")[-1]`` + .. include:: snippets/BMA.rst - OMB - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état d'ébauche dans l'espace des observations. + .. include:: snippets/CostFunctionJ.rst - Exemple : ``omb = ADD.get("OMB")[-1]`` + .. include:: snippets/CostFunctionJb.rst - SigmaBck2 - *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de - qualité :math:`(\sigma^b)^2` de la partie ébauche. + .. include:: snippets/CostFunctionJo.rst - Exemple : ``sb2 = ADD.get("SigmaBck")[-1]`` + .. include:: snippets/Innovation.rst - SigmaObs2 - *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de - qualité :math:`(\sigma^o)^2` de la partie observation. + .. include:: snippets/MahalanobisConsistency.rst - Exemple : ``so2 = ADD.get("SigmaObs")[-1]`` + .. include:: snippets/OMA.rst - SimulatedObservationAtBackground - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'ébauche :math:`\mathbf{x}^b`. + .. include:: snippets/OMB.rst - Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + .. include:: snippets/SigmaBck2.rst - SimulatedObservationAtOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`. + .. include:: snippets/SigmaObs2.rst - Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]`` + .. include:: snippets/SimulatedObservationAtBackground.rst - SimulationQuantiles - *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état - observé qui réalise le quantile demandé, dans le même ordre que les - quantiles requis par l'utilisateur. + .. include:: snippets/SimulatedObservationAtOptimum.rst - Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` + .. include:: snippets/SimulationQuantiles.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst index 3ac5a95..991ad1c 100644 --- a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst @@ -34,56 +34,32 @@ Cet algorithme réalise une estimation de l'état d'un système dynamique par un filtre de Kalman étendu, utilisant un calcul non linéaire de l'état et de l'évolution incrémentale (processus). +Dans le cas d'opérateurs réellement non-linéaires, on peut aisément utiliser +l':ref:`section_ref_algorithm_EnsembleKalmanFilter` ou +l':ref:`section_ref_algorithm_UnscentedKalmanFilter`, qui sont souvent +largement plus adaptés aux comportements non-linéaires mais plus coûteux. On +peut vérifier la linéarité des opérateurs à l'aide de +l':ref:`section_ref_algorithm_LinearityTest`. + Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: Bounds -.. index:: single: ConstrainedBy -.. index:: single: EstimationOf -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/EvolutionError.rst + + .. include:: snippets/EvolutionModel.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -94,30 +70,15 @@ commande. Les options de l'algorithme sont les suivantes: - Bounds - Cette clé permet de définir des bornes supérieure et inférieure pour chaque - variable d'état optimisée. Les bornes doivent être données par une liste de - liste de paires de bornes inférieure/supérieure pour chaque variable, avec - une valeur extrême chaque fois qu'il n'y a pas de borne (``None`` n'est pas - une valeur autorisée lorsqu'il n'y a pas de borne). - - Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,1.e99],[-1.e99,1.e99]]}`` + .. include:: snippets/BoundsWithExtremes.rst - ConstrainedBy - Cette clé permet d'indiquer la méthode de prise en compte des contraintes de - bornes. La seule disponible est "EstimateProjection", qui projette - l'estimation de l'état courant sur les contraintes de bornes. + .. include:: snippets/ConstrainedBy.rst - Exemple : ``{"ConstrainedBy":"EstimateProjection"}`` - - EstimationOf - Cette clé permet de choisir le type d'estimation à réaliser. Cela peut être - soit une estimation de l'état, avec la valeur "State", ou une estimation de - paramètres, avec la valeur "Parameters". Le choix par défaut est "State". - - Exemple : ``{"EstimationOf":"Parameters"}`` + .. include:: snippets/EstimationOf.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -127,7 +88,8 @@ Les options de l'algorithme sont les suivantes: "APosterioriVariances", "BMA", "CostFunctionJ", "CostFunctionJb", "CostFunctionJo", "CurrentState", "Innovation"]. - Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -142,79 +104,34 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` + .. include:: snippets/Analysis.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - APosterioriCorrelations - *Liste de matrices*. Chaque élément est une matrice de corrélation des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]`` - - APosterioriCovariance - *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de - covariances des erreurs *a posteriori* de l'état optimal. - - Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` - - APosterioriStandardDeviations - *Liste de matrices*. Chaque élément est une matrice d'écart-types des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]`` - - APosterioriVariances - *Liste de matrices*. Chaque élément est une matrice de variances des erreurs - *a posteriori* de l'état optimal. - - Exemple : ``V = ADD.get("APosterioriVariances")[-1]`` - - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. + .. include:: snippets/APosterioriCorrelations.rst - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` + .. include:: snippets/APosterioriCovariance.rst - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. + .. include:: snippets/APosterioriStandardDeviations.rst - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` + .. include:: snippets/APosterioriVariances.rst - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. + .. include:: snippets/BMA.rst - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + .. include:: snippets/CostFunctionJ.rst - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. + .. include:: snippets/CostFunctionJb.rst - Exemple : ``Xs = ADD.get("CurrentState")[:]`` + .. include:: snippets/CostFunctionJo.rst - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. + .. include:: snippets/CurrentState.rst - Exemple : ``d = ADD.get("Innovation")[-1]`` + .. include:: snippets/Innovation.rst Voir aussi ++++++++++ Références vers d'autres sections : - :ref:`section_ref_algorithm_KalmanFilter` + - :ref:`section_ref_algorithm_EnsembleKalmanFilter` - :ref:`section_ref_algorithm_UnscentedKalmanFilter` diff --git a/doc/fr/ref_algorithm_FunctionTest.rst b/doc/fr/ref_algorithm_FunctionTest.rst index 59b036b..3bff5de 100644 --- a/doc/fr/ref_algorithm_FunctionTest.rst +++ b/doc/fr/ref_algorithm_FunctionTest.rst @@ -45,33 +45,12 @@ d'opérateur. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: CheckingPoint -.. index:: single: ObservationOperator -.. index:: single: NumberOfPrintedDigits -.. index:: single: NumberOfRepetition -.. index:: single: SetDebug -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - CheckingPoint - *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour - duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à - l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type - "*Vector*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, notée - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*". Différentes formes fonctionnelles peuvent être - utilisées, comme décrit dans la section - :ref:`section_ref_operator_requirements`. Si un contrôle :math:`U` est - inclus dans le modèle d'observation, l'opérateur doit être appliqué à une - paire :math:`(X,U)`. + .. include:: snippets/CheckingPoint.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les @@ -82,26 +61,15 @@ commande. Les options de l'algorithme sont les suivantes: - NumberOfPrintedDigits - Cette clé indique le nombre de décimales de précision pour les affichages de - valeurs réelles. La valeur par défaut est 5, avec un minimum de 0. - - Exemple : ``{"NumberOfPrintedDigits":5}`` - - NumberOfRepetition - Cette clé indique le nombre de fois où répéter l'évaluation de la fonction. - La valeur par défaut est 1. + .. include:: snippets/NumberOfPrintedDigits.rst - Exemple : ``{"NumberOfRepetition":3}`` + .. include:: snippets/NumberOfRepetition.rst - SetDebug - Cette clé requiert l'activation, ou pas, du mode de débogage durant - l'évaluation de la fonction. La valeur par défaut est "False", les choix - sont "True" ou "False". - - Exemple : ``{"SetDebug":False}`` + .. include:: snippets/SetDebug.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -109,7 +77,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["CurrentState", "SimulatedObservationAtCurrentState"]. - Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["CurrentState"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -124,17 +93,9 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties conditionnelles de l'algorithme sont les suivantes: - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état courant, c'est-à-dire dans l'espace des observations. + .. include:: snippets/CurrentState.rst - Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtCurrentState.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_GradientTest.rst b/doc/fr/ref_algorithm_GradientTest.rst index 15e8ab5..3791059 100644 --- a/doc/fr/ref_algorithm_GradientTest.rst +++ b/doc/fr/ref_algorithm_GradientTest.rst @@ -88,35 +88,12 @@ qui doit rester constant jusqu'à ce que l'on atteigne la précision du calcul. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: CheckingPoint -.. index:: single: ObservationOperator -.. index:: single: AmplitudeOfInitialDirection -.. index:: single: EpsilonMinimumExponent -.. index:: single: InitialDirection -.. index:: single: ResiduFormula -.. index:: single: SetSeed -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - CheckingPoint - *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour - duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à - l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type - "*Vector*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, notée - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*". Différentes formes fonctionnelles peuvent être - utilisées, comme décrit dans la section - :ref:`section_ref_operator_requirements`. Si un contrôle :math:`U` est - inclus dans le modèle d'observation, l'opérateur doit être appliqué à une - paire :math:`(X,U)`. + .. include:: snippets/CheckingPoint.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les @@ -127,33 +104,17 @@ commande. Les options de l'algorithme sont les suivantes: - AmplitudeOfInitialDirection - Cette clé indique la mise à l'échelle de la perturbation initiale construite - comme un vecteur utilisé pour la dérivée directionnelle autour du point - nominal de vérification. La valeur par défaut est de 1, ce qui signifie pas - de mise à l'échelle. - - Exemple : ``{"AmplitudeOfInitialDirection":0.5}`` + .. include:: snippets/AmplitudeOfInitialDirection.rst - EpsilonMinimumExponent - Cette clé indique la valeur de l'exposant minimal du coefficient en - puissance de 10 qui doit être utilisé pour faire décroître le multiplicateur - de l'incrément. La valeur par défaut est de -8, et elle doit être entre 0 et - -20. Par exemple, la valeur par défaut conduit à calculer le résidu de la - formule avec un incrément fixe multiplié par 1.e0 jusqu'à 1.e-8. + .. include:: snippets/EpsilonMinimumExponent.rst - Exemple : ``{"EpsilonMinimumExponent":-12}`` + .. include:: snippets/InitialDirection.rst - InitialDirection - Cette clé indique la direction vectorielle utilisée pour la dérivée - directionnelle autour du point nominal de vérification. Cela doit être un - vecteur. Si elle n'est pas spécifiée, la direction par défaut est une - perturbation par défaut autour de zéro de la même taille vectorielle que le - point de vérification. - - Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}`` + .. include:: snippets/SetSeed.rst ResiduFormula + .. index:: single: ResiduFormula + Cette clé indique la formule de résidu qui doit être utilisée pour le test. Le choix par défaut est "Taylor", et les choix possibles sont "Taylor" (résidu du développement de Taylor normalisé de l'opérateur, qui doit @@ -163,17 +124,12 @@ Les options de l'algorithme sont les suivantes: développement de Taylor à l'ordre 0, qui approxime le gradient, et qui doit rester constant). - Exemple : ``{"ResiduFormula":"Taylor"}`` - - SetSeed - Cette clé permet de donner un nombre entier pour fixer la graine du - générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est - par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation par défaut de l'ordinateur. - - Exemple : ``{"SetSeed":1000}`` + Exemple : + ``{"ResiduFormula":"Taylor"}`` StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -181,7 +137,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["CurrentState", "Residu", "SimulatedObservationAtCurrentState"]. - Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["CurrentState"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -196,26 +153,13 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Residu - *Liste de valeurs*. Chaque élément est la valeur du résidu particulier - vérifié lors d'un algorithme de vérification, selon l'ordre des tests - effectués. - - Exemple : ``r = ADD.get("Residu")[:]`` + .. include:: snippets/Residu.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état courant, c'est-à-dire dans l'espace des observations. + .. include:: snippets/CurrentState.rst - Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtCurrentState.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_KalmanFilter.rst b/doc/fr/ref_algorithm_KalmanFilter.rst index 92bc7cc..6e3c25a 100644 --- a/doc/fr/ref_algorithm_KalmanFilter.rst +++ b/doc/fr/ref_algorithm_KalmanFilter.rst @@ -39,57 +39,29 @@ incrémentale (processus) linéaires, même s'il fonctionne parfois dans les cas d'observation à l'aide de l':ref:`section_ref_algorithm_LinearityTest`. En cas de non-linéarité, même peu marquée, on lui préférera -l':ref:`section_ref_algorithm_ExtendedKalmanFilter` ou -l':ref:`section_ref_algorithm_UnscentedKalmanFilter`. +l':ref:`section_ref_algorithm_ExtendedKalmanFilter`, ou +l':ref:`section_ref_algorithm_EnsembleKalmanFilter` et +l':ref:`section_ref_algorithm_UnscentedKalmanFilter` qui sont plus puissants. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: EstimationOf -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/EvolutionError.rst + + .. include:: snippets/EvolutionModel.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -100,14 +72,11 @@ commande. Les options de l'algorithme sont les suivantes: - EstimationOf - Cette clé permet de choisir le type d'estimation à réaliser. Cela peut être - soit une estimation de l'état, avec la valeur "State", ou une estimation de - paramètres, avec la valeur "Parameters". Le choix par défaut est "State". - - Exemple : ``{"EstimationOf":"Parameters"}`` + .. include:: snippets/EstimationOf.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -132,79 +101,34 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` + .. include:: snippets/Analysis.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - APosterioriCorrelations - *Liste de matrices*. Chaque élément est une matrice de corrélation des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]`` - - APosterioriCovariance - *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de - covariances des erreurs *a posteriori* de l'état optimal. - - Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` - - APosterioriStandardDeviations - *Liste de matrices*. Chaque élément est une matrice d'écart-types des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]`` - - APosterioriVariances - *Liste de matrices*. Chaque élément est une matrice de variances des erreurs - *a posteriori* de l'état optimal. - - Exemple : ``V = ADD.get("APosterioriVariances")[-1]`` - - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. + .. include:: snippets/APosterioriCorrelations.rst - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` + .. include:: snippets/APosterioriCovariance.rst - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. + .. include:: snippets/APosterioriStandardDeviations.rst - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` + .. include:: snippets/APosterioriVariances.rst - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. + .. include:: snippets/BMA.rst - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + .. include:: snippets/CostFunctionJ.rst - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. + .. include:: snippets/CostFunctionJb.rst - Exemple : ``Xs = ADD.get("CurrentState")[:]`` + .. include:: snippets/CostFunctionJo.rst - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. + .. include:: snippets/CurrentState.rst - Exemple : ``d = ADD.get("Innovation")[-1]`` + .. include:: snippets/Innovation.rst Voir aussi ++++++++++ Références vers d'autres sections : - :ref:`section_ref_algorithm_ExtendedKalmanFilter` + - :ref:`section_ref_algorithm_EnsembleKalmanFilter` - :ref:`section_ref_algorithm_UnscentedKalmanFilter` diff --git a/doc/fr/ref_algorithm_LinearLeastSquares.rst b/doc/fr/ref_algorithm_LinearLeastSquares.rst index d8d0af9..f163372 100644 --- a/doc/fr/ref_algorithm_LinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_LinearLeastSquares.rst @@ -48,37 +48,14 @@ l':ref:`section_ref_algorithm_3DVAR`. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -90,6 +67,8 @@ commande. Les options de l'algorithme sont les suivantes: StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -98,15 +77,16 @@ Les options de l'algorithme sont les suivantes: "CostFunctionJ", "CostFunctionJb", "CostFunctionJo", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"]. - Exemple : ``{"StoreSupplementaryCalculations":["OMA", "CurrentState"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["OMA", "CurrentState"]}`` *Astuce pour cet algorithme :* - Comme les commandes *"Background"* et *"BackgroundError"* sont requises pour - TOUS les algorithmes de calcul dans l'interface, vous devez fournir une - valeur, malgré le fait que ces commandes ne sont pas requises pour - cet algorithme, et ne seront pas utilisées. La manière la plus simple est - de donner "1" comme un STRING pour les deux. + Comme les commandes *"Background"* et *"BackgroundError"* sont requises + pour TOUS les algorithmes de calcul dans l'interface graphique, vous devez + fournir une valeur, malgré le fait que ces commandes ne sont pas requises + pour cet algorithme, et ne seront pas utilisées. La manière la plus simple + est de donner "1" comme un STRING pour les deux. Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -121,44 +101,19 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` + .. include:: snippets/Analysis.rst - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. + .. include:: snippets/CostFunctionJ.rst - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` + .. include:: snippets/CostFunctionJb.rst - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. - - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` - - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. - - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + .. include:: snippets/CostFunctionJo.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - OMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état optimal dans l'espace des observations. - - Exemple : ``oma = ADD.get("OMA")[-1]`` - - SimulatedObservationAtOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`. + .. include:: snippets/OMA.rst - Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]`` + .. include:: snippets/SimulatedObservationAtOptimum.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_LinearityTest.rst b/doc/fr/ref_algorithm_LinearityTest.rst index 77e70c1..5bdd754 100644 --- a/doc/fr/ref_algorithm_LinearityTest.rst +++ b/doc/fr/ref_algorithm_LinearityTest.rst @@ -111,35 +111,12 @@ de F est vérifiée. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: CheckingPoint -.. index:: single: ObservationOperator -.. index:: single: AmplitudeOfInitialDirection -.. index:: single: EpsilonMinimumExponent -.. index:: single: InitialDirection -.. index:: single: ResiduFormula -.. index:: single: SetSeed -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - CheckingPoint - *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour - duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à - l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type - "*Vector*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, notée - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*". Différentes formes fonctionnelles peuvent être - utilisées, comme décrit dans la section - :ref:`section_ref_operator_requirements`. Si un contrôle :math:`U` est - inclus dans le modèle d'observation, l'opérateur doit être appliqué à une - paire :math:`(X,U)`. + .. include:: snippets/CheckingPoint.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les @@ -150,33 +127,17 @@ commande. Les options de l'algorithme sont les suivantes: - AmplitudeOfInitialDirection - Cette clé indique la mise à l'échelle de la perturbation initiale construite - comme un vecteur utilisé pour la dérivée directionnelle autour du point - nominal de vérification. La valeur par défaut est de 1, ce qui signifie pas - de mise à l'échelle. - - Exemple : ``{"AmplitudeOfInitialDirection":0.5}`` + .. include:: snippets/AmplitudeOfInitialDirection.rst - EpsilonMinimumExponent - Cette clé indique la valeur de l'exposant minimal du coefficient en - puissance de 10 qui doit être utilisé pour faire décroître le multiplicateur - de l'incrément. La valeur par défaut est de -8, et elle doit être entre 0 et - -20. Par exemple, la valeur par défaut conduit à calculer le résidu de la - formule avec un incrément fixe multiplié par 1.e0 jusqu'à 1.e-8. + .. include:: snippets/EpsilonMinimumExponent.rst - Exemple : ``{"EpsilonMinimumExponent":-12}`` + .. include:: snippets/InitialDirection.rst - InitialDirection - Cette clé indique la direction vectorielle utilisée pour la dérivée - directionnelle autour du point nominal de vérification. Cela doit être un - vecteur. Si elle n'est pas spécifiée, la direction par défaut est une - perturbation par défaut autour de zéro de la même taille vectorielle que le - point de vérification. - - Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}`` + .. include:: snippets/SetSeed.rst ResiduFormula + .. index:: single: ResiduFormula + Cette clé indique la formule de résidu qui doit être utilisée pour le test. Le choix par défaut est "CenteredDL", et les choix possibles sont "CenteredDL" (résidu de la différence entre la fonction au point nominal et @@ -189,17 +150,12 @@ Les options de l'algorithme sont les suivantes: normalisé par l'écart quadratique moyen (RMS) au point nominal, qui doit rester proche de 0). - Exemple : ``{"ResiduFormula":"CenteredDL"}`` - - SetSeed - Cette clé permet de donner un nombre entier pour fixer la graine du - générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est - par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation par défaut de l'ordinateur. - - Exemple : ``{"SetSeed":1000}`` + Exemple : + ``{"ResiduFormula":"CenteredDL"}`` StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -207,7 +163,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["CurrentState", "Residu", "SimulatedObservationAtCurrentState"]. - Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["CurrentState"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -222,26 +179,13 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Residu - *Liste de valeurs*. Chaque élément est la valeur du résidu particulier - vérifié lors d'un algorithme de vérification, selon l'ordre des tests - effectués. - - Exemple : ``r = ADD.get("Residu")[:]`` + .. include:: snippets/Residu.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état courant, c'est-à-dire dans l'espace des observations. + .. include:: snippets/CurrentState.rst - Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtCurrentState.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst index 3edc9d4..c0f8dfe 100644 --- a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst @@ -46,49 +46,16 @@ comportement lors de l'optimisation. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: Minimizer -.. index:: single: Bounds -.. index:: single: MaximumNumberOfSteps -.. index:: single: CostDecrementTolerance -.. index:: single: ProjectedGradientTolerance -.. index:: single: GradientNormTolerance -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -100,6 +67,8 @@ commande. Les options de l'algorithme sont les suivantes: Minimizer + .. index:: single: Minimizer + Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par défaut est "LBFGSB", et les choix possibles sont "LBFGSB" (minimisation non linéaire sous contraintes, voir [Byrd95]_, [Morales11]_ et [Zhu97]_), "TNC" @@ -109,55 +78,22 @@ Les options de l'algorithme sont les suivantes: (minimisation non linéaire de type Levenberg-Marquard). Il est fortement conseillé de conserver la valeur par défaut. - Exemple : ``{"Minimizer":"LBFGSB"}`` - - Bounds - Cette clé permet de définir des bornes supérieure et inférieure pour chaque - variable d'état optimisée. Les bornes doivent être données par une liste de - liste de paires de bornes inférieure/supérieure pour chaque variable, avec - une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes - peuvent toujours être spécifiées, mais seuls les optimiseurs sous - contraintes les prennent en compte. + Exemple : + ``{"Minimizer":"LBFGSB"}`` - Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}`` + .. include:: snippets/BoundsWithNone.rst - MaximumNumberOfSteps - Cette clé indique le nombre maximum d'itérations possibles en optimisation - itérative. Le défaut est 15000, qui est très similaire à une absence de - limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre - aux besoins pour des problèmes réels. Pour certains optimiseurs, le nombre - de pas effectif d'arrêt peut être légèrement différent de la limite à cause - d'exigences de contrôle interne de l'algorithme. + .. include:: snippets/MaximumNumberOfSteps.rst - Exemple : ``{"MaximumNumberOfSteps":100}`` + .. include:: snippets/CostDecrementTolerance.rst - CostDecrementTolerance - Cette clé indique une valeur limite, conduisant à arrêter le processus - itératif d'optimisation lorsque la fonction coût décroît moins que cette - tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé - de l'adapter aux besoins pour des problèmes réels. + .. include:: snippets/ProjectedGradientTolerance.rst - Exemple : ``{"CostDecrementTolerance":1.e-7}`` - - ProjectedGradientTolerance - Cette clé indique une valeur limite, conduisant à arrêter le processus - itératif d'optimisation lorsque toutes les composantes du gradient projeté - sont en-dessous de cette limite. C'est utilisé uniquement par les - optimiseurs sous contraintes. Le défaut est -1, qui désigne le défaut - interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé - de le changer. - - Exemple : ``{"ProjectedGradientTolerance":-1}`` - - GradientNormTolerance - Cette clé indique une valeur limite, conduisant à arrêter le processus - itératif d'optimisation lorsque la norme du gradient est en dessous de cette - limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le - défaut est 1.e-5 et il n'est pas recommandé de le changer. - - Exemple : ``{"GradientNormTolerance":1.e-5}`` + .. include:: snippets/GradientNormTolerance.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -170,14 +106,16 @@ Les options de l'algorithme sont les suivantes: "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum", "SimulatedObservationAtCurrentOptimum"]. - Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` *Astuce pour cet algorithme :* Comme la commande *"BackgroundError"* est requise pour TOUS les algorithmes - de calcul dans l'interface, vous devez fournir une valeur, malgré le fait - que cette commande n'est pas requise pour cet algorithme, et ne sera pas - utilisée. La manière la plus simple est de donner "1" comme un STRING. + de calcul dans l'interface graphique, vous devez fournir une valeur, malgré + le fait que cette commande n'est pas requise pour cet algorithme, et ne + sera pas utilisée. La manière la plus simple est de donner "1" comme un + STRING. Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -192,101 +130,45 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. + .. include:: snippets/Analysis.rst - Exemple : ``Xa = ADD.get("Analysis")[-1]`` + .. include:: snippets/CostFunctionJ.rst - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. + .. include:: snippets/CostFunctionJb.rst - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` - - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. - - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` - - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. - - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + .. include:: snippets/CostFunctionJo.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - IndexOfOptimum - *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum - obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas - nécessairement le numéro de la dernière itération. - - Exemple : ``i = ADD.get("IndexOfOptimum")[-1]`` - - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. - - Exemple : ``d = ADD.get("Innovation")[-1]`` + .. include:: snippets/BMA.rst - InnovationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état - courant. + .. include:: snippets/CostFunctionJAtCurrentOptimum.rst - Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]`` + .. include:: snippets/CostFunctionJbAtCurrentOptimum.rst - OMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état optimal dans l'espace des observations. + .. include:: snippets/CostFunctionJoAtCurrentOptimum.rst - Exemple : ``oma = ADD.get("OMA")[-1]`` + .. include:: snippets/CurrentOptimum.rst - OMB - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état d'ébauche dans l'espace des observations. + .. include:: snippets/CurrentState.rst - Exemple : ``omb = ADD.get("OMB")[-1]`` + .. include:: snippets/IndexOfOptimum.rst - SimulatedObservationAtBackground - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'ébauche :math:`\mathbf{x}^b`. + .. include:: snippets/Innovation.rst - Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + .. include:: snippets/InnovationAtCurrentState.rst - SimulatedObservationAtCurrentOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état optimal au pas de temps courant au cours du déroulement de - l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations. + .. include:: snippets/OMA.rst - Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]`` + .. include:: snippets/OMB.rst - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état courant, c'est-à-dire dans l'espace des observations. + .. include:: snippets/SimulatedObservationAtBackground.rst - Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtCurrentOptimum.rst - SimulatedObservationAtOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`. + .. include:: snippets/SimulatedObservationAtCurrentState.rst - Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]`` + .. include:: snippets/SimulatedObservationAtOptimum.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_ObserverTest.rst b/doc/fr/ref_algorithm_ObserverTest.rst index 25b9cf5..5fc7bb9 100644 --- a/doc/fr/ref_algorithm_ObserverTest.rst +++ b/doc/fr/ref_algorithm_ObserverTest.rst @@ -39,22 +39,10 @@ l'interface. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: CheckingPoint -.. index:: single: ObservationOperator -.. index:: single: Observers - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Observers - *Commande obligatoire*. Elle permet de définir des observateurs internes, - qui sont des fonctions liées à une variable particulière, qui sont exécutées - chaque fois que cette variable est modifiée. C'est une manière pratique de - suivre des variables d'intérêt durant le processus d'assimilation de données - ou d'optimisation, en l'affichant ou en la traçant, etc. Des exemples - courants (squelettes) sont fournis pour aider l'utilisateur ou pour - faciliter l'élaboration d'un cas. + .. include:: snippets/Observers.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_checking_keywords`. diff --git a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst index facea9e..f9ca7d7 100644 --- a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst @@ -45,58 +45,18 @@ en assimilation de données. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: MaximumNumberOfSteps -.. index:: single: MaximumNumberOfFunctionEvaluations -.. index:: single: NumberOfInsects -.. index:: single: SwarmVelocity -.. index:: single: GroupRecallRate -.. index:: single: QualityCriterion -.. index:: single: BoxBounds -.. index:: single: SetSeed -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -106,53 +66,39 @@ options particulières, décrites ci-après, de l'algorithme. On se reportera à commande. Les options de l'algorithme sont les suivantes: +.. index:: single: NumberOfInsects +.. index:: single: SwarmVelocity +.. index:: single: GroupRecallRate +.. index:: single: QualityCriterion +.. index:: single: BoxBounds - MaximumNumberOfSteps - Cette clé indique le nombre maximum d'itérations possibles en optimisation - itérative. Le défaut est 50, qui est une limite arbitraire. Il est ainsi - recommandé d'adapter ce paramètre aux besoins pour des problèmes réels. - - Exemple : ``{"MaximumNumberOfSteps":100}`` + .. include:: snippets/MaximumNumberOfSteps_50.rst - MaximumNumberOfFunctionEvaluations - Cette clé indique le nombre maximum d'évaluations possibles de la - fonctionnelle à optimiser. Le défaut est de 15000, qui est une limite - arbitraire. Il est ainsi recommandé d'adapter ce paramètre aux besoins pour - des problèmes réels. Pour certains optimiseurs, le nombre effectif - d'évaluations à l'arrêt peut être légèrement différent de la limite à cause - d'exigences de déroulement interne de l'algorithme. + .. include:: snippets/MaximumNumberOfFunctionEvaluations.rst - Exemple : ``{"MaximumNumberOfFunctionEvaluations":50}`` + .. include:: snippets/QualityCriterion.rst NumberOfInsects Cette clé indique le nombre d'insectes ou de particules dans l'essaim. La valeur par défaut est 100, qui est une valeur par défaut usuelle pour cet algorithme. - Exemple : ``{"NumberOfInsects":100}`` + Exemple : + ``{"NumberOfInsects":100}`` SwarmVelocity Cette clé indique la part de la vitesse d'insecte qui est imposée par l'essaim. C'est une valeur réelle positive. Le défaut est de 1. - Exemple : ``{"SwarmVelocity":1.}`` + Exemple : + ``{"SwarmVelocity":1.}`` GroupRecallRate Cette clé indique le taux de rappel vers le meilleur insecte de l'essaim. C'est une valeur réelle comprise entre 0 et 1. Le défaut est de 0.5. - Exemple : ``{"GroupRecallRate":0.5}`` - - QualityCriterion - Cette clé indique le critère de qualité, qui est minimisé pour trouver - l'estimation optimale de l'état. Le défaut est le critère usuel de - l'assimilation de données nommé "DA", qui est le critère de moindres carrés - pondérés augmentés. Les critères possibles sont dans la liste suivante, dans - laquelle les noms équivalents sont indiqués par un signe "=" : - ["AugmentedWeightedLeastSquares"="AWLS"="DA", "WeightedLeastSquares"="WLS", - "LeastSquares"="LS"="L2", "AbsoluteValue"="L1", "MaximumError"="ME"]. - - Exemple : ``{"QualityCriterion":"DA"}`` + Exemple : + ``{"GroupRecallRate":0.5}`` BoxBounds Cette clé permet de définir des bornes supérieure et inférieure pour chaque @@ -163,17 +109,14 @@ Les options de l'algorithme sont les suivantes: valeur autorisée lorsqu'il n'y a pas de borne). Cette clé est requise et il n'y a pas de valeurs par défaut. - Exemple : ``{"BoxBounds":[[-0.5,0.5], [0.01,2.], [0.,1.e99], [-1.e99,1.e99]]}`` + Exemple : + ``{"BoxBounds":[[-0.5,0.5], [0.01,2.], [0.,1.e99], [-1.e99,1.e99]]}`` - SetSeed - Cette clé permet de donner un nombre entier pour fixer la graine du - générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est - par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation par défaut de l'ordinateur. - - Exemple : ``{"SetSeed":1000}`` + .. include:: snippets/SetSeed.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -183,7 +126,8 @@ Les options de l'algorithme sont les suivantes: "Innovation", "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"]. - Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -198,81 +142,31 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. - - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` - - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. + .. include:: snippets/Analysis.rst - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` + .. include:: snippets/CostFunctionJ.rst - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. + .. include:: snippets/CostFunctionJb.rst - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + .. include:: snippets/CostFunctionJo.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. - - Exemple : ``d = ADD.get("Innovation")[-1]`` - - OMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état optimal dans l'espace des observations. - - Exemple : ``oma = ADD.get("OMA")[-1]`` - - OMB - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état d'ébauche dans l'espace des observations. + .. include:: snippets/BMA.rst - Exemple : ``omb = ADD.get("OMB")[-1]`` + .. include:: snippets/CurrentState.rst - SimulatedObservationAtBackground - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'ébauche :math:`\mathbf{x}^b`. + .. include:: snippets/Innovation.rst - Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + .. include:: snippets/OMA.rst - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant, - c'est-à-dire dans l'espace des observations. + .. include:: snippets/OMB.rst - Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtBackground.rst - SimulatedObservationAtOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`. + .. include:: snippets/SimulatedObservationAtCurrentState.rst - Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]`` + .. include:: snippets/SimulatedObservationAtOptimum.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_QuantileRegression.rst b/doc/fr/ref_algorithm_QuantileRegression.rst index e131865..ed6c1b3 100644 --- a/doc/fr/ref_algorithm_QuantileRegression.rst +++ b/doc/fr/ref_algorithm_QuantileRegression.rst @@ -38,41 +38,14 @@ déterminer les paramètres de modèles satisfaisant aux conditions de quantiles Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: Observation -.. index:: single: ObservationOperator -.. index:: single: Quantile -.. index:: single: Minimizer -.. index:: single: MaximumNumberOfSteps -.. index:: single: CostDecrementTolerance -.. index:: single: Bounds -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -83,39 +56,17 @@ commande. Les options de l'algorithme sont les suivantes: - Quantile - Cette clé permet de définir la valeur réelle du quantile recherché, entre 0 - et 1. La valeur par défaut est 0.5, correspondant à la médiane. - - Exemple : ``{"Quantile":0.5}`` - - MaximumNumberOfSteps - Cette clé indique le nombre maximum d'itérations possibles en optimisation - itérative. Le défaut est 15000, qui est très similaire à une absence de - limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre - aux besoins pour des problèmes réels. + .. include:: snippets/Quantile.rst - Exemple : ``{"MaximumNumberOfSteps":100}`` + .. include:: snippets/MaximumNumberOfSteps.rst - CostDecrementTolerance - Cette clé indique une valeur limite, conduisant à arrêter le processus - itératif d'optimisation lorsque la fonction coût décroît moins que cette - tolérance au dernier pas. Le défaut est de 1.e-6, et il est recommandé de - l'adapter aux besoins pour des problèmes réels. + .. include:: snippets/CostDecrementTolerance_6.rst - Exemple : ``{"CostDecrementTolerance":1.e-7}`` - - Bounds - Cette clé permet de définir des bornes supérieure et inférieure pour chaque - variable d'état optimisée. Les bornes doivent être données par une liste de - liste de paires de bornes inférieure/supérieure pour chaque variable, avec - une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes peuvent - toujours être spécifiées, mais seuls les optimiseurs sous contraintes les - prennent en compte. - - Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}`` + .. include:: snippets/BoundsWithNone.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -125,15 +76,16 @@ Les options de l'algorithme sont les suivantes: "Innovation", "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"]. - Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` *Astuce pour cet algorithme :* Comme les commandes *"BackgroundError"* et *"ObservationError"* sont - requises pour TOUS les algorithmes de calcul dans l'interface, vous devez - fournir une valeur, malgré le fait que ces commandes ne sont pas requises - pour cet algorithme, et ne seront pas utilisées. La manière la plus simple - est de donner "1" comme un STRING pour les deux. + requises pour TOUS les algorithmes de calcul dans l'interface graphique, + vous devez fournir une valeur, malgré le fait que ces commandes ne sont pas + requises pour cet algorithme, et ne seront pas utilisées. La manière la + plus simple est de donner "1" comme un STRING pour les deux. Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -148,81 +100,31 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. + .. include:: snippets/Analysis.rst - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` + .. include:: snippets/CostFunctionJ.rst - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. + .. include:: snippets/CostFunctionJb.rst - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` - - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. - - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + .. include:: snippets/CostFunctionJo.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. - - Exemple : ``d = ADD.get("Innovation")[-1]`` - - OMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état optimal dans l'espace des observations. - - Exemple : ``oma = ADD.get("OMA")[-1]`` - - OMB - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état d'ébauche dans l'espace des observations. + .. include:: snippets/BMA.rst - Exemple : ``omb = ADD.get("OMB")[-1]`` + .. include:: snippets/CurrentState.rst - SimulatedObservationAtBackground - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'ébauche :math:`\mathbf{x}^b`. + .. include:: snippets/Innovation.rst - Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + .. include:: snippets/OMA.rst - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant, - c'est-à-dire dans l'espace des observations. + .. include:: snippets/OMB.rst - Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtBackground.rst - SimulatedObservationAtOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`. + .. include:: snippets/SimulatedObservationAtCurrentState.rst - Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]`` + .. include:: snippets/SimulatedObservationAtOptimum.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_SamplingTest.rst b/doc/fr/ref_algorithm_SamplingTest.rst index 4cabc23..94ec19c 100644 --- a/doc/fr/ref_algorithm_SamplingTest.rst +++ b/doc/fr/ref_algorithm_SamplingTest.rst @@ -57,58 +57,18 @@ OPENTURNS disponible dans SALOME. Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: CheckingPoint -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: SampleAsnUplet -.. index:: single: SampleAsExplicitHyperCube -.. index:: single: SampleAsMinMaxStepHyperCube -.. index:: single: SampleAsIndependantRandomVariables -.. index:: single: QualityCriterion -.. index:: single: SetDebug -.. index:: single: SetSeed -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - CheckingPoint - *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour - duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à - l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type - "*Vector*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, notée - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*". Différentes formes fonctionnelles peuvent être - utilisées, comme décrit dans la section - :ref:`section_ref_operator_requirements`. Si un contrôle :math:`U` est - inclus dans le modèle d'observation, l'opérateur doit être appliqué à une - paire :math:`(X,U)`. + .. include:: snippets/CheckingPoint.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les @@ -118,12 +78,17 @@ options particulières, décrites ci-après, de l'algorithme. On se reportera à commande. Les options de l'algorithme sont les suivantes: +.. index:: single: SampleAsnUplet +.. index:: single: SampleAsExplicitHyperCube +.. index:: single: SampleAsMinMaxStepHyperCube +.. index:: single: SampleAsIndependantRandomVariables SampleAsnUplet Cette clé décrit les points de calcul sous la forme d'une liste de n-uplets, chaque n-uplet étant un état. - Exemple : ``{"SampleAsnUplet":[[0,1,2,3],[4,3,2,1],[-2,3,-4,5]]}`` pour 3 points dans un espace d'état de dimension 4 + Exemple : + ``{"SampleAsnUplet":[[0,1,2,3],[4,3,2,1],[-2,3,-4,5]]}`` pour 3 points dans un espace d'état de dimension 4 SampleAsExplicitHyperCube Cette clé décrit les points de calcul sous la forme d'un hyper-cube, dont on @@ -139,7 +104,8 @@ Les options de l'algorithme sont les suivantes: triplet *[min,max,step]*. C'est donc une liste de la même taille que celle de l'état. Les bornes sont incluses. - Exemple : ``{"SampleAsMinMaxStepHyperCube":[[0.,1.,0.25],[-1,3,1]]}`` pour un espace d'état de dimension 2 + Exemple : + ``{"SampleAsMinMaxStepHyperCube":[[0.,1.,0.25],[-1,3,1]]}`` pour un espace d'état de dimension 2 SampleAsIndependantRandomVariables Cette clé décrit les points de calcul sous la forme d'un hyper-cube, dont @@ -152,35 +118,18 @@ Les options de l'algorithme sont les suivantes: (low,high), ou 'weibull' de paramètre (shape). C'est donc une liste de la même taille que celle de l'état. - Exemple : ``{"SampleAsIndependantRandomVariables":[ ['normal',[0.,1.],3], ['uniform',[-2,2],4]]`` pour un espace d'état de dimension 2 - - QualityCriterion - Cette clé indique le critère de qualité, qui est utilisé pour trouver - l'estimation de l'état. Le défaut est le critère usuel de l'assimilation de - données nommé "DA", qui est le critère de moindres carrés pondérés - augmentés. Les critères possibles sont dans la liste suivante, dans laquelle - les noms équivalents sont indiqués par un signe "=" : - ["AugmentedWeightedLeastSquares"="AWLS"="DA", "WeightedLeastSquares"="WLS", - "LeastSquares"="LS"="L2", "AbsoluteValue"="L1", "MaximumError"="ME"]. - - Exemple : ``{"QualityCriterion":"DA"}`` + Exemple : + ``{"SampleAsIndependantRandomVariables":[ ['normal',[0.,1.],3], ['uniform',[-2,2],4]]`` pour un espace d'état de dimension 2 - SetDebug - Cette clé requiert l'activation, ou pas, du mode de débogage durant - l'évaluation de la fonction. La valeur par défaut est "True", les choix sont - "True" ou "False". + .. include:: snippets/QualityCriterion.rst - Exemple : ``{"SetDebug":False}`` + .. include:: snippets/SetDebug.rst - SetSeed - Cette clé permet de donner un nombre entier pour fixer la graine du - générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est - par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation par défaut de l'ordinateur. - - Exemple : ``{"SetSeed":1000}`` + .. include:: snippets/SetSeed.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -189,7 +138,8 @@ Les options de l'algorithme sont les suivantes: "CostFunctionJo", "CurrentState", "InnovationAtCurrentState", "SimulatedObservationAtCurrentState"]. - Exemple : ``{"StoreSupplementaryCalculations":["CostFunctionJ", "SimulatedObservationAtCurrentState"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["CostFunctionJ", "SimulatedObservationAtCurrentState"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -204,43 +154,19 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. - - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` + .. include:: snippets/CostFunctionJ.rst - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. + .. include:: snippets/CostFunctionJb.rst - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` - - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. - - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + .. include:: snippets/CostFunctionJo.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - InnovationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état - courant. - - Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]`` + .. include:: snippets/CurrentState.rst - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état courant, c'est-à-dire dans l'espace des observations. + .. include:: snippets/InnovationAtCurrentState.rst - Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtCurrentState.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_TangentTest.rst b/doc/fr/ref_algorithm_TangentTest.rst index 21d4568..b26b541 100644 --- a/doc/fr/ref_algorithm_TangentTest.rst +++ b/doc/fr/ref_algorithm_TangentTest.rst @@ -56,34 +56,12 @@ On prend :math:`\mathbf{dx}_0=Normal(0,\mathbf{x})` et Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: CheckingPoint -.. index:: single: ObservationOperator -.. index:: single: AmplitudeOfInitialDirection -.. index:: single: EpsilonMinimumExponent -.. index:: single: InitialDirection -.. index:: single: SetSeed -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - CheckingPoint - *Commande obligatoire*. Elle définit le vecteur utilisé comme l'état autour - duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à - l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type - "*Vector*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, notée - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*". Différentes formes fonctionnelles peuvent être - utilisées, comme décrit dans la section - :ref:`section_ref_operator_requirements`. Si un contrôle :math:`U` est - inclus dans le modèle d'observation, l'opérateur doit être appliqué à une - paire :math:`(X,U)`. + .. include:: snippets/CheckingPoint.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_checking_keywords`. De plus, les @@ -94,41 +72,17 @@ commande. Les options de l'algorithme sont les suivantes: - AmplitudeOfInitialDirection - Cette clé indique la mise à l'échelle de la perturbation initiale construite - comme un vecteur utilisé pour la dérivée directionnelle autour du point - nominal de vérification. La valeur par défaut est de 1, ce qui signifie pas - de mise à l'échelle. - - Exemple : ``{"AmplitudeOfInitialDirection":0.5}`` - - EpsilonMinimumExponent - Cette clé indique la valeur de l'exposant minimal du coefficient en - puissance de 10 qui doit être utilisé pour faire décroître le multiplicateur - de l'incrément. La valeur par défaut est de -8, et elle doit être entre 0 et - -20. Par exemple, la valeur par défaut conduit à calculer le résidu de la - formule avec un incrément fixe multiplié par 1.e0 jusqu'à 1.e-8. - - Exemple : ``{"EpsilonMinimumExponent":-12}`` + .. include:: snippets/AmplitudeOfInitialDirection.rst - InitialDirection - Cette clé indique la direction vectorielle utilisée pour la dérivée - directionnelle autour du point nominal de vérification. Cela doit être un - vecteur. Si elle n'est pas spécifiée, la direction par défaut est une - perturbation par défaut autour de zéro de la même taille vectorielle que le - point de vérification. + .. include:: snippets/EpsilonMinimumExponent.rst - Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}`` + .. include:: snippets/InitialDirection.rst - SetSeed - Cette clé permet de donner un nombre entier pour fixer la graine du - générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est - par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation par défaut de l'ordinateur. - - Exemple : ``{"SetSeed":1000}`` + .. include:: snippets/SetSeed.rst StoreSupplementaryCalculations + .. index:: single: StoreSupplementaryCalculations + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -136,7 +90,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["CurrentState", "Residu", "SimulatedObservationAtCurrentState"]. - Exemple : ``{"StoreSupplementaryCalculations":["CurrentState"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["CurrentState"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -151,26 +106,13 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Residu - *Liste de valeurs*. Chaque élément est la valeur du résidu particulier - vérifié lors d'un algorithme de vérification, selon l'ordre des tests - effectués. - - Exemple : ``r = ADD.get("Residu")[:]`` + .. include:: snippets/Residu.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état courant, c'est-à-dire dans l'espace des observations. + .. include:: snippets/CurrentState.rst - Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtCurrentState.rst Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst index 91ffa4a..a9f14db 100644 --- a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst @@ -35,60 +35,37 @@ filtre de Kalman "unscented", permettant d'éviter de devoir calculer les opérateurs tangent ou adjoint pour les opérateurs d'observation ou d'évolution, comme dans les filtres de Kalman simple ou étendu. +Il s'applique aux cas d'opérateurs d'observation et d'évolution incrémentale +(processus) non-linéaires et présente d'excellentes qualités de robustesse et +de performances. Il peut être comparé à +l':ref:`section_ref_algorithm_EnsembleKalmanFilter`, dont les qualités sont +similaires pour les systèmes non-linéaires. + +Dans le cas d'opérateurs linéaires ou "faiblement" non-linéaire, on peut +aisément utiliser l':ref:`section_ref_algorithm_ExtendedKalmanFilter` ou même +l':ref:`section_ref_algorithm_KalmanFilter`, qui sont souvent largement moins +coûteux en évaluation sur de petits systèmes. On peut vérifier la linéarité des +opérateurs à l'aide de l':ref:`section_ref_algorithm_LinearityTest`. + Commandes requises et optionnelles ++++++++++++++++++++++++++++++++++ -.. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator -.. index:: single: Bounds -.. index:: single: ConstrainedBy -.. index:: single: EstimationOf -.. index:: single: Alpha -.. index:: single: Beta -.. index:: single: Kappa -.. index:: single: Reconditioner -.. index:: single: StoreSupplementaryCalculations - Les commandes requises générales, disponibles dans l'interface en édition, sont les suivantes: - Background - *Commande obligatoire*. Elle définit le vecteur d'ébauche ou - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*" ou de type "*VectorSerie*". - - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Background.rst + + .. include:: snippets/BackgroundError.rst + + .. include:: snippets/EvolutionError.rst + + .. include:: snippets/EvolutionModel.rst + + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Les commandes optionnelles générales, disponibles dans l'interface en édition, sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les @@ -99,30 +76,18 @@ commande. Les options de l'algorithme sont les suivantes: - Bounds - Cette clé permet de définir des bornes supérieure et inférieure pour chaque - variable d'état optimisée. Les bornes doivent être données par une liste de - liste de paires de bornes inférieure/supérieure pour chaque variable, avec - une valeur extrême chaque fois qu'il n'y a pas de borne (``None`` n'est pas - une valeur autorisée lorsqu'il n'y a pas de borne). - - Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,1.e99],[-1.e99,1.e99]]}`` - - ConstrainedBy - Cette clé permet d'indiquer la méthode de prise en compte des contraintes de - bornes. La seule disponible est "EstimateProjection", qui projette - l'estimation de l'état courant sur les contraintes de bornes. + .. include:: snippets/BoundsWithExtremes.rst - Exemple : ``{"ConstrainedBy":"EstimateProjection"}`` + .. include:: snippets/ConstrainedBy.rst - EstimationOf - Cette clé permet de choisir le type d'estimation à réaliser. Cela peut être - soit une estimation de l'état, avec la valeur "State", ou une estimation de - paramètres, avec la valeur "Parameters". Le choix par défaut est "State". - - Exemple : ``{"EstimationOf":"Parameters"}`` + .. include:: snippets/EstimationOf.rst Alpha, Beta, Kappa, Reconditioner + .. index:: single: Alpha + .. index:: single: Beta + .. index:: single: Kappa + .. index:: single: Reconditioner + Ces clés sont des paramètres de mise à l'échelle interne. "Alpha" requiert une valeur comprise entre 1.e-4 et 1. "Beta" a une valeur optimale de 2 pour une distribution *a priori* gaussienne. "Kappa" requiert une valeur entière, @@ -130,9 +95,12 @@ Les options de l'algorithme sont les suivantes: "Reconditioner" requiert une valeur comprise entre 1.e-3 et 10, son défaut étant 1. - Exemple : ``{"Alpha":1,"Beta":2,"Kappa":0,"Reconditioner":1}`` + Exemple : + ``{"Alpha":1,"Beta":2,"Kappa":0,"Reconditioner":1}`` StoreSupplementaryCalculations + + Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des calculs ou du stockage coûteux. La valeur par défaut est une liste vide, @@ -142,7 +110,8 @@ Les options de l'algorithme sont les suivantes: "APosterioriVariances", "BMA", "CostFunctionJ", "CostFunctionJb", "CostFunctionJo", "CurrentState", "Innovation"]. - Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` + Exemple : + ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}`` Informations et variables disponibles à la fin de l'algorithme ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -157,75 +126,29 @@ l':ref:`subsection_r_o_v_Inventaire`. Les sorties non conditionnelles de l'algorithme sont les suivantes: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` + .. include:: snippets/Analysis.rst Les sorties conditionnelles de l'algorithme sont les suivantes: - APosterioriCorrelations - *Liste de matrices*. Chaque élément est une matrice de corrélation des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]`` - - APosterioriCovariance - *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de - covariances des erreurs *a posteriori* de l'état optimal. - - Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` - - APosterioriStandardDeviations - *Liste de matrices*. Chaque élément est une matrice d'écart-types des - erreurs *a posteriori* de l'état optimal. - - Exemple : ``E = ADD.get("APosterioriStandardDeviations")[-1]`` - - APosterioriVariances - *Liste de matrices*. Chaque élément est une matrice de variances des erreurs - *a posteriori* de l'état optimal. - - Exemple : ``V = ADD.get("APosterioriVariances")[-1]`` - - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. + .. include:: snippets/APosterioriCorrelations.rst - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` + .. include:: snippets/APosterioriCovariance.rst - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. + .. include:: snippets/APosterioriStandardDeviations.rst - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` + .. include:: snippets/APosterioriVariances.rst - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. + .. include:: snippets/BMA.rst - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` + .. include:: snippets/CostFunctionJ.rst - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. + .. include:: snippets/CostFunctionJb.rst - Exemple : ``Xs = ADD.get("CurrentState")[:]`` + .. include:: snippets/CostFunctionJo.rst - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. + .. include:: snippets/CurrentState.rst - Exemple : ``d = ADD.get("Innovation")[-1]`` + .. include:: snippets/Innovation.rst Voir aussi ++++++++++ @@ -233,6 +156,7 @@ Voir aussi Références vers d'autres sections : - :ref:`section_ref_algorithm_KalmanFilter` - :ref:`section_ref_algorithm_ExtendedKalmanFilter` + - :ref:`section_ref_algorithm_EnsembleKalmanFilter` Références bibliographiques : - [WikipediaUKF]_ diff --git a/doc/fr/ref_assimilation_keywords.rst b/doc/fr/ref_assimilation_keywords.rst index 05fcd0c..3158136 100644 --- a/doc/fr/ref_assimilation_keywords.rst +++ b/doc/fr/ref_assimilation_keywords.rst @@ -29,16 +29,9 @@ Liste des commandes et mots-clés pour un cas d'assimilation de données ou d'op .. index:: single: Algorithm .. index:: single: AlgorithmParameters -.. index:: single: Background -.. index:: single: BackgroundError .. index:: single: ControlInput .. index:: single: Debug -.. index:: single: EvolutionError -.. index:: single: EvolutionModel .. index:: single: InputVariables -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator .. index:: single: Observer .. index:: single: Observers .. index:: single: Observer Template @@ -73,16 +66,9 @@ Les différentes commandes sont les suivantes: :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 - d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est - définie comme un objet de type "*Vector*". + .. include:: snippets/Background.rst - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". + .. include:: snippets/BackgroundError.rst ControlInput *Commande optionnelle*. Elle indique le vecteur de contrôle utilisé pour @@ -96,21 +82,9 @@ Les différentes commandes sont les suivantes: intermédiaires de débogage. Les choix sont limités entre 0 (pour False) et 1 (pour True). - EvolutionError - *Commande optionnelle*. Elle définit la matrice de covariance des erreurs - d'évolution, usuellement notée :math:`\mathbf{Q}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - EvolutionModel - *Commande optionnelle*. Elle indique l'opérateur d'évolution du modèle, - usuellement noté :math:`M`, qui décrit un pas élémentaire d'évolution. Sa - valeur est définie comme un objet de type "*Function*" ou de type - "*Matrix*". Dans le cas du type "*Function*", différentes formes - fonctionnelles peuvent être utilisées, comme décrit dans la section - :ref:`section_ref_operator_requirements`. Si un contrôle :math:`U` est - inclus dans le modèle d'évolution, l'opérateur doit être appliqué à une - paire :math:`(X,U)`. + .. include:: snippets/EvolutionError.rst + + .. include:: snippets/EvolutionModel.rst InputVariables *Commande optionnelle*. Elle permet d'indiquer le nom et la taille des @@ -118,28 +92,11 @@ Les différentes commandes sont les suivantes: information est destinée à être utilisée dans le traitement algorithmique interne des données. - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Observers *Commande optionnelle*. Elle permet de définir des observateurs internes, diff --git a/doc/fr/ref_checking_keywords.rst b/doc/fr/ref_checking_keywords.rst index 0c8d139..139d9f7 100644 --- a/doc/fr/ref_checking_keywords.rst +++ b/doc/fr/ref_checking_keywords.rst @@ -29,12 +29,7 @@ Liste des commandes et mots-clés pour un cas de vérification .. index:: single: Algorithm .. index:: single: AlgorithmParameters -.. index:: single: CheckingPoint -.. index:: single: BackgroundError .. index:: single: Debug -.. index:: single: Observation -.. index:: single: ObservationError -.. index:: single: ObservationOperator .. index:: single: Observer .. index:: single: Observers .. index:: single: Observer Template @@ -65,45 +60,20 @@ Les différentes commandes sont les suivantes: :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 - duquel réaliser le test requis, noté :math:`\mathbf{x}` et similaire à - l'ébauche :math:`\mathbf{x}^b`. Sa valeur est définie comme un objet de type - "*Vector*". + .. include:: snippets/CheckingPoint.rst - BackgroundError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". + .. include:: snippets/BackgroundError.rst Debug *Commande optionnelle*. Elle définit le niveau de sorties et d'informations intermédiaires de débogage. Les choix sont limités entre 0 (pour False) et 1 (pour True). - Observation - *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en - assimilation de données ou en optimisation, et noté précédemment - :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*" - ou de type "*VectorSerie*". - - ObservationError - *Commande obligatoire*. Elle définit la matrice de covariance des erreurs - d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie - comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de - type "*DiagonalSparseMatrix*". - - ObservationOperator - *Commande obligatoire*. Elle indique l'opérateur d'observation, noté - précédemment :math:`H`, qui transforme les paramètres d'entrée - :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux - observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de - type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*", - différentes formes fonctionnelles peuvent être utilisées, comme décrit dans - la section :ref:`section_ref_operator_requirements`. Si un contrôle - :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être - appliqué à une paire :math:`(X,U)`. + .. include:: snippets/Observation.rst + + .. include:: snippets/ObservationError.rst + + .. include:: snippets/ObservationOperator.rst Observers *Commande optionnelle*. Elle permet de définir des observateurs internes, diff --git a/doc/fr/ref_output_variables.rst b/doc/fr/ref_output_variables.rst index ae691b4..fe67eea 100644 --- a/doc/fr/ref_output_variables.rst +++ b/doc/fr/ref_output_variables.rst @@ -164,241 +164,85 @@ dans l'édition du cas ADAO. Inventaire des informations potentiellement disponibles en sortie +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -.. index:: single: Dry -.. index:: single: Forecast - -L'ensemble des informations potentiellement disponibles en sortie est indiqué -ici indépendamment des algorithmes, pour inventaire. +Les principales informations potentiellement disponibles en sortie sont +indiquées ici indépendamment des algorithmes, pour inventaire. On se reportera +directement aux détails des algorithmes pour avoir l'inventaire exhaustif. L'état optimal est une information qui est toujours naturellement disponible après un calcul d'assimilation de données ou d'optimisation. Il désigné par le mot-clé suivant: - Analysis - *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*` - en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de - données. - - Exemple : ``Xa = ADD.get("Analysis")[-1]`` - -Les variables suivantes sont des variables d'entrée. Elles sont mises à -disposition de l'utilisateur en sortie pour faciliter l'écriture des procédures -de post-processing, et sont conditionnées par une demande utilisateur à l'aide -d'un booléen "*Stored*" en entrée. - - Background - *Vecteur*, dont la disponibilité est conditionnée par "*Stored*" en entrée. - C'est le vecteur d'ébauche :math:`\mathbf{x}^b`. - - Exemple : ``Xb = ADD.get("Background")`` + .. include:: snippets/Analysis.rst - BackgroundError - *Matrice*, dont la disponibilité est conditionnée par "*Stored*" en entrée. - C'est la matrice :math:`\mathbf{B}` de covariances des erreurs *a priori* - de l'ébauche. +Les variables suivantes sont des variables d'entrée que l'on peut aussi obtenir +en sortie. Elles sont mises à disposition de l'utilisateur en sortie pour +faciliter l'écriture des procédures de post-processing, et sont conditionnées +par une demande utilisateur explicite à l'aide d'un booléen "*Stored*" en +entrée. Toutes ces variables d'entrée restituées sont obtenables par la +commande standard ".get(...)", qui s'applique à refournir l'unique objet donné +en entrée. - Exemple : ``B = ADD.get("BackgroundError")`` + .. include:: snippets/Background.rst - EvolutionError - *Matrice*, dont la disponibilité est conditionnée par "*Stored*" en entrée. - C'est la matrice :math:`\mathbf{M}` de covariances des erreurs *a priori* - de l'évolution. + .. include:: snippets/BackgroundError.rst - Exemple : ``M = ADD.get("EvolutionError")`` + .. include:: snippets/EvolutionError.rst - Observation - *Vecteur*, dont la disponibilité est conditionnée par "*Stored*" en entrée. - C'est le vecteur d'observation :math:`\mathbf{y}^o`. + .. include:: snippets/Observation.rst - Exemple : ``Yo = ADD.get("Observation")`` - - ObservationError - *Matrice*, dont la disponibilité est conditionnée par "*Stored*" en entrée. - C'est la matrice :math:`\mathbf{R}` de covariances des erreurs *a priori* - de l'observation. - - Exemple : ``R = ADD.get("ObservationError")`` + .. include:: snippets/ObservationError.rst Toutes les autres informations sont conditionnées par l'algorithme et/ou par la -demande utilisateur de disponibilité. Ce sont les suivantes, par ordre -alphabétique: - - APosterioriCorrelations - *Liste de matrices*. Chaque élément est une matrice de corrélations des - erreurs *a posteriori* de l'état optimal, issue de la matrice - :math:`\mathbf{A}*` des covariances. - - Exemple : ``C = ADD.get("APosterioriCorrelations")[-1]`` - - APosterioriCovariance - *Liste de matrices*. Chaque élément est une matrice :math:`\mathbf{A}*` de - covariances des erreurs *a posteriori* de l'état optimal. - - Exemple : ``A = ADD.get("APosterioriCovariance")[-1]`` - - APosterioriStandardDeviations - *Liste de matrices*. Chaque élément est une matrice diagonale d'écarts-types - des erreurs *a posteriori* de l'état optimal, issue de la matrice - :math:`\mathbf{A}*` des covariances. - - Exemple : ``S = ADD.get("APosterioriStandardDeviations")[-1]`` - - APosterioriVariances - *Liste de matrices*. Chaque élément est une matrice diagonale de variances - des erreurs *a posteriori* de l'état optimal, issue de la matrice - :math:`\mathbf{A}*` des covariances. - - Exemple : ``V = ADD.get("APosterioriVariances")[-1]`` - - BMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'ébauche et l'état optimal. - - Exemple : ``bma = ADD.get("BMA")[-1]`` - - CostFunctionJ - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. - - Exemple : ``J = ADD.get("CostFunctionJ")[:]`` - - CostFunctionJb - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. - - Exemple : ``Jb = ADD.get("CostFunctionJb")[:]`` - - CostFunctionJo - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. - - Exemple : ``Jo = ADD.get("CostFunctionJo")[:]`` - - CostFunctionJAtCurrentOptimum - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis - le début. - - Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]`` - - CostFunctionJbAtCurrentOptimum - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la - valeur correspond à l'état optimal trouvé depuis le début. - - Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]`` - - CostFunctionJoAtCurrentOptimum - *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart - :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas, - la valeur correspond à l'état optimal trouvé depuis le début. - - Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]`` - - CurrentOptimum - *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de - temps courant au cours du déroulement de l'algorithme d'optimisation. Ce - n'est pas nécessairement le dernier état. - - Exemple : ``Xo = ADD.get("CurrentOptimum")[:]`` - - CurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé - au cours du déroulement de l'algorithme d'optimisation. - - Exemple : ``Xs = ADD.get("CurrentState")[:]`` - - IndexOfOptimum - *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum - obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas - nécessairement le numéro de la dernière itération. - - Exemple : ``i = ADD.get("IndexOfOptimum")[-1]`` - - Innovation - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est - en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément - d'évolution. - - Exemple : ``d = ADD.get("Innovation")[-1]`` +demande utilisateur de disponibilité. Les principales sont les suivantes, par +ordre alphabétique: - InnovationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état - courant. + .. include:: snippets/APosterioriCorrelations.rst - Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]`` + .. include:: snippets/APosterioriCovariance.rst - MahalanobisConsistency - *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de - qualité de Mahalanobis. + .. include:: snippets/APosterioriStandardDeviations.rst - Exemple : ``m = ADD.get("MahalanobisConsistency")[-1]`` + .. include:: snippets/APosterioriVariances.rst - OMA - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état optimal dans l'espace des observations. + .. include:: snippets/BMA.rst - Exemple : ``oma = ADD.get("OMA")[-1]`` + .. include:: snippets/CostFunctionJ.rst - OMB - *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre - l'observation et l'état d'ébauche dans l'espace des observations. + .. include:: snippets/CostFunctionJb.rst - Exemple : ``omb = ADD.get("OMB")[-1]`` + .. include:: snippets/CostFunctionJo.rst - Residu - *Liste de valeurs*. Chaque élément est la valeur du résidu particulier - vérifié lors d'un algorithme de vérification, selon l'ordre des tests - effectués. + .. include:: snippets/CostFunctionJAtCurrentOptimum.rst - Exemple : ``r = ADD.get("Residu")[:]`` + .. include:: snippets/CostFunctionJbAtCurrentOptimum.rst - SigmaBck2 - *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de - qualité :math:`(\sigma^b)^2` de la partie ébauche. + .. include:: snippets/CostFunctionJoAtCurrentOptimum.rst - Exemple : ``sb2 = ADD.get("SigmaBck")[-1]`` + .. include:: snippets/CurrentOptimum.rst - SigmaObs2 - *Liste de valeurs*. Chaque élément est une valeur de l'indicateur de - qualité :math:`(\sigma^o)^2` de la partie observation. + .. include:: snippets/CurrentState.rst - Exemple : ``so2 = ADD.get("SigmaObs")[-1]`` + .. include:: snippets/IndexOfOptimum.rst - SimulatedObservationAtBackground - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'ébauche :math:`\mathbf{x}^b`. C'est la prévision à partir de - l'ébauche, et elle est parfois appellée "*Dry*". + .. include:: snippets/Innovation.rst - Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]`` + .. include:: snippets/InnovationAtCurrentState.rst - SimulatedObservationAtCurrentOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état optimal au pas de temps courant au cours du déroulement de - l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations. + .. include:: snippets/OMA.rst - Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]`` + .. include:: snippets/OMB.rst - SimulatedObservationAtCurrentState - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'état courant, c'est-à-dire dans l'espace des observations. + .. include:: snippets/Residu.rst - Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]`` + .. include:: snippets/SimulatedObservationAtBackground.rst - SimulatedObservationAtOptimum - *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à - partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`. C'est la - prévision à partir de l'analyse ou de l'état optimal, et elle est parfois - appellée "*Forecast*". + .. include:: snippets/SimulatedObservationAtCurrentOptimum.rst - Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]`` + .. include:: snippets/SimulatedObservationAtCurrentState.rst - SimulationQuantiles - *Liste de vecteurs*. Chaque élément est un vecteur correspondant à l'état - observé qui réalise le quantile demandé, dans le même ordre que les - quantiles requis par l'utilisateur. + .. include:: snippets/SimulatedObservationAtOptimum.rst - Exemple : ``sQuantiles = ADD.get("SimulationQuantiles")[:]`` + .. include:: snippets/SimulationQuantiles.rst .. [#] Pour de plus amples informations sur PARAVIS, voir le *module PARAVIS* et son aide intégrée disponible dans le menu principal *Aide* de l'environnement SALOME. -- 2.39.2