src/daComposant/daCore/Aidsm.py

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