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)
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.
import traceback
from Noyau import N_OBJECT
-from Aster import prefs
+import prefs
class ETAPE_NIVEAU(N_OBJECT.OBJECT):
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)
# -*- 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"
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'])
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'))
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:
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()
--- /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',
+ # 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
+
--- /dev/null
+"""
+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
+
--- /dev/null
+#@ 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])
+
--- /dev/null
+#@ 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
--- /dev/null
+#@ 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 =' <!-- The path of the shared object -->\n'
+TexteXMLPath += ' <path>'
+TexteXMLPathFIN = '</path>\n'
+
+TexteXMLWrap = '\n<wrapper>\n'
+TexteXMLWrapFin = '\n</wrapper>\n'
+
+TexteXMLLibra = '\n <library>\n\n'
+TexteXMLLibraFin = '\n </library>\n'
+
+TexteXMLDescr = '\n <!-- This section describes all exchanges data between the wrapper and the platform -->\n'
+TexteXMLDescr += ' <description>\n'
+TexteXMLDescrFin = ' </description>\n'
+
+TexteXMLVarLi = '\n <!-- Those variables are substituted in the files above -->\n'
+TexteXMLVarLi += ' <!-- The order of variables is the order of the arguments of the function -->\n'
+TexteXMLVarLi += ' <variable-list>'
+TexteXMLVar_1 = "\n <!-- The definition of variable # "
+TexteXMLVar_2 = " -->"
+TexteXMLVarLiFin = '\n </variable-list>\n'
+TexteXMLVarLiFin += ' <!-- End of variable description -->\n'
+
+TexteXMLWrapM = '\n <!-- Transfert data mode through Wrapper -->'
+TexteXMLWrapMFin = ' </wrap-mode>\n\n'
+
+TexteXMLComm = ' <!-- Command -->\n'
+TexteXMLComm += ' <command>'
+TexteXMLCommFIN = '</command>\n'
+
+TexteXMLExtCo = '\n <external-code>\n'
+TexteXMLExtCoFin = '\n </external-code>\n'
+
+TexteXMLFile = '\n <!-- Those data are external to the platform (input files, etc.)-->\n'
+TexteXMLFile += ' <data>\n'
+TexteXMLFileFin = '\n </data>\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 <variable id="', \
+ '" ', \
+ 1),
+ "Type" : ('type ="', \
+ '">\n', \
+ 1),
+ "Comment" : (' <comment>', \
+ '</comment>\n', \
+ 0),
+ "Unit" : (' <unit>' , \
+ '</unit>\n', \
+ 0),
+ "Regexp" : (' <regexp>' , \
+ '</regexp>\n', \
+ 0),
+ "Format" : (' <format>' , \
+ '</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 <!-- The function that we try to execute through the wrapper -->', \
+ '\n <function provided="yes">', \
+ '\n <function provided="no">', \
+ '</function>', \
+ 1),
+ "GradientName" : ('\n\n <!-- The gradient of the function -->', \
+ '\n <gradient provided="yes">', \
+ '\n <gradient provided="no">', \
+ '</gradient>', \
+ 0),
+ "HessianName" : ('\n\n <!-- The hessian of the function wrapper -->', \
+ '\n <hessian provided="yes">', \
+ '\n <hessian provided="no">' , \
+ '</hessian>\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 <wrap-mode type="', \
+ '"', \
+ 1),
+ "State" : (' state="', \
+ '">\n', \
+ 2, \
+ 'shared">\n'),
+ "InDataTransfer" : (' <in-data-transfer mode="', \
+ '" />\n', \
+ 0),
+ "OutDataTransfer" : (' <out-data-transfer mode="', \
+ '" />\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 <file id="', \
+ '"', '">', \
+ 1),
+ "Type" : (' type="', \
+ '">', \
+ 1),
+ "Name" : ('\n <name>', \
+ '</name>', \
+ 1),
+ "Path" : ('\n <path>', \
+ '</path>', \
+ 1),
+ "Subst" : ('\n <subst>', \
+ '</subst>', \
+ 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 = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\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 += "<!DOCTYPE wrapper SYSTEM \"" + aux + "\">\n"
+ elif self.dictMCVal.has_key("DTDDirectory") :
+ aux = os.path.join(self.dictMCVal["DTDDirectory"], "wrapper.dtd")
+ texte += "<!DOCTYPE wrapper SYSTEM \"" + aux + "\">\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 += ' </variable>\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 <!-- The definition of file # " + str(numfile) + " -->"
+ #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 </file>\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
+
+
--- /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 generateur de fichier au format
+ openturns pour EFICAS.
+
+"""
+import traceback
+import types,string,re
+
+from generator_python import PythonGenerator
+from OpenturnsXML import XMLGenerateur
+from OpenturnsSTD import STDGenerateur
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'openturns',
+ # La factory pour creer une instance du plugin
+ 'factory' : OpenturnsGenerator,
+ }
+
+
+class OpenturnsGenerator(PythonGenerator):
+ """
+ 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
+
+ def gener(self,obj,format='brut'):
+ #print "IDM: gener dans generator_openturns.py"
+ self.initDico()
+ self.text=PythonGenerator.gener(self,obj,format)
+ self.genereXML()
+ 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 pas 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 == "Variables" or "Files":
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generMCFACT(self,obj)
+ if obj.nom == "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 == "MarginalDistribution" :
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generETAPE(self,obj)
+ if obj.nom == "MarginalDistribution" :
+ self.dictMCLois[obj.sd]=self.dictTempo
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+ return s
+
+ def genereXML(self):
+ print "IDM: genereXML dans generator_openturns.py"
+ self.dictMCLois["exchange_file"]=self.listeFichiers
+ MonGenerateur=XMLGenerateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
+ #try :
+ if 1== 1 :
+ self.texteXML=MonGenerateur.CreeXML()
+ #except :
+ else :
+ self.texteXML="Il y a un pb a la Creation du XML"
+
+ def genereSTD(self):
+ MonGenerateur=STDGenerateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
+ #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
+++ /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 generateur de fichier au format
- openturns pour EFICAS.
-
-"""
-import traceback
-import types,string,re
-
-from generator_python import PythonGenerator
-from OpenturnsAster import XMLGenerateur
-from OpenturnsAster import STDGenerateur
-
-def entryPoint():
- """
- Retourne les informations necessaires pour le chargeur de plugins
-
- Ces informations sont retournees dans un dictionnaire
- """
- return {
- # Le nom du plugin
- 'name' : 'openturns',
- # La factory pour creer une instance du plugin
- 'factory' : OpenturnsGenerator,
- }
-
-
-class OpenturnsGenerator(PythonGenerator):
- """
- 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
-
- def gener(self,obj,format='brut'):
- print "IDM: gener dans generator_openturns.py"
- self.initDico()
- self.text=PythonGenerator.gener(self,obj,format)
- self.genereXML()
- 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 pas 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 == "Variables" or "Files":
- self.TraiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generMCFACT(self,obj)
- if obj.nom == "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 == "MarginalDistribution" :
- self.TraiteMCSIMP=0
- self.dictTempo={}
- s=PythonGenerator.generETAPE(self,obj)
- if obj.nom == "MarginalDistribution" :
- self.dictMCLois[obj.sd]=self.dictTempo
- self.dictTempo={}
- self.TraiteMCSIMP=1
- return s
-
- def genereXML(self):
- print "IDM: genereXML dans generator_openturns.py"
- self.dictMCLois["exchange_file"]=self.listeFichiers
- MonGenerateur=XMLGenerateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
- #try :
- if 1== 1 :
- self.texteXML=MonGenerateur.CreeXML()
- #except :
- else :
- self.texteXML="Il y a un pb a la Creation du XML"
-
- def genereSTD(self):
- MonGenerateur=STDGenerateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
- #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
