Improvement of algorithms arguments validation and tests

diff --git a/examples/daSkeletons/External_data_definition_by_scripts/Physical_simulation_functions.py b/examples/daSkeletons/External_data_definition_by_scripts/Physical_simulation_functions.py
index f65ecab18fb5f8b02a16685f318150bd3d3ac5e5..9426fd1d74932a27b77b2ed5fd02d3f1a17c58cd 100644 (file)
--- a/examples/daSkeletons/External_data_definition_by_scripts/Physical_simulation_functions.py
+++ b/examples/daSkeletons/External_data_definition_by_scripts/Physical_simulation_functions.py
@@ -30,34 +30,28 @@ __doc__ = """
     """
 __author__ = "Jean-Philippe ARGAUD"
 #
-import os, numpy, time
-#
 # ==============================================================================
 #
+import os, numpy, time
+#
 def DirectOperator( XX ):
-    """ Direct non-linear simulation operator """
-    #
-    # ------------------------------------------> EXAMPLE TO BE REMOVED
-    if isinstance(XX, type(numpy.matrix([]))):  # EXAMPLE TO BE REMOVED
-        HX = XX.A1.tolist()                     # EXAMPLE TO BE REMOVED
-    elif isinstance(XX, type(numpy.array([]))): # EXAMPLE TO BE REMOVED
-        HX = numpy.matrix(XX).A1.tolist()       # EXAMPLE TO BE REMOVED
-    else:                                       # EXAMPLE TO BE REMOVED
-        HX = numpy.ravel(XX)                    # EXAMPLE TO BE REMOVED
-    # ------------------------------------------> EXAMPLE TO BE REMOVED
-    #
-    return numpy.array( HX )
-
-# ==============================================================================
-from adao.daCore.NumericObjects import FDApproximation
-FDA = FDApproximation( DirectOperator )
-TangentOperator = FDA.TangentOperator
-AdjointOperator = FDA.AdjointOperator
-
+    # Opérateur identité
+    return numpy.ravel(XX)
+#
+def TangentOperator(paire  ):
+    # Opérateur identité
+    (XX, dX) = paire
+    return numpy.ravel(dX)
+#
+def AdjointOperator( paire ):
+    # Opérateur identité
+    (XX, YY) = paire
+    return numpy.ravel(YY)
+#
 # ==============================================================================
 if __name__ == "__main__":
 
-    print("")
+    print()
     print("AUTODIAGNOSTIC")
     print("==============")
 
@@ -66,4 +60,4 @@ if __name__ == "__main__":
 
     FX = DirectOperator( X0 )
     print("FX =", FX)
-    print("")
+    print()

diff --git a/src/daComposant/daAlgorithms/3DVAR.py b/src/daComposant/daAlgorithms/3DVAR.py
index 9517df6e441fbdbdaad35153780d51e5262ed0d2..0a0f31f43bf0b1d22df7e7f7e8467c8b684413d4 100644 (file)
--- a/src/daComposant/daAlgorithms/3DVAR.py
+++ b/src/daComposant/daAlgorithms/3DVAR.py
@@ -147,7 +147,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         # Correction pour pallier a un bug de TNC sur le retour du Minimum
         if "Minimizer" in self._parameters and self._parameters["Minimizer"] == "TNC":

diff --git a/src/daComposant/daAlgorithms/4DVAR.py b/src/daComposant/daAlgorithms/4DVAR.py
index d39a5f1b74a0517d3e841b50c62314fb718f86fe..0b191c6bb1dfdb94ff650f5d0fea48f807ecaf5e 100644 (file)
--- a/src/daComposant/daAlgorithms/4DVAR.py
+++ b/src/daComposant/daAlgorithms/4DVAR.py
@@ -118,7 +118,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         # Correction pour pallier a un bug de TNC sur le retour du Minimum
         if "Minimizer" in self._parameters and self._parameters["Minimizer"] == "TNC":

diff --git a/src/daComposant/daAlgorithms/AdjointTest.py b/src/daComposant/daAlgorithms/AdjointTest.py
index 31561ba1f80d75cfc8139bd2cf765d47fadca622..61ee8f9c6a83c026a46382e478b683f123cde2d5 100644 (file)
--- a/src/daComposant/daAlgorithms/AdjointTest.py
+++ b/src/daComposant/daAlgorithms/AdjointTest.py
@@ -89,7 +89,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         Hm = HO["Direct"].appliedTo
         Ht = HO["Tangent"].appliedInXTo

