pass
#
-__version__="$Name: $"
-__Id__="$Id: cata.py,v 1.3.8.6 2007-06-15 13:57:36 cchris Exp $"
+__version__="$Name: BR_dev_V1_15 $"
+__Id__="$Id: cata.py,v 1.4 2007-06-15 15:52:00 cchris Exp $"
#
JdC = JDC_CATA(code='ASTER',
execmodul=None,
except:
pass
-__version__="$Name: $"
-__Id__="$Id: cata.py,v 1.4.6.1.4.1 2008-10-10 13:28:49 pnoyret Exp $"
+__version__="$Name: BR_dev_V1_15 $"
+__Id__="$Id: cata.py,v 1.5 2008-11-13 10:19:13 cchris Exp $"
EnumTypes = (ListType, TupleType)
--- /dev/null
+#@ MODIF __init__ Intranet DATE 18/09/2007 AUTEUR DURAND C.DURAND
+
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2007 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.
+# ======================================================================
--- /dev/null
+#@ MODIF calc_eolienne Intranet DATE 18/09/2007 AUTEUR DURAND C.DURAND
+
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2007 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.
+# ======================================================================
+#
+# LISTE DES FONCTIONS, MACROS et CATALOGUES
+#
+# MACROS
+#
+# calc_char_houle
+# macr_calc_eolienne
+#
+# FONCTIONS
+#
+# mail_eolienne
+# eolien_regression
+# lect_resu_stream
+# donn_boucle_pas_temps
+# extr_char_houle
+#
+# CATALOGUES
+#
+# CALC_CHAR_HOULE
+# MACR_CALC_EOLIENNE
+#
+#____________________________________________________________________
+#
+# On charge les modules necessaires
+import os
+import Numeric
+import re
+import math
+#
+# permet de definir dans le meme fichier les catalogues et les macros
+from Cata.cata import *
+#
+#____________________________________________________________________
+#____________________________________________________________________
+#
+#____________________________________________________________________
+#___________________ DEBUT MACRO calc_char_houle ____________________
+#
+#
+def calc_char_houle_ops(self, INFO, STREAM, IMPRESSION, **args):
+#
+# 1. args est le dictionnaire des arguments
+# args.keys() est la liste des mots-clés
+# args.keys()[0] est la premiere valeur de cette liste
+# args.keys()[1:] est la liste des valeurs suivantes dans cette liste
+# args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante.
+
+ """ Calcule le chargement du a la houle. """
+
+# On charge les modules nécessaires
+ from Accas import _F
+ import aster
+
+#____________________________________________________________________
+#
+# 1. Préalables
+#____________________________________________________________________
+
+# 1.1 ==> La macro compte pour 1 dans l'exécution des commandes
+
+ self.set_icmd(1)
+
+# 1.2 ==> On importe les définitions des commandes Aster utilisées
+# dans la macro
+
+ EXEC_LOGICIEL = self.get_cmd("EXEC_LOGICIEL")
+ IMPR_TABLE= self.get_cmd("IMPR_TABLE")
+ DEFI_FICHIER= self.get_cmd("DEFI_FICHIER")
+
+# 1.3 ==> Le nom des programmes à lancer
+
+# repertoire_outils = "/home/eolien/ASTER_EOLIEN/"
+ repertoire_outils = aster.repout()
+ calc_houle = repertoire_outils + "calc_houle"
+
+# 1.4 ==> Initialisations
+
+ erreur = 0
+ erreur_partiel = [0]
+ Rep_Calc_ASTER = os.getcwd()
+
+ messages_erreur = { 0 : "<CALC_CHAR_HOULE> Tout va bien.",
+ 1 : "<CALC_CHAR_HOULE> Impossible de créer le répertoire de travail pour le logiciel de calcul de houle.",
+ 100 : "<CALC_CHAR_HOULE> Erreur." }
+
+ while not erreur :
+
+#____________________________________________________________________
+#
+# 2. Répertoires et fichiers
+#____________________________________________________________________
+#
+
+# 2.1. ==> Création du répertoire pour l'exécution du logiciel STREAM_FM
+
+ Nom_Rep_local_houle = "tmp_stream"
+ Rep_Calc_LOGICIEL_local_houle = os.path.join(".",Nom_Rep_local_houle)
+ Rep_Calc_LOGICIEL_global_houle = os.path.join(Rep_Calc_ASTER,Nom_Rep_local_houle)
+
+ try :
+ os.mkdir(Rep_Calc_LOGICIEL_global_houle)
+ except os.error,erreur_partiel :
+ self.cr.warn("Code d'erreur de mkdir : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1])
+ self.cr.fatal("Impossible de créer le répertoire de travail pour le logiciel de calcul de houle : "+Rep_Calc_LOGICIEL_global_houle)
+ erreur = 1
+ break
+
+# 2.2. ==> On cree un fichier annexe pour transmettre des infos à la procédure de lancement
+# de STREAM_FM
+
+ fic_Info_ASTER = os.path.join(Rep_Calc_LOGICIEL_global_houle,"InfoExecASTER")
+ f_execAster = open(fic_Info_ASTER, "w")
+ f_execAster.write(str(INFO)+"\n")
+ f_execAster.close()
+
+#____________________________________________________________________
+#
+# 3. Décodage des arguments de la macro-commande
+# et création des fichiers pour STREAM_FM
+#____________________________________________________________________
+
+# 3.1. ==> Les fichiers pour le logiciel STREAM_FM
+# Ils sont créés dans le répertoire d'exécution du logiciel, avec leurs noms officiels
+
+ fic_data_HT = os.path.join(Rep_Calc_LOGICIEL_global_houle,"AMA_HT.par")
+ fic_data_FM = os.path.join(Rep_Calc_LOGICIEL_global_houle,"AMA_FM.par")
+
+# 3.2 ==> Construction du fichier 'data_HT'
+
+# 3.2.1 ==> Ouverture du fichier data_HT dans un répertoire temporaire
+
+ f_menu = open(fic_data_HT, "w")
+
+# 3.2.2 ==> Lecture et écriture des données nécessaires
+
+ prof = STREAM['PROFONDEUR']
+ h_houle = STREAM['H_HOULE']
+ peri_houle = STREAM['PERI_HOULE']
+ courant_euler = STREAM['COUR_EULERIEN']
+ ordre_fonc = STREAM['ORDR_FONC_COURAN']
+
+ f_menu.write(str(prof)+" <= Profondeur d'eau (m)\n")
+ f_menu.write(str(h_houle)+" <= Hauteur de houle (crete-a-creux) (m)\n")
+ f_menu.write(str(peri_houle)+" <= Periode de houle (s)\n")
+ f_menu.write(str(courant_euler)+" <= Vitesse du courant eulerien (m/s)\n")
+ f_menu.write(str(ordre_fonc)+" <= ordre de la fonction de courant (m/s)\n")
+
+# 3.2.3 ==> Fermeture du fichier data_HT
+
+ f_menu.close()
+
+ if INFO >= 2 :
+ print "===========================\n"
+ print "Contenu du fichier data_HT :"
+ fichier = open (fic_data_HT,"r")
+ les_lignes = fichier.readlines()
+ fichier.close()
+ for ligne in les_lignes :
+ print ligne[:-1]
+ print "===========================\n"
+
+# 3.3 ==> Construction du fichier "data_FM"
+
+# 3.3.1 ==> Ouverture du fichier
+
+ f_FM = open(fic_data_FM, "w")
+
+# 3.3.2 ==> Lecture et écriture des données nécessaires
+
+ diam = STREAM['DEXT_HAUT_BASE']
+ coef_trainee = STREAM['COEF_TRAINEE']
+ coef_inertie = STREAM['COEF_INERTIE']
+ nb_nive_z = STREAM['NB_POINTS_VERT']
+ nb_dt_par_t = STREAM['NB_INTER_PERI']
+
+ f_FM.write(str(diam)+" <= Diametre du cylindre (m)\n")
+ f_FM.write(str(coef_trainee)+" <= Coefficient de trainee Cd\n")
+ f_FM.write(str(coef_inertie)+" <= Coefficient d'inertie Cm\n")
+ f_FM.write(str(nb_nive_z)+" <= Nbe de points sur la verticale\n")
+ f_FM.write(str(nb_dt_par_t)+" <= Nbe de pas de temps sur une periode de houle\n")
+
+# 3.3.3 ==> Fermeture du fichier data_FM
+
+ f_FM.close()
+
+ if INFO >= 2 :
+ print "===========================\n"
+ print "Contenu du fichier data_FM :"
+ fichier = open (fic_data_FM,"r")
+ les_lignes = fichier.readlines()
+ fichier.close()
+ for ligne in les_lignes :
+ print ligne[:-1]
+ print "===========================\n"
+
+# 3.4 ==> Nom du fichier qui contiendra le résultat
+
+ if (IMPRESSION['UNITE'] != None) :
+ Unit_Fich_Resu = 'fort.'+str(IMPRESSION['UNITE'])
+
+#____________________________________________________________________
+#
+# 4. Ecriture de la commande d"exécution du logiciel STREAM
+#
+# Remarque : dans la donnée de la version du logiciel STREAM, il faut remplacer
+# le _ de la donnée par un ., qui
+# est interdit dans la syntaxe du langage de commandes ASTER
+# Remarque : il faut remplacer le N majuscule de la donnee par
+# un n minuscule, qui est interdit dans la syntaxe du langage
+# de commandes ASTER
+#____________________________________________________________________
+#
+
+ VERSION="aster"
+ LOGICIEL = "STREAM"
+
+ EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_LOGICIEL_global_houle, # nom du repertoire du calcul de houle
+ LOGICIEL, # nom du logiciel de calcul de houle
+ VERSION, # version du logiciel de calcul de houle
+ ),
+ LOGICIEL = calc_houle
+ )
+
+#____________________________________________________________________
+#
+# 5. Lecture du fichier de résultats STREAM_FM
+#____________________________________________________________________
+#
+# 5.1 ==> Ouverture, lecture et fermeture du fichier "AMA_FM.res"
+
+ if (IMPRESSION['UNITE'] != None) :
+ fic_resuStream = os.path.join(Rep_Calc_LOGICIEL_global_houle,"AMA_FM.res")
+ f_resu = open(fic_resuStream, "r")
+ lignes = f_resu.readlines()
+ f_resu.close()
+
+ Fic_Tabl_Resu = os.path.join(Rep_Calc_ASTER,Unit_Fich_Resu)
+ f_resu = open(Fic_Tabl_Resu, "w")
+ f_resu.writelines(lignes)
+ f_resu.close()
+#
+#____________________________________________________________________
+#
+# 6. C'est fini !
+#____________________________________________________________________
+#
+ break
+
+# 6.1. ==> Arret en cas d'erreur
+
+ if erreur :
+ if not messages_erreur.has_key(erreur) :
+ erreur = 100
+ self.cr.fatal(messages_erreur[erreur])
+
+ return
+
+#____________________________________________________________________
+#____________________ FIN MACRO calc_char_houle _____________________
+#
+#____________________________________________________________________
+#___________________ DEBUT FONCTION mail_eolienne ___________________
+#
+#
+# ===> Creation des fichiers de commandes GIBI
+#____________________________________________________________________
+#
+
+def mail_eolienne(H_TOTALE, H_BASE, H_IMMERGEE, H_MOYEU, H_JONCTION, DECAL_PALES,
+ DEXT_NACELLE, EPAIS_NACELLE, DEXT_HAUT_BASE, DEXT_BAS_BASE,
+ EPAIS_HAUT_BASE, EPAIS_BAS_BASE, DEXT_HAUT_FUT, DEXT_BAS_FUT,
+ EPAIS_HAUT_FUT, EPAIS_BAS_FUT, NB_ELEM_BASE, NB_ELEM_FUT,
+ NBEL_EPAIS_BASE, NBEL_EPAIS_FUT, NBEL_DCIR_BASE, NBEL_DCIR_FUT,
+ ANGLE_VENT_AXE_X,
+ MODELISATION, TYPE_ELEM, NIVE_GIBI, fichier_datg) :
+
+#
+# 1 ==> Reccuperation du repertoire dans lequel s'execute le calcul ASTER
+#
+ Rep_Calc_ASTER = os.getcwd()
+
+#
+# 2 ==> Decoupage des mailles de la base en fonction du niveau d'eau
+#
+ lb = H_BASE / NB_ELEM_BASE
+ nbi = int(H_IMMERGEE/lb)
+ hbe = H_BASE - H_IMMERGEE
+
+ # CAS 1
+ if ( ((H_IMMERGEE/lb)-nbi) < 0.5 ) :
+ lbi = H_IMMERGEE/nbi
+ if (hbe > 0.0) :
+ nbe = NB_ELEM_BASE - nbi
+ lbe = hbe/nbe
+ else :
+ nbe = 0
+ # CAS 2
+ if ( ((H_IMMERGEE/lb)-nbi) >= 0.5 ) :
+ lbi = H_IMMERGEE/(nbi+1)
+ nbe = NB_ELEM_BASE - (nbi+1)
+ lbe = hbe/nbe
+ nbi = nbi + 1
+
+#
+# 3 ==> Ecriture des donnees necessaires dans le fichier auxiliaire
+#
+ if MODELISATION == 'POUTRE' :
+
+ # 3.1 ==> Ouverture du fichier auxiliaire
+
+ fichier_auxi = os.path.join(Rep_Calc_ASTER,"fichaux")
+ fdaux = open (fichier_auxi,'w')
+
+ # 3.2 ==> Ecriture des donnees dans le fichier auxiliaire
+
+ j = 0
+
+ for i in range(nbi) :
+ j = j+1
+ fdaux.write("base"+str(j)+" = baset . "+str(j)+";\n")
+ if hbe > 0.0 :
+ for i in range(nbe) :
+ j = j+1
+ fdaux.write("base"+str(j)+" = baset . "+str(j)+";\n")
+
+ for i in range(NB_ELEM_FUT) :
+ fdaux.write("fut"+str(i+1)+" = futt . "+str(i+1)+";\n")
+
+ fdaux.write("SAUV FORM eolienne;\n")
+ fdaux.write("FIN;\n")
+
+ # 3.3 ==> Fermeture du fichier auxiliaire
+
+ fdaux.close()
+
+#
+# 4 ==> Ecriture des donnees necessaires dans le fichier de donnees GIBI
+#
+
+# 4.1 ==> Ouverture du fichier de données GIBI
+
+ fdgib = open (fichier_datg,'w')
+
+
+# 4.2 ==> Ecriture des donnees dans le fichier de donnees GIBI
+
+ fdgib.write("*********************************\n")
+ fdgib.write("** Maillage d'une eolienne en mer\n")
+ fdgib.write("*********************************\n")
+ fdgib.write("***********************\n")
+ fdgib.write("***********************\n")
+ fdgib.write("** donnees geometriques\n")
+ fdgib.write("***********************\n")
+
+ fdgib.write("opti nive "+str(NIVE_GIBI)+";\n")
+
+ if MODELISATION == 'POUTRE' :
+ fdgib.write("modbase = 'poutre';\n")
+ fdgib.write("modfut = 'poutre';\n")
+ if MODELISATION == 'COQUE' :
+ fdgib.write("modbase = 'coque';\n")
+ fdgib.write("modfut = 'coque';\n")
+ if MODELISATION == '3D' :
+ fdgib.write("modbase = '3D';\n")
+ fdgib.write("modfut = '3D';\n")
+ if TYPE_ELEM == 'CUB8' : fdgib.write("quad = 'non';\n")
+ if TYPE_ELEM == 'CU20' : fdgib.write("quad = 'oui';\n")
+
+ fdgib.write("**** hauteur totale du monopode (hors nacelle)\n")
+ fdgib.write("h_totale = "+str(H_TOTALE)+";\n")
+ fdgib.write("**** hauteur de la base du monopode\n")
+ fdgib.write("hb = "+str(H_BASE)+";\n")
+ fdgib.write("**** hauteur immergee (deduite du calcul par STREAM)\n")
+ fdgib.write("hbi = "+str(H_IMMERGEE)+";\n")
+ fdgib.write("**** nombre de mailles immergees de la base\n")
+ fdgib.write("nbi = "+str(nbi)+";\n")
+ fdgib.write("**** hauteur emergee\n")
+ fdgib.write("hbe = "+str(hbe)+";\n")
+ fdgib.write("**** nombre de mailles emergees de la base\n")
+ fdgib.write("nbe = "+str(nbe)+";\n")
+ fdgib.write("**** decoupage vertical\n")
+ fdgib.write("nb_base = "+str(NB_ELEM_BASE)+";\n")
+ fdgib.write("nb_fut = "+str(NB_ELEM_FUT)+";\n")
+ fdgib.write("**** diametre et epaisseur bas du fut\n")
+ fdgib.write("dex_bfut = "+str(DEXT_BAS_FUT)+";\n")
+ fdgib.write("ep_bfut = "+str(EPAIS_BAS_FUT)+";\n")
+ fdgib.write("**** diametre et epaisseur haut du fut\n")
+ fdgib.write("dex_hfut = "+str(DEXT_HAUT_FUT)+";\n")
+ fdgib.write("ep_hfut = "+str(EPAIS_HAUT_FUT)+";\n")
+ fdgib.write("**** diametre et epaisseur bas de la base\n")
+ fdgib.write("dex_bbas = "+str(DEXT_BAS_BASE)+";\n")
+ fdgib.write("ep_bbas = "+str(EPAIS_BAS_BASE)+";\n")
+ fdgib.write("**** diametre et epaisseur haut de la base\n")
+ fdgib.write("dex_hbas = "+str(DEXT_HAUT_BASE)+";\n")
+ fdgib.write("ep_hbas = "+str(EPAIS_HAUT_BASE)+";\n")
+
+ if MODELISATION == '3D' or MODELISATION == 'COQUE' :
+ fdgib.write("**** nombre d'elements sur un demi-cercle\n")
+ fdgib.write("nbcirfut = "+str(NBEL_DCIR_FUT)+";\n")
+ fdgib.write("nbcirbas = "+str(NBEL_DCIR_BASE)+";\n")
+ fdgib.write("**** hauteur de la jonction base/fut\n")
+ fdgib.write("hbj = "+str(H_JONCTION)+";\n")
+ if MODELISATION == '3D' :
+ fdgib.write("**** nombre d'elements dans l'epaisseur\n")
+ fdgib.write("nbep_fut = "+str(NBEL_EPAIS_FUT)+";\n")
+ fdgib.write("nbep_bas = "+str(NBEL_EPAIS_BASE)+";\n")
+
+ fdgib.write("**** angle entre la pression du vent et l'axe X (degres)\n")
+ fdgib.write("alpha = "+str(ANGLE_VENT_AXE_X)+";\n")
+ fdgib.write("**** decalage pales\n")
+ fdgib.write("dec0 = "+str(DECAL_PALES)+";\n")
+ fdgib.write("**** hauteur moyeu\n")
+ fdgib.write("hp0 = "+str(H_MOYEU)+";\n")
+
+ fdgib.write("opti echo 0;\n")
+# loc_datg = "/home/eolien/DATG/"
+ loc_datg = aster.repdex()
+ fdgib.write("* \n")
+ fdgib.write(open(os.path.join(loc_datg, 'calc_eolienne.datg'), 'r').read())
+
+# 4.3 ==> Fermeture du fichier de donnees GIBI
+
+ fdgib.close()
+
+# 5 ==> FIN
+
+ return
+
+#____________________________________________________________________
+#____________________ FIN FONCTION mail_eolienne ____________________
+#
+#____________________________________________________________________
+#
+#____________________________________________________________________
+#_________________ DEBUT FONCTION eolien_regression _________________
+#
+#
+# ===> Regression selon les moindres carres
+#____________________________________________________________________
+#
+#
+def eolien_regression (liste, INFO,) :
+#
+#
+#____________________________________________________________________
+#
+# MOINDRES CARRES
+#____________________________________________________________________
+#
+# Calcul des coefficients teta0, teta1, teta2 et teta3 de
+# l'application qui passe au mieux (au sens des moindres carres)
+# par les couples (profondeur,force lineique).
+
+
+# 1 ==> Initialisation
+
+
+# 2 ==> Nombre de points calcules par STREAM selon l'axe vertical
+
+ dim = liste.shape[0]
+
+# Controle : dim == Nb_valeur a voir
+
+# 3 ==> Definition des polynomes
+
+ global P0, P1, P2, P3
+
+ def P0():
+ return 1
+
+ def P1(alpha1, x):
+ return (x-alpha1)
+
+ def P2(alpha1, alpha2, beta2, x):
+ return (x-alpha2)*(x-alpha1) - beta2
+
+ def P3(alpha1, alpha2, alpha3, beta2, beta3, x):
+ return (x-alpha3)*((x-alpha2)*(x-alpha1) - beta2) - beta3*(x-alpha1)
+
+# 4 ==> Definition de la fonction polynomiale de degre 3
+
+ def FF3(alpha1, alpha2, alpha3, beta2, beta3, teta0, teta1, teta2, teta3, x):
+ return teta0*P0() + teta1*P1(alpha1,x) + teta2*P2(alpha1,alpha2,beta2,x) + teta3*P3(alpha1,alpha2,alpha3,beta2,beta3,x)
+
+# 5 ==> Calcul des coefficients alpha1, alpha2, alpha3, beta2 et beta3
+
+ numerateur_alpha1 = 0
+ denominateur_alpha1 = 0
+ alpha1 = 0
+ for i in range(dim) :
+ numerateur_alpha1 = numerateur_alpha1 + liste[[i,0]]*P0()**2
+ denominateur_alpha1 = denominateur_alpha1 + P0()**2
+
+ alpha1 = numerateur_alpha1/denominateur_alpha1
+
+ numerateur_alpha2 = 0
+ denominateur_alpha2 = 0
+ alpha2 = 0
+ numerateur_beta2 = 0
+ denominateur_beta2 = 0
+ beta2 = 0
+ for i in range(dim) :
+ numerateur_alpha2 = numerateur_alpha2 + liste[[i,0]]*P1(alpha1,liste[[i,0]])**2
+ denominateur_alpha2 = denominateur_alpha2 + P1(alpha1,liste[[i,0]])**2
+ numerateur_beta2 = numerateur_beta2 + P1(alpha1,liste[[i,0]])**2
+ denominateur_beta2 = denominateur_beta2 + P0()**2
+
+ alpha2 = numerateur_alpha2/denominateur_alpha2
+ beta2 = numerateur_beta2/denominateur_beta2
+
+ numerateur_alpha3 = 0
+ denominateur_alpha3 = 0
+ alpha3 = 0
+ numerateur_beta3 = 0
+ denominateur_beta3 = 0
+ beta3 = 0
+ for i in range(dim) :
+ numerateur_alpha3 = numerateur_alpha3 + liste[[i,0]]*P2(alpha1,alpha2,beta2,liste[[i,0]])**2
+ denominateur_alpha3 = denominateur_alpha3 + P2(alpha1,alpha2,beta2,liste[[i,0]])**2
+ numerateur_beta3 = numerateur_beta3 + P2(alpha1,alpha2,beta2,liste[[i,0]])**2
+ denominateur_beta3 = denominateur_beta3 + P1(alpha1,liste[[i,0]])**2
+
+ alpha3 = numerateur_alpha3/denominateur_alpha3
+ beta3 = numerateur_beta3/denominateur_beta3
+
+# 6 ==> Calcul des estimateurs cherches : teta0, teta1, teta2, teta3
+
+ numerateur_teta0 = 0
+ denominateur_teta0 = 0
+ teta0 = 0
+ for i in range(dim) :
+ numerateur_teta0 = numerateur_teta0 + liste[[i,1]]*P0()
+ denominateur_teta0 = denominateur_teta0 + P0()**2
+
+ teta0 = numerateur_teta0/denominateur_teta0
+
+ numerateur_teta1 = 0
+ denominateur_teta1 = 0
+ teta1 = 0
+ for i in range(dim) :
+ numerateur_teta1 = numerateur_teta1 + liste[[i,1]]*P1(alpha1,liste[[i,0]])
+ denominateur_teta1 = denominateur_teta1 + P1(alpha1,liste[[i,0]])**2
+
+ teta1 = numerateur_teta1/denominateur_teta1
+
+ numerateur_teta2 = 0
+ denominateur_teta2 = 0
+ teta2 = 0
+ for i in range(dim) :
+ numerateur_teta2 = numerateur_teta2 + liste[[i,1]]*P2(alpha1,alpha2,beta2,liste[[i,0]])
+ denominateur_teta2 = denominateur_teta2 + P2(alpha1,alpha2,beta2,liste[[i,0]])**2
+
+ teta2 = numerateur_teta2/denominateur_teta2
+
+ numerateur_teta3 = 0
+ denominateur_teta3 = 0
+ teta3 = 0
+ for i in range(dim) :
+ numerateur_teta3 = numerateur_teta3 + liste[[i,1]]*P3(alpha1,alpha2,alpha3,beta2,beta3,liste[[i,0]])
+ denominateur_teta3 = denominateur_teta3 + P3(alpha1,alpha2,alpha3,beta2,beta3,liste[[i,0]])**2
+
+ teta3 = numerateur_teta3/denominateur_teta3
+
+# 7 ==> Impression de certains resultats si INFO == 2
+
+ if (INFO == 2) :
+ print " "
+ print "<EOLIEN_REGRESSION> RESULTATS "
+ print " "
+ print "<EOLIEN_REGRESSION> teta0 = ", teta0
+ print "<EOLIEN_REGRESSION> teta1 = ", teta1
+ print "<EOLIEN_REGRESSION> teta2 = ", teta2
+ print "<EOLIEN_REGRESSION> teta3 = ", teta3
+ print " "
+
+ print "<EOLIEN_REGRESSION> ===> VERIFICATION INTERPOLATION\n"
+ print " No point - profondeur - valeur STREAM - valeur par moindres carres \n"
+ for i in range(dim) :
+ print ' %3d %12.4f %12.4f %12.4f' % (i+1,liste[[i,0]],liste[[i,1]],FF3(alpha1, alpha2, alpha3, beta2, beta3, teta0, teta1, teta2, teta3,liste[[i,0]]))
+
+ return (teta0,teta1,teta2,teta3,alpha1,alpha2,alpha3,beta2,beta3)
+
+#____________________________________________________________________
+#_________________ FIN FONCTION eolien_regression ___________________
+#
+#____________________________________________________________________
+#
+#____________________________________________________________________
+#_________________ DEBUT FONCTION lect_resu_stream __________________
+#
+#
+# ===> Lecture du fichier de resultats STREAM_FM
+#____________________________________________________________________
+#
+
+def lect_resu_stream(INFO) :
+
+# 1 ==> Ouverture, lecture et fermeture du fichier "AMA_FM.res"
+
+ Rep_Calc_ASTER = os.getcwd()
+ Nom_Rep_local_houle = "tmp_stream"
+ Rep_Calc_LOGICIEL_local_houle = os.path.join(".",Nom_Rep_local_houle)
+ Rep_Calc_LOGICIEL_global_houle = os.path.join(Rep_Calc_ASTER,Nom_Rep_local_houle)
+
+ fic_resuStream = os.path.join(Rep_Calc_LOGICIEL_global_houle,"AMA_FM.res")
+ f_resu = open(fic_resuStream, "r")
+ lignes = f_resu.readlines()
+ f_resu.close()
+
+# 2 ==> Lecture du nombre de points (valeurs de forces lineiques).
+# Lecture du nombre par lequel la periode a ete decoupee
+# ATENTION ==> le nombre de pas de temps est egal a ce nombre plus un.
+
+ compt_temps = 0
+ compt_valeur = 0
+ dict_temps = {}
+
+ for i in range(len(lignes)) :
+ ligne = lignes[i].split()
+ print"<LECT_RESU_STREAM> ligne = ",ligne
+ if ligne[0] == "/PERIODE" and ligne[2] == "HOULE.................T........:" :
+ periode_houle = float(ligne[len(ligne)-2])
+
+ if INFO == 2 :
+ print "<I> <MACR_CALC_EOLIENNE> Periode de houle = ",periode_houle
+
+ if ligne[0] == "/NB" and ligne[2] == "POINTS" :
+ Nb_valeur = int(ligne[len(ligne)-1])
+
+ if INFO == 2 :
+ print "<I> <MACR_CALC_EOLIENNE> Nb_valeur = ",Nb_valeur
+
+ if ligne[0] == "/NB" and ligne[4] == "TEMPS" :
+ Nb_pas_temps = int(ligne[len(ligne)-1])
+
+ if INFO == 2 :
+ print "<I> <MACR_CALC_EOLIENNE> Nb_pas_temps = ",Nb_pas_temps
+ break
+
+ return(periode_houle,Nb_valeur,Nb_pas_temps,lignes)
+
+#____________________________________________________________________
+#__________________ FIN FONCTION lect_resu_stream ___________________
+#
+#____________________________________________________________________
+#
+#____________________________________________________________________
+#_______________ DEBUT FONCTION donn_boucle_pas_temps _______________
+#
+#
+# ===> Preparation donnees necessaires a la boucle sur les pas de temps
+# et verification du nombre de pas de temps
+#____________________________________________________________________
+#
+
+def donn_boucle_pas_temps(lignes,Nb_pas_temps) :
+
+# 1 ==> Construction du dictionnaire contenant :
+# pas_de_temps : numeros de ligne du fichier resu_STREAM_FM
+
+ compt_temps = 0
+ dict_temps = {}
+
+ for i in range(len(lignes)) :
+ ligne = lignes[i].split()
+ if len(ligne) != 0 :
+ if ligne[0] == "#TITRE" and ligne[1] == "TEMPS" :
+ compt_temps = compt_temps + 1
+ dict_temps["TEMPS_"+str(compt_temps)] = i+1
+
+# 2 ==> Controle de l'egalite : compt_temps == Nb_pas_temps+1
+# et arret en cas d'erreur.
+
+ if compt_temps != (Nb_pas_temps+1) :
+ print"\n <F> <DONN_BOUCLE_PAS_TEMPS> IL Y A UN PROBLEME DANS DE NOMBRE DE PAS DE TEMPS.\n"
+
+ return(dict_temps)
+#
+#____________________________________________________________________
+#________________ FIN FONCTION donn_boucle_pas_temps ________________
+#
+#____________________________________________________________________
+#
+#____________________________________________________________________
+#__________________ DEBUT FONCTION extr_char_houle __________________
+#
+#
+# ===> Extraction des couples (profondeur,force lineique)
+# du fichier resu_STREAM_FM au pas de temps courant et
+# remplissage de la liste de travail.
+#____________________________________________________________________
+#
+#####################
+# VALEUR TEST
+#
+test = 'NON'
+# Nb_pas_temps = 0
+#####################
+
+def extr_char_houle(k,dict_temps,Nb_valeur,lignes) :
+
+ liste = Numeric.zeros((Nb_valeur,2), Numeric.Float)
+
+ nume_ligne_temps = dict_temps["TEMPS_"+str(k)]
+ range_depart = int(nume_ligne_temps) + 2
+ range_arrive = int(nume_ligne_temps) + Nb_valeur + 3
+ for l in range(range_depart, range_arrive) :
+ ligne = lignes[l].split()
+ if (len(ligne) != 0) :
+ Flag_Val=re.match(r'^[-]?([0-9]+\.?[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?$',ligne[0])
+ if (Flag_Val != None) :
+ liste[[(l-range_depart),0]] = float(ligne[0])
+ liste[[(l-range_depart),1]] = float(ligne[1])
+
+ return(range_depart,range_arrive,liste)
+
+#____________________________________________________________________
+#___________________ FIN FONCTION extr_char_houle ___________________
+#
+# _____________________________
+# _______________
+# _____________________________
+#
+#____________________________________________________________________
+#__________________ DEBUT MACRO macr_calc_eolienne __________________
+#
+#
+# ===> MACRO COMMANDE MACR_CALC_EOLIENNE
+#
+#____________________________________________________________________
+#
+# SCRIPT PYTHON
+#
+def macr_calc_eolienne_ops(self, INFO, MONOPODE, EXEC_MAILLAGE, AFFE_MATERIAU, CHARGEMENT,
+ IMPRESSION, MODELISATION, NOM_MAIL_REF, TYPE_ELEM, FATIGUE, **args) :
+
+ """ Calcule la structure de l'eolienne en mer. """
+
+# On charge les modules nécessaires
+ from Accas import _F
+ import aster
+# import os
+
+#____________________________________________________________________
+#
+# 1. Préalables
+#____________________________________________________________________
+#
+# 1.1 ==> La macro compte pour 1 dans l'exécution des commandes
+
+ self.set_icmd(1)
+ erreur = 0
+
+# 1.2 ==> On importe les définitions des commandes Aster utilisées
+# dans la macro
+
+ affemateriau = AFFE_MATERIAU
+# impression = IMPRESSION
+ PRE_GIBI = self.get_cmd("PRE_GIBI")
+ EXEC_LOGICIEL = self.get_cmd("EXEC_LOGICIEL")
+ LIRE_MAILLAGE = self.get_cmd("LIRE_MAILLAGE")
+ DEFI_GROUP = self.get_cmd("DEFI_GROUP")
+ CREA_MAILLAGE = self.get_cmd("CREA_MAILLAGE")
+ MODI_MAILLAGE = self.get_cmd("MODI_MAILLAGE")
+ AFFE_CARA_ELEM = self.get_cmd("AFFE_CARA_ELEM")
+ AFFE_MODELE = self.get_cmd("AFFE_MODELE")
+ AFFE_MATERIAU = self.get_cmd("AFFE_MATERIAU")
+ FORMULE = self.get_cmd("FORMULE")
+ AFFE_CHAR_MECA_F= self.get_cmd("AFFE_CHAR_MECA_F")
+ AFFE_CHAR_MECA= self.get_cmd("AFFE_CHAR_MECA")
+ DEFI_LIST_REEL= self.get_cmd("DEFI_LIST_REEL")
+ STAT_NON_LINE= self.get_cmd("STAT_NON_LINE")
+ MECA_STATIQUE= self.get_cmd("MECA_STATIQUE")
+ CREA_CHAMP= self.get_cmd("CREA_CHAMP")
+ PROJ_CHAMP= self.get_cmd("PROJ_CHAMP")
+ CREA_RESU= self.get_cmd("CREA_RESU")
+ CALC_ELEM= self.get_cmd("CALC_ELEM")
+#
+# IMPR_CO= self.get_cmd("IMPR_CO")
+#
+ IMPR_RESU= self.get_cmd("IMPR_RESU")
+ CALC_NO= self.get_cmd("CALC_NO")
+ CALC_FATIGUE= self.get_cmd("CALC_FATIGUE")
+ DETRUIRE= self.get_cmd("DETRUIRE")
+ DEFI_FICHIER= self.get_cmd("DEFI_FICHIER")
+
+# 1.3 ==> Lecture des donnees
+
+ H_TOTALE = MONOPODE['H_TOTALE']
+ H_BASE = MONOPODE['H_BASE']
+ H_MOYEU = MONOPODE['H_MOYEU']
+ DECAL_PALES = MONOPODE['DECAL_PALES']
+ DEXT_HAUT_BASE = MONOPODE['DEXT_HAUT_BASE']
+ DEXT_BAS_BASE = MONOPODE['DEXT_BAS_BASE']
+ EPAIS_HAUT_BASE = MONOPODE['EPAIS_HAUT_BASE']
+ EPAIS_BAS_BASE = MONOPODE['EPAIS_BAS_BASE']
+ DEXT_HAUT_FUT = MONOPODE['DEXT_HAUT_FUT']
+ DEXT_BAS_FUT = MONOPODE['DEXT_BAS_FUT']
+ EPAIS_HAUT_FUT = MONOPODE['EPAIS_HAUT_FUT']
+ EPAIS_BAS_FUT = MONOPODE['EPAIS_BAS_FUT']
+ NB_ELEM_BASE = MONOPODE['NB_ELEM_BASE']
+ NB_ELEM_FUT = MONOPODE['NB_ELEM_FUT']
+ if (MODELISATION == '3D' or MODELISATION == 'COQUE') :
+ H_JONCTION = MONOPODE['H_JONCTION']
+ DEXT_NACELLE = MONOPODE['DEXT_NACELLE']
+ EPAIS_NACELLE = MONOPODE['EPAIS_NACELLE']
+ NBEL_EPAIS_BASE = MONOPODE['NBEL_EPAIS_BASE']
+ NBEL_EPAIS_FUT = MONOPODE['NBEL_EPAIS_FUT']
+ else :
+ H_JONCTION = None
+ DEXT_NACELLE = None
+ EPAIS_NACELLE = None
+ NBEL_EPAIS_BASE = None
+ NBEL_EPAIS_FUT = None
+
+ if (MODELISATION == '3D') :
+ NBEL_DCIR_BASE = MONOPODE['NBEL_DCIR_BASE']
+ NBEL_DCIR_FUT = MONOPODE['NBEL_DCIR_FUT']
+ else :
+ NBEL_DCIR_BASE = None
+ NBEL_DCIR_FUT = None
+
+ ANGLE_VENT_AXE_X = CHARGEMENT['ANGLE_VENT_AXE_X']
+
+ LOGICIEL = EXEC_MAILLAGE['LOGICIEL']
+ UNITE_DATG = EXEC_MAILLAGE['UNITE_DATG']
+ UNITE_MGIB = EXEC_MAILLAGE['UNITE_MGIB']
+ NIVE_GIBI = EXEC_MAILLAGE['NIVE_GIBI']
+
+# 1.4 ==> Creation du repertoire pour l'execution du logiciel GIBI
+
+ erreur_partiel = [0]
+ Rep_Calc_ASTER = os.getcwd()
+
+ Nom_Rep_local_mail = "tmp_dgib"
+ Rep_Calc_LOGICIEL_local_mail = os.path.join(".",Nom_Rep_local_mail)
+ Rep_Calc_LOGICIEL_global_mail = os.path.join(Rep_Calc_ASTER,Nom_Rep_local_mail)
+
+ try :
+ os.mkdir(Rep_Calc_LOGICIEL_global_mail)
+ except os.error,erreur_partiel :
+ self.cr.warn("Code d'erreur de mkdir : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1])
+ self.cr.fatal("Impossible de creer le repertoire de travail pour le logiciel de maillage : "+Rep_Calc_LOGICIEL_global_mail)
+
+ aux_datg = 'fort.'+str(UNITE_DATG)
+ fichier_datg = os.path.join(Rep_Calc_LOGICIEL_global_mail,aux_datg)
+
+ aux_mgib = 'fort.'+str(UNITE_MGIB)
+ fichier_mgib = os.path.join(Rep_Calc_ASTER,aux_mgib)
+
+ repertoire_outils = aster.repout()
+ if (LOGICIEL == 'GIBI2000') : logi_mail = repertoire_outils+'gibi2000'
+ if (LOGICIEL == 'GIBI98') : logi_mail = repertoire_outils+'gibi98'
+
+# 1.5 ==> Construction du maillage et du modele de reference
+
+ if (MODELISATION == '3D') and (FATIGUE != None) :
+
+ H_IMMERGEE = MONOPODE['H_BASE']
+
+ mail_eolienne(H_TOTALE, H_BASE, H_IMMERGEE, H_MOYEU, H_JONCTION, DECAL_PALES,
+ DEXT_NACELLE, EPAIS_NACELLE, DEXT_HAUT_BASE, DEXT_BAS_BASE,
+ EPAIS_HAUT_BASE, EPAIS_BAS_BASE, DEXT_HAUT_FUT, DEXT_BAS_FUT,
+ EPAIS_HAUT_FUT, EPAIS_BAS_FUT, NB_ELEM_BASE, NB_ELEM_FUT,
+ NBEL_EPAIS_BASE, NBEL_EPAIS_FUT, NBEL_DCIR_BASE, NBEL_DCIR_FUT,
+ ANGLE_VENT_AXE_X,
+ MODELISATION, TYPE_ELEM, NIVE_GIBI, fichier_datg)
+
+ EXEC_LOGICIEL(
+ LOGICIEL=logi_mail,
+ ARGUMENT=(fichier_datg, # fichier de donnees GIBI
+ fichier_mgib, # fichier resultats format GIBI
+ )
+ )
+
+ PRE_GIBI()
+
+ if NOM_MAIL_REF!=None : self.DeclareOut('mail_ref',NOM_MAIL_REF)
+ mail_ref = LIRE_MAILLAGE()
+
+# debut test
+# IMPR_CO(CO=mail_ref,)
+# fin test
+
+ MOREF = AFFE_MODELE( MAILLAGE=mail_ref,
+ AFFE=(_F(GROUP_MA = ('MONOPODE'),
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = '3D',),),);
+
+# 1.6 ==> Lecture du fichier de resultats STREAM_FM
+
+ (periode_houle,Nb_valeur,Nb_pas_temps,lignes) = lect_resu_stream(INFO)
+
+# 1.7 ==> declaration de tableaux pour les concepts Aster
+
+ if (MODELISATION == 'COQUE') :
+ MA2 = [None] * (Nb_pas_temps+1) # pour la modelisation COQUE
+
+ MA = [None] * (Nb_pas_temps+1) # pour les modelisations POUTRE et 3D
+ __MO = [None] * (Nb_pas_temps+1)
+ CARA = [None] * (Nb_pas_temps+1)
+ __affmat = [None] * (Nb_pas_temps+1)
+
+# 1.8 ==> Construction du dictionnaire contenant :
+# pas_de_temps : numeros de ligne du fichier resu_STREAM_FM
+
+ dict_temps = donn_boucle_pas_temps(lignes,Nb_pas_temps)
+
+#____________________________________________________________________
+#
+#####################
+# VALEUR TEST
+#
+ test = 'NON'
+# Nb_pas_temps = 0
+#####################
+#____________________________________________________________________
+#
+# 2. ==> BOUCLE SUR LES PAS DE TEMPS
+# Dans cette boucle, a chaque pas de temps nous produisons :
+# 1. un maillage en fonction de la hauteur d'eau ;
+# 2. un chargement correspondant a la hauteur d'eau et a la modelisation ;
+# 3. un calcul elastique lineaire avec MECA_STATIQUE ;
+# 4. un fichier resultat qui est stocke dans un repertoire .repe ;
+# 5. dans le cas ou un calcul en fatigue est demande nous projetons
+# le champ de contrainte calcule aux noeuds sur un maillage de reference.
+#
+
+ for j in range(Nb_pas_temps+1) :
+
+ k = j + 1
+
+# 2.1 ==> Extraction des couples (profondeur,force lineique)
+# du fichier resu_STREAM_FM au pas de temps courant et
+# remplissage de la liste de travail.
+
+ (range_depart,range_arrive,liste) = extr_char_houle(k,dict_temps,Nb_valeur,lignes)
+
+# 2.2 ==> Extraction de la hauteur d'eau
+
+ H_IMMERGEE = liste[[(range_arrive-range_depart-2),0]]
+ if INFO == 2 :
+ print "<I> <MACR_CALC_EOLIENNE> ==> Numero d'ordre = ", j
+ print "<I> <MACR_CALC_EOLIENNE> ==> hauteur_eau = ", H_IMMERGEE
+
+#####################
+# VALEUR TEST
+#
+# hauteur_eau = 30.
+#####################
+ print "\n<CALC_EOLIENNE> liste = \n", liste
+ print" "
+
+# 2.3 ==> Calcul des coefficients de la regression de maniere a
+# construire un chargement continu.
+
+ (teta0,teta1,teta2,teta3,alpha1,alpha2,alpha3,beta2,beta3) = eolien_regression (liste, INFO)
+
+ print " "
+ print "<I> <MACR_CALC_EOLIENNE> RESULTATS "
+ print " "
+ print "<I> <MACR_CALC_EOLIENNE> teta0 = ", teta0
+ print "<I> <MACR_CALC_EOLIENNE> teta1 = ", teta1
+ print "<I> <MACR_CALC_EOLIENNE> teta2 = ", teta2
+ print "<I> <MACR_CALC_EOLIENNE> teta3 = ", teta3
+ print " "
+
+# 2.4 ==> Creation du maillage pour la hauteur d'eau (H_IMMERGEE) courante
+
+ mail_eolienne(H_TOTALE, H_BASE, H_IMMERGEE, H_MOYEU, H_JONCTION, DECAL_PALES,
+ DEXT_NACELLE, EPAIS_NACELLE, DEXT_HAUT_BASE, DEXT_BAS_BASE,
+ EPAIS_HAUT_BASE, EPAIS_BAS_BASE, DEXT_HAUT_FUT, DEXT_BAS_FUT,
+ EPAIS_HAUT_FUT, EPAIS_BAS_FUT, NB_ELEM_BASE, NB_ELEM_FUT,
+ NBEL_EPAIS_BASE, NBEL_EPAIS_FUT, NBEL_DCIR_BASE, NBEL_DCIR_FUT,
+ ANGLE_VENT_AXE_X,
+ MODELISATION, TYPE_ELEM, NIVE_GIBI, fichier_datg)
+
+# 2.5 ==> Lancement de GIBI
+ EXEC_LOGICIEL(
+ LOGICIEL = logi_mail,
+ ARGUMENT = (fichier_datg, # fichier de donnees GIBI
+ fichier_mgib, # fichier resultats format GIBI
+ )
+ )
+
+# 2.6 ==> Lecture du maillage et definition des groupes
+
+ PRE_GIBI()
+
+ MA[j] = LIRE_MAILLAGE()
+
+ MA[j]=DEFI_GROUP( reuse = MA[j],
+ MAILLAGE = MA[j],
+ CREA_GROUP_NO = _F( TOUT_GROUP_MA='OUI',),);
+
+# debut test
+# IMPR_CO(CO=MA[j],)
+# fin test
+
+# 2.7 ==> Modelisation POUTRE
+
+ if MODELISATION == 'POUTRE' :
+
+ __MO[j]=AFFE_MODELE(MAILLAGE=MA[j],
+ AFFE=_F(GROUP_MA='EOLIENNE',PHENOMENE='MECANIQUE',MODELISATION='POU_D_T',),);
+
+ motscle={}
+ motscle['POUTRE']=[]
+ for i in range(NB_ELEM_FUT) :
+ nom = 'FUT'+str(i+1)
+ incr = (DEXT_BAS_FUT - DEXT_HAUT_FUT)/(2.0*NB_ELEM_FUT)
+ r1 = (DEXT_BAS_FUT/2.0) - (i*incr)
+ r2 = r1 - incr
+ motscle['POUTRE'].append(_F(GROUP_MA=nom,SECTION='CERCLE',CARA=('R1','R2','EP1','EP2',),VALE=(r1,r2,EPAIS_BAS_FUT,EPAIS_HAUT_FUT,),VARI_SECT='HOMOTHETIQUE',), )
+
+ for i in range(NB_ELEM_BASE) :
+ nom = 'BASE'+str(i+1)
+ incr = (DEXT_BAS_BASE - DEXT_HAUT_BASE)/(2.0*NB_ELEM_BASE)
+ r1 = (DEXT_BAS_BASE/2.0) - (i*incr)
+ r2 = r1 - incr
+ motscle['POUTRE'].append(_F(GROUP_MA=nom,SECTION='CERCLE',CARA=('R1','R2','EP1','EP2',),VALE=(r1,r2,EPAIS_BAS_BASE,EPAIS_HAUT_BASE,),VARI_SECT='HOMOTHETIQUE',), )
+
+ CARA[j]=AFFE_CARA_ELEM( MODELE = __MO[j],
+ **motscle );
+
+# 2.8 ==> Modelisation COQUE
+
+ if MODELISATION == 'COQUE' :
+
+ MA2[j] = CREA_MAILLAGE( MAILLAGE=MA[j],
+ MODI_MAILLE=( _F( OPTION = 'QUAD8_9',
+ GROUP_MA = ('PARTEM','PARTIM',),),
+ _F( OPTION = 'TRIA6_7',
+ GROUP_MA = ('JONCTION',),),),
+ );
+
+ __MO[j] = AFFE_MODELE( MAILLAGE=MA2[j],
+ AFFE=( _F( GROUP_MA = ('PARTEM','PARTIM','JONCTION','CHAUTE'),
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = 'COQUE_3D',),
+ _F( GROUP_MA = 'NACELLE',
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = 'POU_D_E',),),
+ );
+
+
+ MA2[j] = MODI_MAILLAGE( reuse = MA2[j],
+ MAILLAGE = MA2[j],
+ ORIE_NORM_COQUE = _F(
+ GROUP_MA = ('PARTEM','PARTIM','JONCTION'),),);
+
+ CARA[j] = AFFE_CARA_ELEM( MODELE=__MO[j],
+ POUTRE=( _F(GROUP_MA = 'NACELLE',
+ SECTION = 'CERCLE',
+ CARA = ('R','EP',),
+ VALE = (dex_nacelle/2.,ep_nacelle,), ),
+ ),
+ COQUE=( _F( GROUP_MA = ('PARTEM','PARTIM','CHAUTE'),
+ EPAIS = ep_b_fut,
+ ANGL_REP = (0.0,90.0,), ),
+
+ _F( GROUP_MA = ('JONCTION'),
+ EPAIS = h_jonction, ),
+ ),
+ );
+
+# 2.9 ==> Modelisation 3D
+
+ if MODELISATION == '3D' :
+
+ __MO[j] = AFFE_MODELE( MAILLAGE=MA[j],
+ AFFE=(_F( GROUP_MA = ('BASE','FUT','JONCTION','CHAUTE','SI1','SE1'),
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = '3D',),
+ _F( GROUP_MA ='NACELLE',
+ PHENOMENE ='MECANIQUE',
+ MODELISATION ='POU_D_E',),),
+ );
+
+ MA[j] = MODI_MAILLAGE( reuse = MA[j],
+ MAILLAGE = MA[j],
+ ORIE_PEAU_3D = _F(
+ GROUP_MA = ('SE1','SI1','CHAUTE'),),
+ );
+
+ CARA[j] = AFFE_CARA_ELEM( MODELE =__MO[j],
+ POUTRE =(
+ _F( GROUP_MA = 'NACELLE',
+ SECTION = 'CERCLE',
+ CARA = ('R','EP',),
+ VALE = (DEXT_NACELLE/2.0,EPAIS_NACELLE,), ),
+ ),
+ );
+
+# 2.10 ==> Affectation du materiau
+
+ motscles={}
+ motscles['AFFE_MATERIAU']=[]
+ for mat in affemateriau :
+ if mat['TOUT'] == None :
+ # Creation de mots-cles pour les AFFE_CHAR_MECA
+ motscles['AFFE_MATERIAU'].append(_F( GROUP_MA = mat['GROUP_MA'],
+ MATER = mat['MATER'],
+ TEMP_REF = mat['TEMP_REF'],) )
+ else :
+ # Creation de mots-cles pour les AFFE_CHAR_MECA
+ motscles['AFFE_MATERIAU'].append(_F( TOUT = 'OUI',
+ MATER = mat['MATER'],
+ TEMP_REF = mat['TEMP_REF'],) )
+ if MODELISATION == 'COQUE' :
+ __affmat[j] = AFFE_MATERIAU( MAILLAGE = MA2[j],
+ MODELE = __MO[j],
+ AFFE = motscles['AFFE_MATERIAU'],
+ )
+ else :
+ __affmat[j] = AFFE_MATERIAU( MAILLAGE = MA[j],
+ MODELE = __MO[j],
+ AFFE = motscles['AFFE_MATERIAU'],
+ )
+
+# 2.11 ==> Chargement et conditions aux limites
+
+ RAUMER = 1027.42 # masse volumique de l'eau de mer (kg/m3)
+ l_elem_stream = 0.3 # longueur des elements de STREAM_FM (m)
+
+ if test == 'OUI':
+ # FC3 poutre
+ if MODELISATION == 'POUTRE' :
+ FC3 = FORMULE(NOM_PARA=('X','Y','Z'),VALE=' -(exp((Z+231.21)/20.187))/0.3')
+ else :
+ # FC3 coque et 3D
+ FC3 = FORMULE(NOM_PARA=('X','Y','Z'),VALE='''- (
+ (3.E-5-(1.E4*Z))+((-6.E-8*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))+2.E-5*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))
+ -0.0021*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))+0.0224*(atan(Y/(X+1.E-8)))+0.9328)*
+ (0.5*'''+str(RAUMER)+'''*1.6**2)))''')
+ else :
+ if MODELISATION == 'POUTRE' :
+ FC3 = FORMULE(NOM_PARA=('X','Y','Z'),VALE=''' -('''
+ +str(teta0)+'''+('''
+ +str(teta1)+''')*(Z-('''+str(alpha1)+'''))+('''
+ +str(teta2)+''')*((Z-('''+str(alpha2)+'''))*(Z-('''+str(alpha1)+'''))-('''+str(beta2)+'''))+('''
+ +str(teta3)+''')*( (Z-('''+str(alpha3)+'''))*((Z-('''+str(alpha2)+'''))*(Z-('''+str(alpha1)+'''))-('''
+ +str(beta2)+'''))-('''+str(beta3)+''')*(Z-('''+str(alpha1)+'''))))/'''+str(l_elem_stream))
+ else :
+ r_bas = (DEXT_HAUT_BASE + DEXT_BAS_FUT)/4.0 # rayon moyen de la base
+ deux_pi_r_bas = 2.0*math.pi*r_bas # rayon moyen de la base multiplie par 2*pi
+ int_dp_etoil = -4.83893 # valeur de l integrale de la fonction de repartition de pression
+
+ FC3 = FORMULE(NOM_PARA=('X','Y','Z'),VALE=''' -(
+ (('''+str(H_BASE)+'''-Z)*1.0E+4)+(
+ ((('''+str(teta0)+'''+'''
+ +str(teta1)+'''*(Z-'''+str(alpha1)+''')+'''
+ +str(teta2)+'''*((Z-'''+str(alpha2)+''')*(Z-'''+str(alpha1)+''')-'''+str(beta2)+''')+'''
+ +str(teta3)+'''*( (Z-'''+str(alpha3)+''')*((Z-'''+str(alpha2)+''')*(Z-'''+str(alpha1)+''')-'''
+ +str(beta2)+''')-'''+str(beta3)+'''*(Z-'''+str(alpha1)+''')))/'''+str(l_elem_stream)+''')-'''
+ +str(deux_pi_r_bas)+'''*(('''+str(H_BASE)+'''-Z)*1.0E+4))*
+ ((-6.E-8*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))+2.E-5*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))
+ -0.0021*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))+0.0224*(atan(Y/(X+1.E-8)))+0.9328))/('''+str(r_bas)+'''*'''+str(int_dp_etoil)+''')))''')
+
+ if CHARGEMENT['VENT'] == 'OUI' :
+ FV0 = CHARGEMENT['FORCE_VENT_FUT']
+ else :
+ FV0 = FORMULE(NOM_PARA=('X','Y','Z'),VALE='0.0*Z')
+
+ if MODELISATION == 'POUTRE' :
+ CH=AFFE_CHAR_MECA_F(MODELE=__MO[j],
+ FORCE_POUTRE=(_F(GROUP_MA='PARTIM',FX=FC3,),
+ _F(GROUP_MA='PARTEM',FX=FV0,),),)
+ if MODELISATION == 'COQUE' :
+ CH=AFFE_CHAR_MECA_F(MODELE=__MO[j],
+ FORCE_COQUE=(_F(GROUP_MA='SI1',PRES=FC3,),
+ _F(GROUP_MA='SE1',PRES=FV0,),),);
+
+ if MODELISATION == '3D' :
+ CH=AFFE_CHAR_MECA_F(MODELE=__MO[j],
+ PRES_REP=(_F(GROUP_MA='SI1',PRES=FC3,),
+ _F(GROUP_MA='SE1',PRES=FV0,),),);
+
+ # force due au poids du rotor decale de d1 (N)
+ F2 = CHARGEMENT['FORCE_POIDS_ROTOR']
+
+ # force due au poids de la nacelle (N)
+ F3 = CHARGEMENT['FORCE_POIDS_NACELLE']
+
+ # force totale en z sur le sommet
+ FCZ = F2+F3
+
+ # force du à l'effort du vent sur les pales
+ FRU = CHARGEMENT['FORCE_VENT_PALES']
+ # moment resistant
+ MRU = CHARGEMENT['MOMENT_RESISTANT']
+
+ # force et moment dus au vent sur le rotor suivant le repère global
+ ALPHAR = CHARGEMENT['ANGLE_VENT_AXE_X']*(math.pi)/180.0
+
+ F1X = FRU*math.cos(ALPHAR)
+ F1Y = FRU*math.sin(ALPHAR)
+ M1X = MRU*math.cos(ALPHAR)
+ M1Y = MRU*math.sin(ALPHAR)
+
+ MCY = M1Y-(MONOPODE['DECAL_PALES']*F2)+(MONOPODE['H_MOYEU']*FRU)
+
+ if MODELISATION == 'POUTRE' :
+ LIMIT=AFFE_CHAR_MECA( MODELE = __MO[j],
+ DDL_IMPO = _F( GROUP_NO='B_BASE',
+ DX=0.0,DY=0.0,DZ=0.0,
+ DRX=0.0,DRY=0.0,DRZ=0.0,),
+ FORCE_NODALE = _F( GROUP_NO='H_FUT',
+ FX=F1X,
+ FY=F1Y,
+ FZ=FCZ,
+ MX=M1X,
+ MY=MCY,
+ MZ=0.0,),)
+
+ if MODELISATION == 'COQUE' :
+ LIMIT=AFFE_CHAR_MECA(MODELE=__MO[j],
+ DDL_IMPO=_F(GROUP_NO='CBASI',
+ DX=0.0,DY=0.0,DZ=0.0,
+ DRX=0.0,DRY=0.0,DRZ=0.0,),
+
+ LIAISON_ELEM=_F(OPTION='COQ_POU',
+ CARA_ELEM = CARA[j],
+ AXE_POUTRE=(0.,0.,1.,),
+ GROUP_MA_1='CHAUTE',
+ GROUP_NO_2='H_FUT',),
+
+ FORCE_NODALE=(_F(GROUP_NO='CHP',
+ FX=F1X,FY=F1Y,FZ=F2,
+ MX=M1X,MY=M1Y,MZ=0.0,),
+
+ _F(GROUP_NO='CHP0',FZ=F3,),
+ ),)
+
+ if MODELISATION == '3D' :
+ LIMIT=AFFE_CHAR_MECA(MODELE=__MO[j],
+ DDL_IMPO=_F(GROUP_NO='CBASI',
+ DX=0.0,DY=0.0,DZ=0.0,),
+
+ LIAISON_ELEM=_F(OPTION='3D_POU',
+ CARA_ELEM = CARA[j],
+ AXE_POUTRE=(0.,0.,1.,),
+ GROUP_MA_1='CHAUTE',
+ GROUP_NO_2='H_FUT',),
+
+ FORCE_NODALE=(_F(GROUP_NO='CHP',
+ FX=F1X,FY=F1Y,FZ=F2,
+ MX=M1X,MY=M1Y,MZ=0.0,),
+
+ _F(GROUP_NO='CHP0',FZ=F3,),
+ ),)
+
+ POIDS=AFFE_CHAR_MECA( MODELE=__MO[j],
+ PESANTEUR=(9.81,0.0,0.0,-1.0,),)
+
+# 2.12 ==> Realisation du calcul
+
+ if MODELISATION == 'POUTRE' :
+
+ TEMPS=DEFI_LIST_REEL(DEBUT=0.0,
+ INTERVALLE=_F(JUSQU_A=1.0,
+ PAS=1.0,),)
+
+ RESU=STAT_NON_LINE(MODELE=__MO[j],
+ CHAM_MATER=__affmat[j],
+ CARA_ELEM=CARA[j],
+ EXCIT=(_F(CHARGE=POIDS,),
+ _F(CHARGE=CH,),
+ _F(CHARGE=LIMIT,),),
+ COMP_INCR=_F(RELATION='ELAS',
+ GROUP_MA='EOLIENNE',),
+ INCREMENT=_F(LIST_INST=TEMPS,
+ NUME_INST_FIN=1,),)
+
+ RESU=CALC_ELEM( reuse =RESU,
+ RESULTAT=RESU,
+ OPTION=('SIEF_ELNO_ELGA','SIGM_ELNO_SIEF','SIPO_ELNO_SIEF',),)
+
+ if MODELISATION == 'COQUE' :
+ RESU=MECA_STATIQUE( MODELE=__MO[j],
+ CHAM_MATER=__affmat[j],
+ CARA_ELEM=CARA[j],
+ EXCIT=(_F(CHARGE=POIDS,),
+ _F(CHARGE=CH,),
+ _F(CHARGE=LIMIT,),),
+ NIVE_COUCHE='MOY',
+ );
+ RESU=CALC_ELEM( reuse =RESU,
+ RESULTAT=RESU,
+ OPTION=('SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',),)
+
+ RESU = CALC_NO( reuse =RESU,
+ RESULTAT=RESU,
+ OPTION=('SIGM_NOEU_DEPL','EQUI_NOEU_SIGM',),);
+
+ if MODELISATION == '3D' :
+ RESU=MECA_STATIQUE( MODELE=__MO[j],
+ CHAM_MATER=__affmat[j],
+ CARA_ELEM=CARA[j],
+ EXCIT=(_F(CHARGE=POIDS,),
+ _F(CHARGE=CH,),
+ _F(CHARGE=LIMIT,),),
+ );
+ RESU=CALC_ELEM( reuse =RESU,
+ RESULTAT=RESU,
+ REPE_COQUE=_F(NIVE_COUCHE='MOY',),
+ OPTION=('SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',));
+
+ RESU = CALC_NO( reuse =RESU,
+ RESULTAT=RESU,
+ OPTION=('SIGM_NOEU_DEPL','EQUI_NOEU_SIGM',),);
+
+# 2.13 ==> Preparation du modele de reference si modelisation 3D calcul de la fatigue
+
+ delta = periode_houle/Nb_pas_temps
+ inst = -periode_houle/2.0 + j*delta
+ if (MODELISATION == '3D') and (FATIGUE != None) :
+
+ if (k == 1) :
+ CHAMREF = AFFE_MATERIAU( MAILLAGE = mail_ref,
+ MODELE = MOREF,
+ AFFE = motscles['AFFE_MATERIAU'],)
+
+ RESPRO = PROJ_CHAMP( METHODE = 'ELEM',
+ NOM_CHAM = 'SIGM_NOEU_DEPL',
+ RESULTAT = RESU,
+ MODELE_1 = __MO[j],
+ MODELE_2 = MOREF,
+ VIS_A_VIS=(
+ _F( GROUP_MA_2='MONOPODE',
+ GROUP_MA_1='MONOPODE' ),
+ ),
+ )
+
+ SIG_PRO = CREA_CHAMP( TYPE_CHAM = 'NOEU_SIEF_R',
+ OPERATION = 'EXTR',
+ RESULTAT = RESPRO ,
+ NOM_CHAM = 'SIGM_NOEU_DEPL',
+ NUME_ORDRE = 1,
+ )
+
+ if (k==1) :
+ RESREF = CREA_RESU(
+ OPERATION = 'AFFE',
+ TYPE_RESU = 'EVOL_ELAS',
+ NOM_CHAM = 'SIGM_NOEU_DEPL',
+ AFFE = _F( CHAM_GD = SIG_PRO,
+ INST = (inst), ),
+ )
+ else :
+ RESREF = CREA_RESU( reuse = RESREF,
+ OPERATION = 'AFFE',
+ TYPE_RESU = 'EVOL_ELAS',
+ NOM_CHAM = 'SIGM_NOEU_DEPL',
+ AFFE = _F( CHAM_GD = SIG_PRO,
+ INST = (inst), ),
+ )
+
+# 2.14 ==> Impression des resultats
+
+ if MODELISATION == 'POUTRE' :
+ fich1='poutre_t='+str(inst)+'.resu'
+ fich2='poutre_t='+str(inst)+'.cast'
+ fich3='poutre_t='+str(inst)+'.ensi'
+ fich4='poutre_t='+str(inst)+'.unv'
+ if MODELISATION == 'COQUE' :
+ fich1='coque_t='+str(inst)+'.resu'
+ fich2='coque_t='+str(inst)+'.cast'
+ fich3='coque_t='+str(inst)+'.ensi'
+ fich4='coque_t='+str(inst)+'.unv'
+ if MODELISATION == '3D' :
+ fich1='3D_t='+str(inst)+'.resu'
+ fich2='3D_t='+str(inst)+'.cast'
+ fich3='3D_t='+str(inst)+'.ensi'
+ fich4='3D_t='+str(inst)+'.unv'
+
+ fich1b = './REPE_OUT/'+fich1
+ fich2b = './REPE_OUT/'+fich2
+ fich3b = './REPE_OUT/'+fich3
+ fich4b = './REPE_OUT/'+fich4
+
+ if IMPRESSION != None :
+ motscles={}
+ motscles['IMPRESSION']=[]
+ # Creation de mots-cles pour les IMPR_RESU
+ for impr in IMPRESSION :
+ if impr['FORMAT']=='RESULTAT':
+ UNIT_1B=DEFI_FICHIER(FICHIER=fich1b)
+ unitr = UNIT_1B
+ if impr['FORMAT']=='CASTEM':
+ UNIT_2B=DEFI_FICHIER(FICHIER=fich2b)
+ unitr = UNIT_2B
+ if impr['FORMAT']=='ENSIGHT':
+ UNIT_3B=DEFI_FICHIER(FICHIER=fich3b)
+ unitr = UNIT_3B
+ if impr['FORMAT']=='IDEAS':
+ UNIT_4B=DEFI_FICHIER(FICHIER=fich4b)
+ unitr = UNIT_4B
+ if MODELISATION == '3D':
+ motscles['IMPRESSION'].append(_F(MAILLAGE=MA[j],RESULTAT=RESU,
+ NOM_CHAM=('DEPL','SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',),) )
+ if MODELISATION == 'COQUE':
+ motscles['IMPRESSION'].append(_F(MAILLAGE=MA2[j],RESULTAT=RESU,
+ NOM_CHAM=('DEPL','SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',),) )
+ if MODELISATION == 'POUTRE':
+ motscles['IMPRESSION'].append(_F(MAILLAGE=MA[j],RESULTAT=RESU,
+ NOM_CHAM=('DEPL','SIGM_ELNO_SIEF','SIPO_ELNO_SIEF',),) )
+
+ IMPR_RESU(FORMAT=impr['FORMAT'],UNITE=unitr,
+ RESU=motscles['IMPRESSION'],)
+
+ for impr in IMPRESSION :
+ if impr['FORMAT']=='RESULTAT':
+ DEFI_FICHIER(ACTION='LIBERER',FICHIER=fich1b)
+ DETRUIRE(CONCEPT=_F( NOM = UNIT_1B))
+ if impr['FORMAT']=='CASTEM':
+ DEFI_FICHIER(ACTION='LIBERER',FICHIER=fich2b)
+ DETRUIRE(CONCEPT=_F( NOM = UNIT_2B))
+ if impr['FORMAT']=='ENSIGHT':
+ DEFI_FICHIER(ACTION='LIBERER',FICHIER=fich3b)
+ DETRUIRE(CONCEPT=_F( NOM = UNIT_3B))
+ if impr['FORMAT']=='IDEAS':
+ DEFI_FICHIER(ACTION='LIBERER',FICHIER=fich4b)
+ DETRUIRE(CONCEPT=_F( NOM = UNIT_4B))
+
+ if (MODELISATION == '3D') and (FATIGUE != None) :
+ DETRUIRE(CONCEPT=_F( NOM = SIG_PRO))
+ DETRUIRE(CONCEPT=_F( NOM = RESPRO))
+ if MODELISATION == 'POUTRE' :
+ DETRUIRE(CONCEPT=_F( NOM = TEMPS))
+
+ DETRUIRE(CONCEPT=_F( NOM = FC3))
+ DETRUIRE(CONCEPT=_F( NOM = CH))
+ DETRUIRE(CONCEPT=_F( NOM = LIMIT))
+ DETRUIRE(CONCEPT=_F( NOM = POIDS))
+ DETRUIRE(CONCEPT=_F( NOM = RESU))
+#
+#____________________________________________________________________
+#
+# 3. Calcul de fatigue.
+# On calcule la fatigue si la modelisation est 3D et si le mot clef
+# fatigue est present.
+#____________________________________________________________________
+#
+# 3.1 ==> Calcul de la fatigue
+#
+ if (MODELISATION == '3D') and (FATIGUE != None) :
+
+ self.DeclareOut('CHFATI',self.sd)
+ CHFATI = CALC_FATIGUE (
+ TYPE_CALCUL = 'FATIGUE_MULTI',
+ TYPE_CHARGE = 'PERIODIQUE',
+ OPTION = 'DOMA_NOEUD',
+ RESULTAT = RESREF,
+ CHAM_MATER = CHAMREF,
+ GROUP_MA = ('BASE','FUT'),
+ MAILLAGE = mail_ref,
+ CRITERE=FATIGUE['CRITERE'],
+ METHODE='CERCLE_EXACT',
+ INFO = 2, )
+
+#____________________________________________________________________
+#
+# 3.2 ==> Impression des resultats de fatigue
+#
+ if IMPRESSION != None :
+ motscles={}
+ motscles['IMPRESSION']=[]
+
+ motscles['IMPRESSION'].append(_F(MAILLAGE=mail_ref,CHAM_GD=CHFATI,) )
+
+ IMPR_RESU( FORMAT=impr['FORMAT'],
+ MODELE = MOREF,
+ RESU=motscles['IMPRESSION'],)
+
+#____________________________________________________________________
+#
+# 4. C'est fini !
+#____________________________________________________________________
+#
+ if erreur :
+ if not messages_erreur.has_key(erreur) :
+ erreur = 100
+ self.cr.fatal(messages_erreur[erreur])
+
+ return
+#
+#____________________________________________________________________
+#____________________________________________________________________
+#
+# CATALOGUES DES MACRO-COMMANDES
+#____________________________________________________________________
+#____________________________________________________________________
+#
+# ________________________________________
+#
+#____________________________________________________________________
+#____________________________________________________________________
+#
+# CATALOGUE DE LA MACRO COMMANDE CALC_CHAR_HOULE
+#____________________________________________________________________
+#____________________________________________________________________
+#
+
+CALC_CHAR_HOULE=MACRO( nom="CALC_CHAR_HOULE",op=calc_char_houle_ops,
+ fr="Calcul le chargement du a la houle.",
+ ang=".",reentrant='n',
+ docu="Ux.xx.xx-a",
+
+ STREAM =FACT(statut='o',max=1,
+ PROFONDEUR =SIMP(statut='o',typ='R'),
+ H_HOULE =SIMP(statut='o',typ='R'),
+ PERI_HOULE =SIMP(statut='o',typ='R'),
+ COUR_EULERIEN =SIMP(statut='o',typ='R'),
+ COEF_TRAINEE =SIMP(statut='o',typ='R'),
+ COEF_INERTIE =SIMP(statut='o',typ='R'),
+ ORDR_FONC_COURAN =SIMP(statut='o',typ='I'),
+ NB_POINTS_VERT =SIMP(statut='o',typ='I'),
+ NB_INTER_PERI =SIMP(statut='o',typ='I'),
+ DEXT_HAUT_BASE =SIMP(statut='o',typ='R'),
+ ),
+
+ IMPRESSION =FACT(statut='f',
+ UNITE =SIMP(statut='o',typ='I'),
+ ),
+
+ INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+
+);
+
+#
+#____________________________________________________________________
+#____________________________________________________________________
+#
+# CATALOGUE DE LA MACRO COMMANDE MACR_CALC_EOLIENNE
+#____________________________________________________________________
+#____________________________________________________________________
+#
+
+def macr_calc_eolienne_prod(self,NOM_MAIL_REF,**args):
+ if NOM_MAIL_REF != None : self.type_sdprod(NOM_MAIL_REF,maillage_sdaster)
+ return cham_no_sdaster
+
+
+MACR_CALC_EOLIENNE=MACRO(nom="MACR_CALC_EOLIENNE",op=macr_calc_eolienne_ops,
+ sd_prod=macr_calc_eolienne_prod,
+ fr="Calcul d une eolienne en mer.",
+ ang=".",reentrant='n',
+ docu="U2.09.04-a",
+
+ EXEC_MAILLAGE =FACT(statut='o',
+ LOGICIEL =SIMP(statut='o',typ='TXM',defaut="GIBI2000",into=("GIBI98","GIBI2000") ),
+ UNITE_DATG =SIMP(statut='f',typ='I',defaut=70),
+ UNITE_MGIB =SIMP(statut='f',typ='I',defaut=19),
+ NIVE_GIBI =SIMP(statut='f',typ='I',defaut=10,into=(3,4,5,6,7,8,9,10,11)),
+ ),
+
+ MODELISATION =SIMP(statut='o',typ='TXM', into=("POUTRE","COQUE","3D") ),
+ NOM_MAIL_REF =SIMP(statut='f',typ=(CO,maillage_sdaster)),
+
+ TYPE_ELEM =SIMP(statut='f',typ='TXM',defaut="CUB8",into=("CUB8","CU20") ),
+
+ b_model_3D =BLOC(condition = "MODELISATION == '3D'",
+
+ MONOPODE =FACT(statut='o',max=1,
+
+ H_TOTALE =SIMP(statut='o',typ='R' ),
+ H_BASE =SIMP(statut='o',typ='R' ),
+ H_MOYEU =SIMP(statut='o',typ='R' ),
+ H_JONCTION =SIMP(statut='o',typ='R' ),
+ DECAL_PALES =SIMP(statut='o',typ='R' ),
+ DEXT_NACELLE =SIMP(statut='o',typ='R' ),
+ EPAIS_NACELLE =SIMP(statut='o',typ='R' ),
+ DEXT_HAUT_BASE =SIMP(statut='o',typ='R' ),
+ DEXT_BAS_BASE =SIMP(statut='f',typ='R' ),
+ EPAIS_HAUT_BASE =SIMP(statut='o',typ='R' ),
+ EPAIS_BAS_BASE =SIMP(statut='f',typ='R' ),
+ DEXT_HAUT_FUT =SIMP(statut='o',typ='R' ),
+ DEXT_BAS_FUT =SIMP(statut='f',typ='R' ),
+ EPAIS_HAUT_FUT =SIMP(statut='o',typ='R' ),
+ EPAIS_BAS_FUT =SIMP(statut='f',typ='R' ),
+ NB_ELEM_BASE =SIMP(statut='f',typ='I',defaut=30),
+ NB_ELEM_FUT =SIMP(statut='f',typ='I',defaut=70),
+ NBEL_EPAIS_BASE =SIMP(statut='f',typ='I',defaut=3),
+ NBEL_EPAIS_FUT =SIMP(statut='f',typ='I',defaut=3),
+ NBEL_DCIR_BASE =SIMP(statut='f',typ='I',defaut=15),
+ NBEL_DCIR_FUT =SIMP(statut='f',typ='I',defaut=15),
+ ),
+ ),
+
+ b_model_coque =BLOC(condition = "MODELISATION == 'COQUE' ",
+
+ MONOPODE =FACT(statut='o',max=1,
+
+ H_TOTALE =SIMP(statut='o',typ='R' ),
+ H_BASE =SIMP(statut='o',typ='R' ),
+ H_MOYEU =SIMP(statut='o',typ='R' ),
+ H_JONCTION =SIMP(statut='o',typ='R' ),
+ DECAL_PALES =SIMP(statut='o',typ='R' ),
+ DEXT_NACELLE =SIMP(statut='o',typ='R' ),
+ EPAIS_NACELLE =SIMP(statut='o',typ='R' ),
+ DEXT_HAUT_BASE =SIMP(statut='o',typ='R' ),
+ DEXT_BAS_BASE =SIMP(statut='f',typ='R' ),
+ EPAIS_HAUT_BASE =SIMP(statut='o',typ='R' ),
+ EPAIS_BAS_BASE =SIMP(statut='f',typ='R' ),
+ DEXT_HAUT_FUT =SIMP(statut='o',typ='R' ),
+ DEXT_BAS_FUT =SIMP(statut='f',typ='R' ),
+ EPAIS_HAUT_FUT =SIMP(statut='o',typ='R' ),
+ EPAIS_BAS_FUT =SIMP(statut='f',typ='R' ),
+ NB_ELEM_BASE =SIMP(statut='f',typ='I',defaut=30),
+ NB_ELEM_FUT =SIMP(statut='f',typ='I',defaut=70),
+ NBEL_DCIR_BASE =SIMP(statut='f',typ='I',defaut=15),
+ NBEL_DCIR_FUT =SIMP(statut='f',typ='I',defaut=15),
+ ),
+ ),
+
+ b_model_poutre =BLOC(condition = "MODELISATION == 'POUTRE' ",
+
+ MONOPODE =FACT(statut='o',max=1,
+
+ H_TOTALE =SIMP(statut='o',typ='R' ),
+ H_BASE =SIMP(statut='o',typ='R' ),
+ H_MOYEU =SIMP(statut='o',typ='R' ),
+ DECAL_PALES =SIMP(statut='o',typ='R' ),
+ DEXT_HAUT_BASE =SIMP(statut='o',typ='R' ),
+ DEXT_BAS_BASE =SIMP(statut='f',typ='R' ),
+ EPAIS_HAUT_BASE =SIMP(statut='o',typ='R' ),
+ EPAIS_BAS_BASE =SIMP(statut='f',typ='R' ),
+ DEXT_HAUT_FUT =SIMP(statut='o',typ='R' ),
+ DEXT_BAS_FUT =SIMP(statut='f',typ='R' ),
+ EPAIS_HAUT_FUT =SIMP(statut='o',typ='R' ),
+ EPAIS_BAS_FUT =SIMP(statut='f',typ='R' ),
+ NB_ELEM_BASE =SIMP(statut='f',typ='I',defaut=30),
+ NB_ELEM_FUT =SIMP(statut='f',typ='I',defaut=70),
+ ),
+ ),
+
+ AFFE_MATERIAU =FACT(statut='o',max=3,
+ regles=(UN_PARMI('TOUT','GROUP_MA'),),
+ TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ GROUP_MA =SIMP(statut='f',typ='TXM',into=("BASE","FUT") ),
+ MATER =SIMP(statut='o',typ=mater_sdaster ),
+ TEMP_REF =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+ ),
+
+ CHARGEMENT =FACT(statut='o',
+ FORCE_POIDS_ROTOR =SIMP(statut='o',typ='R' ),
+ FORCE_POIDS_NACELLE =SIMP(statut='o',typ='R' ),
+ FORCE_VENT_PALES =SIMP(statut='o',typ='R' ),
+ ANGLE_VENT_AXE_X =SIMP(statut='o',typ='R' ),
+ MOMENT_RESISTANT =SIMP(statut='o',typ='R' ),
+ FORCE_VENT_FUT =SIMP(statut='o',typ=(fonction_sdaster,formule) ),
+ VENT =SIMP(statut='o',typ='TXM',into=("OUI","NON") ),
+ HOULE =SIMP(statut='o',typ='TXM',into=("OUI","NON") ),
+ ),
+
+ FATIGUE =FACT(statut='f',
+ CRITERE =SIMP(statut='f',typ='TXM',defaut="DANG_VAN_MODI_AC",into=("MATAKE","DANG_VAN_MODI_AC") ),
+ ),
+
+ SOLVEUR =FACT(statut='d',
+ METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ),
+ b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+ ),
+ b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+ ),
+ b_ldlt_mult =BLOC(condition = "METHODE == 'LDLT' or METHODE == 'MULT_FRONT' ",
+ fr="Paramètres relatifs à la non inversibilité de la matrice à factorise",
+ NPREC =SIMP(statut='f',typ='I',defaut= 8 ),
+ STOP_SINGULIER =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+ ),
+ b_gcpc =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+ NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+ NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
+ ),
+ SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+ ),
+
+ IMPRESSION =FACT(statut='f',
+ FORMAT =SIMP(statut='f',typ='TXM',defaut="RESULTAT",
+ into=("RESULTAT","CASTEM","IDEAS","ENSIGHT")),
+
+ b_format_ideas =BLOC(condition="FORMAT=='IDEAS'",fr="version Ideas",
+ VERSION =SIMP(statut='f',typ='I',defaut=5,into=(4,5)),
+ ),
+
+ b_format_castem =BLOC(condition="FORMAT=='CASTEM'",fr="version Castem",
+ NIVE_GIBI =SIMP(statut='f',typ='I',defaut=10,into=(3,10)),
+ ),
+
+ TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+ INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+ ),
+
+ INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+
+);
--- /dev/null
+#@ MODIF macr_cabri_calc_cata Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2008 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.
+# ======================================================================
+
+from Intranet.macr_cabri_calc_ops import macr_cabri_calc_ops
+from Cata.cata import *
+
+def macr_cabri_calc_prod(self,MODELE_THER,MODELE_MECA,CHAM_MATER,
+ CHAR_THER,CHAR_MECA,RESU_THER,**args):
+ if MODELE_THER != None:
+ self.type_sdprod(MODELE_THER,modele_sdaster)
+ if MODELE_MECA != None:
+ self.type_sdprod(MODELE_MECA,modele_sdaster)
+ if RESU_THER != None:
+ self.type_sdprod(RESU_THER,evol_ther)
+ if CHAM_MATER != None:
+ self.type_sdprod(CHAM_MATER,cham_mater)
+ if CHAR_THER != None:
+ for m in CHAR_THER:
+ self.type_sdprod(m['CHARGE'],char_ther)
+ if CHAR_MECA != None:
+ for m in CHAR_MECA:
+ self.type_sdprod(m['CHARGE'],char_meca)
+ return evol_noli
+
+
+MACR_CABRI_CALC=MACRO(nom="MACR_CABRI_CALC",
+ op=macr_cabri_calc_ops,
+ sd_prod=macr_cabri_calc_prod,
+ fr="Calcul thermo-mécanique d'une jonction boulonnée de tuyauterie",
+ reentrant='n',
+ UIinfo={"groupes":("Outils métier",)},
+ MAILLAGE = SIMP(statut='o',typ=maillage_sdaster,),
+ AFFE_MATERIAU = FACT(statut='o',max='**',
+ regles=(UN_PARMI('TOUT','GROUP_MA',),),
+ TOUT = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ GROUP_MA = SIMP(statut='f',typ='TXM',into=(
+ "BRIDE",
+ "GOUJON",
+ "ROND",
+ "ECROU",
+ "JOINT",) ),
+ MATER = SIMP(statut='o',typ=mater_sdaster),
+ TEMP_REF = SIMP(statut='d',typ='R',defaut= 25. ),
+ ),
+ CHAM_MATER = SIMP(statut = 'f',typ=CO,),
+ MODELE_THER= SIMP(statut = 'f',typ=CO,),
+
+ DEFI_CHAR_THER = FACT(statut ='d',
+ TEMP_INIT = SIMP(statut='d',typ='R',defaut= 25.,),
+ COEF_H_FLUI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
+ TEMP_EXT_FLUI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
+ COEF_H_AIR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
+ TEMP_EXT_AIR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
+ LIST_INST = SIMP(statut='f',typ=listr8_sdaster),
+ ),
+
+ CHAR_THER = FACT(statut = 'f',max=4,
+ CHARGE = SIMP(statut='o',typ=CO),
+ TYPE = SIMP(statut='o',typ='TXM',
+ into=("BRIDE_FLUIDE","BRIDE_AIR","ECROU_GOUJON",
+ "BRIDE_JOINT"),)
+ ),
+
+ RESU_THER = SIMP(statut = 'f',typ=CO,),
+
+
+ MODELE_MECA= SIMP(statut = 'f',typ=CO,),
+
+ DEFI_CHAR_MECA = FACT(statut='o',
+ PRETENS = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
+ PRES_REP = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
+ EFFE_FOND = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
+ ),
+
+ CHAR_MECA = FACT(statut = 'f',max=11,
+ CHARGE = SIMP(statut='o',typ=CO),
+ TYPE = SIMP(statut='o',typ='TXM',
+ into=("BLOC_BAS_GOUJ","BLOC_BAS_JOINT",
+ "BLOC_LAT_ALES","BLOC_LAT_NALES",
+ "PLAN_TUBE",
+ "PRES_FLU","EFFET_FOND",
+ "CONT_JOINT",
+ "DEFO_THER",
+ "SERR_ECROU_1","SERR_ECROU_2",),)
+ ),
+
+ RELATION = SIMP(statut='f',typ='TXM',
+ into=('VMIS_ISOT_TRAC','ELAS','ELAS_VMIS_TRAC',),),
+
+ SOLVEUR = FACT(statut='d',
+ METHODE = SIMP(statut='d',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT",) ),
+ b_mult_front = BLOC(condition = "METHODE == 'MULT_FRONT' ",
+ fr="Paramètres de la méthode multi frontale",
+ RENUM = SIMP(statut='d',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+ NPREC = SIMP(statut='d',typ='I',defaut=8),
+ STOP_SINGULIER = SIMP(statut='d',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+ ),
+ ),
+ INCREMENT = FACT(statut='f',
+ regles=(EXCLUS('NUME_INST_INIT','INST_INIT'),
+ EXCLUS('NUME_INST_FIN','INST_FIN'),),
+ LIST_INST =SIMP(statut='f',typ=listr8_sdaster),
+ EVOLUTION =SIMP(statut='f',typ='TXM',defaut="CHRONOLOGIQUE",
+ into=("CHRONOLOGIQUE",) ),
+ NUME_INST_INIT =SIMP(statut='f',typ='I'),
+ INST_INIT =SIMP(statut='f',typ='R'),
+ NUME_INST_FIN =SIMP(statut='f',typ='I'),
+ INST_FIN =SIMP(statut='f',typ='R'),
+ PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
+ # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ SUBD_METHODE =SIMP( statut='f',typ='TXM',
+ into =("AUCUNE","UNIFORME","EXTRAPOLE"),
+ defaut="AUCUNE",
+ fr="Méthode de subdivision des pas de temps en cas de non-convergence"
+ ),
+ b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
+ fr="Coefficient multiplicateur de la 1ère subdivision"),
+ SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+ b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_OPTION =SIMP(statut='f',typ='TXM',
+ into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+ defaut="IGNORE_PREMIERES",
+ fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+ SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
+ fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+ SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
+ fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+ SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
+ fr="% itération autorisée en plus"),
+ ),
+ # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),),
+ NOM_CHAM =SIMP(statut='f',typ='TXM',),
+ NOM_CMP =SIMP(statut='f',typ='TXM',),
+ VALE =SIMP(statut='f',typ='R'),
+ ),
+ NEWTON =FACT(statut='d',
+ REAC_INCR =SIMP(statut='f',typ='I',defaut= 1 ),
+ PREDICTION =SIMP(statut='f',typ='TXM',into=("TANGENTE","ELASTIQUE","EXTRAPOL") ),
+ MATRICE =SIMP(statut='f',typ='TXM',defaut="TANGENTE",into=("TANGENTE","ELASTIQUE") ),
+ PAS_MINI_ELAS =SIMP(statut='f',typ='R',defaut=0.0E+0),
+ REAC_ITER =SIMP(statut='f',typ='I',defaut=0),
+ EVOL_NOLI =SIMP(statut='f',typ=evol_noli),
+ ),
+ RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
+ into=("IMPLICITE",)),
+ CONVERGENCE =FACT(statut='d',
+ regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),),
+ SIGM_REFE =SIMP(statut='f',typ='R'),
+ EPSI_REFE =SIMP(statut='f',typ='R'),
+ FLUX_THER_REFE =SIMP(statut='f',typ='R'),
+ RESI_REFE_RELA =SIMP(statut='f',typ='R'),
+ RESI_GLOB_MAXI =SIMP(statut='f',typ='R'),
+ RESI_GLOB_RELA =SIMP(statut='f',typ='R'),
+ ITER_GLOB_MAXI =SIMP(statut='f',typ='I',defaut=10),
+ ITER_GLOB_ELAS =SIMP(statut='f',typ='I',defaut=25),
+ ),
+ );
--- /dev/null
+#@ MODIF macr_cabri_calc_ops Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2008 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.
+# ======================================================================
+
+
+def macr_cabri_calc_ops(self,MAILLAGE,MODELE_MECA,MODELE_THER,CHAR_THER,
+ CHAR_MECA,RESU_THER,RESO_INTE,
+ AFFE_MATERIAU,DEFI_CHAR_THER,DEFI_CHAR_MECA,RELATION,SOLVEUR,CONVERGENCE,NEWTON,
+ INCREMENT,CHAM_MATER,**args):
+ """
+ Ecriture de la macro MACR_CABRI_CALC
+ """
+
+ #################################################################
+ ########## PREPARATION MACRO
+ #################################################################
+
+ from Accas import _F
+
+ ier =0
+
+ # On met certains mots-clefs dans des variables locales pour les proteger
+ affemateriau = AFFE_MATERIAU
+ mail = MAILLAGE
+ resointe = RESO_INTE
+
+ # On importe les definitions des commandes a utiliser dans la macro
+ # Le nom de la variable doit etre obligatoirement le nom de la commande
+ DEFI_GROUP = self.get_cmd('DEFI_GROUP')
+ AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU')
+ AFFE_MODELE = self.get_cmd('AFFE_MODELE')
+ MODI_MAILLAGE = self.get_cmd('MODI_MAILLAGE')
+ AFFE_CHAR_THER_F = self.get_cmd('AFFE_CHAR_THER_F')
+ AFFE_CHAR_THER = self.get_cmd('AFFE_CHAR_THER')
+ AFFE_CHAR_MECA_F = self.get_cmd('AFFE_CHAR_MECA_F')
+ AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA')
+ DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
+ DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
+ THER_LINEAIRE = self.get_cmd('THER_LINEAIRE')
+ STAT_NON_LINE = self.get_cmd('STAT_NON_LINE')
+
+ # La macro compte pour 1 dans la numerotation des commandes
+ self.set_icmd(1)
+
+ # Le concept sortant (de type evol_noli) est nomme 'resumeca' dans
+ # le contexte de la macro
+ self.DeclareOut('resumeca',self.sd)
+ self.DeclareOut('mail',MAILLAGE)
+
+ #################################################################
+ ########## PREPARATION DES MODELES
+ #################################################################
+
+ # Definition des groupes
+ mail=DEFI_GROUP(reuse =mail,MAILLAGE=mail,
+ CREA_GROUP_NO=(
+ _F(GROUP_MA='M_GOU',NOM='N_M_GOU',),
+ _F(GROUP_MA='M_JOI',NOM='N_M_JOI',),
+ _F(GROUP_MA='SCBJ',NOM='N_SCBJ',),
+ _F(GROUP_MA='SCJB',NOM='N_SCJB',),
+ _F(GROUP_MA='M_L_AA',NOM='N_M_L_AA',),
+ _F(GROUP_MA='SCEG',NOM='N_SCEG',),
+ _F(GROUP_MA='SCGE',NOM='N_SCGE',),),)
+
+ # Creation du modele thermique
+ if MODELE_THER != None:
+ self.DeclareOut('modther',MODELE_THER)
+
+ modther=AFFE_MODELE(MAILLAGE=mail,
+ AFFE=_F(GROUP_MA=('VTOT','M_GOU','M_TUB','M_JOI','SCBJ','SCJB',
+ 'M_L_AA','M_INT','M_L_SA','M_EXT','SCEG','SCGE',),
+ PHENOMENE='THERMIQUE',
+ MODELISATION='3D_DIAG',),
+ );
+
+ # Creation du modele mecanique
+ if MODELE_MECA != None:
+ self.DeclareOut('modmeca',MODELE_MECA)
+
+ modmeca = AFFE_MODELE(MAILLAGE=mail,
+ AFFE=_F(GROUP_MA=('VTOT','M_GOU','M_TUB','M_JOI','SCBJ','SCJB',
+ 'M_L_AA','M_L_SA','SCEG','SCGE','M_INT','M_EXT',),
+ PHENOMENE='MECANIQUE',
+ MODELISATION='3D',),
+ );
+
+ # Orientation des mailles
+ mail=MODI_MAILLAGE(reuse =mail,
+ MAILLAGE=mail,
+ ORIE_PEAU_3D=(_F(GROUP_MA=('M_INT','M_TUB',),),
+ _F(GROUP_MA=('M_L_AA','M_JOI','M_L_SA',),),),
+ );
+
+
+
+ # Affectation des materiaux (thermique)
+ motscles={}
+ motscles['AFFE']=[]
+ for mat in affemateriau:
+ if mat['TOUT'] == None:
+ # Creation de mots-cles pour les AFFE_CHAR_MECA
+ motscles['AFFE'].append(_F(GROUP_MA=mat['GROUP_MA'],
+ MATER = mat['MATER']))
+ else:
+ # Creation de mots-cles pour les AFFE_CHAR_MECA
+ motscles['AFFE'].append(_F(TOUT='OUI',
+ MATER = mat['MATER']))
+
+ __cham = AFFE_MATERIAU(MAILLAGE=mail,
+ MODELE=modther,
+ AFFE=motscles['AFFE'],
+ )
+
+ #################################################################
+ ########## CONDITIONS AUX LIMITES THERMIQUES
+ #################################################################
+ # Recuperation des parametres thermiques
+
+ if DEFI_CHAR_THER != None:
+ temp_ini = DEFI_CHAR_THER['TEMP_INIT']
+ if DEFI_CHAR_THER['COEF_H_FLUI']!=None:
+ coef_int = DEFI_CHAR_THER['COEF_H_FLUI']
+ else:
+ coef_int = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,0.016,
+ 7200.0,0.016,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ if DEFI_CHAR_THER['TEMP_EXT_FLUI']!=None:
+ temp_int = DEFI_CHAR_THER['TEMP_EXT_FLUI']
+ else:
+ temp_int = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,temp_ini,1.0,temp_ini,11.0,60.0,
+ 600.0,60.0,610.0,280.0,1800.0,280.0,7200.0,280.0,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ if DEFI_CHAR_THER['COEF_H_AIR']!=None:
+ coef_ext = DEFI_CHAR_THER['COEF_H_AIR']
+ else:
+ coef_ext = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,1e-05,7200.0,1e-05,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+
+ if DEFI_CHAR_THER['TEMP_EXT_AIR']!=None:
+ temp_ext = DEFI_CHAR_THER['TEMP_EXT_AIR']
+ else:
+ temp_ext = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,20.0,7200.0,20.0,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ if DEFI_CHAR_THER['LIST_INST']!=None:
+ transi1 = DEFI_CHAR_THER['LIST_INST']
+ else:
+ transi1 = DEFI_LIST_REEL(DEBUT=0.0,
+ INTERVALLE=(_F(JUSQU_A=1.0,
+ NOMBRE=1,),
+ _F(JUSQU_A=11.0,
+ NOMBRE=10,),
+ _F(JUSQU_A=600.0,
+ NOMBRE=10,),
+ _F(JUSQU_A=610.0,
+ NOMBRE=30,),
+ _F(JUSQU_A=1800.0,
+ NOMBRE=30,),
+ _F(JUSQU_A=7200.0,
+ NOMBRE=10,),),);
+ else:
+ temp_ini = DEFI_CHAR_THER['TEMP_INIT']
+ coef_int = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,0.016,
+ 7200.0,0.016,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ temp_int = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,temp_ini,1.0,temp_ini,11.0,60.0,
+ 600.0,60.0,610.0,280.0,1800.0,280.0,7200.0,280.0,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ coef_ext = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,1e-05,7200.0,1e-05,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ temp_ext = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,20.0,7200.0,20.0,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ transi1 = DEFI_LIST_REEL(DEBUT=0.0,
+ INTERVALLE=(_F(JUSQU_A=1.0,
+ NOMBRE=1,),
+ _F(JUSQU_A=11.0,
+ NOMBRE=10,),
+ _F(JUSQU_A=600.0,
+ NOMBRE=10,),
+ _F(JUSQU_A=610.0,
+ NOMBRE=30,),
+ _F(JUSQU_A=1800.0,
+ NOMBRE=30,),
+ _F(JUSQU_A=7200.0,
+ NOMBRE=10,),),);
+ # Que sauver ?
+ if CHAR_THER != None:
+ for m in CHAR_THER:
+ if m['TYPE']=="BRIDE_FLUIDE":
+ self.DeclareOut('cl_th1',m['CHARGE'])
+ if m['TYPE']=="BRIDE_AIR":
+ self.DeclareOut('cl_th2',m['CHARGE'])
+ if m['TYPE']=="ECROU_GOUJON":
+ self.DeclareOut('cl_th3',m['CHARGE'])
+ if m['TYPE']=="BRIDE_JOINT":
+ self.DeclareOut('cl_th4',m['CHARGE'])
+
+ # Echanges thermiques internes entre le fluide et la bride
+ cl_th1=AFFE_CHAR_THER_F(MODELE=modther,
+ ECHANGE=_F(GROUP_MA = 'M_INT',
+ COEF_H = coef_int,
+ TEMP_EXT = temp_int,),);
+
+ # Echanges thermiques externes entre bride et air ambiant
+ cl_th2=AFFE_CHAR_THER_F(MODELE=modther,
+ ECHANGE=_F(GROUP_MA='M_EXT',
+ COEF_H=coef_ext,
+ TEMP_EXT=temp_ext,),);
+
+ # Echanges thermiques entre ecrou et goujon
+ cl_th3=AFFE_CHAR_THER(MODELE=modther,
+ LIAISON_GROUP=_F(GROUP_NO_1='N_SCEG',
+ GROUP_NO_2='N_SCGE',
+ DDL_1='TEMP',
+ COEF_MULT_1=1.0,
+ DDL_2='TEMP',
+ COEF_MULT_2=-1.0,
+ COEF_IMPO=0.0,),);
+
+ # Echanges thermiques entre bride et joint
+ cl_th4=AFFE_CHAR_THER(MODELE=modther,
+ LIAISON_GROUP=_F(GROUP_NO_1='N_SCBJ',
+ GROUP_NO_2='N_SCJB',
+ DDL_1='TEMP',
+ COEF_MULT_1=1.0,
+ DDL_2='TEMP',
+ COEF_MULT_2=-1.0,
+ COEF_IMPO=0.0,),);
+
+
+
+ #################################################################
+ ########## CALCUL THERMIQUE
+ #################################################################
+ if RESU_THER != None:
+ self.DeclareOut('resuther',RESU_THER)
+
+ resuther=THER_LINEAIRE(MODELE=modther,
+ CHAM_MATER=__cham,
+ EXCIT=(_F(CHARGE=cl_th1,),
+ _F(CHARGE=cl_th2,),
+ _F(CHARGE=cl_th3,),
+ _F(CHARGE=cl_th4,),),
+ INCREMENT=_F(LIST_INST=transi1,),
+ ETAT_INIT=_F(VALE=temp_ini,),
+ TITRE='CABRI THERMIQUE &DATE &HEURE',);
+
+ # Affectation des materiaux (mécanique)
+ if CHAM_MATER != None:
+ self.DeclareOut('_chamt',CHAM_MATER)
+ motscles={}
+ motscles['AFFE']=[]
+ motscles['AFFE_VARC']=[]
+ for mat in affemateriau:
+ if mat['TOUT'] == None:
+ # Creation de mots-cles pour les AFFE_CHAR_MECA
+ motscles['AFFE'].append(_F(GROUP_MA=mat['GROUP_MA'],
+ MATER = mat['MATER'],) )
+ motscles['AFFE_VARC'].append(_F(NOM_VARC='TEMP',GROUP_MA=mat['GROUP_MA'],
+ EVOL=resuther,NOM_CHAM='TEMP',
+ VALE_REF = mat['TEMP_REF'],))
+ else:
+ # Creation de mots-cles pour les AFFE_CHAR_MECA
+ motscles['AFFE'].append(_F(TOUT='OUI',
+ MATER = mat['MATER']) )
+ motscles['AFFE_VARC'].append(_F(NOM_VARC='TEMP',TOUT='OUI',
+ EVOL=resuther,NOM_CHAM='TEMP',
+ VALE_REF = mat['TEMP_REF'],))
+
+ _chamt = AFFE_MATERIAU(MAILLAGE=mail,
+ MODELE=modther,
+ AFFE=motscles['AFFE'],
+ AFFE_VARC=motscles['AFFE_VARC'],
+ )
+
+ #################################################################
+ ########## CONDITIONS AUX LIMITES MECANIQUES
+ #################################################################
+ # Recuperation des parametres mecaniques
+ if DEFI_CHAR_MECA != None:
+ if DEFI_CHAR_MECA['PRETENS']!=None:
+ f_pret = DEFI_CHAR_MECA['PRETENS']
+ else:
+ f_pret=DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,0.0,1.0,-0.02,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ if DEFI_CHAR_MECA['PRES_REP']!=None:
+ pre_int = DEFI_CHAR_MECA['PRES_REP']
+ else:
+ pre_int = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,0.0,1.0,0.0,11.0,16.0,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ if DEFI_CHAR_MECA['EFFE_FOND']!=None:
+ eff_fond = DEFI_CHAR_MECA['EFFE_FOND']
+ else:
+ eff_fond=DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,-0.0,1.0,-0.0,11.0,-20.607059,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ else:
+ f_pret=DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,0.0,1.0,-0.02,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+
+ pre_int = DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,0.0,1.0,0.0,11.0,16.0,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+
+ eff_fond=DEFI_FONCTION(NOM_PARA='INST',
+ VALE=(0.0,-0.0,1.0,-0.0,11.0,-20.607059,),
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',);
+ # Que sauver ?
+ if CHAR_MECA != None:
+ for m in CHAR_MECA:
+ if m['TYPE']=="BLOC_BAS_GOUJ":
+ self.DeclareOut('cl_me1',m['CHARGE'])
+ if m['TYPE']=="BLOC_BAS_JOINT":
+ self.DeclareOut('cl_me2',m['CHARGE'])
+ if m['TYPE']=="BLOC_LAT_ALES":
+ self.DeclareOut('cl_me3',m['CHARGE'])
+ if m['TYPE']=="BLOC_LAT_NALES":
+ self.DeclareOut('cl_me4',m['CHARGE'])
+ if m['TYPE']=="PLAN_TUBE":
+ self.DeclareOut('cl_me5',m['CHARGE'])
+ if m['TYPE']=="PRES_FLU":
+ self.DeclareOut('cl_me6',m['CHARGE'])
+ if m['TYPE']=="EFFET_FOND":
+ self.DeclareOut('cl_me7',m['CHARGE'])
+ if m['TYPE']=="CONT_JOINT":
+ self.DeclareOut('cl_me8',m['CHARGE'])
+ if m['TYPE']=="SERR_ECROU_1":
+ self.DeclareOut('cl_me10',m['CHARGE'])
+ if m['TYPE']=="SERR_ECROU_2":
+ self.DeclareOut('cl_me11',m['CHARGE'])
+
+
+ # Blocage bas du goujon
+ cl_me1=AFFE_CHAR_MECA(MODELE=modmeca,
+ DDL_IMPO=_F(GROUP_NO='N_M_GOU',
+ DZ=0.0,),
+ INFO=2,);
+ # Blocage bas du joint
+ cl_me2=AFFE_CHAR_MECA(MODELE=modmeca,
+ DDL_IMPO=_F(GROUP_NO='N_M_JOI',
+ DZ=0.0,),
+ INFO=2,);
+
+ # Blocage lateral, face laterale avec alesage
+ cl_me3=AFFE_CHAR_MECA(MODELE=modmeca,
+ DDL_IMPO=_F(GROUP_NO='N_M_L_AA',
+ DY=0.0,),
+ INFO=2,);
+
+ # Face laterale sans alesage
+ cl_me4=AFFE_CHAR_MECA(MODELE=modmeca,
+ FACE_IMPO=_F(GROUP_MA='M_L_SA',
+ DNOR=0.0,),
+ INFO=2,);
+
+ # Condition de planeite de la face de coupe du tube
+ cl_me5=AFFE_CHAR_MECA(MODELE=modmeca,
+ LIAISON_UNIF=_F(GROUP_MA='M_TUB',
+ DDL='DZ',),
+ INFO=2,);
+ # Pression due au fluide
+ cl_me6=AFFE_CHAR_MECA_F(MODELE=modmeca,
+ PRES_REP=_F(GROUP_MA='M_INT',
+ PRES=pre_int,),
+ INFO=2,);
+
+ # Effet de fond
+ cl_me7=AFFE_CHAR_MECA_F(MODELE=modmeca,
+ PRES_REP=_F(GROUP_MA='M_TUB',
+ PRES=eff_fond,),
+ INFO=2,);
+
+ # Contact zone de joint
+ cl_me8=AFFE_CHAR_MECA(MODELE=modmeca,
+ CONTACT=_F(GROUP_MA_MAIT='SCBJ',
+ GROUP_MA_ESCL='SCJB',),
+ INFO=2,);
+
+ # Serrage ecrou/goujon (pre-tensionnement)
+ cl_me10=AFFE_CHAR_MECA_F(MODELE=modmeca,
+ LIAISON_GROUP=_F(GROUP_NO_1='N_SCEG',
+ GROUP_NO_2='N_SCGE',
+ DDL_1='DZ',
+ COEF_MULT_1=1.0,
+ DDL_2='DZ',
+ COEF_MULT_2=-1.0,
+ COEF_IMPO=f_pret,),
+ INFO=2,);
+
+ cl_me11=AFFE_CHAR_MECA(MODELE=modmeca,
+ LIAISON_GROUP=_F(GROUP_NO_1='N_SCEG',
+ GROUP_NO_2='N_SCGE',
+ DDL_1='DX',
+ COEF_MULT_1=1.0,
+ DDL_2='DX',
+ COEF_MULT_2=-1.0,
+ COEF_IMPO=0.0,),
+ INFO=2,);
+
+
+ #################################################################
+ ########## CALCUL MECANIQUE
+ #################################################################
+ # Options de convergence
+ solveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
+
+ # Elimination des valeurs "None"
+ for i in solveur.keys():
+ if solveur[i]==None : del solveur[i]
+
+
+ transi2 = DEFI_LIST_REEL(DEBUT=0.0,
+ INTERVALLE=(_F(JUSQU_A=1.0,
+ NOMBRE=2,),
+ _F(JUSQU_A=11.0,
+ NOMBRE=20,),
+ _F(JUSQU_A=600.0,
+ NOMBRE=20,),
+ _F(JUSQU_A=610.0,
+ NOMBRE=20,),
+ _F(JUSQU_A=1800.0,
+ NOMBRE=20,),
+ _F(JUSQU_A=7200.0,
+ NOMBRE=20,),),);
+
+ # Options d'incrementation
+ if INCREMENT != None:
+ if INCREMENT['LIST_INST'] != None:
+ listinst = INCREMENT['LIST_INST']
+ else:
+ listinst = transi2
+
+ increment=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
+
+ # Elimination des valeurs "None"
+ for i in increment.keys():
+ if increment[i]==None : del increment[i]
+
+ increment['LIST_INST'] = listinst
+
+ else:
+ listinst = transi2
+ increment =_F(
+ LIST_INST = listinst,
+ ),
+
+ # Options de Newton
+ newton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
+ # Elimination des valeurs "None"
+ for i in newton.keys():
+ if newton[i]==None : del newton[i]
+
+ # Options de convergence
+ convergence=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+ # Elimination des valeurs "None"
+ for i in convergence.keys():
+ if convergence[i]==None : del convergence[i]
+
+ # Options de comportement
+ # Type incremental (=1) ou elastique (=0)
+ comp_incr = 0
+ if RELATION:
+ relation=RELATION
+ if relation == 'VMIS_ISOT_TRAC':
+ comp_incr = 1
+ else:
+ comp_incr = 0
+ else:
+ relation = 'ELAS'
+ comp_incr = 0
+
+
+ # Parametres du calcul
+ if comp_incr == 1:
+ resumeca=STAT_NON_LINE(MODELE=modmeca,
+ CHAM_MATER=_chamt,
+ EXCIT=(_F(CHARGE=cl_me1,),
+ _F(CHARGE=cl_me2,),
+ _F(CHARGE=cl_me3,),
+ _F(CHARGE=cl_me4,),
+ _F(CHARGE=cl_me5,),
+ _F(CHARGE=cl_me6,),
+ _F(CHARGE=cl_me7,),
+ _F(CHARGE=cl_me8,),
+ _F(CHARGE=cl_me10,),
+ _F(CHARGE=cl_me11,),
+ ),
+ SOLVEUR = solveur,
+ COMP_INCR =_F(RELATION=relation,RESO_INTE=resointe),
+ NEWTON = newton,
+ INCREMENT = increment,
+ CONVERGENCE = convergence,
+ TITRE='CABRI THERMOM\xe9CANIQUE &DATE &HEURE',);
+ else:
+ resumeca=STAT_NON_LINE(MODELE=modmeca,
+ CHAM_MATER=_chamt,
+ EXCIT=(_F(CHARGE=cl_me1,),
+ _F(CHARGE=cl_me2,),
+ _F(CHARGE=cl_me3,),
+ _F(CHARGE=cl_me4,),
+ _F(CHARGE=cl_me5,),
+ _F(CHARGE=cl_me6,),
+ _F(CHARGE=cl_me7,),
+ _F(CHARGE=cl_me8,),
+ _F(CHARGE=cl_me10,),
+ _F(CHARGE=cl_me11,),
+ ),
+ SOLVEUR = solveur,
+ COMP_ELAS =_F(RELATION=relation,RESO_INTE=resointe),
+ NEWTON = newton,
+ INCREMENT = increment,
+ CONVERGENCE = convergence,
+ TITRE='CABRI THERMOM\xe9CANIQUE &DATE &HEURE',);
+
+ return ier
--- /dev/null
+#@ MODIF macr_cabri_mail_cata Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2008 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.
+# ======================================================================
+
+from Intranet.macr_cabri_mail_ops import macr_cabri_mail_ops
+from Cata.cata import *
+
+MACR_CABRI_MAIL=MACRO(nom="MACR_CABRI_MAIL",
+ op=macr_cabri_mail_ops,
+ sd_prod=maillage_sdaster,
+ fr="maillage d'une jonction boulonnée de tuyauterie",
+ reentrant='n',
+ UIinfo={"groupes":("Outils métier",)},
+ EXEC_MAILLAGE = FACT(statut='o',
+ LOGICIEL = SIMP(statut = 'o',typ='TXM',into=("GIBI2000",),),
+ UNITE_DATG = SIMP(statut = 'f',typ='I',defaut=70,),
+ UNITE_MGIB = SIMP(statut = 'f',typ='I',defaut=19,),
+ NIVE_GIBI = SIMP(statut = 'f',typ='I',defaut=10,
+ into = (3,4,5,6,7,8,9,10,11),
+ ),
+ ),
+ RAFF_MAILLAGE = FACT(statut = 'd',
+ NB_RADIAL = SIMP(statut = 'f',typ='I',defaut=2,),
+ NB_CIRCONF = SIMP(statut = 'f',typ='I',defaut=3,),
+ NB_VERTICAL = SIMP(statut = 'f',typ='I',defaut=6,),
+ NB_ALESAGE = SIMP(statut = 'f',typ='I',defaut=5,),
+ ),
+ VERI_MAIL = FACT(statut='d',
+ VERIF = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+ APLAT = SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
+ ),
+ GEOM_BRID = FACT(statut = 'o',
+ NORME = SIMP(statut = 'o',typ='TXM',into=("OUI","NON"),),
+ b_bride_iso = BLOC(condition = "NORME == 'OUI'",
+ TYPE = SIMP(statut='o',typ='TXM',
+ into=('A','AA','B','B1','C','D','D1','E','F',
+ 'FF','G','GG','H','H1','I','J','J1',
+ 'K','L','L1','M','N','O','P','S','T','W'),
+ ),
+ ),
+ b_bride_niso = BLOC(condition = "NORME == 'NON'",
+ TUBU_D_EXT = SIMP(statut='o',typ='R',),
+ TUBU_H = SIMP(statut='o',typ='R',),
+ BRID_D_EXT = SIMP(statut='o',typ='R',),
+ BRID_D_INT = SIMP(statut='o',typ='R',),
+ BRID_H = SIMP(statut='o',typ='R',),
+ BRID_D_CONGE = SIMP(statut='o',typ='R',),
+ BRID_R_CONGE = SIMP(statut='o',typ='R',),
+ BRID_D_EPAUL = SIMP(statut='o',typ='R',),
+ BRID_H_EPAUL = SIMP(statut='o',typ='R',),
+ BRID_D_ALESAG = SIMP(statut='o',typ='R',),
+ BRID_P_ALESAG = SIMP(statut='o',typ='R',),
+ BRID_H_ALESAG = SIMP(statut='o',typ='R',),
+ GOUJ_N_GOUJON = SIMP(statut='o',typ='I',),
+ GOUJ_D_GOUJON = SIMP(statut='o',typ='R',),
+ GOUJ_E_FILET = SIMP(statut='o',typ='R',),
+ GOUJ_D_RONDEL = SIMP(statut='o',typ='R',),
+ GOUJ_E_RONDEL = SIMP(statut='o',typ='R',),
+ GOUJ_D_ECROU = SIMP(statut='o',typ='R',),
+ GOUJ_E_ECROU = SIMP(statut='o',typ='R',),
+ ETAN_E_JOINT = SIMP(statut='o',typ='R',),
+ ),
+ ),
+ IMPRESSION = FACT(statut='d',
+ UNITE = SIMP(statut='f',typ='I'),
+ FORMAT = SIMP(statut='f',typ='TXM',defaut="ASTER",
+ into=("ASTER","CASTEM","IDEAS"),
+ ),
+ b_impr_castem = BLOC(condition = "FORMAT == 'CASTEM'",
+ NIVE_GIBI = SIMP(statut='f',typ='I',defaut=10,into=(3,10),),
+ ),
+ b_impr_ideas = BLOC(condition = "FORMAT == 'IDEAS'",
+ VERSION = SIMP(statut='f',typ='I',defaut=5,into=(4,5),),
+ ),
+ ),
+ );
--- /dev/null
+#@ MODIF macr_cabri_mail_dat Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2008 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.
+# ======================================================================
+
+# Données pour les brides standards
+
+
+
+# Pour ajouter une bride x:
+# Définir un dico_bride_x comme ci-dessous puis ajoutez-le à dico_bride_std
+
+# dictionnaire pour la description des variables
+dico_var_geo = {'nbgouj':'Nombre de goujons de la jonction boulonnée (GOUJ_N_GOUJON)',
+ 'dint':'Diamètre intérieur de la bride (BRID_D_INT)',
+ 'dex1':'Diamétre extérieur de la conduite (TUBU_D_EXT)',
+ 'dex2':'Position (diamètre) du congé de la bride (BRID_D_CONGE)',
+ 'dex3':'Diamètre de l''épaulement de la bride au niveau de l''interface d''étanchéité (BRID_D_EPAUL)',
+ 'dtrou':'Position des alésages de la bride permettant l''introduction des goujons (BRID_P_ALESAG)',
+ 'dext':'Diamètre extérieur de la bride (BRID_D_EXT)',
+ 'dt':'Diamètre des alésages de la bride permettant l''introduction des goujons (BRID_D_ALESAG)',
+ 'drd':'Diamètre de la rondelle (GOUJ_D_RONDEL)',
+ 'dg':'Diamètre des goujons de la jonction boulonnée (GOUJ_D_GOUJON)',
+ 'dec':'Diamètre de l''écrou (GOUJ_D_ECROU)',
+ 'rcong':'Rayon du congé de la bride (BRID_R_CONGE)',
+ 'he':'Epaisseur de la rondelle (GOUJ_E_RONDEL)',
+ 'e':'Epaisseur de l''écrou (GOUJ_E_ECROU)',
+ 'hc1':'Hauteur de la bride (BRID_H)',
+ 'hcg1':'Hauteur de conduite (TUBU_H)',
+ 'hb':'Hauteur de l''épaulement de la bride au niveau de l''interface d''étanchéité (BRID_H_EPAUL)',
+ 'htrou':'Hauteur des alésages de la bride permettant l''introduction des goujons (BRID_H_ALESAG)',
+ 'pf':'Profondeur (épaisseur) des filets des goujons (GOUJ_E_FILET)',
+ 'j':'Epaisseur du joint au niveau de l''interface d''étanchéité (ETAN_E_JOINT)'}
+
+dico_var_msh = {'nrad':'Nombre d''éléments radiaux (NBR_RAD)',
+ 'ncir':'Nombre d''éléments circonférentiels (NBR_CIR)',
+ 'nver':'Nombre d''éléments verticaux (NBR_VER)',
+ 'nsect':'Nombre d''éléments de l''alésage (NBR_ALE)',
+ 'temps':'Temps d''analyse'}
+
+# dictionnaires des brides standards
+dico_bride_A = {'nbgouj': 4,
+ 'dint': 15.76,
+ 'dex1': 21.3,
+ 'dex2': 38.,
+ 'dex3': 48.,
+ 'dtrou': 67.,
+ 'dext': 95.,
+ 'dt': 14.,
+ 'drd': 25.,
+ 'dg': 12.,
+ 'dec': 18.,
+ 'rcong': 3.,
+ 'he': 12.,
+ 'e': 2.5,
+ 'hc1': 46.5,
+ 'hcg1': 20,
+ 'hb': 1.5,
+ 'htrou': 20.,
+ 'pf': 1.5,
+ 'j': 2}
+
+dico_bride_AA = {'nbgouj': 32,
+ 'dint': 336.5,
+ 'dex1': 355.6,
+ 'dex2': 395.,
+ 'dex3': 415.,
+ 'dtrou': 460.,
+ 'dext': 515.,
+ 'dt': 22.,
+ 'drd': 36.,
+ 'dg': 20.,
+ 'dec': 30.,
+ 'rcong': 5.,
+ 'he': 20.,
+ 'e': 3.,
+ 'hc1': 115.,
+ 'hcg1': 115./2.,
+ 'hb': 3.,
+ 'htrou': 47.,
+ 'pf': 2.2,
+ 'j': 2}
+
+dico_bride_B = {'nbgouj': 4,
+ 'dint': 26.64,
+ 'dex1': 33.4,
+ 'dex2': 53.,
+ 'dex3': 63.,
+ 'dtrou': 88.,
+ 'dext': 123.,
+ 'dt': 16.,
+ 'drd': 27.,
+ 'dg': 14.,
+ 'dec': 21.,
+ 'rcong': 4.,
+ 'he': 14.,
+ 'e': 2.5,
+ 'hc1': 59.,
+ 'hcg1': 59./2.,
+ 'hb': 1.5,
+ 'htrou': 27.5,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_B1 = {'nbgouj': 4,
+ 'dint': 24.3,
+ 'dex1': 33.4,
+ 'dex2': 53.,
+ 'dex3': 63.,
+ 'dtrou': 88.,
+ 'dext': 123.,
+ 'dt': 16.,
+ 'drd': 27.,
+ 'dg': 14.,
+ 'dec': 21.,
+ 'rcong': 4.,
+ 'he': 14.,
+ 'e': 2.5,
+ 'hc1': 59.,
+ 'hcg1': 59./2.,
+ 'hb': 1.5,
+ 'htrou': 27.5,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_C = {'nbgouj': 8,
+ 'dint': 52.48,
+ 'dex1': 60.3,
+ 'dex2': 84.,
+ 'dex3': 100.,
+ 'dtrou': 127.,
+ 'dext': 165.,
+ 'dt': 18.,
+ 'drd': 30,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 4.,
+ 'he': 16.,
+ 'e': 3,
+ 'hc1': 70.,
+ 'hcg1': 70./2.,
+ 'hb': 1.5,
+ 'htrou': 21.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_D = {'nbgouj': 8,
+ 'dint': 42.9,
+ 'dex1': 60.3,
+ 'dex2': 84.,
+ 'dex3': 100.,
+ 'dtrou': 127.,
+ 'dext': 165.,
+ 'dt': 18.,
+ 'drd': 30,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 87.6,
+ 'hcg1': 87.6/2.,
+ 'hb': 1.5,
+ 'htrou': 38.5,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_D1 = {'nbgouj': 8,
+ 'dint': 49.22,
+ 'dex1': 60.3,
+ 'dex2': 84.,
+ 'dex3': 100.,
+ 'dtrou': 127.,
+ 'dext': 165.,
+ 'dt': 18.,
+ 'drd': 30,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 87.6,
+ 'hcg1': 87.6/2.,
+ 'hb': 1.5,
+ 'htrou': 38.5,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_E = {'nbgouj': 8,
+ 'dint': 83.1,
+ 'dex1': 88.9,
+ 'dex2': 117.5,
+ 'dex3': 135.,
+ 'dtrou': 165.,
+ 'dext': 209.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 80.,
+ 'hcg1': 80./2.,
+ 'hb': 2.,
+ 'htrou': 27.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_F = {'nbgouj': 8,
+ 'dint': 73.66,
+ 'dex1': 88.9,
+ 'dex2': 117.5,
+ 'dex3': 135.,
+ 'dtrou': 165.,
+ 'dext': 209.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 89.,
+ 'hcg1': 89./2.,
+ 'hb': 2.,
+ 'htrou': 36.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_FF = {'nbgouj': 32,
+ 'dint': 396.99,
+ 'dex1': 406.4,
+ 'dex2': 440.,
+ 'dex3': 455.,
+ 'dtrou': 485.,
+ 'dext': 535.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 99.,
+ 'hcg1': 99./2.,
+ 'hb': 3.,
+ 'htrou': 40.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_G = {'nbgouj': 12,
+ 'dint': 66.7,
+ 'dex1': 88.9,
+ 'dex2': 117.5,
+ 'dex3': 135.,
+ 'dtrou': 165.,
+ 'dext': 209.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 98.,
+ 'hcg1': 98./2.,
+ 'hb': 2.,
+ 'htrou': 45.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_GG = {'nbgouj': 36,
+ 'dint': 381.,
+ 'dex1': 406.4,
+ 'dex2': 445.,
+ 'dex3': 460.,
+ 'dtrou': 495.,
+ 'dext': 545.,
+ 'dt': 22.,
+ 'drd': 36,
+ 'dg': 20.,
+ 'dec': 30.,
+ 'rcong': 5.,
+ 'he': 20.,
+ 'e': 3.,
+ 'hc1': 129.,
+ 'hcg1': 129./2.,
+ 'hb': 3.,
+ 'htrou': 63.,
+ 'pf': 2.2,
+ 'j': 2}
+dico_bride_H = {'nbgouj': 12,
+ 'dint': 108.2,
+ 'dex1': 114.3,
+ 'dex2': 146.,
+ 'dex3': 157.,
+ 'dtrou': 190.,
+ 'dext': 225.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 89.,
+ 'hcg1': 89./2.,
+ 'hb': 2.,
+ 'htrou': 33.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_H1 = {'nbgouj': 12,
+ 'dint': 102.6,
+ 'dex1': 114.3,
+ 'dex2': 146.,
+ 'dex3': 157.,
+ 'dtrou': 190.,
+ 'dext': 225.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 89.,
+ 'hcg1': 89./2.,
+ 'hb': 2.,
+ 'htrou': 33.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_I = {'nbgouj': 18,
+ 'dint': 92.1,
+ 'dex1': 114.3,
+ 'dex2': 146.,
+ 'dex3': 160.,
+ 'dtrou': 200.,
+ 'dext': 255.,
+ 'dt': 20.,
+ 'drd': 32.,
+ 'dg': 18.,
+ 'dec': 27.,
+ 'rcong': 5.,
+ 'he': 18.,
+ 'e': 3.,
+ 'hc1': 99.,
+ 'hcg1': 99./2.,
+ 'hb': 2.,
+ 'htrou': 43.,
+ 'pf': 2.2,
+ 'j': 2}
+dico_bride_J = {'nbgouj': 18,
+ 'dint': 87.34,
+ 'dex1': 114.3,
+ 'dex2': 146.,
+ 'dex3': 160.,
+ 'dtrou': 200.,
+ 'dext': 255.,
+ 'dt': 20.,
+ 'drd': 32.,
+ 'dg': 18.,
+ 'dec': 27.,
+ 'rcong': 5.,
+ 'he': 18.,
+ 'e': 3.,
+ 'hc1': 111.,
+ 'hcg1': 111./2.,
+ 'hb': 2.,
+ 'htrou': 55.,
+ 'pf': 2.2,
+ 'j': 2}
+dico_bride_J1 = {'nbgouj': 18,
+ 'dint': 87.3,
+ 'dex1': 114.3,
+ 'dex2': 146.,
+ 'dex3': 160.,
+ 'dtrou': 200.,
+ 'dext': 255.,
+ 'dt': 22.,
+ 'drd': 36.,
+ 'dg': 20.,
+ 'dec': 30.,
+ 'rcong': 5.,
+ 'he': 20.,
+ 'e': 3.,
+ 'hc1': 111.,
+ 'hcg1': 111./2.,
+ 'hb': 2.,
+ 'htrou': 55.,
+ 'pf': 2.2,
+ 'j': 2}
+dico_bride_K = {'nbgouj': 8,
+ 'dint': 161.5,
+ 'dex1': 168.3,
+ 'dex2': 192.,
+ 'dex3': 210.,
+ 'dtrou': 235.,
+ 'dext': 280.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 84.,
+ 'hcg1': 84./2.,
+ 'hb': 2.,
+ 'htrou': 28.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_L = {'nbgouj': 16,
+ 'dint': 154.8,
+ 'dex1': 168.3,
+ 'dex2': 206.,
+ 'dex3': 220.,
+ 'dtrou': 255.,
+ 'dext': 317.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 96.,
+ 'hcg1': 96./2.,
+ 'hb': 2.,
+ 'htrou': 40.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_L1 = {'nbgouj': 16,
+ 'dint': 154.8,
+ 'dex1': 168.3,
+ 'dex2': 206.,
+ 'dex3': 220.,
+ 'dtrou': 255.,
+ 'dext': 317.,
+ 'dt': 20.,
+ 'drd': 32.,
+ 'dg': 18.,
+ 'dec': 27.,
+ 'rcong': 5.,
+ 'he': 18.,
+ 'e': 3.,
+ 'hc1': 96.,
+ 'hcg1': 96./2.,
+ 'hb': 2.,
+ 'htrou': 40.,
+ 'pf': 2.2,
+ 'j': 2}
+dico_bride_M = {'nbgouj': 16,
+ 'dint': 139.7,
+ 'dex1': 168.3,
+ 'dex2': 206.,
+ 'dex3': 220.,
+ 'dtrou': 250.,
+ 'dext': 290.,
+ 'dt': 24.,
+ 'drd': 40.,
+ 'dg': 22.,
+ 'dec': 32.,
+ 'rcong': 5.,
+ 'he': 22.,
+ 'e': 3.,
+ 'hc1': 135.,
+ 'hcg1': 135./2.,
+ 'hb': 3.,
+ 'htrou': 62.,
+ 'pf': 2.2,
+ 'j': 2}
+dico_bride_N = {'nbgouj': 12,
+ 'dint': 131.9,
+ 'dex1': 168.3,
+ 'dex2': 220.,
+ 'dex3': 240.,
+ 'dtrou': 290.,
+ 'dext': 365.,
+ 'dt': 30.,
+ 'drd': 48.,
+ 'dg': 27.,
+ 'dec': 41.,
+ 'rcong': 5.,
+ 'he': 27.,
+ 'e': 4.,
+ 'hc1': 148.,
+ 'hcg1': 148./2.,
+ 'hb': 3.,
+ 'htrou': 75.,
+ 'pf': 2.6,
+ 'j': 2}
+dico_bride_O = {'nbgouj': 12,
+ 'dint': 211.58,
+ 'dex1': 219.1,
+ 'dex2': 248.,
+ 'dex3': 260.,
+ 'dtrou': 292.,
+ 'dext': 335.,
+ 'dt': 20.,
+ 'drd': 32.,
+ 'dg': 18.,
+ 'dec': 27.,
+ 'rcong': 5.,
+ 'he': 18.,
+ 'e': 3.,
+ 'hc1': 87.,
+ 'hcg1': 87./2.,
+ 'hb': 3.,
+ 'htrou': 30.,
+ 'pf': 2.2,
+ 'j': 2}
+dico_bride_P = {'nbgouj': 16,
+ 'dint': 202.74,
+ 'dex1': 219.1,
+ 'dex2': 248.,
+ 'dex3': 260.,
+ 'dtrou': 292.,
+ 'dext': 335.,
+ 'dt': 20.,
+ 'drd': 32,
+ 'dg': 18.,
+ 'dec': 27.,
+ 'rcong': 5.,
+ 'he': 18.,
+ 'e': 3.,
+ 'hc1': 99.,
+ 'hcg1': 99./2.,
+ 'hb': 3.,
+ 'htrou': 42.,
+ 'pf': 2.2,
+ 'j': 2}
+dico_bride_S = {'nbgouj': 16,
+ 'dint': 264.62,
+ 'dex1': 273.,
+ 'dex2': 305.,
+ 'dex3': 315.,
+ 'dtrou': 350.,
+ 'dext': 390.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 89.,
+ 'hcg1': 89./2.,
+ 'hb': 3.,
+ 'htrou': 32.,
+ 'pf': 1.7,
+ 'j': 2}
+dico_bride_T = {'nbgouj': 16,
+ 'dint': 254.56,
+ 'dex1': 273.,
+ 'dex2': 320.,
+ 'dex3': 340.,
+ 'dtrou': 385.,
+ 'dext': 444.,
+ 'dt': 27.,
+ 'drd': 45.,
+ 'dg': 24.,
+ 'dec': 36.,
+ 'rcong': 5.,
+ 'he': 24.,
+ 'e': 4.,
+ 'hc1': 128.,
+ 'hcg1': 128./2.,
+ 'hb': 3.,
+ 'htrou': 55.,
+ 'pf': 2.6,
+ 'j': 2}
+dico_bride_W = {'nbgouj': 28,
+ 'dint': 314.76,
+ 'dex1': 323.9,
+ 'dex2': 360.,
+ 'dex3': 385.,
+ 'dtrou': 415.,
+ 'dext': 460.,
+ 'dt': 18.,
+ 'drd': 30.,
+ 'dg': 16.,
+ 'dec': 24.,
+ 'rcong': 5.,
+ 'he': 16.,
+ 'e': 3.,
+ 'hc1': 96.,
+ 'hcg1': 96./2.,
+ 'hb': 3.,
+ 'htrou': 37.,
+ 'pf': 1.7,
+ 'j': 2}
+
+
+# dictionnaire pour faire le lien entre l'option de bride et les valeurs normalisées
+dico_bride_std = {'AA':dico_bride_AA,
+ 'A':dico_bride_A,
+ 'B':dico_bride_B,
+ 'B1':dico_bride_B1,
+ 'C':dico_bride_C,
+ 'D':dico_bride_D,
+ 'D1':dico_bride_D1,
+ 'E':dico_bride_E,
+ 'F':dico_bride_F,
+ 'FF':dico_bride_FF,
+ 'G':dico_bride_G,
+ 'GG':dico_bride_GG,
+ 'H':dico_bride_H,
+ 'H1':dico_bride_H1,
+ 'I':dico_bride_I,
+ 'J':dico_bride_J,
+ 'J1':dico_bride_J1,
+ 'K':dico_bride_K,
+ 'L':dico_bride_L,
+ 'L1':dico_bride_L1,
+ 'M':dico_bride_M,
+ 'N':dico_bride_N,
+ 'O':dico_bride_O,
+ 'P':dico_bride_P,
+ 'S':dico_bride_S,
+ 'T':dico_bride_T,
+ 'W':dico_bride_W}
--- /dev/null
+#@ MODIF macr_cabri_mail_ops Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2008 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
+
+def macr_cabri_mail_ops(self,EXEC_MAILLAGE,RAFF_MAILLAGE,VERI_MAIL,GEOM_BRID,
+ IMPRESSION,**args):
+ """
+ Ecriture de la macro MACR_CABRI_MAIL
+ """
+ import types
+ from Accas import _F
+
+ ier=0
+
+ # On importe les definitions des commandes a utiliser dans la macro
+ # Le nom de la variable doit etre obligatoirement le nom de la commande
+ EXEC_LOGICIEL = self.get_cmd('EXEC_LOGICIEL')
+ LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
+ PRE_GIBI = self.get_cmd('PRE_GIBI')
+ IMPR_RESU = self.get_cmd('IMPR_RESU')
+
+ # La macro compte pour 1 dans la numerotation des commandes
+ self.set_icmd(1)
+
+ # Le concept sortant (de type mail) est nommé 'nomres' dans
+ # le contexte de la macro
+
+ self.DeclareOut('nomres',self.sd)
+
+ # Chemin de Gibi
+ import aster
+ loc_gibi=aster.repout()
+ gibi2000=loc_gibi+'gibi'
+
+ # Unité pour le fichier maillage produit (format GIBI)
+ unite_mgib = EXEC_MAILLAGE['UNITE_MGIB']
+ # Unité pour le fichier de commandes GIBI
+ unite_datg = EXEC_MAILLAGE['UNITE_DATG']
+ # Niveau gibi
+ niveau_gibi = EXEC_MAILLAGE['NIVE_GIBI']
+
+ # Verif mail
+ ver_apla = VERI_MAIL['APLAT']
+ ver_veri = VERI_MAIL['VERIF']
+
+ # Impression
+ if IMPRESSION['UNITE']!=None:
+ imp_unit = IMPRESSION['UNITE']
+ imp_unitF = 1
+ else:
+ imp_unitF = 0
+ if IMPRESSION['FORMAT']!=None:
+ imp_form = IMPRESSION['FORMAT']
+ imp_formF = 1
+ else:
+ imp_formF = 0
+# if IMPRESSION['FICHIER']!=None:
+# imp_fich = IMPRESSION['FICHIER']
+# imp_fichF = 1
+# else:
+# imp_fichF = 0
+
+ # Maillage
+ nrad = RAFF_MAILLAGE['NB_RADIAL']
+ ncir = RAFF_MAILLAGE['NB_CIRCONF']
+ nver = RAFF_MAILLAGE['NB_VERTICAL']
+ nsect = RAFF_MAILLAGE['NB_ALESAGE']
+ temps = 5.
+
+ maillage = {'nrad': nrad,
+ 'ncir': ncir,
+ 'nver': nver,
+ 'nsect': nsect,
+ 'temps' : temps,}
+
+ # Création du fichier datg
+
+ if GEOM_BRID['NORME'] == 'OUI':
+ # Bride standard
+ type_bride = GEOM_BRID['TYPE']
+ ### Ecriture du fichier GIBI principal (dgib) - Bride STANDARD
+ write_file_dgib_STD(unite_mgib,unite_datg,maillage,type_bride)
+ else:
+ # Bride quelconque
+ geo_bride_qqe = {'nbgouj': GEOM_BRID['GOUJ_N_GOUJON'],
+ 'dint': GEOM_BRID['BRID_D_INT'],
+ 'dex1': GEOM_BRID['TUBU_D_EXT'],
+ 'dex2': GEOM_BRID['BRID_D_CONGE'],
+ 'dex3': GEOM_BRID['BRID_D_EPAUL'],
+ 'dtrou': GEOM_BRID['BRID_P_ALESAG'],
+ 'dext': GEOM_BRID['BRID_D_EXT'],
+ 'dt': GEOM_BRID['BRID_D_ALESAG'],
+ 'drd': GEOM_BRID['GOUJ_D_RONDEL'],
+ 'dg': GEOM_BRID['GOUJ_D_GOUJON'],
+ 'dec': GEOM_BRID['GOUJ_D_ECROU'],
+ 'rcong': GEOM_BRID['BRID_R_CONGE'],
+ 'he': GEOM_BRID['GOUJ_E_ECROU'],
+ 'e': GEOM_BRID['GOUJ_E_RONDEL'],
+ 'hc1': GEOM_BRID['BRID_H'],
+ 'hcg1': GEOM_BRID['TUBU_H'],
+ 'hb': GEOM_BRID['BRID_H_EPAUL'],
+ 'htrou': GEOM_BRID['BRID_H_ALESAG'],
+ 'pf': GEOM_BRID['GOUJ_E_FILET'],
+ 'j': GEOM_BRID['ETAN_E_JOINT']}
+ ### Ecriture du fichier GIBI principal (dgib) - Bride QUELCONQUE
+ write_file_dgib_QQE(unite_mgib,unite_datg,maillage,geo_bride_qqe)
+
+ fichier_datg = 'fort.'+str(unite_datg)
+ fichier_mgib = 'fort.'+str(unite_mgib)
+
+ # Lancement de GIBI
+ EXEC_LOGICIEL(
+ LOGICIEL=gibi2000,
+ ARGUMENT=(fichier_datg, fichier_mgib),
+ )
+ # Lecture du maillage GIBI dans ASTER
+ PRE_GIBI(
+ UNITE_GIBI = unite_mgib,
+ )
+
+ nomres = LIRE_MAILLAGE(VERI_MAIL=_F(APLAT = ver_apla,
+ VERIF = ver_veri ),)
+
+# if (imp_fichF == 1):
+# print imp_fich
+ if (imp_formF == 1):
+ print imp_form
+ if (imp_unitF == 1):
+ print imp_unit
+ # Impression du fichier maillage
+ if (imp_formF == 1):
+ if (imp_form == 'CASTEM'):
+ imp_ngib = IMPRESSION['NIVE_GIBI']
+ IMPR_RESU( RESU = _F(MAILLAGE=nomres, ),
+ FORMAT = 'CASTEM', NIVE_GIBI = imp_ngib )
+ if (imp_form == 'IDEAS'):
+ imp_nver = IMPRESSION['VERSION']
+ IMPR_RESU(RESU = _F(MAILLAGE=nomres,),
+ FORMAT = 'IDEAS', VERSION = imp_nver )
+
+ return ier
+
+
+##############################################################################################
+# Liste des fonctions
+##############################################################################################
+
+#############
+## EXTERNES (appelables depuis l'extérieur)
+#############
+
+### Ecriture du fichier GIBI principal (dgib) - Bride STANDARD
+# null = write_file_dgib_STD(unite_mgib,unite_datg,msh_bride,geo_bride)
+
+### Ecriture du fichier GIBI principal (dgib) - Bride QUELCONQUE
+# null = write_file_dgib_QQE(unite_mgib,unite_datg,msh_bride,geo_bride)
+
+### Imprime tout le catalogue des brides standards disponibles dans un fichier texte
+# null = print_bride_std(nom_fichier)
+
+### Catalogue complet des brides standards disponibles
+# txt = bride_std()
+
+#############
+## INTERNES (réservées au travail interne)
+#############
+
+### Génération du nom du fichier pour le fichier maillage résultant (format GIBI)
+# NomFichier(txt) = name_file_mgib(unite_mgib):
+
+### Génération du nom du fichier pour le fichier générant le maillage (commandes GIBI)
+# NomFichier(txt) = name_file_datg(unite_datg):
+
+### Récupère un fichier texte DATG
+# Txt = text_datg(fichier_datg):
+
+### Génération du texte pour les variables
+# Txt = para_text(dico_var,var):
+
+
+
+#=============================================================================================
+# Importation des modules Python
+#=============================================================================================
+
+from Intranet.macr_cabri_mail_dat import dico_var_geo,dico_var_msh,dico_bride_std
+
+#=============================================================================================
+# Fonctions principales
+#=============================================================================================
+# Ecriture du fichier GIBI principal (dgib) - Bride STANDARD
+def write_file_dgib_STD(unite_mgib,unite_datg,msh_bride,geo_bride):
+
+ # Nom du fichier maillage produit par GIBI
+ nomFichierMGIB = name_file_mgib(unite_mgib)
+
+ # Nom du fichier de commandes pour GIBI
+ nomFichierDATG = name_file_datg(unite_datg)
+
+ # Ouverture du fichier d'entrée de commandes
+ fdgib=open(nomFichierDATG,'w')
+
+ # En-tete
+ text = "**************************************************************\n"
+ text = text + "* Fichier GIBI pour le maillage d'une bride \n"
+ text = text + "**************************************************************\n"
+ text = text + "\n"
+ text = text + "* Ce fichier a été généré automatiquement par la macro ASTER MACR_CABRI_MAIL \n"
+ text = text + "* Ne pas modifier\n"
+ text = text + "\n"
+ text = text + "**************************************************************\n"
+ text = text + "* Type bride: Bride standard \n"
+ text = text + "**************************************************************\n"
+ text = text + "titre '"+"Bride standard"+"';\n"
+ text = text + "** Type bride standard: "+geo_bride+"\n"
+
+ text = text + "\n"
+ text = text + "nomfich = CHAINE \n"
+ if len(nomFichierMGIB)>72:
+ raise Exception, 'Nom de fichier trop long (limité à 72 caractères ' \
+ 'pour GIBI) :\n',nomFichierMGIB
+ elif len(nomFichierMGIB)<=69:
+ text = text + "'"+nomFichierMGIB+"';\n"
+ else:
+ text = text + "'"+nomFichierMGIB[:69]+"'\n" \
+ + "'"+nomFichierMGIB[69:]+"';\n"
+ text = text + "opti dime 3 elem cub8 SAUV FORM nomfich;\n"
+ text = text + "dens 1;\n"
+ text = text + "\n"
+ fdgib.write(text)
+
+ # Procédures internes supplémentaires
+ text = "**************************************************************\n"
+ text = text + "* Procédures supplémentaires \n"
+ text = text + "**************************************************************\n"
+ text = text + text_datg_pro()
+ fdgib.write(text)
+
+ # Début de procédure de création du maillage
+ text = "**************************************************************\n"
+ text = text + "**************************************************************\n"
+ text = text + "********* Début de procédure de création du maillage *********\n"
+ text = text + "**************************************************************\n"
+ text = text + "**************************************************************\n"
+ text = text + "\n debproc constru;\n"
+ fdgib.write(text)
+
+ # Paramètres géométriques
+ car_bride = dico_bride_std[geo_bride]
+ text = "**************************************************************\n"
+ text = text + "* Paramètres géométriques \n"
+ text = text + "**************************************************************\n"
+ text = text + para_text(dico_var_geo,car_bride)
+ fdgib.write(text)
+
+ # Paramètres du maillage
+ text = "**************************************************************\n"
+ text = text + "* Paramètres physiques \n"
+ text = text + "**************************************************************\n"
+ text = text + para_text(dico_var_msh,msh_bride)
+ fdgib.write(text)
+
+ # Algorithme du maillage
+ text = "**************************************************************\n"
+ text = text + "* Algorithme de maillage \n"
+ text = text + "**************************************************************\n"
+ text = text + text_datg_std()
+ fdgib.write(text)
+
+ # Fermeture du fichier maillage
+ fdgib.close()
+
+
+# Ecriture du fichier GIBI principal (dgib) - Bride QUELCONQUE
+def write_file_dgib_QQE(unite_mgib,unite_datg,msh_bride,geo_bride):
+
+ # Nom du fichier maillage produit par GIBI
+ nomFichierMGIB = name_file_mgib(unite_mgib)
+
+ # Nom du fichier de commandes pour GIBI
+ nomFichierDATG = name_file_datg(unite_datg)
+
+ # Ouverture du fichier d'entree de commandes
+ fdgib=open(nomFichierDATG,'w')
+
+ # En-tete
+ text = "**************************************************************\n"
+ text = text + "* Fichier GIBI pour le maillage d'une bride \n"
+ text = text + "**************************************************************\n"
+ text = text + "\n"
+ text = text + "* Ce fichier a été généré automatiquement par la macro ASTER MACR_CABRI_MAIL \n"
+ text = text + "* Ne pas modifier\n"
+ text = text + "\n"
+ text = text + "**************************************************************\n"
+ text = text + "* Type bride: Bride quelconque\n"
+ text = text + "**************************************************************\n"
+ text = text + "titre '"+"Bride Quelconque"+"';\n"
+ text = text + "\n"
+ text = text + "nomfich = CHAINE \n"
+ if len(nomFichierMGIB)>72:
+ raise Exception, 'Nom de fichier trop long (limité à 72 caractères ' \
+ 'pour GIBI) :\n',nomFichierMGIB
+ elif len(nomFichierMGIB)<=69:
+ text = text + "'"+nomFichierMGIB+"';\n"
+ else:
+ text = text + "'"+nomFichierMGIB[:69]+"'\n" \
+ + "'"+nomFichierMGIB[69:]+"';\n"
+ text = text + "opti dime 3 elem cub8 SAUV FORM nomfich;\n"
+ text = text + "dens 1;\n"
+ text = text + "\n"
+ fdgib.write(text)
+
+ # Procédures internes supplémentaires
+ text = "**************************************************************\n"
+ text = text + "* Procédures supplémentaires \n"
+ text = text + "**************************************************************\n"
+ text = text + text_datg_pro()
+ fdgib.write(text)
+
+ # Début de procédure de création du maillage
+ text = "**************************************************************\n"
+ text = text + "**************************************************************\n"
+ text = text + "********* Début de procédure de création du maillage *********\n"
+ text = text + "**************************************************************\n"
+ text = text + "**************************************************************\n"
+ text = text + "\n debproc constru;\n"
+ fdgib.write(text)
+
+ # Paramètres géométriques
+ text = "**************************************************************\n"
+ text = text + "* Paramètres géométriques \n"
+ text = text + "**************************************************************\n"
+ text = text + para_text(dico_var_geo,geo_bride)
+ fdgib.write(text)
+
+ # Paramètres du maillage
+ text = "**************************************************************\n"
+ text = text + "* Paramètres physiques \n"
+ text = text + "**************************************************************\n"
+ text = text + para_text(dico_var_msh,msh_bride)
+ fdgib.write(text)
+
+ # Algorithme du maillage
+ text = "**************************************************************\n"
+ text = text + "* Algorithme de maillage \n"
+ text = text + "**************************************************************\n"
+ text = text + text_datg_qqe()
+ fdgib.write(text)
+
+ # Fermeture du fichier maillage
+ fdgib.close()
+
+# Génération du nom du fichier pour le fichier maillage résultant (format GIBI)
+def name_file_mgib(unite_mgib):
+ cur_dir = os.getcwd()
+ nomFichier = cur_dir+'/fort.'+str(unite_mgib)
+ return nomFichier
+
+
+# Génération du nom du fichier pour le fichier générant le maillage (commandes GIBI)
+def name_file_datg(unite_datg):
+ cur_dir = os.getcwd()
+ nomFichier = cur_dir+'/fort.'+str(unite_datg)
+ return nomFichier
+
+# Récupère un fichier texte DATG: texte GIBI pour procédures
+def text_datg_pro():
+ import aster
+ loc_datg = aster.repdex()
+ datg_bridePro = loc_datg+"macr_cabri_mail_proc.datg"
+ fproc=open(datg_bridePro,'r')
+ procText = fproc.read()
+ fproc.close()
+
+ return procText
+
+# Récupère un fichier texte DATG: texte GIBI pour bride quelconque
+def text_datg_qqe():
+ import aster
+ loc_datg = aster.repdex()
+ datg_brideQqe = loc_datg+"macr_cabri_mail_qqe.datg"
+ fproc=open(datg_brideQqe,'r')
+ procText = fproc.read()
+ fproc.close()
+
+ return procText
+
+# Récupère un fichier texte DATG: texte GIBI pour bride standard
+def text_datg_std():
+ import aster
+ loc_datg = aster.repdex()
+ datg_brideStd = loc_datg+"macr_cabri_mail_std.datg"
+ fproc=open(datg_brideStd,'r')
+ procText = fproc.read()
+ fproc.close()
+
+ return procText
+
+# Génération du texte pour les variables
+def para_text(dico_var,var):
+ text = '\n'
+ for nom_var in var.keys():
+ text = text+"* "+dico_var[nom_var]+"\n"
+ text = text+nom_var+" = "+`var[nom_var]`+";\n"
+ return text
+
+#=============================================================================================
+# Accès au catalogue des brides standards
+# (les brides standards sont décrites dans le fichier Data_Brides.py)
+#=============================================================================================
+
+
+
+# Imprime tout le catalogue des brides standards disponibles dans un fichier texte
+def print_bride_std(nom_fichier):
+ text = bride_std()
+ # Ouverture du fichier
+ finfo=open(nom_fichier,'w')
+ # Ecriture des infos
+ finfo.write(text)
+ # Fermeture du fichier
+ finfo.close()
+
+# Catalogue complet des brides standards disponibles
+def bride_std():
+ # Ligne d'info
+ text = "Liste des brides standards avec leurs dimensions\n"
+ # Première ligne
+ text = text+"\t"
+ for nom_variable in dico_var_geo.keys():
+ text = text + nom_variable+"\t\t"
+ text = text + "\n"
+ # Lignes suivantes
+ for nom_bride in dico_bride_std.keys():
+ bride = dico_bride_std[nom_bride]
+ text = text + nom_bride + '\t'
+ for nom_var in dico_var_geo.keys():
+ chaine = "%f" % (bride[nom_var])
+ text = text+chaine+"\t"
+ text = text + "\n"
+ return text
--- /dev/null
+#@ MODIF macro_bascule_schema_ops Intranet DATE 17/12/2007 AUTEUR GREFFET N.GREFFET
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2007 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.
+# ======================================================================
+
+def macro_bascule_schema_ops (self,MODE,MATE,CARA,
+ INCR_I,INCR_E,
+ SCH_TEMPS_I,SCH_TEMPS_E,SCH_TEMPS_EQ,
+ C_INCR_I,C_INCR_E,
+ EXC_T,NEWT,INIT,TP_BAS,SCH_INI,EQUILIBRAGE,**args):
+ ier=0
+ import copy
+ import aster
+ import string
+ import types
+ from Accas import _F
+ from Noyau.N_utils import AsType
+ from Utilitai.Utmess import UTMESS
+ # On importe les definitions des commandes a utiliser dans la macro
+ DYNA_NON_LINE =self.get_cmd('DYNA_NON_LINE')
+ CREA_CHAMP =self.get_cmd('CREA_CHAMP')
+ DEFI_LIST_REEL =self.get_cmd('DEFI_LIST_REEL')
+ # La macro compte pour 1 dans la numerotation des commandes
+ self.set_icmd(1)
+ # Le concept sortant (de type evol_noli) est nommé
+ # 'nomres' dans le contexte de la macro
+ self.DeclareOut('nomres',self.sd)
+ #
+ #
+ dexct=[]
+ for j in EXC_T :
+ dexct.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dexct[-1].keys():
+ if dexct[-1][i]==None : del dexct[-1][i]
+ #
+ dComp_incri=[]
+ for j in C_INCR_I :
+ dComp_incri.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dComp_incri[-1].keys():
+ if dComp_incri[-1][i]==None : del dComp_incri[-1][i]
+ #
+ dComp_incre=[]
+ for j in C_INCR_E :
+ dComp_incre.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dComp_incre[-1].keys():
+ if dComp_incre[-1][i]==None : del dComp_incre[-1][i]
+ #
+ dincri=[]
+ for j in INCR_I :
+ dincri.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dincri[-1].keys():
+ if dincri[-1][i]==None : del dincri[-1][i]
+ #
+ dincre=[]
+ for j in INCR_E :
+ dincre.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dincre[-1].keys():
+ if dincre[-1][i]==None : del dincre[-1][i]
+ #
+ dschi=[]
+ for j in SCH_TEMPS_I :
+ dschi.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dschi[-1].keys():
+ if dschi[-1][i]==None : del dschi[-1][i]
+ #
+ dsche=[]
+ for j in SCH_TEMPS_I :
+ dsche.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dsche[-1].keys():
+ if dsche[-1][i]==None : del dsche[-1][i]
+ #
+ dscheq=[]
+ for j in SCH_TEMPS_I :
+ dscheq.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dscheq[-1].keys():
+ if dscheq[-1][i]==None : del dscheq[-1][i]
+ #
+ dnew=[]
+ for j in NEWT :
+ dnew.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dnew[-1].keys():
+ if dnew[-1][i]==None : del dnew[-1][i]
+ #
+ dini=[]
+ for j in INIT :
+ dini.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dini[-1].keys():
+ if dini[-1][i]==None : del dini[-1][i]
+ #
+ dequi=[]
+ for j in EQUILIBRAGE :
+ dequi.append(j.cree_dict_valeurs(j.mc_liste))
+ for i in dequi[-1].keys():
+ if dequi[-1][i]==None : del dequi[-1][i]
+ #
+ __L0 = TP_BAS['VALE']
+ dincri1=copy.copy(dincri)
+ dincri1[-1]['INST_FIN']= __L0[0]
+ #
+ __dtimp=dequi[-1]['DT_IMP']
+ __dtexp=dequi[-1]['DT_EXP']
+ #
+ __dim=(-1)*len(dComp_incri)
+ __lis=range(0,__dim,-1)
+ __non_lin='NON'
+ for i in __lis :
+ if (dComp_incri[i]['RELATION']!='DIS_CHOC' and dComp_incri[i]['RELATION']!='ELAS'):
+ __non_lin='OUI'
+ break
+ #
+ #
+ if SCH_INI=='IMPLICITE':
+ dincri1=copy.copy(dincri)
+ dincri1[-1]['INST_FIN']= __L0[0]
+ nomres=DYNA_NON_LINE(MODELE =MODE,
+ CHAM_MATER =MATE,
+ CARA_ELEM =CARA,
+ EXCIT =dexct,
+ COMP_INCR =dComp_incri,
+ INCREMENT =dincri1,
+ SCHEMA_TEMPS=dschi,
+ NEWTON=dnew,
+ ETAT_INIT=dini, )
+ __prc = 'IMPLICITE'
+ #
+ if SCH_INI=='EXPLICITE':
+ dincre1=copy.copy(dincre)
+ dincre1[-1]['INST_FIN']= __L0[0]
+ nomres=DYNA_NON_LINE(MODELE =MODE,
+ CHAM_MATER =MATE,
+ MASS_DIAG='OUI',
+ CARA_ELEM =CARA,
+ EXCIT =dexct,
+ COMP_INCR =dComp_incre,
+ INCREMENT =dincre1,
+ SCHEMA_TEMPS=dsche,
+ NEWTON=dnew,
+ ETAT_INIT=dini, )
+
+ __prc = 'EXPLICITE'
+
+ #
+ __nb=len(__L0)
+ j = 1
+ while 1:
+ #
+ if __prc=='IMPLICITE' :
+ __Ue=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='DEPL', INST=__L0[j-1],)
+ #
+ __Ve=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='VITE', INST=__L0[j-1],)
+ #
+ __Ae=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='ACCE', INST=__L0[j-1],)
+ #
+ __Ce=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='ELGA_SIEF_R', NOM_CHAM='SIEF_ELGA', INST=__L0[j-1],)
+ #
+ __Vae=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='ELGA_VARI_R', NOM_CHAM='VARI_ELGA', INST=__L0[j-1],)
+ dincre1=copy.copy(dincre)
+ dincre1[-1]['INST_FIN'] = __L0[j]
+ dincre1[-1]['INST_INIT']= __L0[j-1]
+ nomres=DYNA_NON_LINE(reuse=nomres,
+ MODELE=MODE,
+ MASS_DIAG='OUI',
+ CHAM_MATER=MATE,
+ CARA_ELEM=CARA,
+ EXCIT=dexct,
+ ETAT_INIT=_F(DEPL=__Ue, VITE=__Ve, ACCE=__Ae,
+ SIGM=__Ce, VARI=__Vae,),
+ COMP_INCR=dComp_incre,
+ INCREMENT=dincre1,
+ SCHEMA_TEMPS=dsche,
+ NEWTON=dnew,)
+ #
+ __prc='EXPLICITE'
+ j = j + 1
+ bool = (j!=(__nb))
+ if (not bool): break
+ #
+ if __prc=='EXPLICITE' :
+ # calcul sur la zone de recouvrement
+ print('calcul d''une solution explicite stabilisée')
+ __U1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='DEPL', INST=__L0[j-1],)
+ #
+ __V1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='VITE', INST=__L0[j-1],)
+ #
+ __A1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='ACCE', INST=__L0[j-1],)
+ #
+ __C1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='ELGA_SIEF_R', NOM_CHAM='SIEF_ELGA', INST=__L0[j-1],)
+ #
+ __Va1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='ELGA_VARI_R', NOM_CHAM='VARI_ELGA', INST=__L0[j-1],)
+ #
+ __lrec=DEFI_LIST_REEL(DEBUT=__L0[j-1],
+ INTERVALLE=_F(JUSQU_A=(__L0[j-1])+(10*(__dtexp)),
+ PAS=__dtexp),)
+ __u_rec=DYNA_NON_LINE(MODELE=MODE,
+ CHAM_MATER=MATE,
+ MASS_DIAG='OUI',
+ CARA_ELEM=CARA,
+ EXCIT=dexct,
+ ETAT_INIT=_F(DEPL=__U1, VITE=__V1, ACCE=__A1,
+ SIGM=__C1, VARI=__Va1,),
+ COMP_INCR=dComp_incre,
+ INCREMENT=_F(LIST_INST=__lrec,
+ INST_INIT=__L0[j-1],
+ INST_FIN=(__L0[j-1])+(10*(__dtexp))),
+ SCHEMA_TEMPS=dscheq,
+ NEWTON=dnew,)
+ #
+ __Ui =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=__u_rec,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='DEPL', INST=(__L0[j-1])+(10*(__dtexp)),)
+ #
+ __Vi =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=__u_rec,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='VITE', INST=(__L0[j-1])+(10*(__dtexp)),)
+ #
+ __Ai =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=__u_rec,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='ACCE', INST=(__L0[j-1])+(10*(__dtexp)),)
+ #
+ # equilibrage du premier pas implicite
+ print('equilibrage du pas explicite stabilisée')
+ dincri1=copy.copy(dincri)
+ dincri1[-1]['INST_FIN'] = ((__L0[j-1])+(10*(__dtexp)))
+ dincri1[-1]['INST_INIT']= (__L0[j-1])
+ nomres=DYNA_NON_LINE(reuse=nomres,
+ MODELE=MODE,
+ CHAM_MATER=MATE,
+ CARA_ELEM=CARA,
+ EXCIT=dexct,
+ ETAT_INIT=_F(DEPL=__Ui, VITE=__Vi, ACCE=__Ai,
+ SIGM=__C1, VARI=__Va1,),
+ COMP_INCR=dComp_incri,
+ INCREMENT=dincri1,
+ SCHEMA_TEMPS=dschi,
+ NEWTON=dnew,)
+ #
+ __Ui =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='DEPL', INST=(__L0[j-1])+(10*(__dtexp)),)
+ #
+ __Vi =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='VITE', INST=(__L0[j-1])+(10*(__dtexp)),)
+ #
+ __Ai =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='ACCE', INST=(__L0[j-1])+(10*(__dtexp)),)
+ #
+ __Ci =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='ELGA_SIEF_R', NOM_CHAM='SIEF_ELGA', INST=(__L0[j-1])+(10*(__dtexp)),)
+ #
+ __Vai=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
+ TYPE_CHAM='ELGA_VARI_R', NOM_CHAM='VARI_ELGA', INST=(__L0[j-1])+(10*(__dtexp)),)
+ #
+ print('calcul implicite après équilibrage')
+ dincri1=copy.copy(dincri)
+ dincri1[-1]['INST_FIN'] = __L0[j]
+ dincri1[-1]['INST_INIT']= ((__L0[j-1])+(10*(__dtexp)))
+ nomres=DYNA_NON_LINE(reuse=nomres,
+ MODELE=MODE,
+ CHAM_MATER=MATE,
+ CARA_ELEM=CARA,
+ EXCIT=dexct,
+ ETAT_INIT=_F(DEPL=__Ui, VITE=__Vi, ACCE=__Ai,
+ SIGM=__Ci, VARI=__Vai,
+ ),
+ COMP_INCR=dComp_incri,
+ INCREMENT=dincri1,
+ SCHEMA_TEMPS=dschi,
+ NEWTON=dnew,)
+ #
+ __prc='IMPLICITE'
+ j = j + 1
+ bool = (j!=(__nb))
+ if (not bool): break
+ #
+ return ier
# faire que la division soit toujours réelle
from __future__ import division
-__version__ = "$Name: $"
-__Id__ = "$Id: cata.py,v 1.2.6.5.4.3 2008-10-10 13:31:49 pnoyret Exp $"
+__version__ = "$Name: BR_dev_V1_15 $"
+__Id__ = "$Id: cata.py,v 1.3 2008-11-13 10:19:13 cchris Exp $"
import Accas
from Accas import *
--- /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 sert pour charger les paramètres de configuration d'EFICAS
+"""
+# Modules Python
+import os, sys, string, types, re
+import traceback
+
+# Modules Eficas
+from Editeur import utils
+
+class CONFIGbase:
+
+ #-----------------------------------
+ def __init__(self,appli):
+ #-----------------------------------
+
+ # Classe de base permettant de lire, afficher
+ # et sauvegarder les fichiers utilisateurs editeur.ini
+ # et style.py
+ # Classe Mere de : class CONFIG(CONFIGbase)
+ # class CONFIGStyle(CONFIGbase):
+ self.appli = appli
+ self.salome = appli.salome
+ self.dRepMat={}
+ if self.appli:
+ self.parent=appli.top
+ else:
+ self.parent=None
+ self.rep_user = utils.get_rep_user()
+ self.lecture_fichier_ini_standard()
+ self.lecture_catalogues_standard()
+ self.lecture_fichier_ini_utilisateur()
+ self.init_liste_param()
+
+ #--------------------------------------
+ def lecture_fichier_ini_standard(self):
+ #--------------------------------------
+ # Verifie l'existence du fichier "standard"
+ # appelle la lecture de ce fichier
+ if not os.path.isfile(self.fic_ini):
+ if self.appli.ihm=="TK" :
+ from widgets import showerror
+ showerror("Erreur","Pas de fichier de configuration" + self.fic_ini+"\n")
+ print "Erreur à la lecture du fichier de configuration : %s" % self.fic_ini
+ sys.exit(0)
+ self.lecture_fichier(self.fic_ini)
+
+ #-----------------------------
+ def lecture_fichier(self,fic):
+ #------------------------------
+ # lit les paramètres du fichier eficas.ini ou style.py
+ # les transforme en attribut de l 'objet
+ # utilisation du dictionnaire local pour récuperer style
+ txt = utils.read_file(fic)
+ from styles import style
+ d=locals()
+ try:
+ exec txt in d
+ except:
+ l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
+ if self.appli.ihm=="TK" :
+ from widgets import showerror
+ showerror("Erreur","Une erreur s'est produite lors de la lecture du fichier : " + fic + "\n")
+ print "Erreur à la lecture du fichier de configuration : %s" % fic
+ sys.exit()
+
+ for k in d.keys() :
+ if k in self.labels.keys() :
+ setattr(self,k,d[k])
+ # Glut horrible pour les repertoires materiau...
+ elif k[0:9]=="rep_mat_v" :
+ setattr(self,k,d[k])
+
+ for k in d['style'].__dict__.keys() :
+ setattr(self,k,d['style'].__dict__[k])
+
+ if hasattr(self,"catalogues") :
+ for ligne in self.catalogues :
+ version=ligne[1]
+ codeSansPoint=re.sub("\.","",version)
+ chaine="rep_mat_"+codeSansPoint
+ if hasattr(self,chaine):
+ rep_mat=getattr(self,chaine)
+ self.dRepMat[version]=str(rep_mat)
+
+
+ #--------------------------------------
+ def lecture_fichier_ini_utilisateur(self):
+ #--------------------------------------
+ # Surcharge les paramètres standards par les paramètres utilisateur s'ils existent
+ self.fic_ini_utilisateur = os.path.join(self.rep_user,self.fichier)
+ if not os.path.isfile(self.fic_ini_utilisateur):
+ return
+ self.lecture_fichier(self.fic_ini_utilisateur)
+
+ #--------------------------------------
+ def lecture_catalogues_standard(self):
+ #--------------------------------------
+ # repertoires Materiau
+ if hasattr(self,"catalogues") :
+ for ligne in self.catalogues :
+ version=ligne[1]
+ cata=ligne[2]
+ self.dRepMat[version]=os.path.join(cata,'materiau')
+
+ #--------------------------------------
+ def affichage_fichier_ini(self):
+ #--------------------------------------
+ """
+ Affichage des valeurs des paramètres relus par Eficas
+ """
+ import widgets
+ result = widgets.Formulaire(self.parent,
+ obj_pere = self,
+ titre = self.titre,
+ texte = self.texte_ini,
+ items = self.l_param,
+ mode='display',
+ commande=('Modifier',self.commande))
+ if result.resultat :
+ #print 'on sauvegarde les nouveaux paramètres :',result.resultat
+ self.save_param_ini(result.resultat)
+
+ #--------------------------------------
+ def save_param_ini(self,dico):
+ #--------------------------------------
+ # sauvegarde
+ # les nouveaux paramètres dans le fichier de configuration utilisateur
+ #
+ f=open(self.fic_ini_utilisateur,'w+')
+ for k,v in dico.items():
+ if self.types[k] in ('mot2','mot3','mot4'):
+ v1=v[1:-1]
+ val=v1.split(",")
+ p = "("
+ listeval=""
+ for valeur in val:
+ listeval = listeval+ p + str(valeur)
+ p=" , "
+ listeval = listeval + ")"
+ f.write(str(self.pref)+str(k) + '=' + str(listeval) + '\n')
+ elif k == 'catalogues' :
+ f.write(k + '\t=\t' + str(v) + '\n')
+ else:
+ f.write(str(self.pref)+str(k) + '\t=\t"' + str(v) + '"\n')
+ f.close()
+ self.lecture_fichier_ini_utilisateur()
+
+ #-------------------------------------------
+ def creation_fichier_ini_si_possible(self):
+ #-------------------------------------------
+ return self.creation_fichier_ini(mode='ignorer_annuler')
+
+ #--------------------------------------------------------
+ def creation_fichier_ini(self,mode='considerer_annuler'):
+ #---------------------------------------------------------
+ # Récupération des valeurs des paramétres requis pour la création du fichier
+ # eficas.ini
+ #
+ import widgets
+ items = self.l_param
+ result = widgets.Formulaire(self.parent,
+ obj_pere = self,
+ titre = "Saisie des données indispensables à la configuration d'EFICAS",
+ texte = self.texte,
+ items = items,
+ mode='query')
+ if not result.resultat :
+ if mode == 'considerer_annuler':
+ test=0
+ if self.appli.ihm=="TK" :
+ from widgets import showerror,askretrycancel
+ test = askretrycancel("Erreur","Données incorrectes !")
+ if not test:
+ # XXX On sort d'EFICAS, je suppose
+ self.appli.exitEFICAS()
+ else:
+ self.creation_fichier_ini()
+ else:
+ return None
+ else :
+ self.save_param_ini(result.resultat)
+ return result.resultat
+
+ #--------------------------
+ def init_liste_param (self):
+ #--------------------------
+ # construit self.l_param
+ # a partir de self.labels et des attributs
+ # de l objet (mis a jour lors de la lecture du fichier)
+ # l_param est une liste de tuples où chaque tuple est de la forme :
+ # (label,nature,nom_var,defaut)
+
+ self.l_param=[]
+ for k in self.labels.keys() :
+ if hasattr(self,k) :
+ if k in self.YesNo.keys():
+ self.l_param.append((self.labels[k],self.types[k],k,self.__dict__[k],
+ self.YesNo[k][0],self.YesNo[k][1]))
+ else :
+ self.l_param.append((self.labels[k],self.types[k],k,self.__dict__[k]))
+ self.l_param = tuple(self.l_param)
+
+
+class CONFIG(CONFIGbase):
+ def __init__(self,appli,rep_ini):
+
+ self.dFichierEditeur={"ASTER" : "editeur.ini",
+ "ASTER_SALOME" : "editeur_salome.ini"}
+ self.texte = "EFICAS a besoin de certains renseignements pour se configurer\n"+\
+ "Veuillez remplir TOUS les champs ci-dessous et appuyer sur 'Valider'\n"+\
+ "Si vous annulez, EFICAS ne se lancera pas !!"
+
+ self.salome=appli.salome
+ self.code=appli.code
+ clef=self.code
+ if self.salome != 0 :
+ clef = clef + "_SALOME"
+ self.fichier=self.dFichierEditeur[clef]
+ self.rep_ini = rep_ini
+ self.fic_ini = os.path.join(self.rep_ini,self.fichier)
+ self.titre = "Paramètres nécessaires à la configuration d'EFICAS"
+ self.texte_ini = "Voici les paramètres que requiert Eficas"
+ self.commande = self.creation_fichier_ini_si_possible
+ self.labels={"savedir" : "Répertoire initial pour Open/Save des fichiers",
+ "rep_travail" : "Répertoire de travail",
+ "rep_mat" : "Répertoire materiaux",
+ "path_doc" : "Chemin d'accès à la doc Aster",
+ "exec_acrobat" : "Ligne de commande Acrobat Reader",
+ "catalogues" : "Versions du code ",
+ "isdeveloppeur" : "Niveau de message ",
+ "path_cata_dev" : "Chemin d'accès aux catalogues développeurs"}
+
+ if self.code == "OPENTURNS" :
+ self.labels["DTDDirectory"]="Chemin d'accès au wraper"
+
+ self.types ={"savedir":"rep", "rep_travail":"rep","rep_mat":"rep",
+ "path_doc": "rep","exec_acrobat":"file","exec_acrobat":"file",
+ "catalogues" :"cata","isdeveloppeur":"YesNo","path_cata_dev":"rep",
+ "DTDDirectory":"rep"}
+
+ self.YesNo={}
+ self.YesNo['isdeveloppeur']=('Deboggage','Utilisation')
+
+ # Valeurs par defaut
+ self.rep_user = utils.get_rep_user()
+ self.initialdir=self.rep_user
+ self.savedir = self.initialdir
+ self.rep_travail=os.path.join(self.rep_user,'uaster','tmp_eficas')
+ self.rep_mat=""
+ self.path_doc=self.rep_user
+ self.exec_acrobat=self.rep_user
+ self.catalogues= os.path.join(self.rep_ini,'..','Cata/cata.py')
+ self.isdeveloppeur='NON'
+ self.path_cata_dev=os.path.join(self.rep_user,'cata')
+ CONFIGbase.__init__ (self,appli)
+ self.pref=""
+
+ #--------------------------------------
+ def save_params(self):
+ #--------------------------------------
+ # sauvegarde
+ # les nouveaux paramètres dans le fichier de configuration utilisateur
+ #
+ l_param=('exec_acrobat', 'rep_ini','catalogues','rep_travail','rep_mat','path_doc','savedir')
+ texte=""
+ for clef in l_param :
+ if hasattr(self,clef):
+ valeur=getattr(self,clef)
+ texte= texte + clef+" = " + repr(valeur) +"\n"
+
+
+ # recuperation des repertoires materiaux
+ try :
+ for item in self.catalogues :
+ try :
+ (code,version,cata,format,defaut)=item
+ except :
+ (code,version,cata,format)=item
+ codeSansPoint=re.sub("\.","",version)
+ chaine="rep_mat_"+codeSansPoint
+ if hasattr(self,chaine):
+ valeur=getattr(self,chaine)
+ texte= texte + chaine+" = '" + str(valeur) +"'\n"
+ except :
+ pass
+
+ f=open(self.fic_ini_utilisateur,'w+')
+ f.write(texte)
+ f.close()
+
+
+class CONFIGStyle(CONFIGbase):
+ def __init__(self,appli,rep_ini):
+ self.salome=appli.salome
+ self.texte = "Pour prendre en compte les modifications \n"+\
+ " RELANCER EFICAS"
+ self.fichier="style.py"
+ self.rep_ini = rep_ini
+ self.fic_ini = os.path.join(self.rep_ini,self.fichier)
+ self.titre = "Paramètres d affichage"
+ self.texte_ini = "Voici les paramètres configurables : "
+ self.commande = self.creation_fichier_ini_si_possible
+ self.labels={"background":"couleur du fonds",
+ "foreground":"couleur de la police standard" ,
+ "standard":" police et taille standard",
+ "standard_italique":"police utilisée pour l'arbre ",
+ "standard_gras_souligne":"police utilisée pour le gras souligné",
+ "canvas_italique":"police italique",
+ "standard_gras":"gras",
+ #"canvas":"police",
+ #"canvas_gras":"police gras",
+ #"canvas_gras_italique":"police gras italique",
+ #"standard12":"police 12",
+ #"standard12_gras":"police 12 gras",
+ #"standard12_gras_italique":"police 12 gras italique",
+ #"standardcourier10":"courrier "
+ "statusfont":"police utilisée dans la status Bar",
+ }
+ self.types ={"background":"mot",
+ "foreground":"mot" ,
+ "standard":"mot2",
+ "standard_italique":"mot3",
+ "standard_gras":"mot3",
+ "standard_gras_souligne":"mot4",
+ "canvas":"mot2",
+ "canvas_italique":"mot3",
+ "canvas_gras":"mot3",
+ "canvas_gras_italique":"mot4",
+ "standard12":"mot2",
+ "standard12_gras":"mot3",
+ "standard12_gras_italique":"mot4",
+ "statusfont":"mot2",
+ "standardcourier10":"mot2"}
+ self.YesNo={}
+ self.l_param=[]
+ CONFIGbase.__init__ (self,appli)
+ self.pref="style."
+
+ def affichage_style_ini(self):
+ self.affichage_fichier_ini()
+
+def make_config(appli,rep):
+ return CONFIG(appli,rep)
+
+def make_config_style(appli,rep):
+ return CONFIGStyle(appli,rep)
+
+
# Accès à la documentation Aster
path_doc = os.path.join(rep_cata,'..','Doc')
-exec_acrobat = "acroread"
+#exec_acrobat = "acroread"
+exec_acrobat = "/local01/assire/v0.5/SALOME-MECA-2008.2/SALOME-MECA/prerequis/xpdf-3.02-linux/xpdf"
# Utilisateur/Développeur
isdeveloppeur = "NON"
path_cata_dev = "/tmp/cata"
catalogues = (
('ASTER','v7.8',os.path.join(rep_cata,'cataSTA7'),'python'),
- ('ASTER','v8.5',os.path.join(rep_cata,'cataSTA8'),'python'),
- ('ASTER','v9.1',os.path.join(rep_cata,'cataSTA9'),'python','defaut'),
+ ('ASTER','v8.7',os.path.join(rep_cata,'cataSTA8'),'python'),
+ ('ASTER','v9.3',os.path.join(rep_cata,'cataSTA9'),'python','defaut'),
)
#
# ======================================================================
+print "import des prefs de Aster"
import os,sys
# REPINI sert à localiser le fichier editeur.ini
# Obligatoire
REPINI=os.path.dirname(os.path.abspath(__file__))
+repIni=REPINI
# INSTALLDIR sert à localiser l'installation d'Eficas
# Obligatoire
-#@ MODIF properties Accas DATE 04/04/2007 AUTEUR aster M.ADMINISTRATEUR
-# CONFIGURATION MANAGEMENT OF EDF VERSION
+#@ MODIF properties Accas DATE 11/06/2008 AUTEUR aster M.ADMINISTRATEUR
# RESPONSABLE D6BHHHH J-P.LEFEBVRE
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# IDENTIFICATION DU GESTIONNAIRE DE COMMANDE ACCAS A PARTIR
# DE LA VERSION DU CODE_ASTER ASSOCIE
#----------------------------------------------------------------------
-version = "9.1.15"
-date = "17/10/2007"
+version = "9.3.0"
+date = "11/06/2008"
exploit = False
--- /dev/null
+
+L_E=DISTRIBUTION(Kind='Normal',
+ Mu=12,
+ Sigma=0.5,);
+
+L_L=DISTRIBUTION(Kind='LogNormal',
+ Settings='MuSigmaOverMu',
+ Gamma=0.0,);
+
+STUDY(Analysis='Reliability',
+ Algorithm='SORM',
+ Method='Cobyla',
+ Threshold=5.0,
+ ComparisonOperator='Less',
+ SeedToBeSet='no',
+ Variables=(_F(Name='E',
+ Type='in',
+ MarginalDistribution=L_E,),
+ _F(Name='L',
+ Type='in',
+ MarginalDistribution=L_L,),
+ _F(Name='O',
+ Type='out',),),
+ Solver='aaa',
+ WrapperPath='aster.so',
+ FunctionName='aster',
+ WrapCouplingMode='fork',
+ Command='/usr/bin/runaster',
+ InDataTransfer='files',
+ OutDataTransfer='files',
+ Files=(_F(Id='fich1',
+ Type='in',
+ Path='../fich_entree',
+ Subst='E,L',),
+ _F(Id='fich2',
+ Type='out',
+ Path='fich_sortie',
+ Subst='O',),),);
from Noyau.N_CR import CR
#
-__Id__="$Id: analyse_catalogue.py,v 1.6.6.1.4.1 2008-10-10 13:22:15 pnoyret Exp $"
-__version__="$Name: $"
+__Id__="$Id: analyse_catalogue.py,v 1.7 2008-11-13 10:19:15 cchris Exp $"
+__version__="$Name: BR_dev_V1_15 $"
#
l_noms_commandes = ['OPER','PROC','MACRO','FORM']
l_noms_composes=['FACT','BLOC','NUPL','FORM']
import re
sous_menus={"ASTER" : {0:{"3D":"3D.comm"},1:{"poutre":"pou.comm"},2:{"salome":"salome.comm"},3:{"divers":"comm"}},
- "OPENTURNS" : {0:{"Anne":"Anne.comm"}}
+ "OPENTURNS_STUDY" : {0:{"Anne":"Std.comm"}},
+ "OPENTURNS_WRAPPER" : {0:{"Anne":"wrapper_exemple.comm"}}
}
class listePatrons :
except:
rep_user_eficas = os.path.join('C:','Eficas_install')
else :
- rep_user_eficas = os.path.join(os.environ['HOME'],'Eficas_install')
+ rep_user_eficas= os.path.join(os.environ['HOME'],'.Eficas_Aster')
if os.path.exists(rep_user_eficas):
if os.path.isfile(rep_user_eficas) :
print "Un fichier de nom %s existe déjà : impossible de créer un répertoire de même nom" %rep_user_eficas
self.jdc_openturn_std=""
self.ihm="QT"
- from Editeur import configuration
+ import configuration
self.CONFIGURATION = self.appliEficas.CONFIGURATION
self.CONFIGStyle = self.appliEficas.CONFIGStyle
self.test=0
if unite :
titre = "Choix unite %d " %unite
texte = "Le fichier %s contient une commande INCLUDE \n" % fic_origine
- texte = texte+'Donnez le nom du fichier correspondant\n à l unité logique %d' % unite
+ texte = texte+'Donnez le nom du fichier correspondant à l unité logique %d' % unite
labeltexte = 'Fichier pour unite %d :' % unite
else:
titre = "Choix d'un fichier de poursuite"
texte = "Le fichier %s contient une commande %s\n" %(fic_origine,'POURSUITE')
- texte = texte+'Donnez le nom du fichier dont vous \n voulez faire une poursuite'
+ texte = texte+'Donnez le nom du fichier dont vous voulez faire une poursuite'
QMessageBox.information( self, titre,texte)
- fn = QFileDialog.getOpenFileName( None, "", self, None, titre )
+ fn = QFileDialog.getOpenFileName( self.CONFIGURATION.savedir,"", self, titre, "" )
if fn.isNull():
return
if saveas or self.fileName is None:
if path is None and self.fileName is not None:
path = os.path.dirname(unicode(self.fileName))
- selectedFilter = QString('')
+ else :
+ path=self.CONFIGURATION.savedir
fn = QFileDialog.getSaveFileName(path,
- self.trUtf8("JDC (*.comm);;"
- "All Files (*)"), self, None,
- self.trUtf8("Save File"), selectedFilter, 0)
-
+ self.trUtf8("JDC (*.comm);;" "All Files (*)"),self, None,
+ self.trUtf8("Save File"), '', 0)
+
if not fn.isNull():
ext = QFileInfo(fn).extension()
if ext.isEmpty():
- ex = selectedFilter.section('(*',1,1).section(')',0,0)
- if not ex.isEmpty():
- fn.append(ex)
+ ex = ".comm"
+ fn.append(ex)
if QFileInfo(fn).exists():
abort = QMessageBox.warning(self,
self.trUtf8("Save File"),
MonMacroPanel.__init__(self,node,parent,name,fl)
#Version TK ??
#if not hasattr(self.node.item.object,'fichier_ini'):
- if not hasattr(self.node.item.object,'fichier_unite'):
+ if not hasattr(self.node.item.object,'fichier_ini'):
self.ajoutPageBad()
else:
self.ajoutPageOk()
self.BChangeFile = QPushButton(self.TabPage,"BChangeFile")
self.BChangeFile.setGeometry(QRect(290,350,161,41))
- self.BChangeFile.setSizePolicy(QSizePolicy(0,0,0,0,self.BChangeFile.sizePolicy().hasHeightForWidth()))
+ #self.BChangeFile.setSizePolicy(QSizePolicy(0,0,0,0,self.BChangeFile.sizePolicy().hasHeightForWidth()))
self.BChangeFile.setText(self._DMacro__tr("Autre Fichier"))
self.connect(self.BBrowse,SIGNAL("clicked()"),self.BBrowsePressed)
if res == 1 : return
appli=self.configuration.appli
- rep_ini=self.configuration.rep_ini
+ repIni=self.configuration.repIni
fic_ini_util=self.configuration.fic_ini_utilisateur
old_fic_ini_util=fic_ini_util+"_old"
commande="mv "+fic_ini_util+" "+old_fic_ini_util
os.system(commande)
- from Editeur import configuration
- configNew=configuration.CONFIG(appli,rep_ini)
+ import configuration
+ configNew=configuration.CONFIG(appli,repIni)
self.configuration=configNew
appli.CONFIGURATION=configNew
self.configuration.save_params()
l3=self.listeValeursCourantes[index:]
for valeur in listeRetour:
self.LBValeurs.insertItem(QString(str(valeur)),index)
+ self.LBValeurs.setCurrentItem(index)
index=index+1
self.listeValeursCourantes=l1+listeRetour+l3
def BImportPressed(self):
- init=QString( self.editor.CONFIGURATION.rep_user)
+ init=QString( self.editor.CONFIGURATION.savedir)
fn = QFileDialog.getOpenFileName(init, self.trUtf8('All Files (*)',))
if fn == None : return
if fn == "" : return
l3=self.listeValeursCourantes[index:]
for valeur in listeRetour:
self.LBValeurs.insertItem(QString(str(valeur)),index)
+ self.LBValeurs.setCurrentItem(index)
index=index+1
self.listeValeursCourantes=l1+listeRetour+l3
SaisieValeur.RemplitPanel(self,self.listeValeursCourantes)
def SeparateurSelect(self,numero):
monBouton=self.BGSeparateur.find(numero)
self.separateur=self.dictSepar[str(monBouton.text())]
+ print self.separateur
def BImportSelPressed(self):
text=str(self.TBtext.selectedText())
def Traitement(self):
import string
+ print "kkkkkkkkkkkkkkkkkkkkk"
if self.textTraite[-1]=="\n" : self.textTraite=self.textTraite[0:-1]
self.textTraite=string.replace(self.textTraite,"\n",self.separateur)
liste1=self.textTraite.split(self.separateur)
+ print self.separateur
+ print liste1
liste=[]
for val in liste1 :
val=str(val)
def saveFile(self):
#recuperation du nom du fichier
- fn = QFileDialog.getSaveFileName(None,
+ fn = QFileDialog.getSaveFileName("",
self.trUtf8("All Files (*)"), self, None,
self.trUtf8("Save File"), '', 0)
if not fn.isNull():
from myMain import Eficas
from viewManager import MyTabview
-from Editeur import configuration
+import configuration
from Editeur import session
import utilIcons
else:
# None will cause open dialog to start with cwd
try :
- userDir=os.path.expanduser("~/Eficas_install/")
- return userDir
- except :
- return ""
+ userDir=self.appli.CONFIGURATION.savedir
+ except :
+ try :
+ userDir=os.path.expanduser("~")
+ except :
+ userDir=""
+ return userDir
def handleEditorOpened(self):
from Accas import FACT,BLOC,SIMP
#
-__version__="$Name: V1_14 $"
-__Id__="$Id: catabrowser.py,v 1.1.4.3.4.1 2008-10-10 13:46:35 pnoyret Exp $"
+__version__="$Name: BR_dev_V1_15 $"
+__Id__="$Id: catabrowser.py,v 1.2 2008-11-13 10:19:19 cchris Exp $"
#
class Tableau:
incr = 10
import definition_cata
#
-__version__="$Name: V1_14 $"
-__Id__="$Id: cataediteur.py,v 1.1.4.3.4.1 2008-10-10 13:47:11 pnoyret Exp $"
+__version__="$Name: BR_dev_V1_15 $"
+__Id__="$Id: cataediteur.py,v 1.2 2008-11-13 10:19:19 cchris Exp $"
#
Fonte_Niveau = fontes.canvas_gras_italique
from widgets import showinfo,showerror
#
-__version__="$Name: V1_14 $"
-__Id__="$Id: compomacro.py,v 1.1.4.4.4.1 2008-10-10 13:47:11 pnoyret Exp $"
+__version__="$Name: BR_dev_V1_15 $"
+__Id__="$Id: compomacro.py,v 1.2 2008-11-13 10:19:19 cchris Exp $"
#
class MACROPanel(panels.OngletPanel):
import panels
#
-__version__="$Name: V1_14 $"
-__Id__="$Id: componuplet.py,v 1.1.4.2.4.1 2008-10-10 13:47:11 pnoyret Exp $"
+__version__="$Name: BR_dev_V1_15 $"
+__Id__="$Id: componuplet.py,v 1.2 2008-11-13 10:19:19 cchris Exp $"
#
myrepr = Repr()
from Ihm import CONNECTOR
#
-__version__="$Name: V1_14 $"
-__Id__="$Id: treewidget.py,v 1.1.4.4.4.1 2008-10-10 13:47:11 pnoyret Exp $"
+__version__="$Name: BR_dev_V1_15 $"
+__Id__="$Id: treewidget.py,v 1.2 2008-11-13 10:19:19 cchris Exp $"
#
Fonte_Standard = fontes.standard
--- /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 ( 'STUDY' ), ),
+ ) # Fin JDC_CATA
+
+# --------------------------------------------------
+# fin entete
+# --------------------------------------------------
+
+# 3. Version d OPENTURNS ?
+
+#===========================================================
+
+
+#================================
+# 1. Definition des LOIS
+#================================
+
+# Nota : les variables de type OPER doivent etre en majuscules !
+DISTRIBUTION = OPER ( nom = "DISTRIBUTION",
+ sd_prod = loi,
+ op = 68,
+ fr = "Definitions des lois marginales utilisees par les variables d'entree",
+
+
+#====
+# 2. Type de la loi de distribution
+#====
+
+ Kind = SIMP ( statut = "o", typ = "TXM",
+ into = ( "Beta",
+ "Exponential",
+ "Gamma",
+ "Geometric",
+ "Gumbel",
+ "Histogram",
+ "Logistic",
+ "LogNormal",
+ "MultiNomial",
+ "Normal",
+ "TruncatedNormal",
+ "Poisson",
+ "Student",
+ "Triangular",
+ "Uniform",
+ "UserDefined",
+ "Weibull",
+ ),
+ fr = "Choix du type de la loi marginale",
+ ang = "1D marginal distribution." ),
+
+#====
+# 3. Definition des parametres selon le type de la loi
+#====
+
+# 3.1. ==> Loi beta
+
+ BETA = BLOC ( condition = " Kind in ( 'Beta', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "RT", "MuSigma" ),
+ defaut = "RT",
+ fr = "Parametrage de la loi beta",
+ ang = "Beta distribution parameter set"
+ ),
+
+ RT_Parameters = BLOC ( condition = " Settings in ( 'RT', ) ",
+
+ R = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre R de la loi",
+ ang = "R parameter"
+ ),
+
+ # T > R
+ T = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre T de la loi | T > R",
+ ang = "T parameter | T > R"
+ ),
+
+ ), # Fin BLOC RT_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre A de la loi",
+ ang = "A parameter"
+ ),
+
+ # B > A
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre B de la loi | B > A",
+ ang = "B parameter | B > A"
+ ),
+
+ ), # Fin BLOC BETA
+
+# 3.2. ==> Loi exponentielle
+
+ EXPONENTIAL = BLOC ( condition = " Kind in ( 'Exponential', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC EXPONENTIAL
+
+# 3.3. ==> Loi gamma
+
+ GAMMA = BLOC ( condition = " Kind in ( 'Gamma', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "KLambda", "MuSigma" ),
+ defaut = "KLambda",
+ fr = "Parametrage de la loi gamma",
+ ang = "Gamma distribution parameter set"
+ ),
+
+ KLambda_Parameters = BLOC ( condition = " Settings in ( 'KLambda', ) ",
+
+ K = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre K de la loi | K > 0",
+ ang = "K parameter | K > 0"
+ ),
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda de la loi | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ ), # Fin BLOC KLambda_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ defaut = 0.0,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ defaut = 1.0,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+
+ ), # Fin BLOC GAMMA
+
+# 3.5. ==> Loi geometrique
+
+ GEOMETRIC = BLOC ( condition = " Kind in ( 'Geometric', ) ",
+
+ P = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ val_max = 1.,
+ fr = "Parametre P | 0 < P < 1",
+ ang = "P parameter | 0 < P < 1"
+ ),
+
+ ), # Fin BLOC GEOMETRIC
+
+# 3.6. ==> Loi gumbel
+
+ GUMBEL = BLOC ( condition = " Kind in ( 'Gumbel', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "AlphaBeta", "MuSigma" ),
+ defaut = "AlphaBeta",
+ fr = "Parametrage de la loi gumbel",
+ ang = "Gumbel distribution parameter set"
+ ),
+
+ AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Alpha de la loi | Alpha > 0",
+ ang = "Alpha parameter | Alpha > 0"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Beta de la loi",
+ ang = "Beta parameter"
+ ),
+
+ ), # Fin BLOC AlphaBeta_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ ), # Fin BLOC GUMBEL
+
+# 3.7. ==> Loi histogramme
+
+ HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ",
+
+ 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 )
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC HISTOGRAM
+
+# 3.8. ==> Loi lognormale
+
+ LOGNORMAL = BLOC ( condition = " Kind in ( 'LogNormal', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "MuSigmaLog", "MuSigma", "MuSigmaOverMu" ),
+ defaut = "MuSigmaLog",
+ fr = "Parametrage de la loi lognormale",
+ ang = "Lognormal distribution parameter set"
+ ),
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', 'MuSigmaOverMu' ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi | Mu > Gamma",
+ ang = "Mu parameter | Mu > Gamma"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
+
+ MuLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu log de la loi",
+ ang = "Mu log parameter"
+ ),
+
+ SigmaLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma log de la loi | SigmaLog > 0",
+ ang = "Sigma log parameter | SigmaLog > 0"
+ ),
+
+ ), # Fin BLOC MuSigmaLog_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC LOGNORMAL
+
+# 3.9. ==> Loi logistique
+
+ LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Alpha de la loi",
+ ang = "Alpha parameter"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Beta de la loi | Beta > = 0",
+ ang = "Beta parameter | Beta > = 0"
+ ),
+
+ ), # Fin BLOC LOGISTIC
+
+# 3.10. ==> Loi multinomiale
+
+ MULTINOMIAL = BLOC ( condition = " Kind in ( 'MultiNomial', ) ",
+
+ N = SIMP ( statut = "o",
+ typ = "E",
+ max = 1,
+ fr = "Dimension de la loi",
+ ang = "DISTRIBUTION dimension"
+ ),
+
+ # Il faut un vecteur P de taille N
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC MULTINOMIAL
+
+# 3.11. ==> Loi normale
+
+ NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC NORMAL
+
+# 3.12. ==> Loi Poisson
+
+ POISSON = BLOC ( condition = " Kind in ( 'Poisson', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda de la loi | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ ), # Fin BLOC POISSON
+
+# 3.13. ==> Loi student
+
+ STUDENT = BLOC ( condition = " Kind in ( 'Student', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Nu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 2.,
+ fr = "Parametre Nu de la loi | V > = 2",
+ ang = "Nu parameter | V > = 2"
+ ),
+
+ ), # Fin BLOC STUDENT
+
+# 3.14. ==> Loi triangulaire
+
+ TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = M < = B",
+ ang = "Lower bound | A < = M < = B"
+ ),
+
+ M = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Mode de la loi | A < = M < = B",
+ ang = "Mode | A < = M < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = M < = B",
+ ang = "Upper bound | A < = M < = B"
+ ),
+
+ ), # Fin BLOC TRIANGULAR
+
+# 3.15. ==> Loi normale tronquee
+
+ TRUNCATEDNORMAL = BLOC ( condition = " Kind in ( 'TruncatedNormal', ) ",
+
+ MuN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ SigmaN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre SigmaN de la loi | SigmaN > 0",
+ ang = "SigmaN parameter | SigmaN> 0"
+ ),
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = B",
+ ang = "Lower bound | A < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = B",
+ ang = "Upper bound | A < = B"
+ ),
+
+ ), # Fin BLOC TRUNCATEDNORMAL
+
+# 3.16. ==> uniforme
+
+ UNIFORM = BLOC ( condition = " Kind in ( 'Uniform', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = B",
+ ang = "Lower bound | A < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = B",
+ ang = "Upper bound | A < = B"
+ ),
+
+ ), # Fin BLOC UNIFORM
+
+# 3.17. ==> Loi definie par l'utilisateur
+
+ USERDEFINED = BLOC ( condition = " Kind in ( 'UserDefined', ) ",
+
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC USERDEFINED
+
+# 3.18. ==> Weibull
+
+ WEIBULL = BLOC ( condition = " Kind in ( 'Weibull', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "AlphaBeta", "MuSigma" ),
+ defaut = "AlphaBeta",
+ fr = "Parametrage de la loi weibull",
+ ang = "Weibull distribution parameter set"
+ ),
+
+ AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Alpha de la loi | Alpha > 0",
+ ang = "Alpha parameter | Alpha > 0"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Beta de la loi | Beta > 0",
+ ang = "Beta parameter | Beta > 0"
+ ),
+
+ ), # Fin BLOC AlphaBeta_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC WEIBULL
+
+); # Fin OPER DISTRIBUTION
+
+#================================
+# 2. Definition du cas d'etude
+#================================
+# Nota : les variables de type PROC doivent etre en majuscules !
+STUDY = PROC ( nom = "STUDY",
+ op = None,
+ docu = "",
+ fr = "Mise en donnee pour le fichier de configuration de OPENTURNS.",
+ ang = "Writes the configuration file for OPENTURNS.",
+
+
+#=====
+# 1. Le Type d'Analyse
+#=====
+
+ Analysis = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Reliability", "Simulation", "QuadraticCumul" ),
+ fr = "Type d'Analyse",
+ ang = "Analysis",
+ ),
+
+#=====
+# 2. Pour la probabilite
+# algorithme et mode choisis
+#=====
+
+ Reliability = BLOC ( condition = " Analysis in ( 'Reliability', ) ",
+
+# 2.1. ==> L'algorithme
+
+ Algorithm = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "FORM", "SORM" ),
+ fr = "Algorithme de fiabilite",
+ ang = "Reliability algorithm"
+ ),
+
+# 2.2. ==> La methode
+# 2.2.1. ==> La methode
+
+ Method = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Cobyla", "AbdoRackwitz" ),
+ fr = "Methode d'optimisation.",
+ ang = "Optimisation method."
+ ),
+
+# 2.2.1. ==> Tirage d'importance
+
+ ImportanceSampling = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "yes", "no" ),
+ defaut = "no",
+ fr = "Tirage d'importance autour du point de conception",
+ ang = "Importance sampling around design point"
+ ),
+
+###
+### Il faut definir ces 3 elements pour ImportanceSampling sans collisioner ceux de Simulation
+###
+ ImportanceSamplingSettings = BLOC ( condition = "ImportanceSampling in ( 'yes', )",
+# 3.1.2. ==> Nombre d...
+
+ ImportanceSampling_BlockSize = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ defaut = 1,
+ fr = "Nombre maximum ...",
+ ang = "Maximum number of ..."
+ ),
+
+# 3.2.3. ==> ... maximum ...
+
+ ImportanceSampling_MaximumCoefficientOfVariation = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " maximum ...",
+ ang = "Absolute maximum ...."
+ ),
+
+# 3.2.4. ==> Maximum d'iterations
+
+ ImportanceSampling_MaximumOuterSampling = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = "Maximum d iterations externes.",
+ ang = "Maximum outer Sampling value."
+ ),
+
+ ), # Fin BLOC ImportanceSamplingSettings
+
+
+# 2.2.2. ==> Regles
+
+ regles = ( EXCLUS ( "MaximumAbsoluteError", "RelativeAbsoluteError" ), ),
+
+# 2.2.3. ==> Nombre d'iterations
+
+ MaximumIterationsNumber = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = "Nombre maximum d iterations.",
+ ang = "Maximum number of iterations."
+ ),
+
+# 2.2.4. ==> Erreur maximum absolue
+
+ MaximumAbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Distance maximum absolue entre 2 iterations successifs.",
+ ang = "Absolute maximum distance between 2 successive iterates."
+ ),
+
+# 2.2.5. ==> Erreur maximum relative
+
+ RelativeAbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Distance maximum relative entre 2 iterations successifs.",
+ ang = "Relative maximum distance between 2 successive iterates."
+ ),
+
+# 2.2.6. ==> Ecart de contrainte absolu
+
+ MaximumConstraintError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Valeur maximum absolue de la fonction \
+ moins la valeur du niveau.",
+ ang = "Maximum absolute value of the constraint function \
+ minus the level value."
+ ),
+
+# 2.2.7. ==> Ecart de residu absolu
+
+ MaximumResidualError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Maximum orthogonality error.",
+ ang = "Maximum orthogonality error."
+ ),
+
+ ), # Fin BLOC Reliability
+
+#=====
+# 3. Pour la probabilite
+# seuil par simulation :
+# algorithme choisi
+#=====
+
+ Simulation = BLOC ( condition = " Analysis in ( 'Simulation', ) ",
+
+# 3.1. ==> L'algorithme
+
+ Algorithm = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "MonteCarlo", "LHS", "DirectionalSampling" ),
+ fr = "Algorithme de simulation",
+ ang = "Simulation algorithm"
+ ),
+
+# 3.1.2. ==> Nombre d...
+
+ BlockSize = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ defaut = 1,
+ fr = "Nombre maximum ...",
+ ang = "Maximum number of ..."
+ ),
+
+# 3.2.3. ==> ... maximum ...
+
+ MaximumCoefficientOfVariation = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " maximum ...",
+ ang = "Absolute maximum ...."
+ ),
+
+# 3.2.4. ==> Maximum d'iterations
+
+ MaximumOuterSamplingType = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ defaut = "UserDefined",
+ into = ( "Wilks", "UserDefined" ),
+ fr = "Mode definition du maximum d iterations",
+ ang = "Definition for the maximum iterations number"
+ ),
+
+ MaximumOuterSamplingType_Wilks = BLOC ( condition = " MaximumOuterSamplingType in ( 'Wilks', ) ",
+
+ Wilks_Alpha = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ val_max = 1.0,
+ defaut = 0.95,
+ fr = "Ordre du quantile.",
+ ang = "Order of the quantile."
+ ),
+
+ Wilks_Beta = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ val_max = 1.0,
+ defaut = 0.90,
+ fr = "Confiance ...",
+ ang = "Confidence ..."
+ ),
+
+ Wilks_I = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 0,
+ defaut = 0,
+ fr = " ...",
+ ang = "Rank ..."
+ ),
+
+ ), # Fin BLOC Wilks
+
+ MaximumOuterSamplingType_UserDefined = BLOC ( condition = " MaximumOuterSamplingType in ( 'UserDefined', ) ",
+
+ MaximumOuterSampling = SIMP ( statut = "o",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ defaut = 250,
+ fr = "Maximum d iterations externes.",
+ ang = "Maximum outer Sampling value."
+ ),
+
+ ), # Fin BLOC UserDefined
+
+# 3.2.6. ==> Root strategy
+
+ DirectionalSampling = BLOC ( condition = " Algorithm in ( 'DirectionalSampling', ) ",
+
+ RootStrategy = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "SafeAndSlow",
+ into = ( "RiskyAndFast", "MediumSafe", "SafeAndSlow" ),
+ fr = "La strategie de recherche des racines",
+ ang = "Root strategy."
+ ),
+
+ SamplingStrategy = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "SafeAndSlow",
+ into = ( "OrthogonalDirection", "RandomDirection" ),
+ fr = "La strategie d'echantillonage",
+ ang = "Sampling strategy."
+ ),
+
+ Solver = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ defaut = "Brent",
+ into = ( "Bisection", "Brent", "Secant" ),
+ fr = "Solver.",
+ ang = "Solver."
+ ),
+
+ SolverSettings = BLOC ( condition = " Solver in ( 'Bisection', 'Brent', 'Secant' ) ",
+
+ regles = ( ENSEMBLE ( 'AbsoluteError', 'RelativeError', 'maximumFunctionEvaluation' ), ),
+
+ AbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " Absolute error ...",
+ ang = "Absolute error ..."
+ ),
+
+ RelativeError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " Relative error ...",
+ ang = "Relative error ..."
+ ),
+
+ MaximumFunctionEvaluation = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = " maximum Function Evaluation ...",
+ ang = "maximum Function Evaluation ..."
+ ),
+
+ ), # Fin BLOC SolverSettings
+
+ ), # Fin BLOC DirectionalSampling
+
+# 3.2.7. ==> Impression des intervalles de confiance
+
+ ConfidenceIntervalProbability = SIMP ( statut = "f",
+ typ = 'R',
+ max = '**',
+ val_min = 0.,
+ val_max = 1.,
+ fr = "Liste des intervalles de confiance voulus",
+ ang = "Confidence intervals"
+ ),
+
+ ), # Fin BLOC Simulation
+
+# QuadraticCumul = BLOC ( condition = " Analysis in ( 'QuadraticCumul', ) ",
+
+# ), # Fin BLOC QuadraticCumul
+
+#=====
+# 4. Pour la probabilite evenement
+#=====
+
+ Event = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
+
+ Threshold = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Le seuil de defaillance.",
+ ang = "Failure threshold."
+ ),
+
+ ComparisonOperator = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "Less", "LessOrEqual", "Equal", "GreaterOrEqual", "Greater" ),
+ fr = "Que faut-il ne pas depasser : un maximum ou un minimum.",
+ ang = "What is the failure threshold : maximum or minimum."
+ ),
+
+ ), # Fin BLOC Event
+
+
+ RandomGenerator = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
+
+ SeedToBeSet = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'no',
+ max = 1,
+ fr = "La racine du generateur aleatoire doit-elle etre positionnee ?",
+ ang = "Does the random generator seed need to be set ?"
+ ),
+
+ SeedSettings = BLOC ( condition = " SeedToBeSet in ( 'yes', ) ",
+
+ RandomGeneratorSeed = SIMP ( statut = "o",
+ typ = "I",
+ max = 1,
+ fr = "Racine du generateur aleatoire",
+ ang = "Random generator seed"
+ ),
+
+ ), # Fin BLOC SeedSettings
+
+ ), # Fin BLOC RandomGenerator
+
+
+#====
+# 5. Definition des parametres
+#====
+
+ Variables = FACT ( statut = "o",
+ min = 1,
+ max = "**",
+
+# 5.1. ==> Nom de la variable
+
+ Name = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom de la variable, identique au nom dans le solver.",
+ ang = "Name of the variable, identical to the name in solver."
+ ),
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "in", "out", ),
+ defaut = "in",
+ fr = "variable d'entree ou de sortie du solver",
+ ang = "Input or Output variable",
+ ),
+
+ Unit = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Unite",
+ ang = "Unit",
+ ),
+
+ Comment = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Commentaire",
+ ang = "Comment",
+ ),
+
+ Regexp = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Expression reguliere",
+ ang = "Regular expression",
+ ),
+
+ Format = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Format d'ecriture",
+ ang = "Format",
+ ),
+
+# 5.2. ==> Variable d'entree
+# 5.2.1. ==> Loi de distribution
+
+ InputVariable = BLOC ( condition = " Type in ( 'in', ) ",
+
+ MarginalDistribution = SIMP ( statut = "o",
+ typ = ( loi, ),
+ max = 1,
+ fr = "Choix de la loi marginale",
+ ang = "1D marginal distribution."
+ ),
+
+# 5.2.2. ==> Parametres de calcul
+
+# 5.2.2.1. ==> Quand on cherche le point de conception, on peut preferer le depart de l'algorithme.
+# Si on ne le fait pas, le programme prendra la valeur mediane.
+
+ PhysicalStartingPoint = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ fr = "Point de demarrage de l'algorithme iteratif",
+ ang = "Initial point for iterative process."
+ ),
+
+# 5.2.2.2. ==> Mode d'obtention du gradient par rapport au parametre
+
+ Gradient = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ into = ( "OUI", "NON" ),
+ defaut = "NON",
+ fr = "ASTER calcule directement le gradient.",
+ ang = "ASTER computes the gradient for this parameter."
+ ),
+
+ GradientProvided = BLOC ( condition = " GRADIENT in ( 'NON', ) ",
+
+ Increment = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ fr = "Increment dans la direction.",
+ ang = "Direction increment."
+ ),
+ ), # Fin BLOC GradientProvided
+
+ ), # Fin BLOC InputVariable
+
+ ), # Fin FACT Variables
+
+#====
+# 6. La fonction
+#====
+
+
+ PhysicalSolver = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ #into = ( "Code_Aster", "Code_Saturne", "User_defined" ),
+ fr = "Nom du solveur de calcul",
+ ang = "Solver name"
+ ),
+
+ WrapperPath = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "chemin d acces au wrapper",
+ ang = "wrapper library path"
+ ),
+
+ FunctionName = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom de la fonction dans le wrapper",
+ ang = "Function's name in wrapper"
+ ),
+
+ GradientName = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du gradient dans le wrapper",
+ ang = "gradient's name in wrapper"
+ ),
+
+ HessianName = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du hessian dans le wrapper",
+ ang = "hessian's name in wrapper"
+ ),
+
+ WrapCouplingMode = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "static-link", "dynamic-link", "fork", ),
+ fr = "mode de couplage du solver",
+ ang = "Solver coupling mode"
+ ),
+
+ DTDDirectory = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "repertoire de la DTD",
+ ang = "DTD directory"
+ ),
+
+ Fork = BLOC ( condition = " WrapCouplingMode in ( 'fork', ) ",
+
+ Command = SIMP ( statut = "o",
+ max = 1,
+ typ = "TXM",
+ fr = "Chemin du solver",
+ ang = "solver path"
+ ),
+ ), # Fin BLOC Fork
+
+ State = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ into = ( "shared", "specific" ),
+ fr = "partage de l etat interne entre les fonctions",
+ ang = "internal state sharing"
+ ),
+
+ InDataTransfer = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
+ fr = "mode de transfert des donnees d entree",
+ ang = "input transfering mode"
+ ),
+
+ OutDataTransfer = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
+ fr = "mode de transfert des donnees de sortie",
+ ang = "output transfering mode"
+ ),
+
+
+
+#====
+# 7. Informations sur les fichiers d'echange
+#====
+
+ Files = FACT ( statut = "f",
+ min = 1,
+ max = "**",
+
+ Id = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Identificateur du fichier",
+ ang = "File id"
+ ),
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "in", "out", ),
+ fr = "Fichier d entree ou de sortie du solveur ?",
+ ang = "Input or Output file ?"
+ ),
+
+ Name = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier",
+ ang = "file name"
+ ),
+
+ Path = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "chemin du fichier",
+ ang = "path file "
+ ),
+
+ Subst = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "liste de variables",
+ ang = "list"
+ ),
+
+ ), # Fin FACT Files
+
+); # Fin PROC STUDY
+
+RESULT = PROC ( nom = "RESULT",
+ op = None,
+ docu = "",
+ fr = "Liste des resultats a produire",
+ ang = "List of results to write out",
+
+ GeneralizedReliabilityIndex = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "yes", "no" ),
+ defaut = "no",
+ max = 1,
+ fr = "Index de fiabilite generalise",
+ ang = "Generalized reliability index"
+ ),
+
+); # Fin PROC Result
+
--- /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 ( 'STUDY' ), ),
+ ) # Fin JDC_CATA
+
+# --------------------------------------------------
+# fin entete
+# --------------------------------------------------
+
+# 3. Version d OPENTURNS ?
+
+#===========================================================
+
+
+#================================
+# 1. Definition des LOIS
+#================================
+
+# Nota : les variables de type OPER doivent etre en majuscules !
+DISTRIBUTION = OPER ( nom = "DISTRIBUTION",
+ sd_prod = loi,
+ op = 68,
+ fr = "Definitions des lois marginales utilisees par les variables d'entree",
+
+
+#====
+# 2. Type de la loi de distribution
+#====
+
+ Kind = SIMP ( statut = "o", typ = "TXM",
+ into = ( "Beta",
+ "Exponential",
+ "Gamma",
+ "Geometric",
+ "Gumbel",
+ "Histogram",
+ "Logistic",
+ "LogNormal",
+ "MultiNomial",
+ "Normal",
+ "TruncatedNormal",
+ "Poisson",
+ "Student",
+ "Triangular",
+ "Uniform",
+ "UserDefined",
+ "Weibull",
+ ),
+ fr = "Choix du type de la loi marginale",
+ ang = "1D marginal distribution." ),
+
+#====
+# 3. Definition des parametres selon le type de la loi
+#====
+
+# 3.1. ==> Loi beta
+
+ BETA = BLOC ( condition = " Kind in ( 'Beta', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "RT", "MuSigma" ),
+ defaut = "RT",
+ fr = "Parametrage de la loi beta",
+ ang = "Beta distribution parameter set"
+ ),
+
+ RT_Parameters = BLOC ( condition = " Settings in ( 'RT', ) ",
+
+ R = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre R de la loi",
+ ang = "R parameter"
+ ),
+
+ # T > R
+ T = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre T de la loi | T > R",
+ ang = "T parameter | T > R"
+ ),
+
+ ), # Fin BLOC RT_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre A de la loi",
+ ang = "A parameter"
+ ),
+
+ # B > A
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre B de la loi | B > A",
+ ang = "B parameter | B > A"
+ ),
+
+ ), # Fin BLOC BETA
+
+# 3.2. ==> Loi exponentielle
+
+ EXPONENTIAL = BLOC ( condition = " Kind in ( 'Exponential', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC EXPONENTIAL
+
+# 3.3. ==> Loi gamma
+
+ GAMMA = BLOC ( condition = " Kind in ( 'Gamma', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "KLambda", "MuSigma" ),
+ defaut = "KLambda",
+ fr = "Parametrage de la loi gamma",
+ ang = "Gamma distribution parameter set"
+ ),
+
+ KLambda_Parameters = BLOC ( condition = " Settings in ( 'KLambda', ) ",
+
+ K = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre K de la loi | K > 0",
+ ang = "K parameter | K > 0"
+ ),
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda de la loi | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ ), # Fin BLOC KLambda_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ defaut = 0.0,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ defaut = 1.0,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+
+ ), # Fin BLOC GAMMA
+
+# 3.5. ==> Loi geometrique
+
+ GEOMETRIC = BLOC ( condition = " Kind in ( 'Geometric', ) ",
+
+ P = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ val_max = 1.,
+ fr = "Parametre P | 0 < P < 1",
+ ang = "P parameter | 0 < P < 1"
+ ),
+
+ ), # Fin BLOC GEOMETRIC
+
+# 3.6. ==> Loi gumbel
+
+ GUMBEL = BLOC ( condition = " Kind in ( 'Gumbel', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "AlphaBeta", "MuSigma" ),
+ defaut = "AlphaBeta",
+ fr = "Parametrage de la loi gumbel",
+ ang = "Gumbel distribution parameter set"
+ ),
+
+ AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Alpha de la loi | Alpha > 0",
+ ang = "Alpha parameter | Alpha > 0"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Beta de la loi",
+ ang = "Beta parameter"
+ ),
+
+ ), # Fin BLOC AlphaBeta_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ ), # Fin BLOC GUMBEL
+
+# 3.7. ==> Loi histogramme
+
+ HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ",
+
+ 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 )
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC HISTOGRAM
+
+# 3.8. ==> Loi lognormale
+
+ LOGNORMAL = BLOC ( condition = " Kind in ( 'LogNormal', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "MuSigmaLog", "MuSigma", "MuSigmaOverMu" ),
+ defaut = "MuSigmaLog",
+ fr = "Parametrage de la loi lognormale",
+ ang = "Lognormal distribution parameter set"
+ ),
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', 'MuSigmaOverMu' ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi | Mu > Gamma",
+ ang = "Mu parameter | Mu > Gamma"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
+
+ MuLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu log de la loi",
+ ang = "Mu log parameter"
+ ),
+
+ SigmaLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma log de la loi | SigmaLog > 0",
+ ang = "Sigma log parameter | SigmaLog > 0"
+ ),
+
+ ), # Fin BLOC MuSigmaLog_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC LOGNORMAL
+
+# 3.9. ==> Loi logistique
+
+ LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Alpha de la loi",
+ ang = "Alpha parameter"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Beta de la loi | Beta > = 0",
+ ang = "Beta parameter | Beta > = 0"
+ ),
+
+ ), # Fin BLOC LOGISTIC
+
+# 3.10. ==> Loi multinomiale
+
+ MULTINOMIAL = BLOC ( condition = " Kind in ( 'MultiNomial', ) ",
+
+ N = SIMP ( statut = "o",
+ typ = "E",
+ max = 1,
+ fr = "Dimension de la loi",
+ ang = "DISTRIBUTION dimension"
+ ),
+
+ # Il faut un vecteur P de taille N
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC MULTINOMIAL
+
+# 3.11. ==> Loi normale
+
+ NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC NORMAL
+
+# 3.12. ==> Loi Poisson
+
+ POISSON = BLOC ( condition = " Kind in ( 'Poisson', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda de la loi | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ ), # Fin BLOC POISSON
+
+# 3.13. ==> Loi student
+
+ STUDENT = BLOC ( condition = " Kind in ( 'Student', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Nu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 2.,
+ fr = "Parametre Nu de la loi | V > = 2",
+ ang = "Nu parameter | V > = 2"
+ ),
+
+ ), # Fin BLOC STUDENT
+
+# 3.14. ==> Loi triangulaire
+
+ TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = M < = B",
+ ang = "Lower bound | A < = M < = B"
+ ),
+
+ M = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Mode de la loi | A < = M < = B",
+ ang = "Mode | A < = M < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = M < = B",
+ ang = "Upper bound | A < = M < = B"
+ ),
+
+ ), # Fin BLOC TRIANGULAR
+
+# 3.15. ==> Loi normale tronquee
+
+ TRUNCATEDNORMAL = BLOC ( condition = " Kind in ( 'TruncatedNormal', ) ",
+
+ MuN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ SigmaN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre SigmaN de la loi | SigmaN > 0",
+ ang = "SigmaN parameter | SigmaN> 0"
+ ),
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = B",
+ ang = "Lower bound | A < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = B",
+ ang = "Upper bound | A < = B"
+ ),
+
+ ), # Fin BLOC TRUNCATEDNORMAL
+
+# 3.16. ==> uniforme
+
+ UNIFORM = BLOC ( condition = " Kind in ( 'Uniform', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = B",
+ ang = "Lower bound | A < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = B",
+ ang = "Upper bound | A < = B"
+ ),
+
+ ), # Fin BLOC UNIFORM
+
+# 3.17. ==> Loi definie par l'utilisateur
+
+ USERDEFINED = BLOC ( condition = " Kind in ( 'UserDefined', ) ",
+
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC USERDEFINED
+
+# 3.18. ==> Weibull
+
+ WEIBULL = BLOC ( condition = " Kind in ( 'Weibull', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "AlphaBeta", "MuSigma" ),
+ defaut = "AlphaBeta",
+ fr = "Parametrage de la loi weibull",
+ ang = "Weibull distribution parameter set"
+ ),
+
+ AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Alpha de la loi | Alpha > 0",
+ ang = "Alpha parameter | Alpha > 0"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Beta de la loi | Beta > 0",
+ ang = "Beta parameter | Beta > 0"
+ ),
+
+ ), # Fin BLOC AlphaBeta_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC WEIBULL
+
+); # Fin OPER DISTRIBUTION
+
+#================================
+# 2. Definition du cas d'etude
+#================================
+# Nota : les variables de type PROC doivent etre en majuscules !
+STUDY = PROC ( nom = "STUDY",
+ op = None,
+ docu = "",
+ fr = "Mise en donnee pour le fichier de configuration de OPENTURNS.",
+ ang = "Writes the configuration file for OPENTURNS.",
+
+
+#=====
+# 1. Le Type d'Analyse
+#=====
+
+ Analysis = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Reliability", "Simulation", "QuadraticCumul" ),
+ fr = "Type d'Analyse",
+ ang = "Analysis",
+ ),
+
+#=====
+# 2. Pour la probabilite
+# algorithme et mode choisis
+#=====
+
+ Reliability = BLOC ( condition = " Analysis in ( 'Reliability', ) ",
+
+# 2.1. ==> L'algorithme
+
+ Algorithm = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "FORM", "SORM" ),
+ fr = "Algorithme de fiabilite",
+ ang = "Reliability algorithm"
+ ),
+
+# 2.2. ==> La methode
+# 2.2.1. ==> La methode
+
+ Method = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Cobyla", "AbdoRackwitz" ),
+ fr = "Methode d'optimisation.",
+ ang = "Optimisation method."
+ ),
+
+# 2.2.2. ==> Regles
+
+ regles = ( EXCLUS ( "MaximumAbsoluteError", "RelativeAbsoluteError" ), ),
+
+# 2.2.3. ==> Nombre d'iterations
+
+ MaximumIterationsNumber = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = "Nombre maximum d iterations.",
+ ang = "Maximum number of iterations."
+ ),
+
+# 2.2.4. ==> Erreur maximum absolue
+
+ MaximumAbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Distance maximum absolue entre 2 iterations successifs.",
+ ang = "Absolute maximum distance between 2 successive iterates."
+ ),
+
+# 2.2.5. ==> Erreur maximum relative
+
+ RelativeAbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Distance maximum relative entre 2 iterations successifs.",
+ ang = "Relative maximum distance between 2 successive iterates."
+ ),
+
+# 2.2.6. ==> Ecart de contrainte absolu
+
+ MaximumConstraintError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Valeur maximum absolue de la fonction \
+ moins la valeur du niveau.",
+ ang = "Maximum absolute value of the constraint function \
+ minus the level value."
+ ),
+
+# 2.2.7. ==> Ecart de residu absolu
+
+ MaximumResidualError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Maximum orthogonality error.",
+ ang = "Maximum orthogonality error."
+ ),
+
+ ), # Fin BLOC Reliability
+
+#=====
+# 3. Pour la probabilite
+# seuil par simulation :
+# algorithme choisi
+#=====
+
+ Simulation = BLOC ( condition = " Analysis in ( 'Simulation', ) ",
+
+# 3.1. ==> L'algorithme
+
+ Algorithm = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "MonteCarlo", "LHS", "DirectionalSampling" ),
+ fr = "Algorithme de simulation",
+ ang = "Simulation algorithm"
+ ),
+
+# 3.1.2. ==> Nombre d...
+
+ BlockSize = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ defaut = 1,
+ fr = "Nombre maximum ...",
+ ang = "Maximum number of ..."
+ ),
+
+# 3.2.3. ==> ... maximum ...
+
+ MaximumCoefficientOfVariation = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " maximum ...",
+ ang = "Absolute maximum ...."
+ ),
+
+# 3.2.4. ==> Maximum d'iterations
+
+ MaximumOuterSamplingType = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "UserDefined",
+ into = ( "Wilks", "UserDefined" ),
+ fr = "Mode definition du maximum d iterations",
+ ang = "Maximum iterations number"
+ ),
+
+ Wilks = BLOC ( condition = " MaximumOuterSamplingType in ( 'Wilks', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ val_max = 1.0,
+ fr = "Ordre du quantile.",
+ ang = "Order of the quantile."
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ val_max = 1.0,
+ fr = "Confiance ...",
+ ang = "Confidence ..."
+ ),
+
+ I = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 0,
+ defaut = 0,
+ fr = " ...",
+ ang = "Rank ..."
+ ),
+
+ ), # Fin BLOC Wilks
+
+ UserDefined = BLOC ( condition = " MaximumOuterSamplingType in ( 'UserDefined', ) ",
+
+ MaximumOuterSampling = SIMP ( statut = "o",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = "Maximum d iterations externes.",
+ ang = "Maximum outer Sampling value."
+ ),
+
+ ), # Fin BLOC UserDefined
+
+# 3.2.6. ==> Root strategy
+
+ DirectionalSampling = BLOC ( condition = " Algorithm in ( 'DirectionalSampling', ) ",
+
+ RootStrategyImplementation = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "SafeAndSlow",
+ into = ( "RiskyAndFast", "MediumSafe", "SafeAndSlow" ),
+ fr = "RootStrategyImplementation.",
+ ang = "RootStrategyImplementation."
+ ),
+
+ SolverImplementation = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "Bisection",
+ into = ( "Bisection", "Brent", "Secant" ),
+ fr = "SolverImplementation.",
+ ang = "SolverImplementation."
+ ),
+
+ SolverImplementationg = BLOC ( condition = " SolverImplementation in ( 'Bisection', 'Brent', 'Secant' ) ",
+
+ regles = ( ENSEMBLE ( 'AbsoluteError', 'RelativeError', 'maximumFunctionEvaluation' ), ),
+
+ AbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " Absolute error ...",
+ ang = "Absolute error ..."
+ ),
+
+ RelativeError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " Relative error ...",
+ ang = "Relative error ..."
+ ),
+
+ MaximumFunctionEvaluation = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = " maximum Function Evaluation ...",
+ ang = "maximum Function Evaluation ..."
+ ),
+
+ ), # Fin BLOC SolverImplementationg
+
+ ), # Fin BLOC DirectionalSampling
+
+# 3.2.7. ==> Impression des intervalles de confiance
+
+ ConfidenceIntervalProbability = SIMP ( statut = "f",
+ typ = 'R',
+ max = '**',
+ val_min = 0.,
+ val_max = 1.,
+ fr = "Liste des intervalles de confiance voulus",
+ ang = "Confidence intervals"
+ ),
+
+ ), # Fin BLOC Simulation
+
+#=====
+# 4. Pour la probabilite evenement
+#=====
+
+ Event = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
+
+ Threshold = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Le seuil de defaillance.",
+ ang = "Failure threshold."
+ ),
+
+ ComparisonOperator = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "Less", "LessOrEqual", "Equal", "GreaterOrEqual", "Greater" ),
+ fr = "Que faut-il ne pas depasser : un maximum ou un minimum.",
+ ang = "What is the failure threshold : maximum or minimum."
+ ),
+
+ ), # Fin BLOC Event
+
+
+ RandomGenerator = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
+
+ SeedToBeSet = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'no',
+ max = 1,
+ fr = "La racine du generateur aleatoire doit-elle etre positionnee ?",
+ ang = "Does the random generator seed need to be set ?"
+ ),
+
+ SeedSettings = BLOC ( condition = " SeedToBeSet in ( 'yes', ) ",
+
+ RandomGeneratorSeed = SIMP ( statut = "o",
+ typ = "I",
+ max = 1,
+ fr = "Racine du generateur aleatoire",
+ ang = "Random generator seed"
+ ),
+
+ ), # Fin BLOC SeedSettings
+
+ ), # Fin BLOC RandomGenerator
+
+
+#====
+# 5. Definition des parametres
+#====
+
+ Variables = FACT ( statut = "o",
+ min = 1,
+ max = "**",
+
+# 5.1. ==> Nom de la variable
+
+ Name = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom de la variable, identique au nom dans le solver.",
+ ang = "Name of the variable, identical to the name in solver."
+ ),
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "in", "out", ),
+ defaut = "in",
+ fr = "variable d'entree ou de sortie du solver",
+ ang = "Input or Output variable",
+ ),
+
+ Unit = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Unite",
+ ang = "Unit",
+ ),
+
+ Comment = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Commentaire",
+ ang = "Comment",
+ ),
+
+ Regexp = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Expression reguliere",
+ ang = "Regular expression",
+ ),
+
+ Format = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Format d'ecriture",
+ ang = "Format",
+ ),
+
+# 5.2. ==> Variable d'entree
+# 5.2.1. ==> Loi de distribution
+
+ InputVariable = BLOC ( condition = " Type in ( 'in', ) ",
+
+ MarginalDistribution = SIMP ( statut = "o",
+ typ = ( loi, ),
+ max = 1,
+ fr = "Choix de la loi marginale",
+ ang = "1D marginal distribution."
+ ),
+
+# 5.2.2. ==> Parametres de calcul
+
+# 5.2.2.1. ==> Quand on cherche le point de conception, on peut preferer le depart de l'algorithme.
+# Si on ne le fait pas, le programme prendra la valeur mediane.
+
+ PhysicalStartingPoint = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ fr = "Point de demarrage de l'algorithme iteratif",
+ ang = "Initial point for iterative process."
+ ),
+
+# 5.2.2.2. ==> Mode d'obtention du gradient par rapport au parametre
+
+ Gradient = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ into = ( "OUI", "NON" ),
+ defaut = "NON",
+ fr = "ASTER calcule directement le gradient.",
+ ang = "ASTER computes the gradient for this parameter."
+ ),
+
+ GradientProvided = BLOC ( condition = " GRADIENT in ( 'NON', ) ",
+
+ Increment = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ fr = "Increment dans la direction.",
+ ang = "Direction increment."
+ ),
+ ), # Fin BLOC GradientProvided
+
+ ), # Fin BLOC InputVariable
+
+ ), # Fin FACT Variables
+
+#====
+# 6. La fonction
+#====
+
+
+ Solver = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ #into = ( "Code_Aster", "Code_Saturne", "User_defined" ),
+ fr = "Nom du solveur de calcul",
+ ang = "Solver name"
+ ),
+
+ WrapperPath = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "chemin d acces au wrapper",
+ ang = "wrapper library path"
+ ),
+
+ FunctionName = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom de la fonction dans le wrapper",
+ ang = "Function's name in wrapper"
+ ),
+
+ GradientName = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du gradient dans le wrapper",
+ ang = "gradient's name in wrapper"
+ ),
+
+ HessianName = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du hessian dans le wrapper",
+ ang = "hessian's name in wrapper"
+ ),
+
+ WrapCouplingMode = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "static-link", "dynamic-link", "fork", ),
+ fr = "mode de couplage du solver",
+ ang = "Solver coupling mode"
+ ),
+
+ DTDDirectory = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "repertoire de la DTD",
+ ang = "DTD directory"
+ ),
+
+ Fork = BLOC ( condition = " WrapCouplingMode in ( 'fork', ) ",
+
+ Command = SIMP ( statut = "o",
+ max = 1,
+ typ = "TXM",
+ fr = "Chemin du solver",
+ ang = "solver path"
+ ),
+ ), # Fin BLOC Fork
+
+ State = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ into = ( "shared", "specific" ),
+ fr = "partage de l etat interne entre les fonctions",
+ ang = "internal state sharing"
+ ),
+
+ InDataTransfer = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
+ fr = "mode de transfert des donnees d entree",
+ ang = "input transfering mode"
+ ),
+
+ OutDataTransfer = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
+ fr = "mode de transfert des donnees de sortie",
+ ang = "output transfering mode"
+ ),
+
+
+
+#====
+# 7. Informations sur les fichiers d'echange
+#====
+
+ Files = FACT ( statut = "f",
+ min = 1,
+ max = "**",
+
+ Id = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Identificateur du fichier",
+ ang = "File id"
+ ),
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "in", "out", ),
+ fr = "Fichier d entree ou de sortie du solveur ?",
+ ang = "Input or Output file ?"
+ ),
+
+ Name = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier",
+ ang = "file name"
+ ),
+
+ Path = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "chemin du fichier",
+ ang = "path file "
+ ),
+
+ Subst = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "liste de variables",
+ ang = "list"
+ ),
+
+ ), # Fin FACT Files
+
+); # Fin PROC STUDY
+
+Result = PROC ( nom = "RESULT",
+ op = None,
+ docu = "",
+ fr = "Liste des resultats a produire",
+ ang = "List of results to write out",
+
+ GeneralizedReliabilityIndex = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "yes", "no" ),
+ defaut = "no",
+ max = 1,
+ fr = "Index de fiabilite generalise",
+ ang = "Generalized reliability index"
+ ),
+
+); # Fin PROC Result
+
--- /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 ( 'STUDY' ), ),
+ ) # Fin JDC_CATA
+
+# --------------------------------------------------
+# fin entete
+# --------------------------------------------------
+
+# 3. Version d OPENTURNS ?
+
+#===========================================================
+
+
+#================================
+# 1. Definition des LOIS
+#================================
+
+# Nota : les variables de type OPER doivent etre en majuscules !
+DISTRIBUTION = OPER ( nom = "DISTRIBUTION",
+ sd_prod = loi,
+ op = 68,
+ fr = "Definitions des lois marginales utilisees par les variables d'entree",
+
+
+#====
+# 2. Type de la loi de distribution
+#====
+
+ Kind = SIMP ( statut = "o", typ = "TXM",
+ into = ( "Beta",
+ "Exponential",
+ "Gamma",
+ "Geometric",
+ "Gumbel",
+ "Histogram",
+ "Logistic",
+ "LogNormal",
+ "MultiNomial",
+ "Normal",
+ "TruncatedNormal",
+ "Poisson",
+ "Student",
+ "Triangular",
+ "Uniform",
+ "UserDefined",
+ "Weibull",
+ ),
+ fr = "Choix du type de la loi marginale",
+ ang = "1D marginal distribution." ),
+
+#====
+# 3. Definition des parametres selon le type de la loi
+#====
+
+# 3.1. ==> Loi beta
+
+ BETA = BLOC ( condition = " Kind in ( 'Beta', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "RT", "MuSigma" ),
+ defaut = "RT",
+ fr = "Parametrage de la loi beta",
+ ang = "Beta distribution parameter set"
+ ),
+
+ RT_Parameters = BLOC ( condition = " Settings in ( 'RT', ) ",
+
+ R = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre R de la loi",
+ ang = "R parameter"
+ ),
+
+ # T > R
+ T = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre T de la loi | T > R",
+ ang = "T parameter | T > R"
+ ),
+
+ ), # Fin BLOC RT_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre A de la loi",
+ ang = "A parameter"
+ ),
+
+ # B > A
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre B de la loi | B > A",
+ ang = "B parameter | B > A"
+ ),
+
+ ), # Fin BLOC BETA
+
+# 3.2. ==> Loi exponentielle
+
+ EXPONENTIAL = BLOC ( condition = " Kind in ( 'Exponential', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC EXPONENTIAL
+
+# 3.3. ==> Loi gamma
+
+ GAMMA = BLOC ( condition = " Kind in ( 'Gamma', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "KLambda", "MuSigma" ),
+ defaut = "KLambda",
+ fr = "Parametrage de la loi gamma",
+ ang = "Gamma distribution parameter set"
+ ),
+
+ KLambda_Parameters = BLOC ( condition = " Settings in ( 'KLambda', ) ",
+
+ K = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre K de la loi | K > 0",
+ ang = "K parameter | K > 0"
+ ),
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda de la loi | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ ), # Fin BLOC KLambda_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ defaut = 0.0,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ defaut = 1.0,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+
+ ), # Fin BLOC GAMMA
+
+# 3.5. ==> Loi geometrique
+
+ GEOMETRIC = BLOC ( condition = " Kind in ( 'Geometric', ) ",
+
+ P = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ val_max = 1.,
+ fr = "Parametre P | 0 < P < 1",
+ ang = "P parameter | 0 < P < 1"
+ ),
+
+ ), # Fin BLOC GEOMETRIC
+
+# 3.6. ==> Loi gumbel
+
+ GUMBEL = BLOC ( condition = " Kind in ( 'Gumbel', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "AlphaBeta", "MuSigma" ),
+ defaut = "AlphaBeta",
+ fr = "Parametrage de la loi gumbel",
+ ang = "Gumbel distribution parameter set"
+ ),
+
+ AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Alpha de la loi | Alpha > 0",
+ ang = "Alpha parameter | Alpha > 0"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Beta de la loi",
+ ang = "Beta parameter"
+ ),
+
+ ), # Fin BLOC AlphaBeta_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ ), # Fin BLOC GUMBEL
+
+# 3.7. ==> Loi histogramme
+
+ HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ",
+
+ 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 )
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC HISTOGRAM
+
+# 3.8. ==> Loi lognormale
+
+ LOGNORMAL = BLOC ( condition = " Kind in ( 'LogNormal', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "MuSigmaLog", "MuSigma", "MuSigmaOverMu" ),
+ defaut = "MuSigmaLog",
+ fr = "Parametrage de la loi lognormale",
+ ang = "Lognormal distribution parameter set"
+ ),
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi | Mu > Gamma",
+ ang = "Mu parameter | Mu > Gamma"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ MuSigmaOverMu_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaOverMu,', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi | Mu > Gamma",
+ ang = "Mu parameter | Mu > Gamma"
+ ),
+
+ SigmaOverMu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre SigmaOverMu de la loi | SigmaOverMu > 0",
+ ang = "SigmaOverMu parameter | SigmaOverMu > 0"
+ ),
+
+ ), # Fin BLOC MuSigmaOverMu_Parameters
+
+ MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
+
+ MuLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu log de la loi",
+ ang = "Mu log parameter"
+ ),
+
+ SigmaLog = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma log de la loi | SigmaLog > 0",
+ ang = "Sigma log parameter | SigmaLog > 0"
+ ),
+
+ ), # Fin BLOC MuSigmaLog_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC LOGNORMAL
+
+# 3.9. ==> Loi logistique
+
+ LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Alpha de la loi",
+ ang = "Alpha parameter"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Beta de la loi | Beta > = 0",
+ ang = "Beta parameter | Beta > = 0"
+ ),
+
+ ), # Fin BLOC LOGISTIC
+
+# 3.10. ==> Loi multinomiale
+
+ MULTINOMIAL = BLOC ( condition = " Kind in ( 'MultiNomial', ) ",
+
+ N = SIMP ( statut = "o",
+ typ = "E",
+ max = 1,
+ fr = "Dimension de la loi",
+ ang = "DISTRIBUTION dimension"
+ ),
+
+ # Il faut un vecteur P de taille N
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC MULTINOMIAL
+
+# 3.11. ==> Loi normale
+
+ NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC NORMAL
+
+# 3.12. ==> Loi Poisson
+
+ POISSON = BLOC ( condition = " Kind in ( 'Poisson', ) ",
+
+ Lambda = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Lambda de la loi | Lambda > 0",
+ ang = "Lambda parameter | Lambda > 0"
+ ),
+
+ ), # Fin BLOC POISSON
+
+# 3.13. ==> Loi student
+
+ STUDENT = BLOC ( condition = " Kind in ( 'Student', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Nu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 2.,
+ fr = "Parametre Nu de la loi | V > = 2",
+ ang = "Nu parameter | V > = 2"
+ ),
+
+ ), # Fin BLOC STUDENT
+
+# 3.14. ==> Loi triangulaire
+
+ TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = M < = B",
+ ang = "Lower bound | A < = M < = B"
+ ),
+
+ M = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Mode de la loi | A < = M < = B",
+ ang = "Mode | A < = M < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = M < = B",
+ ang = "Upper bound | A < = M < = B"
+ ),
+
+ ), # Fin BLOC TRIANGULAR
+
+# 3.15. ==> Loi normale tronquee
+
+ TRUNCATEDNORMAL = BLOC ( condition = " Kind in ( 'TruncatedNormal', ) ",
+
+ MuN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ SigmaN = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre SigmaN de la loi | SigmaN > 0",
+ ang = "SigmaN parameter | SigmaN> 0"
+ ),
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = B",
+ ang = "Lower bound | A < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = B",
+ ang = "Upper bound | A < = B"
+ ),
+
+ ), # Fin BLOC TRUNCATEDNORMAL
+
+# 3.16. ==> uniforme
+
+ UNIFORM = BLOC ( condition = " Kind in ( 'Uniform', ) ",
+
+ A = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne inferieure de la loi | A < = B",
+ ang = "Lower bound | A < = B"
+ ),
+
+ B = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Borne superieure de la loi | A < = B",
+ ang = "Upper bound | A < = B"
+ ),
+
+ ), # Fin BLOC UNIFORM
+
+# 3.17. ==> Loi definie par l'utilisateur
+
+ USERDEFINED = BLOC ( condition = " Kind in ( 'UserDefined', ) ",
+
+ # Il faut definir une collection de couples ( x,p )
+ Values = SIMP ( statut = 'o',
+ typ = 'R',
+ max = '**'
+ ),
+
+ ), # Fin BLOC USERDEFINED
+
+# 3.18. ==> Weibull
+
+ WEIBULL = BLOC ( condition = " Kind in ( 'Weibull', ) ",
+
+ Settings = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "AlphaBeta", "MuSigma" ),
+ defaut = "AlphaBeta",
+ fr = "Parametrage de la loi weibull",
+ ang = "Weibull distribution parameter set"
+ ),
+
+ AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Alpha de la loi | Alpha > 0",
+ ang = "Alpha parameter | Alpha > 0"
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Beta de la loi | Beta > 0",
+ ang = "Beta parameter | Beta > 0"
+ ),
+
+ ), # Fin BLOC AlphaBeta_Parameters
+
+
+ MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
+
+ Mu = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Mu de la loi",
+ ang = "Mu parameter"
+ ),
+
+ Sigma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.,
+ fr = "Parametre Sigma de la loi | Sigma > 0",
+ ang = "Sigma parameter | Sigma > 0"
+ ),
+
+ ), # Fin BLOC MuSigma_Parameters
+
+ Gamma = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Parametre Gamma",
+ ang = "Gamma parameter"
+ ),
+
+ ), # Fin BLOC WEIBULL
+
+); # Fin OPER DISTRIBUTION
+
+#================================
+# 2. Definition du cas d'etude
+#================================
+# Nota : les variables de type PROC doivent etre en majuscules !
+STUDY = PROC ( nom = "STUDY",
+ op = None,
+ docu = "",
+ fr = "Mise en donnee pour le fichier de configuration de OPENTURNS.",
+ ang = "Writes the configuration file for OPENTURNS.",
+
+
+#=====
+# 1. Le Type d'Analyse
+#=====
+
+ Analysis = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Reliability", "Simulation", "QuadraticCumul" ),
+ fr = "Type d'Analyse",
+ ang = "Analysis",
+ ),
+
+#=====
+# 2. Pour la probabilite
+# algorithme et mode choisis
+#=====
+
+ Reliability = BLOC ( condition = " Analysis in ( 'Reliability', ) ",
+
+# 2.1. ==> L'algorithme
+
+ Algorithm = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "FORM", "SORM" ),
+ fr = "Algorithme de fiabilite",
+ ang = "Reliability algorithm"
+ ),
+
+# 2.2. ==> La methode
+# 2.2.1. ==> La methode
+
+ Method = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "Cobyla", "AbdoRackwitz" ),
+ fr = "Methode d'optimisation.",
+ ang = "Optimisation method."
+ ),
+
+# 2.2.2. ==> Regles
+
+ regles = ( EXCLUS ( "MaximumAbsoluteError", "RelativeAbsoluteError" ), ),
+
+# 2.2.3. ==> Nombre d'iterations
+
+ MaximumIterationsNumber = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = "Nombre maximum d iterations.",
+ ang = "Maximum number of iterations."
+ ),
+
+# 2.2.4. ==> Erreur maximum absolue
+
+ MaximumAbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Distance maximum absolue entre 2 iterations successifs.",
+ ang = "Absolute maximum distance between 2 successive iterates."
+ ),
+
+# 2.2.5. ==> Erreur maximum relative
+
+ RelativeAbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Distance maximum relative entre 2 iterations successifs.",
+ ang = "Relative maximum distance between 2 successive iterates."
+ ),
+
+# 2.2.6. ==> Ecart de contrainte absolu
+
+ MaximumConstraintError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Valeur maximum absolue de la fonction \
+ moins la valeur du niveau.",
+ ang = "Maximum absolute value of the constraint function \
+ minus the level value."
+ ),
+
+# 2.2.7. ==> Ecart de residu absolu
+
+ MaximumResidualError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = "Maximum orthogonality error.",
+ ang = "Maximum orthogonality error."
+ ),
+
+ ), # Fin BLOC Reliability
+
+#=====
+# 3. Pour la probabilite
+# seuil par simulation :
+# algorithme choisi
+#=====
+
+ Simulation = BLOC ( condition = " Analysis in ( 'Simulation', ) ",
+
+# 3.1. ==> L'algorithme
+
+ Algorithm = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "MonteCarlo", "LHS", "DirectionalSampling" ),
+ fr = "Algorithme de simulation",
+ ang = "Simulation algorithm"
+ ),
+
+# 3.1.2. ==> Nombre d...
+
+ BlockSize = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ defaut = 1,
+ fr = "Nombre maximum ...",
+ ang = "Maximum number of ..."
+ ),
+
+# 3.2.3. ==> ... maximum ...
+
+ MaximumCoefficientOfVariation = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " maximum ...",
+ ang = "Absolute maximum ...."
+ ),
+
+# 3.2.4. ==> Maximum d'iterations
+
+ MaximumOuterSamplingType = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "UserDefined",
+ into = ( "Wilks", "UserDefined" ),
+ fr = "Mode definition du maximum d iterations",
+ ang = "Maximum iterations number"
+ ),
+
+ Wilks = BLOC ( condition = " MaximumOuterSamplingType in ( 'Wilks', ) ",
+
+ Alpha = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ val_max = 1.0,
+ fr = "Ordre du quantile.",
+ ang = "Order of the quantile."
+ ),
+
+ Beta = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ val_max = 1.0,
+ fr = "Confiance ...",
+ ang = "Confidence ..."
+ ),
+
+ I = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 0,
+ defaut = 0,
+ fr = " ...",
+ ang = "Rank ..."
+ ),
+
+ ), # Fin BLOC Wilks
+
+ UserDefined = BLOC ( condition = " MaximumOuterSamplingType in ( 'UserDefined', ) ",
+
+ MaximumOuterSampling = SIMP ( statut = "o",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = "Maximum d iterations externes.",
+ ang = "Maximum outer Sampling value."
+ ),
+
+ ), # Fin BLOC UserDefined
+
+# 3.2.6. ==> Root strategy
+
+ DirectionalSampling = BLOC ( condition = " Algorithm in ( 'DirectionalSampling', ) ",
+
+ RootStrategyImplementation = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "SafeAndSlow",
+ into = ( "RiskyAndFast", "MediumSafe", "SafeAndSlow" ),
+ fr = "RootStrategyImplementation.",
+ ang = "RootStrategyImplementation."
+ ),
+
+ SolverImplementation = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ defaut = "Bisection",
+ into = ( "Bisection", "Brent", "Secant" ),
+ fr = "SolverImplementation.",
+ ang = "SolverImplementation."
+ ),
+
+ SolverImplementationg = BLOC ( condition = " SolverImplementation in ( 'Bisection', 'Brent', 'Secant' ) ",
+
+ regles = ( ENSEMBLE ( 'AbsoluteError', 'RelativeError', 'maximumFunctionEvaluation' ), ),
+
+ AbsoluteError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " Absolute error ...",
+ ang = "Absolute error ..."
+ ),
+
+ RelativeError = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ val_min = 0.0,
+ fr = " Relative error ...",
+ ang = "Relative error ..."
+ ),
+
+ MaximumFunctionEvaluation = SIMP ( statut = "f",
+ typ = "I",
+ max = 1,
+ val_min = 1,
+ fr = " maximum Function Evaluation ...",
+ ang = "maximum Function Evaluation ..."
+ ),
+
+ ), # Fin BLOC SolverImplementationg
+
+ ), # Fin BLOC DirectionalSampling
+
+# 3.2.7. ==> Impression des intervalles de confiance
+
+ ConfidenceIntervalProbability = SIMP ( statut = "f",
+ typ = 'R',
+ max = '**',
+ val_min = 0.,
+ val_max = 1.,
+ fr = "Liste des intervalles de confiance voulus",
+ ang = "Confidence intervals"
+ ),
+
+ ), # Fin BLOC Simulation
+
+#=====
+# 4. Pour la probabilite evenement
+#=====
+
+ Event = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
+
+ Threshold = SIMP ( statut = "o",
+ typ = "R",
+ max = 1,
+ fr = "Le seuil de defaillance.",
+ ang = "Failure threshold."
+ ),
+
+ ComparisonOperator = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "Less", "LessOrEqual", "Equal", "GreaterOrEqual", "Greater" ),
+ fr = "Que faut-il ne pas depasser : un maximum ou un minimum.",
+ ang = "What is the failure threshold : maximum or minimum."
+ ),
+
+ ), # Fin BLOC Event
+
+
+ RandomGenerator = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
+
+ SeedToBeSet = SIMP ( statut = "o",
+ typ = 'TXM',
+ into = ( 'yes', 'no' ),
+ defaut = 'no',
+ max = 1,
+ fr = "La racine du generateur aleatoire doit-elle etre positionnee ?",
+ ang = "Does the random generator seed need to be set ?"
+ ),
+
+ SeedSettings = BLOC ( condition = " SeedToBeSet in ( 'yes', ) ",
+
+ RandomGeneratorSeed = SIMP ( statut = "o",
+ typ = "I",
+ max = 1,
+ fr = "Racine du generateur aleatoire",
+ ang = "Random generator seed"
+ ),
+
+ ), # Fin BLOC SeedSettings
+
+ ), # Fin BLOC RandomGenerator
+
+
+#====
+# 5. Definition des parametres
+#====
+
+ Variables = FACT ( statut = "o",
+ min = 1,
+ max = "**",
+
+# 5.1. ==> Nom de la variable
+
+ Name = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom de la variable, identique au nom dans le solver.",
+ ang = "Name of the variable, identical to the name in solver."
+ ),
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "in", "out", ),
+ defaut = "in",
+ fr = "variable d'entree ou de sortie du solver",
+ ang = "Input or Output variable",
+ ),
+
+ Unit = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Unite",
+ ang = "Unit",
+ ),
+
+ Comment = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Commentaire",
+ ang = "Comment",
+ ),
+
+ Regexp = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Expression reguliere",
+ ang = "Regular expression",
+ ),
+
+ Format = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Format d'ecriture",
+ ang = "Format",
+ ),
+
+# 5.2. ==> Variable d'entree
+# 5.2.1. ==> Loi de distribution
+
+ InputVariable = BLOC ( condition = " Type in ( 'in', ) ",
+
+ MarginalDistribution = SIMP ( statut = "o",
+ typ = ( loi, ),
+ max = 1,
+ fr = "Choix de la loi marginale",
+ ang = "1D marginal distribution."
+ ),
+
+# 5.2.2. ==> Parametres de calcul
+
+# 5.2.2.1. ==> Quand on cherche le point de conception, on peut preferer le depart de l'algorithme.
+# Si on ne le fait pas, le programme prendra la valeur mediane.
+
+ PhysicalStartingPoint = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ fr = "Point de demarrage de l'algorithme iteratif",
+ ang = "Initial point for iterative process."
+ ),
+
+# 5.2.2.2. ==> Mode d'obtention du gradient par rapport au parametre
+
+ Gradient = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ into = ( "OUI", "NON" ),
+ defaut = "NON",
+ fr = "ASTER calcule directement le gradient.",
+ ang = "ASTER computes the gradient for this parameter."
+ ),
+
+ GradientProvided = BLOC ( condition = " GRADIENT in ( 'NON', ) ",
+
+ Increment = SIMP ( statut = "f",
+ typ = "R",
+ max = 1,
+ fr = "Increment dans la direction.",
+ ang = "Direction increment."
+ ),
+ ), # Fin BLOC GradientProvided
+
+ ), # Fin BLOC InputVariable
+
+ ), # Fin FACT Variables
+
+#====
+# 6. La fonction
+#====
+
+
+ Solver = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ #into = ( "Code_Aster", "Code_Saturne", "User_defined" ),
+ fr = "Nom du solveur de calcul",
+ ang = "Solver name"
+ ),
+
+ WrapperPath = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "chemin d acces au wrapper",
+ ang = "wrapper library path"
+ ),
+
+ FunctionName = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom de la fonction dans le wrapper",
+ ang = "Function's name in wrapper"
+ ),
+
+ GradientName = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du gradient dans le wrapper",
+ ang = "gradient's name in wrapper"
+ ),
+
+ HessianName = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du hessian dans le wrapper",
+ ang = "hessian's name in wrapper"
+ ),
+
+ WrapCouplingMode = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "static-link", "dynamic-link", "fork", ),
+ fr = "mode de couplage du solver",
+ ang = "Solver coupling mode"
+ ),
+
+ DTDDirectory = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "repertoire de la DTD",
+ ang = "DTD directory"
+ ),
+
+ Fork = BLOC ( condition = " WrapCouplingMode in ( 'fork', ) ",
+
+ Command = SIMP ( statut = "o",
+ max = 1,
+ typ = "TXM",
+ fr = "Chemin du solver",
+ ang = "solver path"
+ ),
+ ), # Fin BLOC Fork
+
+ State = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ into = ( "shared", "specific" ),
+ fr = "partage de l etat interne entre les fonctions",
+ ang = "internal state sharing"
+ ),
+
+ InDataTransfer = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
+ fr = "mode de transfert des donnees d entree",
+ ang = "input transfering mode"
+ ),
+
+ OutDataTransfer = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
+ fr = "mode de transfert des donnees de sortie",
+ ang = "output transfering mode"
+ ),
+
+
+
+#====
+# 7. Informations sur les fichiers d'echange
+#====
+
+ Files = FACT ( statut = "f",
+ min = 1,
+ max = "**",
+
+ Id = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "Identificateur du fichier",
+ ang = "File id"
+ ),
+
+ Type = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ into = ( "in", "out", ),
+ fr = "Fichier d entree ou de sortie du solveur ?",
+ ang = "Input or Output file ?"
+ ),
+
+ Name = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "Nom du fichier",
+ ang = "file name"
+ ),
+
+ Path = SIMP ( statut = "o",
+ typ = "TXM",
+ max = 1,
+ fr = "chemin du fichier",
+ ang = "path file "
+ ),
+
+ Subst = SIMP ( statut = "f",
+ typ = "TXM",
+ max = 1,
+ fr = "liste de variables",
+ ang = "list"
+ ),
+
+ ), # Fin FACT Files
+
+); # Fin PROC STUDY
+
+Result = PROC ( nom = "RESULT",
+ op = None,
+ docu = "",
+ fr = "Liste des resultats a produire",
+ ang = "List of results to write out",
+
+ GeneralizedReliabilityIndex = SIMP ( statut = "o",
+ typ = "TXM",
+ into = ( "yes", "no" ),
+ defaut = "no",
+ max = 1,
+ fr = "Index de fiabilite generalise",
+ ang = "Generalized reliability index"
+ ),
+
+); # Fin PROC Result
+
--- /dev/null
+import os
+
+import prefs
+
+rep_cata = prefs.REPINI
+
+# Acces a la documentation
+path_doc = os.path.join(rep_cata,'Doc')
+exec_acrobat = "/usr/bin/xpdf"
+
+# Utilisateur/Developpeur
+isdeveloppeur = "NON"
+path_cata_dev = "/tmp/cata"
+
+# Repertoire temporaire
+rep_travail = "/tmp"
+
+# Repertoire initial
+initialdir=os.curdir
+
+DTDDirectory="/local/openturns/Logiciels/OpenTURNS/install/share/openturns/wrappers/"
+
+# Choix des catalogues
+rep_mat=" "
+
+catalogues = (
+# ('OPENTURNS','v0',os.path.join(rep_cata,'Open_Cata_V0.py'),'openturns'),
+ ('OPENTURNS','v1',os.path.join(rep_cata,'Open_Cata_V1.py'),'openturns'),
+ ('OPENTURNS','IDM v7',os.path.join(rep_cata,'Open_Cata_IDM_V7.py'),'openturns'),
+# ('OPENTURNS','vg',os.path.join(rep_cata,'Open_Cata_gn.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 a lancer EFICAS configure pour Code_Aster
+"""
+# Modules Python
+import sys
+
+# Modules Eficas
+import prefs
+prefs.code="OPENTURNS"
+
+sys.path[:0]=[prefs.INSTALLDIR]
+
+import InterfaceTK
+from InterfaceTK import eficas_go
+
+if len(sys.argv) > 1 :
+ # on veut ouvrir un fichier directement au lancement d'Eficas
+ eficas_go.lance_eficas(code='OPENTURNS',fichier = sys.argv[1])
+else:
+ # on veut ouvrir Eficas 'vide'
+ eficas_go.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, sys
+
+# 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"
+
+# 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'
+
+EditeurDir=INSTALLDIR+"/Editeur"
+sys.path[:0]=[INSTALLDIR]
+
+ICONDIR=os.path.join(INSTALLDIR,'Editeur','icons')
+
+# Preference
+if os.name == 'nt':
+ userprefs = os.sep.join( [ os.environ['HOMEDRIVE'], os.environ['HOMEPATH'], 'Eficas_install', 'prefs.py' ])
+else :
+ userprefs=os.path.expanduser("~/Eficas_install/prefs.py")
+
+if os.path.isfile(userprefs):
+ try:
+ execfile(userprefs)
+ except:
+ pass
+
+
+#-------------------------------------------------------------------
+# Partie pour TK
+#-------------------------------------------------------------------
+
+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
+#!/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 Openturns
+"""
+# Modules Python
+
+# Modules Eficas
+import prefs
+prefs.code="OPENTURNS"
+from InterfaceQT import eficas_go
+
+eficas_go.lance_eficas(code=prefs.code)
--- /dev/null
+# -*- coding: utf-8 -*-
+"""
+ Ce module sert à construire les distributions d'EFICAS pour Openturns
+ en fonction du tag CVS courant
+ Les distributions sont :
+ - un tar.gz pour UNIX ne contenant pas mxTextTools
+ L'utilisation de ce module est la suivante :
+ 1- Se mettre dans un répertoire de travail
+ 2- Configurer son environnement pour utiliser le référentiel CVS EFICAS
+ 3- Exporter les sources d'EficasV1 par la commande :
+ cvs export -r TAG -d Eficas_export EficasV1
+ ou TAG est le tag CVS de la version que l'on veut distribuer (par exemple V1_1p1)
+ 5- Aller dans le répertoire Eficas_export
+ 6- Executer le script sdist.py
+ python sdist.py
+ Ce qui a pour effet de creer un repertoire dist contenant la distribution
+ et de la copier dans le répertoire indiqué par dir_download s'il est accessible
+
+"""
+import os,shutil,glob,sys
+import types
+
+nom_distrib="QTEficasOpenturns_V1_0"
+path_distrib=os.path.join("dist",nom_distrib)
+path_TextTools="/home/eficas/pkg/mxTools/egenix2.0.2pourWindows/mx/TextTools"
+dir_download= "/home/eficas/WWW/telechargement/eficas"
+
+def main():
+ if os.path.isdir('dist'):shutil.rmtree('dist')
+
+ copyfiles('.',path_distrib,['LICENSE.TERMS','INSTALL','NEWS'])
+
+ copyfiles('../Editeur',os.path.join(path_distrib,'Editeur'),['*.py','faqs.txt'])
+ copyfiles('../InterfaceTK',os.path.join(path_distrib,'InterfaceTK'),['*.py','faqs.txt'])
+ copyfiles('../InterfaceQT',os.path.join(path_distrib,'InterfaceQT'),['*.py','faqs.txt'])
+ copyfiles('../Ui',os.path.join(path_distrib,'Ui'),['*.ui','makefile'])
+ copyfiles('../Openturns',os.path.join(path_distrib,'Openturns'),['*.py','*.ini'])
+ copyfiles('../Ihm',os.path.join(path_distrib,'Ihm'),['*.py'])
+ copyfiles('../Extensions',os.path.join(path_distrib,'Extensions'),['*.py'])
+ copyfiles('../Misc',os.path.join(path_distrib,'Misc'),['*.py'])
+ copyfiles('../Accas',os.path.join(path_distrib,'Accas'),['*.py'])
+ copyfiles('../Accas',os.path.join(path_distrib,'Noyau'),['*.py'])
+ copyfiles('../Accas',os.path.join(path_distrib,'Validation'),['*.py'])
+ # AIDE
+ copyfiles('../AIDE',os.path.join(path_distrib,'AIDE'),['*.py'])
+ copyfiles('../AIDE/fichiers',os.path.join(path_distrib,'AIDE','fichiers'),['*'])
+ copyfiles('.',os.path.join(path_distrib,'AIDE','fichiers'),['INSTALL','NEWS'])
+ copyfiles('../Editeur',os.path.join(path_distrib,'AIDE','fichiers'),['faqs.txt'])
+ # ______________________
+
+ copyfiles('../convert',os.path.join(path_distrib,'convert'),['*.py'])
+ copyfiles('../convert/Parserv5',os.path.join(path_distrib,'convert','Parserv5'),['*.py'])
+ copyfiles('../generator',os.path.join(path_distrib,'generator'),['*.py'])
+ copyfiles('../Editeur/icons',os.path.join(path_distrib,'Editeur','icons'),['*.gif'])
+ copyfiles('../Editeur/icons',os.path.join(path_distrib,'Editeur','icons'),['*.png'])
+ copyfiles('../Editeur/Patrons/',os.path.join(path_distrib,'Editeur','Patrons'),['*.com*'])
+ copyfiles('../Editeur/Patrons/OPENTURNS',os.path.join(path_distrib,'Editeur','Patrons','OPENTURNS'),['*.com*'])
+
+ copyfiles('../Noyau',os.path.join(path_distrib,'Noyau'),['*.py'])
+ copyfiles('../Validation',os.path.join(path_distrib,'Validation'),['*.py'])
+
+
+ tarball= maketarball('dist',nom_distrib,nom_distrib)
+ try:
+ shutil.copy(tarball,dir_download)
+ except:
+ print "Repertoire de download inconnu : ",dir_download
+
+
+
+def make_dir(dir_cible):
+ if type(dir_cible) is not types.StringType:
+ raise "make_dir : dir_cible doit etre une string (%s)" % `dir_cible`
+ head,tail=os.path.split(dir_cible)
+ tails=[tail]
+ while head and tail and not os.path.isdir(head):
+ head,tail=os.path.split(head)
+ tails.insert(0, tail)
+
+ for d in tails:
+ head = os.path.join(head, d)
+ if not os.path.isdir(head):os.mkdir(head)
+
+
+def copyfiles(dir_origin,dir_cible,listfiles):
+ if not os.path.isdir(dir_cible):make_dir(dir_cible)
+ for glob_files in listfiles:
+ for file in glob.glob(os.path.join(dir_origin,glob_files)):
+ shutil.copy(file,dir_cible)
+
+
+def maketarball(dir_trav,dir_cible,nom_tar):
+ prev=os.getcwd()
+ print prev
+ os.chdir(dir_trav)
+ os.system("tar -cf "+nom_tar+".tar "+dir_cible)
+ os.system("gzip -f9 "+nom_tar+".tar ")
+ os.chdir(prev)
+ return os.path.join(dir_trav,nom_tar+".tar.gz")
+
+
+main()
+
--- /dev/null
+# Necessaire pour compatibilite avec Aster
<rect>
<x>0</x>
<y>0</y>
- <width>413</width>
- <height>497</height>
+ <width>410</width>
+ <height>661</height>
</rect>
</property>
<property name="caption">
<cstring>TBtext</cstring>
</property>
</widget>
+ <widget class="QPushButton" row="1" column="1">
+ <property name="name">
+ <cstring>BImportSel</cstring>
+ </property>
+ <property name="text">
+ <string>Ajouter Selection</string>
+ </property>
+ </widget>
+ <widget class="QPushButton" row="2" column="1">
+ <property name="name">
+ <cstring>BImportTout</cstring>
+ </property>
+ <property name="text">
+ <string>Importer Tout</string>
+ </property>
+ </widget>
<widget class="QButtonGroup" row="1" column="0" rowspan="2" colspan="1">
<property name="name">
<cstring>BGSeparateur</cstring>
<property name="minimumSize">
<size>
<width>180</width>
- <height>100</height>
+ <height>130</height>
</size>
</property>
<property name="title">
<string>Séparateur</string>
</property>
- <widget class="QLayoutWidget">
+ <widget class="QRadioButton">
<property name="name">
- <cstring>layout1</cstring>
+ <cstring>Bvirgule</cstring>
</property>
<property name="geometry">
<rect>
- <x>17</x>
- <y>20</y>
- <width>150</width>
- <height>74</height>
+ <x>12</x>
+ <y>52</y>
+ <width>104</width>
+ <height>22</height>
</rect>
</property>
- <grid>
- <property name="name">
- <cstring>unnamed</cstring>
- </property>
- <widget class="QRadioButton" row="2" column="0">
- <property name="name">
- <cstring>BpointVirgule</cstring>
- </property>
- <property name="text">
- <string>point-virgule</string>
- </property>
- </widget>
- <widget class="QRadioButton" row="0" column="0">
- <property name="name">
- <cstring>Bespace</cstring>
- </property>
- <property name="text">
- <string>espace</string>
- </property>
- <property name="checked">
- <bool>true</bool>
- </property>
- </widget>
- <widget class="QRadioButton" row="1" column="0">
- <property name="name">
- <cstring>Bvirgule</cstring>
- </property>
- <property name="text">
- <string>virgule</string>
- </property>
- </widget>
- </grid>
+ <property name="text">
+ <string>virgule</string>
+ </property>
+ </widget>
+ <widget class="QRadioButton">
+ <property name="name">
+ <cstring>Bespace</cstring>
+ </property>
+ <property name="geometry">
+ <rect>
+ <x>12</x>
+ <y>24</y>
+ <width>104</width>
+ <height>22</height>
+ </rect>
+ </property>
+ <property name="text">
+ <string>espace</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ <widget class="QRadioButton">
+ <property name="name">
+ <cstring>BpointVirgule</cstring>
+ </property>
+ <property name="geometry">
+ <rect>
+ <x>12</x>
+ <y>80</y>
+ <width>104</width>
+ <height>22</height>
+ </rect>
+ </property>
+ <property name="text">
+ <string>point-virgule</string>
+ </property>
</widget>
- </widget>
- <widget class="QPushButton" row="2" column="1">
- <property name="name">
- <cstring>BImportTout</cstring>
- </property>
- <property name="text">
- <string>Importer Tout</string>
- </property>
- </widget>
- <widget class="QPushButton" row="1" column="1">
- <property name="name">
- <cstring>BImportSel</cstring>
- </property>
- <property name="text">
- <string>Ajouter Selection</string>
- </property>
</widget>
</grid>
</widget>
