src/daComposant/daCore/Aidsm.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # Copyright (C) 2008-2020 EDF R&D
   4 #
   5 # This library is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU Lesser General Public
   7 # License as published by the Free Software Foundation; either
   8 # version 2.1 of the License.
   9 #
  10 # This library is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 # Lesser General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU Lesser General Public
  16 # License along with this library; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 #
  19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 #
  21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  22
  23 """
  24     Normalized interface for ADAO scripting (generic API)
  25 """
  26 __author__ = "Jean-Philippe ARGAUD"
  27 __all__ = ["Aidsm"]
  28
  29 import os
  30 import sys
  31 #
  32 from daCore.BasicObjects import State, Covariance, FullOperator, Operator
  33 from daCore.BasicObjects import AlgorithmAndParameters, DataObserver
  34 from daCore.BasicObjects import RegulationAndParameters, CaseLogger
  35 from daCore import PlatformInfo
  36 #
  37 from daCore import ExtendedLogging ; ExtendedLogging.ExtendedLogging() # A importer en premier
  38 import logging
  39
  40 # ==============================================================================
  41 class Aidsm(object):
  42     """ ADAO Internal Data Structure Model """
  43     def __init__(self, name = "", addViewers=None):
  44         self.__name = str(name)
  45         self.__directory    = None
  46         self.__case = CaseLogger(self.__name, "case", addViewers)
  47         #
  48         self.__adaoObject   = {}
  49         self.__StoredInputs = {}
  50         self.__PostAnalysis = []
  51         #
  52         self.__Concepts = [
  53             "AlgorithmParameters",
  54             "Background",
  55             "CheckingPoint",
  56             "ControlInput",
  57             "Observation",
  58             "BackgroundError",
  59             "ObservationError",
  60             "EvolutionError",
  61             "ObservationOperator",
  62             "EvolutionModel",
  63             "ControlModel",
  64             "Name",
  65             "Directory",
  66             "Debug",
  67             "NoDebug",
  68             "RegulationParameters",
  69             "Observer",
  70             ]
  71         #
  72         for ename in self.__Concepts:
  73             self.__adaoObject[ename] = None
  74         for ename in ("ObservationOperator", "EvolutionModel", "ControlModel"):
  75             self.__adaoObject[ename] = {}
  76         for ename in ("Observer",):
  77             self.__adaoObject[ename]   = []
  78             self.__StoredInputs[ename] = []
  79         self.__StoredInputs["Name"] = self.__name
  80         self.__StoredInputs["Directory"] = self.__directory
  81         #
  82         # Récupère le chemin du répertoire parent et l'ajoute au path
  83         # (Cela complète l'action de la classe PathManagement dans PlatformInfo,
  84         # qui est activée dans Persistence)
  85         self.__parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
  86         sys.path.insert(0, self.__parent)
  87         sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
  88
  89     def set(self,
  90             Concept              = None, # Premier argument
  91             Algorithm            = None,
  92             AppliedInXb          = None,
  93             AvoidRC              = True,
  94             Checked              = False,
  95             ColMajor             = False,
  96             ColNames             = None,
  97             DataFile             = None,
  98             DiagonalSparseMatrix = None,
  99             ExtraArguments       = None,
 100             Info                 = None,
 101             InputFunctionAsMulti = False,
 102             Matrix               = None,
 103             ObjectFunction       = None,
 104             ObjectMatrix         = None,
 105             OneFunction          = None,
 106             Parameters           = None,
 107             ScalarSparseMatrix   = None,
 108             Scheduler            = None,
 109             Script               = None,
 110             Stored               = False,
 111             String               = None,
 112             Template             = None,
 113             ThreeFunctions       = None,
 114             Variable             = None,
 115             Vector               = None,
 116             VectorSerie          = None,
 117             ):
 118         "Interface unique de definition de variables d'entrees par argument"
 119         self.__case.register("set",dir(),locals(),None,True)
 120         try:
 121             if   Concept in ("Background", "CheckingPoint", "ControlInput", "Observation"):
 122                 commande = getattr(self,"set"+Concept)
 123                 commande(Vector, VectorSerie, Script, DataFile, ColNames, ColMajor, Stored, Scheduler, Checked )
 124             elif Concept in ("BackgroundError", "ObservationError", "EvolutionError"):
 125                 commande = getattr(self,"set"+Concept)
 126                 commande(Matrix, ScalarSparseMatrix, DiagonalSparseMatrix,
 127                          Script, Stored, ObjectMatrix, Checked )
 128             elif Concept == "AlgorithmParameters":
 129                 self.setAlgorithmParameters( Algorithm, Parameters, Script )
 130             elif Concept == "RegulationParameters":
 131                 self.setRegulationParameters( Algorithm, Parameters, Script )
 132             elif Concept == "Name":
 133                 self.setName(String)
 134             elif Concept == "Directory":
 135                 self.setDirectory(String)
 136             elif Concept == "Debug":
 137                 self.setDebug()
 138             elif Concept == "NoDebug":
 139                 self.setNoDebug()
 140             elif Concept == "Observer":
 141                 self.setObserver( Variable, Template, String, Script, Info, ObjectFunction, Scheduler )
 142             elif Concept == "ObservationOperator":
 143                 self.setObservationOperator(
 144                     Matrix, OneFunction, ThreeFunctions, AppliedInXb,
 145                     Parameters, Script, ExtraArguments,
 146                     Stored, AvoidRC, InputFunctionAsMulti, Checked )
 147             elif Concept in ("EvolutionModel", "ControlModel"):
 148                 commande = getattr(self,"set"+Concept)
 149                 commande(
 150                     Matrix, OneFunction, ThreeFunctions,
 151                     Parameters, Script, Scheduler, ExtraArguments,
 152                     Stored, AvoidRC, InputFunctionAsMulti, Checked )
 153             else:
 154                 raise ValueError("the variable named '%s' is not allowed."%str(Concept))
 155         except Exception as e:
 156             if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
 157             else: msg = ""
 158             raise ValueError(("during settings, the following error occurs:\n"+\
 159                               "\n%s %s\n\nSee also the potential messages, "+\
 160                               "which can show the origin of the above error, "+\
 161                               "in the launching terminal.")%(str(e),msg))
 162
 163     # -----------------------------------------------------------
 164
 165     def setBackground(self,
 166             Vector         = None,
 167             VectorSerie    = None,
 168             Script         = None,
 169             DataFile       = None,
 170             ColNames       = None,
 171             ColMajor       = False,
 172             Stored         = False,
 173             Scheduler      = None,
 174             Checked        = False):
 175         "Definition d'un concept de calcul"
 176         Concept = "Background"
 177         self.__case.register("set"+Concept, dir(), locals())
 178         self.__adaoObject[Concept] = State(
 179             name               = Concept,
 180             asVector           = Vector,
 181             asPersistentVector = VectorSerie,
 182             asScript           = self.__with_directory(Script),
 183             asDataFile         = DataFile,
 184             colNames           = ColNames,
 185             colMajor           = ColMajor,
 186             scheduledBy        = Scheduler,
 187             toBeChecked        = Checked,
 188             )
 189         if Stored:
 190             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 191         return 0
 192
 193     def setCheckingPoint(self,
 194             Vector         = None,
 195             VectorSerie    = None,
 196             Script         = None,
 197             DataFile       = None,
 198             ColNames       = None,
 199             ColMajor       = False,
 200             Stored         = False,
 201             Scheduler      = None,
 202             Checked        = False):
 203         "Definition d'un concept de calcul"
 204         Concept = "CheckingPoint"
 205         self.__case.register("set"+Concept, dir(), locals())
 206         self.__adaoObject[Concept] = State(
 207             name               = Concept,
 208             asVector           = Vector,
 209             asPersistentVector = VectorSerie,
 210             asScript           = self.__with_directory(Script),
 211             asDataFile         = DataFile,
 212             colNames           = ColNames,
 213             colMajor           = ColMajor,
 214             scheduledBy        = Scheduler,
 215             toBeChecked        = Checked,
 216             )
 217         if Stored:
 218             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 219         return 0
 220
 221     def setControlInput(self,
 222             Vector         = None,
 223             VectorSerie    = None,
 224             Script         = None,
 225             DataFile       = None,
 226             ColNames       = None,
 227             ColMajor       = False,
 228             Stored         = False,
 229             Scheduler      = None,
 230             Checked        = False):
 231         "Definition d'un concept de calcul"
 232         Concept = "ControlInput"
 233         self.__case.register("set"+Concept, dir(), locals())
 234         self.__adaoObject[Concept] = State(
 235             name               = Concept,
 236             asVector           = Vector,
 237             asPersistentVector = VectorSerie,
 238             asScript           = self.__with_directory(Script),
 239             asDataFile         = DataFile,
 240             colNames           = ColNames,
 241             colMajor           = ColMajor,
 242             scheduledBy        = Scheduler,
 243             toBeChecked        = Checked,
 244             )
 245         if Stored:
 246             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 247         return 0
 248
 249     def setObservation(self,
 250             Vector         = None,
 251             VectorSerie    = None,
 252             Script         = None,
 253             DataFile       = None,
 254             ColNames       = None,
 255             ColMajor       = False,
 256             Stored         = False,
 257             Scheduler      = None,
 258             Checked        = False):
 259         "Definition d'un concept de calcul"
 260         Concept = "Observation"
 261         self.__case.register("set"+Concept, dir(), locals())
 262         self.__adaoObject[Concept] = State(
 263             name               = Concept,
 264             asVector           = Vector,
 265             asPersistentVector = VectorSerie,
 266             asScript           = self.__with_directory(Script),
 267             asDataFile         = DataFile,
 268             colNames           = ColNames,
 269             colMajor           = ColMajor,
 270             scheduledBy        = Scheduler,
 271             toBeChecked        = Checked,
 272             )
 273         if Stored:
 274             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 275         return 0
 276
 277     def setBackgroundError(self,
 278             Matrix               = None,
 279             ScalarSparseMatrix   = None,
 280             DiagonalSparseMatrix = None,
 281             Script               = None,
 282             Stored               = False,
 283             ObjectMatrix         = None,
 284             Checked              = False):
 285         "Definition d'un concept de calcul"
 286         Concept = "BackgroundError"
 287         self.__case.register("set"+Concept, dir(), locals())
 288         self.__adaoObject[Concept] = Covariance(
 289             name          = Concept,
 290             asCovariance  = Matrix,
 291             asEyeByScalar = ScalarSparseMatrix,
 292             asEyeByVector = DiagonalSparseMatrix,
 293             asCovObject   = ObjectMatrix,
 294             asScript      = self.__with_directory(Script),
 295             toBeChecked   = Checked,
 296             )
 297         if Stored:
 298             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 299         return 0
 300
 301     def setObservationError(self,
 302             Matrix               = None,
 303             ScalarSparseMatrix   = None,
 304             DiagonalSparseMatrix = None,
 305             Script               = None,
 306             Stored               = False,
 307             ObjectMatrix         = None,
 308             Checked              = False):
 309         "Definition d'un concept de calcul"
 310         Concept = "ObservationError"
 311         self.__case.register("set"+Concept, dir(), locals())
 312         self.__adaoObject[Concept] = Covariance(
 313             name          = Concept,
 314             asCovariance  = Matrix,
 315             asEyeByScalar = ScalarSparseMatrix,
 316             asEyeByVector = DiagonalSparseMatrix,
 317             asCovObject   = ObjectMatrix,
 318             asScript      = self.__with_directory(Script),
 319             toBeChecked   = Checked,
 320             )
 321         if Stored:
 322             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 323         return 0
 324
 325     def setEvolutionError(self,
 326             Matrix               = None,
 327             ScalarSparseMatrix   = None,
 328             DiagonalSparseMatrix = None,
 329             Script               = None,
 330             Stored               = False,
 331             ObjectMatrix         = None,
 332             Checked              = False):
 333         "Definition d'un concept de calcul"
 334         Concept = "EvolutionError"
 335         self.__case.register("set"+Concept, dir(), locals())
 336         self.__adaoObject[Concept] = Covariance(
 337             name          = Concept,
 338             asCovariance  = Matrix,
 339             asEyeByScalar = ScalarSparseMatrix,
 340             asEyeByVector = DiagonalSparseMatrix,
 341             asCovObject   = ObjectMatrix,
 342             asScript      = self.__with_directory(Script),
 343             toBeChecked   = Checked,
 344             )
 345         if Stored:
 346             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 347         return 0
 348
 349     def setObservationOperator(self,
 350             Matrix               = None,
 351             OneFunction          = None,
 352             ThreeFunctions       = None,
 353             AppliedInXb          = None,
 354             Parameters           = None,
 355             Script               = None,
 356             ExtraArguments       = None,
 357             Stored               = False,
 358             AvoidRC              = True,
 359             InputFunctionAsMulti = False,
 360             Checked              = False):
 361         "Definition d'un concept de calcul"
 362         Concept = "ObservationOperator"
 363         self.__case.register("set"+Concept, dir(), locals())
 364         self.__adaoObject[Concept] = FullOperator(
 365             name             = Concept,
 366             asMatrix         = Matrix,
 367             asOneFunction    = OneFunction,
 368             asThreeFunctions = ThreeFunctions,
 369             asScript         = self.__with_directory(Script),
 370             asDict           = Parameters,
 371             appliedInX       = AppliedInXb,
 372             extraArguments   = ExtraArguments,
 373             avoidRC          = AvoidRC,
 374             inputAsMF        = InputFunctionAsMulti,
 375             scheduledBy      = None,
 376             toBeChecked      = Checked,
 377             )
 378         if Stored:
 379             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 380         return 0
 381
 382     def setEvolutionModel(self,
 383             Matrix               = None,
 384             OneFunction          = None,
 385             ThreeFunctions       = None,
 386             Parameters           = None,
 387             Script               = None,
 388             Scheduler            = None,
 389             ExtraArguments       = None,
 390             Stored               = False,
 391             AvoidRC              = True,
 392             InputFunctionAsMulti = False,
 393             Checked              = False):
 394         "Definition d'un concept de calcul"
 395         Concept = "EvolutionModel"
 396         self.__case.register("set"+Concept, dir(), locals())
 397         self.__adaoObject[Concept] = FullOperator(
 398             name             = Concept,
 399             asMatrix         = Matrix,
 400             asOneFunction    = OneFunction,
 401             asThreeFunctions = ThreeFunctions,
 402             asScript         = self.__with_directory(Script),
 403             asDict           = Parameters,
 404             appliedInX       = None,
 405             extraArguments   = ExtraArguments,
 406             avoidRC          = AvoidRC,
 407             inputAsMF        = InputFunctionAsMulti,
 408             scheduledBy      = Scheduler,
 409             toBeChecked      = Checked,
 410             )
 411         if Stored:
 412             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 413         return 0
 414
 415     def setControlModel(self,
 416             Matrix               = None,
 417             OneFunction          = None,
 418             ThreeFunctions       = None,
 419             Parameters           = None,
 420             Script               = None,
 421             Scheduler            = None,
 422             ExtraArguments       = None,
 423             Stored               = False,
 424             AvoidRC              = True,
 425             InputFunctionAsMulti = False,
 426             Checked              = False):
 427         "Definition d'un concept de calcul"
 428         Concept = "ControlModel"
 429         self.__case.register("set"+Concept, dir(), locals())
 430         self.__adaoObject[Concept] = FullOperator(
 431             name             = Concept,
 432             asMatrix         = Matrix,
 433             asOneFunction    = OneFunction,
 434             asThreeFunctions = ThreeFunctions,
 435             asScript         = self.__with_directory(Script),
 436             asDict           = Parameters,
 437             appliedInX       = None,
 438             extraArguments   = ExtraArguments,
 439             avoidRC          = AvoidRC,
 440             inputAsMF        = InputFunctionAsMulti,
 441             scheduledBy      = Scheduler,
 442             toBeChecked      = Checked,
 443             )
 444         if Stored:
 445             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 446         return 0
 447
 448     def setName(self, String=None):
 449         "Definition d'un concept de calcul"
 450         self.__case.register("setName",dir(),locals())
 451         if String is not None:
 452             self.__name = str(String)
 453         else:
 454             self.__name = None
 455         self.__StoredInputs["Name"] = self.__name
 456
 457     def setDirectory(self, String=None):
 458         "Definition d'un concept de calcul"
 459         self.__case.register("setDirectory",dir(),locals())
 460         if os.path.isdir(os.path.abspath(str(String))):
 461             self.__directory = os.path.abspath(str(String))
 462         else:
 463             self.__directory = None
 464         self.__StoredInputs["Directory"] = self.__directory
 465
 466     def setDebug(self, __level = 10):
 467         "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
 468         self.__case.register("setDebug",dir(),locals())
 469         log = logging.getLogger()
 470         log.setLevel( __level )
 471         self.__StoredInputs["Debug"]   = __level
 472         self.__StoredInputs["NoDebug"] = False
 473         return 0
 474
 475     def setNoDebug(self):
 476         "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
 477         self.__case.register("setNoDebug",dir(),locals())
 478         log = logging.getLogger()
 479         log.setLevel( logging.WARNING )
 480         self.__StoredInputs["Debug"]   = logging.WARNING
 481         self.__StoredInputs["NoDebug"] = True
 482         return 0
 483
 484     def setAlgorithmParameters(self,
 485             Algorithm  = None,
 486             Parameters = None,
 487             Script     = None):
 488         "Definition d'un concept de calcul"
 489         Concept = "AlgorithmParameters"
 490         self.__case.register("set"+Concept, dir(), locals())
 491         self.__adaoObject[Concept] = AlgorithmAndParameters(
 492             name          = Concept,
 493             asAlgorithm   = Algorithm,
 494             asDict        = Parameters,
 495             asScript      = self.__with_directory(Script),
 496             )
 497         return 0
 498
 499     def updateAlgorithmParameters(self,
 500             Parameters = None,
 501             Script     = None):
 502         "Mise a jour d'un concept de calcul"
 503         if "AlgorithmParameters" not in self.__adaoObject:
 504             raise ValueError("No algorithm registred, ask for one before updating parameters")
 505         self.__adaoObject["AlgorithmParameters"].updateParameters(
 506             asDict        = Parameters,
 507             asScript      = self.__with_directory(Script),
 508             )
 509         return 0
 510
 511     def setRegulationParameters(self,
 512             Algorithm  = None,
 513             Parameters = None,
 514             Script     = None):
 515         "Definition d'un concept de calcul"
 516         Concept = "RegulationParameters"
 517         self.__case.register("set"+Concept, dir(), locals())
 518         self.__adaoObject[Concept] = RegulationAndParameters(
 519             name          = Concept,
 520             asAlgorithm   = Algorithm,
 521             asDict        = Parameters,
 522             asScript      = self.__with_directory(Script),
 523             )
 524         return 0
 525
 526     def setObserver(self,
 527             Variable       = None,
 528             Template       = None,
 529             String         = None,
 530             Script         = None,
 531             Info           = None,
 532             ObjectFunction = None,
 533             Scheduler      = None):
 534         "Definition d'un concept de calcul"
 535         Concept = "Observer"
 536         self.__case.register("set"+Concept, dir(), locals())
 537         self.__adaoObject[Concept].append( DataObserver(
 538             name        = Concept,
 539             onVariable  = Variable,
 540             asTemplate  = Template,
 541             asString    = String,
 542             asScript    = self.__with_directory(Script),
 543             asObsObject = ObjectFunction,
 544             withInfo    = Info,
 545             scheduledBy = Scheduler,
 546             withAlgo    = self.__adaoObject["AlgorithmParameters"]
 547             ))
 548         return 0
 549
 550     def removeObserver(self,
 551             Variable       = None,
 552             ObjectFunction = None,
 553             ):
 554         "Permet de retirer un observer à une ou des variable nommée"
 555         if "AlgorithmParameters" not in self.__adaoObject:
 556             raise ValueError("No algorithm registred, ask for one before removing observers")
 557         #
 558         # Vérification du nom de variable et typage
 559         # -----------------------------------------
 560         if isinstance(Variable, str):
 561             VariableNames = (Variable,)
 562         elif isinstance(Variable, list):
 563             VariableNames = tuple(map( str, Variable ))
 564         else:
 565             raise ValueError("The observer requires a name or a list of names of variables.")
 566         #
 567         # Association interne de l'observer à la variable
 568         # -----------------------------------------------
 569         for ename in VariableNames:
 570             if ename not in self.__adaoObject["AlgorithmParameters"]:
 571                 raise ValueError("An observer requires to be removed on a variable named %s which does not exist."%ename)
 572             else:
 573                 return self.__adaoObject["AlgorithmParameters"].removeObserver( ename, ObjectFunction )
 574
 575     # -----------------------------------------------------------
 576
 577     def get(self, Concept=None, noDetails=True ):
 578         "Recuperation d'une sortie du calcul"
 579         if Concept is not None:
 580             try:
 581                 self.__case.register("get", dir(), locals(), Concept) # Break pickle in Python 2
 582             except Exception:
 583                 pass
 584             if Concept in self.__StoredInputs:
 585                 return self.__StoredInputs[Concept]
 586                 #
 587             elif self.__adaoObject["AlgorithmParameters"] is not None and Concept == "AlgorithmParameters":
 588                 return self.__adaoObject["AlgorithmParameters"].get()
 589                 #
 590             elif self.__adaoObject["AlgorithmParameters"] is not None and Concept in self.__adaoObject["AlgorithmParameters"]:
 591                 return self.__adaoObject["AlgorithmParameters"].get( Concept )
 592                 #
 593             elif Concept == "AlgorithmRequiredParameters" and self.__adaoObject["AlgorithmParameters"] is not None:
 594                 return self.__adaoObject["AlgorithmParameters"].getAlgorithmRequiredParameters(noDetails)
 595                 #
 596             else:
 597                 raise ValueError("The requested key \"%s\" does not exists as an input or a stored variable."%Concept)
 598         else:
 599             allvariables = {}
 600             allvariables.update( {"AlgorithmParameters":self.__adaoObject["AlgorithmParameters"].get()} )
 601             # allvariables.update( self.__adaoObject["AlgorithmParameters"].get() )
 602             allvariables.update( self.__StoredInputs )
 603             allvariables.pop('Observer', None)
 604             return allvariables
 605
 606     # -----------------------------------------------------------
 607
 608     def get_available_variables(self):
 609         """
 610         Renvoie les variables potentiellement utilisables pour l'étude,
 611         initialement stockées comme données d'entrées ou dans les algorithmes,
 612         identifiés par les chaînes de caractères. L'algorithme doit avoir été
 613         préalablement choisi sinon la méthode renvoie "None".
 614         """
 615         if len(list(self.__adaoObject["AlgorithmParameters"].keys())) == 0 and \
 616             len(list(self.__StoredInputs.keys())) == 0:
 617             return None
 618         else:
 619             variables = []
 620             if len(list(self.__adaoObject["AlgorithmParameters"].keys())) > 0:
 621                 variables.extend(list(self.__adaoObject["AlgorithmParameters"].keys()))
 622             if len(list(self.__StoredInputs.keys())) > 0:
 623                 variables.extend( list(self.__StoredInputs.keys()) )
 624             variables.remove('Observer')
 625             variables.sort()
 626             return variables
 627
 628     def get_available_algorithms(self):
 629         """
 630         Renvoie la liste des algorithmes potentiellement utilisables, identifiés
 631         par les chaînes de caractères.
 632         """
 633         files = []
 634         for directory in sys.path:
 635             trypath = os.path.join(directory,"daAlgorithms")
 636             if os.path.isdir(trypath):
 637                 for fname in os.listdir(trypath):
 638                     if os.path.isfile(os.path.join(trypath,fname)):
 639                         root, ext = os.path.splitext(fname)
 640                         if ext != ".py": continue
 641                         fc = open(os.path.join(trypath,fname)).read()
 642                         iselal = bool("class ElementaryAlgorithm" in fc)
 643                         if iselal and ext == '.py' and root != '__init__':
 644                             files.append(root)
 645         files.sort()
 646         return files
 647
 648     def get_algorithms_main_path(self):
 649         """
 650         Renvoie le chemin pour le répertoire principal contenant les algorithmes
 651         """
 652         return self.__parent
 653
 654     def add_algorithms_path(self, Path=None):
 655         """
 656         Ajoute au chemin de recherche des algorithmes un répertoire dans lequel
 657         se trouve un sous-répertoire "daAlgorithms"
 658         """
 659         if not os.path.isdir(Path):
 660             raise ValueError("The given "+Path+" argument must exist as a directory")
 661         if not os.path.isdir(os.path.join(Path,"daAlgorithms")):
 662             raise ValueError("The given \""+Path+"\" argument must contain a subdirectory named \"daAlgorithms\"")
 663         if not os.path.isfile(os.path.join(Path,"daAlgorithms","__init__.py")):
 664             raise ValueError("The given \""+Path+"/daAlgorithms\" path must contain a file named \"__init__.py\"")
 665         sys.path.insert(0, os.path.abspath(Path))
 666         sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
 667         return 0
 668
 669     # -----------------------------------------------------------
 670
 671     def execute(self, Executor=None, SaveCaseInFile=None, nextStep=False):
 672         "Lancement du calcul"
 673         self.__case.register("execute",dir(),locals(),None,True)
 674         self.updateAlgorithmParameters(Parameters={"nextStep":bool(nextStep)})
 675         if not nextStep: Operator.CM.clearCache()
 676         try:
 677             if   Executor == "YACS": self.__executeYACSScheme( SaveCaseInFile )
 678             else:                    self.__executePythonScheme( SaveCaseInFile )
 679         except Exception as e:
 680             if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
 681             else: msg = ""
 682             raise ValueError(("during execution, the following error occurs:\n"+\
 683                              "\n%s %s\n\nSee also the potential messages, "+\
 684                              "which can show the origin of the above error, "+\
 685                              "in the launching terminal.\n")%(str(e),msg))
 686         return 0
 687
 688     def __executePythonScheme(self, FileName=None):
 689         "Lancement du calcul"
 690         self.__case.register("executePythonScheme", dir(), locals())
 691         if FileName is not None:
 692             self.dump( FileName, "TUI")
 693         self.__adaoObject["AlgorithmParameters"].executePythonScheme( self.__adaoObject )
 694         return 0
 695
 696     def __executeYACSScheme(self, FileName=None):
 697         "Lancement du calcul"
 698         self.__case.register("executeYACSScheme", dir(), locals())
 699         self.dump( FileName, "YACS")
 700         self.__adaoObject["AlgorithmParameters"].executeYACSScheme( FileName )
 701         return 0
 702
 703     # -----------------------------------------------------------
 704
 705     def dump(self, FileName=None, Formater="TUI"):
 706         "Restitution normalisée des commandes"
 707         __Upa = "\n".join(self.__PostAnalysis)
 708         return self.__case.dump(FileName, Formater, __Upa)
 709
 710     def load(self, FileName=None, Content=None, Object=None, Formater="TUI"):
 711         "Chargement normalisé des commandes"
 712         __commands = self.__case.load(FileName, Content, Object, Formater)
 713         from numpy import array, matrix
 714         for __command in __commands:
 715             if __command.find("set")>-1 and __command.find("set_")<0:
 716                 exec("self."+__command)
 717             else:
 718                 self.__PostAnalysis.append(__command)
 719         return self
 720
 721     def convert(self,
 722         FileNameFrom=None, ContentFrom=None, ObjectFrom=None, FormaterFrom="TUI",
 723         FileNameTo=None, FormaterTo="TUI",
 724         ):
 725         "Conversion normalisée des commandes"
 726         return self.load(
 727             FileName=FileNameFrom, Content=ContentFrom, Object=ObjectFrom, Formater=FormaterFrom
 728             ).dump(
 729             FileName=FileNameTo, Formater=FormaterTo
 730             )
 731
 732     def clear(self):
 733         "Effacement du contenu du cas en cours"
 734         self.__init__(self.__name)
 735
 736     # -----------------------------------------------------------
 737
 738     def __with_directory(self, __filename=None):
 739         if os.path.exists(str(__filename)):
 740             __fullpath = __filename
 741         elif os.path.exists(os.path.join(str(self.__directory), str(__filename))):
 742             __fullpath = os.path.join(self.__directory, str(__filename))
 743         else:
 744             __fullpath = __filename
 745         return __fullpath
 746
 747     def __dir__(self):
 748         "Clarifie la visibilité des méthodes"
 749         return ['set', 'get', 'execute', 'dump', 'load', '__doc__', '__init__', '__module__']
 750
 751     def prepare_to_pickle(self):
 752         "Retire les variables non pickelisables, avec recopie efficace"
 753         if self.__adaoObject['AlgorithmParameters'] is not None:
 754             for k in self.__adaoObject['AlgorithmParameters'].keys():
 755                 if k == "Algorithm": continue
 756                 if k in self.__StoredInputs:
 757                     raise ValueError("The key \"%s\" to be transfered for pickling will overwrite an existing one."%(k,))
 758                 if self.__adaoObject['AlgorithmParameters'].hasObserver( k ):
 759                     self.__adaoObject['AlgorithmParameters'].removeObserver( k, "", True )
 760                 self.__StoredInputs[k] = self.__adaoObject['AlgorithmParameters'].pop(k, None)
 761         if sys.version_info[0] == 2:
 762             del self.__adaoObject # Because it breaks pickle in Python 2. Not required for Python 3
 763             del self.__case       # Because it breaks pickle in Python 2. Not required for Python 3
 764         if sys.version_info.major < 3:
 765             return 0
 766         else:
 767             return self.__StoredInputs
 768
 769 # ==============================================================================
 770 if __name__ == "__main__":
 771     print('\n AUTODIAGNOSTIC\n')