diff --git a/src/daComposant/daAlgorithms/Blue.py b/src/daComposant/daAlgorithms/Blue.py
index d8d5b86460fa26fef9cb8cafce867e6973f7ecaa..4ff41be4a8439e7ab99ac14d3be347e6e0385f1e 100644 (file)
--- a/src/daComposant/daAlgorithms/Blue.py
+++ b/src/daComposant/daAlgorithms/Blue.py
@@ -104,7 +104,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         Hm = HO["Tangent"].asMatrix(Xb)
         Hm = Hm.reshape(Y.size,Xb.size) # ADAO & check shape

diff --git a/src/daComposant/daAlgorithms/DerivativeFreeOptimization.py b/src/daComposant/daAlgorithms/DerivativeFreeOptimization.py
index d6b4cb22b2366c3b5d09173d8378c14ac1e74ce2..cac169d234394c2185b92fb7e52d8e5944ac62de 100644 (file)
--- a/src/daComposant/daAlgorithms/DerivativeFreeOptimization.py
+++ b/src/daComposant/daAlgorithms/DerivativeFreeOptimization.py
@@ -119,7 +119,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         if not PlatformInfo.has_nlopt and not self._parameters["Minimizer"] in ["COBYLA", "POWELL", "SIMPLEX"]:
             logging.warning("%s Minimization by SIMPLEX is forced because %s is unavailable (COBYLA, POWELL are also available)"%(self._name,self._parameters["Minimizer"]))

diff --git a/src/daComposant/daAlgorithms/DifferentialEvolution.py b/src/daComposant/daAlgorithms/DifferentialEvolution.py
index b36407abad6cf52e227a9c4e8c5dfb28d4748fd0..4db00f76940e976d8dac662c287d7a038081d16f 100644 (file)
--- a/src/daComposant/daAlgorithms/DifferentialEvolution.py
+++ b/src/daComposant/daAlgorithms/DifferentialEvolution.py
@@ -149,7 +149,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         len_X = numpy.asarray(Xb).size
         popsize = round(self._parameters["PopulationSize"]/len_X)

diff --git a/src/daComposant/daAlgorithms/EnsembleBlue.py b/src/daComposant/daAlgorithms/EnsembleBlue.py
index 75be71ef2dcfa86fafe231c3b67f3f2090abc63c..9a45f75f60408cc7630d929bc363f92284fda06c 100644 (file)
--- a/src/daComposant/daAlgorithms/EnsembleBlue.py
+++ b/src/daComposant/daAlgorithms/EnsembleBlue.py
@@ -64,7 +64,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         # Précalcul des inversions de B et R
         # ----------------------------------

diff --git a/src/daComposant/daAlgorithms/EnsembleKalmanFilter.py b/src/daComposant/daAlgorithms/EnsembleKalmanFilter.py
index 5e683966d81595acad573b05bb5a7892fecfae81..8905c2146ab933a5599fe688127774a9fc9fe78a 100644 (file)
--- a/src/daComposant/daAlgorithms/EnsembleKalmanFilter.py
+++ b/src/daComposant/daAlgorithms/EnsembleKalmanFilter.py
@@ -96,7 +96,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         if self._parameters["EstimationOf"] == "Parameters":
             self._parameters["StoreInternalVariables"] = True

diff --git a/src/daComposant/daAlgorithms/ExtendedBlue.py b/src/daComposant/daAlgorithms/ExtendedBlue.py
index 6a9ebd5280a97301520c33e02cbca9589e3fb3c0..73451e01ea5a0d582b57f91ad3184f23aa1da2ef 100644 (file)
--- a/src/daComposant/daAlgorithms/ExtendedBlue.py
+++ b/src/daComposant/daAlgorithms/ExtendedBlue.py
@@ -104,7 +104,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         Hm = HO["Tangent"].asMatrix(Xb)
         Hm = Hm.reshape(Y.size,Xb.size) # ADAO & check shape

diff --git a/src/daComposant/daAlgorithms/ExtendedKalmanFilter.py b/src/daComposant/daAlgorithms/ExtendedKalmanFilter.py
index 1cd932a3fbea3c87fd8f4a6e5fecdc2832ce96e1..6b831e5c1bdf6c3638a6da4c7ebfaedce911ef59 100644 (file)
--- a/src/daComposant/daAlgorithms/ExtendedKalmanFilter.py
+++ b/src/daComposant/daAlgorithms/ExtendedKalmanFilter.py
@@ -93,7 +93,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         if self._parameters["EstimationOf"] == "Parameters":
             self._parameters["StoreInternalVariables"] = True

