src/daComposant/daCore/Aidsm.py

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