From: Pascale Noyret Date: Wed, 26 Sep 2007 08:23:33 +0000 (+0000) Subject: PN debut Openturns X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=d3cc5487ced655289c75b169843c1e9c0c213acc;p=tools%2Feficas.git PN debut Openturns --- diff --git a/Aster/eficas_aster.py b/Aster/eficas_aster.py index deaa5455..a13a68ce 100755 --- a/Aster/eficas_aster.py +++ b/Aster/eficas_aster.py @@ -29,4 +29,4 @@ import prefs from InterfaceTK import eficas_go -eficas_go.lance_eficas() +eficas_go.lance_eficas(code=prefs.code) diff --git a/Openturns/Open_Cata_IDM.py b/Openturns/Open_Cata_IDM.py new file mode 100755 index 00000000..8d5e3366 --- /dev/null +++ b/Openturns/Open_Cata_IDM.py @@ -0,0 +1,1157 @@ +# -*- 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."), +## diff --git a/Openturns/Open_Cata_V0.py b/Openturns/Open_Cata_V0.py new file mode 100755 index 00000000..63d69516 --- /dev/null +++ b/Openturns/Open_Cata_V0.py @@ -0,0 +1,535 @@ +# -*- 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."), +## diff --git a/Openturns/editeur.ini b/Openturns/editeur.ini new file mode 100644 index 00000000..98582adf --- /dev/null +++ b/Openturns/editeur.ini @@ -0,0 +1,27 @@ +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'), + ) + diff --git a/Openturns/eficas_openturns.py b/Openturns/eficas_openturns.py new file mode 100755 index 00000000..98bf7fd3 --- /dev/null +++ b/Openturns/eficas_openturns.py @@ -0,0 +1,60 @@ +#!/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') diff --git a/Openturns/prefs.py b/Openturns/prefs.py new file mode 100644 index 00000000..0de3b3bc --- /dev/null +++ b/Openturns/prefs.py @@ -0,0 +1,82 @@ +# -*- 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',''), + ('Ouvrir','openJDC',''), + ('Enregistrer','saveJDC',''), + ('Enregistrer sous','saveasJDC',''), + None, + ('Fermer','closeJDC',''), + ('Quitter','exitEFICAS',''), + ] + ), + ('Edition',[ + ('Copier','copy',''), + ('Couper','cut',''), + ('Coller','paste',''), + ] + ), + ('Jeu de commandes',[ + ('Rapport de validation','visuCRJDC',''), + ('Fichier à plat','visu_a_plat',''), + ] + ), + ] + } + diff --git a/Openturns/properties.py b/Openturns/properties.py new file mode 100644 index 00000000..8ba0ed7e --- /dev/null +++ b/Openturns/properties.py @@ -0,0 +1,25 @@ +# -*- 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" diff --git a/Openturns/style.py b/Openturns/style.py new file mode 100644 index 00000000..7da9d534 --- /dev/null +++ b/Openturns/style.py @@ -0,0 +1 @@ +# Necessaire pour compatibilite avec Aster diff --git a/convert/convert_openturns.py b/convert/convert_openturns.py new file mode 100644 index 00000000..527e6f65 --- /dev/null +++ b/convert/convert_openturns.py @@ -0,0 +1,128 @@ +# -*- 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 + diff --git a/generator/OpenturnsAster.py b/generator/OpenturnsAster.py new file mode 100644 index 00000000..0f02ee89 --- /dev/null +++ b/generator/OpenturnsAster.py @@ -0,0 +1,278 @@ +# -*- 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 = '\n' +EnTeteXML += '' +EnTeteXML += '\n' +EnTeteXML += ' \n\n' +EnTeteXMLDescr = ' \n' +EnTeteXMLDescr += ' ' + +EnTeteXMLFinDescr = ' \n' +EnTeteXMLFinDescr+= ' \n' +EnTeteXMLFinDescr+= ' \n' +EnTeteXMLFinDescr+= ' \n' + +EnTeteXMLFinLib = ' \n\n' + +EnTeteXMLFIN = ' \n' +EnTeteXMLFIN += '\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 \n',1), + "Comment" : (' ', '\n',0), + "Unit" : (' ' , '\n',0), + "Regexp" : (' ' , '\n',0), + "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 ','\n ','',1), + "Gradient" : ('\n ','\n ','',0), + "Hessian" : ('\n ', '\n ','\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 \n', 2, "shared>\n"), + "ModeEntree" : (' \n',0), + "ModeSortie" : (' \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=' ' + try : + textePath += self.dictMCVal["Chemin"] + except : + print "*********************************************" + print "* ERREUR GENERATION XML *" + print "* champ wrapper non rempli *" + print "*********************************************" + textePath+='\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+=' \n' + texteVar+='\n \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=' "'+dictMCVal["commande"]+'\n' + else : + texteComm=' # no 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 + + diff --git a/generator/generator_openturns.py b/generator/generator_openturns.py new file mode 100644 index 00000000..cb314efa --- /dev/null +++ b/generator/generator_openturns.py @@ -0,0 +1,119 @@ +# -*- 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 diff --git a/generator/generator_vers3DSalome.py b/generator/generator_vers3DSalome.py index e16722af..920a32aa 100644 --- a/generator/generator_vers3DSalome.py +++ b/generator/generator_vers3DSalome.py @@ -35,7 +35,6 @@ import Extensions from Extensions.parametre import ITEM_PARAMETRE from Formatage import Formatage from generator_python import PythonGenerator -from Editeur.widgets import showerror def entryPoint(): """ @@ -119,6 +118,7 @@ class vers3DSalomeGenerator(PythonGenerator): """ """ 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: @@ -150,6 +150,7 @@ class vers3DSalomeGenerator(PythonGenerator): 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):