diff --git a/src/daComposant/daAlgorithms/FunctionTest.py b/src/daComposant/daAlgorithms/FunctionTest.py
index 2914c4338958f9495ad17ef4c3e5d8693565592a..18986f85ec23bf4cbf65bd4c257d7b625ca8c167 100644 (file)
--- a/src/daComposant/daAlgorithms/FunctionTest.py
+++ b/src/daComposant/daAlgorithms/FunctionTest.py
@@ -76,7 +76,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         Hm = HO["Direct"].appliedTo
         #

diff --git a/src/daComposant/daAlgorithms/GradientTest.py b/src/daComposant/daAlgorithms/GradientTest.py
index acde0007e76d5bc6daea806d604fc3254e47e9d0..81814c3f43b5ba42debfd64c763e6ac6156b7352 100644 (file)
--- a/src/daComposant/daAlgorithms/GradientTest.py
+++ b/src/daComposant/daAlgorithms/GradientTest.py
@@ -114,7 +114,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         Hm = HO["Direct"].appliedTo
         if self._parameters["ResiduFormula"] in ["Taylor", "TaylorOnNorm"]:

diff --git a/src/daComposant/daAlgorithms/InputValuesTest.py b/src/daComposant/daAlgorithms/InputValuesTest.py
index a49957a2ecb7a3956733b2a0e2a334264ae923a7..7bda3dac702a2875741a380bc154e34c4bf828e8 100644 (file)
--- a/src/daComposant/daAlgorithms/InputValuesTest.py
+++ b/src/daComposant/daAlgorithms/InputValuesTest.py
@@ -71,7 +71,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         _p = self._parameters["NumberOfPrintedDigits"]
         numpy.set_printoptions(precision=_p)

diff --git a/src/daComposant/daAlgorithms/KalmanFilter.py b/src/daComposant/daAlgorithms/KalmanFilter.py
index 4bc9686a4947747c82e89dd48626b778a0a4cbaa..bfa4167bf84cedd368140b97577190161811844c 100644 (file)
--- a/src/daComposant/daAlgorithms/KalmanFilter.py
+++ b/src/daComposant/daAlgorithms/KalmanFilter.py
@@ -82,7 +82,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         if self._parameters["EstimationOf"] == "Parameters":
             self._parameters["StoreInternalVariables"] = True

diff --git a/src/daComposant/daAlgorithms/LinearLeastSquares.py b/src/daComposant/daAlgorithms/LinearLeastSquares.py
index f36aa16add8877a36e71e2bfc65fb70348c6a656..d63bbdec41121c07532800b54b0dd7b4bc36538f 100644 (file)
--- a/src/daComposant/daAlgorithms/LinearLeastSquares.py
+++ b/src/daComposant/daAlgorithms/LinearLeastSquares.py
@@ -65,11 +65,11 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
-        Hm = HO["Tangent"].asMatrix(None)
+        Hm = HO["Tangent"].asMatrix(Xb)
         Hm = Hm.reshape(Y.size,-1) # ADAO & check shape
-        Ha = HO["Adjoint"].asMatrix(None)
+        Ha = HO["Adjoint"].asMatrix(Xb)
         Ha = Ha.reshape(-1,Y.size) # ADAO & check shape
         #
         RI = R.getI()

diff --git a/src/daComposant/daAlgorithms/LinearityTest.py b/src/daComposant/daAlgorithms/LinearityTest.py
index 02a0963919fdfd01de093615158400c351e55cd3..ca896bd7c23b97bbabe68ec147581352558be48e 100644 (file)
--- a/src/daComposant/daAlgorithms/LinearityTest.py
+++ b/src/daComposant/daAlgorithms/LinearityTest.py
@@ -96,7 +96,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         def RMS(V1, V2):
             import math

diff --git a/src/daComposant/daAlgorithms/LocalSensitivityTest.py b/src/daComposant/daAlgorithms/LocalSensitivityTest.py
index f8ed9340ad431390e9449f8721d57f4f968e6869..d14c71cdd0b80800f6f35195fa216f07b2280146 100644 (file)
--- a/src/daComposant/daAlgorithms/LocalSensitivityTest.py
+++ b/src/daComposant/daAlgorithms/LocalSensitivityTest.py
@@ -53,7 +53,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         if self._parameters["SetDebug"]:
             CUR_LEVEL = logging.getLogger().getEffectiveLevel()

