From 0902ddf73d382e5bb9e93d632758bb5154347e3d Mon Sep 17 00:00:00 2001 From: Pascale Noyret Date: Wed, 4 Mar 2009 10:57:54 +0000 Subject: [PATCH] *** empty log message *** --- InterfaceQT4/editor.py | 31 +- InterfaceQT4/readercata.py | 6 +- Openturns_Study/OpenTURNS_Cata_Study_V4.py | 1620 ++++++++++++++++++++ Openturns_Study/catalogues_openturns.ini | 2 +- Openturns_Study/prefs.py | 6 +- 5 files changed, 1643 insertions(+), 22 deletions(-) create mode 100644 Openturns_Study/OpenTURNS_Cata_Study_V4.py diff --git a/InterfaceQT4/editor.py b/InterfaceQT4/editor.py index 77d6d821..87a94709 100644 --- a/InterfaceQT4/editor.py +++ b/InterfaceQT4/editor.py @@ -299,16 +299,18 @@ class JDCEditor(QSplitter): #------------------------------# def affiche_infos(self,message): #------------------------------# - if self.salome : - if not hasattr(self.appliEficas,'MessageLabel') : - self.appliEficas.leLayout=QDockWindow(self.appliEficas) - self.appliEficas.MessageLabel = QLabel(self.appliEficas.leLayout,"MessageLabel") - self.appliEficas.MessageLabel.setAlignment(Qt.AlignBottom) - self.appliEficas.leLayout.setWidget(self.appliEficas.MessageLabel) - self.appliEficas.moveDockWindow(self.appliEficas.leLayout,Qt.DockBottom) - self.appliEficas.MessageLabel.setText(message) - self.appliEficas.MessageLabel.show() - self.appliEficas.leLayout.show() + #PN --> devenu inutile avec QT4 + #if self.salome : + # if not hasattr(self.appliEficas,'MessageLabel') : + # self.appliEficas.leLayout=QDockWidget(self.appliEficas) + # self.appliEficas.MessageLabel = QLabel("MessageLabel",self.appliEficas.leLayout) + # self.appliEficas.MessageLabel.setAlignment(Qt.AlignBottom) + # self.appliEficas.leLayout.setAllowedAreas(Qt.BottomDockWidgetArea) + # self.appliEficas.leLayout.setWidget(self.appliEficas.MessageLabel) + # #self.appliEficas.moveDockWindow(self.appliEficas.leLayout,Qt.DockBottom) + # self.appliEficas.MessageLabel.setText(message) + # self.appliEficas.MessageLabel.show() + # self.appliEficas.leLayout.show() if self.sb: self.sb.showMessage(message)#,2000) @@ -565,18 +567,19 @@ class JDCEditor(QSplitter): #if 1 : file_homard = fn[:fn.rfind(".")] + '.conf_homard' - self.jdc_homard=self.generator.get_homard() + #self.jdc_homard=self.generator.get_homard() + self.jdc_homard="" f=open(file_homard,'w') for ligne in self.jdc_homard: f.write(ligne) f.write('\n') f.close() - except : #else : + except : pass -# if self.salome : -# self.QWParent.appli.addJdcInSalome( self.fichier) + if self.salome : + self.appliEficas.addJdcInSalome( self.fichier) # if self.code == 'ASTER': # self.QWParent.appli.createOrUpdateMesh(self) # #PN ; TODO diff --git a/InterfaceQT4/readercata.py b/InterfaceQT4/readercata.py index 8a2f645c..51cf86b9 100644 --- a/InterfaceQT4/readercata.py +++ b/InterfaceQT4/readercata.py @@ -246,8 +246,7 @@ class READERCATA: liste_choix = self.dico_catalogues.keys() liste_choix.sort() - lab=QString("Eficas V1.") - lab+=QString(version) + lab=QString(VERSION_EFICAS) lab+=QString(" pour ") lab+=QString(self.code) lab+=QString(" avec le catalogue ") @@ -262,8 +261,7 @@ class READERCATA: widgetChoix=MonChoixCata(liste_choix,self, self.appliEficas, "", True ) ret=widgetChoix.exec_() - lab=QString("Eficas V1.") - lab+=QString(version) + lab=QString(VERSION_EFICAS) lab+=QString(" pour ") lab+=QString(self.code) lab+=QString(" avec le catalogue ") diff --git a/Openturns_Study/OpenTURNS_Cata_Study_V4.py b/Openturns_Study/OpenTURNS_Cata_Study_V4.py new file mode 100644 index 00000000..bea8eb75 --- /dev/null +++ b/Openturns_Study/OpenTURNS_Cata_Study_V4.py @@ -0,0 +1,1620 @@ +# -*- coding: utf-8 -*- + +# -------------------------------------------------- +# debut entete +# -------------------------------------------------- + +#from Accas import ASSD, JDC_CATA, AU_MOINS_UN, PROC, SIMP, FACT, OPER, MACRO, BLOC, A_VALIDATOR +from Accas import * + +class loi ( ASSD ) : pass +class variable ( ASSD ) : pass + +import types +class Tuple: + def __init__(self,ntuple): + self.ntuple=ntuple + + def __convert__(self,valeur): + if type(valeur) == types.StringType: + return None + if len(valeur) != self.ntuple: + return None + return valeur + + def info(self): + return "Tuple de %s elements" % self.ntuple + + __repr__=info + __str__=info + + +#CONTEXT.debug = 1 +JdC = JDC_CATA ( code = 'OPENTURNS_STUDY', + execmodul = None, + regles = ( AU_MOINS_UN ( 'CRITERIA' ), AU_MOINS_UN ( 'MODEL' ), ), + ) # Fin JDC_CATA + +# -------------------------------------------------- +# fin entete +# -------------------------------------------------- + +LOG = PROC ( nom = "LOG", + op = None, + docu = "", + + DebugMessages = SIMP ( statut = "o", + typ = "TXM", + into = ( 'yes', 'no' ), + defaut = 'no', + fr = "Affichage du niveau de debug de la bibliotheque Open TURNS", + ang = "Open TURNS library debug level print", + ), + + WrapperMessages = SIMP ( statut = "o", + typ = "TXM", + into = ( 'yes', 'no' ), + defaut = 'no', + fr = "Affichage du niveau de wrapper de la bibliotheque Open TURNS", + ang = "Open TURNS library debug level print", + ), + + UserMessages = SIMP ( statut = "o", + typ = "TXM", + into = ( 'yes', 'no' ), + defaut = 'no', + fr = "Affichage du niveau de user de la bibliotheque Open TURNS", + ang = "Open TURNS library user level print", + ), + + InfoMessages = SIMP ( statut = "o", + typ = "TXM", + into = ( 'yes', 'no' ), + defaut = 'yes', + fr = "Affichage du niveau de info de la bibliotheque Open TURNS", + ang = "Open TURNS library info level print", + ), + + WarningMessages = SIMP ( statut = "o", + typ = "TXM", + into = ( 'yes', 'no' ), + defaut = 'yes', + fr = "Affichage du niveau de warning de la bibliotheque Open TURNS", + ang = "Open TURNS library warning level print", + ), + + ErrorMessages = SIMP ( statut = "o", + typ = "TXM", + into = ( 'yes', 'no' ), + defaut = 'yes', + fr = "Affichage du niveau de error de la bibliotheque Open TURNS", + ang = "Open TURNS library error level print", + ), + +) # Fin PROC LOG + + + + +#================================ +# 0. Definition du modele physique +#================================ + + +DETERMINISTICVARIABLE = OPER ( nom = "DETERMINISTICVARIABLE", + sd_prod = variable, + op = None, + fr = "Variable deterministe", + ang = "Deterministic variable", + + N = SIMP ( statut = 'o', + typ = "TXM", + fr = "Nom", + ang = "Name", + ), + + T = SIMP ( statut = 'o', + defaut = "in", + into = ( "in" , "out", ), + typ = "TXM", + fr = "Type", + ang = "Type", + ), + + R = SIMP ( statut = 'o', + defaut = 0, + typ = "I", + fr = "Rang", + ang = "Rank", + ), + +) # Fin OPER DETERMINISTICVARIABLE + + + +import ops +MODEL = MACRO ( nom = "MODEL", + op = None, + UIinfo = { "groupes" : ( "Gestion du travail", ) }, + fr = "Chargement du wrapper du modele physique", + ang = "Physical model wrapper load", + sd_prod = ops.INCLUDE, + op_init = ops.INCLUDE_context, + fichier_ini = 1, + + FileName = SIMP ( statut = "o", + typ = "TXM", + fr = "Nom du modele physique", + ang = "Physical model identifier", + ), + +) # Fin PROC MODEL + + + + +VARIABLE = PROC ( nom = "VARIABLE", + op = None, + docu = "", + fr = "Variable probabiliste", + ang = "Probabilistic variable", + + ModelVariable = SIMP ( statut = "o", + typ = ( variable, ), + ), + + Distribution = SIMP ( statut = "o", + typ = ( loi, ), + ), + +) # Fin PROC VARIABLE + + + + +#================================ +# 1. Definition des LOIS +#================================ + +# Nota : les variables de type OPER doivent etre en majuscules ! +# Nota : les variables de type OPER doivent etre de premier niveau (pas imbriquees dans un autre type) +DISTRIBUTION = OPER ( nom = "DISTRIBUTION", + sd_prod = loi, + op = 68, + fr = "Definitions des lois marginales utilisees par les variables d'entree", + + +#==== +# Type 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", + ), + +#==== +# Definition des parametres selon le type de la loi +#==== + + 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 + + + + 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 + + + + 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 + + + + 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 + + + + 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 + + + + HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ", + + First = SIMP ( statut = "o", + typ = "R", + max = 1, + fr = "Premier point de la distribution", + ang = "First point", + ), + + # Il faut definir une collection de couples ( x,p ) + Values = SIMP ( statut = 'o', + typ = Tuple(2), + max = '**', + fr = "Liste de couples (point,probabilite)", + ang = "(point,probabiblity) couple list", + validators=VerifTypeTuple(('R','R')), + ), + + ), # Fin BLOC HISTOGRAM + + + + 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 + + + + 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 + + + + MULTINOMIAL = BLOC ( condition = " Kind in ( 'MultiNomial', ) ", + + N = SIMP ( statut = "o", + typ = "I", + max = 1, + fr = "Dimension de la loi", + ang = "Distribution dimension", + ), + + # Il faut un vecteur P de taille N + Mu = SIMP ( statut = 'o', + typ = 'R', + max = '**', + ), + + ), # Fin BLOC MULTINOMIAL + + + + 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 + + + + 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 + + + + 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 + + + + 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 + + + + 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 + + + + 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 + + + + 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 + + + + 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 + + + + + + + +#================================ +# 3. Definition de l'etude +#================================ + +# Nota : les variables de type PROC doivent etre en majuscules ! +CRITERIA = PROC ( nom = "CRITERIA", + op = None, + docu = "", + fr = "Mise en donnee pour le fichier de configuration de OPENTURNS.", + ang = "Writes the configuration file for OPENTURNS.", + + + + Type = SIMP ( statut = "o", + typ = "TXM", + into = ( "Min/Max", "Central Uncertainty", "Threshold Exceedence" ), + fr = "Type d'Analyse", + ang = "Analysis", + ), + + + + + + + + MinMax = BLOC ( condition = " Type in ( 'Min/Max', ) ", + + Method = SIMP ( statut = "o", + typ = "TXM", + into = ( "Experiment Plane", "Random Sampling" ), + fr = "Methode", + ang = "Method", + ), + # UC 3.1.1 + ExperimentPlaneSettings = BLOC ( condition = " Method in ( 'Experiment Plane', ) ", + + ExperimentPlane = SIMP ( statut = "o", + typ = "TXM", + into = ( "Axial", "Factorial", "Composite", ), + fr = "Methode", + ang = "Method", + ), + + Levels = SIMP ( statut = "o", + typ = "R", + val_min = 0.0, + max = '**', + fr = "Nombre de niveaux dans chaque direction", + ang = "Levels in each direction", + ), + + # Scaled Vector + UnitsPerDimension = SIMP ( statut = "o", + typ = "R", + max = '**', + fr = "Unite par dimension (autant que de variables declarees)", + ang = "Units per dimension (as much as declared variables)", + ), + + # Translation Vector + Center = SIMP ( statut = "o", + typ = "R", + max = '**', + fr = "Unite par dimension", + ang = "Units per dimension", + ), + + ), # Fin BLOC ExperimentPlaneSettings + + + + RandomSamplingSettings = BLOC ( condition = " Method in ( 'Random Sampling', ) ", + + PointsNumber = SIMP ( statut = "o", + typ = "I", + val_min = 1, + fr = "Nombre de points", + ang = "Points number", + ), + + ), # Fin BLOC RandomSamplingSettings + + Result = SIMP ( statut = "o", + typ = "TXM", + into = ( "Min/Max", ), + defaut = "Min/Max", + fr = "Le minimum et le maximum", + ang = "The min and max values", + ), + + + ), # Fin BLOC MinMax + + + + + CentralUncertainty = BLOC ( condition = " Type in ( 'Central Uncertainty', ) ", + + Method = SIMP ( statut = "o", + typ = "TXM", + into = ( "Taylor Variance Decomposition", "Random Sampling" ), + fr = "Methode", + ang = "Method", + ), + + # UC 3.2. + TaylorVarianceDecompositionSettings = BLOC ( condition = " Method in ( 'Taylor Variance Decomposition', ) ", + + Result = FACT ( statut = "o", + min = 1, + max = "**", + + MeanFirstOrder = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Moyenne au premier ordre", + ang = "MeanFirstOrder", + ), + + StandardDeviationFirstOrder = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Ecart-type au premier ordre", + ang = "StandardDeviationFirstOrder", + ), + + MeanSecondOrder = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Moyenne au second ordre", + ang = "MeanSecondOrder", + ), + + ImportanceFactor = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Facteur d'importance pour variable de sortie scalaire", + ang = "ImportanceFactor", + ), + + ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ", + + NumericalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Resultats numeriques", + ang = "NumericalResults", + ), + + GraphicalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Resultats graphiques", + ang = "GraphicalResults", + ), + + ), # Fin BLOC ImportanceFactorSettings + + ), # Fin FACT Result + + ), # Fin BLOC TaylorVarianceDecompositionSettings + + + + RandomSamplingSettings = BLOC ( condition = " Method in ( 'Random Sampling', ) ", + + PointsNumber = SIMP ( statut = "o", + typ = "I", + val_min = 1, + fr = "Nombre de points", + ang = "Points number", + ), + + Result = FACT ( statut = "o", + min = 1, + max = "**", + + EmpiricalMean = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Moyenne empirique", + ang = "Empirical mean", + ), + + EmpiricalStandardDeviation = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Ecart-type empirique", + ang = "Empirical standard deviation", + ), + + EmpiricalQuantile = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Quantile empirique", + ang = "Empirical quantile", + ), + + EmpiricalQuantileSettings = BLOC ( condition = " EmpiricalQuantile in ( 'yes', ) ", + + EmpiricalQuantile_Order = SIMP ( statut = "o", + typ = 'R', + defaut = 0.95, + max = 1, + val_min = 0.0, + val_max = 1.0, + fr = "Ordre du quantile empirique", + ang = "Empirical quantile order", + ), + + ), # Fin BLOC EmpiricalQuantileSettings + + AnalysedCorrelations = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Correlations analysees", + ang = "Analysed correlations", + ), + + KernelSmoothing = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Kernel smoothing de l'echantillon", + ang = "Kernel smoothing of the sample", + ), + + ), # Fin FACT Result + + ), # Fin BLOC RandomSamplingSettings + + ), # Fin BLOC CentralUncertainty + + + + + ThresholdExceedence = BLOC ( condition = " Type in ( 'Threshold Exceedence', ) ", + + Event = FACT ( statut = "o", + min = 1, + max = 1, + + 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 FACT Event + + + Method = SIMP ( statut = "o", + typ = "TXM", + into = ( "Simulation", "Analytical" ), + fr = "Methode", + ang = "Method", + ), + + SimulationSettings = BLOC ( condition = " Method in ( 'Simulation', ) ", + + Algorithm = SIMP ( statut = "o", + typ = "TXM", + into = ( "MonteCarlo", "LHS", "ImportanceSampling" ), + fr = "Algorithme de simulation", + ang = "Simulation algorithm", + ), + + + RandomGenerator = FACT ( statut = "o", + min = 1, + max = 1, + + 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 FACT RandomGenerator + + + BlockSize = SIMP ( statut = "f", + typ = "I", + max = 1, + val_min = 1, + defaut = 1, + fr = "Nombre de calculs realises en bloc", + ang = "Number of computations as a block", + ), + + MaximumOuterSampling = SIMP ( statut = "o", + typ = "I", + max = 1, + val_min = 1, + fr = "Maximum d'iterations externes", + ang = "Maximum outer Sampling value", + ), + + MaximumCoefficientOfVariation = SIMP ( statut = "f", + typ = "R", + max = 1, + defaut = 0.1, + val_min = 0.0, + fr = " maximum ...", + ang = "Absolute maximum ...." + ), + + ImportanceSamplingSettings = BLOC ( condition = " Algorithm in ( 'ImportanceSampling', ) ", + + MeanVector = SIMP ( statut = "o", + typ = "R", + max = "**", + fr = "Moyenne", + ang = "Mean vector", + ), + + Correlation = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'Independent', 'Linear' ), + defaut = 'Linear', + max = 1, + fr = "Le type de correlation entre les variables", + ang = "Correlation between variables", + ), + + ), # Fin BLOC ImportanceSamplingSettings + + Result = FACT ( statut = "o", + min = 1, + max = "**", + + Probability = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', ), + defaut = 'yes', + max = 1, + fr = "Probabiblite", + ang = "Probability", + ), + + StandardDeviation = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', ), + defaut = 'yes', + max = 1, + fr = "Ecart type", + ang = "Standard deviation", + ), + + ConfidenceInterval = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Ecart-type empirique", + ang = "Empirical standard deviation", + ), + + ConfidenceIntervalSettings = BLOC ( condition = " ConfidenceInterval in ( 'yes', ) ", + + Level = SIMP ( statut = "o", + typ = 'R', + defaut = 0.9, + max = 1, + val_min = 0.0, + val_max = 1.0, + fr = "Niveau de confiance", + ang = "Confidence level", + ), + + ), # Fin BLOC ConfidenceIntervalSettings + + VariationCoefficient = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Coefficient de variation", + ang = "VariationCoefficient", + ), + + IterationNumber = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Nombre d'iterations", + ang = "Iteration number", + ), + + ConvergenceGraph = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Graphe de convergence", + ang = "Convergence graph", + ), + + ), # Fin FACT Result + + + + ), # Fin BLOC SimulationSettings + + + + AnalyticalSettings = BLOC ( condition = " Method in ( 'Analytical', ) ", + + Approximation = SIMP ( statut = "o", + typ = "TXM", + defaut = "FirstOrder", + into = ( "FirstOrder", "SecondOrder" ), + max = 1, + fr = "Approximation", + ang = "Approximation", + ), + + OptimizationAlgorithm = SIMP ( statut = "o", + typ = "TXM", + defaut = "Cobyla", + into = ( "Cobyla", "AbdoRackwitz" ), + max = 1, + fr = "Methode d'optimisation", + ang = "Optimisation method", + ), + + + PhysicalStartingPoint = SIMP ( statut = "f", + typ = "R", + max = "**", + fr = "Point de demarrage de l'algorithme iteratif", + ang = "Initial point for iterative process", + ), + + MaximumIterationsNumber = SIMP ( statut = "f", + typ = "I", + max = 1, + val_min = 1, + fr = "Nombre maximum d iterations", + ang = "Maximum number of iterations", + ), + + + MaximumAbsoluteError = SIMP ( statut = "f", + typ = "R", + max = 1, + defaut = 1E-4, + val_min = 0.0, + fr = "Distance maximum absolue entre 2 iterations successifs", + ang = "Absolute maximum distance between 2 successive iterates", + ), + + MaximumRelativeError = SIMP ( statut = "f", + typ = "R", + max = 1, + defaut = 1E-4, + val_min = 0.0, + fr = "Distance maximum relative entre 2 iterations successives", + ang = "Relative maximum distance between 2 successive iterates", + ), + + MaximumConstraintError = SIMP ( statut = "f", + typ = "R", + max = 1, + defaut = 1E-4, + 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", + ), + + ImportanceSampling = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Tirage d'importance au point de conception", + ang = "Importance sampling at design point", + ), + + FirstOrder = BLOC ( condition = " Approximation in ( 'FirstOrder', ) ", + + Probability = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', ), + defaut = 'yes', + max = 1, + fr = "Probabiblite", + ang = "Probability", + ), + + DesignPoint = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Point de conception", + ang = "Design point", + ), + + HasoferReliabilityIndex = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Indice de fiabilite", + ang = "Reliability index", + ), + + ImportanceFactor = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Facteur d'importance pour variable de sortie scalaire", + ang = "ImportanceFactor", + ), + + ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ", + + ImportanceFactorNumericalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Resultats numeriques", + ang = "NumericalResults", + ), + + ImportanceFactorGraphicalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Resultats graphiques", + ang = "GraphicalResults", + ), + + ), # Fin BLOC ImportanceFactorSettings + + + SensitivityAnalysis = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Analyse de sensibilite", + ang = "Sensitivity analysis", + ), + + SensitivityAnalysisSettings = BLOC ( condition = " SensitivityAnalysis in ( 'yes', ) ", + + FORMEventProbabilitySensitivity = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Indice de fiabilite de Hasofer", + ang = "Hasofer reliability index", + ), + + FORMEventProbabilitySensitivitySettings = BLOC ( condition = " FORMEventProbabilitySensitivity in ( 'yes', ) ", + + FORMEventProbabilitySensitivityNumericalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Resultats numeriques", + ang = "NumericalResults", + ), + + FORMEventProbabilitySensitivityGraphicalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Resultats graphiques", + ang = "GraphicalResults", + ), + + ), # Fin BLOC FORMEventProbabilitySensitivitySettings + + HasoferReliabilityIndexSensitivity = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Indice de fiabilite de Hasofer", + ang = "Hasofer reliability index", + ), + + HasoferReliabilityIndexSensitivitySettings = BLOC ( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ", + + HasoferReliabilityIndexSensitivityNumericalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Resultats numeriques", + ang = "NumericalResults", + ), + + HasoferReliabilityIndexSensitivityGraphicalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Resultats graphiques", + ang = "GraphicalResults", + ), + + ), # Fin BLOC HasoferReliabilityIndexSettings + + ), # Fin BLOC SensitivityAnalysisSettings + + FunctionCallsNumber = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Nombre d'appels a la fonction", + ang = "Function calls number", + ), + + + ), # Fin BLOC FirstOrder + + + SecondOrder = BLOC ( condition = " Approximation in ( 'SecondOrder', ) ", + + + TvedtApproximation = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Approximation de Tvedt", + ang = "Tvedt approximation", + ), + + HohenBichlerApproximation = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Approximation de HohenBichler", + ang = "HohenBichler approximation", + ), + + BreitungApproximation = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Approximation de Breitung", + ang = "Breitung approximation", + ), + + DesignPoint = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Point de conception", + ang = "Design point", + ), + + ImportanceFactor = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Facteur d'importance pour variable de sortie scalaire", + ang = "ImportanceFactor", + ), + + ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ", + + ImportanceFactorNumericalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Resultats numeriques", + ang = "NumericalResults", + ), + + ImportanceFactorGraphicalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Resultats graphiques", + ang = "GraphicalResults", + ), + + ), # Fin BLOC ImportanceFactorSettings + + SensitivityAnalysis = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Analyse de sensibilite", + ang = "Sensitivity analysis", + ), + + SensitivityAnalysisSettings = BLOC ( condition = " SensitivityAnalysis in ( 'yes', ) ", + + HasoferReliabilityIndexSensitivity = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Indice de fiabilite de Hasofer", + ang = "Hasofer reliability index", + ), + + HasoferReliabilityIndexSensitivitySettings = BLOC ( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ", + + HasoferReliabilityIndexSensitivityNumericalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'yes', + max = 1, + fr = "Resultats numeriques", + ang = "NumericalResults", + ), + + HasoferReliabilityIndexSensitivityGraphicalResults = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Resultats graphiques", + ang = "GraphicalResults", + ), + + ), # Fin BLOC HasoferReliabilityIndexSettings + + ), # Fin BLOC SensitivityAnalysisSettings + + FunctionCallsNumber = SIMP ( statut = "o", + typ = 'TXM', + into = ( 'yes', 'no' ), + defaut = 'no', + max = 1, + fr = "Nombre d'appels a la fonction", + ang = "Function calls number", + ), + + + ), # Fin BLOC SecondOrder + + + + ), # Fin BLOC AnalyticalSettings + + + + ), # Fin BLOC ThresholdExceedence + + + +) # Fin PROC CRITERIA + + + + + + + diff --git a/Openturns_Study/catalogues_openturns.ini b/Openturns_Study/catalogues_openturns.ini index 7cd5b3c1..8185a163 100644 --- a/Openturns_Study/catalogues_openturns.ini +++ b/Openturns_Study/catalogues_openturns.ini @@ -6,7 +6,7 @@ rep_cata=os.getcwd() catalogues = ( # (code,version,catalogue,formatIn,formatOut) #('OPENTURNS_WRAPPER','V1',os.path.join(rep_cata,'OpenTURNS_Cata_Wrapper_V1.py'),'openturns_wrapper','wrapper'), - ('OPENTURNS_STUDY','V3',os.path.join(rep_cata,'OpenTURNS_Cata_Study_V3.py'),'openturns_study','wrapper'), + ('OPENTURNS_STUDY','V4',os.path.join(rep_cata,'OpenTURNS_Cata_Study_V4.py'),'openturns_study','wrapper'), #('OPENTURNS','Wrapper',os.path.join(rep_cata,'OpenTURNS_Cata_Wrapper_V1.py'),'openturns'), ) diff --git a/Openturns_Study/prefs.py b/Openturns_Study/prefs.py index 5fff47f6..e3c95cec 100644 --- a/Openturns_Study/prefs.py +++ b/Openturns_Study/prefs.py @@ -46,9 +46,9 @@ rep_cata = INSTALLDIR path_doc = os.path.join(rep_cata,'Doc') exec_acrobat = "/usr/bin/xpdf" -# Repertoire initial -DTDDirectory="/local00/home/dutka/OpenTURNS/dutka/devel/build/install/share/openturns/wrappers/" +# OpenTURNS Python module +OpenTURNS_path="/local00/home/dutka/OpenTURNS/dutka/build/install/lib/python2.4/site-packages" # Choix des catalogues sys.path[:0]=[INSTALLDIR] - +sys.path.append( OpenTURNS_path ) -- 2.39.2