Minor documentation improvements

[modules/adao.git] / src / daComposant / daCore / BasicObjects.py

diff --git a/src/daComposant/daCore/BasicObjects.py b/src/daComposant/daCore/BasicObjects.py
index 0099c210e28a5bd89066e45189ccf1be99aef06f..0cc2cb04fd55367082218c5480a1033ae341fe4f 100644 (file)
--- a/src/daComposant/daCore/BasicObjects.py
+++ b/src/daComposant/daCore/BasicObjects.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
 # -*- coding: utf-8 -*-
 #

-# Copyright (C) 2008-2019 EDF R&D
+# Copyright (C) 2008-2021 EDF R&D

 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public


@@ -30,13 +30,11 @@ import os
 import sys
 import logging
 import copy
 import sys
 import logging
 import copy

+import time

 import numpy
 from functools import partial
 import numpy
 from functools import partial

-from daCore import Persistence
-from daCore import PlatformInfo
-from daCore import Interfaces
+from daCore import Persistence, PlatformInfo, Interfaces

 from daCore import Templates
 from daCore import Templates

-from daCore.Interfaces import ImportFromScript, ImportFromFile

 
 # ==============================================================================
 class CacheManager(object):
 
 # ==============================================================================
 class CacheManager(object):


@@ -48,38 +46,47 @@ class CacheManager(object):
                  lenghtOfRedundancy    = -1,
                 ):
         """
                  lenghtOfRedundancy    = -1,
                 ):
         """

-        Les caractéristiques de tolérance peuvent être modifées à la création.
+        Les caractéristiques de tolérance peuvent être modifiées à la création.

         """
         """

-        self.__tolerBP  = float(toleranceInRedundancy)
-        self.__lenghtOR = int(lenghtOfRedundancy)
-        self.__initlnOR = self.__lenghtOR
+        self.__tolerBP   = float(toleranceInRedundancy)
+        self.__lenghtOR  = int(lenghtOfRedundancy)
+        self.__initlnOR  = self.__lenghtOR
+        self.__seenNames = []
+        self.__enabled   = True

         self.clearCache()
 
     def clearCache(self):
         "Vide le cache"
         self.clearCache()
 
     def clearCache(self):
         "Vide le cache"

-        self.__listOPCV = [] # Operator Previous Calculated Points, Results, Point Norms
+        self.__listOPCV = [] # Previous Calculated Points, Results, Point Norms, Operator
+        self.__seenNames = []

         # logging.debug("CM Tolerance de determination des doublons : %.2e", self.__tolerBP)
 
         # logging.debug("CM Tolerance de determination des doublons : %.2e", self.__tolerBP)
 

-    def wasCalculatedIn(self, xValue ): #, info="" ):
+    def wasCalculatedIn(self, xValue, oName="" ): #, info="" ):

         "Vérifie l'existence d'un calcul correspondant à la valeur"
         __alc = False
         __HxV = None
         "Vérifie l'existence d'un calcul correspondant à la valeur"
         __alc = False
         __HxV = None

-        for i in range(min(len(self.__listOPCV),self.__lenghtOR)-1,-1,-1):
-            if not hasattr(xValue, 'size') or (xValue.size != self.__listOPCV[i][0].size):
-                # logging.debug("CM Différence de la taille %s de X et de celle %s du point %i déjà calculé", xValue.shape,i,self.__listOPCP[i].shape)
-                continue
-            if numpy.linalg.norm(numpy.ravel(xValue) - self.__listOPCV[i][0]) < self.__tolerBP * self.__listOPCV[i][2]:
-                __alc  = True
-                __HxV = self.__listOPCV[i][1]
-                # logging.debug("CM Cas%s déja calculé, portant le numéro %i", info, i)
-                break
+        if self.__enabled:
+            for i in range(min(len(self.__listOPCV),self.__lenghtOR)-1,-1,-1):
+                if not hasattr(xValue, 'size') or (str(oName) != self.__listOPCV[i][3]) or (xValue.size != self.__listOPCV[i][0].size):
+                    # logging.debug("CM Différence de la taille %s de X et de celle %s du point %i déjà calculé", xValue.shape,i,self.__listOPCP[i].shape)
+                    pass
+                elif numpy.linalg.norm(numpy.ravel(xValue) - self.__listOPCV[i][0]) < self.__tolerBP * self.__listOPCV[i][2]:
+                    __alc  = True
+                    __HxV = self.__listOPCV[i][1]
+                    # logging.debug("CM Cas%s déja calculé, portant le numéro %i", info, i)
+                    break

         return __alc, __HxV
 
         return __alc, __HxV
 

-    def storeValueInX(self, xValue, HxValue ):
-        "Stocke un calcul correspondant à la valeur"
+    def storeValueInX(self, xValue, HxValue, oName="" ):
+        "Stocke pour un opérateur o un calcul Hx correspondant à la valeur x"

         if self.__lenghtOR < 0:
             self.__lenghtOR = 2 * xValue.size + 2
             self.__initlnOR = self.__lenghtOR
         if self.__lenghtOR < 0:
             self.__lenghtOR = 2 * xValue.size + 2
             self.__initlnOR = self.__lenghtOR

+            self.__seenNames.append(str(oName))
+        if str(oName) not in self.__seenNames: # Etend la liste si nouveau
+            self.__lenghtOR += 2 * xValue.size + 2
+            self.__initlnOR += self.__lenghtOR
+            self.__seenNames.append(str(oName))

         while len(self.__listOPCV) > self.__lenghtOR:
             # logging.debug("CM Réduction de la liste des cas à %i éléments par suppression du premier", self.__lenghtOR)
             self.__listOPCV.pop(0)
         while len(self.__listOPCV) > self.__lenghtOR:
             # logging.debug("CM Réduction de la liste des cas à %i éléments par suppression du premier", self.__lenghtOR)
             self.__listOPCV.pop(0)


@@ -87,16 +94,19 @@ class CacheManager(object):
             copy.copy(numpy.ravel(xValue)),
             copy.copy(HxValue),
             numpy.linalg.norm(xValue),
             copy.copy(numpy.ravel(xValue)),
             copy.copy(HxValue),
             numpy.linalg.norm(xValue),

+            str(oName),

             ) )
 
     def disable(self):
         "Inactive le cache"
         self.__initlnOR = self.__lenghtOR
         self.__lenghtOR = 0
             ) )
 
     def disable(self):
         "Inactive le cache"
         self.__initlnOR = self.__lenghtOR
         self.__lenghtOR = 0

+        self.__enabled  = False

 
     def enable(self):
         "Active le cache"
         self.__lenghtOR = self.__initlnOR
 
     def enable(self):
         "Active le cache"
         self.__lenghtOR = self.__initlnOR

+        self.__enabled  = True

 
 # ==============================================================================
 class Operator(object):
 
 # ==============================================================================
 class Operator(object):