diff --git a/src/daComposant/daAlgorithms/NonLinearLeastSquares.py b/src/daComposant/daAlgorithms/NonLinearLeastSquares.py
index 231764c14cdf3e6cb73ec9c9f35261f7a9e0a6dd..0d976d95926fa24f35ee8f0ee618cae9efd78bd6 100644 (file)
--- a/src/daComposant/daAlgorithms/NonLinearLeastSquares.py
+++ b/src/daComposant/daAlgorithms/NonLinearLeastSquares.py
@@ -110,7 +110,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         # Correction pour pallier a un bug de TNC sur le retour du Minimum
         if "Minimizer" in self._parameters and self._parameters["Minimizer"] == "TNC":

diff --git a/src/daComposant/daAlgorithms/ObserverTest.py b/src/daComposant/daAlgorithms/ObserverTest.py
index c13f0aa2f831f46fd9db83ea3ad1435937e27f99..82551b8ff64101a9a337694821c8faf0e370600e 100644 (file)
--- a/src/daComposant/daAlgorithms/ObserverTest.py
+++ b/src/daComposant/daAlgorithms/ObserverTest.py
@@ -33,7 +33,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         print("Results of observer check on all potential variables or commands,")
         print("         only activated on selected ones by explicit association.")
         print("")

diff --git a/src/daComposant/daAlgorithms/ParallelFunctionTest.py b/src/daComposant/daAlgorithms/ParallelFunctionTest.py
index 8fc24657b812b3d50205d3fd0383a9960bf88049..acb4dd27fd333ec6406a04d40c068008442ce353 100644 (file)
--- a/src/daComposant/daAlgorithms/ParallelFunctionTest.py
+++ b/src/daComposant/daAlgorithms/ParallelFunctionTest.py
@@ -76,7 +76,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         Hm = HO["Direct"].appliedTo
         #

diff --git a/src/daComposant/daAlgorithms/ParticleSwarmOptimization.py b/src/daComposant/daAlgorithms/ParticleSwarmOptimization.py
index 0b62667a78c1e131a0234bb587326d3078503df9..3125052557db3beb09c285ebd12ee1a79fbf4df0 100644 (file)
--- a/src/daComposant/daAlgorithms/ParticleSwarmOptimization.py
+++ b/src/daComposant/daAlgorithms/ParticleSwarmOptimization.py
@@ -120,16 +120,16 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         if ("BoxBounds" in self._parameters) and isinstance(self._parameters["BoxBounds"], (list, tuple)) and (len(self._parameters["BoxBounds"]) > 0):
             BoxBounds = self._parameters["BoxBounds"]
-            logging.debug("%s Prise en compte des bornes d'incréments de paramètres effectuee"%(self._name,))
+            logging.debug("%s Prise en compte des bornes d'incréments de paramètres effectuée"%(self._name,))
         else:
-            raise ValueError("Particle Swarm Optimization requires bounds on all variables to be given.")
+            raise ValueError("Particle Swarm Optimization requires bounds on all variables increments to be truly given (BoxBounds).")
         BoxBounds   = numpy.array(BoxBounds)
         if numpy.isnan(BoxBounds).any():
-            raise ValueError("Particle Swarm Optimization requires bounds on all variables increments to be truly given, \"None\" is not allowed. The actual increments bounds are:\n%s"%BoxBounds)
+            raise ValueError("Particle Swarm Optimization requires bounds on all variables increments to be truly given (BoxBounds), \"None\" is not allowed. The actual increments bounds are:\n%s"%BoxBounds)
         #
         Phig = float( self._parameters["GroupRecallRate"] )
         Phip = 1. - Phig

diff --git a/src/daComposant/daAlgorithms/QuantileRegression.py b/src/daComposant/daAlgorithms/QuantileRegression.py
index d50c3a455a9a65ad561bb35495abd992f45f757e..c6615675132e3fb68275dedb08e7cf2d3347d644 100644 (file)
--- a/src/daComposant/daAlgorithms/QuantileRegression.py
+++ b/src/daComposant/daAlgorithms/QuantileRegression.py
@@ -96,7 +96,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         Hm = HO["Direct"].appliedTo
         #

