# -*- 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 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
+from daCore.Interfaces import ImportFromScript, ImportFromFile
# ==============================================================================
class CacheManager(object):
__alc = False
__HxV = None
for i in range(min(len(self.__listOPCV),self.__lenghtOR)-1,-1,-1):
- if xValue.size != self.__listOPCV[i][0].size:
+ if not hasattr(xValue, 'size') or (xValue.size != self.__listOPCV[i][0].size):
# logging.debug("CM Différence de la taille %s de X et de celle %s du point %i déjà calculé", xValue.shape,i,self.__listOPCP[i].shape)
continue
if numpy.linalg.norm(numpy.ravel(xValue) - self.__listOPCV[i][0]) < self.__tolerBP * self.__listOPCV[i][2]:
NbCallsOfCached = 0
CM = CacheManager()
#
- def __init__(self, fromMethod=None, fromMatrix=None, avoidingRedundancy = True):
+ def __init__(self,
+ fromMethod = None,
+ fromMatrix = None,
+ avoidingRedundancy = True,
+ inputAsMultiFunction = False,
+ extraArguments = None,
+ ):
"""
- 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
+ - 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 )
- if fromMethod is not None:
+ self.__AvoidRC = bool( avoidingRedundancy )
+ self.__inputAsMF = bool( inputAsMultiFunction )
+ 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.__Matrix = None
+ self.__Type = "Method"
elif fromMatrix is not None:
self.__Method = None
self.__Matrix = numpy.matrix( fromMatrix, numpy.float )
"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
- devant a priori être du bon type.
+ Permet de restituer le résultat de l'application de l'opérateur à une
+ série d'arguments xValue. Cette méthode se contente d'appliquer, chaque
+ argument devant a priori être du bon type.
Arguments :
- - xValue : argument adapté pour appliquer l'opérateur
+ - les arguments par série sont :
+ - xValue : argument adapté pour appliquer l'opérateur
+ - HValue : valeur précalculée de l'opérateur en ce point
+ - argsAsSerie : indique si les arguments sont une mono ou multi-valeur
"""
- 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)
+ _xValue = (xValue,)
+ if HValue is not None:
+ _HValue = (HValue,)
else:
- __alreadyCalculated = False
+ _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[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 __alreadyCalculated:
- self.__addOneCacheCall()
- HxValue = __HxV
- else:
- if self.__Matrix is not None:
- self.__addOneMatrixCall()
- HxValue = self.__Matrix * xValue
+ if len(_xserie)>0 and self.__Matrix is None:
+ if self.__extraArgs is None:
+ _hserie = self.__Method( _xserie ) # Calcul MF
else:
- self.__addOneMethodCall()
- HxValue = self.__Method( xValue )
- if self.__AvoidRC:
- Operator.CM.storeValueInX(xValue,HxValue)
- #
- return HxValue
-
- def appliedControledFormTo(self, paire ):
+ _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:
+ _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, paires, argsAsSerie = False):
"""
- Permet de restituer le résultat de l'application de l'opérateur à une
- paire (xValue, uValue). Cette méthode se contente d'appliquer, son
+ 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
argument devant a priori être du bon type. Si la uValue est None,
on suppose que l'opérateur ne s'applique qu'à xValue.
Arguments :
- - xValue : argument X adapté pour appliquer l'opérateur
- - uValue : argument U adapté pour appliquer l'opérateur
+ - paires : les arguments par paire sont :
+ - xValue : argument X adapté pour appliquer l'opérateur
+ - uValue : argument U adapté pour appliquer l'opérateur
+ - argsAsSerie : indique si l'argument est une mono ou multi-valeur
"""
- assert len(paire) == 2, "Incorrect number of arguments"
- xValue, uValue = paire
+ if argsAsSerie: _xuValue = paires
+ else: _xuValue = (paires,)
+ PlatformInfo.isIterable( _xuValue, True, " in Operator.appliedControledFormTo" )
+ #
if self.__Matrix is not None:
- self.__addOneMatrixCall()
- return self.__Matrix * xValue
- elif uValue is not None:
- self.__addOneMethodCall()
- return self.__Method( (xValue, uValue) )
+ HxValue = []
+ for paire in _xuValue:
+ _xValue, _uValue = paire
+ self.__addOneMatrixCall()
+ HxValue.append( self.__Matrix * _xValue )
else:
- self.__addOneMethodCall()
- return self.__Method( xValue )
+ HxValue = []
+ for paire in _xuValue:
+ _xuValue = []
+ _xValue, _uValue = paire
+ if _uValue is not None:
+ _xuValue.append( paire )
+ else:
+ _xuValue.append( _xValue )
+ self.__addOneMethodCall( len(_xuValue) )
+ 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, 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.
- Cette méthode se contente d'appliquer, son argument devant a priori
- être du bon type. Si l'opérateur est linéaire car c'est une matrice,
- alors il est valable en tout point nominal et il n'est pas nécessaire
- d'utiliser xNominal.
- Arguments : une liste contenant
- - xNominal : argument permettant de donner le point où l'opérateur
- est construit pour etre ensuite appliqué
- - xValue : argument adapté pour appliquer l'opérateur
+ 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
+ xNominal. Cette méthode se contente d'appliquer, son argument devant a
+ priori être du bon type. Si l'opérateur est linéaire car c'est une
+ matrice, alors il est valable en tout point nominal et xNominal peut
+ être quelconque. Il n'y a qu'une seule paire par défaut, et argsAsSerie
+ permet d'indiquer que l'argument est multi-paires.
+ Arguments :
+ - paires : les arguments par paire sont :
+ - xNominal : série d'arguments permettant de donner le point où
+ l'opérateur est construit pour être ensuite appliqué
+ - xValue : série d'arguments adaptés pour appliquer l'opérateur
+ - argsAsSerie : indique si l'argument est une mono ou multi-valeur
"""
- 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) )
+ 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]
- def asMatrix(self, ValueForMethodForm = "UnknownVoidValue"):
+ def asMatrix(self, ValueForMethodForm = "UnknownVoidValue", argsAsSerie = False):
"""
Permet de renvoyer l'opérateur sous la forme d'une matrice
"""
if self.__Matrix is not None:
self.__addOneMatrixCall()
- return self.__Matrix
+ mValue = [self.__Matrix,]
elif ValueForMethodForm is not "UnknownVoidValue": # Ne pas utiliser "None"
- self.__addOneMethodCall()
- return numpy.matrix( self.__Method( (ValueForMethodForm, None) ) )
+ mValue = []
+ if argsAsSerie:
+ self.__addOneMethodCall( len(ValueForMethodForm) )
+ for _vfmf in ValueForMethodForm:
+ mValue.append( numpy.matrix( self.__Method(((_vfmf, None),)) ) )
+ else:
+ self.__addOneMethodCall()
+ mValue = self.__Method(((ValueForMethodForm, None),))
else:
raise ValueError("Matrix form of the operator defined as a function/method requires to give an operating point.")
+ #
+ if argsAsSerie: return mValue
+ else: return mValue[-1]
def shape(self):
"""
self.__NbCallsAsMatrix += 1 # Decompte local
Operator.NbCallsAsMatrix += 1 # Decompte global
- def __addOneMethodCall(self):
+ def __addOneMethodCall(self, nb = 1):
"Comptabilise un appel"
- self.__NbCallsAsMethod += 1 # Decompte local
- Operator.NbCallsAsMethod += 1 # Decompte global
+ self.__NbCallsAsMethod += nb # Decompte local
+ Operator.NbCallsAsMethod += nb # Decompte global
def __addOneCacheCall(self):
"Comptabilise un appel"
def __init__(self,
name = "GenericFullOperator",
asMatrix = None,
- asOneFunction = None, # Fonction
- asThreeFunctions = None, # Fonctions dictionary
- asScript = None, # Fonction(s) script
+ asOneFunction = None, # 1 Fonction
+ asThreeFunctions = None, # 3 Fonctions in a dictionary
+ 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):
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 "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 "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, extraArguments = self.__extraArgs )
+ 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 )
- 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, extraArguments = self.__extraArgs )
+ 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 )
- self.__FO["Tangent"] = Operator( fromMatrix = __matrice, avoidingRedundancy = avoidRC )
- self.__FO["Adjoint"] = Operator( fromMatrix = __matrice.T, avoidingRedundancy = avoidRC )
+ 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.")
+ raise ValueError("Improperly defined 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 not isinstance(__appliedInX, 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
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.__required_inputs = {"RequiredInputValues":{"mandatory":(), "optional":()}}
#
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["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")
def _pre_run(self, Parameters, Xb=None, Y=None, R=None, B=None, Q=None ):
"Pré-calcul"
self.__setParameters(Parameters)
#
# Corrections et complements
- def __test_vvalue( argument, variable, argname):
+ 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))
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):
+ #
+ 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))
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" )
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
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"
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
#
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 isinstance(self.__V.shape, (tuple, list)):
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, (list, numpy.ndarray, tuple)):
if numpy.ravel(other).size == self.shape[1]: # Vecteur
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.ismatrix() and isinstance(other, (list, numpy.ndarray, tuple)):
+ if numpy.ravel(other).size == self.shape[1]: # Vecteur
+ return numpy.asmatrix(numpy.ravel(other)) * self.__C
+ 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))
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"%(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():
raise ValueError("Loading as \"%s\" is not available"%__format)
return __formater.load(__filename, __content, __object)
+# ==============================================================================
+def MultiFonction( __xserie, _extraArguments = None, _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
+ """
+ # Vérifications et définitions initiales
+ if not PlatformInfo.isIterable( __xserie ):
+ raise TypeError("MultiFonction not iterable unkown input type: %s"%(type(__xserie),))
+ #
+ # Calculs effectifs
+ __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),))
+ #
+ return __multiHX
+
# ==============================================================================
def CostFunction3D(_x,
_Hm = None, # Pour simuler Hm(x) : HO["Direct"].appliedTo
# ==============================================================================
if __name__ == "__main__":
- print('\n AUTODIAGNOSTIC \n')
+ print('\n AUTODIAGNOSTIC\n')
