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