src/daComposant/daCore/Aidsm.py

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