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