self.types ={"initialdir":"rep", "rep_travail":"rep","rep_mat":"rep",
"path_doc": "rep","exec_acrobat":"file","exec_acrobat":"file",
- "catalogues" :"cata","isdeveloppeur":"YesNo","path_cata_dev":"rep"}
+ "catalogues" :"cata","isdeveloppeur":"YesNo","path_cata_dev":"rep",
+ "DTDDirectory":"rep"}
self.YesNo={}
self.YesNo['isdeveloppeur']=('Deboggage','Utilisation')
import os,traceback
import ConfigParser
import re
-import prefs
# Les valeurs decodees par optparse sont mises dans un objet dictionnaire-like.
# On l'utilise comme environnement de session.
def create_parser():
# creation du parser des options de la ligne de commande
+ import prefs
parser=optparse.OptionParser(usage="usage: %prog [options]",version="%prog 1.13")
parser.add_option("-j","--jdc",dest="comm",type='string',
# Modules Eficas
sys.path.append(INSTALLDIR+"/Aster")
- import prefs
+ from Aster import prefs
if hasattr(prefs,'encoding'):
# Hack pour changer le codage par defaut des strings
import sys
filetypes = ( ("format "+self.appli.format_fichier.get(), ".com*"),("Tous",'*'))
elif self.code == 'HOMARD' :
filetypes = ( ("format "+self.appli.format_fichier.get(), ".py"),("Tous",'*'))
+ elif self.code == 'OPENTURNS' :
+ filetypes = ( ("format "+self.appli.format_fichier.get(), ".com*"),("Tous",'*'))
else:
filetypes = ( ("format "+self.appli.format_fichier.get(), ".py"),)
if not hasattr(self,'initialdir'):
else :
return
- format=self.appli.format_fichier.get()
# Il faut convertir le contenu du fichier en fonction du format
if convert.plugins.has_key(format):
# Le convertisseur existe on l'utilise
--- /dev/null
+# -*- coding: utf-8 -*-
+
+# --------------------------------------------------
+# debut entete
+# --------------------------------------------------
+
+import Accas
+from Accas import *
+
+class loi ( ASSD ) : pass
+
+
+#CONTEXT.debug = 1
+JdC = JDC_CATA ( code = 'OPENTURNS',
+ execmodul = None,
+ regles = ( AU_MOINS_UN ( 'STUDY' ), ),
+ ) # Fin JDC_CATA
+
+# --------------------------------------------------
+# fin entete
+# --------------------------------------------------
+
+# 3. Version d OPENTURNS ?
+
+#===========================================================
+
+
+#================================
+# 1. Definition des LOIS
+#================================
+
+# Nota : les variables de type OPER doivent etre en majuscules !
+DISTRIBUTION = OPER ( nom = "DISTRIBUTION",
+ sd_prod = loi,
+ op = 68,
+ fr = "Definitions des lois marginales utilisees par les variables d'entree",
+
+
+#====
+# 2. Type de la loi de distribution
+#====
+
+ Kind = SIMP ( statut = "o", typ = "TXM",
+ into = ( "Beta",
+ "Exponential",
+ "Gamma",
+ "Geometric",
+ "Gumbel",
+ "Histogram",
+ "Logistic",
+ "LogNormal",
+ "MultiNomial",
+ "Normal",
+ "TruncatedNormal",
+ "Poisson",
+ "Student",
+ "Triangular",
+ "Uniform",
+ "UserDefined",
+ "Weibull",
+ ),
+ fr = "Choix du type de la loi marginale",
+ ang = "1D marginal distribution." ),
+
+#====
+# 3. Definition des parametres selon le type de la loi
+#====
+
+# 3.1. ==> Loi beta
+
+ BETA = BLOC ( condition = " Kind in ( 'Beta', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "RT", "MuSigma" ),
+ defaut = "RT",
+ fr = "Parametrage de la loi beta",
+ ang = "Beta distribution parameter set"
+ ),
+
+ RT_Parameters = BLOC ( condition = " Settings in ( 'RT', ) ",
+
+ R = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre R de la loi",
+ ang = "R parameter"
+ ),
+
+ # T > R
+ T = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre T de la loi | T > R",
+ ang = "T parameter | T > R"
+ ),
+
+ ), # Fin BLOC RT_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre A de la loi",
+ ang = "A parameter"
+ ),
+
+ # B > A
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre B de la loi | B > A",
+ ang = "B parameter | B > A"
+ ),
+
+ ), # Fin BLOC BETA
+
+# 3.2. ==> Loi exponentielle
+
+ EXPONENTIAL = BLOC ( condition = " Kind in ( 'Exponential', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC EXPONENTIAL
+
+# 3.3. ==> Loi gamma
+
+ GAMMA = BLOC ( condition = " Kind in ( 'Gamma', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "KLambda", "MuSigma" ),
+ defaut = "KLambda",
+ fr = "Parametrage de la loi gamma",
+ ang = "Gamma distribution parameter set"
+ ),
+
+ KLambda_Parameters = BLOC ( condition = " Settings in ( 'KLambda', ) ",
+
+ K = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre K de la loi | K > 0",
+ ang = "K parameter | K > 0"
+ ),
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda de la loi | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ ), # Fin BLOC KLambda_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ defaut = 0.0,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ defaut = 1.0,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+
+ ), # Fin BLOC GAMMA
+
+# 3.5. ==> Loi geometrique
+
+ GEOMETRIC = BLOC ( condition = " Kind in ( 'Geometric', ) ",
+
+ P = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ val_max = 1.,
+ fr = "Parametre P | 0 < P < 1",
+ ang = "P parameter | 0 < P < 1"
+ ),
+
+ ), # Fin BLOC GEOMETRIC
+
+# 3.6. ==> Loi gumbel
+
+ GUMBEL = BLOC ( condition = " Kind in ( 'Gumbel', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "AlphaBeta", "MuSigma" ),
+ defaut = "AlphaBeta",
+ fr = "Parametrage de la loi gumbel",
+ ang = "Gumbel distribution parameter set"
+ ),
+
+ AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Alpha de la loi | Alpha > 0",
+ ang = "Alpha parameter | Alpha > 0"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Beta de la loi",
+ ang = "Beta parameter"
+ ),
+
+ ), # Fin BLOC AlphaBeta_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ ), # Fin BLOC GUMBEL
+
+# 3.7. ==> Loi histogramme
+
+ HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ",
+
+ Sup = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la distribution",
+ ang = "Upper bound"
+ ),
+
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC HISTOGRAM
+
+# 3.8. ==> Loi lognormale
+
+ LOGNORMAL = BLOC ( condition = " Kind in ( 'LogNormal', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "MuSigmaLog", "MuSigma", "MuSigmaOverMu" ),
+ defaut = "MuSigmaLog",
+ fr = "Parametrage de la loi lognormale",
+ ang = "Lognormal distribution parameter set"
+ ),
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi | Mu > Gamma",
+ ang = "Mu parameter | Mu > Gamma"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ MuSigmaOverMu_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaOverMu,' ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi | Mu > Gamma",
+ ang = "Mu parameter | Mu > Gamma"
+ ),
+
+ SigmaOverMu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre SigmaOverMu de la loi | SigmaOverMu > 0",
+ ang = "SigmaOverMu parameter | SigmaOverMu > 0"
+ ),
+
+ ), # Fin BLOC MuSigmaOverMu_Parameters
+
+ MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
+
+ MuLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu log de la loi",
+ ang = "Mu log parameter"
+ ),
+
+ SigmaLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma log de la loi | SigmaLog > 0",
+ ang = "Sigma log parameter | SigmaLog > 0"
+ ),
+
+ ), # Fin BLOC MuSigmaLog_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC LOGNORMAL
+
+# 3.9. ==> Loi logistique
+
+ LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Alpha de la loi",
+ ang = "Alpha parameter"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Beta de la loi | Beta > = 0",
+ ang = "Beta parameter | Beta > = 0"
+ ),
+
+ ), # Fin BLOC LOGISTIC
+
+# 3.10. ==> Loi multinomiale
+
+ MULTINOMIAL = BLOC ( condition = " Kind in ( 'MultiNomial', ) ",
+
+ N = SIMP ( statut = "o",
+ typ = "E",
+ max = 1,
+ fr = "Dimension de la loi",
+ ang = "DISTRIBUTION dimension"
+ ),
+
+ # Il faut un vecteur P de taille N
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC MULTINOMIAL
+
+# 3.11. ==> Loi normale
+
+ NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC NORMAL
+
+# 3.12. ==> Loi Poisson
+
+ POISSON = BLOC ( condition = " Kind in ( 'Poisson', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda de la loi | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ ), # Fin BLOC POISSON
+
+# 3.13. ==> Loi student
+
+ STUDENT = BLOC ( condition = " Kind in ( 'Student', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Nu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 2.,
+ fr = "Parametre Nu de la loi | V > = 2",
+ ang = "Nu parameter | V > = 2"
+ ),
+
+ ), # Fin BLOC STUDENT
+
+# 3.14. ==> Loi triangulaire
+
+ TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = M < = B",
+ ang = "Lower bound | A < = M < = B"
+ ),
+
+ M = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Mode de la loi | A < = M < = B",
+ ang = "Mode | A < = M < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = M < = B",
+ ang = "Upper bound | A < = M < = B"
+ ),
+
+ ), # Fin BLOC TRIANGULAR
+
+# 3.15. ==> Loi normale tronquee
+
+ TRUNCATEDNORMAL = BLOC ( condition = " Kind in ( 'TruncatedNormal', ) ",
+
+ MuN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ SigmaN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre SigmaN de la loi | SigmaN > 0",
+ ang = "SigmaN parameter | SigmaN> 0"
+ ),
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = B",
+ ang = "Lower bound | A < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = B",
+ ang = "Upper bound | A < = B"
+ ),
+
+ ), # Fin BLOC TRUNCATEDNORMAL
+
+# 3.16. ==> uniforme
+
+ UNIFORM = BLOC ( condition = " Kind in ( 'Uniform', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = B",
+ ang = "Lower bound | A < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = B",
+ ang = "Upper bound | A < = B"
+ ),
+
+ ), # Fin BLOC UNIFORM
+
+# 3.17. ==> Loi definie par l'utilisateur
+
+ USERDEFINED = BLOC ( condition = " Kind in ( 'UserDefined', ) ",
+
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC USERDEFINED
+
+# 3.18. ==> Weibull
+
+ WEIBULL = BLOC ( condition = " Kind in ( 'Weibull', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "AlphaBeta", "MuSigma" ),
+ defaut = "AlphaBeta",
+ fr = "Parametrage de la loi weibull",
+ ang = "Weibull distribution parameter set"
+ ),
+
+ AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Alpha de la loi | Alpha > 0",
+ ang = "Alpha parameter | Alpha > 0"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Beta de la loi | Beta > 0",
+ ang = "Beta parameter | Beta > 0"
+ ),
+
+ ), # Fin BLOC AlphaBeta_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC WEIBULL
+
+); # Fin OPER DISTRIBUTION
+
+#================================
+# 2. Definition du cas d'etude
+#================================
+# Nota : les variables de type PROC doivent etre en majuscules !
+STUDY = PROC ( nom = "STUDY",
+ op = None,
+ docu = "",
+ fr = "Mise en donnee pour le fichier de configuration de OPENTURNS.",
+ ang = "Writes the configuration file for OPENTURNS.",
+
+
+#=====
+# 1. Le Type d'Analyse
+#=====
+
+ Analysis = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Reliability", "Simulation", "QuadraticCumul" ),
+ fr = "Type d'Analyse",
+ ang = "Analysis",
+ ),
+
+#=====
+# 2. Pour la probabilite
+# algorithme et mode choisis
+#=====
+
+ Reliability = BLOC ( condition = " Analysis in ( 'Reliability', ) ",
+
+# 2.1. ==> L'algorithme
+
+ Algorithm = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "FORM", "SORM" ),
+ fr = "Algorithme de fiabilite",
+ ang = "Reliability algorithm"
+ ),
+
+# 2.2. ==> La methode
+# 2.2.1. ==> La methode
+
+ Method = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Cobyla", "AbdoRackwitz" ),
+ fr = "Methode d'optimisation.",
+ ang = "Optimisation method."
+ ),
+
+# 2.2.2. ==> Regles
+
+ regles = ( EXCLUS ( "MaximumAbsoluteError", "RelativeAbsoluteError" ), ),
+
+# 2.2.3. ==> Nombre d'iterations
+
+ MaximumIterationsNumber = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = "Nombre maximum d iterations.",
+ ang = "Maximum number of iterations."
+ ),
+
+# 2.2.4. ==> Erreur maximum absolue
+
+ MaximumAbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Distance maximum absolue entre 2 iterations successifs.",
+ ang = "Absolute maximum distance between 2 successive iterates."
+ ),
+
+# 2.2.5. ==> Erreur maximum relative
+
+ RelativeAbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Distance maximum relative entre 2 iterations successifs.",
+ ang = "Relative maximum distance between 2 successive iterates."
+ ),
+
+# 2.2.6. ==> Ecart de contrainte absolu
+
+ MaximumConstraintError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Valeur maximum absolue de la fonction \
+ moins la valeur du niveau.",
+ ang = "Maximum absolute value of the constraint function \
+ minus the level value."
+ ),
+
+# 2.2.7. ==> Ecart de residu absolu
+
+ MaximumResidualError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Maximum orthogonality error.",
+ ang = "Maximum orthogonality error."
+ ),
+
+ ), # Fin BLOC Reliability
+
+#=====
+# 3. Pour la probabilite
+# seuil par simulation :
+# algorithme choisi
+#=====
+
+ Simulation = BLOC ( condition = " Analysis in ( 'Simulation', ) ",
+
+# 3.1. ==> L'algorithme
+
+ Algorithm = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "MonteCarlo", "LHS", "DirectionalSampling" ),
+ fr = "Algorithme de simulation",
+ ang = "Simulation algorithm"
+ ),
+
+# 3.1.2. ==> Nombre d...
+
+ BlockSize = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ defaut = 1,
+ fr = "Nombre maximum ...",
+ ang = "Maximum number of ..."
+ ),
+
+# 3.2.3. ==> ... maximum ...
+
+ MaximumCoefficientOfVariation = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " maximum ...",
+ ang = "Absolute maximum ...."
+ ),
+
+# 3.2.4. ==> Maximum d'iterations
+
+ MaximumOuterSamplingType = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "UserDefined",
+ into = ( "Wilks", "UserDefined" ),
+ fr = "Mode definition du maximum d iterations",
+ ang = "Maximum iterations number"
+ ),
+
+ Wilks = BLOC ( condition = " MaximumOuterSamplingType in ( 'Wilks', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ val_max = 1.0,
+ fr = "Ordre du quantile.",
+ ang = "Order of the quantile."
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ val_max = 1.0,
+ fr = "Confiance ...",
+ ang = "Confidence ..."
+ ),
+
+ I = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 0,
+ defaut = 0,
+ fr = " ...",
+ ang = "Rank ..."
+ ),
+
+ ), # Fin BLOC Wilks
+
+ UserDefined = BLOC ( condition = " MaximumOuterSamplingType in ( 'UserDefined', ) ",
+
+ MaximumOuterSampling = SIMP ( statut = "o",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = "Maximum d iterations externes.",
+ ang = "Maximum outer Sampling value."
+ ),
+
+ ), # Fin BLOC UserDefined
+
+# 3.2.6. ==> Root strategy
+
+ DirectionalSampling = BLOC ( condition = " Algorithm in ( 'DirectionalSampling', ) ",
+
+ RootStrategyImplementation = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "SafeAndSlow",
+ into = ( "RiskyAndFast", "MediumSafe", "SafeAndSlow" ),
+ fr = "RootStrategyImplementation.",
+ ang = "RootStrategyImplementation."
+ ),
+
+ SolverImplementation = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "Bisection",
+ into = ( "Bisection", "Brent", "Secant" ),
+ fr = "SolverImplementation.",
+ ang = "SolverImplementation."
+ ),
+
+ SolverImplementationg = BLOC ( condition = " SolverImplementation in ( 'Bisection', 'Brent', 'Secant' ) ",
+
+ regles = ( ENSEMBLE ( 'AbsoluteError', 'RelativeError', 'maximumFunctionEvaluation' ), ),
+
+ AbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " Absolute error ...",
+ ang = "Absolute error ..."
+ ),
+
+ RelativeError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " Relative error ...",
+ ang = "Relative error ..."
+ ),
+
+ MaximumFunctionEvaluation = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = " maximum Function Evaluation ...",
+ ang = "maximum Function Evaluation ..."
+ ),
+
+ ), # Fin BLOC SolverImplementationg
+
+ ), # Fin BLOC DirectionalSampling
+
+# 3.2.7. ==> Impression des intervalles de confiance
+
+ ConfidenceIntervalProbability = SIMP ( statut = "f",
+ typ = 'R',
+ max = '**',
+ val_min = 0.,
+ val_max = 1.,
+ fr = "Liste des intervalles de confiance voulus",
+ ang = "Confidence intervals"
+ ),
+
+ ), # Fin BLOC Simulation
+
+#=====
+# 4. Pour la probabilite evenement
+#=====
+
+ Event = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
+
+ Threshold = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Le seuil de defaillance.",
+ ang = "Failure threshold."
+ ),
+
+ ComparisonOperator = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "Less", "LessOrEqual", "Equal", "GreaterOrEqual", "Greater" ),
+ fr = "Que faut-il ne pas depasser : un maximum ou un minimum.",
+ ang = "What is the failure threshold : maximum or minimum."
+ ),
+
+ ), # Fin BLOC Event
+
+
+ RandomGenerator = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
+
+ SeedToBeSet = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'no',
+ max = 1,
+ fr = "La racine du generateur aleatoire doit-elle etre positionnee ?",
+ ang = "Does the random generator seed need to be set ?"
+ ),
+
+ SeedSettings = BLOC ( condition = " SeedToBeSet in ( 'yes', ) ",
+
+ RandomGeneratorSeed = SIMP ( statut = "o",
+ typ = "I",
+ max = 1,
+ fr = "Racine du generateur aleatoire",
+ ang = "Random generator seed"
+ ),
+
+ ), # Fin BLOC SeedSettings
+
+ ), # Fin BLOC RandomGenerator
+
+
+#====
+# 5. Definition des parametres
+#====
+
+ Variables = FACT ( statut = "o",
+ min = 1,
+ max = "**",
+
+# 5.1. ==> Nom de la variable
+
+ Name = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom de la variable, identique au nom dans le solver.",
+ ang = "Name of the variable, identical to the name in solver."
+ ),
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "in", "out", ),
+ defaut = "in",
+ fr = "variable d'entree ou de sortie du solver",
+ ang = "Input or Output variable",
+ ),
+
+ Unit = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Unite",
+ ang = "Unit",
+ ),
+
+ Comment = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Commentaire",
+ ang = "Comment",
+ ),
+
+ Regexp = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Expression reguliere",
+ ang = "Regular expression",
+ ),
+
+ Format = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Format d'ecriture",
+ ang = "Format",
+ ),
+
+# 5.2. ==> Variable d'entree
+# 5.2.1. ==> Loi de distribution
+
+ InputVariable = BLOC ( condition = " Type in ( 'in', ) ",
+
+ MarginalDistribution = SIMP ( statut = "o",
+ typ = ( loi, ),
+ max = 1,
+ fr = "Choix de la loi marginale",
+ ang = "1D marginal distribution."
+ ),
+
+# 5.2.2. ==> Parametres de calcul
+
+# 5.2.2.1. ==> Quand on cherche le point de conception, on peut preferer le depart de l'algorithme.
+# Si on ne le fait pas, le programme prendra la valeur mediane.
+
+ PhysicalStartingPoint = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ fr = "Point de demarrage de l'algorithme iteratif",
+ ang = "Initial point for iterative process."
+ ),
+
+# 5.2.2.2. ==> Mode d'obtention du gradient par rapport au parametre
+
+ Gradient = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ into = ( "OUI", "NON" ),
+ defaut = "NON",
+ fr = "ASTER calcule directement le gradient.",
+ ang = "ASTER computes the gradient for this parameter."
+ ),
+
+ GradientProvided = BLOC ( condition = " GRADIENT in ( 'NON', ) ",
+
+ Increment = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ fr = "Increment dans la direction.",
+ ang = "Direction increment."
+ ),
+ ), # Fin BLOC GradientProvided
+
+ ), # Fin BLOC InputVariable
+
+ ), # Fin FACT Variables
+
+#====
+# 6. La fonction
+#====
+
+
+ Solver = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ #into = ( "Code_Aster", "Code_Saturne", "User_defined" ),
+ fr = "Nom du solveur de calcul",
+ ang = "Solver name"
+ ),
+
+ WrapperPath = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "chemin d acces au wrapper",
+ ang = "wrapper library path"
+ ),
+
+ FunctionName = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom de la fonction dans le wrapper",
+ ang = "Function's name in wrapper"
+ ),
+
+ GradientName = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du gradient dans le wrapper",
+ ang = "gradient's name in wrapper"
+ ),
+
+ HessianName = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du hessian dans le wrapper",
+ ang = "hessian's name in wrapper"
+ ),
+
+ WrapCouplingMode = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "static-link", "dynamic-link", "fork", ),
+ fr = "mode de couplage du solver",
+ ang = "Solver coupling mode"
+ ),
+
+ DTDDirectory = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "repertoire de la DTD",
+ ang = "DTD directory"
+ ),
+
+ Fork = BLOC ( condition = " WrapCouplingMode in ( 'fork', ) ",
+
+ Command = SIMP ( statut = "o",
+ max = 1,
+ typ = "TXM",
+ fr = "Chemin du solver",
+ ang = "solver path"
+ ),
+ ), # Fin BLOC Fork
+
+ State = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ into = ( "shared", "specific" ),
+ fr = "partage de l etat interne entre les fonctions",
+ ang = "internal state sharing"
+ ),
+
+ InDataTransfer = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
+ fr = "mode de transfert des donnees d entree",
+ ang = "input transfering mode"
+ ),
+
+ OutDataTransfer = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
+ fr = "mode de transfert des donnees de sortie",
+ ang = "output transfering mode"
+ ),
+
+
+
+#====
+# 7. Informations sur les fichiers d'echange
+#====
+
+ Files = FACT ( statut = "f",
+ min = 1,
+ max = "**",
+
+ Id = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Identificateur du fichier",
+ ang = "File id"
+ ),
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "in", "out", ),
+ fr = "Fichier d entree ou de sortie du solveur ?",
+ ang = "Input or Output file ?"
+ ),
+
+ Name = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier",
+ ang = "file name"
+ ),
+
+ Path = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "chemin du fichier",
+ ang = "path file "
+ ),
+
+ Subst = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "liste de variables",
+ ang = "list"
+ ),
+
+ ), # Fin FACT Files
+
+); # Fin PROC STUDY
+
+Result = PROC ( nom = "RESULT",
+ op = None,
+ docu = "",
+ fr = "Liste des resultats a produire",
+ ang = "List of results to write out",
+
+ GeneralizedReliabilityIndex = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "yes", "no" ),
+ defaut = "no",
+ max = 1,
+ fr = "Index de fiabilite generalise",
+ ang = "Generalized reliability index"
+ ),
+
+); # Fin PROC Result
+
rep_cata = prefs.REPINI
-# Accès à la documentation
+# Acces a la documentation
path_doc = os.path.join(rep_cata,'Doc')
exec_acrobat = "/usr/bin/xpdf"
-# Utilisateur/Développeur
+# Utilisateur/Developpeur
isdeveloppeur = "NON"
path_cata_dev = "/tmp/cata"
-# Répertoire temporaire
+# Repertoire temporaire
rep_travail = "/tmp"
-# Répertoire initial
+# Repertoire initial
initialdir=os.curdir
+DTDDirectory="/local/openturns/Logiciels/OpenTURNS/install/share/openturns/wrappers/"
+
# Choix des catalogues
rep_mat=" "
catalogues = (
# ('OPENTURNS','v0',os.path.join(rep_cata,'Open_Cata_V0.py'),'openturns'),
('OPENTURNS','v1',os.path.join(rep_cata,'Open_Cata_V1.py'),'openturns'),
- ('OPENTURNS','IDM v1',os.path.join(rep_cata,'Open_Cata_IDM_V1.py'),'openturns'),
+ ('OPENTURNS','IDM v7',os.path.join(rep_cata,'Open_Cata_IDM_V7.py'),'openturns'),
# ('OPENTURNS','vg',os.path.join(rep_cata,'Open_Cata_gn.py'),'openturns'),
)
NomSolverSD = "mySolver"
NomResu = "myResu"
-class Defaut(STDGenerateur, XMLGenerateur) :
+class Defaut :
+# Cette classe ajoute les parametres par defaut propres au Solver Aster
+# Elle va d abord enrichir le dictionnaire DictMCVal avec des valeurs par defaut
+# C est la methode enrichitMCVal
+# Elle va ensuite enrichir les variables
+# C est la methode enrichitListeVariables
- def __init__(self, parent) :
+ 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.
+ self.enrichitMCVal()
+ self.enrichitListeVariables()
+ def enrichitMCVal(self) :
+ #=====================
+ # InformationSolver : nom du wrapper, type de fichiers d'echange, etc
+ #----------------------------------------------------------------------
+ # Ajoute les informations sur le wrapper
+ # nom du wrapper, type de fichiers d'echange, etc.
dico = { "WrapperPath" : "Code_Aster.so",
"FunctionName" : "Code_Aster",
"WrapCouplingMode" : "fork",
"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.
+ self.parent.ajouteDictMCVal(dico)
-
- 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.
+ #InformationSolverFile : parametres par defaut pour les fichiers d'echange
+ #--------------------------------------------------------------------------
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
+ dicoIn = { "Id" : "file_in", "Type" : "in", "Name" : "StdIn", "Path" : "commandes_aster" }
+ liste.append(dicoIn)
+ dicoOut = { "Id" : "file_out", "Type" : "out", "Name" : "StdOut", "Path" : "resultats_aster", }
+ liste.append(dicoOut)
+ dicoFile={"exchange_file" : liste}
+ self.parent.ajouteDictMCVal(dicoFile)
# D.2. InformationSolverCommande : arguments, etc
#-------------------------------------------------------------------------
# . 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
+# dico = { "file_out" : (1, "-fic_de_aster_vers_ot"),
+# "variable_in" : (1, "-variable") }
+# self.parent.InformationSolverCommande["Code_Aster"] = dico
+
+
+ def enrichitListeVariables(self) :
+ # parametres par defaut pour chaque variable
+ #--------------------------------------------
+ dico_in = { "Regexp" : '"^" , "Name", "(.*)= *[0-9eE.+-]+([)]?;?)$"',
+ "Format" : '"Name", "\\1=%20.13G\\2"'
+ }
+ dico_out = { "Regexp" : '"(.*)"' }
+ self.parent.ajouteInfoVariables(dico_in,dico_out)
+
+class MonSTDGenerateur(STDGenerateur) :
def CreeResu (self) :
#------------------
. Resultats :
. Ecriture des odres d'impression.
'''
- Algorithm = str (self.parent.dictMCVal["Algorithm"])
+ if self.DictMCVal.has_key("Analysis"):
+ self.Analysis = str(self.DictMCVal["Analysis"])
+ else :
+ self.Analysis = None
+ self.fic_resu_OpenTURNS = "fic_resu_OpenTURNS_glop"
+ Algorithm = str (self.DictMCVal["Algorithm"])
texte = "\n\n# Le resultat\n"
texte += DecalSTDsaut + NomResu + " = " + NomAlgo + ".getResult()"
texte += DecalSTDsaut + "###" + "print " + NomResu
# Particularites des algorithmes de fiabilite
- if self.parent.Analysis in ( "Reliability", ) :
+ if self.Analysis in ( "Reliability", ) :
texte += DecalSTDsaut + "aux = " + NomResu + ".getIsStandardPointOriginInFailureSpace()"
texte += DecalSTDsaut + "if aux :"
texte += DecalSTDsaut + DecalSTD + "texte_bis = \"est\""
l_aux.append("PhysicalSpaceDesignPoint")
l_aux.append("ImportanceFactors")
texte += DecalSTDsaut + "l_aux_var = []"
- for DictVariable in self.parent.ListeVariables :
+ for DictVariable in self.ListeVariables :
if ( DictVariable["Type"] == "in" ) :
texte += DecalSTDsaut + "l_aux_var.append(\"" + DictVariable["Name"] + "\")"
texte += DecalSTDsaut + "l_aux = []"
# Particularites des algorithmes de simulation
- if self.parent.Analysis in ( "Simulation", ) :
+ if self.Analysis in ( "Simulation", ) :
l_aux = [ ("Probabilite de defaillance", "ProbabilityEstimate") ]
l_aux.append ( ("Variance", "VarianceEstimate") )
l_aux.append ( ("Nombre d\'iterations", "OuterSampling") )
+ 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"]
+ if self.DictMCVal.has_key("ConfidenceIntervalProbability") :
+ aux = self.DictMCVal["ConfidenceIntervalProbability"]
texte += DecalSTDsaut + "proba = " + NomResu + ".getProbabilityEstimate()"
texte += DecalSTDsaut + "t_aux = "
if ( type(aux) is type(0.) ) :
# 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 = open(\"" + self.fic_resu_OpenTURNS + "\", \"w\")"
texte += DecalSTDsaut + "file_resu.write(text_resu)"
texte += DecalSTDsaut + "file_resu.close()"
texte += DecalSTDsaut + "probability = " + NomResu + ".getEventProbability()"
'''
Classe generale du generateur
- dictMCVal : dictionnaire des mots-cles
+ 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
+ DictLois : dictionnaires des lois
'''
- def __init__ (self, dictMCVal, ListeVariables, DictSup ) :
+ def __init__ (self, DictMCVal, ListeVariables, DictLois ) :
+ #---------------------------------------------------------#
self.ListeVariables = ListeVariables
- self.DictSup = DictSup
- self.dictMCVal = dictMCVal
- self.InformationSolver = {}
- self.InformationSolverVariable = {}
- self.InformationSolverFile = {}
- self.InformationSolverCommande = {}
- self.fic_resu_OpenTURNS_defaut = None
-
+ self.ListeVariablesIn = []
+ self.DictLois = DictLois
+ self.DictMCVal = DictMCVal
+ self.DictTypeVar = {}
+ self.nbVarIn = 0
self.creeInfoVar()
- self.creeInfoSolver()
- if dictMCVal.has_key("Analysis"):
- self.Analysis = str(dictMCVal["Analysis"])
-
+ #
+ # On charge eventuellement le Solver par defaut
+ # et les valeurs par defaut du Solver (dans l init)
+ #
+ try :
+ #if 1 :
+ Solver = self.DictMCVal["PhysicalSolver"]
+ import_name = "Defaut"+Solver
+ self.module = __import__( import_name, globals(), locals() )
+ monDefaut = self.module.Defaut( self )
+ #else :
+ except:
+ self.module = None
+
+
+ def getSTDGenerateur(self) :
+ #--------------------------#
+ try :
+ gener = self.module.__dict__["MonSTDGenerateur"]
+ monSTDGenerateur=gener( self.DictMCVal, self.ListeVariablesIn, self.DictLois )
+ except :
+ from OpenturnsSTD import STDGenerateur
+ monSTDGenerateur = STDGenerateur( self.DictMCVal, self.ListeVariablesIn, self.DictLois )
+ return monSTDGenerateur
+
+ def getXMLGenerateur(self) :
+ #--------------------------#
+ try :
+ gener = self.module.__dict__["MonXMLGenerateur"]
+ monXMLGenerateur=gener( self.DictMCVal, self.ListeVariables, self.DictLois )
+ except :
+ from OpenturnsXML import XMLGenerateur
+ monXMLGenerateur = XMLGenerateur( self.DictMCVal, self.ListeVariables, self.DictLois )
+ return monXMLGenerateur
+
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.
+ On repere les variables in/out et on les numerote.
"""
- # 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
+ liste = []
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])
-
+ if not DictVariable.has_key("Type") : DictVariable["Type"] = "in"
+ self.DictTypeVar[num] = DictVariable["Type"]
+ if DictVariable["Type"] == "in" :
+ self.nbVarIn = self.nbVarIn + 1
+ self.ListeVariablesIn.append( DictVariable )
+ liste.append( DictVariable )
+ num = num + 1
+ self.ListeVariables = liste
+
+
+ def ajouteDictMCVal(self, dicoPlus) :
+ #-----------------------------------#
+ # Appele par le classe Defaut du python specifique au code (exple DefautASTER.py)
+ # enrichit self.DictMCVal avec les valeurs donnees dans dicoPlus
+ # si elles ne sont pas deja dans le dictionnaire
+
+ for clef in dicoPlus.keys():
+ if not self.DictMCVal.has_key(clef) :
+ self.DictMCVal[clef] = dicoPlus[clef]
+
+ def ajouteInfoVariables (self, dicoVariablesIn, dicoVariablesOut) :
+ #-----------------------------------------------------------------#
+ # Appele par le classe Defaut du python specifique au code (exple DefautASTER.py)
+ # met a jour les dictionnaires qui decrivent les variables (regexp par exemple)
+ liste=[]
+ num = 0
+ for dictVariable in self.ListeVariables:
+ if self.DictTypeVar[num] == "in" :
+ dico = dicoVariablesIn
+ else :
+ dico = dicoVariablesOut
+ for nouvelleVariable in dico.keys() :
+ if not dictVariable.has_key(nouvelleVariable):
+ dictVariable[nouvelleVariable] = dico[nouvelleVariable]
+ liste.append( dictVariable )
+ num = num + 1
__revision__ = "V1.0"
import os
-import OpenturnsBase
#=============================================
-# G. La classe de creation du fichier STD
+# La classe de creation du fichier STD
#=============================================
-class STDGenerateur (OpenturnsBase.Generateur) :
+class STDGenerateur :
'''
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 __init__ (self, DictMCVal, ListeVariables, DictLois ) :
+ #---------------------------------------------------------#
+
+ self.NomAlgo = "myAlgo"
+ self.DictMCVal = DictMCVal
+ self.ListeVariables = ListeVariables
+ self.DictLois = DictLois
+
+ self.ListeOrdreMCReliability = (
+ "MaximumIterationsNumber",
+ "MaximumAbsoluteError",
+ "RelativeAbsoluteError",
+ "MaximumConstraintError",
+ "MaximumResidualError",
+ )
+ self.ListeOrdreMCDirectionalSampling = (
+ "RootStrategy",
+ "SamplingStrategy",
+ )
+ self.ListeOrdreMCParametresAlgo = (
+ "BlockSize",
+ "MaximumCoefficientOfVariation",
+ )
+ self.ListeOrdreImportanceSampling = (
+ "ImportanceSampling_BlockSize",
+ "ImportanceSampling_MaximumCoefficientOfVariation",
+ "ImportanceSampling_MaximumOuterSampling",
+ )
+
+ # Ce dictionnaire contient la liste de tous les parametres possibles pour chaque loi
+ # Les parametres qui n'apparaissent pas ne pourront pas etre substitues dans le fichier
+ # produit (etude python), et donc n'apparaitront pas.
+ self.listeParamLoi = {
+ "Beta" : ["Mu", "Sigma", "T", "R", "A", "B" ],
+ "Exponential" : ["Lambda", "Gamma" ],
+ "Gamma" : ["K", "Mu", "Sigma", "Lambda", "Gamma" ],
+ #"Geometric" : ["P", ],
+ "Gumbel" : ["Alpha","Beta","Mu","Sigma" ],
+ #"Histogram" : ["Sup", "Values" ],
+ "LogNormal" : ["MuLog", "SigmaLog", "Mu", "Sigma", "SigmaOverMu", "Gamma", ],
+ "Logistic" : [ "Alpha", "Beta" ],
+ #"MultiNomial" : [ "N", "Values" ],
+ "Normal" : ["Mu", "Sigma" ],
+ "Poisson" : [ "Lambda", ],
+ "Student" : [ "Mu", "Nu" ],
+ "Triangular" : [ "A", "M", "B" ],
+ "TruncatedNormal" : [ "MuN", "SigmaN", "A", "B" ],
+ "Uniform" : [ "A", "B" ],
+ #"UserDefined" : [ "Values", ],
+ "Weibull" : [ "Alpha", "Beta", "Mu", "Sigma", "Gamma" ],
+ }
+
+ # Ce dictionnaire contient, pour chaque loi qui possede plusieurs parametrages possibles,
+ # la correspondance entre le parametrage et son "numero" pour Open TURNS.
+ self.listeParamLoiSettings = {
+ "Beta" : { "RT" : "0", "MuSigma" : "1" }, \
+ "Gamma" : { "KLambda" : "0", "MuSigma" : "1" }, \
+ "Gumbel" : { "AlphaBeta" : "0", "MuSigma" : "1" }, \
+ "LogNormal" : { "MuSigmaLog" : "0", "MuSigma" : "1", "MuSigmaOverMu" : "2" }, \
+ "Weibull" : { "AlphaBeta" : "0", "MuSigma" : "1" }, \
+ }
+
+
def CreeSTD (self) :
#------------------
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.CreeAnalyse()
+ self.texte += self.CreeResu()
self.texte += self.CreeTexteFin()
return self.texte
- def CreeEntete (self) :
- #------------------
- '''
- L'entete :
- . Donnees :
- . Resultats :
- '''
+# ______________________________________
+#
+# Methodes liees a la creation de la partie Analayse
+# Si le mot clef Analyse existe la methode portant le meme nom va etre appele
+# Exple : si self.DictMCVal["Analysis"]=="Reliability" on appelle la methode Reliability(self)
+#
+ def CreeAnalyse (self) :
+ #----------------------
+ # Appelee par CreeSTD
+ texte=""
+ if self.DictMCVal.has_key("Analysis"):
+ texte += apply( STDGenerateur.__dict__[self.DictMCVal["Analysis"]], (self,) )
+ return texte
- 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"
+ def Reliability (self) :
+ #------------------------
+ # Appelee eventuellement par CreeAnalyse
+ texte = self.CreeEvent()
+ texte += "\n# La methode\n\n"
+ if not self.DictMCVal.has_key("Method"):
+ print 'Attention Mot Clef "Method" non renseigne'
+ return texte
+
+ texte += " myMethod = "+ self.DictMCVal["Method"] + "()\n"
+ texte += " myMethod.setSpecificParameters( " + self.DictMCVal["Method"] + "SpecificParameters() )\n"
+
+ for MC in self.ListeOrdreMCReliability :
+ if self.DictMCVal.has_key(MC) and self.DictMCVal[MC] != None :
+ texte += " myMethod.set"+ MC +"( " + str(self.DictMCVal[MC]) + " )\n\n "
+
+ texte += "\n# L'algorithme\n\n"
+ if not self.DictMCVal.has_key("Algorithm"):
+ print 'Attention Mot Clef "Algorithm" non renseigne'
+ return texte
+ texte += " " + self.NomAlgo + " = " + str (self.DictMCVal["Algorithm"])
+ texte += "( NearestPointAlgorithm(myMethod), myEvent, myPhysicalStartingPoint )\n"
+ texte += " " + self.NomAlgo + ".run()\n "
+
+ if self.DictMCVal.has_key("ImportanceSampling") and self.DictMCVal["ImportanceSampling"]=="yes" :
+ texte += self.ImportanceSampling()
+ return texte
+
+ def Simulation (self) :
+ #------------------------
+ # Appelee eventuellement par CreeAnalyse
+ texte = self.CreeEvent()
+ texte += "\n# L'algorithme\n\n"
+ if not self.DictMCVal.has_key("Algorithm"):
+ print 'Attention Mot Clef "Algorithm" non renseigne'
+ return texte
+ texte += " " + self.NomAlgo + " = " + str (self.DictMCVal["Algorithm"])
+ texte += "( myEvent )\n"
+ if self.DictMCVal["Algorithm"] == "DirectionalSampling" :
+ texte += self.DirectionalSampling()
+ texte += self.ParametresAlgo()
+ texte += " " + self.NomAlgo + ".run() "
+ return texte
+
+
+ def DirectionalSampling (self) :
+ #-------------------------------
+ # Appelee eventuellement par Simulation
+ texte = ""
+ for MC in self.ListeOrdreMCDirectionalSampling :
+ if self.DictMCVal.has_key(MC) and self.DictMCVal[MC] != None :
+ texte += apply(STDGenerateur.__dict__[self.DictMCVal[MC]], (self,))
+ return texte
+
+ def RootStrategy(self):
+ #----------------------
+ # Appelee eventuellement par DirectionalSampling
+ texte = " myRoot = " + self.DictMCVal["RootStrategy"] + "()\n"
+ if self.DictMCVal.has_key("Solver") and (self.DictMCVal["Solver"] != None) :
+ texte += " mySolver = " + self.DictMCVal["Solver"] + "() \n"
+ texte += " myRoot.setSolver( Solver( mySolver ) ) \n"
+ texte += " " + self.NomAlgo + ".setRootStrategy( RootStrategy( myRoot )) \n"
+ return texte
+
+ def SamplingStrategy(self):
+ #--------------------------
+ # Appelee eventuellement par DirectionalSampling
+ texte += " mySampling = " + self.DictMCVal["SamplingStrategy"] + "()\n"
+ texte += " mySampling.setSamplingStrategy( SamplingStrategy( mySampling ) )\n"
+ return texte
+
+
+ def QuadraticCumul (self) :
+ #--------------------------
+ # Appelee eventuellement par CreeAnalyse
+ texte = "\n# Cumul quadratique\n\n"
+ texte += " myQuadraticCumul = QuadraticCumul( myRandomVector_out)\n\n"
+ texte += " firstOrderMean = myQuadraticCumul.getMeanFirstOrder()\n"
+ texte += " secondOrderMean = myQuadraticCumul.getMeanSecondOrder()\n"
+ texte += " covariance = myQuadraticCumul.getCovariance()\n"
+ texte += " importanceFactors = myQuadraticCumul.getImportanceFactors()\n"
+ return texte
+
+ def CreeEvent (self) :
+ #------------------
+ # Appelee eventuellement par Simulation et Reliability
+ texte = "\n# L'evenement\n\n"
+ if not self.DictMCVal.has_key("Threshold") or not self.DictMCVal.has_key("ComparisonOperator"):
+ print 'Attention Mot Clef "Threshold" ou "ComparisonOperator" non renseigne'
+ return texte
+ texte += " seuil = " +str (self.DictMCVal["Threshold"]) + "\n"
+ texte += " myEvent = Event(myRandomVector_out,"
+ texte += "ComparisonOperator(" + str (self.DictMCVal["ComparisonOperator"]) + "()), seuil) \n"
return texte
+ def ParametresAlgo( self ):
+ #---------------------------
+ # Appelee par Simulation
+
+ texte += " nbMaxOutSampling = "
+
+ if self.DictMCVal["MaximumOuterSamplingType"] == "UserDefined" :
+ texte += str(self.DictMCVal["MaximumOuterSampling"])
+
+ elif self.DictMCVal["MaximumOuterSamplingType"] == "Wilks" :
+ texte += "Wilks.ComputeSampleSize( " + str(self.DictMCVal["Wilks_Alpha"]) + ", " \
+ + str(self.DictMCVal["Wilks_Beta"]) + ", " + str(self.DictMCVal["Wilks_I"]) + " )"
+ texte += '\n print "MaximumOuterSampling = ", nbMaxOutSampling, "\n" \n'
+
+ texte += " " + NomAlgo + ".setMaximumOuterSampling(nbMaxOutSampling)"
+ for MC in self.ListeOrdreMCParametresAlgo :
+ if self.DictMCVal.has_key(MC) and self.DictMCVal[MC] != None :
+ texte += " myMethod.set"+ MC +"(" + str(self.DictMCVal[MC]) + ")\n\n "
+
+# _____________________________________
+
def CreeRandomGenerator (self) :
#-------------------------------
- '''
- L'initialisation du generateur aleatoire
- '''
- texte = ""
- if self.dictMCVal.has_key("RandomGeneratorSeed") :
+ # Appelee par CreeSTD
+ 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"]
+ texte += " RandomGenerator().SetSeed(%d)\n" % self.DictMCVal["RandomGeneratorSeed"]
return texte
def CreeFunction (self) :
#-------------------------
+ # Appelee par CreeSTD
'''
La fonction :
- . Donnees :
- . Resultats :
- . Remarque : le nom 'solver' est en dur ici. Il doit imperativement correspondre
+ 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
+ texte += ' dim = myFunction.getInputNumericalPointDimension()\n'
return texte
def CreeCopula (self) :
#------------------
- '''
- La copule :
- . Donnees :
- . Resultats :
- '''
+ # Appelee par CreeSTD
texte = "\n# La copule\n\n"
texte += " myCopula = IndependentCopula(dim)\n"
return texte
def CreeDistribution (self) :
#----------------------------
- '''
- La distribution :
- . Donnees :
- . Resultats :
- '''
+ # Appelee par CreeSTD
texte = "\n# La distribution\n\n"
texte += " myDistribution = ComposedDistribution(myCollection, Copula(myCopula))\n"
return texte
def CreeRandomVector (self) :
#----------------------------
- '''
- Le Random Vector :
- . Donnees :
- . Resultats :
- '''
+ # Appelee par CreeSTD
texte = "\n# Le Random Vector\n\n"
texte += " myRandomVector_in = RandomVector(Distribution(myDistribution))\n"
- texte += " myRandomVector_out = RandomVector(myFunction,myRandomVector_in )\n"
+ 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", ) :
+ def ImportanceSampling (self) :
+ #-----------------------------
+ # Appele eventuellement par Reliability
-# 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 = " 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 += " 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"
+ for MC in self.ListeOrdreImportanceSampling :
+ if self.DictMCVal.has_key("MC") :
+ debut=" importanceSamplingAlgo.set"+MC.split("_")[-1]
+ texte += debut + "( " + str(self.DictMCVal[MC]) + " )\n"
+ texte += "\n importanceSamplingAlgo.run()\n\n"
self.NomAlgo = "importanceSamplingAlgo"
-
return texte
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()"
- 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) :
- #------------------------------------
+ def CreeLois (self) :
+ #------------------
'''
- La loi normale uniforme
'''
code_erreur = 0
- if ( self.loi["B"] < self.loi["A"] ) :
- code_erreur = 1
+ texte = "\n# Les lois\n\n"
+ if self.DictMCVal.has_key("Analysis") and self.DictMCVal["Analysis"] == "Reliability" :
+ texte += " myPhysicalStartingPoint = NumericalPoint(dim, 0.0)\n"
+ texte += " myCollection = DistributionCollection(dim)\n\n"
- 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 )
+ numVar = 0
+ for DictVariable in self.ListeVariables :
- return texte, Nom, code_erreur
+ boolLoiDef = True
+ if DictVariable.has_key("MarginalDistribution") and DictVariable.has_key("Name"):
+ ConceptLoi = DictVariable["MarginalDistribution"]
+ NomLoi = DictVariable["Name"]+"_Dist"
+ else :
+ boolLoiDef = False
+
+ if boolLoiDef and self.DictLois.has_key(ConceptLoi):
+ loi = self.DictLois[ConceptLoi]
+ else :
+ boolLoiDef = False
+
+ if boolLoiDef and loi.has_key("Kind") :
+ TypeLoi = loi["Kind"]
+ else :
+ boolLoiDef = False
+
+ if not boolLoiDef or TypeLoi not in self.listeParamLoi.keys() :
+ texte += " Loi " + TypeLoi +" non programmee \n"
+ numVar += 1
+ continue
+
+ ListeParametres = []
+ TexteParametres = ""
+ for Param in self.listeParamLoi[TypeLoi]:
+ if loi.has_key(Param) :
+ texte += " " + NomLoi + "_" + Param + " = " + str(loi[Param]) + "\n"
+ ListeParametres.append(NomLoi + "_" + Param)
+ TexteParametres += NomLoi + "_" + Param + ","
+
+ texte += " " + NomLoi + " = " + TypeLoi + "( "
+
+ if loi.has_key("Settings" ) and self.listeParamLoiSettings.has_key(TypeLoi) \
+ and self.listeParamLoiSettings[TypeLoi].has_key(loi["Settings"]):
+ NumParam = self.listeParamLoiSettings[TypeLoi][loi["Settings"]]
+ texte += TexteParametres + NumParam +" )\n"
+ else :
+ texte += TexteParametres[:-1] + " )\n"
+
+ texte += " " + NomLoi + '.setName( "'+DictVariable["Name"] +'" )\n'
+ texte += " myCollection["+str(numVar)+"] = Distribution( "+NomLoi+" )\n"
+
+ if self.DictMCVal["Analysis"] == "Reliability" :
+ texte += " myPhysicalStartingPoint["+str(numVar)+"] = "
+ if DictVariable.has_key("PhysicalStartingPoint") :
+ texte += str(DictVariable["PhysicalStartingPoint"]) +"\n\n"
+ else :
+ texte += NomLoi+".computeQuantile( 0.5 )[0]\n\n"
- def UserDefined (self, NomDsOpenTurns) :
- #---------------------------------------
- '''
- La loi histogramme
- '''
- code_erreur = 1
- texte = "Loi definie par l'utilisateur non programmee."
+ numVar += 1
+ return texte
-### texte, Nom = self.loi_commun ( NomDsOpenTurns, "UserDefined", l_parametres_loi, l_mots_cles )
- return texte, Nom, code_erreur
+# _____________________________________________________
- def Weibull (self, NomDsOpenTurns) :
- #------------------------------------
+ def CreeEntete (self) :
+ #------------------
'''
- La loi triangulaire
+ Entete :
'''
- 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
+ texte = "#!/usr/bin/env python\n"
+ texte += "# -*- coding: iso-8859-1 -*-\n"
+ texte += "import sys\n"
+ texte += "import os\n"
+ if self.DictLois.has_key("dir_openturns_python") :
+ texte += "sys.path.append(\"" + self.DictLois["dir_openturns_python"] + "\")\n"
+ if self.DictLois.has_key("DTDDirectory") :
+ texte += "os.environ[\"OPENTURNS_WRAPPER_PATH\"] = \".:" + self.DictLois["DTDDirectory"] + "\"\n"
+ texte += "from openturns import *\n"
+ texte += "error_message = None\n"
+ texte += "try : \n"
+ return texte
def CreeTexteFin(self) :
#------------------------------------
texte += ' print texte"\n'
texte += "sys.exit(error_message)\n"
return texte
+
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
+# Les variables
#---------------------
# OrdreVariable contient l'ordre des MC pour definir une variable en XML
# 0 : debut de ligne
# 1 : fin de ligne
# 2 : code : 0 : facultatif, 1 : obligatoire
+# Type est sur la meme ligne que Name
-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) }
+OrdreVariable = ( 'Name', 'Type', 'Comment', 'Unit', 'Regexp', 'Format' )
+dictMCXML = { "Name" : ( ' <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
+# 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,
# 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
-#-------------------------------------
+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,
+ ),
+ }
+
+# 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
# 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
+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 ),
+ }
+
+# 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,
# 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)}
+OrdreExchangeFile = ( 'Id', 'Type', 'Name', 'Path', 'Subst' )
+dictFilXML = { "Id" : ( '\n <file id="', '">' ),
+ "Type" : ( ' type="' , '">' ),
+ "Name" : ( '\n <name>' , '</name>' ),
+ "Path" : ( '\n <path>' , '</path>' ),
+ "Subst" : ( '\n <subst>' , '</subst>' ),
+ }
-#=============================================
-# F. La classe de creation du fichier XML
-#=============================================
+#==========================
+# La classe de creation XML
+#==========================
-class XMLGenerateur (OpenturnsBase.Generateur) :
+class XMLGenerateur :
'''
Generation du fichier XML
'''
- def __init__ (self, dictMCVal, ListeVariables, DictSup) :
- #-------------------------------------------------------
- OpenturnsBase.Generateur.__init__ (self, dictMCVal, ListeVariables, DictSup)
- self.ListeFiles=[]
+ def __init__ (self, DictMCVal, ListeVariables, DictLois ) :
+ #---------------------------------------------------------#
+ self.ListeFiles = []
+ self.DictMCVal = DictMCVal
+ self.ListeVariables = ListeVariables
+ self.DictLois = DictLois
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.CreeWrapperAndPath()
+ self.texte += self.CreeVariables()
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 :
+ La variable DTDDirectory doit etre dans DictMCVal
'''
-
- 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")
+ #PN a faire : recuperer DTDDirectory dans editeur.ini
+ texte = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n"
+ if self.DictMCVal.has_key("DTDDirectory") :
+ aux = os.path.join(self.DictMCVal["DTDDirectory"], "wrapper.dtd")
texte += "<!DOCTYPE wrapper SYSTEM \"" + aux + "\">\n"
+ texte += '\n<wrapper>\n'
+ texte += '\n <library>\n\n'
return texte
- def CreePath (self) :
- #------------------
- '''
- Path
- '''
- texte = TexteXMLPath
- try :
- texte += self.dictMCVal["WrapperPath"]
- except :
+ def CreeWrapperAndPath (self) :
+ #-----------------------------#
+ texte = ' <!-- The path of the shared object -->\n'
+ texte += ' <path>'
+ if self.DictMCVal.has_key("WrapperPath") :
+ texte += self.DictMCVal["WrapperPath"]
+ else :
print "*********************************************"
print "* ERREUR GENERATION XML *"
print "* champ WrapperPath non rempli *"
print "*********************************************"
- texte += TexteXMLPathFIN
+ texte += '</path>\n\n\n'
+
return texte
- def CreeVariable (self) :
- #---------------------
- '''
- Chacune des variables
- '''
+ def CreeVariables (self) :
+ #------------------------#
+ texte =' <!-- This section describes all exchanges data between the wrapper and the platform -->\n'
+ texte +=' <description>\n\n'
+ texte +=' <!-- Those variables are substituted in the files above -->\n'
+ texte +=' <!-- The order of variables is the order of the arguments of the function -->\n\n'
+ texte += ' <variable-list>'
+
numvar = 0
- texte = TexteXMLVarLi
for DictVariable in self.ListeVariables :
- texte += TexteXMLVar_1 + str(numvar) + TexteXMLVar_2
+ texte += "\n <!-- The definition of variable # "+ str(numvar) + " -->\n"
for MC in OrdreVariable :
if DictVariable.has_key(MC) :
- texte += dictMCXML[MC][0]+DictVariable[MC]+dictMCXML[MC][1]
+ texte += dictMCXML[MC][0] + DictVariable[MC] + dictMCXML[MC][1]
else :
if dictMCXML[MC][2] :
print "**************************************************"
print "**************************************************"
texte += ' </variable>\n'
numvar += 1
- texte += TexteXMLVarLiFin
+ texte += '\n </variable-list>\n'
+ texte += ' <!-- End of variable description -->\n'
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]
+ if self.DictMCVal.has_key(MC) :
+ texte += dictLibXML[MC][1] + self.DictMCVal[MC] + dictLibXML[MC][3]
else :
- texte += dictLibXML[MC][2]+dictLibXML[MC][3]
+ texte += dictLibXML[MC][2] + dictLibXML[MC][3]
if dictLibXML[MC][4] :
print "**************************************************"
print "* ERREUR GENERATION XML *"
print "* champ obligatoire non rempli pour wrapper *"
print "**************************************************"
+ texte += ' </description>\n\n'
+ texte += ' </library>\n'
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
+ texte = '\n <external-code>\n'
+ texte += '\n <!-- Those data are external to the platform (input files, etc.)-->\n'
+ texte += ' <data>\n'
+
+ if self.DictMCVal.has_key("exchange_file") :
+ for dico in self.DictMCVal["exchange_file"] :
+ texte += "\n <!-- The definition of file -->"
+ for MC in OrdreExchangeFile :
+ if dico.has_key(MC) :
+ texte += dictFilXML[MC][0] + dico[MC] + dictFilXML[MC][1]
+ texte += "\n </file>\n"
+ texte += '\n </data>\n'
return texte
def CreeWrapMode (self) :
- #----------------------
+ #-----------------------#
'''
WrapMode
'''
- texte = TexteXMLWrapM
+ texte = '\n <!-- Transfert data mode through Wrapper -->'
+
for MC in OrdreWrapMode :
- if self.dictMCVal.has_key(MC) :
- texte += dictWrMXML[MC][0]+self.dictMCVal[MC]+dictWrMXML[MC][1]
+ 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]
+ 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
+ texte += ' </wrap-mode>\n\n'
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
+ texte = ' <!-- Command -->\n'
+ texte += ' <command>'
+ if self.DictMCVal.has_key("Command") :
+ texte += self.DictMCVal["Command"]
+ if self.DictMCVal.has_key("ArguCommande") :
+ for argument in self.DictMCVal[ArguCommande] :
+ texte += " " + argument
+ texte += "\n"
else :
texte += '# no command'
- texte += TexteXMLCommFIN
+ texte +='</command>\n'
+ texte +='\n </external-code>\n'
+ texte +='\n</wrapper>\n'
return texte
-
import types,string,re
from generator_python import PythonGenerator
-from OpenturnsXML import XMLGenerateur
-from OpenturnsSTD import STDGenerateur
+from OpenturnsBase import Generateur
+#from OpenturnsXML import XMLGenerateur
+#from OpenturnsSTD import STDGenerateur
def entryPoint():
"""
return s
def generETAPE(self,obj):
- if obj.nom == "MarginalDistribution" :
+ if obj.nom == "DISTRIBUTION" :
self.TraiteMCSIMP=0
self.dictTempo={}
s=PythonGenerator.generETAPE(self,obj)
- if obj.nom == "MarginalDistribution" :
+ if obj.nom == "DISTRIBUTION" :
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)
+ #print "IDM: genereXML dans generator_openturns.py"
+ if self.listeFichiers != [] :
+ self.dictMCVal["exchange_file"]=self.listeFichiers
+ MonBaseGenerateur=Generateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
+ MonGenerateur=MonBaseGenerateur.getXMLGenerateur()
#try :
if 1== 1 :
self.texteXML=MonGenerateur.CreeXML()
self.texteXML="Il y a un pb a la Creation du XML"
def genereSTD(self):
- MonGenerateur=STDGenerateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
+ MonBaseGenerateur=Generateur(self.dictMCVal, self.listeVariables, self.dictMCLois)
+ MonGenerateur=MonBaseGenerateur.getSTDGenerateur()
#try :
if 1== 1 :
self.texteSTD=MonGenerateur.CreeSTD()
#except :
else :
- self.texteSTD="Il y a un pb a la Creation du STD"
+ self.texteSTD="Il y a un pb a la Creation du STD"
def getOpenturnsXML(self):
return self.texteXML
