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