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             InputAsMF      = False,
 354             Checked        = False):
 355         "Definition d'un concept de calcul"
 356         Concept = "ObservationOperator"
 357         self.__case.register("set"+Concept, dir(), locals())
 358         self.__adaoObject[Concept] = FullOperator(
 359             name             = Concept,
 360             asMatrix         = Matrix,
 361             asOneFunction    = OneFunction,
 362             asThreeFunctions = ThreeFunctions,
 363             asScript         = self.__with_directory(Script),
 364             asDict           = Parameters,
 365             appliedInX       = AppliedInXb,
 366             avoidRC          = AvoidRC,
 367             inputAsMF        = InputAsMF,
 368             scheduledBy      = None,
 369             toBeChecked      = Checked,
 370             )
 371         if Stored:
 372             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 373         return 0
 374
 375     def setEvolutionModel(self,
 376             Matrix         = None,
 377             OneFunction    = None,
 378             ThreeFunctions = None,
 379             Parameters     = None,
 380             Script         = None,
 381             Scheduler      = None,
 382             Stored         = False,
 383             AvoidRC        = True,
 384             InputAsMF      = False,
 385             Checked        = False):
 386         "Definition d'un concept de calcul"
 387         Concept = "EvolutionModel"
 388         self.__case.register("set"+Concept, dir(), locals())
 389         self.__adaoObject[Concept] = FullOperator(
 390             name             = Concept,
 391             asMatrix         = Matrix,
 392             asOneFunction    = OneFunction,
 393             asThreeFunctions = ThreeFunctions,
 394             asScript         = self.__with_directory(Script),
 395             asDict           = Parameters,
 396             appliedInX       = None,
 397             avoidRC          = AvoidRC,
 398             inputAsMF        = InputAsMF,
 399             scheduledBy      = Scheduler,
 400             toBeChecked      = Checked,
 401             )
 402         if Stored:
 403             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 404         return 0
 405
 406     def setControlModel(self,
 407             Matrix         = None,
 408             OneFunction    = None,
 409             ThreeFunctions = None,
 410             Parameters     = None,
 411             Script         = None,
 412             Scheduler      = None,
 413             Stored         = False,
 414             AvoidRC        = True,
 415             InputAsMF      = False,
 416             Checked        = False):
 417         "Definition d'un concept de calcul"
 418         Concept = "ControlModel"
 419         self.__case.register("set"+Concept, dir(), locals())
 420         self.__adaoObject[Concept] = FullOperator(
 421             name             = Concept,
 422             asMatrix         = Matrix,
 423             asOneFunction    = OneFunction,
 424             asThreeFunctions = ThreeFunctions,
 425             asScript         = self.__with_directory(Script),
 426             asDict           = Parameters,
 427             appliedInX       = None,
 428             avoidRC          = AvoidRC,
 429             inputAsMF        = InputAsMF,
 430             scheduledBy      = Scheduler,
 431             toBeChecked      = Checked,
 432             )
 433         if Stored:
 434             self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
 435         return 0
 436
 437     def setName(self, String=None):
 438         "Definition d'un concept de calcul"
 439         self.__case.register("setName",dir(),locals())
 440         if String is not None:
 441             self.__name = str(String)
 442         else:
 443             self.__name = None
 444         self.__StoredInputs["Name"] = self.__name
 445
 446     def setDirectory(self, String=None):
 447         "Definition d'un concept de calcul"
 448         self.__case.register("setDirectory",dir(),locals())
 449         if os.path.isdir(os.path.abspath(str(String))):
 450             self.__directory = os.path.abspath(str(String))
 451         else:
 452             self.__directory = None
 453         self.__StoredInputs["Directory"] = self.__directory
 454
 455     def setDebug(self, __level = 10):
 456         "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
 457         self.__case.register("setDebug",dir(),locals())
 458         log = logging.getLogger()
 459         log.setLevel( __level )
 460         self.__StoredInputs["Debug"]   = __level
 461         self.__StoredInputs["NoDebug"] = False
 462         return 0
 463
 464     def setNoDebug(self):
 465         "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
 466         self.__case.register("setNoDebug",dir(),locals())
 467         log = logging.getLogger()
 468         log.setLevel( logging.WARNING )
 469         self.__StoredInputs["Debug"]   = logging.WARNING
 470         self.__StoredInputs["NoDebug"] = True
 471         return 0
 472
 473     def setAlgorithmParameters(self,
 474             Algorithm  = None,
 475             Parameters = None,
 476             Script     = None):
 477         "Definition d'un concept de calcul"
 478         Concept = "AlgorithmParameters"
 479         self.__case.register("set"+Concept, dir(), locals())
 480         self.__adaoObject[Concept] = AlgorithmAndParameters(
 481             name          = Concept,
 482             asAlgorithm   = Algorithm,
 483             asDict        = Parameters,
 484             asScript      = self.__with_directory(Script),
 485             )
 486         return 0
 487
 488     def updateAlgorithmParameters(self,
 489             Parameters = None,
 490             Script     = None):
 491         "Mise a jour d'un concept de calcul"
 492         if "AlgorithmParameters" not in self.__adaoObject:
 493             raise ValueError("No algorithm registred, ask for one before updating parameters")
 494         self.__adaoObject["AlgorithmParameters"].updateParameters(
 495             asDict        = Parameters,
 496             asScript      = self.__with_directory(Script),
 497             )
 498         return 0
 499
 500     def setRegulationParameters(self,
 501             Algorithm  = None,
 502             Parameters = None,
 503             Script     = None):
 504         "Definition d'un concept de calcul"
 505         Concept = "RegulationParameters"
 506         self.__case.register("set"+Concept, dir(), locals())
 507         self.__adaoObject[Concept] = RegulationAndParameters(
 508             name          = Concept,
 509             asAlgorithm   = Algorithm,
 510             asDict        = Parameters,
 511             asScript      = self.__with_directory(Script),
 512             )
 513         return 0
 514
 515     def setObserver(self,
 516             Variable       = None,
 517             Template       = None,
 518             String         = None,
 519             Script         = None,
 520             Info           = None,
 521             ObjectFunction = None,
 522             Scheduler      = None):
 523         "Definition d'un concept de calcul"
 524         Concept = "Observer"
 525         self.__case.register("set"+Concept, dir(), locals())
 526         self.__adaoObject[Concept].append( DataObserver(
 527             name        = Concept,
 528             onVariable  = Variable,
 529             asTemplate  = Template,
 530             asString    = String,
 531             asScript    = self.__with_directory(Script),
 532             asObsObject = ObjectFunction,
 533             withInfo    = Info,
 534             scheduledBy = Scheduler,
 535             withAlgo    = self.__adaoObject["AlgorithmParameters"]
 536             ))
 537         return 0
 538
 539     def removeObserver(self,
 540             Variable       = None,
 541             ObjectFunction = None,
 542             ):
 543         "Permet de retirer un observer à une ou des variable nommée"
 544         if "AlgorithmParameters" not in self.__adaoObject:
 545             raise ValueError("No algorithm registred, ask for one before removing observers")
 546         #
 547         # Vérification du nom de variable et typage
 548         # -----------------------------------------
 549         if isinstance(Variable, str):
 550             VariableNames = (Variable,)
 551         elif isinstance(Variable, list):
 552             VariableNames = tuple(map( str, Variable ))
 553         else:
 554             raise ValueError("The observer requires a name or a list of names of variables.")
 555         #
 556         # Association interne de l'observer à la variable
 557         # -----------------------------------------------
 558         for ename in VariableNames:
 559             if ename not in self.__adaoObject["AlgorithmParameters"]:
 560                 raise ValueError("An observer requires to be removed on a variable named %s which does not exist."%ename)
 561             else:
 562                 return self.__adaoObject["AlgorithmParameters"].removeObserver( ename, ObjectFunction )
 563
 564     # -----------------------------------------------------------
 565
 566     def get(self, Concept=None, noDetails=True ):
 567         "Recuperation d'une sortie du calcul"
 568         if Concept is not None:
 569             try:
 570                 self.__case.register("get", dir(), locals(), Concept) # Break pickle in Python 2
 571             except Exception:
 572                 pass
 573             if Concept in self.__StoredInputs:
 574                 return self.__StoredInputs[Concept]
 575                 #
 576             elif self.__adaoObject["AlgorithmParameters"] is not None and Concept == "AlgorithmParameters":
 577                 return self.__adaoObject["AlgorithmParameters"].get()
 578                 #
 579             elif self.__adaoObject["AlgorithmParameters"] is not None and Concept in self.__adaoObject["AlgorithmParameters"]:
 580                 return self.__adaoObject["AlgorithmParameters"].get( Concept )
 581                 #
 582             elif Concept == "AlgorithmRequiredParameters" and self.__adaoObject["AlgorithmParameters"] is not None:
 583                 return self.__adaoObject["AlgorithmParameters"].getAlgorithmRequiredParameters(noDetails)
 584                 #
 585             else:
 586                 raise ValueError("The requested key \"%s\" does not exists as an input or a stored variable."%Concept)
 587         else:
 588             allvariables = {}
 589             allvariables.update( {"AlgorithmParameters":self.__adaoObject["AlgorithmParameters"].get()} )
 590             # allvariables.update( self.__adaoObject["AlgorithmParameters"].get() )
 591             allvariables.update( self.__StoredInputs )
 592             allvariables.pop('Observer', None)
 593             return allvariables
 594
 595     # -----------------------------------------------------------
 596
 597     def get_available_variables(self):
 598         """
 599         Renvoie les variables potentiellement utilisables pour l'étude,
 600         initialement stockées comme données d'entrées ou dans les algorithmes,
 601         identifiés par les chaînes de caractères. L'algorithme doit avoir été
 602         préalablement choisi sinon la méthode renvoie "None".
 603         """
 604         if len(list(self.__adaoObject["AlgorithmParameters"].keys())) == 0 and \
 605             len(list(self.__StoredInputs.keys())) == 0:
 606             return None
 607         else:
 608             variables = []
 609             if len(list(self.__adaoObject["AlgorithmParameters"].keys())) > 0:
 610                 variables.extend(list(self.__adaoObject["AlgorithmParameters"].keys()))
 611             if len(list(self.__StoredInputs.keys())) > 0:
 612                 variables.extend( list(self.__StoredInputs.keys()) )
 613             variables.remove('Observer')
 614             variables.sort()
 615             return variables
 616
 617     def get_available_algorithms(self):
 618         """
 619         Renvoie la liste des algorithmes potentiellement utilisables, identifiés
 620         par les chaînes de caractères.
 621         """
 622         files = []
 623         for directory in sys.path:
 624             trypath = os.path.join(directory,"daAlgorithms")
 625             if os.path.isdir(trypath):
 626                 for fname in os.listdir(trypath):
 627                     if os.path.isfile(os.path.join(trypath,fname)):
 628                         fc = open(os.path.join(trypath,fname)).read()
 629                         iselal = bool("class ElementaryAlgorithm" in fc)
 630                         root, ext = os.path.splitext(fname)
 631                         if iselal and ext == '.py' and root != '__init__':
 632                             files.append(root)
 633         files.sort()
 634         return files
 635
 636     def get_algorithms_main_path(self):
 637         """
 638         Renvoie le chemin pour le répertoire principal contenant les algorithmes
 639         """
 640         return self.__parent
 641
 642     def add_algorithms_path(self, Path=None):
 643         """
 644         Ajoute au chemin de recherche des algorithmes un répertoire dans lequel
 645         se trouve un sous-répertoire "daAlgorithms"
 646         """
 647         if not os.path.isdir(Path):
 648             raise ValueError("The given "+Path+" argument must exist as a directory")
 649         if not os.path.isdir(os.path.join(Path,"daAlgorithms")):
 650             raise ValueError("The given \""+Path+"\" argument must contain a subdirectory named \"daAlgorithms\"")
 651         if not os.path.isfile(os.path.join(Path,"daAlgorithms","__init__.py")):
 652             raise ValueError("The given \""+Path+"/daAlgorithms\" path must contain a file named \"__init__.py\"")
 653         sys.path.insert(0, os.path.abspath(Path))
 654         sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
 655         return 0
 656
 657     # -----------------------------------------------------------
 658
 659     def execute(self, Executor=None, SaveCaseInFile=None):
 660         "Lancement du calcul"
 661         self.__case.register("execute",dir(),locals(),None,True)
 662         Operator.CM.clearCache()
 663         try:
 664             if   Executor == "YACS": self.__executeYACSScheme( SaveCaseInFile )
 665             else:                    self.__executePythonScheme( SaveCaseInFile )
 666         except Exception as e:
 667             if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
 668             else: msg = ""
 669             raise ValueError(("during execution, the following error occurs:\n"+\
 670                              "\n%s %s\n\nSee also the potential messages, "+\
 671                              "which can show the origin of the above error, "+\
 672                              "in the launching terminal.\n")%(str(e),msg))
 673         return 0
 674
 675     def __executePythonScheme(self, FileName=None):
 676         "Lancement du calcul"
 677         self.__case.register("executePythonScheme", dir(), locals())
 678         if FileName is not None:
 679             self.dump( FileName, "TUI")
 680         self.__adaoObject["AlgorithmParameters"].executePythonScheme( self.__adaoObject )
 681         return 0
 682
 683     def __executeYACSScheme(self, FileName=None):
 684         "Lancement du calcul"
 685         self.__case.register("executeYACSScheme", dir(), locals())
 686         self.dump( FileName, "YACS")
 687         self.__adaoObject["AlgorithmParameters"].executeYACSScheme( FileName )
 688         return 0
 689
 690     # -----------------------------------------------------------
 691
 692     def dump(self, FileName=None, Formater="TUI"):
 693         "Restitution normalisée des commandes"
 694         __Upa = "\n".join(self.__PostAnalysis)
 695         return self.__case.dump(FileName, Formater, __Upa)
 696
 697     def load(self, FileName=None, Content=None, Object=None, Formater="TUI"):
 698         "Chargement normalisé des commandes"
 699         __commands = self.__case.load(FileName, Content, Object, Formater)
 700         from numpy import array, matrix
 701         for __command in __commands:
 702             if __command.find("set")>-1 and __command.find("set_")<0:
 703                 exec("self."+__command)
 704             else:
 705                 self.__PostAnalysis.append(__command)
 706         return self
 707
 708     def convert(self,
 709         FileNameFrom=None, ContentFrom=None, ObjectFrom=None, FormaterFrom="TUI",
 710         FileNameTo=None, FormaterTo="TUI",
 711         ):
 712         "Conversion normalisée des commandes"
 713         return self.load(
 714             FileName=FileNameFrom, Content=ContentFrom, Object=ObjectFrom, Formater=FormaterFrom
 715             ).dump(
 716             FileName=FileNameTo, Formater=FormaterTo
 717             )
 718
 719     def clear(self):
 720         "Effacement du contenu du cas en cours"
 721         self.__init__(self.__name)
 722
 723     # -----------------------------------------------------------
 724
 725     def __with_directory(self, __filename=None):
 726         if os.path.exists(str(__filename)):
 727             __fullpath = __filename
 728         elif os.path.exists(os.path.join(str(self.__directory), str(__filename))):
 729             __fullpath = os.path.join(self.__directory, str(__filename))
 730         else:
 731             __fullpath = __filename
 732         return __fullpath
 733
 734     def __dir__(self):
 735         "Clarifie la visibilité des méthodes"
 736         return ['set', 'get', 'execute', 'dump', 'load', '__doc__', '__init__', '__module__']
 737
 738     def prepare_to_pickle(self):
 739         "Retire les variables non pickelisables, avec recopie efficace"
 740         if self.__adaoObject['AlgorithmParameters'] is not None:
 741             for k in self.__adaoObject['AlgorithmParameters'].keys():
 742                 if k == "Algorithm": continue
 743                 if k in self.__StoredInputs:
 744                     raise ValueError("the key \"%s\s to be transfered for pickling will overwrite an existing one.")
 745                 if self.__adaoObject['AlgorithmParameters'].hasObserver( k ):
 746                     self.__adaoObject['AlgorithmParameters'].removeObserver( k, "", True )
 747                 self.__StoredInputs[k] = self.__adaoObject['AlgorithmParameters'].pop(k, None)
 748         if sys.version_info[0] == 2:
 749             del self.__adaoObject # Because it breaks pickle in Python 2. Not required for Python 3
 750             del self.__case       # Because it breaks pickle in Python 2. Not required for Python 3
 751         if sys.version_info.major < 3:
 752             return 0
 753         else:
 754             return self.__StoredInputs
 755
 756 # ==============================================================================
 757 if __name__ == "__main__":
 758     print('\n AUTODIAGNOSTIC \n')