# -*- coding: utf-8 -*-
#
-# Copyright (C) 2008-2018 EDF R&D
+# Copyright (C) 2008-2019 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
import copy
import numpy
from functools import partial
-from daCore import Persistence
-from daCore import PlatformInfo
-from daCore import Interfaces
+from daCore import Persistence, PlatformInfo, 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, inputAsMultiFunction = False):
+ def __init__(self,
+ fromMethod = None,
+ fromMatrix = None,
+ avoidingRedundancy = True,
+ inputAsMultiFunction = False,
+ enableMultiProcess = False,
+ extraArguments = None,
+ ):
"""
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
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
+ - avoidingRedundancy : booléen évitant (ou pas) les calculs redondants
+ - inputAsMultiFunction : booléen indiquant une fonction explicitement
+ définie (ou pas) en multi-fonction
+ - extraArguments : arguments supplémentaires passés à la fonction de
+ base et ses dérivées (tuple ou dictionnaire)
"""
self.__NbCallsAsMatrix, self.__NbCallsAsMethod, self.__NbCallsOfCached = 0, 0, 0
- self.__AvoidRC = bool( avoidingRedundancy )
+ self.__AvoidRC = bool( avoidingRedundancy )
self.__inputAsMF = bool( inputAsMultiFunction )
+ self.__mpEnabled = bool( enableMultiProcess )
+ self.__extraArgs = extraArguments
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.__Method = partial( MultiFonction, _sFunction=fromMethod, _mpEnabled=self.__mpEnabled)
self.__Matrix = None
self.__Type = "Method"
elif fromMatrix is not None:
HxValue.append( _hv )
#
if len(_xserie)>0 and self.__Matrix is None:
- _hserie = self.__Method( _xserie ) # Calcul MF
+ if self.__extraArgs is None:
+ _hserie = self.__Method( _xserie ) # Calcul MF
+ else:
+ _hserie = self.__Method( _xserie, self.__extraArgs ) # 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:
if argsAsSerie: return HxValue
else: return HxValue[-1]
- def appliedControledFormTo(self, paires, argsAsSerie = False ):
+ def appliedControledFormTo(self, paires, argsAsSerie = False):
"""
Permet de restituer le résultat de l'application de l'opérateur à des
paires (xValue, uValue). Cette méthode se contente d'appliquer, son
else:
_xuValue.append( _xValue )
self.__addOneMethodCall( len(_xuValue) )
- HxValue = self.__Method( _xuValue ) # Calcul MF
+ if self.__extraArgs is None:
+ HxValue = self.__Method( _xuValue ) # Calcul MF
+ else:
+ HxValue = self.__Method( _xuValue, self.__extraArgs ) # Calcul MF
#
if argsAsSerie: return HxValue
else: return HxValue[-1]
- def appliedInXTo(self, paires, argsAsSerie = False ):
+ def appliedInXTo(self, paires, argsAsSerie = False):
"""
Permet de restituer le résultat de l'application de l'opérateur à une
série d'arguments xValue, sachant que l'opérateur est valable en
HxValue.append( self.__Matrix * _xValue )
else:
self.__addOneMethodCall( len(_nxValue) )
- HxValue = self.__Method( _nxValue ) # Calcul MF
+ if self.__extraArgs is None:
+ HxValue = self.__Method( _nxValue ) # Calcul MF
+ else:
+ HxValue = self.__Method( _nxValue, self.__extraArgs ) # Calcul MF
#
if argsAsSerie: return HxValue
else: return HxValue[-1]
asScript = None, # 1 or 3 Fonction(s) by script
asDict = None, # Parameters
appliedInX = None,
+ extraArguments = None,
avoidRC = True,
inputAsMF = False,# Fonction(s) as Multi-Functions
scheduledBy = None,
toBeChecked = False,
):
""
- self.__name = str(name)
- self.__check = bool(toBeChecked)
+ self.__name = str(name)
+ self.__check = bool(toBeChecked)
+ self.__extraArgs = extraArguments
#
- self.__FO = {}
+ self.__FO = {}
#
__Parameters = {}
if (asDict is not None) and isinstance(asDict, dict):
__Parameters.update( asDict )
- if "DifferentialIncrement" in asDict:
- __Parameters["withIncrement"] = asDict["DifferentialIncrement"]
- if "CenteredFiniteDifference" in asDict:
- __Parameters["withCenteredDF"] = asDict["CenteredFiniteDifference"]
- if "EnableMultiProcessing" in asDict:
- __Parameters["withmpEnabled"] = asDict["EnableMultiProcessing"]
- if "NumberOfProcesses" in asDict:
- __Parameters["withmpWorkers"] = asDict["NumberOfProcesses"]
+ # Priorité à EnableMultiProcessingInDerivatives=True
+ if "EnableMultiProcessing" in __Parameters and __Parameters["EnableMultiProcessing"]:
+ __Parameters["EnableMultiProcessingInDerivatives"] = True
+ __Parameters["EnableMultiProcessingInEvaluation"] = False
+ if "EnableMultiProcessingInDerivatives" not in __Parameters:
+ __Parameters["EnableMultiProcessingInDerivatives"] = False
+ if __Parameters["EnableMultiProcessingInDerivatives"]:
+ __Parameters["EnableMultiProcessingInEvaluation"] = False
+ if "EnableMultiProcessingInEvaluation" not in __Parameters:
+ __Parameters["EnableMultiProcessingInEvaluation"] = False
+ if "withIncrement" in __Parameters: # Temporaire
+ __Parameters["DifferentialIncrement"] = __Parameters["withIncrement"]
#
if asScript is not None:
__Matrix, __Function = None, None
if asMatrix:
- __Matrix = ImportFromScript(asScript).getvalue( self.__name )
+ __Matrix = Interfaces.ImportFromScript(asScript).getvalue( self.__name )
elif asOneFunction:
- __Function = { "Direct":ImportFromScript(asScript).getvalue( "DirectOperator" ) }
+ __Function = { "Direct":Interfaces.ImportFromScript(asScript).getvalue( "DirectOperator" ) }
__Function.update({"useApproximatedDerivatives":True})
__Function.update(__Parameters)
elif asThreeFunctions:
__Function = {
- "Direct" :ImportFromScript(asScript).getvalue( "DirectOperator" ),
- "Tangent":ImportFromScript(asScript).getvalue( "TangentOperator" ),
- "Adjoint":ImportFromScript(asScript).getvalue( "AdjointOperator" ),
+ "Direct" :Interfaces.ImportFromScript(asScript).getvalue( "DirectOperator" ),
+ "Tangent":Interfaces.ImportFromScript(asScript).getvalue( "TangentOperator" ),
+ "Adjoint":Interfaces.ImportFromScript(asScript).getvalue( "AdjointOperator" ),
}
__Function.update(__Parameters)
else:
if isinstance(__Function, dict) and \
("useApproximatedDerivatives" in __Function) and bool(__Function["useApproximatedDerivatives"]) and \
("Direct" in __Function) and (__Function["Direct"] is not None):
- if "withCenteredDF" not in __Function: __Function["withCenteredDF"] = False
- if "withIncrement" not in __Function: __Function["withIncrement"] = 0.01
- if "withdX" not in __Function: __Function["withdX"] = None
- if "withAvoidingRedundancy" not in __Function: __Function["withAvoidingRedundancy"] = True
- if "withToleranceInRedundancy" not in __Function: __Function["withToleranceInRedundancy"] = 1.e-18
- 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(
+ if "CenteredFiniteDifference" not in __Function: __Function["CenteredFiniteDifference"] = False
+ if "DifferentialIncrement" not in __Function: __Function["DifferentialIncrement"] = 0.01
+ if "withdX" not in __Function: __Function["withdX"] = None
+ if "withAvoidingRedundancy" not in __Function: __Function["withAvoidingRedundancy"] = avoidRC
+ if "withToleranceInRedundancy" not in __Function: __Function["withToleranceInRedundancy"] = 1.e-18
+ if "withLenghtOfRedundancy" not in __Function: __Function["withLenghtOfRedundancy"] = -1
+ if "NumberOfProcesses" not in __Function: __Function["NumberOfProcesses"] = None
+ if "withmfEnabled" not in __Function: __Function["withmfEnabled"] = inputAsMF
+ from daCore import NumericObjects
+ FDA = NumericObjects.FDApproximation(
Function = __Function["Direct"],
- centeredDF = __Function["withCenteredDF"],
- increment = __Function["withIncrement"],
+ centeredDF = __Function["CenteredFiniteDifference"],
+ increment = __Function["DifferentialIncrement"],
dX = __Function["withdX"],
avoidingRedundancy = __Function["withAvoidingRedundancy"],
toleranceInRedundancy = __Function["withToleranceInRedundancy"],
lenghtOfRedundancy = __Function["withLenghtOfRedundancy"],
- mpEnabled = __Function["withmpEnabled"],
- mpWorkers = __Function["withmpWorkers"],
+ mpEnabled = __Function["EnableMultiProcessingInDerivatives"],
+ mpWorkers = __Function["NumberOfProcesses"],
mfEnabled = __Function["withmfEnabled"],
)
- 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 )
+ self.__FO["Direct"] = Operator( fromMethod = FDA.DirectOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs, enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] )
+ self.__FO["Tangent"] = Operator( fromMethod = FDA.TangentOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
+ self.__FO["Adjoint"] = Operator( fromMethod = FDA.AdjointOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
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, inputAsMultiFunction = inputAsMF )
- self.__FO["Tangent"] = Operator( fromMethod = __Function["Tangent"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
- self.__FO["Adjoint"] = Operator( fromMethod = __Function["Adjoint"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
+ self.__FO["Direct"] = Operator( fromMethod = __Function["Direct"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs, enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] )
+ self.__FO["Tangent"] = Operator( fromMethod = __Function["Tangent"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
+ self.__FO["Adjoint"] = Operator( fromMethod = __Function["Adjoint"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
elif asMatrix is not None:
__matrice = numpy.matrix( __Matrix, numpy.float )
- self.__FO["Direct"] = Operator( fromMatrix = __matrice, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
+ self.__FO["Direct"] = Operator( fromMatrix = __matrice, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] )
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.")
+ raise ValueError("The %s object is improperly defined or undefined, it requires at minima either a matrix, a Direct operator for approximate derivatives or a Tangent/Adjoint operators pair. Please check your operator input."%self.__name)
#
if __appliedInX is not None:
self.__FO["AppliedInX"] = {}
def __repr__(self):
"x.__repr__() <==> repr(x)"
- return repr(self.__V)
+ return repr(self.__FO)
def __str__(self):
"x.__str__() <==> str(x)"
- return str(self.__V)
+ return str(self.__FO)
# ==============================================================================
class Algorithm(object):
interne à l'objet, mais auquel on accède par la méthode "get".
Les variables prévues sont :
- - CostFunctionJ : fonction-cout globale, somme des deux parties suivantes
- - CostFunctionJb : partie ébauche ou background de la fonction-cout
- - CostFunctionJo : partie observations de la fonction-cout
- - GradientOfCostFunctionJ : gradient de la fonction-cout globale
- - GradientOfCostFunctionJb : gradient de la partie ébauche de la fonction-cout
- - GradientOfCostFunctionJo : gradient de la partie observations de la fonction-cout
+ - APosterioriCorrelations : matrice de corrélations de la matrice A
+ - APosterioriCovariance : matrice de covariances a posteriori : A
+ - APosterioriStandardDeviations : vecteur des écart-types de la matrice A
+ - APosterioriVariances : vecteur des variances de la matrice A
+ - Analysis : vecteur d'analyse : Xa
+ - BMA : Background moins Analysis : Xa - Xb
+ - CostFunctionJ : fonction-coût globale, somme des deux parties suivantes Jb et Jo
+ - CostFunctionJAtCurrentOptimum : fonction-coût globale à l'état optimal courant lors d'itérations
+ - CostFunctionJb : partie ébauche ou background de la fonction-coût : Jb
+ - CostFunctionJbAtCurrentOptimum : partie ébauche à l'état optimal courant lors d'itérations
+ - CostFunctionJo : partie observations de la fonction-coût : Jo
+ - CostFunctionJoAtCurrentOptimum : partie observations à l'état optimal courant lors d'itérations
+ - CurrentOptimum : état optimal courant lors d'itérations
- CurrentState : état courant lors d'itérations
- - Analysis : l'analyse Xa
- - SimulatedObservationAtBackground : l'état observé H(Xb) à l'ébauche
- - SimulatedObservationAtCurrentState : l'état observé H(X) à l'état courant
- - SimulatedObservationAtOptimum : l'état observé H(Xa) à l'optimum
+ - GradientOfCostFunctionJ : gradient de la fonction-coût globale
+ - GradientOfCostFunctionJb : gradient de la partie ébauche de la fonction-coût
+ - GradientOfCostFunctionJo : gradient de la partie observations de la fonction-coût
+ - IndexOfOptimum : index de l'état optimal courant lors d'itérations
- Innovation : l'innovation : d = Y - H(X)
- InnovationAtCurrentState : l'innovation à l'état courant : dn = Y - H(Xn)
- - SigmaObs2 : indicateur de correction optimale des erreurs d'observation
- - SigmaBck2 : indicateur de correction optimale des erreurs d'ébauche
+ - JacobianMatrixAtBackground : matrice jacobienne à l'état d'ébauche
+ - JacobianMatrixAtCurrentState : matrice jacobienne à l'état courant
+ - JacobianMatrixAtOptimum : matrice jacobienne à l'optimum
+ - KalmanGainAtOptimum : gain de Kalman à l'optimum
- MahalanobisConsistency : indicateur de consistance des covariances
- - OMA : Observation moins Analysis : Y - Xa
+ - OMA : Observation moins Analyse : Y - Xa
- OMB : Observation moins Background : Y - Xb
- - AMB : Analysis moins Background : Xa - Xb
- - APosterioriCovariance : matrice A
- - APosterioriVariances : variances de la matrice A
- - APosterioriStandardDeviations : écart-types de la matrice A
- - APosterioriCorrelations : correlations de la matrice A
+ - PredictedState : état prédit courant lors d'itérations
- Residu : dans le cas des algorithmes de vérification
+ - SigmaBck2 : indicateur de correction optimale des erreurs d'ébauche
+ - SigmaObs2 : indicateur de correction optimale des erreurs d'observation
+ - SimulatedObservationAtBackground : l'état observé H(Xb) à l'ébauche
+ - SimulatedObservationAtCurrentOptimum : l'état observé H(X) à l'état optimal courant
+ - SimulatedObservationAtCurrentState : l'état observé H(X) à l'état courant
+ - SimulatedObservationAtOptimum : l'état observé H(Xa) à l'optimum
+ - SimulationQuantiles : états observés H(X) pour les quantiles demandés
On peut rajouter des variables à stocker dans l'initialisation de
l'algorithme élémentaire qui va hériter de cette classe
"""
self._parameters = {"StoreSupplementaryCalculations":[]}
self.__required_parameters = {}
self.__required_inputs = {"RequiredInputValues":{"mandatory":(), "optional":()}}
+ self.__variable_names_not_public = {"nextStep":False} # Duplication dans AlgorithmAndParameters
+ self.__canonical_parameter_name = {} # Correspondance "lower"->"correct"
+ self.__canonical_stored_name = {} # Correspondance "lower"->"correct"
#
self.StoredVariables = {}
+ self.StoredVariables["APosterioriCorrelations"] = Persistence.OneMatrix(name = "APosterioriCorrelations")
+ self.StoredVariables["APosterioriCovariance"] = Persistence.OneMatrix(name = "APosterioriCovariance")
+ self.StoredVariables["APosterioriStandardDeviations"] = Persistence.OneVector(name = "APosterioriStandardDeviations")
+ self.StoredVariables["APosterioriVariances"] = Persistence.OneVector(name = "APosterioriVariances")
+ self.StoredVariables["Analysis"] = Persistence.OneVector(name = "Analysis")
+ self.StoredVariables["BMA"] = Persistence.OneVector(name = "BMA")
self.StoredVariables["CostFunctionJ"] = Persistence.OneScalar(name = "CostFunctionJ")
- self.StoredVariables["CostFunctionJb"] = Persistence.OneScalar(name = "CostFunctionJb")
- self.StoredVariables["CostFunctionJo"] = Persistence.OneScalar(name = "CostFunctionJo")
self.StoredVariables["CostFunctionJAtCurrentOptimum"] = Persistence.OneScalar(name = "CostFunctionJAtCurrentOptimum")
+ self.StoredVariables["CostFunctionJb"] = Persistence.OneScalar(name = "CostFunctionJb")
self.StoredVariables["CostFunctionJbAtCurrentOptimum"] = Persistence.OneScalar(name = "CostFunctionJbAtCurrentOptimum")
+ self.StoredVariables["CostFunctionJo"] = Persistence.OneScalar(name = "CostFunctionJo")
self.StoredVariables["CostFunctionJoAtCurrentOptimum"] = Persistence.OneScalar(name = "CostFunctionJoAtCurrentOptimum")
+ self.StoredVariables["CurrentOptimum"] = Persistence.OneVector(name = "CurrentOptimum")
+ self.StoredVariables["CurrentState"] = Persistence.OneVector(name = "CurrentState")
self.StoredVariables["GradientOfCostFunctionJ"] = Persistence.OneVector(name = "GradientOfCostFunctionJ")
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["SimulatedObservationAtBackground"] = Persistence.OneVector(name = "SimulatedObservationAtBackground")
- self.StoredVariables["SimulatedObservationAtCurrentState"] = Persistence.OneVector(name = "SimulatedObservationAtCurrentState")
- self.StoredVariables["SimulatedObservationAtOptimum"] = Persistence.OneVector(name = "SimulatedObservationAtOptimum")
- self.StoredVariables["SimulatedObservationAtCurrentOptimum"] = Persistence.OneVector(name = "SimulatedObservationAtCurrentOptimum")
self.StoredVariables["Innovation"] = Persistence.OneVector(name = "Innovation")
+ self.StoredVariables["InnovationAtCurrentAnalysis"] = Persistence.OneVector(name = "InnovationAtCurrentAnalysis")
self.StoredVariables["InnovationAtCurrentState"] = Persistence.OneVector(name = "InnovationAtCurrentState")
- self.StoredVariables["SigmaObs2"] = Persistence.OneScalar(name = "SigmaObs2")
- self.StoredVariables["SigmaBck2"] = Persistence.OneScalar(name = "SigmaBck2")
+ self.StoredVariables["JacobianMatrixAtBackground"] = Persistence.OneMatrix(name = "JacobianMatrixAtBackground")
+ self.StoredVariables["JacobianMatrixAtCurrentState"] = Persistence.OneMatrix(name = "JacobianMatrixAtCurrentState")
+ self.StoredVariables["JacobianMatrixAtOptimum"] = Persistence.OneMatrix(name = "JacobianMatrixAtOptimum")
+ self.StoredVariables["KalmanGainAtOptimum"] = Persistence.OneMatrix(name = "KalmanGainAtOptimum")
self.StoredVariables["MahalanobisConsistency"] = Persistence.OneScalar(name = "MahalanobisConsistency")
self.StoredVariables["OMA"] = Persistence.OneVector(name = "OMA")
self.StoredVariables["OMB"] = Persistence.OneVector(name = "OMB")
- self.StoredVariables["BMA"] = Persistence.OneVector(name = "BMA")
- self.StoredVariables["APosterioriCovariance"] = Persistence.OneMatrix(name = "APosterioriCovariance")
- self.StoredVariables["APosterioriVariances"] = Persistence.OneVector(name = "APosterioriVariances")
- self.StoredVariables["APosterioriStandardDeviations"] = Persistence.OneVector(name = "APosterioriStandardDeviations")
- self.StoredVariables["APosterioriCorrelations"] = Persistence.OneMatrix(name = "APosterioriCorrelations")
- self.StoredVariables["SimulationQuantiles"] = Persistence.OneMatrix(name = "SimulationQuantiles")
+ self.StoredVariables["PredictedState"] = Persistence.OneVector(name = "PredictedState")
self.StoredVariables["Residu"] = Persistence.OneScalar(name = "Residu")
+ self.StoredVariables["SigmaBck2"] = Persistence.OneScalar(name = "SigmaBck2")
+ self.StoredVariables["SigmaObs2"] = Persistence.OneScalar(name = "SigmaObs2")
+ self.StoredVariables["SimulatedObservationAtBackground"] = Persistence.OneVector(name = "SimulatedObservationAtBackground")
+ self.StoredVariables["SimulatedObservationAtCurrentAnalysis"]= Persistence.OneVector(name = "SimulatedObservationAtCurrentAnalysis")
+ self.StoredVariables["SimulatedObservationAtCurrentOptimum"] = Persistence.OneVector(name = "SimulatedObservationAtCurrentOptimum")
+ self.StoredVariables["SimulatedObservationAtCurrentState"] = Persistence.OneVector(name = "SimulatedObservationAtCurrentState")
+ self.StoredVariables["SimulatedObservationAtOptimum"] = Persistence.OneVector(name = "SimulatedObservationAtOptimum")
+ self.StoredVariables["SimulationQuantiles"] = Persistence.OneMatrix(name = "SimulationQuantiles")
+ #
+ for k in self.StoredVariables:
+ self.__canonical_stored_name[k.lower()] = k
+ #
+ for k, v in self.__variable_names_not_public.items():
+ self.__canonical_parameter_name[k.lower()] = k
+ self.__canonical_parameter_name["algorithm"] = "Algorithm"
+ self.__canonical_parameter_name["storesupplementarycalculations"] = "StoreSupplementaryCalculations"
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"))
+ logging.debug("%s Taille mémoire utilisée de %.0f Mio"%(self._name, self._m.getUsedMemory("Mio")))
#
- # Mise a jour de self._parameters avec Parameters
- self.__setParameters(Parameters)
+ # Mise a jour des paramètres internes avec le contenu de Parameters, en
+ # reprenant les valeurs par défauts pour toutes celles non définies
+ self.__setParameters(Parameters, reset=True)
+ for k, v in self.__variable_names_not_public.items():
+ if k not in self._parameters: self.__setParameters( {k:v} )
#
- # Corrections et complements
+ # Corrections et compléments
def __test_vvalue(argument, variable, argname):
if argument is None:
if variable in self.__required_inputs["RequiredInputValues"]["mandatory"]:
des classes de persistance.
"""
if key is not None:
- return self.StoredVariables[key]
+ return self.StoredVariables[self.__canonical_stored_name[key.lower()]]
else:
return self.StoredVariables
def __contains__(self, key=None):
"D.__contains__(k) -> True if D has a key k, else False"
- return key in self.StoredVariables
+ if key is None or key.lower() not in self.__canonical_stored_name:
+ return False
+ else:
+ return self.__canonical_stored_name[key.lower()] in self.StoredVariables
def keys(self):
"D.keys() -> list of D's keys"
def pop(self, k, d):
"D.pop(k[,d]) -> v, remove specified key and return the corresponding value"
- if hasattr(self, "StoredVariables"):
- return self.StoredVariables.pop(k, d)
+ if hasattr(self, "StoredVariables") and k.lower() in self.__canonical_stored_name:
+ return self.StoredVariables.pop(self.__canonical_stored_name[k.lower()], d)
else:
try:
msg = "'%s'"%k
"listval" : listval,
"message" : message,
}
+ self.__canonical_parameter_name[name.lower()] = name
logging.debug("%s %s (valeur par défaut = %s)", self._name, message, self.setParameterValue(name))
def getRequiredParameters(self, noDetails=True):
"""
Renvoie la valeur d'un paramètre requis de manière contrôlée
"""
- default = self.__required_parameters[name]["default"]
- typecast = self.__required_parameters[name]["typecast"]
- minval = self.__required_parameters[name]["minval"]
- maxval = self.__required_parameters[name]["maxval"]
- listval = self.__required_parameters[name]["listval"]
+ __k = self.__canonical_parameter_name[name.lower()]
+ default = self.__required_parameters[__k]["default"]
+ typecast = self.__required_parameters[__k]["typecast"]
+ minval = self.__required_parameters[__k]["minval"]
+ maxval = self.__required_parameters[__k]["maxval"]
+ listval = self.__required_parameters[__k]["listval"]
#
if value is None and default is None:
__val = None
else: __val = typecast( default )
else:
if typecast is None: __val = value
- else: __val = typecast( value )
+ else:
+ try:
+ __val = typecast( value )
+ except:
+ raise ValueError("The value '%s' for the parameter named '%s' can not be correctly evaluated with type '%s'."%(value, __k, typecast))
#
if minval is not None and (numpy.array(__val, float) < minval).any():
- raise ValueError("The parameter named \"%s\" of value \"%s\" can not be less than %s."%(name, __val, minval))
+ raise ValueError("The parameter named '%s' of value '%s' can not be less than %s."%(__k, __val, minval))
if maxval is not None and (numpy.array(__val, float) > maxval).any():
- raise ValueError("The parameter named \"%s\" of value \"%s\" can not be greater than %s."%(name, __val, maxval))
+ raise ValueError("The parameter named '%s' of value '%s' can not be greater than %s."%(__k, __val, maxval))
if listval is not None:
if typecast is list or typecast is tuple or isinstance(__val,list) or isinstance(__val,tuple):
for v in __val:
if v not in listval:
- raise ValueError("The value \"%s\" of the parameter named \"%s\" is not allowed, it has to be in the list %s."%(v, name, listval))
+ raise ValueError("The value '%s' is not allowed for the parameter named '%s', it has to be in the list %s."%(v, __k, listval))
elif __val not in listval:
- raise ValueError("The value \"%s\" of the parameter named \"%s\" is not allowed, it has to be in the list %s."%( __val, name,listval))
+ raise ValueError("The value '%s' is not allowed for the parameter named '%s', it has to be in the list %s."%( __val, __k,listval))
+ #
return __val
def requireInputArguments(self, mandatory=(), optional=()):
self.__required_inputs["RequiredInputValues"]["mandatory"] = tuple( mandatory )
self.__required_inputs["RequiredInputValues"]["optional"] = tuple( optional )
- def __setParameters(self, fromDico={}):
+ def __setParameters(self, fromDico={}, reset=False):
"""
Permet de stocker les paramètres reçus dans le dictionnaire interne.
"""
self._parameters.update( fromDico )
+ __inverse_fromDico_keys = {}
+ for k in fromDico.keys():
+ if k.lower() in self.__canonical_parameter_name:
+ __inverse_fromDico_keys[self.__canonical_parameter_name[k.lower()]] = k
+ #~ __inverse_fromDico_keys = dict([(self.__canonical_parameter_name[k.lower()],k) for k in fromDico.keys()])
+ __canonic_fromDico_keys = __inverse_fromDico_keys.keys()
for k in self.__required_parameters.keys():
- if k in fromDico.keys():
- self._parameters[k] = self.setParameterValue(k,fromDico[k])
- else:
+ if k in __canonic_fromDico_keys:
+ self._parameters[k] = self.setParameterValue(k,fromDico[__inverse_fromDico_keys[k]])
+ elif reset:
self._parameters[k] = self.setParameterValue(k)
+ else:
+ pass
logging.debug("%s %s : %s", self._name, self.__required_parameters[k]["message"], self._parameters[k])
# ==============================================================================
self.updateParameters( asDict, asScript )
#
if asAlgorithm is None and asScript is not None:
- __Algo = ImportFromScript(asScript).getvalue( "Algorithm" )
+ __Algo = Interfaces.ImportFromScript(asScript).getvalue( "Algorithm" )
else:
__Algo = asAlgorithm
#
self.__P.update( {"Algorithm":self.__A} )
#
self.__setAlgorithm( self.__A )
+ #
+ self.__variable_names_not_public = {"nextStep":False} # Duplication dans Algorithm
def updateParameters(self,
asDict = None,
):
"Mise a jour des parametres"
if asDict is None and asScript is not None:
- __Dict = ImportFromScript(asScript).getvalue( self.__name, "Parameters" )
+ __Dict = Interfaces.ImportFromScript(asScript).getvalue( self.__name, "Parameters" )
else:
__Dict = asDict
#
elif key in self.__P:
return self.__P[key]
else:
- return self.__P
+ allvariables = self.__P
+ for k in self.__variable_names_not_public: allvariables.pop(k, None)
+ return allvariables
def pop(self, k, d):
"Necessaire pour le pickling"
return self.__algorithm.StoredVariables[ __V ].hasDataObserver()
def keys(self):
- return list(self.__algorithm.keys()) + list(self.__P.keys())
+ __allvariables = list(self.__algorithm.keys()) + list(self.__P.keys())
+ for k in self.__variable_names_not_public:
+ if k in __allvariables: __allvariables.remove(k)
+ return __allvariables
def __contains__(self, key=None):
"D.__contains__(k) -> True if D has a key k, else False"
self.__P = {}
#
if asAlgorithm is None and asScript is not None:
- __Algo = ImportFromScript(asScript).getvalue( "Algorithm" )
+ __Algo = Interfaces.ImportFromScript(asScript).getvalue( "Algorithm" )
else:
__Algo = asAlgorithm
#
if asDict is None and asScript is not None:
- __Dict = ImportFromScript(asScript).getvalue( self.__name, "Parameters" )
+ __Dict = Interfaces.ImportFromScript(asScript).getvalue( self.__name, "Parameters" )
else:
__Dict = asDict
#
self.__P.update( dict(__Dict) )
#
if __Algo is not None:
- self.__P.update( {"Algorithm":self.__A} )
+ self.__P.update( {"Algorithm":__Algo} )
def get(self, key = None):
"Vérifie l'existence d'une clé de variable ou de paramètres"
elif (asTemplate is not None) and (asTemplate in Templates.ObserverTemplates):
__FunctionText = Templates.ObserverTemplates[asTemplate]
elif asScript is not None:
- __FunctionText = ImportFromScript(asScript).getstring()
+ __FunctionText = Interfaces.ImportFromScript(asScript).getstring()
else:
__FunctionText = ""
__Function = ObserverF(__FunctionText)
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".
+ ligne (colMajor=False, par défaut) 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)
if asScript is not None:
__Vector, __Series = None, None
if asPersistentVector:
- __Series = ImportFromScript(asScript).getvalue( self.__name )
+ __Series = Interfaces.ImportFromScript(asScript).getvalue( self.__name )
else:
- __Vector = ImportFromScript(asScript).getvalue( self.__name )
+ __Vector = Interfaces.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]
+ __Series = Interfaces.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 = Interfaces.ImportFromFile(asDataFile).getvalue( [self.__name,] )[1]
+ if bool(colMajor) and not Interfaces.ImportFromFile(asDataFile).getformat() == "application/numpy.npz":
__Series = numpy.transpose(__Series)
- elif not bool(colMajor) and ImportFromFile(asDataFile).getformat() == "application/numpy.npz":
+ elif not bool(colMajor) and Interfaces.ImportFromFile(asDataFile).getformat() == "application/numpy.npz":
__Series = numpy.transpose(__Series)
else:
if colNames is not None:
- __Vector = ImportFromFile(asDataFile).getvalue( colNames )[1]
+ __Vector = Interfaces.ImportFromFile(asDataFile).getvalue( colNames )[1]
else:
- __Vector = ImportFromFile(asDataFile).getvalue( [self.__name,] )[1]
+ __Vector = Interfaces.ImportFromFile(asDataFile).getvalue( [self.__name,] )[1]
if bool(colMajor):
__Vector = numpy.ravel(__Vector, order = "F")
else:
self.shape = (self.shape[0],1)
self.size = self.shape[0] * self.shape[1]
else:
- raise ValueError("The %s object is improperly defined, it requires at minima either a vector, a list/tuple of vectors or a persistent object. Please check your vector input."%self.__name)
+ raise ValueError("The %s object is improperly defined or undefined, it requires at minima either a vector, a list/tuple of vectors or a persistent object. Please check your vector input."%self.__name)
#
if scheduledBy is not None:
self.__T = scheduledBy
if asScript is not None:
__Matrix, __Scalar, __Vector, __Object = None, None, None, None
if asEyeByScalar:
- __Scalar = ImportFromScript(asScript).getvalue( self.__name )
+ __Scalar = Interfaces.ImportFromScript(asScript).getvalue( self.__name )
elif asEyeByVector:
- __Vector = ImportFromScript(asScript).getvalue( self.__name )
+ __Vector = Interfaces.ImportFromScript(asScript).getvalue( self.__name )
elif asCovObject:
- __Object = ImportFromScript(asScript).getvalue( self.__name )
+ __Object = Interfaces.ImportFromScript(asScript).getvalue( self.__name )
else:
- __Matrix = ImportFromScript(asScript).getvalue( self.__name )
+ __Matrix = Interfaces.ImportFromScript(asScript).getvalue( self.__name )
else:
__Matrix, __Scalar, __Vector, __Object = asCovariance, asEyeByScalar, asEyeByVector, asCovObject
#
return __formater.load(__filename, __content, __object)
# ==============================================================================
-def MultiFonction( __xserie, _sFunction = lambda x: x ):
+def MultiFonction(
+ __xserie,
+ _extraArguments = None,
+ _sFunction = lambda x: x,
+ _mpEnabled = False,
+ _mpWorkers = None,
+ ):
"""
Pour une liste ordonnée de vecteurs en entrée, renvoie en sortie la liste
correspondante de valeurs de la fonction en argument
"""
+ # Vérifications et définitions initiales
+ # logging.debug("MULTF Internal multifonction calculations begin with function %s"%(_sFunction.__name__,))
if not PlatformInfo.isIterable( __xserie ):
- raise ValueError("MultiFonction not iterable unkown input type: %s"%(type(__xserie),))
+ raise TypeError("MultiFonction not iterable unkown input type: %s"%(type(__xserie),))
+ if _mpEnabled:
+ if (_mpWorkers is None) or (_mpWorkers is not None and _mpWorkers < 1):
+ __mpWorkers = None
+ else:
+ __mpWorkers = int(_mpWorkers)
+ try:
+ import multiprocessing
+ __mpEnabled = True
+ except ImportError:
+ __mpEnabled = False
+ else:
+ __mpEnabled = False
+ __mpWorkers = None
#
- __multiHX = []
- for __xvalue in __xserie:
- __multiHX.append( _sFunction( __xvalue ) )
+ # Calculs effectifs
+ if __mpEnabled:
+ _jobs = []
+ if _extraArguments is None:
+ _jobs = __xserie
+ elif _extraArguments is not None and isinstance(_extraArguments, (list, tuple, map)):
+ for __xvalue in __xserie:
+ _jobs.append( [__xvalue, ] + list(_extraArguments) )
+ else:
+ raise TypeError("MultiFonction extra arguments unkown input type: %s"%(type(_extraArguments),))
+ # logging.debug("MULTF Internal multiprocessing calculations begin : evaluation of %i point(s)"%(len(_jobs),))
+ import multiprocessing
+ with multiprocessing.Pool(__mpWorkers) as pool:
+ __multiHX = pool.map( _sFunction, _jobs )
+ pool.close()
+ pool.join()
+ # logging.debug("MULTF Internal multiprocessing calculation end")
+ else:
+ # logging.debug("MULTF Internal monoprocessing calculation begin")
+ __multiHX = []
+ if _extraArguments is None:
+ for __xvalue in __xserie:
+ __multiHX.append( _sFunction( __xvalue ) )
+ elif _extraArguments is not None and isinstance(_extraArguments, (list, tuple, map)):
+ for __xvalue in __xserie:
+ __multiHX.append( _sFunction( __xvalue, *_extraArguments ) )
+ elif _extraArguments is not None and isinstance(_extraArguments, dict):
+ for __xvalue in __xserie:
+ __multiHX.append( _sFunction( __xvalue, **_extraArguments ) )
+ else:
+ raise TypeError("MultiFonction extra arguments unkown input type: %s"%(type(_extraArguments),))
+ # logging.debug("MULTF Internal monoprocessing calculation end")
#
+ # logging.debug("MULTF Internal multifonction calculations end")
return __multiHX
# ==============================================================================
# ==============================================================================
if __name__ == "__main__":
- print('\n AUTODIAGNOSTIC \n')
+ print('\n AUTODIAGNOSTIC\n')
