src/daComposant/daCore/Aidsm.py

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