From a9cf86ae7b161dd145fe8174515e2f0b603f2ce5 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Sat, 2 Feb 2013 16:56:10 +0100 Subject: [PATCH] Improving and simplifying result variables access methods --- doc/advanced.rst | 4 +- doc/examples.rst | 8 +- doc/using.rst | 5 +- .../test004_ADAO_JDC_using_scripts.comm.in | 2 +- .../daSalome/test005_ADAO_Operators.comm.in | 2 +- examples/daSalome/test006_Observers.comm.in | 4 +- .../test006_Observers_observer_with_file.py | 4 +- .../Script_UserPostAnalysis.py | 6 +- src/daComposant/daAlgorithms/3DVAR.py | 20 +- src/daComposant/daAlgorithms/AdjointTest.py | 8 +- src/daComposant/daAlgorithms/Blue.py | 10 +- src/daComposant/daAlgorithms/EnsembleBlue.py | 14 +- src/daComposant/daAlgorithms/GradientTest.py | 8 +- src/daComposant/daAlgorithms/KalmanFilter.py | 33 +- .../daAlgorithms/LinearLeastSquares.py | 6 +- .../daAlgorithms/NonLinearLeastSquares.py | 18 +- .../daAlgorithms/ParticleSwarmOptimization.py | 4 +- .../daAlgorithms/QuantileRegression.py | 10 +- src/daComposant/daCore/AssimilationStudy.py | 257 ++++++-- src/daComposant/daCore/Persistence.py | 593 +++++++++--------- src/daComposant/daDiagnostics/RMS.py | 2 +- .../daDiagnostics/ReduceVariance.py | 4 +- .../daNumerics/ApproximatedDerivatives.py | 3 + src/tests/daSalome/test000_Blue.py | 12 +- .../daSalome/test000_Blue_AnalysisCode.py | 12 +- src/tests/daSalome/test017.comm.in | 4 +- .../test_aster_zzzz159a_LBFGSB.comm.in | 8 +- 27 files changed, 601 insertions(+), 460 deletions(-) diff --git a/doc/advanced.rst b/doc/advanced.rst index e16a843..b5cc361 100644 --- a/doc/advanced.rst +++ b/doc/advanced.rst @@ -108,12 +108,12 @@ This can be done using "*observers*", that are scripts associated with one variable. In order to use this feature, one has to build scripts using as standard inputs (available in the namespace) the variables ``var`` and ``info``. The variable ``var`` is to be used in the same way as for the final ADD object, -that is as a list object through its "*valueserie*" method. +that is as a list/tuple object. As an example, here is one very simple script used to print the value of one monitored variable:: - print " --->",info," Value =",var.valueserie(-1) + print " --->",info," Value =",var[-1] Stored in a python file, this script can be associated to each variable available in the "*SELECTION*" keyword of the "*Observers*" command: diff --git a/doc/examples.rst b/doc/examples.rst index 0dd0baf..6125a57 100644 --- a/doc/examples.rst +++ b/doc/examples.rst @@ -153,7 +153,7 @@ To obtain this, the in-line script node need to have an input port of type the "*algoResults*" output port of the computation bloc. Then the code to fill in the script node is:: - Xa = results.ADD.get("Analysis").valueserie(-1) + Xa = results.ADD.get("Analysis")[-1] print print "Analysis =",Xa @@ -522,9 +522,9 @@ illustrates the fact:: import numpy # xt, names = True_state() - xa = ADD.get("Analysis").valueserie(-1) - x_series = ADD.get("CurrentState").valueserie() - J = ADD.get("CostFunctionJ").valueserie() + xa = ADD.get("Analysis")[-1] + x_series = ADD.get("CurrentState")[:] + J = ADD.get("CostFunctionJ")[:] # # Verifying the results by printing # --------------------------------- diff --git a/doc/using.rst b/doc/using.rst index a10c7e3..f63e06b 100644 --- a/doc/using.rst +++ b/doc/using.rst @@ -159,15 +159,14 @@ variables stored along the calculation. The main is the "*Analysis*" one, that can be obtained by the python command (for example in an in-line script node or a script provided through the "*UserPostAnalysis*" keyword):: - ADD = algoResults.getAssimilationStudy() - Analysis = ADD.get("Analysis").valueserie() + Analysis = ADD.get("Analysis")[:] "*Analysis*" is a complex object, similar to a list of values calculated at each step of data assimilation calculation. In order to get and print the optimal data assimilation state evaluation, in script provided through the "*UserPostAnalysis*" keyword, one can use:: - Xa = ADD.get("Analysis").valueserie(-1) + Xa = ADD.get("Analysis")[-1] print "Optimal state:", Xa print diff --git a/examples/daSalome/test004_ADAO_JDC_using_scripts.comm.in b/examples/daSalome/test004_ADAO_JDC_using_scripts.comm.in index 26b9341..f400c52 100644 --- a/examples/daSalome/test004_ADAO_JDC_using_scripts.comm.in +++ b/examples/daSalome/test004_ADAO_JDC_using_scripts.comm.in @@ -26,7 +26,7 @@ ASSIMILATION_STUDY(Study_name='Test', UserPostAnalysis=_F(FROM='String', STRING= """import numpy -Xa = ADD.get("Analysis").valueserie(-1) +Xa = ADD.get("Analysis")[-1] print print "Size of Analysis = %i"%len(Xa) print "Min, mean, max = %8.3f, %8.3f, %8.3f"%(min(Xa),numpy.mean(Xa),max(Xa)) diff --git a/examples/daSalome/test005_ADAO_Operators.comm.in b/examples/daSalome/test005_ADAO_Operators.comm.in index 2c60c85..76f2c94 100644 --- a/examples/daSalome/test005_ADAO_Operators.comm.in +++ b/examples/daSalome/test005_ADAO_Operators.comm.in @@ -27,7 +27,7 @@ ASSIMILATION_STUDY(Study_name='Test', STRING= """import numpy Xb = Study.getBackground() -Xa = ADD.get("Analysis").valueserie(-1) +Xa = ADD.get("Analysis")[-1] print print "Size of Background...........= %i"%len(Xb.A1) print "Size of Analysis.............= %i"%len(Xa) diff --git a/examples/daSalome/test006_Observers.comm.in b/examples/daSalome/test006_Observers.comm.in index 365a064..26d95db 100644 --- a/examples/daSalome/test006_Observers.comm.in +++ b/examples/daSalome/test006_Observers.comm.in @@ -34,7 +34,7 @@ ASSIMILATION_STUDY(Study_name='test_observers', CostFunctionJ_data=_F(NodeType='String', Value= """print " ---> observerCost" -print " var =",var.valueserie() +print " var =",var[:] print " info =",info # import Gnuplot @@ -46,7 +46,7 @@ except NameError: gp = Gnuplot.Gnuplot() gp('set style data lines') gp('set title "'+str(info)+'"') -gp.plot( Gnuplot.Data( var.valueserie() ) ) +gp.plot( Gnuplot.Data( var[:] ) ) filename = os.path.join("/tmp", "imageCost_%02i.ps"%numero) print " imageCost %s"%filename gp.hardcopy(filename=filename, color=1) diff --git a/examples/daSalome/test006_Observers_observer_with_file.py b/examples/daSalome/test006_Observers_observer_with_file.py index c85e5bc..1ca883d 100644 --- a/examples/daSalome/test006_Observers_observer_with_file.py +++ b/examples/daSalome/test006_Observers_observer_with_file.py @@ -1,5 +1,5 @@ print " ---> observerState" -print " var =",var.valueserie(-1) +print " var =",var[-1] print " info =",info # import Gnuplot @@ -13,7 +13,7 @@ except NameError: gp = Gnuplot.Gnuplot() gp('set style data lines') gp('set title "'+str(info)+'"') -gp.plot( Gnuplot.Data( var.valueserie(-1) ) ) +gp.plot( Gnuplot.Data( var[-1] ) ) filename = os.path.join("/tmp", "imageState_%02i.ps"%numero) print " imageState \"%s\""%filename diff --git a/examples/daSkeletons/External_data_definition_by_scripts/Script_UserPostAnalysis.py b/examples/daSkeletons/External_data_definition_by_scripts/Script_UserPostAnalysis.py index a5bf58c..b0534cd 100644 --- a/examples/daSkeletons/External_data_definition_by_scripts/Script_UserPostAnalysis.py +++ b/examples/daSkeletons/External_data_definition_by_scripts/Script_UserPostAnalysis.py @@ -34,9 +34,9 @@ from Physical_data_and_covariance_matrices import True_state import numpy # xt, names = True_state() -xa = ADD.get("Analysis").valueserie(-1) -x_series = ADD.get("CurrentState").valueserie() -J = ADD.get("CostFunctionJ").valueserie() +xa = ADD.get("Analysis")[-1] +x_series = ADD.get("CurrentState")[:] +J = ADD.get("CostFunctionJ")[:] # # Verifying the results by printing # --------------------------------- diff --git a/src/daComposant/daAlgorithms/3DVAR.py b/src/daComposant/daAlgorithms/3DVAR.py index 78ca36e..9b63849 100644 --- a/src/daComposant/daAlgorithms/3DVAR.py +++ b/src/daComposant/daAlgorithms/3DVAR.py @@ -87,7 +87,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): listval = ["APosterioriCovariance", "BMA", "OMA", "OMB", "Innovation", "SigmaObs2", "MahalanobisConsistency"] ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -107,13 +107,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Opérateur d'observation # ----------------------- - Hm = H["Direct"].appliedTo - Ha = H["Adjoint"].appliedInXTo + Hm = HO["Direct"].appliedTo + Ha = HO["Adjoint"].appliedInXTo # # Utilisation éventuelle d'un vecteur H(Xb) précalculé # ---------------------------------------------------- - if H["AppliedToX"] is not None and H["AppliedToX"].has_key("HXb"): - HXb = H["AppliedToX"]["HXb"] + if HO["AppliedToX"] is not None and HO["AppliedToX"].has_key("HXb"): + HXb = HO["AppliedToX"]["HXb"] else: HXb = Hm( Xb ) HXb = numpy.asmatrix(numpy.ravel( HXb )).T @@ -240,13 +240,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): else: raise ValueError("Error in Minimizer name: %s"%self._parameters["Minimizer"]) # - StepMin = numpy.argmin( self.StoredVariables["CostFunctionJ"].valueserie()[nbPreviousSteps:] ) + nbPreviousSteps - MinJ = self.StoredVariables["CostFunctionJ"].valueserie(step = StepMin) + IndexMin = numpy.argmin( self.StoredVariables["CostFunctionJ"][nbPreviousSteps:] ) + nbPreviousSteps + MinJ = self.StoredVariables["CostFunctionJ"][IndexMin] # # Correction pour pallier a un bug de TNC sur le retour du Minimum # ---------------------------------------------------------------- if self._parameters["StoreInternalVariables"]: - Minimum = self.StoredVariables["CurrentState"].valueserie(step = StepMin) + Minimum = self.StoredVariables["CurrentState"][IndexMin] # # Obtention de l'analyse # ---------------------- @@ -257,9 +257,9 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # Calcul de la covariance d'analyse # --------------------------------- if "APosterioriCovariance" in self._parameters["StoreSupplementaryCalculations"]: - HtM = H["Tangent"].asMatrix(ValueForMethodForm = Xa) + HtM = HO["Tangent"].asMatrix(ValueForMethodForm = Xa) HtM = HtM.reshape(Y.size,Xa.size) # ADAO & check shape - HaM = H["Adjoint"].asMatrix(ValueForMethodForm = Xa) + HaM = HO["Adjoint"].asMatrix(ValueForMethodForm = Xa) HaM = HaM.reshape(Xa.size,Y.size) # ADAO & check shape HessienneI = [] nb = Xa.size diff --git a/src/daComposant/daAlgorithms/AdjointTest.py b/src/daComposant/daAlgorithms/AdjointTest.py index 77849fd..7276b7b 100644 --- a/src/daComposant/daAlgorithms/AdjointTest.py +++ b/src/daComposant/daAlgorithms/AdjointTest.py @@ -69,7 +69,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): message = "Titre du tableau et de la figure", ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -79,9 +79,9 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Opérateur d'observation # ----------------------- - Hm = H["Direct"].appliedTo - Ht = H["Tangent"].appliedInXTo - Ha = H["Adjoint"].appliedInXTo + Hm = HO["Direct"].appliedTo + Ht = HO["Tangent"].appliedInXTo + Ha = HO["Adjoint"].appliedInXTo # # Construction des perturbations # ------------------------------ diff --git a/src/daComposant/daAlgorithms/Blue.py b/src/daComposant/daAlgorithms/Blue.py index 1a5278f..46130cf 100644 --- a/src/daComposant/daAlgorithms/Blue.py +++ b/src/daComposant/daAlgorithms/Blue.py @@ -38,7 +38,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): listval = ["APosterioriCovariance", "BMA", "OMA", "OMB", "Innovation", "SigmaBck2", "SigmaObs2", "MahalanobisConsistency"] ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -48,13 +48,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Opérateur d'observation # ----------------------- - Hm = H["Tangent"].asMatrix(None) - Ha = H["Adjoint"].asMatrix(None) + Hm = HO["Tangent"].asMatrix(None) + Ha = HO["Adjoint"].asMatrix(None) # # Utilisation éventuelle d'un vecteur H(Xb) précalculé # ---------------------------------------------------- - if H["AppliedToX"] is not None and H["AppliedToX"].has_key("HXb"): - HXb = H["AppliedToX"]["HXb"] + if HO["AppliedToX"] is not None and HO["AppliedToX"].has_key("HXb"): + HXb = HO["AppliedToX"]["HXb"] else: HXb = Hm * Xb HXb = numpy.asmatrix(numpy.ravel( HXb )).T diff --git a/src/daComposant/daAlgorithms/EnsembleBlue.py b/src/daComposant/daAlgorithms/EnsembleBlue.py index c50f2e1..8643cf1 100644 --- a/src/daComposant/daAlgorithms/EnsembleBlue.py +++ b/src/daComposant/daAlgorithms/EnsembleBlue.py @@ -36,7 +36,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): message = "Graine fixée pour le générateur aléatoire", ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None ): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -77,12 +77,12 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Initialisation des opérateurs d'observation et de la matrice gain # ----------------------------------------------------------------- - Hm = H["Tangent"].asMatrix(None) - Ha = H["Adjoint"].asMatrix(None) + Hm = HO["Tangent"].asMatrix(None) + Ha = HO["Adjoint"].asMatrix(None) # # Calcul de la matrice de gain dans l'espace le plus petit et de l'analyse # ------------------------------------------------------------------------ - if Y.size <= Xb.valueserie(0).size: + if Y.size <= Xb[0].size: if self._parameters["R_scalar"] is not None: R = self._parameters["R_scalar"] * numpy.eye(Y.size, dtype=numpy.float) K = B * Ha * (Hm * B * Ha + R).I @@ -92,15 +92,15 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # Calcul du BLUE pour chaque membre de l'ensemble # ----------------------------------------------- for iens in range(nb_ens): - d = EnsembleY[:,iens] - Hm * Xb.valueserie(iens) - Xa = Xb.valueserie(iens) + K*d + d = EnsembleY[:,iens] - Hm * Xb[iens] + Xa = Xb[iens] + K*d self.StoredVariables["CurrentState"].store( Xa.A1 ) self.StoredVariables["Innovation"].store( d.A1 ) # # Fabrication de l'analyse # ------------------------ - Members = self.StoredVariables["CurrentState"].valueserie()[-nb_ens:] + Members = self.StoredVariables["CurrentState"][-nb_ens:] Xa = numpy.matrix( Members ).mean(axis=0) self.StoredVariables["Analysis"].store( Xa.A1 ) # diff --git a/src/daComposant/daAlgorithms/GradientTest.py b/src/daComposant/daAlgorithms/GradientTest.py index 1e574cb..aa547a7 100644 --- a/src/daComposant/daAlgorithms/GradientTest.py +++ b/src/daComposant/daAlgorithms/GradientTest.py @@ -87,7 +87,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): message = "Label de la courbe tracée dans la figure", ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -97,9 +97,9 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Opérateur d'observation # ----------------------- - Hm = H["Direct"].appliedTo + Hm = HO["Direct"].appliedTo if self._parameters["ResiduFormula"] is "Taylor": - Ht = H["Tangent"].appliedInXTo + Ht = HO["Tangent"].appliedInXTo # # Construction des perturbations # ------------------------------ @@ -231,7 +231,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): f.write(msgs) f.close() # - Residus = self.StoredVariables["CostFunctionJ"].valueserie()[-len(Perturbations):] + Residus = self.StoredVariables["CostFunctionJ"][-len(Perturbations):] if self._parameters["ResiduFormula"] is "Taylor": PerturbationsCarre = [ 10**(2*i) for i in xrange(-len(NormesdFXGdX)+1,1) ] PerturbationsCarre.reverse() diff --git a/src/daComposant/daAlgorithms/KalmanFilter.py b/src/daComposant/daAlgorithms/KalmanFilter.py index 3cfd1f0..a6a1514 100644 --- a/src/daComposant/daAlgorithms/KalmanFilter.py +++ b/src/daComposant/daAlgorithms/KalmanFilter.py @@ -23,6 +23,7 @@ import logging from daCore import BasicObjects, PlatformInfo m = PlatformInfo.SystemUsage() +import numpy # ============================================================================== class ElementaryAlgorithm(BasicObjects.Algorithm): @@ -36,7 +37,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): listval = ["APosterioriCovariance", "Innovation"] ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -44,20 +45,20 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # ---------------------- self.setParameters(Parameters) # - # Opérateur d'observation - # ----------------------- - Hm = H["Tangent"].asMatrix(None) - Ha = H["Adjoint"].asMatrix(None) - # + # Opérateurs + # ---------- if B is None: raise ValueError("Background error covariance matrix has to be properly defined!") if R is None: raise ValueError("Observation error covariance matrix has to be properly defined!") + Hm = HO["Tangent"].asMatrix(None) + Ha = HO["Adjoint"].asMatrix(None) + # + Mm = EM["Tangent"].asMatrix(None) + Mt = EM["Adjoint"].asMatrix(None) # - # Opérateur d'évolution - # --------------------- - Mm = M["Tangent"].asMatrix(None) - Mt = M["Adjoint"].asMatrix(None) + if CM is not None and U is not None: + Cm = CM["Tangent"].asMatrix(None) # # Nombre de pas du Kalman identique au nombre de pas d'observations # ----------------------------------------------------------------- @@ -72,10 +73,18 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): self.StoredVariables["APosterioriCovariance"].store( Pn ) # for step in range(duration-1): - Xn_predicted = Mm * Xn + if CM is not None and U is not None: + if hasattr(U,"store") and len(U)>1: + Xn_predicted = Mm * Xn + Cm * numpy.asmatrix(numpy.ravel( U[step] )).T + elif hasattr(U,"store") and len(U)==1: + Xn_predicted = Mm * Xn + Cm * numpy.asmatrix(numpy.ravel( U[0] )).T + else: + Xn_predicted = Mm * Xn + Cm * numpy.asmatrix(numpy.ravel( U )).T + else: + Xn_predicted = Mm * Xn Pn_predicted = Mm * Pn * Mt + Q # - d = Y.valueserie(step+1) - Hm * Xn_predicted + d = numpy.asmatrix(numpy.ravel( Y[step+1] )).T - Hm * Xn_predicted K = Pn_predicted * Ha * (Hm * Pn_predicted * Ha + R).I Xn = Xn_predicted + K * d Pn = Pn_predicted - K * Hm * Pn_predicted diff --git a/src/daComposant/daAlgorithms/LinearLeastSquares.py b/src/daComposant/daAlgorithms/LinearLeastSquares.py index 3d59e9e..5ef5e68 100644 --- a/src/daComposant/daAlgorithms/LinearLeastSquares.py +++ b/src/daComposant/daAlgorithms/LinearLeastSquares.py @@ -38,7 +38,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): listval = ["OMA"] ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -48,8 +48,8 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Opérateur d'observation # ----------------------- - Hm = H["Tangent"].asMatrix(None) - Ha = H["Adjoint"].asMatrix(None) + Hm = HO["Tangent"].asMatrix(None) + Ha = HO["Adjoint"].asMatrix(None) # if R is not None: RI = R.I diff --git a/src/daComposant/daAlgorithms/NonLinearLeastSquares.py b/src/daComposant/daAlgorithms/NonLinearLeastSquares.py index c325988..634c36c 100644 --- a/src/daComposant/daAlgorithms/NonLinearLeastSquares.py +++ b/src/daComposant/daAlgorithms/NonLinearLeastSquares.py @@ -87,7 +87,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): listval = ["BMA", "OMA", "OMB", "Innovation"] ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -107,13 +107,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Opérateur d'observation # ----------------------- - Hm = H["Direct"].appliedTo - Ha = H["Adjoint"].appliedInXTo + Hm = HO["Direct"].appliedTo + Ha = HO["Adjoint"].appliedInXTo # # Utilisation éventuelle d'un vecteur H(Xb) précalculé # ---------------------------------------------------- - if H["AppliedToX"] is not None and H["AppliedToX"].has_key("HXb"): - HXb = H["AppliedToX"]["HXb"] + if HO["AppliedToX"] is not None and HO["AppliedToX"].has_key("HXb"): + HXb = HO["AppliedToX"]["HXb"] else: HXb = Hm( Xb ) HXb = numpy.asmatrix(numpy.ravel( HXb )).T @@ -194,7 +194,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): GradJb = 0. GradJo = - Ha( (_X, RI * (Y - _HX)) ) GradJ = numpy.asmatrix( numpy.ravel( GradJb ) + numpy.ravel( GradJo ) ).T - return - RdemiI*H["Tangent"].asMatrix( _X ) + return - RdemiI*HO["Tangent"].asMatrix( _X ) # # Point de démarrage de l'optimisation : Xini = Xb # ------------------------------------ @@ -281,13 +281,13 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): else: raise ValueError("Error in Minimizer name: %s"%self._parameters["Minimizer"]) # - StepMin = numpy.argmin( self.StoredVariables["CostFunctionJ"].valueserie()[nbPreviousSteps:] ) + nbPreviousSteps - MinJ = self.StoredVariables["CostFunctionJ"].valueserie(step = StepMin) + IndexMin = numpy.argmin( self.StoredVariables["CostFunctionJ"][nbPreviousSteps:] ) + nbPreviousSteps + MinJ = self.StoredVariables["CostFunctionJ"][IndexMin] # # Correction pour pallier a un bug de TNC sur le retour du Minimum # ---------------------------------------------------------------- if self._parameters["StoreInternalVariables"]: - Minimum = self.StoredVariables["CurrentState"].valueserie(step = StepMin) + Minimum = self.StoredVariables["CurrentState"][IndexMin] # # Obtention de l'analyse # ---------------------- diff --git a/src/daComposant/daAlgorithms/ParticleSwarmOptimization.py b/src/daComposant/daAlgorithms/ParticleSwarmOptimization.py index 1c9b869..5558da5 100644 --- a/src/daComposant/daAlgorithms/ParticleSwarmOptimization.py +++ b/src/daComposant/daAlgorithms/ParticleSwarmOptimization.py @@ -90,7 +90,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): listval = ["BMA", "OMA", "OMB", "Innovation"] ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -113,7 +113,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Opérateur d'observation # ----------------------- - Hm = H["Direct"].appliedTo + Hm = HO["Direct"].appliedTo # # Précalcul des inversions de B et R # ---------------------------------- diff --git a/src/daComposant/daAlgorithms/QuantileRegression.py b/src/daComposant/daAlgorithms/QuantileRegression.py index 76743ec..6200721 100644 --- a/src/daComposant/daAlgorithms/QuantileRegression.py +++ b/src/daComposant/daAlgorithms/QuantileRegression.py @@ -72,7 +72,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): listval = ["BMA", "OMA", "OMB", "Innovation"] ) - def run(self, Xb=None, Y=None, H=None, M=None, R=None, B=None, Q=None, Parameters=None): + def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None): logging.debug("%s Lancement"%self._name) logging.debug("%s Taille mémoire utilisée de %.1f Mo"%(self._name, m.getUsedMemory("M"))) # @@ -82,12 +82,12 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # # Opérateur d'observation # ----------------------- - Hm = H["Direct"].appliedTo + Hm = HO["Direct"].appliedTo # # Utilisation éventuelle d'un vecteur H(Xb) précalculé # ---------------------------------------------------- - if H["AppliedToX"] is not None and H["AppliedToX"].has_key("HXb"): - HXb = H["AppliedToX"]["HXb"] + if HO["AppliedToX"] is not None and HO["AppliedToX"].has_key("HXb"): + HXb = HO["AppliedToX"]["HXb"] else: HXb = Hm( Xb ) HXb = numpy.asmatrix(numpy.ravel( HXb )).T @@ -118,7 +118,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm): # def GradientOfCostFunction(x): _X = numpy.asmatrix(numpy.ravel( x )).T - Hg = H["Tangent"].asMatrix( _X ) + Hg = HO["Tangent"].asMatrix( _X ) return Hg # # Point de démarrage de l'optimisation : Xini = Xb diff --git a/src/daComposant/daCore/AssimilationStudy.py b/src/daComposant/daCore/AssimilationStudy.py index b415835..05a0abe 100644 --- a/src/daComposant/daCore/AssimilationStudy.py +++ b/src/daComposant/daCore/AssimilationStudy.py @@ -66,13 +66,15 @@ class AssimilationStudy: de covariance est B. """ self.__name = str(name) - self.__Xb = None - self.__Y = None - self.__B = None - self.__R = None - self.__Q = None - self.__H = {} - self.__M = {} + self.__Xb = None + self.__Y = None + self.__U = None + self.__B = None + self.__R = None + self.__Q = None + self.__HO = {} + self.__EM = {} + self.__CM = {} # self.__X = Persistence.OneVector() self.__Parameters = {} @@ -129,7 +131,7 @@ class AssimilationStudy: else: self.__Xb = asPersistentVector else: - raise ValueError("Error: improperly defined background") + raise ValueError("Error: improperly defined background, it requires at minima either a vector, a list/tuple of vectors or a persistent object") if toBeStored: self.__StoredInputs["Background"] = self.__Xb return 0 @@ -200,7 +202,7 @@ class AssimilationStudy: else: self.__Y = asPersistentVector else: - raise ValueError("Error: improperly defined observations") + raise ValueError("Error: improperly defined observations, it requires at minima either a vector, a list/tuple of vectors or a persistent object") if toBeStored: self.__StoredInputs["Observation"] = self.__Y return 0 @@ -287,45 +289,45 @@ class AssimilationStudy: centeredDF = asFunction["withCenteredDF"], increment = asFunction["withIncrement"], dX = asFunction["withdX"] ) - self.__H["Direct"] = Operator( fromMethod = FDA.DirectOperator ) - self.__H["Tangent"] = Operator( fromMethod = FDA.TangentOperator ) - self.__H["Adjoint"] = Operator( fromMethod = FDA.AdjointOperator ) + self.__HO["Direct"] = Operator( fromMethod = FDA.DirectOperator ) + self.__HO["Tangent"] = Operator( fromMethod = FDA.TangentOperator ) + self.__HO["Adjoint"] = Operator( fromMethod = FDA.AdjointOperator ) elif (type(asFunction) is type({})) and \ asFunction.has_key("Tangent") and asFunction.has_key("Adjoint") and \ (asFunction["Tangent"] is not None) and (asFunction["Adjoint"] is not None): if not asFunction.has_key("Direct") or (asFunction["Direct"] is None): - self.__H["Direct"] = Operator( fromMethod = asFunction["Tangent"] ) + self.__HO["Direct"] = Operator( fromMethod = asFunction["Tangent"] ) else: - self.__H["Direct"] = Operator( fromMethod = asFunction["Direct"] ) - self.__H["Tangent"] = Operator( fromMethod = asFunction["Tangent"] ) - self.__H["Adjoint"] = Operator( fromMethod = asFunction["Adjoint"] ) + self.__HO["Direct"] = Operator( fromMethod = asFunction["Direct"] ) + self.__HO["Tangent"] = Operator( fromMethod = asFunction["Tangent"] ) + self.__HO["Adjoint"] = Operator( fromMethod = asFunction["Adjoint"] ) elif asMatrix is not None: matrice = numpy.matrix( asMatrix, numpy.float ) - self.__H["Direct"] = Operator( fromMatrix = matrice ) - self.__H["Tangent"] = Operator( fromMatrix = matrice ) - self.__H["Adjoint"] = Operator( fromMatrix = matrice.T ) + self.__HO["Direct"] = Operator( fromMatrix = matrice ) + self.__HO["Tangent"] = Operator( fromMatrix = matrice ) + self.__HO["Adjoint"] = Operator( fromMatrix = matrice.T ) del matrice else: raise ValueError("Improperly defined observation operator, it requires at minima either a matrix, a Direct for approximate derivatives or a Tangent/Adjoint pair.") # if appliedToX is not None: - self.__H["AppliedToX"] = {} + self.__HO["AppliedToX"] = {} if type(appliedToX) is not dict: raise ValueError("Error: observation operator defined by \"appliedToX\" need a dictionary as argument.") for key in appliedToX.keys(): if type( appliedToX[key] ) is type( numpy.matrix([]) ): # Pour le cas où l'on a une vraie matrice - self.__H["AppliedToX"][key] = numpy.matrix( appliedToX[key].A1, numpy.float ).T + self.__HO["AppliedToX"][key] = numpy.matrix( appliedToX[key].A1, numpy.float ).T elif type( appliedToX[key] ) is type( numpy.array([]) ) and len(appliedToX[key].shape) > 1: # Pour le cas où l'on a un vecteur représenté en array avec 2 dimensions - self.__H["AppliedToX"][key] = numpy.matrix( appliedToX[key].reshape(len(appliedToX[key]),), numpy.float ).T + self.__HO["AppliedToX"][key] = numpy.matrix( appliedToX[key].reshape(len(appliedToX[key]),), numpy.float ).T else: - self.__H["AppliedToX"][key] = numpy.matrix( appliedToX[key], numpy.float ).T + self.__HO["AppliedToX"][key] = numpy.matrix( appliedToX[key], numpy.float ).T else: - self.__H["AppliedToX"] = None + self.__HO["AppliedToX"] = None # if toBeStored: - self.__StoredInputs["ObservationOperator"] = self.__H + self.__StoredInputs["ObservationOperator"] = self.__HO return 0 # ----------------------------------------------------------- @@ -371,29 +373,29 @@ class AssimilationStudy: centeredDF = asFunction["withCenteredDF"], increment = asFunction["withIncrement"], dX = asFunction["withdX"] ) - self.__M["Direct"] = Operator( fromMethod = FDA.DirectOperator ) - self.__M["Tangent"] = Operator( fromMethod = FDA.TangentOperator ) - self.__M["Adjoint"] = Operator( fromMethod = FDA.AdjointOperator ) + self.__EM["Direct"] = Operator( fromMethod = FDA.DirectOperator ) + self.__EM["Tangent"] = Operator( fromMethod = FDA.TangentOperator ) + self.__EM["Adjoint"] = Operator( fromMethod = FDA.AdjointOperator ) elif (type(asFunction) is type({})) and \ asFunction.has_key("Tangent") and asFunction.has_key("Adjoint") and \ (asFunction["Tangent"] is not None) and (asFunction["Adjoint"] is not None): if not asFunction.has_key("Direct") or (asFunction["Direct"] is None): - self.__M["Direct"] = Operator( fromMethod = asFunction["Tangent"] ) + self.__EM["Direct"] = Operator( fromMethod = asFunction["Tangent"] ) else: - self.__M["Direct"] = Operator( fromMethod = asFunction["Direct"] ) - self.__M["Tangent"] = Operator( fromMethod = asFunction["Tangent"] ) - self.__M["Adjoint"] = Operator( fromMethod = asFunction["Adjoint"] ) + self.__EM["Direct"] = Operator( fromMethod = asFunction["Direct"] ) + self.__EM["Tangent"] = Operator( fromMethod = asFunction["Tangent"] ) + self.__EM["Adjoint"] = Operator( fromMethod = asFunction["Adjoint"] ) elif asMatrix is not None: matrice = numpy.matrix( asMatrix, numpy.float ) - self.__M["Direct"] = Operator( fromMatrix = matrice ) - self.__M["Tangent"] = Operator( fromMatrix = matrice ) - self.__M["Adjoint"] = Operator( fromMatrix = matrice.T ) + self.__EM["Direct"] = Operator( fromMatrix = matrice ) + self.__EM["Tangent"] = Operator( fromMatrix = matrice ) + self.__EM["Adjoint"] = Operator( fromMatrix = matrice.T ) del matrice else: - raise ValueError("Improperly defined evolution operator, it requires at minima either a matrix, a Direct for approximate derivatives or a Tangent/Adjoint pair.") + raise ValueError("Improperly defined evolution model, it requires at minima either a matrix, a Direct for approximate derivatives or a Tangent/Adjoint pair.") # if toBeStored: - self.__StoredInputs["EvolutionModel"] = self.__M + self.__StoredInputs["EvolutionModel"] = self.__EM return 0 def setEvolutionError(self, @@ -432,6 +434,108 @@ class AssimilationStudy: self.__StoredInputs["EvolutionError"] = self.__Q return 0 + # ----------------------------------------------------------- + def setControlModel(self, + asFunction = {"Direct":None, "Tangent":None, "Adjoint":None, + "useApproximatedDerivatives":False, + "withCenteredDF" :False, + "withIncrement" :0.01, + "withdX" :None, + }, + asMatrix = None, + Scheduler = None, + toBeStored = False, + ): + """ + Permet de définir un opérateur de controle C. L'ordre de priorité des + définitions et leur sens sont les suivants : + - si asFunction["Tangent"] et asFunction["Adjoint"] ne sont pas None + alors on définit l'opérateur à l'aide de fonctions. Si la fonction + "Direct" n'est pas définie, on prend la fonction "Tangent". + Si "useApproximatedDerivatives" est vrai, on utilise une approximation + des opérateurs tangents et adjoints. On utilise par défaut des + différences finies non centrées ou centrées (si "withCenteredDF" est + vrai) avec un incrément multiplicatif "withIncrement" de 1% autour + du point courant ou sur le point fixe "withdX". + - si les fonctions ne sont pas disponibles et si asMatrix n'est pas + None, alors on définit l'opérateur "Direct" et "Tangent" à l'aide de + la matrice, et l'opérateur "Adjoint" à l'aide de la transposée. La + matrice fournie doit être sous une forme compatible avec le + constructeur de numpy.matrix. + - toBeStored : booléen indiquant si la donnée d'entrée est sauvée pour + être rendue disponible au même titre que les variables de calcul + """ + if (type(asFunction) is type({})) and \ + asFunction.has_key("useApproximatedDerivatives") and bool(asFunction["useApproximatedDerivatives"]) and \ + asFunction.has_key("Direct") and (asFunction["Direct"] is not None): + if not asFunction.has_key("withCenteredDF"): asFunction["withCenteredDF"] = False + if not asFunction.has_key("withIncrement"): asFunction["withIncrement"] = 0.01 + if not asFunction.has_key("withdX"): asFunction["withdX"] = None + from daNumerics.ApproximatedDerivatives import FDApproximation + FDA = FDApproximation( + Function = asFunction["Direct"], + centeredDF = asFunction["withCenteredDF"], + increment = asFunction["withIncrement"], + dX = asFunction["withdX"] ) + self.__CM["Direct"] = Operator( fromMethod = FDA.DirectOperator ) + self.__CM["Tangent"] = Operator( fromMethod = FDA.TangentOperator ) + self.__CM["Adjoint"] = Operator( fromMethod = FDA.AdjointOperator ) + elif (type(asFunction) is type({})) and \ + asFunction.has_key("Tangent") and asFunction.has_key("Adjoint") and \ + (asFunction["Tangent"] is not None) and (asFunction["Adjoint"] is not None): + if not asFunction.has_key("Direct") or (asFunction["Direct"] is None): + self.__CM["Direct"] = Operator( fromMethod = asFunction["Tangent"] ) + else: + self.__CM["Direct"] = Operator( fromMethod = asFunction["Direct"] ) + self.__CM["Tangent"] = Operator( fromMethod = asFunction["Tangent"] ) + self.__CM["Adjoint"] = Operator( fromMethod = asFunction["Adjoint"] ) + elif asMatrix is not None: + matrice = numpy.matrix( asMatrix, numpy.float ) + self.__CM["Direct"] = Operator( fromMatrix = matrice ) + self.__CM["Tangent"] = Operator( fromMatrix = matrice ) + self.__CM["Adjoint"] = Operator( fromMatrix = matrice.T ) + del matrice + else: + raise ValueError("Improperly defined input control model, it requires at minima either a matrix, a Direct for approximate derivatives or a Tangent/Adjoint pair.") + # + if toBeStored: + self.__StoredInputs["ControlModel"] = self.__CM + return 0 + + def setControlInput(self, + asVector = None, + asPersistentVector = None, + Scheduler = None, + toBeStored = False, + ): + """ + Permet de définir le controle en entree : + - asVector : entrée des données, comme un vecteur compatible avec le + constructeur de numpy.matrix + - asPersistentVector : entrée des données, comme un vecteur de type + persistent contruit avec la classe ad-hoc "Persistence" + - Scheduler est le contrôle temporel des données disponibles + - toBeStored : booléen indiquant si la donnée d'entrée est sauvée pour + être rendue disponible au même titre que les variables de calcul + """ + if asVector is not None: + if isinstance(asVector,numpy.matrix): + self.__U = numpy.matrix( asVector.A1, numpy.float ).T + else: + self.__U = numpy.matrix( asVector, numpy.float ).T + elif asPersistentVector is not None: + if isinstance(asPersistentVector,list) or isinstance( asPersistentVector,tuple): + self.__U = Persistence.OneVector("ControlInput", basetype=numpy.array) + for y in asPersistentVector: + self.__U.store( y ) + else: + self.__U = asPersistentVector + else: + raise ValueError("Error: improperly defined control input, it requires at minima either a vector, a list/tuple of vectors or a persistent object") + if toBeStored: + self.__StoredInputs["ControlInput"] = self.__U + return 0 + # ----------------------------------------------------------- def setControls (self, asVector = None, @@ -568,6 +672,12 @@ class AssimilationStudy: else: __Y_shape = self.__Y.shape() else: raise TypeError("Y has no attribute of shape: problem !") # + if self.__U is None: __U_shape = (0,) + elif hasattr(self.__U,"shape"): + if type(self.__U.shape) is tuple: __U_shape = self.__U.shape + else: __U_shape = self.__U.shape() + else: raise TypeError("U has no attribute of shape: problem !") + # if self.__B is None and self.__B_scalar is None: __B_shape = (0,0) elif self.__B is None and self.__B_scalar is not None: @@ -592,19 +702,26 @@ class AssimilationStudy: else: __Q_shape = self.__Q.shape() else: raise TypeError("Q has no attribute of shape: problem !") # - if len(self.__H) == 0: __H_shape = (0,0) - elif type(self.__H) is type({}): __H_shape = (0,0) - elif hasattr(self.__H["Direct"],"shape"): - if type(self.__H["Direct"].shape) is tuple: __H_shape = self.__H["Direct"].shape - else: __H_shape = self.__H["Direct"].shape() + if len(self.__HO) == 0: __HO_shape = (0,0) + elif type(self.__HO) is type({}): __HO_shape = (0,0) + elif hasattr(self.__HO["Direct"],"shape"): + if type(self.__HO["Direct"].shape) is tuple: __HO_shape = self.__HO["Direct"].shape + else: __HO_shape = self.__HO["Direct"].shape() else: raise TypeError("H has no attribute of shape: problem !") # - if len(self.__M) == 0: __M_shape = (0,0) - elif type(self.__M) is type({}): __M_shape = (0,0) - elif hasattr(self.__M["Direct"],"shape"): - if type(self.__M["Direct"].shape) is tuple: __M_shape = self.__M["Direct"].shape - else: __M_shape = self.__M["Direct"].shape() - else: raise TypeError("M has no attribute of shape: problem !") + if len(self.__EM) == 0: __EM_shape = (0,0) + elif type(self.__EM) is type({}): __EM_shape = (0,0) + elif hasattr(self.__EM["Direct"],"shape"): + if type(self.__EM["Direct"].shape) is tuple: __EM_shape = self.__EM["Direct"].shape + else: __EM_shape = self.__EM["Direct"].shape() + else: raise TypeError("EM has no attribute of shape: problem !") + # + if len(self.__CM) == 0: __CM_shape = (0,0) + elif type(self.__CM) is type({}): __CM_shape = (0,0) + elif hasattr(self.__CM["Direct"],"shape"): + if type(self.__CM["Direct"].shape) is tuple: __CM_shape = self.__CM["Direct"].shape + else: __CM_shape = self.__CM["Direct"].shape() + else: raise TypeError("CM has no attribute of shape: problem !") # # Vérification des conditions # --------------------------- @@ -619,17 +736,17 @@ class AssimilationStudy: raise ValueError("Shape characteristic of R is incorrect: \"%s\""%(__R_shape,)) if not( min(__Q_shape) == max(__Q_shape) ): raise ValueError("Shape characteristic of Q is incorrect: \"%s\""%(__Q_shape,)) - if not( min(__M_shape) == max(__M_shape) ): - raise ValueError("Shape characteristic of M is incorrect: \"%s\""%(__M_shape,)) - # - if len(self.__H) > 0 and not(type(self.__H) is type({})) and not( __H_shape[1] == max(__Xb_shape) ): - raise ValueError("Shape characteristic of H \"%s\" and X \"%s\" are incompatible"%(__H_shape,__Xb_shape)) - if len(self.__H) > 0 and not(type(self.__H) is type({})) and not( __H_shape[0] == max(__Y_shape) ): - raise ValueError("Shape characteristic of H \"%s\" and Y \"%s\" are incompatible"%(__H_shape,__Y_shape)) - if len(self.__H) > 0 and not(type(self.__H) is type({})) and len(self.__B) > 0 and not( __H_shape[1] == __B_shape[0] ): - raise ValueError("Shape characteristic of H \"%s\" and B \"%s\" are incompatible"%(__H_shape,__B_shape)) - if len(self.__H) > 0 and not(type(self.__H) is type({})) and len(self.__R) > 0 and not( __H_shape[0] == __R_shape[1] ): - raise ValueError("Shape characteristic of H \"%s\" and R \"%s\" are incompatible"%(__H_shape,__R_shape)) + if not( min(__EM_shape) == max(__EM_shape) ): + raise ValueError("Shape characteristic of EM is incorrect: \"%s\""%(__EM_shape,)) + # + if len(self.__HO) > 0 and not(type(self.__HO) is type({})) and not( __HO_shape[1] == max(__Xb_shape) ): + raise ValueError("Shape characteristic of H \"%s\" and X \"%s\" are incompatible"%(__HO_shape,__Xb_shape)) + if len(self.__HO) > 0 and not(type(self.__HO) is type({})) and not( __HO_shape[0] == max(__Y_shape) ): + raise ValueError("Shape characteristic of H \"%s\" and Y \"%s\" are incompatible"%(__HO_shape,__Y_shape)) + if len(self.__HO) > 0 and not(type(self.__HO) is type({})) and len(self.__B) > 0 and not( __HO_shape[1] == __B_shape[0] ): + raise ValueError("Shape characteristic of H \"%s\" and B \"%s\" are incompatible"%(__HO_shape,__B_shape)) + if len(self.__HO) > 0 and not(type(self.__HO) is type({})) and len(self.__R) > 0 and not( __HO_shape[0] == __R_shape[1] ): + raise ValueError("Shape characteristic of H \"%s\" and 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.__StoredInputs["AlgorithmName"] in ["EnsembleBlue",]: @@ -644,8 +761,11 @@ class AssimilationStudy: if self.__R is not None and len(self.__R) > 0 and not( __R_shape[1] == max(__Y_shape) ): raise ValueError("Shape characteristic of R \"%s\" and Y \"%s\" are incompatible"%(__R_shape,__Y_shape)) # - if self.__M is not None and len(self.__M) > 0 and not(type(self.__M) is type({})) and not( __M_shape[1] == max(__Xb_shape) ): - raise ValueError("Shape characteristic of M \"%s\" and X \"%s\" are incompatible"%(__M_shape,__Xb_shape)) + if self.__EM is not None and len(self.__EM) > 0 and not(type(self.__EM) is type({})) and not( __EM_shape[1] == max(__Xb_shape) ): + raise ValueError("Shape characteristic of EM \"%s\" and X \"%s\" are incompatible"%(__EM_shape,__Xb_shape)) + # + if self.__CM is not None and len(self.__CM) > 0 and not(type(self.__CM) is type({})) and not( __CM_shape[1] == max(__U_shape) ): + raise ValueError("Shape characteristic of CM \"%s\" and U \"%s\" are incompatible"%(__CM_shape,__U_shape)) # return 1 @@ -664,8 +784,10 @@ class AssimilationStudy: self.__algorithm.run( Xb = self.__Xb, Y = self.__Y, - H = self.__H, - M = self.__M, + U = self.__U, + HO = self.__HO, + EM = self.__EM, + CM = self.__CM, R = self.__R, B = self.__B, Q = self.__Q, @@ -885,8 +1007,9 @@ class AssimilationStudy: def prepare_to_pickle(self): self.__algorithmFile = None self.__diagnosticFile = None - self.__H = {} - self.__M = {} + self.__HO = {} + self.__EM = {} + self.__CM = {} # ============================================================================== if __name__ == "__main__": @@ -909,7 +1032,7 @@ if __name__ == "__main__": print "Observation :", [0.5, 1.5, 2.5] print "Demi-somme :", list((numpy.array([0, 1, 2])+numpy.array([0.5, 1.5, 2.5]))/2) print " qui doit être identique à :" - print "Analyse résultante :", ADD.get("Analysis").valueserie(0) + print "Analyse résultante :", ADD.get("Analysis")[0] print print "Algorithmes disponibles.......................:", ADD.get_available_algorithms() @@ -937,7 +1060,7 @@ if __name__ == "__main__": print "Exemple de mise en place d'un observeur :" def obs(var=None,info=None): print " ---> Mise en oeuvre de l'observer" - print " var =",var.valueserie(-1) + print " var =",var[-1] print " info =",info ADD.setDataObserver( 'Analysis', HookFunction=obs, Scheduler = [2, 4], HookParameters = "Second observer") # Attention, il faut décaler le stockage de 1 pour suivre le pas interne diff --git a/src/daComposant/daCore/Persistence.py b/src/daComposant/daCore/Persistence.py index a2a36c2..1ddd4f6 100644 --- a/src/daComposant/daCore/Persistence.py +++ b/src/daComposant/daCore/Persistence.py @@ -26,7 +26,7 @@ __doc__ = """ """ __author__ = "Jean-Philippe ARGAUD" -import numpy +import numpy, copy from PlatformInfo import PathManagement ; PathManagement() @@ -45,22 +45,17 @@ class Persistence: La gestion interne des données est exclusivement basée sur les variables initialisées ici (qui ne sont pas accessibles depuis l'extérieur des objets comme des attributs) : - __step : numérotation par défaut du pas courant __basetype : le type de base de chaque valeur, sous la forme d'un type permettant l'instanciation ou le casting Python - __steps : les pas de stockage. Par défaut, c'est __step __values : les valeurs de stockage. Par défaut, c'est None """ self.__name = str(name) self.__unit = str(unit) # - self.__step = -1 self.__basetype = basetype # - self.__steps = [] - self.__values = [] - self.__tags = [] - self.__tagkeys = {} + self.__values = [] + self.__tags = [] # self.__dynamic = False # @@ -75,51 +70,34 @@ class Persistence: else: self.__basetype = basetype - def store(self, value=None, step=None, tags={}): + def store(self, value=None, **kwargs): """ - Stocke une valeur à un pas. Une instanciation est faite avec le type de - base pour stocker l'objet. Si le pas n'est pas fournit, on utilise - l'étape de stockage comme valeur de pas. + Stocke une valeur avec ses informations de filtrage. """ if value is None: raise ValueError("Value argument required") - self.__step += 1 - if step is not None: - self.__steps.append(step) - else: - self.__steps.append(self.__step) # self.__values.append(self.__basetype(value)) - # - self.__tags.append( dict(tags)) - self.__tagkeys.update(dict(tags)) + self.__tags.append(kwargs) # if self.__dynamic: self.__replots() + __step = len(self.__values) - 1 for hook, parameters, scheduler in self.__dataobservers: - if self.__step in scheduler: + if __step in scheduler: hook( self, parameters ) - def pop(self, item=None, step=None): + def pop(self, item=None): """ - Retire une valeur enregistree. Par defaut, retire par le numero d'item, - sinon cherche le step demande et le retire s'il existe. Sans argument, + Retire une valeur enregistree par son index de stockage. Sans argument, retire le dernier objet enregistre. - Attention, la liste des cles "tagkeys" n'est pas mise a jour. """ if item is not None: - index = int(item) - self.__steps.pop(index) - self.__values.pop(index) - self.__tags.pop(index) - elif step is not None: - index = int(self.__steps.index(int(step))) - self.__steps.pop(index) - self.__values.pop(index) - self.__tags.pop(index) + __index = int(item) + self.__values.pop(__index) + self.__tags.pop(__index) else: - self.__steps.pop() self.__values.pop() self.__tags.pop() - + def shape(self): """ Renvoie la taille sous forme numpy du dernier objet stocké. Si c'est un @@ -128,7 +106,7 @@ class Persistence: longueur. Par défaut, renvoie 1. """ if len(self.__values) > 0: - if self.__basetype in [numpy.matrix, numpy.array]: + if self.__basetype in [numpy.matrix, numpy.array, numpy.ravel]: return self.__values[-1].shape elif self.__basetype in [int, float]: return (1,) @@ -139,162 +117,96 @@ class Persistence: else: raise ValueError("Object has no shape before its first storage") + # --------------------------------------------------------- + def __str__(self): + msg = " Index Value Tags\n" + for i,v in enumerate(self.__values): + msg += " i=%05i %10s %s\n"%(i,v,self.__tags[i]) + return msg + def __len__(self): - """ - Renvoie le nombre d'éléments dans un séquence ou la plus grande - dimension d'une matrice - """ - return max( self.shape() ) + return len(self.__values) + + def __getitem__(self, index=None ): + return copy.copy(self.__values[index]) + + def count(self, value): + return self.__values.count(value) + + def index(self, value, start=0, stop=None): + if stop is None : stop = len(self.__values) + return self.__values.index(value, start, stop) # --------------------------------------------------------- - def itemserie(self, item=None, step=None, tags=None, - allSteps=False): - """ - Les "item" sont les index de la liste des pas de "step". Ils sont - renvoyés par cette fonction selon les filtres définis par les mots-clés. - - Les comportements sont les suivants : - - Renvoie par défaut toute la liste des index. - - Si l'argument "item" est valide, renvoie uniquement cet index. - - Si l'argument "step" existe dans la liste des pas de stockage, - renvoie le premier index (si allSteps=False) ou tous les index - (si allSteps=True) de ce "step" dans les pas de stockage. - - Si l'argument "tags" est un dictionnaire correct, renvoie les - index des pas caractérisés par toutes les paires "tag/valeur" des - tags indiqués, ou rien sinon. - - Cette méthode est à vocation interne pour simplifier les accès aux pas - par la méthode "stepserie", aux attributs par la méthode "tagserie" et - aux valeurs par la méthode "valueserie". - """ - # - # Cherche l'item demandé - if item is not None and item < len(self.__steps): - return [item,] - # - # Cherche le ou les items dont le "step" est demandé - elif step is not None and step in self.__steps: - if allSteps: - allIndexes = [] - searchFrom = 0 - try: - while self.__steps.index(step,searchFrom) >= 0: - searchFrom = self.__steps.index(step,searchFrom) - allIndexes.append( searchFrom ) - searchFrom +=1 - except ValueError, e: - pass - return allIndexes - else: - return [self.__steps.index(step),] - # - # Cherche le ou les items dont les "tags" sont demandés - elif tags is not None and type(tags) is dict : - allIndexes = [] - for i, attributs in enumerate(self.__tags): # Boucle sur les attributs de chaque pas - selection = True # Booleen permettant de traiter la combinaison "ET" des tags - for key in tags.keys(): # Boucle sur tous les tags de filtrage - if key not in self.__tagkeys.keys(): continue # Passe au suivant s'il n'existe nulle part - if not( key in attributs.keys() and attributs[key] == tags[key] ): - selection = False - if selection: - allIndexes.append(i) - allIndexes = list(set(allIndexes)) - allIndexes.sort() - return allIndexes - # - # Renvoie par défaut tous les items valides - else: - return range(len(self.__steps)) - - def stepserie(self, item=None, step=None, tags=None): - """ - Les "step" sont les pas nommés de stockage. Par défaut, s'il ne sont pas - définis explicitement, ils sont identiques aux index de stockage. Ils - sont renvoyés par cette fonction selon les filtres définis par les - mots-clés. - - Les comportements sont les suivants : - - Renvoie par défaut toute la liste des pas. - - Si l'argument "item" est valide, renvoie le pas à cet index. - - Si l'argument "step" existe dans la liste des pas, le renvoie. - - Si l'argument "tags" est un dictionnaire correct, renvoie les pas - caractérisés par toutes les paires "tag/valeur" des tags indiqués, - ou rien sinon. - """ - if item is not None and item < len(self.__steps): - return self.__steps[item] - elif step is not None and step in self.__steps: - return step - elif tags is not None: - allIndexes = self.itemserie(tags = tags) - return [self.__steps[index] for index in allIndexes] - else: - return self.__steps + def __filteredIndexes(self, **kwargs): + __indexOfFilteredItems = range(len(self.__tags)) + __filteringKwTags = kwargs.keys() + if len(__filteringKwTags) > 0: + for tagKey in __filteringKwTags: + __tmp = [] + for i in __indexOfFilteredItems: + if self.__tags[i].has_key(tagKey): + if self.__tags[i][tagKey] == kwargs[tagKey]: + __tmp.append( i ) + elif isinstance(kwargs[tagKey],(list,tuple)) and self.__tags[i][tagKey] in kwargs[tagKey]: + __tmp.append( i ) + __indexOfFilteredItems = __tmp + if len(__indexOfFilteredItems) == 0: break + return __indexOfFilteredItems - def valueserie(self, item=None, step=None, tags=None, - allSteps=False): - """ - Les valeurs stockées sont renvoyées par cette fonction selon les filtres - définis par les mots-clés. - - Les comportements sont les suivants : - - Renvoie par défaut toute la liste des valeurs. - - Si l'argument "item" est valide, renvoie la valeur à cet index. - - Si l'argument "step" existe dans la liste des pas de stockage, - renvoie la première valeur (si allSteps=False) ou toutes les - valeurs (si allSteps=True). - - Si l'argument "tags" est un dictionnaire correct, renvoie les - valeurs aux pas caractérisés par toutes les paires "tag/valeur" - des tags indiqués, ou rien sinon. - """ - if item is not None and item < len(self.__values): - return self.__values[item] - elif step is not None: - allIndexes = self.itemserie(step = step, allSteps = allSteps) - if allSteps: - return [self.__values[index] for index in allIndexes] + # --------------------------------------------------------- + def values(self, **kwargs): + __indexOfFilteredItems = self.__filteredIndexes(**kwargs) + return [self.__values[i] for i in __indexOfFilteredItems] + + def keys(self, keyword=None , **kwargs): + __indexOfFilteredItems = self.__filteredIndexes(**kwargs) + __keys = [] + for i in __indexOfFilteredItems: + if self.__tags[i].has_key( keyword ): + __keys.append( self.__tags[i][keyword] ) + else: + __keys.append( None ) + return __keys + + def items(self, keyword=None , **kwargs): + __indexOfFilteredItems = self.__filteredIndexes(**kwargs) + __pairs = [] + for i in __indexOfFilteredItems: + if self.__tags[i].has_key( keyword ): + __pairs.append( [self.__tags[i][keyword], self.__values[i]] ) else: - return self.__values[allIndexes[0]] - elif tags is not None: - allIndexes = self.itemserie(tags = tags) - return [self.__values[index] for index in allIndexes] + __pairs.append( [None, self.__values[i]] ) + return __pairs + + def tagkeys(self): + __allKeys = [] + for dicotags in self.__tags: + __allKeys.extend( dicotags.keys() ) + __allKeys = list(set(__allKeys)) + __allKeys.sort() + return __allKeys + + # def valueserie(self, item=None, allSteps=True, **kwargs): + # if item is not None: + # return self.__values[item] + # else: + # __indexOfFilteredItems = self.__filteredIndexes(**kwargs) + # if not allSteps and len(__indexOfFilteredItems) > 0: + # return self.__values[__indexOfFilteredItems[0]] + # else: + # return [self.__values[i] for i in __indexOfFilteredItems] + + def tagserie(self, item=None, withValues=False, outputTag=None, **kwargs): + if item is None: + __indexOfFilteredItems = self.__filteredIndexes(**kwargs) else: - return self.__values - - def tagserie(self, item=None, step=None, tags=None, - allSteps=False, withValues=False, - outputTag=None): - """ - Les "tag" sont les attributs nommés, sous forme de paires "clé/valeur", - qu'il est possible d'associer avec chaque pas de stockage. Par défaut, - s'il ne sont pas définis explicitement, il n'y en a pas. Ils sont - renvoyés par cette fonction selon les filtres définis par les mots-clés. - On obtient uniquement la liste des clés de tags avec "withValues=False" - ou la liste des paires "clé/valeurs" avec "withValues=True". - - On peut aussi obtenir les valeurs d'un tag satisfaisant aux conditions - de filtrage en "item/step/tags" en donnant le nom du tag dans - "outputTag". - - Les comportements sont les suivants : - - Renvoie par défaut toute la liste des tags. - - Si l'argument "item" est valide, renvoie le tag à cet index. - - Si l'argument "step" existe dans la liste des pas de stockage, - renvoie les tags du premier pas (si allSteps=False) ou la liste - des tags de tous les pas (si allSteps=True). - - Si l'argument "tags" est un dictionnaire correct, renvoie les - valeurs aux pas caractérisés par toutes les paires "tag/valeur" - des tags indiqués, ou rien sinon. - """ - # - # Cherche tous les index satisfaisant les conditions - allIndexes = self.itemserie(item = item, step = step, tags = tags, allSteps = allSteps) + __indexOfFilteredItems = [item,] # # Dans le cas où la sortie donne les valeurs d'un "outputTag" if outputTag is not None and type(outputTag) is str : outputValues = [] - for index in allIndexes: + for index in __indexOfFilteredItems: if outputTag in self.__tags[index].keys(): outputValues.append( self.__tags[index][outputTag] ) outputValues = list(set(outputValues)) @@ -304,34 +216,24 @@ class Persistence: # Dans le cas où la sortie donne les tags satisfaisants aux conditions else: if withValues: - return [self.__tags[index] for index in allIndexes] + return [self.__tags[index] for index in __indexOfFilteredItems] else: allTags = {} - for index in allIndexes: + for index in __indexOfFilteredItems: allTags.update( self.__tags[index] ) allKeys = allTags.keys() allKeys.sort() return allKeys - def stepnumber(self): - """ - Renvoie le nombre de pas de stockage. - """ - return len(self.__steps) - # --------------------------------------------------------- - # Méthodes d'accès de type dictionnaire - def keys(self): - return self.stepserie() - - def values(self): - return self.valueserie() + # Pour compatibilite + def stepnumber(self): + return len(self.__values) - def items(self): - pairs = [] - for i in xrange(self.stepnumber()): - pairs.append( (self.stepserie(item=i), self.valueserie(item=i)) ) - return pairs + # Pour compatibilite + def stepserie(self, **kwargs): + __indexOfFilteredItems = self.__filteredIndexes(**kwargs) + return __indexOfFilteredItems # --------------------------------------------------------- def means(self): @@ -486,8 +388,8 @@ class Persistence: # # Tracé du ou des vecteurs demandés indexes = [] - if step is not None and step in self.__steps: - indexes.append(self.__steps.index(step)) + if step is not None and step < len(self.__values): + indexes.append(step) elif item is not None and item < len(self.__values): indexes.append(item) else: @@ -828,16 +730,16 @@ class CompositePersistence: self.__StoredObjects["RmsBMA"] = OneScalar("RmsBMA") # - def store(self, name=None, value=None, step=None, tags={}): + def store(self, name=None, value=None, **kwargs): """ Stockage d'une valeur "value" pour le "step" dans la variable "name". """ if name is None: raise ValueError("Storable object name is required for storage.") if name not in self.__StoredObjects.keys(): raise ValueError("No such name '%s' exists in storable objects."%name) - self.__StoredObjects[name].store( value=value, step=step, tags=tags ) + self.__StoredObjects[name].store( value=value, **kwargs ) - def add_object(self, name=None, persistenceType=Persistence, basetype=numpy.array ): + def add_object(self, name=None, persistenceType=Persistence, basetype=None ): """ Ajoute dans les objets stockables un nouvel objet défini par son nom, son type de Persistence et son type de base à chaque pas. @@ -845,7 +747,10 @@ class CompositePersistence: if name is None: raise ValueError("Object name is required for adding an object.") if name in self.__StoredObjects.keys(): raise ValueError("An object with the same name '%s' already exists in storable objects. Choose another one."%name) - self.__StoredObjects[name] = persistenceType( name=str(name), basetype=basetype ) + if basetype is None: + self.__StoredObjects[name] = persistenceType( name=str(name) ) + else: + self.__StoredObjects[name] = persistenceType( name=str(name), basetype=basetype ) def get_object(self, name=None ): """ @@ -974,15 +879,82 @@ class CompositePersistence: if __name__ == "__main__": print '\n AUTODIAGNOSTIC \n' + OBJ = Persistence() + OBJ.store( 2) + OBJ.store( 3, Campagne="GR514") + OBJ.store( 4, Campagne="GR514") + OBJ.store( 5, Campagne="GR514") + OBJ.store( 6, Campagne="CA206", CDF="c020") + OBJ.store( 7, Campagne="GR514") + OBJ.store( 8, Campagne="GR514", CDF="c020") + OBJ.store( 9, Campagne="GR514", CDF="c020", BU=100.5) + print + print OBJ + print + print "Nombre d'items stockés..........................:", len(OBJ) + print + print "Mots-clé utilisés...............................:", OBJ.tagkeys() + print + print "Obtention de valeurs, clefs, items en fonction du filtrage" + print """ OBJ.values()................................:""", OBJ.values() + print """ OBJ.values(Campagne="GR514")................:""", OBJ.values(Campagne="GR514") + print """ OBJ.values(Campagne="c020").................:""", OBJ.values(Campagne="c020") + print """ OBJ.values(CDF="c020")......................:""", OBJ.values(CDF="c020") + print """ OBJ.values(Campagne="GR514",CDF="c020").....:""", OBJ.values(Campagne="GR514",CDF="c020") + print """ OBJ.values(Campagne=("GR514","CA206").......:""", OBJ.values(Campagne=("GR514","CA206")) + print + print """ OBJ.keys()..................................:""", OBJ.keys() + print """ OBJ.keys(Campagne="GR514")..................:""", OBJ.keys(Campagne="GR514") + print """ OBJ.keys(Campagne="c020")...................:""", OBJ.keys(Campagne="c020") + print """ OBJ.keys(CDF="c020")........................:""", OBJ.keys(CDF="c020") + print """ OBJ.keys(Campagne="GR514",CDF="c020").......:""", OBJ.keys(Campagne="GR514",CDF="c020") + print """ OBJ.keys(Campagne=("GR514","CA206").........:""", OBJ.keys(Campagne=("GR514","CA206")) + print + print """ OBJ.items().................................:""", OBJ.items() + print """ OBJ.items(Campagne="GR514").................:""", OBJ.items(Campagne="GR514") + print """ OBJ.items(Campagne="c020")..................:""", OBJ.items(Campagne="c020") + print """ OBJ.items(CDF="c020").......................:""", OBJ.items(CDF="c020") + print """ OBJ.items(Campagne="GR514",CDF="c020")......:""", OBJ.items(Campagne="GR514",CDF="c020") + print """ OBJ.items(Campagne=("GR514","CA206")........:""", OBJ.items(Campagne=("GR514","CA206")) + print + print "Obtention de valeurs de clefs particulières en fonction du filtrage" + print """ OBJ.keys("Campagne")........................:""", OBJ.keys("Campagne") + print """ OBJ.keys("CDF").............................:""", OBJ.keys("CDF") + print """ OBJ.keys("CDF",Campagne="GR514")............:""", OBJ.keys("CDF",Campagne="GR514") + print """ OBJ.keys("Campagne",CDF="c020").............:""", OBJ.keys("Campagne",CDF="c020") + print """ OBJ.keys("CDF",CDF="c020")..................:""", OBJ.keys("CDF",CDF="c020") + print """ OBJ.keys("BU")..............................:""", OBJ.keys("BU") + print """ OBJ.keys("CDF",Campagne=("GR514","CA206")...:""", OBJ.keys("CDF",Campagne=("GR514","CA206")) + print + print """ OBJ.items("Campagne").......................:""", OBJ.items("Campagne") + print """ OBJ.items("CDF")............................:""", OBJ.items("CDF") + print """ OBJ.items("CDF",Campagne="GR514")...........:""", OBJ.items("CDF",Campagne="GR514") + print """ OBJ.items("Campagne",CDF="c020")............:""", OBJ.items("Campagne",CDF="c020") + print """ OBJ.items("CDF",CDF="c020").................:""", OBJ.items("CDF",CDF="c020") + print """ OBJ.items("BU").............................:""", OBJ.items("BU") + print """ OBJ.items("CDF",Campagne=("GR514","CA206")..:""", OBJ.items("CDF",Campagne=("GR514","CA206")) + print + print "Obtention de valeurs comme dans une liste" + print """ OBJ[0]......................................:""", OBJ[0] + print """ OBJ[1]......................................:""", OBJ[1] + print """ OBJ[-1].....................................:""", OBJ[-1] + print """ OBJ[2:4]....................................:""", OBJ[2:4] + print """ OBJ[:]......................................:""", OBJ[:] + print """ len(OBJ)....................................:""", len(OBJ) + print """ OBJ.count(4)................................:""", OBJ.count("4") + print """ OBJ.index(4)................................:""", OBJ.index("4") + print """ OBJ.index(9)................................:""", OBJ.index("9") + print + print "======> Un flottant" OBJET_DE_TEST = OneScalar("My float", unit="cm") OBJET_DE_TEST.store( 5.) OBJET_DE_TEST.store(-5.) OBJET_DE_TEST.store( 1.) print "Les pas de stockage :", OBJET_DE_TEST.stepserie() - print "Les valeurs :", OBJET_DE_TEST.valueserie() - print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1) - print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1) + print "Les valeurs :", OBJET_DE_TEST[:] + print "La 2ème valeur :", OBJET_DE_TEST[1] + print "La dernière valeur :", OBJET_DE_TEST[-1] print "Valeurs par pas :" print " La moyenne :", OBJET_DE_TEST.means() print " L'écart-type :", OBJET_DE_TEST.stds() @@ -1000,7 +972,7 @@ if __name__ == "__main__": print "Taille \"len\" :", len(OBJET_DE_TEST) del OBJET_DE_TEST print - + print "======> Un flottant" OBJET_DE_TEST = OneScalar("My float", unit="cm") OBJET_DE_TEST.store( 5., step="azerty") @@ -1010,14 +982,12 @@ if __name__ == "__main__": OBJET_DE_TEST.store( 5., step="poiuyt") OBJET_DE_TEST.store(-5., step="azerty") OBJET_DE_TEST.store( 1., step="poiuyt") - print "Les pas de stockage :", OBJET_DE_TEST.stepserie() - print "Les valeurs :", OBJET_DE_TEST.valueserie() - print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1) - print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1) - print "Premier index :", OBJET_DE_TEST.valueserie( step = "azerty", allSteps = False ) - print "Valeurs identiques :", OBJET_DE_TEST.valueserie( step = "azerty", allSteps = True ) - print "Premier index :", OBJET_DE_TEST.valueserie( step = "poiuyt", allSteps = False ) - print "Valeurs identiques :", OBJET_DE_TEST.valueserie( step = "poiuyt", allSteps = True ) + print "Les noms de pas :", OBJET_DE_TEST.keys("step") + print "Les valeurs :", OBJET_DE_TEST[:] + print "La 2ème valeur :", OBJET_DE_TEST[1] + print "La dernière valeur :", OBJET_DE_TEST[-1] + print "Valeurs identiques :", OBJET_DE_TEST.values( step = "azerty" ) + print "Valeurs identiques :", OBJET_DE_TEST.values( step = "poiuyt" ) del OBJET_DE_TEST print @@ -1027,9 +997,9 @@ if __name__ == "__main__": OBJET_DE_TEST.store(-5 ) OBJET_DE_TEST.store( 1.) print "Les pas de stockage :", OBJET_DE_TEST.stepserie() - print "Les valeurs :", OBJET_DE_TEST.valueserie() - print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1) - print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1) + print "Les valeurs :", OBJET_DE_TEST[:] + print "La 2ème valeur :", OBJET_DE_TEST[1] + print "La dernière valeur :", OBJET_DE_TEST[-1] print "Valeurs par pas :" print " La moyenne :", OBJET_DE_TEST.means() print " L'écart-type :", OBJET_DE_TEST.stds() @@ -1054,9 +1024,9 @@ if __name__ == "__main__": OBJET_DE_TEST.store( False ) OBJET_DE_TEST.store( True ) print "Les pas de stockage :", OBJET_DE_TEST.stepserie() - print "Les valeurs :", OBJET_DE_TEST.valueserie() - print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1) - print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1) + print "Les valeurs :", OBJET_DE_TEST[:] + print "La 2ème valeur :", OBJET_DE_TEST[1] + print "La dernière valeur :", OBJET_DE_TEST[-1] print "Taille \"shape\" :", OBJET_DE_TEST.shape() print "Taille \"len\" :", len(OBJET_DE_TEST) del OBJET_DE_TEST @@ -1068,9 +1038,9 @@ if __name__ == "__main__": OBJET_DE_TEST.store( (-5, 5 ) ) OBJET_DE_TEST.store( (1., 1.) ) print "Les pas de stockage :", OBJET_DE_TEST.stepserie() - print "Les valeurs :", OBJET_DE_TEST.valueserie() - print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1) - print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1) + print "Les valeurs :", OBJET_DE_TEST[:] + print "La 2ème valeur :", OBJET_DE_TEST[1] + print "La dernière valeur :", OBJET_DE_TEST[-1] print "Valeurs par pas :" print " La moyenne :", OBJET_DE_TEST.means() print " L'écart-type :", OBJET_DE_TEST.stds() @@ -1095,9 +1065,9 @@ if __name__ == "__main__": OBJET_DE_TEST.store( (False, 5 ) ) OBJET_DE_TEST.store( (True , 1.) ) print "Les pas de stockage :", OBJET_DE_TEST.stepserie() - print "Les valeurs :", OBJET_DE_TEST.valueserie() - print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1) - print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1) + print "Les valeurs :", OBJET_DE_TEST[:] + print "La 2ème valeur :", OBJET_DE_TEST[1] + print "La dernière valeur :", OBJET_DE_TEST[-1] print "Valeurs par pas : attention, on peut les calculer car True=1, False=0, mais cela n'a pas de sens" print " La moyenne :", OBJET_DE_TEST.means() print " L'écart-type :", OBJET_DE_TEST.stds() @@ -1122,9 +1092,9 @@ if __name__ == "__main__": OBJET_DE_TEST.store( 3 ) OBJET_DE_TEST.store( 7 ) print "Les pas de stockage :", OBJET_DE_TEST.stepserie() - print "Les valeurs :", OBJET_DE_TEST.valueserie() - print "La 2ème valeur :", OBJET_DE_TEST.valueserie(1) - print "La dernière valeur :", OBJET_DE_TEST.valueserie(-1) + print "Les valeurs :", OBJET_DE_TEST[:] + print "La 2ème valeur :", OBJET_DE_TEST[1] + print "La dernière valeur :", OBJET_DE_TEST[-1] print "Taille \"shape\" :", OBJET_DE_TEST.shape() print "Taille \"len\" :", len(OBJET_DE_TEST) del OBJET_DE_TEST @@ -1135,10 +1105,10 @@ if __name__ == "__main__": for i in range(5): OBJET_DE_TEST.store( 7+i ) print "Taille \"len\" :", len(OBJET_DE_TEST) - print "Les pas de stockage :", OBJET_DE_TEST.keys() + print "Les clés absentes :", OBJET_DE_TEST.keys() print "Les valeurs :", OBJET_DE_TEST.values() print "Les paires :", OBJET_DE_TEST.items() - OBJET_DE_TEST.pop(step=1) + OBJET_DE_TEST.pop(1) print "Les valeurs sans la 1:", OBJET_DE_TEST.values() OBJET_DE_TEST.pop(item=2) print "Les valeurs sans la 2:", OBJET_DE_TEST.values() @@ -1164,9 +1134,9 @@ if __name__ == "__main__": OBJET_DE_TEST.add_object("ValeursStr", persistenceType=Persistence, basetype=str ) OBJET_DE_TEST.store("ValeursStr","IGN3") OBJET_DE_TEST.store("ValeursStr","c021") - print "Les valeurs :", OBJET_DE_TEST.get_object("ValeursStr").valueserie() + print "Les valeurs :", OBJET_DE_TEST.get_object("ValeursStr")[:] print "Acces comme dict :", OBJET_DE_TEST["ValeursStr"].stepserie() - print "Acces comme dict :", OBJET_DE_TEST["ValeursStr"].valueserie() + print "Acces comme dict :", OBJET_DE_TEST["ValeursStr"][:] print "Objets actifs :", OBJET_DE_TEST.get_stored_objects( hideVoidObjects = True ) print "--> Suppression d'un objet" OBJET_DE_TEST.del_object("ValeursVectorielles") @@ -1222,15 +1192,14 @@ if __name__ == "__main__": for i in range(1,11): D.store( i*i ) print "Taille \"shape\" du dernier objet stocké",OBJET_DE_TEST.shape() - print "Taille \"len\" du dernier objet stocké",len(OBJET_DE_TEST) - print "Nombre d'objets stockés",OBJET_DE_TEST.stepnumber() + print "Nombre d'objets stockés",len(OBJET_DE_TEST) del OBJET_DE_TEST print print "======> Affectation simple d'observateurs dynamiques" def obs(var=None,info=None): print " ---> Mise en oeuvre de l'observer" - print " var =",var.valueserie(-1) + print " var =",var[-1] print " info =",info OBJET_DE_TEST = Persistence("My object", unit="", basetype=list) D = OBJET_DE_TEST @@ -1245,11 +1214,11 @@ if __name__ == "__main__": print "======> Affectation multiple d'observateurs dynamiques" def obs(var=None,info=None): print " ---> Mise en oeuvre de l'observer" - print " var =",var.valueserie(-1) + print " var =",var[-1] print " info =",info def obs_bis(var=None,info=None): print " ---> Mise en oeuvre de l'observer" - print " var =",var.valueserie(-1) + print " var =",var[-1] print " info =",info OBJET_DE_TEST = Persistence("My object", unit="", basetype=list) D = OBJET_DE_TEST @@ -1284,44 +1253,40 @@ if __name__ == "__main__": OBJET_DE_TEST = CompositePersistence("My CompositePersistence", defaults=False) OBJET_DE_TEST.add_object("My ecarts", basetype = numpy.array) - OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5), tags = {"Camp":"Base","Carte":"IGN3","Niveau":1024,"Palier":"Premier"} ) - OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+1, tags = {"Camp":"Base","Carte":"IGN4","Niveau": 210,"Palier":"Premier"} ) - OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+2, tags = {"Camp":"Base","Carte":"IGN1","Niveau":1024} ) - OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+3, tags = {"Camp":"Sommet","Carte":"IGN2","Niveau":4024,"Palier":"Second","FullMap":True} ) + OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5), Camp="Base", Carte="IGN3", Niveau=1024, Palier="Premier" ) + OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+1, Camp="Base", Carte="IGN4", Niveau= 210, Palier="Premier" ) + OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+2, Camp="Base", Carte="IGN1", Niveau=1024 ) + OBJET_DE_TEST.store( "My ecarts", numpy.arange(1,5)+3, Camp="Sommet", Carte="IGN2", Niveau=4024, Palier="Second", FullMap=True ) print "Les pas de stockage :", OBJET_DE_TEST["My ecarts"].stepserie() - print "Les valeurs :", OBJET_DE_TEST["My ecarts"].valueserie() - print "La 2ème valeur :", OBJET_DE_TEST["My ecarts"].valueserie(1) - print "La dernière valeur :", OBJET_DE_TEST["My ecarts"].valueserie(-1) + print "Les valeurs :", OBJET_DE_TEST["My ecarts"][:] + print "La 2ème valeur :", OBJET_DE_TEST["My ecarts"][1] + print "La dernière valeur :", OBJET_DE_TEST["My ecarts"][-1] print "Liste des attributs :", OBJET_DE_TEST["My ecarts"].tagserie() print "Taille \"shape\" :", OBJET_DE_TEST["My ecarts"].shape() print "Taille \"len\" :", len(OBJET_DE_TEST["My ecarts"]) print - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Palier":"Premier"} ) - print "Valeurs pour tag :", OBJET_DE_TEST["My ecarts"].valueserie( tags={"Palier":"Premier"} ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Palier="Premier" ) + print "Valeurs pour tag :", OBJET_DE_TEST["My ecarts"].values( Palier="Premier" ) print - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Niveau":1024} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Base"} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"TOTO"} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Toto":"Premier"} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Carte="IGN1" ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Niveau=1024 ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Camp="Base" ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Camp="TOTO" ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Toto="Premier" ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Carte="IGN1" ) print print "Combinaison 'ET' de plusieurs Tags" - print "Attendu : [0, 1], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Base", "Palier":"Premier"} ) - print "Attendu : [], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Sommet", "Palier":"Premier"} ) - # Attention : {"Camp":"Sommet", "Camp":"Base"} == {"Camp":"Base"} - print "Attendu : [0, 1, 2], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Sommet", "Camp":"Base"} ) - print "Attendu : [2], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1", "Niveau":1024} ) + print "Attendu : [0, 1], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( Camp="Base", Palier="Premier" ) + print "Attendu : [], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( Camp="Sommet", Palier="Premier" ) + print "Attendu : [3], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( Camp="Sommet" ) + print "Attendu : [2], trouvé :",OBJET_DE_TEST["My ecarts"].stepserie( Carte="IGN1", Niveau=1024 ) print print "Liste des tags pour le pas (item) 1 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 1) print "Liste des tags pour le pas (item) 2 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 2) - print "Comme le step et l'item sont identiques par défaut, on doit avoir la même chose :" - print "Liste des tags pour le pas (step) 1 :",OBJET_DE_TEST["My ecarts"].tagserie(step = 1) - print "Liste des tags pour le pas (step) 2 :",OBJET_DE_TEST["My ecarts"].tagserie(step = 2) print print "Liste des tags/valeurs pour le pas 1 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 1, withValues=True) print "Liste des tags/valeurs pour le pas 2 :",OBJET_DE_TEST["My ecarts"].tagserie(item = 2, withValues=True) @@ -1333,10 +1298,10 @@ if __name__ == "__main__": print OBJET_DE_TEST.add_object("My other ecarts", basetype = numpy.array) - OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5), tags = {"Camp":"Base","Carte":"IGN3","Niveau":1024,"Palier":"Premier"} ) - OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+1, tags = {"Camp":"Base","Carte":"IGN4","Niveau": 210,"Palier":"Premier"} ) - OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+2, tags = {"Camp":"Base","Carte":"IGN1","Niveau":1024} ) - OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+3, tags = {"Camp":"Sommet","Carte":"IGN2","Niveau":4024,"Palier":"Second"} ) + OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5), Camp="Base", Carte="IGN3",Niveau=1024,Palier="Premier" ) + OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+1, Camp="Base", Carte="IGN4",Niveau= 210,Palier="Premier" ) + OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+2, Camp="Base", Carte="IGN1",Niveau=1024 ) + OBJET_DE_TEST.store( "My other ecarts", numpy.arange(-1,5)+3, Camp="Sommet",Carte="IGN2",Niveau=4024,Palier="Second" ) print "Objets présents dans le composite :",OBJET_DE_TEST.get_stored_objects() fichier = "composite.pkl.gz" @@ -1352,41 +1317,83 @@ if __name__ == "__main__": print "Objets présents dans le composite :",OBJET_DE_TEST.get_stored_objects() print "Taille des objets contenus :" for name in OBJET_DE_TEST.get_stored_objects(): - print " Objet \"%s\" : taille unitaire de %i"%(name,len(OBJET_DE_TEST[name])) + print " Objet \"%s\" : taille unitaire de %i"%(name,len(OBJET_DE_TEST[name][-1])) print print "Les pas de stockage :", OBJET_DE_TEST["My ecarts"].stepserie() - print "Les valeurs :", OBJET_DE_TEST["My ecarts"].valueserie() - print "La 2ème valeur :", OBJET_DE_TEST["My ecarts"].valueserie(1) - print "La dernière valeur :", OBJET_DE_TEST["My ecarts"].valueserie(-1) + print "Les valeurs :", OBJET_DE_TEST["My ecarts"][:] + print "La 2ème valeur :", OBJET_DE_TEST["My ecarts"][1] + print "La dernière valeur :", OBJET_DE_TEST["My ecarts"][-1] print "Liste des attributs :", OBJET_DE_TEST["My ecarts"].tagserie() print "Taille \"shape\" :", OBJET_DE_TEST["My ecarts"].shape() print "Taille \"len\" :", len(OBJET_DE_TEST["My ecarts"]) print - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Palier":"Premier"} ) - print "Valeurs pour tag :", OBJET_DE_TEST["My ecarts"].valueserie( tags={"Palier":"Premier"} ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Palier="Premier" ) + print "Valeurs pour tag :", OBJET_DE_TEST["My ecarts"].values( Palier="Premier" ) print - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Niveau":1024} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"Base"} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Camp":"TOTO"} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Toto":"Premier"} ) - print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( tags={"Carte":"IGN1"} ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Carte="IGN1" ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Niveau=1024 ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Camp="Base" ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Camp="TOTO" ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Toto="Premier" ) + print "Pas pour tag :", OBJET_DE_TEST["My ecarts"].stepserie( Carte="IGN1" ) print + #import sys ; sys.exit() print "Attributs :", OBJET_DE_TEST["My ecarts"].tagserie() - print "Attributs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( tags={"Camp":"Base"} ) - print "Attributs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( tags={"Niveau":4024} ) + print "Attributs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( Camp="Base" ) + print "Attributs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( Niveau=4024 ) print print "Attributs et valeurs :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True ) - print "Attributs et valeurs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True, tags={"Camp":"Base"} ) - print "Attributs et valeurs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True, tags={"Niveau":4024} ) + print "Attributs et valeurs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True, Camp="Base" ) + print "Attributs et valeurs pour tag filtré :", OBJET_DE_TEST["My ecarts"].tagserie( withValues=True, Niveau=4024 ) print print "Valeur d'attribut pour un tag donné 'BU' :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau" ) - print "Valeur d'attribut pour un tag donné 'BU' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau", tags={"Camp":"Base"} ) - print "Valeur d'attribut pour un tag donné 'BU' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau", tags={"Palier":"Second"} ) - print "Valeur d'attribut pour un tag donné 'Camp' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Camp", tags={"Palier":"Premier"} ) - print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", tags={"Palier":"Premier"} ) - print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", tags={"Palier":"Premier","Niveau":4024} ) - print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", tags={"Palier":"Premier","Niveau":210} ) + print "Valeur d'attribut pour un tag donné 'BU' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau", Camp="Base" ) + print "Valeur d'attribut pour un tag donné 'BU' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Niveau", Palier="Second" ) + print "Valeur d'attribut pour un tag donné 'Camp' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Camp", Palier="Premier" ) + print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", Palier="Premier" ) + print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", Palier="Premier", Niveau=4024 ) + print "Valeur d'attribut pour un tag donné 'Carte' filtré :", OBJET_DE_TEST["My ecarts"].tagserie( outputTag = "Carte", Palier="Premier", Niveau=210 ) + print + + print "======> Cas d'erreur" + OBJET_DE_TEST = OneScalar("My float", unit="cm") + OBJET_DE_TEST.store( 5., step="azerty") + OBJET_DE_TEST.store(-5., step="poiuyt") + OBJET_DE_TEST.store( 1., step="azerty") + OBJET_DE_TEST.store( 0., step="xxxxxx") + OBJET_DE_TEST.store( 5., step="poiuyt") + OBJET_DE_TEST.store(-5., step="azerty") + OBJET_DE_TEST.store( 1., step="poiuyt") + print "Les pas de stockage :", OBJET_DE_TEST.stepserie() + print "Les valeurs :", OBJET_DE_TEST[:] + print "La 2ème valeur :", OBJET_DE_TEST[1] + print "La dernière valeur :", OBJET_DE_TEST[-1] + print "Valeurs 'azerty' :", OBJET_DE_TEST.values( step = "azerty" ) + print "Valeurs 'poiuyt' :", OBJET_DE_TEST.values( step = "poiuyt" ) + print + print "Nombre de valeurs :", len(OBJET_DE_TEST) + try: + x = OBJET_DE_TEST[7] + print "La 8ème valeur :", x + except IndexError, e: + print "Erreur correcte :",e + try: + x = OBJET_DE_TEST[7] + print "La 8ème valeur :", x + except IndexError, e: + print "Erreur correcte :",e + print + + print "======> Impression d'objet Persistence" + OBJET_DE_TEST = OneScalar("My float", unit="cm") + OBJET_DE_TEST.store( 5., step="azerty") + OBJET_DE_TEST.store(-5., step="poiuyt") + OBJET_DE_TEST.store( 1., step="azerty") + OBJET_DE_TEST.store( 0., step="xxxxxx") + OBJET_DE_TEST.store( 5., step="poiuyt") + OBJET_DE_TEST.store(-5., step="azerty") + OBJET_DE_TEST.store( 1., step="poiuyt") + print OBJET_DE_TEST print diff --git a/src/daComposant/daDiagnostics/RMS.py b/src/daComposant/daDiagnostics/RMS.py index bba6934..1bc82e1 100644 --- a/src/daComposant/daDiagnostics/RMS.py +++ b/src/daComposant/daDiagnostics/RMS.py @@ -81,7 +81,7 @@ if __name__ == "__main__": vect2 = [0,0,0,0,0,0,0,0,0,0] D.calculate(vect1,vect2) print " Les valeurs de RMS attendues sont les suivantes : [1.0, 1.0, 1.0, 3.0, 0.53162016515553656, 0.73784217096601323]" - print " Les RMS obtenues................................:", D.valueserie() + print " Les RMS obtenues................................:", D[:] print " La moyenne......................................:", D.mean() print diff --git a/src/daComposant/daDiagnostics/ReduceVariance.py b/src/daComposant/daDiagnostics/ReduceVariance.py index ccd287a..ee42f19 100644 --- a/src/daComposant/daDiagnostics/ReduceVariance.py +++ b/src/daComposant/daDiagnostics/ReduceVariance.py @@ -86,7 +86,7 @@ if __name__ == "__main__": print " La variance de OMA est de...........................:", x2.var() # D.calculate( vectorOMB = x1, vectorOMA = x2) - if not D.valueserie(0) : + if not D[0] : print " Résultat : l'analyse NE RÉDUIT PAS la variance" else : print " Résultat : l'analyse RÉDUIT la variance" @@ -104,7 +104,7 @@ if __name__ == "__main__": print " La variance de OMA est de...........................:", x2.var() # D.calculate( vectorOMB = x1, vectorOMA = x2) - if not D.valueserie(1) : + if not D[1] : print " Résultat : l'analyse NE RÉDUIT PAS la variance" else : print " Résultat : l'analyse RÉDUIT la variance" diff --git a/src/daComposant/daNumerics/ApproximatedDerivatives.py b/src/daComposant/daNumerics/ApproximatedDerivatives.py index 9089cb5..9e09e6d 100644 --- a/src/daComposant/daNumerics/ApproximatedDerivatives.py +++ b/src/daComposant/daNumerics/ApproximatedDerivatives.py @@ -91,6 +91,9 @@ class FDApproximation: logging.debug(" Incrément de............: %s*X"%float(self.__increment)) logging.debug(" Approximation centrée...: %s"%(self.__centeredDF)) # + if X is None or len(X)==0: + raise ValueError("Nominal point X for approximate derivatives can not be None or void.") + # _X = numpy.asmatrix(numpy.ravel( X )).T # if self.__dX is None: diff --git a/src/tests/daSalome/test000_Blue.py b/src/tests/daSalome/test000_Blue.py index 46d3ef2..8e290a0 100644 --- a/src/tests/daSalome/test000_Blue.py +++ b/src/tests/daSalome/test000_Blue.py @@ -17,7 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -# Author: André Ribes, andre.ribes@edf.fr, EDF R&D +# Author: André Ribes, andre.ribes@edf.fr, EDF R&D study_config = {} study_config["Name"] = "test000_Blue" @@ -61,14 +61,14 @@ precision = 1.e-13 Xa = ADD.get("Analysis") print print " Nombre d'analyses :",Xa.stepnumber() -print " Analyse résultante :",Xa.valueserie(0) +print " Analyse résultante :",Xa[0] # -# Vérification du résultat +# Vérification du résultat # ------------------------ -if max(numpy.array(Xa.valueserie(0))-numpy.array([0.25, 1.25, 2.25])) > precision: - raise ValueError("Résultat du test erroné") +if max(numpy.array(Xa[0])-numpy.array([0.25, 1.25, 2.25])) > precision: + raise ValueError("Résultat du test erroné") else: - print " Test correct, erreur maximale inférieure à %s"%precision + print " Test correct, erreur maximale inférieure à %s"%precision print """ Analysis_config["From"] = "String" diff --git a/src/tests/daSalome/test000_Blue_AnalysisCode.py b/src/tests/daSalome/test000_Blue_AnalysisCode.py index 8d76957..85c4ef1 100644 --- a/src/tests/daSalome/test000_Blue_AnalysisCode.py +++ b/src/tests/daSalome/test000_Blue_AnalysisCode.py @@ -17,7 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -# Author: André Ribes, andre.ribes@edf.fr, EDF R&D +# Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D import numpy precision = 1.e-13 @@ -25,13 +25,13 @@ precision = 1.e-13 Xa = ADD.get("Analysis") print print " Nombre d'analyses :",Xa.stepnumber() -print " Analyse résultante :",Xa.valueserie(0) +print " Analyse résultante :",Xa[0] # -# Vérification du résultat +# Vérification du résultat # ------------------------ -if max(numpy.array(Xa.valueserie(0))-numpy.array([0.25, 1.25, 2.25])) > precision: - raise ValueError("Résultat du test erroné") +if max(numpy.array(Xa[0])-numpy.array([0.25, 1.25, 2.25])) > precision: + raise ValueError("Résultat du test erroné") else: - print " Test correct, erreur maximale inférieure à %s"%precision + print " Test correct, erreur maximale inférieure à %s"%precision print diff --git a/src/tests/daSalome/test017.comm.in b/src/tests/daSalome/test017.comm.in index 2a56c7d..4d6c934 100644 --- a/src/tests/daSalome/test017.comm.in +++ b/src/tests/daSalome/test017.comm.in @@ -30,8 +30,8 @@ dimension = 300 precision = 1.e-10 xt = numpy.matrix(numpy.arange(dimension)).T xb = Study.getBackground() -xa = numpy.array(ADD.get("Analysis").valueserie(0)) -d = numpy.array(ADD.get("Innovation").valueserie(0)) +xa = numpy.array(ADD.get("Analysis")[0]) +d = numpy.array(ADD.get("Innovation")[0]) # # Verification du resultat # ------------------------ diff --git a/src/tests/daSalome/test_aster_zzzz159a_LBFGSB.comm.in b/src/tests/daSalome/test_aster_zzzz159a_LBFGSB.comm.in index fcfe703..e5dcd70 100644 --- a/src/tests/daSalome/test_aster_zzzz159a_LBFGSB.comm.in +++ b/src/tests/daSalome/test_aster_zzzz159a_LBFGSB.comm.in @@ -37,15 +37,15 @@ ASSIMILATION_STUDY(Study_name='aster_zzzz159a_LBFGSB', STRING= """import numpy import os -xa = ADD.get("Analysis").valueserie(0) -Innovation = ADD.get("Innovation").valueserie(0) +xa = ADD.get("Analysis")[0] +Innovation = ADD.get("Innovation")[0] A = [] -J = ADD.get("CostFunctionJ").valueserie() +J = ADD.get("CostFunctionJ")[:] ADD.setDiagnostic("PlotVectors", "J") MonPlot = ADD.get("J") if os.path.isfile("recherche_xx_Fonctionnelles.ps"): os.remove("recherche_xx_Fonctionnelles.ps") -MonPlot.calculate([J,ADD.get("CostFunctionJb").valueserie(),ADD.get("CostFunctionJo").valueserie()], +MonPlot.calculate([J,ADD.get("CostFunctionJb")[:],ADD.get("CostFunctionJo")[:]], title = "Fonctionnelles J, Jb et Jo", ltitle = ["J","Jb","Jo"], xlabel = "Pas", ylabel = "Valeur", -- 2.39.2