From: Jean-Philippe ARGAUD Date: Mon, 6 Apr 2015 12:36:48 +0000 (+0200) Subject: Adding documentation for TUI (examples) and script entries X-Git-Tag: V7_6_0~24 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=0d0f38bcd4e4c565ba0e28e085360bfe060cfd2d;p=modules%2Fadao.git Adding documentation for TUI (examples) and script entries --- diff --git a/doc/fr/tui.rst b/doc/fr/tui.rst index dbd2776..688069b 100644 --- a/doc/fr/tui.rst +++ b/doc/fr/tui.rst @@ -128,18 +128,19 @@ suivante pour un op Dans le cas beaucoup plus courant d'un opérateur non-linéaire, il doit être préalablement disponible sous la forme d'une fonction Python connue dans -l'espace de nommage courant. L'exemple suivant montre une fonction (qui réalise -ici le même opérateur linéaire que ci-dessus) et l'enregistre dans le cas ADAO:: +l'espace de nommage courant. L'exemple suivant montre une fonction +``simulation`` (qui réalise ici le même opérateur linéaire que ci-dessus) et +l'enregistre dans le cas ADAO:: - def fonction(x): + def simulation(x): import numpy __x = numpy.matrix(numpy.ravel(numpy.matrix(x))).T __H = numpy.matrix("1 0 0;0 2 0;0 0 3") return __H * __x # case.set( 'ObservationOperator', - DirectFunction = fonction, - Parameters = {"useApproximatedDerivatives":True}, + OneFunction = simulation, + Parameters = {"DifferentialIncrement":0.01}, ) Pour connaître les résultats intermédiaire ou finaux du calcul du cas, on peut @@ -289,112 +290,138 @@ Les commandes disponibles sont les suivantes : .. index:: single: setBackground -**setBackground** (*Vector , VectorSerie , Stored*) +**setBackground** (*Vector, VectorSerie, Script, Stored*) Cette commande permet de définir l'ébauche :math:`\mathbf{x}^b`. Selon les - algorithmes, on peut définir un vecteur simple par "*Vector*", ou une liste - de vecteurs par "*VectorSerie*". + algorithmes, on peut le définir comme un vecteur simple par "*Vector*", ou + comme une liste de vecteurs par "*VectorSerie*". Si on le définit par un + script dans "*Script*", le vecteur est de type "*Vector*" (par défaut) ou + "*VectorSerie*" selon que l'une de ces variables est placée à "*True*". .. index:: single: setBackgroundError -**setBackgroundError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Stored*) +**setBackgroundError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Script, Stored*) Cette commande permet de définir la matrice :math:`\mathbf{B}` des covariance des erreurs d'ébauche. La matrice peut être définie de manière complète par "*Matrix*", ou de manière parcimonieuse comme une matrice diagonale dont on donne la variance unique sur la diagonale par "*ScalarSparseMatrix*", ou comme une matrice diagonale dont on donne le vecteur des variances situé sur la diagonale par "*DiagonalSparseMatrix*". + Si on la définit par un script dans "*Script*", la matrice est de type + "*Matrix*" (par défaut), "*ScalarSparseMatrix*" ou "*DiagonalSparseMatrix*" + selon que l'une de ces variables est placée à "*True*". .. index:: single: setCheckingPoint -**setCheckingPoint** (*Vector, VectorSerie, Stored*) +**setCheckingPoint** (*Vector, VectorSerie, Script, Stored*) Cette commande permet de définir un point courant :math:`\mathbf{x}` utilisé - pour un algorithme de vérification. Selon les algorithmes, on peut définir - un vecteur simple par "Vector", ou une liste de vecteurs par "VectorSerie". + pour un algorithme de vérification. Selon les algorithmes, on peut le + définir comme un vecteur simple par "*Vector*", ou comme une liste de + vecteurs par "*VectorSerie*". Si on le définit par un script dans + "*Script*", le vecteur est de type "*Vector*" (par défaut) ou + "*VectorSerie*" selon que l'une de ces variables est placée à "*True*". .. index:: single: setControlModel -**setControlModel** (*Matrix, DirectFunction, ThreeFunctions, Parameters, Stored*) +**setControlModel** (*Matrix, OneFunction, ThreeFunctions, Parameters, Script, Stored*) Cette commande permet de définir l'opérateur de contrôle :math:`O`, qui décrit un contrôle d'entrée linéaire externe de l'opérateur d'évolution ou d'observation. On se reportera :ref:`section_ref_operator_control`. Sa valeur est définie comme un objet de type fonction ou de type "*Matrix*". Dans le cas d'une fonction, différentes formes fonctionnelles peuvent être utilisées, comme décrit dans la section - :ref:`section_ref_operator_requirements`, et entrées par "*DirectFunction*" - ou "*ThreeFunctions*". Les paramètres de contrôle de l'approximation - numérique de l'opérateur adjoint, dans le cas "*DirectFunction*", peuvent - être renseignés par un dictionnaire dans "*Parameters*". Les entrées - potentielles de ce dictionnaire de paramètres sont - "*DifferentialIncrement*", "*CenteredFiniteDifference*", - "*EnableMultiProcessing*", "*NumberOfProcesses*" (similaires à celles de - l'interface graphique). + :ref:`section_ref_operator_requirements`, et entrées par "*OneFunction*" ou + "*ThreeFunctions*". Dans le cas d'une définition par "*Script*", l'opérateur + est de type "*Matrix*", "*OneFunction*" ou "*ThreeFunctions*" selon que + l'une de ces variables est placée à "*True*". Les paramètres de contrôle de + l'approximation numérique de l'opérateur adjoint, dans le cas + "*OneFunction*", peuvent être renseignés par un dictionnaire dans + "*Parameters*". Les entrées potentielles de ce dictionnaire de paramètres + sont "*DifferentialIncrement*", "*CenteredFiniteDifference*" (similaires à + celles de l'interface graphique). .. index:: single: setControlInput -**setControlInput** (*Vector, VectorSerie, Stored*) +**setControlInput** (*Vector, VectorSerie, Script, Stored*) Cette commande permet de définir le vecteur de contrôle :math:`\mathbf{u}`. - Selon les algorithmes, on peut définir un vecteur simple par "Vector", ou - une liste de vecteurs par "VectorSerie". + Selon les algorithmes, on peut le définir comme un vecteur simple par + "*Vector*", ou comme une liste de vecteurs par "*VectorSerie*". Si on le + définit par un script dans "*Script*", le vecteur est de type "*Vector*" + (par défaut) ou "*VectorSerie*" selon que l'une de ces variables est placée + à "*True*". .. index:: single: setEvolutionError -**setEvolutionError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Stored*) +**setEvolutionError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Script, Stored*) Cette commande permet de définir la matrice :math:`\mathbf{Q}` des covariance des erreurs d'évolution. La matrice peut être définie de manière complète par "*Matrix*", ou de manière parcimonieuse comme une matrice diagonale dont on donne la variance unique sur la diagonale par "*ScalarSparseMatrix*", ou comme une matrice diagonale dont on donne le vecteur des variances situé sur la diagonale par "*DiagonalSparseMatrix*". + Si on la définit par un script dans "*Script*", la matrice est de type + "*Matrix*" (par défaut), "*ScalarSparseMatrix*" ou "*DiagonalSparseMatrix*" + selon que l'une de ces variables est placée à "*True*". .. index:: single: setEvolutionModel -**setEvolutionModel** (*Matrix, DirectFunction, ThreeFunctions, Parameters, Stored*) +**setEvolutionModel** (*Matrix, OneFunction, ThreeFunctions, Parameters, Script, Stored*) Cette commande permet de définir l'opérateur d'evolution :math:`M`, qui décrit un pas élémentaire d'évolution. Sa valeur est définie comme un objet de type fonction ou de type "*Matrix*". Dans le cas d'une fonction, différentes formes fonctionnelles peuvent être utilisées, comme décrit dans la section :ref:`section_ref_operator_requirements`, et entrées par - "*DirectFunction*" ou "*ThreeFunctions*". Les paramètres de contrôle de - l'approximation numérique de l'opérateur adjoint, dans le cas - "*DirectFunction*", peuvent être renseignés par un dictionnaire dans - "*Parameters*". Les entrées potentielles de ce dictionnaire de paramètres - sont "*DifferentialIncrement*", "*CenteredFiniteDifference*", - "*EnableMultiProcessing*", "*NumberOfProcesses*" (similaires à celles de - l'interface graphique). + "*OneFunction*" ou "*ThreeFunctions*". Dans le cas d'une définition par + "*Script*", l'opérateur est de type "*Matrix*", "*OneFunction*" ou + "*ThreeFunctions*" selon que l'une de ces variables est placée à "*True*". + Les paramètres de contrôle de l'approximation numérique de l'opérateur + adjoint, dans le cas "*OneFunction*", peuvent être renseignés par un + dictionnaire dans "*Parameters*". Les entrées potentielles de ce + dictionnaire de paramètres sont "*DifferentialIncrement*", + "*CenteredFiniteDifference*", "*EnableMultiProcessing*", + "*NumberOfProcesses*" (similaires à celles de l'interface graphique). .. index:: single: setObservation -**setObservation** (*Vector, VectorSerie, Stored*) +**setObservation** (*Vector, VectorSerie, Script, Stored*) Cette commande permet de définir le vecteur d'observation - :math:`\mathbf{y}^o`. Selon les cas, on peut définir un vecteur simple par - "Vector", ou une liste de vecteurs par "VectorSerie". + :math:`\mathbf{y}^o`. Selon les algorithmes, on peut le définir comme un + vecteur simple par "*Vector*", ou comme une liste de vecteurs par + "*VectorSerie*". Si on le définit par un script dans "*Script*", le vecteur + est de type "*Vector*" (par défaut) ou "*VectorSerie*" selon que l'une de + ces variables est placée à "*True*". .. index:: single: setObservationError -**setObservationError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Stored*) +**setObservationError** (*Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Script, Stored*) Cette commande permet de définir la matrice :math:`\mathbf{R}` des covariance des erreurs d'observation. La matrice peut être définie de manière complète par "*Matrix*", ou de manière parcimonieuse comme une matrice diagonale dont on donne la variance unique sur la diagonale par "*ScalarSparseMatrix*", ou comme une matrice diagonale dont on donne le vecteur des variances situé sur la diagonale par "*DiagonalSparseMatrix*". + Si on la définit par un script dans "*Script*", la matrice est de type + "*Matrix*" (par défaut), "*ScalarSparseMatrix*" ou "*DiagonalSparseMatrix*" + selon que l'une de ces variables est placée à "*True*". .. index:: single: setObservationOperator -**setObservationOperator** (*Matrix, DirectFunction, ThreeFunctions, Parameters, Stored*) +**setObservationOperator** (*Matrix, OneFunction, ThreeFunctions, Parameters, Script, Stored*) Cette commande permet de définir l'opérateur d'observation :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 fonction ou de type "*Matrix*". Dans le cas d'une fonction, différentes formes fonctionnelles peuvent être utilisées, comme décrit dans la section - :ref:`section_ref_operator_requirements`, et entrées par "*DirectFunction*" - ou "*ThreeFunctions*". Les paramètres de contrôle de l'approximation - numérique de l'opérateur adjoint, dans le cas "*DirectFunction*", peuvent - être renseignés par un dictionnaire dans "*Parameters*". Les entrées - potentielles de ce dictionnaire de paramètres sont "*DifferentialIncrement*", - "*CenteredFiniteDifference*", "*EnableMultiProcessing*", - "*NumberOfProcesses*" (similaires à celles de l'interface graphique). + :ref:`section_ref_operator_requirements`, et entrées par "*OneFunction*" ou + "*ThreeFunctions*". Dans le cas d'une définition par "*Script*", l'opérateur + est de type "*Matrix*", "*OneFunction*" ou "*ThreeFunctions*" selon que + l'une de ces variables est placée à "*True*". Les paramètres de contrôle de + l'approximation numérique de l'opérateur adjoint, dans le cas + "*OneFunction*", peuvent être renseignés par un dictionnaire dans + "*Parameters*". Les entrées potentielles de ce dictionnaire de paramètres + sont "*DifferentialIncrement*", "*CenteredFiniteDifference*", + "*EnableMultiProcessing*", "*NumberOfProcesses*" (similaires à celles de + l'interface graphique). .. index:: single: set @@ -403,7 +430,8 @@ Les commandes disponibles sont les suivantes : commandes de ce paragraphe. Son premier argument est le nom du concept à définir (par exemple "*Background*" ou "*ObservationOperator*"), sur lequel s'applique ensuite les arguments qui suivent, qui sont les mêmes que dans - les commandes individuelles ci-dessus. + les commandes individuelles précédentes. Lors de l'usage de cette commande, + il est indispensable de nommer les arguments (par exemple "*Vector=...*"). Paramétrer le calcul, les sorties, etc. +++++++++++++++++++++++++++++++++++++++ @@ -488,8 +516,134 @@ Obtenir s fois aux :ref:`section_ref_output_variables` et aux documentations individuelles des algorithmes. -.. Exemples plus avancés de cas de calcul TUI ADAO -.. ----------------------------------------------- +Exemples plus avancés de cas de calcul TUI ADAO +----------------------------------------------- + +On propose ici des exemples plus complets de cas de calcul TUI ADAO, en donnant +l'objectif de l'exemple et un jeu de commandes qui permet de parvenir à cet +objectif. + +Exploitation indépendante des résultats d'un cas de calcul +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +L'objectif est d'effectuer en TUI la mise en données d'un cas de calcul ADAO, +son exécution, puis la récupération des résultats pour ensuite enchaîner sur une +exploitation indépendante de ces résultats (cette dernière n'étant pas décrite +ici, puisque dépendante de l'utilisateur). + +Les hypothèses du cas utilisateur sont les suivantes. On suppose : + +#. que l'on veut recaler 3 paramètres ``alpha``, ``beta`` et ``gamma`` dans un domaine borné, +#. que l'on dispose d'observations nommées ``observations``, +#. que l'utilisateur dispose en Python d'une fonction de simulation physique appellée ``simulation`` préalablement testée, qui transforme les 3 paramètres en résultats similaires aux observations, +#. que l'exploitation indépendante, que l'utilisateur veut faire, est représentée ici par l'affichage simple de l'état initial, de l'état optimal, de la simulation en ce point, des états intermédiaires et du nombre d'itérations d'optimisation. + +Pour effectuer de manière simple cet essai de cas de calcul TUI, on se donne par +exemple les entrées suivantes, parfaitement arbitraires, en construisant les +observations par simulation pour se placer dans un cas d'expériences jumelles:: + + # + # Construction artificielle d'un exemple de données utilisateur + # ------------------------------------------------------------- + alpha = 5. + beta = 7 + gamma = 9.0 + # + alphamin, alphamax = 0., 10. + betamin, betamax = 3, 13 + gammamin, gammamax = 1.5, 15.5 + # + def simulation(x): + import numpy + __x = numpy.matrix(numpy.ravel(numpy.matrix(x))).T + __H = numpy.matrix("1 0 0;0 2 0;0 0 3; 1 2 3") + return __H * __x + # + # Observations obtenues par simulation + # ------------------------------------ + observations = simulation((2, 3, 4)) + +Le jeu de commandes que l'on peut utiliser est le suivant:: + + import numpy + import adaoBuilder + # + # Mise en forme des entrées + # ------------------------- + Xb = (alpha, beta, gamma) + Bounds = ( + (alphamin, alphamax), + (betamin, betamax ), + (gammamin, gammamax)) + # + # TUI ADAO + # -------- + case = adaoBuilder.New() + case.set( 'AlgorithmParameters', + Algorithm = '3DVAR', + Parameters = { + "Bounds":Bounds, + "MaximumNumberOfSteps":100, + "StoreSupplementaryCalculations":[ + "CostFunctionJ", + "CurrentState", + "SimulatedObservationAtOptimum", + ], + } + ) + case.set( 'Background', Vector = numpy.array(Xb), Stored = True ) + case.set( 'Observation', Vector = numpy.array(observations) ) + case.set( 'BackgroundError', ScalarSparseMatrix = 1.0e10 ) + case.set( 'ObservationError', ScalarSparseMatrix = 1.0 ) + case.set( 'ObservationOperator', + OneFunction = simulation, + Parameters = {"DifferentialIncrement":0.0001}, + ) + case.set( 'Observer', Variable="CurrentState", Template="ValuePrinter" ) + case.execute() + # + # Exploitation indépendante + # ------------------------- + Xbackground = case.get("Background") + Xoptimum = case.get("Analysis")[-1] + FX_at_optimum = case.get("SimulatedObservationAtOptimum")[-1] + J_values = case.get("CostFunctionJ")[:] + print + print "Nombre d'itérations internes...: %i"%len(J_values) + print "Etat initial...................:",numpy.ravel(Xbackground) + print "Etat optimal...................:",numpy.ravel(Xoptimum) + print "Simulation à l'état optimal....:",numpy.ravel(FX_at_optimum) + print + +L'exécution de jeu de commandes donne le résultat suivant:: + + CurrentState [ 5. 7. 9.] + CurrentState [ 0. 3. 1.5] + CurrentState [ 1.40006418 3.86705307 3.7061137 ] + CurrentState [ 1.42580231 3.68474804 3.81008738] + CurrentState [ 1.60220353 3.0677108 4.06146069] + CurrentState [ 1.72517855 3.03296953 4.04915706] + CurrentState [ 2.00010755 3. 4.00055409] + CurrentState [ 1.99995528 3. 3.99996367] + CurrentState [ 2.00000007 3. 4.00000011] + CurrentState [ 2. 3. 4.] + + Nombre d'itérations internes...: 10 + Etat initial...................: [ 5. 7. 9.] + Etat optimal...................: [ 2. 3. 4.] + Simulation à l'état optimal....: [ 2. 6. 12. 20.] + +Comme il se doit en expériences jumelles, on constate que l'on retouve bien les +paramètres qui ont servi à construire artificiellement les observations. + +.. Réconciliation de courbes à l'aide de MedCoupling +.. +++++++++++++++++++++++++++++++++++++++++++++++++ + +.. Utilisation de fonctions de surveillance de type "observer" +.. +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +.. Suivre d'un recalage à l'aide de MatPlotLib +.. +++++++++++++++++++++++++++++++++++++++++++ .. Equivalences entre l'interface graphique (GUI) et l'interface textuelle (TUI) .. ----------------------------------------------------------------------------- diff --git a/src/daComposant/daCore/AssimilationStudy.py b/src/daComposant/daCore/AssimilationStudy.py index 4e9acfc..fa942df 100644 --- a/src/daComposant/daCore/AssimilationStudy.py +++ b/src/daComposant/daCore/AssimilationStudy.py @@ -117,10 +117,7 @@ class AssimilationStudy: être rendue disponible au même titre que les variables de calcul """ if asVector is not None: - if type( asVector ) is type( numpy.matrix([]) ): - self.__Xb = numpy.matrix( asVector.A1, numpy.float ).T - else: - self.__Xb = numpy.matrix( asVector, numpy.float ).T + self.__Xb = numpy.matrix( numpy.ravel(numpy.matrix(asVector)), numpy.float ).T elif asPersistentVector is not None: if type(asPersistentVector) in [type([]),type(()),type(numpy.array([])),type(numpy.matrix([]))]: self.__Xb = Persistence.OneVector("Background", basetype=numpy.matrix) @@ -185,10 +182,7 @@ class AssimilationStudy: être rendue disponible au même titre que les variables de calcul """ if asVector is not None: - if type( asVector ) is type( numpy.matrix([]) ): - self.__Y = numpy.matrix( asVector.A1, numpy.float ).T - else: - self.__Y = numpy.matrix( asVector, numpy.float ).T + self.__Y = numpy.matrix( numpy.ravel(numpy.matrix(asVector)), numpy.float ).T elif asPersistentVector is not None: if type(asPersistentVector) in [type([]),type(()),type(numpy.array([])),type(numpy.matrix([]))]: self.__Y = Persistence.OneVector("Observation", basetype=numpy.matrix) @@ -573,10 +567,7 @@ class AssimilationStudy: être rendue disponible au même titre que les variables de calcul """ if asVector is not None: - if isinstance(asVector,numpy.matrix): - self.__U = numpy.matrix( asVector.A1, numpy.float ).T - else: - self.__U = numpy.matrix( asVector, numpy.float ).T + self.__U = numpy.matrix( numpy.ravel(numpy.matrix(asVector)), numpy.float ).T elif asPersistentVector is not None: if type(asPersistentVector) in [type([]),type(()),type(numpy.array([])),type(numpy.matrix([]))]: self.__U = Persistence.OneVector("ControlInput", basetype=numpy.matrix) diff --git a/src/daSalome/adaoBuilder.py b/src/daSalome/adaoBuilder.py index 5017fe7..8ac7727 100644 --- a/src/daSalome/adaoBuilder.py +++ b/src/daSalome/adaoBuilder.py @@ -26,6 +26,7 @@ __author__ = "Jean-Philippe ARGAUD" __all__ = ["New"] +import os from daCore import AssimilationStudy class New(object): @@ -43,11 +44,12 @@ class New(object): Concept = None, Algorithm = None, DiagonalSparseMatrix = None, - DirectFunction = None, Info = None, Matrix = None, + OneFunction = None, Parameters = None, ScalarSparseMatrix = None, + Script = None, Stored = False, String = None, Template = None, @@ -60,31 +62,31 @@ class New(object): self.__dumper.register("set",dir(),locals(),None,True) try: if Concept == "Background": - self.setBackground(Vector,VectorSerie,Stored) + self.setBackground(Vector,VectorSerie,Script,Stored) elif Concept == "BackgroundError": self.setBackgroundError(Matrix,ScalarSparseMatrix, - DiagonalSparseMatrix,Stored) + DiagonalSparseMatrix,Script,Stored) elif Concept == "CheckingPoint": - self.setCheckingPoint(Vector,VectorSerie,Stored) + self.setCheckingPoint(Vector,VectorSerie,Script,Stored) elif Concept == "ControlModel": - self.setControlModel(Matrix,DirectFunction, - ThreeFunctions,Parameters,Stored) + self.setControlModel(Matrix,OneFunction,ThreeFunctions, + Parameters,Script,Stored) elif Concept == "ControlInput": - self.setControlInput(Vector,VectorSerie,Stored) + self.setControlInput(Vector,VectorSerie,Script,Stored) elif Concept == "EvolutionError": self.setEvolutionError(Matrix,ScalarSparseMatrix, - DiagonalSparseMatrix,Stored) + DiagonalSparseMatrix,Script,Stored) elif Concept == "EvolutionModel": - self.setEvolutionModel(Matrix,DirectFunction, - ThreeFunctions,Parameters,Stored) + self.setEvolutionModel(Matrix,OneFunction,ThreeFunctions, + Parameters,Script,Stored) elif Concept == "Observation": - self.setObservation(Vector,VectorSerie,Stored) + self.setObservation(Vector,VectorSerie,Script,Stored) elif Concept == "ObservationError": self.setObservationError(Matrix,ScalarSparseMatrix, - DiagonalSparseMatrix,Stored) + DiagonalSparseMatrix,Script,Stored) elif Concept == "ObservationOperator": - self.setObservationOperator(Matrix,DirectFunction, - ThreeFunctions,Parameters,Stored) + self.setObservationOperator(Matrix,OneFunction,ThreeFunctions, + Parameters,Script,Stored) elif Concept == "AlgorithmParameters": self.setAlgorithmParameters(Algorithm,Parameters) elif Concept == "Debug": @@ -106,10 +108,18 @@ class New(object): self, Vector = None, VectorSerie = None, + Script = None, Stored = False): "Définition d'une entrée de calcul" self.__dumper.register("setBackground", dir(), locals()) - __Vector, __PersistentVector = Vector, VectorSerie + if Script is not None: + __Vector, __PersistentVector = None, None + if VectorSerie: + __PersistentVector = _ImportFromScript(Script).getvalue( "Background" ) + else: + __Vector = _ImportFromScript(Script).getvalue( "Background" ) + else: + __Vector, __PersistentVector = Vector, VectorSerie # self.__adaoStudy.setBackground( asVector = __Vector, @@ -122,10 +132,20 @@ class New(object): Matrix = None, ScalarSparseMatrix = None, DiagonalSparseMatrix = None, + Script = None, Stored = False): "Définition d'une entrée de calcul" self.__dumper.register("setBackgroundError", dir(), locals()) - __Covariance, __Scalar, __Vector = Matrix, ScalarSparseMatrix, DiagonalSparseMatrix + if Script is not None: + __Covariance, __Scalar, __Vector = None, None, None + if ScalarSparseMatrix: + __Scalar = _ImportFromScript(Script).getvalue( "BackgroundError" ) + elif DiagonalSparseMatrix: + __Vector = _ImportFromScript(Script).getvalue( "BackgroundError" ) + else: + __Covariance = _ImportFromScript(Script).getvalue( "BackgroundError" ) + else: + __Covariance, __Scalar, __Vector = Matrix, ScalarSparseMatrix, DiagonalSparseMatrix # self.__adaoStudy.setBackgroundError( asCovariance = __Covariance, @@ -138,10 +158,18 @@ class New(object): self, Vector = None, VectorSerie = None, + Script = None, Stored = False): "Définition d'une entrée de vérification" self.__dumper.register("setCheckingPoint", dir(), locals()) - __Vector, __PersistentVector = Vector, VectorSerie + if Script is not None: + __Vector, __PersistentVector = None, None + if VectorSerie: + __PersistentVector = _ImportFromScript(Script).getvalue( "CheckingPoint" ) + else: + __Vector = _ImportFromScript(Script).getvalue( "CheckingPoint" ) + else: + __Vector, __PersistentVector = Vector, VectorSerie # self.__adaoStudy.setBackground( asVector = __Vector, @@ -152,34 +180,51 @@ class New(object): def setControlModel( self, Matrix = None, - DirectFunction = None, + OneFunction = None, ThreeFunctions = None, Parameters = None, + Script = None, Stored = False): "Définition d'une entrée de calcul" self.__dumper.register("setControlModel", dir(), locals()) __Parameters = {} if Parameters is not None and type(Parameters) == type({}): - if DirectFunction is not None: - __Parameters["useApproximatedDerivatives"] = True if Parameters.has_key("DifferentialIncrement"): __Parameters["withIncrement"] = Parameters["DifferentialIncrement"] if Parameters.has_key("CenteredFiniteDifference"): __Parameters["withCenteredDF"] = Parameters["CenteredFiniteDifference"] - __Matrix = Matrix - if DirectFunction is not None: - __Function = { "Direct":DirectFunction } - __Function.update(__Parameters) - elif ThreeFunctions is not None: - if (type(ThreeFunctions) is not type({})) or \ - not ThreeFunctions.has_key("Direct") or \ - not ThreeFunctions.has_key("Tangent") or \ - not ThreeFunctions.has_key("Adjoint"): - raise ValueError("ThreeFunctions has to be a dictionnary and to have the 3 keys Direct, Tangent, Adjoint") - __Function = ThreeFunctions - __Function.update(__Parameters) + if Script is not None: + __Matrix, __Function = None, None + if Matrix: + __Matrix = _ImportFromScript(Script).getvalue( "ObservationOperator" ) + elif OneFunction: + __Function = { "Direct":_ImportFromScript(Script).getvalue( "DirectOperator" ) } + __Function.update({"useApproximatedDerivatives":True}) + __Function.update(__Parameters) + elif ThreeFunctions: + __Function = { + "Direct" :_ImportFromScript(Script).getvalue( "DirectOperator" ), + "Tangent":_ImportFromScript(Script).getvalue( "TangentOperator" ), + "Adjoint":_ImportFromScript(Script).getvalue( "AdjointOperator" ), + } + __Function.update(__Parameters) + else: - __Function = None + __Matrix = Matrix + if OneFunction is not None: + __Function = { "Direct":OneFunction } + __Function.update({"useApproximatedDerivatives":True}) + __Function.update(__Parameters) + elif ThreeFunctions is not None: + if (type(ThreeFunctions) is not type({})) or \ + not ThreeFunctions.has_key("Direct") or \ + not ThreeFunctions.has_key("Tangent") or \ + not ThreeFunctions.has_key("Adjoint"): + raise ValueError("ThreeFunctions has to be a dictionnary and to have the 3 keys Direct, Tangent, Adjoint") + __Function = ThreeFunctions + __Function.update(__Parameters) + else: + __Function = None # self.__adaoStudy.setControlModel( asFunction = __Function, @@ -191,10 +236,18 @@ class New(object): self, Vector = None, VectorSerie = None, + Script = None, Stored = False): "Définition d'une entrée de calcul" self.__dumper.register("setControlInput", dir(), locals()) - __Vector, __PersistentVector = Vector, VectorSerie + if Script is not None: + __Vector, __PersistentVector = None, None + if VectorSerie: + __PersistentVector = _ImportFromScript(Script).getvalue( "ControlInput" ) + else: + __Vector = _ImportFromScript(Script).getvalue( "ControlInput" ) + else: + __Vector, __PersistentVector = Vector, VectorSerie # self.__adaoStudy.setControlInput( asVector = __Vector, @@ -207,10 +260,20 @@ class New(object): Matrix = None, ScalarSparseMatrix = None, DiagonalSparseMatrix = None, + Script = None, Stored = False): "Définition d'une entrée de calcul" self.__dumper.register("setEvolutionError", dir(), locals()) - __Covariance, __Scalar, __Vector = Matrix, ScalarSparseMatrix, DiagonalSparseMatrix + if Script is not None: + __Covariance, __Scalar, __Vector = None, None, None + if ScalarSparseMatrix: + __Scalar = _ImportFromScript(Script).getvalue( "EvolutionError" ) + elif DiagonalSparseMatrix: + __Vector = _ImportFromScript(Script).getvalue( "EvolutionError" ) + else: + __Covariance = _ImportFromScript(Script).getvalue( "EvolutionError" ) + else: + __Covariance, __Scalar, __Vector = Matrix, ScalarSparseMatrix, DiagonalSparseMatrix # self.__adaoStudy.setEvolutionError( asCovariance = __Covariance, @@ -222,16 +285,15 @@ class New(object): def setEvolutionModel( self, Matrix = None, - DirectFunction = None, + OneFunction = None, ThreeFunctions = None, Parameters = None, + Script = None, Stored = False): "Définition d'une entrée de calcul" self.__dumper.register("setEvolutionModel", dir(), locals()) __Parameters = {} if Parameters is not None and type(Parameters) == type({}): - if DirectFunction is not None: - __Parameters["useApproximatedDerivatives"] = True if Parameters.has_key("DifferentialIncrement"): __Parameters["withIncrement"] = Parameters["DifferentialIncrement"] if Parameters.has_key("CenteredFiniteDifference"): @@ -240,20 +302,38 @@ class New(object): __Parameters["withmpEnabled"] = Parameters["EnableMultiProcessing"] if Parameters.has_key("NumberOfProcesses"): __Parameters["withmpWorkers"] = Parameters["NumberOfProcesses"] - __Matrix = Matrix - if DirectFunction is not None: - __Function = { "Direct":DirectFunction } - __Function.update(__Parameters) - elif ThreeFunctions is not None: - if (type(ThreeFunctions) is not type({})) or \ - not ThreeFunctions.has_key("Direct") or \ - not ThreeFunctions.has_key("Tangent") or \ - not ThreeFunctions.has_key("Adjoint"): - raise ValueError("ThreeFunctions has to be a dictionnary and to have the 3 keys Direct, Tangent, Adjoint") - __Function = ThreeFunctions - __Function.update(__Parameters) + if Script is not None: + __Matrix, __Function = None, None + if Matrix: + __Matrix = _ImportFromScript(Script).getvalue( "ObservationOperator" ) + elif OneFunction: + __Function = { "Direct":_ImportFromScript(Script).getvalue( "DirectOperator" ) } + __Function.update({"useApproximatedDerivatives":True}) + __Function.update(__Parameters) + elif ThreeFunctions: + __Function = { + "Direct" :_ImportFromScript(Script).getvalue( "DirectOperator" ), + "Tangent":_ImportFromScript(Script).getvalue( "TangentOperator" ), + "Adjoint":_ImportFromScript(Script).getvalue( "AdjointOperator" ), + } + __Function.update(__Parameters) + else: - __Function = None + __Matrix = Matrix + if OneFunction is not None: + __Function = { "Direct":OneFunction } + __Function.update({"useApproximatedDerivatives":True}) + __Function.update(__Parameters) + elif ThreeFunctions is not None: + if (type(ThreeFunctions) is not type({})) or \ + not ThreeFunctions.has_key("Direct") or \ + not ThreeFunctions.has_key("Tangent") or \ + not ThreeFunctions.has_key("Adjoint"): + raise ValueError("ThreeFunctions has to be a dictionnary and to have the 3 keys Direct, Tangent, Adjoint") + __Function = ThreeFunctions + __Function.update(__Parameters) + else: + __Function = None # self.__adaoStudy.setEvolutionModel( asFunction = __Function, @@ -265,10 +345,18 @@ class New(object): self, Vector = None, VectorSerie = None, + Script = None, Stored = False): "Définition d'une entrée de calcul" self.__dumper.register("setObservation", dir(), locals()) - __Vector, __PersistentVector = Vector, VectorSerie + if Script is not None: + __Vector, __PersistentVector = None, None + if VectorSerie: + __PersistentVector = _ImportFromScript(Script).getvalue( "Observation" ) + else: + __Vector = _ImportFromScript(Script).getvalue( "Observation" ) + else: + __Vector, __PersistentVector = Vector, VectorSerie # self.__adaoStudy.setObservation( asVector = __Vector, @@ -281,10 +369,20 @@ class New(object): Matrix = None, ScalarSparseMatrix = None, DiagonalSparseMatrix = None, + Script = None, Stored = False): "Définition d'une entrée de calcul" self.__dumper.register("setObservationError", dir(), locals()) - __Covariance, __Scalar, __Vector = Matrix, ScalarSparseMatrix, DiagonalSparseMatrix + if Script is not None: + __Covariance, __Scalar, __Vector = None, None, None + if ScalarSparseMatrix: + __Scalar = _ImportFromScript(Script).getvalue( "ObservationError" ) + elif DiagonalSparseMatrix: + __Vector = _ImportFromScript(Script).getvalue( "ObservationError" ) + else: + __Covariance = _ImportFromScript(Script).getvalue( "ObservationError" ) + else: + __Covariance, __Scalar, __Vector = Matrix, ScalarSparseMatrix, DiagonalSparseMatrix # self.__adaoStudy.setObservationError( asCovariance = __Covariance, @@ -296,16 +394,15 @@ class New(object): def setObservationOperator( self, Matrix = None, - DirectFunction = None, + OneFunction = None, ThreeFunctions = None, Parameters = None, + Script = None, Stored = False): "Définition d'une entrée de calcul" self.__dumper.register("setObservationOperator", dir(), locals()) __Parameters = {} if Parameters is not None and type(Parameters) == type({}): - if DirectFunction is not None: - __Parameters["useApproximatedDerivatives"] = True if Parameters.has_key("DifferentialIncrement"): __Parameters["withIncrement"] = Parameters["DifferentialIncrement"] if Parameters.has_key("CenteredFiniteDifference"): @@ -314,20 +411,38 @@ class New(object): __Parameters["withmpEnabled"] = Parameters["EnableMultiProcessing"] if Parameters.has_key("NumberOfProcesses"): __Parameters["withmpWorkers"] = Parameters["NumberOfProcesses"] - __Matrix = Matrix - if DirectFunction is not None: - __Function = { "Direct":DirectFunction } - __Function.update(__Parameters) - elif ThreeFunctions is not None: - if (type(ThreeFunctions) is not type({})) or \ - not ThreeFunctions.has_key("Direct") or \ - not ThreeFunctions.has_key("Tangent") or \ - not ThreeFunctions.has_key("Adjoint"): - raise ValueError("ThreeFunctions has to be a dictionnary and to have the 3 keys Direct, Tangent, Adjoint") - __Function = ThreeFunctions - __Function.update(__Parameters) + if Script is not None: + __Matrix, __Function = None, None + if Matrix: + __Matrix = _ImportFromScript(Script).getvalue( "ObservationOperator" ) + elif OneFunction: + __Function = { "Direct":_ImportFromScript(Script).getvalue( "DirectOperator" ) } + __Function.update({"useApproximatedDerivatives":True}) + __Function.update(__Parameters) + elif ThreeFunctions: + __Function = { + "Direct" :_ImportFromScript(Script).getvalue( "DirectOperator" ), + "Tangent":_ImportFromScript(Script).getvalue( "TangentOperator" ), + "Adjoint":_ImportFromScript(Script).getvalue( "AdjointOperator" ), + } + __Function.update(__Parameters) + else: - __Function = None + __Matrix = Matrix + if OneFunction is not None: + __Function = { "Direct":OneFunction } + __Function.update({"useApproximatedDerivatives":True}) + __Function.update(__Parameters) + elif ThreeFunctions is not None: + if (type(ThreeFunctions) is not type({})) or \ + not ThreeFunctions.has_key("Direct") or \ + not ThreeFunctions.has_key("Tangent") or \ + not ThreeFunctions.has_key("Adjoint"): + raise ValueError("ThreeFunctions has to be a dictionnary and to have the 3 keys Direct, Tangent, Adjoint") + __Function = ThreeFunctions + __Function.update(__Parameters) + else: + __Function = None # self.__adaoStudy.setObservationOperator( asFunction = __Function, @@ -413,6 +528,7 @@ class New(object): if type(e) == type(SyntaxError()): msg = "at %s: %s"%(e.offset, e.text) else: msg = "" raise ValueError("during execution, the following error occurs:\n\n%s %s\n\nSee also the potential messages, which can show the origin of the above error, in the launching terminal."%(str(e),msg)) + execute = executePythonScheme def executeYACSScheme(self, File=None): @@ -468,12 +584,12 @@ class _DumpLogger(object): self.__switchoff = True if not __switchoff: self.__switchoff = False - def dump(self,filename=None): + def dump(self,__filename=None): "Restitution de la liste des commandes de création d'un cas" - if filename is None: + if __filename is None: return "\n".join(self.__logSerie) else: - fid = open(filename,"w") + fid = open(__filename,"w") fid.writelines(self.__logSerie) fid.close() @@ -490,6 +606,27 @@ class _ObserverF(object): "Restitution du pointeur de fonction dans l'objet" return self.func +class _ImportFromScript(object): + """ + Obtention d'une variable nommée depuis un fichier script importé + """ + def __init__(self, __filename=None): + "Verifie l'existence et importe le script" + __filename = __filename.rstrip(".py") + if __filename is None: + raise ValueError("The name of the file containing the variable to be imported has to be specified.") + if not os.path.isfile(str(__filename)+".py"): + raise ValueError("The file containing the variable to be imported doesn't seem to exist. The given file name is:\n \"%s\""%__filename) + self.__scriptfile = __import__(__filename, globals(), locals(), []) + def getvalue(self, __varname=None ): + "Renvoie la variable demandee" + if __varname is None: + raise ValueError("The name of the variable to be imported has to be specified.") + if not hasattr(self.__scriptfile, __varname): + raise ValueError("The imported script file doesn't contain the specified variable \"%s\"."%__varname) + else: + return getattr(self.__scriptfile, __varname) + # ============================================================================== if __name__ == "__main__": print '\n AUTODIAGNOSTIC \n'