# -*- coding: utf-8 -*-
#
-# Copyright (C) 2008-2017 EDF R&D
+# Copyright (C) 2008-2018 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
"""
Définit les outils généraux élémentaires.
-
- Ce module est destiné à être appelée par AssimilationStudy.
"""
__author__ = "Jean-Philippe ARGAUD"
__all__ = []
-import os, sys, logging, copy
+import os
+import sys
+import logging
+import copy
import numpy
+from functools import partial
from daCore import Persistence
from daCore import PlatformInfo
+from daCore import Interfaces
from daCore import Templates
+from daCore.Interfaces import ImportFromScript, ImportFromFile
# ==============================================================================
class CacheManager(object):
NbCallsOfCached = 0
CM = CacheManager()
#
- def __init__(self, fromMethod=None, fromMatrix=None, avoidingRedundancy = True):
+ def __init__(self, fromMethod=None, fromMatrix=None, avoidingRedundancy = True, inputAsMultiFunction = False):
"""
- On construit un objet de ce type en fournissant à l'aide de l'un des
- deux mots-clé, soit une fonction python, soit une matrice.
+ On construit un objet de ce type en fournissant, à l'aide de l'un des
+ deux mots-clé, soit une fonction ou un multi-fonction python, soit une
+ matrice.
Arguments :
- fromMethod : argument de type fonction Python
- fromMatrix : argument adapté au constructeur numpy.matrix
- avoidingRedundancy : évite ou pas les calculs redondants
+ - inputAsMultiFunction : fonction explicitement définie ou pas en multi-fonction
"""
self.__NbCallsAsMatrix, self.__NbCallsAsMethod, self.__NbCallsOfCached = 0, 0, 0
self.__AvoidRC = bool( avoidingRedundancy )
- if fromMethod is not None:
- self.__Method = fromMethod
+ self.__inputAsMF = bool( inputAsMultiFunction )
+ if fromMethod is not None and self.__inputAsMF:
+ self.__Method = fromMethod # logtimer(fromMethod)
+ self.__Matrix = None
+ self.__Type = "Method"
+ elif fromMethod is not None and not self.__inputAsMF:
+ self.__Method = partial( MultiFonction, _sFunction=fromMethod)
self.__Matrix = None
self.__Type = "Method"
elif fromMatrix is not None:
"Renvoie le type"
return self.__Type
- def appliedTo(self, xValue, HValue = None):
+ def appliedTo(self, xValue, HValue = None, argsAsSerie = False):
"""
Permet de restituer le résultat de l'application de l'opérateur à un
argument xValue. Cette méthode se contente d'appliquer, son argument
Arguments :
- xValue : argument adapté pour appliquer l'opérateur
"""
- if HValue is not None:
- HxValue = numpy.asmatrix( numpy.ravel( HValue ) ).T
- if self.__AvoidRC:
- Operator.CM.storeValueInX(xValue,HxValue)
+ if argsAsSerie:
+ _xValue = xValue
+ _HValue = HValue
else:
- if self.__AvoidRC:
- __alreadyCalculated, __HxV = Operator.CM.wasCalculatedIn(xValue)
- else:
- __alreadyCalculated = False
- #
- if __alreadyCalculated:
- self.__addOneCacheCall()
- HxValue = __HxV
+ _xValue = (xValue,)
+ if HValue is not None:
+ _HValue = (HValue,)
else:
- if self.__Matrix is not None:
- self.__addOneMatrixCall()
- HxValue = self.__Matrix * xValue
- else:
- self.__addOneMethodCall()
- HxValue = self.__Method( xValue )
+ _HValue = HValue
+ PlatformInfo.isIterable( _xValue, True, " in Operator.appliedTo" )
+ #
+ if _HValue is not None:
+ assert len(_xValue) == len(_HValue), "Incompatible number of elements in xValue and HValue"
+ HxValue = []
+ for i in range(len(_HValue)):
+ HxValue.append( numpy.asmatrix( numpy.ravel( _HValue[i] ) ).T )
if self.__AvoidRC:
- Operator.CM.storeValueInX(xValue,HxValue)
- #
- return HxValue
+ Operator.CM.storeValueInX(_xValue[i],HxValue[-1])
+ else:
+ HxValue = []
+ _xserie = []
+ _hindex = []
+ for i, xv in enumerate(_xValue):
+ if self.__AvoidRC:
+ __alreadyCalculated, __HxV = Operator.CM.wasCalculatedIn(xv)
+ else:
+ __alreadyCalculated = False
+ #
+ if __alreadyCalculated:
+ self.__addOneCacheCall()
+ _hv = __HxV
+ else:
+ if self.__Matrix is not None:
+ self.__addOneMatrixCall()
+ _hv = self.__Matrix * xv
+ else:
+ self.__addOneMethodCall()
+ _xserie.append( xv )
+ _hindex.append( i )
+ _hv = None
+ HxValue.append( _hv )
+ #
+ if len(_xserie)>0 and self.__Matrix is None:
+ _hserie = self.__Method( _xserie ) # Calcul MF
+ if not hasattr(_hserie, "pop"):
+ raise TypeError("The user input multi-function doesn't seem to return sequence results, behaving like a mono-function. It has to be checked.")
+ for i in _hindex:
+ _xv = _xserie.pop(0)
+ _hv = _hserie.pop(0)
+ HxValue[i] = _hv
+ if self.__AvoidRC:
+ Operator.CM.storeValueInX(_xv,_hv)
+ #
+ if argsAsSerie: return HxValue
+ else: return HxValue[-1]
def appliedControledFormTo(self, paire ):
"""
self.__addOneMethodCall()
return self.__Method( xValue )
- def appliedInXTo(self, paire ):
+ def appliedInXTo(self, paires, argsAsSerie = False ):
"""
Permet de restituer le résultat de l'application de l'opérateur à un
argument xValue, sachant que l'opérateur est valable en xNominal.
est construit pour etre ensuite appliqué
- xValue : argument adapté pour appliquer l'opérateur
"""
- assert len(paire) == 2, "Incorrect number of arguments"
- xNominal, xValue = paire
+ if argsAsSerie: _nxValue = paires
+ else: _nxValue = (paires,)
+ PlatformInfo.isIterable( _nxValue, True, " in Operator.appliedInXTo" )
+ #
if self.__Matrix is not None:
- self.__addOneMatrixCall()
- return self.__Matrix * xValue
+ HxValue = []
+ for paire in _nxValue:
+ _xNominal, _xValue = paire
+ self.__addOneMatrixCall()
+ HxValue.append( self.__Matrix * _xValue )
else:
- self.__addOneMethodCall()
- return self.__Method( (xNominal, xValue) )
+ self.__addOneMethodCall( len(_nxValue) )
+ HxValue = self.__Method( _nxValue ) # Calcul MF
+ #
+ if argsAsSerie: return HxValue
+ else: return HxValue[-1]
def asMatrix(self, ValueForMethodForm = "UnknownVoidValue"):
"""
name = "GenericFullOperator",
asMatrix = None,
asOneFunction = None, # Fonction
- asThreeFunctions = None, # Dictionnaire de fonctions
- asScript = None,
+ asThreeFunctions = None, # Fonctions dictionary
+ asScript = None, # Fonction(s) script
asDict = None, # Parameters
appliedInX = None,
avoidRC = True,
+ inputAsMF = False,# Fonction(s) as Multi-Functions
scheduledBy = None,
toBeChecked = False,
):
if "withLenghtOfRedundancy" not in __Function: __Function["withLenghtOfRedundancy"] = -1
if "withmpEnabled" not in __Function: __Function["withmpEnabled"] = False
if "withmpWorkers" not in __Function: __Function["withmpWorkers"] = None
+ if "withmfEnabled" not in __Function: __Function["withmfEnabled"] = inputAsMF
from daNumerics.ApproximatedDerivatives import FDApproximation
FDA = FDApproximation(
Function = __Function["Direct"],
lenghtOfRedundancy = __Function["withLenghtOfRedundancy"],
mpEnabled = __Function["withmpEnabled"],
mpWorkers = __Function["withmpWorkers"],
+ mfEnabled = __Function["withmfEnabled"],
)
- self.__FO["Direct"] = Operator( fromMethod = FDA.DirectOperator, avoidingRedundancy = avoidRC )
- self.__FO["Tangent"] = Operator( fromMethod = FDA.TangentOperator, avoidingRedundancy = avoidRC )
- self.__FO["Adjoint"] = Operator( fromMethod = FDA.AdjointOperator, avoidingRedundancy = avoidRC )
+ self.__FO["Direct"] = Operator( fromMethod = FDA.DirectOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF)
+ self.__FO["Tangent"] = Operator( fromMethod = FDA.TangentOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
+ self.__FO["Adjoint"] = Operator( fromMethod = FDA.AdjointOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
elif isinstance(__Function, dict) and \
("Direct" in __Function) and ("Tangent" in __Function) and ("Adjoint" in __Function) and \
(__Function["Direct"] is not None) and (__Function["Tangent"] is not None) and (__Function["Adjoint"] is not None):
- self.__FO["Direct"] = Operator( fromMethod = __Function["Direct"], avoidingRedundancy = avoidRC )
- self.__FO["Tangent"] = Operator( fromMethod = __Function["Tangent"], avoidingRedundancy = avoidRC )
- self.__FO["Adjoint"] = Operator( fromMethod = __Function["Adjoint"], avoidingRedundancy = avoidRC )
+ self.__FO["Direct"] = Operator( fromMethod = __Function["Direct"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
+ self.__FO["Tangent"] = Operator( fromMethod = __Function["Tangent"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
+ self.__FO["Adjoint"] = Operator( fromMethod = __Function["Adjoint"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
elif asMatrix is not None:
- __matrice = numpy.matrix( asMatrix, numpy.float )
- self.__FO["Direct"] = Operator( fromMatrix = __matrice, avoidingRedundancy = avoidRC )
- self.__FO["Tangent"] = Operator( fromMatrix = __matrice, avoidingRedundancy = avoidRC )
- self.__FO["Adjoint"] = Operator( fromMatrix = __matrice.T, avoidingRedundancy = avoidRC )
+ __matrice = numpy.matrix( __Matrix, numpy.float )
+ self.__FO["Direct"] = Operator( fromMatrix = __matrice, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
+ self.__FO["Tangent"] = Operator( fromMatrix = __matrice, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
+ self.__FO["Adjoint"] = Operator( fromMatrix = __matrice.T, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
del __matrice
else:
raise ValueError("Improperly defined observation operator, it requires at minima either a matrix, a Direct for approximate derivatives or a Tangent/Adjoint pair.")
#
if __appliedInX is not None:
self.__FO["AppliedInX"] = {}
- if type(__appliedInX) is not dict:
- raise ValueError("Error: observation operator defined by \"AppliedInX\" need a dictionary as argument.")
for key in list(__appliedInX.keys()):
if type( __appliedInX[key] ) is type( numpy.matrix([]) ):
# Pour le cas où l'on a une vraie matrice
self._name = str( name )
self._parameters = {"StoreSupplementaryCalculations":[]}
self.__required_parameters = {}
- self.StoredVariables = {}
+ self.__required_inputs = {"RequiredInputValues":{"mandatory":(), "optional":()}}
#
+ self.StoredVariables = {}
self.StoredVariables["CostFunctionJ"] = Persistence.OneScalar(name = "CostFunctionJ")
self.StoredVariables["CostFunctionJb"] = Persistence.OneScalar(name = "CostFunctionJb")
self.StoredVariables["CostFunctionJo"] = Persistence.OneScalar(name = "CostFunctionJo")
self.StoredVariables["GradientOfCostFunctionJb"] = Persistence.OneVector(name = "GradientOfCostFunctionJb")
self.StoredVariables["GradientOfCostFunctionJo"] = Persistence.OneVector(name = "GradientOfCostFunctionJo")
self.StoredVariables["CurrentState"] = Persistence.OneVector(name = "CurrentState")
+ self.StoredVariables["PredictedState"] = Persistence.OneVector(name = "PredictedState")
self.StoredVariables["Analysis"] = Persistence.OneVector(name = "Analysis")
self.StoredVariables["IndexOfOptimum"] = Persistence.OneIndex(name = "IndexOfOptimum")
self.StoredVariables["CurrentOptimum"] = Persistence.OneVector(name = "CurrentOptimum")
self.StoredVariables["SimulationQuantiles"] = Persistence.OneMatrix(name = "SimulationQuantiles")
self.StoredVariables["Residu"] = Persistence.OneScalar(name = "Residu")
- def _pre_run(self, Parameters ):
+ def _pre_run(self, Parameters, Xb=None, Y=None, R=None, B=None, Q=None ):
"Pré-calcul"
logging.debug("%s Lancement", self._name)
logging.debug("%s Taille mémoire utilisée de %.0f Mio", self._name, self._m.getUsedMemory("Mio"))
self.__setParameters(Parameters)
#
# Corrections et complements
+ def __test_vvalue(argument, variable, argname):
+ if argument is None:
+ if variable in self.__required_inputs["RequiredInputValues"]["mandatory"]:
+ raise ValueError("%s %s vector %s has to be properly defined!"%(self._name,argname,variable))
+ elif variable in self.__required_inputs["RequiredInputValues"]["optional"]:
+ logging.debug("%s %s vector %s is not set, but is optional."%(self._name,argname,variable))
+ else:
+ logging.debug("%s %s vector %s is not set, but is not required."%(self._name,argname,variable))
+ else:
+ logging.debug("%s %s vector %s is set, and its size is %i."%(self._name,argname,variable,numpy.array(argument).size))
+ return 0
+ __test_vvalue( Xb, "Xb", "Background or initial state" )
+ __test_vvalue( Y, "Y", "Observation" )
+ #
+ def __test_cvalue(argument, variable, argname):
+ if argument is None:
+ if variable in self.__required_inputs["RequiredInputValues"]["mandatory"]:
+ raise ValueError("%s %s error covariance matrix %s has to be properly defined!"%(self._name,argname,variable))
+ elif variable in self.__required_inputs["RequiredInputValues"]["optional"]:
+ logging.debug("%s %s error covariance matrix %s is not set, but is optional."%(self._name,argname,variable))
+ else:
+ logging.debug("%s %s error covariance matrix %s is not set, but is not required."%(self._name,argname,variable))
+ else:
+ logging.debug("%s %s error covariance matrix %s is set."%(self._name,argname,variable))
+ return 0
+ __test_cvalue( R, "R", "Observation" )
+ __test_cvalue( B, "B", "Background" )
+ __test_cvalue( Q, "Q", "Evolution" )
+ #
if ("Bounds" in self._parameters) and isinstance(self._parameters["Bounds"], (list, tuple)) and (len(self._parameters["Bounds"]) > 0):
logging.debug("%s Prise en compte des bornes effectuee"%(self._name,))
else:
logging.debug("%s Terminé", self._name)
return 0
+ def _toStore(self, key):
+ "True if in StoreSupplementaryCalculations, else False"
+ return key in self._parameters["StoreSupplementaryCalculations"]
+
def get(self, key=None):
"""
Renvoie l'une des variables stockées identifiée par la clé, ou le
raise ValueError("The value \"%s\" of the parameter named \"%s\" is not allowed, it has to be in the list %s."%( __val, name,listval))
return __val
+ def requireInputArguments(self, mandatory=(), optional=()):
+ """
+ Permet d'imposer des arguments requises en entrée
+ """
+ self.__required_inputs["RequiredInputValues"]["mandatory"] = tuple( mandatory )
+ self.__required_inputs["RequiredInputValues"]["optional"] = tuple( optional )
+
def __setParameters(self, fromDico={}):
"""
Permet de stocker les paramètres reçus dans le dictionnaire interne.
self._parameters[k] = self.setParameterValue(k)
logging.debug("%s %s : %s", self._name, self.__required_parameters[k]["message"], self._parameters[k])
-# ==============================================================================
-class Diagnostic(object):
- """
- Classe générale d'interface de type diagnostic
-
- Ce template s'utilise de la manière suivante : il sert de classe "patron" en
- même temps que l'une des classes de persistance, comme "OneScalar" par
- exemple.
-
- Une classe élémentaire de diagnostic doit implémenter ses deux méthodes, la
- méthode "_formula" pour écrire explicitement et proprement la formule pour
- l'écriture mathématique du calcul du diagnostic (méthode interne non
- publique), et "calculate" pour activer la précédente tout en ayant vérifié
- et préparé les données, et pour stocker les résultats à chaque pas (méthode
- externe d'activation).
- """
- def __init__(self, name = "", parameters = {}):
- "Initialisation"
- self.name = str(name)
- self.parameters = dict( parameters )
-
- def _formula(self, *args):
- """
- Doit implémenter l'opération élémentaire de diagnostic sous sa forme
- mathématique la plus naturelle possible.
- """
- raise NotImplementedError("Diagnostic mathematical formula has not been implemented!")
-
- def calculate(self, *args):
- """
- Active la formule de calcul avec les arguments correctement rangés
- """
- raise NotImplementedError("Diagnostic activation method has not been implemented!")
-
-# ==============================================================================
-class DiagnosticAndParameters(object):
- """
- Classe générale d'interface d'interface de type diagnostic
- """
- def __init__(self,
- name = "GenericDiagnostic",
- asDiagnostic = None,
- asIdentifier = None,
- asDict = None,
- asScript = None,
- asUnit = None,
- asBaseType = None,
- asExistingDiags = None,
- ):
- """
- """
- self.__name = str(name)
- self.__D = None
- self.__I = None
- self.__P = {}
- self.__U = ""
- self.__B = None
- self.__E = tuple(asExistingDiags)
- self.__TheDiag = None
- #
- if asScript is not None:
- __Diag = ImportFromScript(asScript).getvalue( "Diagnostic" )
- __Iden = ImportFromScript(asScript).getvalue( "Identifier" )
- __Dict = ImportFromScript(asScript).getvalue( self.__name, "Parameters" )
- __Unit = ImportFromScript(asScript).getvalue( "Unit" )
- __Base = ImportFromScript(asScript).getvalue( "BaseType" )
- else:
- __Diag = asDiagnostic
- __Iden = asIdentifier
- __Dict = asDict
- __Unit = asUnit
- __Base = asBaseType
- #
- if __Diag is not None:
- self.__D = str(__Diag)
- if __Iden is not None:
- self.__I = str(__Iden)
- else:
- self.__I = str(__Diag)
- if __Dict is not None:
- self.__P.update( dict(__Dict) )
- if __Unit is None or __Unit == "None":
- self.__U = ""
- if __Base is None or __Base == "None":
- self.__B = None
- #
- self.__setDiagnostic( self.__D, self.__I, self.__U, self.__B, self.__P, self.__E )
-
- def get(self):
- "Renvoie l'objet"
- return self.__TheDiag
-
- def __setDiagnostic(self, __choice = None, __name = "", __unit = "", __basetype = None, __parameters = {}, __existings = () ):
- """
- Permet de sélectionner un diagnostic a effectuer
- """
- if __choice is None:
- raise ValueError("Error: diagnostic choice has to be given")
- __daDirectory = "daDiagnostics"
- #
- # Recherche explicitement le fichier complet
- # ------------------------------------------
- __module_path = None
- for directory in sys.path:
- if os.path.isfile(os.path.join(directory, __daDirectory, str(__choice)+'.py')):
- __module_path = os.path.abspath(os.path.join(directory, __daDirectory))
- if __module_path is None:
- raise ImportError("No diagnostic module named \"%s\" was found in a \"%s\" subdirectory\n The search path is %s"%(__choice, __daDirectory, sys.path))
- #
- # Importe le fichier complet comme un module
- # ------------------------------------------
- try:
- __sys_path_tmp = sys.path ; sys.path.insert(0,__module_path)
- self.__diagnosticFile = __import__(str(__choice), globals(), locals(), [])
- sys.path = __sys_path_tmp ; del __sys_path_tmp
- except ImportError as e:
- raise ImportError("The module named \"%s\" was found, but is incorrect at the import stage.\n The import error message is: %s"%(__choice,e))
- #
- # Instancie un objet du type élémentaire du fichier
- # -------------------------------------------------
- if __name in __existings:
- raise ValueError("A default input with the same name \"%s\" already exists."%str(__name))
- else:
- self.__TheDiag = self.__diagnosticFile.ElementaryDiagnostic(
- name = __name,
- unit = __unit,
- basetype = __basetype,
- parameters = __parameters )
- return 0
-
# ==============================================================================
class AlgorithmAndParameters(object):
"""
#
self.updateParameters( asDict, asScript )
#
- if asScript is not None:
+ if asAlgorithm is None and asScript is not None:
__Algo = ImportFromScript(asScript).getvalue( "Algorithm" )
else:
__Algo = asAlgorithm
asScript = None,
):
"Mise a jour des parametres"
- if asScript is not None:
+ if asDict is None and asScript is not None:
__Dict = ImportFromScript(asScript).getvalue( self.__name, "Parameters" )
else:
__Dict = asDict
Operator.CM.clearCache()
#
if not isinstance(asDictAO, dict):
- raise ValueError("The objects for algorithm calculation has to be given as a dictionnary, and is not")
+ raise ValueError("The objects for algorithm calculation have to be given together as a dictionnary, and they are not")
if hasattr(asDictAO["Background"],"getO"): self.__Xb = asDictAO["Background"].getO()
elif hasattr(asDictAO["CheckingPoint"],"getO"): self.__Xb = asDictAO["CheckingPoint"].getO()
else: self.__Xb = None
if hasattr(asDictAO["ControlInput"],"getO"): self.__U = asDictAO["ControlInput"].getO()
else: self.__U = asDictAO["ControlInput"]
if hasattr(asDictAO["ObservationOperator"],"getO"): self.__HO = asDictAO["ObservationOperator"].getO()
- else: self.__HO = asDictAO["ObservationOperator"]
+ else: self.__HO = asDictAO["ObservationOperator"]
if hasattr(asDictAO["EvolutionModel"],"getO"): self.__EM = asDictAO["EvolutionModel"].getO()
else: self.__EM = asDictAO["EvolutionModel"]
if hasattr(asDictAO["ControlModel"],"getO"): self.__CM = asDictAO["ControlModel"].getO()
def executeYACSScheme(self, FileName=None):
"Permet de lancer le calcul d'assimilation"
if FileName is None or not os.path.exists(FileName):
- raise ValueError("a existing DIC Python file name has to be given for YACS execution.\n")
- if not os.environ.has_key("ADAO_ROOT_DIR"):
- raise ImportError("Unable to get ADAO_ROOT_DIR environnement variable. Please launch SALOME to add ADAO_ROOT_DIR to your environnement.\n")
- #
- __converterExe = os.path.join(os.environ["ADAO_ROOT_DIR"], "bin/salome", "AdaoYacsSchemaCreator.py")
- __inputFile = os.path.abspath(FileName)
- __outputFile = __inputFile[:__inputFile.rfind(".")] + '.xml'
- #
- __args = ["python", __converterExe, __inputFile, __outputFile]
- import subprocess
- __p = subprocess.Popen(__args)
- (__stdoutdata, __stderrdata) = __p.communicate()
- if not os.path.exists(__outputFile):
- __msg = "An error occured during the execution of the ADAO YACS Schema\n"
- __msg += "Creator applied on the input file:\n"
- __msg += " %s\n"%__outputFile
- __msg += "If SALOME GUI is launched by command line, see errors\n"
- __msg += "details in your terminal.\n"
- raise ValueError(__msg)
- #
+ raise ValueError("a YACS file name has to be given for YACS execution.\n")
+ else:
+ __file = os.path.abspath(FileName)
+ logging.debug("The YACS file name is \"%s\"."%__file)
+ if not PlatformInfo.has_salome or \
+ not PlatformInfo.has_yacs or \
+ not PlatformInfo.has_adao:
+ raise ImportError("\n\n"+\
+ "Unable to get SALOME, YACS or ADAO environnement variables.\n"+\
+ "Please load the right environnement before trying to use it.\n")
+ #
+ import pilot
+ import SALOMERuntime
+ import loader
+ SALOMERuntime.RuntimeSALOME_setRuntime()
+
+ r = pilot.getRuntime()
+ xmlLoader = loader.YACSLoader()
+ xmlLoader.registerProcCataLoader()
try:
- import pilot
- import SALOMERuntime
- import loader
- SALOMERuntime.RuntimeSALOME_setRuntime()
-
- r = pilot.getRuntime()
- xmlLoader = loader.YACSLoader()
- xmlLoader.registerProcCataLoader()
- try:
- catalogAd = r.loadCatalog("proc", __outputFile)
- except:
- pass
+ catalogAd = r.loadCatalog("proc", __file)
r.addCatalog(catalogAd)
-
- try:
- p = xmlLoader.load(__outputFile)
- except IOError as ex:
- print("IO exception: %s"%(ex,))
-
- logger = p.getLogger("parser")
- if not logger.isEmpty():
- print("The imported file has errors :")
- print(logger.getStr())
-
- if not p.isValid():
- print("Le schéma n'est pas valide et ne peut pas être exécuté")
- print(p.getErrorReport())
-
- info=pilot.LinkInfo(pilot.LinkInfo.ALL_DONT_STOP)
- p.checkConsistency(info)
- if info.areWarningsOrErrors():
- print("Le schéma n'est pas cohérent et ne peut pas être exécuté")
- print(info.getGlobalRepr())
-
- e = pilot.ExecutorSwig()
- e.RunW(p)
- if p.getEffectiveState() != pilot.DONE:
- print(p.getErrorReport())
except:
- raise ValueError("execution error of YACS scheme")
+ pass
+
+ try:
+ p = xmlLoader.load(__file)
+ except IOError as ex:
+ print("The YACS XML schema file can not be loaded: %s"%(ex,))
+
+ logger = p.getLogger("parser")
+ if not logger.isEmpty():
+ print("The imported YACS XML schema has errors on parsing:")
+ print(logger.getStr())
+
+ if not p.isValid():
+ print("The YACS XML schema is not valid and will not be executed:")
+ print(p.getErrorReport())
+
+ info=pilot.LinkInfo(pilot.LinkInfo.ALL_DONT_STOP)
+ p.checkConsistency(info)
+ if info.areWarningsOrErrors():
+ print("The YACS XML schema is not coherent and will not be executed:")
+ print(info.getGlobalRepr())
+
+ e = pilot.ExecutorSwig()
+ e.RunW(p)
+ if p.getEffectiveState() != pilot.DONE:
+ print(p.getErrorReport())
#
return 0
"""
Permet de sélectionner l'algorithme à utiliser pour mener à bien l'étude
d'assimilation. L'argument est un champ caractère se rapportant au nom
- d'un fichier contenu dans "../daAlgorithms" et réalisant l'opération
- d'assimilation sur les arguments fixes.
+ d'un algorithme réalisant l'opération sur les arguments fixes.
"""
if choice is None:
raise ValueError("Error: algorithm choice has to be given")
if os.path.isfile(os.path.join(directory, daDirectory, str(choice)+'.py')):
module_path = os.path.abspath(os.path.join(directory, daDirectory))
if module_path is None:
- raise ImportError("No algorithm module named \"%s\" was found in a \"%s\" subdirectory\n The search path is %s"%(choice, daDirectory, sys.path))
+ raise ImportError("No algorithm module named \"%s\" has been found in the search path.\n The search path is %s"%(choice, sys.path))
#
# Importe le fichier complet comme un module
# ------------------------------------------
try:
sys_path_tmp = sys.path ; sys.path.insert(0,module_path)
self.__algorithmFile = __import__(str(choice), globals(), locals(), [])
+ if not hasattr(self.__algorithmFile, "ElementaryAlgorithm"):
+ raise ImportError("this module does not define a valid elementary algorithm.")
self.__algorithmName = str(choice)
sys.path = sys_path_tmp ; del sys_path_tmp
except ImportError as e:
if not( min(__EM_shape) == max(__EM_shape) ):
raise ValueError("Shape characteristic of evolution operator (EM) is incorrect: \"%s\"."%(__EM_shape,))
#
- if len(self.__HO) > 0 and not(type(self.__HO) is type({})) and not( __HO_shape[1] == max(__Xb_shape) ):
+ if len(self.__HO) > 0 and not isinstance(self.__HO, dict) and not( __HO_shape[1] == max(__Xb_shape) ):
raise ValueError("Shape characteristic of observation operator (H) \"%s\" and state (X) \"%s\" are incompatible."%(__HO_shape,__Xb_shape))
- if len(self.__HO) > 0 and not(type(self.__HO) is type({})) and not( __HO_shape[0] == max(__Y_shape) ):
+ if len(self.__HO) > 0 and not isinstance(self.__HO, dict) and not( __HO_shape[0] == max(__Y_shape) ):
raise ValueError("Shape characteristic of observation operator (H) \"%s\" and observation (Y) \"%s\" are incompatible."%(__HO_shape,__Y_shape))
- if len(self.__HO) > 0 and not(type(self.__HO) is type({})) and len(self.__B) > 0 and not( __HO_shape[1] == __B_shape[0] ):
+ if len(self.__HO) > 0 and not isinstance(self.__HO, dict) and len(self.__B) > 0 and not( __HO_shape[1] == __B_shape[0] ):
raise ValueError("Shape characteristic of observation operator (H) \"%s\" and a priori errors covariance matrix (B) \"%s\" are incompatible."%(__HO_shape,__B_shape))
- if len(self.__HO) > 0 and not(type(self.__HO) is type({})) and len(self.__R) > 0 and not( __HO_shape[0] == __R_shape[1] ):
+ if len(self.__HO) > 0 and not isinstance(self.__HO, dict) and len(self.__R) > 0 and not( __HO_shape[0] == __R_shape[1] ):
raise ValueError("Shape characteristic of observation operator (H) \"%s\" and observation errors covariance matrix (R) \"%s\" are incompatible."%(__HO_shape,__R_shape))
#
if self.__B is not None and len(self.__B) > 0 and not( __B_shape[1] == max(__Xb_shape) ):
if self.__R is not None and len(self.__R) > 0 and not( __R_shape[1] == max(__Y_shape) ):
raise ValueError("Shape characteristic of observation errors covariance matrix (R) \"%s\" and observation (Y) \"%s\" are incompatible."%(__R_shape,__Y_shape))
#
- if self.__EM is not None and len(self.__EM) > 0 and not(type(self.__EM) is type({})) and not( __EM_shape[1] == max(__Xb_shape) ):
+ if self.__EM is not None and len(self.__EM) > 0 and not isinstance(self.__EM, dict) and not( __EM_shape[1] == max(__Xb_shape) ):
raise ValueError("Shape characteristic of evolution model (EM) \"%s\" and state (X) \"%s\" are incompatible."%(__EM_shape,__Xb_shape))
#
- if self.__CM is not None and len(self.__CM) > 0 and not(type(self.__CM) is type({})) and not( __CM_shape[1] == max(__U_shape) ):
+ if self.__CM is not None and len(self.__CM) > 0 and not isinstance(self.__CM, dict) and not( __CM_shape[1] == max(__U_shape) ):
raise ValueError("Shape characteristic of control model (CM) \"%s\" and control (U) \"%s\" are incompatible."%(__CM_shape,__U_shape))
#
if ("Bounds" in self.__P) \
#
return 1
+# ==============================================================================
+class RegulationAndParameters(object):
+ """
+ Classe générale d'interface d'action pour la régulation et ses paramètres
+ """
+ def __init__(self,
+ name = "GenericRegulation",
+ asAlgorithm = None,
+ asDict = None,
+ asScript = None,
+ ):
+ """
+ """
+ self.__name = str(name)
+ self.__P = {}
+ #
+ if asAlgorithm is None and asScript is not None:
+ __Algo = ImportFromScript(asScript).getvalue( "Algorithm" )
+ else:
+ __Algo = asAlgorithm
+ #
+ if asDict is None and asScript is not None:
+ __Dict = ImportFromScript(asScript).getvalue( self.__name, "Parameters" )
+ else:
+ __Dict = asDict
+ #
+ if __Dict is not None:
+ self.__P.update( dict(__Dict) )
+ #
+ if __Algo is not None:
+ self.__P.update( {"Algorithm":self.__A} )
+
+ def get(self, key = None):
+ "Vérifie l'existence d'une clé de variable ou de paramètres"
+ if key in self.__P:
+ return self.__P[key]
+ else:
+ return self.__P
+
# ==============================================================================
class DataObserver(object):
"""
asVector = None,
asPersistentVector = None,
asScript = None,
+ asDataFile = None,
+ colNames = None,
+ colMajor = False,
scheduledBy = None,
toBeChecked = False,
):
nommée "name", la variable est de type "asVector" (par défaut) ou
"asPersistentVector" selon que l'une de ces variables est placée à
"True".
+ - asDataFile : si un ou plusieurs fichiers valides sont donnés
+ contenant des valeurs en colonnes, elles-mêmes nommées "colNames"
+ (s'il n'y a pas de nom de colonne indiquée, on cherche une colonne
+ nommée "name"), on récupère les colonnes et on les range ligne après
+ ligne (colMajor=False) ou colonne après colonne (colMajor=True). La
+ variable résultante est de type "asVector" (par défaut) ou
+ "asPersistentVector" selon que l'une de ces variables est placée à
+ "True".
"""
self.__name = str(name)
self.__check = bool(toBeChecked)
__Series = ImportFromScript(asScript).getvalue( self.__name )
else:
__Vector = ImportFromScript(asScript).getvalue( self.__name )
+ elif asDataFile is not None:
+ __Vector, __Series = None, None
+ if asPersistentVector:
+ if colNames is not None:
+ __Series = ImportFromFile(asDataFile).getvalue( colNames )[1]
+ else:
+ __Series = ImportFromFile(asDataFile).getvalue( [self.__name,] )[1]
+ if bool(colMajor) and not ImportFromFile(asDataFile).getformat() == "application/numpy.npz":
+ __Series = numpy.transpose(__Series)
+ elif not bool(colMajor) and ImportFromFile(asDataFile).getformat() == "application/numpy.npz":
+ __Series = numpy.transpose(__Series)
+ else:
+ if colNames is not None:
+ __Vector = ImportFromFile(asDataFile).getvalue( colNames )[1]
+ else:
+ __Vector = ImportFromFile(asDataFile).getvalue( [self.__name,] )[1]
+ if bool(colMajor):
+ __Vector = numpy.ravel(__Vector, order = "F")
+ else:
+ __Vector = numpy.ravel(__Vector, order = "C")
else:
__Vector, __Series = asVector, asPersistentVector
#
self.size = self.__V.size
elif __Series is not None:
self.__is_series = True
- if type(__Series) in (tuple, list, numpy.ndarray, numpy.matrix):
+ if isinstance(__Series, (tuple, list, numpy.ndarray, numpy.matrix, str)):
self.__V = Persistence.OneVector(self.__name, basetype=numpy.matrix)
+ if isinstance(__Series, str): __Series = eval(__Series)
for member in __Series:
self.__V.store( numpy.matrix( numpy.asmatrix(member).A1, numpy.float ).T )
- import sys ; sys.stdout.flush()
else:
self.__V = __Series
- if type(self.__V.shape) in (tuple, list):
+ if isinstance(self.__V.shape, (tuple, list)):
self.shape = self.__V.shape
else:
self.shape = self.__V.shape()
def __validate(self):
"Validation"
+ if self.__C is None:
+ raise UnboundLocalError("%s covariance matrix value has not been set!"%(self.__name,))
if self.ismatrix() and min(self.shape) != max(self.shape):
raise ValueError("The given matrix for %s is not a square one, its shape is %s. Please check your matrix input."%(self.__name,self.shape))
if self.isobject() and min(self.shape) != max(self.shape):
def __mul__(self, other):
"x.__mul__(y) <==> x*y"
- if self.ismatrix() and isinstance(other,numpy.matrix):
+ if self.ismatrix() and isinstance(other, (int, numpy.matrix, float)):
return self.__C * other
- elif self.ismatrix() and (isinstance(other,numpy.ndarray) \
- or isinstance(other,list) \
- or isinstance(other,tuple)):
+ elif self.ismatrix() and isinstance(other, (list, numpy.ndarray, tuple)):
if numpy.ravel(other).size == self.shape[1]: # Vecteur
return self.__C * numpy.asmatrix(numpy.ravel(other)).T
elif numpy.asmatrix(other).shape[0] == self.shape[1]: # Matrice
return self.__C * numpy.asmatrix(other)
else:
raise ValueError("operands could not be broadcast together with shapes %s %s in %s matrix"%(self.shape,numpy.asmatrix(other).shape,self.__name))
- elif self.isvector() and (isinstance(other,numpy.matrix) \
- or isinstance(other,numpy.ndarray) \
- or isinstance(other,list) \
- or isinstance(other,tuple)):
+ elif self.isvector() and isinstance(other, (list, numpy.matrix, numpy.ndarray, tuple)):
if numpy.ravel(other).size == self.shape[1]: # Vecteur
return numpy.asmatrix(self.__C * numpy.ravel(other)).T
elif numpy.asmatrix(other).shape[0] == self.shape[1]: # Matrice
raise ValueError("operands could not be broadcast together with shapes %s %s in %s matrix"%(self.shape,numpy.ravel(other).shape,self.__name))
elif self.isscalar() and isinstance(other,numpy.matrix):
return self.__C * other
- elif self.isscalar() and (isinstance(other,numpy.ndarray) \
- or isinstance(other,list) \
- or isinstance(other,tuple)):
+ elif self.isscalar() and isinstance(other, (list, numpy.ndarray, tuple)):
if len(numpy.asarray(other).shape) == 1 or numpy.asarray(other).shape[1] == 1 or numpy.asarray(other).shape[0] == 1:
return self.__C * numpy.asmatrix(numpy.ravel(other)).T
else:
def __rmul__(self, other):
"x.__rmul__(y) <==> y*x"
- if self.ismatrix() and isinstance(other,numpy.matrix):
+ if self.ismatrix() and isinstance(other, (int, numpy.matrix, float)):
return other * self.__C
elif self.isvector() and isinstance(other,numpy.matrix):
if numpy.ravel(other).size == self.shape[0]: # Vecteur
elif numpy.asmatrix(other).shape[1] == self.shape[0]: # Matrice
return numpy.asmatrix(numpy.array(other) * self.__C)
else:
- raise ValueError("operands could not be broadcast together with shapes %s %s in %s matrix"%(self.shape,numpy.ravel(other).shape,self.__name))
+ raise ValueError("operands could not be broadcast together with shapes %s %s in %s matrix"%(numpy.ravel(other).shape,self.shape,self.__name))
elif self.isscalar() and isinstance(other,numpy.matrix):
return other * self.__C
elif self.isobject():
return self.func
# ==============================================================================
-class ImportFromScript(object):
+class CaseLogger(object):
"""
- Obtention d'une variable nommee depuis un fichier script importe
+ Conservation des commandes de creation d'un cas
"""
- def __init__(self, __filename=None):
- "Verifie l'existence et importe le script"
- self.__filename = __filename.rstrip(".py")
- if self.__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(self.__filename)+".py"):
- raise ValueError("The file containing the variable to be imported doesn't seem to exist. The given file name is:\n \"%s\""%self.__filename)
- self.__scriptfile = __import__(self.__filename, globals(), locals(), [])
- self.__scriptstring = open(self.__filename+".py",'r').read()
- def getvalue(self, __varname=None, __synonym=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):
- if __synonym is None:
- raise ValueError("The imported script file \"%s\" doesn't contain the specified variable \"%s\"."%(str(self.__filename)+".py",__varname))
- elif not hasattr(self.__scriptfile, __synonym):
- raise ValueError("The imported script file \"%s\" doesn't contain the specified variable \"%s\"."%(str(self.__filename)+".py",__synonym))
- else:
- return getattr(self.__scriptfile, __synonym)
+ def __init__(self, __name="", __objname="case", __addViewers=None, __addLoaders=None):
+ self.__name = str(__name)
+ self.__objname = str(__objname)
+ self.__logSerie = []
+ self.__switchoff = False
+ self.__viewers = {
+ "TUI" :Interfaces._TUIViewer,
+ "SCD" :Interfaces._SCDViewer,
+ "YACS":Interfaces._YACSViewer,
+ }
+ self.__loaders = {
+ "TUI" :Interfaces._TUIViewer,
+ "COM" :Interfaces._COMViewer,
+ }
+ if __addViewers is not None:
+ self.__viewers.update(dict(__addViewers))
+ if __addLoaders is not None:
+ self.__loaders.update(dict(__addLoaders))
+
+ def register(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
+ "Enregistrement d'une commande individuelle"
+ if __command is not None and __keys is not None and __local is not None and not self.__switchoff:
+ if "self" in __keys: __keys.remove("self")
+ self.__logSerie.append( (str(__command), __keys, __local, __pre, __switchoff) )
+ if __switchoff:
+ self.__switchoff = True
+ if not __switchoff:
+ self.__switchoff = False
+
+ def dump(self, __filename=None, __format="TUI", __upa=""):
+ "Restitution normalisée des commandes"
+ if __format in self.__viewers:
+ __formater = self.__viewers[__format](self.__name, self.__objname, self.__logSerie)
+ else:
+ raise ValueError("Dumping as \"%s\" is not available"%__format)
+ return __formater.dump(__filename, __upa)
+
+ def load(self, __filename=None, __content=None, __object=None, __format="TUI"):
+ "Chargement normalisé des commandes"
+ if __format in self.__loaders:
+ __formater = self.__loaders[__format]()
else:
- return getattr(self.__scriptfile, __varname)
- def getstring(self):
- "Renvoie le script complet"
- return self.__scriptstring
+ raise ValueError("Loading as \"%s\" is not available"%__format)
+ return __formater.load(__filename, __content, __object)
+
+# ==============================================================================
+def MultiFonction( __xserie, _sFunction = lambda x: x ):
+ """
+ Pour une liste ordonnée de vecteurs en entrée, renvoie en sortie la liste
+ correspondante de valeurs de la fonction en argument
+ """
+ if not PlatformInfo.isIterable( __xserie ):
+ raise ValueError("MultiFonction not iterable unkown input type: %s"%(type(__xserie),))
+ #
+ __multiHX = []
+ for __xvalue in __xserie:
+ __multiHX.append( _sFunction( __xvalue ) )
+ #
+ return __multiHX
# ==============================================================================
def CostFunction3D(_x,