1 # -*- coding: utf-8 -*-
3 # Copyright (C) 2008-2024 EDF R&D
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.
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.
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
19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
24 Normalized interface for ADAO scripting (generic API).
26 __author__ = "Jean-Philippe ARGAUD"
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
40 from daCore import ExtendedLogging
41 ExtendedLogging.ExtendedLogging() # A importer en premier
42 import logging # noqa: E402
44 # ==============================================================================
46 """ ADAO Internal Data Structure Model """
48 "__name", "__objname", "__directory", "__case", "__parent",
49 "__adaoObject", "__StoredInputs", "__PostAnalysis", "__Concepts",
52 def __init__(self, name="", addViewers=None):
53 self.__name = str(name)
55 self.__directory = None
56 self.__case = CaseLogger(self.__name, "case", addViewers)
58 self.__adaoObject = {}
59 self.__StoredInputs = {}
60 self.__PostAnalysis = []
62 self.__Concepts = [ # Liste exhaustive
63 "AlgorithmParameters",
77 "ObservationOperator",
79 "RegulationParameters",
80 "SupplementaryParameters",
84 for ename in self.__Concepts:
85 self.__adaoObject[ename] = None
86 for ename in ("ObservationOperator", "EvolutionModel", "ControlModel"):
87 self.__adaoObject[ename] = {}
88 for ename in ("BackgroundError", "ObservationError"):
89 self.__adaoObject[ename] = Covariance(ename, asEyeByScalar = 1.)
90 for ename in ("EvolutionError",):
91 self.__adaoObject[ename] = Covariance(ename, asEyeByScalar = 1.e-16)
92 for ename in ("Observer", "UserPostAnalysis"):
93 self.__adaoObject[ename] = []
94 self.__StoredInputs[ename] = [] # Vide par defaut
95 self.__StoredInputs["Name"] = self.__name
96 self.__StoredInputs["Directory"] = self.__directory
98 # Récupère le chemin du répertoire parent et l'ajoute au path
99 # (Cela complète l'action de la classe PathManagement dans PlatformInfo,
100 # qui est activée dans Persistence)
101 self.__parent = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
102 sys.path.insert(0, self.__parent)
103 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
106 Concept = None, # Premier argument
114 DiagonalSparseMatrix = None,
115 ExtraArguments = None,
117 InputFunctionAsMulti = False,
119 ObjectFunction = None,
123 PerformanceProfile = None,
124 ScalarSparseMatrix = None,
131 ThreeFunctions = None,
136 "Interface unique de définition de variables d'entrées par argument"
137 self.__case.register("set", dir(), locals(), None, True)
139 if Concept in ("Background", "CheckingPoint", "ControlInput", "Observation"):
140 commande = getattr(self, "set" + Concept)
141 commande(Vector, VectorSerie, Script, DataFile, ColNames, ColMajor, Stored, Scheduler, Checked )
142 elif Concept in ("BackgroundError", "ObservationError", "EvolutionError"):
143 commande = getattr(self, "set" + Concept)
144 commande(Matrix, ScalarSparseMatrix, DiagonalSparseMatrix,
145 Script, Stored, ObjectMatrix, Checked )
146 elif Concept == "AlgorithmParameters":
147 self.setAlgorithmParameters( Algorithm, Parameters, Script )
148 elif Concept == "RegulationParameters":
149 self.setRegulationParameters( Algorithm, Parameters, Script )
150 elif Concept == "Name":
152 elif Concept == "Directory":
153 self.setDirectory(String)
154 elif Concept == "Debug":
156 elif Concept == "NoDebug":
158 elif Concept == "Observer":
160 Variable, Template, String, Script, Info,
161 ObjectFunction, CrossObs, SyncObs, Scheduler )
162 elif Concept == "UserPostAnalysis":
163 self.setUserPostAnalysis( Template, String, Script )
164 elif Concept == "SupplementaryParameters":
165 self.setSupplementaryParameters( Parameters, Script )
166 elif Concept == "ObservationOperator":
167 self.setObservationOperator(
168 Matrix, OneFunction, ThreeFunctions, AppliedInXb,
169 Parameters, Script, ExtraArguments,
170 Stored, PerformanceProfile, InputFunctionAsMulti, Checked )
171 elif Concept in ("EvolutionModel", "ControlModel"):
172 commande = getattr(self, "set" + Concept)
174 Matrix, OneFunction, ThreeFunctions,
175 Parameters, Script, Scheduler, ExtraArguments,
176 Stored, PerformanceProfile, InputFunctionAsMulti, Checked )
178 raise ValueError("the variable named '%s' is not allowed."%str(Concept))
179 except Exception as e:
180 if isinstance(e, SyntaxError):
181 msg = " at %s: %s"%(e.offset, e.text)
185 "during settings, the following error occurs:\n" + \
186 "\n%s%s\n\nSee also the potential messages, " + \
187 "which can show the origin of the above error, " + \
188 "in the launching terminal.")%(str(e), msg))
190 # -----------------------------------------------------------
203 "Définition d'un concept de calcul"
204 Concept = "Background"
205 self.__case.register("set" + Concept, dir(), locals())
206 self.__adaoObject[Concept] = State(
209 asPersistentVector = VectorSerie,
210 asScript = self.__with_directory(Script),
211 asDataFile = DataFile,
214 scheduledBy = Scheduler,
215 toBeChecked = Checked,
218 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
221 def setCheckingPoint(
232 "Définition d'un concept de calcul"
233 Concept = "CheckingPoint"
234 self.__case.register("set" + Concept, dir(), locals())
235 self.__adaoObject[Concept] = State(
238 asPersistentVector = VectorSerie,
239 asScript = self.__with_directory(Script),
240 asDataFile = DataFile,
243 scheduledBy = Scheduler,
244 toBeChecked = Checked,
247 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
261 "Définition d'un concept de calcul"
262 Concept = "ControlInput"
263 self.__case.register("set" + Concept, dir(), locals())
264 self.__adaoObject[Concept] = State(
267 asPersistentVector = VectorSerie,
268 asScript = self.__with_directory(Script),
269 asDataFile = DataFile,
272 scheduledBy = Scheduler,
273 toBeChecked = Checked,
276 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
290 "Définition d'un concept de calcul"
291 Concept = "Observation"
292 self.__case.register("set" + Concept, dir(), locals())
293 self.__adaoObject[Concept] = State(
296 asPersistentVector = VectorSerie,
297 asScript = self.__with_directory(Script),
298 asDataFile = DataFile,
301 scheduledBy = Scheduler,
302 toBeChecked = Checked,
305 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
308 def setBackgroundError(
311 ScalarSparseMatrix = None,
312 DiagonalSparseMatrix = None,
317 "Définition d'un concept de calcul"
318 Concept = "BackgroundError"
319 self.__case.register("set" + Concept, dir(), locals())
320 self.__adaoObject[Concept] = Covariance(
322 asCovariance = Matrix,
323 asEyeByScalar = ScalarSparseMatrix,
324 asEyeByVector = DiagonalSparseMatrix,
325 asCovObject = ObjectMatrix,
326 asScript = self.__with_directory(Script),
327 toBeChecked = Checked,
330 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
333 def setObservationError(
336 ScalarSparseMatrix = None,
337 DiagonalSparseMatrix = None,
342 "Définition d'un concept de calcul"
343 Concept = "ObservationError"
344 self.__case.register("set" + Concept, dir(), locals())
345 self.__adaoObject[Concept] = Covariance(
347 asCovariance = Matrix,
348 asEyeByScalar = ScalarSparseMatrix,
349 asEyeByVector = DiagonalSparseMatrix,
350 asCovObject = ObjectMatrix,
351 asScript = self.__with_directory(Script),
352 toBeChecked = Checked,
355 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
358 def setEvolutionError(
361 ScalarSparseMatrix = None,
362 DiagonalSparseMatrix = None,
367 "Définition d'un concept de calcul"
368 Concept = "EvolutionError"
369 self.__case.register("set" + Concept, dir(), locals())
370 self.__adaoObject[Concept] = Covariance(
372 asCovariance = Matrix,
373 asEyeByScalar = ScalarSparseMatrix,
374 asEyeByVector = DiagonalSparseMatrix,
375 asCovObject = ObjectMatrix,
376 asScript = self.__with_directory(Script),
377 toBeChecked = Checked,
380 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
383 def setObservationOperator(
387 ThreeFunctions = None,
391 ExtraArguments = None,
393 PerformanceProfile = None,
394 InputFunctionAsMulti = False,
396 "Définition d'un concept de calcul"
397 Concept = "ObservationOperator"
398 self.__case.register("set" + Concept, dir(), locals())
399 self.__adaoObject[Concept] = FullOperator(
402 asOneFunction = OneFunction,
403 asThreeFunctions = ThreeFunctions,
404 asScript = self.__with_directory(Script),
406 appliedInX = AppliedInXb,
407 extraArguments = ExtraArguments,
408 performancePrf = PerformanceProfile,
409 inputAsMF = InputFunctionAsMulti,
411 toBeChecked = Checked,
414 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
417 def setEvolutionModel(
421 ThreeFunctions = None,
425 ExtraArguments = None,
427 PerformanceProfile = None,
428 InputFunctionAsMulti = False,
430 "Définition d'un concept de calcul"
431 Concept = "EvolutionModel"
432 self.__case.register("set" + Concept, dir(), locals())
433 self.__adaoObject[Concept] = FullOperator(
436 asOneFunction = OneFunction,
437 asThreeFunctions = ThreeFunctions,
438 asScript = self.__with_directory(Script),
441 extraArguments = ExtraArguments,
442 performancePrf = PerformanceProfile,
443 inputAsMF = InputFunctionAsMulti,
444 scheduledBy = Scheduler,
445 toBeChecked = Checked,
448 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
455 ThreeFunctions = None,
459 ExtraArguments = None,
461 PerformanceProfile = None,
462 InputFunctionAsMulti = False,
464 "Définition d'un concept de calcul"
465 Concept = "ControlModel"
466 self.__case.register("set" + Concept, dir(), locals())
467 self.__adaoObject[Concept] = FullOperator(
470 asOneFunction = OneFunction,
471 asThreeFunctions = ThreeFunctions,
472 asScript = self.__with_directory(Script),
475 extraArguments = ExtraArguments,
476 performancePrf = PerformanceProfile,
477 inputAsMF = InputFunctionAsMulti,
478 scheduledBy = Scheduler,
479 toBeChecked = Checked,
482 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
485 def setName(self, String=None):
486 "Définition d'un concept de calcul"
487 self.__case.register("setName", dir(), locals())
488 if String is not None:
489 self.__name = str(String)
492 self.__StoredInputs["Name"] = self.__name
494 def setDirectory(self, String=None):
495 "Définition d'un concept de calcul"
496 self.__case.register("setDirectory", dir(), locals())
497 if os.path.isdir(os.path.abspath(str(String))):
498 self.__directory = os.path.abspath(str(String))
500 self.__directory = None
501 self.__StoredInputs["Directory"] = self.__directory
503 def setDebug(self, __level = 10):
504 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
505 self.__case.register("setDebug", dir(), locals())
506 log = logging.getLogger()
507 log.setLevel( __level )
508 logging.debug("Mode debug initialisé avec %s %s"%(version.name, version.version))
509 self.__StoredInputs["Debug"] = __level
510 self.__StoredInputs["NoDebug"] = False
513 def setNoDebug(self):
514 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
515 self.__case.register("setNoDebug", dir(), locals())
516 log = logging.getLogger()
517 log.setLevel( logging.WARNING )
518 self.__StoredInputs["Debug"] = logging.WARNING
519 self.__StoredInputs["NoDebug"] = True
522 def setAlgorithmParameters(
527 "Définition d'un concept de calcul"
528 Concept = "AlgorithmParameters"
529 self.__case.register("set" + Concept, dir(), locals())
530 self.__adaoObject[Concept] = AlgorithmAndParameters(
532 asAlgorithm = Algorithm,
534 asScript = self.__with_directory(Script),
538 def updateAlgorithmParameters(
542 "Mise à jour d'un concept de calcul"
543 Concept = "AlgorithmParameters"
544 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
545 raise ValueError("\n\nNo algorithm registred, set one before updating parameters or executing\n")
546 self.__adaoObject[Concept].updateParameters(
548 asScript = self.__with_directory(Script),
553 def setRegulationParameters(
558 "Définition d'un concept de calcul"
559 Concept = "RegulationParameters"
560 self.__case.register("set" + Concept, dir(), locals())
561 self.__adaoObject[Concept] = RegulationAndParameters(
563 asAlgorithm = Algorithm,
565 asScript = self.__with_directory(Script),
569 def setSupplementaryParameters(
573 "Définition d'un concept de calcul"
574 Concept = "SupplementaryParameters"
575 self.__case.register("set" + Concept, dir(), locals())
576 self.__adaoObject[Concept] = ExternalParameters(
579 asScript = self.__with_directory(Script),
583 def updateSupplementaryParameters(
587 "Mise à jour d'un concept de calcul"
588 Concept = "SupplementaryParameters"
589 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
590 self.__adaoObject[Concept] = ExternalParameters(name = Concept)
591 self.__adaoObject[Concept].updateParameters(
593 asScript = self.__with_directory(Script),
604 ObjectFunction = None,
608 "Définition d'un concept de calcul"
610 self.__case.register("set" + Concept, dir(), locals())
611 self.__adaoObject[Concept].append( DataObserver(
613 onVariable = Variable,
614 asTemplate = Template,
616 asScript = self.__with_directory(Script),
617 asObsObject = ObjectFunction,
621 scheduledBy = Scheduler,
622 withAlgo = self.__adaoObject["AlgorithmParameters"]
629 ObjectFunction = None ):
630 "Permet de retirer un observer à une ou des variable nommées"
631 if "AlgorithmParameters" not in self.__adaoObject:
632 raise ValueError("No algorithm registred, ask for one before removing observers")
634 # Vérification du nom de variable et typage
635 # -----------------------------------------
636 if isinstance(Variable, str):
637 VariableNames = (Variable,)
638 elif isinstance(Variable, list):
639 VariableNames = tuple(map( str, Variable ))
641 raise ValueError("The observer requires a name or a list of names of variables.")
643 # Association interne de l'observer à la variable
644 # -----------------------------------------------
645 for ename in VariableNames:
646 if ename not in self.__adaoObject["AlgorithmParameters"]:
647 raise ValueError("An observer requires to be removed on a variable named %s which does not exist."%ename)
649 return self.__adaoObject["AlgorithmParameters"].removeObserver( ename, ObjectFunction )
651 def setUserPostAnalysis(
656 "Définition d'un concept de calcul"
657 Concept = "UserPostAnalysis"
658 self.__case.register("set" + Concept, dir(), locals())
659 self.__adaoObject[Concept].append( repr(UserScript(
661 asTemplate = Template,
663 asScript = self.__with_directory(Script),
667 # -----------------------------------------------------------
669 def get(self, Concept=None, noDetails=True ):
670 "Récupération d'une sortie du calcul"
671 if Concept is not None:
673 self.__case.register("get", dir(), locals(), Concept) # Break pickle in Python 2
676 if Concept in self.__StoredInputs:
677 return self.__StoredInputs[Concept]
679 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept == "AlgorithmParameters":
680 return self.__adaoObject["AlgorithmParameters"].get()
682 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept in self.__adaoObject["AlgorithmParameters"]:
683 return self.__adaoObject["AlgorithmParameters"].get( Concept )
685 elif Concept == "AlgorithmRequiredParameters" and self.__adaoObject["AlgorithmParameters"] is not None:
686 return self.__adaoObject["AlgorithmParameters"].getAlgorithmRequiredParameters(noDetails)
688 elif Concept == "AlgorithmRequiredInputs" and self.__adaoObject["AlgorithmParameters"] is not None:
689 return self.__adaoObject["AlgorithmParameters"].getAlgorithmInputArguments()
691 elif Concept == "AlgorithmAttributes" and self.__adaoObject["AlgorithmParameters"] is not None:
692 return self.__adaoObject["AlgorithmParameters"].getAlgorithmAttributes()
694 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept == "SupplementaryParameters":
695 return self.__adaoObject["SupplementaryParameters"].get()
697 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept in self.__adaoObject["SupplementaryParameters"]:
698 return self.__adaoObject["SupplementaryParameters"].get( Concept )
701 raise ValueError("The requested key \"%s\" does not exists as an input or a stored variable."%Concept)
704 allvariables.update( {"AlgorithmParameters": self.__adaoObject["AlgorithmParameters"].get()} )
705 if self.__adaoObject["SupplementaryParameters"] is not None:
706 allvariables.update( {"SupplementaryParameters": self.__adaoObject["SupplementaryParameters"].get()} )
707 # allvariables.update( self.__adaoObject["AlgorithmParameters"].get() )
708 allvariables.update( self.__StoredInputs )
709 allvariables.pop('Observer', None)
710 allvariables.pop('UserPostAnalysis', None)
713 # -----------------------------------------------------------
715 def __get_available_variables(self):
717 Renvoie les variables potentiellement utilisables pour l'étude,
718 initialement stockées comme données d'entrées ou dans les algorithmes,
719 identifiés par les chaînes de caractères. L'algorithme doit avoir été
720 préalablement choisi sinon la méthode renvoie "None".
722 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) == 0 and \
723 len(list(self.__StoredInputs.keys())) == 0:
727 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) > 0:
728 variables.extend(list(self.__adaoObject["AlgorithmParameters"].keys()))
729 if self.__adaoObject["SupplementaryParameters"] is not None and \
730 len(list(self.__adaoObject["SupplementaryParameters"].keys())) > 0:
731 variables.extend(list(self.__adaoObject["SupplementaryParameters"].keys()))
732 if len(list(self.__StoredInputs.keys())) > 0:
733 variables.extend( list(self.__StoredInputs.keys()) )
734 variables.remove('Observer')
735 variables.remove('UserPostAnalysis')
739 def __get_available_algorithms(self):
741 Renvoie la liste des algorithmes potentiellement utilisables, identifiés
742 par les chaînes de caractères.
745 for directory in sys.path:
746 trypath = os.path.join(directory, "daAlgorithms")
747 if os.path.isdir(trypath):
748 for fname in os.listdir(trypath):
749 if os.path.isfile(os.path.join(trypath, fname)):
750 root, ext = os.path.splitext(fname)
753 with open(os.path.join(trypath, fname)) as fc:
754 iselal = bool("class ElementaryAlgorithm" in fc.read())
755 if iselal and ext == '.py' and root != '__init__':
760 def __get_algorithms_main_path(self):
762 Renvoie le chemin pour le répertoire principal contenant les algorithmes
766 def __add_algorithms_path(self, Path=None):
768 Ajoute au chemin de recherche des algorithmes un répertoire dans lequel
769 se trouve un sous-répertoire "daAlgorithms"
771 if not os.path.isdir(Path):
772 raise ValueError("The given " + Path + " argument must exist as a directory")
773 if not os.path.isdir(os.path.join(Path, "daAlgorithms")):
774 raise ValueError("The given \"" + Path + "\" argument must contain a subdirectory named \"daAlgorithms\"")
775 if not os.path.isfile(os.path.join(Path, "daAlgorithms", "__init__.py")):
776 raise ValueError("The given \"" + Path + "/daAlgorithms\" path must contain a file named \"__init__.py\"")
777 sys.path.insert(0, os.path.abspath(Path))
778 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
781 # -----------------------------------------------------------
783 def execute(self, Executor=None, SaveCaseInFile=None, nextStep=False):
784 "Lancement du calcul"
785 self.__case.register("execute", dir(), locals(), None, True)
786 self.updateAlgorithmParameters(Parameters={"nextStep": bool(nextStep)})
788 Operator.CM.clearCache()
790 if Executor == "YACS":
791 self.__executeYACSScheme( SaveCaseInFile )
793 self.__executePythonScheme( SaveCaseInFile )
794 except Exception as e:
795 if isinstance(e, SyntaxError):
796 msg = "at %s: %s"%(e.offset, e.text)
800 "during execution, the following error occurs:\n" + \
801 "\n%s %s\n\nSee also the potential messages, " + \
802 "which can show the origin of the above error, " + \
803 "in the launching terminal.\n")%(str(e), msg))
806 def __executePythonScheme(self, FileName=None):
807 "Lancement du calcul"
808 self.__case.register("executePythonScheme", dir(), locals())
809 if FileName is not None:
810 self.dump( FileName, "TUI")
811 self.__adaoObject["AlgorithmParameters"].executePythonScheme( self.__adaoObject )
812 if "UserPostAnalysis" in self.__adaoObject and len(self.__adaoObject["UserPostAnalysis"]) > 0:
813 self.__objname = self.__retrieve_objname()
814 for __UpaOne in self.__adaoObject["UserPostAnalysis"]:
815 __UpaOne = eval(str(__UpaOne))
816 exec(__UpaOne, {}, {'self': self, 'ADD': self, 'case': self, 'adaopy': self, self.__objname: self})
819 def __executeYACSScheme(self, FileName=None):
820 "Lancement du calcul"
821 self.__case.register("executeYACSScheme", dir(), locals())
822 self.dump( FileName, "YACS")
823 self.__adaoObject["AlgorithmParameters"].executeYACSScheme( FileName )
826 # -----------------------------------------------------------
828 def dump(self, FileName=None, Formater="TUI"):
829 "Restitution normalisée des commandes"
830 __Upa = "\n".join(self.__PostAnalysis)
831 return self.__case.dump(FileName, Formater, __Upa)
833 def load(self, FileName=None, Content=None, Object=None, Formater="TUI"):
834 "Chargement normalisé des commandes"
835 __commands = self.__case.load(FileName, Content, Object, Formater)
836 from numpy import array, matrix # noqa: F401
837 for __command in __commands:
838 if (__command.find("set") > -1 and __command.find("set_") < 0) or 'UserPostAnalysis' in __command:
839 exec("self." + __command, {}, locals())
841 self.__PostAnalysis.append(__command)
845 FileNameFrom=None, ContentFrom=None, ObjectFrom=None, FormaterFrom="TUI",
846 FileNameTo=None, FormaterTo="TUI" ):
847 "Conversion normalisée des commandes"
849 FileName=FileNameFrom, Content=ContentFrom, Object=ObjectFrom, Formater=FormaterFrom
851 FileName=FileNameTo, Formater=FormaterTo
855 "Effacement du contenu du cas en cours"
856 self.__init__(self.__name)
858 # -----------------------------------------------------------
860 def __with_directory(self, __filename=None):
861 if os.path.exists(str(__filename)):
862 __fullpath = __filename
863 elif os.path.exists(os.path.join(str(self.__directory), str(__filename))):
864 __fullpath = os.path.join(self.__directory, str(__filename))
866 __fullpath = __filename
869 def __retrieve_objname(self):
870 "Ne pas utiliser dans le __init__, la variable appelante n'existe pas encore"
872 for level in reversed(inspect.stack()):
873 __names += [name for name, value in level.frame.f_locals.items() if value is self]
874 __names += [name for name, value in globals().items() if value is self]
875 while 'self' in __names:
876 __names.remove('self') # Devrait toujours être trouvé, donc pas d'erreur
878 self.__objname = __names[0]
880 self.__objname = "ADD"
881 return self.__objname
884 "Clarifie la visibilité des méthodes"
885 return ['set', 'get', 'execute', 'dump', 'load', '__doc__', '__init__', '__module__']
888 "Représentation pour impression (mais pas repr)"
889 msg = self.dump(None, "SimpleReportInPlainTxt")
892 def sysinfo(self, title=""):
893 msg = PlatformInfo.PlatformInfo().getAllInformation(" ", title)
896 def callinfo(self, __prefix=" "):
898 for oname in ["ObservationOperator", "EvolutionModel"]:
899 if hasattr(self.__adaoObject[oname], "nbcalls"):
900 ostats = self.__adaoObject[oname].nbcalls()
901 msg += "\n%sNumber of calls for the %s:"%(__prefix, oname)
902 for otype in ["Direct", "Tangent", "Adjoint"]:
904 msg += "\n%s%30s : %s"%(__prefix, "%s evaluation"%(otype,), ostats[otype][0])
908 def prepare_to_pickle(self):
909 "Retire les variables non pickelisables, avec recopie efficace"
910 if self.__adaoObject['AlgorithmParameters'] is not None:
911 for k in self.__adaoObject['AlgorithmParameters'].keys():
914 if k in self.__StoredInputs:
915 raise ValueError("The key \"%s\" to be transfered for pickling will overwrite an existing one."%(k,))
916 if self.__adaoObject['AlgorithmParameters'].hasObserver( k ):
917 self.__adaoObject['AlgorithmParameters'].removeObserver( k, "", True )
918 self.__StoredInputs[k] = self.__adaoObject['AlgorithmParameters'].pop(k, None)
919 if sys.version_info[0] == 2:
920 del self.__adaoObject # Because it breaks pickle in Python 2. Not required for Python 3
921 del self.__case # Because it breaks pickle in Python 2. Not required for Python 3
922 if sys.version_info.major < 3:
925 return self.__StoredInputs
927 # ==============================================================================
928 if __name__ == "__main__":
929 print("\n AUTODIAGNOSTIC\n")