Debug = SIMP(statut="f", typ = "I", into=(0, 1), defaut=0),
Algorithm = SIMP(statut="o", typ = "TXM", into=(${check_names})),
CheckingPoint = F_CheckingPoint("o"),
+ BackgroundError = F_BackgroundError("f"),
Observation = F_Observation("f"),
+ ObservationError = F_ObservationError("f"),
ObservationOperator = F_ObservationOperator("o"),
AlgorithmParameters = F_AlgorithmParameters("f"),
UserDataInit = F_Init("f"),
--- /dev/null
+..
+ Copyright (C) 2008-2014 EDF R&D
+
+ This file is part of SALOME ADAO module.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+ Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
+
+.. index:: single: SamplingTest
+.. _section_ref_algorithm_SamplingTest:
+
+Checking algorithm "SamplingTest"
+---------------------------------
+
+Description
++++++++++++
+
+This algorithm allows to calculate the values, linked to a :math:`\mathbf{x}`
+state, of the data assimilation error function :math:`J` and of the observation
+operator, for an priori given states sample. This is a useful algorithm to test
+the sensitivity, of the error function :math:`J` in particular, to the state
+:math:`\mathbf{x}` variations. When a state is not observable, a *"NaN"* value
+is returned.
+
+The sampling of the states :math:`\mathbf{x}` can be given explicitly or under
+the form of hypercubes.
+
+Optional and required commands
+++++++++++++++++++++++++++++++
+
+.. 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: SetDebug
+.. index:: single: StoreSupplementaryCalculations
+
+The general required commands, available in the editing user interface, are the
+following:
+
+ CheckingPoint
+ *Required command*. This indicates the vector used as the state around which
+ to perform the required check, noted :math:`\mathbf{x}` and similar to the
+ background :math:`\mathbf{x}^b`. It is defined as a "*Vector*" type object.
+
+ BackgroundError
+ *Required command*. This indicates the background error covariance matrix,
+ previously noted as :math:`\mathbf{B}`. Its value is defined as a "*Matrix*"
+ type object, a "*ScalarSparseMatrix*" type object, or a
+ "*DiagonalSparseMatrix*" type object.
+
+ Observation
+ *Required command*. This indicates the observation vector used for data
+ assimilation or optimization, previously noted as :math:`\mathbf{y}^o`. It
+ is defined as a "*Vector*" or a *VectorSerie* type object.
+
+ ObservationError
+ *Required command*. This indicates the observation error covariance matrix,
+ previously noted as :math:`\mathbf{R}`. It is defined as a "*Matrix*" type
+ object, a "*ScalarSparseMatrix*" type object, or a "*DiagonalSparseMatrix*"
+ type object.
+
+ ObservationOperator
+ *Required command*. This indicates the observation operator, previously
+ noted :math:`H`, which transforms the input parameters :math:`\mathbf{x}` to
+ results :math:`\mathbf{y}` to be compared to observations
+ :math:`\mathbf{y}^o`. Its value is defined as a "*Function*" type object or
+ a "*Matrix*" type one. In the case of "*Function*" type, different
+ functional forms can be used, as described in the section
+ :ref:`section_ref_operator_requirements`. If there is some control :math:`U`
+ included in the observation, the operator has to be applied to a pair
+ :math:`(X,U)`.
+
+The general optional commands, available in the editing user interface, are
+indicated in :ref:`section_ref_assimilation_keywords`. In particular, the
+optional command "*AlgorithmParameters*" allows to choose the specific options,
+described hereafter, of the algorithm. See
+:ref:`section_ref_options_AlgorithmParameters` for the good use of this command.
+
+The options of the algorithm are the following:
+
+ SampleAsnUplet
+ This key describes the calculations points as a list of n-uplets, each
+ n-uplet being a state.
+
+ SampleAsExplicitHyperCube
+ This key describes the calculations points as an hypercube, from which one
+ gives the list of sampling of each variable as a list. That is then a list
+ of lists, each of them being potentially of different size.
+
+ SampleAsMinMaxStepHyperCube
+ This key describes the calculations points as an hypercube from which one
+ the sampling of each variable by a triplet *[min,max,step]*. That is then a
+ list of the same size then the one of the state.
+
+ SetDebug
+ This key requires the activation, or not, of the debug mode during the
+ function evaluation. The default is "True", the choices are "True" or
+ "False".
+
+ StoreSupplementaryCalculations
+ This list indicates the names of the supplementary variables that can be
+ available at the end of the algorithm. It involves potentially costly
+ calculations or memory consumptions. The default is a void list, none of
+ these variables being calculated and stored by default. The possible names
+ are in the following list: ["CostFunctionJ", "CurrentState", "Innovation",
+ "ObservedState"].
+
+See also
+++++++++
+
+References to other sections:
+ - :ref:`section_ref_algorithm_FunctionTest`
.. 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
to perform the required check, noted :math:`\mathbf{x}` and similar to the
background :math:`\mathbf{x}^b`. It is defined as a "*Vector*" type object.
+ BackgroundError
+ *Required command*. This indicates the background error covariance matrix,
+ previously noted as :math:`\mathbf{B}`. Its value is defined as a "*Matrix*"
+ type object, a "*ScalarSparseMatrix*" type object, or a
+ "*DiagonalSparseMatrix*" type object.
+
Debug
*Optional command*. This define the level of trace and intermediary debug
information. The choices are limited between 0 (for False) and 1 (for
True).
+ Observation
+ *Required command*. This indicates the observation vector used for data
+ assimilation or optimization, previously noted as :math:`\mathbf{y}^o`. It
+ is defined as a "*Vector*" or a *VectorSerie* type object.
+
+ ObservationError
+ *Required command*. This indicates the observation error covariance matrix,
+ previously noted as :math:`\mathbf{R}`. It is defined as a "*Matrix*" type
+ object, a "*ScalarSparseMatrix*" type object, or a "*DiagonalSparseMatrix*"
+ type object.
+
ObservationOperator
*Required command*. This indicates the observation operator, previously
noted :math:`H`, which transforms the input parameters :math:`\mathbf{x}` to
ref_algorithm_LinearityTest
ref_algorithm_ObserverTest
ref_algorithm_TangentTest
+ ref_algorithm_SamplingTest
--- /dev/null
+..
+ Copyright (C) 2008-2014 EDF R&D
+
+ This file is part of SALOME ADAO module.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+ Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
+
+.. index:: single: SamplingTest
+.. _section_ref_algorithm_SamplingTest:
+
+Algorithme de vérification "*SamplingTest*"
+-------------------------------------------
+
+Description
++++++++++++
+
+Cet algorithme permet d'établir les valeurs, liées à un état :math:`\mathbf{x}`,
+de la fonctionnelle d'erreur d'assimilation de données :math:`J` et de
+l'opérateur d'observation, pour un échantillon d'états donné a priori. C'est un
+algorithme utile pour tester la sensibilité, de la fonctionnelle :math:`J` en
+particulier, aux variations de l'état :math:`\mathbf{x}`. Lorsque un état n'est
+pas observable, une value *"NaN"* est retournée.
+
+L'échantillon des états :math:`\mathbf{x}` peut être fourni explicitement ou
+sous la forme d'hypercubes.
+
+Commandes requises et optionnelles
+++++++++++++++++++++++++++++++++++
+
+.. 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: 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*".
+
+ 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)`.
+
+Les commandes optionnelles générales, disponibles dans l'interface en édition,
+sont indiquées dans la :ref:`section_ref_checking_keywords`. En particulier, la
+commande optionnelle "*AlgorithmParameters*" permet d'indiquer les options
+particulières, décrites ci-après, de l'algorithme. On se reportera à la
+:ref:`section_ref_options_AlgorithmParameters` pour le bon usage de cette
+commande.
+
+Les options de l'algorithme sont les suivantes:
+
+ SampleAsnUplet
+ Cette clé décrit les points de calcul sous la forme d'une liste de n-uplets,
+ chaque n-uplet étant un état.
+
+ SampleAsExplicitHyperCube
+ Cette clé décrit les points de calcul sous la forme d'un hyper-cube, dont on
+ donne la liste des échantillonages de chaque variable comme une liste. C'est
+ donc une liste de listes, chacune étant de taille potentiellement
+ différente.
+
+ SampleAsMinMaxStepHyperCube
+ Cette clé décrit les points de calcul sous la forme d'un hyper-cube dont on
+ donne la liste des échantillonages de chaque variable par un triplet
+ *[min,max,step]*. C'est donc une liste de la même taille que celle de
+ l'état.
+
+ 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".
+
+ 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,
+ aucune de ces variables n'étant calculée et stockée par défaut. Les noms
+ possibles sont dans la liste suivante : ["CostFunctionJ", "CurrentState",
+ "Innovation", "ObservedState"].
+
+Voir aussi
+++++++++++
+
+Références vers d'autres sections :
+ - :ref:`section_ref_algorithm_FunctionTest`
.. 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
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*".
+
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
ref_algorithm_LinearityTest
ref_algorithm_ObserverTest
ref_algorithm_TangentTest
+ ref_algorithm_SamplingTest
--- /dev/null
+#-*-coding:iso-8859-1-*-
+#
+# Copyright (C) 2008-2014 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
+
+import logging
+from daCore import BasicObjects
+import numpy, copy, itertools
+
+# ==============================================================================
+class ElementaryAlgorithm(BasicObjects.Algorithm):
+ def __init__(self):
+ BasicObjects.Algorithm.__init__(self, "SAMPLINGTEST")
+ self.defineRequiredParameter(
+ name = "SampleAsnUplet",
+ default = [],
+ typecast = list,
+ message = "Points de calcul définis par une liste de n-uplet",
+ )
+ self.defineRequiredParameter(
+ name = "SampleAsExplicitHyperCube",
+ default = [],
+ typecast = list,
+ message = "Points de calcul définis par un hyper-cube dont on donne la liste des échantillonages de chaque variable comme une liste",
+ )
+ self.defineRequiredParameter(
+ name = "SampleAsMinMaxStepHyperCube",
+ default = [],
+ typecast = list,
+ message = "Points de calcul définis par un hyper-cube dont on donne la liste des échantillonages de chaque variable par un triplet [min,max,step]",
+ )
+ self.defineRequiredParameter(
+ name = "SetDebug",
+ default = False,
+ typecast = bool,
+ message = "Activation du mode debug lors de l'exécution",
+ )
+ self.defineRequiredParameter(
+ name = "StoreSupplementaryCalculations",
+ default = [],
+ typecast = tuple,
+ message = "Liste de calculs supplémentaires à stocker et/ou effectuer",
+ listval = ["CostFunctionJ","CurrentState","Innovation","ObservedState"]
+ )
+
+ def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
+ self._pre_run()
+ #
+ self.setParameters(Parameters)
+ #
+ Hm = HO["Direct"].appliedTo
+ #
+ Xn = copy.copy( Xb )
+ #
+ # ---------------------------
+ if len(self._parameters["SampleAsnUplet"]) > 0:
+ sampleList = self._parameters["SampleAsnUplet"]
+ for i,Xx in enumerate(sampleList):
+ if numpy.ravel(Xx).size != Xn.size:
+ raise ValueError("The size %i of the %ith state X in the sample and %i of the checking point Xb are different, they have to be identical."%(numpy.ravel(Xx).size,i+1,Xn.size))
+ elif len(self._parameters["SampleAsExplicitHyperCube"]) > 0:
+ sampleList = itertools.product(*list(self._parameters["SampleAsExplicitHyperCube"]))
+ elif len(self._parameters["SampleAsMinMaxStepHyperCube"]) > 0:
+ coordinatesList = []
+ for i,dim in enumerate(self._parameters["SampleAsMinMaxStepHyperCube"]):
+ if len(dim) != 3:
+ raise ValueError("For dimension %i, the variable definition %s is incorrect, it should be [min,max,step]."%(i,dim))
+ else:
+ coordinatesList.append(numpy.linspace(*dim))
+ sampleList = itertools.product(*coordinatesList)
+ else:
+ sampleList = iter([Xn,])
+ # ----------
+ BI = B.getI()
+ RI = R.getI()
+ def CostFunction(x,HmX):
+ if numpy.any(numpy.isnan(HmX)):
+ _X = numpy.nan
+ _HX = numpy.nan
+ Jb, Jo, J = numpy.nan, numpy.nan, numpy.nan
+ else:
+ _X = numpy.asmatrix(numpy.ravel( x )).T
+ _HX = numpy.asmatrix(numpy.ravel( HmX )).T
+ Jb = 0.5 * (_X - Xb).T * BI * (_X - Xb)
+ Jo = 0.5 * (Y - _HX).T * RI * (Y - _HX)
+ J = float( Jb ) + float( Jo )
+ if "CurrentState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["CurrentState"].store( _X )
+ if "Innovation" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["Innovation"].store( Y - _HX )
+ if "ObservedState" in self._parameters["StoreSupplementaryCalculations"]:
+ self.StoredVariables["ObservedState"].store( _HX )
+ self.StoredVariables["CostFunctionJb"].store( Jb )
+ self.StoredVariables["CostFunctionJo"].store( Jo )
+ self.StoredVariables["CostFunctionJ" ].store( J )
+ return J, Jb, Jo
+ # ----------
+ if self._parameters["SetDebug"]:
+ CUR_LEVEL = logging.getLogger().getEffectiveLevel()
+ logging.getLogger().setLevel(logging.DEBUG)
+ print("===> Beginning of evaluation, activating debug\n")
+ print(" %s\n"%("-"*75,))
+ #
+ # ----------
+ for i,Xx in enumerate(sampleList):
+ if self._parameters["SetDebug"]:
+ print("===> Launching evaluation for state %i"%i)
+ __Xn = numpy.asmatrix(numpy.ravel( Xx )).T
+ try:
+ Yn = Hm( __Xn )
+ except:
+ Yn = numpy.nan
+ #
+ J, Jb, Jo = CostFunction(__Xn,Yn)
+ # ----------
+ #
+ if self._parameters["SetDebug"]:
+ print("\n %s\n"%("-"*75,))
+ print("===> End evaluation, deactivating debug if necessary\n")
+ logging.getLogger().setLevel(CUR_LEVEL)
+ #
+ self._post_run(HO)
+ return 0
+
+# ==============================================================================
+if __name__ == "__main__":
+ print '\n AUTODIAGNOSTIC \n'
"AdjointTest",
"ObserverTest",
"TangentTest",
+ "SamplingTest",
]
AlgoDataRequirements = {}
"CheckingPoint",
"ObservationOperator",
]
+AlgoDataRequirements["SamplingTest"] = [
+ "CheckingPoint", "BackgroundError",
+ "Observation", "ObservationError",
+ "ObservationOperator",
+ ]
AlgoType = {}
AlgoType["3DVAR"] = "Optim"
"Analysis",
"CurrentState",
"Innovation",
+ "ObservedState",
"OMA",
"OMB",
"BMA",
