From 9ad06a01edbbe9660f8e6af3d01e76d9f805fb73 Mon Sep 17 00:00:00 2001 From: PASCALE NOYRET Date: Mon, 30 May 2022 12:10:40 +0200 Subject: [PATCH] ajout cata_UQ --- ReacteurNumerique/cata_UQ.py | 1702 ++++++++++++++++++++++++++++++++++ 1 file changed, 1702 insertions(+) create mode 100644 ReacteurNumerique/cata_UQ.py diff --git a/ReacteurNumerique/cata_UQ.py b/ReacteurNumerique/cata_UQ.py new file mode 100644 index 00000000..eb4f7851 --- /dev/null +++ b/ReacteurNumerique/cata_UQ.py @@ -0,0 +1,1702 @@ +import os, sys +repInitial = os.path.dirname(os.path.abspath(__file__)) +repEficas = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if os.path.dirname(repInitial) not in sys.path : + sys.path.insert(0,repInitial) +if os.path.dirname(repEficas) not in sys.path : + sys.path.insert(0,repEficas) +import types + +from Accas import OPER, BLOC, FACT, SIMP, ASSD, JDC_CATA, VerifTypeTuple, Matrice, Tuple, AU_MOINS_UN, A_VALIDATOR, PROC +from Noyau.N_VALIDATOR import Valid + +def creeLienVPVI(monMC): + if monMC.valeur == () or monMC.valeur == None : return + print (monMC) + +# a faire +class infFrereMC(Valid): + def __init__(self,nomMCFrere): + self.nomMCFrere = nomMCFrere +# +listeLoiDistribution= ( #"Beta", + #"Exponential", + #"Gamma", + #"Geometric", + #"Gumbel", + #"Histogram", + #"Laplace", + #"Logistic", + #"LogNormal", + #"MultiNomial", + #"NonCentralStudent", + #"Normal", + #"Poisson", + #"Rayleigh", + #"Student", + #"Triangular", + "TruncatedNormal", + "Uniform", + #"UserDefined", + #"Weibull", + ), + +##==== +## Definition des parametres selon le type de la loi +##==== + +def creeBeta ( MuMax=1 ): + MuSimp = SIMP( statut = "o", typ = "R", max = 1, val_max=MuMax, + fr = "Moyenne de la loi", + ang = "Mean value", + ) + BETA = BLOC( condition = "Distribution == '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=MuSimp, + 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 + return BETA + +def creeExponential (): + EXPONENTIAL = BLOC( condition = " Distribution 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 + return EXPONENTIAL + +#def creeGamma (): +# GAMMA = BLOC( condition = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 = " Distribution 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 +# +# +# +def creeTruncatedNormal(): + TRUNCATEDNORMAL = BLOC( condition = " Distribution 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 + return TRUNCATEDNORMAL + + +def verifieBorneInUniforme(self): + if self.valeur < self.parent.getChild('A').valeur : print ('uuuuuuuuuuuuuuuuuu') + if self.valeur < self.parent.getChild('A').valeur : return ( "il faut A < B") + +def creeUniform(): + UNIFORM = BLOC( condition = " Distribution in ( 'Uniform', ) ", + + A = SIMP( statut = "o", + typ = "R", + max = 1, + defaut=0, + #fr = "Borne inferieure du support de la loi | A < B", + #ang = "Support lower bound | A < B", + ), + + B = SIMP( statut = "o", + typ = "R", + max = 1, + defaut=200, + #fr = "Borne superieure du support de la loi | A < B", + #ang = "Support upper bound | A < B", + #siValide=verifieBorneInUniforme, + #validators=[infFrereMC('A'),] + ), + ) # Fin BLOC UNIFORM + return UNIFORM + +# +# +# USERDEFINED = BLOC( condition = " Distribution in ( 'UserDefined', ) ", +# +# # Il faut definir une collection de couples ( x,p ) +# Values = SIMP( statut = 'o', +# typ = 'R', +# max = '**', +# ), +# +# ), # Fin BLOC USERDEFINED +# +# +# +# WEIBULL = BLOC( condition = " Distribution 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 +# +# +# +##================================ +## Definition du modele physique +##================================ +# +# +#Deterministic_variable = OPER ( nom = "Deterministic_variable", +# sd_prod = variable, +# op = None, +# fr = "Variable deterministe", +# ang = "Deterministic variable", +# UIinfo={"groupes":("UQ",)}, +# +# 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 +# +# +# +# +#Correlation = PROC ( nom = 'Correlation', +# op = None, +# docu = "", +# fr = "Correlation entre variables", +# ang = "Variable correlation", +# UIinfo={"groupes":("UQ",)}, +# +# 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 +# +# +# +# +# +##================================ +## 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", +# UIinfo={"groupes":("UQ",)}, +# +# +# +# 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 +# +# +## -------------------------------------------------- +## Niveau de Journalisation +## -------------------------------------------------- +# +#Journalisation_Code = PROC ( nom = "Journalisation_Code", +# docu = "", +# UIinfo={"groupes":("UQ",)}, +# +# 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 Niveaux_Log_Code +# +# +# +# +# + +def affineDistribution(monDico,var,loi): + nomLoi=list(monDico[var].keys())[0] + argsLoi=loi[nomLoi] + nomFonction='cree'+nomLoi + maFonction=globals()[nomFonction] + bloc=maFonction(**argsLoi) + + +def creeDistributionsSelonVariable(monDico): + lesBlocs={} + for var in monDico : + listeLoisComplete=monDico[var] + listeChoix=[] + for loi in listeLoisComplete: + nomLoi=list(loi.keys())[0] + listeChoix.append(nomLoi) + nomBlocVar = 'b_Model_Variable_' + var + laCondition ="ModelVariable == '" + var + "'" + distribution = SIMP(statut='o', typ='TXM', into=listeChoix) + dicoDistribution={} + for loi in listeLoisComplete: + nomLoi = list(loi.keys())[0] + argsLoi = loi[nomLoi] + nomFonction = 'cree'+nomLoi + maFonction = globals()[nomFonction] + bloc = maFonction(**argsLoi) + nomBloc = 'b_Model_Variable_' + var+'_'+nomLoi + dicoDistribution[nomBloc]=bloc + lesBlocs[nomBlocVar]= BLOC(condition=laCondition, Distribution = distribution, **dicoDistribution) + print (lesBlocs) + return lesBlocs + + + +def creeOperExpressionIncertitude(monDico, maListe): + listeDesVariablesPossibles = list(monDico.keys()) + listeDesVariablesSortiePossibles = maListe + modelVariable = SIMP ( statut = "o", + typ = ( 'TXM'), + fr = "Variable d'entrée du modèle", + ang = "Input variable of the model", + into = listeDesVariablesPossibles, + fenetreIhm='menuDeroulant', + homo='constant', + ) + laConsigne = SIMP(statut="o", homo="information", typ="TXM", defaut=' ') + xPathVariable = SIMP(statut='d', typ='TXM', defaut=(), max='**', min=0,)# siValide=creeLienVPVI) + blocs=creeDistributionsSelonVariable(monDico) + # Attention + # l ordre des motclefs en 3.7 a l air de dépendre de l ordre de creation des objets + # et non d un dict ordonné. on retombe toujours sur ce pb + return PROC ( nom = "ExpressionIncertitude", #UIinfo={"groupes":("CACHE",)}, + Input = FACT( max=1, statut ='o', + VariableProbabiliste = FACT ( max='**', statut ='cache', + fr = "Variable probabiliste", + ang = "Probabilistic variable", + ModelVariable = modelVariable, + Consigne = laConsigne, + xPathVariable = xPathVariable, + **blocs + ), + ), + Propagation = FACT( max=1, statut ='o', + Methode = SIMP( statut = "o", typ = "TXM", max=1, into = ('Taylor', 'MonteCarlo'), defaut='Taylor'), + BlocMonteCarlo1 = BLOC ( condition = "Methode == 'MonteCarlo'", + SimulationsNumber = SIMP ( statut = "o", typ = "I", val_min = 1, + fr = "Nombre de points", + ang = "Points number",), + + ), + BlocTaylor = BLOC( condition = "Methode == 'Taylor'", + Result = FACT( statut = "o", min = 1, + MeanFirstOrder = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes', + fr = "Moyenne au premier ordre", + ang = "MeanFirstOrder",), + StandardDeviationFirstOrder = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes', + fr = "Ecart-type au premier ordre", + ang = "StandardDeviationFirstOrder",), + MeanSecondOrder = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'no', + fr = "Moyenne au second ordre", + ang = "MeanSecondOrder",), + ),# fin Result + ), # fin BlocTaylor + BlocMonteCarlo2 = BLOC ( condition = "Methode == 'MonteCarlo'", + Result = FACT( statut = "o", min = 1, + EmpiricalMean = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes', + fr = "Moyenne empirique", + ang = "Empirical mean",), + EmpiricalStandardDeviation = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes', + fr = "Ecart-type empirique", + ang = "Empirical standard deviation",), + EmpiricalQuantile = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes', + fr = "Quantile empirique", + ang = "Empirical quantile",), + BlocEmpiricalQuantileSettings = BLOC ( condition = " EmpiricalQuantile in ( 'yes', ) ", + EmpiricalQuantile_Order = SIMP ( statut = "o", typ = 'R', defaut = 0.95, + val_min = 0.0, val_max = 1.0, + fr = "Ordre du quantile empirique", + ang = "Empirical quantile order",), + ), # Fin BlocEmpiricalQuantileSettings + ),# fin Result + ),# fin BlocMonteCarlo2 + ), # fin Propoagation + Output = FACT (max=1, statut ='o', + VariableDeSortie = FACT ( max='**', statut ='o', + NomDeLaVariable = SIMP ( statut = "o", typ = "TXM", into = listeDesVariablesSortiePossibles, defaut='Average_mass_flux'), + Physique = SIMP (statut = "o", typ = "TXM",into = ('Neutronics', 'ThermoHydraulics'),defaut='Neutronics'), + FonctionDAggregation = SIMP(statut = 'o', typ= 'TXM', into = ('Max', 'Min', 'Med', 'Moy', 'Sum'),defaut=('Max'), max='**', homo='SansOrdreNiDoublon'), + Unit = SIMP ( statut = "f", typ = "TXM", fr = "Unite", ang = "Unit",), + Format = SIMP ( statut = "f", typ = "TXM", fr = "Format de sortie", ang = "format", into =['med', 'csv']), + ), + ), + Execution = FACT (max=1, statut ='o', + UncertaintyTool = SIMP ( statut = "o", typ = "TXM", into = ['Uranie', 'OpenTurns'], defaut='Uranie'), + bloc_OT = BLOC (condition = 'UncertaintyTool == "OpenTurns"', + ExecutionMode = SIMP ( statut = "o", typ = "TXM", into = ['local', 'cluster']), + NbDeBranches = SIMP ( statut = "o", typ = "I", val_min = 0, fr='nb d evaluations simultanees'), + JobName = SIMP ( statut = 'o', typ ="TXM", defaut='idefix_job'), + NbOfProcs = SIMP ( statut = 'o', typ ="I" , defaut = 1, val_min = 1), + bloc_OT_local = BLOC (condition = 'ExecutionMode == "local"', + ), + bloc_OT_cluster = BLOC (condition = 'ExecutionMode == "cluster"', + resourceName = SIMP ( statut = 'o', typ ="TXM", defaut ='gaia'), + multiJobStudy = SIMP ( statut = "o", typ = bool, defaut=False), + ), + ), + ), + ) + return ExpressionIncertitude + -- 2.39.2