nom=maVariableListe[i].id_
type=maVariableListe[i].type_
if type :
- ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
- else :
ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='out',R=%d);\n" % (nom, nom, i)
+ else :
+ ligneTexte="%s=DETERMINISTICVARIABLE(N='%s',T='in',R=%d);\n" % (nom, nom, i)
self.fichier_text = self.fichier_text + ligneTexte
except:
self.make_incl2_except()
# permet de savoir si le concept a été calculé (1) ou non (0)
self.executed = 0
# initialise la partie "sd"
- super(ASSD, self).__init__(nomj='?&?&?&?&')
+ super(ASSD, self).__init__() # Python 2.6
def __getitem__(self,key):
return self.etape[key]
Gamma = SIMP ( statut = "o",
typ = "R",
max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter",
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
),
First = SIMP ( statut = "o",
typ = "R",
max = 1,
- fr = "Premier point de la distribution",
- ang = "First point",
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
),
# 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",
+ fr = "Liste de couples : largeur de classe, probabilité associée",
+ ang = "Class bandwidth, associated probability couple list",
validators=VerifTypeTuple(('R','R')),
),
Gamma = SIMP ( statut = "o",
typ = "R",
max = 1,
- fr = "Borne inferieure du supoport de la loi",
+ fr = "Borne inferieure du support de la loi",
ang = "Support lower bound",
),
typ = "R",
max = 1,
val_min = 0.,
- fr = "Parametre Beta de la loi | Beta > = 0",
- ang = "Beta parameter | Beta > = 0",
+ fr = "Parametre Beta de la loi | Beta > 0",
+ ang = "Beta parameter | Beta > 0",
),
), # Fin BLOC LOGISTIC
N = SIMP ( statut = "o",
typ = "I",
max = 1,
- fr = "Dimension de la loi",
- ang = "Distribution dimension",
+ fr = "Parametre N de la loi | N > 0",
+ ang = "N parameter | N > 0",
),
- # Il faut un vecteur P de taille N
- Mu = SIMP ( statut = 'o',
- typ = 'R',
- max = '**',
- ),
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = "R",
+ max = '**',
+ fr = "Liste de probabilités",
+ ang = "Probability list",
+ validators=VerifTypeTuple(('R','R')),
+ ),
), # Fin BLOC MULTINOMIAL
Nu = SIMP ( statut = "o",
typ = "R",
max = 1,
- fr = "Parametre Nu de la loi",
- ang = "Nu parameter",
+ fr = "Parametre Nu de la loi | Nu > 0",
+ ang = "Nu parameter | Nu > 0",
),
Delta = SIMP ( statut = "o",
typ = "R",
max = 1,
- fr = "Parametre Delta de la loi",
- ang = "Delta parameter",
+ fr = "Parametre Delta de la loi | Delta > 0",
+ ang = "Delta parameter | Delta > 0",
),
Gamma = SIMP ( statut = "o",
typ = "R",
max = 1,
- fr = "Parametre Gamma de la loi",
+ fr = "Parametre Gamma de centrage de la loi",
ang = "Gamma parameter",
),
Mu = SIMP ( statut = "o",
typ = "R",
max = 1,
- fr = "Moyenne de la loi",
- ang = "Mean value",
+ 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",
+ fr = "Parametre Nu de la loi | Nu > 2",
+ ang = "Nu parameter | Nu > 2",
),
Sigma = SIMP ( statut = "o",
MuN = SIMP ( statut = "o",
typ = "R",
max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter",
+ fr = "Moyenne de la loi Normale non tronquée",
+ ang = "Mean value of the associated non truncated normal distribution",
),
SigmaN = SIMP ( statut = "o",
typ = "R",
max = 1,
val_min = 0.,
- fr = "Parametre SigmaN de la loi | SigmaN > 0",
- ang = "SigmaN parameter | SigmaN> 0",
+ fr = "Ecart-type de la loi Normale non tronquée",
+ ang = "Standard deviation of the associated non truncated normal distribution",
),
A = SIMP ( statut = "o",
typ = "R",
max = 1,
- fr = "Borne inferieure de la loi | A < = B",
- ang = "Lower bound | A < = B",
+ 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",
+ fr = "Borne superieure de la loi | A < B",
+ ang = "Upper bound | A < B",
),
), # Fin BLOC TRUNCATEDNORMAL
ModelVariable = SIMP ( statut = "o",
typ = ( variable, ),
+ fr = "Variable d'entrée du modèle",
+ ang = "Input variable of the model",
),
Distribution = SIMP ( statut = "o",
typ = ( loi, ),
+ fr = "Modélisation probabiliste",
+ ang = "Probabilistic modelisation",
),
) # Fin PROC VARIABLE
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.",
+ fr = "Critère de l'étude d'incertitudes",
+ ang = "Uncertainty study criteria",
Type = SIMP ( statut = "o",
typ = "TXM",
into = ( "Min/Max", "Central Uncertainty", "Threshold Exceedence" ),
- fr = "Type d'Analyse",
- ang = "Analysis",
+ fr = "Type du critère",
+ ang = "Criteria type",
),
ExperimentPlane = SIMP ( statut = "o",
typ = "TXM",
into = ( "Axial", "Factorial", "Composite", ),
- fr = "Methode",
- ang = "Method",
+ fr = "Type du plan d'expérience",
+ ang = "Experiment plane type",
),
Levels = SIMP ( statut = "o",
typ = "R",
val_min = 0.0,
max = '**',
- fr = "Nombre de niveaux dans chaque direction",
+ fr = "Liste de niveaux dans chaque direction",
ang = "Levels in each direction",
),
# Scaled Vector
- UnitsPerDimension = SIMP ( statut = "o",
+ UnitPerDimension = SIMP ( statut = "o",
typ = "R",
max = '**',
- fr = "Unite par dimension (autant que de variables declarees)",
+ fr = "Unité par dimension (autant que de variables declarées)",
ang = "Units per dimension (as much as declared variables)",
),
Center = SIMP ( statut = "o",
typ = "R",
max = '**',
- fr = "Unite par dimension",
- ang = "Units per dimension",
+ fr = "Centre du plan d'expérience",
+ ang = "Experiment plan center",
),
), # Fin BLOC ExperimentPlaneSettings
typ = "TXM",
into = ( "Min/Max", ),
defaut = "Min/Max",
- fr = "Le minimum et le maximum",
+ fr = "Le minimum et le maximum de la variable d'intérêt",
ang = "The min and max values",
),
defaut = 0.1,
val_min = 0.0,
val_max = 1.0,
- fr = " maximum ...",
- ang = "Absolute maximum ...."
+ fr = "Coefficient de variation maximum",
+ ang = "Maximum coefficient of variation"
),
ImportanceSamplingSettings = BLOC ( condition = " Algorithm in ( 'ImportanceSampling', ) ",
TvedtApproximation = SIMP ( statut = "o",
typ = 'TXM',
into = ( 'yes', 'no' ),
- defaut = 'no',
+ defaut = 'yes',
max = 1,
fr = "Approximation de Tvedt",
ang = "Tvedt approximation",
HohenBichlerApproximation = SIMP ( statut = "o",
typ = 'TXM',
into = ( 'yes', 'no' ),
- defaut = 'no',
+ defaut = 'yes',
max = 1,
fr = "Approximation de HohenBichler",
ang = "HohenBichler approximation",
BreitungApproximation = SIMP ( statut = "o",
typ = 'TXM',
into = ( 'yes', 'no' ),
- defaut = 'no',
+ defaut = 'yes',
max = 1,
fr = "Approximation de Breitung",
ang = "Breitung approximation",
--- /dev/null
+# -*- 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
+
+class Matrice:
+ def __init__(self,nbLigs=None,nbCols=None,methodeCalculTaille=None,formatSortie="ligne",valSup=None,valMin=None,structure=None):
+ self.nbLigs=nbLigs
+ self.nbCols=nbCols
+ self.methodeCalculTaille=methodeCalculTaille
+ self.formatSortie=formatSortie
+ self.valSup=valSup
+ self.valMin=valMin
+ self.structure=structure
+
+ def __convert__(self,valeur):
+ # Attention ne verifie pas grand chose
+ if type(valeur) != types.ListType :
+ return None
+ return valeur
+
+ def info(self):
+ return "Matrice %s x %s" % (self.nbLigs, self.nbCols)
+
+ __repr__=info
+ __str__=info
+
+
+#CONTEXT.debug = 1
+JdC = JDC_CATA ( code = 'OPENTURNS_STUDY',
+ execmodul = None,
+ regles = ( AU_MOINS_UN ( 'CRITERIA' ),
+ AU_MOINS_UN ( 'MODEL' ),
+ AVANT ( ('DISTRIBUTION', 'MODEL'), 'VARIABLE' ),
+# A_CLASSER ( 'VARIABLE', 'CORRELATION' ),
+# A_CLASSER ( 'VARIABLE', 'CRITERIA' ),
+# A_CLASSER ( 'CORRELATION', 'CRITERIA' ),
+ ),
+ ) # 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
+# Ordre Catalogue LOG
+
+
+
+
+
+#================================
+# 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",
+ "Laplace",
+ "Logistic",
+ "LogNormal",
+ "MultiNomial",
+ "NonCentralStudent",
+ "Normal",
+ "Poisson",
+ "Rayleigh",
+ "Student",
+ "Triangular",
+ "TruncatedNormal",
+ "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 | R > 0",
+ ang = "R parameter | R > 0",
+ ),
+
+ # 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ # B > A
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure du support de la loi",
+ ang = "Support upper bound",
+ ),
+
+ ), # 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 = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ ), # 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,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
+ ),
+
+
+ ), # 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ ), # Fin BLOC GUMBEL
+
+
+
+ HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ",
+
+ First = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
+ ),
+
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = Tuple(2),
+ max = '**',
+ fr = "Liste de couples : largeur de classe, hauteur de classe",
+ ang = "Class bandwidth, class height couple list",
+ validators=VerifTypeTuple(('R','R')),
+ ),
+
+ ), # Fin BLOC HISTOGRAM
+
+
+
+ LAPLACE = BLOC ( condition = " Kind in ( 'Laplace', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0",
+ ),
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ ), # Fin BLOC LAPLACE
+
+ 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ MuSigmaOverMu_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaOverMu', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ SigmaOverMu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Rapport ecart type / moyenne de la loi",
+ ang = "Standard deviation / mean value ratio",
+ ),
+
+ ), # Fin BLOC MuSigmaOverMu_Parameters
+
+ MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
+
+ MuLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne du log",
+ ang = "Log mean value",
+ ),
+
+ SigmaLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type du log",
+ ang = "Log standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigmaLog_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ ), # Fin BLOC LOGNORMAL
+
+
+
+ LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
+ ),
+
+ 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 = "Parametre N de la loi | N > 0",
+ ang = "N parameter | N > 0",
+ ),
+
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = "R",
+ max = '**',
+ fr = "Liste de probabilités",
+ ang = "Probability list",
+ validators=VerifTypeTuple(('R','R')),
+ ),
+
+ ), # Fin BLOC MULTINOMIAL
+
+
+ NONCENTRALSTUDENT = BLOC ( condition = " Kind in ( 'NonCentralStudent', ) ",
+
+ Nu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Nu de la loi | Nu > 0",
+ ang = "Nu parameter | Nu > 0",
+ ),
+
+ Delta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Delta de la loi | Delta > 0",
+ ang = "Delta parameter | Delta > 0",
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma de centrage de la loi",
+ ang = "Gamma parameter",
+ ),
+
+ ), # Fin BLOC NONCENTRALSTUDENT
+
+
+ NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # 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
+
+
+
+ RAYLEIGH = BLOC ( condition = " Kind in ( 'Rayleigh', ) ",
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0",
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+ ), # Fin BLOC RAYLEIGH
+
+
+ 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 | Nu > 2",
+ ang = "Nu parameter | Nu > 2",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Sigma de la loi",
+ ang = "Sigma parameter",
+ ),
+
+ ), # Fin BLOC STUDENT
+
+
+
+ TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi | A < M < B",
+ ang = "Support 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 du support de la loi | A < M < B",
+ ang = "Support upper bound | A < M < B",
+ ),
+
+ ), # Fin BLOC TRIANGULAR
+
+
+
+ TRUNCATEDNORMAL = BLOC ( condition = " Kind in ( 'TruncatedNormal', ) ",
+
+ MuN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi Normale non tronquée",
+ ang = "Mean value of the associated non truncated normal distribution",
+ ),
+
+ SigmaN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart-type de la loi Normale non tronquée",
+ ang = "Standard deviation of the associated non truncated normal distribution",
+ ),
+
+ 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 du support de la loi | A < B",
+ ang = "Support lower bound | A < B",
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure du support de la loi | A < B",
+ ang = "Support 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ ), # Fin BLOC WEIBULL
+
+) # Fin OPER DISTRIBUTION
+# Ordre Catalogue DISTRIBUTION
+
+
+
+#================================
+# 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
+# Ordre Catalogue DETERMINISTICVARIABLE
+
+
+
+import opsOT
+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 = opsOT.INCLUDE,
+ op_init = opsOT.INCLUDE_context,
+ fichier_ini = 1,
+
+ FileName = SIMP ( statut = "o",
+ typ = "Fichier",
+ fr = "Nom du modele physique",
+ ang = "Physical model identifier",
+ ),
+
+) # Fin PROC MODEL
+# Ordre Catalogue MODEL
+
+
+
+
+VARIABLE = PROC ( nom = "VARIABLE",
+ op = None,
+ docu = "",
+ fr = "Variable probabiliste",
+ ang = "Probabilistic variable",
+
+ ModelVariable = SIMP ( statut = "o",
+ typ = ( variable, ),
+ fr = "Variable d'entrée du modèle",
+ ang = "Input variable of the model",
+ ),
+
+ Distribution = SIMP ( statut = "o",
+ typ = ( loi, ),
+ fr = "Modélisation probabiliste",
+ ang = "Probabilistic modelisation",
+ ),
+
+) # Fin PROC VARIABLE
+# Ordre Catalogue VARIABLE
+
+
+CORRELATION = PROC ( nom = 'CORRELATION',
+ op = None,
+ docu = "",
+ fr = "Correlation entre variables",
+ ang = "Variable correlation",
+
+ Copula = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( "Independent", "Normal" ),
+ defaut = "Independent",
+ fr = "Type de la copule",
+ ang = "Copula kind",
+ ),
+
+ Matrix = BLOC ( condition = "Copula in ( 'Normal', )",
+
+ CorrelationMatrix = SIMP ( statut = "o",
+ typ = Matrice(nbLigs=None,
+ nbCols=None,
+ methodeCalculTaille='NbDeVariables',
+ valSup=1,
+ valMin=-1,
+ structure="symetrique"),
+ fr = "Matrice de correlation entre les variables d'entree",
+ ang = "Correlation matrix for input variables",
+ ),
+ ), # Fin BLOC Matrix
+
+
+) # Fin PROC CORRELATION
+# Ordre Catalogue CORRELATION
+
+
+
+
+
+#================================
+# Definition de l'etude
+#================================
+
+# Nota : les variables de type PROC doivent etre en majuscules !
+CRITERIA = PROC ( nom = "CRITERIA",
+ op = None,
+ docu = "",
+ fr = "Critère de l'étude d'incertitudes",
+ ang = "Uncertainty study criteria",
+
+
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Min/Max", "Central Uncertainty", "Threshold Exceedence" ),
+ fr = "Type du critère",
+ ang = "Criteria type",
+ ),
+
+
+
+
+
+
+
+ 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 = "Type du plan d'expérience",
+ ang = "Experiment plane type",
+ ),
+
+ Levels = SIMP ( statut = "o",
+ typ = "R",
+ val_min = 0.0,
+ max = '**',
+ fr = "Liste de niveaux dans chaque direction",
+ ang = "Levels in each direction",
+ ),
+
+ # Scaled Vector
+ UnitPerDimension = SIMP ( statut = "o",
+ typ = "R",
+ max = '**',
+ fr = "Unité par dimension (autant que de variables declarées)",
+ ang = "Units per dimension (as much as declared variables)",
+ ),
+
+ # Translation Vector
+ Center = SIMP ( statut = "o",
+ typ = "R",
+ max = '**',
+ fr = "Centre du plan d'expérience",
+ ang = "Experiment plan center",
+ ),
+
+ ), # Fin BLOC ExperimentPlaneSettings
+
+
+
+ RandomSamplingSettings = BLOC ( condition = " Method in ( 'Random Sampling', ) ",
+
+ SimulationsNumber = 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 de la variable d'intérêt",
+ 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 = 'no',
+ max = 1,
+ fr = "Moyenne au second ordre",
+ ang = "MeanSecondOrder",
+ ),
+
+ ImportanceFactor = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Facteur d'importance pour variable de sortie scalaire",
+ ang = "ImportanceFactor",
+ ),
+ ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ",
+
+ ImportanceFactorDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des facteurs d'importance",
+ ang = "Importance Factor Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ImportanceFactorSettings
+
+ ), # Fin FACT Result
+
+ ), # Fin BLOC TaylorVarianceDecompositionSettings
+
+
+
+ RandomSamplingSettings = BLOC ( condition = " Method in ( 'Random Sampling', ) ",
+
+ SimulationsNumber = 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
+
+ CorrelationAnalysis = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Correlations analysees",
+ ang = "Analysed correlations",
+ ),
+
+ KernelSmoothing = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Kernel smoothing de l'echantillon",
+ ang = "Kernel smoothing of the sample",
+ ),
+
+ KernelSmoothingSettings = BLOC ( condition = " KernelSmoothing in ( 'yes', ) ",
+
+ KernelSmoothingDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique de la reconstruction a noyau",
+ ang = "Kernel Smoothing Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC KernelSmoothingSettings
+
+ ), # 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", "FORM_SORM" ),
+ 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 = "o",
+ 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 = "o",
+ typ = "R",
+ max = 1,
+ defaut = 0.1,
+ val_min = 0.0,
+ val_max = 1.0,
+ fr = "Coefficient de variation maximum",
+ ang = "Maximum coefficient of variation"
+ ),
+
+ 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 = 'Independent',
+ 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 = "Intervale de confiance",
+ ang = "Confidence interval",
+ ),
+
+ 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 = "Coefficient of variation",
+ ),
+
+ SimulationsNumber = 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",
+ ),
+
+ ConvergenceGraphSettings = BLOC ( condition = " ConvergenceGraph in ( 'yes', ) ",
+
+ ConvergenceDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique de la convergence",
+ ang = "Convergence Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ConvergenceGraphSettings
+
+ ), # Fin FACT Result
+
+
+
+ ), # Fin BLOC SimulationSettings
+
+
+
+ FORM_SORMSettings = BLOC ( condition = " Method in ( 'FORM_SORM', ) ",
+
+ 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 = "Optimization 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 = "o",
+ typ = "R",
+ max = 1,
+ defaut = 1E-4,
+ val_min = 0.0,
+ fr = "Distance maximum absolue entre 2 iterations successives",
+ ang = "Absolute maximum distance between 2 successive iterates",
+ ),
+
+ MaximumRelativeError = SIMP ( statut = "o",
+ 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 = "o",
+ 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",
+ ),
+
+ FORMResult = 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 = 'yes',
+ max = 1,
+ fr = "Facteur d'importance pour variable de sortie scalaire",
+ ang = "Importance factor",
+ ),
+
+ ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ",
+
+ ImportanceFactorDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des facteurs d'importance",
+ ang = "Importance Factor Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ImportanceFactorSettings
+
+ SensitivityAnalysis = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ 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 = 'yes',
+ max = 1,
+ fr = "Indice de fiabilite de Hasofer",
+ ang = "Hasofer reliability index",
+ ),
+
+ FORMEventProbabilitySensitivitySettings = BLOC ( condition = " FORMEventProbabilitySensitivity in ( 'yes', ) ",
+
+ FORMEventProbabilitySensitivityDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des sensibilites",
+ ang = "Sensitivity Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC FORMEventProbabilitySensitivitySettings
+
+ HasoferReliabilityIndexSensitivity = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Indice de fiabilite de Hasofer",
+ ang = "Hasofer reliability index",
+ ),
+
+ HasoferReliabilityIndexSensitivitySettings = BLOC ( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ",
+
+ HasoferReliabilityIndexSensitivityDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des sensibilites",
+ ang = "Sensitivity Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC FHasoferReliabilityIndexSensitivitySettings
+
+ ), # Fin BLOC SensitivityAnalysisSettings
+
+ FunctionCallsNumber = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Nombre d'appels a la fonction",
+ ang = "Function calls number",
+ ),
+
+
+ ), # Fin BLOC FORMResult
+
+
+ SORMResult = BLOC ( condition = " Approximation in ( 'SecondOrder', ) ",
+
+
+ TvedtApproximation = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Approximation de Tvedt",
+ ang = "Tvedt approximation",
+ ),
+
+ HohenBichlerApproximation = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Approximation de HohenBichler",
+ ang = "HohenBichler approximation",
+ ),
+
+ BreitungApproximation = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ 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 = 'yes',
+ max = 1,
+ fr = "Facteur d'importance pour variable de sortie scalaire",
+ ang = "Importance factor",
+ ),
+
+ ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ",
+
+ ImportanceFactorDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des facteurs d'importance",
+ ang = "Importance Factor Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ImportanceFactorSettings
+
+ SensitivityAnalysis = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ 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 = 'yes',
+ max = 1,
+ fr = "Indice de fiabilite de Hasofer",
+ ang = "Hasofer reliability index",
+ ),
+
+ HasoferReliabilityIndexSensitivitySettings = BLOC ( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ",
+
+ HasoferReliabilityIndexSensitivityDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des sensibilites",
+ ang = "Sensitivity Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC FHasoferReliabilityIndexSensitivitySettings
+
+ ), # Fin BLOC SensitivityAnalysisSettings
+
+ FunctionCallsNumber = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Nombre d'appels a la fonction",
+ ang = "Function calls number",
+ ),
+
+
+ ), # Fin BLOC SecondOrder
+
+
+
+ ), # Fin BLOC FORM_SORMSettings
+
+
+
+ ), # Fin BLOC ThresholdExceedence
+
+
+
+) # Fin PROC CRITERIA
+# Ordre Catalogue CRITERIA
+
+
+
+
+
+
+
--- /dev/null
+# -*- 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
+
+class Matrice:
+ def __init__(self,nbLigs=None,nbCols=None,methodeCalculTaille=None,formatSortie="ligne",valSup=None,valMin=None,structure=None):
+ self.nbLigs=nbLigs
+ self.nbCols=nbCols
+ self.methodeCalculTaille=methodeCalculTaille
+ self.formatSortie=formatSortie
+ self.valSup=valSup
+ self.valMin=valMin
+ self.structure=structure
+
+ def __convert__(self,valeur):
+ # Attention ne verifie pas grand chose
+ if type(valeur) != types.ListType :
+ return None
+ return valeur
+
+ def info(self):
+ return "Matrice %s x %s" % (self.nbLigs, self.nbCols)
+
+ __repr__=info
+ __str__=info
+
+
+#CONTEXT.debug = 1
+JdC = JDC_CATA ( code = 'OPENTURNS_STUDY',
+ execmodul = None,
+ regles = ( AU_MOINS_UN ( 'CRITERIA' ),
+ AU_MOINS_UN ( 'MODEL' ),
+ AVANT ( ('DISTRIBUTION', 'MODEL'), 'VARIABLE' ),
+# A_CLASSER ( 'VARIABLE', 'CORRELATION' ),
+# A_CLASSER ( 'VARIABLE', 'CRITERIA' ),
+# A_CLASSER ( 'CORRELATION', 'CRITERIA' ),
+ ),
+ ) # 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
+# Ordre Catalogue LOG
+
+
+
+
+
+#================================
+# 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",
+ "Laplace",
+ "Logistic",
+ "LogNormal",
+ "MultiNomial",
+ "NonCentralStudent",
+ "Normal",
+ "Poisson",
+ "Rayleigh",
+ "Student",
+ "Triangular",
+ "TruncatedNormal",
+ "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 | R > 0",
+ ang = "R parameter | R > 0",
+ ),
+
+ # 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ # B > A
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure du support de la loi",
+ ang = "Support upper bound",
+ ),
+
+ ), # 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 = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ ), # 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,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # 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
+
+
+
+ LAPLACE = BLOC ( condition = " Kind in ( 'Laplace', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0",
+ ),
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ ), # Fin BLOC LAPLACE
+
+ 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ MuSigmaOverMu_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaOverMu', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ SigmaOverMu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Rapport ecart type / moyenne de la loi",
+ ang = "Standard deviation / mean value ratio",
+ ),
+
+ ), # Fin BLOC MuSigmaOverMu_Parameters
+
+ MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
+
+ MuLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne du log",
+ ang = "Log mean value",
+ ),
+
+ SigmaLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type du log",
+ ang = "Log standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigmaLog_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
+ ),
+
+ ), # Fin BLOC LOGNORMAL
+
+
+
+ LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
+ ),
+
+ 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
+
+
+ NONCENTRALSTUDENT = BLOC ( condition = " Kind in ( 'NonCentralStudent', ) ",
+
+ Nu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Nu de la loi",
+ ang = "Nu parameter",
+ ),
+
+ Delta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Delta de la loi",
+ ang = "Delta parameter",
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma de la loi",
+ ang = "Gamma parameter",
+ ),
+
+ ), # Fin BLOC NONCENTRALSTUDENT
+
+
+ NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # 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
+
+
+
+ RAYLEIGH = BLOC ( condition = " Kind in ( 'Rayleigh', ) ",
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0",
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+ ), # Fin BLOC RAYLEIGH
+
+
+ STUDENT = BLOC ( condition = " Kind in ( 'Student', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Nu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 2.,
+ fr = "Parametre Nu de la loi | V > 2",
+ ang = "Nu parameter | V > 2",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Sigma de la loi",
+ ang = "Sigma parameter",
+ ),
+
+ ), # Fin BLOC STUDENT
+
+
+
+ TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi | A < M < B",
+ ang = "Support 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 du support de la loi | A < M < B",
+ ang = "Support 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 du support de la loi | A < B",
+ ang = "Support lower bound | A < B",
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure du support de la loi | A < B",
+ ang = "Support 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ ), # Fin BLOC WEIBULL
+
+) # Fin OPER DISTRIBUTION
+# Ordre Catalogue DISTRIBUTION
+
+
+
+#================================
+# 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
+# Ordre Catalogue DETERMINISTICVARIABLE
+
+
+
+import opsOT
+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 = opsOT.INCLUDE,
+ op_init = opsOT.INCLUDE_context,
+ fichier_ini = 1,
+
+ FileName = SIMP ( statut = "o",
+ typ = "Fichier",
+ fr = "Nom du modele physique",
+ ang = "Physical model identifier",
+ ),
+
+) # Fin PROC MODEL
+# Ordre Catalogue 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
+# Ordre Catalogue VARIABLE
+
+
+CORRELATION = PROC ( nom = 'CORRELATION',
+ op = None,
+ docu = "",
+ fr = "Correlation entre variables",
+ ang = "Variable correlation",
+
+ Copula = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( "Independent", "Normal" ),
+ defaut = "Independent",
+ fr = "Type de la copule",
+ ang = "Copula kind",
+ ),
+
+ Matrix = BLOC ( condition = "Copula in ( 'Normal', )",
+
+ CorrelationMatrix = SIMP ( statut = "o",
+ typ = Matrice(nbLigs=None,
+ nbCols=None,
+ methodeCalculTaille='NbDeVariables',
+ valSup=1,
+ valMin=-1,
+ structure="symetrique"),
+ fr = "Matrice de correlation entre les variables d'entree",
+ ang = "Correlation matrix for input variables",
+ ),
+ ), # Fin BLOC Matrix
+
+
+) # Fin PROC CORRELATION
+# Ordre Catalogue CORRELATION
+
+
+
+
+
+#================================
+# 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', ) ",
+
+ SimulationsNumber = 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 = 'no',
+ max = 1,
+ fr = "Moyenne au second ordre",
+ ang = "MeanSecondOrder",
+ ),
+
+ ImportanceFactor = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Facteur d'importance pour variable de sortie scalaire",
+ ang = "ImportanceFactor",
+ ),
+ ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ",
+
+ ImportanceFactorDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des facteurs d'importance",
+ ang = "Importance Factor Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ImportanceFactorSettings
+
+ ), # Fin FACT Result
+
+ ), # Fin BLOC TaylorVarianceDecompositionSettings
+
+
+
+ RandomSamplingSettings = BLOC ( condition = " Method in ( 'Random Sampling', ) ",
+
+ SimulationsNumber = 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
+
+ CorrelationAnalysis = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Correlations analysees",
+ ang = "Analysed correlations",
+ ),
+
+ KernelSmoothing = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Kernel smoothing de l'echantillon",
+ ang = "Kernel smoothing of the sample",
+ ),
+
+ KernelSmoothingSettings = BLOC ( condition = " KernelSmoothing in ( 'yes', ) ",
+
+ KernelSmoothingDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique de la reconstruction a noyau",
+ ang = "Kernel Smoothing Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC KernelSmoothingSettings
+
+ ), # 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", "FORM_SORM" ),
+ 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 = "o",
+ 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 = "o",
+ typ = "R",
+ max = 1,
+ defaut = 0.1,
+ val_min = 0.0,
+ val_max = 1.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 = 'Independent',
+ 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 = "Intervale de confiance",
+ ang = "Confidence interval",
+ ),
+
+ 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 = "Coefficient of variation",
+ ),
+
+ SimulationsNumber = 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",
+ ),
+
+ ConvergenceGraphSettings = BLOC ( condition = " ConvergenceGraph in ( 'yes', ) ",
+
+ ConvergenceDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique de la convergence",
+ ang = "Convergence Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ConvergenceGraphSettings
+
+ ), # Fin FACT Result
+
+
+
+ ), # Fin BLOC SimulationSettings
+
+
+
+ FORM_SORMSettings = BLOC ( condition = " Method in ( 'FORM_SORM', ) ",
+
+ 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 = "Optimization 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 = "o",
+ typ = "R",
+ max = 1,
+ defaut = 1E-4,
+ val_min = 0.0,
+ fr = "Distance maximum absolue entre 2 iterations successives",
+ ang = "Absolute maximum distance between 2 successive iterates",
+ ),
+
+ MaximumRelativeError = SIMP ( statut = "o",
+ 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 = "o",
+ 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",
+ ),
+
+ FORMResult = 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 = 'yes',
+ max = 1,
+ fr = "Facteur d'importance pour variable de sortie scalaire",
+ ang = "Importance factor",
+ ),
+
+ ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ",
+
+ ImportanceFactorDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des facteurs d'importance",
+ ang = "Importance Factor Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ImportanceFactorSettings
+
+ SensitivityAnalysis = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ 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 = 'yes',
+ max = 1,
+ fr = "Indice de fiabilite de Hasofer",
+ ang = "Hasofer reliability index",
+ ),
+
+ FORMEventProbabilitySensitivitySettings = BLOC ( condition = " FORMEventProbabilitySensitivity in ( 'yes', ) ",
+
+ FORMEventProbabilitySensitivityDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des sensibilites",
+ ang = "Sensitivity Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC FORMEventProbabilitySensitivitySettings
+
+ HasoferReliabilityIndexSensitivity = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Indice de fiabilite de Hasofer",
+ ang = "Hasofer reliability index",
+ ),
+
+ HasoferReliabilityIndexSensitivitySettings = BLOC ( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ",
+
+ HasoferReliabilityIndexSensitivityDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des sensibilites",
+ ang = "Sensitivity Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC FHasoferReliabilityIndexSensitivitySettings
+
+ ), # Fin BLOC SensitivityAnalysisSettings
+
+ FunctionCallsNumber = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Nombre d'appels a la fonction",
+ ang = "Function calls number",
+ ),
+
+
+ ), # Fin BLOC FORMResult
+
+
+ SORMResult = 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 = 'yes',
+ max = 1,
+ fr = "Facteur d'importance pour variable de sortie scalaire",
+ ang = "Importance factor",
+ ),
+
+ ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ",
+
+ ImportanceFactorDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des facteurs d'importance",
+ ang = "Importance Factor Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ImportanceFactorSettings
+
+ SensitivityAnalysis = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ 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 = 'yes',
+ max = 1,
+ fr = "Indice de fiabilite de Hasofer",
+ ang = "Hasofer reliability index",
+ ),
+
+ HasoferReliabilityIndexSensitivitySettings = BLOC ( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ",
+
+ HasoferReliabilityIndexSensitivityDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des sensibilites",
+ ang = "Sensitivity Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC FHasoferReliabilityIndexSensitivitySettings
+
+ ), # Fin BLOC SensitivityAnalysisSettings
+
+ FunctionCallsNumber = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Nombre d'appels a la fonction",
+ ang = "Function calls number",
+ ),
+
+
+ ), # Fin BLOC SecondOrder
+
+
+
+ ), # Fin BLOC FORM_SORMSettings
+
+
+
+ ), # Fin BLOC ThresholdExceedence
+
+
+
+) # Fin PROC CRITERIA
+# Ordre Catalogue CRITERIA
+
+
+
+
+
+
+
--- /dev/null
+# -*- 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
+
+class Matrice:
+ def __init__(self,nbLigs=None,nbCols=None,methodeCalculTaille=None,formatSortie="ligne",valSup=None,valMin=None,structure=None):
+ self.nbLigs=nbLigs
+ self.nbCols=nbCols
+ self.methodeCalculTaille=methodeCalculTaille
+ self.formatSortie=formatSortie
+ self.valSup=valSup
+ self.valMin=valMin
+ self.structure=structure
+
+ def __convert__(self,valeur):
+ # Attention ne verifie pas grand chose
+ if type(valeur) != types.ListType :
+ return None
+ return valeur
+
+ def info(self):
+ return "Matrice %s x %s" % (self.nbLigs, self.nbCols)
+
+ __repr__=info
+ __str__=info
+
+
+#CONTEXT.debug = 1
+JdC = JDC_CATA ( code = 'OPENTURNS_STUDY',
+ execmodul = None,
+ regles = ( AU_MOINS_UN ( 'CRITERIA' ),
+ AU_MOINS_UN ( 'MODEL' ),
+ AVANT ( ('DISTRIBUTION', 'MODEL'), 'VARIABLE' ),
+# A_CLASSER ( 'VARIABLE', 'CORRELATION' ),
+# A_CLASSER ( 'VARIABLE', 'CRITERIA' ),
+# A_CLASSER ( 'CORRELATION', 'CRITERIA' ),
+ ),
+ ) # 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
+# Ordre Catalogue LOG
+
+
+
+
+
+#================================
+# 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",
+ "Laplace",
+ "Logistic",
+ "LogNormal",
+ "MultiNomial",
+ "NonCentralStudent",
+ "Normal",
+ "Poisson",
+ "Rayleigh",
+ "Student",
+ "Triangular",
+ "TruncatedNormal",
+ "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 | R > 0",
+ ang = "R parameter | R > 0",
+ ),
+
+ # 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ # B > A
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure du support de la loi",
+ ang = "Support upper bound",
+ ),
+
+ ), # 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 = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ ), # 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,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
+ ),
+
+
+ ), # 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ ), # Fin BLOC GUMBEL
+
+
+
+ HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ",
+
+ First = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
+ ),
+
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = Tuple(2),
+ max = '**',
+ fr = "Liste de couples : largeur de classe, hauteur de classe",
+ ang = "Class bandwidth, class height couple list",
+ validators=VerifTypeTuple(('R','R')),
+ ),
+
+ ), # Fin BLOC HISTOGRAM
+
+
+
+ LAPLACE = BLOC ( condition = " Kind in ( 'Laplace', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0",
+ ),
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ ), # Fin BLOC LAPLACE
+
+ 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ MuSigmaOverMu_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaOverMu', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ SigmaOverMu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Rapport ecart type / moyenne de la loi",
+ ang = "Standard deviation / mean value ratio",
+ ),
+
+ ), # Fin BLOC MuSigmaOverMu_Parameters
+
+ MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
+
+ MuLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne du log",
+ ang = "Log mean value",
+ ),
+
+ SigmaLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type du log",
+ ang = "Log standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigmaLog_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ ), # Fin BLOC LOGNORMAL
+
+
+
+ LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du supoport de la loi",
+ ang = "Support lower bound",
+ ),
+
+ 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 = "Parametre N de la loi | N > 0",
+ ang = "N parameter | N > 0",
+ ),
+
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = "R",
+ max = '**',
+ fr = "Liste de probabilités",
+ ang = "Probability list",
+ validators=VerifTypeTuple(('R','R')),
+ ),
+
+ ), # Fin BLOC MULTINOMIAL
+
+
+ NONCENTRALSTUDENT = BLOC ( condition = " Kind in ( 'NonCentralStudent', ) ",
+
+ Nu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Nu de la loi | Nu > 0",
+ ang = "Nu parameter | Nu > 0",
+ ),
+
+ Delta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Delta de la loi | Delta > 0",
+ ang = "Delta parameter | Delta > 0",
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma de centrage de la loi",
+ ang = "Gamma parameter",
+ ),
+
+ ), # Fin BLOC NONCENTRALSTUDENT
+
+
+ NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # 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
+
+
+
+ RAYLEIGH = BLOC ( condition = " Kind in ( 'Rayleigh', ) ",
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0",
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+ ), # Fin BLOC RAYLEIGH
+
+
+ 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 | Nu > 2",
+ ang = "Nu parameter | Nu > 2",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Sigma de la loi",
+ ang = "Sigma parameter",
+ ),
+
+ ), # Fin BLOC STUDENT
+
+
+
+ TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi | A < M < B",
+ ang = "Support 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 du support de la loi | A < M < B",
+ ang = "Support upper bound | A < M < B",
+ ),
+
+ ), # Fin BLOC TRIANGULAR
+
+
+
+ TRUNCATEDNORMAL = BLOC ( condition = " Kind in ( 'TruncatedNormal', ) ",
+
+ MuN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Moyenne de la loi Normale non tronquée",
+ ang = "Mean value of the associated non truncated normal distribution",
+ ),
+
+ SigmaN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart-type de la loi Normale non tronquée",
+ ang = "Standard deviation of the associated non truncated normal distribution",
+ ),
+
+ 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 du support de la loi | A < B",
+ ang = "Support lower bound | A < B",
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure du support de la loi | A < B",
+ ang = "Support 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 = "Moyenne de la loi",
+ ang = "Mean value",
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Ecart type de la loi",
+ ang = "Standard deviation",
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure du support de la loi",
+ ang = "Support lower bound",
+ ),
+
+ ), # Fin BLOC WEIBULL
+
+) # Fin OPER DISTRIBUTION
+# Ordre Catalogue DISTRIBUTION
+
+
+
+#================================
+# 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
+# Ordre Catalogue DETERMINISTICVARIABLE
+
+
+
+import opsOT
+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 = opsOT.INCLUDE,
+ op_init = opsOT.INCLUDE_context,
+ fichier_ini = 1,
+
+ FileName = SIMP ( statut = "o",
+ typ = "Fichier",
+ fr = "Nom du modele physique",
+ ang = "Physical model identifier",
+ ),
+
+) # Fin PROC MODEL
+# Ordre Catalogue MODEL
+
+
+
+
+VARIABLE = PROC ( nom = "VARIABLE",
+ op = None,
+ docu = "",
+ fr = "Variable probabiliste",
+ ang = "Probabilistic variable",
+
+ ModelVariable = SIMP ( statut = "o",
+ typ = ( variable, ),
+ fr = "Variable d'entrée du modèle",
+ ang = "Input variable of the model",
+ ),
+
+ Distribution = SIMP ( statut = "o",
+ typ = ( loi, ),
+ fr = "Modélisation probabiliste",
+ ang = "Probabilistic modelisation",
+ ),
+
+) # Fin PROC VARIABLE
+# Ordre Catalogue VARIABLE
+
+
+CORRELATION = PROC ( nom = 'CORRELATION',
+ op = None,
+ docu = "",
+ fr = "Correlation entre variables",
+ ang = "Variable correlation",
+
+ Copula = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( "Independent", "Normal" ),
+ defaut = "Independent",
+ fr = "Type de la copule",
+ ang = "Copula kind",
+ ),
+
+ Matrix = BLOC ( condition = "Copula in ( 'Normal', )",
+
+ CorrelationMatrix = SIMP ( statut = "o",
+ typ = Matrice(nbLigs=None,
+ nbCols=None,
+ methodeCalculTaille='NbDeVariables',
+ valSup=1,
+ valMin=-1,
+ structure="symetrique"),
+ fr = "Matrice de correlation entre les variables d'entree",
+ ang = "Correlation matrix for input variables",
+ ),
+ ), # Fin BLOC Matrix
+
+
+) # Fin PROC CORRELATION
+# Ordre Catalogue CORRELATION
+
+
+
+
+
+#================================
+# Definition de l'etude
+#================================
+
+# Nota : les variables de type PROC doivent etre en majuscules !
+CRITERIA = PROC ( nom = "CRITERIA",
+ op = None,
+ docu = "",
+ fr = "Critère de l'étude d'incertitudes",
+ ang = "Uncertainty study criteria",
+
+
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Min/Max", "Central Uncertainty", "Threshold Exceedence" ),
+ fr = "Type du critère",
+ ang = "Criteria type",
+ ),
+
+
+
+
+
+
+
+ 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 = "Type du plan d'expérience",
+ ang = "Experiment plane type",
+ ),
+
+ Levels = SIMP ( statut = "o",
+ typ = "R",
+ val_min = 0.0,
+ max = '**',
+ fr = "Liste de niveaux dans chaque direction",
+ ang = "Levels in each direction",
+ ),
+
+ # Scaled Vector
+ UnitPerDimension = SIMP ( statut = "o",
+ typ = "R",
+ max = '**',
+ fr = "Unité par dimension (autant que de variables declarées)",
+ ang = "Units per dimension (as much as declared variables)",
+ ),
+
+ # Translation Vector
+ Center = SIMP ( statut = "o",
+ typ = "R",
+ max = '**',
+ fr = "Centre du plan d'expérience",
+ ang = "Experiment plan center",
+ ),
+
+ ), # Fin BLOC ExperimentPlaneSettings
+
+
+
+ RandomSamplingSettings = BLOC ( condition = " Method in ( 'Random Sampling', ) ",
+
+ SimulationsNumber = 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 de la variable d'intérêt",
+ 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 = 'no',
+ max = 1,
+ fr = "Moyenne au second ordre",
+ ang = "MeanSecondOrder",
+ ),
+
+ ImportanceFactor = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Facteur d'importance pour variable de sortie scalaire",
+ ang = "ImportanceFactor",
+ ),
+ ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ",
+
+ ImportanceFactorDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des facteurs d'importance",
+ ang = "Importance Factor Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ImportanceFactorSettings
+
+ ), # Fin FACT Result
+
+ ), # Fin BLOC TaylorVarianceDecompositionSettings
+
+
+
+ RandomSamplingSettings = BLOC ( condition = " Method in ( 'Random Sampling', ) ",
+
+ SimulationsNumber = 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
+
+ CorrelationAnalysis = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Correlations analysees",
+ ang = "Analysed correlations",
+ ),
+
+ KernelSmoothing = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Kernel smoothing de l'echantillon",
+ ang = "Kernel smoothing of the sample",
+ ),
+
+ KernelSmoothingSettings = BLOC ( condition = " KernelSmoothing in ( 'yes', ) ",
+
+ KernelSmoothingDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique de la reconstruction a noyau",
+ ang = "Kernel Smoothing Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC KernelSmoothingSettings
+
+ ), # 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", "FORM_SORM" ),
+ 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 = "o",
+ 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 = "o",
+ typ = "R",
+ max = 1,
+ defaut = 0.1,
+ val_min = 0.0,
+ val_max = 1.0,
+ fr = "Coefficient de variation maximum",
+ ang = "Maximum coefficient of variation"
+ ),
+
+ ImportanceSamplingSettings = BLOC ( condition = " Algorithm in ( 'ImportanceSampling', ) ",
+
+ MeanVector = SIMP ( statut = "o",
+ typ = "R",
+ max = "**",
+ fr = "Moyenne",
+ ang = "Mean vector",
+ ),
+
+
+ ), # 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 = "Intervale de confiance",
+ ang = "Confidence interval",
+ ),
+
+ 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 = "Coefficient of variation",
+ ),
+
+ SimulationsNumber = 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",
+ ),
+
+ ConvergenceGraphSettings = BLOC ( condition = " ConvergenceGraph in ( 'yes', ) ",
+
+ ConvergenceDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique de la convergence",
+ ang = "Convergence Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ConvergenceGraphSettings
+
+ ), # Fin FACT Result
+
+
+
+ ), # Fin BLOC SimulationSettings
+
+
+
+ FORM_SORMSettings = BLOC ( condition = " Method in ( 'FORM_SORM', ) ",
+
+ 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 = "Optimization 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 = "o",
+ typ = "R",
+ max = 1,
+ defaut = 1E-4,
+ val_min = 0.0,
+ fr = "Distance maximum absolue entre 2 iterations successives",
+ ang = "Absolute maximum distance between 2 successive iterates",
+ ),
+
+ MaximumRelativeError = SIMP ( statut = "o",
+ 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 = "o",
+ 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",
+ ),
+
+ FORMResult = 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 = 'yes',
+ max = 1,
+ fr = "Facteur d'importance pour variable de sortie scalaire",
+ ang = "Importance factor",
+ ),
+
+ ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ",
+
+ ImportanceFactorDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des facteurs d'importance",
+ ang = "Importance Factor Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ImportanceFactorSettings
+
+ SensitivityAnalysis = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ 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 = 'yes',
+ max = 1,
+ fr = "Indice de fiabilite de Hasofer",
+ ang = "Hasofer reliability index",
+ ),
+
+ FORMEventProbabilitySensitivitySettings = BLOC ( condition = " FORMEventProbabilitySensitivity in ( 'yes', ) ",
+
+ FORMEventProbabilitySensitivityDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des sensibilites",
+ ang = "Sensitivity Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC FORMEventProbabilitySensitivitySettings
+
+ HasoferReliabilityIndexSensitivity = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Indice de fiabilite de Hasofer",
+ ang = "Hasofer reliability index",
+ ),
+
+ HasoferReliabilityIndexSensitivitySettings = BLOC ( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ",
+
+ HasoferReliabilityIndexSensitivityDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des sensibilites",
+ ang = "Sensitivity Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC FHasoferReliabilityIndexSensitivitySettings
+
+ ), # Fin BLOC SensitivityAnalysisSettings
+
+ FunctionCallsNumber = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Nombre d'appels a la fonction",
+ ang = "Function calls number",
+ ),
+
+
+ ), # Fin BLOC FORMResult
+
+
+ SORMResult = BLOC ( condition = " Approximation in ( 'SecondOrder', ) ",
+
+
+ TvedtApproximation = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Approximation de Tvedt",
+ ang = "Tvedt approximation",
+ ),
+
+ HohenBichlerApproximation = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Approximation de HohenBichler",
+ ang = "HohenBichler approximation",
+ ),
+
+ BreitungApproximation = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ 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 = 'yes',
+ max = 1,
+ fr = "Facteur d'importance pour variable de sortie scalaire",
+ ang = "Importance factor",
+ ),
+
+ ImportanceFactorSettings = BLOC ( condition = " ImportanceFactor in ( 'yes', ) ",
+
+ ImportanceFactorDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des facteurs d'importance",
+ ang = "Importance Factor Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC ImportanceFactorSettings
+
+ SensitivityAnalysis = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ 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 = 'yes',
+ max = 1,
+ fr = "Indice de fiabilite de Hasofer",
+ ang = "Hasofer reliability index",
+ ),
+
+ HasoferReliabilityIndexSensitivitySettings = BLOC ( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ",
+
+ HasoferReliabilityIndexSensitivityDrawingFilename = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier graphique des sensibilites",
+ ang = "Sensitivity Drawing Filename",
+ ),
+
+
+ ), # Fin BLOC FHasoferReliabilityIndexSensitivitySettings
+
+ ), # Fin BLOC SensitivityAnalysisSettings
+
+ FunctionCallsNumber = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'yes',
+ max = 1,
+ fr = "Nombre d'appels a la fonction",
+ ang = "Function calls number",
+ ),
+
+
+ ), # Fin BLOC SecondOrder
+
+
+
+ ), # Fin BLOC FORM_SORMSettings
+
+
+
+ ), # Fin BLOC ThresholdExceedence
+
+
+
+) # Fin PROC CRITERIA
+# Ordre Catalogue CRITERIA
+
+
+
+
+
+
+
catalogues = (
# (code,version,catalogue,formatIn,formatOut)
- #('OPENTURNS_WRAPPER','V1',os.path.join(rep_cata,'OpenTURNS_Cata_Wrapper_V1.py'),'openturns_wrapper','wrapper'),
- ('OPENTURNS_STUDY','V6',os.path.join(rep_cata,'OpenTURNS_Cata_Study_V6.py'),'openturns_study','wrapper'),
- #('OPENTURNS_STUDY','V4',os.path.join(rep_cata,'OpenTURNS_Cata_Study_VPN.py'),'openturns_study','wrapper'),
- #('OPENTURNS','Wrapper',os.path.join(rep_cata,'OpenTURNS_Cata_Wrapper_V1.py'),'openturns'),
+ ('OPENTURNS_STUDY','V8',os.path.join(rep_cata,'OpenTURNS_Cata_Study_V8.py'),'openturns_study','wrapper'),
)
"marginal" : "marginal",
"collection" : "collection",
"copula" : "copula",
+ "correlation" : "correlation",
+ "R" : "R",
+ "vars" : "vars",
"description" : "description",
"inputRandomVector" : "inputRandomVector",
"outputRandomVector" : "outputRandomVector",
txt = "# Charge le modele physique\n"
txt = "%s = WrapperFile( '%s' )\n" % (self.variable["wrapper"], name)
+ txt += "%s = %s.getWrapperData()\n" % (self.variable["wrapperdata"], self.variable["wrapper"])
txt += "# Ces lignes sont utiles pour le fonctionnement du script sous Salome\n"
txt += "if globals().has_key('%s'):\n" % self.variable["framework"]
- txt += " %s = %s.getWrapperData()\n" % (self.variable["wrapperdata"], self.variable["wrapper"])
txt += " %s = %s.getFrameworkData()\n" % (self.variable["frameworkdata"], self.variable["wrapperdata"])
txt += " %s.studyid_ = %s['%s']\n" % (self.variable["frameworkdata"], self.variable["framework"], self.variable["studyid"])
txt += " %s.studycase_ = %s['%s']\n" % (self.variable["frameworkdata"], self.variable["framework"], self.variable["studycase"])
Cree la copule de la loi jointe
'''
txt = "# Definit la copule de la loi jointe\n"
- txt += "%s = IndependentCopula( %s )\n" % (self.variable["copula"], self.variable["n"])
+
+ if ( self.DictMCVal.has_key( 'Copula' ) ):
+ if ( self.DictMCVal[ 'Copula' ] in ( 'Independent', ) ):
+ txt += "%s = IndependentCopula( %s )\n" % (self.variable["copula"], self.variable["n"])
+ elif ( self.DictMCVal[ 'Copula' ] in ( 'Normal', ) ):
+ varList = self.DictMCVal[ 'CorrelationMatrix' ][0]
+ dimension = len(varList)
+ txt += "%s = {}\n" % self.variable["correlation"]
+ for i in range( dimension ):
+ txt += "%s['%s'] = {}\n" % (self.variable["correlation"], varList[i])
+ for j in range ( dimension ):
+ txt += "%s['%s']['%s'] = %g\n" % (self.variable["correlation"], varList[i], varList[j], self.DictMCVal[ 'CorrelationMatrix' ][i+1][j])
+ txt += "%s = getCorrelationMatrixFromMap( %s.getVariableList(), %s )\n" % (self.variable["R"], self.variable["wrapperdata"], self.variable["correlation"])
+ txt += "%s = NormalCopula( %s )\n" % (self.variable["copula"], self.variable["R"])
+
txt += "\n"
return txt
if ( self.DictMCVal.has_key( 'MeanFirstOrder' ) ):
if ( self.DictMCVal[ 'MeanFirstOrder' ] == "yes" ):
txt += "%s = %s.getMeanFirstOrder()\n" % (self.variable["meanFirstOrder"], self.variable["myQuadraticCumul"])
- txt += "print '%s = ', %s\n" % ("meanFirstOrder", self.variable["meanFirstOrder"])
+ txt += "print '%s = ', %s\n" % ("mean First Order", self.variable["meanFirstOrder"])
txt += "\n"
if ( self.DictMCVal.has_key( 'MeanSecondOrder' ) ):
if ( self.DictMCVal[ 'MeanSecondOrder' ] == "yes" ):
txt += "%s = %s.getMeanSecondOrder()\n" % (self.variable["meanSecondOrder"], self.variable["myQuadraticCumul"])
- txt += "print '%s = ', %s\n" % ("meanSecondOrder", self.variable["meanSecondOrder"])
+ txt += "print '%s = ', %s\n" % ("mean Second Order", self.variable["meanSecondOrder"])
txt += "\n"
if ( self.DictMCVal.has_key( 'StandardDeviationFirstOrder' ) ):
txt += "dim = %s.getDimension()\n" % self.variable["standardDeviationFirstOrder"]
txt += "for i in range( dim ):\n"
txt += " %s[ i, i ] = math.sqrt( %s[ i, i ] )\n" % (self.variable["standardDeviationFirstOrder"], self.variable["standardDeviationFirstOrder"])
- txt += "print '%s = ', %s\n" % ("standardDeviationFirstOrder", self.variable["standardDeviationFirstOrder"])
+ txt += " print '%s = ', %s[ i, i ]\n" % ("standard Deviation First Order", self.variable["standardDeviationFirstOrder"])
txt += "\n"
if ( self.DictMCVal.has_key( 'ImportanceFactor' ) ):
if ( self.DictMCVal.has_key( 'EmpiricalMean' ) ):
if ( self.DictMCVal[ 'EmpiricalMean' ] == "yes" ):
txt += "%s = %s.computeMean()\n" % (self.variable["empiricalMean"], self.variable["outputSample"])
- txt += "print '%s =', %s\n" % ("empiricalMean", self.variable["empiricalMean"])
+ txt += "print '%s =', %s[0]\n" % ("empirical Mean", self.variable["empiricalMean"])
txt += "\n"
if ( self.DictMCVal.has_key( 'EmpiricalStandardDeviation' ) ):
txt += "dim = %s.getDimension()\n" % self.variable["empiricalStandardDeviation"]
txt += "for i in range( dim ):\n"
txt += " %s[ i, i ] = math.sqrt( %s[ i, i ] )\n" % (self.variable["empiricalStandardDeviation"], self.variable["empiricalStandardDeviation"])
- txt += "print '%s = ', %s\n" % ("empiricalStandardDeviation", self.variable["empiricalStandardDeviation"])
+ txt += " print '%s = ', %s[ i, i ]\n" % ("empirical Standard Deviation", self.variable["empiricalStandardDeviation"])
txt += "\n"
if ( self.DictMCVal.has_key( 'EmpiricalQuantile_Order' ) ):
ordre = self.DictMCVal[ 'EmpiricalQuantile_Order' ]
txt += "%s = %s.computeQuantile( %s )\n" % (self.variable["empiricalQuantile"], self.variable["outputSample"], ordre)
- txt += "print '%s ( %s ) =', %s\n" % ("empiricalQuantile", ordre, self.variable["empiricalQuantile"])
+ txt += "print '%s ( %s ) =', %s\n" % ("empirical Quantile", ordre, self.variable["empiricalQuantile"])
txt += "\n"
if ( self.DictMCVal.has_key( 'CorrelationAnalysis' ) ):
if ( self.DictMCVal.has_key( 'StandardDeviation' ) ):
if ( self.DictMCVal[ 'StandardDeviation' ] == "yes" ):
txt += "%s = math.sqrt( %s.getProbabilityEstimate() )\n" % (self.variable["standardDeviation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("standardDeviation", self.variable["standardDeviation"])
+ txt += "print '%s =', %s\n" % ("standard Deviation", self.variable["standardDeviation"])
txt += "\n"
if ( self.DictMCVal.has_key( 'ConfidenceInterval' ) and self.DictMCVal.has_key( 'Probability' ) ):
if ( self.DictMCVal.has_key( 'VariationCoefficient' ) ):
if ( self.DictMCVal[ 'VariationCoefficient' ] == "yes" ):
txt += "%s = %s.getCoefficientOfVariation()\n" % (self.variable["coefficientOfVariation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("coefficientOfVariation", self.variable["coefficientOfVariation"])
+ txt += "print '%s =', %s\n" % ("coefficient of Variation", self.variable["coefficientOfVariation"])
txt += "\n"
if ( self.DictMCVal.has_key( 'SimulationsNumber' ) ):
if ( self.DictMCVal[ 'SimulationsNumber' ] == "yes" ):
txt += "%s = %s.getOuterSampling()\n" % (self.variable["simulationNumbers"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("simulationNumbers", self.variable["simulationNumbers"])
+ txt += "print '%s =', %s\n" % ("simulation Numbers", self.variable["simulationNumbers"])
txt += "\n"
if ( self.DictMCVal.has_key( 'ConvergenceGraph' ) and self.DictMCVal.has_key( 'ConfidenceInterval' ) ):
if ( self.DictMCVal.has_key( 'HasoferReliabilityIndex' ) ):
if ( self.DictMCVal[ 'HasoferReliabilityIndex' ] == "yes" ):
txt += "%s = %s.getHasoferReliabilityIndex()\n" % (self.variable["hasoferReliabilityIndex"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("hasoferReliabilityIndex", self.variable["hasoferReliabilityIndex"])
+ txt += "print '%s =', %s\n" % ("hasofer Reliability Index", self.variable["hasoferReliabilityIndex"])
txt += "\n"
if ( self.DictMCVal.has_key( 'DesignPoint' ) ):
if ( self.DictMCVal[ 'DesignPoint' ] == "yes" ):
txt += "%s = %s.getStandardSpaceDesignPoint()\n" % (self.variable["standardSpaceDesignPoint"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("standardSpaceDesignPoint", self.variable["standardSpaceDesignPoint"])
+ txt += "print '%s =', %s\n" % ("standard Space Design Point", self.variable["standardSpaceDesignPoint"])
txt += "%s = %s.getPhysicalSpaceDesignPoint()\n" % (self.variable["physicalSpaceDesignPoint"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("physicalSpaceDesignPoint", self.variable["physicalSpaceDesignPoint"])
+ txt += "print '%s =', %s\n" % ("physical Space Design Point", self.variable["physicalSpaceDesignPoint"])
txt += "\n"
if ( self.DictMCVal.has_key( 'ImportanceFactor' ) ):
if ( self.DictMCVal[ 'ImportanceFactor' ] == "yes" ):
+ txt += "print 'Importance Factors:'\n"
txt += "%s = %s.getImportanceFactors()\n" % (self.variable["importanceFactors"], self.variable["myResult"])
txt += "for i in range(%s.getDimension()):\n" % self.variable["importanceFactors"]
txt += " print %s.getDescription()[i], ':', %s[i]*100., '%%'\n" % (self.variable["distribution"], self.variable["importanceFactors"])
if ( self.DictMCVal.has_key( 'TvedtApproximation' ) ):
if ( self.DictMCVal[ 'TvedtApproximation' ] == "yes" ):
txt += "%s = %s.getEventProbabilityTvedt()\n" % (self.variable["tvedtApproximation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("tvedtApproximation", self.variable["tvedtApproximation"])
+ txt += "print '%s =', %s\n" % ("Tvedt Approximation", self.variable["tvedtApproximation"])
txt += "\n"
if ( self.DictMCVal.has_key( 'HohenBichlerApproximation' ) ):
if ( self.DictMCVal[ 'HohenBichlerApproximation' ] == "yes" ):
txt += "%s = %s.getEventProbabilityHohenBichler()\n" % (self.variable["hohenBichlerApproximation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("hohenBichlerApproximation", self.variable["tvedtApproximation"])
+ txt += "print '%s =', %s\n" % ("HohenBichler Approximation", self.variable["tvedtApproximation"])
txt += "\n"
if ( self.DictMCVal.has_key( 'BreitungApproximation' ) ):
if ( self.DictMCVal[ 'BreitungApproximation' ] == "yes" ):
txt += "%s = %s.getEventProbabilityBreitung()\n" % (self.variable["breitungApproximation"], self.variable["myResult"])
- txt += "print '%s =', %s\n" % ("breitungApproximation", self.variable["breitungApproximation"])
+ txt += "print '%s =', %s\n" % ("Breitung Approximation", self.variable["breitungApproximation"])
txt += "\n"
for i in range(dimension):
txt += "%s[%d] = %g\n" % (self.variable["meanVector"], i, meanVector[i])
- if ( self.DictMCVal.has_key( 'Correlation' ) ):
- if ( self.DictMCVal[ 'Correlation' ] in ( 'Independent', ) ):
- txt += "%s = Normal( %s, CovarianceMatrix( IdentityMatrix( %s ) ) )\n" % (self.variable["importanceDensity"], self.variable["meanVector"], self.variable["n"])
- elif ( self.DictMCVal[ 'Correlation' ] in ( 'Linear', ) ):
- txt += "# Linear correlation not yet implemented\n"
+ txt += "%s = Normal( %s, CovarianceMatrix( IdentityMatrix( %s ) ) )\n" % (self.variable["importanceDensity"], self.variable["meanVector"], self.variable["n"])
txt += "%s = ImportanceSampling( %s, Distribution( %s ) )\n" % (self.variable["myAlgo"], self.variable["myEvent"], self.variable["importanceDensity"])
txt += "\n"
txt += "%s = %s.getGradientCallsNumber() - %s\n" % (self.variable["modelGradientCalls"], self.variable["model"], self.variable["modelGradientCalls"])
txt += "%s = %s.getHessianCallsNumber() - %s\n" % (self.variable["modelHessianCalls"], self.variable["model"], self.variable["modelHessianCalls"])
txt += "\n"
- txt += "print '%s =', %s\n" % ("modelEvaluationCalls", self.variable["modelEvaluationCalls"])
- txt += "print '%s =', %s\n" % ("modelGradientCalls", self.variable["modelGradientCalls"])
- txt += "print '%s =', %s\n" % ("modelHessianCalls", self.variable["modelHessianCalls"])
+ txt += "print '%s =', %s\n" % ("model Evaluation Calls", self.variable["modelEvaluationCalls"])
+ txt += "print '%s =', %s\n" % ("model Gradient Calls", self.variable["modelGradientCalls"])
+ txt += "print '%s =', %s\n" % ("model Hessian Calls", self.variable["modelHessianCalls"])
txt += "\n"
return txt