diff --git a/src/daComposant/daAlgorithms/SamplingTest.py b/src/daComposant/daAlgorithms/SamplingTest.py
index d6fc1633cedb7d54be3975e9d86a52106f8aed0f..f71d9f46b6890db28f09be7368fd1d15a67caad8 100644 (file)
--- a/src/daComposant/daAlgorithms/SamplingTest.py
+++ b/src/daComposant/daAlgorithms/SamplingTest.py
@@ -96,7 +96,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         Hm = HO["Direct"].appliedTo
         #

diff --git a/src/daComposant/daAlgorithms/TabuSearch.py b/src/daComposant/daAlgorithms/TabuSearch.py
index 0b7da4eed9c4225b8718cdc5003ea27d09effdba..f239a15083a4331bda8d0a655608511af10ac951 100644 (file)
--- a/src/daComposant/daAlgorithms/TabuSearch.py
+++ b/src/daComposant/daAlgorithms/TabuSearch.py
@@ -132,7 +132,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         if self._parameters["NoiseDistribution"] == "Uniform":
             nrange = numpy.ravel(self._parameters["NoiseHalfRange"]) # Vecteur

diff --git a/src/daComposant/daAlgorithms/TangentTest.py b/src/daComposant/daAlgorithms/TangentTest.py
index 6b507b4c77a49dbf1850162a4c63b7111185c031..7ad1ce8f1bef7e696c210c8786b42ca5c72dea43 100644 (file)
--- a/src/daComposant/daAlgorithms/TangentTest.py
+++ b/src/daComposant/daAlgorithms/TangentTest.py
@@ -96,7 +96,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         Hm = HO["Direct"].appliedTo
         Ht = HO["Tangent"].appliedInXTo

diff --git a/src/daComposant/daAlgorithms/UnscentedKalmanFilter.py b/src/daComposant/daAlgorithms/UnscentedKalmanFilter.py
index 23d160ef7ffec39c8e2bfb19d2bb3c7782418f96..496f5d32399ba54e2ab11932c8c4ba51ffe53b66 100644 (file)
--- a/src/daComposant/daAlgorithms/UnscentedKalmanFilter.py
+++ b/src/daComposant/daAlgorithms/UnscentedKalmanFilter.py
@@ -113,7 +113,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             ))
 
     def run(self, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None, Parameters=None):
-        self._pre_run(Parameters, Xb, Y, R, B, Q)
+        self._pre_run(Parameters, Xb, Y, U, HO, EM, CM, R, B, Q)
         #
         if self._parameters["EstimationOf"] == "Parameters":
             self._parameters["StoreInternalVariables"] = True

diff --git a/src/daComposant/daCore/BasicObjects.py b/src/daComposant/daCore/BasicObjects.py
index c27247f108a9f50e3b30f5eaf7d811732b01f946..a3893603705ab650069f8c22f423cd5630736cb5 100644 (file)
--- a/src/daComposant/daCore/BasicObjects.py
+++ b/src/daComposant/daCore/BasicObjects.py
@@ -680,7 +680,7 @@ class Algorithm(object):
         self.__canonical_parameter_name["algorithm"] = "Algorithm"
         self.__canonical_parameter_name["storesupplementarycalculations"] = "StoreSupplementaryCalculations"
 
-    def _pre_run(self, Parameters, Xb=None, Y=None, R=None, B=None, Q=None ):
+    def _pre_run(self, Parameters, Xb=None, Y=None, U=None, HO=None, EM=None, CM=None, R=None, B=None, Q=None ):
         "Pré-calcul"
         logging.debug("%s Lancement", self._name)
         logging.debug("%s Taille mémoire utilisée de %.0f Mio"%(self._name, self._m.getUsedMemory("Mio")))
@@ -691,36 +691,57 @@ class Algorithm(object):
         for k, v in self.__variable_names_not_public.items():
             if k not in self._parameters:  self.__setParameters( {k:v} )
         #
-        # Corrections et compléments
-        def __test_vvalue(argument, variable, argname):
+        # Corrections et compléments des vecteurs
+        def __test_vvalue(argument, variable, argname, symbol=None):
+            if symbol is None: symbol = variable
             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))
+                    raise ValueError("%s %s vector %s is not set and has to be properly defined!"%(self._name,argname,symbol))
                 elif variable in self.__required_inputs["RequiredInputValues"]["optional"]:
-                    logging.debug("%s %s vector %s is not set, but is optional."%(self._name,argname,variable))
+                    logging.debug("%s %s vector %s is not set, but is optional."%(self._name,argname,symbol))
                 else:
-                    logging.debug("%s %s vector %s is not set, but is not required."%(self._name,argname,variable))
+                    logging.debug("%s %s vector %s is not set, but is not required."%(self._name,argname,symbol))
             else:
-                logging.debug("%s %s vector %s is set, and its size is %i."%(self._name,argname,variable,numpy.array(argument).size))
+                logging.debug("%s %s vector %s is set, and its size is %i."%(self._name,argname,symbol,numpy.array(argument).size))
             return 0
         __test_vvalue( Xb, "Xb", "Background or initial state" )
         __test_vvalue( Y,  "Y",  "Observation" )
+        __test_vvalue( U,  "U",  "Control" )
         #
-        def __test_cvalue(argument, variable, argname):
+        # Corrections et compléments des covariances
+        def __test_cvalue(argument, variable, argname, symbol=None):
+            if symbol is None: symbol = variable
             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))
+                    raise ValueError("%s %s error covariance matrix %s is not set and has to be properly defined!"%(self._name,argname,symbol))
                 elif variable in self.__required_inputs["RequiredInputValues"]["optional"]:
-                    logging.debug("%s %s error covariance matrix %s is not set, but is optional."%(self._name,argname,variable))
+                    logging.debug("%s %s error covariance matrix %s is not set, but is optional."%(self._name,argname,symbol))
                 else:
-                    logging.debug("%s %s error covariance matrix %s is not set, but is not required."%(self._name,argname,variable))
+                    logging.debug("%s %s error covariance matrix %s is not set, but is not required."%(self._name,argname,symbol))
             else:
-                logging.debug("%s %s error covariance matrix %s is set."%(self._name,argname,variable))
+                logging.debug("%s %s error covariance matrix %s is set."%(self._name,argname,symbol))
             return 0
-        __test_cvalue( R, "R", "Observation" )
         __test_cvalue( B, "B", "Background" )
+        __test_cvalue( R, "R", "Observation" )
         __test_cvalue( Q, "Q", "Evolution" )
         #
+        # Corrections et compléments des opérateurs
+        def __test_ovalue(argument, variable, argname, symbol=None):
+            if symbol is None: symbol = variable
+            if argument is None or (isinstance(argument,dict) and len(argument)==0):
+                if variable in self.__required_inputs["RequiredInputValues"]["mandatory"]:
+                    raise ValueError("%s %s operator %s is not set and has to be properly defined!"%(self._name,argname,symbol))
+                elif variable in self.__required_inputs["RequiredInputValues"]["optional"]:
+                    logging.debug("%s %s operator %s is not set, but is optional."%(self._name,argname,symbol))
+                else:
+                    logging.debug("%s %s operator %s is not set, but is not required."%(self._name,argname,symbol))
+            else:
+                logging.debug("%s %s operator %s is set."%(self._name,argname,symbol))
+            return 0
+        __test_ovalue( HO, "HO", "Observation", "H" )
+        __test_ovalue( EM, "EM", "Evolution", "M" )
+        __test_ovalue( CM, "CM", "Control Model", "C" )
+        #
         if ("Bounds" in self._parameters) and isinstance(self._parameters["Bounds"], (list, tuple)) and (len(self._parameters["Bounds"]) > 0):
             logging.debug("%s Prise en compte des bornes effectuee"%(self._name,))
         else:

diff --git a/src/daComposant/daCore/NumericObjects.py b/src/daComposant/daCore/NumericObjects.py
index c09d5b0eb3463e546611719fb9d3aed2e7c1df13..97b0e36982ab00eff68ad093d11724b94965b446 100644 (file)
--- a/src/daComposant/daCore/NumericObjects.py
+++ b/src/daComposant/daCore/NumericObjects.py
@@ -483,6 +483,7 @@ def mmqr(
         #
         variables = variables + step
         if bounds is not None:
+            # Attention : boucle infinie à éviter si un intervalle est trop petit
             while( (variables < numpy.ravel(numpy.asmatrix(bounds)[:,0])).any() or (variables > numpy.ravel(numpy.asmatrix(bounds)[:,1])).any() ):
                 step      = step/2.
                 variables = variables - step