@@ -109,10 +119,12 @@ class Operator(object):
     CM = CacheManager()
     #
     def __init__(self,
     CM = CacheManager()
     #
     def __init__(self,

+        name                 = "GenericOperator",

         fromMethod           = None,
         fromMatrix           = None,
         avoidingRedundancy   = True,
         inputAsMultiFunction = False,
         fromMethod           = None,
         fromMatrix           = None,
         avoidingRedundancy   = True,
         inputAsMultiFunction = False,

+        enableMultiProcess   = False,

         extraArguments       = None,
         ):
         """
         extraArguments       = None,
         ):
         """


@@ -120,6 +132,7 @@ class Operator(object):
         deux mots-clé, soit une fonction ou un multi-fonction python, soit une
         matrice.
         Arguments :
         deux mots-clé, soit une fonction ou un multi-fonction python, soit une
         matrice.
         Arguments :

+        - name : nom d'opérateur

         - fromMethod : argument de type fonction Python
         - fromMatrix : argument adapté au constructeur numpy.matrix
         - avoidingRedundancy : booléen évitant (ou pas) les calculs redondants
         - fromMethod : argument de type fonction Python
         - fromMatrix : argument adapté au constructeur numpy.matrix
         - avoidingRedundancy : booléen évitant (ou pas) les calculs redondants


@@ -128,16 +141,18 @@ class Operator(object):
         - extraArguments : arguments supplémentaires passés à la fonction de
           base et ses dérivées (tuple ou dictionnaire)
         """
         - extraArguments : arguments supplémentaires passés à la fonction de
           base et ses dérivées (tuple ou dictionnaire)
         """

+        self.__name      = str(name)

         self.__NbCallsAsMatrix, self.__NbCallsAsMethod, self.__NbCallsOfCached = 0, 0, 0
         self.__AvoidRC   = bool( avoidingRedundancy )
         self.__inputAsMF = bool( inputAsMultiFunction )
         self.__NbCallsAsMatrix, self.__NbCallsAsMethod, self.__NbCallsOfCached = 0, 0, 0
         self.__AvoidRC   = bool( avoidingRedundancy )
         self.__inputAsMF = bool( inputAsMultiFunction )

+        self.__mpEnabled = bool( enableMultiProcess )

         self.__extraArgs = extraArguments
         if   fromMethod is not None and self.__inputAsMF:
             self.__Method = fromMethod # logtimer(fromMethod)
             self.__Matrix = None
             self.__Type   = "Method"
         elif fromMethod is not None and not self.__inputAsMF:
         self.__extraArgs = extraArguments
         if   fromMethod is not None and self.__inputAsMF:
             self.__Method = fromMethod # logtimer(fromMethod)
             self.__Matrix = None
             self.__Type   = "Method"
         elif fromMethod is not None and not self.__inputAsMF:

-            self.__Method = partial( MultiFonction, _sFunction=fromMethod)
+            self.__Method = partial( MultiFonction, _sFunction=fromMethod, _mpEnabled=self.__mpEnabled)

             self.__Matrix = None
             self.__Type   = "Method"
         elif fromMatrix is not None:
             self.__Matrix = None
             self.__Type   = "Method"
         elif fromMatrix is not None:


@@ -164,7 +179,7 @@ class Operator(object):
         "Renvoie le type"
         return self.__Type
 
         "Renvoie le type"
         return self.__Type
 

-    def appliedTo(self, xValue, HValue = None, argsAsSerie = False):
+    def appliedTo(self, xValue, HValue = None, argsAsSerie = False, returnSerieAsArrayMatrix = False):

         """
         Permet de restituer le résultat de l'application de l'opérateur à une
         série d'arguments xValue. Cette méthode se contente d'appliquer, chaque
         """
         Permet de restituer le résultat de l'application de l'opérateur à une
         série d'arguments xValue. Cette méthode se contente d'appliquer, chaque


@@ -188,18 +203,18 @@ class Operator(object):
         #
         if _HValue is not None:
             assert len(_xValue) == len(_HValue), "Incompatible number of elements in xValue and HValue"
         #
         if _HValue is not None:
             assert len(_xValue) == len(_HValue), "Incompatible number of elements in xValue and HValue"

-            HxValue = []
+            _HxValue = []

             for i in range(len(_HValue)):
             for i in range(len(_HValue)):

-                HxValue.append( numpy.asmatrix( numpy.ravel( _HValue[i] ) ).T )
+                _HxValue.append( numpy.asmatrix( numpy.ravel( _HValue[i] ) ).T )

                 if self.__AvoidRC:
                 if self.__AvoidRC:

-                    Operator.CM.storeValueInX(_xValue[i],HxValue[-1])
+                    Operator.CM.storeValueInX(_xValue[i],_HxValue[-1],self.__name)

         else:
         else:

-            HxValue = []
+            _HxValue = []

             _xserie = []
             _hindex = []
             for i, xv in enumerate(_xValue):
                 if self.__AvoidRC:
             _xserie = []
             _hindex = []
             for i, xv in enumerate(_xValue):
                 if self.__AvoidRC:

-                    __alreadyCalculated, __HxV = Operator.CM.wasCalculatedIn(xv)
+                    __alreadyCalculated, __HxV = Operator.CM.wasCalculatedIn(xv,self.__name)

                 else:
                     __alreadyCalculated = False
                 #
                 else:
                     __alreadyCalculated = False
                 #


@@ -209,13 +224,14 @@ class Operator(object):
                 else:
                     if self.__Matrix is not None:
                         self.__addOneMatrixCall()
                 else:
                     if self.__Matrix is not None:
                         self.__addOneMatrixCall()

-                        _hv = self.__Matrix * xv
+                        _xv = numpy.matrix(numpy.ravel(xv)).T
+                        _hv = self.__Matrix * _xv

                     else:
                         self.__addOneMethodCall()
                         _xserie.append( xv )
                         _hindex.append(  i )
                         _hv = None
                     else:
                         self.__addOneMethodCall()
                         _xserie.append( xv )
                         _hindex.append(  i )
                         _hv = None

-                HxValue.append( _hv )
+                _HxValue.append( _hv )

             #
             if len(_xserie)>0 and self.__Matrix is None:
                 if self.__extraArgs is None:
             #
             if len(_xserie)>0 and self.__Matrix is None:
                 if self.__extraArgs is None:


@@ -227,14 +243,17 @@ class Operator(object):
                 for i in _hindex:
                     _xv = _xserie.pop(0)
                     _hv = _hserie.pop(0)
                 for i in _hindex:
                     _xv = _xserie.pop(0)
                     _hv = _hserie.pop(0)

-                    HxValue[i] = _hv
+                    _HxValue[i] = _hv

                     if self.__AvoidRC:
                     if self.__AvoidRC:

-                        Operator.CM.storeValueInX(_xv,_hv)
+                        Operator.CM.storeValueInX(_xv,_hv,self.__name)

         #
         #

-        if argsAsSerie: return HxValue
-        else:           return HxValue[-1]
+        if returnSerieAsArrayMatrix:
+            _HxValue = numpy.stack([numpy.ravel(_hv) for _hv in _HxValue], axis=1)
+        #
+        if argsAsSerie: return _HxValue
+        else:           return _HxValue[-1]

 
 

-    def appliedControledFormTo(self, paires, argsAsSerie = False ):
+    def appliedControledFormTo(self, paires, argsAsSerie = False, returnSerieAsArrayMatrix = False):

         """
         Permet de restituer le résultat de l'application de l'opérateur à des
         paires (xValue, uValue). Cette méthode se contente d'appliquer, son
         """
         Permet de restituer le résultat de l'application de l'opérateur à des
         paires (xValue, uValue). Cette méthode se contente d'appliquer, son


@@ -251,30 +270,33 @@ class Operator(object):
         PlatformInfo.isIterable( _xuValue, True, " in Operator.appliedControledFormTo" )
         #
         if self.__Matrix is not None:
         PlatformInfo.isIterable( _xuValue, True, " in Operator.appliedControledFormTo" )
         #
         if self.__Matrix is not None:

-            HxValue = []
+            _HxValue = []

             for paire in _xuValue:
                 _xValue, _uValue = paire
             for paire in _xuValue:
                 _xValue, _uValue = paire

+                _xValue = numpy.matrix(numpy.ravel(_xValue)).T

                 self.__addOneMatrixCall()
                 self.__addOneMatrixCall()

-                HxValue.append( self.__Matrix * _xValue )
+                _HxValue.append( self.__Matrix * _xValue )

         else:
         else:

-            HxValue = []
+            _xuArgs = []

             for paire in _xuValue:
             for paire in _xuValue:

-                _xuValue = []

                 _xValue, _uValue = paire
                 if _uValue is not None:
                 _xValue, _uValue = paire
                 if _uValue is not None:

-                    _xuValue.append( paire )
+                    _xuArgs.append( paire )

                 else:
                 else:

-                    _xuValue.append( _xValue )
-            self.__addOneMethodCall( len(_xuValue) )
+                    _xuArgs.append( _xValue )
+            self.__addOneMethodCall( len(_xuArgs) )

             if self.__extraArgs is None:
             if self.__extraArgs is None:

-                HxValue = self.__Method( _xuValue ) # Calcul MF
+                _HxValue = self.__Method( _xuArgs ) # Calcul MF

             else:
             else:

-                HxValue = self.__Method( _xuValue, self.__extraArgs ) # Calcul MF
+                _HxValue = self.__Method( _xuArgs, self.__extraArgs ) # Calcul MF
+        #
+        if returnSerieAsArrayMatrix:
+            _HxValue = numpy.stack([numpy.ravel(_hv) for _hv in _HxValue], axis=1)

         #
         #

-        if argsAsSerie: return HxValue
-        else:           return HxValue[-1]
+        if argsAsSerie: return _HxValue
+        else:           return _HxValue[-1]

 
 

-    def appliedInXTo(self, paires, argsAsSerie = False ):
+    def appliedInXTo(self, paires, argsAsSerie = False, returnSerieAsArrayMatrix = False):

         """
         Permet de restituer le résultat de l'application de l'opérateur à une
         série d'arguments xValue, sachant que l'opérateur est valable en
         """
         Permet de restituer le résultat de l'application de l'opérateur à une
         série d'arguments xValue, sachant que l'opérateur est valable en


@@ -295,20 +317,24 @@ class Operator(object):
         PlatformInfo.isIterable( _nxValue, True, " in Operator.appliedInXTo" )
         #
         if self.__Matrix is not None:
         PlatformInfo.isIterable( _nxValue, True, " in Operator.appliedInXTo" )
         #
         if self.__Matrix is not None:

-            HxValue = []
+            _HxValue = []

             for paire in _nxValue:
                 _xNominal, _xValue = paire
             for paire in _nxValue:
                 _xNominal, _xValue = paire

+                _xValue = numpy.matrix(numpy.ravel(_xValue)).T

                 self.__addOneMatrixCall()
                 self.__addOneMatrixCall()

-                HxValue.append( self.__Matrix * _xValue )
+                _HxValue.append( self.__Matrix * _xValue )

         else:
             self.__addOneMethodCall( len(_nxValue) )
             if self.__extraArgs is None:
         else:
             self.__addOneMethodCall( len(_nxValue) )
             if self.__extraArgs is None:

-                HxValue = self.__Method( _nxValue ) # Calcul MF
+                _HxValue = self.__Method( _nxValue ) # Calcul MF

             else:
             else:

-                HxValue = self.__Method( _nxValue, self.__extraArgs ) # Calcul MF
+                _HxValue = self.__Method( _nxValue, self.__extraArgs ) # Calcul MF

         #
         #

-        if argsAsSerie: return HxValue
-        else:           return HxValue[-1]
+        if returnSerieAsArrayMatrix:
+            _HxValue = numpy.stack([numpy.ravel(_hv) for _hv in _HxValue], axis=1)
+        #
+        if argsAsSerie: return _HxValue
+        else:           return _HxValue[-1]

 
     def asMatrix(self, ValueForMethodForm = "UnknownVoidValue", argsAsSerie = False):
         """
 
     def asMatrix(self, ValueForMethodForm = "UnknownVoidValue", argsAsSerie = False):
         """


@@ -317,7 +343,7 @@ class Operator(object):
         if self.__Matrix is not None:
             self.__addOneMatrixCall()
             mValue = [self.__Matrix,]
         if self.__Matrix is not None:
             self.__addOneMatrixCall()
             mValue = [self.__Matrix,]

-        elif ValueForMethodForm is not "UnknownVoidValue": # Ne pas utiliser "None"
+        elif not isinstance(ValueForMethodForm,str) or ValueForMethodForm != "UnknownVoidValue": # Ne pas utiliser "None"

             mValue = []
             if argsAsSerie:
                 self.__addOneMethodCall( len(ValueForMethodForm) )
             mValue = []
             if argsAsSerie:
                 self.__addOneMethodCall( len(ValueForMethodForm) )


@@ -404,28 +430,32 @@ class FullOperator(object):
         __Parameters = {}
         if (asDict is not None) and isinstance(asDict, dict):
             __Parameters.update( asDict )
         __Parameters = {}
         if (asDict is not None) and isinstance(asDict, dict):
             __Parameters.update( asDict )

-            if "DifferentialIncrement" in asDict:
-                __Parameters["withIncrement"]  = asDict["DifferentialIncrement"]
-            if "CenteredFiniteDifference" in asDict:
-                __Parameters["withCenteredDF"] = asDict["CenteredFiniteDifference"]
-            if "EnableMultiProcessing" in asDict:
-                __Parameters["withmpEnabled"]  = asDict["EnableMultiProcessing"]
-            if "NumberOfProcesses" in asDict:
-                __Parameters["withmpWorkers"]  = asDict["NumberOfProcesses"]
+        # Priorité à EnableMultiProcessingInDerivatives=True
+        if "EnableMultiProcessing" in __Parameters and __Parameters["EnableMultiProcessing"]:
+            __Parameters["EnableMultiProcessingInDerivatives"] = True
+            __Parameters["EnableMultiProcessingInEvaluation"]  = False
+        if "EnableMultiProcessingInDerivatives"  not in __Parameters:
+            __Parameters["EnableMultiProcessingInDerivatives"]  = False
+        if __Parameters["EnableMultiProcessingInDerivatives"]:
+            __Parameters["EnableMultiProcessingInEvaluation"]  = False
+        if "EnableMultiProcessingInEvaluation"  not in __Parameters:
+            __Parameters["EnableMultiProcessingInEvaluation"]  = False
+        if "withIncrement" in __Parameters: # Temporaire
+            __Parameters["DifferentialIncrement"] = __Parameters["withIncrement"]

         #
         if asScript is not None:
             __Matrix, __Function = None, None
             if asMatrix:
         #
         if asScript is not None:
             __Matrix, __Function = None, None
             if asMatrix:

-                __Matrix = ImportFromScript(asScript).getvalue( self.__name )
+                __Matrix = Interfaces.ImportFromScript(asScript).getvalue( self.__name )

             elif asOneFunction:
             elif asOneFunction:

-                __Function = { "Direct":ImportFromScript(asScript).getvalue( "DirectOperator" ) }
+                __Function = { "Direct":Interfaces.ImportFromScript(asScript).getvalue( "DirectOperator" ) }

                 __Function.update({"useApproximatedDerivatives":True})
                 __Function.update(__Parameters)
             elif asThreeFunctions:
                 __Function = {
                 __Function.update({"useApproximatedDerivatives":True})
                 __Function.update(__Parameters)
             elif asThreeFunctions:
                 __Function = {

-                    "Direct" :ImportFromScript(asScript).getvalue( "DirectOperator" ),
-                    "Tangent":ImportFromScript(asScript).getvalue( "TangentOperator" ),
-                    "Adjoint":ImportFromScript(asScript).getvalue( "AdjointOperator" ),
+                    "Direct" :Interfaces.ImportFromScript(asScript).getvalue( "DirectOperator" ),
+                    "Tangent":Interfaces.ImportFromScript(asScript).getvalue( "TangentOperator" ),
+                    "Adjoint":Interfaces.ImportFromScript(asScript).getvalue( "AdjointOperator" ),

                     }
                 __Function.update(__Parameters)
         else:
                     }
                 __Function.update(__Parameters)
         else:


@@ -477,45 +507,45 @@ class FullOperator(object):
         if isinstance(__Function, dict) and \
                 ("useApproximatedDerivatives" in __Function) and bool(__Function["useApproximatedDerivatives"]) and \
                 ("Direct" in __Function) and (__Function["Direct"] is not None):
         if isinstance(__Function, dict) and \
                 ("useApproximatedDerivatives" in __Function) and bool(__Function["useApproximatedDerivatives"]) and \
                 ("Direct" in __Function) and (__Function["Direct"] is not None):

-            if "withCenteredDF"            not in __Function: __Function["withCenteredDF"]            = False
-            if "withIncrement"             not in __Function: __Function["withIncrement"]             = 0.01
-            if "withdX"                    not in __Function: __Function["withdX"]                    = None
-            if "withAvoidingRedundancy"    not in __Function: __Function["withAvoidingRedundancy"]    = avoidRC
-            if "withToleranceInRedundancy" not in __Function: __Function["withToleranceInRedundancy"] = 1.e-18
-            if "withLenghtOfRedundancy"    not in __Function: __Function["withLenghtOfRedundancy"]    = -1
-            if "withmpEnabled"             not in __Function: __Function["withmpEnabled"]             = False
-            if "withmpWorkers"             not in __Function: __Function["withmpWorkers"]             = None
-            if "withmfEnabled"             not in __Function: __Function["withmfEnabled"]             = inputAsMF
-            from daNumerics.ApproximatedDerivatives import FDApproximation
-            FDA = FDApproximation(
+            if "CenteredFiniteDifference"           not in __Function: __Function["CenteredFiniteDifference"]           = False
+            if "DifferentialIncrement"              not in __Function: __Function["DifferentialIncrement"]              = 0.01
+            if "withdX"                             not in __Function: __Function["withdX"]                             = None
+            if "withAvoidingRedundancy"             not in __Function: __Function["withAvoidingRedundancy"]             = avoidRC
+            if "withToleranceInRedundancy"          not in __Function: __Function["withToleranceInRedundancy"]          = 1.e-18
+            if "withLenghtOfRedundancy"             not in __Function: __Function["withLenghtOfRedundancy"]             = -1
+            if "NumberOfProcesses"                  not in __Function: __Function["NumberOfProcesses"]                  = None
+            if "withmfEnabled"                      not in __Function: __Function["withmfEnabled"]                      = inputAsMF
+            from daCore import NumericObjects
+            FDA = NumericObjects.FDApproximation(
+                name                  = self.__name,

                 Function              = __Function["Direct"],
                 Function              = __Function["Direct"],

-                centeredDF            = __Function["withCenteredDF"],
-                increment             = __Function["withIncrement"],
+                centeredDF            = __Function["CenteredFiniteDifference"],
+                increment             = __Function["DifferentialIncrement"],

                 dX                    = __Function["withdX"],
                 avoidingRedundancy    = __Function["withAvoidingRedundancy"],
                 toleranceInRedundancy = __Function["withToleranceInRedundancy"],
                 lenghtOfRedundancy    = __Function["withLenghtOfRedundancy"],
                 dX                    = __Function["withdX"],
                 avoidingRedundancy    = __Function["withAvoidingRedundancy"],
                 toleranceInRedundancy = __Function["withToleranceInRedundancy"],
                 lenghtOfRedundancy    = __Function["withLenghtOfRedundancy"],

-                mpEnabled             = __Function["withmpEnabled"],
-                mpWorkers             = __Function["withmpWorkers"],
+                mpEnabled             = __Function["EnableMultiProcessingInDerivatives"],
+                mpWorkers             = __Function["NumberOfProcesses"],

                 mfEnabled             = __Function["withmfEnabled"],
                 )
                 mfEnabled             = __Function["withmfEnabled"],
                 )

-            self.__FO["Direct"]  = Operator( fromMethod = FDA.DirectOperator,  avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
-            self.__FO["Tangent"] = Operator( fromMethod = FDA.TangentOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
-            self.__FO["Adjoint"] = Operator( fromMethod = FDA.AdjointOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
+            self.__FO["Direct"]  = Operator( name = self.__name,           fromMethod = FDA.DirectOperator,  avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs, enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] )
+            self.__FO["Tangent"] = Operator( name = self.__name+"Tangent", fromMethod = FDA.TangentOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
+            self.__FO["Adjoint"] = Operator( name = self.__name+"Adjoint", fromMethod = FDA.AdjointOperator, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )

         elif isinstance(__Function, dict) and \
                 ("Direct" in __Function) and ("Tangent" in __Function) and ("Adjoint" in __Function) and \
                 (__Function["Direct"] is not None) and (__Function["Tangent"] is not None) and (__Function["Adjoint"] is not None):
         elif isinstance(__Function, dict) and \
                 ("Direct" in __Function) and ("Tangent" in __Function) and ("Adjoint" in __Function) and \
                 (__Function["Direct"] is not None) and (__Function["Tangent"] is not None) and (__Function["Adjoint"] is not None):

-            self.__FO["Direct"]  = Operator( fromMethod = __Function["Direct"],  avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
-            self.__FO["Tangent"] = Operator( fromMethod = __Function["Tangent"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
-            self.__FO["Adjoint"] = Operator( fromMethod = __Function["Adjoint"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
+            self.__FO["Direct"]  = Operator( name = self.__name,           fromMethod = __Function["Direct"],  avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs, enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] )
+            self.__FO["Tangent"] = Operator( name = self.__name+"Tangent", fromMethod = __Function["Tangent"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )
+            self.__FO["Adjoint"] = Operator( name = self.__name+"Adjoint", fromMethod = __Function["Adjoint"], avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, extraArguments = self.__extraArgs )

         elif asMatrix is not None:
             __matrice = numpy.matrix( __Matrix, numpy.float )
         elif asMatrix is not None:
             __matrice = numpy.matrix( __Matrix, numpy.float )

-            self.__FO["Direct"]  = Operator( fromMatrix = __matrice,   avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
-            self.__FO["Tangent"] = Operator( fromMatrix = __matrice,   avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
-            self.__FO["Adjoint"] = Operator( fromMatrix = __matrice.T, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
+            self.__FO["Direct"]  = Operator( name = self.__name,           fromMatrix = __matrice,   avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF, enableMultiProcess = __Parameters["EnableMultiProcessingInEvaluation"] )
+            self.__FO["Tangent"] = Operator( name = self.__name+"Tangent", fromMatrix = __matrice,   avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )
+            self.__FO["Adjoint"] = Operator( name = self.__name+"Adjoint", fromMatrix = __matrice.T, avoidingRedundancy = avoidRC, inputAsMultiFunction = inputAsMF )

             del __matrice
         else:
             del __matrice
         else:

-            raise ValueError("Improperly defined observation operator, it requires at minima either a matrix, a Direct for approximate derivatives or a Tangent/Adjoint pair.")
+            raise ValueError("The %s object is improperly defined or undefined, it requires at minima either a matrix, a Direct operator for approximate derivatives or a Tangent/Adjoint operators pair. Please check your operator input."%self.__name)

         #
         if __appliedInX is not None:
             self.__FO["AppliedInX"] = {}
         #
         if __appliedInX is not None:
             self.__FO["AppliedInX"] = {}


@@ -536,11 +566,11 @@ class FullOperator(object):
 
     def __repr__(self):
         "x.__repr__() <==> repr(x)"
 
     def __repr__(self):
         "x.__repr__() <==> repr(x)"

-        return repr(self.__V)
+        return repr(self.__FO)

 
     def __str__(self):
         "x.__str__() <==> str(x)"
 
     def __str__(self):
         "x.__str__() <==> str(x)"

-        return str(self.__V)
+        return str(self.__FO)

 
 # ==============================================================================
 class Algorithm(object):
 
 # ==============================================================================
 class Algorithm(object):


@@ -573,6 +603,7 @@ class Algorithm(object):
             - CostFunctionJbAtCurrentOptimum : partie ébauche à l'état optimal courant lors d'itérations
             - CostFunctionJo : partie observations de la fonction-coût : Jo
             - CostFunctionJoAtCurrentOptimum : partie observations à l'état optimal courant lors d'itérations
             - CostFunctionJbAtCurrentOptimum : partie ébauche à l'état optimal courant lors d'itérations
             - CostFunctionJo : partie observations de la fonction-coût : Jo
             - CostFunctionJoAtCurrentOptimum : partie observations à l'état optimal courant lors d'itérations

+            - CurrentIterationNumber : numéro courant d'itération dans les algorithmes itératifs, à partir de 0

             - CurrentOptimum : état optimal courant lors d'itérations
             - CurrentState : état courant lors d'itérations
             - GradientOfCostFunctionJ  : gradient de la fonction-coût globale
             - CurrentOptimum : état optimal courant lors d'itérations
             - CurrentState : état courant lors d'itérations
             - GradientOfCostFunctionJ  : gradient de la fonction-coût globale


@@ -588,7 +619,7 @@ class Algorithm(object):
             - MahalanobisConsistency : indicateur de consistance des covariances
             - OMA : Observation moins Analyse : Y - Xa
             - OMB : Observation moins Background : Y - Xb
             - MahalanobisConsistency : indicateur de consistance des covariances
             - OMA : Observation moins Analyse : Y - Xa
             - OMB : Observation moins Background : Y - Xb

-            - PredictedState : état prédit courant lors d'itérations
+            - ForecastState : état prédit courant lors d'itérations

             - Residu : dans le cas des algorithmes de vérification
             - SigmaBck2 : indicateur de correction optimale des erreurs d'ébauche
             - SigmaObs2 : indicateur de correction optimale des erreurs d'observation
             - Residu : dans le cas des algorithmes de vérification
             - SigmaBck2 : indicateur de correction optimale des erreurs d'ébauche
             - SigmaObs2 : indicateur de correction optimale des erreurs d'observation


@@ -606,7 +637,13 @@ class Algorithm(object):
         self._name = str( name )
         self._parameters = {"StoreSupplementaryCalculations":[]}
         self.__required_parameters = {}
         self._name = str( name )
         self._parameters = {"StoreSupplementaryCalculations":[]}
         self.__required_parameters = {}

-        self.__required_inputs = {"RequiredInputValues":{"mandatory":(), "optional":()}}
+        self.__required_inputs = {
+            "RequiredInputValues":{"mandatory":(), "optional":()},
+            "ClassificationTags":[],
+            }
+        self.__variable_names_not_public = {"nextStep":False} # Duplication dans AlgorithmAndParameters
+        self.__canonical_parameter_name = {} # Correspondance "lower"->"correct"
+        self.__canonical_stored_name = {}    # Correspondance "lower"->"correct"

         #
         self.StoredVariables = {}
         self.StoredVariables["APosterioriCorrelations"]              = Persistence.OneMatrix(name = "APosterioriCorrelations")
         #
         self.StoredVariables = {}
         self.StoredVariables["APosterioriCorrelations"]              = Persistence.OneMatrix(name = "APosterioriCorrelations")


@@ -621,13 +658,16 @@ class Algorithm(object):
         self.StoredVariables["CostFunctionJbAtCurrentOptimum"]       = Persistence.OneScalar(name = "CostFunctionJbAtCurrentOptimum")
         self.StoredVariables["CostFunctionJo"]                       = Persistence.OneScalar(name = "CostFunctionJo")
         self.StoredVariables["CostFunctionJoAtCurrentOptimum"]       = Persistence.OneScalar(name = "CostFunctionJoAtCurrentOptimum")
         self.StoredVariables["CostFunctionJbAtCurrentOptimum"]       = Persistence.OneScalar(name = "CostFunctionJbAtCurrentOptimum")
         self.StoredVariables["CostFunctionJo"]                       = Persistence.OneScalar(name = "CostFunctionJo")
         self.StoredVariables["CostFunctionJoAtCurrentOptimum"]       = Persistence.OneScalar(name = "CostFunctionJoAtCurrentOptimum")

+        self.StoredVariables["CurrentIterationNumber"]               = Persistence.OneIndex(name = "CurrentIterationNumber")

         self.StoredVariables["CurrentOptimum"]                       = Persistence.OneVector(name = "CurrentOptimum")
         self.StoredVariables["CurrentState"]                         = Persistence.OneVector(name = "CurrentState")
         self.StoredVariables["CurrentOptimum"]                       = Persistence.OneVector(name = "CurrentOptimum")
         self.StoredVariables["CurrentState"]                         = Persistence.OneVector(name = "CurrentState")

+        self.StoredVariables["ForecastState"]                        = Persistence.OneVector(name = "ForecastState")

         self.StoredVariables["GradientOfCostFunctionJ"]              = Persistence.OneVector(name = "GradientOfCostFunctionJ")
         self.StoredVariables["GradientOfCostFunctionJb"]             = Persistence.OneVector(name = "GradientOfCostFunctionJb")
         self.StoredVariables["GradientOfCostFunctionJo"]             = Persistence.OneVector(name = "GradientOfCostFunctionJo")
         self.StoredVariables["GradientOfCostFunctionJ"]              = Persistence.OneVector(name = "GradientOfCostFunctionJ")
         self.StoredVariables["GradientOfCostFunctionJb"]             = Persistence.OneVector(name = "GradientOfCostFunctionJb")
         self.StoredVariables["GradientOfCostFunctionJo"]             = Persistence.OneVector(name = "GradientOfCostFunctionJo")

-        self.StoredVariables["IndexOfOptimum"]                       = Persistence.OneIndex(name = "IndexOfOptimum")
+        self.StoredVariables["IndexOfOptimum"]                       = Persistence.OneIndex(name  = "IndexOfOptimum")

         self.StoredVariables["Innovation"]                           = Persistence.OneVector(name = "Innovation")
         self.StoredVariables["Innovation"]                           = Persistence.OneVector(name = "Innovation")

+        self.StoredVariables["InnovationAtCurrentAnalysis"]          = Persistence.OneVector(name = "InnovationAtCurrentAnalysis")

         self.StoredVariables["InnovationAtCurrentState"]             = Persistence.OneVector(name = "InnovationAtCurrentState")
         self.StoredVariables["JacobianMatrixAtBackground"]           = Persistence.OneMatrix(name = "JacobianMatrixAtBackground")
         self.StoredVariables["JacobianMatrixAtCurrentState"]         = Persistence.OneMatrix(name = "JacobianMatrixAtCurrentState")
         self.StoredVariables["InnovationAtCurrentState"]             = Persistence.OneVector(name = "InnovationAtCurrentState")
         self.StoredVariables["JacobianMatrixAtBackground"]           = Persistence.OneMatrix(name = "JacobianMatrixAtBackground")
         self.StoredVariables["JacobianMatrixAtCurrentState"]         = Persistence.OneMatrix(name = "JacobianMatrixAtCurrentState")


@@ -636,54 +676,87 @@ class Algorithm(object):
         self.StoredVariables["MahalanobisConsistency"]               = Persistence.OneScalar(name = "MahalanobisConsistency")
         self.StoredVariables["OMA"]                                  = Persistence.OneVector(name = "OMA")
         self.StoredVariables["OMB"]                                  = Persistence.OneVector(name = "OMB")
         self.StoredVariables["MahalanobisConsistency"]               = Persistence.OneScalar(name = "MahalanobisConsistency")
         self.StoredVariables["OMA"]                                  = Persistence.OneVector(name = "OMA")
         self.StoredVariables["OMB"]                                  = Persistence.OneVector(name = "OMB")

-        self.StoredVariables["PredictedState"]                       = Persistence.OneVector(name = "PredictedState")

         self.StoredVariables["Residu"]                               = Persistence.OneScalar(name = "Residu")
         self.StoredVariables["SigmaBck2"]                            = Persistence.OneScalar(name = "SigmaBck2")
         self.StoredVariables["SigmaObs2"]                            = Persistence.OneScalar(name = "SigmaObs2")
         self.StoredVariables["SimulatedObservationAtBackground"]     = Persistence.OneVector(name = "SimulatedObservationAtBackground")
         self.StoredVariables["Residu"]                               = Persistence.OneScalar(name = "Residu")
         self.StoredVariables["SigmaBck2"]                            = Persistence.OneScalar(name = "SigmaBck2")
         self.StoredVariables["SigmaObs2"]                            = Persistence.OneScalar(name = "SigmaObs2")
         self.StoredVariables["SimulatedObservationAtBackground"]     = Persistence.OneVector(name = "SimulatedObservationAtBackground")

+        self.StoredVariables["SimulatedObservationAtCurrentAnalysis"]= Persistence.OneVector(name = "SimulatedObservationAtCurrentAnalysis")

         self.StoredVariables["SimulatedObservationAtCurrentOptimum"] = Persistence.OneVector(name = "SimulatedObservationAtCurrentOptimum")
         self.StoredVariables["SimulatedObservationAtCurrentState"]   = Persistence.OneVector(name = "SimulatedObservationAtCurrentState")
         self.StoredVariables["SimulatedObservationAtOptimum"]        = Persistence.OneVector(name = "SimulatedObservationAtOptimum")
         self.StoredVariables["SimulationQuantiles"]                  = Persistence.OneMatrix(name = "SimulationQuantiles")
         self.StoredVariables["SimulatedObservationAtCurrentOptimum"] = Persistence.OneVector(name = "SimulatedObservationAtCurrentOptimum")
         self.StoredVariables["SimulatedObservationAtCurrentState"]   = Persistence.OneVector(name = "SimulatedObservationAtCurrentState")
         self.StoredVariables["SimulatedObservationAtOptimum"]        = Persistence.OneVector(name = "SimulatedObservationAtOptimum")
         self.StoredVariables["SimulationQuantiles"]                  = Persistence.OneMatrix(name = "SimulationQuantiles")

+        #
+        for k in self.StoredVariables:
+            self.__canonical_stored_name[k.lower()] = k
+        #
+        for k, v in self.__variable_names_not_public.items():
+            self.__canonical_parameter_name[k.lower()] = k
+        self.__canonical_parameter_name["algorithm"] = "Algorithm"
+        self.__canonical_parameter_name["storesupplementarycalculations"] = "StoreSupplementaryCalculations"

 
 

-    def _pre_run(self, Parameters, Xb=None, Y=None, R=None, B=None, Q=None ):
+    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)
         "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"))
-        #
-        # Mise a jour de self._parameters avec Parameters
-        self.__setParameters(Parameters)
-        #
-        # Corrections et complements
-        def __test_vvalue(argument, variable, argname):
+        logging.debug("%s Taille mémoire utilisée de %.0f Mio"%(self._name, self._m.getUsedMemory("Mio")))
+        self._getTimeState(reset=True)
+        #
+        # Mise a jour des paramètres internes avec le contenu de Parameters, en
+        # reprenant les valeurs par défauts pour toutes celles non définies
+        self.__setParameters(Parameters, reset=True)
+        for k, v in self.__variable_names_not_public.items():
+            if k not in self._parameters:  self.__setParameters( {k:v} )
+        #
+        # Corrections et compléments des vecteurs
+        def __test_vvalue(argument, variable, argname, symbol=None):
+            if symbol is None: symbol = variable

             if argument is None:
                 if variable in self.__required_inputs["RequiredInputValues"]["mandatory"]:
             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"]:
                 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:
                 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:
             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" )
             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"]:
             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"]:
                 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:
                 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:
             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
             return 0

-        __test_cvalue( R, "R", "Observation" )

         __test_cvalue( B, "B", "Background" )
         __test_cvalue( B, "B", "Background" )

+        __test_cvalue( R, "R", "Observation" )

         __test_cvalue( Q, "Q", "Evolution" )
         #
         __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:
         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:


@@ -719,10 +792,11 @@ class Algorithm(object):
                     _EI = numpy.diag(1./numpy.sqrt(numpy.diag(_A)))
                     _C = numpy.dot(_EI, numpy.dot(_A, _EI))
                     self.StoredVariables["APosterioriCorrelations"].store( _C )
                     _EI = numpy.diag(1./numpy.sqrt(numpy.diag(_A)))
                     _C = numpy.dot(_EI, numpy.dot(_A, _EI))
                     self.StoredVariables["APosterioriCorrelations"].store( _C )

-        if _oH is not None:
+        if _oH is not None and "Direct" in _oH and "Tangent" in _oH and "Adjoint" in _oH:

             logging.debug("%s Nombre d'évaluation(s) de l'opérateur d'observation direct/tangent/adjoint.: %i/%i/%i", self._name, _oH["Direct"].nbcalls(0),_oH["Tangent"].nbcalls(0),_oH["Adjoint"].nbcalls(0))
             logging.debug("%s Nombre d'appels au cache d'opérateur d'observation direct/tangent/adjoint..: %i/%i/%i", self._name, _oH["Direct"].nbcalls(3),_oH["Tangent"].nbcalls(3),_oH["Adjoint"].nbcalls(3))
         logging.debug("%s Taille mémoire utilisée de %.0f Mio", self._name, self._m.getUsedMemory("Mio"))
             logging.debug("%s Nombre d'évaluation(s) de l'opérateur d'observation direct/tangent/adjoint.: %i/%i/%i", self._name, _oH["Direct"].nbcalls(0),_oH["Tangent"].nbcalls(0),_oH["Adjoint"].nbcalls(0))
             logging.debug("%s Nombre d'appels au cache d'opérateur d'observation direct/tangent/adjoint..: %i/%i/%i", self._name, _oH["Direct"].nbcalls(3),_oH["Tangent"].nbcalls(3),_oH["Adjoint"].nbcalls(3))
         logging.debug("%s Taille mémoire utilisée de %.0f Mio", self._name, self._m.getUsedMemory("Mio"))

+        logging.debug("%s Durées d'utilisation CPU de %.1fs et elapsed de %.1fs", self._name, self._getTimeState()[0], self._getTimeState()[1])

         logging.debug("%s Terminé", self._name)
         return 0
 
         logging.debug("%s Terminé", self._name)
         return 0
 


@@ -739,13 +813,16 @@ class Algorithm(object):
         des classes de persistance.
         """
         if key is not None:
         des classes de persistance.
         """
         if key is not None:

-            return self.StoredVariables[key]
+            return self.StoredVariables[self.__canonical_stored_name[key.lower()]]

         else:
             return self.StoredVariables
 
     def __contains__(self, key=None):
         "D.__contains__(k) -> True if D has a key k, else False"
         else:
             return self.StoredVariables
 
     def __contains__(self, key=None):
         "D.__contains__(k) -> True if D has a key k, else False"

-        return key in self.StoredVariables
+        if key is None or key.lower() not in self.__canonical_stored_name:
+            return False
+        else:
+            return self.__canonical_stored_name[key.lower()] in self.StoredVariables

 
     def keys(self):
         "D.keys() -> list of D's keys"
 
     def keys(self):
         "D.keys() -> list of D's keys"


@@ -756,8 +833,8 @@ class Algorithm(object):
 
     def pop(self, k, d):
         "D.pop(k[,d]) -> v, remove specified key and return the corresponding value"
 
     def pop(self, k, d):
         "D.pop(k[,d]) -> v, remove specified key and return the corresponding value"

-        if hasattr(self, "StoredVariables"):
-            return self.StoredVariables.pop(k, d)
+        if hasattr(self, "StoredVariables") and k.lower() in self.__canonical_stored_name:
+            return self.StoredVariables.pop(self.__canonical_stored_name[k.lower()], d)

         else:
             try:
                 msg = "'%s'"%k
         else:
             try:
                 msg = "'%s'"%k


@@ -776,7 +853,7 @@ class Algorithm(object):
         """
         raise NotImplementedError("Mathematical assimilation calculation has not been implemented!")
 
         """
         raise NotImplementedError("Mathematical assimilation calculation has not been implemented!")
 

-    def defineRequiredParameter(self, name = None, default = None, typecast = None, message = None, minval = None, maxval = None, listval = None):
+    def defineRequiredParameter(self, name = None, default = None, typecast = None, message = None, minval = None, maxval = None, listval = None, listadv = None):

         """
         Permet de définir dans l'algorithme des paramètres requis et leurs
         caractéristiques par défaut.
         """
         Permet de définir dans l'algorithme des paramètres requis et leurs
         caractéristiques par défaut.


@@ -790,8 +867,10 @@ class Algorithm(object):
             "minval"   : minval,
             "maxval"   : maxval,
             "listval"  : listval,
             "minval"   : minval,
             "maxval"   : maxval,
             "listval"  : listval,

+            "listadv"  : listadv,

             "message"  : message,
             }
             "message"  : message,
             }

+        self.__canonical_parameter_name[name.lower()] = name

         logging.debug("%s %s (valeur par défaut = %s)", self._name, message, self.setParameterValue(name))
 
     def getRequiredParameters(self, noDetails=True):
         logging.debug("%s %s (valeur par défaut = %s)", self._name, message, self.setParameterValue(name))
 
     def getRequiredParameters(self, noDetails=True):


@@ -808,11 +887,13 @@ class Algorithm(object):
         """
         Renvoie la valeur d'un paramètre requis de manière contrôlée
         """
         """
         Renvoie la valeur d'un paramètre requis de manière contrôlée
         """

-        default  = self.__required_parameters[name]["default"]
-        typecast = self.__required_parameters[name]["typecast"]
-        minval   = self.__required_parameters[name]["minval"]
-        maxval   = self.__required_parameters[name]["maxval"]
-        listval  = self.__required_parameters[name]["listval"]
+        __k = self.__canonical_parameter_name[name.lower()]
+        default  = self.__required_parameters[__k]["default"]
+        typecast = self.__required_parameters[__k]["typecast"]
+        minval   = self.__required_parameters[__k]["minval"]
+        maxval   = self.__required_parameters[__k]["maxval"]
+        listval  = self.__required_parameters[__k]["listval"]
+        listadv  = self.__required_parameters[__k]["listadv"]

         #
         if value is None and default is None:
             __val = None
         #
         if value is None and default is None:
             __val = None


@@ -821,40 +902,96 @@ class Algorithm(object):
             else:                __val = typecast( default )
         else:
             if typecast is None: __val = value
             else:                __val = typecast( default )
         else:
             if typecast is None: __val = value

-            else:                __val = typecast( value )
+            else:
+                try:
+                    __val = typecast( value )
+                except:
+                    raise ValueError("The value '%s' for the parameter named '%s' can not be correctly evaluated with type '%s'."%(value, __k, typecast))

         #
         if minval is not None and (numpy.array(__val, float) < minval).any():
         #
         if minval is not None and (numpy.array(__val, float) < minval).any():

-            raise ValueError("The parameter named \"%s\" of value \"%s\" can not be less than %s."%(name, __val, minval))
+            raise ValueError("The parameter named '%s' of value '%s' can not be less than %s."%(__k, __val, minval))

         if maxval is not None and (numpy.array(__val, float) > maxval).any():
         if maxval is not None and (numpy.array(__val, float) > maxval).any():

-            raise ValueError("The parameter named \"%s\" of value \"%s\" can not be greater than %s."%(name, __val, maxval))
-        if listval is not None:
+            raise ValueError("The parameter named '%s' of value '%s' can not be greater than %s."%(__k, __val, maxval))
+        if listval is not None or listadv is not None:

             if typecast is list or typecast is tuple or isinstance(__val,list) or isinstance(__val,tuple):
                 for v in __val:
             if typecast is list or typecast is tuple or isinstance(__val,list) or isinstance(__val,tuple):
                 for v in __val:

-                    if v not in listval:
-                        raise ValueError("The value \"%s\" of the parameter named \"%s\" is not allowed, it has to be in the list %s."%(v, name, listval))
-            elif __val not in listval:
-                raise ValueError("The value \"%s\" of the parameter named \"%s\" is not allowed, it has to be in the list %s."%( __val, name,listval))
+                    if listval is not None and v in listval: continue
+                    elif listadv is not None and v in listadv: continue
+                    else:
+                        raise ValueError("The value '%s' is not allowed for the parameter named '%s', it has to be in the list %s."%(v, __k, listval))
+            elif not (listval is not None and __val in listval) and not (listadv is not None and __val in listadv):
+                raise ValueError("The value '%s' is not allowed for the parameter named '%s', it has to be in the list %s."%( __val, __k,listval))
+        #

         return __val
 
     def requireInputArguments(self, mandatory=(), optional=()):
         """
         return __val
 
     def requireInputArguments(self, mandatory=(), optional=()):
         """

-        Permet d'imposer des arguments requises en entrée
+        Permet d'imposer des arguments de calcul requis en entrée.

         """
         self.__required_inputs["RequiredInputValues"]["mandatory"] = tuple( mandatory )
         self.__required_inputs["RequiredInputValues"]["optional"]  = tuple( optional )
 
         """
         self.__required_inputs["RequiredInputValues"]["mandatory"] = tuple( mandatory )
         self.__required_inputs["RequiredInputValues"]["optional"]  = tuple( optional )
 

-    def __setParameters(self, fromDico={}):
+    def getInputArguments(self):
+        """
+        Permet d'obtenir les listes des arguments de calcul requis en entrée.
+        """
+        return self.__required_inputs["RequiredInputValues"]["mandatory"], self.__required_inputs["RequiredInputValues"]["optional"]
+
+    def setAttributes(self, tags=()):
+        """
+        Permet d'adjoindre des attributs comme les tags de classification.
+        Renvoie la liste actuelle dans tous les cas.
+        """
+        self.__required_inputs["ClassificationTags"].extend( tags )
+        return self.__required_inputs["ClassificationTags"]
+
+    def __setParameters(self, fromDico={}, reset=False):

         """
         Permet de stocker les paramètres reçus dans le dictionnaire interne.
         """
         self._parameters.update( fromDico )
         """
         Permet de stocker les paramètres reçus dans le dictionnaire interne.
         """
         self._parameters.update( fromDico )

+        __inverse_fromDico_keys = {}
+        for k in fromDico.keys():
+            if k.lower() in self.__canonical_parameter_name:
+                __inverse_fromDico_keys[self.__canonical_parameter_name[k.lower()]] = k
+        #~ __inverse_fromDico_keys = dict([(self.__canonical_parameter_name[k.lower()],k) for k in fromDico.keys()])
+        __canonic_fromDico_keys = __inverse_fromDico_keys.keys()

         for k in self.__required_parameters.keys():
         for k in self.__required_parameters.keys():

-            if k in fromDico.keys():
-                self._parameters[k] = self.setParameterValue(k,fromDico[k])
-            else:
+            if k in __canonic_fromDico_keys:
+                self._parameters[k] = self.setParameterValue(k,fromDico[__inverse_fromDico_keys[k]])
+            elif reset:

                 self._parameters[k] = self.setParameterValue(k)
                 self._parameters[k] = self.setParameterValue(k)

+            else:
+                pass

             logging.debug("%s %s : %s", self._name, self.__required_parameters[k]["message"], self._parameters[k])
 
             logging.debug("%s %s : %s", self._name, self.__required_parameters[k]["message"], self._parameters[k])
 

+    def _getTimeState(self, reset=False):
+        """
+        Initialise ou restitue le temps de calcul (cpu/elapsed) à la seconde
+        """
+        if reset:
+            self.__initial_cpu_time      = time.process_time()
+            self.__initial_elapsed_time  = time.perf_counter()
+            return 0., 0.
+        else:
+            self.__cpu_time     = time.process_time() - self.__initial_cpu_time
+            self.__elapsed_time = time.perf_counter() - self.__initial_elapsed_time
+            return self.__cpu_time, self.__elapsed_time
+
+    def _StopOnTimeLimit(self, X=None, withReason=False):
+        "Stop criteria on time limit: True/False [+ Reason]"
+        c, e = self._getTimeState()
+        if "MaximumCpuTime" in self._parameters and c > self._parameters["MaximumCpuTime"]:
+            __SC, __SR = True, "Reached maximum CPU time (%.1fs > %.1fs)"%(c, self._parameters["MaximumCpuTime"])
+        elif "MaximumElapsedTime" in self._parameters and e > self._parameters["MaximumElapsedTime"]:
+            __SC, __SR = True, "Reached maximum elapsed time (%.1fs > %.1fs)"%(e, self._parameters["MaximumElapsedTime"])
+        else:
+            __SC, __SR = False, ""
+        if withReason:
+            return __SC, __SR
+        else:
+            return __SC
+

 # ==============================================================================
 class AlgorithmAndParameters(object):
     """
 # ==============================================================================
 class AlgorithmAndParameters(object):
     """


@@ -879,7 +1016,7 @@ class AlgorithmAndParameters(object):
         self.updateParameters( asDict, asScript )
         #
         if asAlgorithm is None and asScript is not None:
         self.updateParameters( asDict, asScript )
         #
         if asAlgorithm is None and asScript is not None:

-            __Algo = ImportFromScript(asScript).getvalue( "Algorithm" )
+            __Algo = Interfaces.ImportFromScript(asScript).getvalue( "Algorithm" )

         else:
             __Algo = asAlgorithm
         #
         else:
             __Algo = asAlgorithm
         #


@@ -888,6 +1025,8 @@ class AlgorithmAndParameters(object):
             self.__P.update( {"Algorithm":self.__A} )
         #
         self.__setAlgorithm( self.__A )
             self.__P.update( {"Algorithm":self.__A} )
         #
         self.__setAlgorithm( self.__A )

+        #
+        self.__variable_names_not_public = {"nextStep":False} # Duplication dans Algorithm

 
     def updateParameters(self,
                  asDict     = None,
 
     def updateParameters(self,
                  asDict     = None,


@@ -895,7 +1034,7 @@ class AlgorithmAndParameters(object):
                 ):
         "Mise a jour des parametres"
         if asDict is None and asScript is not None:
                 ):
         "Mise a jour des parametres"
         if asDict is None and asScript is not None:

-            __Dict = ImportFromScript(asScript).getvalue( self.__name, "Parameters" )
+            __Dict = Interfaces.ImportFromScript(asScript).getvalue( self.__name, "Parameters" )

         else:
             __Dict = asDict
         #
         else:
             __Dict = asDict
         #


@@ -1003,7 +1142,9 @@ class AlgorithmAndParameters(object):
         elif key in self.__P:
             return self.__P[key]
         else:
         elif key in self.__P:
             return self.__P[key]
         else:

-            return self.__P
+            allvariables = self.__P
+            for k in self.__variable_names_not_public: allvariables.pop(k, None)
+            return allvariables

 
     def pop(self, k, d):
         "Necessaire pour le pickling"
 
     def pop(self, k, d):
         "Necessaire pour le pickling"


@@ -1013,6 +1154,14 @@ class AlgorithmAndParameters(object):
         "Renvoie la liste des paramètres requis selon l'algorithme"
         return self.__algorithm.getRequiredParameters(noDetails)
 
         "Renvoie la liste des paramètres requis selon l'algorithme"
         return self.__algorithm.getRequiredParameters(noDetails)
 

+    def getAlgorithmInputArguments(self):
+        "Renvoie la liste des entrées requises selon l'algorithme"
+        return self.__algorithm.getInputArguments()
+
+    def getAlgorithmAttributes(self):
+        "Renvoie la liste des attributs selon l'algorithme"
+        return self.__algorithm.setAttributes()
+

     def setObserver(self, __V, __O, __I, __S):
         if self.__algorithm is None \
             or isinstance(self.__algorithm, dict) \
     def setObserver(self, __V, __O, __I, __S):
         if self.__algorithm is None \
             or isinstance(self.__algorithm, dict) \


@@ -1050,7 +1199,10 @@ class AlgorithmAndParameters(object):
         return self.__algorithm.StoredVariables[ __V ].hasDataObserver()
 
     def keys(self):
         return self.__algorithm.StoredVariables[ __V ].hasDataObserver()
 
     def keys(self):

-        return list(self.__algorithm.keys()) + list(self.__P.keys())
+        __allvariables = list(self.__algorithm.keys()) + list(self.__P.keys())
+        for k in self.__variable_names_not_public:
+            if k in __allvariables: __allvariables.remove(k)
+        return __allvariables

 
     def __contains__(self, key=None):
         "D.__contains__(k) -> True if D has a key k, else False"
 
     def __contains__(self, key=None):
         "D.__contains__(k) -> True if D has a key k, else False"


@@ -1236,12 +1388,12 @@ class RegulationAndParameters(object):
         self.__P          = {}
         #
         if asAlgorithm is None and asScript is not None:
         self.__P          = {}
         #
         if asAlgorithm is None and asScript is not None:

-            __Algo = ImportFromScript(asScript).getvalue( "Algorithm" )
+            __Algo = Interfaces.ImportFromScript(asScript).getvalue( "Algorithm" )

         else:
             __Algo = asAlgorithm
         #
         if asDict is None and asScript is not None:
         else:
             __Algo = asAlgorithm
         #
         if asDict is None and asScript is not None:

-            __Dict = ImportFromScript(asScript).getvalue( self.__name, "Parameters" )
+            __Dict = Interfaces.ImportFromScript(asScript).getvalue( self.__name, "Parameters" )

         else:
             __Dict = asDict
         #
         else:
             __Dict = asDict
         #


@@ -1249,7 +1401,7 @@ class RegulationAndParameters(object):
             self.__P.update( dict(__Dict) )
         #
         if __Algo is not None:
             self.__P.update( dict(__Dict) )
         #
         if __Algo is not None:

-            self.__P.update( {"Algorithm":__Algo} )
+            self.__P.update( {"Algorithm":str(__Algo)} )

 
     def get(self, key = None):
         "Vérifie l'existence d'une clé de variable ou de paramètres"
 
     def get(self, key = None):
         "Vérifie l'existence d'une clé de variable ou de paramètres"


@@ -1298,19 +1450,11 @@ class DataObserver(object):
         else:
             raise ValueError("setting an observer has to be done over a variable name or a list of variable names.")
         #
         else:
             raise ValueError("setting an observer has to be done over a variable name or a list of variable names.")
         #

-        if asString is not None:
-            __FunctionText = asString
-        elif (asTemplate is not None) and (asTemplate in Templates.ObserverTemplates):
-            __FunctionText = Templates.ObserverTemplates[asTemplate]
-        elif asScript is not None:
-            __FunctionText = ImportFromScript(asScript).getstring()
-        else:
-            __FunctionText = ""
-        __Function = ObserverF(__FunctionText)
-        #

         if asObsObject is not None:
             self.__O = asObsObject
         else:
         if asObsObject is not None:
             self.__O = asObsObject
         else:

+            __FunctionText = str(UserScript('Observer', asTemplate, asString, asScript))
+            __Function = Observer2Func(__FunctionText)

             self.__O = __Function.getfunc()
         #
         for k in range(len(self.__V)):
             self.__O = __Function.getfunc()
         #
         for k in range(len(self.__V)):


@@ -1329,6 +1473,89 @@ class DataObserver(object):
         "x.__str__() <==> str(x)"
         return str(self.__V)+"\n"+str(self.__O)
 
         "x.__str__() <==> str(x)"
         return str(self.__V)+"\n"+str(self.__O)
 

+# ==============================================================================
+class UserScript(object):
+    """
+    Classe générale d'interface de type texte de script utilisateur
+    """
+    def __init__(self,
+                 name       = "GenericUserScript",
+                 asTemplate = None,
+                 asString   = None,
+                 asScript   = None,
+                ):
+        """
+        """
+        self.__name       = str(name)
+        #
+        if asString is not None:
+            self.__F = asString
+        elif self.__name == "UserPostAnalysis" and (asTemplate is not None) and (asTemplate in Templates.UserPostAnalysisTemplates):
+            self.__F = Templates.UserPostAnalysisTemplates[asTemplate]
+        elif self.__name == "Observer" and (asTemplate is not None) and (asTemplate in Templates.ObserverTemplates):
+            self.__F = Templates.ObserverTemplates[asTemplate]
+        elif asScript is not None:
+            self.__F = Interfaces.ImportFromScript(asScript).getstring()
+        else:
+            self.__F = ""
+
+    def __repr__(self):
+        "x.__repr__() <==> repr(x)"
+        return repr(self.__F)
+
+    def __str__(self):
+        "x.__str__() <==> str(x)"
+        return str(self.__F)
+
+# ==============================================================================
+class ExternalParameters(object):
+    """
+    Classe générale d'interface de type texte de script utilisateur
+    """
+    def __init__(self,
+                 name        = "GenericExternalParameters",
+                 asDict      = None,
+                 asScript    = None,
+                ):
+        """
+        """
+        self.__name = str(name)
+        self.__P    = {}
+        #
+        self.updateParameters( asDict, asScript )
+
+    def updateParameters(self,
+                 asDict     = None,
+                 asScript   = None,
+                ):
+        "Mise a jour des parametres"
+        if asDict is None and asScript is not None:
+            __Dict = Interfaces.ImportFromScript(asScript).getvalue( self.__name, "ExternalParameters" )
+        else:
+            __Dict = asDict
+        #
+        if __Dict is not None:
+            self.__P.update( dict(__Dict) )
+
+    def get(self, key = None):
+        if key in self.__P:
+            return self.__P[key]
+        else:
+            return list(self.__P.keys())
+
+    def keys(self):
+        return list(self.__P.keys())
+
+    def pop(self, k, d):
+        return self.__P.pop(k, d)
+
+    def items(self):
+        return self.__P.items()
+
+    def __contains__(self, key=None):
+        "D.__contains__(k) -> True if D has a key k, else False"
+        return key in self.__P
+

 # ==============================================================================
 class State(object):
     """
 # ==============================================================================
 class State(object):
     """


@@ -1360,10 +1587,10 @@ class State(object):
           contenant des valeurs en colonnes, elles-mêmes nommées "colNames"
           (s'il n'y a pas de nom de colonne indiquée, on cherche une colonne
           nommée "name"), on récupère les colonnes et on les range ligne après
           contenant des valeurs en colonnes, elles-mêmes nommées "colNames"
           (s'il n'y a pas de nom de colonne indiquée, on cherche une colonne
           nommée "name"), on récupère les colonnes et on les range ligne après

-          ligne (colMajor=False) ou colonne après colonne (colMajor=True). La
-          variable résultante est de type "asVector" (par défaut) ou
-          "asPersistentVector" selon que l'une de ces variables est placée à
-          "True".
+          ligne (colMajor=False, par défaut) ou colonne après colonne
+          (colMajor=True). La variable résultante est de type "asVector" (par
+          défaut) ou "asPersistentVector" selon que l'une de ces variables est
+          placée à "True".

         """
         self.__name       = str(name)
         self.__check      = bool(toBeChecked)
         """
         self.__name       = str(name)
         self.__check      = bool(toBeChecked)


@@ -1376,25 +1603,25 @@ class State(object):
         if asScript is not None:
             __Vector, __Series = None, None
             if asPersistentVector:
         if asScript is not None:
             __Vector, __Series = None, None
             if asPersistentVector:

-                __Series = ImportFromScript(asScript).getvalue( self.__name )
+                __Series = Interfaces.ImportFromScript(asScript).getvalue( self.__name )

             else:
             else:

-                __Vector = ImportFromScript(asScript).getvalue( self.__name )
+                __Vector = Interfaces.ImportFromScript(asScript).getvalue( self.__name )

         elif asDataFile is not None:
             __Vector, __Series = None, None
             if asPersistentVector:
                 if colNames is not None:
         elif asDataFile is not None:
             __Vector, __Series = None, None
             if asPersistentVector:
                 if colNames is not None:

-                    __Series = ImportFromFile(asDataFile).getvalue( colNames )[1]
+                    __Series = Interfaces.ImportFromFile(asDataFile).getvalue( colNames )[1]

                 else:
                 else:

-                    __Series = ImportFromFile(asDataFile).getvalue( [self.__name,] )[1]
-                if bool(colMajor) and not ImportFromFile(asDataFile).getformat() == "application/numpy.npz":
+                    __Series = Interfaces.ImportFromFile(asDataFile).getvalue( [self.__name,] )[1]
+                if bool(colMajor) and not Interfaces.ImportFromFile(asDataFile).getformat() == "application/numpy.npz":

                     __Series = numpy.transpose(__Series)
                     __Series = numpy.transpose(__Series)

-                elif not bool(colMajor) and ImportFromFile(asDataFile).getformat() == "application/numpy.npz":
+                elif not bool(colMajor) and Interfaces.ImportFromFile(asDataFile).getformat() == "application/numpy.npz":

                     __Series = numpy.transpose(__Series)
             else:
                 if colNames is not None:
                     __Series = numpy.transpose(__Series)
             else:
                 if colNames is not None:

-                    __Vector = ImportFromFile(asDataFile).getvalue( colNames )[1]
+                    __Vector = Interfaces.ImportFromFile(asDataFile).getvalue( colNames )[1]

                 else:
                 else:

-                    __Vector = ImportFromFile(asDataFile).getvalue( [self.__name,] )[1]
+                    __Vector = Interfaces.ImportFromFile(asDataFile).getvalue( [self.__name,] )[1]

                 if bool(colMajor):
                     __Vector = numpy.ravel(__Vector, order = "F")
                 else:
                 if bool(colMajor):
                     __Vector = numpy.ravel(__Vector, order = "F")
                 else:


@@ -1424,7 +1651,7 @@ class State(object):
                 self.shape       = (self.shape[0],1)
             self.size        = self.shape[0] * self.shape[1]
         else:
                 self.shape       = (self.shape[0],1)
             self.size        = self.shape[0] * self.shape[1]
         else:

-            raise ValueError("The %s object is improperly defined, it requires at minima either a vector, a list/tuple of vectors or a persistent object. Please check your vector input."%self.__name)
+            raise ValueError("The %s object is improperly defined or undefined, it requires at minima either a vector, a list/tuple of vectors or a persistent object. Please check your vector input."%self.__name)

         #
         if scheduledBy is not None:
             self.__T = scheduledBy
         #
         if scheduledBy is not None:
             self.__T = scheduledBy


@@ -1496,13 +1723,13 @@ class Covariance(object):
         if asScript is not None:
             __Matrix, __Scalar, __Vector, __Object = None, None, None, None
             if asEyeByScalar:
         if asScript is not None:
             __Matrix, __Scalar, __Vector, __Object = None, None, None, None
             if asEyeByScalar:

-                __Scalar = ImportFromScript(asScript).getvalue( self.__name )
+                __Scalar = Interfaces.ImportFromScript(asScript).getvalue( self.__name )

             elif asEyeByVector:
             elif asEyeByVector:

-                __Vector = ImportFromScript(asScript).getvalue( self.__name )
+                __Vector = Interfaces.ImportFromScript(asScript).getvalue( self.__name )

             elif asCovObject:
             elif asCovObject:

-                __Object = ImportFromScript(asScript).getvalue( self.__name )
+                __Object = Interfaces.ImportFromScript(asScript).getvalue( self.__name )

             else:
             else:

-                __Matrix = ImportFromScript(asScript).getvalue( self.__name )
+                __Matrix = Interfaces.ImportFromScript(asScript).getvalue( self.__name )

         else:
             __Matrix, __Scalar, __Vector, __Object = asCovariance, asEyeByScalar, asEyeByVector, asCovObject
         #
         else:
             __Matrix, __Scalar, __Vector, __Object = asCovariance, asEyeByScalar, asEyeByVector, asCovObject
         #


@@ -1628,6 +1855,30 @@ class Covariance(object):
         elif self.isobject() and hasattr(self.__C,"choleskyI"):
             return Covariance(self.__name+"H", asCovObject   = self.__C.choleskyI() )
 
         elif self.isobject() and hasattr(self.__C,"choleskyI"):
             return Covariance(self.__name+"H", asCovObject   = self.__C.choleskyI() )
 

+    def sqrtm(self):
+        "Racine carrée matricielle"
+        if   self.ismatrix():
+            import scipy
+            return Covariance(self.__name+"C", asCovariance  = scipy.linalg.sqrtm(self.__C) )
+        elif self.isvector():
+            return Covariance(self.__name+"C", asEyeByVector = numpy.sqrt( self.__C ) )
+        elif self.isscalar():
+            return Covariance(self.__name+"C", asEyeByScalar = numpy.sqrt( self.__C ) )
+        elif self.isobject() and hasattr(self.__C,"sqrt"):
+            return Covariance(self.__name+"C", asCovObject   = self.__C.sqrt() )
+
+    def sqrtmI(self):
+        "Inversion de la racine carrée matricielle"
+        if   self.ismatrix():
+            import scipy
+            return Covariance(self.__name+"H", asCovariance  = scipy.linalg.sqrtm(self.__C).I )
+        elif self.isvector():
+            return Covariance(self.__name+"H", asEyeByVector = 1.0 / numpy.sqrt( self.__C ) )
+        elif self.isscalar():
+            return Covariance(self.__name+"H", asEyeByScalar = 1.0 / numpy.sqrt( self.__C ) )
+        elif self.isobject() and hasattr(self.__C,"sqrtI"):
+            return Covariance(self.__name+"H", asCovObject   = self.__C.sqrtI() )
+

     def diag(self, msize=None):
         "Diagonale de la matrice"
         if   self.ismatrix():
     def diag(self, msize=None):
         "Diagonale de la matrice"
         if   self.ismatrix():


@@ -1771,7 +2022,7 @@ class Covariance(object):
         return self.shape[0]
 
 # ==============================================================================
         return self.shape[0]
 
 # ==============================================================================

-class ObserverF(object):
+class Observer2Func(object):

     """
     Creation d'une fonction d'observateur a partir de son texte
     """
     """
     Creation d'une fonction d'observateur a partir de son texte
     """


@@ -1835,27 +2086,69 @@ class CaseLogger(object):
         return __formater.load(__filename, __content, __object)
 
 # ==============================================================================
         return __formater.load(__filename, __content, __object)
 
 # ==============================================================================

-def MultiFonction( __xserie, _extraArguments = None, _sFunction = lambda x: x ):
+def MultiFonction(
+        __xserie,
+        _extraArguments = None,
+        _sFunction      = lambda x: x,
+        _mpEnabled      = False,
+        _mpWorkers      = None,
+        ):

     """
     Pour une liste ordonnée de vecteurs en entrée, renvoie en sortie la liste
     correspondante de valeurs de la fonction en argument
     """
     """
     Pour une liste ordonnée de vecteurs en entrée, renvoie en sortie la liste
     correspondante de valeurs de la fonction en argument
     """

+    # Vérifications et définitions initiales
+    # logging.debug("MULTF Internal multifonction calculations begin with function %s"%(_sFunction.__name__,))

     if not PlatformInfo.isIterable( __xserie ):
         raise TypeError("MultiFonction not iterable unkown input type: %s"%(type(__xserie),))
     if not PlatformInfo.isIterable( __xserie ):
         raise TypeError("MultiFonction not iterable unkown input type: %s"%(type(__xserie),))

+    if _mpEnabled:
+        if (_mpWorkers is None) or (_mpWorkers is not None and _mpWorkers < 1):
+            __mpWorkers = None
+        else:
+            __mpWorkers = int(_mpWorkers)
+        try:
+            import multiprocessing
+            __mpEnabled = True
+        except ImportError:
+            __mpEnabled = False
+    else:
+        __mpEnabled = False
+        __mpWorkers = None

     #
     #

-    __multiHX = []
-    if _extraArguments is None:
-        for __xvalue in __xserie:
-            __multiHX.append( _sFunction( __xvalue ) )
-    elif _extraArguments is not None and isinstance(_extraArguments, (list, tuple, map)):
-        for __xvalue in __xserie:
-            __multiHX.append( _sFunction( __xvalue, *_extraArguments ) )
-    elif _extraArguments is not None and isinstance(_extraArguments, dict):
-        for __xvalue in __xserie:
-            __multiHX.append( _sFunction( __xvalue, **_extraArguments ) )
+    # Calculs effectifs
+    if __mpEnabled:
+        _jobs = []
+        if _extraArguments is None:
+            _jobs = __xserie
+        elif _extraArguments is not None and isinstance(_extraArguments, (list, tuple, map)):
+            for __xvalue in __xserie:
+                _jobs.append( [__xvalue, ] + list(_extraArguments) )
+        else:
+            raise TypeError("MultiFonction extra arguments unkown input type: %s"%(type(_extraArguments),))
+        # logging.debug("MULTF Internal multiprocessing calculations begin : evaluation of %i point(s)"%(len(_jobs),))
+        import multiprocessing
+        with multiprocessing.Pool(__mpWorkers) as pool:
+            __multiHX = pool.map( _sFunction, _jobs )
+            pool.close()
+            pool.join()
+        # logging.debug("MULTF Internal multiprocessing calculation end")

     else:
     else:

-        raise TypeError("MultiFonction extra arguments unkown input type: %s"%(type(_extraArguments),))
+        # logging.debug("MULTF Internal monoprocessing calculation begin")
+        __multiHX = []
+        if _extraArguments is None:
+            for __xvalue in __xserie:
+                __multiHX.append( _sFunction( __xvalue ) )
+        elif _extraArguments is not None and isinstance(_extraArguments, (list, tuple, map)):
+            for __xvalue in __xserie:
+                __multiHX.append( _sFunction( __xvalue, *_extraArguments ) )
+        elif _extraArguments is not None and isinstance(_extraArguments, dict):
+            for __xvalue in __xserie:
+                __multiHX.append( _sFunction( __xvalue, **_extraArguments ) )
+        else:
+            raise TypeError("MultiFonction extra arguments unkown input type: %s"%(type(_extraArguments),))
+        # logging.debug("MULTF Internal monoprocessing calculation end")

     #
     #

+    # logging.debug("MULTF Internal multifonction calculations end")

     return __multiHX
 
 # ==============================================================================
     return __multiHX
 
 # ==============================================================================


@@ -1975,4 +2268,4 @@ def CostFunction3D(_x,
 
 # ==============================================================================
 if __name__ == "__main__":
 
 # ==============================================================================
 if __name__ == "__main__":

-    print('\n AUTODIAGNOSTIC \n')
+    print('\n AUTODIAGNOSTIC\n')