From: Christian Caremoli <> Date: Thu, 13 Nov 2008 10:35:12 +0000 (+0000) Subject: CCAR: report version dev (branche 1_14) dans branche 1_15 X-Git-Tag: V0_a1_SEPQT4~72 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=74d964994b6ee6fde8202501dafcdc89511383df;p=tools%2Feficas.git CCAR: report version dev (branche 1_14) dans branche 1_15 --- diff --git a/Aster/Cata/cataSTA7/cata.py b/Aster/Cata/cataSTA7/cata.py index cc4ccf06..849b5c89 100644 --- a/Aster/Cata/cataSTA7/cata.py +++ b/Aster/Cata/cataSTA7/cata.py @@ -34,8 +34,8 @@ except: 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, diff --git a/Aster/Cata/cataSTA8/cata.py b/Aster/Cata/cataSTA8/cata.py index a506925a..16a7f01e 100755 --- a/Aster/Cata/cataSTA8/cata.py +++ b/Aster/Cata/cataSTA8/cata.py @@ -34,8 +34,8 @@ try: 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) diff --git a/Aster/Cata/cataSTA9/Intranet/__init__.py b/Aster/Cata/cataSTA9/Intranet/__init__.py new file mode 100644 index 00000000..88770065 --- /dev/null +++ b/Aster/Cata/cataSTA9/Intranet/__init__.py @@ -0,0 +1,19 @@ +#@ 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. +# ====================================================================== diff --git a/Aster/Cata/cataSTA9/Intranet/calc_eolienne.py b/Aster/Cata/cataSTA9/Intranet/calc_eolienne.py new file mode 100644 index 00000000..e565b6cb --- /dev/null +++ b/Aster/Cata/cataSTA9/Intranet/calc_eolienne.py @@ -0,0 +1,1722 @@ +#@ 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 : " Tout va bien.", + 1 : " Impossible de créer le répertoire de travail pour le logiciel de calcul de houle.", + 100 : " 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 " RESULTATS " + print " " + print " teta0 = ", teta0 + print " teta1 = ", teta1 + print " teta2 = ", teta2 + print " teta3 = ", teta3 + print " " + + print " ===> 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" ligne = ",ligne + if ligne[0] == "/PERIODE" and ligne[2] == "HOULE.................T........:" : + periode_houle = float(ligne[len(ligne)-2]) + + if INFO == 2 : + print " Periode de houle = ",periode_houle + + if ligne[0] == "/NB" and ligne[2] == "POINTS" : + Nb_valeur = int(ligne[len(ligne)-1]) + + if INFO == 2 : + print " Nb_valeur = ",Nb_valeur + + if ligne[0] == "/NB" and ligne[4] == "TEMPS" : + Nb_pas_temps = int(ligne[len(ligne)-1]) + + if INFO == 2 : + print " 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 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 " ==> Numero d'ordre = ", j + print " ==> hauteur_eau = ", H_IMMERGEE + +##################### +# VALEUR TEST +# +# hauteur_eau = 30. +##################### + print "\n 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 " RESULTATS " + print " " + print " teta0 = ", teta0 + print " teta1 = ", teta1 + print " teta2 = ", teta2 + print " 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)), + +); diff --git a/Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_cata.py b/Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_cata.py new file mode 100644 index 00000000..8cddc463 --- /dev/null +++ b/Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_cata.py @@ -0,0 +1,190 @@ +#@ 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), + ), + ); diff --git a/Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_ops.py b/Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_ops.py new file mode 100644 index 00000000..81d8ea32 --- /dev/null +++ b/Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_ops.py @@ -0,0 +1,555 @@ +#@ 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 diff --git a/Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_cata.py b/Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_cata.py new file mode 100644 index 00000000..6af1e04c --- /dev/null +++ b/Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_cata.py @@ -0,0 +1,92 @@ +#@ 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),), + ), + ), + ); diff --git a/Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_dat.py b/Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_dat.py new file mode 100644 index 00000000..751f4165 --- /dev/null +++ b/Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_dat.py @@ -0,0 +1,628 @@ +#@ 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} diff --git a/Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_ops.py b/Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_ops.py new file mode 100644 index 00000000..f122a995 --- /dev/null +++ b/Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_ops.py @@ -0,0 +1,459 @@ +#@ 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 diff --git a/Aster/Cata/cataSTA9/Intranet/macro_bascule_schema_ops.py b/Aster/Cata/cataSTA9/Intranet/macro_bascule_schema_ops.py new file mode 100644 index 00000000..8f763edd --- /dev/null +++ b/Aster/Cata/cataSTA9/Intranet/macro_bascule_schema_ops.py @@ -0,0 +1,296 @@ +#@ 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 diff --git a/Aster/Cata/cataSTA9/cata.py b/Aster/Cata/cataSTA9/cata.py index 9107d31c..35955bcf 100644 --- a/Aster/Cata/cataSTA9/cata.py +++ b/Aster/Cata/cataSTA9/cata.py @@ -21,8 +21,8 @@ # 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 * diff --git a/Aster/configuration.py b/Aster/configuration.py new file mode 100644 index 00000000..476be419 --- /dev/null +++ b/Aster/configuration.py @@ -0,0 +1,369 @@ +# -*- 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) + + diff --git a/Aster/editeur_salome.ini b/Aster/editeur_salome.ini index d0881d54..9805411b 100644 --- a/Aster/editeur_salome.ini +++ b/Aster/editeur_salome.ini @@ -27,7 +27,8 @@ rep_Pmw = os.path.join(prefs.REPINI,'../Pmw') # 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" @@ -42,7 +43,7 @@ rep_mat_v91=os.path.join(rep_cata,'cataSTA9','materiau') 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'), ) diff --git a/Aster/prefs.py b/Aster/prefs.py index 5fc73e58..921613fc 100644 --- a/Aster/prefs.py +++ b/Aster/prefs.py @@ -19,11 +19,13 @@ # # ====================================================================== +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 diff --git a/Aster/properties.py b/Aster/properties.py index 72607722..fc860faf 100644 --- a/Aster/properties.py +++ b/Aster/properties.py @@ -1,5 +1,4 @@ -#@ 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 @@ -20,6 +19,6 @@ # 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 diff --git a/Editeur/Patrons/OPENTURNS/Anne.comm b/Editeur/Patrons/OPENTURNS/Anne.comm new file mode 100644 index 00000000..ebb124cc --- /dev/null +++ b/Editeur/Patrons/OPENTURNS/Anne.comm @@ -0,0 +1,38 @@ + +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',),),); diff --git a/Editeur/analyse_catalogue.py b/Editeur/analyse_catalogue.py index 70d449bb..9d986ff2 100644 --- a/Editeur/analyse_catalogue.py +++ b/Editeur/analyse_catalogue.py @@ -24,8 +24,8 @@ import re,string,cPickle,os 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'] diff --git a/Editeur/listePatrons.py b/Editeur/listePatrons.py index fe54d854..eeccfb2f 100644 --- a/Editeur/listePatrons.py +++ b/Editeur/listePatrons.py @@ -2,7 +2,8 @@ import os 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 : diff --git a/Editeur/utils.py b/Editeur/utils.py index ecb01bb3..c40920a1 100644 --- a/Editeur/utils.py +++ b/Editeur/utils.py @@ -54,7 +54,7 @@ def get_rep_user(): 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 diff --git a/InterfaceQT/editor.py b/InterfaceQT/editor.py index 3e282300..f5c8762b 100644 --- a/InterfaceQT/editor.py +++ b/InterfaceQT/editor.py @@ -52,7 +52,7 @@ class JDCEditor(QSplitter): 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 @@ -267,15 +267,15 @@ class JDCEditor(QSplitter): 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 @@ -644,18 +644,17 @@ class JDCEditor(QSplitter): 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"), diff --git a/InterfaceQT/monIncludePanel.py b/InterfaceQT/monIncludePanel.py index b2e925bd..cec4661c 100644 --- a/InterfaceQT/monIncludePanel.py +++ b/InterfaceQT/monIncludePanel.py @@ -41,7 +41,7 @@ class MonIncludePanel(MonMacroPanel): 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() @@ -68,7 +68,7 @@ class MonIncludePanel(MonMacroPanel): 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) diff --git a/InterfaceQT/monOptionsEditeur.py b/InterfaceQT/monOptionsEditeur.py index 89c4510c..70c0dbdb 100644 --- a/InterfaceQT/monOptionsEditeur.py +++ b/InterfaceQT/monOptionsEditeur.py @@ -124,13 +124,13 @@ class Options(desOptions): 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() diff --git a/InterfaceQT/monPlusieursBasePanel.py b/InterfaceQT/monPlusieursBasePanel.py index 0907cbed..98a52255 100644 --- a/InterfaceQT/monPlusieursBasePanel.py +++ b/InterfaceQT/monPlusieursBasePanel.py @@ -110,11 +110,12 @@ class MonPlusieursBasePanel(DPlusBase,QTPanel,SaisieValeur): 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 diff --git a/InterfaceQT/monPlusieursIntoPanel.py b/InterfaceQT/monPlusieursIntoPanel.py index 80fa4235..4a738c7f 100644 --- a/InterfaceQT/monPlusieursIntoPanel.py +++ b/InterfaceQT/monPlusieursIntoPanel.py @@ -91,6 +91,7 @@ class MonPlusieursIntoPanel(DPlusInto,QTPanel,SaisieValeur): 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) diff --git a/InterfaceQT/monSelectVal.py b/InterfaceQT/monSelectVal.py index c3c64148..9c5c2f50 100644 --- a/InterfaceQT/monSelectVal.py +++ b/InterfaceQT/monSelectVal.py @@ -58,6 +58,7 @@ class MonSelectVal(DSelVal): 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()) @@ -70,9 +71,12 @@ class MonSelectVal(DSelVal): 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) diff --git a/InterfaceQT/qtCommun.py b/InterfaceQT/qtCommun.py index e89ffc22..99a9afca 100644 --- a/InterfaceQT/qtCommun.py +++ b/InterfaceQT/qtCommun.py @@ -311,7 +311,7 @@ class ViewText(QDialog): 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(): diff --git a/InterfaceQT/qtEficas.py b/InterfaceQT/qtEficas.py index 0e537d87..c698dd28 100644 --- a/InterfaceQT/qtEficas.py +++ b/InterfaceQT/qtEficas.py @@ -11,7 +11,7 @@ from qt import * from myMain import Eficas from viewManager import MyTabview -from Editeur import configuration +import configuration from Editeur import session import utilIcons diff --git a/InterfaceQT/viewManager.py b/InterfaceQT/viewManager.py index c4542f10..01938695 100644 --- a/InterfaceQT/viewManager.py +++ b/InterfaceQT/viewManager.py @@ -2482,10 +2482,13 @@ class MyTabview(Tabview): 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): diff --git a/InterfaceTK/catabrowser.py b/InterfaceTK/catabrowser.py index 7ce303ed..fcf48671 100644 --- a/InterfaceTK/catabrowser.py +++ b/InterfaceTK/catabrowser.py @@ -36,8 +36,8 @@ from Accas import OPER,PROC,MACRO,FORM 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 diff --git a/InterfaceTK/cataediteur.py b/InterfaceTK/cataediteur.py index e7e4499e..8d8870b1 100644 --- a/InterfaceTK/cataediteur.py +++ b/InterfaceTK/cataediteur.py @@ -39,8 +39,8 @@ from Accas import ASSD,GEOM 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 diff --git a/InterfaceTK/compomacro.py b/InterfaceTK/compomacro.py index e8f05053..6375f92b 100644 --- a/InterfaceTK/compomacro.py +++ b/InterfaceTK/compomacro.py @@ -36,8 +36,8 @@ from widgets import Fenetre,FenetreYesNo 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): diff --git a/InterfaceTK/componuplet.py b/InterfaceTK/componuplet.py index 474b643e..c962498c 100644 --- a/InterfaceTK/componuplet.py +++ b/InterfaceTK/componuplet.py @@ -30,8 +30,8 @@ from Editeur import Objecttreeitem 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() diff --git a/InterfaceTK/treewidget.py b/InterfaceTK/treewidget.py index 9768ada6..29499d13 100644 --- a/InterfaceTK/treewidget.py +++ b/InterfaceTK/treewidget.py @@ -27,8 +27,8 @@ import images 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 diff --git a/Openturns/Open_Cata_IDM_V5.py b/Openturns/Open_Cata_IDM_V5.py new file mode 100644 index 00000000..38940769 --- /dev/null +++ b/Openturns/Open_Cata_IDM_V5.py @@ -0,0 +1,1266 @@ +# -*- 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 + diff --git a/Openturns/Open_Cata_IDM_V6.py b/Openturns/Open_Cata_IDM_V6.py new file mode 100644 index 00000000..fde985de --- /dev/null +++ b/Openturns/Open_Cata_IDM_V6.py @@ -0,0 +1,1202 @@ +# -*- 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 + diff --git a/Openturns/Open_Cata_IDM_V7.py b/Openturns/Open_Cata_IDM_V7.py new file mode 100644 index 00000000..eee33278 --- /dev/null +++ b/Openturns/Open_Cata_IDM_V7.py @@ -0,0 +1,1221 @@ +# -*- 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 + diff --git a/Openturns/editeur.ini b/Openturns/editeur.ini new file mode 100644 index 00000000..65eca18b --- /dev/null +++ b/Openturns/editeur.ini @@ -0,0 +1,32 @@ +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'), + ) + diff --git a/Openturns/eficas_openturns.py b/Openturns/eficas_openturns.py new file mode 100755 index 00000000..599ad837 --- /dev/null +++ b/Openturns/eficas_openturns.py @@ -0,0 +1,43 @@ +#!/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') diff --git a/Openturns/prefs.py b/Openturns/prefs.py new file mode 100644 index 00000000..50b2a5ec --- /dev/null +++ b/Openturns/prefs.py @@ -0,0 +1,95 @@ +# -*- 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',''), + ('Ouvrir','openJDC',''), + ('Enregistrer','saveJDC',''), + ('Enregistrer sous','saveasJDC',''), + None, + ('Fermer','closeJDC',''), + ('Quitter','exitEFICAS',''), + ] + ), + ('Edition',[ + ('Copier','copy',''), + ('Couper','cut',''), + ('Coller','paste',''), + ] + ), + ('Jeu de commandes',[ + ('Rapport de validation','visuCRJDC',''), + ('Fichier à plat','visu_a_plat',''), + ] + ), + ] + } + diff --git a/Openturns/properties.py b/Openturns/properties.py new file mode 100644 index 00000000..8ba0ed7e --- /dev/null +++ b/Openturns/properties.py @@ -0,0 +1,25 @@ +# -*- coding: utf-8 -*- +#@ MODIF properties Accas DATE 10/10/2002 AUTEUR gcbhhhh M.ADMINISTRATEUR +# CONFIGURATION MANAGEMENT OF EDF VERSION +# RESPONSABLE D6BHHHH J-P.LEFEBVRE +# ====================================================================== +# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# IDENTIFICATION DU GESTIONNAIRE DE COMMANDE ACCAS A PARTIR +# DE LA VERSION DU CODE_ASTER ASSOCIE +#---------------------------------------------------------------------- +version = "7.1.0" +date = "23/04/2003" diff --git a/Openturns/qtEficas_openturns.py b/Openturns/qtEficas_openturns.py new file mode 100755 index 00000000..ea0782e2 --- /dev/null +++ b/Openturns/qtEficas_openturns.py @@ -0,0 +1,33 @@ +#!/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) diff --git a/Openturns/sdistOTqt.py b/Openturns/sdistOTqt.py new file mode 100644 index 00000000..acf75c26 --- /dev/null +++ b/Openturns/sdistOTqt.py @@ -0,0 +1,103 @@ +# -*- 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() + diff --git a/Openturns/style.py b/Openturns/style.py new file mode 100644 index 00000000..7da9d534 --- /dev/null +++ b/Openturns/style.py @@ -0,0 +1 @@ +# Necessaire pour compatibilite avec Aster diff --git a/Ui/desSelectVal.ui b/Ui/desSelectVal.ui index ae092f56..f77f36c1 100644 --- a/Ui/desSelectVal.ui +++ b/Ui/desSelectVal.ui @@ -8,8 +8,8 @@ 0 0 - 413 - 497 + 410 + 661 @@ -24,6 +24,22 @@ TBtext + + + BImportSel + + + Ajouter Selection + + + + + BImportTout + + + Importer Tout + + BGSeparateur @@ -31,73 +47,63 @@ 180 - 100 + 130 Séparateur - + - layout1 + Bvirgule - 17 - 20 - 150 - 74 + 12 + 52 + 104 + 22 - - - unnamed - - - - BpointVirgule - - - point-virgule - - - - - Bespace - - - espace - - - true - - - - - Bvirgule - - - virgule - - - + + virgule + + + + + Bespace + + + + 12 + 24 + 104 + 22 + + + + espace + + + true + + + + + BpointVirgule + + + + 12 + 80 + 104 + 22 + + + + point-virgule + - - - - BImportTout - - - Importer Tout - - - - - BImportSel - - - Ajouter Selection -