1 #-*-coding:iso-8859-1-*-
3 # Copyright (C) 2008-2009 EDF R&D
5 # This library is free software; you can redistribute it and/or
6 # modify it under the terms of the GNU Lesser General Public
7 # License as published by the Free Software Foundation; either
8 # version 2.1 of the License.
10 # This library is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 # Lesser General Public License for more details.
15 # You should have received a copy of the GNU Lesser General Public
16 # License along with this library; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 Définit les outils généraux élémentaires.
24 Ce module est destiné à etre appelée par AssimilationStudy pour constituer
25 les objets élémentaires de l'algorithme.
27 __author__ = "Jean-Philippe ARGAUD - Mars 2008"
32 # ==============================================================================
35 Classe générale d'interface de type opérateur
37 def __init__(self, fromMethod=None, fromMatrix=None):
39 On construit un objet de ce type en fournissant à l'aide de l'un des
40 deux mots-clé, soit une fonction python, soit matrice.
42 - fromMethod : argument de type fonction Python
43 - fromMatrix : argument adapté au constructeur numpy.matrix
45 if fromMethod is not None:
46 self.__Method = fromMethod
48 elif fromMatrix is not None:
50 self.__Matrix = numpy.matrix( fromMatrix, numpy.float )
55 def appliedTo(self, xValue):
57 Permet de restituer le résultat de l'application de l'opérateur à un
58 argument xValue. Cette méthode se contente d'appliquer, son argument
59 devant a priori être du bon type.
61 - xValue : argument adapté pour appliquer l'opérateur
63 if self.__Matrix is not None:
64 return self.__Matrix * xValue
66 return self.__Method( xValue )
68 def appliedInXTo(self, (xNominal, xValue) ):
70 Permet de restituer le résultat de l'application de l'opérateur à un
71 argument xValue, sachant que l'opérateur est valable en xNominal.
72 Cette méthode se contente d'appliquer, son argument devant a priori
73 être du bon type. Si l'opérateur est linéaire car c'est une matrice,
74 alors il est valable en tout point nominal et il n'est pas nécessaire
76 Arguments : une liste contenant
77 - xNominal : argument permettant de donner le point où l'opérateur
78 est construit pour etre ensuite appliqué
79 - xValue : argument adapté pour appliquer l'opérateur
81 if self.__Matrix is not None:
82 return self.__Matrix * xValue
84 return self.__Method( (xNominal, xValue) )
88 Permet de renvoyer l'opérateur sous la forme d'une matrice
90 if self.__Matrix is not None:
93 raise ValueError("Matrix form of the operator is not available")
97 Renvoie la taille sous forme numpy si l'opérateur est disponible sous
98 la forme d'une matrice
100 if self.__Matrix is not None:
101 return self.__Matrix.shape
103 raise ValueError("Matrix form of the operator is not available, nor the shape")
105 # ==============================================================================
108 Classe générale d'interface de type algorithme
110 Elle donne un cadre pour l'écriture d'une classe élémentaire d'algorithme
111 d'assimilation, en fournissant un container (dictionnaire) de variables
112 persistantes initialisées, et des méthodes d'accès à ces variables stockées.
114 Une classe élémentaire d'algorithme doit implémenter la méthode "run".
118 L'initialisation présente permet de fabriquer des variables de stockage
119 disponibles de manière générique dans les algorithmes élémentaires. Ces
120 variables de stockage sont ensuite conservées dans un dictionnaire
121 interne à l'objet, mais auquel on accède par la méthode "get".
123 Les variables prévues sont :
124 - Analysis : l'analyse
125 - Innovation : l'innovation : d = Y - H Xb
126 - SigmaObs2 : correction optimale des erreurs d'observation
127 - SigmaBck2 : correction optimale des erreurs d'ébauche
128 - OMA : Observation moins Analysis : Y - Xa
129 - OMB : Observation moins Background : Y - Xb
130 - AMB : Analysis moins Background : Xa - Xb
131 - CovarianceAPosteriori : matrice A
132 On peut rajouter des variables à stocker dans l'initialisation de
133 l'algorithme élémentaire qui va hériter de cette classe
135 self.StoredVariables = {}
136 self.StoredVariables["CostFunctionJ"] = Persistence.OneScalar(name = "CostFunctionJ")
137 self.StoredVariables["CostFunctionJb"] = Persistence.OneScalar(name = "CostFunctionJb")
138 self.StoredVariables["CostFunctionJo"] = Persistence.OneScalar(name = "CostFunctionJo")
139 self.StoredVariables["GradientOfCostFunctionJ"] = Persistence.OneScalar(name = "GradientOfCostFunctionJ")
140 self.StoredVariables["GradientOfCostFunctionJb"] = Persistence.OneScalar(name = "GradientOfCostFunctionJb")
141 self.StoredVariables["GradientOfCostFunctionJo"] = Persistence.OneScalar(name = "GradientOfCostFunctionJo")
142 self.StoredVariables["Analysis"] = Persistence.OneVector(name = "Analysis")
143 self.StoredVariables["Innovation"] = Persistence.OneVector(name = "Innovation")
144 self.StoredVariables["SigmaObs2"] = Persistence.OneScalar(name = "SigmaObs2")
145 self.StoredVariables["SigmaBck2"] = Persistence.OneScalar(name = "SigmaBck2")
146 self.StoredVariables["OMA"] = Persistence.OneVector(name = "OMA")
147 self.StoredVariables["OMB"] = Persistence.OneVector(name = "OMB")
148 self.StoredVariables["BMA"] = Persistence.OneVector(name = "BMA")
149 self.StoredVariables["CovarianceAPosteriori"] = Persistence.OneMatrix(name = "CovarianceAPosteriori")
152 def get(self, key=None):
154 Renvoie l'une des variables stockées identifiée par la clé, ou le
155 dictionnaire de l'ensemble des variables disponibles en l'absence de
156 clé. Ce sont directement les variables sous forme objet qui sont
157 renvoyées, donc les méthodes d'accès à l'objet individuel sont celles
158 des classes de persistance.
161 return self.StoredVariables[key]
163 return self.StoredVariables
165 def has_key(self, key=None):
167 Vérifie si l'une des variables stockées est identifiée par la clé.
169 return self.StoredVariables.has_key(key)
171 def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Par=None):
173 Doit implémenter l'opération élémentaire de calcul d'assimilation sous
174 sa forme mathématique la plus naturelle possible.
176 raise NotImplementedError("Mathematical assimilation calculation has not been implemented!")
178 # ==============================================================================
181 Classe générale d'interface de type diagnostic
183 Ce template s'utilise de la manière suivante : il sert de classe "patron" en
184 même temps que l'une des classes de persistance, comme "OneScalar" par
187 Une classe élémentaire de diagnostic doit implémenter ses deux méthodes, la
188 méthode "_formula" pour écrire explicitement et proprement la formule pour
189 l'écriture mathématique du calcul du diagnostic (méthode interne non
190 publique), et "calculate" pour activer la précédente tout en ayant vérifié
191 et préparé les données, et pour stocker les résultats à chaque pas (méthode
192 externe d'activation).
194 def __init__(self, name = "", parameters = {}):
195 self.name = str(name)
196 self.parameters = dict( parameters )
198 def _formula(self, *args):
200 Doit implémenter l'opération élémentaire de diagnostic sous sa forme
201 mathématique la plus naturelle possible.
203 raise NotImplementedError("Diagnostic mathematical formula has not been implemented!")
205 def calculate(self, *args):
207 Active la formule de calcul avec les arguments correctement rangés
209 raise NotImplementedError("Diagnostic activation method has not been implemented!")
211 # ==============================================================================
212 if __name__ == "__main__":
213 print '\n AUTODIAGNOSTIC \n'