From 384e3ee8400bae37e2f27fb42301df0767c9b76f Mon Sep 17 00:00:00 2001 From: Pascale Noyret Date: Fri, 8 Feb 2008 09:13:17 +0000 Subject: [PATCH] *** empty log message *** --- Editeur/import_code.py | 2 +- Editeur/session.py | 2 +- Extensions/etape_niveau.py | 2 +- InterfaceQT/qtEficas.py | 2 + Openturns/sdistOTqt.py | 34 +- convert/convert_openturns.py | 128 ++++ generator/DefautASTER.py | 223 ++++++ generator/OpenturnsBase.py | 231 ++++++ generator/OpenturnsSTD.py | 682 ++++++++++++++++++ generator/OpenturnsXML.py | 340 +++++++++ ..._Cata_IDM_V5.py => generator_openturns.py} | 6 +- 11 files changed, 1619 insertions(+), 33 deletions(-) create mode 100644 convert/convert_openturns.py create mode 100644 generator/DefautASTER.py create mode 100644 generator/OpenturnsBase.py create mode 100644 generator/OpenturnsSTD.py create mode 100644 generator/OpenturnsXML.py rename generator/{generator_openturns_from_Open_Cata_IDM_V5.py => generator_openturns.py} (96%) diff --git a/Editeur/import_code.py b/Editeur/import_code.py index 5dc27ac5..9dec4a20 100644 --- a/Editeur/import_code.py +++ b/Editeur/import_code.py @@ -23,7 +23,7 @@ les imports de modules Python """ import sys -from Aster import prefs +import prefs # Ce chemin permet d'importer les modules Noyau et Validation # représentant le code utilisé (si fourni) diff --git a/Editeur/session.py b/Editeur/session.py index 53cec618..2ecc8dc7 100644 --- a/Editeur/session.py +++ b/Editeur/session.py @@ -47,7 +47,7 @@ except: import os,traceback import ConfigParser import re -from Aster import prefs +import prefs # Les valeurs decodees par optparse sont mises dans un objet dictionnaire-like. # On l'utilise comme environnement de session. diff --git a/Extensions/etape_niveau.py b/Extensions/etape_niveau.py index 2db15130..a51c5fff 100644 --- a/Extensions/etape_niveau.py +++ b/Extensions/etape_niveau.py @@ -25,7 +25,7 @@ import traceback from Noyau import N_OBJECT -from Aster import prefs +import prefs class ETAPE_NIVEAU(N_OBJECT.OBJECT): diff --git a/InterfaceQT/qtEficas.py b/InterfaceQT/qtEficas.py index 8c67fff4..2933987d 100644 --- a/InterfaceQT/qtEficas.py +++ b/InterfaceQT/qtEficas.py @@ -37,6 +37,8 @@ class Appli(Eficas): if code == "ASTER" : from Aster import prefs sys.path.append(INSTALLDIR+"/Aster") + else : + import prefs self.top=self self.CONFIGURATION = configuration.make_config(self,prefs.REPINI) self.CONFIGStyle = configuration.make_config_style(self,prefs.REPINI) diff --git a/Openturns/sdistOTqt.py b/Openturns/sdistOTqt.py index fbff8810..a354e981 100644 --- a/Openturns/sdistOTqt.py +++ b/Openturns/sdistOTqt.py @@ -1,32 +1,26 @@ # -*- coding: utf-8 -*- """ - Ce module sert à construire les distributions d'EFICAS en fonction - du tag CVS courant + Ce module sert à construire les distributions d'EFICAS pour Openturns + en fonction du tag CVS courant Les distributions sont : - un tar.gz pour UNIX ne contenant pas mxTextTools - - un zip pour Windows contenant mx TextTools préinstallé L'utilisation de ce module est la suivante : 1- Se mettre dans un répertoire de travail 2- Configurer son environnement pour utiliser le référentiel CVS EFICAS 3- Exporter les sources d'EficasV1 par la commande : cvs export -r TAG -d Eficas_export EficasV1 ou TAG est le tag CVS de la version que l'on veut distribuer (par exemple V1_1p1) - 4- Copier le répertoire fourni par Aster (ACCAS6.2.0) au meme niveau que Eficas_export 5- Aller dans le répertoire Eficas_export 6- Executer le script sdist.py python sdist.py - Ce qui a pour effet de creer un repertoire dist contenant les 2 distributions - et de les copier dans le répertoire indiqué par dir_download s'il est accessible + Ce qui a pour effet de creer un repertoire dist contenant la distribution + et de la copier dans le répertoire indiqué par dir_download s'il est accessible """ import os,shutil,glob,sys import types -version="$Name: BR_dev_V1_14 $"[7:-2] or 'Test1_4' -# ==========Path du noyau fourni par Aster==================== -path_Noyau="../../AccasAster" -# ============================================================ -nom_distrib="QTEficas"+version+"Openturns" +nom_distrib="QTEficasOpenturns_V1_0" path_distrib=os.path.join("dist",nom_distrib) path_TextTools="/home/eficas/pkg/mxTools/egenix2.0.2pourWindows/mx/TextTools" dir_download= "/home/eficas/WWW/telechargement/eficas" @@ -59,10 +53,8 @@ def main(): copyfiles('../Editeur/icons',os.path.join(path_distrib,'Editeur','icons'),['*.gif']) copyfiles('../Editeur/Patrons',os.path.join(path_distrib,'Editeur','Patrons'),['*.com*']) - copyfiles(os.path.join(path_Noyau,'Noyau'),os.path.join(path_distrib,'Noyau'),['*.py']) - copyfiles(os.path.join(path_Noyau,'Validation'),os.path.join(path_distrib,'Validation'),['*.py']) - copyfiles(os.path.join(path_Noyau,'Accas'),os.path.join(path_distrib,'Aster'),['properties.py']) - copyfiles(os.path.join(path_Noyau,'Cata'),os.path.join(path_distrib,'Aster','Cata'),['__init__.py',]) + copyfiles('../Noyau'),os.path.join(path_distrib,'Noyau'),['*.py']) + copyfiles('../Validation'),os.path.join(path_distrib,'Validation'),['*.py']) copyfiles('../Tools',os.path.join(path_distrib,'Tools'),['*.py']) copyfiles('../Tools/foztools',os.path.join(path_distrib,'Tools','foztools'),['*.py']) @@ -78,7 +70,6 @@ def main(): print "Repertoire de download inconnu : ",dir_download shutil.copy('prefs.py.win',os.path.join(path_distrib,'Aster','prefs.py')) - shutil.copy('editeur.ini.win',os.path.join(path_distrib,'Aster','editeur.ini')) try: shutil.copytree(path_TextTools,os.path.join(path_distrib,'Tools','TextTools')) @@ -86,11 +77,6 @@ def main(): print "Impossible de recuperer mxTextTools : ",dir_download sys.exit(1) - zipfile= makezipfile('dist',nom_distrib,nom_distrib) - try: - shutil.copy(zipfile,dir_download) - except: - print "Repertoire de download inconnu : ",dir_download def make_dir(dir_cible): if type(dir_cible) is not types.StringType: @@ -122,12 +108,6 @@ def maketarball(dir_trav,dir_cible,nom_tar): os.chdir(prev) return os.path.join(dir_trav,nom_tar+".tar.gz") -def makezipfile(dir_trav,dir_cible,nom_tar): - prev=os.getcwd() - os.chdir(dir_trav) - os.system("zip -rq "+nom_tar+".zip "+dir_cible) - os.chdir(prev) - return os.path.join(dir_trav,nom_tar+".zip") main() diff --git a/convert/convert_openturns.py b/convert/convert_openturns.py new file mode 100644 index 00000000..527e6f65 --- /dev/null +++ b/convert/convert_openturns.py @@ -0,0 +1,128 @@ +# -*- 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', + # 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 + diff --git a/generator/DefautASTER.py b/generator/DefautASTER.py new file mode 100644 index 00000000..de676e30 --- /dev/null +++ b/generator/DefautASTER.py @@ -0,0 +1,223 @@ +""" +Ce module contient les variables +par defaut pour Aster +""" + +from OpenturnsSTD import STDGenerateur +from OpenturnsXML import XMLGenerateur + +#==================================================== +# Preparation du fichier STD +#==================================================== +# C.1. Parties du texte en dur dans le fichier STD +#------------------------------------------------- + +DecalSTD = " " +DecalSTDsaut = "\n " + +TexteSTDFIN ="\n\nexcept : \n" +TexteSTDFIN += DecalSTD + "error_message = sys.exc_type\n" +TexteSTDFIN += "\nif error_message is not None :\n" +TexteSTDFIN += DecalSTD + "texte = \"\\n=================================================\"" +TexteSTDFIN += DecalSTD + "texte += \"\\nMessage d'erreur : \" + str(error_message)" +TexteSTDFIN += DecalSTD + "texte += \"\\n=================================================\\n\"" +TexteSTDFIN += DecalSTD + "print texte" +TexteSTDFIN += DecalSTD + "\nsys.exit(error_message)\n" + +# C.2. Definition de composants dans le fichier STD +#-------------------------------------------------- + +NomFunction = "myFunction" +NomPhysicalStartingPoint = "myPhysicalStartingPoint" +NomCollection = "myCollection" +NomCopule = "myCopula" +NomDistribution = "myDistribution" +NomRandomVector_in = "myRandomVector_in" +NomRandomVector_out = "myRandomVector_out" +NomEvent = "myEvent" +NomMethod = "myMethod" +NomAlgo = "myAlgo" +NomRoot = "myRoot" +NomSampling = "mySampling" +NomSolverSD = "mySolver" +NomResu = "myResu" + +class Defaut(STDGenerateur, XMLGenerateur) : + + def __init__(self, parent) : + self.parent=parent + self.positionne() + self.parent.fic_resu_OpenTURNS_defaut = "fic_resu_OpenTURNS_glop" + + + def positionne(self) : +#============================================= +# . InformationSolver : nom du wrapper, type de fichiers d'echange, etc +#------------------------------------------------------------------------- +# InformationSolver est un dictionnaire indexe par le nom du solveur externe appele. +# InformationSolver[solveur] est lui-meme un dictionnaire qui contient les parametres +# par defaut pour chaque solveur : nom du wrapper, type de fichiers d'echange, etc. + + + dico = { "WrapperPath" : "Code_Aster.so", + "FunctionName" : "Code_Aster", + "WrapCouplingMode" : "fork", + "State" : "shared", + "InDataTransfer" : "files", + "OutDataTransfer" : "files", + } + + self.parent.InformationSolver["Code_Aster"] = dico + +#2. InformationSolverVariable : parametres par defaut pour chaque variable +#---------------------------------------------------------------------------- +# InformationSolverVariable est un dictionnaire indexe par le nom du solveur externe appele. +# InformationSolverVariable[solveur] est tuple qui contient deux dictionnaires ; chacun +# contient les parametres par defaut pour chaque variable avec ce solveur : regexp, etc. + + + dico_in = { "Regexp" : ("^" , "Name", "(.*)= *[0-9eE.+-]+([)]?;?)$"), + "Format" : ("Name", "\\1=%20.13G\\2") + } + dico_out = { "Regexp" : ("(.*)",) } + self.parent.InformationSolverVariable["Code_Aster"] = (dico_in, dico_out) + +# D.3. InformationSolverFile : parametres par defaut pour chaque fichier d'echange +#--------------------------------------------------------------------------------- +# InformationSolverFile est un dictionnaire indexe par le nom du solveur externe appele. +# InformationSolverFile[solveur] est une liste qui contient des dictionnaires ; chacun +# Dontient les parametres par defaut pour chaque fichier avec ce solveur : Id, etc. + + liste = [] + dico = { "Id" : "file_in", + "Type" : "in", + "Name" : "StdIn", + "Path" : "commandes_aster", + } + liste.append(dico) + dico = { "Id" : "file_out", + "Type" : "out", + "Name" : "StdOut", + "Path" : "resultats_aster", + } + liste.append(dico) + self.parent.InformationSolverFile["Code_Aster"] = liste + +# D.2. InformationSolverCommande : arguments, etc +#------------------------------------------------------------------------- +# InformationSolverCommande est un dictionnaire indexe par le nom du solveur externe appele. +# InformationSolverCommande[solveur] est lui-meme un dictionnaire qui contient les parametres +# supplementaires pour la commande. +# Des parametres sont donnes sous forme de tuple : (ok/nok, "mot-cle") ou (ok/nok, "mot-cle", valeur) +# . On ajoute seulement si ok +# . Avec (ok/nok, "mot-cle"), on ajoute en arguments les couples ("mot-cle", nom_du_parametre) +# . Avec (ok/nok, "mot-cle", valeur), on ajoute en arguments les couples ("mot-cle", valeur) + + + dico = { "file_out" : (1, "-fic_de_aster_vers_ot"), + "variable_in" : (1, "-variable") + } + self.parent.InformationSolverCommande["Code_Aster"] = dico + + + def CreeResu (self) : + #------------------ + ''' + Le resultat : + . Donnees : + . l'algorithme choisi. + . Resultats : + . Ecriture des odres d'impression. + ''' + Algorithm = str (self.parent.dictMCVal["Algorithm"]) + texte = "\n\n# Le resultat\n" + texte += DecalSTDsaut + NomResu + " = " + NomAlgo + ".getResult()" + texte += DecalSTDsaut + "###" + "print " + NomResu + texte += DecalSTDsaut + "text_resu = \"Resultats\\n=======\\n\"" + +# Particularites des algorithmes de fiabilite + + if self.parent.Analysis in ( "Reliability", ) : + texte += DecalSTDsaut + "aux = " + NomResu + ".getIsStandardPointOriginInFailureSpace()" + texte += DecalSTDsaut + "if aux :" + texte += DecalSTDsaut + DecalSTD + "texte_bis = \"est\"" + texte += DecalSTDsaut + "else :" + texte += DecalSTDsaut + DecalSTD + "texte_bis = \"n\'est pas\"" + texte += DecalSTDsaut + "text_resu += \"\\nLe point initial \" + texte_bis + \" dans l\'espace de defaillance.\"" + l_aux = [ ("Probabilite de defaillance", "EventProbability") ] + l_aux.append ( ("Indice de confiance generalise", "GeneralisedReliabilityIndex") ) + l_aux.append ( ("Indice de confiance de Hasofer", "HasoferReliabilityIndex") ) + for t_aux in l_aux : + texte += DecalSTDsaut + "text_resu += \"\\n" + t_aux[0] + " = \" + str(" \ + + NomResu + ".get" + t_aux[1] + "())" + l_aux = [] + l_aux.append("StandardSpaceDesignPoint") + l_aux.append("PhysicalSpaceDesignPoint") + l_aux.append("ImportanceFactors") + texte += DecalSTDsaut + "l_aux_var = []" + for DictVariable in self.parent.ListeVariables : + if ( DictVariable["Type"] == "in" ) : + texte += DecalSTDsaut + "l_aux_var.append(\"" + DictVariable["Name"] + "\")" + texte += DecalSTDsaut + "l_aux = []" + for type_resu in l_aux : + texte += DecalSTDsaut + "l_aux.append(" + NomResu + ".get" + type_resu + "())" + texte += DecalSTDsaut + "for resu in l_aux :" + texte += DecalSTDsaut + DecalSTD + "if not resu.isEmpty() :" + texte += DecalSTDsaut + DecalSTD + DecalSTD + "text_resu += \"\\n\" + resu.getName() + \" :\"" + texte += DecalSTDsaut + DecalSTD + DecalSTD + "size = resu.getDimension()" + texte += DecalSTDsaut + DecalSTD + DecalSTD + "l_aux_1 = resu.getCollection()" + texte += DecalSTDsaut + DecalSTD + DecalSTD + "for iaux in range(size) :" + texte += DecalSTDsaut + DecalSTD + DecalSTD + DecalSTD + "text_resu += \"\\n. \" + l_aux_var[iaux] + \" : \" + str(l_aux_1[iaux])" + +# Particularites des algorithmes de simulation + + if self.parent.Analysis in ( "Simulation", ) : + l_aux = [ ("Probabilite de defaillance", "ProbabilityEstimate") ] + l_aux.append ( ("Variance", "VarianceEstimate") ) + l_aux.append ( ("Nombre d\'iterations", "OuterSampling") ) + for t_aux in l_aux : + texte += DecalSTDsaut + "text_resu += \"\\n" + t_aux[0] + " = \" + str(" \ + + NomResu + ".get" + t_aux[1] + "())" + texte += DecalSTDsaut + "text_resu += \"\\nNombre d'evaluations de l'etat limite = \" + str(" \ + + NomResu + ".getOuterSampling()*" + NomResu + ".getBlockSize())" + if self.parent.dictMCVal.has_key("ConfidenceIntervalProbability") : + aux = self.parent.dictMCVal["ConfidenceIntervalProbability"] + texte += DecalSTDsaut + "proba = " + NomResu + ".getProbabilityEstimate()" + texte += DecalSTDsaut + "t_aux = " + if ( type(aux) is type(0.) ) : + texte += "(" + str(aux) + ")" + t_aux = [ str(aux) ] + else : + texte += str(aux) + texte += DecalSTDsaut + "for val in t_aux :" + texte += DecalSTDsaut + DecalSTD + "length = " + NomResu + ".getConfidenceLength(val)" + texte += DecalSTDsaut + DecalSTD + "vinf = str( proba - 0.5*length )" + texte += DecalSTDsaut + DecalSTD + "vsup = str( proba + 0.5*length )" + texte += DecalSTDsaut + DecalSTD + "text_resu += \"\\nIntervalle de confiance a \" + str(val) + \" = [ \" " + texte += "+ vinf + \" , \" + vsup + \" ]\"" + +# Generalites + + texte += DecalSTDsaut + "d_aux = {}" + texte += DecalSTDsaut + "d_aux[\"E\"] = ( \"de la fonction\", " + NomFunction + ".getEvaluationCallsNumber() )" + texte += DecalSTDsaut + "d_aux[\"G\"] = ( \"du gradient\", " + NomFunction + ".getGradientCallsNumber() )" + texte += DecalSTDsaut + "d_aux[\"H\"] = ( \"du hessien\", " + NomFunction + ".getHessianCallsNumber() )" + texte += DecalSTDsaut + "for cle in d_aux.keys() :" + texte += DecalSTDsaut + DecalSTD + "if d_aux[cle][1] > 0 :" + texte += DecalSTDsaut + DecalSTD + DecalSTD + "text_resu += \"\\nNombre d\'appels au solveur pour le calcul \"" \ + + " + d_aux[cle][0] + \" = \" + str(d_aux[cle][1])" + +# Impression + + if self.parent.DictSup.has_key("fic_resu_OpenTURNS") : + fic_resu_OpenTURNS = self.parent.DictSup["fic_resu_OpenTURNS"] + else : + fic_resu_OpenTURNS = fic_resu_OpenTURNS_defaut + texte += DecalSTDsaut + "print \"\\n\", text_resu, \"\\n\"" + texte += DecalSTDsaut + "file_resu = open(\"" + fic_resu_OpenTURNS + "\", \"w\")" + texte += DecalSTDsaut + "file_resu.write(text_resu)" + texte += DecalSTDsaut + "file_resu.close()" + texte += DecalSTDsaut + "probability = " + NomResu + ".getEventProbability()" + + return texte + diff --git a/generator/OpenturnsBase.py b/generator/OpenturnsBase.py new file mode 100644 index 00000000..4f85d50c --- /dev/null +++ b/generator/OpenturnsBase.py @@ -0,0 +1,231 @@ +#@ AJOUT OpenturnsSolver Macro +# -*- coding: iso-8859-1 -*- +# RESPONSABLE + +""" +Ce module contient la partie commune +aux generateurs XML et Etude d Openturns +""" + +__revision__ = "V1.0" + +import os +import sys + +path=os.getcwd() +pathDef=path+"DefautOpenturns" + +sys.path.append(pathDef) + + +#============================================= +# La classe generale +#============================================= + +class Generateur : + + ''' + Classe generale du generateur + dictMCVal : dictionnaire des mots-cles + ListeVariables : chaque variable est decrite par un dictionnaire ; cette liste les regroupe + DictSup : dictionnaires d'options supplementaires, facultatives + fic_resu_OpenTURNS : nom du fichier d'ecritue des resultats OpenTURNS + exchange_file : liste de dictionnaires caracterisant les fichiers d'echange + dir_openturns_python : repertoire ou se trouve openturns.py + ''' + def __init__ (self, dictMCVal, ListeVariables, DictSup ) : + self.ListeVariables = ListeVariables + self.DictSup = DictSup + self.dictMCVal = dictMCVal + self.InformationSolver = {} + self.InformationSolverVariable = {} + self.InformationSolverFile = {} + self.InformationSolverCommande = {} + self.fic_resu_OpenTURNS_defaut = None + + self.creeInfoVar() + self.creeInfoSolver() + if dictMCVal.has_key("Analysis"): + self.Analysis = str(dictMCVal["Analysis"]) + + def creeInfoVar (self) : + """ + On repere les variables in et on les numerote. + On cree/complete les informations liees aux variables selon chaque solveur. + Si aucun solveur n'a ete precise, on ne fait rien (heureusement !) + Si le solveur demande n'a pas d'informations par defaut, on ne fait encore rien. + Sinon, on retient chacune des informations par defaut sauf si + elle a ete donnee explicitement. + Au final, le dictionnaire des mots-cles self.DictVariable aura ete enrichi et le traitement + ulterieur des ecritures se fera sans savoir si un solveur a ete precise. + """ + # A-t-on une information specifique au solveur ? Si oui, c'est un dictionnaire. + if self.dictMCVal.has_key("PhysicalSolver") : + Solver = self.dictMCVal["PhysicalSolver"] + try : + import_name="Defaut"+Solver + module=__import__(import_name,globals(),locals()) + monDefaut=module.Defaut(self) + except: + monDefaut=None + pass + + + tuple_solver = None + if self.InformationSolverVariable.has_key(Solver) : + tuple_solver = self.InformationSolverVariable[Solver] + + # On va parcourir toutes les variables de la liste. Le dictionnaire les caracterisant + # va etre (eventuellement) enrichi du type et d'informations specifiques au solveur. + # A la fin il faudra avoir substitue la liste des dictionnaires, d'ou le passage + # par une liste auxiliaire + l_aux = [] + self.dictTypeVar = {} + self.nbVarIn = 0 + num = 0 + for DictVariable in self.ListeVariables : + # par defaut, une variable non typee est "in" + if not DictVariable.has_key("Type") : + DictVariable["Type"] ="in" + # On memorise ce type et on compte les "in" + self.dictTypeVar[num] = DictVariable["Type"] + if DictVariable["Type"] == "in" : + self.nbVarIn = self.nbVarIn + 1 + # Avec des informations solveur : + if tuple_solver is not None : + if DictVariable["Type"] == "in" : + dico_solver = tuple_solver[0] + else : + dico_solver = tuple_solver[1] + for cle in dico_solver.keys() : + if not DictVariable.has_key(cle) : + if Generateur.__dict__.has_key(cle) : + chaine = apply(Generateur.__dict__[cle], (self, dico_solver[cle], DictVariable)) + else : + chaine = dico_solver[cle] + DictVariable[cle] = chaine + l_aux.append(DictVariable) + num = num+1 + self.ListeVariables = l_aux + + + def Regexp ( self, info, DictVariable) : + """ + info est un tuple qui contient les caracteristiques de l'expression reguliere, + avec la convention suivante : + . si info[n] existe dans DictVariable, on ecrit DictVariable[info[n]] + . sinon, on ecrit info[n] + """ + chaine = "" + for aux in info : + if DictVariable.has_key(aux) : + chaine += DictVariable[aux] + else : + chaine += aux + return chaine + + + def Format ( self, info, DictVariable) : + """ + Identique a Regexp + """ + chaine = self.Regexp ( info, DictVariable) + return chaine + + + def creeInfoSolver (self) : + """ + On cree/complete les informations liees au solveur. + Si aucun solveur n'a ete precise, on ne fait rien (heureusement !) + Pour chaque etape, si le solveur demande n'a pas d'informations par defaut, + on ne fait rien. + Sinon, on retient chacune des informations par defaut sauf si + elle a ete donnee explicitement. + Le but est de modifier ou d'enrichir les structures de donnees pour que les + fonctions d'impression du XML ou du STD fonctionnent en aveugle, sans savoir + si un solveur a ete precise. + Etape 2 : Complement des mots-cles avec ceux par defaut + Au final, le dictionnaire des mots-cles self.dictMCVal aura ete enrichi. + Etape 3 : Determination de la liste des fichiers d'echange + Au final, self.ListeFiles contient les dictionnaires caracterisant + chaque fichier (cf. CreeFile). + Etape 4 : Determination des eventueles arguments de la commande. + Au final, self.ArguCommande contient la liste des arguments de + la commande (cf. CreeCommande). + """ + + if self.dictMCVal.has_key("PhysicalSolver") : + +# 1. ==> Le nom du solveur externe + Solver = self.dictMCVal["PhysicalSolver"] + +# 2. ==> Complement des mots-cles avec ceux par defaut. + if self.InformationSolver.has_key(Solver) : + dico_solver = self.InformationSolver[Solver] + for cle in dico_solver.keys() : + if not self.dictMCVal.has_key(cle) : + self.dictMCVal[cle] = dico_solver[cle] + +# 3. ==> Determination de la liste des fichiers d'echange +# C'est d'abord celle eventuellement fournie en argument : + if self.DictSup.has_key("exchange_file") : + l_sup = self.DictSup["exchange_file"] + else : + l_sup = [] + l_aux = [] + for fichier in l_sup : + l_aux.append(fichier) +# On enrichit par des options par defaut : + if self.InformationSolverFile.has_key(Solver) : + +# Reperage des fichiers definis par defaut +# Si le fichier n'est pas defini dans la liste en argument, on l'ajoute + liste_solver = self.InformationSolverFile[Solver] + for dico in liste_solver : + file_id = dico["Id"] + on_ajoute = 1 + for fichier in l_sup : + if ( fichier["Id"]==file_id ) : + on_ajoute = 0 + break + if on_ajoute : + l_aux.append(dico) +# On archive la liste + self.ListeFiles = l_aux + +# 4. ==> Arguments de la commande + + self.ArguCommande = " " +# On enrichit par des options par defaut : + if self.InformationSolverCommande.has_key(Solver) : + dico_solver = self.InformationSolverCommande[Solver] + self.ArguCommande = [] + for cle in dico_solver.keys() : + t_aux = dico_solver[cle] + if t_aux[0] : + if ( cle[-3:] == "out" ) : + type_ech = cle[-3:] + type_info = cle[:-4] + elif ( cle[-2:] == "in" ) : + type_ech = cle[-2:] + type_info = cle[:-3] + else : + type_ech = None + type_info = cle + if ( type_ech is not None ) : + if ( type_info == "file" ) : + l_aux = self.ListeFiles + cle_1 = "Type" + cle_2 = "Path" + else : + l_aux = self.ListeVariables + cle_1 = "Type" + cle_2 = "Name" + for dico in l_aux : + if dico[cle_1] == type_ech : + self.ArguCommande.append(t_aux[1]) + self.ArguCommande.append(dico[cle_2]) + else : + self.ArguCommande.append(t_aux[1]) + self.ArguCommande.append(t_aux[2]) + diff --git a/generator/OpenturnsSTD.py b/generator/OpenturnsSTD.py new file mode 100644 index 00000000..7f1ae0e9 --- /dev/null +++ b/generator/OpenturnsSTD.py @@ -0,0 +1,682 @@ +#@ AJOUT OpenturnsSolver Macro +# -*- coding: iso-8859-1 -*- +# RESPONSABLE + +""" +Ce module contient le generateur Etude pour Openturns +""" + +__revision__ = "V1.0" + +import os +import OpenturnsBase + + + +#============================================= +# G. La classe de creation du fichier STD +#============================================= + +class STDGenerateur (OpenturnsBase.Generateur) : + + ''' + Generation du fichier pyhton + ''' + def __init__ (self, dictMCVal, ListeVariables, DictSup) : + #-------------------------------------------------------- + self.Analysis= None + self.NomAlgo="myAlgo" + OpenturnsBase.Generateur.__init__ (self, dictMCVal, ListeVariables, DictSup) + print self.Analysis + + def CreeSTD (self) : + #------------------ + ''' + Pilotage de la creation du fichier python + ''' + self.texte = self.CreeEntete() + self.texte += self.CreeRandomGenerator() + self.texte += self.CreeFunction() + self.texte += self.CreeLois() + self.texte += self.CreeCopula() + self.texte += self.CreeDistribution() + self.texte += self.CreeRandomVector() + if self.Analysis in ("QuadraticCumul", ) : + self.texte += self.CreeQuadraticCumul() + if self.Analysis in ( "Reliability", "Simulation" ) : + self.texte += self.CreeEvent() + if self.Analysis in ( "Reliability", ) : + self.texte += self.CreeMethod() + if self.Analysis in ( "Reliability", "Simulation" ) : + self.texte += self.CreeAlgo() + #PN Juste pour tester aujourdhui + # a modifier bien sur + if self.dictMCVal.has_key("PhysicalSolver") and \ + self.dictMCVal["PhysicalSolver"] == "ASTER" : + print "il faut creer l autre partie Resultat pour GN" + self.texte += self.CreeResu() + self.texte += self.CreeTexteFin() + return self.texte + + def CreeEntete (self) : + #------------------ + ''' + L'entete : + . Donnees : + . Resultats : + ''' + + texte = "#!/usr/bin/env python\n" + texte += "# -*- coding: iso-8859-1 -*-\n" + texte += "import sys\n" + texte += "import os\n" + if self.DictSup.has_key("dir_openturns_python") : + texte += "sys.path.append(\"" + self.DictSup["dir_openturns_python"] + "\")\n" + if self.DictSup.has_key("DTDDirectory") : + texte += "os.environ[\"OPENTURNS_WRAPPER_PATH\"] = \".:" + self.DictSup["DTDDirectory"] + "\"\n" + texte += "from openturns import *\n" + texte += "error_message = None\n" + texte += "try : \n" + return texte + + def CreeRandomGenerator (self) : + #------------------------------- + ''' + L'initialisation du generateur aleatoire + ''' + texte = "" + 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 : + . Donnees : + . Resultats : + . Remarque : le nom 'solver' est en dur ici. Il doit imperativement correspondre + au nom du fichier xml : 'solver.xml' + ''' + texte = "\n# La fonction\n\n" + texte += ' myFunction = NumericalMathFunction(\"XXXXXX\")\n' + texte += ' dim = myFunction.getInputNumericalPointDimension()\n' + return texte + + + def CreeLois (self) : + #------------------ + ''' + Chacune des lois + ''' + code_erreur = 0 + texte = "\n# Les lois\n\n" + if self.Analysis == "Reliability" : + texte += " myPhysicalStartingPoint = NumericalPoint(dim, 0.0)\n" + texte += " myCollection = DistributionCollection(dim)\n" + numVar = 0 + self.loi = None + for DictVariable in self.ListeVariables : + if self.dictTypeVar[numVar] == "in" : + self.loi = DictVariable["MarginalDistribution"] + fonction = self.loi["Kind"] + texte_loi, Nom, code_erreur = apply(STDGenerateur.__dict__[fonction], (self, DictVariable["Name"])) + if code_erreur : + break + texte += " " + texte_loi + texte += " myCollection["+str(numVar)+"] = Distribution("+Nom+")\n" + if self.Analysis == "Reliability" : + texte += " myPhysicalStartingPoint["+str(numVar)+"] = " + if DictVariable.has_key("PhysicalStartingPoint") : + texte += str(DictVariable["PhysicalStartingPoint"]) +"\n" + else : + texte += Nom+".computeQuantile(0.5)[0]\n" + numVar = numVar+1 + return texte + + + def CreeCopula (self) : + #------------------ + ''' + La copule : + . Donnees : + . Resultats : + ''' + texte = "\n# La copule\n\n" + texte += " myCopula = IndependentCopula(dim)\n" + return texte + + + def CreeDistribution (self) : + #---------------------------- + ''' + La distribution : + . Donnees : + . Resultats : + ''' + texte = "\n# La distribution\n\n" + texte += " myDistribution = ComposedDistribution(myCollection, Copula(myCopula))\n" + return texte + + + def CreeRandomVector (self) : + #---------------------------- + ''' + Le Random Vector : + . Donnees : + . Resultats : + ''' + texte = "\n# Le Random Vector\n\n" + texte += " myRandomVector_in = RandomVector(Distribution(myDistribution))\n" + texte += " myRandomVector_out = RandomVector(myFunction,myRandomVector_in )\n" + return texte + + + def CreeEvent (self) : + #------------------ + ''' + L'evenement : + . Donnees : + . le nom du random vector est toujours le meme. + . Le type de comparaison et la valeur du seuil sont des donnees externes. + . Resultats : + . le nom de l'evenement produit est toujours le meme. + ''' + texte = "\n# L'evenement\n\n" + texte += " seuil = " +str (self.dictMCVal["Threshold"]) + "\n" + texte += " myEvent = Event(myRandomVector_out," + texte += "ComparisonOperator(" + str (self.dictMCVal["ComparisonOperator"]) + "()), seuil) \n" + return texte + + + def CreeMethod (self) : + #------------------ + ''' + La methode : + . Donnees : + . la methode choisie. + . ses parametres. + . Resultats : + . le nom de la methode produite est toujours le meme. + ''' + Method = str (self.dictMCVal["Method"]) + texte = "\n# La methode\n\n" + texte += " myMethod = "+ Method + " () \n" + texte += " myMethod.setSpecificParameters(" + Method + "SpecificParameters()) \n " + t_aux = ( "MaximumIterationsNumber", "MaximumAbsoluteError", "RelativeAbsoluteError", \ + "MaximumConstraintError", "MaximumResidualError" ) + texte += self.CreeOption ("myMethod", t_aux) + return texte + + def CreeQuadraticCumul (self) : + #------------------ + ''' + Cumul quadratique : + . Donnees : + . le vecteur aleatoire de sortie + . Resultats : + . moments d'ordre 1 et 2, covariance facteurs d'importance + ''' + 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 CreeAlgo (self) : + #------------------ + ''' + L'algorithme : + . Donnees : + . la methode choisie. + . ses parametres. + . Resultats : + . le nom de l'algorithme produit est toujours le meme. + ''' + Algorithm = str (self.dictMCVal["Algorithm"]) + texte = "\n# L'algorithme\n\n" + +# 1. Definition de l'algorithme + + texte += " " + self.NomAlgo + " = " + Algorithm + "(" + if self.Analysis in ( "Reliability", ) : + texte += "NearestPointAlgorithm(myMethod), myEvent, myPhysicalStartingPoint" + else : + texte += "myEvent" + texte += ") \n" + +# 2. Particularites des algorithmes de simulation + + if self.Analysis in ( "Simulation", ) : + +# 2.1. Particularites de la simulation directionnelle + + if Algorithm in ( "DirectionalSampling", ) : + if self.dictMCVal.has_key("RootStrategy") : + texte += " myRoot = " + self.dictMCVal["RootStrategy"] + "()\n" + if self.dictMCVal.has_key("Solver") : + texte += " mySolver = " + self.dictMCVal["Solver"] + "() \n" + texte += " myRoot.setSolver( Solver( mySolver ) ) \n" + texte += " " + self.NomAlgo + ".setRootStrategy( RootStrategy( myRoot )) \n" + if self.dictMCVal.has_key("SamplingStrategy") : + texte += " mySampling = " + self.dictMCVal["SamplingStrategy"] + "()\n" + texte += " mySampling.setSamplingStrategy( SamplingStrategy( mySampling ) )\n" + +# 2.2. Parametres de l'algorithme + + texte += " nbMaxOutSampling = " + if self.dictMCVal["MaximumOuterSamplingType"] in ( "UserDefined", ) : + texte += str(self.dictMCVal["MaximumOuterSampling"]) + "\n" + elif self.dictMCVal["MaximumOuterSamplingType"] in ( "Wilks", ) : + texte += "Wilks.ComputeSampleSize( " + str(self.dictMCVal["Wilks_Alpha"]) + ", " + str(self.dictMCVal["Wilks_Beta"]) + ", " + str(self.dictMCVal["Wilks_I"]) + " )\n" + texte += ' print \"MaximumOuterSampling = \", nbMaxOutSampling\n' + texte += " " + self.NomAlgo + ".setMaximumOuterSampling(nbMaxOutSampling)\n" + t_aux = ( "BlockSize", "MaximumCoefficientOfVariation" ) + texte += self.CreeOption ("myAlgo", t_aux) + +# 3. Lancement + + texte += " " + self.NomAlgo + ".run() \n" + +# 4. Tirage d'importance + + 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" + + if self.dictMCVal.has_key("ImportanceSampling_BlockSize") : + texte += " importanceSamplingAlgo.setBloxkSize( " + str(self.dictMCVal["ImportanceSampling_BlockSize"]) + " )\n" + if self.dictMCVal.has_key("ImportanceSampling_MaximumCoefficientOfVariation") : + texte += " importanceSamplingAlgo.setMaximumCoefficientOfVariation( " + str(self.dictMCVal["ImportanceSampling_MaximumCoefficientOfVariation"]) + " )\n" + if self.dictMCVal.has_key("ImportanceSampling_MaximumOuterSampling") : + texte += " importanceSamplingAlgo.setMaximumOuterSampling( "+str(self.dictMCVal["ImportanceSampling_MaximumOuterSampling"])+" )\n" + texte += "\n importanceSamplingAlgo.run()\n\n" + + self.NomAlgo = "importanceSamplingAlgo" + + return texte + + + def CreeResu (self) : + #------------------ + ''' + Le resultat : + . Donnees : + . l'algorithme choisi. + . Resultats : + . Ecriture des ordres d'impression. + ''' + Algorithm = str (self.dictMCVal["Algorithm"]) + texte = "\n# Le resultat\n\n" + texte += " myResu = " + self.NomAlgo + ".getResult() \n" + texte += " probability = myResu.getEventProbability()" + + return texte + + + + def CreeOption (self, NomObjet, Liste) : + #--------------------------------------- + ''' + Ajoute des options a un objet + . Donnees : + . le nom de l'objet. + . la liste des parametres a explorer + . Resultats : + . la ou les lignes de texte supplementaire + ''' +### print "Entree dans CreeOption avec ", NomObjet, Liste + texte = " " + for cle in Liste : + if self.dictMCVal.has_key(cle) : + aux = self.dictMCVal[cle] + if aux is not None : + texte += " " + NomObjet + ".set" + cle + "(" + str(aux) + ")\n\n " + return texte + + + + +# Les fonctions chapeau qui definissent les lois +# Elles sont appelees via apply dans CreeLois + + def loi_commun (self, NomDsOpenTurns, NomLoi, l_parametres_loi, l_mots_cles ) : + #------------------------------------------------------------------------------ + ''' + La partie commune a toutes les lois + . Donnees : + . NomDsOpenTurns : nom de la variable + . NomLoi : nom de la loi de distribution pour cette variable + . l_parametres_loi : liste des parametres utilises pour cette loi. + On definit une variable par valeur + . l_mots_cles : liste des mots_cles utilises pour cette loi. + Si le mot_cle est dans la liste des parametres, on + emploie sa valeur. + Si le mot-cle est de type "n/p", on met le quotient entre + le parametre n et le parametre p (cas de la lognormal) + Sinon, on met la valeur directement. + . Resultats : + . texte : le morceau de python correspondant + ''' +# Le nom de la loi + Nom_de_la_loi = NomDsOpenTurns + "_Dist" + +### print "l_mots_cles = ", l_mots_cles +### print "l_parametres_loi = ", l_parametres_loi +# Ecriture des valeurs des arguments de la loi + texte = "\n" + for param_loi in l_parametres_loi : +### print ". param_loi = ", param_loi + texte += " " + Nom_de_la_loi + "_" + param_loi + " = " + str (self.loi[param_loi]) + "\n" + +# Ecriture de l'expression de la loi + aux = "" + for mot_cle in l_mots_cles : +### print ". mot_cle = ", mot_cle + if mot_cle in l_parametres_loi : + aux += " " + Nom_de_la_loi + "_" + mot_cle + "," + else : + auxbis = str(mot_cle) + if type(mot_cle) == type("a") : + if len(mot_cle) >= 3 : + if mot_cle[1] == "/" : + n = int(mot_cle[0]) + p = int(mot_cle[2]) + auxbis = Nom_de_la_loi + "_" + l_parametres_loi[n] + "/" + Nom_de_la_loi + "_" + l_parametres_loi[p] + aux += " " + auxbis + "," + texte += "\n " + Nom_de_la_loi + " = " + NomLoi + "(" + aux[:-1] + ")\n" +# Memorisation du nom de la loi + texte += " " + Nom_de_la_loi + '.setName("'+NomDsOpenTurns+'")\n' + + return texte, Nom_de_la_loi + + def Beta (self, NomDsOpenTurns) : + #-------------------------------- + ''' + La loi beta + ''' + code_erreur = 0 + if ( ( self.loi["B"] < self.loi["A"] ) ) : + code_erreur = 1 + if ( self.loi["Settings"] == "RT" ) : + if ( ( self.loi["T"] < self.loi["R"] ) ) : + code_erreur = 1 + l_parametres_loi = [ "R", "T", "A", "B" ] + l_mots_cles = l_parametres_loi + elif ( self.loi["Settings"] == "MuSigma" ) : + l_parametres_loi = [ "Mu", "Sigma", "A", "B" ] + l_mots_cles = [ "Mu", "Sigma", "A", "B", "1" ] + + if code_erreur : + Nom = None + texte = "" + else : + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Beta", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Exponential (self, NomDsOpenTurns) : + #--------------------------------------- + ''' + La loi exponentielle + ''' + code_erreur = 0 + l_parametres_loi = [ "Lambda", "Gamma" ] + l_mots_cles = l_parametres_loi + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Exponential", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Gamma (self, NomDsOpenTurns) : + #--------------------------------- + ''' + La loi gamma + ''' + code_erreur = 0 + if ( self.loi["Settings"] == "KLambda" ) : + l_parametres_loi = [ "K", "Lambda", "Gamma" ] + l_mots_cles = l_parametres_loi + elif ( self.loi["Settings"] == "MuSigma" ) : + l_parametres_loi = [ "Mu", "Sigma", "Gamma" ] + l_mots_cles = [ "Mu", "Sigma", "Gamma", "1" ] + + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Gamma", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Geometric (self, NomDsOpenTurns) : + #------------------------------------ + ''' + La loi geometrique + ''' + code_erreur = 1 + texte = "Loi geometrique non programmee." + +### texte, Nom = self.loi_commun ( NomDsOpenTurns, "Geometric", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Gumbel (self, NomDsOpenTurns) : + #----------------------------------- + ''' + La loi Gumbel + ''' + code_erreur = 0 + if ( self.loi["Settings"] == "AlphaBeta" ) : + l_parametres_loi = [ "Alpha", "Beta" ] + l_mots_cles = l_parametres_loi + elif ( self.loi["Settings"] == "MuSigma" ) : + l_parametres_loi = [ "Mu", "Sigma", "Gamma" ] + l_mots_cles = [ "Mu", "Sigma", "Gamma", "1" ] + + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Gumbel", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Histogram (self, NomDsOpenTurns) : + #------------------------------------- + ''' + La loi histogramme + ''' + code_erreur = 1 + texte = "Loi histogramme non programmee." + +### texte, Nom = self.loi_commun ( NomDsOpenTurns, "Histogram", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def LogNormal (self, NomDsOpenTurns) : + #------------------------------------- + ''' + La loi lognormale + ''' + code_erreur = 0 + if ( self.loi["Settings"] == "MuSigmaLog" ) : + l_parametres_loi = [ "MuLog", "SigmaLog", "Gamma" ] + l_mots_cles = l_parametres_loi + elif ( self.loi["Settings"] == "MuSigma" ) : + if ( ( self.loi["Mu"] < self.loi["Gamma"] ) ) : + code_erreur = 1 + l_parametres_loi = [ "Mu", "Sigma", "Gamma" ] + l_mots_cles = [ "Mu", "Sigma", "Gamma", "1" ] + elif ( self.loi["Settings"] == "MuSigmaOverMu" ) : + if ( ( self.loi["Mu"] < self.loi["Gamma"] ) ) : + code_erreur = 1 + l_parametres_loi = [ "Mu", "Sigma", "Gamma" ] + l_mots_cles = [ "Mu", "1/0", "Gamma", "2" ] + + if code_erreur : + Nom = None + texte = "" + else : + texte, Nom = self.loi_commun ( NomDsOpenTurns, "LogNormal", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Logistic (self, NomDsOpenTurns) : + #------------------------------------ + ''' + La loi logistique + ''' + code_erreur = 0 + l_parametres_loi = [ "Alpha", "Beta" ] + l_mots_cles = l_parametres_loi + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Logistic", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def MultiNomial (self, NomDsOpenTurns) : + #--------------------------------------- + ''' + La loi MultiNomial + ''' + code_erreur = 1 + texte = "Loi multi-nomiale non programmee." + +### texte, Nom = self.loi_commun ( NomDsOpenTurns, "MultiNomial", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Normal (self, NomDsOpenTurns) : + #------------------------------------ + ''' + La loi normale + ''' + code_erreur = 0 + l_parametres_loi = [ "Mu", "Sigma" ] + l_mots_cles = l_parametres_loi + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Normal", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Poisson (self, NomDsOpenTurns) : + #------------------------------------ + ''' + La loi de Poisson + ''' + code_erreur = 0 + l_parametres_loi = [ "Lambda" ] + l_mots_cles = l_parametres_loi + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Poisson", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Student (self, NomDsOpenTurns) : + #------------------------------------ + ''' + La loi de Student + ''' + code_erreur = 0 + l_parametres_loi = [ "Mu", "Nu" ] + l_mots_cles = l_parametres_loi + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Student", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Triangular (self, NomDsOpenTurns) : + #------------------------------------ + ''' + La loi triangulaire + ''' + code_erreur = 0 + if ( self.loi["B"] < self.loi["A"] ) : + code_erreur = 1 + if ( ( self.loi["M"] < self.loi["A"] ) or ( self.loi["M"] > self.loi["B"] ) ) : + code_erreur = 1 + + if code_erreur : + Nom = None + texte = "" + else : + l_parametres_loi = [ "A", "M", "B" ] + l_mots_cles = l_parametres_loi + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Triangular", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def TruncatedNormal (self, NomDsOpenTurns) : + #------------------------------------------- + ''' + La loi normale tronquee + ''' + code_erreur = 0 + if ( self.loi["B"] < self.loi["A"] ) : + code_erreur = 1 + + if code_erreur : + Nom = None + texte = "" + else : + l_parametres_loi = [ "MuN", "SigmaN", "A", "B" ] + l_mots_cles = l_parametres_loi + texte, Nom = self.loi_commun ( NomDsOpenTurns, "TruncatedNormal", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Uniform (self, NomDsOpenTurns) : + #------------------------------------ + ''' + La loi normale uniforme + ''' + code_erreur = 0 + if ( self.loi["B"] < self.loi["A"] ) : + code_erreur = 1 + + if code_erreur : + Nom = None + texte = "" + else : + l_parametres_loi = [ "A", "B" ] + l_mots_cles = l_parametres_loi + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Uniform", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def UserDefined (self, NomDsOpenTurns) : + #--------------------------------------- + ''' + La loi histogramme + ''' + code_erreur = 1 + texte = "Loi definie par l'utilisateur non programmee." + +### texte, Nom = self.loi_commun ( NomDsOpenTurns, "UserDefined", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + def Weibull (self, NomDsOpenTurns) : + #------------------------------------ + ''' + La loi triangulaire + ''' + code_erreur = 0 + + if ( self.loi["Settings"] == "AlphaBeta" ) : + l_parametres_loi = [ "Alpha", "Beta", "Gamma" ] + l_mots_cles = l_parametres_loi + elif ( self.loi["Settings"] == "MuSigma" ) : + l_parametres_loi = [ "Mu", "Sigma", "Gamma" ] + l_mots_cles = [ "Mu", "Sigma", "Gamma", "1" ] + + texte, Nom = self.loi_commun ( NomDsOpenTurns, "Weibull", l_parametres_loi, l_mots_cles ) + + return texte, Nom, code_erreur + + 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 diff --git a/generator/OpenturnsXML.py b/generator/OpenturnsXML.py new file mode 100644 index 00000000..4a64b75e --- /dev/null +++ b/generator/OpenturnsXML.py @@ -0,0 +1,340 @@ +#@ AJOUT OpenturnsSolver Macro +# -*- coding: iso-8859-1 -*- +# RESPONSABLE + +""" +Ce module contient le generateur XML pour Openturns +""" + +import OpenturnsBase + + +#==================================================== +# B. Preparation du fichier XML +#==================================================== +# B.1. Parties du texte en dur dans le fichier XML +#------------------------------------------------- + +TexteXMLPath =' \n' +TexteXMLPath += ' ' +TexteXMLPathFIN = '\n' + +TexteXMLWrap = '\n\n' +TexteXMLWrapFin = '\n\n' + +TexteXMLLibra = '\n \n\n' +TexteXMLLibraFin = '\n \n' + +TexteXMLDescr = '\n \n' +TexteXMLDescr += ' \n' +TexteXMLDescrFin = ' \n' + +TexteXMLVarLi = '\n \n' +TexteXMLVarLi += ' \n' +TexteXMLVarLi += ' ' +TexteXMLVar_1 = "\n " +TexteXMLVarLiFin = '\n \n' +TexteXMLVarLiFin += ' \n' + +TexteXMLWrapM = '\n ' +TexteXMLWrapMFin = ' \n\n' + +TexteXMLComm = ' \n' +TexteXMLComm += ' ' +TexteXMLCommFIN = '\n' + +TexteXMLExtCo = '\n \n' +TexteXMLExtCoFin = '\n \n' + +TexteXMLFile = '\n \n' +TexteXMLFile += ' \n' +TexteXMLFileFin = '\n \n' + +# B.2. Definition de composants dans le fichier XML +#-------------------------------------------------- +# B.2.1. Les variables +#--------------------- + +# OrdreVariable contient l'ordre des MC pour definir une variable en XML +# dictMCXML a pour cle le nom du MC dans la commande, +# Il contient aussi une liste donnant les informations suivantes +# 0 : debut de ligne +# 1 : fin de ligne +# 2 : code : 0 : facultatif, 1 : obligatoire + +OrdreVariable = ('Name', 'Type', 'Comment', 'Unit', 'Regexp', 'Format') +dictMCXML = { "Name" : ('\n \n', \ + 1), + "Comment" : (' ', \ + '\n', \ + 0), + "Unit" : (' ' , \ + '\n', \ + 0), + "Regexp" : (' ' , \ + '\n', \ + 0), + "Format" : (' ' , \ + '\n', \ + 0) } + + +# B.2.2. Les fonctions du wrapper +#-------------------------------- +# OrdreLibrary contient l'ordre des MC pour definir la partie library en XML +# dictLibXML a pour cle le nom du MC dans la commande, +# Il contient aussi une liste donnant les informations suivantes : +# 0 : debut de ligne +# 1 : milieu de ligne si le MC est present +# 2 : milieu de ligne si le MC n est pas present +# 3 : fin de ligne +# 4 : code : 0 : facultatif, 1 : obligatoire sans defaut + +OrdreLibrary = ('FunctionName', 'GradientName', 'HessianName') +dictLibXML = { "FunctionName" : ('\n\n ', \ + '\n ', \ + '\n ', \ + '', \ + 1), + "GradientName" : ('\n\n ', \ + '\n ', \ + '\n ', \ + '', \ + 0), + "HessianName" : ('\n\n ', \ + '\n ', \ + '\n ' , \ + '\n\n', \ + 0) } + +# B.2.3. Les communications du wrapper +#------------------------------------- +# OrdreWrapMode contient l'ordre des MC pour definir la partie WrapMode en XML +# dictWrMXML a pour cle le nom du MC dans la commande, +# Il contient aussi une liste donnant les informations suivantes +# 0 : debut de ligne +# 1 : fin de ligne +# 2 : code : 0 : facultatif, 1 : obligatoire sans defaut, 2 : obligatoire avec defaut +# 3 : valeur par defaut eventuelle +OrdreWrapMode = ('WrapCouplingMode', 'State', 'InDataTransfer', 'OutDataTransfer') +dictWrMXML = { "WrapCouplingMode" : ('\n \n', \ + 2, \ + 'shared">\n'), + "InDataTransfer" : (' \n', \ + 0), + "OutDataTransfer" : (' \n', \ + 0)} + +# B.2.4. Les fichiers d'echange du wrapper +#----------------------------------------- +# OrdreExchangeFile contient l'ordre des MC pour definir la partie OrdreExchangeFile en XML +# dictFilXML a pour cle le nom du MC dans la commande, +# Il contient aussi une liste donnant les informations suivantes +# 0 : debut de ligne +# 1 : fin de ligne +# 2 : code : 0 : facultatif, 1 : obligatoire sans defaut +OrdreExchangeFile = ('Id', 'Type', 'Name', 'Path', 'Subst') +dictFilXML = { "Id" : ('\n ', \ + 1), + "Type" : (' type="', \ + '">', \ + 1), + "Name" : ('\n ', \ + '', \ + 1), + "Path" : ('\n ', \ + '', \ + 1), + "Subst" : ('\n ', \ + '', \ + 1)} + + +#============================================= +# F. La classe de creation du fichier XML +#============================================= + +class XMLGenerateur (OpenturnsBase.Generateur) : + + ''' + Generation du fichier XML + ''' + def __init__ (self, dictMCVal, ListeVariables, DictSup) : + #------------------------------------------------------- + OpenturnsBase.Generateur.__init__ (self, dictMCVal, ListeVariables, DictSup) + self.ListeFiles=[] + + def CreeXML (self) : + #------------------ + ''' + Pilotage general de la creation du fichier XML + ''' + self.texte = self.CreeEntete() + self.texte += TexteXMLWrap + + self.texte += TexteXMLLibra + self.texte += self.CreePath() + + self.texte += TexteXMLDescr + self.texte += self.CreeVariable() + self.texte += self.CreeLibrary() + self.texte += TexteXMLDescrFin + + self.texte += TexteXMLLibraFin + + self.texte += TexteXMLExtCo + self.texte += self.CreeFile() + self.texte += self.CreeWrapMode() + self.texte += self.CreeCommande() + self.texte += TexteXMLExtCoFin + + self.texte += TexteXMLWrapFin + + return self.texte + + + def CreeEntete (self) : + #------------------ + ''' + L'entete : + . Donnees : + . Resultats : + ''' + + texte = "\n" + ##PN a faire : choisir l un des deux dico. + if self.DictSup.has_key("DTDDirectory") : + aux = os.path.join(self.DictSup["DTDDirectory"], "wrapper.dtd") + texte += "\n" + elif self.dictMCVal.has_key("DTDDirectory") : + aux = os.path.join(self.dictMCVal["DTDDirectory"], "wrapper.dtd") + texte += "\n" + return texte + + + def CreePath (self) : + #------------------ + ''' + Path + ''' + texte = TexteXMLPath + try : + texte += self.dictMCVal["WrapperPath"] + except : + print "*********************************************" + print "* ERREUR GENERATION XML *" + print "* champ WrapperPath non rempli *" + print "*********************************************" + texte += TexteXMLPathFIN + return texte + + + def CreeVariable (self) : + #--------------------- + ''' + Chacune des variables + ''' + numvar = 0 + texte = TexteXMLVarLi + for DictVariable in self.ListeVariables : + texte += TexteXMLVar_1 + str(numvar) + TexteXMLVar_2 + for MC in OrdreVariable : + if DictVariable.has_key(MC) : + texte += dictMCXML[MC][0]+DictVariable[MC]+dictMCXML[MC][1] + else : + if dictMCXML[MC][2] : + print "**************************************************" + print "* ERREUR GENERATION XML *" + print "* champ obligatoire non rempli pour variable *" + print "**************************************************" + texte += ' \n' + numvar += 1 + texte += TexteXMLVarLiFin + return texte + + def CreeLibrary (self) : + #--------------------- + ''' + Librairies + ''' + texte = "" + for MC in OrdreLibrary : + texte += dictLibXML[MC][0] + if self.dictMCVal.has_key(MC) : + texte += dictLibXML[MC][1]+self.dictMCVal[MC]+dictLibXML[MC][3] + else : + texte += dictLibXML[MC][2]+dictLibXML[MC][3] + if dictLibXML[MC][4] : + print "**************************************************" + print "* ERREUR GENERATION XML *" + print "* champ obligatoire non rempli pour wrapper *" + print "**************************************************" + return texte + + def CreeFile (self) : + #------------------ + ''' + Fichiers + ''' + numfile = 0 + texte = TexteXMLFile + for dico in self.ListeFiles : + numfile += 1 + texte += "\n " + #file_id = dico["Id"] pn ??? inutile ?? + for MC in OrdreExchangeFile : + if dico.has_key(MC) : + texte += dictFilXML[MC][0] + dico[MC] + dictFilXML[MC][1] + texte += "\n \n" + texte += TexteXMLFileFin + return texte + + def CreeWrapMode (self) : + #---------------------- + ''' + WrapMode + ''' + texte = TexteXMLWrapM + for MC in OrdreWrapMode : + if self.dictMCVal.has_key(MC) : + texte += dictWrMXML[MC][0]+self.dictMCVal[MC]+dictWrMXML[MC][1] + else : + if dictWrMXML[MC][2] == 2 : + texte += dictWrMXML[MC][0]+dictWrMXML[MC][3] + elif dictWrMXML[MC][2] == 1 : + print "**************************************************" + print "* ERREUR GENERATION XML *" + print "* champ obligatoire non rempli pour external *" + print "**************************************************" + texte += TexteXMLWrapMFin + return texte + + def CreeCommande (self) : + #---------------------- + ''' + La commande + On lui passera en argument les options supplementaires eventuelles + ''' + texte = TexteXMLComm + if self.dictMCVal.has_key("Command") : + texte += self.dictMCVal["Command"] + for argument in self.ArguCommande : + texte += " " + argument + else : + texte += '# no command' + texte += TexteXMLCommFIN + return texte + + diff --git a/generator/generator_openturns_from_Open_Cata_IDM_V5.py b/generator/generator_openturns.py similarity index 96% rename from generator/generator_openturns_from_Open_Cata_IDM_V5.py rename to generator/generator_openturns.py index a4d5f48c..c0f6497e 100644 --- a/generator/generator_openturns_from_Open_Cata_IDM_V5.py +++ b/generator/generator_openturns.py @@ -27,8 +27,8 @@ import traceback import types,string,re from generator_python import PythonGenerator -from OpenturnsAster import XMLGenerateur -from OpenturnsAster import STDGenerateur +from OpenturnsXML import XMLGenerateur +from OpenturnsSTD import STDGenerateur def entryPoint(): """ @@ -63,7 +63,7 @@ class OpenturnsGenerator(PythonGenerator): self.TraiteMCSIMP=1 def gener(self,obj,format='brut'): - print "IDM: gener dans generator_openturns.py" + #print "IDM: gener dans generator_openturns.py" self.initDico() self.text=PythonGenerator.gener(self,obj,format) self.genereXML() -- 2.39.2