From: Pascale Noyret Date: Mon, 18 Feb 2008 13:52:30 +0000 (+0000) Subject: *** empty log message *** X-Git-Tag: V1_14_OT_1_2~8 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=fec7f977d5eb376edf1adfdaae190fb48d01697b;p=modules%2Feficas.git *** empty log message *** --- diff --git a/Editeur/configuration.py b/Editeur/configuration.py index 1bdfa20d..a0c3f474 100644 --- a/Editeur/configuration.py +++ b/Editeur/configuration.py @@ -244,7 +244,8 @@ class CONFIG(CONFIGbase): 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') diff --git a/Editeur/session.py b/Editeur/session.py index 2ecc8dc7..235e9a4d 100644 --- a/Editeur/session.py +++ b/Editeur/session.py @@ -47,7 +47,6 @@ except: 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. @@ -204,6 +203,7 @@ def print_d_env(): 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', diff --git a/InterfaceQT/qtEficas.py b/InterfaceQT/qtEficas.py index 2933987d..3badffe5 100644 --- a/InterfaceQT/qtEficas.py +++ b/InterfaceQT/qtEficas.py @@ -219,7 +219,7 @@ if __name__=='__main__': # 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 diff --git a/InterfaceTK/bureau.py b/InterfaceTK/bureau.py index 13a3ceb7..8423bbda 100644 --- a/InterfaceTK/bureau.py +++ b/InterfaceTK/bureau.py @@ -336,6 +336,8 @@ class BUREAU: 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'): @@ -354,7 +356,6 @@ class BUREAU: 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 diff --git a/Openturns/Open_Cata_IDM_V7.py b/Openturns/Open_Cata_IDM_V7.py new file mode 100644 index 00000000..2381c33b --- /dev/null +++ b/Openturns/Open_Cata_IDM_V7.py @@ -0,0 +1,1221 @@ +# -*- 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 + diff --git a/Openturns/editeur.ini b/Openturns/editeur.ini index f8c8a518..65eca18b 100644 --- a/Openturns/editeur.ini +++ b/Openturns/editeur.ini @@ -4,27 +4,29 @@ import prefs 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'), ) diff --git a/generator/DefautASTER.py b/generator/DefautASTER.py index de676e30..97e22263 100644 --- a/generator/DefautASTER.py +++ b/generator/DefautASTER.py @@ -42,23 +42,25 @@ NomSampling = "mySampling" 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", @@ -67,41 +69,18 @@ class Defaut(STDGenerateur, XMLGenerateur) : "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 #------------------------------------------------------------------------- @@ -114,11 +93,22 @@ class Defaut(STDGenerateur, XMLGenerateur) : # . 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) : #------------------ @@ -129,7 +119,12 @@ class Defaut(STDGenerateur, XMLGenerateur) : . 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 @@ -137,7 +132,7 @@ class Defaut(STDGenerateur, XMLGenerateur) : # 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\"" @@ -155,7 +150,7 @@ class Defaut(STDGenerateur, XMLGenerateur) : 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 = []" @@ -171,7 +166,7 @@ class Defaut(STDGenerateur, XMLGenerateur) : # 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") ) @@ -180,8 +175,8 @@ class Defaut(STDGenerateur, XMLGenerateur) : + 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.) ) : @@ -209,12 +204,8 @@ class Defaut(STDGenerateur, XMLGenerateur) : # 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()" diff --git a/generator/OpenturnsBase.py b/generator/OpenturnsBase.py index fee46c7d..316a34eb 100644 --- a/generator/OpenturnsBase.py +++ b/generator/OpenturnsBase.py @@ -26,206 +26,95 @@ class Generateur : ''' 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 diff --git a/generator/OpenturnsSTD.py b/generator/OpenturnsSTD.py index 7f1ae0e9..9fb4b234 100644 --- a/generator/OpenturnsSTD.py +++ b/generator/OpenturnsSTD.py @@ -9,25 +9,81 @@ Ce module contient le generateur Etude pour Openturns __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) : #------------------ @@ -41,108 +97,167 @@ class STDGenerateur (OpenturnsBase.Generateur) : 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 @@ -150,11 +265,7 @@ class STDGenerateur (OpenturnsBase.Generateur) : 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 @@ -162,128 +273,22 @@ class STDGenerateur (OpenturnsBase.Generateur) : 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" @@ -291,29 +296,20 @@ class STDGenerateur (OpenturnsBase.Generateur) : 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()" @@ -322,352 +318,92 @@ class STDGenerateur (OpenturnsBase.Generateur) : - 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) : #------------------------------------ @@ -680,3 +416,4 @@ class STDGenerateur (OpenturnsBase.Generateur) : texte += ' print texte"\n' texte += "sys.exit(error_message)\n" return texte + diff --git a/generator/OpenturnsXML.py b/generator/OpenturnsXML.py index 4a64b75e..7452d1fa 100644 --- a/generator/OpenturnsXML.py +++ b/generator/OpenturnsXML.py @@ -6,54 +6,7 @@ Ce module contient le generateur XML pour Openturns """ -import OpenturnsBase - - -#==================================================== -# B. Preparation du fichier XML -#==================================================== -# B.1. Parties du texte en dur dans le fichier XML -#------------------------------------------------- - -TexteXMLPath =' \n' -TexteXMLPath += ' ' -TexteXMLPathFIN = '\n' - -TexteXMLWrap = '\n\n' -TexteXMLWrapFin = '\n\n' - -TexteXMLLibra = '\n \n\n' -TexteXMLLibraFin = '\n \n' - -TexteXMLDescr = '\n \n' -TexteXMLDescr += ' \n' -TexteXMLDescrFin = ' \n' - -TexteXMLVarLi = '\n \n' -TexteXMLVarLi += ' \n' -TexteXMLVarLi += ' ' -TexteXMLVar_1 = "\n " -TexteXMLVarLiFin = '\n \n' -TexteXMLVarLiFin += ' \n' - -TexteXMLWrapM = '\n ' -TexteXMLWrapMFin = ' \n\n' - -TexteXMLComm = ' \n' -TexteXMLComm += ' ' -TexteXMLCommFIN = '\n' - -TexteXMLExtCo = '\n \n' -TexteXMLExtCoFin = '\n \n' - -TexteXMLFile = '\n \n' -TexteXMLFile += ' \n' -TexteXMLFileFin = '\n \n' - -# B.2. Definition de composants dans le fichier XML -#-------------------------------------------------- -# B.2.1. Les variables +# Les variables #--------------------- # OrdreVariable contient l'ordre des MC pour definir une variable en XML @@ -62,29 +15,19 @@ TexteXMLFileFin = '\n \n' # 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 \n', \ - 1), - "Comment" : (' ', \ - '\n', \ - 0), - "Unit" : (' ' , \ - '\n', \ - 0), - "Regexp" : (' ' , \ - '\n', \ - 0), - "Format" : (' ' , \ - '\n', \ - 0) } +OrdreVariable = ( 'Name', 'Type', 'Comment', 'Unit', 'Regexp', 'Format' ) +dictMCXML = { "Name" : ( ' \n', 1 ), + "Comment" : ( ' ' , '\n', 0 ), + "Unit" : ( ' ' , '\n', 0 ), + "Regexp" : ( ' ' , '\n', 0 ), + "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, @@ -95,25 +38,29 @@ dictMCXML = { "Name" : ('\n ', \ - '\n ', \ - '\n ', \ - '', \ - 1), - "GradientName" : ('\n\n ', \ - '\n ', \ - '\n ', \ - '', \ - 0), - "HessianName" : ('\n\n ', \ - '\n ', \ - '\n ' , \ - '\n\n', \ - 0) } - -# B.2.3. Les communications du wrapper -#------------------------------------- +OrdreLibrary = ( 'FunctionName', 'GradientName', 'HessianName' ) +dictLibXML = { "FunctionName" : ( '\n\n ', + '\n ', + '\n ', + '', + 1, + ), + "GradientName" : ( '\n\n ', + '\n ', + '\n ', + '', + 0, + ), + "HessianName" : ( '\n\n ', + '\n ', + '\n ' , + '\n\n', + 0, + ), + } + +# 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 @@ -121,22 +68,14 @@ dictLibXML = { "FunctionName" : ('\n\n \n' + texte += ' ' + 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 += '\n\n\n' + return texte - def CreeVariable (self) : - #--------------------- - ''' - Chacune des variables - ''' + def CreeVariables (self) : + #------------------------# + texte =' \n' + texte +=' \n\n' + texte +=' \n' + texte +=' \n\n' + texte += ' ' + numvar = 0 - texte = TexteXMLVarLi for DictVariable in self.ListeVariables : - texte += TexteXMLVar_1 + str(numvar) + TexteXMLVar_2 + texte += "\n \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 "**************************************************" @@ -261,80 +176,89 @@ class XMLGenerateur (OpenturnsBase.Generateur) : print "**************************************************" texte += ' \n' numvar += 1 - texte += TexteXMLVarLiFin + texte += '\n \n' + texte += ' \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 += ' \n\n' + texte += ' \n' return texte def CreeFile (self) : - #------------------ + #-------------------# ''' Fichiers ''' - numfile = 0 - texte = TexteXMLFile - for dico in self.ListeFiles : - numfile += 1 - texte += "\n " - #file_id = dico["Id"] pn ??? inutile ?? - for MC in OrdreExchangeFile : - if dico.has_key(MC) : - texte += dictFilXML[MC][0] + dico[MC] + dictFilXML[MC][1] - texte += "\n \n" - texte += TexteXMLFileFin + texte = '\n \n' + texte += '\n \n' + texte += ' \n' + + if self.DictMCVal.has_key("exchange_file") : + for dico in self.DictMCVal["exchange_file"] : + texte += "\n " + for MC in OrdreExchangeFile : + if dico.has_key(MC) : + texte += dictFilXML[MC][0] + dico[MC] + dictFilXML[MC][1] + texte += "\n \n" + texte += '\n \n' return texte def CreeWrapMode (self) : - #---------------------- + #-----------------------# ''' WrapMode ''' - texte = TexteXMLWrapM + texte = '\n ' + 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 += ' \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 = ' \n' + texte += ' ' + 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 +='\n' + texte +='\n \n' + texte +='\n\n' return texte - diff --git a/generator/generator_openturns.py b/generator/generator_openturns.py index c0f6497e..b3118c60 100644 --- a/generator/generator_openturns.py +++ b/generator/generator_openturns.py @@ -27,8 +27,9 @@ import traceback 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(): """ @@ -98,20 +99,22 @@ class OpenturnsGenerator(PythonGenerator): 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() @@ -120,13 +123,14 @@ class OpenturnsGenerator(PythonGenerator): 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