X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FdaComposant%2FdaCore%2FBasicObjects.py;h=eefbea3806812c12230658e7ad229270ecbf40a7;hb=a6845547d27bcdc0928f898a4c8a2e4fc276c69e;hp=e8b5755065a5855011015f23037290f795bdf3e5;hpb=c761e79a0ca835b448c19ec706f597ad21b67a03;p=modules%2Fadao.git diff --git a/src/daComposant/daCore/BasicObjects.py b/src/daComposant/daCore/BasicObjects.py index e8b5755..eefbea3 100644 --- a/src/daComposant/daCore/BasicObjects.py +++ b/src/daComposant/daCore/BasicObjects.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (C) 2008-2021 EDF R&D +# Copyright (C) 2008-2023 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 @@ -32,6 +32,7 @@ import logging import copy import time import numpy +import warnings from functools import partial from daCore import Persistence, PlatformInfo, Interfaces from daCore import Templates @@ -43,14 +44,14 @@ class CacheManager(object): """ def __init__(self, toleranceInRedundancy = 1.e-18, - lenghtOfRedundancy = -1, + lengthOfRedundancy = -1, ): """ Les caractéristiques de tolérance peuvent être modifiées à la création. """ self.__tolerBP = float(toleranceInRedundancy) - self.__lenghtOR = int(lenghtOfRedundancy) - self.__initlnOR = self.__lenghtOR + self.__lengthOR = int(lengthOfRedundancy) + self.__initlnOR = self.__lengthOR self.__seenNames = [] self.__enabled = True self.clearCache() @@ -65,7 +66,7 @@ class CacheManager(object): __alc = False __HxV = None if self.__enabled: - for i in range(min(len(self.__listOPCV),self.__lenghtOR)-1,-1,-1): + for i in range(min(len(self.__listOPCV),self.__lengthOR)-1,-1,-1): if not hasattr(xValue, 'size'): pass elif (str(oName) != self.__listOPCV[i][3]): @@ -82,15 +83,15 @@ class CacheManager(object): def storeValueInX(self, xValue, HxValue, oName="" ): "Stocke pour un opérateur o un calcul Hx correspondant à la valeur x" - if self.__lenghtOR < 0: - self.__lenghtOR = 2 * min(xValue.size, 50) + 2 # 2 * xValue.size + 2 - self.__initlnOR = self.__lenghtOR + if self.__lengthOR < 0: + self.__lengthOR = 2 * min(numpy.size(xValue), 50) + 2 + self.__initlnOR = self.__lengthOR self.__seenNames.append(str(oName)) if str(oName) not in self.__seenNames: # Etend la liste si nouveau - self.__lenghtOR += 2 * min(xValue.size, 50) + 2 # 2 * xValue.size + 2 - self.__initlnOR += self.__lenghtOR + self.__lengthOR += 2 * min(numpy.size(xValue), 50) + 2 + self.__initlnOR += self.__lengthOR self.__seenNames.append(str(oName)) - while len(self.__listOPCV) > self.__lenghtOR: + while len(self.__listOPCV) > self.__lengthOR: self.__listOPCV.pop(0) self.__listOPCV.append( ( copy.copy(numpy.ravel(xValue)), # 0 Previous point @@ -101,13 +102,13 @@ class CacheManager(object): def disable(self): "Inactive le cache" - self.__initlnOR = self.__lenghtOR - self.__lenghtOR = 0 + self.__initlnOR = self.__lengthOR + self.__lengthOR = 0 self.__enabled = False def enable(self): "Active le cache" - self.__lenghtOR = self.__initlnOR + self.__lengthOR = self.__initlnOR self.__enabled = True # ============================================================================== @@ -246,7 +247,11 @@ class Operator(object): 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.") + raise TypeError( + "The user input multi-function doesn't seem to return a"+\ + " result sequence, behaving like a mono-function. It has"+\ + " to be checked." + ) for i in _hindex: _xv = _xserie.pop(0) _hv = _hserie.pop(0) @@ -495,19 +500,16 @@ class FullOperator(object): __Function = asThreeFunctions __Function.update({"useApproximatedDerivatives":True}) else: - raise ValueError("The functions has to be given in a dictionnary which have either 1 key (\"Direct\") or 3 keys (\"Direct\" (optionnal), \"Tangent\" and \"Adjoint\")") + raise ValueError( + "The functions has to be given in a dictionnary which have either"+\ + " 1 key (\"Direct\") or"+\ + " 3 keys (\"Direct\" (optionnal), \"Tangent\" and \"Adjoint\")") if "Direct" not in asThreeFunctions: __Function["Direct"] = asThreeFunctions["Tangent"] __Function.update(__Parameters) else: __Function = None # - # if sys.version_info[0] < 3 and isinstance(__Function, dict): - #  for k in ("Direct", "Tangent", "Adjoint"): - #  if k in __Function and hasattr(__Function[k],"__class__"): - #  if type(__Function[k]) is type(self.__init__): - #  raise TypeError("can't use a class method (%s) as a function for the \"%s\" operator. Use a real function instead."%(type(__Function[k]),k)) - # if appliedInX is not None and isinstance(appliedInX, dict): __appliedInX = appliedInX elif appliedInX is not None: @@ -527,7 +529,7 @@ class FullOperator(object): if "withReducingMemoryUse" not in __Function: __Function["withReducingMemoryUse"] = __reduceM 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 "withLengthOfRedundancy" not in __Function: __Function["withLengthOfRedundancy"] = -1 if "NumberOfProcesses" not in __Function: __Function["NumberOfProcesses"] = None if "withmfEnabled" not in __Function: __Function["withmfEnabled"] = inputAsMF from daCore import NumericObjects @@ -541,42 +543,95 @@ class FullOperator(object): reducingMemoryUse = __Function["withReducingMemoryUse"], avoidingRedundancy = __Function["withAvoidingRedundancy"], toleranceInRedundancy = __Function["withToleranceInRedundancy"], - lenghtOfRedundancy = __Function["withLenghtOfRedundancy"], + lengthOfRedundancy = __Function["withLengthOfRedundancy"], mpEnabled = __Function["EnableMultiProcessingInDerivatives"], mpWorkers = __Function["NumberOfProcesses"], mfEnabled = __Function["withmfEnabled"], ) - self.__FO["Direct"] = Operator( name = self.__name, fromMethod = FDA.DirectOperator, reducingMemoryUse = __reduceM, avoidingRedundancy = __avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs, enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] ) - self.__FO["Tangent"] = Operator( name = self.__name+"Tangent", fromMethod = FDA.TangentOperator, reducingMemoryUse = __reduceM, avoidingRedundancy = __avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs ) - self.__FO["Adjoint"] = Operator( name = self.__name+"Adjoint", fromMethod = FDA.AdjointOperator, reducingMemoryUse = __reduceM, avoidingRedundancy = __avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs ) + self.__FO["Direct"] = Operator( + name = self.__name, + fromMethod = FDA.DirectOperator, + reducingMemoryUse = __reduceM, + avoidingRedundancy = __avoidRC, + inputAsMultiFunction = inputAsMF, + extraArguments = self.__extraArgs, + enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] ) + self.__FO["Tangent"] = Operator( + name = self.__name+"Tangent", + fromMethod = FDA.TangentOperator, + reducingMemoryUse = __reduceM, + avoidingRedundancy = __avoidRC, + inputAsMultiFunction = inputAsMF, + extraArguments = self.__extraArgs ) + self.__FO["Adjoint"] = Operator( + name = self.__name+"Adjoint", + fromMethod = FDA.AdjointOperator, + reducingMemoryUse = __reduceM, + 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( name = self.__name, fromMethod = __Function["Direct"], reducingMemoryUse = __reduceM, avoidingRedundancy = __avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs, enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] ) - self.__FO["Tangent"] = Operator( name = self.__name+"Tangent", fromMethod = __Function["Tangent"], reducingMemoryUse = __reduceM, avoidingRedundancy = __avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs ) - self.__FO["Adjoint"] = Operator( name = self.__name+"Adjoint", fromMethod = __Function["Adjoint"], reducingMemoryUse = __reduceM, avoidingRedundancy = __avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs ) + self.__FO["Direct"] = Operator( + name = self.__name, + fromMethod = __Function["Direct"], + reducingMemoryUse = __reduceM, + avoidingRedundancy = __avoidRC, + inputAsMultiFunction = inputAsMF, + extraArguments = self.__extraArgs, + enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] ) + self.__FO["Tangent"] = Operator( + name = self.__name+"Tangent", + fromMethod = __Function["Tangent"], + reducingMemoryUse = __reduceM, + avoidingRedundancy = __avoidRC, + inputAsMultiFunction = inputAsMF, + extraArguments = self.__extraArgs ) + self.__FO["Adjoint"] = Operator( + name = self.__name+"Adjoint", + fromMethod = __Function["Adjoint"], + reducingMemoryUse = __reduceM, + avoidingRedundancy = __avoidRC, + inputAsMultiFunction = inputAsMF, + extraArguments = self.__extraArgs ) elif asMatrix is not None: if isinstance(__Matrix, str): __Matrix = PlatformInfo.strmatrix2liststr( __Matrix ) __matrice = numpy.asarray( __Matrix, dtype=float ) - self.__FO["Direct"] = Operator( name = self.__name, fromMatrix = __matrice, reducingMemoryUse = __reduceM, avoidingRedundancy = __avoidRC, inputAsMultiFunction = inputAsMF, enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] ) - self.__FO["Tangent"] = Operator( name = self.__name+"Tangent", fromMatrix = __matrice, reducingMemoryUse = __reduceM, avoidingRedundancy = __avoidRC, inputAsMultiFunction = inputAsMF ) - self.__FO["Adjoint"] = Operator( name = self.__name+"Adjoint", fromMatrix = __matrice.T, reducingMemoryUse = __reduceM, avoidingRedundancy = __avoidRC, inputAsMultiFunction = inputAsMF ) + self.__FO["Direct"] = Operator( + name = self.__name, + fromMatrix = __matrice, + reducingMemoryUse = __reduceM, + avoidingRedundancy = __avoidRC, + inputAsMultiFunction = inputAsMF, + enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] ) + self.__FO["Tangent"] = Operator( + name = self.__name+"Tangent", + fromMatrix = __matrice, + reducingMemoryUse = __reduceM, + avoidingRedundancy = __avoidRC, + inputAsMultiFunction = inputAsMF ) + self.__FO["Adjoint"] = Operator( + name = self.__name+"Adjoint", + fromMatrix = __matrice.T, + reducingMemoryUse = __reduceM, + avoidingRedundancy = __avoidRC, + inputAsMultiFunction = inputAsMF ) del __matrice else: - 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) + raise ValueError( + "The %s object is improperly defined or undefined,"%self.__name+\ + " it requires at minima either a matrix, a Direct operator for"+\ + " approximate derivatives or a Tangent/Adjoint operators pair."+\ + " Please check your operator input.") # if __appliedInX is not None: self.__FO["AppliedInX"] = {} - 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.__FO["AppliedInX"][key] = numpy.matrix( __appliedInX[key].A1, numpy.float ).T - elif type( __appliedInX[key] ) is type( numpy.array([]) ) and len(__appliedInX[key].shape) > 1: - # Pour le cas où l'on a un vecteur représenté en array avec 2 dimensions - self.__FO["AppliedInX"][key] = numpy.matrix( __appliedInX[key].reshape(len(__appliedInX[key]),), numpy.float ).T - else: - self.__FO["AppliedInX"][key] = numpy.matrix( __appliedInX[key], numpy.float ).T + for key in __appliedInX: + if isinstance(__appliedInX[key], str): + __appliedInX[key] = PlatformInfo.strvect2liststr( __appliedInX[key] ) + self.__FO["AppliedInX"][key] = numpy.ravel( __appliedInX[key] ).reshape((-1,1)) else: self.__FO["AppliedInX"] = None @@ -625,6 +680,12 @@ class Algorithm(object): - CurrentIterationNumber : numéro courant d'itération dans les algorithmes itératifs, à partir de 0 - CurrentOptimum : état optimal courant lors d'itérations - CurrentState : état courant lors d'itérations + - CurrentStepNumber : pas courant d'avancement dans les algorithmes en évolution, à partir de 0 + - EnsembleOfSimulations : ensemble d'états (sorties, simulations) rangés par colonne dans une matrice + - EnsembleOfSnapshots : ensemble d'états rangés par colonne dans une matrice + - EnsembleOfStates : ensemble d'états (entrées, paramètres) rangés par colonne dans une matrice + - ForecastCovariance : covariance de l'état prédit courant lors d'itérations + - ForecastState : état prédit courant lors d'itérations - 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 @@ -638,8 +699,6 @@ class Algorithm(object): - MahalanobisConsistency : indicateur de consistance des covariances - OMA : Observation moins Analyse : Y - Xa - OMB : Observation moins Background : Y - Xb - - ForecastCovariance : covariance de l'état prédit courant lors d'itérations - - ForecastState : état prédit courant lors d'itérations - Residu : dans le cas des algorithmes de vérification - SampledStateForQuantiles : échantillons d'états pour l'estimation des quantiles - SigmaBck2 : indicateur de correction optimale des erreurs d'ébauche @@ -666,6 +725,7 @@ class Algorithm(object): 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.__replace_by_the_new_name = {} # Nouveau nom à partir d'un nom ancien # self.StoredVariables = {} self.StoredVariables["APosterioriCorrelations"] = Persistence.OneMatrix(name = "APosterioriCorrelations") @@ -684,6 +744,10 @@ class Algorithm(object): self.StoredVariables["CurrentIterationNumber"] = Persistence.OneIndex(name = "CurrentIterationNumber") self.StoredVariables["CurrentOptimum"] = Persistence.OneVector(name = "CurrentOptimum") self.StoredVariables["CurrentState"] = Persistence.OneVector(name = "CurrentState") + self.StoredVariables["CurrentStepNumber"] = Persistence.OneIndex(name = "CurrentStepNumber") + self.StoredVariables["EnsembleOfSimulations"] = Persistence.OneMatrix(name = "EnsembleOfSimulations") + self.StoredVariables["EnsembleOfSnapshots"] = Persistence.OneMatrix(name = "EnsembleOfSnapshots") + self.StoredVariables["EnsembleOfStates"] = Persistence.OneMatrix(name = "EnsembleOfStates") self.StoredVariables["ForecastCovariance"] = Persistence.OneMatrix(name = "ForecastCovariance") self.StoredVariables["ForecastState"] = Persistence.OneVector(name = "ForecastState") self.StoredVariables["GradientOfCostFunctionJ"] = Persistence.OneVector(name = "GradientOfCostFunctionJ") @@ -700,7 +764,10 @@ class Algorithm(object): self.StoredVariables["MahalanobisConsistency"] = Persistence.OneScalar(name = "MahalanobisConsistency") self.StoredVariables["OMA"] = Persistence.OneVector(name = "OMA") self.StoredVariables["OMB"] = Persistence.OneVector(name = "OMB") + self.StoredVariables["OptimalPoints"] = Persistence.OneVector(name = "OptimalPoints") + self.StoredVariables["ReducedBasis"] = Persistence.OneMatrix(name = "ReducedBasis") self.StoredVariables["Residu"] = Persistence.OneScalar(name = "Residu") + self.StoredVariables["Residus"] = Persistence.OneVector(name = "Residus") self.StoredVariables["SampledStateForQuantiles"] = Persistence.OneMatrix(name = "SampledStateForQuantiles") self.StoredVariables["SigmaBck2"] = Persistence.OneScalar(name = "SigmaBck2") self.StoredVariables["SigmaObs2"] = Persistence.OneScalar(name = "SigmaObs2") @@ -725,12 +792,12 @@ class Algorithm(object): logging.debug("%s Taille mémoire utilisée de %.0f Mio"%(self._name, self._m.getUsedMemory("Mio"))) self._getTimeState(reset=True) # - # Mise a jour des paramètres internes avec le contenu de Parameters, en + # Mise à 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 compléments des vecteurs def __test_vvalue(argument, variable, argname, symbol=None): if symbol is None: symbol = variable @@ -747,12 +814,14 @@ class Algorithm(object): elif variable in self.__required_inputs["RequiredInputValues"]["optional"]: logging.debug("%s %s vector %s is optional and set, and its size is %i."%(self._name,argname,symbol,numpy.array(argument).size)) else: - logging.debug("%s %s vector %s is set although neither required nor optional, and its size is %i."%(self._name,argname,symbol,numpy.array(argument).size)) + logging.debug( + "%s %s vector %s is set although neither required nor optional, and its size is %i."%( + self._name,argname,symbol,numpy.array(argument).size)) return 0 __test_vvalue( Xb, "Xb", "Background or initial state" ) __test_vvalue( Y, "Y", "Observation" ) __test_vvalue( U, "U", "Control" ) - # + # Corrections et compléments des covariances def __test_cvalue(argument, variable, argname, symbol=None): if symbol is None: symbol = variable @@ -774,7 +843,7 @@ class Algorithm(object): __test_cvalue( B, "B", "Background" ) __test_cvalue( R, "R", "Observation" ) __test_cvalue( Q, "Q", "Evolution" ) - # + # Corrections et compléments des opérateurs def __test_ovalue(argument, variable, argname, symbol=None): if symbol is None: symbol = variable @@ -802,7 +871,9 @@ class Algorithm(object): logging.debug("%s Bounds taken into account"%(self._name,)) else: self._parameters["Bounds"] = None - if ("StateBoundsForQuantiles" in self._parameters) and isinstance(self._parameters["StateBoundsForQuantiles"], (list, tuple)) and (len(self._parameters["StateBoundsForQuantiles"]) > 0): + if ("StateBoundsForQuantiles" in self._parameters) \ + and isinstance(self._parameters["StateBoundsForQuantiles"], (list, tuple)) \ + and (len(self._parameters["StateBoundsForQuantiles"]) > 0): logging.debug("%s Bounds for quantiles states taken into account"%(self._name,)) # Attention : contrairement à Bounds, pas de défaut à None, sinon on ne peut pas être sans bornes # @@ -827,18 +898,10 @@ class Algorithm(object): # Verbosité et logging if logging.getLogger().level < logging.WARNING: self._parameters["optiprint"], self._parameters["optdisp"] = 1, 1 - if PlatformInfo.has_scipy: - import scipy.optimize - self._parameters["optmessages"] = scipy.optimize.tnc.MSG_ALL - else: - self._parameters["optmessages"] = 15 + self._parameters["optmessages"] = 15 else: self._parameters["optiprint"], self._parameters["optdisp"] = -1, 0 - if PlatformInfo.has_scipy: - import scipy.optimize - self._parameters["optmessages"] = scipy.optimize.tnc.MSG_NONE - else: - self._parameters["optmessages"] = 15 + self._parameters["optmessages"] = 0 # return 0 @@ -856,8 +919,12 @@ class Algorithm(object): _C = numpy.dot(_EI, numpy.dot(_A, _EI)) self.StoredVariables["APosterioriCorrelations"].store( _C ) if _oH is not None and "Direct" in _oH and "Tangent" in _oH and "Adjoint" in _oH: - logging.debug("%s Nombre d'évaluation(s) de l'opérateur d'observation direct/tangent/adjoint.: %i/%i/%i", self._name, _oH["Direct"].nbcalls(0),_oH["Tangent"].nbcalls(0),_oH["Adjoint"].nbcalls(0)) - logging.debug("%s Nombre d'appels au cache d'opérateur d'observation direct/tangent/adjoint..: %i/%i/%i", self._name, _oH["Direct"].nbcalls(3),_oH["Tangent"].nbcalls(3),_oH["Adjoint"].nbcalls(3)) + logging.debug( + "%s Nombre d'évaluation(s) de l'opérateur d'observation direct/tangent/adjoint.: %i/%i/%i", + self._name, _oH["Direct"].nbcalls(0),_oH["Tangent"].nbcalls(0),_oH["Adjoint"].nbcalls(0)) + logging.debug( + "%s Nombre d'appels au cache d'opérateur d'observation direct/tangent/adjoint..: %i/%i/%i", + self._name, _oH["Direct"].nbcalls(3),_oH["Tangent"].nbcalls(3),_oH["Adjoint"].nbcalls(3)) logging.debug("%s Taille mémoire utilisée de %.0f Mio", self._name, self._m.getUsedMemory("Mio")) logging.debug("%s Durées d'utilisation CPU de %.1fs et elapsed de %.1fs", self._name, self._getTimeState()[0], self._getTimeState()[1]) logging.debug("%s Terminé", self._name) @@ -901,22 +968,31 @@ class Algorithm(object): else: try: msg = "'%s'"%k - except: + except Exception: raise TypeError("pop expected at least 1 arguments, got 0") "If key is not found, d is returned if given, otherwise KeyError is raised" try: return d - except: + except Exception: raise KeyError(msg) def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): """ - Doit implémenter l'opération élémentaire de calcul d'assimilation sous - sa forme mathématique la plus naturelle possible. + Doit implémenter l'opération élémentaire de calcul algorithmique. """ - raise NotImplementedError("Mathematical assimilation calculation has not been implemented!") - - def defineRequiredParameter(self, name = None, default = None, typecast = None, message = None, minval = None, maxval = None, listval = None, listadv = None): + raise NotImplementedError("Mathematical algorithmic calculation has not been implemented!") + + def defineRequiredParameter(self, + name = None, + default = None, + typecast = None, + message = None, + minval = None, + maxval = None, + listval = None, + listadv = None, + oldname = None, + ): """ Permet de définir dans l'algorithme des paramètres requis et leurs caractéristiques par défaut. @@ -932,8 +1008,12 @@ class Algorithm(object): "listval" : listval, "listadv" : listadv, "message" : message, + "oldname" : oldname, } self.__canonical_parameter_name[name.lower()] = name + if oldname is not None: + self.__canonical_parameter_name[oldname.lower()] = name # Conversion + self.__replace_by_the_new_name[oldname.lower()] = name logging.debug("%s %s (valeur par défaut = %s)", self._name, message, self.setParameterValue(name)) def getRequiredParameters(self, noDetails=True): @@ -968,7 +1048,7 @@ class Algorithm(object): else: try: __val = typecast( value ) - except: + except Exception: 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(): @@ -1019,6 +1099,14 @@ class Algorithm(object): __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 __inverse_fromDico_keys.values(): + if k.lower() in self.__replace_by_the_new_name: + __newk = self.__replace_by_the_new_name[k.lower()] + __msg = "the parameter \"%s\" used in \"%s\" algorithm case is deprecated and has to be replaced by \"%s\"."%(k,self._name,__newk) + __msg += " Please update your code." + warnings.warn(__msg, FutureWarning, stacklevel=50) + # for k in self.__required_parameters.keys(): if k in __canonic_fromDico_keys: self._parameters[k] = self.setParameterValue(k,fromDico[__inverse_fromDico_keys[k]]) @@ -1094,6 +1182,7 @@ class PartialAlgorithm(object): self.StoredVariables["CostFunctionJb"] = Persistence.OneScalar(name = "CostFunctionJb") self.StoredVariables["CostFunctionJo"] = Persistence.OneScalar(name = "CostFunctionJo") self.StoredVariables["CurrentIterationNumber"] = Persistence.OneIndex(name = "CurrentIterationNumber") + self.StoredVariables["CurrentStepNumber"] = Persistence.OneIndex(name = "CurrentStepNumber") # self.__canonical_stored_name = {} for k in self.StoredVariables: @@ -1156,7 +1245,7 @@ class AlgorithmAndParameters(object): asDict = None, asScript = None, ): - "Mise a jour des parametres" + "Mise à jour des paramètres" if asDict is None and asScript is not None: __Dict = Interfaces.ImportFromScript(asScript).getvalue( self.__name, "Parameters" ) else: @@ -1229,7 +1318,7 @@ class AlgorithmAndParameters(object): try: catalogAd = r.loadCatalog("proc", __file) r.addCatalog(catalogAd) - except: + except Exception: pass try: @@ -1359,7 +1448,8 @@ class AlgorithmAndParameters(object): 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\" has been found in the search path.\n The search path is %s"%(choice, 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 # ------------------------------------------ @@ -1371,7 +1461,8 @@ class AlgorithmAndParameters(object): self.__algorithmName = str(choice) 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)) + 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 # ------------------------------------------------- @@ -1460,13 +1551,21 @@ class AlgorithmAndParameters(object): raise ValueError("Shape characteristic of evolution operator (EM) is incorrect: \"%s\"."%(__EM_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)) + 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 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)) + 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 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)) + 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 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)) + 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.__algorithmName in ["EnsembleBlue",]: @@ -1476,16 +1575,24 @@ class AlgorithmAndParameters(object): self.__Xb.store( numpy.asarray(member, dtype=float) ) __Xb_shape = min(__B_shape) else: - raise ValueError("Shape characteristic of a priori errors covariance matrix (B) \"%s\" and background (Xb) \"%s\" are incompatible."%(__B_shape,__Xb_shape)) + raise ValueError( + "Shape characteristic of a priori errors covariance matrix (B)"+\ + " \"%s\" and background vector (Xb) \"%s\" are incompatible."%(__B_shape,__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)) + raise ValueError( + "Shape characteristic of observation errors covariance matrix (R)"+\ + " \"%s\" and observation vector (Y) \"%s\" are incompatible."%(__R_shape,__Y_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)) + 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 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)) + raise ValueError( + "Shape characteristic of control model (CM)"+\ + " \"%s\" and control (U) \"%s\" are incompatible."%(__CM_shape,__U_shape)) # if ("Bounds" in self.__P) \ and (isinstance(self.__P["Bounds"], list) or isinstance(self.__P["Bounds"], tuple)) \ @@ -1640,7 +1747,7 @@ class UserScript(object): # ============================================================================== class ExternalParameters(object): """ - Classe générale d'interface de type texte de script utilisateur + Classe générale d'interface pour le stockage des paramètres externes """ def __init__(self, name = "GenericExternalParameters", @@ -1658,7 +1765,7 @@ class ExternalParameters(object): asDict = None, asScript = None, ): - "Mise a jour des parametres" + "Mise à jour des paramètres" if asDict is None and asScript is not None: __Dict = Interfaces.ImportFromScript(asScript).getvalue( self.__name, "ExternalParameters" ) else: @@ -1769,7 +1876,6 @@ class State(object): elif __Series is not None: self.__is_series = True if isinstance(__Series, (tuple, list, numpy.ndarray, numpy.matrix, str)): - #~ self.__V = Persistence.OneVector(self.__name, basetype=numpy.matrix) self.__V = Persistence.OneVector(self.__name) if isinstance(__Series, str): __Series = PlatformInfo.strmatrix2liststr(__Series) @@ -1787,7 +1893,10 @@ class State(object): self.shape = (self.shape[0],1) self.size = self.shape[0] * self.shape[1] else: - 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) + raise ValueError( + "The %s object is improperly defined or undefined,"%self.__name+\ + " it requires at minima either a vector, a list/tuple of"+\ + " vectors or a persistent object. Please check your vector input.") # if scheduledBy is not None: self.__T = scheduledBy @@ -1874,7 +1983,10 @@ class Covariance(object): __Scalar = PlatformInfo.strvect2liststr( __Scalar ) if len(__Scalar) > 0: __Scalar = __Scalar[0] if numpy.array(__Scalar).size != 1: - raise ValueError(' The diagonal multiplier given to define a sparse matrix is not a unique scalar value.\n Its actual measured size is %i. Please check your scalar input.'%numpy.array(__Scalar).size) + raise ValueError( + " The diagonal multiplier given to define a sparse matrix is"+\ + " not a unique scalar value.\n Its actual measured size is"+\ + " %i. Please check your scalar input."%numpy.array(__Scalar).size) self.__is_scalar = True self.__C = numpy.abs( float(__Scalar) ) self.shape = (0,0) @@ -1907,7 +2019,6 @@ class Covariance(object): self.size = 0 else: pass - # raise ValueError("The %s covariance matrix has to be specified either as a matrix, a vector for its diagonal or a scalar multiplying an identity matrix."%self.__name) # self.__validate() @@ -1925,13 +2036,13 @@ class Covariance(object): raise ValueError("The \"%s\" covariance matrix is not positive-definite. Please check your vector input."%(self.__name,)) if self.ismatrix() and (self.__check or logging.getLogger().level < logging.WARNING): try: - L = numpy.linalg.cholesky( self.__C ) - except: + numpy.linalg.cholesky( self.__C ) + except Exception: raise ValueError("The %s covariance matrix is not symmetric positive-definite. Please check your matrix input."%(self.__name,)) if self.isobject() and (self.__check or logging.getLogger().level < logging.WARNING): try: - L = self.__C.cholesky() - except: + self.__C.cholesky() + except Exception: raise ValueError("The %s covariance object is not symmetric positive-definite. Please check your matrix input."%(self.__name,)) def isscalar(self): @@ -2099,7 +2210,10 @@ class Covariance(object): return self.__C + numpy.asmatrix(other) elif self.isvector() or self.isscalar(): _A = numpy.asarray(other) - _A.reshape(_A.size)[::_A.shape[1]+1] += self.__C + if len(_A.shape) == 1: + _A.reshape((-1,1))[::2] += self.__C + else: + _A.reshape(_A.size)[::_A.shape[1]+1] += self.__C return numpy.asmatrix(_A) def __radd__(self, other): @@ -2163,14 +2277,16 @@ class Covariance(object): 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)) + 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, (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 return numpy.asmatrix((self.__C * (numpy.asarray(other).transpose())).transpose()) 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"%(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, (list, numpy.ndarray, tuple)): @@ -2181,7 +2297,8 @@ class Covariance(object): elif self.isobject(): return self.__C.__mul__(other) else: - raise NotImplementedError("%s covariance matrix __mul__ method not available for %s type!"%(self.__name,type(other))) + raise NotImplementedError( + "%s covariance matrix __mul__ method not available for %s type!"%(self.__name,type(other))) def __rmatmul__(self, other): "x.__rmul__(y) <==> y@x" @@ -2193,20 +2310,23 @@ class Covariance(object): elif numpy.asmatrix(other).shape[0] == self.shape[1]: # Matrice return numpy.asmatrix(other) * self.__C else: - raise ValueError("operands could not be broadcast together with shapes %s %s in %s matrix"%(numpy.asmatrix(other).shape,self.shape,self.__name)) + raise ValueError( + "operands could not be broadcast together with shapes %s %s in %s matrix"%(numpy.asmatrix(other).shape,self.shape,self.__name)) elif self.isvector() and isinstance(other,numpy.matrix): if numpy.ravel(other).size == self.shape[0]: # Vecteur return numpy.asmatrix(numpy.ravel(other) * self.__C) 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"%(numpy.ravel(other).shape,self.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.__C.__rmatmul__(other) else: - raise NotImplementedError("%s covariance matrix __rmatmul__ method not available for %s type!"%(self.__name,type(other))) + raise NotImplementedError( + "%s covariance matrix __rmatmul__ method not available for %s type!"%(self.__name,type(other))) def __rmul__(self, other): "x.__rmul__(y) <==> y*x" @@ -2218,14 +2338,16 @@ class Covariance(object): elif numpy.asmatrix(other).shape[0] == self.shape[1]: # Matrice return numpy.asmatrix(other) * self.__C else: - raise ValueError("operands could not be broadcast together with shapes %s %s in %s matrix"%(numpy.asmatrix(other).shape,self.shape,self.__name)) + raise ValueError( + "operands could not be broadcast together with shapes %s %s in %s matrix"%(numpy.asmatrix(other).shape,self.shape,self.__name)) elif self.isvector() and isinstance(other,numpy.matrix): if numpy.ravel(other).size == self.shape[0]: # Vecteur return numpy.asmatrix(numpy.ravel(other) * self.__C) 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"%(numpy.ravel(other).shape,self.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.isscalar() and isinstance(other,float): @@ -2233,7 +2355,8 @@ class Covariance(object): elif self.isobject(): return self.__C.__rmul__(other) else: - raise NotImplementedError("%s covariance matrix __rmul__ method not available for %s type!"%(self.__name,type(other))) + raise NotImplementedError( + "%s covariance matrix __rmul__ method not available for %s type!"%(self.__name,type(other))) def __len__(self): "x.__len__() <==> len(x)" @@ -2340,7 +2463,6 @@ def MultiFonction( if __mpEnabled: _jobs = __xserie # 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() @@ -2365,121 +2487,6 @@ def MultiFonction( # logging.debug("MULTF Internal multifonction calculations end") return __multiHX -# ============================================================================== -def CostFunction3D(_x, - _Hm = None, # Pour simuler Hm(x) : HO["Direct"].appliedTo - _HmX = None, # Simulation déjà faite de Hm(x) - _arg = None, # Arguments supplementaires pour Hm, sous la forme d'un tuple - _BI = None, - _RI = None, - _Xb = None, - _Y = None, - _SIV = False, # A résorber pour la 8.0 - _SSC = [], # self._parameters["StoreSupplementaryCalculations"] - _nPS = 0, # nbPreviousSteps - _QM = "DA", # QualityMeasure - _SSV = {}, # Entrée et/ou sortie : self.StoredVariables - _fRt = False, # Restitue ou pas la sortie étendue - _sSc = True, # Stocke ou pas les SSC - ): - """ - Fonction-coût générale utile pour les algorithmes statiques/3D : 3DVAR, BLUE - et dérivés, Kalman et dérivés, LeastSquares, SamplingTest, PSO, SA, Tabu, - DFO, QuantileRegression - """ - if not _sSc: - _SIV = False - _SSC = {} - else: - for k in ["CostFunctionJ", - "CostFunctionJb", - "CostFunctionJo", - "CurrentOptimum", - "CurrentState", - "IndexOfOptimum", - "SimulatedObservationAtCurrentOptimum", - "SimulatedObservationAtCurrentState", - ]: - if k not in _SSV: - _SSV[k] = [] - if hasattr(_SSV[k],"store"): - _SSV[k].append = _SSV[k].store # Pour utiliser "append" au lieu de "store" - # - _X = numpy.asmatrix(numpy.ravel( _x )).T - if _SIV or "CurrentState" in _SSC or "CurrentOptimum" in _SSC: - _SSV["CurrentState"].append( _X ) - # - if _HmX is not None: - _HX = _HmX - else: - if _Hm is None: - raise ValueError("COSTFUNCTION3D Operator has to be defined.") - if _arg is None: - _HX = _Hm( _X ) - else: - _HX = _Hm( _X, *_arg ) - _HX = numpy.asmatrix(numpy.ravel( _HX )).T - # - if "SimulatedObservationAtCurrentState" in _SSC or \ - "SimulatedObservationAtCurrentOptimum" in _SSC: - _SSV["SimulatedObservationAtCurrentState"].append( _HX ) - # - if numpy.any(numpy.isnan(_HX)): - Jb, Jo, J = numpy.nan, numpy.nan, numpy.nan - else: - _Y = numpy.asmatrix(numpy.ravel( _Y )).T - if _QM in ["AugmentedWeightedLeastSquares", "AWLS", "AugmentedPonderatedLeastSquares", "APLS", "DA"]: - if _BI is None or _RI is None: - raise ValueError("Background and Observation error covariance matrix has to be properly defined!") - _Xb = numpy.asmatrix(numpy.ravel( _Xb )).T - Jb = 0.5 * (_X - _Xb).T * _BI * (_X - _Xb) - Jo = 0.5 * (_Y - _HX).T * _RI * (_Y - _HX) - elif _QM in ["WeightedLeastSquares", "WLS", "PonderatedLeastSquares", "PLS"]: - if _RI is None: - raise ValueError("Observation error covariance matrix has to be properly defined!") - Jb = 0. - Jo = 0.5 * (_Y - _HX).T * _RI * (_Y - _HX) - elif _QM in ["LeastSquares", "LS", "L2"]: - Jb = 0. - Jo = 0.5 * (_Y - _HX).T * (_Y - _HX) - elif _QM in ["AbsoluteValue", "L1"]: - Jb = 0. - Jo = numpy.sum( numpy.abs(_Y - _HX) ) - elif _QM in ["MaximumError", "ME"]: - Jb = 0. - Jo = numpy.max( numpy.abs(_Y - _HX) ) - elif _QM in ["QR", "Null"]: - Jb = 0. - Jo = 0. - else: - raise ValueError("Unknown asked quality measure!") - # - J = float( Jb ) + float( Jo ) - # - if _sSc: - _SSV["CostFunctionJb"].append( Jb ) - _SSV["CostFunctionJo"].append( Jo ) - _SSV["CostFunctionJ" ].append( J ) - # - if "IndexOfOptimum" in _SSC or \ - "CurrentOptimum" in _SSC or \ - "SimulatedObservationAtCurrentOptimum" in _SSC: - IndexMin = numpy.argmin( _SSV["CostFunctionJ"][_nPS:] ) + _nPS - if "IndexOfOptimum" in _SSC: - _SSV["IndexOfOptimum"].append( IndexMin ) - if "CurrentOptimum" in _SSC: - _SSV["CurrentOptimum"].append( _SSV["CurrentState"][IndexMin] ) - if "SimulatedObservationAtCurrentOptimum" in _SSC: - _SSV["SimulatedObservationAtCurrentOptimum"].append( _SSV["SimulatedObservationAtCurrentState"][IndexMin] ) - # - if _fRt: - return _SSV - else: - if _QM in ["QR"]: # Pour le QuantileRegression - return _HX - else: - return J - # ============================================================================== if __name__ == "__main__": print('\n AUTODIAGNOSTIC\n')