From 5196279b0c6d1ecd53fd76149526313f96d78db3 Mon Sep 17 00:00:00 2001 From: Christian Caremoli <> Date: Fri, 13 Jun 2008 14:31:32 +0000 Subject: [PATCH] CCAR: ajout nouveaux fichiers catalogue --- Aster/Cata/cataSTA9/Intranet/__init__.py | 19 + Aster/Cata/cataSTA9/Intranet/calc_eolienne.py | 1722 +++++++++++++++++ .../cataSTA9/Intranet/macr_cabri_calc_cata.py | 190 ++ .../cataSTA9/Intranet/macr_cabri_calc_ops.py | 555 ++++++ .../cataSTA9/Intranet/macr_cabri_mail_cata.py | 92 + .../cataSTA9/Intranet/macr_cabri_mail_dat.py | 628 ++++++ .../cataSTA9/Intranet/macr_cabri_mail_ops.py | 459 +++++ .../Intranet/macro_bascule_schema_ops.py | 296 +++ .../Cata/cataSTA9/Macro/dyna_iss_vari_ops.py | 349 ++++ Aster/Cata/cataSTA9/Messages/algorith17.py | 28 + Aster/Cata/cataSTA9/Messages/archivage.py | 37 + .../Cata/cataSTA9/Messages/discretisation.py | 97 + Aster/Cata/cataSTA9/Messages/mecanonline3.py | 77 + Aster/Cata/cataSTA9/Messages/mecanonline4.py | 85 + Aster/Cata/cataSTA9/Messages/mecanonline5.py | 59 + Aster/Cata/cataSTA9/Messages/observation.py | 92 + Aster/Cata/cataSTA9/Messages/rupture1.py | 233 +++ Aster/Cata/cataSTA9/Messages/seisme.py | 155 ++ Aster/Cata/cataSTA9/Messages/unilater.py | 35 + Aster/Cata/cataSTA9/Messages/vide.py | 26 + Aster/Cata/cataSTA9/Messages/volufini.py | 52 + Aster/Cata/cataSTA9/SD/co_table_container.py | 29 + Aster/Cata/cataSTA9/SD/sd_table_container.py | 81 + 23 files changed, 5396 insertions(+) create mode 100644 Aster/Cata/cataSTA9/Intranet/__init__.py create mode 100644 Aster/Cata/cataSTA9/Intranet/calc_eolienne.py create mode 100644 Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_cata.py create mode 100644 Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_ops.py create mode 100644 Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_cata.py create mode 100644 Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_dat.py create mode 100644 Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_ops.py create mode 100644 Aster/Cata/cataSTA9/Intranet/macro_bascule_schema_ops.py create mode 100644 Aster/Cata/cataSTA9/Macro/dyna_iss_vari_ops.py create mode 100644 Aster/Cata/cataSTA9/Messages/algorith17.py create mode 100644 Aster/Cata/cataSTA9/Messages/archivage.py create mode 100644 Aster/Cata/cataSTA9/Messages/discretisation.py create mode 100644 Aster/Cata/cataSTA9/Messages/mecanonline3.py create mode 100644 Aster/Cata/cataSTA9/Messages/mecanonline4.py create mode 100644 Aster/Cata/cataSTA9/Messages/mecanonline5.py create mode 100644 Aster/Cata/cataSTA9/Messages/observation.py create mode 100644 Aster/Cata/cataSTA9/Messages/rupture1.py create mode 100644 Aster/Cata/cataSTA9/Messages/seisme.py create mode 100644 Aster/Cata/cataSTA9/Messages/unilater.py create mode 100644 Aster/Cata/cataSTA9/Messages/vide.py create mode 100644 Aster/Cata/cataSTA9/Messages/volufini.py create mode 100644 Aster/Cata/cataSTA9/SD/co_table_container.py create mode 100644 Aster/Cata/cataSTA9/SD/sd_table_container.py 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/Macro/dyna_iss_vari_ops.py b/Aster/Cata/cataSTA9/Macro/dyna_iss_vari_ops.py new file mode 100644 index 00000000..32475ab1 --- /dev/null +++ b/Aster/Cata/cataSTA9/Macro/dyna_iss_vari_ops.py @@ -0,0 +1,349 @@ +#@ MODIF dyna_iss_vari_ops Macro DATE 21/04/2008 AUTEUR ZENTNER I.ZENTNER +# -*- 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 Accas import _F +import string +from Utilitai.Utmess import UTMESS + +def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNITE_RESU_FORC, + NB_FREQ, PAS, UNITE_RESU_IMPE, TYPE, MATR_GENE ,INFO, + **args): + """ + Macro DYNA_ISS_VARI + """ + ier=0 + import Numeric as Num + import LinearAlgebra as LinAl + import MLab + import os + import aster + diag = MLab.diag + max = MLab.max + min = MLab.min + sum = Num.sum + abs = Num.absolute + conj = Num.conjugate + from Utilitai.Table import Table + + def get_group_coord(group): + """Retourne les coordonnees des noeuds du groupe 'group' + """ + l_ind = Num.array(coll_grno.get('%-8s' % group, [])) - 1 + return Num.take(t_coordo, l_ind) + + + # On importe les definitions des commandes a utiliser dans la macro + + COMB_MATR_ASSE = self.get_cmd('COMB_MATR_ASSE') + LIRE_IMPE_MISS = self.get_cmd('LIRE_IMPE_MISS') + LIRE_FORC_MISS = self.get_cmd('LIRE_FORC_MISS') + COMB_MATR_ASSE = self.get_cmd('COMB_MATR_ASSE') + + CREA_CHAMP = self.get_cmd('CREA_CHAMP') + DYNA_LINE_HARM = self.get_cmd('DYNA_LINE_HARM') + DETRUIRE= self.get_cmd('DETRUIRE') + + DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') + CREA_TABLE = self.get_cmd('CREA_TABLE') + + # Comptage commandes + declaration concept sortant + self.set_icmd(1) + self.DeclareOut('tab_out', self.sd) + macro='DYNA_ISS_VARI' +#-------------------------------------------------------- + dgene = MATR_GENE[0].cree_dict_valeurs(MATR_GENE[0].mc_liste) + if dgene['MATR_AMOR'] != None: + aster.affiche('MESSAGE',' MATR_AMOR existe') + __ma_amort = MATR_GENE['MATR_AMOR'] + else: + __ma_amort=COMB_MATR_ASSE(CALC_AMOR_GENE=_F(MASS_GENE = MATR_GENE['MATR_MASS'] , + RIGI_GENE = MATR_GENE['MATR_RIGI'] , + AMOR_REDUIT= ( 0.0,), + ), + ); + aster.affiche('MESSAGE',' MATR_AMOR pas donnee, on prend AMOR_REDUIT=0.0,') +# dint = INTERF[0].cree_dict_valeurs(INTERF[0].mc_liste) +# dcoh = MATR_COHE[0].cree_dict_valeurs(MATR_COHE[0].mc_liste) + + from SD.sd_maillage import sd_maillage + from SD.sd_base_modale import sd_base_modale + from SD.sd_resultat import sd_resultat + from SD.sd_cham_gene import sd_cham_gene + # MAILLAGE + nom_bamo = MATR_GENE['MATR_RIGI'].REFA.get()[0] + nume_ddl = aster.getvectjev(nom_bamo[0:8] + ' .REFD ' )[3] + nom_mail = aster.getvectjev( nume_ddl[0:19] + '.REFN ' )[0] + num_mail = sd_maillage(nom_mail) + # MODELE, DDLGENE + nom_ddlgene = MATR_GENE['MATR_RIGI'].REFA.get()[1] + nom_modele = aster.getvectjev( nume_ddl[0:19] + '.LILI ' )[1] + nume_resu = self.jdc.sds_dict[string.strip(nom_bamo)] + nume_ddlgene = self.jdc.sds_dict[string.strip(nom_ddlgene)] + nume_modele = self.jdc.sds_dict[string.strip(nom_modele[0:8])] + + #TEST base modale + nom_bamo1 = MATR_GENE['MATR_MASS'].REFA.get()[0] + nom_bamo2 = MATR_GENE['MATR_RIGI'].REFA.get()[0] + if string.strip(nom_bamo) != string.strip(nom_bamo1) or string.strip(nom_bamo) != string.strip(nom_bamo2) or string.strip(nom_bamo1) != string.strip(nom_bamo2): + UTMESS('F','ALGORITH5_42') + + + nbnot, nbl, nbma, nbsm, nbsmx, dime = num_mail.DIME.get() + + # coordonnees des noeuds + l_coordo = num_mail.COORDO.VALE.get() + t_coordo = Num.array(l_coordo) + t_coordo.shape = nbnot, 3 + # groupes de noeuds + coll_grno = num_mail.GROUPENO.get() + GROUP_NO_INTER=INTERF['GROUP_NO_INTERF'] + noe_interf = get_group_coord(GROUP_NO_INTER) + # print noe_interf + nbno, nbval = noe_interf.shape + if INFO==2: + aster.affiche('MESSAGE','NBNO INTERFACE : '+str(nbno)) + # MODES + nbval, nbmodt,nbmodd,nbmods = nume_resu.UTIL.get() + + + nbmodt2 = MATR_GENE['MATR_RIGI'].DESC.get()[1] + if nbmodt2 != nbmodt: + UTMESS('F','ALGORITH5_42') + + if INFO==2: + texte = 'NOMBRE DE MODES: '+str(nbmodt)+' MODES DYNAMIQUES: '+str(nbmodd)+' MODES STATIQUES: '+str(nbmods) + aster.affiche('MESSAGE',texte) + aster.affiche('MESSAGE','COMPOSANTE '+NOM_CMP) + SPEC = Num.zeros((NB_FREQ,nbmodt,nbmodt), Num.Float)+1j +# +#--------------------------------------------------------------------- + # BOUCLE SUR LES FREQUENCES + VITE_ONDE = MATR_COHE['VITE_ONDE'] + alpha = MATR_COHE['PARA_ALPHA'] + abscisse = [None]*NB_FREQ + + for k in range(0,NB_FREQ): + freqk=FREQ_INIT+PAS*k + aster.affiche('MESSAGE','FREQUENCE DE CALCUL: '+str(freqk)) + + # Matrice de coherence + XX=noe_interf[:,0] + YY=noe_interf[:,1] + + XN=Num.repeat(XX,nbno) + YN=Num.repeat(YY,nbno) + XR=Num.reshape(XN,(nbno,nbno)) + YR=Num.reshape(YN,(nbno,nbno)) + XRT=Num.transpose(XR) + YRT=Num.transpose(YR) + DX=XR-XRT + DY=YR-YRT + DIST=DX**2+DY**2 + COHE=Num.exp(-(DIST*(alpha*freqk/VITE_ONDE)**2.)) + + # On desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas + aster.matfpe(-1) + eig, vec =LinAl.eigenvectors(COHE) + aster.matfpe(1) + eig=eig.real + vec=vec.real + # on rearrange selon un ordre decroissant + eig = Num.where(eig < 1.E-10, 0.0, eig) + order = (Num.argsort(eig)[::-1]) + eig = Num.take(eig, order) + vec = Num.take(vec, order, 0) + + #----------------------- + # Nombre de modes POD a retenir + etot=sum(diag(COHE)) + ener=0.0 + nbme=0 + + if INFO==2: + aster.affiche('MESSAGE','ETOT :'+str(etot)) + while nbme < nbno: + ener= eig[nbme]+ener + prec=ener/etot + nbme=nbme+1 + if INFO==2: + aster.affiche('MESSAGE','VALEUR PROPRE '+str(nbme)+' : '+str(eig[nbme-1])) + if prec > PRECISION : + break + + aster.affiche('MESSAGE','NOMBRE DE MODES POD RETENUS : '+str(nbme)) + aster.affiche('MESSAGE','PRECISION (ENERGIE RETENUE) : '+str(prec)) + + PVEC=Num.zeros((nbme,nbno), Num.Float) + for k1 in range(0,nbme): + PVEC[k1, 0:nbno]=Num.sqrt(eig[k1])*vec[k1] + # CALCUL DE FS variable------------------------------- + XO=Num.zeros((nbme,nbmods), Num.Float) + if NOM_CMP=='DX': + COMP = 1 + elif NOM_CMP=='DY': + COMP = 2 + elif NOM_CMP=='DZ': + COMP = 3 + + #---------MODES interface + # ----- boucle sur les modes statiques + for mods in range(0,nbmods): + nmo = nbmodd+mods+1 + __CHAM=CREA_CHAMP( TYPE_CHAM='NOEU_DEPL_R', + OPERATION='EXTR', + NUME_ORDRE=nmo, + RESULTAT = nume_resu , + NOM_CHAM = 'DEPL' + ); + MCMP =__CHAM.EXTR_COMP(NOM_CMP,[GROUP_NO_INTER]).valeurs + + NNO =__CHAM.EXTR_COMP(NOM_CMP,[GROUP_NO_INTER], topo=1).noeud + + + som=sum(MCMP) + max1=max(MCMP) + min1=min(MCMP) + maxm=max([abs(max1),abs(min1)]) + #CALCUL DE XO +# on recupere la composante COMP (dx,dy,dz) des modes et on projete + # CAS 1: MODES DE CORPS RIGIDE + if INTERF['MODE_INTERF'] =='CORP_RIGI': + for modp in range(0,nbme): + #modes de translation + if mods+1 <=3: + if abs(som)<10.E-6: + XO[modp,mods]=0.0 + else : + fact=1./som + XO[modp,mods]=fact*Num.innerproduct(MCMP,PVEC[modp]) + #modes de rotation + else: + if maxm<10.E-6: + if som<10.E-6: + XO[modp,mods]=0.0 + else : + UTMESS('F','ALGORITH6_86') + else : + fact = 1./(nbno) + XO[modp,mods]=1./(maxm**2.)*fact*Num.innerproduct(MCMP,PVEC[modp]) + + # CAS 2: MODES EF + if INTERF['MODE_INTERF'] =='TOUT': + for modp in range(0,nbme): + if abs(som)<10.E-6: + if maxm<10.E-6: + XO[modp,mods]=0.0 + else: + UTMESS('F','UTILITAI5_89') + else: + fact=1./som + XO[modp,mods]=fact*Num.innerproduct(MCMP,PVEC[modp]) + + DETRUIRE(CONCEPT=_F(NOM=(__CHAM)),INFO=1) + + #----Impedances etc.----------------------------------------------------------------- + + if k>0: + DETRUIRE(CONCEPT=_F(NOM=(__impe,__fosi,__rito)),INFO=1) + + __impe = LIRE_IMPE_MISS(BASE=nume_resu, + TYPE=TYPE, + NUME_DDL_GENE=nume_ddlgene, + UNITE_RESU_IMPE= UNITE_RESU_IMPE, + FREQ_EXTR=freqk, + ); + __rito=COMB_MATR_ASSE(COMB_C=( + _F(MATR_ASSE=__impe, + COEF_C=1.0+0.j,), + _F(MATR_ASSE=MATR_GENE['MATR_RIGI'], + COEF_C=1.0+0.j,), + ), + SANS_CMP='LAGR', + ); + __fosi = LIRE_FORC_MISS(BASE=nume_resu, + NUME_DDL_GENE=nume_ddlgene, + NOM_CMP=NOM_CMP, + NOM_CHAM='DEPL', + UNITE_RESU_FORC = UNITE_RESU_FORC, + FREQ_EXTR=freqk,); + # impedance + MIMPE=__impe.EXTR_MATR_GENE() + # extraction de la partie modes interface + KRS = MIMPE[nbmodd:nbmodt,nbmodd:nbmodt] + + # force sismique pour verif +# FS0=__fosi.EXTR_VECT_GENE_C() +# FSE=FS0[nbmodd:nbmodt][:] + SP=Num.zeros((nbmodt,nbmodt),Num.Float) + for k1 in range(0,nbme): + # calcul de la force sismique mode POD par mode POD + FS = Num.matrixmultiply(KRS,XO[k1]) + Fzero=Num.zeros((1,nbmodd),Num.Float) + FS2=Num.concatenate((Fzero,Num.reshape(FS,(1,nbmods))),1) + # Calcul harmonique + __fosi.RECU_VECT_GENE_C(FS2[0]) + __dyge = DYNA_LINE_HARM(MODELE= nume_modele, + MATR_MASS = MATR_GENE['MATR_MASS'], + MATR_RIGI = __rito, + FREQ = freqk, + MATR_AMOR = __ma_amort, + EXCIT =_F ( VECT_ASSE = __fosi, + COEF_MULT= 1.0, + ), + ); + # recuperer le vecteur modal depl calcule par dyge + desc = __dyge.DESC.get() + assert desc[0].strip() == 'DEPL', 'Champ DEPL non trouvé' + nomcham = __dyge.TACH.get()[1][0].strip() + cham = sd_cham_gene(nomcham) + RS = Num.array(cham.VALE.get()) + SP=SP+RS*conj(RS[:,Num.NewAxis]) + DETRUIRE(CONCEPT=_F(NOM=(__dyge)),INFO=1) + + + SPEC[k]=SP + + abscisse[k]= freqk +##--------------------------------------------------------------------- +# Ecriture des tables +#--------------------------------------------------------------------- +# ------ CREATION DE L OBJET TABLE + tab = Table() + tab.append({'NOM_CHAM' : 'DSP', 'OPTION' : 'TOUT', 'DIMENSION' : nbmodt}) + foncc=Num.array([None]*NB_FREQ*3) + for k2 in range(nbmodt): + for k1 in range(k2+1): + ks=0 + for k in range(NB_FREQ) : + foncc[ks]=abscisse[k] + foncc[ks+1]= SPEC[k][k1,k2].real + foncc[ks+2]= SPEC[k][k1,k2].imag + ks=ks+3 + _f = DEFI_FONCTION(NOM_PARA='FREQ', + NOM_RESU='SPEC', + VALE_C = foncc.tolist() ) + + # Ajout d'une ligne dans la Table + tab.append({'NUME_ORDRE_I' : k1+1, 'NUME_ORDRE_J' : k2+1, 'FONCTION_C' : _f.nom}) + + + # Creation du concept en sortie + tab_out = CREA_TABLE(TYPE_TABLE='TABLE_FONCTION', + **tab.dict_CREA_TABLE()) + return ier diff --git a/Aster/Cata/cataSTA9/Messages/algorith17.py b/Aster/Cata/cataSTA9/Messages/algorith17.py new file mode 100644 index 00000000..8cfe79e1 --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/algorith17.py @@ -0,0 +1,28 @@ +#@ MODIF algorith17 Messages DATE 23/10/2007 AUTEUR BOITEAU O.BOITEAU +# -*- 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 _(x) : return x + +cata_msg={ +1: _(""" + Solveur linéaire MUMPS distribué, routine CRESOL. + Le processeur de rang %(i1)d ne s'est vu attribuer aucune maille physique + du modèle! +"""), +} diff --git a/Aster/Cata/cataSTA9/Messages/archivage.py b/Aster/Cata/cataSTA9/Messages/archivage.py new file mode 100644 index 00000000..44a42452 --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/archivage.py @@ -0,0 +1,37 @@ +#@ MODIF archivage Messages DATE 11/03/2008 AUTEUR CNGUYEN C.NGUYEN +# -*- 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 _(x) : return x + +cata_msg = { + +95 : _(""" +Accès par instant sans évolution ordonnée interdit (ARCHIVAGE) +"""), + +97 : _(""" +L'archivage va écraser des instants déjà calculés (ARCHIVAGE) +"""), + +98 : _(""" +L'archivage va laisser des trous dans la sd EVOL_NOLI (ARCHIVAGE, NUME_INIT) +"""), + +} diff --git a/Aster/Cata/cataSTA9/Messages/discretisation.py b/Aster/Cata/cataSTA9/Messages/discretisation.py new file mode 100644 index 00000000..437f2dc6 --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/discretisation.py @@ -0,0 +1,97 @@ +#@ MODIF discretisation Messages DATE 19/12/2007 AUTEUR ABBAS M.ABBAS +# -*- 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 _(x) : return x + +cata_msg = { + +1 : _(""" +Certains pas de temps de la liste (LISTE_INST) sont plus petits + que le pas de temps minimal renseigné (SUBD_PAS_MINI) +"""), + +2 : _(""" + il faut donner SUBD_NIVEAU et/ou SUBD_PAS_MINI +"""), + +3 : _(""" + le nombre de subdivisions du pas de temps doit etre plus grand que 1 (SUBD_PAS) +"""), + +6 : _(""" + valeur de SUBD_ITER_IGNO incoherent avec ITER_GLOB_MAXI. + augmentez ITER_GLOB_MAXI +"""), + +7 : _(""" + valeur de SUBD_ITER_FIN incoherent avec ITER_GLOB_MAXI. + augmentez ITER_GLOB_MAXI +"""), + + +86 : _(""" +Il n'y a aucun instant de calcul ('LIST_INST' absent). +"""), + +87 : _(""" +La liste d'instants n'est pas croissante. +"""), + +88 : _(""" +Vous tentez d'accéder à l'instant initial ou final, alors que vous +n'avez pas une évolution ordonnée (EVOLUTION='SANS') +"""), + +89 : _(""" +Instant initial introuvable dans la liste d'instants (LIST_INST). +"""), + +90 : _(""" +Instant final introuvable dans la liste d'instants (LIST_INST). +"""), + +91 : _(""" + NUME_INST_INIT plus petit que NUME_INST_FIN avec EVOLUTION: 'RETROGRADE' +"""), + +92 : _(""" + NUME_INST_INIT plus grand que NUME_INST_FIN +"""), + +93: _(""" + NUME_INST_INIT n'appartient pas à la liste d'instants +"""), + +94 : _(""" + -> Le numéro d'ordre correspondant à l'instant final de calcul NUME_INST_FIN + n'appartient pas à la liste des numéros d'ordre. + Dans ce cas, Aster considère pour numéro d'ordre final, le dernier de + la liste fournie. + -> Risque & Conseil : + Afin d'éviter des pertes de résultats, assurez-vous que le numéro d'ordre + associé à l'instant NUME_INST_FIN appartienne bien à la liste des numéros + d'ordre. +"""), + +99 : _(""" +Le nombre de niveau de subdivisions doit etre plus grand que 1 (SUBD_NIVEAU) +"""), + +} diff --git a/Aster/Cata/cataSTA9/Messages/mecanonline3.py b/Aster/Cata/cataSTA9/Messages/mecanonline3.py new file mode 100644 index 00000000..04d7e737 --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/mecanonline3.py @@ -0,0 +1,77 @@ +#@ MODIF mecanonline3 Messages DATE 19/12/2007 AUTEUR ABBAS M.ABBAS +# -*- 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 _(x) : return x + +cata_msg = { + +70 : _(""" + macro_element statique et FETI incompatibles +"""), + +71 : _(""" + chargement onde plane et FETI incompatibles +"""), + +72 : _(""" + forces fluides sur les grappes et FETI incompatibles +"""), + +73 : _(""" + forces d'inertie et FETI incompatibles +"""), + +75 : _(""" + forces d'inertie derivées et FETI incompatibles +"""), + +78 : _(""" + FETI et contact discret incompatibles ! +"""), + +89 : _(""" + contact et recherche linéaire peuvent poser des problèmes de convergence +"""), + +90 : _(""" + la combinaison: contact-frottement et solveur GCPC n'est pas disponible. +"""), + +91 : _(""" + contact méthode continue et recherche linéaire sont incompatibles +"""), + +92 : _(""" + contact méthode continue et pilotage sont incompatibles +"""), + +93 : _(""" + la combinaison: méthode continue en contact et solveur GCPC n'est pas disponible. +"""), + +94 : _(""" + LIAISON_UNILATER et PILOTAGE sont des fonctionnalités incompatibles +"""), + +95 : _(""" + LIAISON_UNILATER et recherche linéaire peuvent poser des problèmes de convergence +"""), + +} diff --git a/Aster/Cata/cataSTA9/Messages/mecanonline4.py b/Aster/Cata/cataSTA9/Messages/mecanonline4.py new file mode 100644 index 00000000..f5df9811 --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/mecanonline4.py @@ -0,0 +1,85 @@ +#@ MODIF mecanonline4 Messages DATE 12/02/2008 AUTEUR ABBAS M.ABBAS +# -*- 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 _(x) : return x + +cata_msg = { + +3 : _(""" +Il y a trop de colonnes de SUIVI_DDL (limité à quatre) +"""), + +5 : _(""" +Le fichier pour le SUIVI_DDL doit etre défini dans la première occurrence +"""), + +6 : _(""" +Le fichier pour le SUIVI_DDL a été donné sans unité logique +"""), + +21 : _(""" +Le format est trop grand pour la largeur max. d'une colonne (16) +"""), + + +35 : _(""" + On utilise MECA_NON_LINE en enrichissant les résultats (REUSE). + Mais on ne définit pas d'état initial: on prend un état initial nul. +"""), + +37 : _(""" + On ne trouve aucun numéro d'ordre pour le concept EVOl_NOLI de nom <%(k1)s> +"""), + +41 : _(""" + Le champ des déplacements (ou sa dérivée pour la sensibilité) n'a pas été trouvé + dans le concept EVOL_NOLI de nom <%(k1)s> +"""), + +42 : _(""" + Le champ des contraintes (ou sa dérivée pour la sensibilité) n'a pas été trouvé + dans le concept EVOL_NOLI de nom <%(k1)s> +"""), + +43 : _(""" + Le champ des vitesses (ou sa dérivée pour la sensibilité) n'a pas été trouvé + dans le concept EVOL_NOLI de nom <%(k1)s> + On suppose qu'on part d'un champ de vitesses nulles. +"""), + +44 : _(""" + Le champ des accélérations (ou sa dérivée pour la sensibilité) n'a pas été trouvé + dans le concept EVOL_NOLI de nom <%(k1)s> + On calcule un champ d'accélérations initiales, ce qui est possible puisque les vitesses initiales sont nulles +"""), + +45 : _(""" + Le champ des accélérations (ou sa dérivée pour la sensibilité) n'a pas été trouvé + dans le concept EVOL_NOLI de nom <%(k1)s> + On ne peut pas calculer un champ d'accélérations initiales, car les vitesses initiales ne sont pas nulles +"""), + +46 : _(""" + Le champ des variables internes (ou sa dérivée pour la sensibilité) n'a pas été trouvé + dans le concept EVOL_NOLI de nom <%(k1)s> +"""), + + +} diff --git a/Aster/Cata/cataSTA9/Messages/mecanonline5.py b/Aster/Cata/cataSTA9/Messages/mecanonline5.py new file mode 100644 index 00000000..64fb667d --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/mecanonline5.py @@ -0,0 +1,59 @@ +#@ MODIF mecanonline5 Messages DATE 19/05/2008 AUTEUR ABBAS M.ABBAS +# -*- 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 _(x) : return x + +cata_msg = { + + +21 : _(""" + -> Critère de convergence est lache ! + -> Risque & Conseil : La valeur de RESI_GLOB_RELA est supérieure à 10-4. + Cela peut nuire à la qualité de la solution. Vous ne vérifiez pas l'équilibre de + manière rigoureuse. +"""), + +44 : _(""" +Pour la prédiction de type 'DEPL_CALCULE', il faut obligatoirement: + - ITER_GLOB_MAXI = 0 + - ARRET = 'NON' +"""), + +45 : _(""" +Il faut préciser un concept EVOL_NOLI en prédiction de type 'DEPL_CALCULE' +"""), + +46 : _(""" + -> La définition des paramètres RHO_MIN et RHO_EXCL est contradictoire. + On choisit de prendre RHO_MIN à RHO_EXCL. + -> Risque & Conseil : + RHO_MIN ne doit pas etre compris entre -RHO_EXCL et RHO_EXCL + +"""), + +47 : _(""" + -> La définition des paramètres RHO_MAX et RHO_EXCL est contradictoire. + On choisit de prendre RHO_MAX à -RHO_EXCL. + -> Risque & Conseil : + RHO_MAX ne doit pas etre compris entre -RHO_EXCL et RHO_EXCL + +"""), + +} diff --git a/Aster/Cata/cataSTA9/Messages/observation.py b/Aster/Cata/cataSTA9/Messages/observation.py new file mode 100644 index 00000000..2c8ad16d --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/observation.py @@ -0,0 +1,92 @@ +#@ MODIF observation Messages DATE 19/12/2007 AUTEUR ABBAS M.ABBAS +# -*- 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 _(x) : return x + +cata_msg = { + +1 : _(""" + l'entité %(k1)s n'est pas possible %(k2)s +"""), + +2 : _(""" + erreur dans les données d'observation + le noeud %(k1)s n'existe pas dans %(k2)s +"""), + +3 : _(""" + erreur dans les données d'observation + le GROUP_NO %(k1)s n'existe pas dans %(k2)s +"""), + +4 : _(""" + erreur dans les données d'observation + la maille %(k1)s n'existe pas dans %(k2)s +"""), + +5 : _(""" + erreur dans les données d'observation + le GROUP_MA %(k1)s n'existe pas dans %(k2)s +"""), + +6 : _(""" + erreur dans les données d'observation + pour "NOM_CHAM" %(k1)s , il faut renseigner %(k2)s ou %(k3)s +"""), + +7 : _(""" + erreur dans les données d'observation + pour "NOM_CHAM" %(k1)s , il faut renseigner %(k2)s et %(k3)s +"""), + +45 : _(""" + le champ absolu n'est accessible qu'en présence de modes statiques +"""), + +49 : _(""" + il faut definir "LIST_ARCH" ou "LIST_INST" ou "INST" ou "PAS_OBSE" + au premier mot cle facteur "OBSERVATION" +"""), + +50 : _(""" + seule la valeur de "LIST_ARCH" ou "LIST_INST" ou "INST" ou "PAS_OBSE" + du premier mot cle facteur "OBSERVATION" est prise en compte +"""), + +79 : _(""" + DDL inconnu sur le noeud ou la maille specifiée pour le suivi +"""), + +85 : _(""" +Le nombre de SUIVI_DDL est limité à 4. +"""), + +86 : _(""" +Mélange de champs de nature différente dans le meme mot-clé facteur SUIVI. +"""), + +87 : _(""" +Mélange de champs de nature différente dans le meme mot-clé facteur OBSERVATION +"""), + +99: _(""" + le champ %(k1)s est incompatible avec la commande %(k2)s +"""), + +} diff --git a/Aster/Cata/cataSTA9/Messages/rupture1.py b/Aster/Cata/cataSTA9/Messages/rupture1.py new file mode 100644 index 00000000..b4ddcdfc --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/rupture1.py @@ -0,0 +1,233 @@ +#@ MODIF rupture1 Messages DATE 04/02/2008 AUTEUR GALENNE E.GALENNE +# -*- 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 _(x) : return x + +cata_msg={ +1: _(""" +L'option de lissage 'LAGRANGE_REGU' n'a pas été développée lorsque +le nombre de noeuds d'un fond de fissure fermé est pair. +-> Risque et Conseil : +Veuillez utiliser une autre option de lissage +(par exemple, le lissage 'LAGRANGE' pour le champ theta) +"""), + +2: _(""" +%(k1)s n'est pas un GROUP_NO ou un GROUP_MA. +"""), + +6: _(""" +Le rayon R_SUP (ou R_SUP_FO) doit obligatoirement etre supérieur au rayon +R_INF (resp. R_INF_FO). +-> Risque et Conseil : +Veuillez revoir votre mise en données. +"""), + +7: _(""" +Problème dans RINF et RSUP. +-> Risque et Conseil : +Veuillez revoir les valeurs fournies aux mots-clés R_INF ou R_INF_FO +ou R_SUP ou R_SUP_FO. +"""), + +8: _(""" +Le groupe %(k1)s n'appartient pas au maillage : %(k2)s +"""), + +9: _(""" +Le fond de fissure n'est pas complet. +-> Risque et Conseil : +Veuillez revoir la mise en données de l'opérateur DEFI_FOND_FISS. +"""), + +10: _(""" +Le fond de fissure ne doit etre défini que par un noeud. +-> Risque et Conseil : +Veuillez revoir le contenu du mot-clé GROUP_NO ou NOEUD ou FOND_FISS. +"""), + +11: _(""" +Il faut un mot clé parmis FOND_FISS ou FISSURE pour l'option %(k1)s +Veuillez le renseigner. +"""), + +12: _(""" +Aucun champ initial trouvé. +"""), + +13: _(""" +%(k1)s : champ initial impossible avec cette option. +"""), + +14: _(""" +Nombre de bornes erroné. +-> Risque et Conseil : +On doit en avoir autant que de numéros d'ordre. +"""), + +15: _(""" +Le résultat n'est pas un EVOL_NOLI. +"""), + +16: _(""" +Le champ %(k1)s n'a pas été trouvé. +"""), + +17: _(""" +L'association: lissage du champ THETA par les polynomes de Lagrange + lissage de G autre que par des polynomes de Lagrange +n'est pas possible. +-> Risque et Conseil : +Veuillez consulter la documentation U4.82.03 pour déterminer une +association satisfaisante. +"""), + +19: _(""" +Il faut définir la normale au fond de fissure. +-> Risque et Conseil : +Veuillez revoir la mise en données de l'opérateur DEFI_FOND_FISS +(mot-clé NORMALE). +"""), + +20: _(""" +Une déformation initiale est présente dans la charge. Ceci est incompatible +avec la contrainte initiale sigma_init. +-> Risque et Conseil : +On ne peut pas faire de calcul en introduisant simultanément une contrainte +initiale ET une déformation initiale. Veuillez revoir les données. +"""), + +21: _(""" +Seule une loi de comportement élastique isotrope est valide pour +le calcul de DG. +"""), + +22: _(""" +Le calcul de DG n'a pas été étendu à la plasticité ! +"""), + +23: _(""" +CALC_G - option CALC_G : détection de chargements non nuls sur l'axe, +le calcul est impossible. +-> Risque et Conseil : +En 2D-axi, le calcul de G n'est pas possible pour les éléments de l'axe de +symétrie si un chargement est imposé sur ceux-ci. +Modifier les couronnes R_INF et R_SUP pour qu'elles soient toutes les deux +plus petites que le rayon du fond de fissure. +"""), + +24: _(""" +L'option CALC_K_G est incompatible avec les comportements incrémentaux, +avec les comportements non linéaires et avec la déformation GREEN. +"""), + +25: _(""" +Il faut affecter les éléments de bord (E et NU) pour le calcul des fic. +-> Risque et Conseil : +Veuillez revoir la mise en données des opérateurs DEFI_MATERIAU +et AFFE_MATERIAU. +"""), + +26: _(""" +La masse volumique RHO n'a pas été définie. +-> Risque et Conseil : +Pour l'option K_G_MODA, il est indispensable de fournir la masse volumique +du matériau considéré. Veuillez revoir la mise en données de l'opérateur +DEFI_MATERIAU. +"""), + +27: _(""" +L'option est incompatible avec les comportements incrémentaux ainsi +qu'avec la déformation Green. +"""), + +28: _(""" +Le champ de nom symbolique %(k1)s existe déjà dans la SD RESULTAT %(k1)s. +"""), + +29: _(""" +Arret sur erreur(s) 'utilisateur': deux mailles du fond de fissure sont +non consécutives dans la numérotation des noeuds. +-> Risque et Conseil : +Veuillez revoir l'ordre des mailles fournies au mot-clé MAILLE. +"""), + +30: _(""" +Il faut donner 3 composantes de la direction. +-> Risque et Conseil : +Si vous utilisez CALC_THETA/THETA_2D ou CALG_G/THETA en 2d, veuillez fournir +une valeur nulle pour la 3eme composante. +"""), + +31: _(""" +Option non opérationnelle: +Seule l'option COURONNE est à utiliser dans le cas ou +on emploie le mot clé THETA_3D ou THETA_2D. +"""), + +32: _(""" +Option inexistante: +Seule l'option BANDE est à utiliser dans le cas ou on emploie +le mot clé THETA_BANDE . +"""), + +33: _(""" +La tangente à l'origine n'est pas orthogonale à la normale au plan de la fissure. +Normale au plan : (%(r1)f,%(r2)f,%(r3)f) +-> Risque et Conseil : +La tangente à l'origine DTAN_ORIG est nécessairement dans le plan de la fissure, +donc orthogonale à la normale au plan, calculée à partir des fonctions de niveaux +(level set) qui définissent la fissure. Vérifier les données. +"""), + +34: _(""" +La tangente à l'extrémité n'est pas orthogonale à la normale au plan de la fissure. +Normale au plan : (%(r1)f,%(r2)f,%(r3)f) +-> Risque et Conseil : +La tangente à l'extrémité DTAN_EXTR est nécessairement dans le plan de la fissure, +donc orthogonale à la normale au plan, calculée à partir des fonctions de niveaux +(level set) qui définissent la fissure. Vérifier les données. +"""), + +35: _(""" +Les directions normales au plan de la fissure entre les points %(i1)d et %(i2)d successifs du fond forment un angle +supérieur à 10 degrés. +-> Risque et Conseils +L'interpolation des sauts de déplacements est basée sur les champs singuliers +correspondants à une fissure plane. La fissure utilisée ici est trop irrégulière et +il y a donc un risque d'obtenir des résultats imprécis. +"""), + +36: _(""" +La tangente à l'origine n'est pas orthogonale à la normale au plan de la fissure +défini par VECT_K1. +-> Risque et Conseil : +La tangente à l'origine DTAN_ORIG est nécessairement dans le plan de la fissure, +donc orthogonale au VECT_K1 fourni. Vérifier les données. +"""), + +37: _(""" +La tangente à l'extrémité n'est pas orthogonale à la normale au plan de la fissure +défini par VECT_K1. +-> Risque et Conseil : +La tangente à l'extrémité DTAN_EXTR est nécessairement dans le plan de la fissure, +donc orthogonale au VECT_K1 fourni. Vérifier les données. +"""), +} diff --git a/Aster/Cata/cataSTA9/Messages/seisme.py b/Aster/Cata/cataSTA9/Messages/seisme.py new file mode 100644 index 00000000..7136efdd --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/seisme.py @@ -0,0 +1,155 @@ +#@ MODIF seisme Messages DATE 05/11/2007 AUTEUR VIVAN L.VIVAN +# -*- 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 _(x) : return x + +cata_msg={ + + 1: _(""" + le noeud %(k1)s n'appartient pas au maillage: %(k2)s +"""), + + 2: _(""" + le groupe de noeuds %(k1)s n'appartient pas au maillage: %(k2)s +"""), + + 3: _(""" + le noeud %(k1)s n'est pas un noeud support. +"""), + + 4: _(""" + le vecteur directeur du spectre est nul. +"""), + + 5: _(""" + cas du MONO_APPUI: vous avez déjà donné un spectre pour cette direction. +"""), + + 6: _(""" + erreur(s) rencontrée(s) lors de la lecture des supports. +"""), + + 7: _(""" + vous avez déjà donné un spectre pour le support %(k1)s +"""), + + 8: _(""" + on ne peut pas traiter du MONO_APPUI et du MULTI_APPUI simultanément. +"""), + + 9: _(""" + on n'a pas pu extraire le premier champ des modes mécaniques. +"""), + +10: _(""" + correction statique non prise en compte pour l'option: %(k1)s +"""), + +11: _(""" + trop d'amortissements modaux + nombre d'amortissement: %(i1)d + nombre de mode : %(i2)d +"""), + +12: _(""" + amortissement non diagonal, on ne sait pas traiter. +"""), + +13: _(""" + il manque des amortissements modaux + nombre d'amortissements: %(i1)d + nombre de modes : %(i2)d +"""), + +14: _(""" + on ne peut pas demander de réponse secondaire sans la réponse primaire +"""), + +15: _(""" + analyse spectrale : + la base modale utilisée est : %(k1)s + le nombre de vecteurs de base est : %(i1)d + la règle de combinaison modale est : %(k2)s + les options de calcul demandées sont : %(k3)s """ + ), + +16: _(""" + %(k1)s """ + ), + +17: _(""" + la nature de l'excitation est : %(k1)s """ + ), + +18: _(""" + la règle de combinaison des réponses + directionnelles est : %(k1)s """ + ), + +19: _(""" + la règle de combinaison des contributions + de chaque mouvement d'appui est : %(k1)s """ + ), + +20: _(""" + erreur dans les données + la masse de la structure n'existe pas dans la table: %(k1)s +"""), + +21: _(""" + il faut au moins 2 occurences de DEPL_MULT_APPUI pour la combinaison des appuis. +"""), + +22: _(""" + COMB_DEPL_APPUI: il faut au moins définir 2 cas derrière le mot clé LIST_CAS. +"""), + +23: _(""" + données incompatibles + pour la direction : %(k1)s + nombre de blocage : %(i1)d + nombre d'excitations: %(i2)d +"""), + +24: _(""" + données incompatibles + pour les modes mécaniques : %(k1)s + il manque l'option : %(k2)s +"""), + +25: _(""" + problème stockage + option de calcul: %(k1)s + occurence : %(i1)d + nom du champ : %(k3)s +"""), + +26: _(""" + problème stockage + option de calcul: %(k1)s + direction : %(k2)s + nom du champ : %(k3)s +"""), + +27: _(""" +"""), + +} + diff --git a/Aster/Cata/cataSTA9/Messages/unilater.py b/Aster/Cata/cataSTA9/Messages/unilater.py new file mode 100644 index 00000000..07b09970 --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/unilater.py @@ -0,0 +1,35 @@ +#@ MODIF unilater Messages DATE 19/12/2007 AUTEUR ABBAS M.ABBAS +# -*- 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 _(x) : return x + +cata_msg = { + +51 : _(""" +Il y a plusieurs charges contenant des liaisons unilatérales. +"""), + + +75: _(""" +Pour le mot-clef LIAISON_UNILATER. +La composante %(k2)s est inexistante sur le noeud %(k1)s +"""), + +} diff --git a/Aster/Cata/cataSTA9/Messages/vide.py b/Aster/Cata/cataSTA9/Messages/vide.py new file mode 100644 index 00000000..9ab83a69 --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/vide.py @@ -0,0 +1,26 @@ +#@ MODIF vide Messages DATE 19/11/2007 AUTEUR COURTOIS M.COURTOIS +# -*- 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 _(x) : return x + +cata_msg = { +1 : _(''), +} + diff --git a/Aster/Cata/cataSTA9/Messages/volufini.py b/Aster/Cata/cataSTA9/Messages/volufini.py new file mode 100644 index 00000000..df5f4f85 --- /dev/null +++ b/Aster/Cata/cataSTA9/Messages/volufini.py @@ -0,0 +1,52 @@ +#@ MODIF volufini Messages DATE 06/05/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 _(x) : return x + +cata_msg = { + +1 : _(""" + -> type de maille %(k1)s incorrect + """), + +2 : _(""" + -> le sommet de numero global %(i1)i n appartient pas + -> a la maille %(i2)i +"""), + +3 : _(""" + -> Nombre de voisins %(i1)i trop grand +"""), + +4 : _(""" + -> Nombre de sommets communs %(i1)i trop grand +"""), + +5 : _(""" + -> Le nombre de mailles %(i1)i est inferieur a 1 +"""), +6 : _(""" + -> Le type de voisinage %(k1)s est inconnu +"""), +7 : _(""" + -> Le type de voisinage %(k1)s a une longueur %(i1)i trop grande +"""), + +} diff --git a/Aster/Cata/cataSTA9/SD/co_table_container.py b/Aster/Cata/cataSTA9/SD/co_table_container.py new file mode 100644 index 00000000..71bad133 --- /dev/null +++ b/Aster/Cata/cataSTA9/SD/co_table_container.py @@ -0,0 +1,29 @@ +#@ MODIF co_table_container SD DATE 12/02/2008 AUTEUR REZETTE C.REZETTE +# -*- 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 SD import * +from co_table import table_sdaster +from sd_table_container import sd_table_container + +# ----------------------------------------------------------------------------- +class table_container(table_sdaster,sd_table_container): + """Table contenant les colonnes NOM_OBJET, TYPE_OBJET et NOM_SD. + """ + diff --git a/Aster/Cata/cataSTA9/SD/sd_table_container.py b/Aster/Cata/cataSTA9/SD/sd_table_container.py new file mode 100644 index 00000000..1afe1a17 --- /dev/null +++ b/Aster/Cata/cataSTA9/SD/sd_table_container.py @@ -0,0 +1,81 @@ +#@ MODIF sd_table_container SD DATE 12/02/2008 AUTEUR REZETTE C.REZETTE +# -*- 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 SD import * + +from SD.sd_table import sd_table, Colonne +from SD.sd_vect_elem import sd_vect_elem +from SD.sd_matr_elem import sd_matr_elem +from SD.sd_cham_elem import sd_cham_elem +# -------------------------------------------------------------------- +# sd_table contenant les colonnes nommée "NOM_OBJET","TYPE_OBJET", +# et "NOM_SD" +# -------------------------------------------------------------------- + + + +class sd_table_container(sd_table): +#------------------------------------- + nomj = SDNom(fin=19) + + def check_table_container(self, checker): + + # vérification de l'existence de la table + if not self.exists() : + checker.err(self,"La sd_table_container %s ne semble" + +"pas exister" %(nomj)) + + # on vérifie la présence des paramètres + # 'NOM_OBJET','TYPE_OBJET','NOM_SD' + param=['NOM_OBJET','TYPE_OBJET','NOM_SD'] + shape = self.TBNP.get() + assert 3,shape[0] # la table a exactement 3 paramètres + for n in param: + col=self.get_column_name(n) + if col == None: + checker.err(self,"Paramètre %s manquant!" %(n)) + + # on vérifie que les colonnes ne sont pas vides + data = col.data.get() + if data is not None: + if col.data.lonuti != shape[1]: + checker.err(self,"Taille inconsitante %d!=%d" % + (col.data.lonuti,shape[1])) + + + # on vérifie le contenu de la colonne NOM_SD + col1=self.get_column_name('TYPE_OBJET') + col2=self.get_column_name('NOM_SD') + nbli=col1.data.lonuti + lnom1=col1.data.get_stripped() + lnom2=col2.data.get_stripped() + for k in range(nbli): + if lnom1[k][:9]=='VECT_ELEM': + sd5=sd_vect_elem(lnom2[k]) + sd5.check(checker) + elif lnom1[k][:9]=='MATR_ELEM': + sd5=sd_matr_elem(lnom2[k]) + sd5.check(checker) + elif lnom1[k][:9]=='CHAM_ELEM': + sd5=sd_cham_elem(lnom2[k]) + sd5.check(checker) + else: + assert 0,lnom1[k] + -- 2.39.2