From: Jean-Philippe ARGAUD Date: Mon, 28 Jul 2014 21:52:24 +0000 (+0200) Subject: Adding sampling test algorithm X-Git-Tag: V7_5_0rc1~12 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=9dfa2ecd52337f722a01d89c88f8b14dd9527d2d;p=modules%2Fadao.git Adding sampling test algorithm --- diff --git a/bin/AdaoCatalogGenerator.py b/bin/AdaoCatalogGenerator.py index 09c0094..b7ff1ce 100644 --- a/bin/AdaoCatalogGenerator.py +++ b/bin/AdaoCatalogGenerator.py @@ -211,7 +211,9 @@ CHECKING_STUDY = PROC(nom="CHECKING_STUDY", 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"), diff --git a/doc/en/ref_algorithm_SamplingTest.rst b/doc/en/ref_algorithm_SamplingTest.rst new file mode 100644 index 0000000..4a0114f --- /dev/null +++ b/doc/en/ref_algorithm_SamplingTest.rst @@ -0,0 +1,132 @@ +.. + 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` diff --git a/doc/en/ref_checking_keywords.rst b/doc/en/ref_checking_keywords.rst index 29e7437..fa53367 100644 --- a/doc/en/ref_checking_keywords.rst +++ b/doc/en/ref_checking_keywords.rst @@ -30,7 +30,10 @@ List of commands and keywords for an ADAO checking case .. 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 @@ -68,11 +71,28 @@ The different commands are the following: 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 diff --git a/doc/en/reference.rst b/doc/en/reference.rst index 124d4a1..c9285a0 100644 --- a/doc/en/reference.rst +++ b/doc/en/reference.rst @@ -113,3 +113,4 @@ The mathematical notations used afterward are explained in the section ref_algorithm_LinearityTest ref_algorithm_ObserverTest ref_algorithm_TangentTest + ref_algorithm_SamplingTest diff --git a/doc/fr/ref_algorithm_SamplingTest.rst b/doc/fr/ref_algorithm_SamplingTest.rst new file mode 100644 index 0000000..6485a2b --- /dev/null +++ b/doc/fr/ref_algorithm_SamplingTest.rst @@ -0,0 +1,137 @@ +.. + 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` diff --git a/doc/fr/ref_checking_keywords.rst b/doc/fr/ref_checking_keywords.rst index 06fda97..faa3444 100644 --- a/doc/fr/ref_checking_keywords.rst +++ b/doc/fr/ref_checking_keywords.rst @@ -30,7 +30,10 @@ Liste des commandes et mots-cl .. 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 @@ -70,11 +73,29 @@ Les diff 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 diff --git a/doc/fr/reference.rst b/doc/fr/reference.rst index db138c8..8818eb3 100644 --- a/doc/fr/reference.rst +++ b/doc/fr/reference.rst @@ -116,3 +116,4 @@ ADAO. Les notations math ref_algorithm_LinearityTest ref_algorithm_ObserverTest ref_algorithm_TangentTest + ref_algorithm_SamplingTest diff --git a/src/daComposant/daAlgorithms/SamplingTest.py b/src/daComposant/daAlgorithms/SamplingTest.py new file mode 100644 index 0000000..b14133d --- /dev/null +++ b/src/daComposant/daAlgorithms/SamplingTest.py @@ -0,0 +1,144 @@ +#-*-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' diff --git a/src/daSalome/daYacsSchemaCreator/infos_daComposant.py b/src/daSalome/daYacsSchemaCreator/infos_daComposant.py index 53f33f5..1840081 100644 --- a/src/daSalome/daYacsSchemaCreator/infos_daComposant.py +++ b/src/daSalome/daYacsSchemaCreator/infos_daComposant.py @@ -77,6 +77,7 @@ CheckAlgos = [ "AdjointTest", "ObserverTest", "TangentTest", + "SamplingTest", ] AlgoDataRequirements = {} @@ -157,6 +158,11 @@ AlgoDataRequirements["TangentTest"] = [ "CheckingPoint", "ObservationOperator", ] +AlgoDataRequirements["SamplingTest"] = [ + "CheckingPoint", "BackgroundError", + "Observation", "ObservationError", + "ObservationOperator", + ] AlgoType = {} AlgoType["3DVAR"] = "Optim" @@ -236,6 +242,7 @@ ObserversList = [ "Analysis", "CurrentState", "Innovation", + "ObservedState", "OMA", "OMB", "BMA",