import prefs
from InterfaceTK import eficas_go
-eficas_go.lance_eficas()
+eficas_go.lance_eficas(code=prefs.code)
--- /dev/null
+# -*- coding: utf-8 -*-
+
+# --------------------------------------------------
+# debut entete
+# --------------------------------------------------
+
+import Accas
+from Accas import *
+
+class loi (ASSD) : pass
+
+
+#CONTEXT.debug=1
+JdC = JDC_CATA(code='OPENTURNS',
+ execmodul=None,
+ regles = (AU_MOINS_UN('DONNEES_OPENTURNS'),),
+
+ ) # Fin JDC_CATA
+
+# --------------------------------------------------
+# fin entete
+# --------------------------------------------------
+
+# 3. Version d OPENTURNS ?
+
+#===========================================================
+
+
+#================================
+# 1. Definition des LOIS
+#
+# TODO --> verifier que l expression reguliere se compile en python
+#
+#================================
+
+LoiMarginale = OPER(nom="LoiMarginale",
+ sd_prod=loi,
+ op=68,
+ fr="loi",
+
+ TypeDeLoi = SIMP(statut="o",
+ typ="TXM",
+ into=("Beta",
+ "Exponentielle",
+ "DefinieParUtilisateur",
+ "Gamma",
+ "Geometrique",
+ "Gumbel",
+ "Histogramme",
+ "Logistique",
+ "LogNormale",
+ "MultiNomiale",
+ "Normale",
+ "NormaleTronquee",
+ "Poisson",
+ "Student",
+ "Triangulaire",
+ "Uniforme",
+ "Weibull",
+ ),
+ defaut="Normale",
+ fr="Type de la loi 1D",
+ ang="Distribution 1D"),
+#
+# Loi beta
+#
+ b_beta = BLOC(condition="TypeDeLoi=='Beta'",
+
+ Parametrage = SIMP(statut="o",
+ typ="TXM",
+ max=1,
+ into=("RT","MuSigma"),
+ defaut="RT",
+ fr="Parametrage de la loi beta",
+ ang="Beta distribution parameter set"),
+
+ b_param_rt = BLOC(condition="Parametrage=='RT'",
+
+ R = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ val_min=0.,
+ fr="Parametre R de la loi",
+ ang="R parameter"),
+
+ # T > R
+ T = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre T de la loi | T > R",
+ ang="T parameter | T > R"),
+
+ ), # Fin BLOC
+
+
+ b_param_ms = BLOC(condition="Parametrage=='MuSigma'",
+
+ Mu = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu de la loi",
+ ang="Mu parameter"),
+
+ Sigma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Sigma de la loi | Sigma > 0",
+ ang="Sigma parameter | Sigma > 0"),
+
+ ), # Fin BLOC
+
+
+ A = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre A de la loi",
+ ang="A parameter"),
+
+ # B > A
+ B = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ fr="Parametre B de la loi | B > A",
+ ang="B parameter | B > A"),
+
+ ), # Fin BLOC
+
+#
+# Loi exponentielle
+#
+ b_exponentielle = BLOC(condition="TypeDeLoi=='Exponentielle'",
+
+ Lambda = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Lambda | Lambda > 0",
+ ang="Lambda parameter | Lambda > 0"),
+
+ Gamma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ fr="Parametre Gamma",
+ ang="Gamma parameter"),
+
+ ), # Fin BLOC
+
+#
+# Loi definie par l'utilisateur
+#
+ b_def_utilisateur = BLOC(condition="TypeDeLoi=='DefinieParUtilisateur'",
+
+ # Il faut definir une collection de couples (x,p)
+
+
+ ), # Fin BLOC
+
+#
+# Loi gamma
+#
+ b_gamma = BLOC(condition="TypeDeLoi=='Gamma'",
+
+ Parametrage = SIMP(statut="o",
+ typ="TXM",
+ max=1,
+ into=("KLambda","MuSigma"),
+ defaut="KLambda",
+ fr="Parametrage de la loi gamma",
+ ang="Gamma distribution parameter set"),
+
+ b_param_kl = BLOC(condition="Parametrage=='KLambda'",
+
+ K = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre K de la loi | K > 0",
+ ang="K parameter | K > 0"),
+
+ Lambda = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Lambda de la loi | Lambda > 0",
+ ang="Lambda parameter | Lambda > 0"),
+
+ ), # Fin BLOC
+
+
+ b_param_ms = BLOC(condition="Parametrage=='MuSigma'",
+
+ Mu = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu de la loi",
+ ang="Mu parameter"),
+
+ Sigma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Sigma de la loi | Sigma > 0",
+ ang="Sigma parameter | Sigma > 0"),
+
+ ), # Fin BLOC
+
+ Gamma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ fr="Parametre Gamma",
+ ang="Gamma parameter"),
+
+
+ ), # Fin BLOC
+
+#
+# Loi geometrique
+#
+ b_geometrique = BLOC(condition="TypeDeLoi=='Geometrique'",
+
+ P = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.5,
+ val_min=0.,
+ val_max=1.,
+ fr="Parametre P | 0 < P < 1",
+ ang="P parameter | 0 < P < 1"),
+
+ ), # Fin BLOC
+
+#
+# Loi gumbel
+#
+ b_gumbel = BLOC(condition="TypeDeLoi=='Gumbel'",
+
+ Parametrage = SIMP(statut="o",
+ typ="TXM",
+ max=1,
+ into=("AlphaBeta","MuSigma"),
+ defaut="AlphaBeta",
+ fr="Parametrage de la loi gumbel",
+ ang="Gumbel distribution parameter set"),
+
+ b_param_ab = BLOC(condition="Parametrage=='AlphaBeta'",
+
+ Alpha = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ val_min=0.,
+ fr="Parametre Alpha de la loi | Alpha > 0",
+ ang="Alpha parameter | Alpha > 0"),
+
+ Beta = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Beta de la loi",
+ ang="Beta parameter"),
+
+ ), # Fin BLOC
+
+
+ b_param_ms = BLOC(condition="Parametrage=='MuSigma'",
+
+ Mu = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu de la loi",
+ ang="Mu parameter"),
+
+ Sigma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Sigma de la loi | Sigma > 0",
+ ang="Sigma parameter | Sigma > 0"),
+
+ ), # Fin BLOC
+
+ ), # Fin BLOC
+
+#
+# Loi histogramme
+#
+ b_histogramme = BLOC(condition="TypeDeLoi=='Histogramme'",
+
+ Sup = SIMP(statut="o",
+ typ="R",
+ max=1,
+ fr="Borne superieure de la distribution",
+ ang="Upper bound"),
+
+ # Il faut definir une collection de couples (x,p)
+
+
+ ), # Fin BLOC
+
+#
+# Loi lognormale
+#
+ b_lognormale = BLOC(condition="TypeDeLoi=='LogNormale'",
+
+ Parametrage = SIMP(statut="o",
+ typ="TXM",
+ max=1,
+ into=("MuSigmaLog","MuSigma","MuSigmaOverMu"),
+ defaut="MuSigmaLog",
+ fr="Parametrage de la loi lognormale",
+ ang="Lognormal distribution parameter set"),
+
+ b_param_msl = BLOC(condition="Parametrage=='MuSigmaLog'",
+
+ MuLog = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu log de la loi",
+ ang="Mu log parameter"),
+
+ SigmaLog = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Sigma log de la loi | SigmaLog > 0",
+ ang="Sigma log parameter | SigmaLog > 0"),
+
+
+ ), # Fin BLOC
+
+
+ b_param_ms = BLOC(condition="Parametrage=='MuSigma'",
+
+ # Mu > Gamma
+ Mu = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu de la loi",
+ ang="Mu parameter"),
+
+ Sigma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Sigma de la loi | Sigma > 0",
+ ang="Sigma parameter | Sigma > 0"),
+
+ ), # Fin BLOC
+
+ b_param_msom = BLOC(condition="Parametrage=='MuSigmaOverMu'",
+
+ Mu = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu de la loi | Mu > Gamma",
+ ang="Mu parameter | Mu > Gamma"),
+
+ SigmaOverMu = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Sigma sur Mu de la loi",
+ ang="Sigma over Mu parameter"),
+
+
+ ), # Fin BLOC
+
+
+ Gamma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ fr="Parametre Gamma",
+ ang="Gamma parameter"),
+
+ ), # Fin BLOC
+
+#
+# Loi logistique
+#
+ b_logistique = BLOC(condition="TypeDeLoi=='Logistique'",
+
+ Alpha = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Alpha de la loi",
+ ang="Alpha parameter"),
+
+ Beta = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Beta de la loi | Beta >= 0",
+ ang="Beta parameter | Beta >= 0"),
+
+ ), # Fin BLOC
+
+#
+# Loi multinomiale
+#
+ b_multinom = BLOC(condition="TypeDeLoi=='MultiNomiale'",
+
+
+ N = SIMP(statut="o",
+ typ="E",
+ max=1,
+ defaut=1,
+ fr="Dimension de la loi",
+ ang="Distribution dimension"),
+
+ # Il faut un vecteur P de taille N
+
+ ), # Fin BLOC
+
+#
+# Loi normale
+#
+ b_normale = BLOC(condition="TypeDeLoi=='Normale'",
+
+ Mu = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu de la loi",
+ ang="Mu parameter"),
+
+ Sigma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Sigma de la loi | Sigma > 0",
+ ang="Sigma parameter | Sigma > 0"),
+
+ ), # Fin BLOC
+
+#
+# Loi normale tronquee
+#
+ b_normale = BLOC(condition="TypeDeLoi=='NormaleTronquee'",
+
+ MuN = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu de la loi",
+ ang="Mu parameter"),
+
+ SigmaN = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre SigmaN de la loi | SigmaN > 0",
+ ang="SigmaN parameter | SigmaN> 0"),
+
+ A = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=-1.0,
+ fr="Borne inferieure de la loi | A <= B",
+ ang="Lower bound | A <= B"),
+
+ B = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ fr="Borne superieure de la loi | A <= B",
+ ang="Upper bound | A <= B"),
+
+ ), # Fin BLOC
+
+#
+# Loi poisson
+#
+ b_poisson = BLOC(condition="TypeDeLoi=='Poisson'",
+
+ Lambda = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Lambda de la loi | Lambda > 0",
+ ang="Lambda parameter | Lambda > 0"),
+
+ ), # Fin BLOC
+
+#
+# Loi student
+#
+ b_student = BLOC(condition="TypeDeLoi=='Student'",
+
+ Mu = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu de la loi",
+ ang="Mu parameter"),
+
+ V = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=2.0,
+ val_min=2.,
+ fr="Parametre V de la loi | V >= 2",
+ ang="V parameter | V >= 2"),
+
+ ), # Fin BLOC
+
+
+#
+# Loi triangulaire
+#
+ b_triang = BLOC(condition="TypeDeLoi=='Triangulaire'",
+
+ A = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=-1.0,
+ fr="Borne inferieure de la loi | A <= M <= B",
+ ang="Lower bound | A <= M <= B"),
+
+ M = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Mode de la loi | A <= M <= B",
+ ang="Mode | A <= M <= B"),
+
+ B = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ fr="Borne superieure de la loi | A <= M <= B",
+ ang="Upper bound | A <= M <= B"),
+
+ ), # Fin BLOC
+#
+# Loi uniforme
+#
+ b_uniforme = BLOC(condition="TypeDeLoi=='Uniforme'",
+
+ A = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=-1.0,
+ fr="Borne inferieure de la loi | A <= B",
+ ang="Lower bound | A <= B"),
+
+ B = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ fr="Borne superieure de la loi | A <= B",
+ ang="Upper bound | A <= B"),
+
+ ), # Fin BLOC
+
+
+#
+# Loi weibull
+#
+ b_weibull = BLOC(condition="TypeDeLoi=='Weibull'",
+
+ Parametrage = SIMP(statut="o",
+ typ="TXM",
+ max=1,
+ into=("AlphaBeta","MuSigma"),
+ defaut="AlphaBeta",
+ fr="Parametrage de la loi weibull",
+ ang="Weibull distribution parameter set"),
+
+ b_param_ab = BLOC(condition="Parametrage=='AlphaBeta'",
+
+ Alpha = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ val_min=0.,
+ fr="Parametre Alpha de la loi | Alpha > 0",
+ ang="Alpha parameter | Alpha > 0"),
+
+ Beta = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Beta de la loi | Beta > 0",
+ ang="Beta parameter | Beta > 0"),
+
+ ), # Fin BLOC
+
+
+ b_param_ms = BLOC(condition="Parametrage=='MuSigma'",
+
+ Mu = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=0.0,
+ fr="Parametre Mu de la loi",
+ ang="Mu parameter"),
+
+ Sigma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ defaut=1.0,
+ val_min=0.,
+ fr="Parametre Sigma de la loi | Sigma > 0",
+ ang="Sigma parameter | Sigma > 0"),
+
+ ), # Fin BLOC
+
+ Gamma = SIMP(statut="o",
+ typ="R",
+ max=1,
+ fr="Parametre Gamma",
+ ang="Gamma parameter"),
+
+ ), # Fin BLOC
+
+ ) # Fin OPER
+
+#================================
+# 2. Definition des VARIABLES
+#
+# TODO --> verifier que l expression reguliere se compile en python
+#
+#================================
+DONNEES_OPENTURNS = PROC(nom="DONNEES_OPENTURNS",
+ op=None,
+ docu="",
+ fr="Mise en donnee pour le fichier de configuration de OPENTURNS.",
+ ang="Writes the configuration file for OPENTURNS.",
+
+ Variable = FACT(statut="o",
+ min=1,
+ max="**",
+
+ NomDsOpenTurns = SIMP(statut="o",
+ typ="TXM",
+ fr="Nom de la variable, dans OpenTurns",
+ ang="Name of the variable for OpenTuurs"),
+
+ Type = SIMP(statut="o",
+ typ="TXM",
+ into=("in", "out",),
+ defaut="in",
+ fr="variable d'entree ou de sortie du solver",
+ ang="Input or output variable"),
+
+ ValeurDefaut = SIMP(statut="f",
+ typ="R",
+ defaut=0.0,
+ fr="valeur par defaut de la variable ",
+ ang="default value"),
+
+
+
+
+ LoiMarginale = SIMP(statut="o",
+ typ=(loi,),
+ fr="Choix de la loi",
+ ang="Distribution"),
+
+ Comment = SIMP(statut="f",
+ typ="TXM",
+ fr="Commentaire",
+ ang="Comment"),
+
+ Unit = SIMP(statut="f",
+ typ="TXM",
+ fr="Unite",
+ ang="Unit"),
+
+ Regexp = SIMP(statut="f",
+ typ="TXM",
+ fr="expression reguliere de lecture",
+ ang="regular expression for reading"),
+
+ Format = SIMP(statut="f",
+ typ="TXM",
+ fr="format d'ecriture",
+ ang="writing format"),
+
+ ), # Fin FACT
+
+#================================================================
+#
+# 4. Informations sur les FICHIERS
+#
+#================================================================
+
+ Fichier = FACT(statut="f",
+ min=1,
+ max="**",
+
+ Identificateur = SIMP(statut="o",
+ typ="TXM",
+ fr="Identificateur du fichier",
+ ang="File id"),
+
+ Type = SIMP(statut="o",
+ typ="TXM",
+ into=("in", "out",),
+ defaut="in",
+ fr="fichier d'entree ou de sortie du solver",
+ ang="Input or Output file"),
+
+ Nom = SIMP(statut="f",
+ typ="TXM",
+ fr="Nom du fichier",
+ ang="file name"),
+
+ Chemin = SIMP(statut="o",
+ typ="TXM",
+ fr="chemin du fichier",
+ ang="path file "),
+
+ ), # Fin FACT
+
+
+#================================================================
+#
+# 5. Informations sur le WRAPPER
+#
+# TODO --> verifier que la chaine de caractere se termine par so
+# Chemin du wrapper devrait finir par .so
+#
+#================================================================
+
+ Wrapper = FACT(statut="o",
+ min=1,
+ max=1,
+
+ Chemin = SIMP(statut="o",
+ typ="TXM",
+ defaut="aster.so",
+ fr="chemin d acces au wrapper",
+ ang="wrapper library path"),
+
+ Fonction = SIMP(statut="o",
+ typ="TXM",
+ fr="Nom de la fonction dans le wrapper",
+ ang="Function's name in wrapper"),
+
+ Gradient = SIMP(statut="f",
+ typ="TXM",
+ fr="gradient",
+ ang="gradient"),
+
+ Hessian = SIMP(statut="f",
+ typ="TXM",
+ fr="hessian",
+ ang="hessian"),
+
+ Mode = FACT(statut="o",
+ min=1,
+ max=1,
+
+ Type = SIMP(statut="o",
+ typ="TXM",
+ into=( "static-link", "dynamic-link","fork",),
+ defaut="static-link",
+ fr="mode de couplage du solver",
+ ang="Solver coupling mode"),
+
+ Etat = SIMP(statut="f",
+ typ="TXM",
+ into=( "shared", "specific"),
+ defaut="shared",
+ fr="partage de l etat interne entre les fonctions",
+ ang="internal state sharing"),
+
+ ModeEntree = SIMP(statut="o",
+ typ="TXM",
+ into=( "files","pipe","arguments","socket","CORBA",),
+ defaut="files",
+ fr="mode de transfert des donn? d entree",
+ ang="input transfering mode"),
+
+ ModeSortie = SIMP(statut="o",
+ typ="TXM",
+ into=( "files","pipe","arguments","socket","CORBA",),
+ defaut="files",
+ fr="mode de transfert des donn? de sortie",
+ ang="output transfering mode"),
+
+ b_Fork = BLOC(condition="Type=='fork'",
+ Commande = SIMP(statut="o",
+ typ="TXM",
+ fr="Chemin du solver",
+ ang="solver path"),
+ ), # Fin BLOC
+
+ ), # Fin FACT
+
+ ), # Fin FACT
+
+#===========================================================
+# 1. Le Type d'Analyse
+#
+# TypeAnalyse : Deterministe (min/max)
+# Probabiliste analyse en valeur centrale
+# Probabiliste analyse en valeur extreme
+#===========================================================
+
+# TypeAnalyse = SIMP(statut="o",typ="TXM",
+# into=("MinMax","Centrale","Extreme"),
+# fr="Type d'Analyse",
+# ang="Analyse",
+# ),
+
+
+#==============
+# 2. Fonction
+#=============
+#
+#
+ Fonction = SIMP(statut="o",
+ typ="TXM",
+ into=("Adaptateur", "Analytique"),
+ fr="Logiciel de calcul",
+ ang="software solver"),
+
+ b_Adaptateur = BLOC(condition="Fonction=='Adaptateur'",
+ NomSolver = SIMP(statut="f",
+ typ="TXM",
+ into=("Aster","Toto"),
+ fr="Logiciel de calcul",
+ ang="software solver"),
+ ), # Fin BLOC
+
+#====================================================
+# 3. Cas dune analyse probabiliste en valeur extreme
+#====================================================
+ #
+ b_Extreme = BLOC(condition="TypeAnalyse=='Extreme'",
+
+
+ MethodeSimulaton = SIMP(statut="f",
+ typ="TXM",
+ into=( "MonteCarlo brut", "MonteCarlo LHS" ,
+ "Simulation directionnelle", "FORM" ,
+ "FORM MonteCarlo Pt Conception ", "SORM",) ,
+ fr="Methode de Simulation",
+ ang=" Simulation Method"),
+ ), # Fin BLOC
+
+
+ ) # Fin PROC
+
+
+
+
+
+# Loi lognormale
+#
+# b_lognormale=BLOC(condition="Loi=='LogNormale'",
+#
+# ValeMinimale = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur minimale.",
+# ang="Minimal value."),
+
+# Vale_Moyenne = SIMP(statut="f",typ="R",max=1,
+# fr="Valeur moyenne dans l'espace de la loi normale.",
+# ang="Mean value in the space of the normal law."),
+#
+# EcartType = SIMP(statut="f",typ="R",max=1,
+# fr="Ecart type dans l'espace de la loi normale.",
+# ang="Standard deviation in the space of the normal law."),
+#
+# VALE_MOY_PHY = SIMP(statut="f",typ="R",max=1,
+# fr="Valeur moyenne dans l'espace physique.",
+# ang="Mean value in the physical space."),
+#
+# ECART_TYPE_PHY = SIMP(statut="f",typ="R",max=1,
+# fr="Ecart type dans l'espace physique.",
+# ang="Standard deviation in the physical space."),
+#
+# regles=(AU_MOINS_UN("VALE_MOY" ,"VALE_MOY_PHY"),
+# AU_MOINS_UN("ECART_TYPE","ECART_TYPE_PHY"),
+# EXCLUS ("VALE_MOY" ,"VALE_MOY_PHY"),
+# EXCLUS ("VALE_MOY" ,"ECART_TYPE_PHY"),
+# EXCLUS ("ECART_TYPE","VALE_MOY_PHY"),
+# EXCLUS ("ECART_TYPE","ECART_TYPE_PHY")),
+#
+# ),
+
+#
+# ==> Loi uniforme
+#
+# b_uniforme=BLOC(condition="LOI=='UNIFORME'",
+#
+# VALE_MIN = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur minimale.",
+# ang="Minimal value."),
+#
+# VALE_MAX = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur maximale.",
+# ang="Maximal value."),
+
+# ),
+
+# 5.2.4. ==> Loi normale tronqu饊##
+# b_normale_tronquee=BLOC(condition="LOI=='NORMALE_TRONQUEE'",
+##
+# VALE_MOY = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur moyenne de la loi normale compl败.",
+# ang="Mean value for the entire normal law."),
+##
+# ECART_TYPE = SIMP(statut="o",typ="R",max=1,
+# fr="Ecart type de la loi normale compl败.",
+# ang="Standard deviation for the entire normal law."),
+##
+# VALE_MIN = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur minimale.",
+# ang="Minimal value."),
+##
+# VALE_MAX = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur maximale.",
+# ang="Maximal value."),
+##
+# ),
+##
+## 5.3. ==> Param贲es de calcul
+## 5.3.1. ==> Soit on cherche le point de conception, soit on le connait deja
+##
+# regles=(EXCLUS("POINT_INI","POINT_CONCEPT"),
+# EXCLUS("POINT_REF","POINT_CONCEPT"),),
+##
+## 5.3.2. ==> Quand on cherche le point de conception, on peut pr飩ser le d鰡rt de l'algorithme.
+## Si on ne le fait pas, le programme prendra la valeur moyenne.
+##
+# POINT_INI = SIMP(statut="f",typ="R",max=1,
+# fr="Point de d魡rrage de l'algorithme it鲡tif.",
+# ang="Initial point for iterative process."),
+##
+## 5.3.3. ==> Quand on cherche le point de conception, on peut pr飩ser un point de r馩rence pour normaliser.
+## Si on ne le fait pas, le programme prendra la valeur moyenne.
+##
+# POINT_REF = SIMP(statut="f",typ="R",max=1,
+# fr="Point de r馩rence de l'algorithme it鲡tif.",
+# ang="Reference point for iterative process."),
+##
+## 5.3.4. ==> Quand on cherche uniquement la probabilit頤e d馡illance, il faut donner le point de conception
+##
+# POINT_CONCEPT = SIMP(statut="f",typ="R",max=1,
+# fr="Point de conception.",
+# ang="Design point."),
+##
+## 5.4. ==> Mode d'obtention du gradient par rapport ?e param贲e
+##
+# GRADIENT = SIMP(statut="o",typ="TXM",max=1,
+# into=("OUI","NON"),
+# fr="ASTER calcule directement le gradient.",
+# ang="ASTER computes the gradient for this parameter."),
+#
+# b_gradient=BLOC(condition="GRADIENT=='NON'",
+# INCREMENT = SIMP(statut="o",typ="R",max=1,
+# fr="Incr魥nt dans la direction.",
+# ang="Direction increment."),
+# ),
+#
+#
+#
+# Type le plus general
+#class entier (ASSD):pass
+#class reel (ASSD):pass
+#class complexe(ASSD):pass
+#class liste (ASSD):pass
+#class chaine (ASSD):pass
+
+# Types geometriques
+#class no (GEOM):pass
+#class grno(GEOM):pass
+#class ma (GEOM):pass
+#class grma(GEOM):pass
+
+#
+#
+#
+##
+##====
+## 4. Options
+##====
+## 4.1. ==> G鮩rales
+##
+## 4.1.1. ==> La valeur du seuil
+##
+# SEUIL = SIMP(statut="o",typ="R",max=1,
+# fr="Le seuil de d馡illance.",
+# ang="Failure threshold."),
+##
+## 4.1.2. ==> Le type du seuil : on a deux cas de figure selon que
+## la d馡illance a lieu au dessus d'un seuil maximum ou
+## en dessous d'un seuil minimum
+##
+# SEUIL_TYPE = SIMP(statut="o",typ="TXM",max=1,
+# into=("MINIMUM","MAXIMUM"),
+# fr="Que faut-il ne pas d鰡sser : un maximum ou un minimum.",
+# ang="What is the failure threshold : maximum or minimum."),
+##
+## 4.2. ==> Pour MEFISTO
+##
+##
+## 4.2.1. ==> Pilotage de la recherche du point de conception
+##
+# RECH_PT_CONCEPT = SIMP(statut="f",typ="TXM",defaut="OUI",
+# into=("OUI","NON"),
+# fr="Pour trouver le point de conception.",
+# ang="To find the design point."),
+##
+# b_rech_pt_concept=BLOC( condition = "RECH_PT_CONCEPT=='OUI'",
+##
+# EPSILON_U = SIMP(statut="f",typ="R",defaut=1.0E-2,
+# fr="Pr飩sion du test d'arret sur les points it鲡tifs dans l'espace standard.",
+# ang="Precision of stop test for iterative points in standard space."),
+##
+# EPSILON_G = SIMP(statut="f",typ="R",defaut=1.0E-2,
+# fr="Pr飩sion du test d'arret sur la proximit頤e la surface d'鴡t limite.",
+# ang="Precision of stop test for limit state surface."),
+##
+# TAU = SIMP(statut="f",typ="R",defaut=5.0E-1,
+# fr="Param贲e de la m鴨ode de minimisation.",
+# ang="Parameter for the minimization method."),
+##
+# OMEGA = SIMP(statut="f",typ="R",defaut=1.0E-4,
+# fr="Param贲e de la m鴨ode de minimisation.",
+# ang="Parameter for the minimization method."),
+##
+# ITER_MAX = SIMP(statut="f",typ="I",defaut=50,
+# fr="Nombre maximum d'it鲡tions.",
+# ang="Maximum number of iterations."),
+# ),
+##
+## 4.2.2. ==> M鴨ode(s) employ饨s) pour la probabilit頤e d馡illance
+##
+# METHODE_FORM = SIMP(statut="f",typ="TXM",defaut="OUI",
+# into=("OUI","NON"),
+# fr="Recherche de la probabilit頤e d馡illance avec la m鴨ode FORM.",
+# ang="Research of failure probability with FORM method."),
+##
+# METHODE_SORM = SIMP(statut="f",typ="TXM",defaut="NON",
+# into=("OUI","NON"),
+# fr="Recherche de la probabilit頤e d馡illance avec la m鴨ode SORM.",
+# ang="Research of failure probability with SORM method."),
+##
+# TIRAGE_IMPORTANCE = SIMP(statut="f",typ="TXM",defaut="NON",
+# into=("OUI","NON"),
+# fr="Recherche de la probabilit頤e d馡illance avec le tirage d'importance.",
+# ang="Research of failure probability with ."),
+##
+# b_tirage_importance=BLOC( condition = "TIRAGE_IMPORTANCE=='OUI'",
+##
+# NB_SIMULATION = SIMP(statut="f",typ="I",defaut=3,
+# fr="Nombre de simulations pour le tirage d'importance.",
+# ang="Number of simulation for."),
+##
+# ),
+##
+## 4.2.3. ==> Cr顴ion d'une surface de r鰯nse polynomiale
+##
+# POLYNOME_TAYLOR = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),),
+# HGRAD = SIMP(statut="f",typ="R",defaut=1.0E-2,
+# fr="Pas incr魥ntal pour le calcul des gradients.",
+# ang="Step for calculation of gradients."),
+# HHESS = SIMP(statut="f",typ="R",defaut=1.0E-2,
+# fr="Pas incr魥ntal pour le calcul des d鲩v? secondes.",
+# ang="Step for calculation of second derivatives."),
+##
+## 4.2.4. ==> Recherche d'un plan d'exp鲩ence
+##
+# PLAN_EXPERIENCE = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+# fr="Construction d'un plan d'exp鲩ence.",
+# ang="Construction of an experiment plan."),
+##
+# b_plan_experience=BLOC( condition = "PLAN_EXPERIENCE=='OUI'",
+##
+# ALPHA = SIMP(statut="f",typ="R",defaut=2.0E-1,
+# fr="Plan d'exp鲩ence : maille du plan de type composite centr鮢,
+# ang="Experiment plane : mesh centered composite."),
+##
+# BETA = SIMP(statut="f",typ="R",defaut=4.0E-1,
+# fr="Plan d'exp鲩ence : maille du plan de type factoriel.",
+# ang="Experiment plane : mesh factor."),
+##
+# ),
+##
+## 4.2.5. ==> Les tests
+## 4.2.5.1. ==> Test de la sphere
+##
+# T_SPHERE = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+# fr="Test de la sph貥.",
+# ang="Sphere test."),
+##
+# b_test_de_la_sphere=BLOC( condition = "T_SPHERE=='OUI'",
+##
+# METHODE_TEST = SIMP(statut="f",typ="TXM",defaut="GAUSSIENNE",
+# into=("GAUSSIENNE","PARAMETRIQUE","REJECTION"),
+# fr="Type de m鴨ode.",
+# ang="Method."),
+##
+# NB_POINT = SIMP(statut="f",typ="I",max=1,defaut=40,
+# fr="Nombre de points de la sphere.",
+# ang="Number of points over the sphere.")
+# ),
+##
+## 4.2.5.2. ==> Test du maximum fort
+##
+# T_MAXIMUM_FORT = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+# fr="Test du maximum fort.",
+# ang="Strong maximum test."),
+##
+# b_test_du_maximum_fort=BLOC( condition = "T_MAXIMUM_FORT=='OUI'",
+##
+# COS_LIM = SIMP(statut="f",typ="R",max=1,defaut=1.0,
+# fr="Cosinus de l'angle d'exclusion.",
+# ang="Cosine of angle of exclusion."),
+##
+# DPROB = SIMP(statut="f",typ="R",max=1,defaut=4.3E-1,
+# fr="Fraction d'iso-densit頤e probabilit頤e d馡illance.",
+# ang="Fraction.")
+##
+# ),
+##
+## 4.2.5.3. ==> Test du hessien
+##
+# T_HESSIEN = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+# fr="Test du hessien.",
+# ang="Hessian test."),
+##
+## 4.2.6. ==> Les correlations entre les variables
+##
+# MATRICE = SIMP(statut="f",typ="R",max="**",
+# fr="Matrice de corr鬡tion entre les variables.",
+# ang="Correlation matrix."),
+##
--- /dev/null
+# -*- coding: utf-8 -*-
+
+# --------------------------------------------------
+# debut entete
+# --------------------------------------------------
+
+import Accas
+from Accas import *
+
+class loi (ASSD) : pass
+
+
+#CONTEXT.debug=1
+JdC = JDC_CATA(code='OPENTURNS',
+ execmodul=None,
+ regles = (AU_MOINS_UN('DONNEES_OPENTURNS'),),
+ )
+
+# --------------------------------------------------
+# fin entete
+# --------------------------------------------------
+
+# 3. Version d OPENTURNS ?
+
+#===========================================================
+
+
+#================================
+# 1. Definition des LOIS
+#
+# TODO --> verifier que l expression reguliere se compile en python
+#
+#================================
+
+LOIMARG = OPER(nom="LOIMARG",sd_prod=loi,op= 68, fr="loi",
+
+ TypeDeLoi = SIMP(statut="o",typ="TXM",
+ into=("Uniforme","Normale","LogNormale",),
+ defaut="Normale", fr="Type de la loi 1D",
+ ang="Distribution 1D"),
+#
+# Loi normale
+#
+ b_normale=BLOC(condition="TypeDeLoi=='Normale'",
+
+ ValeMoyenne = SIMP(statut="o",typ="R",max=1,
+ fr="Valeur moyenne.",
+ ang="Mean value."),
+
+ EcartType = SIMP(statut="o",typ="R",max=1,
+ fr="Ecart type.",
+ ang="Standard deviation."),
+ ),
+
+ );
+
+#================================
+# 2. Definition des VARIABLES
+#
+# TODO --> verifier que l expression reguliere se compile en python
+#
+#================================
+DONNEES_OPENTURNS=PROC(nom="DONNEES_OPENTURNS",op=None, docu="",
+ fr="Mise en données pour le fichier de configuration de OPENTURNS.",
+ ang="Writes the configuration file for OPENTURNS.",
+
+ Variable = FACT(statut="o",min=1,max="**",
+
+ NomDsOpenTurns = SIMP(statut="o",typ="TXM",
+ fr="Nom de la variable, dans OpenTurns",
+ ang="Name of the variable for OpenTuurs"),
+
+ Type = SIMP(statut="o",typ="TXM",
+ into=( "in", "out",),
+ defaut="in",
+ fr="variable d'entrée ou de sortie du solver",
+ ang="Input or Output variable",
+ ),
+
+ ValeurDefaut=SIMP(statut="f",typ="R",
+ defaut=0.0,
+ fr="valeur par defaut de la variable ",
+ ang="default value",
+ ),
+
+
+
+ LoiMarginale = SIMP(statut="o",typ=(loi,),
+ fr="Choix de la loi",
+ ang="Distribution"),
+
+ Comment = SIMP(statut="f",typ="TXM",
+ fr="Commentaire",
+ ang="Comment"),
+
+ Unit = SIMP(statut="f",typ="TXM",
+ fr="Unite",
+ ang="Unit"),
+
+ Regexp = SIMP(statut="f",typ="TXM",
+ fr="expression reguliére de lecture",
+ ang="regular expression for reading"),
+
+ Format = SIMP(statut="f",typ="TXM",
+ fr="format d'écriture",
+ ang="writing format"),
+ ),
+
+#================================================================
+#
+# 4. Informations sur les FICHIERS
+#
+#================================================================
+
+ Fichier = FACT(statut="f",min=1,max="**",
+
+ Identificateur = SIMP(statut="o",typ="TXM",
+ fr="Identificateur du fichier",
+ ang="File id"),
+
+ Type = SIMP(statut="o",typ="TXM",
+ into=( "in", "out",),
+ defaut="in",
+ fr="fichier d'entrée ou de sortie du solver",
+ ang="Input or Output file",
+ ),
+
+ Nom = SIMP(statut="f",typ="TXM",
+ fr="Nom du fichier",
+ ang="file name"),
+
+ Chemin = SIMP(statut="o",typ="TXM",
+ fr="chemin du fichier",
+ ang="path file "),
+ ),
+
+
+#================================================================
+#
+# 5. Informations sur le WRAPPER
+#
+# TODO --> verifier que la chaine de caractere se termine par so
+# Chemin du wrapper devrait finir par .so
+#
+#================================================================
+
+ Wrapper = FACT(statut="o",min=1,max=1,
+
+ Chemin = SIMP(statut="o",typ="TXM",
+ defaut="aster.so",
+ fr="chemin d acces au wrapper",
+ ang="wrapper library path",),
+
+ Fonction = SIMP(statut="o",typ="TXM",
+ fr="Nom de la fonction dans le wrapper",
+ ang="Function's name in wrapper",),
+
+ Gradient = SIMP(statut="f",typ="TXM",
+ fr="gradient",
+ ang="gradient",),
+
+ Hessian = SIMP(statut="f",typ="TXM",
+ fr="hessian",
+ ang="hessian",),
+
+ Mode = FACT(statut="o",min=1,max=1,
+
+ Type = SIMP(statut="o",typ="TXM",
+ into=( "static-link", "dynamic-link","fork",),
+ defaut="static-link",
+ fr="mode de couplage du solver",
+ ang="Solver coupling mode",
+ ),
+
+ Etat = SIMP(statut="f",typ="TXM",
+ into=( "shared", "specific"),
+ defaut="shared",
+ fr="partage de l etat interne entre les fonctions",
+ ang="internal state sharing",
+ ),
+
+ ModeEntree = SIMP(statut="o",typ="TXM",
+ into=( "files","pipe","arguments","socket","CORBA",),
+ defaut="files",
+ fr="mode de transfert des données d entree",
+ ang="input transfering mode",
+ ),
+
+ ModeSortie = SIMP(statut="o",typ="TXM",
+ into=( "files","pipe","arguments","socket","CORBA",),
+ defaut="files",
+ fr="mode de transfert des données de sortie",
+ ang="output transfering mode",
+ ),
+
+ b_Fork=BLOC(condition="Type=='fork'",
+ Commande = SIMP(statut="o",typ="TXM",
+ fr="Chemin du solver",
+ ang="solver path"),
+ ),
+ ),
+ ),
+
+#===========================================================
+# 1. Le Type d'Analyse
+#
+# TypeAnalyse : Deterministe (min/max)
+# Probabiliste analyse en valeur centrale
+# Probabiliste analyse en valeur extreme
+#===========================================================
+
+# TypeAnalyse = SIMP(statut="o",typ="TXM",
+# into=("MinMax","Centrale","Extreme"),
+# fr="Type d'Analyse",
+# ang="Analyse",
+# ),
+
+
+#==============
+# 2. Fonction
+#=============
+#
+#
+# Fonction = SIMP(statut="o",typ="TXM",
+# into=("Adaptateur", "Analytique"),
+# fr="Logiciel de calcul",
+# ang="software solver"),
+
+# b_Adaptateur=BLOC(condition="Fonction=='Adaptateur'",
+# NomSolver = SIMP(statut="f",typ="TXM",
+# into=("Aster","Toto"),
+# fr="Logiciel de calcul",
+# ang="software solver"),
+# ),
+
+#====================================================
+# 3. Cas dune analyse probabiliste en valeur extreme
+#====================================================
+#
+ b_Extreme=BLOC(condition="TypeAnalyse=='Extreme'",
+
+
+ MethodeSimulaton = SIMP(statut="f",typ="TXM",
+ into=( "MonteCarlo brut", "MonteCarlo LHS" ,
+ "Simulation directionnelle", "FORM" ,
+ "FORM MonteCarlo Pt Conception ", "SORM",) ,
+ fr="Méthode de Simulation",
+ ang=" Simulation Method"),
+ ),
+
+
+);
+# Loi lognormale
+#
+# b_lognormale=BLOC(condition="Loi=='LogNormale'",
+#
+# ValeMinimale = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur minimale.",
+# ang="Minimal value."),
+
+# Vale_Moyenne = SIMP(statut="f",typ="R",max=1,
+# fr="Valeur moyenne dans l'espace de la loi normale.",
+# ang="Mean value in the space of the normal law."),
+#
+# EcartType = SIMP(statut="f",typ="R",max=1,
+# fr="Ecart type dans l'espace de la loi normale.",
+# ang="Standard deviation in the space of the normal law."),
+#
+# VALE_MOY_PHY = SIMP(statut="f",typ="R",max=1,
+# fr="Valeur moyenne dans l'espace physique.",
+# ang="Mean value in the physical space."),
+#
+# ECART_TYPE_PHY = SIMP(statut="f",typ="R",max=1,
+# fr="Ecart type dans l'espace physique.",
+# ang="Standard deviation in the physical space."),
+#
+# regles=(AU_MOINS_UN("VALE_MOY" ,"VALE_MOY_PHY"),
+# AU_MOINS_UN("ECART_TYPE","ECART_TYPE_PHY"),
+# EXCLUS ("VALE_MOY" ,"VALE_MOY_PHY"),
+# EXCLUS ("VALE_MOY" ,"ECART_TYPE_PHY"),
+# EXCLUS ("ECART_TYPE","VALE_MOY_PHY"),
+# EXCLUS ("ECART_TYPE","ECART_TYPE_PHY")),
+#
+# ),
+
+#
+# ==> Loi uniforme
+#
+# b_uniforme=BLOC(condition="LOI=='UNIFORME'",
+#
+# VALE_MIN = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur minimale.",
+# ang="Minimal value."),
+#
+# VALE_MAX = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur maximale.",
+# ang="Maximal value."),
+
+# ),
+
+# 5.2.4. ==> Loi normale tronquée
+##
+# b_normale_tronquee=BLOC(condition="LOI=='NORMALE_TRONQUEE'",
+##
+# VALE_MOY = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur moyenne de la loi normale complète.",
+# ang="Mean value for the entire normal law."),
+##
+# ECART_TYPE = SIMP(statut="o",typ="R",max=1,
+# fr="Ecart type de la loi normale complète.",
+# ang="Standard deviation for the entire normal law."),
+##
+# VALE_MIN = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur minimale.",
+# ang="Minimal value."),
+##
+# VALE_MAX = SIMP(statut="o",typ="R",max=1,
+# fr="Valeur maximale.",
+# ang="Maximal value."),
+##
+# ),
+##
+## 5.3. ==> Paramètres de calcul
+## 5.3.1. ==> Soit on cherche le point de conception, soit on le connait deja
+##
+# regles=(EXCLUS("POINT_INI","POINT_CONCEPT"),
+# EXCLUS("POINT_REF","POINT_CONCEPT"),),
+##
+## 5.3.2. ==> Quand on cherche le point de conception, on peut préciser le départ de l'algorithme.
+## Si on ne le fait pas, le programme prendra la valeur moyenne.
+##
+# POINT_INI = SIMP(statut="f",typ="R",max=1,
+# fr="Point de démarrage de l'algorithme itératif.",
+# ang="Initial point for iterative process."),
+##
+## 5.3.3. ==> Quand on cherche le point de conception, on peut préciser un point de référence pour normaliser.
+## Si on ne le fait pas, le programme prendra la valeur moyenne.
+##
+# POINT_REF = SIMP(statut="f",typ="R",max=1,
+# fr="Point de référence de l'algorithme itératif.",
+# ang="Reference point for iterative process."),
+##
+## 5.3.4. ==> Quand on cherche uniquement la probabilité de défaillance, il faut donner le point de conception
+##
+# POINT_CONCEPT = SIMP(statut="f",typ="R",max=1,
+# fr="Point de conception.",
+# ang="Design point."),
+##
+## 5.4. ==> Mode d'obtention du gradient par rapport à ce paramètre
+##
+# GRADIENT = SIMP(statut="o",typ="TXM",max=1,
+# into=("OUI","NON"),
+# fr="ASTER calcule directement le gradient.",
+# ang="ASTER computes the gradient for this parameter."),
+#
+# b_gradient=BLOC(condition="GRADIENT=='NON'",
+# INCREMENT = SIMP(statut="o",typ="R",max=1,
+# fr="Incrément dans la direction.",
+# ang="Direction increment."),
+# ),
+#
+#
+#
+# Type le plus general
+#class entier (ASSD):pass
+#class reel (ASSD):pass
+#class complexe(ASSD):pass
+#class liste (ASSD):pass
+#class chaine (ASSD):pass
+
+# Types geometriques
+#class no (GEOM):pass
+#class grno(GEOM):pass
+#class ma (GEOM):pass
+#class grma(GEOM):pass
+
+#
+#
+#
+##
+##====
+## 4. Options
+##====
+## 4.1. ==> Générales
+##
+## 4.1.1. ==> La valeur du seuil
+##
+# SEUIL = SIMP(statut="o",typ="R",max=1,
+# fr="Le seuil de défaillance.",
+# ang="Failure threshold."),
+##
+## 4.1.2. ==> Le type du seuil : on a deux cas de figure selon que
+## la défaillance a lieu au dessus d'un seuil maximum ou
+## en dessous d'un seuil minimum
+##
+# SEUIL_TYPE = SIMP(statut="o",typ="TXM",max=1,
+# into=("MINIMUM","MAXIMUM"),
+# fr="Que faut-il ne pas dépasser : un maximum ou un minimum.",
+# ang="What is the failure threshold : maximum or minimum."),
+##
+## 4.2. ==> Pour MEFISTO
+##
+##
+## 4.2.1. ==> Pilotage de la recherche du point de conception
+##
+# RECH_PT_CONCEPT = SIMP(statut="f",typ="TXM",defaut="OUI",
+# into=("OUI","NON"),
+# fr="Pour trouver le point de conception.",
+# ang="To find the design point."),
+##
+# b_rech_pt_concept=BLOC( condition = "RECH_PT_CONCEPT=='OUI'",
+##
+# EPSILON_U = SIMP(statut="f",typ="R",defaut=1.0E-2,
+# fr="Précision du test d'arret sur les points itératifs dans l'espace standard.",
+# ang="Precision of stop test for iterative points in standard space."),
+##
+# EPSILON_G = SIMP(statut="f",typ="R",defaut=1.0E-2,
+# fr="Précision du test d'arret sur la proximité de la surface d'état limite.",
+# ang="Precision of stop test for limit state surface."),
+##
+# TAU = SIMP(statut="f",typ="R",defaut=5.0E-1,
+# fr="Paramètre de la méthode de minimisation.",
+# ang="Parameter for the minimization method."),
+##
+# OMEGA = SIMP(statut="f",typ="R",defaut=1.0E-4,
+# fr="Paramètre de la méthode de minimisation.",
+# ang="Parameter for the minimization method."),
+##
+# ITER_MAX = SIMP(statut="f",typ="I",defaut=50,
+# fr="Nombre maximum d'itérations.",
+# ang="Maximum number of iterations."),
+# ),
+##
+## 4.2.2. ==> Méthode(s) employée(s) pour la probabilité de défaillance
+##
+# METHODE_FORM = SIMP(statut="f",typ="TXM",defaut="OUI",
+# into=("OUI","NON"),
+# fr="Recherche de la probabilité de défaillance avec la méthode FORM.",
+# ang="Research of failure probability with FORM method."),
+##
+# METHODE_SORM = SIMP(statut="f",typ="TXM",defaut="NON",
+# into=("OUI","NON"),
+# fr="Recherche de la probabilité de défaillance avec la méthode SORM.",
+# ang="Research of failure probability with SORM method."),
+##
+# TIRAGE_IMPORTANCE = SIMP(statut="f",typ="TXM",defaut="NON",
+# into=("OUI","NON"),
+# fr="Recherche de la probabilité de défaillance avec le tirage d'importance.",
+# ang="Research of failure probability with ."),
+##
+# b_tirage_importance=BLOC( condition = "TIRAGE_IMPORTANCE=='OUI'",
+##
+# NB_SIMULATION = SIMP(statut="f",typ="I",defaut=3,
+# fr="Nombre de simulations pour le tirage d'importance.",
+# ang="Number of simulation for."),
+##
+# ),
+##
+## 4.2.3. ==> Création d'une surface de réponse polynomiale
+##
+# POLYNOME_TAYLOR = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),),
+# HGRAD = SIMP(statut="f",typ="R",defaut=1.0E-2,
+# fr="Pas incrémental pour le calcul des gradients.",
+# ang="Step for calculation of gradients."),
+# HHESS = SIMP(statut="f",typ="R",defaut=1.0E-2,
+# fr="Pas incrémental pour le calcul des dérivées secondes.",
+# ang="Step for calculation of second derivatives."),
+##
+## 4.2.4. ==> Recherche d'un plan d'expérience
+##
+# PLAN_EXPERIENCE = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+# fr="Construction d'un plan d'expérience.",
+# ang="Construction of an experiment plan."),
+##
+# b_plan_experience=BLOC( condition = "PLAN_EXPERIENCE=='OUI'",
+##
+# ALPHA = SIMP(statut="f",typ="R",defaut=2.0E-1,
+# fr="Plan d'expérience : maille du plan de type composite centré.",
+# ang="Experiment plane : mesh centered composite."),
+##
+# BETA = SIMP(statut="f",typ="R",defaut=4.0E-1,
+# fr="Plan d'expérience : maille du plan de type factoriel.",
+# ang="Experiment plane : mesh factor."),
+##
+# ),
+##
+## 4.2.5. ==> Les tests
+## 4.2.5.1. ==> Test de la sphere
+##
+# T_SPHERE = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+# fr="Test de la sphère.",
+# ang="Sphere test."),
+##
+# b_test_de_la_sphere=BLOC( condition = "T_SPHERE=='OUI'",
+##
+# METHODE_TEST = SIMP(statut="f",typ="TXM",defaut="GAUSSIENNE",
+# into=("GAUSSIENNE","PARAMETRIQUE","REJECTION"),
+# fr="Type de méthode.",
+# ang="Method."),
+##
+# NB_POINT = SIMP(statut="f",typ="I",max=1,defaut=40,
+# fr="Nombre de points de la sphere.",
+# ang="Number of points over the sphere.")
+# ),
+##
+## 4.2.5.2. ==> Test du maximum fort
+##
+# T_MAXIMUM_FORT = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+# fr="Test du maximum fort.",
+# ang="Strong maximum test."),
+##
+# b_test_du_maximum_fort=BLOC( condition = "T_MAXIMUM_FORT=='OUI'",
+##
+# COS_LIM = SIMP(statut="f",typ="R",max=1,defaut=1.0,
+# fr="Cosinus de l'angle d'exclusion.",
+# ang="Cosine of angle of exclusion."),
+##
+# DPROB = SIMP(statut="f",typ="R",max=1,defaut=4.3E-1,
+# fr="Fraction d'iso-densité de probabilité de défaillance.",
+# ang="Fraction.")
+##
+# ),
+##
+## 4.2.5.3. ==> Test du hessien
+##
+# T_HESSIEN = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+# fr="Test du hessien.",
+# ang="Hessian test."),
+##
+## 4.2.6. ==> Les correlations entre les variables
+##
+# MATRICE = SIMP(statut="f",typ="R",max="**",
+# fr="Matrice de corrélation entre les variables.",
+# ang="Correlation matrix."),
+##
--- /dev/null
+import os
+
+import prefs
+
+rep_cata = prefs.REPINI
+
+# Accès à la documentation
+path_doc = os.path.join(rep_cata,'Doc')
+exec_acrobat = "/usr/bin/xpdf"
+
+# Utilisateur/Développeur
+isdeveloppeur = "NON"
+path_cata_dev = "/tmp/cata"
+
+# Répertoire temporaire
+rep_travail = "/tmp"
+
+# Répertoire initial
+initialdir=os.curdir
+
+# Choix des catalogues
+rep_mat=" "
+
+catalogues = (
+ ('OPENTURNS','v1',os.path.join(rep_cata,'Open_Cata_V0.py'),'openturns'),
+ )
+
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+"""
+ Ce module sert à lancer EFICAS configuré pour Code_Aster
+"""
+# Modules Python
+import sys
+import Tkinter
+
+# Modules Eficas
+import prefs
+
+sys.path[:0]=[prefs.INSTALLDIR]
+
+from Editeur import session
+from InterfaceTK import eficas
+from InterfaceTK import splash
+
+
+def lance_eficas(code=None,fichier=None):
+ """
+ Lance l'appli EFICAS
+ """
+ # Analyse des arguments de la ligne de commande
+ options=session.parse(sys.argv)
+ if code !=None : prefs.code=code
+
+ root = Tkinter.Tk()
+ splash.init_splash(root,code=code,titre="Lancement d'EFICAS pour %s" %code)
+ splash._splash.configure(text="Chargement d'EFICAS en cours.\n Veuillez patienter ...")
+ eficas.EFICAS(root,code=code,ihm="TK")
+
+ root.mainloop()
+
+if len(sys.argv) > 1 :
+ # on veut ouvrir un fichier directement au lancement d'Eficas
+ lance_eficas(code='OPENTURNS',fichier = sys.argv[1])
+else:
+ # on veut ouvrir Eficas 'vide'
+ lance_eficas(code='OPENTURNS')
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+
+import os
+
+CODE="OPENTURNS"
+# REPINI sert à localiser le fichier editeur.ini
+# Obligatoire
+REPINI=os.path.dirname(os.path.abspath(__file__))
+
+# INSTALLDIR sert à localiser l'installation d'Eficas
+# Obligatoire
+INSTALLDIR=os.path.join(REPINI,'..')
+
+# CODE_PATH sert à localiser Noyau et Validation éventuellement
+# non contenus dans la distribution EFICAS
+# Par défaut on utilise les modules de INSTALLDIR
+# Peut valoir None (defaut)
+CODE_PATH = None
+
+CODE="OPENTURNS"
+
+# ICONDIR sert à localiser le répertoire contenant les icones
+# Par défaut on utilise le répertoire icons dans Editeur
+ICONDIR=os.path.join(INSTALLDIR,'Editeur','icons')
+
+# lang indique la langue utilisée pour les chaines d'aide : fr ou ang
+lang='fr'
+
+# Codage des strings qui accepte les accents (en remplacement de 'ascii')
+encoding='iso-8859-1'
+
+labels= ('Fichier','Edition','Jeu de commandes',
+ )
+
+appli_composants=['readercata','bureau',
+ 'options',
+ ]
+
+menu_defs={ 'bureau': [
+ ('Fichier',[
+ ('Nouveau','newJDC','<Control-n>'),
+ ('Ouvrir','openJDC','<Control-o>'),
+ ('Enregistrer','saveJDC','<Control-e>'),
+ ('Enregistrer sous','saveasJDC','<Control-s>'),
+ None,
+ ('Fermer','closeJDC','<Control-f>'),
+ ('Quitter','exitEFICAS','<Control-q>'),
+ ]
+ ),
+ ('Edition',[
+ ('Copier','copy','<Control-c>'),
+ ('Couper','cut','<Control-x>'),
+ ('Coller','paste','<Control-v>'),
+ ]
+ ),
+ ('Jeu de commandes',[
+ ('Rapport de validation','visuCRJDC','<Control-r>'),
+ ('Fichier à plat','visu_a_plat','<Control-p>'),
+ ]
+ ),
+ ]
+ }
+
--- /dev/null
+# -*- coding: utf-8 -*-
+#@ MODIF properties Accas DATE 10/10/2002 AUTEUR gcbhhhh M.ADMINISTRATEUR
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# RESPONSABLE D6BHHHH J-P.LEFEBVRE
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# IDENTIFICATION DU GESTIONNAIRE DE COMMANDE ACCAS A PARTIR
+# DE LA VERSION DU CODE_ASTER ASSOCIE
+#----------------------------------------------------------------------
+version = "7.1.0"
+date = "23/04/2003"
--- /dev/null
+# Necessaire pour compatibilite avec Aster
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient le plugin convertisseur de fichier
+ au format python pour EFICAS.
+
+ Un plugin convertisseur doit fournir deux attributs de classe :
+ extensions et formats et deux méthodes : readfile,convert.
+
+ L'attribut de classe extensions est une liste d'extensions
+ de fichiers préconisées pour ce type de format. Cette information
+ est seulement indicative.
+
+ L'attribut de classe formats est une liste de formats de sortie
+ supportés par le convertisseur. Les formats possibles sont :
+ eval, dict ou exec.
+ Le format eval est un texte source Python qui peut etre evalué. Le
+ résultat de l'évaluation est un objet Python quelconque.
+ Le format dict est un dictionnaire Python.
+ Le format exec est un texte source Python qui peut etre executé.
+
+ La méthode readfile a pour fonction de lire un fichier dont le
+ nom est passé en argument de la fonction.
+ - convertisseur.readfile(nom_fichier)
+
+ La méthode convert a pour fonction de convertir le fichier
+ préalablement lu dans un objet du format passé en argument.
+ - objet=convertisseur.convert(outformat)
+
+ Ce convertisseur supporte le format de sortie exec
+
+"""
+import sys,string,traceback
+
+import parseur_python
+from Noyau import N_CR
+
+def entryPoint():
+ """
+ Retourne les informations nécessaires pour le chargeur de plugins
+ Ces informations sont retournées dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'openturns',
+ # La factory pour créer une instance du plugin
+ 'factory' : PythonParser,
+ }
+
+
+class PythonParser:
+ """
+ Ce convertisseur lit un fichier au format python avec la
+ methode readfile : convertisseur.readfile(nom_fichier)
+ et retourne le texte au format outformat avec la
+ methode convertisseur.convert(outformat)
+
+ Ses caractéristiques principales sont exposées dans 2 attributs
+ de classe :
+ - extensions : qui donne une liste d'extensions de fichier préconisées
+ - formats : qui donne une liste de formats de sortie supportés
+ """
+ # Les extensions de fichier préconisées
+ extensions=('.py',)
+ # Les formats de sortie supportés (eval dict ou exec)
+ # Le format exec est du python executable (commande exec) converti avec PARSEUR_PYTHON
+ # Le format execnoparseur est du python executable (commande exec) non converti
+ formats=('exec','execnoparseur')
+
+ def __init__(self,cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le
+ # compte-rendu standard
+ self.text=''
+ if cr :
+ self.cr=cr
+ else:
+ self.cr=N_CR.CR(debut='CR convertisseur format python',
+ fin='fin CR format python')
+
+ def readfile(self,filename):
+ self.filename=filename
+ try:
+ self.text=open(filename).read()
+ except:
+ self.cr.fatal("Impossible ouvrir fichier %s" % filename)
+ return
+
+ def convert(self,outformat,appli=None):
+ if outformat == 'exec':
+ try:
+ #txt=parseur_python.PARSEUR_PYTHON(self.text).get_texte(appli)
+ #print txt
+ #return txt
+ return parseur_python.PARSEUR_PYTHON(self.text).get_texte(appli)
+ except:
+ # Erreur lors de la conversion
+ l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],
+ sys.exc_info()[2])
+ self.cr.exception("Impossible de convertir le fichier python \
+ qui doit contenir des erreurs.\n \
+ On retourne le fichier non converti \n \
+ Prévenir la maintenance. \n" + string.join(l))
+ # On retourne néanmoins le source initial non converti (au cas où)
+ return self.text
+ elif outformat == 'execnoparseur':
+ return self.text
+ else:
+ raise "Format de sortie : %s, non supporté"
+ return None
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient la partie commune a Aster et Eficas
+ des generateurs XML et Etude pour Openturns
+
+"""
+import Accas
+
+#____________________________________________
+#
+# Parties du texte en dur dans le fichier SML
+#
+#_____________________________________________
+
+EnTeteXML = '<?xml version="1.0" encoding="ISO-8859-1"?>\n'
+EnTeteXML += '<!DOCTYPE wrapper SYSTEM "wrapper.dtd"\n>'
+EnTeteXML += '<wrapper>\n'
+EnTeteXML += ' <library>\n\n'
+EnTeteXMLDescr = ' <description>\n'
+EnTeteXMLDescr += ' <variable-list>'
+
+EnTeteXMLFinDescr = ' </description>\n'
+EnTeteXMLFinDescr+= ' </library>\n'
+EnTeteXMLFinDescr+= ' <external-code>\n'
+EnTeteXMLFinDescr+= ' <data></data>\n'
+
+EnTeteXMLFinLib = ' </wrap-mode>\n\n'
+
+EnTeteXMLFIN = ' </external-code>\n'
+EnTeteXMLFIN += '</wrapper>\n'
+
+#_________________________________________________________________
+#
+# Definition des variables dans le fichier SML
+#
+#_________________________________________________________________
+
+# OrdreVariable contient l ordre des MC pour definir une variable en XML
+# dictMCXML a pour clef le nom du MC dans Aster,
+# Il contient aussi une liste donnant les informations suivantes
+# 1 debut de ligne
+# 2 fin de ligne
+# 3 Obligatoire 0 facultatif 1 obligatoire
+
+OrdreVariable=('NomDsOpenTurns','Type','Comment','Unit','Regexp','Format')
+dictMCXML={ "NomDsOpenTurns" : ('\n <variable id="','" ', 1),
+ "Type" : ('type ="', '">\n',1),
+ "Comment" : (' <comment>', '</comment>\n',0),
+ "Unit" : (' <unit>' , '</unit>\n',0),
+ "Regexp" : (' <regexp>' , '</regexp>\n',0),
+ "Format" : (' <format>' , '</format>\n',0)}
+
+# OrdreLibrary contient l ordre des MC pour definir la partie library en XML
+# dictLibXML a pour clef le nom du MC dans Aster,
+# Il contient aussi une liste donnant les informations suivantes
+# 1 debut de ligne
+# 2 milieu de ligne si le MC n est pas present
+# 3 fin de ligne
+# 4 Obligatoire 0 facultatif 1 obligatoire
+
+OrdreLibrary=('Fonction','Gradient','Hessian')
+dictLibXML={ "Fonction" : ('\n <function provided="yes">','\n <function provided="no">','</function>',1),
+ "Gradient" : ('\n <gradient provided="yes">','\n <gradient provided="no">','</gradient>',0),
+ "Hessian" : ('\n <hessian provided="yes">', '\n <hessian provided="no">','</hessian>\n\n',0)}
+
+# OrdreExternal contient l ordre des MC pour definir la partie External en XML
+# dictExtXML a pour clef le nom du MC dans Aster,
+# Il contient aussi une liste donnant les informations suivantes
+# 1 debut de ligne
+# 2 fin de ligne
+# 3 Obligatoire 0 facultatif 1 obligatoire 2 avec defaut
+# 4 valeur par defaut
+OrdreExternal=('Type','Etat','ModeEntree','ModeSortie')
+dictExtXML={ "Type" : ('\n <wrap-mode type="','"',1),
+ "Etat" : (' state="', '"shared">\n', 2, "shared>\n"),
+ "ModeEntree" : (' <in-data-transfer mode="','" />\n',0),
+ "ModeSortie" : (' <out-data-transfer mode="','" />\n',0)}
+#____________________________________________
+#
+# Parties du texte en dur dans le fichier STD
+#
+#_____________________________________________
+
+# a ce stade, le nom du fichier n est pas connu
+# XXXXX sera remplace ultérieurement ( dans bureau.py)
+EnTeteSTD = 'try : \n'
+EnTeteSTD += ' myFunction = NumericalMathFunction("XXXXXX")\n'
+EnTeteSTD += ' dim=myFunction.getInputNumericalPointDimension()\n'
+
+EnTeteRun = ' vect = RandomVector(Distribution(myDistribution))\n'
+EnTeteRun = ' output = RandomVector(myFunction,vect)\n'
+EnTeteRun += ' myCobyla = Cobyla()\n'
+EnTeteRun += ' myCobyla.setSpecificParameters(CobylaSpecificParameters()\n'
+EnTeteRun += ' myCobyla.setMaximumIterationNumber(100)\n'
+EnTeteRun += ' myCobyla.setMaximumAbsoluteError(1.0e-10)\n'
+EnTeteRun += ' myCobyla.setMaximumRelativeError(1.0e-10)\n'
+EnTeteRun += ' myCobyla.setMaximumResidualError(1.0e-10)\n'
+EnTeteRun += ' myCobyla.setMaximumConstraintError(1.0e-10)\n'
+EnTeteRun += ' myAlgo=FORM(NearestPointAlgorithm(myCobyla),myEvent,mean)\n'
+EnTeteRun += ' myAlgo.run()\n'
+EnTeteRun += ' myAlgo.getResult()\n'
+
+EnTeteSTDFIN ='except : \n'
+EnTeteSTDFIN+=' import sys\n'
+EnTeteSTDFIN+=' print sys.exc_type, sys.exec_value\n'
+
+
+#-------------------
+# Creation des Lois
+#-------------------
+
+
+#-----------------#
+class Generateur:
+#-----------------#
+
+ def __init__(self,dictMCVal,ListeVariables, dictMCLois):
+ self.dictMCVal=dictMCVal
+ self.ListeVariables=ListeVariables
+ self.dictMCLois=dictMCLois
+ self.dictMCVal=dictMCVal
+
+#-------------------------------#
+class XMLGenerateur(Generateur):
+#-------------------------------#
+ def __init__(self,dictMCVal,ListeVariables, dictMCLois):
+ #-------------------------------------------------------
+ Generateur.__init__(self,dictMCVal,ListeVariables, dictMCLois)
+
+ def CreeXML(self) :
+ #------------------
+ self.texte = EnTeteXML
+ self.texte += self.CreePath()
+ self.texte += EnTeteXMLDescr
+ self.texte += self.CreeVariable()
+ self.texte += self.CreeLibrary()
+ self.texte += self.CreeExternal()
+ self.texte += self.CreeCommande()
+ self.texte += EnTeteXMLFIN
+ return self.texte
+
+
+ def CreePath(self):
+ #------------------
+ textePath=' <path>'
+ try :
+ textePath += self.dictMCVal["Chemin"]
+ except :
+ print "*********************************************"
+ print "* ERREUR GENERATION XML *"
+ print "* champ wrapper non rempli *"
+ print "*********************************************"
+ textePath+='</path>\n\n '
+ return textePath
+
+
+ def CreeVariable(self):
+ #---------------------
+ texteVar=""
+ for DictVariable in self.ListeVariables :
+ for MC in OrdreVariable :
+ if DictVariable.has_key(MC) :
+ texteVar+=dictMCXML[MC][0]+DictVariable[MC]+dictMCXML[MC][1]
+ else :
+ if dictMCXML[MC][2] :
+ print "**************************************************"
+ print "* ERREUR GENERATION XML *"
+ print "* champ obligatoire non rempli pour variable *"
+ print "**************************************************"
+ texteVar+=' </variable>\n'
+ texteVar+='\n </variable-list>\n'
+ return texteVar
+
+ def CreeLibrary(self):
+ #---------------------
+ texteLib=""
+ for MC in OrdreLibrary :
+ if self.dictMCVal.has_key(MC) :
+ texteLib+=dictLibXML[MC][0]+self.dictMCVal[MC]+dictLibXML[MC][2]
+ else :
+ texteLib+=dictLibXML[MC][1]+dictLibXML[MC][2]
+ if dictLibXML[MC][3] :
+ print "**************************************************"
+ print "* ERREUR GENERATION XML *"
+ print "* champ obligatoire non rempli pour wrapper *"
+ print "**************************************************"
+ texteLib+=EnTeteXMLFinDescr
+ return texteLib
+
+ def CreeExternal(self):
+ #----------------------
+ texteExt=""
+ for MC in OrdreExternal :
+ if self.dictMCVal.has_key(MC) :
+ texteExt+=dictExtXML[MC][0]+self.dictMCVal[MC]+dictExtXML[MC][1]
+ else :
+ if dictExtXML[MC][2] == 2 :
+ texteExt+=dictExtXML[MC][0]+dictExtXML[MC][3]
+ elif dictExtXML[MC][2] == 1 :
+ print "**************************************************"
+ print "* ERREUR GENERATION XML *"
+ print "* champ obligatoire non rempli pour external *"
+ print "**************************************************"
+ texteExt+=EnTeteXMLFinLib
+ return texteExt
+
+ def CreeCommande(self):
+ #----------------------
+ if self.dictMCVal.has_key("commande") :
+ texteComm=' <command>"'+dictMCVal["commande"]+'</command>\n'
+ else :
+ texteComm=' <command># no command</command>\n'
+ return texteComm
+
+#--------------------------------
+class STDGenerateur(Generateur):
+#--------------------------------
+ def __init__(self,dictMCVal,ListeVariables, dictMCLois):
+ Generateur.__init__(self,dictMCVal,ListeVariables, dictMCLois)
+
+ def CreeSTD(self) :
+ #------------------
+ self.texte = EnTeteSTD
+ self.texte +=self.CreeLois()
+ self.texte += EnTeteRun
+ self.texte += EnTeteSTDFIN
+ return self.texte
+
+ def CreeLois(self) :
+ #------------------
+ dim=len(self.ListeVariables)
+ TexteLois=" aCollection=DistributionCollection("+str(dim)+")\n\n"
+ numVar=0
+ self.loi=None
+ for variable in self.ListeVariables :
+ self.loi=variable["LoiMarginale"]
+ fonction=self.loi["TypeDeLoi"]
+ Texte,Nom=apply(STDGenerateur.__dict__[fonction],(self,numVar))
+ TexteLois+=Texte
+ TexteLois+=" aCollection["+str(numVar)+"]="+Nom+"\n\n"
+ numVar=numVar+1
+ TexteLois+=" aCopula=IndependentCopula("+str(dim)+")\n"
+ TexteLois+=' aCopula.setName("EficasCopula")\n'
+ TexteLois+=' myDistribution.ComposedDistribution(aCollection,Copula(aCopula))\n'
+ return TexteLois
+
+
+ def Normale(self,numVar) :
+ #------------------
+ Nom="marginal"
+ Nom+=str(numVar)
+ Texte=" "+Nom
+ Texte +="=Normal("
+ Texte+=str(self.loi["ValeMoyenne"])+","
+ Texte+=str(self.loi["EcartType"])+")\n"
+ Texte+=' marginal.setName("'+Nom+")\n"
+ return Texte,Nom
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+"""
+ Ce module contient le plugin generateur de fichier au format
+ homard pour EFICAS.
+
+"""
+import traceback
+import types,string,re
+
+from generator_python import PythonGenerator
+from OpenturnsAster import XMLGenerateur
+from OpenturnsAster import STDGenerateur
+
+def entryPoint():
+ """
+ Retourne les informations nécessaires pour le chargeur de plugins
+
+ Ces informations sont retournées dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'openturns',
+ # La factory pour créer une instance du plugin
+ 'factory' : OpenturnsGenerator,
+ }
+
+
+class OpenturnsGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format xml
+
+ """
+ # Les extensions de fichier préconisées
+ extensions=('.comm',)
+
+ def initDico(self):
+ self.dictMCVal={}
+ self.ListeVariables=[]
+ self.dictMCLois={}
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+
+ def gener(self,obj,format='brut'):
+ self.initDico()
+ self.text=PythonGenerator.gener(self,obj,format)
+ self.genereXML()
+ self.genereSTD()
+ return self.text
+
+ def generMCSIMP(self,obj) :
+ """
+ Convertit un objet MCSIMP en texte python
+ Remplit le dictionnaire des MCSIMP si nous ne sommes pas ni dans une loi, ni dans une variable
+ """
+ s=PythonGenerator.generMCSIMP(self,obj)
+ if self.TraiteMCSIMP == 1 :
+ self.dictMCVal[obj.nom]=obj.val
+ else :
+ self.dictTempo[obj.nom]=obj.valeur
+ return s
+
+ def generMCFACT(self,obj):
+ # Il n est pas possible d utiliser obj.valeur qui n est pas
+ # a jour pour les nouvelles variables ou les modifications
+ if obj.nom == "Variable" :
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generMCFACT(self,obj)
+ if obj.nom == "Variable" :
+ self.ListeVariables.append(self.dictTempo)
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+ return s
+
+ def generETAPE(self,obj):
+ if obj.nom == "LOIMARG" :
+ self.TraiteMCSIMP=0
+ self.dictTempo={}
+ s=PythonGenerator.generETAPE(self,obj)
+ if obj.nom == "LOIMARG" :
+ self.dictMCLois[obj.sd]=self.dictTempo
+ self.dictTempo={}
+ self.TraiteMCSIMP=1
+ return s
+
+ def genereXML(self):
+ MonGenerateur=XMLGenerateur(self.dictMCVal, self.ListeVariables, self.dictMCLois)
+ self.texteXML=MonGenerateur.CreeXML()
+
+ def genereSTD(self):
+ MonGenerateur=STDGenerateur(self.dictMCVal, self.ListeVariables, self.dictMCLois)
+ self.texteSTD=MonGenerateur.CreeSTD()
+
+ def getOpenturnsXML(self):
+ return self.texteXML
+
+ def getOpenturnsSTD(self):
+ return self.texteSTD
from Extensions.parametre import ITEM_PARAMETRE
from Formatage import Formatage
from generator_python import PythonGenerator
-from Editeur.widgets import showerror
def entryPoint():
"""
"""
"""
if obj.isvalid() == 0 :
+ from Editeur.widgets import showerror
showerror("Element non valide","Salome ne sait pas traiter les élements non valides")
return
for v in obj.mc_liste:
if self.boolGpMa == 1:
self.list_commandes.append((self.commande,self.dict_attributs))
else :
+ from Editeur.widgets import showerror
showerror("Elements ne portant pas sur un Groupe de Maille","Salome ne sait pas montrer ce type d' element")
def generMCList(self,obj):
