--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient le plugin convertisseur de fichier
+ au format python pour EFICAS.
+
+ Un plugin convertisseur doit fournir deux attributs de classe :
+ extensions et formats et deux méthodes : readfile,convert.
+
+ L'attribut de classe extensions est une liste d'extensions
+ de fichiers préconisées pour ce type de format. Cette information
+ est seulement indicative.
+
+ L'attribut de classe formats est une liste de formats de sortie
+ supportés par le convertisseur. Les formats possibles sont :
+ eval, dict ou exec.
+ Le format eval est un texte source Python qui peut etre evalué. Le
+ résultat de l'évaluation est un objet Python quelconque.
+ Le format dict est un dictionnaire Python.
+ Le format exec est un texte source Python qui peut etre executé.
+
+ La méthode readfile a pour fonction de lire un fichier dont le
+ nom est passé en argument de la fonction.
+ - convertisseur.readfile(nom_fichier)
+
+ La méthode convert a pour fonction de convertir le fichier
+ préalablement lu dans un objet du format passé en argument.
+ - objet=convertisseur.convert(outformat)
+
+ Ce convertisseur supporte le format de sortie exec
+
+"""
+import sys,string,traceback
+
+import parseur_python
+from Noyau import N_CR
+
+def entryPoint():
+ """
+ Retourne les informations nécessaires pour le chargeur de plugins
+ Ces informations sont retournées dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'openturns_study',
+ # La factory pour créer une instance du plugin
+ 'factory' : PythonParser,
+ }
+
+
+class PythonParser:
+ """
+ Ce convertisseur lit un fichier au format python avec la
+ methode readfile : convertisseur.readfile(nom_fichier)
+ et retourne le texte au format outformat avec la
+ methode convertisseur.convert(outformat)
+
+ Ses caractéristiques principales sont exposées dans 2 attributs
+ de classe :
+ - extensions : qui donne une liste d'extensions de fichier préconisées
+ - formats : qui donne une liste de formats de sortie supportés
+ """
+ # Les extensions de fichier préconisées
+ extensions=('.py',)
+ # Les formats de sortie supportés (eval dict ou exec)
+ # Le format exec est du python executable (commande exec) converti avec PARSEUR_PYTHON
+ # Le format execnoparseur est du python executable (commande exec) non converti
+ formats=('exec','execnoparseur')
+
+ def __init__(self,cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le
+ # compte-rendu standard
+ self.text=''
+ if cr :
+ self.cr=cr
+ else:
+ self.cr=N_CR.CR(debut='CR convertisseur format python',
+ fin='fin CR format python')
+
+ def readfile(self,filename):
+ self.filename=filename
+ try:
+ self.text=open(filename).read()
+ except:
+ self.cr.fatal("Impossible ouvrir fichier %s" % filename)
+ return
+
+ def convert(self,outformat,appli=None):
+ if outformat == 'exec':
+ try:
+ #txt=parseur_python.PARSEUR_PYTHON(self.text).get_texte(appli)
+ #print txt
+ #return txt
+ return parseur_python.PARSEUR_PYTHON(self.text).get_texte(appli)
+ except:
+ # Erreur lors de la conversion
+ l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],
+ sys.exc_info()[2])
+ self.cr.exception("Impossible de convertir le fichier python \
+ qui doit contenir des erreurs.\n \
+ On retourne le fichier non converti \n \
+ Prévenir la maintenance. \n" + string.join(l))
+ # On retourne néanmoins le source initial non converti (au cas où)
+ return self.text
+ elif outformat == 'execnoparseur':
+ return self.text
+ else:
+ raise "Format de sortie : %s, non supporté"
+ return None
+
class STDGenerateur :
'''
- Generation du fichier pyhton
+ Generation du fichier python
'''
def __init__ (self, DictMCVal, ListeVariables, DictLois ) :
- #---------------------------------------------------------#
-
- self.NomAlgo = "myAlgo"
self.DictMCVal = DictMCVal
self.ListeVariables = ListeVariables
self.DictLois = DictLois
-
- self.ListeOrdreMCReliability = (
- "MaximumIterationsNumber",
- "MaximumAbsoluteError",
- "RelativeAbsoluteError",
- "MaximumConstraintError",
- "MaximumResidualError",
- )
- self.ListeOrdreMCDirectionalSampling = (
- "RootStrategy",
- "SamplingStrategy",
- )
- self.ListeOrdreMCParametresAlgo = (
- "BlockSize",
- "MaximumCoefficientOfVariation",
- )
- self.ListeOrdreImportanceSampling = (
- "ImportanceSampling_BlockSize",
- "ImportanceSampling_MaximumCoefficientOfVariation",
- "ImportanceSampling_MaximumOuterSampling",
- )
-
- # Ce dictionnaire contient la liste de tous les parametres possibles pour chaque loi
- # Les parametres qui n'apparaissent pas ne pourront pas etre substitues dans le fichier
- # produit (etude python), et donc n'apparaitront pas.
- self.listeParamLoi = {
- "Beta" : ["Mu", "Sigma", "T", "R", "A", "B" ],
- "Exponential" : ["Lambda", "Gamma" ],
- "Gamma" : ["K", "Mu", "Sigma", "Lambda", "Gamma" ],
- #"Geometric" : ["P", ],
- "Gumbel" : ["Alpha","Beta","Mu","Sigma" ],
- #"Histogram" : ["Sup", "Values" ],
- "LogNormal" : ["MuLog", "SigmaLog", "Mu", "Sigma", "SigmaOverMu", "Gamma", ],
- "Logistic" : [ "Alpha", "Beta" ],
- #"MultiNomial" : [ "N", "Values" ],
- "Normal" : ["Mu", "Sigma" ],
- "Poisson" : [ "Lambda", ],
- "Student" : [ "Mu", "Nu" ],
- "Triangular" : [ "A", "M", "B" ],
- "TruncatedNormal" : [ "MuN", "SigmaN", "A", "B" ],
- "Uniform" : [ "A", "B" ],
- #"UserDefined" : [ "Values", ],
- "Weibull" : [ "Alpha", "Beta", "Mu", "Sigma", "Gamma" ],
- }
-
- # Ce dictionnaire contient, pour chaque loi qui possede plusieurs parametrages possibles,
- # la correspondance entre le parametrage et son "numero" pour Open TURNS.
- self.listeParamLoiSettings = {
- "Beta" : { "RT" : "0", "MuSigma" : "1" }, \
- "Gamma" : { "KLambda" : "0", "MuSigma" : "1" }, \
- "Gumbel" : { "AlphaBeta" : "0", "MuSigma" : "1" }, \
- "LogNormal" : { "MuSigmaLog" : "0", "MuSigma" : "1", "MuSigmaOverMu" : "2" }, \
- "Weibull" : { "AlphaBeta" : "0", "MuSigma" : "1" }, \
- }
-
-
+ print "DictMCVal=", DictMCVal
+ print "ListeVariables=", ListeVariables
+ print "DictLois=", DictLois
def CreeSTD (self) :
'''
Pilotage de la creation du fichier python
'''
- self.texte = self.Entete()
- #self.texte += self.CreeRandomGenerator()
- #self.texte += self.CreeFunction()
- #self.texte += self.CreeLois()
- #self.texte += self.CreeCopula()
- #self.texte += self.CreeDistribution()
- #self.texte += self.CreeRandomVector()
- #self.texte += self.CreeAnalyse()
- #self.texte += self.CreeResu()
- #self.texte += self.CreeTexteFin()
- self.texte += self.PiedDePage()
- return self.texte
-
-# ______________________________________
-
- def Entete (self) :
- '''
- Entete pour charger les bibliotheques Python
- '''
- texte = """\
-#!/usr/bin/env python
-## -*- Python -*-
-
-## Library loading
-import sys
-import os
-from openturns import *
-
-"""
- return texte
-
- def PiedDePage (self) :
- '''
- Ferme le fichier proprement
- '''
- return 'print "OK"\n'
-
-# ______________________________________
-
- def CreeRandomGenerator (self) :
- #-------------------------------
- '''
- Positionnement du generateur aleatoire pour rejouer des etudes avec les memes valeurs
- '''
- texte = "\n"
- texte += "# RandomGenerator"
- texte += "\n"
- if self.DictMCVal.has_key("RandomGeneratorSeed") :
- texte += "# We set the RandomGenerator seed in order to replay the study\n"
- texte += "RandomGenerator().SetSeed(%d)\n" % self.DictMCVal["RandomGeneratorSeed"]
- return texte
-
-# _____________________________________
-
- def CreeFunction (self) :
- #------------------------
- '''
- La fonction :
- Remarque : la chaine 'XXXXXX' est remplacee par le nom du solver au moment de l enregistrement
- '''
- texte = "\n"
- texte += "# La fonction\n"
- texte += "\n"
- texte += "myFunction = NumericalMathFunction('XXXXXX')\n"
- texte += "dim = myFunction.getInputNumericalPointDimension()\n"
- return texte
-
-# ______________________________________
-
- def CreeLois (self) :
- #------------------
- '''
- La definition des distributions marginales pour la propagation des incertitudes
- '''
- code_erreur = 0
- texte = "\n"
- texte += "# Les lois\n"
- texte += "\n"
- if self.DictMCVal.has_key("Analysis") and self.DictMCVal["Analysis"] == "Reliability" :
- texte += "myPhysicalStartingPoint = NumericalPoint(dim, 0.0)\n"
- texte += "myCollection = DistributionCollection(dim)\n\n"
-
- numVar = 0
- for DictVariable in self.ListeVariables :
-
- boolLoiDef = True
- if DictVariable.has_key("MarginalDistribution") and DictVariable.has_key("Name"):
- ConceptLoi = DictVariable["MarginalDistribution"]
- NomLoi = DictVariable["Name"]+"_Dist"
- else :
- boolLoiDef = False
-
- if boolLoiDef and self.DictLois.has_key(ConceptLoi):
- loi = self.DictLois[ConceptLoi]
- else :
- boolLoiDef = False
-
- if boolLoiDef and loi.has_key("Kind") :
- TypeLoi = loi["Kind"]
- else :
- boolLoiDef = False
-
- if not boolLoiDef or TypeLoi not in self.listeParamLoi.keys() :
- texte += " Loi " + TypeLoi +" non programmee \n"
- numVar += 1
- continue
-
- ListeParametres = []
- TexteParametres = ""
- for Param in self.listeParamLoi[TypeLoi]:
- if loi.has_key(Param) :
- texte += " " + NomLoi + "_" + Param + " = " + str(loi[Param]) + "\n"
- ListeParametres.append(NomLoi + "_" + Param)
- TexteParametres += NomLoi + "_" + Param + ","
-
- texte += " " + NomLoi + " = " + TypeLoi + "( "
-
- if loi.has_key("Settings" ) and self.listeParamLoiSettings.has_key(TypeLoi) \
- and self.listeParamLoiSettings[TypeLoi].has_key(loi["Settings"]):
- NumParam = self.listeParamLoiSettings[TypeLoi][loi["Settings"]]
- texte += TexteParametres + NumParam +" )\n"
- else :
- texte += TexteParametres[:-1] + " )\n"
-
- texte += " " + NomLoi + '.setName( "'+DictVariable["Name"] +'" )\n'
- texte += " myCollection["+str(numVar)+"] = Distribution( "+NomLoi+" )\n"
-
- if self.DictMCVal["Analysis"] == "Reliability" :
- texte += " myPhysicalStartingPoint["+str(numVar)+"] = "
- if DictVariable.has_key("PhysicalStartingPoint") :
- texte += str(DictVariable["PhysicalStartingPoint"]) +"\n\n"
- else :
- texte += NomLoi+".computeQuantile( 0.5 )[0]\n\n"
-
- numVar += 1
- return texte
-
-# ______________________________________
-
- def CreeCopula (self) :
- #------------------
- # Appelee par CreeSTD
- texte = "\n# La copule\n\n"
- texte += " myCopula = IndependentCopula(dim)\n"
- return texte
-# ______________________________________
-
- def CreeDistribution (self) :
- #----------------------------
- # Appelee par CreeSTD
- texte = "\n# La distribution\n\n"
- texte += " myDistribution = ComposedDistribution(myCollection, Copula(myCopula))\n"
- return texte
-
-# ______________________________________
+ return 'Zloup !'
- def CreeRandomVector (self) :
- #----------------------------
- # Appelee par CreeSTD
- texte = "\n# Le Random Vector\n\n"
- texte += " myRandomVector_in = RandomVector(Distribution(myDistribution))\n"
- texte += " myRandomVector_out = RandomVector(myFunction, myRandomVector_in)\n"
- return texte
-
-# ______________________________________
-
-#
-# Methodes liees a la creation de la partie Analayse
-# Si le mot clef Analyse existe la methode portant le meme nom va etre appele
-# Exple : si self.DictMCVal["Analysis"]=="Reliability" on appelle la methode Reliability(self)
-#
- def CreeAnalyse (self) :
- #----------------------
- # Appelee par CreeSTD
- texte=""
- if self.DictMCVal.has_key("Analysis"):
- texte += apply( STDGenerateur.__dict__[self.DictMCVal["Analysis"]], (self,) )
- return texte
-
-# ______________________________________
-
- def CreeResu (self) :
- #------------------
- '''
- '''
- texte = "\n# Le resultat\n\n"
- texte += " myResu = " + self.NomAlgo + ".getResult() \n"
- texte += " probability = myResu.getEventProbability()"
-
- return texte
-
-# ______________________________________
-
- def CreeTexteFin(self) :
- #------------------------------------
- texte ='\n\nexcept : \n'
- texte += ' error_message = sys.exc_type\n'
- texte += ' if error_message is not None :\n'
- texte += ' texte = "================================================= \\n"\n'
- texte += ' texte += " Message d\'erreur : \" + str(error_message) + "\\n"\n'
- texte += ' texte += "=================================================\\n"\n'
- texte += ' print texte"\n'
- texte += "sys.exit(error_message)\n"
- return texte
-# ______________________________________
-# \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
-# ______________________________________
-
-
-
-
- def Reliability (self) :
- #------------------------
- # Appelee eventuellement par CreeAnalyse
- texte = self.CreeEvent()
- texte += "\n# La methode\n\n"
- if not self.DictMCVal.has_key("Method"):
- print 'Attention Mot Clef "Method" non renseigne'
- return texte
-
- texte += " myMethod = "+ self.DictMCVal["Method"] + "()\n"
- texte += " myMethod.setSpecificParameters( " + self.DictMCVal["Method"] + "SpecificParameters() )\n"
-
- for MC in self.ListeOrdreMCReliability :
- if self.DictMCVal.has_key(MC) and self.DictMCVal[MC] != None :
- texte += " myMethod.set"+ MC +"( " + str(self.DictMCVal[MC]) + " )\n\n "
-
- texte += "\n# L'algorithme\n\n"
- if not self.DictMCVal.has_key("Algorithm"):
- print 'Attention Mot Clef "Algorithm" non renseigne'
- return texte
- texte += " " + self.NomAlgo + " = " + str (self.DictMCVal["Algorithm"])
- texte += "( NearestPointAlgorithm(myMethod), myEvent, myPhysicalStartingPoint )\n"
- texte += " " + self.NomAlgo + ".run()\n "
-
- if self.DictMCVal.has_key("ImportanceSampling") and self.DictMCVal["ImportanceSampling"]=="yes" :
- texte += self.ImportanceSampling()
- return texte
-
- def Simulation (self) :
- #------------------------
- # Appelee eventuellement par CreeAnalyse
- texte = self.CreeEvent()
- texte += "\n# L'algorithme\n\n"
- if not self.DictMCVal.has_key("Algorithm"):
- print 'Attention Mot Clef "Algorithm" non renseigne'
- return texte
- texte += " " + self.NomAlgo + " = " + str (self.DictMCVal["Algorithm"])
- texte += "( myEvent )\n"
- if self.DictMCVal["Algorithm"] == "DirectionalSampling" :
- texte += self.DirectionalSampling()
- texte += self.ParametresAlgo()
- texte += " " + self.NomAlgo + ".run() "
- return texte
-
-
- def DirectionalSampling (self) :
- #-------------------------------
- # Appelee eventuellement par Simulation
- texte = ""
- for MC in self.ListeOrdreMCDirectionalSampling :
- if self.DictMCVal.has_key(MC) and self.DictMCVal[MC] != None :
- texte += apply(STDGenerateur.__dict__[self.DictMCVal[MC]], (self,))
- return texte
-
- def RootStrategy(self):
- #----------------------
- # Appelee eventuellement par DirectionalSampling
- texte = " myRoot = " + self.DictMCVal["RootStrategy"] + "()\n"
- if self.DictMCVal.has_key("Solver") and (self.DictMCVal["Solver"] != None) :
- texte += " mySolver = " + self.DictMCVal["Solver"] + "() \n"
- texte += " myRoot.setSolver( Solver( mySolver ) ) \n"
- texte += " " + self.NomAlgo + ".setRootStrategy( RootStrategy( myRoot )) \n"
- return texte
-
- def SamplingStrategy(self):
- #--------------------------
- # Appelee eventuellement par DirectionalSampling
- texte += " mySampling = " + self.DictMCVal["SamplingStrategy"] + "()\n"
- texte += " mySampling.setSamplingStrategy( SamplingStrategy( mySampling ) )\n"
- return texte
-
-
- def QuadraticCumul (self) :
- #--------------------------
- # Appelee eventuellement par CreeAnalyse
- texte = "\n# Cumul quadratique\n\n"
- texte += " myQuadraticCumul = QuadraticCumul( myRandomVector_out)\n\n"
- texte += " firstOrderMean = myQuadraticCumul.getMeanFirstOrder()\n"
- texte += " secondOrderMean = myQuadraticCumul.getMeanSecondOrder()\n"
- texte += " covariance = myQuadraticCumul.getCovariance()\n"
- texte += " importanceFactors = myQuadraticCumul.getImportanceFactors()\n"
- return texte
-
- def CreeEvent (self) :
- #------------------
- # Appelee eventuellement par Simulation et Reliability
- texte = "\n# L'evenement\n\n"
- if not self.DictMCVal.has_key("Threshold") or not self.DictMCVal.has_key("ComparisonOperator"):
- print 'Attention Mot Clef "Threshold" ou "ComparisonOperator" non renseigne'
- return texte
- texte += " seuil = " +str (self.DictMCVal["Threshold"]) + "\n"
- texte += " myEvent = Event(myRandomVector_out,"
- texte += "ComparisonOperator(" + str (self.DictMCVal["ComparisonOperator"]) + "()), seuil) \n"
- return texte
-
- def ParametresAlgo( self ):
- #---------------------------
- # Appelee par Simulation
-
- texte += " nbMaxOutSampling = "
-
- if self.DictMCVal["MaximumOuterSamplingType"] == "UserDefined" :
- texte += str(self.DictMCVal["MaximumOuterSampling"])
-
- elif self.DictMCVal["MaximumOuterSamplingType"] == "Wilks" :
- texte += "Wilks.ComputeSampleSize( " + str(self.DictMCVal["Wilks_Alpha"]) + ", " \
- + str(self.DictMCVal["Wilks_Beta"]) + ", " + str(self.DictMCVal["Wilks_I"]) + " )"
- texte += '\n print "MaximumOuterSampling = ", nbMaxOutSampling, "\n" \n'
-
- texte += " " + NomAlgo + ".setMaximumOuterSampling(nbMaxOutSampling)"
- for MC in self.ListeOrdreMCParametresAlgo :
- if self.DictMCVal.has_key(MC) and self.DictMCVal[MC] != None :
- texte += " myMethod.set"+ MC +"(" + str(self.DictMCVal[MC]) + ")\n\n "
-
-
-
-
-# _______________________________
-
-
-
- def ImportanceSampling (self) :
- #-----------------------------
- # Appele eventuellement par Reliability
-
- texte = " temporaryResult = " + self.NomAlgo + ".getResult()\n\n"
- texte += " mean = temporaryResult.getPhysicalSpaceDesignPoint()\n"
- texte += " sigma = NumericalPoint( mean.getDimension(), 1.0 )\n"
- texte += " R = CorrelationMatrix( mean.getDimension() )\n"
- texte += " myImportance = Normal( mean, sigma, R )\n\n\n"
-
- texte += " importanceSamplingAlgo = ImportanceSampling( myEvent, Distribution( myImportance ) )\n\n"
-
- for MC in self.ListeOrdreImportanceSampling :
- if self.DictMCVal.has_key("MC") :
- debut=" importanceSamplingAlgo.set"+MC.split("_")[-1]
- texte += debut + "( " + str(self.DictMCVal[MC]) + " )\n"
-
- texte += "\n importanceSamplingAlgo.run()\n\n"
- self.NomAlgo = "importanceSamplingAlgo"
- return texte
#
# ======================================================================
"""
- Ce module contient le plugin generateur de fichier au format
- openturns pour EFICAS.
+ Ce module contient le plugin generateur de fichier au format
+ openturns pour EFICAS.
"""
import traceback
def entryPoint():
"""
- Retourne les informations necessaires pour le chargeur de plugins
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournees dans un dictionnaire
+ Ces informations sont retournees dans un dictionnaire
"""
return {
# Le nom du plugin
class OpenturnsGenerator(PythonGenerator):
"""
- Ce generateur parcourt un objet de type JDC et produit
- un texte au format eficas et
- un texte au format xml
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format xml
"""
# Les extensions de fichier permis?
extensions=('.comm',)
def initDico(self):
- self.dictMCVal={}
- self.listeVariables=[]
- self.listeFichiers=[]
- self.dictMCLois={}
- self.dictTempo={}
- self.TraiteMCSIMP=1
- self.texteSTD="""#!/usr/bin/env python
- import sys
- print "Invalid file. Check build process."
- sys.exit(1)
- """
- self.texteXML="<!-- Invalid file. Check build process. -->\n"
+ self.dictMCVal={}
+ self.listeVariables=[]
+ self.listeFichiers=[]
+ self.dictMCLois={}
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+ self.texteSTD="""#!/usr/bin/env python
+ import sys
+ print "Invalid file. Check build process."
+ sys.exit(1)
+ """
def gener(self,obj,format='brut'):
- #print "IDM: gener dans generator_openturns_study.py"
- self.initDico()
- self.text=PythonGenerator.gener(self,obj,format)
- #self.genereXML()
- self.genereSTD()
- return self.text
+ print "IDM: gener dans generator_openturns_study.py"
+ self.initDico()
+ self.text=PythonGenerator.gener(self,obj,format)
+ self.genereSTD()
+ return self.text
def generMCSIMP(self,obj) :
- """
- Convertit un objet MCSIMP en texte python
- Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
- """
- s=PythonGenerator.generMCSIMP(self,obj)
- if self.TraiteMCSIMP == 1 :
- self.dictMCVal[obj.nom]=obj.val
- else :
- self.dictTempo[obj.nom]=obj.valeur
- return s
+ """
+ Convertit un objet MCSIMP en texte python
+ Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
+ """
+ s=PythonGenerator.generMCSIMP(self,obj)
+ if self.TraiteMCSIMP == 1 :
+ self.dictMCVal[obj.nom]=obj.val
+ else :
+ self.dictTempo[obj.nom]=obj.valeur
+ return s
def generMCFACT(self,obj):
- # Il n est pas possible d utiliser obj.valeur qui n est pas
- # a jour pour les nouvelles variables ou les modifications
- if obj.nom in ( "Variables", "Files", ) :
- self.TraiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generMCFACT(self,obj)
- if obj.nom in ( "Variables", ) :
- self.listeVariables.append(self.dictTempo)
- self.dictTempo={}
- else :
- self.listeFichiers.append(self.dictTempo)
- self.TraiteMCSIMP=1
- return s
+ # Il n est pas possible d utiliser obj.valeur qui n est pas
+ # a jour pour les nouvelles variables ou les modifications
+ if obj.nom in ( "Variables", "Files", ) :
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generMCFACT(self,obj)
+ if obj.nom in ( "Variables", ) :
+ self.listeVariables.append(self.dictTempo)
+ self.dictTempo={}
+ else :
+ self.listeFichiers.append(self.dictTempo)
+ self.TraiteMCSIMP=1
+ return s
def generETAPE(self,obj):
- if obj.nom in ( "DISTRIBUTION", ) :
- self.TraiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generETAPE(self,obj)
- if obj.nom in ( "DISTRIBUTION", ) :
- self.dictMCLois[obj.sd]=self.dictTempo
- self.dictTempo={}
- self.TraiteMCSIMP=1
- return s
-
- #def genereXML(self):
- # print "IDM: genereXML dans generator_openturns_study.py"
- # if self.listeFichiers != [] :
- # self.dictMCVal["Files"]=self.listeFichiers
- # MonBaseGenerateur=Generateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
- # MonGenerateur=MonBaseGenerateur.getXMLGenerateur()
- # #try :
- # if 1== 1 :
- # self.texteXML=MonGenerateur.CreeXML()
- # #except :
- # else :
- # self.texteXML="Il y a un pb a la Creation du XML"
+ if obj.nom in ( "DISTRIBUTION", ) :
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generETAPE(self,obj)
+ if obj.nom in ( "DISTRIBUTION", ) :
+ self.dictMCLois[obj.sd]=self.dictTempo
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+ return s
def genereSTD(self):
- print "IDM: genereSTD dans generator_openturns_study.py"
- MonBaseGenerateur=Generateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
- MonGenerateur=MonBaseGenerateur.getSTDGenerateur()
- #try :
- if 1== 1 :
- self.texteSTD=MonGenerateur.CreeSTD()
- #except :
- else :
- self.texteSTD="Il y a un pb a la Creation du STD"
-
- #def getOpenturnsXML(self):
- # return self.texteXML
-
- def getOpenturnsSTD(self):
- return self.texteSTD
+ print "IDM: genereSTD dans generator_openturns_study.py"
+ MonBaseGenerateur=Generateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
+ MonGenerateur=MonBaseGenerateur.getSTDGenerateur()
+ #try :
+ if 1== 1 :
+ self.texteSTD=MonGenerateur.CreeSTD()
+ #except :
+ else :
+ self.texteSTD="Il y a un pb a la Creation du STD"
+
+ def writeOpenturnsSTD(self, filename):
+ f = open( str(filename), 'wb')
+ f.write( self.texteSTD )
+ f.close()
+
+
