From: eficas <> Date: Fri, 7 Oct 2005 07:48:30 +0000 (+0000) Subject: version 8.1.16 X-Git-Tag: CC_param_poursuite~79 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=09d68da0390f25313835da5467ecae3b00e094bb;p=tools%2Feficas.git version 8.1.16 --- diff --git a/Aster/Cata/cataSTA81/Macro/__init__.py b/Aster/Cata/cataSTA81/Macro/__init__.py new file mode 100644 index 00000000..4aebb58b --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/__init__.py @@ -0,0 +1,21 @@ +#@ MODIF __init__ Macro DATE 20/09/2004 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# +# +# ====================================================================== diff --git a/Aster/Cata/cataSTA81/Macro/calc_fonction_ops.py b/Aster/Cata/cataSTA81/Macro/calc_fonction_ops.py new file mode 100644 index 00000000..4169d1a6 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/calc_fonction_ops.py @@ -0,0 +1,328 @@ +#@ MODIF calc_fonction_ops Macro DATE 19/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2005 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 tocomplex(arg): + if arg[0]=='RI' : return complex(arg[1],arg[2]) + if arg[0]=='MP' : return complex(arg[1]*cos(arg[2]),arg[1]*sin(arg[2])) + +def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP, + SPEC_OSCI,ABS,COMB,COMB_C,COMPOSE,EXTRACTION, + ENVELOPPE,ASSE,CORR_ACCE,PUISSANCE,INVERSE, + NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE, + PROL_GAUCHE,NOM_PARA_FONC,INTERPOL_FONC,PROL_DROITE_FONC, + PROL_GAUCHE_FONC,**args): + """ + Ecriture de la macro CALC_FONCTION + """ + ier=0 + import types + import string + import copy + from math import pi + from Utilitai.t_fonction import t_fonction,t_fonction_c,t_nappe + from Utilitai import liss_enveloppe + from Accas import _F + from Cata.cata import nappe_sdaster,fonction_sdaster,fonction_c + from Utilitai.Utmess import UTMESS + from Numeric import alltrue,less,array,reshape,cos,sin,exp,sqrt + from Numeric import choose,zeros,Float + import aster_fonctions + EnumType = (types.ListType,types.TupleType) + + ### On importe les definitions des commandes a utiliser dans la macro + DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') + DEFI_NAPPE = self.get_cmd('DEFI_NAPPE') + + ### Comptage commandes + déclaration concept sortant + self.set_icmd(1) + self.DeclareOut('C_out',self.sd) + + ### type de traitement + ### + if (INTEGRE != None): + __ff=INTEGRE['FONCTION'].convert() + if INTEGRE['METHODE']=='TRAPEZE' : __ex=__ff.trapeze(INTEGRE['COEF']) + if INTEGRE['METHODE']=='SIMPSON' : __ex=__ff.simpson(INTEGRE['COEF']) + ### + if (DERIVE != None): + __ff=DERIVE['FONCTION'].convert() + __ex=__ff.derive() + ### + if (INVERSE != None): + __ff=INVERSE['FONCTION'].convert() + __ex=__ff.inverse() + ### + if (ABS != None): + __ff=ABS['FONCTION'].convert() + __ex=__ff.abs() + ### + if (COMPOSE != None): + __ff=COMPOSE['FONC_RESU'].convert() + __fg=COMPOSE['FONC_PARA'].convert() + __ex=__ff[__fg] + ### + if (ASSE != None): + __f0=ASSE['FONCTION'][0].convert() + __f1=ASSE['FONCTION'][1].convert() + __ex=__f0.cat(__f1,ASSE['SURCHARGE']) + ### + if (COMB != None): + list_fonc=[] + if isinstance(self.sd,nappe_sdaster): + for mcfact in COMB : + list_fonc.append(mcfact['FONCTION'].convert()) + list_fonch=[] + for f in list_fonc : + __ex=f + for g in list_fonc : + __ex=__ex.homo_support(g) + list_fonch.append(__ex) + list_fonc=list_fonch + elif isinstance(self.sd,fonction_sdaster): + for mcfact in COMB : + __ex=mcfact['FONCTION'].convert() + list_fonc.append(__ex) + + __ex=list_fonc[0] + __ex=__ex*COMB[0]['COEF'] + i=1 + for item in list_fonc[1:] : + item=item*COMB[i]['COEF'] + __ex=__ex+item + i=i+1 + ### + if (COMB_C != None): + list_fonc=[] + if isinstance(self.sd,nappe_sdaster): + for mcfact in COMB_C : + list_fonc.append(mcfact['FONCTION'].convert()) + list_fonch=[] + for f in list_fonc : + __ex=f + for g in list_fonc : + __ex=__ex.homo_support(g) + list_fonch.appen(__ex) + list_fonc=list_fonch + elif isinstance(self.sd,fonction_sdaster) or isinstance(self.sd,fonction_c): + for mcfact in COMB_C : + __ex=mcfact['FONCTION'].convert(arg='complex') + list_fonc.append(__ex) + + __ex=list_fonc[0] + if COMB_C[0]['COEF_R']!=None: __ex=__ex*complex(COMB_C[0]['COEF_R']) + if COMB_C[0]['COEF_C']!=None: + if type(COMB_C[0]['COEF_C']) in EnumType : __ex=__ex*tocomplex(COMB_C[0]['COEF_C']) + else : __ex=__ex*COMB_C[0]['COEF_C'] + i=1 + for item in list_fonc[1:] : + if COMB_C[i]['COEF_R']!=None: coef=complex(COMB_C[i]['COEF_R']) + if COMB_C[i]['COEF_C']!=None: + if type(COMB_C[i]['COEF_C']) in EnumType : coef=tocomplex(COMB_C[i]['COEF_C']) + else : coef=COMB_C[i]['COEF_C'] + item=item*coef + __ex=__ex+item + i=i+1 + ### mot clé LIST_PARA uniquement présent si COMB ou COMB_C + if (COMB != None) or (COMB_C != None) : + if (args['LIST_PARA'] != None) : + __ex=__ex.evalfonc(args['LIST_PARA'].Valeurs()) + ### + if (PUISSANCE != None): + __ff=PUISSANCE['FONCTION'].convert() + __ex=__ff + for i in range(PUISSANCE['EXPOSANT']-1) : __ex=__ex*__ff + ### + if (EXTRACTION != None): + if EXTRACTION['PARTIE']=='REEL' : __ex=EXTRACTION['FONCTION'].convert(arg='real') + if EXTRACTION['PARTIE']=='IMAG' : __ex=EXTRACTION['FONCTION'].convert(arg='imag') + if EXTRACTION['PARTIE']=='MODULE' : __ex=EXTRACTION['FONCTION'].convert(arg='modul') + if EXTRACTION['PARTIE']=='PHASE' : __ex=EXTRACTION['FONCTION'].convert(arg='phase') + ### + if (ENVELOPPE != None): + list_fonc=[] + l_env=ENVELOPPE['FONCTION'] + if type(l_env) not in EnumType : l_env=(l_env,) + if isinstance(self.sd,nappe_sdaster): + for f in l_env : list_fonc.append(f.convert()) + list_fonch=[] + for f in list_fonc : + __ff=f + for g in list_fonc : + __ff=__ff.homo_support(g) + list_fonch.append(__ff) + list_fonc=list_fonch + vale_para=list_fonc[0].vale_para + para =list_fonc[0].para + l_fonc_f =[] + for i in range(len(vale_para)): + __ff=list_fonc[0].l_fonc[i] + if ENVELOPPE['CRITERE']=='SUP' : + for f in list_fonc[1:] : __ff=__ff.sup(f.l_fonc[i]) + if ENVELOPPE['CRITERE']=='INF' : + for f in list_fonc[1:] : __ff=__ff.inf(f.l_fonc[i]) + l_fonc_f.append(__ff) + __ex=t_nappe(vale_para,l_fonc_f,para) + elif isinstance(self.sd,fonction_sdaster): + for f in l_env : list_fonc.append(f.convert()) + __ex=list_fonc[0] + if ENVELOPPE['CRITERE']=='SUP' : + for f in list_fonc[1:] : __ex=__ex.sup(f) + if ENVELOPPE['CRITERE']=='INF' : + for f in list_fonc[1:] : __ex=__ex.inf(f) + ### + if (CORR_ACCE != None): + __ex=CORR_ACCE['FONCTION'].convert() + para=copy.copy(__ex.para) + # suppression de la tendance de l accelero + __ex=__ex.suppr_tend() + # calcul de la vitesse + __ex=__ex.trapeze(0.) + # calcul de la tendance de la vitesse : y = a1*x +a0 + __ex=__ex.suppr_tend() + if CORR_ACCE['CORR_DEPL']=='OUI': + # suppression de la tendance deplacement + # calcul du deplacement : integration + __ex=__ex.trapeze(0.) + # calcul de la tendance du déplacement : y = a1*x +a0 + __ex=__ex.suppr_tend() + # regeneration de la vitesse : derivation + __ex=__ex.derive() + # regeneration de l accelero : derivation + __ex=__ex.derive() + __ex.para=para + ### + if (FFT != None): + if isinstance(self.sd,fonction_c): + __ff=FFT['FONCTION'].convert() + __ex=__ff.fft(FFT['METHODE']) + if isinstance(self.sd,fonction_sdaster): + __ff=FFT['FONCTION'].convert(arg='complex') + __ex=__ff.fft(FFT['METHODE'],FFT['SYME']) + ### + if (SPEC_OSCI != None): + if SPEC_OSCI['AMOR_REDUIT']==None : + l_amor=[0.02,0.05,0.1] + UTMESS('I','CALC_FONCTION',' : génération par défaut de 3 amortissements :'+str(l_amor)) + else : + if type(SPEC_OSCI['AMOR_REDUIT']) not in EnumType : + l_amor=[SPEC_OSCI['AMOR_REDUIT'],] + else : l_amor= SPEC_OSCI['AMOR_REDUIT'] + if SPEC_OSCI['FREQ']==None and SPEC_OSCI['LIST_FREQ']==None: + l_freq=[] + for i in range(56) : l_freq.append( 0.2+0.050*i) + for i in range( 8) : l_freq.append( 3.0+0.075*i) + for i in range(14) : l_freq.append( 3.6+0.100*i) + for i in range(24) : l_freq.append( 5.0+0.125*i) + for i in range(28) : l_freq.append( 8.0+0.250*i) + for i in range( 6) : l_freq.append(15.0+0.500*i) + for i in range( 4) : l_freq.append(18.0+1.000*i) + for i in range(10) : l_freq.append(22.0+1.500*i) + texte=[] + for i in range(len(l_freq)/5) : + texte.append(' %f %f %f %f %f' %tuple(l_freq[i*5:i*5+5])) + UTMESS('I','CALC_FONCTION',' : génération par défaut de 150 fréquences :\n'+'\n'.join(texte)) + elif SPEC_OSCI['LIST_FREQ']!=None: + l_freq=SPEC_OSCI['LIST_FREQ'].Valeurs() + elif SPEC_OSCI['FREQ']!=None: + if type(SPEC_OSCI['FREQ']) not in EnumType: + l_freq=[SPEC_OSCI['FREQ'],] + else : l_freq= SPEC_OSCI['FREQ'] + if abs(SPEC_OSCI['NORME'])<1.E-10 : + UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, la norme ne peut etre nulle') + if SPEC_OSCI['NATURE_FONC']!='ACCE' : + UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, le type de la fonction doit etre ACCE') + if SPEC_OSCI['METHODE']!='NIGAM' : + UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, seule la méthode NIGAM est codée') + eps=1.e-6 + for amor in l_amor : + if amor>(1-eps) : + UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, la méthode choisie '\ + 'suppose des amortissements sous-critiques, amor<1.') + + __ff=SPEC_OSCI['FONCTION'].convert() + + # appel à SPEC_OSCI + spectr = aster_fonctions.SPEC_OSCI(__ff.vale_x, __ff.vale_y, l_freq, l_amor) + + # construction de la nappe + vale_para = l_amor + para = { 'INTERPOL' : ['LIN','LOG'], + 'NOM_PARA_FONC' : 'FREQ', + 'NOM_PARA' : 'AMOR', + 'PROL_DROITE' : 'EXCLU', + 'PROL_GAUCHE' : 'EXCLU', + 'NOM_RESU' : SPEC_OSCI['NATURE'] } + para_fonc = { 'INTERPOL' : ['LOG','LOG'], + 'NOM_PARA' : 'FREQ', + 'PROL_DROITE' : 'CONSTANT', + 'PROL_GAUCHE' : 'EXCLU', + 'NOM_RESU' : SPEC_OSCI['NATURE'] } + if SPEC_OSCI['NATURE']=='DEPL' : ideb = 0 + elif SPEC_OSCI['NATURE']=='VITE' : ideb = 1 + else : ideb = 2 + l_fonc = [] + for iamor in range(len(l_amor)) : + l_fonc.append(t_fonction(l_freq,spectr[iamor,ideb,:]/SPEC_OSCI['NORME'],para_fonc)) + __ex=t_nappe(vale_para,l_fonc,para) + ### + if (LISS_ENVELOP!= None): + __ff=LISS_ENVELOP['NAPPE'].convert() + sp_nappe=liss_enveloppe.nappe(listFreq=__ff.l_fonc[0].vale_x, listeTable=[f.vale_y for f in __ff.l_fonc], listAmor=__ff.vale_para, entete="") + sp_lisse=liss_enveloppe.lissage(nappe=sp_nappe,fmin=LISS_ENVELOP['FREQ_MIN'],fmax=LISS_ENVELOP['FREQ_MAX'],elarg=LISS_ENVELOP['ELARG'],tole_liss=LISS_ENVELOP['TOLE_LISS']) + para_fonc=__ff.l_fonc[0].para + l_fonc=[] + for val in sp_lisse.listTable : + l_fonc.append(t_fonction(sp_lisse.listFreq,val,para_fonc)) + __ex=t_nappe(vale_para=sp_lisse.listAmor,l_fonc=l_fonc,para=__ff.para) + + ### creation de la fonction produite par appel à DEFI_FONCTION + ### on récupère les paramètres issus du calcul de __ex + ### et on les surcharge par ceux imposés par l'utilisateur + + if isinstance(__ex,t_fonction) or isinstance(__ex,t_fonction_c): + para=__ex.para + if NOM_PARA !=None : para['NOM_PARA'] =NOM_PARA + if NOM_RESU !=None : para['NOM_RESU'] =NOM_RESU + if PROL_DROITE!=None : para['PROL_DROITE']=PROL_DROITE + if PROL_GAUCHE!=None : para['PROL_GAUCHE']=PROL_GAUCHE + if INTERPOL !=None : para['INTERPOL'] =INTERPOL + if isinstance(__ex,t_fonction_c): para['VALE_C'] = __ex.tabul() + elif isinstance(__ex,t_fonction) : para['VALE'] = __ex.tabul() + C_out=DEFI_FONCTION(**para) + elif isinstance(__ex,t_nappe): + def_fonc=[] + for f in __ex.l_fonc : + para=f.para + def_fonc.append(_F(VALE =f.tabul(), + INTERPOL =f.para['INTERPOL'], + PROL_DROITE=f.para['PROL_DROITE'], + PROL_GAUCHE=f.para['PROL_GAUCHE'],) + ) + para=__ex.para + if NOM_PARA !=None : para['NOM_PARA'] =NOM_PARA + if NOM_RESU !=None : para['NOM_RESU'] =NOM_RESU + if PROL_DROITE !=None : para['PROL_DROITE']=PROL_DROITE + if PROL_GAUCHE !=None : para['PROL_GAUCHE']=PROL_GAUCHE + if NOM_PARA_FONC !=None : para['NOM_PARA_FONC'] =INTERPOL + if INTERPOL_FONC !=None : para['INTERPOL'] =INTERPOL + C_out=DEFI_NAPPE(PARA=__ex.vale_para.tolist(),DEFI_FONCTION=def_fonc,**para) + return ier + diff --git a/Aster/Cata/cataSTA81/Macro/calc_precont_ops.py b/Aster/Cata/cataSTA81/Macro/calc_precont_ops.py new file mode 100644 index 00000000..68ddb810 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/calc_precont_ops.py @@ -0,0 +1,467 @@ +#@ MODIF calc_precont_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2003 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. +# ====================================================================== + + +# RESPONSABLE ASSIRE A.ASSIRE + +def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, + CABLE_BP,CABLE_BP_INACTIF, + COMP_INCR,ETAT_INIT,NEWTON,RECH_LINEAIRE, + CONVERGENCE,INCREMENT,SOLVEUR,SOLV_NON_LOCAL, + LAGR_NON_LOCAL,PARM_THETA,INFO,TITRE,**args): + + + """ + Ecriture de la macro CALC_PRECONT + """ + import copy + import aster + import string + import types + from Accas import _F + from Noyau.N_utils import AsType + from Utilitai.Utmess import UTMESS + ier=0 + + # On importe les definitions des commandes a utiliser dans la macro + AFFE_MODELE = self.get_cmd('AFFE_MODELE') + CREA_CHAMP = self.get_cmd('CREA_CHAMP') + 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') + CALC_NO = self.get_cmd('CALC_NO') + CREA_CHAMP = self.get_cmd('CREA_CHAMP') + DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') + RECU_TABLE = self.get_cmd('RECU_TABLE') + DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU') + AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU') + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # Le concept sortant (de type evol_noli) est nomme RES dans + # le contexte de la macro + + self.DeclareOut('RES',self.sd) + + # ------------------------------------------------------------- + # 1. CREATION DES MOTS-CLES ET CONCEPTS POUR LES STAT_NON_LINE + # ------------------------------------------------------------ + + + # 1.1 Recuperation de la liste d'instants, de l'instant initial et final + # Creation de la nouvelle liste d'instants + # ---------------------------------------------------------- + + dIncrement=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste) + + __prec = dIncrement['PRECISION'] + __L0 = dIncrement['LIST_INST'] + __L1 = __L0.Valeurs() + + # Traitement de l'etat initial + if ETAT_INIT: + dEtatInit=ETAT_INIT[0].cree_dict_valeurs(ETAT_INIT[0].mc_liste) + for i in dEtatInit.keys(): + if dEtatInit[i]==None : del dEtatInit[i] + + __EVINIT = dEtatInit['EVOL_NOLI'] + else : + dEtatInit=None + + # Test de la presence de reuse= + if self.reuse == None: + dReuse=None + else : + dReuse='RES' + + # Teste si INST_INIT est donné ou bien recalcule __TMIN + if dIncrement['INST_INIT'] == None: + if self.reuse == None: + __TMIN = __L1[0] + else: + __dico = __EVINIT.LIST_VARI_ACCES() + __TMIN = __dico['INST'][-1] + else: + __TMIN = dIncrement['INST_INIT'] + + # Teste si INST_FIN est donné ou bien recalcule __TMAX + if dIncrement['INST_FIN'] == None: + __TMAX = __L1[-1] + else: + __TMAX = dIncrement['INST_FIN'] + + # Teste si INST_INIT est bien plus petit que INST_FIN + if __TMAX <= __TMIN: + UTMESS('F','CALC_PRECONT','INST_FIN PLUS PETIT QUE INST_INIT') + + # Cree la liste d'instant __L2 allant de __TMIN a __TMAX et contenant + # un instant supplementaire __TINT + __L2=[] + for m in __L1: + if m>=__TMIN and m<=__TMAX: + __L2.append(m) + + __TINT = (9.*__L2[-1] + __L2[-2])/10. + __L2[-1:-1] = [__TINT] + + # __LST0 est la liste d'instants utilisée pour l'etape 1 + __LST0=DEFI_LIST_REEL( DEBUT = __TMIN, + INTERVALLE = _F(JUSQU_A = __TMAX, NOMBRE = 1),) + + # __LST et __FCT sont utilisés pour les etapes 2 et 3 + __LST=DEFI_LIST_REEL(VALE=__L2,); + __FCT=DEFI_FONCTION(INTERPOL=('LIN','LIN'), + NOM_PARA='INST', + VALE=(__TMIN,0.0,__TINT,1.0,__TMAX,1.0),); + + for i in dIncrement.keys(): + if dIncrement[i]==None : del dIncrement[i] + dIncrement['LIST_INST']= __LST + dIncrement['INST_FIN'] = __TINT + + + + # 1.2 Recuperation des parametres pour STAT_NON_LINE + # ------------------------------------------------------- + + dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste) + for i in dNewton.keys(): + if dNewton[i]==None : del dNewton[i] + + dConvergence=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste) + for i in dConvergence.keys(): + if dConvergence[i]==None : del dConvergence[i] + + dSolveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste) + for i in dSolveur.keys(): + if dSolveur[i]==None : del dSolveur[i] + + if RECH_LINEAIRE: + dRech_lin=RECH_LINEAIRE[0].cree_dict_valeurs(RECH_LINEAIRE[0].mc_liste) + for i in dRech_lin.keys(): + if dRech_lin[i]==None : del dRech_lin[i] + else : + dRech_lin=None + + if SOLV_NON_LOCAL: + dSolv_nonloc=SOLV_NON_LOCAL[0].cree_dict_valeurs(SOLV_NON_LOCAL[0].mc_liste) + for i in dSolv_nonloc.keys(): + if dSolv_nonloc[i]==None : del dSolv_nonloc[i] + else : + dSolv_nonloc=None + + if LAGR_NON_LOCAL: + dLagr_nonloc=LAGR_NON_LOCAL[0].cree_dict_valeurs(LAGR_NON_LOCAL[0].mc_liste) + for i in dLagr_nonloc.keys(): + if dLagr_nonloc[i]==None : del dLagr_nonloc[i] + else : + dLagr_nonloc=None + + + + # 1.3 Creation des mots-cles pour les 3 AFFE_CHAR_MECA + # Recuperation des cables dans les concepts CABLE_BP + # et CABLE_BP_INACTIF + # ------------------------------------------------------ + if type(CABLE_BP) is not types.NoneType: + if type(CABLE_BP) is not types.TupleType: + CABLE_BP0 = CABLE_BP + CABLE_BP = [] + CABLE_BP.append ( CABLE_BP0 ) + + if type(CABLE_BP_INACTIF) is not types.NoneType: + if type(CABLE_BP_INACTIF) is not types.TupleType: + CABLE_BP_INACTIF0 = CABLE_BP_INACTIF + CABLE_BP_INACTIF = [] + CABLE_BP_INACTIF.append ( CABLE_BP_INACTIF0 ) + + motscles={} + motscles['RELA_CINE_BP']=[] + motscle2={} + motscle2['RELA_CINE_BP']=[] + motscle3={} + motscle3['RELA_CINE_BP']=[] + __GROUP_MA_A=[] + Result = [[None]*1] + for mcabl in CABLE_BP: + # Creation de mots-cles pour les AFFE_CHAR_MECA + motscles['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl, + SIGM_BPEL = 'OUI', + RELA_CINE = 'NON',) ) + motscle2['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl, + SIGM_BPEL = 'NON', + RELA_CINE = 'OUI',) ) + motscle3['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl, + SIGM_BPEL = 'OUI', + RELA_CINE = 'OUI',) ) + + # Creation de __GROUP_MA_A : liste des noms des cables contenus + # dans chaque concept CABLE_BP = cables a activer + __TCAB = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP'); + __nb = 0 + while 1: + try: + Result[__nb][0] = __TCAB['NOM_CABLE',__nb+1] + __CAB = __TCAB['NOM_CABLE',__nb+1] + if __nb == 0: + __GROUP_MA_A.append(__CAB) + else: + i = 0 + # enlève les doublons + for m in __GROUP_MA_A: + i=i+1 + if __CAB == m: + break + if i == len(__GROUP_MA_A): + __GROUP_MA_A.append(__CAB) + + __nb = __nb + 1 + Result.append([None]*1) + # Si on a lu toutes les valeurs alors on sort de la boucle + except KeyError: + break + + # Creation de __GROUP_MA_I : liste des noms des cables contenus + # dans chaque CABLE_BP_INACTIF + # __GROUP_MA_CABLE = liste des cables actifs et inactifs + Result = [[None]*1] + __GROUP_MA_I=[] + + if CABLE_BP_INACTIF: + for mcabl in CABLE_BP_INACTIF: + __TCA0 = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP'); + __nb = 0 + while 1: + try: + Result[__nb][0] = __TCA0['NOM_CABLE',__nb+1] + __CA0 = __TCA0['NOM_CABLE',__nb+1] + if __nb == 0: + __GROUP_MA_I.append(__CA0) + else: + i = 0 + # enlève les doublons + for m in __GROUP_MA_I: + i=i+1 + if __CA0 == m: + break + if i == len(__GROUP_MA_I): + __GROUP_MA_I.append(__CA0) + + __nb = __nb + 1 + Result.append([None]*1) + # Si on a lu toutes les valeurs alors on sort de la boucle + except KeyError: + break + motscle6={} + motscle6['RELA_CINE_BP']=[] + for mcabl in CABLE_BP_INACTIF: + # Creation de mots-cles pour les AFFE_CHAR_MECA + motscle6['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl, + SIGM_BPEL = 'NON', + RELA_CINE = 'OUI',) ) + + __GROUP_MA_CABLES = __GROUP_MA_A + __GROUP_MA_I + + + # 1.4 Creation des mots-clés facteurs COMP_INCR + # pour étape 2 (dComp_incr0) et étape 3 (dComp_incr1) + # ------------------------------------------------------ + + dComp_incr=[] + for j in COMP_INCR : + dComp_incr.append(j.cree_dict_valeurs(j.mc_liste)) + for i in dComp_incr[-1].keys(): + if dComp_incr[-1][i]==None : del dComp_incr[-1][i] + + dComp_incr0=copy.copy(dComp_incr) + dComp_incr1=copy.copy(dComp_incr) + + dComp_incr0.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_CABLES) ) + if __GROUP_MA_I: + dComp_incr1.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_I) ) + + + # 1.5 Modele contenant uniquement les cables de precontrainte + # --------------------------------------------------------- + + __MOD = string.ljust(MODELE.nom,8) + __MOD =__MOD+'.MODELE .NOMA ' + __LMAIL = aster.getvectjev(__MOD) + __MAIL = string.strip(__LMAIL[0]) + + objma=self.get_sd_avant_etape(__MAIL,self) + + __M_CA=AFFE_MODELE( MAILLAGE=objma, + AFFE =_F( GROUP_MA = __GROUP_MA_A, + PHENOMENE = 'MECANIQUE', + MODELISATION = 'BARRE') ) + + + # 1.6 Blocage de tous les noeuds des cables actifs + # -------------------------------------------------- + + _B_CA=AFFE_CHAR_MECA(MODELE=__M_CA, + DDL_IMPO= _F( GROUP_MA = __GROUP_MA_A, + DX = 0., + DY = 0., + DZ = 0.),) + + + # 1.7 Chargements concernant les cables + # ------------------------------------- + _C_CN=AFFE_CHAR_MECA(MODELE=__M_CA,**motscles) + _C_CA=AFFE_CHAR_MECA(MODELE=MODELE,**motscle2) + _C_CT=AFFE_CHAR_MECA(MODELE=MODELE,**motscle3) + if CABLE_BP_INACTIF: + _C_CI=AFFE_CHAR_MECA(MODELE=MODELE,**motscle6) + + + + # ------------------------------------------------------------- + # 2. CALCULS + # ------------------------------------------------------------ + + + #------------------------------------------------------------------- + # 2.1 Premiere etape : calcul sur le(s) cable(s) et + # recuperation des _F_CAs aux noeuds + # on travaile entre tmin et tmax + #------------------------------------------------------------------- + + __EV1=STAT_NON_LINE( + MODELE = __M_CA, + CHAM_MATER = CHAM_MATER, + CARA_ELEM = CARA_ELEM, + EXCIT =(_F(CHARGE = _B_CA), + _F(CHARGE = _C_CN),), + COMP_INCR =_F( RELATION = 'ELAS', + DEFORMATION = 'PETIT', + TOUT = 'OUI'), + INCREMENT =_F(LIST_INST = __LST0, + PRECISION = __prec), + SOLVEUR = dSolveur, + PARM_THETA = PARM_THETA, + INFO =INFO, + TITRE = TITRE, ) + + __EV1 = CALC_NO( reuse = __EV1, + RESULTAT = __EV1, + GROUP_MA = __GROUP_MA_A, + OPTION = 'FORC_NODA' ) + + __REA = CREA_CHAMP ( + TYPE_CHAM = 'NOEU_DEPL_R', + OPERATION = 'EXTR', + RESULTAT = __EV1, + NOM_CHAM = 'FORC_NODA', + INST = __TMAX); + + __REAC = CREA_CHAMP (TYPE_CHAM='NOEU_DEPL_R', + OPERATION = 'ASSE', + MODELE = MODELE, + ASSE= _F(GROUP_MA=__GROUP_MA_A, + CHAM_GD=__REA, + COEF_R = -1.), ) + + _F_CA=AFFE_CHAR_MECA(MODELE=__M_CA, + VECT_ASSE = __REAC ) + + + + #----------------------------------------------------------------------- + # 2.2 Deuxieme etape : application de la precontrainte sur le beton + # en desactivant les cables + #----------------------------------------------------------------------- + + # Regeneration des mots-cles EXCIT passés en argument de la macro + dExcit=[] + for j in EXCIT : + dExcit.append(j.cree_dict_valeurs(j.mc_liste)) + for i in dExcit[-1].keys(): + if dExcit[-1][i]==None : del dExcit[-1][i] + + if CABLE_BP_INACTIF: + dExcit.append(_F(CHARGE=_C_CI),) + + # Creation du mots-cle EXCIT pour le STAT_NON_LINE + dExcit1=copy.copy(dExcit) + dExcit1.append(_F(CHARGE=_C_CA),) + dExcit1.append(_F(CHARGE = _F_CA, + FONC_MULT=__FCT ),) + + RES=STAT_NON_LINE( + MODELE =MODELE, + CARA_ELEM =CARA_ELEM, + CHAM_MATER = CHAM_MATER, + COMP_INCR=dComp_incr0, + INCREMENT=dIncrement, + ETAT_INIT = dEtatInit, + NEWTON =dNewton, + CONVERGENCE=dConvergence, + RECH_LINEAIRE = dRech_lin, + SOLVEUR = dSolveur, + SOLV_NON_LOCAL = dSolv_nonloc, + LAGR_NON_LOCAL = dLagr_nonloc, + ARCHIVAGE = _F(INST = __TINT), + PARM_THETA = PARM_THETA, + INFO =INFO, + TITRE = TITRE, + EXCIT = dExcit1, + ) + + # Recuperation du dernier numero d'ordre pour pouvoir l'écraser dans RES + __dico2 = RES.LIST_VARI_ACCES() + __no = __dico2['NUME_ORDRE'][-1] + + + #----------------------------------------------------------------------- + # 2.2 Troisieme etape : on remet la tension dans les cables + #----------------------------------------------------------------------- + + # Creation du mots-cles EXCIT pour le STAT_NON_LINE + dExcit2=copy.copy(dExcit) + dExcit2.append(_F(CHARGE=_C_CT,) ) + + # Calcul sur un seul pas (de __TINT a __TMAX) + RES=STAT_NON_LINE( reuse = RES, + ETAT_INIT = _F(EVOL_NOLI =RES), + MODELE = MODELE, + CHAM_MATER = CHAM_MATER, + CARA_ELEM = CARA_ELEM, + COMP_INCR=dComp_incr1, + INCREMENT=_F(LIST_INST = __LST, + PRECISION = __prec), + NEWTON =dNewton, + RECH_LINEAIRE = dRech_lin, + CONVERGENCE=dConvergence, + SOLVEUR = dSolveur, + SOLV_NON_LOCAL = dSolv_nonloc, + LAGR_NON_LOCAL = dLagr_nonloc, + ARCHIVAGE = _F(NUME_INIT = __no, + DETR_NUME_SUIV = 'OUI' ), + PARM_THETA = PARM_THETA, + INFO =INFO, + TITRE = TITRE, + EXCIT =dExcit2, + ) + + return ier + diff --git a/Aster/Cata/cataSTA81/Macro/calc_table_ops.py b/Aster/Cata/cataSTA81/Macro/calc_table_ops.py new file mode 100644 index 00000000..f50617ed --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/calc_table_ops.py @@ -0,0 +1,176 @@ +#@ MODIF calc_table_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2005 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. +# ====================================================================== + +# RESPONSABLE MCOURTOI M.COURTOIS +from types import * +import aster +EnumTypes=(ListType, TupleType) + +def calc_table_ops(self,TABLE,FILTRE,EXTR,RENOMME,TRI,COMB,OPER,INFO,**args): + """ + Macro CALC_TABLE permettant de faire des opérations sur une table + """ + macro='CALC_TABLE' + from Accas import _F + from Cata.cata import table_jeveux + from Utilitai.Utmess import UTMESS + from Utilitai import transpose + from Utilitai.Table import Table, merge + + ier=0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # Le concept sortant (de type table_sdaster) est tab + self.DeclareOut('tabout',self.sd) + + # On importe les definitions des commandes a utiliser dans la macro + # Le nom de la variable doit etre obligatoirement le nom de la commande + CREA_TABLE = self.get_cmd('CREA_TABLE') + DETRUIRE = self.get_cmd('DETRUIRE') + + tab=TABLE.EXTR_TABLE() + + #---------------------------------------------- + # 1. Traitement du FILTRE + Filtre=[] + # format pour l'impression des filtres + form_filtre='\nFILTRE -> NOM_PARA: %-16s CRIT_COMP: %-4s VALE: %s' + if FILTRE<>None: + for Fi in FILTRE: + dF = Fi.cree_dict_valeurs(Fi.mc_liste) + for mc in dF.keys(): + if dF[mc]==None: del dF[mc] + Filtre.append(dF) + + for Fi in Filtre: + col = getattr(tab, Fi['NOM_PARA']) + # peu importe le type + opts=[Fi[k] for k in ('VALE','VALE_I','VALE_C','VALE_K') if Fi.has_key(k)] + kargs={} + for k in ('CRITERE','PRECISION'): + if Fi.has_key(k): + kargs[k]=Fi[k] + tab = tab & ( getattr(col, Fi['CRIT_COMP'])(*opts,**kargs) ) + # trace l'operation dans le titre + #if FORMAT in ('TABLEAU','ASTER'): + tab.titr+=form_filtre % (Fi['NOM_PARA'], Fi['CRIT_COMP'], \ + ' '.join([str(v) for v in opts])) + + #---------------------------------------------- + # 2. Traitement de EXTR + if EXTR<>None: + lpar=EXTR['NOM_PARA'] + if not type(lpar) in EnumTypes: + lpar=[lpar] + for p in lpar: + if not p in tab.para: + UTMESS('F', macro, 'Paramètre %s inexistant dans la table %s' % (p, TABLE.nom)) + tab=tab[EXTR['NOM_PARA']] + + #---------------------------------------------- + # 3. Traitement de RENOMME + if RENOMME<>None: + for MCFi in RENOMME: + pold, pnew = MCFi['NOM_PARA'] + if not pold in tab.para: + UTMESS('F', macro, 'Paramètre %s inexistant dans la table %s' % (pold, TABLE.nom)) + elif tab.para.count(pnew)>0: + UTMESS('F', macro, 'Le paramètre %s existe déjà dans la table %s' % (pnew, TABLE.nom)) + else: + tab.para[tab.para.index(pold)]=pnew + for lig in tab: + lig[pnew]=lig[pold] + del lig[pold] + + #---------------------------------------------- + # 4. Traitement du TRI + if TRI<>None: + tab.sort(CLES=TRI['NOM_PARA'], ORDRE=TRI['ORDRE']) + + #---------------------------------------------- + # 5. Traitement de COMB + if COMB<>None: + tab2=COMB['TABLE'].EXTR_TABLE() + opts=[tab, tab2] + if COMB['NOM_PARA']<>None: + lpar=COMB['NOM_PARA'] + if not type(lpar) in EnumTypes: + lpar=[lpar] + for p in lpar: + if not p in tab.para: + UTMESS('F', macro, 'Paramètre %s inexistant dans la table %s' % (p, TABLE.nom)) + if not p in tab2.para: + UTMESS('F', macro, 'Paramètre %s inexistant dans la table %s' % (p, COMB['TABLE'].nom)) + opts.append(lpar) + tab=merge(*opts) + + #---------------------------------------------- + # 6. Traitement de OPER + if OPER<>None: + for MCFi in OPER: + if MCFi['NOM_PARA'] in tab.para : + UTMESS('F', macro, 'Le paramètre %s existe déjà dans la table %s' % (MCFi['NOM_PARA'], TABLE.nom)) + func=MCFi['FORMULE'] + tabpar=[] + for para in func.nompar : + if para not in tab.para : + UTMESS('F', macro, 'Le paramètre de la formule %s est inexistant dans la table %s' % (para, TABLE.nom)) + i=tab.para.index(para) + if tab.type[i]<>'R' : + UTMESS('F', macro, 'Le paramètre %s doit etre réel dans la table %s' % (para, TABLE.nom)) + vals=getattr(tab,para).values() + tabpar.append(vals) + tabpar=transpose.transpose(tabpar) + vectval=[] + for lpar in tabpar: + # si un paramètre est absent, on ne peut pas évaluer la formule + if None in lpar: + vectval.append(None) + else: + vectval.append(func(*lpar)) + # ajout de la colonne dans la table + if INFO==2: + aster.affiche('MESSAGE', 'Ajout de la colonne %s : %s' % (MCFi['NOM_PARA']+repr(vectval))+'\n') + tab[MCFi['NOM_PARA']]=vectval + + #---------------------------------------------- + # 99. Création de la table_sdaster résultat + # cas réentrant : il faut détruire l'ancienne table_sdaster + if self.sd.nom==TABLE.nom: + DETRUIRE(CONCEPT=_F(NOM=TABLE.nom,),) + + dprod=tab.dict_CREA_TABLE() + if INFO==2: + echo_mess=[] + echo_mess.append( '@-'*30+'\n' ) + echo_mess.append( tab ) + from pprint import pformat + echo_mess.append( pformat(dprod) ) + echo_mess.append( '@-'*30+'\n' ) + texte_final=string.join(echo_mess) + aster.affiche('MESSAGE',texte_final) + + # surcharge par le titre fourni + if args['TITRE']<>None: + dprod['TITRE']=tuple(['%-80s' % lig for lig in args['TITRE']]) + tabout=CREA_TABLE(**dprod) + + return ier diff --git a/Aster/Cata/cataSTA81/Macro/defi_cable_bp_ops.py b/Aster/Cata/cataSTA81/Macro/defi_cable_bp_ops.py new file mode 100644 index 00000000..552fe5e0 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/defi_cable_bp_ops.py @@ -0,0 +1,310 @@ +#@ MODIF defi_cable_bp_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2003 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. +# ====================================================================== +# RESPONSABLE ASSIRE A.ASSIRE + +# =========================================================================== +# CORPS DE LA MACRO "DEFI_CABLE_BP" +# ------------------------------------- +# USAGE : +# Entrée : +# - MAILLAGE +# - MODELE +# - CABLE +# - CHAM_MATER +# - CARA_ELEM +# - GROUP_MA_BETON +# - DEFI_CABLE +# - TYPE_ANCRAGE +# - TENSION_INIT +# - RECUL_ANCRAGE +# - RELAXATION +# - CONE +# RAYON +# LONGUEUR +# PRESENT OUI ou NON deux fois +# - TITRE +# - INFO 1 / 2 +# +# =========================================================================== + + + +def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, + DEFI_CABLE,TYPE_ANCRAGE,TENSION_INIT,RECUL_ANCRAGE, + RELAXATION,CONE,TITRE,INFO,**args): + + """ + Ecriture de la macro DEFI_CABLE_BP + """ + from Accas import _F + import aster,string + from Utilitai.Utmess import UTMESS + ier=0 + + # On importe les definitions des commandes a utiliser dans la macro + DEFI_GROUP = self.get_cmd('DEFI_GROUP') + IMPR_RESU = self.get_cmd('IMPR_RESU') + DEFI_CABLE_OP = self.get_cmd('DEFI_CABLE_OP') + RECU_TABLE = self.get_cmd('RECU_TABLE') + IMPR_TABLE = self.get_cmd('IMPR_TABLE') + IMPR_CO = self.get_cmd('IMPR_CO') + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # Le concept sortant (de type char_meca) est nomme CHCABLE dans + # le contexte de la macro + + self.DeclareOut('__DC',self.sd) + + # ---------------------------------------------------------------------------- # + # Début de la Macro : + + motscles={} + + # RECUPERATION DES INFOS DONNEES PAR LE MOT-CLE "CONE" + + if CONE: + dCONE=CONE[0].cree_dict_valeurs(CONE[0].mc_liste) + for i in dCONE.keys(): + if dCONE[i]==None : del dCONE[i] + + RAYON = dCONE['RAYON'] + LONGUEUR = dCONE['LONGUEUR'] + + motscles['CONE']=[] + motscles['CONE'].append( dCONE ) + + + # VERIFICATION QUE LE MAILLAGE EST COHERENT AVEC LE MODELE + + __MAIL = aster.getvectjev( string.ljust(MODELE.nom,8) + '.MODELE .NOMA ' ) + if string.ljust(MAILLAGE.nom,8) != __MAIL[0] : + echo_mess=[] + echo_mess.append( ' \n' ) + echo_mess.append( ' # ---------------------------------------------------------------------------\n' ) + echo_mess.append( ' # DEFI_CABLE_BP - Erreur : LE CONCEPT MAILLAGE RENSEIGNE NE CORRESPOND \n' ) + echo_mess.append( ' # PAS A CELUI UTILISE DANS LE MODELE ! \n' ) + echo_mess.append( ' # '+MAILLAGE.nom+' - '+__MAIL[0]+'\n' ) + echo_mess.append( ' # ---------------------------------------------------------------------------\n' ) + message=string.join(echo_mess) + UTMESS('F',message) + + + # DEFINITION DU NOM DES GROUP_NO + + __NOM = '_AN_' + __LGNO = MAILLAGE.LIST_GROUP_NO() + __LGN1 = [] + for i in __LGNO : + __LGN1.append( i[0][:len(__NOM)] ) + + __NB = __LGN1.count(__NOM) + +# FIN RECUPERATION DES INFOS DONNEES PAR LE MOT-CLE "CONE" + + + # RECUPERATION DES INFOS DONNEES PAR LE MOT-CLE "DEFI_CABLE" + + dDEFI_CABLE=[] + for j in DEFI_CABLE : + dDEFI_CABLE.append(j.cree_dict_valeurs(j.mc_liste)) + for i in dDEFI_CABLE[-1].keys(): + if dDEFI_CABLE[-1][i]==None : del dDEFI_CABLE[-1][i] + + + # BOUCLE SUR LES FACTEURS DU MOT-CLE "DEFI_CABLE" + + motscles['DEFI_CABLE']=[] + + for i in dDEFI_CABLE: + + # CAS OU L'ON A DEFINI LE MOT-CLE "CONE" + if CONE: + + # CREATION DU PREMIER TUNNEL + + if dCONE['PRESENT'][0] == 'OUI': + __NB = __NB + 1 + __NOM1 = __NOM + str( int(__NB) ) + + motscle2={} + motscle2['CREA_GROUP_NO']=[] + + if i.has_key('GROUP_MA') == 1: + __CAB = i['GROUP_MA'] + motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': [ GROUP_MA_BETON, __CAB ], 'GROUP_MA_AXE': __CAB, 'NOM': __NOM1}]} + if i.has_key('MAILLE') == 1: + echo_mess=[] + echo_mess.append( ' \n' ) + echo_mess.append( ' # ---------------------------------------------------------------------------\n' ) + echo_mess.append( ' # DEFI_CABLE_BP - Erreur : MAILLE INTERDIT - UTILISER GROUP_MA \n' ) + echo_mess.append( ' # ---------------------------------------------------------------------------\n' ) + message=string.join(echo_mess) + UTMESS('F',message) + if i.has_key('GROUP_NO_ANCRAGE') == 1: + __PC1 = i['GROUP_NO_ANCRAGE'][0] + motscle2['CREA_GROUP_NO'][0]['GROUP_NO_ORIG'] = __PC1 + if i.has_key('NOEUD_ANCRAGE') == 1: + __PC1 = i['NOEUD_ANCRAGE'][0] + motscle2['CREA_GROUP_NO'][0]['NOEUD_ORIG'] = __PC1 + + + DEFI_GROUP( reuse=MAILLAGE, + MAILLAGE=MAILLAGE, + INFO=INFO, + ALARME='NON', + **motscle2 + ) ; + + # CREATION DU DEUXIEME TUNNEL + + if dCONE['PRESENT'][1] == 'OUI': + __NB = __NB + 1 + __NOM2 = __NOM + str( int(__NB) ) + + motscle2={} + motscle2['CREA_GROUP_NO']=[] + + if i.has_key('GROUP_MA') == 1: + __CAB = i['GROUP_MA'] + motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': [ GROUP_MA_BETON, __CAB ], 'GROUP_MA_AXE': __CAB, 'NOM': __NOM2}]} + if i.has_key('MAILLE') == 1: + echo_mess=[] + echo_mess.append( ' \n' ) + echo_mess.append( ' # ---------------------------------------------------------------------------\n' ) + echo_mess.append( ' # DEFI_CABLE_BP - Erreur : MAILLE INTERDIT - UTILISER GROUP_MA \n' ) + echo_mess.append( ' # ---------------------------------------------------------------------------\n' ) + message=string.join(echo_mess) + UTMESS('F',message) + if i.has_key('GROUP_NO_ANCRAGE') == 1: + __PC1 = i['GROUP_NO_ANCRAGE'][1] + motscle2['CREA_GROUP_NO'][0]['GROUP_NO_ORIG'] = __PC1 + if i.has_key('NOEUD_ANCRAGE') == 1: + __PC1 = i['NOEUD_ANCRAGE'][1] + motscle2['CREA_GROUP_NO'][0]['NOEUD_ORIG'] = __PC1 + + DEFI_GROUP( reuse=MAILLAGE, + MAILLAGE=MAILLAGE, + INFO=INFO, + ALARME='NON', + **motscle2 + ) ; + + + # CREATION DES NOUVEAUX FACTEURS DU MOT-CLE "DEFI_CABLE" POUR DEFI_CABLE_BP + + if dCONE['PRESENT'][0] == 'OUI' and dCONE['PRESENT'][1] == 'OUI': + if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], + GROUP_NO_FUT=( __NOM1,__NOM2, ), ), ) + if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], + GROUP_NO_FUT=( __NOM1,__NOM2, ), ), ) + + if dCONE['PRESENT'][0] == 'OUI' and dCONE['PRESENT'][1] == 'NON': + if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], + GROUP_NO_FUT=( __NOM1, ), ), ) + if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], + GROUP_NO_FUT=( __NOM1, ), ), ) + + if dCONE['PRESENT'][0] == 'NON' and dCONE['PRESENT'][1] == 'OUI': + if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], + GROUP_NO_FUT=( __NOM2, ), ), ) + if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], + GROUP_NO_FUT=( __NOM2, ), ), ) + + if dCONE['PRESENT'][0] == 'NON' and dCONE['PRESENT'][1] == 'NON': + if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], ), ) + if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], ), ) + + + # CAS OU L'ON A PAS DEFINI LE MOT-CLE "CONE" + else: + if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], ), ) + + if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], + NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], ), ) + + if i.has_key('MAILLE') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(MAILLE=i['MAILLE'], + GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], ), ) + + if i.has_key('MAILLE') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: + motscles['DEFI_CABLE'].append( _F(MAILLE=i['MAILLE'], + NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], ), ) + + +# FIN BOUCLE sur i in DEFI_CABLE + + + # LANCEMENT DE DEFI_CABLE_BP + + if RELAXATION: + dRelaxation=RELAXATION[0].cree_dict_valeurs(RELAXATION[0].mc_liste) + for i in dRelaxation.keys(): + if dRelaxation[i]==None : del dRelaxation[i] + + __DC=DEFI_CABLE_OP(MODELE=MODELE, + CHAM_MATER=CHAM_MATER, + CARA_ELEM=CARA_ELEM, + GROUP_MA_BETON=GROUP_MA_BETON, + TYPE_ANCRAGE=TYPE_ANCRAGE, + TENSION_INIT=TENSION_INIT, + RECUL_ANCRAGE=RECUL_ANCRAGE, + RELAXATION=dRelaxation, + INFO=INFO, + **motscles + ); + + else: + + __DC=DEFI_CABLE_OP(MODELE=MODELE, + CHAM_MATER=CHAM_MATER, + CARA_ELEM=CARA_ELEM, + GROUP_MA_BETON=GROUP_MA_BETON, + TYPE_ANCRAGE=TYPE_ANCRAGE, + TENSION_INIT=TENSION_INIT, + RECUL_ANCRAGE=RECUL_ANCRAGE, + INFO=INFO, + **motscles + ); + +# __TCAB = RECU_TABLE(CO=__DC,NOM_TABLE='CABLE_BP'); +# IMPR_TABLE(TABLE=__TCAB); + + return ier diff --git a/Aster/Cata/cataSTA81/Macro/defi_part_feti_ops.py b/Aster/Cata/cataSTA81/Macro/defi_part_feti_ops.py new file mode 100644 index 00000000..9e446613 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/defi_part_feti_ops.py @@ -0,0 +1,194 @@ +#@ MODIF defi_part_feti_ops Macro DATE 30/08/2005 AUTEUR ASSIRE A.ASSIRE +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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. +# ====================================================================== +# RESPONSABLE ASSIRE A.ASSIRE + + +# =========================================================================== +# CORPS DE LA MACRO "DEFI_PART_FETI" +# ------------------------------------- +# USAGE : +# MAILLAGE maillage a partitionner +# MODELE modele (facultatif) +# NB_PART nb de sous-domaines +# EXCIT liste des chargements +# METHODE PMETIS, KMETIS ou AUTRE +# LOGICIEL si AUTRE alors on attend un chemin complet vers executable +# NOM_GROUP_MA Un nom de base pour les group_ma contenant les SD +# INFO 1,2 +# +# =========================================================================== +# script PYTHON : lancement de DEFI_PART_PA_OPS et de DEFI_PART_OPS + + +def defi_part_feti_ops(self,NB_PART,METHODE,TRAITER_BORDS,NOM_GROUP_MA,CORRECTION_CONNEX,INFO,**args): + + import aster, string, sys + + from Accas import _F + from Noyau.N_utils import AsType + + from Utilitai import partition + + # DEBUT DE LA MACRO + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + ier=0 + + # On importe les definitions des commandes a utiliser dans la macro + DEFI_PART_OPS = self.get_cmd('DEFI_PART_OPS') + INFO_EXEC_ASTER = self.get_cmd('INFO_EXEC_ASTER') + DEFI_FICHIER = self.get_cmd('DEFI_FICHIER') + DETRUIRE = self.get_cmd('DETRUIRE') + DEFI_PART_PA_OPS = self.get_cmd('DEFI_PART_PA_OPS') + + nompro='DEFI_PART_FETI' + + # Maillage + if args.has_key('MODELE'): + if args['MODELE'] != None: + __MOD = string.ljust(args['MODELE'].nom,8) + __MOD =__MOD+'.MODELE .NOMA ' + __LMAIL = aster.getvectjev(__MOD) + __MAIL = string.strip(__LMAIL[0]) + MAILLAGE=self.get_sd_avant_etape(__MAIL,self) + else: + MAILLAGE=args['MAILLAGE'] + + # Nom des GROUP_MA générés + NOM_GROUP_MA = string.strip(NOM_GROUP_MA) + + # Test sur le nombre de caractères de NOM_GROUP_MA + if ( len(NOM_GROUP_MA)+len(str(NB_PART)) > 7 ): + ln=7-len(str(NB_PART)) + UTMESS('F', nompro, 'Afin de pouvoir générer les GROUP_MA, réduisez le nombre '\ + 'de caractères de NOM_GROUP_MA à un maximum de : %i' %ln) + + # Verification que des GROUP_MA ne portent pas deja les memes noms + _lst = [] + for i in MAILLAGE.LIST_GROUP_MA(): + _lst.append( string.strip(i[0]) ) + for i in range(NB_PART): + if ( NOM_GROUP_MA+str(i) in _lst ): + ngrma=NOM_GROUP_MA+str(i) + UTMESS('F', nompro, "Il existe déjà un GROUP_MA nommé : %s" %ngrma) + if args.has_key('NOM_GROUP_MA_BORD') : + if args['NOM_GROUP_MA_BORD'] != None : + if ( args['NOM_GROUP_MA_BORD']+str(i) in _lst ): + ngrma=args['NOM_GROUP_MA_BORD']+str(i) + UTMESS('F', nompro, "Il existe déjà un GROUP_MA nommé : %s" %ngrma) + + # Le concept sortant dans le contexte de la macro + self.DeclareOut('_SDFETI',self.sd) + + # Debut : + + # Regeneration des mots-cles GROUPAGE passés en argument de la macro + motscle1= {} + if args.has_key('GROUPAGE'): + if args['GROUPAGE'] != None : + dGroup=[] + for j in args['GROUPAGE']: + dGroup.append(j.cree_dict_valeurs(j.mc_liste)) + for i in dGroup[-1].keys(): + if dGroup[-1][i]==None : del dGroup[-1][i] + motscle1['GROUPAGE']=dGroup + + # Regeneration des mots-cles POIDS_MAILLES passés en argument de la macro + if args.has_key('POIDS_MAILLES'): + if args['POIDS_MAILLES'] != None : + dEval=[] + for j in args['POIDS_MAILLES']: + dEval.append(j.cree_dict_valeurs(j.mc_liste)) + for i in dEval[-1].keys(): + if dEval[-1][i]==None : del dEval[-1][i] + motscle1['POIDS_MAILLES']=dEval + + # Y a t'il présence du mot clé : NOM_GROUP_MA_BORD + if args.has_key('GROUP_MA_BORD'): + if args['GROUP_MA_BORD'] != None : + motscle1['GROUP_MA_BORD']=args['GROUP_MA_BORD'] + + # Y a t'il présence du mot clé : LOGICIEL + if args.has_key('LOGICIEL'): + if args['LOGICIEL'] != None : + motscle1['LOGICIEL']=args['LOGICIEL'] + + # Y a t'il présence du mot clé : MODELE + if args.has_key('MODELE'): + if args['MODELE'] != None : + motscle1['MODELE']=args['MODELE'] + + # Partitionnement + _SDFETI=DEFI_PART_PA_OPS( + MAILLAGE=MAILLAGE, + INFO=INFO, + METHODE=METHODE, + NB_PART=NB_PART, + CORRECTION_CONNEX=CORRECTION_CONNEX, + TRAITER_BORDS=TRAITER_BORDS, + NOM_GROUP_MA=NOM_GROUP_MA, + **motscle1 + ); + + # Liste des groupes de mailles du maillage + _LST_GMA = MAILLAGE.LIST_GROUP_MA() + _LST_GMA = map(lambda x: x[0], _LST_GMA) + + # Creation de la SDFETI + if args.has_key('MODELE'): + if args['MODELE'] != None : + _tmp = [] + for i in range(NB_PART): + txt = { 'GROUP_MA': NOM_GROUP_MA + str(i) } + _tmp.append( txt ) + + if args.has_key('NOM_GROUP_MA_BORD') : + if args['NOM_GROUP_MA_BORD'] != None : + if ( args['NOM_GROUP_MA_BORD']+str(i) in _LST_GMA ): + txt['GROUP_MA_BORD'] = string.strip(args['NOM_GROUP_MA_BORD']) + str(i) + _tmp.append( txt ) + + motscle2= {'DEFI': _tmp } + + # Regeneration des mots-cles EXCIT passés en argument de la macro + if args.has_key('EXCIT'): + if args['EXCIT'] != None : + dExcit=[] + for j in args['EXCIT']: + dExcit.append(j.cree_dict_valeurs(j.mc_liste)) + for i in dExcit[-1].keys(): + if dExcit[-1][i]==None : del dExcit[-1][i] + motscle2['EXCIT']=dExcit + + _SDFETI=DEFI_PART_OPS(NOM='SDD', + MODELE=args['MODELE'], + INFO=1, + **motscle2 + ); + else: + _SDFETI=None + + else: + _SDFETI=None + + + # Fin : + + return ier diff --git a/Aster/Cata/cataSTA81/Macro/fiabilite_fichier.py b/Aster/Cata/cataSTA81/Macro/fiabilite_fichier.py new file mode 100644 index 00000000..1462a5ec --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/fiabilite_fichier.py @@ -0,0 +1,335 @@ +#@ MODIF fiabilite_fichier Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS +# +class fiabilite_fichier : +# + """ Classe des fichiers de données des logiciels fiabilistes + Cette classe a été mise au point pour le couplage entre + Code_ASTER et MEFISTO, mais pourrait servir ailleurs. + """ +# +# +#==== +# 1. Le constructeur +#==== +# +# + def __init__ ( self, jdc, Rep_Calc_LOGICIEL_global, nomfic, info = 1 ) : +# +# jdc : le jeu de commandes en cours de traitement +# + self.jdc = jdc +# +# Rep_Calc_LOGICIEL_global : le répertoire d'exécution du logiciel de fiabilité +# + self.Rep_Calc_LOGICIEL_global = Rep_Calc_LOGICIEL_global +# +# nomfic : nom local du fichier à créer +# + self.nomfic = nomfic +# +# messages_erreur : messages d'erreur +# + self.messages_erreur = { 0 : "Tout va bien", + 1 : "==> Ce fichier est inconnu.", + 2 : "==> Ce type d'ouverture est inconnu.", + 10 : "==> Problème à l'ouverture.", + 11 : "==> Problème à la fermeture.", + 20 : "==> Problème à l'impression." } +# +# info : niveau d'information au sens ASTER +# + self.info = info +# +# ligne_sep : ligne de séparation +# + self.ligne_sep = "=========================================================" + self.ligne_commentaire = "#" + self.ligne_sep + "\n" +# + if info >= 2 : + print "Création du fichier : "+self.nomfic +# +#==== +# 2. Ouverture du fichier +#==== +# + def Ouvre_Fichier ( self, type_ouvr ) : +# +# 2.0. ==> Préalables +# + """ + Ouvre le fichier en lecture ou écriture. + 0 : tout s'est bien passé + 1 : on veut ouvrir en lecture un fichier qui n'existe pas + 2 : le mode d'ouverture est inconnu + 10 : impossible d'ouvrir + """ +# + import os +# +# 2.1. ==> Le nom global du fichier +# + self.nomfic_global = os.path.join(self.Rep_Calc_LOGICIEL_global,self.nomfic) +# +# 2.2. ==> Controles +# + erreur = 0 +# + if ( type_ouvr == "w" or type_ouvr == "r" ) : +# + if ( type_ouvr == "r" ) : + if not os.path.isfile(self.nomfic_global) : + erreur = 1 + + else : +# + self.jdc.cr.warn("Type d'ouverture : "+type_ouvr) + erreur = 2 +# +# 2.3. ==> Ouverture vraie +# + if not erreur : +# + erreur_partiel = [0] + try : + self.fic = open( self.nomfic_global, type_ouvr ) + except os.error,erreur_partiel : + self.jdc.cr.warn("Code d'erreur de open : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1]) + erreur = 10 +# +# 2.4. ==> C'est fini +# + if erreur : + self.jdc.cr.warn("Fichier : "+self.nomfic) + self.jdc.cr.warn(self.messages_erreur[erreur]) +# + return erreur +# +#==== +# 3. Fermeture du fichier +#==== +# + def Ferme_Fichier ( self ) : +# +# 3.0. ==> Préalables +# + """ + Ferme le fichier. + 0 : tout s'est bien passé + 20 : impossible d'imprimer + """ +# + import os +# +# 3.1. ==> Controles +# + erreur = 0 +# + if not os.path.isfile(self.nomfic_global) : + erreur = 1 +# +# 3.2. ==> Fermeture vraie +# + if not erreur : +# + erreur_partiel = [0] + try : + self.fic.close( ) + except os.error,erreur_partiel : + self.jdc.cr.warn("Code d'erreur de close : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1]) + erreur = 11 +# +# 3.3. ==> C'est fini +# + if erreur : + self.jdc.cr.warn("Fichier : "+self.nomfic) + self.jdc.cr.warn(self.messages_erreur[erreur]) +# + return erreur +# +#==== +# 4. Impression du contenu du fichier +#==== +# + def Imprime_Fichier ( self ) : +# +# 4.0. ==> Préalables +# + """ + Imprime le fichier. + 0 : tout s'est bien passé + 20 : impossible d'imprimer + """ +# +# 4.1. ==> Lecture +# + erreur = self.Ouvre_Fichier ( "r" ) + if not erreur : + les_lignes = self.fic.readlines() + erreur = self.Ferme_Fichier ( ) +# +# 4.2. ==> Impression +# + if not erreur : +# + print "\n"+self.ligne_sep + print "Contenu du fichier " + self.nomfic," :" + for ligne in les_lignes : + print ligne[:-1] + print self.ligne_sep+"\n" +# +# 4.4. ==> C'est fini +# + if erreur : + erreur = 20 + self.jdc.cr.warn("Fichier : "+self.nomfic) + self.jdc.cr.warn(self.messages_erreur[erreur]) +# + return erreur +# +#==== +# 5. Ecriture de lignes de commentaires +#==== +# + def Ecrit_Commentaires ( self, comm ) : +# + """ + Liste = commentaires à écrire + Soit c'est une chaine qu'on écrit sur une ligne ; + Soit c'est une liste, qu'on écrit à raison de une par ligne. + Remarque : cela suppose que le fichier est ouvert en écriture + """ +# + if type(comm) == type([ ]) : + Liste = comm + else : + Liste = [comm] +# + for ligne in Liste : + self.fic.write("# "+str(ligne)+"\n") +# +#==== +# 6. Ecriture de lignes de titres +#==== +# + def Ecrit_Titre ( self, comm ) : +# + """ + Liste = commentaires à écrire, encadrés par des séparateurs + Soit c'est une chaine qu'on écrit sur une ligne ; + Soit c'est une liste, qu'on écrit à raison de une par ligne. + Remarque : cela suppose que le fichier est ouvert en écriture + """ +# + self.fic.write(self.ligne_commentaire) + self.Ecrit_Commentaires(comm) + self.fic.write(self.ligne_commentaire) +# +#==== +# 7. Ecriture d'une ligne de valeurs +#==== +# + def Ecrit_Valeurs ( self, val ) : +# + """ + Liste = liste des valeurs à écrire, représenatn une ligne + Remarque : cela suppose que le fichier est ouvert en écriture + """ +# + if type(val) == type([ ]) : + ligne = " " + for aux in val : + ligne = ligne + " " + str(aux) + else : + ligne = str(val) +# + self.fic.write(ligne+"\n") +# +# +#======================================================================================= +#======================================================================================= + + +# +# +if __name__ == "__main__" : +# + import os + import sys + import tempfile +# +# 1. ==> Préalable +# + Rep_Calc_LOGICIEL_global = tempfile.mktemp() + os.mkdir(Rep_Calc_LOGICIEL_global) +# + jdc = None +# +# 2. ==> Création de la classe +# + nomfic = "dataGrad" + fic = fiabilite_fichier ( jdc, Rep_Calc_LOGICIEL_global , nomfic ) +# +# 3. ==> Ouverture du fichier +# + erreur = fic.Ouvre_Fichier ( "w" ) +# +# 4. ==> Remplissage du fichier +# + if not erreur : + aux = ["Titre 1", "Titre 2"] + fic.Ecrit_Titre (aux) + aux = ["Ligne 1", "Ligne 2"] + fic.Ecrit_Commentaires (aux) + aux = "Ligne en forme de chaine" + fic.Ecrit_Commentaires (aux) + aux = 1789.1792 + fic.Ecrit_Commentaires (aux) + aux = [1, 0.0] + fic.Ecrit_Valeurs (aux) + aux = 1958. + fic.Ecrit_Valeurs (aux) +# +# 5. ==> Fermeture du fichier +# + if not erreur : + erreur = fic.Ferme_Fichier ( ) +# +# 4. ==> Impression du fichier +# + if not erreur : + erreur = fic.Imprime_Fichier ( ) +# +# 4. ==> La fin +# + Liste = os.listdir(Rep_Calc_LOGICIEL_global) +# + for nomfic in Liste : + fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic) + os.chmod (fic_total,0755) + os.remove (fic_total) + os.rmdir (Rep_Calc_LOGICIEL_global) +# + if erreur : + mess = "Erreur " + str(erreur) + else : + mess = "Fin normale." + sys.exit(mess) diff --git a/Aster/Cata/cataSTA81/Macro/fiabilite_mefisto.py b/Aster/Cata/cataSTA81/Macro/fiabilite_mefisto.py new file mode 100644 index 00000000..3f820843 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/fiabilite_mefisto.py @@ -0,0 +1,448 @@ +#@ MODIF fiabilite_mefisto Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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. +# ====================================================================== + + +# RESPONSABLE GNICOLAS G.NICOLAS +# +def fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global, + INFO, VERSION, + SEUIL, SEUIL_TYPE, + VARIABLE, + valeurs_lois, + **args ) : +# +# valeurs_lois est un dictionnaire indexé sur les variables. +# Chaque case, valeurs_lois[m], est un dictionnaire contenant : +# d["v_moy_physique"] = valeur moyenne physique +# d["v_moy_loi"] = valeur moyenne de la loi +# d["v_min_loi"] = valeur minimale de la loi +# d["v_max_loi"] = valeur maximale de la loi +# d["sigma_loi"] = ecart type de la loi +# +# args est le dictionnaire des arguments optionnels +# 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. +# + """ Ecriture des données spécifiques à MEFISTO. """ +# + from Macro import fiabilite_fichier + import os + import string +# +#____________________________________________________________________ +# +# 1. Préalables +#____________________________________________________________________ +# +# + messages_erreur = { 0 : "Tout va bien", + 1 : "Fichier inconnu.", + 2 : "Problème d'ouverture de fichier.", + 10 : "Problème d'ouverture de fichier.", + 11 : "Problème de fermeture de fichier.", + 20 : "Problème d'impression de fichier.", + 50 : "Donnée inacceptable.", + 100 : "Erreur." } +# + trad_oui_non = { "OUI" : 1, + "NON" : 0 } +# + erreur = 0 +# + while not erreur : +# +#____________________________________________________________________ +# +# 2. Les fichiers pour le logiciel de fiabilité +# Ils sont créés dans le répertoire d'exécution du logiciel de fiabilité, avec leurs noms officiels +#____________________________________________________________________ +# +# + fic_dataMenu = "dataMenu" + fic_dataStoch = "dataStoch" + fic_dataNum = "dataNum" + fic_dataGrad = "dataGrad" +# +#____________________________________________________________________ +# +# 3. Construction du fichier 'dataMenu' +#____________________________________________________________________ +# +# 3.1 ==> Ouverture du fichier +# + f_menu = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataMenu, INFO ) + erreur = f_menu.Ouvre_Fichier ( "w" ) + if erreur : + break +# +# 3.2 ==> Ecriture des données nécessaires +# + f_menu.Ecrit_Titre ("MENU DU PROGRAMME MEFISTO") + f_menu.Ecrit_Titre ("1 <=> OUI et 0 <=> NON (entiers)") +# + f_menu.Ecrit_Titre ("Recherche du point de conception") + aux = trad_oui_non[args["RECH_PT_CONCEPT"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("First Order Reliability Analyses") + aux = trad_oui_non[args["METHODE_FORM"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Second Order Reliability Analyses") + aux = trad_oui_non[args["METHODE_SORM"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Importance Sampling Analyses") + aux = trad_oui_non[args["TIRAGE_IMPORTANCE"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Optimality Test (1) : Hessian Test") + aux = trad_oui_non[args["T_HESSIEN"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Optimality Test (2) : Sphere Test") + aux = trad_oui_non[args["T_SPHERE"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Optimality Test (3) : Strong Max Test") + aux = trad_oui_non[args["T_MAXIMUM_FORT"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Experiment Plan") + aux = trad_oui_non[args["PLAN_EXPERIENCE"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Polynomial Taylor Approximation (order 2)") + aux = trad_oui_non[args["POLYNOME_TAYLOR"]] + f_menu.Ecrit_Valeurs (aux) +# +# 3.3 ==> Fermeture du fichier +# + erreur = f_menu.Ferme_Fichier ( ) + if erreur : + break +# + if INFO >= 2 : + erreur = f_menu.Imprime_Fichier ( ) + if erreur : + break +# +#____________________________________________________________________ +# +# 4. Construction du fichier "dataStoch" +#____________________________________________________________________ +# +# 4.1 ==> Ouverture du fichier +# + f_stoch = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataStoch, INFO ) + erreur = f_stoch.Ouvre_Fichier ( "w" ) + if erreur : + break +# +# 4.2 ==> Nombre d'occurence de VARIABLE +# + nb_occu_variable = len(VARIABLE) +# +# 4.3 ==> Ecriture des données nécessaires +# + f_stoch.Ecrit_Titre ("Code name") + aux=string.replace(VERSION,"_",".") + aux=string.replace(aux,"N","n") + aux=string.replace(aux,"V","v") + f_stoch.Ecrit_Valeurs ( "aster_" + aux ) +# + aux = [ "Gradients evaluated by the code" ] + aux.append("1 : Au moins 1 ; 0 : aucun") + f_stoch.Ecrit_Titre (aux) + gradient = 0 + for m in VARIABLE : + if m["GRADIENT"] == "OUI" : gradient = 1 + f_stoch.Ecrit_Valeurs (gradient) +# + f_stoch.Ecrit_Titre ("Variates number") + f_stoch.Ecrit_Valeurs ( nb_occu_variable ) +# + aux = [ "Stochastic Variates" ] + aux.append("1: Uniforme (min, max)") + aux.append("2: Normal (mean, std dev)") + aux.append("3: LogNormal (mean, std dev, min)") + aux.append("4: Normal Truncated (mean, std dev, min, max)") + f_stoch.Ecrit_Titre (aux) +# + for m in VARIABLE : +# + d = valeurs_lois[m] + if m["LOI"] == "UNIFORME" : + f_stoch.Ecrit_Valeurs ( [ m["NOM"], 1 , d["v_min_loi"] , d["v_max_loi"] ] ) + elif m["LOI"] == "NORMALE" : + f_stoch.Ecrit_Valeurs ( [ m["NOM"], 2 , d["v_moy_loi"] , d["sigma_loi"] ] ) + elif m["LOI"] == "LOGNORMALE" : + f_stoch.Ecrit_Valeurs ( [ m["NOM"], 3 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] ] ) + elif m["LOI"] == "NORMALE_TRONQUEE" : + f_stoch.Ecrit_Valeurs ( [ m["NOM"], 4 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] , d["v_max_loi"] ] ) + else : + erreur = 50 +# + if erreur : + break +# + f_stoch.Ecrit_Titre ("Initial Points") + for m in VARIABLE : + if m["POINT_INI"] is None : + aux = valeurs_lois[m]["v_moy_physique"] + else : + aux = m["POINT_INI"] + f_stoch.Ecrit_Valeurs ( aux ) +# + f_stoch.Ecrit_Titre ("Reference Points") + for m in VARIABLE : + if m["POINT_REF"] is None : + aux = valeurs_lois[m]["v_moy_physique"] + else : + aux = m["POINT_REF"] + f_stoch.Ecrit_Valeurs ( aux ) +# + f_stoch.Ecrit_Titre ("Design Points") + for m in VARIABLE : + if args["RECH_PT_CONCEPT"] == "OUI" : + aux = 1792. + elif m["POINT_CONCEPT"] is None : + aux = valeurs_lois[m]["v_moy_physique"] + else : + aux = m["POINT_CONCEPT"] + f_stoch.Ecrit_Valeurs ( aux ) +# + f_stoch.Ecrit_Titre ("Correlation matrix fictive") + for m in range(nb_occu_variable) : + aux = [ ] + for n in range(nb_occu_variable) : + aux.append(args["MATRICE"][n + m*nb_occu_variable]) + f_stoch.Ecrit_Valeurs ( aux ) +# + f_stoch.Ecrit_Titre ("Parameter threshold value") + if SEUIL_TYPE == "MAXIMUM" : + aux = SEUIL + else : + aux = -SEUIL + f_stoch.Ecrit_Valeurs ( aux ) +# +# 4.4 ==> Fermeture du fichier +# + erreur = f_stoch.Ferme_Fichier ( ) + if erreur : + break +# + if INFO >= 2 : + erreur = f_stoch.Imprime_Fichier ( ) + if erreur : + break +# +#____________________________________________________________________ +# +# 5. Construction du fichier 'dataNum' +#____________________________________________________________________ +# +# 5.1 ==> Ouverture du fichier +# + f_num = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataNum, INFO ) + erreur = f_num.Ouvre_Fichier ( "w" ) + if erreur : + break +# +# 5.2 ==> Ecriture des données nécessaires +# + f_num.Ecrit_Titre ("Parameters : EpsU, EpsG, Tau, Omega, iterMax") + if args["RECH_PT_CONCEPT"] == "OUI" : + f_num.Ecrit_Valeurs (args["EPSILON_U"]) + f_num.Ecrit_Valeurs (args["EPSILON_G"]) + f_num.Ecrit_Valeurs (args["TAU"]) + f_num.Ecrit_Valeurs (args["OMEGA"]) + f_num.Ecrit_Valeurs (args["ITER_MAX"]) + else : + aux = 0.1848 + for k in range(5) : + f_num.Ecrit_Valeurs (aux) +# + f_num.Ecrit_Titre ("Parameters : hgrad, hhess") + f_num.Ecrit_Valeurs (args["HGRAD"]) + f_num.Ecrit_Valeurs (args["HHESS"]) +# + aux = [ "Parameter Optimality Test(sphere)" ] + aux.append("1: Parametric Method (Point Number in each direction)") + aux.append("2: Gaussian Method (Total Point Number)") + aux.append("3: Rejection Method (Total Point Number)") + f_num.Ecrit_Titre (aux) +# + if args["T_SPHERE"] == "OUI" : +# + if args["METHODE_TEST"] == "PARAMETRIQUE" : + aux1 = 1 + elif args["METHODE_TEST"] == "GAUSSIENNE" : + aux1 = 2 + elif args["METHODE_TEST"] == "REJECTION" : + aux1 = 3 + else : + self.cr.warn("METHODE DE TEST : "+args["METHODE_TEST"]) + erreur = 50 + break +# + aux2 = args["NB_POINT"] +# + else : +# +# remarque : il faut mettre une valeur plausible en aux1, sinon plantage violent ... + aux1 = 1 + aux2 = 1789 +# + f_num.Ecrit_Valeurs ( [ aux1 , aux2 ] ) +# + aux = [ "Parameters : alpha, beta" ] + aux.append("alpha: common net") + aux.append("beta: extreme net") + f_num.Ecrit_Titre (aux) + if args["PLAN_EXPERIENCE"] == "OUI" : + aux1 = args["ALPHA"] + aux2 = args["BETA"] + else : + aux1 = 1789.0 + aux2 = 1789.0 + f_num.Ecrit_Valeurs ( aux1 ) + f_num.Ecrit_Valeurs ( aux2 ) +# + f_num.Ecrit_Titre ("Parameters Strong Max Test : cosLim, dProb") + if args["T_MAXIMUM_FORT"] == "OUI" : + aux1 = args["COS_LIM"] + aux2 = args["DPROB"] + else : + aux1 = 0.1789 + aux2 = 0.1789 + f_num.Ecrit_Valeurs ( aux1 ) + f_num.Ecrit_Valeurs ( aux2 ) +# + f_num.Ecrit_Titre ("Parameter Importance Samplings : Simulation Number") + if args["TIRAGE_IMPORTANCE"] == "OUI" : + aux = args["NB_SIMULATION"] + else : + aux = 1945 + f_num.Ecrit_Valeurs ( aux ) +# +# 5.3 ==> Fermeture du fichier +# + erreur = f_num.Ferme_Fichier ( ) + if erreur : + break +# + if INFO >= 2 : + erreur = f_num.Imprime_Fichier ( ) + if erreur : + break +# +#____________________________________________________________________ +# +# 6. Construction du fichier 'dataGrad' +#____________________________________________________________________ +# +# 6.1 ==> Création du fichier +# + f_grad = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataGrad, INFO ) + erreur = f_grad.Ouvre_Fichier ( "w" ) + if erreur : + break +# +# 6.2 ==> Ecriture des données nécessaires +# + f_grad.Ecrit_Titre ("Commentaires") +# + for m in VARIABLE : + f_grad.Ecrit_Commentaires (m["NOM"]) + if m["GRADIENT"] == "OUI" : + gradient = 1 + increment = 0.0 + else : + gradient = 0 + increment = m["INCREMENT"] + aux = [gradient,increment] + f_grad.Ecrit_Valeurs (aux) +# +# 6.3 ==> Fermeture du fichier +# + erreur = f_grad.Ferme_Fichier ( ) + if erreur : + break +# + if INFO >= 2 : + erreur = f_grad.Imprime_Fichier ( ) + if erreur : + break +# +#____________________________________________________________________ +# +# 7. C'est fini ! +#____________________________________________________________________ +# + break +# + if erreur : + if not messages_erreur.has_key(erreur) : + erreur = 100 + self.cr.warn(messages_erreur[erreur]) + erreur = 11 +# + return erreur +# +########################## Fin de la fonction################################## +# +########################## Auto-test################################## +# +if __name__ == "__main__" : +# + import os + import sys + import tempfile +# + Rep_Calc_LOGICIEL_global = tempfile.mktemp() + os.mkdir(Rep_Calc_LOGICIEL_global) +# + INFO = 2 + VERSION = "V3_2" + SEUIL = 1789. + SEUIL_TYPE = "MAXIMUM" + VARIABLE = [] + args = {} + valeurs = {} +# + erreur = fiabilite_mefisto ( None, Rep_Calc_LOGICIEL_global, + INFO, VERSION, + SEUIL, SEUIL_TYPE, + VARIABLE, + valeurs, + **args ) +### print "Erreur = ", erreur + Liste = os.listdir(Rep_Calc_LOGICIEL_global) +# + for nomfic in Liste : + fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic) + os.chmod (fic_total,0755) + os.remove (fic_total) + os.rmdir (Rep_Calc_LOGICIEL_global) +# + sys.exit("blabla") diff --git a/Aster/Cata/cataSTA81/Macro/impr_fonction_ops.py b/Aster/Cata/cataSTA81/Macro/impr_fonction_ops.py new file mode 100644 index 00000000..a05fff1c --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/impr_fonction_ops.py @@ -0,0 +1,402 @@ +#@ MODIF impr_fonction_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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. +# ====================================================================== + +# RESPONSABLE MCOURTOI M.COURTOIS + +import os.path + +# ------------------------------------------------------------------------------ +def impr_fonction_ops(self, FORMAT, COURBE, INFO, **args): + """ + Macro IMPR_FONCTION permettant d'imprimer dans un fichier des fonctions, + colonnes de table... + Erreurs dans IMPR_FONCTION pour ne pas perdre la base. + """ + macro='IMPR_FONCTION' + import pprint + import aster + from Accas import _F + from Utilitai import Graph + from Utilitai.Utmess import UTMESS + from Utilitai.UniteAster import UniteAster + ier=0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # On importe les definitions des commandes a utiliser dans la macro + # Le nom de la variable doit etre obligatoirement le nom de la commande + CALC_FONC_INTERP = self.get_cmd('CALC_FONC_INTERP') + DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL') + DETRUIRE = self.get_cmd('DETRUIRE') + + #---------------------------------------------- + # 0. Traitement des arguments, initialisations + # unité logique des fichiers réservés + ul_reserve=(8,) + UL = UniteAster() + + # 0.1. Fichier + nomfich=None + if args['UNITE'] and args['UNITE']<>6: + nomfich=UL.Nom(args['UNITE']) + if INFO==2: + aster.affiche('MESSAGE', ' Nom du fichier :'+nomfich+'\n') + if nomfich and os.path.exists(nomfich) and os.stat(nomfich).st_size<>0: + if FORMAT=='XMGRACE': + niv='A' + else: + niv='I' + UTMESS(niv,macro,'Le fichier '+nomfich+' existe déjà, on écrit ' \ + 'à la suite.') + + # 0.2. Récupération des valeurs sous COURBE + unparmi=('FONCTION','LIST_RESU','FONC_X','ABSCISSE') + + # i0 : indice du mot-clé facteur qui contient LIST_PARA, sinon i0=0 + i0=0 + Courbe=[] + iocc=-1 + for Ci in COURBE: + iocc+=1 + dC = Ci.cree_dict_valeurs(Ci.mc_liste) + if dC.has_key('LIST_PARA') and dC['LIST_PARA']!=None and i0==0: + i0=iocc + for mc in dC.keys(): + if dC[mc]==None: del dC[mc] + Courbe.append(dC) + if INFO==2: + aster.affiche('MESSAGE',' Nombre de fonctions à analyser : '+str(len(Courbe))+'\n') + + # 0.3. Devra-t-on interpoler globalement ? + # Dans ce cas, linter__ est le LIST_PARA + # ou, à défaut, les abscisses de la première courbe + interp=False + if FORMAT=='TABLEAU': + interp=True + dCi=Courbe[i0] + if dCi.has_key('LIST_PARA'): + linter__=dCi['LIST_PARA'] + else: + obj=None + for typi in unparmi: + if dCi.has_key(typi): + obj=dCi[typi] + typ=obj.__class__.__name__ + break + if obj==None: + UTMESS('S',macro,'incohérence entre le catalogue et la macro.') + if typi=='FONCTION': + if typ=='nappe_sdaster': + lpar,lval=obj.Valeurs() + linterp=lval[0][0] + else: + linterp=obj.Valeurs()[0] + elif typi=='FONC_X': + lbid,linterp=obj.Valeurs() + elif typi=='ABSCISSE': + linterp=obj + linter__=DEFI_LIST_REEL(VALE=linterp) + if INFO==2: + aster.affiche('MESSAGE', ' Interpolation globale sur la liste :\n'+pprint.pformat(linter__.Valeurs())+'\n') + + + #---------------------------------------------- + # 1. Récupération des valeurs des N courbes sous forme + # d'une liste de N listes + #---------------------------------------------- + graph=Graph.Graph() + iocc=-1 + for dCi in Courbe: + iocc+=1 + + # 1.1. Type d'objet à traiter + obj=None + for typi in unparmi: + if dCi.has_key(typi): + obj=dCi[typi] + typ=obj.__class__.__name__ + break + if not dCi.has_key('LEGENDE') and hasattr(obj,'get_name'): + dCi['LEGENDE']=obj.get_name() + if obj==None: + UTMESS('S',macro,'incohérence entre le catalogue et la macro.') + + # 1.2. Extraction des valeurs + + # 1.2.1. Mot-clé FONCTION + if typi=='FONCTION': + if typ=='nappe_sdaster': + lpar,lval=obj.Valeurs() + dico,ldicf=obj.Parametres() + Leg=dCi['LEGENDE'] + for i in range(len(lpar)): + p=lpar[i] + lx=lval[i][0] + ly=lval[i][1] + # sur quelle liste interpoler chaque fonction + if i==0: + if interp: + li__=linter__ + elif dCi.has_key('LIST_PARA'): + li__=dCi['LIST_PARA'] + else: + li__=DEFI_LIST_REEL(VALE=lx) + # compléter les paramètres d'interpolation + dic=dico.copy() + dic.update(ldicf[i]) + + if (interp or dCi.has_key('LIST_PARA')) and i>0: + ftmp__=CALC_FONC_INTERP( + FONCTION=obj, + VALE_PARA=p, + LIST_PARA_FONC=li__, + **dic + ) + pv,lv2=ftmp__.Valeurs() + lx=lv2[0][0] + ly=lv2[0][1] + # on stocke les données dans le Graph + nomresu=dic['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)) + dicC={ + 'Val' : [lx,ly], + 'Lab' : [dic['NOM_PARA_FONC'],nomresu] + } + # ajoute la valeur du paramètre + dCi['LEGENDE'] = '%s %s=%g' % (Leg,dic['NOM_PARA'].strip(),p) + Graph.AjoutParaCourbe(dicC, args=dCi) + graph.AjoutCourbe(**dicC) + DETRUIRE(CONCEPT=_F(NOM=('li__','ftmp__'),),ALARME='NON',INFO=1) + else: + ftmp__=obj + dpar=ftmp__.Parametres() + if interp: + ftmp__=CALC_FONC_INTERP( + FONCTION=obj, + LIST_PARA=linter__, + **dpar + ) + elif dCi.has_key('LIST_PARA'): + ftmp__=CALC_FONC_INTERP( + FONCTION=obj, + LIST_PARA=dCi['LIST_PARA'], + **dpar + ) + lval=list(ftmp__.Valeurs()) + lx=lval[0] + lr=lval[1] + if typ=='fonction_c' and dCi.has_key('PARTIE'): + if dCi['PARTIE']=='IMAG' : lr=lval[2] + # on stocke les données dans le Graph + if typ=='fonction_c' and not dCi.has_key('PARTIE'): + nomresu=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)) + dicC={ + 'Val' : lval, + 'Lab' : [dpar['NOM_PARA'],nomresu+'_R',nomresu+'_I'] + } + else: + nomresu=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)) + dicC={ + 'Val' : [lx,lr], + 'Lab' : [dpar['NOM_PARA'],nomresu] + } + Graph.AjoutParaCourbe(dicC, args=dCi) + graph.AjoutCourbe(**dicC) + + # 1.2.2. Mot-clé LIST_RESU + elif typi=='LIST_RESU': + if interp and iocc>0: + UTMESS('S',macro,"""Il n'y a pas de règles d'interpolation pour LIST_PARA/LIST_RESU, + LIST_PARA/LIST_RESU ne peut donc apparaitre qu'une seule fois + et à la première occurence de COURBE""") + lx=dCi['LIST_PARA'].Valeurs() + lr=obj.Valeurs() + if len(lx)<>len(lr): + UTMESS('S',macro,"LIST_PARA et LIST_RESU n'ont pas la meme taille") + # on stocke les données dans le Graph + dicC={ + 'Val' : [lx,lr], + 'Lab' : [dCi['LIST_PARA'].get_name(),obj.get_name()] + } + Graph.AjoutParaCourbe(dicC, args=dCi) + graph.AjoutCourbe(**dicC) + + # 1.2.3. Mot-clé FONC_X + # exemple : obj(t)=sin(t), on imprime x=sin(t), y=cos(t) + # ob2(t)=cos(t) + elif typi=='FONC_X': + ob2=dCi['FONC_Y'] + # peut-on blinder au niveau du catalogue + if typ=="nappe_sdaster" or ob2.__class__.__name__=="nappe_sdaster": + UTMESS('S',macro,"FONC_X/FONC_Y ne peuvent pas etre des nappes !") + if interp and iocc>0: + UTMESS('S',macro,"""Au format 'TABLEAU' ,FONC_X/FONC_Y ne peut apparaitre qu'une seule fois + et à la première occurence de COURBE""") + ftmp__=obj + dpar=ftmp__.Parametres() + ftm2__=ob2 + dpa2=ftm2__.Parametres() + intloc=False + if interp and not dCi.has_key('LIST_PARA'): + # dans ce cas, linter__ contient les ordonnées de FONC_X + intloc=False + li__=linter__ + elif dCi.has_key('LIST_PARA'): + intloc=True + li__=dCi['LIST_PARA'] + if intloc: + ftmp__=CALC_FONC_INTERP( + FONCTION=obj, + LIST_PARA=li__, + **dpar + ) + lt,lx=ftmp__.Valeurs() + ftm2__=CALC_FONC_INTERP( + FONCTION=ob2, + LIST_PARA=li__, + **dpa2 + ) + else: + lt,lx=ftmp__.Valeurs() + li__=DEFI_LIST_REEL(VALE=lt) + ftm2__=CALC_FONC_INTERP( + FONCTION=ob2, + LIST_PARA=li__, + **dpa2 + ) + + lbid,ly=ftm2__.Valeurs() + # on stocke les données dans le Graph + # on imprime la liste des paramètres seulement si LIST_PARA + if intloc: + nomresur=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)) + nomresu2=dpa2['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)+1) + dicC={ + 'Val' : [lt,lx,ly], + 'Lab' : [dpar['NOM_PARA'],nomresur,nomresu2] + } + else: + nomresur=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)) + nomresu2=dpa2['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)+1) + dicC={ + 'Val' : [lx,ly], + 'Lab' : [nomresur,nomresu2] + } + Graph.AjoutParaCourbe(dicC, args=dCi) + graph.AjoutCourbe(**dicC) + + # 1.2.4. Mot-clé ABSCISSE / ORDONNEE + elif typi=='ABSCISSE': + if interp and iocc>0: + UTMESS('S',macro,"""Il n'y a pas de règles d'interpolation pour ABSCISSE/ORDONNEE, + ABSCISSE/ORDONNEE ne peut donc apparaitre qu'une seule fois + et à la première occurence de COURBE""") + lx=obj + lr=dCi['ORDONNEE'] + if len(lx)<>len(lr): + UTMESS('S',macro,"ABSCISSE et ORDONNEE n'ont pas la meme taille") + # on stocke les données dans le Graph + dicC={ + 'Val' : [lx,lr], + 'Lab' : ['Absc','Ordo'] + } + Graph.AjoutParaCourbe(dicC, args=dCi) + graph.AjoutCourbe(**dicC) + + # 1.2.9. ménage + DETRUIRE(CONCEPT=_F(NOM=('li__','ftmp__','ftm2__'),),ALARME='NON',INFO=1) + + # 1.2.99. ménage hors boucle + DETRUIRE(CONCEPT=_F(NOM=('linter__'),), ALARME='NON',INFO=1) + + # 1.3. dbg + if INFO==2: + message='\n'+'-'*70+'\n Contenu du Graph : \n'+'-'*70 + message=message+graph.__repr__() + message=message+'-'*70+'\n' + aster.affiche('MESSAGE',message) + + #---------------------------------------------- + # 2. Impression du 'tableau' de valeurs + #---------------------------------------------- + + # 2.0. Surcharge des propriétés du graphique et des axes + # (bloc quasiment identique dans Table) + if args['TITRE']<>None: graph.Titre=args['TITRE'] + if args['SOUS_TITRE']<>None: graph.SousTitre=args['SOUS_TITRE'] + if FORMAT in ('XMGRACE','AGRAF'): + if args['BORNE_X']<>None: + graph.Min_X=args['BORNE_X'][0] + graph.Max_X=args['BORNE_X'][1] + if args['BORNE_Y']<>None: + graph.Min_Y=args['BORNE_Y'][0] + graph.Max_Y=args['BORNE_Y'][1] + if args['LEGENDE_X']<>None: graph.Legende_X=args['LEGENDE_X'] + if args['LEGENDE_Y']<>None: graph.Legende_Y=args['LEGENDE_Y'] + if args['ECHELLE_X']<>None: graph.Echelle_X=args['ECHELLE_X'] + if args['ECHELLE_Y']<>None: graph.Echelle_Y=args['ECHELLE_Y'] + if args['GRILLE_X']<>None: graph.Grille_X=args['GRILLE_X'] + if args['GRILLE_Y']<>None: graph.Grille_Y=args['GRILLE_Y'] + + kargs={ + 'FORMAT' : FORMAT, + 'FICHIER' : nomfich, + } + + # 2.1. au format TABLEAU + if FORMAT=='TABLEAU': + # surcharge par les formats de l'utilisateur + kargs['dform']={ + 'csep' : args['SEPARATEUR'], + 'ccom' : args['COMMENTAIRE'], + 'cdeb' : args['DEBUT_LIGNE'], + 'cfin' : args['FIN_LIGNE'] + } + + # 2.2. au format AGRAF + elif FORMAT=='AGRAF': + nomdigr=None + if args['UNITE_DIGR']<>6: + nomdigr=UL.Nom(args['UNITE_DIGR']) + kargs['FICHIER']=[nomfich, nomdigr] + kargs['dform']={ 'formR' : '%12.5E' } + + # 2.3. au format XMGRACE et dérivés + elif FORMAT=='XMGRACE': + kargs['dform']={ 'formR' : '%.8g' } + kargs['PILOTE']=args['PILOTE'] + + # 2.39. Format inconnu + else: + UTMESS('S',macro,'Format inconnu : '+FORMAT) + + # Traiter le cas des UL réservées + if args['UNITE'] and args['UNITE'] in ul_reserve: + UL.Etat(args['UNITE'], etat='F') + if FORMAT=='AGRAF' and args['UNITE_DIGR']<>args['UNITE'] \ + and args['UNITE_DIGR'] in ul_reserve: + UL.Etat(args['UNITE_DIGR'], etat='F') + + # 2.4. On trace ! + graph.Trace(**kargs) + + # 99. Traiter le cas des UL réservées + UL.EtatInit() + + return ier diff --git a/Aster/Cata/cataSTA81/Macro/impr_table_ops.py b/Aster/Cata/cataSTA81/Macro/impr_table_ops.py new file mode 100644 index 00000000..60a19b2b --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/impr_table_ops.py @@ -0,0 +1,247 @@ +#@ MODIF impr_table_ops Macro DATE 19/09/2005 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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. +# ====================================================================== + +# RESPONSABLE MCOURTOI M.COURTOIS + +import os.path +import re + +from types import ListType, TupleType, StringTypes +EnumTypes=(ListType, TupleType) + + +# ------------------------------------------------------------------------------ +def impr_table_ops(self, FORMAT, TABLE, INFO, **args): + """ + Macro IMPR_TABLE permettant d'imprimer une table dans un fichier. + Erreurs dans IMPR_TABLE pour ne pas perdre la base. + """ + macro='IMPR_TABLE' + import aster + from Accas import _F + from Cata.cata import table_jeveux + from Utilitai.Utmess import UTMESS + from Utilitai.UniteAster import UniteAster + ier=0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # On importe les definitions des commandes a utiliser dans la macro + # Le nom de la variable doit etre obligatoirement le nom de la commande + DETRUIRE = self.get_cmd('DETRUIRE') + RECU_FONCTION = self.get_cmd('RECU_FONCTION') + + #---------------------------------------------- + # 0. Traitement des arguments, initialisations + # unité logique des fichiers réservés + ul_reserve=(8,) + UL = UniteAster() + + # 0.1. Fichier + nomfich=None + if args['UNITE'] and args['UNITE']<>6: + nomfich=UL.Nom(args['UNITE']) + if nomfich and os.path.exists(nomfich) and os.stat(nomfich).st_size<>0: + if FORMAT=='XMGRACE': + UTMESS('A',macro,'Le fichier '+nomfich+' existe déjà, on écrit ' \ + 'à la suite.') + + # 0.2. Création des dictionnaires des FILTRES + Filtre=[] + if args['FILTRE']: + for Fi in args['FILTRE']: + dF = Fi.cree_dict_valeurs(Fi.mc_liste) + for mc in dF.keys(): + if dF[mc]==None: del dF[mc] + Filtre.append(dF) + # format pour l'impression des filtres + form_filtre='\nFILTRE -> NOM_PARA: %-16s CRIT_COMP: %-4s VALE: %s' + + # 0.3. Création de la liste des tables (une seule sans SENSIBILITE) + form_sens='\n... SENSIBILITE AU PARAMETRE %s' + ltab=[] + if args['SENSIBILITE']: + nmemo='&NOSENSI.MEMO.CORR'.ljust(24) + vect=aster.getvectjev(nmemo) + if vect: + lps=args['SENSIBILITE'] + if not type(lps) in EnumTypes: + lps=[lps,] + for ps in [ps.get_name() for ps in lps]: + trouv=False + for ch in vect[0:len(vect):2]: + if ch[0:8].strip()==TABLE.get_name() and ch[8:16].strip()==ps: + trouv=True + ncomp=ch[16:24].strip() + sdtab=table_jeveux(ncomp) + tabs=sdtab.EXTR_TABLE() + tabs.titr+=form_sens % ps + ltab.append([tabs, sdtab]) + if not trouv: + UTMESS('A',macro,'Dérivée de %s par rapport à %s non disponible'\ + % (TABLE.get_name(), ps)) + else: + UTMESS('A',macro,'Pas de calcul de sensibilité accessible.') + else: + ltab.append([TABLE.EXTR_TABLE(), TABLE]) + + if len(ltab)<1: + return ier + + # 0.4.1. liste des paramètres à conserver + nom_para=ltab[0][0].para + if args['NOM_PARA']: + nom_para=args['NOM_PARA'] + if not type(nom_para) in EnumTypes: + nom_para=[nom_para,] + + # 0.4.2. Traiter le cas des UL réservées + if args['UNITE'] and args['UNITE'] in ul_reserve: + UL.Etat(args['UNITE'], etat='F') + + #---------------------------------------------- + # Boucle sur les tables + for tab, sdtab in ltab: + + # ----- 1. Infos de base + if INFO==2: + print 'IMPRESSION DE LA TABLE : %s' % sdtab.get_name() + + if args['TITRE']: + tab.titr=args['TITRE'] + '\n' + tab.titr + + # ----- 2. Filtres + for Fi in Filtre: + col = getattr(tab, Fi['NOM_PARA']) + # peu importe le type + opts=[Fi[k] for k in ('VALE','VALE_I','VALE_C','VALE_K') if Fi.has_key(k)] + kargs={} + for k in ('CRITERE','PRECISION'): + if Fi.has_key(k): + kargs[k]=Fi[k] + tab = tab & ( getattr(col, Fi['CRIT_COMP'])(*opts,**kargs) ) + # trace l'operation dans le titre + #if FORMAT in ('TABLEAU','ASTER'): + tab.titr+=form_filtre % (Fi['NOM_PARA'], Fi['CRIT_COMP'], \ + ' '.join([str(v) for v in opts])) + + # ----- 3. Tris + if args['TRI']: + # une seule occurence de TRI + T0=args['TRI'][0] + dT=T0.cree_dict_valeurs(T0.mc_liste) + tab.sort(CLES=dT['NOM_PARA'], ORDRE=dT['ORDRE']) + + # ----- 4. Impression + # vérification des paramètres + for p in nom_para: + if not p in tab.para: + UTMESS('A', 'IMPR_TABLE', 'Paramètre absent de la table : %s' % p) + + # sélection des paramètres + timp=tab[nom_para] + + # passage des mots-clés de mise en forme à la méthode Impr + kargs=args.copy() + kargs.update({ + 'FORMAT' : FORMAT, + 'FICHIER' : nomfich, + 'dform' : {}, + }) + # pour l'impression des fonctions + kfonc={ + 'FORMAT' : FORMAT, + 'FICHIER' : nomfich, + } + + # 4.1. au format AGRAF + if FORMAT=='AGRAF': + kargs['dform']={ 'formR' : '%12.5E' } + kfonc['FORMAT']='TABLEAU' + + # 4.2. au format XMGRACE et dérivés + elif FORMAT=='XMGRACE': + kargs['dform']={ 'formR' : '%.8g' } + kargs['PILOTE']=args['PILOTE'] + kfonc['PILOTE']=args['PILOTE'] + + # 4.3. format spécifié dans les arguments + if args['FORMAT_R']: + kargs['dform'].update({ 'formR' : fmtF2PY(args['FORMAT_R']) }) + + # 4.4. regroupement par paramètre : PAGINATION + if args['PAGINATION']: + l_ppag=args['PAGINATION'] + if not type(l_ppag) in EnumTypes: + l_ppag=[l_ppag,] + kargs['PAGINATION'] = [p for p in l_ppag if p in nom_para] + l_para_err = [p for p in l_ppag if not p in nom_para] + if len(l_para_err)>0: + UTMESS('A', 'IMPR_TABLE', 'Paramètres absents de la table (ou de '\ + 'NOM_PARA) : %s' % ', '.join(l_para_err)) + + timp.Impr(**kargs) + + # ----- 5. IMPR_FONCTION='OUI' + if args['IMPR_FONCTION'] and args['IMPR_FONCTION']=='OUI': + # cherche parmi les cellules celles qui contiennent un nom de fonction + dfon={} + for row in timp: + for par,cell in row.items(): + if type(cell) in StringTypes: + if aster.getvectjev(cell.strip().ljust(19)+'.PROL')<>None: + dfon[cell.strip().ljust(19)]=par + # impression des fonctions trouvées + for f,par in dfon.items(): + __fonc=RECU_FONCTION( + TABLE=sdtab, + FILTRE=_F( + NOM_PARA=par, + VALE_K=f, + ), + NOM_PARA_TABL=par, + ) + __fonc.Trace(**kfonc) + DETRUIRE(CONCEPT=_F(NOM=('__fonc',),), ALARME='NON', INFO=1,) + + # 99. Traiter le cas des UL réservées + UL.EtatInit() + + return ier + +# ------------------------------------------------------------------------------ +def fmtF2PY(fformat): + """Convertit un format Fortran en format Python (printf style). + Gère uniquement les fortrans réels, par exemple : E12.5, 1PE13.6, D12.5... + """ + fmt='' + matP=re.search('([0-9]+)P',fformat) + if matP: + fmt+=' '*int(matP.group(1)) + matR=re.search('([eEdDfFgG]{1})([\.0-9]+)',fformat) + if matR: + fmt+='%'+matR.group(2)+re.sub('[dD]+','E',matR.group(1)) + try: + s=fmt % -0.123 + except (ValueError, TypeError), msg: + fmt='%12.5E' + print 'Error :',msg + print 'Format par défaut utilisé :',fmt + return fmt diff --git a/Aster/Cata/cataSTA81/Macro/info_fonction_ops.py b/Aster/Cata/cataSTA81/Macro/info_fonction_ops.py new file mode 100644 index 00000000..b728f6a4 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/info_fonction_ops.py @@ -0,0 +1,252 @@ +#@ MODIF info_fonction_ops Macro DATE 12/05/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2005 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 info_fonction_ops(self,RMS,NOCI_SEISME,MAX,NORME,ECART_TYPE,**args): + """ + Ecriture de la macro INFO_FONCTION + """ + ier=0 + import string + from Utilitai.t_fonction import t_fonction,t_fonction_c,t_nappe + import math + from Accas import _F + from Utilitai.Utmess import UTMESS + + ### On importe les definitions des commandes a utiliser dans la macro + CREA_TABLE = self.get_cmd('CREA_TABLE') + CALC_FONCTION = self.get_cmd('CALC_FONCTION') + + ### Comptage commandes + déclaration concept sortant + self.set_icmd(1) + self.DeclareOut('C_out',self.sd) + + ### type de traitement + + ### + if (MAX != None): + __ff=MAX['FONCTION'].convert() + __ex=__ff.extreme() + n_mini=len(__ex['min']) + n_maxi=len(__ex['max']) + listeMCF=[_F(LISTE_K=[MAX['FONCTION'].nom]*(n_mini+n_maxi),PARA='FONCTION'), + _F(LISTE_K=['MINI',]*n_mini+['MAXI',]*n_maxi,PARA='TYPE'),] + if isinstance(__ff,t_nappe) : + listeMCF=listeMCF+[\ + _F(LISTE_R=[i[0] for i in __ex['min']]+[i[0] for i in __ex['max']],PARA=__ff.para['NOM_PARA']),\ + _F(LISTE_R=[i[1] for i in __ex['min']]+[i[1] for i in __ex['max']],PARA=__ff.para['NOM_PARA_FONC']),\ + _F(LISTE_R=[i[2] for i in __ex['min']]+[i[2] for i in __ex['max']],PARA=__ff.para['NOM_RESU'])] + else : + listeMCF=listeMCF+[\ + _F(LISTE_R=[i[0] for i in __ex['min']]+[i[0] for i in __ex['max']],PARA=__ff.para['NOM_PARA']),\ + _F(LISTE_R=[i[1] for i in __ex['min']]+[i[1] for i in __ex['max']],PARA=__ff.para['NOM_RESU'])] + C_out=CREA_TABLE(LISTE=listeMCF) + + ### + if (ECART_TYPE != None): + __ff=ECART_TYPE['FONCTION'].convert() + if ECART_TYPE['INST_INIT']!=None : tini=ECART_TYPE['INST_INIT'] + else : tini=__ff.vale_x[0] + if ECART_TYPE['INST_FIN' ]!=None : tfin=ECART_TYPE['INST_FIN' ] + else : tfin=__ff.vale_x[-1] + __ff=__ff.cut(tini,__ff.vale_x[-1],ECART_TYPE['PRECISION'],ECART_TYPE['CRITERE']) + __ff=__ff.cut(__ff.vale_x[0],tfin,ECART_TYPE['PRECISION'],ECART_TYPE['CRITERE']) + if ECART_TYPE['METHODE' ]=='SIMPSON' : __ex=__ff.simpson(0.) + if ECART_TYPE['METHODE' ]=='TRAPEZE' : __ex=__ff.trapeze(0.) + fmoy=__ex.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0]) + __ff=__ff+(-1*fmoy) + __ff=__ff*__ff + if ECART_TYPE['METHODE' ]=='SIMPSON' : __ez=__ff.simpson(0.) + if ECART_TYPE['METHODE' ]=='TRAPEZE' : __ez=__ff.trapeze(0.) + sigma=math.sqrt(__ez.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0])) + C_out=CREA_TABLE(LISTE=(_F(LISTE_K=ECART_TYPE['FONCTION'].nom,PARA='FONCTION'), + _F(LISTE_K=ECART_TYPE['METHODE'] ,PARA='METHODE'), + _F(LISTE_R=fmoy ,PARA='MOYENNE'), + _F(LISTE_R=sigma ,PARA='ECART_TYPE'), + _F(LISTE_R=tini ,PARA='INST_INIT'), + _F(LISTE_R=tfin ,PARA='INST_FIN'),) + ) + + ### + if (RMS != None): + RMS =list(RMS) + sigm =[] + tmpi =[] + tmpf =[] + nomf =[] + meth =[] + for i_rms in RMS : + __ff=i_rms['FONCTION'].convert() + if i_rms['INST_INIT']!=None : tini=i_rms['INST_INIT'] + else : tini=__ff.vale_x[0] + if i_rms['INST_FIN' ]!=None : tfin=i_rms['INST_FIN' ] + else : tfin=__ff.vale_x[-1] + __ff=__ff.cut(tini,__ff.vale_x[-1],i_rms['PRECISION'],i_rms['CRITERE']) + __ff=__ff.cut(__ff.vale_x[0],tfin,i_rms['PRECISION'],i_rms['CRITERE']) + __ff=__ff*__ff + if i_rms['METHODE' ]=='SIMPSON' : __ez=__ff.simpson(0.) + if i_rms['METHODE' ]=='TRAPEZE' : + __ez=__ff.trapeze(0.) + sigm.append(math.sqrt(__ez.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0]))) + tmpi.append(tini) + tmpf.append(tfin) + nomf.append(i_rms['FONCTION'].nom) + meth.append(i_rms['METHODE']) + C_out=CREA_TABLE(LISTE=(_F(LISTE_K=nomf ,PARA='FONCTION'), + _F(LISTE_K=meth ,PARA='METHODE'), + _F(LISTE_R=tmpi ,PARA='INST_INIT'), + _F(LISTE_R=tmpf ,PARA='INST_FIN'), + _F(LISTE_R=sigm ,PARA='RMS'), ) + ) + + ### + if (NORME != None): + __ff=NORME['FONCTION'].convert() + norme=[] + for __fi in __ff.l_fonc : + norme.append(__fi.normel2()) + nom=[NORME['FONCTION'].nom,]*len(norme) + C_out=CREA_TABLE(LISTE=(_F(LISTE_R=norme ,PARA='NORME'), + _F(LISTE_K=nom ,PARA='FONCTION'), ) + ) + + ### + if (NOCI_SEISME != None): + l_table=[] + if NOCI_SEISME['SPEC_OSCI'] !=None : + ### cas intensité spectrale d'une nappe de SRO + ### la seule option licite est INTE_SPEC + UTMESS('I','INFO_FONCTION',''' : intensite spectrale, avant de calculer l'\ +intensite spectrale, il est prudent de verifier la norme de la nappe sur laquelle \ +porte le calcul, ceci peut etre une source d erreurs.''') + amor=NOCI_SEISME['AMOR_REDUIT'] + fini=NOCI_SEISME['FREQ_INIT' ] + ffin=NOCI_SEISME['FREQ_FIN' ] + __sp =NOCI_SEISME['SPEC_OSCI'].convert() + vale_x=__sp.l_fonc[0].vale_x + vale_y=[__sp(amor,f) for f in vale_x] + para =__sp.l_fonc[0].para + __srov=t_fonction(vale_x,vale_y,para) + if NOCI_SEISME['NATURE']=='DEPL' : + __srov.vale_y=(__srov.vale_y/__srov.vale_x)*2.*math.pi + elif NOCI_SEISME['NATURE']=='VITE' : + __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x + elif NOCI_SEISME['NATURE']=='ACCE' : + __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x + __srov.vale_y=__srov.vale_y/__srov.vale_x/2./math.pi + __srov=__srov.cut(fini,ffin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) + insp=__srov.trapeze(0.).vale_y[-1] + l_table.append(_F(LISTE_R=fini ,PARA='FREQ_INIT' )) + l_table.append(_F(LISTE_R=ffin ,PARA='FREQ_FIN' )) + l_table.append(_F(LISTE_R=amor ,PARA='AMOR_REDUIT')) + l_table.append(_F(LISTE_R=insp ,PARA='INTE_SPECT' )) + if NOCI_SEISME['FONCTION'] !=None : + ### cas fonction + l_table.append(_F(LISTE_K=NOCI_SEISME['FONCTION'].nom,PARA='FONCTION')) + __ac=NOCI_SEISME['FONCTION'].convert() + option= NOCI_SEISME['OPTION'] + if NOCI_SEISME['INST_INIT']!=None : tdeb=NOCI_SEISME['INST_INIT'] + else : tdeb=__ac.vale_x[0] + if NOCI_SEISME['INST_FIN' ]!=None : tfin=NOCI_SEISME['INST_FIN' ] + else : tfin=__ac.vale_x[-1] + # calcul de la vitesse : + __vi=__ac.trapeze(NOCI_SEISME['COEF']) + # calcul du déplacement : + __de=__vi.trapeze(NOCI_SEISME['COEF']) + # calcul de |acceleration| : + __aa=__ac.abs() + # calcul de integrale(|acceleration|) : + ### on "coupe" la fonction entre tdeb et tfin + __ac=__ac.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) + __vi=__vi.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) + __de=__de.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) + __aa=__aa.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) + if NOCI_SEISME['FREQ' ]!=None : l_freq=NOCI_SEISME['FREQ'] + elif NOCI_SEISME['LIST_FREQ']!=None : l_freq=NOCI_SEISME['LIST_FREQ'].Valeurs() + else : + # fréquences par défaut + l_freq=[] + for i in range(56) : l_freq.append( 0.2+0.050*i) + for i in range( 8) : l_freq.append( 3.0+0.075*i) + for i in range(14) : l_freq.append( 3.6+0.100*i) + for i in range(24) : l_freq.append( 5.0+0.125*i) + for i in range(28) : l_freq.append( 8.0+0.250*i) + for i in range( 6) : l_freq.append(15.0+0.500*i) + for i in range( 4) : l_freq.append(18.0+1.000*i) + for i in range(10) : l_freq.append(22.0+1.500*i) + if option in('TOUT','MAXI','ACCE_SUR_VITE') : + # calcul du max des valeurs absolues + maxa_ac=__ac.abs().extreme()['max'][0][1] + maxa_vi=__vi.abs().extreme()['max'][0][1] + maxa_de=__de.abs().extreme()['max'][0][1] + l_table.append(_F(LISTE_R=maxa_ac,PARA='ACCE_MAX')) + l_table.append(_F(LISTE_R=maxa_vi,PARA='VITE_MAX')) + l_table.append(_F(LISTE_R=maxa_de,PARA='DEPL_MAX')) + l_table.append(_F(LISTE_R=maxa_ac/maxa_vi,PARA='ACCE_SUR_VITE')) + if option in('TOUT','INTE_ARIAS') : + __a2=__ac*__ac + inte_arias=__a2.trapeze(0.).vale_y[-1] + inte_arias=inte_arias*math.pi/NOCI_SEISME['PESANTEUR']/2. + l_table.append(_F(LISTE_R=inte_arias,PARA='INTE_ARIAS')) + if option in('TOUT','POUV_DEST') : + __v2=__vi*__vi + pouv_dest=__v2.trapeze(0.).vale_y[-1] + pouv_dest=pouv_dest*(math.pi)**3/NOCI_SEISME['PESANTEUR']/2. + l_table.append(_F(LISTE_R=pouv_dest,PARA='POUV_DEST')) + if option in('TOUT','VITE_ABSO_CUMU') : + __vc=__aa.trapeze(0.) + vite_abso=__vc.vale_y[-1] + l_table.append(_F(LISTE_R=vite_abso,PARA='VITE_ABSO_CUMU')) + if option in('TOUT','INTE_SPEC') : + amor=NOCI_SEISME['AMOR_REDUIT'] + fini=NOCI_SEISME['FREQ_INIT' ] + ffin=NOCI_SEISME['FREQ_FIN' ] + __so= CALC_FONCTION(SPEC_OSCI=_F( + NATURE ='VITE', + NATURE_FONC='ACCE', + FONCTION =NOCI_SEISME['FONCTION'], + METHODE ='NIGAM', + NORME =NOCI_SEISME['NORME'], + FREQ =l_freq, + AMOR_REDUIT=(amor,) + ), ) + __srov=__so.convert().l_fonc[0] + __srov=__srov.cut(fini,ffin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) + __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x + insp=__srov.trapeze(0.).vale_y[-1] + l_table.append(_F(LISTE_R=fini ,PARA='FREQ_INIT' )) + l_table.append(_F(LISTE_R=ffin ,PARA='FREQ_FIN' )) + l_table.append(_F(LISTE_R=amor ,PARA='AMOR_REDUIT')) + l_table.append(_F(LISTE_R=insp ,PARA='INTE_SPECT' )) + if option in('TOUT','DUREE_PHAS_FORT') : + __a2=__ac*__ac + __i2=__a2.trapeze(0.) + arias = __i2.vale_y[-1]*math.pi/NOCI_SEISME['PESANTEUR']/2. + valinf = arias * NOCI_SEISME['BORNE_INF'] + valsup = arias * NOCI_SEISME['BORNE_SUP'] + for i in range(len(__i2.vale_x)) : + ariask = __i2.vale_y[i]*math.pi/NOCI_SEISME['PESANTEUR']/2. + if ariask>=valinf : break + for j in range(len(__i2.vale_x)-1,-1,-1) : + ariask = __i2.vale_y[j]*math.pi/NOCI_SEISME['PESANTEUR']/2. + if ariask<=valsup : break + dphfor = __i2.vale_x[j] - __i2.vale_x[i] + l_table.append(_F(LISTE_R=dphfor,PARA='DUREE_PHAS_FORT')) + C_out=CREA_TABLE(LISTE=l_table) + + return ier diff --git a/Aster/Cata/cataSTA81/Macro/lire_fonction_ops.py b/Aster/Cata/cataSTA81/Macro/lire_fonction_ops.py new file mode 100644 index 00000000..748774ea --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/lire_fonction_ops.py @@ -0,0 +1,268 @@ +#@ MODIF lire_fonction_ops Macro DATE 24/05/2005 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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.path, Numeric + +# ------------------------------------------------------------------------------ +def lire_blocs(nomfich, SEPAR): + """Retourne la liste des blocs + """ + def info(ib, nlig, ncol): + """Affiche les infos d'un bloc""" + print " . Bloc %2d : %6d lignes, %6d colonnes" % (ib, nlig, ncol) + print " Lecture des blocs du fichier '%s'" % nomfich + fich=open(nomfich, 'r') + ier=0 + message = '' + if SEPAR=='None' : SEPAR=None + blocs = [] + lignes = [] + llen=0 + il=0 + for line in fich: + il+=1 + try: + if line.strip()=='': + raise ValueError + splin = line.split(SEPAR) + lignes.append(map(float, splin)) + if llen==0: + llen=len(splin) + elif len(splin)<>llen: + ier+=1 + message='Ligne %d : %d champs au lieu de %d attendus' % (il,len(splin),llen) + return ier, message, [] + except ValueError: + if lignes==[]: + pass # dans ce cas, on a plusieurs lignes délimitant 2 fonctions + else: + blocs.append(Numeric.array(lignes)) + info(len(blocs), len(lignes), llen) + lignes=[] + llen=0 + fich.close() + if lignes!=[] : + blocs.append(Numeric.array(lignes)) + info(len(blocs), len(lignes), llen) + return ier, message, blocs + +# ------------------------------------------------------------------------------ +def liste_double(nomfich,INDIC_PARA,INDIC_RESU,SEPAR): + """Méthode de construction du VALE pour le format libre + format LIBRE + Les lignes contenant autre chose que des séquences de nombres + réels et de séparateurs sont considérées comme délimitant deux + fonctions différentes. Cette situation correspond à l exception + ValueError levée par le map de float. Le deuxieme indice de + INDIC_PARA et INDIC_RESU est l indice permettant de pointer sur la + fonction voulue, au sens de ce découpage. + """ + from Utilitai.transpose import transpose + ier, message, blocs = lire_blocs(nomfich, SEPAR) + if ier<>0: + return ier,message,[] + + # vérifications de cohérences lignes et colonnes + nb_blocs = len(blocs) + bloc_para = INDIC_PARA[0] + col_para = INDIC_PARA[1] + bloc_resu = INDIC_RESU[0] + col_resu = INDIC_RESU[1] + msg=[] + if bloc_para>nb_blocs : + ier+=1 + msg.append("Il y a %d blocs or INDIC_PARA=(%d, .)" % (nb_blocs, bloc_para)) + if bloc_resu>nb_blocs: + ier+=1 + msg.append("Il y a %d blocs or INDIC_RESU=(%d, .)" % (nb_blocs, bloc_resu)) + if ier<>0: + return ier, '\n'.join(msg), [] + + if col_para>len(blocs[bloc_para-1][0]): + ier+=1 + msg.append("Le bloc %d comporte %d colonnes or INDIC_PARA=(., %d)" % \ + (bloc_para, len(blocs[bloc_para-1][0]), col_para)) + if col_resu>len(blocs[bloc_resu-1][0]) : + ier+=1 + msg.append("Le bloc %d comporte %d colonnes or INDIC_RESU=(., %d)" % \ + (bloc_resu, len(blocs[bloc_resu-1][0]), col_resu)) + if ier<>0: + return ier, '\n'.join(msg), [] + + # construction du VALE de la fonction par recherche des indices + # de colonnes et de fonctions dans le tableau blocs + vale_para = blocs[bloc_para-1][:,col_para-1] + vale_resu = blocs[bloc_resu-1][:,col_resu-1] + if len(vale_para)!=len(vale_resu) : + ier+=1 + print 'VALE_PARA =', vale_para + print 'VALE_RESU =', vale_resu + message="""Les deux colonnes extraites n'ont pas la meme longueur + %d lignes pour PARA + %d lignes pour RESU""" % (len(vale_para), len(vale_resu)) + if ier<>0: + return ier,message,[] + + laux=transpose([vale_para, vale_resu]) + liste_vale=[] + for v in laux: liste_vale.extend(v) + return ier,'',liste_vale + +# ------------------------------------------------------------------------------ +def liste_simple(nomfich,INDIC_PARA,SEPAR): + """recherche d'une liste simple + """ + ier, message, blocs = lire_blocs(nomfich, SEPAR) + + # vérifications de cohérences lignes et colonnes + nb_blocs = len(blocs) + bloc_para = INDIC_PARA[0] + col_para = INDIC_PARA[1] + msg=[] + if bloc_para>nb_blocs : + ier+=1 + msg.append("Il y a %d blocs or INDIC_PARA=(%d, .)" % (nb_blocs, bloc_para)) + if col_para>len(blocs[bloc_para-1][0]): + ier+=1 + msg.append("Le bloc %d comporte %d colonnes or INDIC_PARA=(., %d)" % \ + (bloc_para, len(blocs[bloc_para-1][0]), col_para)) + if ier<>0: + return ier, '\n'.join(msg), [] + + # construction du VALE de la fonction par recherche des indices + # de colonnes et de fonctions dans le tableau l_fonc + vale_1=blocs[bloc_para-1][:,col_para-1] + return ier,'',vale_1.tolist() + +# ------------------------------------------------------------------------------ +def lire_fonction_ops(self,FORMAT,TYPE,SEPAR,INDIC_PARA,UNITE, + NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE, + PROL_GAUCHE,VERIF,INFO,TITRE,**args): + """Méthode corps de la macro + """ + from Accas import _F + from Utilitai.Utmess import UTMESS + from Utilitai.UniteAster import UniteAster + + ier=0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # On recopie le mot cle defi_fonction pour le proteger + if TYPE=='NAPPE' : + mc_DEFI_FONCTION=args['DEFI_FONCTION'] + + # On importe les definitions des commandes a utiliser dans la macro + DEFI_FONCTION =self.get_cmd('DEFI_FONCTION') + DEFI_NAPPE =self.get_cmd('DEFI_NAPPE') + + nompro='LIRE_FONCTION' + + # Lecture de la fonction dans un fichier d unité logique UNITE + UL = UniteAster() + nomfich=UL.Nom(UNITE) + if not os.path.isfile(nomfich): + UTMESS('F', nompro, "le fichier '%s' est introuvable" % nomfich) + + # fonction(_c) ou nappe en sortie + self.DeclareOut('ut_fonc',self.sd) + + if TYPE=='FONCTION': + # mise en forme de la liste de valeurs suivant le format choisi : + ier,message,liste_vale=liste_double(nomfich,INDIC_PARA,args['INDIC_RESU'],SEPAR) + if ier!=0: UTMESS('F', nompro, message) + + # création de la fonction ASTER : + ut_fonc=DEFI_FONCTION( NOM_PARA =NOM_PARA, + NOM_RESU =NOM_RESU, + PROL_DROITE=PROL_DROITE, + PROL_GAUCHE=PROL_GAUCHE, + INTERPOL =INTERPOL, + INFO =INFO, + TITRE =TITRE, + VERIF =VERIF, + VALE =liste_vale,) + + elif TYPE=='FONCTION_C': + # mise en forme de la liste de valeurs suivant le format choisi : + if 'INDIC_REEL' in args : + indic1=args['INDIC_REEL'] + indic2=args['INDIC_IMAG'] + if 'INDIC_MODU' in args : + indic1=args['INDIC_MODU'] + indic2=args['INDIC_PHAS'] + ier,message,liste_vale_r=liste_double(nomfich,INDIC_PARA,indic1,SEPAR) + if ier!=0: UTMESS('F', nompro, message) + + ier,message,liste_vale_i=liste_double(nomfich,INDIC_PARA,indic2,SEPAR) + if ier!=0: UTMESS('F', nompro, message) + + liste=[] + if 'INDIC_REEL' in args : + for i in range(len(liste_vale_r)/2) : + liste.extend([liste_vale_r[2*i],liste_vale_r[2*i+1],liste_vale_i[2*i+1]]) + elif 'INDIC_MODU' in args : + for i in range(len(liste_vale_r)/2) : + module=liste_vale_r[2*i+1] + phase =liste_vale_i[2*i+1] + liste.extend([liste_vale_r[2*i],module*cos(phase),module*sin(phase)]) + + # création de la fonction ASTER : + ut_fonc=DEFI_FONCTION( NOM_PARA =NOM_PARA, + NOM_RESU =NOM_RESU, + PROL_DROITE =PROL_DROITE, + PROL_GAUCHE =PROL_GAUCHE, + INTERPOL =INTERPOL, + INFO =INFO, + TITRE =TITRE, + VERIF =VERIF, + VALE_C =liste,) + + elif TYPE=='NAPPE': + + # création de la nappe ASTER : + motscles={} + motscles['DEFI_FONCTION']=[] + for elem in mc_DEFI_FONCTION: + ier,message,liste_vale=liste_double(nomfich,args['INDIC_ABSCISSE'],elem['INDIC_RESU'],SEPAR) + if ier!=0: UTMESS('F', nompro, message) + + motscles['DEFI_FONCTION'].append( _F( VALE =liste_vale, + INTERPOL =args['INTERPOL_FONC'], + PROL_DROITE=args['PROL_DROITE_FONC'], + PROL_GAUCHE=args['PROL_GAUCHE_FONC'] ) ) + ier,message,liste_para=liste_simple(nomfich,INDIC_PARA,SEPAR) + if ier!=0: UTMESS('F', nompro, message) + + # création de la nappe + ut_fonc=DEFI_NAPPE( PARA =liste_para, + NOM_PARA =NOM_PARA, + NOM_PARA_FONC =args['NOM_PARA_FONC'], + NOM_RESU =NOM_RESU, + PROL_DROITE =PROL_DROITE, + PROL_GAUCHE =PROL_GAUCHE, + INTERPOL =INTERPOL, + INFO =INFO, + TITRE =TITRE, + VERIF =VERIF, + **motscles) + # remet UNITE dans son état initial + UL.EtatInit() + return ier diff --git a/Aster/Cata/cataSTA81/Macro/lire_inte_spec_ops.py b/Aster/Cata/cataSTA81/Macro/lire_inte_spec_ops.py new file mode 100644 index 00000000..21e7724b --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/lire_inte_spec_ops.py @@ -0,0 +1,117 @@ +#@ MODIF lire_inte_spec_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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 lire_inte_spec_ops(self,UNITE,FORMAT,NOM_PARA,NOM_RESU,INTERPOL, + PROL_DROITE,PROL_GAUCHE,TITRE,INFO,**args): + ier=0 + + from Accas import _F + import os + from math import cos,sin + from Utilitai.Utmess import UTMESS + from Utilitai.UniteAster import UniteAster + # On importe les definitions des commandes a utiliser dans la macro + DEFI_FONCTION =self.get_cmd('DEFI_FONCTION') + CREA_TABLE =self.get_cmd('CREA_TABLE') + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + nompro='LIRE_INTE_SPEC' + + # Lecture de la fonction dans un fichier d unité logique UNITE + UL = UniteAster() + nomfich=UL.Nom(UNITE) + if not os.path.isfile(nomfich): + UTMESS('F', nompro, "le fichier '%s' est introuvable" % nomfich) + file=open(nomfich,'r') + texte=file.read() + file.close() + + list_fonc=texte.split('FONCTION_C') + entete=list_fonc.pop(0) + try : + entete=entete[entete.index('DIM'):] + dim=int(entete[entete.index('=')+1:entete.index('\n')]) + except ValueError : + UTMESS('F', nompro, "la dimension DIM n est pas précisée dans le fichier lu") + + if len(list_fonc)!=(dim*(dim+1)/2): + UTMESS('F', nompro, "nombre de fonctions incorrect") + + nume_i=[] + nume_j=[] + l_fonc=[] + for i in range(dim*(dim+1)/2): + numi=list_fonc[i][list_fonc[i].index('I =')+3:] + numi=numi[:numi.index('\n')] + nume_i.append(int(numi)) + numj=list_fonc[i][list_fonc[i].index('J =')+3:] + numj=numj[:numj.index('\n')] + nume_j.append(int(numj)) + try : + vale_fonc=list_fonc[i][list_fonc[i].index('VALEUR =\n')+9:list_fonc[i].index('FINSF\n')] + vale_fonc=vale_fonc.replace('\n',' ') + vale_fonc=map(float,vale_fonc.split()) + except ValueError : + UTMESS('F', nompro, "erreur dans les données de fonctions") + + liste=[] + if FORMAT=='REEL_IMAG': + liste=vale_fonc + elif FORMAT=='MODULE_PHASE': + for i in range(len(vale_fonc)/3) : + module=vale_fonc[3*i+1] + phase =vale_fonc[3*i+2] + liste=liste+[vale_fonc[3*i],module*cos(phase),module*sin(phase)] + + # création de la fonction ASTER : + _fonc=DEFI_FONCTION( NOM_PARA =NOM_PARA, + NOM_RESU =NOM_RESU, + PROL_DROITE=PROL_DROITE, + PROL_GAUCHE=PROL_GAUCHE, + INTERPOL =INTERPOL, + INFO =INFO, + TITRE =TITRE, + VALE_C =liste,) + l_fonc.append(_fonc.nom) + + nume_ib=[] + nume_jb=[] + for i in range(dim): + for j in range(i,dim): + nume_ib.append(i+1) + nume_jb.append(j+1) + if nume_i!=nume_ib or nume_j!=nume_jb : + UTMESS('F', nompro, "erreur dans les indices") + mcfact=[] + mcfact.append(_F(PARA='NOM_CHAM' ,LISTE_K=(NOM_RESU),NUME_LIGN=(1,))) + mcfact.append(_F(PARA='OPTION' ,LISTE_K=('TOUT',) ,NUME_LIGN=(1,))) + mcfact.append(_F(PARA='DIMENSION' ,LISTE_I=(dim,) ,NUME_LIGN=(1,))) + mcfact.append(_F(PARA='NUME_ORDRE_I',LISTE_I=nume_i ,NUME_LIGN=range(2,len(nume_i)+2))) + mcfact.append(_F(PARA='NUME_ORDRE_J',LISTE_I=nume_j ,NUME_LIGN=range(2,len(nume_j)+2))) + mcfact.append(_F(PARA='FONCTION' ,LISTE_K=l_fonc ,NUME_LIGN=range(2,len(list_fonc)+2))) + self.DeclareOut('tab_inte',self.sd) + tab_inte=CREA_TABLE(TYPE_TABLE='TABL_INTE_SPEC', + LISTE=mcfact, + TITRE=TITRE,) + + # remet UNITE dans son état initial + UL.EtatInit() + return ier diff --git a/Aster/Cata/cataSTA81/Macro/lire_table_ops.py b/Aster/Cata/cataSTA81/Macro/lire_table_ops.py new file mode 100644 index 00000000..ea470c6d --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/lire_table_ops.py @@ -0,0 +1,177 @@ +#@ MODIF lire_table_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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 string + +# ------------------------------------------------------------------------------ +def lecture_table(texte,nume,separ): + """Méthode de construction du dictionnaire PARAMETRE / LISTE DE VALEURS + format ASTER + Les lignes contenant autre chose que des séquences de nombres + réels et de séparateurs sont considérées comme délimitant deux + fonctions différentes. Cette situation correspond à l exception + ValueError levée par le map de float. Le deuxieme indice de + VALE_PARA et VALE_RESU est l indice permettant de pointer sur la + fonction voulue, au sens de ce découpage. + """ + + from Utilitai.transpose import transpose + if string.strip(separ)=='' : separ=None + tab_lue={} + nume_lign=[] + idt_deb='#DEBUT_TABLE\n' + idt_fin='#FIN_TABLE\n' + idt_tit='#TITRE' + if nume>texte.count(idt_deb) : + message= " NUME_TABLE :le nombre de blocs de tables dans " + message=message+"le fichier est "+str(texte.count(idt_deb)) + return 1,message,None,None,None + for i in range(nume): + texte=texte[texte.index(idt_deb)+1:] + texte=texte[:texte.index(idt_fin)] + + titre_tab=[string.rstrip(elem[7:-1]) for elem in texte if elem.find(idt_tit)!=-1] + texte_tab=[elem.split(separ) for elem in texte if elem.find(idt_tit)==-1] + + if ( separ!=None) : + tab_trav=[] + for line in texte_tab : + ligne=[] + for elem in line : + if ( elem != '' and elem !='\n') : + ligne.append(string.strip(elem)) + tab_trav.append(ligne) + texte_tab=tab_trav + + list_para=texte_tab[0] + list_type=texte_tab[1] + texte_tab.pop(0) + texte_tab.pop(0) + nb_para=len(texte_tab[0]) + + for line in texte_tab : + if len(line)!=nb_para : + message= " incoherence dans le nombre de colonnes " + message=message+"de la table a lire" + return 1,message,None,None,None + texte_tab=transpose(texte_tab) + for i in range(nb_para): + tab_trav=[] + list_val=[] + col_type=list_type[i] + if col_type=='R': + try : + texte_tab[i]=map(float,texte_tab[i]) + nume_lign.append([0]) + except ValueError: +# Presence de - dans la ligne + for indice in range(len(texte_tab[i])): + if texte_tab[i][indice]!='-': + tab_trav.append(indice+1) + list_val.append(float(texte_tab[i][indice])) + + nume_lign.append(tab_trav) + texte_tab[i]=list_val + elif col_type=='I' : + try : + texte_tab[i]=map(int,texte_tab[i]) + nume_lign.append([0]) +# Presence de - dans la ligne + except ValueError: + for indice in range(len(texte_tab[i])): + if texte_tab[i][indice]!='-': + tab_trav.append(indice+1) + list_val.append(float(texte_tab[i][indice])) + nume_lign.append(tab_trav) + texte_tab[i]=list_val + + else : + try : nume_lign.append([0]) + except ValueError: pass + + tab_lue[list_para[i]]=(list_type[i],texte_tab[i],nume_lign[i]) + + return 0,None,titre_tab,list_para,tab_lue + + +# ------------------------------------------------------------------------------ +def lire_table_ops(self,UNITE,FORMAT,NUME_TABLE,SEPARATEUR, + TYPE_TABLE,PARA,TITRE,**args): + """Méthode corps de la macro LIRE_TABLE + """ + import os + from Accas import _F + from Utilitai.Utmess import UTMESS + from Utilitai.UniteAster import UniteAster + + ier=0 + nompro='LIRE_TABLE' + ### On importe les definitions des commandes a utiliser dans la macro + CREA_TABLE =self.get_cmd('CREA_TABLE') + + ### La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + ### Lecture de la table dans un fichier d unité logique UNITE + UL = UniteAster() + nomfich=UL.Nom(UNITE) + if not os.path.isfile(nomfich): + UTMESS('F', nompro, "le fichier '%s' est introuvable" % nomfich) + + file=open(nomfich,'r') + texte=file.readlines() + file.close() + + ### mise en forme de la liste de valeurs suivant le format choisi : + if FORMAT=='ASTER': + ier,message,titr_tab,list_para,tab_lue=lecture_table(texte,NUME_TABLE,SEPARATEUR) + if ier!=0 : + UTMESS('F', nompro, message) + else : pass + + ### création de la table ASTER : + self.DeclareOut('ut_tab',self.sd) + mcfact=[] + num_col=0 + for tab_para in list_para: + mcsimp={} + mcsimp['PARA']=tab_para + + if tab_lue[tab_para][2] != [0] : + mcsimp['NUME_LIGN']=tab_lue[tab_para][2] + + if tab_lue[tab_para][0] not in ('I','R') : + mcsimp['TYPE_K'] =tab_lue[tab_para][0] + mcsimp['LISTE_K']=tab_lue[tab_para][1] + elif tab_lue[tab_para][0]=='I' : + mcsimp['LISTE_I']=tab_lue[tab_para][1] + elif tab_lue[tab_para][0]=='R' : + mcsimp['LISTE_R']=tab_lue[tab_para][1] + + mcfact.append( _F(**mcsimp) ) + num_col = num_col + 1 + motscles={} + motscles['LISTE']=mcfact + + ut_tab=CREA_TABLE(TITRE=titr_tab,TYPE_TABLE=TYPE_TABLE, **motscles) + + # remet UNITE dans son état initial + UL.EtatInit() + return ier diff --git a/Aster/Cata/cataSTA81/Macro/macr_adap_mail_ops.py b/Aster/Cata/cataSTA81/Macro/macr_adap_mail_ops.py new file mode 100644 index 00000000..6c7afabb --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_adap_mail_ops.py @@ -0,0 +1,789 @@ +#@ MODIF macr_adap_mail_ops Macro DATE 04/07/2005 AUTEUR GNICOLAS G.NICOLAS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2003 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. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS +# +def macr_adap_mail_ops ( self, + INFO, VERSION_HOMARD, LANGUE, + NOMBRE, QUALITE, CONNEXITE, TAILLE, INTERPENETRATION, + NON_SIMPLEXE, MAILLAGE_FRONTIERE, + **args): + """ + Ecriture des macros MACR_ADAP_MAIL/MACR_INFO_MAIL + Remarque : on ne mentionne explicitement que les mots-clés communs aux + deux macros. Les autres sont dans le dictionnaire 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. +# +### print args +### print args.keys() +### if len (args.keys())>0 : print args.keys()[0] +### print args["MAILLAGE"] +# +# 2. Les caractéristiques d'un passage sont conservées dans un dictionnaire. Il y a autant de +# dictionnaires que de sollicitations pour une série d'adaptation. L'ensemble de ces dictionnaires +# est conservé dans la liste Liste_Passages. Cette liste est nécessairement globale pour pouvoir +# la retrouver à chaque nouveau passage. +# Description du dictionnaire de passages : +# dico["Maillage_0"] = o ; string ; nom du concept du maillage initial de la série d'adaptation +# dico["Maillage_NP1"] = o ; string ; nom du concept du dernier maillage adapté +# dico["Rep_Calc_HOMARD_global"] = o ; string ; Nom global du répertoire de calcul pour HOMARD +# dico["Rep_Calc_HOMARD_local"] = o ; string ; Nom local du répertoire de calcul pour HOMARD +# depuis le répertoire de calcul pour ASTER +# dico["niter"] = o ; entier ; numéro d'itération +# +# 3. Les caractéristiques d'un maillage sont conservées dans un dictionnaire. Il y a autant de +# dictionnaires que de maillages manipulés. L'ensemble de ces dictionnaires est conservé +# dans la liste Liste_Maillages. +# Description du dictionnaire de maillages : +# dico["Type_Maillage"] = o ; string ; "MAILLAGE_N", "MAILLAGE_NP1" ou "MAILLAGE_FRONTIERE" +# dico["Nom_ASTER"] = o ; concept ASTER associé +# dico["Action"] = o ; string ; "A_ecrire" ou "A_lire" +# dico["NOM_MED"] = o ; string ; Nom MED du maillage +# +# 4. Les caractéristiques d'un champ sont conservées dans un dictionnaire. Il y a autant de +# dictionnaires que de champs manipulés. L'ensemble de ces dictionnaires est conservé +# dans la liste Liste_Champs. +# Description du dictionnaire de champs : +# dico["Type_Champ"] = o ; string ; "INDICATEUR" ou "CHAMP_MAJ" +# dico["RESULTAT"] = f ; concept ASTER du résutat associé +# dico["NOM_CHAM"] = f ; string ; Nom ASTER du champ +# dico["CHAM_GD"] = f ; concept ASTER du champ de grandeur associée +# dico["COMPOSANTE"] = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur) +# dico["NUME_ORDRE"] = f ; entier ; Numéro d'ordre du champ +# dico["INST"] = f ; entier ; Instant du champ +# dico["PRECISION"] = f ; entier ; Précision sur l'instant du champ +# dico["CRITERE"] = f ; entier ; Critère de précision sur l'instant du champ +# dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage +# dico["NOM_MED"] = o ; string ; Nom MED du champ +# + from Accas import _F + import aster + import string + import types + import os + import shutil +# + global Liste_Passages +# +#-------------------------------------------------------------------- +# 1. Préalables +#-------------------------------------------------------------------- +# +# 1.1. ==> La macro compte pour 1 dans la numerotation des commandes +# + self.set_icmd(1) +# +# 1.2. ==> Numéro du passage dans cette macro +# + try : + self.jdc.indice_macro_homard = self.jdc.indice_macro_homard + 1 + except : + self.jdc.indice_macro_homard = 1 + Liste_Passages = [] + Numero_Passage_Fonction = self.jdc.indice_macro_homard +### print "Numero_Passage_Fonction = ",Numero_Passage_Fonction +# +# 1.3. ==> On importe les definitions des commandes a utiliser dans la macro +# + DEFI_FICHIER = self.get_cmd("DEFI_FICHIER") + IMPR_RESU = self.get_cmd("IMPR_RESU") + EXEC_LOGICIEL = self.get_cmd("EXEC_LOGICIEL") + IMPR_FICO_HOMA = self.get_cmd("IMPR_FICO_HOMA") + LIRE_MAILLAGE = self.get_cmd("LIRE_MAILLAGE") + LIRE_CHAMP = self.get_cmd("LIRE_CHAMP") + DETRUIRE = self.get_cmd('DETRUIRE') +# +# 1.4. ==> Le nom du programme HOMARD à lancer +# + repertoire_outils = aster.repout() + homard = repertoire_outils + "homard" +# +# 1.5. ==> Initialisations +# + codret = 0 + codret_partiel = [0] + Rep_Calc_ASTER = os.getcwd() +# + Liste_Maillages = [] + Liste_Champs = [] + dico_indi = {} +# + ADAPTATION = None + MAJ_CHAM = None +# + unite = 71 +# +#-------------------------------------------------------------------- +# 2. Décodage des arguments de la macro-commande +#-------------------------------------------------------------------- +# 2.1. ==> Données de pilotage de l'adaptation +# + if ( self.nom == "MACR_ADAP_MAIL" ) : +# + modhom = "ADAP" +# + ADAPTATION = args["ADAPTATION"] + if args.has_key("MAJ_CHAM") : + MAJ_CHAM = args["MAJ_CHAM"] +# +# 2.1.1. ==> Les concepts "maillage" +# + for mot_cle in ["MAILLAGE_N","MAILLAGE_NP1"] : + dico = {} + dico["Type_Maillage"] = mot_cle + dico["Nom_ASTER"] = ADAPTATION[mot_cle] + if ( mot_cle == "MAILLAGE_N" ) : + dico["Action"] = "A_ecrire" + else : + dico["Action"] = "A_lire" + Liste_Maillages.append(dico) +# +# 2.1.2. ==> L'éventuel indicateur d'erreur +# + if ADAPTATION["LIBRE"] != None : + dico = {} + dico["Type_Champ"] = "INDICATEUR" + if ( ADAPTATION["RESULTAT_N"] != None ) : + lresu = 1 + dico["RESULTAT"] = ADAPTATION["RESULTAT_N"] + noresu = dico["RESULTAT"].nom + dico["NOM_CHAM"] = ADAPTATION["INDICATEUR"] + nomsym = dico["NOM_CHAM"] + if ( ADAPTATION["NUME_ORDRE"] != None ) : + dico["NUME_ORDRE"] = ADAPTATION["NUME_ORDRE"] + if ( ADAPTATION["INST"] != None ) : + dico["INST"] = ADAPTATION["INST"] + for cle in [ "PRECISION", "CRITERE" ] : + if ( ADAPTATION[cle] != None ) : + dico[cle] = ADAPTATION[cle] + else : + lresu = 0 + dico["CHAM_GD"] = ADAPTATION["CHAM_GD"] + noresu = dico["CHAM_GD"].nom + nomsym = " " + nopase = " " +# +### print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase + dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase ) +### print "dico[\"NOM_MED\"] = ", dico["NOM_MED"] + dico["COMPOSANTE"] = ADAPTATION["NOM_CMP_INDICA"] + Liste_Champs.append(dico) + dico_indi = dico +### print dico +# +# 2.1.3. ==> Les champs à mettre à jour +# +### print ".. Debut de 2.1.3." +# + if ( MAJ_CHAM != None ) : +# + for maj_cham in MAJ_CHAM : +### print maj_cham +# + dico = {} + dico["Type_Champ"] = "CHAMP_MAJ" + Liste_aux = [ "CHAM_MAJ", "TYPE_CHAM", "NOM_CHAM" ] + if ( maj_cham["RESULTAT"] != None ) : + lresu = 1 + Liste_aux.append("RESULTAT") + if ( maj_cham["NUME_ORDRE"] != None ) : + dico["NUME_ORDRE"] = maj_cham["NUME_ORDRE"] + elif ( maj_cham["INST"] != None ) : + dico["INST"] = maj_cham["INST"] + for cle in [ "PRECISION", "CRITERE" ] : + if ( maj_cham[cle] != None ) : + dico[cle] = maj_cham[cle] + noresu = maj_cham["RESULTAT"].nom + nomsym = maj_cham["NOM_CHAM"] + else : + lresu = 0 + Liste_aux.append("CHAM_GD") + noresu = maj_cham["CHAM_GD"].nom + nomsym = " " + for cle in Liste_aux : + dico[cle] = maj_cham[cle] + nopase = " " +### print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase + dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase ) +# +### print dico + Liste_Champs.append(dico) +# +# 2.2. ==> Données de pilotage de l'information +# + else : +# + modhom = "INFO" +# + dico = {} + dico["Type_Maillage"] = "MAILLAGE_N" + dico["Nom_ASTER"] = args["MAILLAGE"] + dico["Action"] = "A_ecrire" + Liste_Maillages.append(dico) +# +# 2.3. ==> Suivi de frontière +# +### print ".. Debut de 2.3." +# + if ( MAILLAGE_FRONTIERE != None ) : +# + dico = {} + dico["Type_Maillage"] = "MAILLAGE_FRONTIERE" + dico["Nom_ASTER"] = MAILLAGE_FRONTIERE + dico["Action"] = "A_ecrire" + Liste_Maillages.append(dico) +# +#-------------------------------------------------------------------- +# 3. Préparation du lancement des commandes +#-------------------------------------------------------------------- +# +# 3.1. ==> . Elaboration des noms MED des concepts de maillage +# . Memorisation des noms ASTER du maillage en entrée et en sortie (sous forme string) +# On crée une nouvelle liste des dictionnaires décrivant les maillages +# et à la fin on écrase l'ancienne liste par cette nouvelle. +# +### print ".. Debut de 3.1." +# + L = [] + for dico in Liste_Maillages : + dico["NOM_MED"] = aster.mdnoma(dico["Nom_ASTER"].nom) + L.append(dico) + if ( dico["Type_Maillage"] == "MAILLAGE_N" ) : + Nom_Concept_Maillage_N = dico["Nom_ASTER"].nom + elif ( dico["Type_Maillage"] == "MAILLAGE_NP1" ) : + Nom_Concept_Maillage_NP1 = dico["Nom_ASTER"].nom + Liste_Maillages = L +# +# 3.2. ==> Recherche du numéro d'itération et du répertoire de travail +# +# 3.2.1. ==> Par défaut : +# . le numéro d'itération est nul +# . le nom du répertoire de lancement de HOMARD est construit sur le nom +# du maillage en entrée et le numéro de passage dans la fonction +# +### print ".. Debut de 3.2.1." +# + niter = 0 + Nom_Rep_local = Nom_Concept_Maillage_N + "_" + modhom + "_" + str(Numero_Passage_Fonction) + Rep_Calc_HOMARD_local = os.path.join(".",Nom_Rep_local) + Rep_Calc_HOMARD_global = os.path.join(Rep_Calc_ASTER,Nom_Rep_local) +### print "Rep_Calc_HOMARD_local = ", Rep_Calc_HOMARD_local +### print "Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global +# +# 3.2.2. ==> En adaptation : +# + if ( modhom == "ADAP" ) : +# +# 3.2.2.1. ==> On recherche si dans les passages déjà effectués, il en existe un +# dont le maillage d'arrivée était l'actuel maillage d'entrée. Si c'est +# le cas, cela veut dire que l'adaptation en cours est la suite d'une +# précédente. On doit donc utiliser le meme répertoire. Le numéro +# d'itération est celui de l'adaptation précédente augmenté de 1. +# + for dico in Liste_Passages : + if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) : + niter = dico["niter"] + 1 + Rep_Calc_HOMARD_local = dico["Rep_Calc_HOMARD_local"] + Rep_Calc_HOMARD_global = dico["Rep_Calc_HOMARD_global"] +# +# 3.2.2.2. ==> Memorisation de ce passage +# +# 3.2.2.2.1. ==> Enregistrement d'un nouveau cas de figure +# + if ( niter == 0 ) : + dico = {} + dico["Maillage_0"] = Nom_Concept_Maillage_N + dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1 + dico["Rep_Calc_HOMARD_local"] = Rep_Calc_HOMARD_local + dico["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global + dico["niter"] = niter + Liste_Passages.append(dico) +# +# 3.2.2.2.2. ==> Modification du cas en cours +# + else : + L = [] + for dico in Liste_Passages : + if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) : + dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1 + dico["niter"] = niter + L.append(dico) + Liste_Passages = L +# +### print "niter = ", niter, ", Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global +# +#-------------------------------------------------------------------- +# 4. Ecriture des commandes +#-------------------------------------------------------------------- +# +# 4.1. ==> Création du répertoire pour homard +# attention : on ne fait cette creation qu'une seule fois par cas +# d'adaptation ou d'information +# + if ( niter == 0 ) : +# + try : + os.mkdir(Rep_Calc_HOMARD_global) + except os.error,codret_partiel : + self.cr.warn("Code d'erreur de mkdir : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) + self.cr.fatal(" Impossible de créer le répertoire de travail pour HOMARD : "+Rep_Calc_HOMARD_global) + codret = codret + 1 +# +# 4.2. ==> Ecriture des commandes de creation des donnees MED +# +# On doit écrire : le maillage, +# le champ d'indicateur d'erreur +# les champs à convertir +# Remarque : on met tout dans le meme fichier +# +# Chacune de ces écritures est optionnelle selon le contexte. +# + if ( INFO > 1 ) : infomail = "OUI" + else : infomail = "NON" +# +# 4.2.1. ==> Noms des fichiers d'ASTER vers HOMARD et éventuellement de HOMARD vers ASTER +# Remarque : aujourd'hui, les écritures ou les lectures au format MED se font obligatoirement sur +# un fichier de nom fort.n, placé dans le répertoire de calcul +# Dans le fichier de configuration, on donne comme nom MAILL.(niter).MED en entrée et +# MAILL.(niter+1).MED en sortie (cf. adhc00) +# Tant que les E/S MED n'ont pas évolué, on fait un lien pour assurer la cohérence. +# +# 4.2.1.1. ==> D'ASTER vers HOMARD +# + Unite_Fichier_ASTER_vers_HOMARD = 1787 + 2*Numero_Passage_Fonction + Fichier_ASTER_vers_HOMARD = os.path.join(Rep_Calc_ASTER,"fort." + str(Unite_Fichier_ASTER_vers_HOMARD)) + Fichier_HOMARD_Entree = os.path.join(Rep_Calc_HOMARD_global,"MAILL."+str(niter)+".MED") +### print "Fichier_ASTER_vers_HOMARD = ",Fichier_ASTER_vers_HOMARD +### print "Fichier_HOMARD_Entree = ",Fichier_HOMARD_Entree + try : + os.symlink(Fichier_ASTER_vers_HOMARD,Fichier_HOMARD_Entree) + except os.error,codret_partiel : + self.cr.warn("Code d'erreur de symlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) + self.cr.fatal(" Probleme au lien entre " + Fichier_ASTER_vers_HOMARD + " et " + Fichier_HOMARD_Entree) + codret = codret + 1 +# +# 4.2.1.2. ==> De HOMARD vers ASTER +# + if ( modhom == "ADAP" ) : + Unite_Fichier_HOMARD_vers_ASTER = Unite_Fichier_ASTER_vers_HOMARD + 1 + Fichier_HOMARD_vers_ASTER = os.path.join(Rep_Calc_ASTER,"fort." + str(Unite_Fichier_HOMARD_vers_ASTER)) + Fichier_HOMARD_Sortie = os.path.join(Rep_Calc_HOMARD_global,"MAILL."+str(niter+1)+".MED") +### print "Fichier_HOMARD_vers_ASTER = ",Fichier_HOMARD_vers_ASTER +### print "Fichier_HOMARD_Sortie = ",Fichier_HOMARD_Sortie + try : + os.symlink(Fichier_HOMARD_vers_ASTER,Fichier_HOMARD_Sortie) + except os.error,codret_partiel : + self.cr.warn("Code d'erreur de symlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) + self.cr.fatal(" Probleme au lien entre " + Fichier_HOMARD_vers_ASTER + " et " + Fichier_HOMARD_Sortie) + codret = codret + 1 +# +# 4.2.2. La définition du fichier de ASTER vers HOMARD +# + DEFI_FICHIER ( ACTION= "ASSOCIER", + UNITE = Unite_Fichier_ASTER_vers_HOMARD, + TYPE = "LIBRE", + INFO = INFO ) +# +# 4.2.3. Le(s) maillage(s) +# Le maillage de calcul et l'éventuel maillage de la frontiere sont écrits +# dans le meme fichier MED +# En fait, on pourrait s'en passer au dela de la 1ère itération +# car HOMARD a mémorisé. Mais dès que l'on écrit un champ, +# les conventions MED imposent la présence du maillage dans le fichier. +# Donc on va toujours écrire. +# + for dico in Liste_Maillages : + if ( dico["Action"] == "A_ecrire" ) : + motscsi={} + motscsi["MAILLAGE"] = dico["Nom_ASTER"] + motscfa={} + motscfa["RESU"]=_F( INFO_MAILLAGE=infomail, + **motscsi ) +# + IMPR_RESU ( INFO = INFO, + FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD, + **motscfa ) +# +# 4.2.4. Le(s) champ(s) +# Attention : il se peut que l'on demande la mise à jour du champ qui a servi comme +# indicateur d'erreur. Si c'est le cas, il ne faut pas demander son +# impression sinon il y a plantage d'IMPR_RESU qui ne sait pas substituer +# deux champs. D'ailleurs, c'est plus économique ainsi ! +# Remarque : pour l'adaptation, on ne demande a priori qu'une composante du champ d'indicateur. +# s'il y a demande de mise à jour, toutes les composantes sont concernées. Il faut +# donc dans ce cas imprimer le champ total. +# dico["Type_Champ"] = o ; string ; "INDICATEUR" ou "CHAMP_MAJ" +# dico["RESULTAT"] = f ; concept ASTER du résutat associé +# dico["NOM_CHAM"] = f ; string ; Nom ASTER du champ +# dico["CHAM_GD"] = f ; concept ASTER du champ de grandeur associée +# dico["COMPOSANTE"] = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur) +# dico["NUME_ORDRE"] = f ; entier ; Numéro d'ordre du champ +# dico["INST"] = f ; entier ; Instant du champ +# dico["PRECISION"] = f ; entier ; Précision sur l'instant du champ +# dico["CRITERE"] = f ; entier ; Critère de précision sur l'instant du champ +# dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage +# dico["NOM_MED"] = o ; string ; Nom MED du champ +# +# 4.2.4.1. Recherche d'un doublon éventuel sur le champ d'indicateur d'erreur +# +### print "dico_indi = ",dico_indi + if len(dico_indi) > 0 : + indic_est_deja_imprime = 0 + if dico_indi.has_key("RESULTAT") : + Liste_aux = [ "RESULTAT", "NOM_CHAM" ] + else : + Liste_aux = [ "CHAM_GD" ] + else : + indic_est_deja_imprime = 1 + Liste_aux = [ ] +### print ".. Au debut de la boucle, Liste_aux = ",Liste_aux +### print ".. Au debut de la boucle, indic_est_deja_imprime = ",indic_est_deja_imprime +# + Liste_Champs_imprime = [] + for dico in Liste_Champs : +### print "\n.... dico = ",dico +# Pour un champ à mettre à jour, on a toujours impression + if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : + Liste_Champs_imprime.append(dico) +# Si le champ d'indicateur n'a toujours pas été repéré comme champ à mettre à jour : + if not indic_est_deja_imprime : +# Est-ce le meme champ ? + ok = 1 + for cle in Liste_aux : + if ( dico.has_key(cle) ) : +### print "...... dico_indi[cle] = ",dico_indi[cle] +### print "...... dico[cle] = ",dico[cle] + if ( dico_indi[cle] != dico[cle] ) : + ok = 0 + break + else : + ok = 0 + break +# Si oui, est-ce au meme moment ? (remarque : si rien n'est désigné, c'est qu'il n'y a qu'un +# seul instant ... donc c'est le meme ! En revanche, on ne sait pas comparer une donnée +# en numéro d'ordre et une donnée en instant. On croise les doigts.) + if ok : + for cle in [ "NUME_ORDRE", "INST" ] : + if dico.has_key(cle) : + if ( dico[cle] != None ) : + if dico_indi.has_key(cle) : + if ( dico_indi[cle] != dico[cle] ) : + ok = 0 + break + if ok : indic_est_deja_imprime = 1 +### print "\n\nFin de la boucle .. indic_est_deja_imprime = ",indic_est_deja_imprime +# Si le champ d'indicateur n'a pas été repéré comme champ à mettre à jour, il faut +# l'inclure dans les champs à imprimer + if not indic_est_deja_imprime : Liste_Champs_imprime.append(dico_indi) +# +# 4.2.4.2. Impressions après le filtrage précédent +### print ".. Debut de 4.2.4.2." +# + for dico in Liste_Champs_imprime : + motscsi={} + for cle in [ "RESULTAT", "NOM_CHAM", "CHAM_GD", "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] : + if dico.has_key(cle) : + if ( dico[cle] != None ) : + motscsi[cle] = dico[cle] + if dico.has_key("COMPOSANTE") : + motscsi["NOM_CMP"] = dico["COMPOSANTE"] + motscfa={} + motscfa["RESU"]=_F( INFO_MAILLAGE=infomail, + **motscsi + ) +### print ".. motscfa = ",motscfa +# + IMPR_RESU ( INFO = INFO, + FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD, + **motscfa ) +# +# 4.3. ==> Ecriture de la commande d'écriture des fichiers de données pour HOMARD +# + motscfa={} +# +# 4.3.1. ==> Le traitement +# + motscsi={} +# +# 4.3.1.1. ==> Le type de traitement +# + if ( modhom == "ADAP" ) : + if ( ADAPTATION["UNIFORME"] != None ) : + motscsi["UNIFORME"] = ADAPTATION["UNIFORME"] + else : + motscsi["ADAPTATION"] = ADAPTATION["LIBRE"] + else : + motscsi["INFORMATION"] = "OUI" +# +# 4.3.1.2. ==> Les noms med des maillages +# + for dico in Liste_Maillages : +### print "Nom MED de " + dico["Type_Maillage"] + " = " + dico["NOM_MED"] + motscsi[ "NOM_MED_"+dico["Type_Maillage"] ] = dico["NOM_MED"] +# +# 4.3.1.3. ==> Les caracteristiques de l'éventuel indicateur d'erreur +# + for dico in Liste_Champs : + if ( dico["Type_Champ"] == "INDICATEUR" ) : + Liste_aux = [ "NOM_MED", "COMPOSANTE" ] + if dico.has_key("NUME_ORDRE") : + Liste_aux.append("NUME_ORDRE") + else : + for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] : + Liste_aux.append(cle) + for cle in Liste_aux : + if dico.has_key(cle) : + if ( dico[cle] != None ) : + motscsi[cle] = dico[cle] +# +# 4.3.1.4. ==> Les critères de raffinement et les niveaux extremes +# + if ( modhom == "ADAP" ) : + Liste_aux = [ ] + if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "RAFFINEMENT" ) : + Liste_aux.append("CRIT_RAFF_ABS") + Liste_aux.append("CRIT_RAFF_REL") + Liste_aux.append("CRIT_RAFF_PE") + if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "DERAFFINEMENT" ) : + Liste_aux.append("CRIT_DERA_ABS") + Liste_aux.append("CRIT_DERA_REL") + Liste_aux.append("CRIT_DERA_PE") + niveau = 0 + if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "RAFFINEMENT" or ADAPTATION["UNIFORME"] == "RAFFINEMENT" ) : + Liste_aux.append("NIVE_MAX") + niveau = niveau + 1 + if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "DERAFFINEMENT" or ADAPTATION["UNIFORME"] == "DERAFFINEMENT" ) : + Liste_aux.append("NIVE_MIN") + niveau = niveau + 2 + for mot_cle in Liste_aux : + if ( ADAPTATION[mot_cle] != None ) : + motscsi[mot_cle] = ADAPTATION[mot_cle] +# + if ( niveau == 2 ) : + if ( ADAPTATION["NIVE_MIN"] > ADAPTATION["NIVE_MAX"] ) : + self.cr.fatal(" Le niveau minimum doit etre inferieur au niveau maximum.") + codret = codret + 1 +# +# 4.3.1.5. ==> Numéro d'itération +# + if ( modhom == "ADAP" ) : + motscsi["NITER"] = niter +# +# 4.3.1.6. ==> Suivi de la frontiere +# + if args.has_key("GROUP_MA") : + if ( args["GROUP_MA"] != None ) : + motscsi["GROUP_MA"] = args["GROUP_MA"] +# +# 4.3.1.7. ==> Bilan +# + motscfa["TRAITEMENT"] = _F(**motscsi) +# +# 4.3.2. ==> L'analyse +# + motscsi={} + if ( NOMBRE != None ) : motscsi["NOMBRE" ] = NOMBRE + if ( QUALITE != None ) : motscsi["QUALITE" ] = QUALITE + if ( CONNEXITE != None ) : motscsi["CONNEXITE" ] = CONNEXITE + if ( TAILLE != None ) : motscsi["TAILLE" ] = TAILLE + if ( INTERPENETRATION != None ) : motscsi["INTERPENETRATION" ] = INTERPENETRATION +# + motscfa["ANALYSE"] = _F(**motscsi) +# +# 4.3.3. ==> La mise à jour de champs +# + prem = 1 + for dico in Liste_Champs : + motscsi={} + if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : + Liste_aux = [ "NOM_MED", "COMPOSANTE" ] + if dico.has_key("NUME_ORDRE") : + Liste_aux.append("NUME_ORDRE") + else : + for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] : + Liste_aux.append(cle) + for cle in Liste_aux : + if dico.has_key(cle) : + if ( dico[cle] != None ) : + motscsi[cle] = dico[cle] +### print motscsi + if prem : + motscfa["MAJ_CHAM"] = [_F(**motscsi),] + prem = 0 + else : + motscfa["MAJ_CHAM"].append(_F(**motscsi)) +# +# 4.3.4. ==> La commande +# +# 4.3.4.1. ==> Les fichiers annexes +# + dico = {} +# + Nom_Fichier_Configuration = "HOMARD.Configuration" + Fichier_Configuration = os.path.join(Rep_Calc_HOMARD_global,Nom_Fichier_Configuration) + dico[Fichier_Configuration] = ("HOMARD_CONFIG","UNITE_CONF",unite) +# + if ( modhom != "ADAP" ) : + unite = unite + 1 + Nom_Fichier_Donnees = "HOMARD.Donnees" + Fichier_Donnees = os.path.join(Rep_Calc_HOMARD_global,Nom_Fichier_Donnees) +# 1234567890123456 + dico[Fichier_Donnees] = ("HOMARD_DONN","UNITE_DONN",unite) +# +# 4.3.4.2. ==> L'ouverture de ces fichiers +# + for fic in dico.keys() : + DEFI_FICHIER ( ACTION= "ASSOCIER", FICHIER = fic, UNITE = dico[fic][2], + TYPE = "ASCII", ACCES = "NEW", INFO = INFO ) + motscfa[dico[fic][1]] = dico[fic][2] +# +# 4.3.4.3. ==> Ecriture +# +### print motscfa + IMPR_FICO_HOMA ( INFO=INFO, LANGUE = LANGUE, NON_SIMPLEXE = NON_SIMPLEXE, **motscfa ) +# +### for fic in dico.keys() : +### print "\nContenu de ", fic +### fichier = open (fic,"r") +### les_lignes = fichier.readlines() +### fichier.close() +### for ligne in les_lignes : +### print ligne[:-1] +# +# 4.3.4.4. ==> La fermeture des fichiers locaux +# Remarque : il faut le faire ici pour que le gestionnaire de DEFI_FICHIER soit à jour +# Remarque : aujourd'hui on est obligé de passer par le numéro d'unité logique +# + for fic in dico.keys() : + DEFI_FICHIER ( ACTION= "LIBERER", UNITE = dico[fic][2], INFO = INFO ) +# +# 4.4. ==> Ecriture de la commande d'exécution de homard +# Remarque : dans la donnée de la version de HOMARD, il faut remplacer +# le _ de la donnee 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 +# Remarque : pour le nommage des fichiers d'échange entre ASTER et HOMARD, on utilise +# la convention implicite du fort.n des entrees/sorties au format MED +# +### Fichier_ASTER_vers_HOMARD_2 = os.path.join("/home/gnicolas","fort." + str(Unite_Fichier_ASTER_vers_HOMARD)) +### shutil.copyfile(Fichier_ASTER_vers_HOMARD,Fichier_ASTER_vers_HOMARD_2) +# + VERSION_HOMARD=string.replace(VERSION_HOMARD,"_",".") + VERSION_HOMARD=string.replace(VERSION_HOMARD,"N","n") + if ( VERSION_HOMARD[-6:]=="_PERSO" ): +# motscsi["ARGUMENT"]=_F("TYPEXE"="-PERSO") + VERSION_HOMARD=VERSION_HOMARD[:-6] +# + if ( modhom == "ADAP" ) : + Nom_Fichier_Donnees = "0" +# + EXEC_LOGICIEL ( ARGUMENT = (_F(NOM_PARA=Rep_Calc_HOMARD_global), # nom du repertoire + _F(NOM_PARA=VERSION_HOMARD), # version de homard + _F(NOM_PARA=str(INFO)), # niveau d information + _F(NOM_PARA=Nom_Fichier_Donnees), # fichier de données HOMARD + ), + LOGICIEL = homard + ) +# +### if ( modhom == "ADAP" ) : +### Fichier_HOMARD_vers_ASTER_2 = os.path.join("/home/gnicolas","fort." + str(Unite_Fichier_HOMARD_vers_ASTER)) +### shutil.copyfile(Fichier_HOMARD_vers_ASTER,Fichier_HOMARD_vers_ASTER_2) +# +# 4.5. ==> Ecriture de la commande de lecture des resultats med +# Remarque : +# La fonction self.DeclareOut(a,b) focntionne ainsi : +# a est une chaine de caracteres +# b est la variable déclarée dans la commande +# le but est de associer le contenu de b à la variable locale qui sera désignée par a +# Exemple : +# self.DeclareOut("maillage_np1",ADAPTATION["MAILLAGE_NP1"]) +# ==> la variable maillage_np1 est identifiée à l'argument "MAILLAGE_NP1" du mot-clé ADAPTATION +# + if ( modhom == "ADAP" ) : +# +# 4.5.1. ==> Le maillage +# + self.DeclareOut("maillage_np1",ADAPTATION["MAILLAGE_NP1"]) + for dico in Liste_Maillages : + if ( dico["Action"] == "A_lire" ) : + maillage_np1 = LIRE_MAILLAGE ( UNITE = Unite_Fichier_HOMARD_vers_ASTER, + FORMAT = "MED", + NOM_MED = dico["NOM_MED"], + VERI_MAIL = _F(VERIF="NON"), INFO_MED = INFO, INFO = INFO ) +# +# 4.5.2. ==> Les champs +# + for dico in Liste_Champs : + if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : +### print dico + self.DeclareOut("champ_maj",dico["CHAM_MAJ"]) + motscsi={} + for cle in [ "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] : + if dico.has_key(cle) : + if ( dico[cle] != None ) : + motscsi[cle] = dico[cle] + if dico.has_key("NUME_ORDRE") : + motscsi["NUME_PT"] = dico["NUME_ORDRE"] + champ_maj = LIRE_CHAMP ( UNITE = Unite_Fichier_HOMARD_vers_ASTER, FORMAT = "MED", + MAILLAGE = maillage_np1, + NOM_MED = dico["NOM_MED"], NOM_CMP_IDEM = "OUI", TYPE_CHAM = dico["TYPE_CHAM"], + INFO = INFO, **motscsi ) +# +#-------------------------------------------------------------------- +# 5. Menage des fichiers MED et HOMARD devenus inutiles +#-------------------------------------------------------------------- +# + fic = os.path.join(Rep_Calc_HOMARD_global,"MAILL."+str(niter)+".HOM") + Liste_aux = [ Fichier_ASTER_vers_HOMARD, Fichier_HOMARD_Entree, fic ] + if ( modhom == "ADAP" ) : + Liste_aux.append(Fichier_HOMARD_vers_ASTER) + Liste_aux.append(Fichier_HOMARD_Sortie) +# + for fic in Liste_aux : + if ( INFO > 1 ) : print "Destruction du fichier ", fic + if os.path.islink(fic) : + try : + os.unlink(fic) + except os.error,codret_partiel : + self.cr.warn("Code d'erreur de unlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) + self.cr.warn("Impossible d'enlever le lien sur le fichier : "+fic) + codret = codret + 1 + if os.path.isfile(fic) : + try : + os.remove(fic) + except os.error,codret_partiel : + self.cr.warn("Code d'erreur de remove : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) + self.cr.warn("Impossible de détruire le fichier : "+fic) + codret = codret + 1 +### print os.listdir(Rep_Calc_ASTER) +### print os.listdir(Rep_Calc_HOMARD_global) +# +#-------------------------------------------------------------------- +# 6. C'est fini ! +#-------------------------------------------------------------------- +# + return codret diff --git a/Aster/Cata/cataSTA81/Macro/macr_ascouf_calc_ops.py b/Aster/Cata/cataSTA81/Macro/macr_ascouf_calc_ops.py new file mode 100644 index 00000000..f72ebd58 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_ascouf_calc_ops.py @@ -0,0 +1,687 @@ +#@ MODIF macr_ascouf_calc_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM, + FOND_FISS,CHARGE,RESU_THER,AFFE_MATERIAU, + PRES_REP,ECHANGE,TORS_P1,COMP_INCR,COMP_ELAS, + SOLVEUR,CONVERGENCE,NEWTON,RECH_LINEAIRE, + INCREMENT,THETA_3D,IMPR_TABLE,IMPRESSION,INFO,TITRE ,**args): + """ + Ecriture de la macro MACR_ASCOUF_CALC + """ + from Accas import _F + import types + import math + import aster + from math import pi,sin,cos,sqrt,atan2 + from Utilitai.Utmess import UTMESS + ier=0 +# On recopie les mots cles affe_materiau et impr_table pour les proteger + mc_AFFE_MATERIAU=AFFE_MATERIAU + mc_IMPR_TABLE =IMPR_TABLE + # On importe les definitions des commandes a utiliser dans la macro + AFFE_MODELE =self.get_cmd('AFFE_MODELE' ) + AFFE_MATERIAU =self.get_cmd('AFFE_MATERIAU' ) + AFFE_CARA_ELEM =self.get_cmd('AFFE_CARA_ELEM' ) + AFFE_CHAR_THER_F =self.get_cmd('AFFE_CHAR_THER_F') + THER_LINEAIRE =self.get_cmd('THER_LINEAIRE' ) + AFFE_CHAR_MECA =self.get_cmd('AFFE_CHAR_MECA' ) + STAT_NON_LINE =self.get_cmd('STAT_NON_LINE' ) + CALC_ELEM =self.get_cmd('CALC_ELEM' ) + IMPR_RESU =self.get_cmd('IMPR_RESU' ) + IMPR_TABLE =self.get_cmd('IMPR_TABLE' ) + DEFI_FOND_FISS =self.get_cmd('DEFI_FOND_FISS' ) + CALC_THETA =self.get_cmd('CALC_THETA' ) + CALC_G_THETA_T =self.get_cmd('CALC_G_THETA_T' ) + CALC_G_LOCAL_T =self.get_cmd('CALC_G_LOCAL_T' ) + POST_RCCM =self.get_cmd('POST_RCCM' ) + POST_RELEVE_T =self.get_cmd('POST_RELEVE_T' ) + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) +#------------------------------------------------------------------ +# DATA + GRMAIL = ('COUDE','PEAUINT','PEAUEXT','EXTUBE','CLGV','FACE1','FACE2') +#------------------------------------------------------------------ +# + if CL_BOL_P2_GV!=None : + if TYPE_MAILLAGE=='SOUS_EPAIS_COUDE' : + message= ' la condition aux limites sur bol a section conique \n' + message=message+' est ignoree pour un coude avec sous-epaisseurs \n' + UTMESS('A', "MACR_ASCOUF_CALC", message) + elif (TYPE_MAILLAGE[:4]!='FISS') and (CL_BOL_P2_GV['AZIMUT']!=None) : + UTMESS('E', "MACR_ASCOUF_CALC", "mot-cle AZIMUT non autorise dans le cas d un coude sain") +# + if mc_IMPR_TABLE!=None : + FLAG = 0 + if (mc_IMPR_TABLE['NOM_PARA']==None) and (mc_IMPR_TABLE['POSI_ANGUL']==None) and (mc_IMPR_TABLE['POSI_CURV_LONGI']==None) : + UTMESS('E', "MACR_ASCOUF_CALC", "POSI_ANGUL POSI_CURV_LONGI est obligatoire") + return ier + if (mc_IMPR_TABLE['NOM_PARA']!=None) : + impr_table_nom_para= mc_IMPR_TABLE['NOM_PARA'] + for impt in impr_table_nom_para : + if impt in ('SI_LONG','SI_CIRC','SI_RADI') : + FLAG = 1 + if (((impt['ANGLE']==None) and (impt['POSI_ANGUL']==None) and (impt['R_CINTR' ]==None)) or + ((impt['ANGLE']==None) and (impt['R_CINTR' ]==None) and (impt['POSI_CURV_LONGI']==None)) ) : + UTMESS('E', "MACR_ASCOUF_CALC", "il faut renseigner : ANGLE, R_CINTR et POSI_ANGUL ou ANGLE, R_CINTR et POSI_CURV_LONGI") + if (mc_IMPR_TABLE['NOM_PARA']==None) : FLAG = 1 + if not FLAG : UTMESS('A', "MACR_ASCOUF_CALC","ANGL_COUDE et ANGL_SOUS_EPAI sont inutiles dans ce cas") +# +#------------------------------------------------------------------ +# +# --- commande AFFE_MODELE --- +# + self.DeclareOut('modele',MODELE) + mcfact=[] + if (PRES_REP!=None) and (PRES_REP['PRES_LEVRE']=='OUI') and (TYPE_MAILLAGE[:4]=='FISS') : + mcfact.append(_F(GROUP_MA=GRMAIL ,PHENOMENE='MECANIQUE',MODELISATION='3D' )) + else: + mcfact.append(_F(GROUP_MA=GRMAIL[:5] ,PHENOMENE='MECANIQUE',MODELISATION='3D' )) + if TORS_P1!=None : + mcfact.append(_F(GROUP_MA='P1' ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR')) + if CL_BOL_P2_GV==None : + mcfact.append(_F(GROUP_MA='P2' ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR')) + modele = AFFE_MODELE( MAILLAGE = MAILLAGE , + AFFE = mcfact ) + if ECHANGE!=None : # modele thermique + __modthe = AFFE_MODELE( MAILLAGE = MAILLAGE , + AFFE = _F(TOUT ='OUI', + PHENOMENE ='THERMIQUE', + MODELISATION='3D' ) ) +#------------------------------------------------------------------ +# +# --- commande AFFE_MATERIAU --- +# + if CHAM_MATER!=None : self.DeclareOut('affmat',CHAM_MATER) + mcfact=[] + for mater in mc_AFFE_MATERIAU : + if mater['TOUT']!=None : + mcfact.append(_F(TOUT =mater['TOUT' ],MATER=mater['MATER'],TEMP_REF=mater['TEMP_REF'])) + rccmat = mater['MATER'] + else : + mcfact.append(_F(GROUP_MA=mater['GROUP_MA'],MATER=mater['MATER'],TEMP_REF=mater['TEMP_REF'])) + if mater['GROUP_MA'][:5]=='COUDE' : + if TORS_P1!=None : + mcfact.append(_F(GROUP_MA='P1',MATER=mater['MATER'],TEMP_REF=mater['TEMP_REF'])) + mcfact.append(_F(GROUP_MA='P2',MATER=mater['MATER'],TEMP_REF=mater['TEMP_REF'])) + elif (len(mc_AFFE_MATERIAU)==1) and (CL_BOL_P2_GV==None) : + mcfact.append(_F(GROUP_MA='P2',MATER=mater['MATER'],TEMP_REF=mater['TEMP_REF'])) + elif (mater['BOL' ][:3]=='BOL' ) and (CL_BOL_P2_GV==None) : + mcfact.append(_F(GROUP_MA='P2',MATER=mater['MATER'],TEMP_REF=mater['TEMP_REF'])) + affmat = AFFE_MATERIAU( MAILLAGE = MAILLAGE , + MODELE = modele , + AFFE = mcfact ) +#------------------------------------------------------------------ +# +# --- commande AFFE_CARA_ELEM --- +# + if (TORS_P1!=None) or (CL_BOL_P2_GV==None) : + if CARA_ELEM!=None : self.DeclareOut('carael',CARA_ELEM) + motscles={} + motscles['DISCRET']=[] + if (TORS_P1!=None) : motscles['DISCRET'].append(_F( GROUP_MA='P1' , + CARA ='K_TR_D_N', + VALE = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ),) + if (CL_BOL_P2_GV==None) : motscles['DISCRET'].append(_F( GROUP_MA='P2' , + CARA ='K_TR_D_N', + VALE = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ),) + + carael = AFFE_CARA_ELEM( MODELE = modele ,**motscles) +# + if ECHANGE!=None : +#------------------------------------------------------------------ +# +# --- commande AFFE_CHAR_THER_F --- +# condition aux limites +# + __chther = AFFE_CHAR_THER_F( MODELE = __modthe , + ECHANGE= _F(GROUP_MA='PEAUINT', + COEF_H =ECHANGE['COEF_H'], + TEMP_EXT=ECHANGE['TEMP_EXT'],), ) +#------------------------------------------------------------------ +# +# --- calcul thermique --- +# + if RESU_THER!=None : self.DeclareOut('resuth',RESU_THER) + mcsimp={} + if INCREMENT['NUME_INST_INIT']!=None : mcsimp['NUME_INIT']=INCREMENT['NUME_INST_INIT'] + if INCREMENT['NUME_INST_FIN' ]!=None : mcsimp['NUME_FIN' ]=INCREMENT['NUME_INST_FIN' ] + mcfact=_F(LIST_INST=INCREMENT['LIST_INST'],**mcsimp) + resuth = THER_LINEAIRE( MODELE = __modthe , + CHAM_MATER = affmat , + TEMP_INIT = _F(STATIONNAIRE='OUI',), + EXCIT = _F(CHARGE=__chther,), + INCREMENT = mcfact, ) +# + if CHARGE!=None : self.DeclareOut('chmeth',CHARGE) + chmeth = AFFE_CHAR_MECA( MODELE = modele , + TEMP_CALCULEE = resuth ) +#------------------------------------------------------------------ +# +# --- commande AFFE_CHAR_MECA --- +# condition aux limites de type raccord 3d-poutre +# ou bien blocage de mouvements rigides en cas d embout +# a section conique, bol de type gv +# + motscles={} + motscles['LIAISON_ELEM']=[] + if TORS_P1!=None : + motscles['LIAISON_ELEM'].append(_F( OPTION ='3D_POU' , + GROUP_MA_1='EXTUBE', + GROUP_NO_2='P1') ) + if CL_BOL_P2_GV==None : + motscles['LIAISON_ELEM'].append(_F( OPTION ='3D_POU' , + GROUP_MA_1='CLGV', + GROUP_NO_2='P2') ) + motscles['DDL_IMPO' ]=_F( GROUP_NO ='P2' , + DX = 0.0 , + DY = 0.0 , + DZ = 0.0 , + DRX = 0.0 , + DRY = 0.0 , + DRZ = 0.0 , ) + else : + motscles['FACE_IMPO' ]=_F( GROUP_MA ='CLGV' , + DNOR = 0.0 , ) + ALPHA = CL_BOL_P2_GV['ANGLE' ] + AZIM = CL_BOL_P2_GV['AZIMUT'] + ALPHAR = ALPHA*pi/180.0 + AZIMR = AZIM *pi/180.0 + DDLB1 = [] + COEFB1 = [] + if (AZIM!=0.0) and (AZIM!=180.0) and (ALPHA!=90.0) : + DDLB1.append('DX') + COEFB1.append(SIN(AZIMR)*COS(ALPHAR)) + if (AZIM!=90.0) : + DDLB1.append('DY') + COEFB1.append(COS(AZIMR)) + if (AZIM!=0.) and (AZIM!=180.) and (ALPHA!=0.): + DDLB1.append('DZ') + COEFB1.append(-SIN(AZIMR)*SIN(ALPHAR)) + POINT=['BOUT1',]*len(DDLB1) + motscles['LIAISON_DDL']=_F( GROUP_NO = POINT , + DDL = DDLB1 , + COEF_MULT = COEFB1 , + COEF_IMPO = 0.0 , ) + + __conlim = AFFE_CHAR_MECA( MODELE = modele ,**motscles) +# +# --- commande AFFE_CHAR_MECA --- +# chargement mecanique : pres_rep, effet de fond +# + if PRES_REP!=None : + motscles={} + if (PRES_REP['PRES_LEVRE']=='OUI') and (TYPE_MAILLAGE[:4]=='FISS') : + motscles['PRES_REP']=_F( GROUP_MA = ('PEAUINT','FACE1','FACE2') , + PRES = PRES_REP['PRES'] ,) + else : + motscles['PRES_REP']=_F( GROUP_MA = 'PEAUINT', + PRES = PRES_REP['PRES'] ,) + if PRES_REP['EFFE_FOND_P1']!=None : + motscles['EFFE_FOND']=_F( GROUP_MA_INT = 'BORDTU' , + GROUP_MA = 'EXTUBE' , + PRES = PRES_REP['PRES'] ,) +# + __chpres = AFFE_CHAR_MECA( MODELE = modele ,**motscles) +# +# --- commande AFFE_CHAR_MECA --- +# chargement mecanique : torseur d efforts +# + if TORS_P1!=None : + __chtor = [None]*6 + i=0 + for tors in TORS_P1: + mcsimp={} + if tors['FX']!=None : mcsimp['FX']=tors['FX'] + if tors['FY']!=None : mcsimp['FY']=tors['FY'] + if tors['FZ']!=None : mcsimp['FZ']=tors['FZ'] + if tors['MX']!=None : mcsimp['MX']=tors['MX'] + if tors['MY']!=None : mcsimp['MY']=tors['MY'] + if tors['MZ']!=None : mcsimp['MZ']=tors['MZ'] + mcfact=_F(GROUP_NO='P1',**mcsimp) + __chtor[i] = AFFE_CHAR_MECA( MODELE = modele , + FORCE_NODALE = mcfact , ) + i=i+1 +# +# --- commande STAT_NON_LINE --- +# + motscles={} +# + mcfex=[] # mot clé facteur EXCIT + mcfex.append(_F(CHARGE=__conlim,)) + if ECHANGE!=None : + mcfex.append(_F(CHARGE=chmeth,)) + if PRES_REP!=None: + if PRES_REP['FONC_MULT']!=None : + mcfex.append(_F(CHARGE=__chpres,FONC_MULT=PRES_REP['FONC_MULT'])) + else : + mcfex.append(_F(CHARGE=__chpres,)) + if TORS_P1!=None: + i=0 + for tors in TORS_P1 : + if tors['FONC_MULT']!=None : + mcfex.append(_F(CHARGE=__chtor[i],FONC_MULT=tors['FONC_MULT'])) + else : + mcfex.append(_F(CHARGE=__chtor[i],)) + i=i+1 + motscles['EXCIT'] =mcfex +# + mcfci=[] # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets + if COMP_INCR!=None : + mcfci.append(_F(TOUT='OUI' ,RELATION=COMP_INCR['RELATION'])) + elif COMP_ELAS!=None : + motscles['COMP_ELAS'] =_F(GROUP_MA='COUDE',RELATION=COMP_ELAS['RELATION']) + if TORS_P1!=None : mcfci.append( _F(GROUP_MA='P1',RELATION='ELAS')) + if CL_BOL_P2_GV==None: mcfci.append( _F(GROUP_MA='P2',RELATION='ELAS')) + motscles['COMP_INCR'] =mcfci +# + dSolveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste) + for i in dSolveur.keys(): + if dSolveur[i]==None : del dSolveur[i] +# + dConverg=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste) + for i in dConverg.keys(): + if dConverg[i]==None : del dConverg[i] +# + dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste) + for i in dNewton.keys(): + if dNewton[i]==None : del dNewton[i] +# + dRechlin=RECH_LINEAIRE[0].cree_dict_valeurs(RECH_LINEAIRE[0].mc_liste) + for i in dRechlin.keys(): + if dRechlin[i]==None : del dRechlin[i] +# + dIncrem=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste) + for i in dIncrem.keys(): + if dIncrem[i]==None : del dIncrem[i] +# + if TITRE!=None : + motscles['TITRE' ] =TITRE + motscles ['SOLVEUR' ] =dSolveur + motscles ['CONVERGENCE' ] =dConverg + motscles ['NEWTON' ] =dNewton + motscles ['RECH_LINEAIRE'] =dRechlin + motscles ['INCREMENT' ] =dIncrem + self.DeclareOut('nomres',self.sd) + nomres = STAT_NON_LINE( MODELE = modele , + CHAM_MATER = affmat , + CARA_ELEM = carael , + INFO = INFO , **motscles) +# +# --- commande CALC_ELEM --- +# + nomres = CALC_ELEM( reuse = nomres, + RESULTAT = nomres , + MODELE = modele , + TOUT_ORDRE = 'OUI' , + OPTION = ('SIEF_ELNO_ELGA','EQUI_ELNO_SIGM') , + INFO = INFO ,) +# +# --- post-traitements --- +# + if TYPE_MAILLAGE=='SOUS_EPAIS_COUDE': +# +# --- post traitement sous-epaisseurs: ligaments --- +# + if mc_IMPR_TABLE!=None: +# + SECT=('MI','TU','GV') + LIG=('FDRO','EXDR','EXTR','EXGA','FGAU','INGA','INTR','INDR') + if mc_IMPR_TABLE['POSI_ANGUL']==None: + ASEP=(mc_IMPR_TABLE['POSI_CURV_LONGI']/mc_IMPR_TABLE['R_CINTR'])*(180./pi) + else : + ASEP=mc_IMPR_TABLE['POSI_ANGUL'] +# +# moyenne_rccm, invariant et moyenne sur les ligaments dans +# l epaisseur +# + l_grno=MAILLAGE.LIST_GROUP_NO() + tabprl=[None]*4 + tablig=[None]*4 +# +# prelevements des ligaments circonferentiels et longitudinaux +# de la sous-epaisseur +# + lgrno=[] + for tgrno in l_grno : + if tgrno[0][:3] in ('CIR','LON') : lgrno.append(tgrno[0]) + elif tgrno[0][:5]=='PCENT' : lgrno.append(tgrno[0]) + elif (tgrno[0][:4] in LIG) and (tgrno[0][4:6] not in ('GV','TU','MI')): lgrno.append(tgrno[0]) +# + motscles={} + motscles['ACTION']=[] + for grno in lgrno : + motscles['ACTION'].append(_F(RESULTAT=nomres, + NOM_CHAM='SIEF_ELNO_ELGA', + TOUT_CMP='OUI', + INTITULE=grno, + GROUP_NO=grno, + OPERATION='EXTRACTION',)) + motscles['TITRE']='TABLE DE POST-TRAITEMENT SECTION SOUS-EPAISSEUR' + tabprl[1]=POST_RELEVE_T(**motscles) + tablig[1]=POST_RCCM(MATER = rccmat, + TYPE_RESU_MECA = 'EVOLUTION', + OPTION = 'PM_PB', + TRANSITOIRE=_F(TABL_RESU_MECA = tabprl[1],),) +# + motscles={} + motscles['ACTION']=[] + for tgrno in lgrno : + motscles['ACTION'].append(_F(RESULTAT=nomres, + NOM_CHAM='SIEF_ELNO_ELGA', + INTITULE=tgrno, + GROUP_NO=tgrno, + INVARIANT='OUI', + OPERATION='EXTRACTION',)) + motscles['TITRE']='TABLE DE POST-TRAITEMENT SECTION SOUS-EPAISSEUR' + + tablig[2]=POST_RELEVE_T(**motscles) +# + motscles={} + nommail=MAILLAGE.nom + coord =aster.getvectjev(nommail.ljust(8)+'.COORDO .VALE') + linomno =aster.getvectjev(nommail.ljust(8)+'.NOMNOE') + collgrno=aster.getcolljev(nommail.ljust(8)+'.GROUPENO') + + motscles['ACTION']=[] + for tgrno in lgrno : + if tgrno[:3]!='LON' : + if mc_IMPR_TABLE['TRANSFORMEE']=='TUBE': vecty=(0.,0.,1.) + else : vecty=(sin(ASEP*pi/180.),0.,cos(ASEP*pi/180.)) + else : + if mc_IMPR_TABLE['TRANSFORMEE']=='TUBE': vecty=(0.,0.,1.) + else : + grpn=collgrno['FGAUTU '] + LT1=coord[3*(grpn[0]-1)+2] + for node in grpn: + X = coord[3*(node-1)] + Y = coord[3*(node-1)+1] + Z = coord[3*(node-1)+2] + RCIN = mc_IMPR_TABLE['R_CINTR'] + if Z=120.) and (AZIM<=240.0): X = RM-EP/2.0 - SUREP + else: X = RM-EP/2.0 + else: X = RM+EP/2.0 + AZIMR = AZIM*2.0*pi/360.0 +# +# -- CALCUL COTE AXIALE DU CENTRE FISSURE SUR LA PLAQUE EN FONCTION +# DE L ABSCISSE CURVILIGNE DONNEE SUR LE COUDE OU DE LA POSITION +# ANGULAIRE +# + if DSF: + if GEOM=='COUDE': SFP = SF/(1.0+X/RC*cos(AZIMR)) + else : SFP = SF + else : + BETAR = BETA*2.0*pi/360.0 + if (GEOM=='COUDE'): + SF = BETAR*(RC+X*cos(AZIMR)) + SFP = SF/(1.0+X/RC*cos(AZIMR)) + else: + SF = BETAR*RC + SFP = SF + if (GEOM=='COUDE'): echo_mess.append( 'COTE AXIALE CENTRE FISSURE SUR COUDE : %.2f \n'%SF) + if (GEOM=='TUBE') : echo_mess.append( 'COTE AXIALE CENTRE FISSURE SUR TUBE : %.2f \n'%SF ) + echo_mess.append( 'COTE AXIALE CENTRE FISSURE SUR PLAQUE : %.2f \n'%SFP) +# +# ON ENVISAGE LE CAS OU UNE PARTIE DE L AXE EST DANS LES +# DROITES DES EMBOUTS. LA TRANSFORMATION N EST FAITE QUE SUR LA +# PARTIE RESTANT DANS LE COUDE. +# + if (GEOM=='COUDE'): DIST = ALPHA*2.0*pi/360.0*(RC+X*cos(AZIMR)) + else : DIST = ALPHA*2.0*pi/360.0*RC + BCOUD = 0.0 + BEMB = 0.0 + if abs(ORIEN)<0.01: +# -- FISSURE LONGITUDINALE (0 DEGRE) + BSUP = SF + AXEC + BINF = SF - AXEC + if BSUP>DIST: + BCOUD = DIST - BINF + BEMB = BSUP - DIST + elif BINF<0. : + BCOUD = BSUP + BEMB = abs(BINF) + elif (BINF>=0. and BSUP<=DIST): + BCOUD = 2.0*AXEC + elif abs(ORIEN-90.)<0.01: +# -- FISSURE CIRCONFERENTIELLE (90 DEGRES) + BSUP = SF + BINF = SF + if BSUP>DIST: + BCOUD = DIST - BINF + BEMB = BSUP - DIST + elif BINF<0. : + BCOUD = BSUP + BEMB = abs(BINF) + elif (BINF>=0. and BSUP<=DIST): + BCOUD = 2.0*AXEC + else: +# -- FISSURE A +/- 45 DEGRES SUR INTRADOS OU EXTRADOS + BSUP = SF + sqrt(2.0)/2.0*AXEC + BINF = SF - sqrt(2.0)/2.0*AXEC + if BSUP>DIST: + BCOUD = (DIST - BINF)*sqrt(2.0) + BEMB = (BSUP - DIST)*sqrt(2.0) + elif BINF<0. : + BCOUD = BSUP *sqrt(2.0) + BEMB = abs(BINF)*sqrt(2.0) + elif (BINF>=0. and BSUP<=DIST): + BCOUD = 2.0*AXEC + echo_mess.append( 'PARTIE DU GRAND AXE DANS LE COUDE : %.2f \n'%BCOUD) + echo_mess.append( 'PARTIE DU GRAND AXE DANS L EMBOUT : %.2f \n'%BEMB) +# +# -- CALCUL DE LA TAILLE DU GRAND AXE FISSURE SUR LA PLAQUE +# + NEWT=0 + if abs(ORIEN)<0.01: +# -- FISSURE LONGITUDINALE (0 DEGRE) + if GEOM=='COUDE': AXECP = BCOUD/(1.0+X/RC*cos(AZIMR)) + BEMB + else : AXECP = BCOUD + BEMB + elif abs(ORIEN-90.)<0.01: +# -- FISSURE CIRCONFERENTIELLE (90 DEGRES) + AXECP = (BCOUD+BEMB)*RM/X + else : + if GEOM=='COUDE': +# ------- TRANSFORMATION COUDE + if AZIM in (0.,180.): +# -- FISSURE A +/- 45 DEGRES SUR INTRADOS OU EXTRADOS + AXECP = BCOUD*RM*sqrt(2.)/( X*sqrt(1.+(RM/X+RM/RC*cos(AZIMR))**2) )+\ + BEMB*sqrt( (1.0+(X/RM)**2)*0.5 ) + else : +# -- FISSURE A +/- 45 DEGRES AILLEURS + AXECP = funct_root.root(ASCFON,(BCOUD-1.,BCOUD+1.)) + AXECP = AXECP + BEMB*sqrt( (1.+(X/RM)**2)*0.5 ) + AXECC = ASCFON(AXECP)+BCOUD + NEWT=1 + elif GEOM=='TUBE': + AXECP = (BCOUD+BEMB)*sqrt( (1.+(X/RM)**2)*0.5 ) + else : + AXECP = BCOUD + BEMB +# + if GEOM=='COUDE': + echo_mess.append( 'TAILLE GRAND AXE COUDE DONNE : %.2f \n'%(2.*AXEC)) + elif GEOM=='TUBE': + echo_mess.append( 'TAILLE GRAND AXE TUBE DONNE : %.2f \n'%(2.*AXEC)) + echo_mess.append( 'TAILLE GRAND AXE PLAQUE DEDUIT : %.2f \n'%AXECP) + if NEWT: + echo_mess.append( 'METHODE DE NEWTON FISSURE A 45 DEGRES --> \n') + echo_mess.append( 'TAILLE GRAND AXE COUDE RECALCULE : %.2f \n'%AXECC) + if GEOM=='COUDE' and BEMB>0. and BSUP>DIST : + SFP = ALPHA*2.*pi*RC/360. - AXECP/2. + BEMB + echo_mess.append( 'CORRECTION CENTRE : FISSURE A CHEVAL SUR EMBOUT \n') + echo_mess.append( 'ABSC. CURV. AXIALE CENTRE FISSURE SUR PLAQUE : %.2f \n'%SFP) + if GEOM=='COUDE' and BEMB>0. and BINF<0. : + SFP = + AXECP/2. - BEMB + echo_mess.append( 'CORRECTION CENTRE : FISSURE A CHEVAL SUR EMBOUT \n') + echo_mess.append( 'ABSC. CURV. AXIALE CENTRE FISSURE SUR PLAQUE : %.2f \n'%SFP) +# +# -- CORRECTION DU PETIT AXE DE LA FISSURE QUAND CELLE-CI SE TROUVE SUR +# LA ZONE DE SUREPAISSEUR +# + ALPHAR = ALPHA*2.*pi/360. + ZSUR1 = ALPHAR*RC/10. + ZSUR2 = ALPHAR*RC*9./10. + YFISS = (AZIMR-pi/2.)*RM + MU = 0. + if (AZIM>=120.) and (AZIM<=240.): + if (SFP>=ZSUR1) and (SFP<=ZSUR2): MU = 1. + elif (SFP<=ZSUR1): MU = SFP/ZSUR1 + elif (SFP>ZSUR2): MU = (ALPHAR*RC-SFP)/ZSUR1 + elif (AZIM>=90.) and (AZIM<=120.): + if (SFP>=ZSUR1) and (SFP<=ZSUR2): MU = YFISS/(pi/6.*RM) + elif (SFP<=ZSUR1): MU = YFISS*SFP/(pi/6.*RM*ZSUR1) + elif (SFP>ZSUR2): MU = YFISS*(ALPHAR*RC-SFP)/(pi/6.*RM*ZSUR1) + elif (AZIM>=240.) and (AZIM<=270.): + if (SFP>=ZSUR1) and (SFP<=ZSUR2): MU = (YFISS-5.*pi/6.*RM)/(pi/6.*RM) + elif (SFP<=ZSUR1): MU = (YFISS-5.*pi/6.*RM)*SFP/(pi/6.*RM*ZSUR1) + elif (SFP>ZSUR2): MU = (YFISS-5.*pi/6.*RM)*(ALPHAR*RC-SFP)/(pi/6.*RM*ZSUR1) +# + if SUREP!=0.: + AXEAP = AXEA * EP / ( EP + MU*SUREP ) + echo_mess.append( '--> CORRECTION DUE A LA SUREPAISSEUR \n' ) + echo_mess.append( '--> TAILLE PETIT AXE PLAQUE : %.2f \n'%AXEAP ) + else: AXEAP = AXEA +# + texte_final=string.join(echo_mess) + aster.affiche('MESSAGE',texte_final) + return AXEAP,AXECP,SFP + + +# ------------------------------------------------------------------------------ +def ASCSEP(MCL_SOUS_EPAIS,ALPHA,RM,RC,EP,GEOM,SYME): + """ + MACR_ASCOUF_MAIL ASCSEP + taille initiale sur la plaque des sous-epaisseurs + + ------------DONNEES FOURNIES PAR L UTILISATEUR-------------------- + + ALPHA = ANGLE DU COUDE + RM = RAYON MOYEN DU COUDE + RC = RAYON DE CINTRAGE DU COUDE + EP = EPAISSEUR DU COUDE + GEOM = TYPE DE GEOMETRIE MODELISEE (COUDE OU TUBE) + SYME = QUART DE STRUCTURE SI 'OUI' + + """ + ier=0 + CG=pi/180. + echo_mess=['MACR_ASCOUF_MAIL ASCSEP \n',] +# +# --- BOUCLE SUR L ENSEMBLE DES SOUS-EPAISSEURS +# + i=0 + for ssep in MCL_SOUS_EPAIS : + i=i+1 + echo_mess.append( '-------------------------------------\n') + echo_mess.append( 'SOUS-EPAISSEUR NUMERO %d\n'%i) + echo_mess.append( '-------------------------------------\n') +# +# --- CAS DES SOUS-EPAISSEURS AXISYMETRIQUES +# + if ssep['TYPE']=='AXIS': + echo_mess.append( 'SOUS-EPAISSEUR AXISYMETRIQUE : \n') + echo_mess.append( 'CALCUL DE LA TAILLE LONGI ENVELOPPE EN INTRADOS (AZIMUT PI)\n') + ssep.ICIRP = 2.*pi*RM + ssep.ISCP = pi*RM + ssep.IPHIC = 180. + AZIMC = pi + else: +# +# -- CALCUL DE L ABSCISSE CURVILIGNE CIRCONF.SUR LA PLAQUE +# EN FONCTION DE L AZIMUT OU DE L ABSCISSE CURVIL.CIRCONF +# SUR LE COUDE DU CENTRE DE LA SOUS-EPAISSEUR +# NB : MESURE FAITE EN PEAU EXTERNE SUR LE COUDE +# + if ssep['POSI_CURV_CIRC']!=None: + ssep.ISCP = ssep['POSI_CURV_CIRC']*RM/(RM+EP/2.) + AZIMC = ssep.ISCP/RM + ssep.IPHIC = ssep['POSI_CURV_CIRC']/(RM+EP/2.)*180./pi + echo_mess.append( 'AZIMUT CENTRE SOUS-EPAISSEUR (DEGRES) : %.2f \n'%ssep.IPHIC) + else: + ssep.ISCP = ssep['AZIMUT']*pi*RM/180. + AZIMC = ssep['AZIMUT']*pi/180. + echo_mess.append( 'ABSC. CURV. CIRCONF. CENTRE SOUS-EPAISSEUR SUR COUDE : %.2f \n'%(AZIMC*(RM+EP/2.))) +# +# PASSAGE DANS LE REPERE PLAQUE (0,2PI) AVEC ORIGINE FLANC DROIT +# CAR L ORIGINE DES DONNEES CIRCONF. EST EN EXTRADOS +# + if ssep.ISCP>(3.*pi*RM/2.): ssep.ISCP = ssep.ISCP - 3.*pi*RM/2. + else: ssep.ISCP = ssep.ISCP + pi*RM/2. + echo_mess.append( 'ABSC. CURV. CIRCONF. CENTRE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ISCP) +# +# -- CALCUL DE LA TAILLE CIRCONFERENTIELLE +# NB : MESURE FAITE EN PEAU EXTERNE SUR LE COUDE +# + ssep.ICIRP = ssep['AXE_CIRC']*(RM/(RM+EP/2.)) + if ssep.ICIRP>(2.*pi*RM) : + texte_final=string.join(echo_mess) + aster.affiche("MESSAGE",texte_final) + message= ' ASCSEP valeur hors domaine \n' + message=message+' sous-epaisseur numero : %d \n'%i + message=message+' taille axe circonferentiel : %.2f \n'%ssep.ICIRP + message=message+' bord plaque : %.2f \n'%2*pi*RM + UTMESS('F', "MACR_ASCOUF_MAIL", message) + echo_mess.append( 'TAILLE CIRCONFERENTIELLE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ICIRP) + echo_mess.append( '<=> TAILLE EQUIVALENTE SUR LA CIRCONFERENCE (DEGRES) : %.2f \n'%(ssep.ICIRP*360./(2.*pi*RM))) + +# +# -- CALCUL COTE AXIALE DU CENTRE SOUS-EPAISSEUR SUR LA PLAQUE +# EN FONCTION DE L ABSCISSE CURVILIGNE DONNEE SUR LE COUDE +# OU DE LA POSITION ANGULAIRE +# NB : MESURE FAITE EN PEAU EXTERNE SUR LE COUDE +# + if ssep['POSI_CURV_LONGI']!=None: + if GEOM=='COUDE': + ssep.ISLP = ssep['POSI_CURV_LONGI']/(1.+(RM+EP/2.)/RC*cos(AZIMC)) + AZIML = ssep.ISLP/RC + echo_mess.append( 'ANGLE COUDE CENTRE SOUS-EPAISSEUR (DEGRES) : %.2f \n'%(AZIML*180./pi)) + else : + ssep.ISLP = ssep['POSI_CURV_LONGI'] + if (SYME in ('QUART','DEMI')) and (ssep.ISLP!=ALPHA*CG*RC/2.) : + texte_final=string.join(echo_mess) + aster.affiche("MESSAGE",texte_final) + message= ' ASCSEP cas de symetrie :\n' + message=message+ ' la sous-epaisseur doit etre dans la section mediane du coude !\n' + UTMESS('F', "MACR_ASCOUF_MAIL", message) + else : + if GEOM=='COUDE': + echo_mess.append( 'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR COUDE : %.2f \n'%((ssep.BETA)*CG*(RC+(RM+EP/2.)*cos(AZIMC)))) + AZIML = (ssep.BETA)*CG + else : + echo_mess.append( 'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR TUBE : %.2f \n'%((ssep.BETA)*CG*RC) ) + ssep.ISLP = (ssep.BETA)*CG*RC + if (SYME in ('QUART','DEMI')) and (ssep.BETA!=ALPHA/2.) : + texte_final=string.join(echo_mess) + aster.affiche("MESSAGE",texte_final) + message= ' ASCSEP cas de symetrie :\n' + message=message+ ' la sous-epaisseur doit etre dans la section mediane du coude !\n' + UTMESS('F', "MACR_ASCOUF_MAIL", message) + echo_mess.append( 'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ISLP) +# +# -- CALCUL DE LA TAILLE LONGITUDINALE +# NB : MESURE FAITE EN PEAU EXTERNE SUR LE COUDE +# +# ON ENVISAGE LE CAS OU UNE PARTIE DE L AXE EST DANS LES +# DROITES DES EMBOUTS. LA TRANSFORMATION N EST FAITE QUE SUR LA +# PARTIE RESTANT DANS LE COUDE. +# + if GEOM=='COUDE' : DIST = ALPHA*CG*(RC+(RM+EP/2.)*cos(AZIMC)) + else : DIST = ALPHA*CG*RC + if ssep['POSI_CURV_LONGI']!=None: + BSUP = ssep['POSI_CURV_LONGI']+ssep['AXE_LONGI']/2. + BINF = ssep['POSI_CURV_LONGI']-ssep['AXE_LONGI']/2. + else: + if GEOM=='COUDE' : + BSUP = ssep.BETA*CG*(RC+(RM+EP/2.)*cos(AZIMC))+ssep['AXE_LONGI']/2. + BINF = ssep.BETA*CG*(RC+(RM+EP/2.)*cos(AZIMC))-ssep['AXE_LONGI']/2. + else: + BSUP = ssep.BETA*CG*RC + ssep['AXE_LONGI']/2. + BINF = ssep.BETA*CG*RC - ssep['AXE_LONGI']/2. + BCOUD1 = 0. + BCOUD2 = 0. + BEMB1 = 0. + BEMB2 = 0. + if BINF<0. and BSUP>DIST : + BCOUD1 = DIST + BEMB1 = abs(BINF) + BSUP-DIST + elif BSUP>DIST : + BCOUD1 = DIST - BINF + BEMB1 = BSUP - DIST + elif BINF<0 : + BCOUD2 = BSUP + BEMB2 = abs(BINF) + elif (BINF>=0. and BSUP<=DIST) : + BCOUD1 = ssep['AXE_LONGI'] + BCOUD = BCOUD1+ BCOUD2 + BEMB = BEMB1 + BEMB2 + if GEOM=='COUDE' : BPLAQ = BCOUD/(1.+(RM+EP/2.)/RC*cos(AZIMC)) + else : BPLAQ = BCOUD + ssep.ILONP = BPLAQ+BEMB + if BEMB1>0.: + ssep.ISLP = ALPHA*CG*RC - ssep.ILONP/2. + BEMB1 + echo_mess.append( 'CORRECTION CENTRE : SOUS-EP. A CHEVAL SUR EMBOUT \n') + echo_mess.append( 'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ISLP) + if BEMB2>0.: + ssep.ISLP = ssep.ILONP/2. - BEMB2 + echo_mess.append( 'CORRECTION CENTRE : SOUS-EP. A CHEVAL SUR EMBOUT \n') + echo_mess.append( 'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ISLP) + if ssep.ISLP<0. : ssep.ISLP = 0. + if (ssep.ISLP>ALPHA*CG*RC) : ssep.ISLP = ALPHA*CG*RC +# +# SI LE CENTRE DE LA SOUS-EP CALCULE SUR LA PLAQUE EST DANS L EMBOUT +# ON CORRIGE SA POSITION EN LE METTANT A L INTERFACE SINON CA PLANTE +# DANS LA PROC DE MAILLAGE (A AMELIORER) +# + echo_mess.append( 'TAILLE LONGITUDINALE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ILONP) + echo_mess.append( '<=> TAILLE EQUIVALENTE PAR RAPPORT A L ANGLE DU COUDE (DEGRES): %.2f \n'%(ssep.ILONP*360/(2*pi*RC))) +# + texte_final=string.join(echo_mess) + aster.affiche('MESSAGE',texte_final) + return ier + +# ------------------------------------------------------------------------------ +def ASCTCI(MCL_SOUS_EPAIS,RM): + """ + MACR_ASCOUF_MAIL ASCTCI + APPELEE DANS : ASCSYM et ASCPRE + CALCUL TABLEAU TRIE DES ABSCISSES DES CENTRES DE SOUS-EPAISSEURS + + ------------DONNEES FOURNIES PAR L UTILISATEUR-------------------- + + RM = RAYON MOYEN DU COUDE + + -----------------DONNEES RENVOYEES----------------------- + + IABSC1 = CORRESPONDANCE ABSC. CURVI. CIRCONF. SOUS-EP. I + IABSC2 = CORRESPONDANCE ABSC. GAUCHE ET DROITE CIRCONF. SOUS-EP. I + COORXD = ABSC. DU BORD DROIT DE LA SOUS-EP I + COORXG = ABSC. DU BORD GAUCHE DE LA SOUS-EP I + + """ +# +# --- tri du tableau des abscisses curvilignes circonf. plaque +# + echo_mess=['MACR_ASCOUF_MAIL ASCTCI \n',] + TAMPON = [] + COORXG = [] + COORYG = [] + i=0 + for ssep in MCL_SOUS_EPAIS : + i=i+1 + if (ssep.ISCP>2.*pi*RM) or (ssep.ISCP<0.) : + texte_final=string.join(echo_mess) + aster.affiche("MESSAGE",texte_final) + message= ' valeur hors domaine \n' + message=message+ ' SOUS-EPAISSEUR NUMERO :%d'%MCL_SOUS_EPAIS.index(ssep) + message=message+ ' ABSC. CURV. CIRCONF. :%.2f \n'%ssep.ISCP + message=message+ ' BORD PLAQUE :%.2f \n'%(2.*pi*RM) + UTMESS('F', "MACR_ASCOUF_MAIL", message) + TAMPON.append((ssep.ISCP,i)) + TAMPON.sort() + IABSC1=[] + for j in range(i): + IABSC1.append(TAMPON[j][1]) + echo_mess.append( ' \n') + echo_mess.append( 'TRI DES CENTRES ABSC. CURV. CIRCONF. :\n ') + echo_mess.append( '------------------------------------\n') + i=0 + for ssep in TAMPON : + i=i+1 + echo_mess.append( '%d) SOUS-EP NO %d <> XC = %.2f \n'%(i,ssep[1],ssep[0]) ) +# +# --- calcul des abcisses droites et gauches des sous-epaisseurs +# + COORXD=[] + COORXG=[] + for bid in TAMPON : + XG=bid[0]-MCL_SOUS_EPAIS[bid[1]-1].ICIRP/2. + if XG<0. : XG=XG+2.*pi*RM + COORXG.append(XG) + XD=bid[0]+MCL_SOUS_EPAIS[bid[1]-1].ICIRP/2. + if XD>2.*pi*RM : XD=XD-2.*pi*RM + COORXD.append(XD) +# +# --- tri des bornes d'intervalles en abscisse +# + TAMPON = [] + for j in range(len(MCL_SOUS_EPAIS)): + TAMPON.append((COORXG[j],2*j+1)) + TAMPON.append((COORXD[j],2*j+2)) + TAMPON.sort() + IABSC2=[] + for j in range(2*len(MCL_SOUS_EPAIS)): + IABSC2.append(TAMPON[j][1]) + echo_mess.append( '\n') + echo_mess.append( 'TRI DES INTERVALLES G ET D ABSC. CURV. CIRCONF. :\n') + echo_mess.append( '-----------------------------------------------\n' ) + for j in range(2*len(MCL_SOUS_EPAIS)): + if fmod(IABSC2[j],2): + echo_mess.append( '%d) SOUS-EP NO %d <> XG = %.2f \n'%(j+1,IABSC1[IABSC2[j]/2],TAMPON[j][0])) + else: + echo_mess.append( '%d) SOUS-EP NO %d <> XD = %.2f \n'%(j+1,IABSC1[IABSC2[j]/2-1],TAMPON[j][0])) +# + texte_final=string.join(echo_mess) + aster.affiche('MESSAGE',texte_final) + return TAMPON,IABSC1,IABSC2,COORXD,COORXG + +# ------------------------------------------------------------------------------ +def ASCTLO(MCL_SOUS_EPAIS,RC,ALPHA,LTCHAR,LTCLIM): + """ + MACR_ASCOUF_MAIL ASCTLO + APPELEE DANS : ASCSYM et ASCPRE + CALCUL TABLEAU TRIE DES ORDONNEES DES CENTRES DE SOUS-EPAISSEURS + + ------------DONNEES FOURNIES PAR L UTILISATEUR-------------------- + + RC = RAYON MOYEN DU COUDE + ALPHA = ANGLE DU COUDE + LTCHAR = LONGUEUR DE L'EMBOUT DU COTE CHARGEMENT + LTCLIM = LONGUEUR DE L'EMBOUT DU COTE CONDITIONS AUX LIMITES + + -----------------DONNEES RENVOYEES----------------------- + + IORDO1 = CORRESPONDANCE ORDO. CURVI. LONGIT. SOUS-EP. I + IORDO2 = CORRESPONDANCE ORDO. GAUCHE ET DROITE LONGIT. SOUS-EP. I + COORYI = ORDONNEE. DU BORD INTERIEUR DE LA SOUS-EP I + COORYS = ORDONNEE. DU BORD SUPERIEUR DE LA SOUS-EP I + + """ +# +# tri du tableau des abscisses curvilignes axiales plaque +# + echo_mess=['MACR_ASCOUF_MAIL ASCTLO \n',] + ALPHAR = 2.*ALPHA*pi/360. + TAMPON = [] + i=0 + for ssep in MCL_SOUS_EPAIS : + i=i+1 + if (ssep.ISLP>ALPHAR*RC) or (ssep.ISLP<0.) : + texte_final=string.join(echo_mess) + aster.affiche("MESSAGE",texte_final) + message= ' valeur hors domaine \n' + message=message+ ' SOUS-EPAISSEUR NUMERO :%d \n'%MCL_SOUS_EPAIS.index(ssep) + message=message+ ' ABSC. CURV. LONGIT. :%.2f \n'%ssep.ISLP + message=message+ ' BORDS PLAQUE :%.2f \n'%(ALPHAR*RC) + UTMESS('F', "MACR_ASCOUF_MAIL", message) + TAMPON.append((ssep.ISLP,i)) + TAMPON.sort() + IORDO1=[] + for j in range(i): + IORDO1.append(TAMPON[j][1]) + echo_mess.append( '\n') + echo_mess.append( 'TRI DES CENTRES ABSC. CURV. LONGIT. : \n') + echo_mess.append( '------------------------------------ \n') + i=0 + for ssep in TAMPON : + i=i+1 + echo_mess.append( '%d) SOUS-EP NO %d <> YC = %.2f \n'%(i,ssep[1],ssep[0])) +# +# calcul des abscisses sup. et inf. des sous-ep. +# + COORYI=[] + COORYS=[] + EPS=0.000000000001 + for bid in TAMPON : + i=i+1 + YI=bid[0]-MCL_SOUS_EPAIS[bid[1]-1].ILONP/2. + YS=bid[0]+MCL_SOUS_EPAIS[bid[1]-1].ILONP/2. + if fabs(bid[0])(ALPHAR*RC+LTCLIM): + texte_final=string.join(echo_mess) + aster.affiche("MESSAGE",texte_final) + message= ' valeur hors domaine \n' + message=message+ ' SOUS-EPAISSEUR NUMERO :%d \n'%bid[1] + message=message+ ' BORD INFERIEUR :%.2f \n'%YI + message=message+ ' BORDS PLAQUE :%.2f \n'%(ALPHAR*RC+LTCLIM) + UTMESS('F', "MACR_ASCOUF_MAIL", message) + COORYI.append(YI) + COORYS.append(YS) +# +# tri des bornes d'intervalles en abscisse +# + TAMPON = [] + for j in range(len(MCL_SOUS_EPAIS)): + TAMPON.append((COORYI[j],2*j+1)) + TAMPON.append((COORYS[j],2*j+2)) + TAMPON.sort() + IORDO2=[] + for j in range(2*len(MCL_SOUS_EPAIS)): + IORDO2.append(TAMPON[j][1]) + echo_mess.append( '\n') + echo_mess.append( 'TRI DES INTERVALLES I ET S ABSC. CURV. LONGIT. : \n') + echo_mess.append( '----------------------------------------------- \n') + for j in range(2*len(MCL_SOUS_EPAIS)): + if fmod(IORDO2[j],2): + echo_mess.append( '%d) SOUS-EP NO %d <> YI = %.2f \n'%(j+1,IORDO1[IORDO2[j]/2],TAMPON[j][0])) + else: + echo_mess.append( '%d) SOUS-EP NO %d <> YS = %.2f \n'%(j+1,IORDO1[IORDO2[j]/2-1],TAMPON[j][0])) +# + texte_final=string.join(echo_mess) + aster.affiche('MESSAGE',texte_final) + return TAMPON,IORDO1,IORDO2,COORYI,COORYS +# +# +################################################################################ +################################################################################ +################################################################################ +# MACR_ASCOUF_MAIL ASCNBE +# APPELEE DANS : ASCSYM et ASCPRE +# CALCUL DU NOMBRE D'ELEMENTS LONGI ET CIRCONF. DANS LES SOUS-EPAISSEURS +# +#-----------------DONNEES FOURNIES PAR L UTILISATEUR-------------------- +# +# COORXG = ABSCISSE DU BORD GAUCHE DE LA SOUS-EPAISSEUR I +# COORXD = ABSCISSE DU BORD DROIT DE LA SOUS-EPAISSEUR I +# COORYI = ORDONNEE DU BORD INFERIEUR DE LA SOUS-EPAISSEUR I +# COORYS = ORDONNEE DU BORD SUPERIEUR DE LA SOUS-EPAISSEUR I +# BD = ABSCISSE DU BORD DROIT DE LA ZONE CIRCONF J +# BG = ABSCISSE DU BORD GAUCHE DE LA ZONE CIRCONF J +# BS = ORDONNEE DU BORD SUPERIEUR DE LA ZONE LONGI J +# BI = ORDONNEE DU BORD INFERIEUR DE LA ZONE LONGI J +# DNX = DENSITE ET NOMBRE D'ELEMENTS CIRCONF. DE LA ZONE J +# DNY = DENSITE ET NOMBRE D'ELEMENTS LONGIT. DE LA ZONE J +# INDSEX = NUMERO DE SOUS-EPAISSEUR CONTENU DANS LA ZONE CIRCONF J +# INDSEY = NUMERO DE SOUS-EPAISSEUR CONTENU DANS LA ZONE LONGI J +# RM = RAYON MOYEN DU COUDE +# RC = RAYON DE CINTRAGE DU COUDE +# IABSC1 = CORRESPONDANCE ABSCISSE CURVILIGNE CIRCONF. SOUS-EP. I +# IORDO1 = CORRESPONDANCE ABSCISSE CURVILIGNE LONGIT. SOUS-EP. I +# +#----------------------DONNEES RENVOYEES----------------------- +# +# NLX = NOMBRE TOTAL D'ELEMENTS CIRCONF. DE LA SOUS-EPAISSEUR K +# NLY = NOMBRE TOTAL D'ELEMENTS LONGIT. DE LA SOUS-EPAISSEUR K +# +# ------------------------------------------------------------------------------ +def ASCNBE(MCL_SOUS_EPAIS,COORXG,COORXD,COORYI,COORYS,BD,BG,BS,BI,DNX,DNY,RM,RC, + INDSEX,INDSEY,IABSC1,IORDO1): +# +# calcul du nombre d'elements longi. et circonf. dans les sous-epaisseurs: +# + echo_mess=['MACR_ASCOUF_MAIL ASCNBE \n',] + echo_mess.append( '\n') + echo_mess.append( 'DETERMINATION DU NOMBRE D''ELEMENTS DANS LES SOUS-EPAISSEURS :\n') + echo_mess.append( '------------------------------------------------------------\n') + NLX=[0]*len(MCL_SOUS_EPAIS) + NLY=[0]*len(MCL_SOUS_EPAIS) + for j in range(len(BD)): + if INDSEX[j]!=0: +# calcul au passage du nombre d'elements sur chaque zone circonf. + RNBEL = (BD[j]-BG[j])*360./(DNX[2*j]*2.*pi*RM) + RNBEL2 = RNBEL - floor(RNBEL) + if RNBEL2 <= 0.5 : NBEL=int(floor(RNBEL)) + else : NBEL=int(floor(RNBEL))+1 + if NBEL <= 1 : NBEL=2 +# calcul au passage du nombre d'elements sur chaque sous-epaisseur circonf. + for i in range(len(MCL_SOUS_EPAIS)): + l=IABSC1[i]-1 + if ((COORXG[l]=COORXG[l] and BD[j]<=COORXD[l])\ + or (COORXG[l]>=COORXD[l] and (BG[j]<=COORXG[l] or BD[j]>=COORXD[l]))): + NLX[i]=NLX[i]+NBEL + echo_mess.append( 'SOUS-EP NO %d ZONE CIRC. NO %d NB ELEM. = %d \n'%(i+1,j+1,NBEL)) + + for j in range(len(BS)): + if INDSEY[j]!=0: +# calcul au passage du nombre d'elements sur chaque zone longi. + RNBEL = ((BS[j]-BI[j])*360.)/(DNY[2*j]*2.*pi*RC) + RNBEL2 = RNBEL - floor(RNBEL) + if RNBEL2 <= 0.5 : NBEL=int(floor(RNBEL)) + else : NBEL=int(floor(RNBEL))+1 + if NBEL <= 1 : NBEL=2 +# calcul au passage du nombre d'elements sur chaque sous-epaisseur circonf. + i=0 + for i in range(len(MCL_SOUS_EPAIS)): + l=IORDO1[i]-1 + if (BI[j]>=COORYI[l] and BS[j]<=COORYS[l]): + NLY[i]=NLY[i]+NBEL + echo_mess.append( 'SOUS-EP NO %d ZONE LONGI. NO %d NB ELEM. = %d \n'%(i+1,j+1,NBEL) ) + + for j in range(len(NLX)): + echo_mess.append( 'SOUS-EP NO %d NBE TOTAL ELEMENTS CIRCONF. : %d \n'%(j+1,NLX[j])) + echo_mess.append( 'SOUS-EP NO %d NBE TOTAL ELEMENTS LONGI. : %d \n'%(j+1,NLY[j])) + +# + texte_final=string.join(echo_mess) + aster.affiche('MESSAGE',texte_final) + return NLX,NLY +# +################################################################################ +################################################################################ +################################################################################ +# MACR_ASCOUF_MAIL ASCSYM +# PREPARATION DES DONNEES POUR LE MAILLAGE DE PLAQUE AVEC +# SOUS-EPAISSEURS : +# CAS D UNE SOUS-EPAISSEUR DANS LE PLAN DE SYMETRIE +# CONSTRUCTION D UN QUART DU MAILLAGE +# - CALCUL TABLEAU TRIE DES ABSCISSES ET ORDONNEES DES CENTRES +# - CALCUL TABLEAU DES ZONES COUVERTES PAR LES SOUS-EPAISSEURS +# +#-----------------DONNEES FOURNIES PAR L UTILISATEUR-------------------- +# +# RM = RAYON MOYEN DU COUDE +# RC = RAYON DE CINTRAGE DU COUDE +# ALPHA = ANGLE DU COUDE +# LT = LONGUEUR DE L EMBOUT DU COTE CHARGEMENT +# LGV = LONGUEUR DE L EMBOUT DU COTE CONDITIONS AUX LIMITES +# NBSEP = NOMBRE DE SOUS-EPAISSEURS +# +#----------------------DONNEES RENVOYEES----------------------- +# +# NZONEX = NOMBRE DE ZONES CIRCONFERENTIELLES +# NZONEY = NOMBRE DE ZONES LONGITUDINALES +# +# ------------------------------------------------------------------------------ +def ASCSYM(MCL_SOUS_EPAIS,RM,RC,ALPHA,LTCHAR,LTCLIM): + ier=0 + echo_mess=['MACR_ASCOUF_MAIL ASCSYM \n',] + DERAFC = 18. + DERAFL = 5. + INDSEX = [] + INDSEY = [] + BG = [] + BD = [] + INDBG = [] + INDBD = [] + DNX = [] + +# +# --- tri des donnees sous-ep. en circonferentiel + TAMPON,IABSC1,IABSC2,COORXD,COORXG=ASCTCI(MCL_SOUS_EPAIS,RM) +# +# --- calcul des zones en circonferentiel +# + ssep=MCL_SOUS_EPAIS[0] + if (ssep.ISCP BORNE INF. = %.2f \n'\ + ' / BORNE SUP. = %.2f * SOUS-EPAISSEUR'%(j+1,BI[j],BS[j])) + else: + echo_mess.append( 'ZONE NO %d <> BORNE INF. = %.2f \n'\ + ' / BORNE SUP. = %.2f'%(j+1,BI[j],BS[j])) + +# calcul du nombre d'elements longi. et circonf. dans les soue-ep + NLX,NLY=ASCNBE(MCL_SOUS_EPAIS,COORXG,COORXD,COORYI,COORYS,BD,BG,BS,BI, + DNX,DNY,RM,RC,INDSEX,INDSEY,IABSC1,IORDO1) + + texte_final=string.join(echo_mess) + aster.affiche('MESSAGE',texte_final) + return ier,NLX,NLY,NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,DNX,DNY +################################################################################ +################################################################################ +################################################################################ +################################################################################ +# MACR_ASCOUF_MAIL ASCPRE +# PREPARATION DES DONNEES POUR LE MAILLAGE DE PLAQUE +# SOUS-EPAISSEURS : +# - CALCUL TABLEAU TRIE DES ABSCISSES ET ORDONNEES DES CENTRES +# - CALCUL TABLEAU DES ZONES COUVERTES PAR LES SOUS-EPAISSEURS +# +#-----------------DONNEES FOURNIES PAR L UTILISATEUR-------------------- +# +# RM = RAYON MOYEN DU COUDE +# RC = RAYON DE CINTRAGE DU COUDE +# ALPHA = ANGLE DU COUDE +# LT = LONGUEUR DE L EMBOUT DU COTE CHARGEMENT +# LGV = LONGUEUR DE L EMBOUT DU COTE CONDITIONS AUX LIMITES +# NBSEP = NOMBRE DE SOUS-EPAISSEURS +# SYME = "QUART" DE STRUCTURE, "DEMI" STRUCTURE OU BIEN "ENTIER" +# +#----------------------DONNEES RENVOYEES----------------------- +# +# NZONEX = NOMBRE DE ZONES CIRCONFERENTIELLES +# NZONEY = NOMBRE DE ZONES LONGITUDINALES +# +# ------------------------------------------------------------------------------ +def ASCPRE(MCL_SOUS_EPAIS,RM,RC,ALPHA,SYME,LTCHAR,LTCLIM): + ier=0 + echo_mess=['MACR_ASCOUF_MAIL ASCPRE \n',] + ALPHAR = 2.*ALPHA*pi/360. + DERAFC = 18. + DERAFL = 5. + EPSI = 0.001 + NBSEP = len(MCL_SOUS_EPAIS) + echo_mess.append( 'RECHERCHE DES ZONES DE SOUS-EPAISSEURS DANS LE COUDE\n' ) + +# tri des donnees sous-epaisseurs en circonferentiel + TAMPON,IABSC1,IABSC2,COORXD,COORXG=ASCTCI(MCL_SOUS_EPAIS,RM) +# --- calcul des recouvrements de zones en circonferentiel +# + NZONEX=0 + j=0 + ICE=1 + NBGAU=0 + NBDRO=0 + TYPG=0 + TYPD=0 + go10=1 + go20=1 +# + BG =[] + BD =[] + INDBG =[] + INDBD =[] + DNX =[] + INDSEX=[] +# + + while go10: + + j=j+1 +# +# definition de la zone courante (borne gauche, borne droite) +# +# TYPG = type de la borne: +# 0 : borne gauche sous-epaisseur +# 1 : borne droite sous-epaisseur +# 2 : centre sous-epaisseur +# + if j>2*NBSEP and ICE= 2*NBSEP : + MIND = TAMPON[2*NBSEP-1][0] + MING = MIND + if fmod(IABSC2[2*NBSEP-1],2): + TYPG = 0 + NUMG = IABSC1[IABSC2[2*NBSEP-1]/2] + else: + TYPG = 1 + NUMG = IABSC1[IABSC2[2*NBSEP-1]/2-1] + TYPD=TYPG + NUMD=NUMG + else: + MING=TAMPON[j-1][0] + MIND=TAMPON[j][0] + if fmod(IABSC2[j-1],2): + TYPG = 0 + NUMG = IABSC1[IABSC2[j-1]/2] + else: + TYPG = 1 + NUMG = IABSC1[IABSC2[j-1]/2-1] + if fmod(IABSC2[j],2): + TYPD = 0 + NUMD = IABSC1[IABSC2[j]/2] + else: + TYPD = 1 + NUMD = IABSC1[IABSC2[j]/2-1] + if fabs(MING-MIND)2*NBSEP and ICE>=NBSEP: + break #on sort de la boucle + + while go20: + i=ICE + if i<=NBSEP: +# recherche des centres a intercaler + INDC=IABSC1[i-1] + if i>1: +# le centre est deja le meme que precedent + if fabs(MCL_SOUS_EPAIS[INDC-1].ISCP-MCL_SOUS_EPAIS[IABSC1[i-2]-1].ISCP) < EPSI : + ICE=ICE+1 + continue + if MCL_SOUS_EPAIS[INDC-1].ISCP < MING : +# le centre est la nouvelle borne gauche + j=j-1 + MIND = MING + TYPD = TYPG + NUMD = NUMG + MING = MCL_SOUS_EPAIS[INDC-1].ISCP + TYPG = 2 + NUMG = INDC + ICE = ICE+1 + elif MCL_SOUS_EPAIS[INDC-1].ISCP < MIND : +# le centre est la nouvelle borne droite + MIND = MCL_SOUS_EPAIS[INDC-1].ISCP + TYPD = 2 + NUMD = INDC + ICE = ICE+1 + continue + else:pass + NZONEX=NZONEX+1 +# +# codes d'intervalles de zones +# 0 0 = zone sous-ep. +# 0 1 = sous-ep. a droite de la zone +# 1 0 = sous-ep. a gauche de la zone +# 1 1 = sous-ep. a droite et a gauche de la zone +# +# cas ou la premiere zone ne commence pas au bord de la plaque + if MING>0. and NZONEX==1 : + BG.append(0.) + BD.append(MING) + if TYPG==0: + INDBG.append(0) + INDBD.append(1) + DNX.append(DERAFC) + DNX.append(0) + INDSEX.append(0) + elif TYPG==1 or TYPG==2: + INDBG.append(0) + INDBD.append(0) + DNX.append(MCL_SOUS_EPAIS[NUMG-1].IDENC) + DNX.append(0) + INDSEX.append(NUMG) + else: pass + NZONEX=NZONEX+1 +# + BG.append(MING) + BD.append(MIND) +# + if TYPG == 0: +# borne gauche zone = borne gauche ssep + NBGAU=NBGAU+1 + INDBG.append(0) + INDBD.append(0) + if TYPD == 0: +# borne droite zone = borne gauche ssep + DNX.append(MCL_SOUS_EPAIS[NUMG-1].IDENC) + DNX.append(0) + INDSEX.append(NUMG) + elif TYPD == 1 or TYPD == 2: +# borne droite zone = borne droite ssep : TYPD=1 +# borne droite zone = centre ssep : TYPD=2 + LTMP=[] + LTMP.append((MCL_SOUS_EPAIS[NUMG-1].IDENC,NUMG)) + LTMP.append((MCL_SOUS_EPAIS[NUMD-1].IDENC,NUMD)) + LTMP.sort() + DNX.append(LTMP[0][0]) + DNX.append(0) + INDSEX.append(LTMP[0][1]) + else: pass +# + elif TYPG == 1: +# borne gauche zone = borne droite ssep + NBDRO = NBDRO+1 + if TYPD == 0: +# borne droite zone = borne gauche ssep + if NBDRO==NBGAU: + INDBG.append(1) + INDBD.append(1) + DNX.append(DERAFC) + DNX.append(0) + INDSEX.append(0) + else: +# cas tordu: une sous-ep enveloppe le tout + INDBG.append(0) + INDBD.append(0) + DNX.append(MCL_SOUS_EPAIS[NUMG-1].IDENC) + DNX.append(0) + INDSEX.append(NUMG) + elif TYPD == 1 or TYPD == 2: +# borne droite zone = borne droite ssep : TYPD=1 +# borne droite zone = centre ssep : TYPD=2 + INDBG.append(0) + INDBD.append(0) + DNX.append(MCL_SOUS_EPAIS[NUMD-1].IDENC) + DNX.append(0) + INDSEX.append(NUMD) + else: pass +# + elif TYPG == 2: +# borne gauche zone = centre ssep + INDBG.append(0) + INDBD.append(0) + if TYPD == 0: +# borne droite zone = borne gauche ssep + DNX.append(MCL_SOUS_EPAIS[NUMG-1].IDENC) + DNX.append(0) + INDSEX.append(NUMG) + elif TYPD == 1 or TYPD == 2: +# borne droite zone = borne droite ssep : TYPD=1 +# borne droite zone = centre ssep : TYPD=2 + LTMP=[] + LTMP.append((MCL_SOUS_EPAIS[NUMG-1].IDENC,NUMG)) + LTMP.append((MCL_SOUS_EPAIS[NUMD-1].IDENC,NUMD)) + LTMP.sort() + DNX.append(LTMP[0][0]) + DNX.append(0) + INDSEX.append(LTMP[0][1]) + else:pass + else:pass + if j<=(2*NBSEP-2) or ICE<=NBSEP or (TYPD==2 and j<2*NBSEP): + iout=0 + break #on retourne dans la boucle go10 + else : + iout=1 + break #on sort definitivement + if iout:break + + if MIND<2.*pi*RM: + NZONEX=NZONEX+1 + BG.append(MIND) + BD.append(2.*pi*RM) + if TYPD==0 or TYPD==2: + INDBG.append(0) + INDBD.append(0) + DNX.append(MCL_SOUS_EPAIS[NUMD-1].IDENC) + DNX.append(0) + INDSEX.append(NUMD) + elif TYPD==1: + INDBG.append(1) + INDBD.append(0) + DNX.append(DERAFC) + DNX.append(0) + INDSEX.append(0) + else:pass + +# au cas ou 2.*pi*RM correspond a une borne d'intevalle de sous-ep ou a +# un centre de sous-ep. + if fabs(BG[NZONEX-1]-BD[NZONEX-1]) BORNE GAUCHE = %.2f \n'\ + ' / BORNE DROITE = %.2f * SOUS-EPAISSEUR'%(j+1,BG[j],BD[j])) + else: + echo_mess.append( 'ZONE NO %d <> BORNE GAUCHE = %.2f \n'\ + ' / BORNE DROITE = %.2f'%(j+1,BG[j],BD[j])) + + +# --- tri des donnees sous-ep. en axial + TAMPON,IORDO1,IORDO2,COORYI,COORYS=ASCTLO(MCL_SOUS_EPAIS,RC,ALPHA,LTCHAR,LTCLIM) + + BI = [] + BS = [] + INDBI = [] + INDBS = [] + DNY = [] + INDSEY = [] + + if SYME == 'DEMI': +# calcul des zones en axial : +# zones (0,bord inferieur) et (bord inferieur,centre sous-ep.) + ssep = MCL_SOUS_EPAIS[0] + BI.append(0.) + BI.append(ssep.ISLP-ssep.ILONP/2.) + BS.append(ssep.ISLP-ssep.ILONP/2.) + BS.append(ssep.ISLP) + INDBI.append(0) + INDBI.append(0) + INDBS.append(1) + INDBS.append(0) + DNY.append(DERAFL) + DNY.append(0) + DNY.append(ssep.IDENL) + DNY.append(0) + INDSEY.append(0) + INDSEY.append(1) + NZONEY=1 +# + else: +# +# calcul des recouvrements de zones en axial + j = 0 + ICE = 1 + NBINF = 0 + NBSUP = 0 + TYPI=0 + TYPS=0 + go40=1 + go50=1 + NZONEY=0 +# + while go40: + j=j+1 +# +# definition de la zone courante (borne inf, borne sup) +# +# typi = type de la borne +# 0 : borne inf. sous-ep. +# 1 : borne sup. sous-ep. +# 2 : centre sous-ep. +# + if TYPS==2: +# cas ou la borne sup. de la zone prec. etait un centre + MINI=MINS + TYPI=TYPS + NUMI=NUMS + MINS=TAMPON[j-1][0] + if fmod(IORDO2[j-1],2): + TYPS = 0 + NUMS = IORDO1[IORDO2[j-1]/2] + else: + TYPS = 1 + NUMS = IORDO1[IORDO2[j-1]/2-1] + j=j-1 + else: + if j>= 2*NBSEP : + MINI = TAMPON[2*NBSEP-1][0] + MINS = MINI + if fmod(IORDO2[2*NBSEP-1],2): + TYPI = 0 + NUMI = IORDO1[IORDO2[2*NBSEP-1]/2] + else: + TYPI = 1 + NUMI = IORDO1[IORDO2[2*NBSEP-1]/2-1] + TYPS=TYPI + NUMS=NUMI + else: + MINI=TAMPON[j-1][0] + MINS=TAMPON[j][0] + if fmod(IORDO2[j-1],2): + TYPI = 0 + NUMI = IORDO1[IORDO2[j-1]/2] + else: + TYPI = 1 + NUMI = IORDO1[IORDO2[j-1]/2-1] + if fmod(IORDO2[j],2): + TYPS = 0 + NUMS = IORDO1[IORDO2[j]/2] + else: + TYPS = 1 + NUMS = IORDO1[IORDO2[j]/2-1] + if fabs(MINI-MINS)1: +# le centre est deja le meme que le precedent + if fabs(MCL_SOUS_EPAIS[INDC-1].ISLP-MCL_SOUS_EPAIS[IORDO1[i-2]-1].ISLP)0. and NZONEY==1: + first=0 + BI.append(0.) + BS.append(MINI) + if TYPI==0: + INDBI.append(0) + INDBS.append(1) + DNY.append(DERAFL) + DNY.append(0) + INDSEY.append(0) + elif TYPI==1 or TYPI==2: + INDBI.append(0) + INDBS.append(0) + DNY.append(MCL_SOUS_EPAIS[NUMI-1].IDENL) + DNY.append(0) + INDSEY.append(NUMI) + else:pass + NZONEY = NZONEY+1 +# + BI.append(MINI) + BS.append(MINS) + + if TYPI==0: +# borne inferieure zone = borne inferieure ssep + NBINF = NBINF+1 + INDBI.append(0) + INDBS.append(0) + if TYPS==0: +# borne superieure zone = borne inferieur ssep + DNY.append(MCL_SOUS_EPAIS[NUMI-1].IDENL) + DNY.append(0) + INDSEY.append(NUMI) + elif TYPS==1 or TYPS==2: +# borne superieure zone = borne superieure ssep:TYPS==1 +# borne superieure zone = centre ssep:TYPS==2 + LTMP=[] + LTMP.append((MCL_SOUS_EPAIS[NUMI-1].IDENL,NUMI)) + LTMP.append((MCL_SOUS_EPAIS[NUMS-1].IDENL,NUMS)) + LTMP.sort() + DNY.append(LTMP[0][0]) + DNY.append(0) + INDSEY.append(LTMP[0][1]) + else:pass + elif TYPI==1: +# borne inferieure zone=borne superieure ssep + NBSUP = NBSUP+1 + if TYPS==0: +# borne superieure zone = borne inferieur ssep + if NBSUP==NBINF: + INDBI.append(1) + INDBS.append(1) + DNY.append(DERAFL) + DNY.append(0) + INDSEY.append(0) + else: +# cas tordu: une sous-ep. enveloppe le tout + INDBI.append(0) + INDBS.append(0) + DNY.append(MCL_SOUS_EPAIS[NUMI-1].IDENL) + DNY.append(0) + INDSEY.append(NUMI) + elif TYPS==1 or TYPS==2: +# borne superieure zone = borne superieure ssep:TYPS==1 +# borne superieure zone = centre ssep:TYPS==2 + INDBI.append(0) + INDBS.append(0) + DNY.append(MCL_SOUS_EPAIS[NUMS-1].IDENL) + DNY.append(0) + INDSEY.append(NUMS) + else:pass + elif TYPI==2: +# borne inferieure zone = centre ssep + INDBI.append(0) + INDBS.append(0) + if TYPS==0: +# borne superieure zone = borne inferieure ssep + DNY.append(MCL_SOUS_EPAIS[NUMI-1].IDENL) + DNY.append(0) + INDSEY.append(NUMI) + elif TYPS==1 or TYPS==2: +# borne superieure zone = borne superieure ssep + LTMP=[] + LTMP.append((MCL_SOUS_EPAIS[NUMI-1].IDENL,NUMI)) + LTMP.append((MCL_SOUS_EPAIS[NUMS-1].IDENL,NUMS)) + LTMP.sort() + DNY.append(LTMP[0][0]) + DNY.append(0) + INDSEY.append(LTMP[0][1]) + else:pass + else:pass + if j<=(2*NBSEP-2) or TYPS==2: + iout=0 + break #on retourne dans la boucle go40 + else: + iout=1 + break #on sort definitivement + if iout:break + +# cas ou la derniere zone ne finit pas au bout de la plaque + if MINS BORNE INF. = %.2f \n'\ + ' / BORNE SUP. = %.2f * SOUS-EPAISSEUR'%(j+1,BI[j],BS[j])) + else: + echo_mess.append( 'ZONE NO %d <> BORNE INF. = %.2f \n'\ + ' / BORNE SUP. = %.2f '%(j+1,BI[j],BS[j])) + +# calcul du nombre d'elements longi. et circonf. dans les sous-ep + NLX,NLY=ASCNBE(MCL_SOUS_EPAIS,COORXG,COORXD,COORYI,COORYS,BD,BG,BS,BI, + DNX,DNY,RM,RC,INDSEX,INDSEY,IABSC1,IORDO1) + + + texte_final=string.join(echo_mess) + aster.affiche('MESSAGE',texte_final) + return ier,NLX,NLY,NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,DNX,DNY + +################################################################################ +################################################################################ +################################################################################ +# MACR_ASCOUF_MAIL write_file_dgib_ASCFDO +# +# ECRIT DANS UN FICHIER LES DONNES GIBI DE LA PROCEDURE +# "PLAQUE FISSUREE" +# + +# ------------------------------------------------------------------------------ +def write_file_dgib_ASCFDO(nomFichierDATG,RM,RC,ALPHA,NBTRAN,EP1,EP2,EPI,TETA1, + TETA2,LTRAN,SUREP,LTCHAR,LTCLIM,TYPBOL,AXEAP,AXECP,NT,NS,NC, + SFP,ORIEN,AZIM,RC0,RC2,RC3,POSIT,EPSI,NIVMAG,SYME, loc_datg) : + + if TYPBOL!= None: + if TYPBOL=='CUVE' : TYPEMB = 'typcuv' + if TYPBOL=='GV' : TYPEMB = 'typegv' + if TYPBOL=='ASP_MPP' : TYPEMB = 'typapp' + else: + TYPEMB =' ' + + if POSIT =='DEB_INT' : + POSIT2 = 'interne' + else: + POSIT2 = 'externe' + if SYME[:6]=='ENTIER' : ZSYME = 'entier' + elif SYME[:5]=='QUART' : ZSYME = 'quart' + else : ZSYME = 'demi' + C=AXECP/2. + TETAF=AZIM*pi/180. + + POIVIR = ' ;\n' + texte='* DEBUT PARAMETRES UTILISATEUR\n' + texte=texte+'*\n' + texte=texte+'c = '+str(C) +POIVIR + texte=texte+'a = '+str(AXEAP) +POIVIR + texte=texte+'nt = '+str(NT) +POIVIR + texte=texte+'ns = '+str(NS) +POIVIR + texte=texte+'nc = '+str(NC) +POIVIR + texte=texte+'rm = '+str(RM) +POIVIR + texte=texte+'rc = '+str(RC) +POIVIR + texte=texte+'alphac = '+str(ALPHA) +POIVIR + texte=texte+'nbtranep = '+str(NBTRAN) +POIVIR + texte=texte+'ep1 = '+str(EP1) +POIVIR + texte=texte+'ep2 = '+str(EP2) +POIVIR + texte=texte+'epi = '+str(EPI) +POIVIR + texte=texte+'teta1 = '+str(TETA1) +POIVIR + texte=texte+'teta2 = '+str(TETA2) +POIVIR + texte=texte+'ltran = '+str(LTRAN) +POIVIR + texte=texte+'posfis = '+str(SFP) +POIVIR + texte=texte+'ksiref = '+str(ORIEN) +POIVIR + texte=texte+'surep = '+str(SUREP) +POIVIR + texte=texte+'teta_f = '+str(TETAF) +POIVIR + texte=texte+'rc0 = '+str(RC0) +POIVIR + texte=texte+'rc2 = '+str(RC2) +POIVIR + texte=texte+'rc3 = '+str(RC3) +POIVIR + texte=texte+"pos = '"+POSIT2+"'" +POIVIR + texte=texte+'lt = '+str(LTCHAR) +POIVIR + texte=texte+'lgv = '+str(LTCLIM) +POIVIR + texte=texte+"typembou = '"+TYPEMB+"'" +POIVIR + texte=texte+"zsyme = '"+ZSYME+"'" +POIVIR + texte=texte+'epsif = '+str(EPSI) +POIVIR + texte=texte+'nivmag = '+str(NIVMAG) +POIVIR + texte=texte+'*\n' + texte=texte+'* FIN PARAMETRES UTILISATEUR\n' + texte=texte+'opti donn ' + texte=texte+"'"+loc_datg+'ascouf_fiss_v4.datg'+"';\n" + fdgib=open(nomFichierDATG,'w') + fdgib.write(texte) + fdgib.close() + +################################################################################ +################################################################################ +################################################################################ +# MACR_ASCOUF_MAIL write_file_dgib_ASCSQO +# +# ECRIT DANS UN FICHIER LES DONNEES GIBI DE LA PROCEDURE +# "PLAQUE SOUS-EPAISSEUR" +# +#-----------------DONNEES FOURNIES PAR L'UTILISATEUR-------------------- +# +# RM = RAYON MOYEN DU COUDE +# RC = RAYON DE CINTRAGE DU COUDE +# ALPHA = ANGLE DU COUDE +# NBTRAN = NOMBRE DE TRANSITION D'EPAISSEUR (0, 1 OU 2) +# EP1 = EPAISSEUR DU COUDE (COTE EMBOUT 1 SI TRANSITION) +# EP2 = EPAISSEUR DU COUDE (COTE EMBOUT 2 SI TRANSITION) +# EPI = EPAISSEUR DU COUDE INTERMEDIAIRE SI TRANSITION A 2 PENTES +# TETA1 = ANGLE DE LA PREMIERE TRANSITION D'EPAISSEUR EVENTUELLE +# TETA2 = ANGLE DE LA DEUXIEME TRANSITION D'EPAISSEUR EVENTUELLE +# LTRAN = LONGUEUR ENTRE FIN DE L'EMBOUT 1 ET DEBUT DE TRANSITION +# LTCHAR = LONGUEUR DE L'EMBOUT DU COTE CHARGEMENT +# LCLIM = LONGUEUR DE L'EMBOUT DU COTE CONDITIONS AUX LIMITES +# GEOM = TYPE DE GEOMETRIE MODELISEE (COUDE OU TUBE) +# SYME = "QUART" DE STRUCTURE, "DEMI" STRUCTURE OU BIEN "ENTIER" +# NBEP = NOMBRE D'ELEMENTS DANS LE COUDE +# NLX = NOMBRE D'ELEMENTS CIRCONF. DE LA SOUS-EPAISSEUR +# NLY = NOMBRE D'ELEMENTS LONGI DE LA SOUS-EPAISSEUR + +# ------------------------------------------------------------------------------ +def write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2, + EPI,TETA1,MCL_SOUS_EPAIS,TETA2,LTRAN,LTCHAR,LTCLIM,GEOM, + SYME,NBEP,NLX,NLY,NIVMAG,loc_datg) : + + ssep= MCL_SOUS_EPAIS[0] + POIVIR = ' ;\n' + texte=' nivmag = '+str(NIVMAG) +POIVIR + texte=texte+' option dime 3 elem '+TYPELE+' nive nivmag echo 0'+POIVIR + texte=texte+'*\n' + texte=texte+'coory = table '+POIVIR + texte=texte+'coorz = table '+POIVIR + texte=texte+'prof = table '+POIVIR + texte=texte+'posit = table '+POIVIR + texte=texte+'axisym = table '+POIVIR + texte=texte+'axecir = table '+POIVIR + texte=texte+'axelon = table '+POIVIR + texte=texte+'sousep = table '+POIVIR + texte=texte+'coorzc = table '+POIVIR + texte=texte+'axelonc = table '+POIVIR + texte=texte+'*\n' + texte=texte+'* DEBUT PARAMETRES UTILISATEUR\n' + texte=texte+'*\n' + texte=texte+'* parametres generaux\n' + texte=texte+'*\n' + texte=texte+' pirad = '+str(pi) +POIVIR + texte=texte+' rm = '+str(RM) +POIVIR + texte=texte+' rc = '+str(RC) +POIVIR + texte=texte+' alpha = '+str(ALPHA) +POIVIR + texte=texte+' lt1 = '+str(LTCHAR) +POIVIR + texte=texte+' lt2 = '+str(LTCLIM) +POIVIR + texte=texte+' nbtranep = '+str(NBTRAN) +POIVIR + texte=texte+' ep1 = '+str(EP1) +POIVIR + texte=texte+' ep2 = '+str(EP2) +POIVIR + texte=texte+' epI = '+str(EPI) +POIVIR + texte=texte+' teta1 = '+str(TETA1) +POIVIR + texte=texte+' teta2 = '+str(TETA2) +POIVIR + texte=texte+' ltran = '+repr(LTRAN) +POIVIR + if GEOM == 'COUDE': + texte=texte+" zcoude = 'oui' "+POIVIR + else: + texte=texte+" zcoude = 'non' "+POIVIR + if SYME == 'ENTIER': + texte=texte+" zsyme = 'entier' "+POIVIR + elif SYME == 'QUART': + texte=texte+" zsyme = 'quart' "+POIVIR + else: + texte=texte+" zsyme = 'demi' "+POIVIR + if TYPELE == 'CU20': + texte=texte+" zquad = 'oui' "+POIVIR + else: + texte=texte+" zquad = 'non' "+POIVIR + SCP=pi*RM + texte=texte+' nxep = '+str(NBEP) +POIVIR + texte=texte+'*\n' + texte=texte+'* Caracteristiques de la sous-epaisseur\n' + texte=texte+'*\n' + texte=texte+' tysep = '+str(ssep.ICIRP) +POIVIR + texte=texte+' tzsep = '+str(ssep.ILONP) +POIVIR + texte=texte+' prof . 1 = '+str(ssep['PROFONDEUR']) +POIVIR + texte=texte+' ycsep = '+str(SCP-pi*RM) +POIVIR + texte=texte+' theta = '+str(ssep.IPHIC) +POIVIR + texte=texte+' zcsep = '+repr(ssep.ISLP) +POIVIR + + texte=texte+" posit . 1 = '"+str(ssep['SOUS_EPAIS'].lower())+"'"+POIVIR + texte=texte+' nby = '+str(int(NLX[0])) +POIVIR + texte=texte+' nbz = '+str(int(NLY[0])) +POIVIR + texte=texte+' nbxse = '+str(ssep['NB_ELEM_RADI']) +POIVIR + texte=texte+' axelonc . 1 = '+str(ssep['AXE_LONGI'])+POIVIR + if ssep['POSI_CURV_LONGI']!=None: + texte=texte+' coorzc . 1 = '+repr(ssep['POSI_CURV_LONGI'])+POIVIR + else: + DZC=ssep.BETA*pi*(RC+(RM+EP1/2.)*cos(pi/2.))/180. + texte=texte+' coorzc . 1 = '+repr(DZC)+POIVIR + if ssep['TYPE']=='AXIS': + texte=texte+" zaxis = 'oui' "+POIVIR + else: + texte=texte+" zaxis = 'non' "+POIVIR + if ssep['EMPREINTE'] == 'OUI': + texte=texte+" sousep . 1 = 'oui'"+POIVIR + else: + texte=texte+" sousep . 1 = 'non'"+POIVIR + texte=texte+'*\n' + texte=texte+'* FIN PARAMETRES UTILISATEUR \n' + texte=texte+'opti donn ' + texte=texte+"'"+loc_datg+'ascouf_ssep_mono_v1.datg'+"'"+POIVIR + fdgib=open(nomFichierDATG,'w') + fdgib.write(texte) + fdgib.close() +################################################################################ +################################################################################ +################################################################################ +# MACR_ASCOUF_MAIL write_subpart_file_pgib_POST +# +# APPELEE DANS : write_file_pgib_ASCSQ2 , write_file_pgib_ASCSD2 +# DEFINIE UNE CHAINE DE CARACTERES UTILISEE LORS DE L'ECRITURE DU +# FICHIER GIBI DE POST-TRAITEMENTS +# +#-----------------DONNEES FOURNIES PAR L'UTILISATEUR-------------------- +# +# NLX = NOMBRE D'ELEMENTS CIRCONF. DE LA SOUS-EPAISSEUR +# NLY = NOMBRE D'ELEMENTS LONGI DE LA SOUS-EPAISSEUR +# +#-----------------DONNEE RENVOYEE PAR ASTER-------------------- +# +# texte = chaine de caracteres contenant des instructions gibi +# de post-traitements +# +# ------------------------------------------------------------------------------ +def write_subpart_file_pgib_POST(MCL_SOUS_EPAIS,NLX,NLY): + CAR3 = ('fdro','exdr','extr','exga','fgau','inga','intr','indr') + + POIVIR = ' ;\n' + texte='* DEBUT POINTS DE POST-TRAITEMENT\n' + texte=texte+'*\n' + issep=0 + for ssep in MCL_SOUS_EPAIS: + issep=issep+1 + texte=texte+'*\n' + texte=texte+'* sous-epaisseur No '+str( issep)+'\n' + texte=texte+'*\n' + if ssep['TYPE'] == 'ELLI': + texte=texte+'*\n' + texte=texte+'* plans circonf longi et colonne centrale \n' + texte=texte+'*\n' + texte=texte+'pcirc'+str( issep)+' = circo .'+str(issep).rjust(4)+POIVIR + texte=texte+'plong'+str( issep)+' = longi .'+str(issep).rjust(4)+POIVIR + texte=texte+'pcent'+str( issep)+' = centr .'+str(issep).rjust(4)+POIVIR + texte=texte+'*\n' + texte=texte+'* ligaments tous les 45 degres a epaisseur minimale \n' + texte=texte+'*\n' + texte=texte+'isep = '+str( issep)+POIVIR + for k in range(8): + texte=texte+'ilig = '+str(k+1)+POIVIR + texte=texte+'rlig = ilig/10. + isep'+POIVIR + texte=texte+str(CAR3[k])+str( issep)+' = lig45 . rlig'+POIVIR + if ssep['TYPE'] == 'ELLI': + texte=texte+'*\n' + texte=texte+"* ligaments circonferentiels a l'epaisseur minimale\n" + texte=texte+'*\n' + texte=texte+'isep = '+str(issep)+POIVIR + for k in range(2*NLX[issep-1]+1): + texte=texte+'ilig = '+str(k+1)+POIVIR + texte=texte+'rlig = ilig/100. + isep'+POIVIR + texte=texte+'cir'+str(issep)+'_'+str(k+1)+' = ligcir . rlig'+POIVIR + texte=texte+'*\n' + texte=texte+"* ligaments longitudinaux a l'epaisseur minimale\n" + texte=texte+'* \n' + for k in range(2*NLY[issep-1]+1): + texte=texte+'ilig = '+str(k+1)+POIVIR + texte=texte+'rlig = ilig/100. + isep'+POIVIR + texte=texte+'lon'+str(issep)+'_'+str(k+1)+' = liglon . rlig'+POIVIR + texte=texte+'* FIN POINTS DE POST-TRAITEMENT\n' + return texte + +################################################################################ +################################################################################ +################################################################################ +# MACR_ASCOUF_MAIL write_file_pgib_ASCSQ2 +# +# ECRIT DANS UN FICHIER LES DONNEES GIBI DE LA PROCEDURE +# "PLAQUE SOUS-EPAISSEURS" +# IL S'AGIT DE LA DEUXIEME PARTIE ( APRES LES DONNEES UTILISATEUR ) +# +# +#-----------------DONNEES FOURNIES PAR L'UTILISATEUR-------------------- +# +# NLX = NOMBRE TOTAL D'ELEMENTS CIRCONF. DE LA SOUS-EPAISSEUR K +# NLY = NOMBRE TOTAL D'ELEMENTS LONGIT. DE LA SOUS-EPAISSEUR K + +# ------------------------------------------------------------------------------ +def write_file_pgib_ASCSQ2(MCL_SOUS_EPAIS,NLX,NLY): + POIVIR = ' ;\n' + texte=write_subpart_file_pgib_POST(MCL_SOUS_EPAIS,NLX,NLY) + texte=texte+'*\n' + texte=texte+'p1 = 0. 0. (-1.*lt1)'+POIVIR + texte=texte+'p2 = 0. 0. (coor 3 bou3)'+POIVIR + texte=texte+'ma = coude et p1 et p2'+POIVIR + texte=texte+"opti sauv form 'fort.8'"+POIVIR + texte=texte+'sort ma'+POIVIR + texte=texte+'sauv form ma'+POIVIR + texte=texte+'fin'+POIVIR + fpgib=open('fort.71','w') + fpgib.write(texte) + fpgib.close() + +################################################################################ +################################################################################ +################################################################################ +# MACR_ASCOUF_MAIL write_file_pgib_ASCSP1 +# +# ECRIT DANS UN FICHIER LES DONNEES GIBI DE LA PROCEDURE +# "PLAQUE SOUS-EPAISSEURS" +# IL S'AGIT DE LA PREMIERE PARTIE ( AVANT LES DONNEES UTILISATEUR ) +# +# +# ------------------------------------------------------------------------------ +def write_file_dgib_ASCSP1(nomFichierDATG,TYPELE,MCL_SOUS_EPAIS,NIVMAG,loc_datg): + + POIVIR = ' ;\n' + texte=' nivmag = '+str(NIVMAG)+POIVIR + texte=texte+' option dime 3 elem '+TYPELE+' nive nivmag echo 0 '+POIVIR + texte=texte+'*\n' + texte=texte+'bg = table '+POIVIR + texte=texte+'bd = table '+POIVIR + texte=texte+'bi = table '+POIVIR + texte=texte+'bs = table '+POIVIR + texte=texte+'indbg = table '+POIVIR + texte=texte+'indbd = table '+POIVIR + texte=texte+'indbi = table '+POIVIR + texte=texte+'indbs = table '+POIVIR + texte=texte+'axecir = table '+POIVIR + texte=texte+'axelon = table '+POIVIR + texte=texte+'axelonc = table '+POIVIR + texte=texte+'coorzc = table '+POIVIR + texte=texte+'prof = table '+POIVIR + texte=texte+'posit = table '+POIVIR + texte=texte+'coory = table '+POIVIR + texte=texte+'coorz = table '+POIVIR + texte=texte+'deny = table '+POIVIR + texte=texte+'nbely = table '+POIVIR + texte=texte+'denz = table '+POIVIR + texte=texte+'nbelz = table '+POIVIR + texte=texte+'axisym = table '+POIVIR + texte=texte+'sousep = table '+POIVIR + texte=texte+'* \n' + texte=texte+'opti donn ' + texte=texte+"'"+loc_datg+'ascouf_ssep_mult_v1.datg'+"';\n" + fdgib=open(nomFichierDATG,'w') + fdgib.write(texte) + fdgib.close() + +################################################################################ +################################################################################ +################################################################################ +# MACR_ASCOUF_MAIL write_file_pgib_ASCSDO +# +# ECRIT DANS UN FICHIER LES DONNEES GIBI DE LA PROCEDURE +# "PLAQUE SOUS-EPAISSEURS" +# +#-----------------DONNEES FOURNIES PAR L'UTILISATEUR-------------------- +# +# RM = RAYON MOYEN DU COUDE +# RC = RAYON DE CINTRAGE DU COUDE +# ALPHA = ANGLE DU COUDE +# EP = EPAISSEUR DU COUDE +# LTCHAR = LONGUEUR DE L'EMBOUT DU COTE CHARGEMENT +# LCLIM = LONGUEUR DE L'EMBOUT DU COTE CONDITIONS AUX LIMITES +# GEOM = TYPE DE GEOMETRIE MODELISEE (COUDE OU TUBE) +# SYME = QUART DE STRUCTURE SI 'OUI' +# INDBG = INDICATEUR BORD GAUCHE DE LA ZONE CIRCONF J +# INDBD = INDICATEUR BORD DROIT DE LA ZONE CIRCONF J +# BG = ABSCISSE DU BORD GAUCHE DE LA ZONE CIRCONF J +# BD = ABSCISSE DU BORD DROIT DE LA ZONE CIRCONF J +# BI = ORDONNEE DU BORD INFERIEUR DE LA ZONE LONGI J +# BS = ORDONNEE DU BORD SUPERIEUR DE LA ZONE LONGI J +# INDBI = INDICATEUR BORD INFERIEUR DE LA ZONE LONGI J +# INDBS = INDICATEUR BORD SUPERIEUR DE LA ZONE LONGI J +# INDSEX = NUMERO DE SOUS-EPAISSEUR CONTENU DANS LA ZONE CIRCONF J +# INDSEY = NUMERO DE SOUS-EPAISSEUR CONTENU DANS LA ZONE LONGI J +# DNX = DENSITE ET NOMBRE D'ELEMENTS CIRCONF. DE LA ZONE J +# DNY = DENSITE ET NOMBRE D'ELEMENTS LONGIT. DE LA ZONE J +# NZONEX = NOMBRE DE ZONES CIRCONFERENTIELLES +# NZONEY = NOMBRE DE ZONES LONGITUDINALES +# +# ------------------------------------------------------------------------------ +def write_file_pgib_ASCSDO(RM,RC,ALPHA,EP,LTCLIM,LTCHAR,NBEP, + NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS, + DNX,DNY,MCL_SOUS_EPAIS,GEOM,SYME): + + POIVIR = ' ;\n' + NY=20 + DELTAY=2.*pi*RM/NY + + def nint(x): + if 0(ALPHA*RC*pi/180.0) : + message= ' valeur hors domaine de validite \n' + message=message+' sous-epaisseur numero : %d \n'%isep + message=message+' abscisse curv. longit. : %.2f \n'%ssep['POSI_CURV_LONGI'] + message=message+' valeur maximale autorisee : %.2f \n'%(ALPHA*RC*pi/180.0) + UTMESS('F', "MACR_ASCOUF_MAIL", message) + LDEFAU = ssep['POSI_CURV_LONGI'] + ssep['AXE_LONGI']/2.0 + BETA = 0.0 + else: + BETA=ssep['POSI_ANGUL'] + if (BETA<0.) or (BETA>ALPHA) : + message= ' valeur hors domaine de validite \n' + message=message+' sous-epaisseur numero : %d \n'%isep + message=message+' position angulaire centre sous-ep : %.2f \n'%BETA + message=message+' valeur limite autorisee : %.2f \n'%ALPHA + UTMESS('F', "MACR_ASCOUF_MAIL", message) + LDEFAU = (BETA*RC*pi/180.0) + ssep['AXE_LONGI']/2.0 +# + if ssep['POSI_CURV_CIRC']!=None: + if ssep['POSI_CURV_CIRC']>(2*pi*RM) : + message= ' valeur hors domaine de validite \n' + message=message+' sous-epaisseur numero : %d \n'%isep + message=message+' abscisse curv. circonf. : %.2f \n'%ssep['POSI_CURV_CIRC'] + message=message+' valeur limite autorisee : %.2f \n'%(2*pi*RM) + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if ssep['POSI_CURV_CIRC']!=(pi*RM) and ssep['TYPE']=='AXIS': + message= ' le centre d une sous-epaisseur \n' + message=message+' axisymetrique est impose en intrados (pi*RM) \n' + UTMESS('F', "MACR_ASCOUF_MAIL", message) + else: + ssep.IPHIC=ssep['AZIMUT'] + if ssep['AZIMUT']!=180. and ssep['TYPE']=='AXIS': + message= ' le centre d une sous-epaisseur \n' + message=message+' axisymetrique est impose en intrados \n' + message=message+' l azimut est fixe a 180 degres \n' + UTMESS('F', "MACR_ASCOUF_MAIL", message) +# l_ITYPE.append(ssep['TYPE' ]) +# l_ICIRC.append(ssep['AXE_CIRC' ]) +# l_ILONC.append(ssep['AXE_LONGI' ]) +# l_IPROC.append(ssep['PROFONDEUR' ]) +# l_ISLC.append( ssep['POSI_CURV_LONGI']) +# l_IBETC.append(BETA) + ssep.BETA=BETA +# l_ISCC.append( ssep['POSI_CURV_CIRC' ]) +# l_IPHIC.append(ssep['AZIMUT' ]) +# l_IPOS.append( ssep['SOUS_EPAIS' ]) +# l_INBEL.append(ssep['NB_ELEM_LONGI' ]) +# l_INBEC.append(ssep['NB_ELEM_CIRC' ]) +# l_IEVID.append(ssep['EMPREINTE' ]) + + if SOUS_EPAIS_COUDE!=None and COUDE['NB_ELEM_EPAIS']!=3 : + message= ' le nombre d elements dans l \n' + message=message+' epaisseur du coude n est pas parametrable pour \n' + message=message+' la version 2 de la procedure de plaque avec sous \n' + message=message+' -epaisseur : mot-cle NB_ELEM_EPAIS ignore \n' + UTMESS('A', "MACR_ASCOUF_MAIL", message) +# +################################################################################ +# --- verifications de coherences --- +################################################################################ +# +# donnees globales + if COUDE['TRANSFORMEE']=='COUDE' or COUDE['TRAN_EPAIS']=='NON' : + if SUREP<0. or SUREP>(RM-EP1/2.0): + message= ' valeur hors domaine de validite \n' + message=message+' surepaisseur : \n',SUREP + message=message+' valeur limite autorisee (RM-EP1/2) : %.2f \n'%(RM-EP1/2.0) + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if RC<=(RM+EP1/2.0): + message= ' valeur hors domaine de validite \n' + message=message+' le rayon de cintrage : %.2f \n',RC + message=message+' doit etre superieur a (RM+EP1/2) : %.2f \n'%(RM+EP1/2.0) + UTMESS('F', "MACR_ASCOUF_MAIL", message) +# +# coude fissure +# + if FISS_COUDE!=None: + if (RM/EP1)<5. or (RM/EP1)>50.: + message= ' valeur hors domaine de validite (5,50) \n' + message=message+' rapport RM/EP1 : %.2f \n'%(RM/EP1) + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if FISS_COUDE['ABSC_CURV']!=None: + if SF<0. or SF>(ALPHA*RC*pi/180.0) : + message= ' valeur hors domaine de validite \n' + message=message+' abscisse curviligne centre fissure : %.2f \n'%SF + message=message+' valeur limite autorisee : %.2f \n'%(ALPHA*RC*pi/180.0) + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (NT-2*(NT/2))!=0: + message= ' valeur hors domaine de validite \n' + message=message+' nombre de tranches : %d \n'%NT + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if FISS_COUDE['ABSC_CURV'] and ((BETA<0.) or (BETA>ALPHA)): + message= ' valeur hors domaine de validite \n' + message=message+' position angulaire centre fissure : %.2f \n'%BETA + message=message+' posi_angul doit etre >= 0 et <= %.2f \n'%ALPHA + UTMESS('F', "MACR_ASCOUF_MAIL", message) +# +# transition d epaisseur +# + if NBTRAN!=0: + LCOUDE = ALPHA * RC * pi / 180.0 + DEXT = 2.0*RM + EP1 + if (LTRANLCOUDE) : + message= ' valeur hors domaine de validite \n' + message=message+' debut transition d epaisseur : %.2f \n'%LTRAN + message=message+' valeur minimale autorisee : %.2f \n'%LDEFAU + message=message+' valeur maximale autorisee : %.2f \n'%LCOUDE + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (TETA1<0.) or (TETA1>30.) : + message= ' valeur hors domaine de validite \n' + message=message+' angle de transition TETA1 : %.2f \n'%TETA1 + message=message+' valeur minimale autorisee : %.2f \n'%0. + message=message+' valeur maximale autorisee : %.2f \n'%30. + UTMESS('F', "MACR_ASCOUF_MAIL", message) +# +# transition d epaisseur a une pente +# + if NBTRAN==1: + if (EP1<12.) or (EP1>80.) : + message= ' valeur hors domaine de validite \n' + message=message+' epaisseur avant la transition : %.2f \n'%EP1 + message=message+' valeur minimale autorisee : %.2f \n'%12. + message=message+' valeur maximale autorisee : %.2f \n'%80. + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (EP2<20.) or (EP2>110.) : + message= ' valeur hors domaine de validite \n' + message=message+' epaisseur apres la transition : %.2f \n'%EP2 + message=message+' valeur minimale autorisee : %.2f \n'%20. + message=message+' valeur maximale autorisee : %.2f \n'%110. + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (EP1>EP2) : + message= ' l epaisseur avant la transition \n' + message=message+' doit etre inferieure \n' + message=message+' a celle apres la transition \n' + UTMESS('F', "MACR_ASCOUF_MAIL", message) + LTRANF = LTRAN + ((EP2-EP1)/(tan(TETA1))) + if (LTRANF>LCOUDE) : + message= ' valeur hors domaine de validite \n' + message=message+' fin transition d epaisseur : %.2f \n'%LTRANF + message=message+' valeur limite autorisee : %.2f \n'%LCOUDE + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if DEXT<112. or DEXT>880. : + message= ' valeur hors domaine de validite\n' + message=message+' diam ext du tube avant transition: %.2f \n'%DEXT + message=message+' valeur minimum autorisee : %.2f \n'%112. + message=message+' valeur maximum autorisee : %.2f \n'%880. + UTMESS('F', "MACR_ASCOUF_MAIL", message) +# +# transition d epaisseur a une pente +# + else: + if (TETA2<0.) or (TETA2>45.) : + message= ' valeur hors domaine de validite\n' + message=message+' angle de transition TETA2: %.2f \n'%TETA2 + message=message+' valeur minimum autorisee : %.2f \n'%0. + message=message+' valeur maximum autorisee : %.2f \n'%45. + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (EP1<7.) or (EP1>35.) : + message= ' valeur hors domaine de validite\n' + message=message+' epaisseur avant 1ere transition: %.2f \n'%EP1 + message=message+' valeur minimum autorisee : %.2f \n'%7. + message=message+' valeur maximum autorisee : %.2f \n'%35. + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (EP2<15.) or (EP2>40.) : + message= ' valeur hors domaine de validite\n' + message=message+' epaisseur avant 2eme transition: %.2f \n'%EP2 + message=message+' valeur minimum autorisee : %.2f \n'%15. + message=message+' valeur maximum autorisee : %.2f \n'%40. + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (EPI<15.) or (EPI>40.) : + message= ' valeur hors domaine de validite\n' + message=message+' epaisseur intermediaire: %.2f \n'%EPI + message=message+' valeur minimum autorisee : %.2f \n'%15. + message=message+' valeur maximum autorisee : %.2f \n'%40. + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (EP1>EPI) : + message= ' valeur hors domaine de validite\n' + message=message+' l epaisseur avant la transition \n' + message=message+' doit etre inferieure a l epaisseur intermediaire \n' + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (EP2LCOUDE) : + message= ' valeur hors domaine de validite\n' + message=message+' fin transition d epaisseur: %.2f \n'%LTRANF + message=message+' valeur limite autorisee : %.2f \n'%LCOUDE + UTMESS('F', "MACR_ASCOUF_MAIL", message) + if (DEXT<77.) or (DEXT>355.) : + message= ' valeur hors domaine de validite\n' + message=message+' diam ext du tube avant transition: %.2f \n'%LTRANF + message=message+' valeur minimum autorisee : %.2f \n'%77. + message=message+' valeur maximum autorisee : %.2f \n'%355. + UTMESS('F', "MACR_ASCOUF_MAIL", message) +# +################################################################################ +# --- calcul taille initiale des defauts sur la plaque --- +################################################################################ +# +# + if FISS_COUDE!=None: + DSF=(FISS_COUDE['ABSC_CURV']!=None) + AXEAP,AXECP,SFP = ASCFIS(ALPHA, RM, RC, EP1, SUREP, GEOM, FPROF, + DGAXEC, AZIM, POSIT, SF, DSF, BETA, ORIEN) + elif MCL_SOUS_EPAIS!=None : + ier= ASCSEP(MCL_SOUS_EPAIS,ALPHA,RM,RC,EP1,GEOM,SYME) + for ssep in MCL_SOUS_EPAIS: + ssep.IDENL = ssep.ILONP/ssep['NB_ELEM_LONGI']*180./(pi*RC) + ssep.IDENC = ssep.ICIRP/ssep['NB_ELEM_CIRC']*180./(pi*RM) + if SYME=='QUART' : +# quart de structure + ier,NLX,NLY,NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,DNX,DNY\ + = ASCSYM(MCL_SOUS_EPAIS,RM,RC,ALPHA,LTCHAR,LTCLIM) + else : +# demi-structure ou entiere + ier,NLX,NLY,NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,DNX,DNY\ + = ASCPRE(MCL_SOUS_EPAIS,RM,RC,ALPHA,SYME,LTCHAR,LTCLIM) +# +# + loc_gibi=aster.repout() + logiel = EXEC_MAILLAGE['LOGICIEL' ] + UNITD = EXEC_MAILLAGE['UNITE_DATG'] + UNITP = EXEC_MAILLAGE['UNITE_MGIB'] + if logiel=='GIBI98' : logiel = loc_gibi+'gibi98' + elif logiel=='GIBI2000': logiel = loc_gibi+'gibi2000' + else : + UTMESS('F', "MACR_ASCOUF_MAIL", "seuls gibi98 et gibi2000 sont appelables") +# +# --- ecriture sur le fichier .datg de la procedure --- +# +# Nom du fichier de commandes pour GIBI + nomFichierDATG = 'fort.'+str(UNITD) +# Nom du fichier de maillage GIBI + nomFichierGIBI = 'fort.'+str(UNITP) + loc_datg = aster.repdex() +# + if FISS_COUDE!=None: +# procedure coude fissure (MOT-CLE FISS_COUDE) + write_file_dgib_ASCFDO(nomFichierDATG,RM,RC,ALPHA,NBTRAN,EP1,EP2,EPI,TETA1, + TETA2,LTRAN,SUREP,LTCHAR,LTCLIM,TYPBOL,AXEAP,AXECP,NT,NS,NC,SFP, + ORIEN,AZIM,RC0,RC2,RC3,POSIT,EPSI,NIVMAG,SYME,loc_datg) + elif MCL_SOUS_EPAIS!=None : + if SOUS_EPAIS_MULTI==None : +# procedure coude sous-ep.: (MOT-CLE SOUS_EPAIS_COUDE) + write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2, + EPI,TETA1,MCL_SOUS_EPAIS,TETA2,LTRAN,LTCHAR,LTCLIM,GEOM, + SYME,NBEP,NLX,NLY,NIVMAG,loc_datg) + write_file_pgib_ASCSQ2(MCL_SOUS_EPAIS,NLX,NLY) + else: +# procedure coude sous-ep.:(MOT-CLE SOUS_EPAIS_MULTI) + write_file_dgib_ASCSP1(nomFichierDATG,TYPELE,MCL_SOUS_EPAIS,NIVMAG,loc_datg) + write_file_pgib_ASCSDO(RM,RC,ALPHA,EP1,LTCLIM,LTCHAR,NBEP, + NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS, + DNX,DNY,MCL_SOUS_EPAIS,GEOM,SYME) + write_file_pgib_ASCSP2(MCL_SOUS_EPAIS,NLX,NLY) + else: +# procedure coude regle + write_file_dgib_ASCRDO(nomFichierDATG,TYPELE,NIVMAG,TYPBOL,ALPHA,RC,RM,EP1,SUREP, + LTCLIM,LTCHAR,NBEP,loc_datg) + + +# GIBI + EXEC_LOGICIEL( LOGICIEL = logiel , + ARGUMENT = ( _F(NOM_PARA=nomFichierDATG), + _F(NOM_PARA=nomFichierGIBI), ), ) +# PRE_GIBI + PRE_GIBI() + + if SYME == 'QUART' : self.DeclareOut('nomres',self.sd) +# LIRE_MAILLAGE + nomres=LIRE_MAILLAGE(INFO=INFO) + +# DEFI_GROUP 1 + + motscles={} + l_CREA_GROUP_NO=[] + l_CREA_GROUP_NO.append('BORD1') + l_CREA_GROUP_NO.append('CLGV') + l_CREA_GROUP_NO.append('BORD2') + l_CREA_GROUP_NO.append('PEAUINT') + l_CREA_GROUP_NO.append('PEAUEXT') + +# cas des fissures axisymetriques + if FISS_COUDE!=None: + if FISS_COUDE['AXIS']=='OUI': + motscles['CREA_GROUP_MA']=[] + motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FONDFISS', + NOM = 'MAIL_ORI', + POSITION = 'INIT' , ),) + +# conversion des groupes de mailles en groupes du bloc fissure + if FISS_COUDE!=None: + if SYME == 'ENTIER': + l_CREA_GROUP_NO.append('NOLIG1') + l_CREA_GROUP_NO.append('FACE1') + l_CREA_GROUP_NO.append('NOLIG2') + l_CREA_GROUP_NO.append('FACE2') + l_CREA_GROUP_NO.append('FONDFISS') + + motscles['CREA_GROUP_NO']=[] + motscles['CREA_GROUP_NO'].append(_F(GROUP_MA=tuple(l_CREA_GROUP_NO))) + +# conversion des groupes de mailles en groupes de noeuds pour les +# ligaments des sous-ep. + if MCL_SOUS_EPAIS!=None: + issep=0 + for ssep in MCL_SOUS_EPAIS: + issep=issep+1 + if ssep['TYPE']=='ELLI': + for k in range(2*NLX[issep-1]+1): + chtmp=str(issep)+'_'+str(k+1) + ch1='CIR'+chtmp + ch2='ICI'+chtmp + motscles['CREA_GROUP_NO'].append(_F(NOM = ch2, + GROUP_MA = ch1,),) + motscles['CREA_GROUP_NO'].append(_F(NOM = 'IPCEN'+str(issep), + GROUP_MA = 'PCENT'+str(issep),),) + for k in range(2*NLY[issep-1]+1): + chtmp=str(issep)+'_'+str(k+1) + ch1='LON'+chtmp + ch2='ILO'+chtmp + motscles['CREA_GROUP_NO'].append(_F(NOM = ch2, + GROUP_MA = ch1,),) + for k in range(2*NLX[issep-1]+1): + chtmp=str(issep)+'_'+str(k+1) + ch1='ICI'+chtmp + ch2='OCI'+chtmp + ch3='ECI'+chtmp + motscles['CREA_GROUP_NO'].append(_F(NOM = ch2, + INTERSEC = ('PEAUEXT',ch1),),) + motscles['CREA_GROUP_NO'].append(_F(NOM = ch3, + INTERSEC = ('PEAUINT',ch1),),) + motscles['CREA_GROUP_NO'].append(_F(NOM = 'OPCEN'+str(issep), + INTERSEC = ('PEAUEXT','IPCEN'+str(issep),),),) + motscles['CREA_GROUP_NO'].append(_F(NOM = 'EPCEN'+str(issep), + INTERSEC = ('PEAUINT','IPCEN'+str(issep),),),) + for k in range(2*NLY[issep-1]+1): + chtmp=str(issep)+'_'+str(k+1) + ch1='ILO'+chtmp + ch2='OLO'+chtmp + ch3='ELO'+chtmp + motscles['CREA_GROUP_NO'].append(_F(NOM = ch2, + INTERSEC = ('PEAUEXT',ch1),),) + motscles['CREA_GROUP_NO'].append(_F(NOM = ch3, + INTERSEC = ('PEAUINT',ch1),),) + for k in range(2*NLX[issep-1]+1): + chtmp=str(issep)+'_'+str(k+1) + ch1='CIR'+chtmp + ch2='ICI'+chtmp + ch3='OCI'+chtmp + ch4='ECI'+chtmp + motscles['CREA_GROUP_NO'].append(_F(OPTION = 'SEGM_DROI_ORDO', + NOM = ch1, + GROUP_NO = ch2, + GROUP_NO_ORIG = ch3, + GROUP_NO_EXTR = ch4, + PRECISION = PRECIS, + CRITERE = CRITER,),) + motscles['CREA_GROUP_NO'].append(_F(OPTION = 'SEGM_DROI_ORDO', + NOM = 'PCENT'+str(issep), + GROUP_NO = 'IPCEN'+str(issep), + GROUP_NO_ORIG = 'OPCEN'+str(issep), + GROUP_NO_EXTR = 'EPCEN'+str(issep), + PRECISION = PRECIS, + CRITERE = CRITER,),) + for k in range(2*NLY[issep-1]+1): + chtmp=str(issep)+'_'+str(k+1) + ch1='LON'+chtmp + ch2='ILO'+chtmp + ch3='OLO'+chtmp + ch4='ELO'+chtmp + motscles['CREA_GROUP_NO'].append(_F(OPTION = 'SEGM_DROI_ORDO', + NOM = ch1, + GROUP_NO = ch2, + GROUP_NO_ORIG = ch3, + GROUP_NO_EXTR = ch4, + PRECISION = PRECIS, + CRITERE = CRITER,),) +# 1/ noms intermediaires des groupes de noeuds representant les ligaments +# des sections: TU,MI,GV et sous-ep. + for k in range(8): + motscles['CREA_GROUP_NO'].append(_F( NOM = CAR3[k]+str(issep), + GROUP_MA = CAR6[k]+str(issep),),) + + for k in range(3): + if SYME == 'ENTIER' or k!=2: + for j in range(8): + motscles['CREA_GROUP_NO'].append(_F( NOM = CAR3[j]+SECT[k], + GROUP_MA = CAR6[j]+SECT[k],),) + +# 2/ determination et nommage des noeuds origine et extremite des groupes de noeuds +# representant les ligaments de la ou des sections: sous-ep. + issep=0 + for ssep in MCL_SOUS_EPAIS: + issep=issep+1 + for k in range(8): + motscles['CREA_GROUP_NO'].append(_F( NOM = CAR4[k]+str(issep), + INTERSEC = ('PEAUEXT',CAR3[k]+str(issep),),),) + motscles['CREA_GROUP_NO'].append(_F( NOM = CAR5[k]+str(issep), + INTERSEC = ('PEAUINT',CAR3[k]+str(issep),),),) +# 3/ nommage final des groupes de noeuds representant les ligaments +# de la ou des sections: sous-ep. + for k in range(8): + motscles['CREA_GROUP_NO'].append(_F(OPTION = 'SEGM_DROI_ORDO', + NOM = CAR6[k]+str(issep), + GROUP_NO = CAR3[k]+str(issep), + GROUP_NO_ORIG = CAR4[k]+str(issep), + GROUP_NO_EXTR = CAR5[k]+str(issep), + PRECISION = PRECIS, + CRITERE = CRITER,),) + +# 4/ determination et nommage des noeuds origine et extremite des groupes de noeuds +# representant les ligaments des sections: TU,MI,GV + for k in range(3): + if SYME == 'ENTIER' or k!=2: + for j in range(8): + motscles['CREA_GROUP_NO'].append(_F( NOM = CAR4[j]+SECT[k], + INTERSEC = ('PEAUEXT',CAR3[j]+SECT[k],),),) + motscles['CREA_GROUP_NO'].append(_F( NOM = CAR5[j]+SECT[k], + INTERSEC = ('PEAUINT',CAR3[j]+SECT[k],),),) +# 5/ nommage final des groupes de noeuds representant les ligaments des sections: TU,MI,GV + for j in range(8): + motscles['CREA_GROUP_NO'].append(_F(OPTION = 'SEGM_DROI_ORDO', + NOM = CAR6[j]+SECT[k], + GROUP_NO = CAR3[j]+SECT[k], + GROUP_NO_ORIG = CAR4[j]+SECT[k], + GROUP_NO_EXTR = CAR5[j]+SECT[k], + PRECISION = PRECIS, + CRITERE = CRITER,),) + + + nomres=DEFI_GROUP(reuse =nomres, + MAILLAGE=nomres, + **motscles ) +# +# DEFI_GROUP 2 + if FISS_COUDE!=None: +# creation des groupes petit axe et grand axe fissure par +# intersection de groupes existants + motscles={} + motscles['CREA_GROUP_NO']=[] + l_peau=[] + l_intersec=[] + if POSIT == 'DEB_INT': + l_peau.append('PEAUINT') + else: + l_peau.append('PEAUEXT') + + if SYME == 'ENTIER' : + l_intersec.append('FACE1') + motscles['CREA_GROUP_NO'].append(_F(NOM = 'P_AXE_1', + INTERSEC = ('NOLIG1','FACE1'),),) + motscles['CREA_GROUP_NO'].append(_F(NOM = 'G_AXE_1', + INTERSEC = tuple(l_peau+l_intersec),),) + l_intersec=[] + l_intersec.append('FACE2') + motscles['CREA_GROUP_NO'].append(_F(NOM = 'P_AXE_2', + INTERSEC = ('NOLIG2','FACE2'),),) + motscles['CREA_GROUP_NO'].append(_F(NOM = 'G_AXE_2', + INTERSEC = tuple(l_peau+l_intersec),),) + + nomres=DEFI_GROUP(reuse =nomres, + MAILLAGE=nomres, + **motscles ) + +# AFFE_MODELE + __MODELE=AFFE_MODELE( MAILLAGE=nomres, + AFFE=_F( GROUP_MA = 'COUDE' , + PHENOMENE = 'MECANIQUE' , + MODELISATION = '3D' , ) + ) + +# MODI_MAILLAGE 1 + motscles={} + if GEOM == 'COUDE': + motscles['TUBE_COUDE']=[] + motscles['TUBE_COUDE'].append(_F(ANGLE=ALPHA, + R_CINTR=RC, + L_TUBE_P1=LTCHAR),) + motscles['PLAQ_TUBE']=[] + D_PLAQ_TUBE={} + D_PLAQ_TUBE['DEXT']=DEXT + D_PLAQ_TUBE['EPAIS']=EP1 + D_PLAQ_TUBE['L_TUBE_P1']=LTCHAR + if SYME == 'QUART' : D_PLAQ_TUBE['COUTURE']='NON' + if FISS_COUDE!=None: + D_PLAQ_TUBE['AZIMUT']=AZIM + elif SOUS_EPAIS_COUDE!=None : + D_PLAQ_TUBE['AZIMUT']=MCL_SOUS_EPAIS[0].IPHIC + else:pass + motscles['PLAQ_TUBE'].append(_F(**D_PLAQ_TUBE),) + nomres=MODI_MAILLAGE( reuse =nomres, + MAILLAGE=nomres, + **motscles ) + +# MODI_MAILLAGE 2 + motscles={} + motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXTUBE'),) + if FISS_COUDE!=None: + if FISS_COUDE['FISSURE'] == 'DEB_INIT': + motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXTUBE','FACE1','FACE2'),) + nomres=MODI_MAILLAGE(reuse =nomres, + MAILLAGE=nomres, + MODELE =__MODELE, + **motscles) + +# CREA_MAILLAGE + if SYME != 'QUART': + self.DeclareOut('nomre2',self.sd) + motscles={} + motscles['CREA_POI1']=[] + motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P1', + GROUP_NO='P1'),) + if TYPBOL == None : + motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P2', + GROUP_NO='P2'),) + nomre2=CREA_MAILLAGE( MAILLAGE=nomres, + **motscles) + else: + nomre2=nomres + + +# IMPRESSSION + if IMPRESSION!=None: + if IMPRESSION.__class__.__name__ !='MCList' : IMPRESSION =[IMPRESSION,] + for impr in IMPRESSION : +# + motscles={} + if impr['FORMAT']=='IDEAS' : motscles['VERSION'] =impr['VERSION'] + if impr['FORMAT']=='CASTEM' : motscles['NIVE_GIBI'] =impr['NIVE_GIBI'] + if impr['UNITE']!=None : motscles['UNITE'] =impr['UNITE'] + impr_resu = _F( MAILLAGE = nomre2,) +# + IMPR_RESU( RESU = impr_resu, + FORMAT= impr['FORMAT'],**motscles) + + + + return ier + + diff --git a/Aster/Cata/cataSTA81/Macro/macr_aspic_calc_ops.py b/Aster/Cata/cataSTA81/Macro/macr_aspic_calc_ops.py new file mode 100644 index 00000000..2bef7b6c --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_aspic_calc_ops.py @@ -0,0 +1,804 @@ +#@ MODIF macr_aspic_calc_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM, + FOND_FISS_1,FOND_FISS_2,CHARGE,RESU_THER,AFFE_MATERIAU,EQUILIBRE, + PRES_REP,ECHANGE,TORS_CORP,TORS_TUBU,COMP_INCR,COMP_ELAS, + THETA_3D,OPTION,SOLVEUR,CONVERGENCE,NEWTON,RECH_LINEAIRE, + INCREMENT,PAS_AZIMUT,IMPRESSION,INFO,TITRE ,**args): + """ + Ecriture de la macro MACR_ASPIC_CALC + """ + from Accas import _F + import types + from Utilitai.Utmess import UTMESS + ier=0 +#------------------------------------------------------------------ + # On recopie le mot cle affe_materiau pour le proteger + mc_AFFE_MATERIAU=AFFE_MATERIAU +#------------------------------------------------------------------ + # On importe les definitions des commandes a utiliser dans la macro + AFFE_MODELE =self.get_cmd('AFFE_MODELE' ) + AFFE_MATERIAU =self.get_cmd('AFFE_MATERIAU' ) + AFFE_CARA_ELEM =self.get_cmd('AFFE_CARA_ELEM' ) + AFFE_CHAR_THER_F =self.get_cmd('AFFE_CHAR_THER_F') + THER_LINEAIRE =self.get_cmd('THER_LINEAIRE' ) + AFFE_CHAR_MECA =self.get_cmd('AFFE_CHAR_MECA' ) + STAT_NON_LINE =self.get_cmd('STAT_NON_LINE' ) + CALC_ELEM =self.get_cmd('CALC_ELEM' ) + POST_RELEVE_T =self.get_cmd('POST_RELEVE_T' ) + IMPR_TABLE =self.get_cmd('IMPR_TABLE' ) + POST_RCCM =self.get_cmd('POST_RCCM' ) + DEFI_FOND_FISS =self.get_cmd('DEFI_FOND_FISS' ) + CALC_THETA =self.get_cmd('CALC_THETA' ) + CALC_G_THETA_T =self.get_cmd('CALC_G_THETA_T' ) + CALC_G_LOCAL_T =self.get_cmd('CALC_G_LOCAL_T' ) + IMPR_RESU =self.get_cmd('IMPR_RESU' ) + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + +#------------------------------------------------------------------ +# data + GRMAIL= ('EQUERRE','PEAUINT','EXCORP1','EXCORP2','EXTUBU','LEVRTUBU','LEVRCORP') + NOMNOE= ('P1_CORP','P2_CORP','P_TUBU ') + IMPRT1= ('NUME_ORDRE','INTITULE','RESU' ,'NOM_CHAM', + 'ABSC_CURV' ,'COOR_X' ,'COOR_Y','COOR_Z' , + 'SIXX' ,'SIXY' ,'SIXZ' ) + IMPRT2= ('NUME_ORDRE','INTITULE','RESU' ,'NOM_CHAM', + 'ABSC_CURV' ,'COOR_X' ,'COOR_Y','COOR_Z' , + 'SIYY' ,'SIXY' ,'SIYZ' ) + IMPRT3= ('NUME_ORDRE','INTITULE','RESU' ,'NOM_CHAM', + 'ABSC_CURV' ,'COOR_X' ,'COOR_Y','COOR_Z' , + 'TEMP' ) + APPRES= ('PEAUINT ','LEVRTUBU','LEVRCORP') +#------------------------------------------------------------------ +# + i=0 + for mate in mc_AFFE_MATERIAU: + if mate['RCCM']=='OUI' : + i=i+1 + MRCCM=mate['MATER'] + if i>1 : + UTMESS('E', "MACR_ASPIC_CALC", "vous affectez plus d un materiau contenant l option rccm") +# + if (TYPE_MAILLAGE[:4]=='SAIN') and (TUBULURE==None) : + UTMESS('E', "MACR_ASPIC_CALC", "pour les piquages sains, TUBULURE doit etre renseigne") +# + if EQUILIBRE['NOEUD'] not in ('P1_CORP','P2_CORP') : + UTMESS('E', "MACR_ASPIC_CALC", "EQUILIBRE[NOEUD] : on attend P1_CORP ou P2_CORP") +# + if PRES_REP['EFFE_FOND']=='OUI' : + if PRES_REP['NOEUD']==None : + UTMESS('E', "MACR_ASPIC_CALC", "il faut preciser un noeud pour EFFE_FOND") + if PRES_REP['NOEUD'] not in ('P1_CORP','P2_CORP') : + UTMESS('E', "MACR_ASPIC_CALC", "PRES_REP[NOEUD] : on attend P1_CORP ou P2_CORP") + if PRES_REP['NOEUD']==EQUILIBRE['NOEUD'] : + UTMESS('E', "MACR_ASPIC_CALC", "on ne peut appliquer un EFFE_FOND sur PRES_REP[NOEUD] car ce noeud est bloque") +# + if TORS_CORP!=None : + for tors in TORS_CORP : + if tors['NOEUD'] not in ('P1_CORP','P2_CORP') : + UTMESS('E', "MACR_ASPIC_CALC", "TORS_CORP[NOEUD] : on attend P1_CORP ou P2_CORP") + if tors['NOEUD']==EQUILIBRE['NOEUD'] : + UTMESS('E', "MACR_ASPIC_CALC", "on ne peut appliquer un torseur sur TORS_CORP[NOEUD] car ce noeud est bloque") +# + if (TYPE_MAILLAGE[:4]=='SAIN') and (THETA_3D!=None) : + UTMESS('E', "MACR_ASPIC_CALC", "si TYPE_MAILLAGE SAIN : mecanique de la rupture impossible") +# + if OPTION in ('CALC_G_MAX','CALC_G_MAX_LOCAL') : + if BORNES==None : + UTMESS('E', "MACR_ASPIC_CALC", "mot-clef obligatoire avec cette option") +# + if IMPRESSION!=None : + if IMPRESSION['FORMAT'] in ('IDEAS','CASTEM') : + if IMPRESSION['NOM_CHAM']==None : + UTMESS('E', "MACR_ASPIC_CALC", "impression de resultats demandée sans preciser le nom des champs cf. la documentation utilisateur : U4.PC.20.") +# +#------------------------------------------------------------------ +# +# --- commande AFFE_MODELE --- +# + if MODELE!=None : self.DeclareOut('modele',MODELE) + mcfact=[] + if (PRES_REP['PRES_LEVRE']=='OUI') and (TYPE_MAILLAGE[-4:]=='_DEB') : + mcfact.append(_F(GROUP_MA=GRMAIL, PHENOMENE='MECANIQUE',MODELISATION='3D' )) + else: + mcfact.append(_F(GROUP_MA=GRMAIL[:-2],PHENOMENE='MECANIQUE',MODELISATION='3D' )) + mcfact.append( _F(GROUP_MA='P1_CORP' ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR')) + mcfact.append( _F(GROUP_MA='P2_CORP' ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR')) + mcfact.append( _F(GROUP_MA='P_TUBU' ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR')) + modele = AFFE_MODELE( MAILLAGE = MAILLAGE , + AFFE = mcfact ) + if ECHANGE!=None : # modele thermique + __modthe = AFFE_MODELE( MAILLAGE = MAILLAGE , + AFFE = _F(GROUP_MA =GRMAIL[:-2], + PHENOMENE ='THERMIQUE', + MODELISATION='3D' ) ) +# +# --- commande AFFE_MATERIAU --- +# + if CHAM_MATER!=None : self.DeclareOut('affmat',CHAM_MATER) + mcfact=[] + for mater in mc_AFFE_MATERIAU : + if mater['TOUT']!=None : mcfact.append(_F(TOUT =mater['TOUT' ],MATER=mater['MATER'],TEMP_REF=mater['TEMP_REF'])) + else : mcfact.append(_F(GROUP_MA=mater['GROUP_MA'],MATER=mater['MATER'],TEMP_REF=mater['TEMP_REF'])) + affmat = AFFE_MATERIAU( MAILLAGE = MAILLAGE , + MODELE = modele , + AFFE = mcfact ) +# +# --- commande AFFE_CARA_ELEM --- +# + if CARA_ELEM!=None : self.DeclareOut('carael',CARA_ELEM) + carael = AFFE_CARA_ELEM( MODELE = modele , + DISCRET = ( _F( GROUP_MA='P1_CORP' , + CARA ='K_TR_D_N', + VALE = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ), + _F( GROUP_MA='P2_CORP' , + CARA ='K_TR_D_N', + VALE = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ), + _F( GROUP_MA='P_TUBU' , + CARA ='K_TR_D_N', + VALE = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ), ) ) +# +# --- commande AFFE_CHAR_THER_F --- +# condition aux limites +# + if ECHANGE!=None : + __chther = AFFE_CHAR_THER_F( MODELE = __modthe , + ECHANGE=( _F(GROUP_MA='PEAUTUBU', + COEF_H =ECHANGE['COEF_H_TUBU'], + TEMP_EXT=ECHANGE['TEMP_EXT'],), + _F(GROUP_MA='PEAUCORP', + COEF_H =ECHANGE['COEF_H_CORP'], + TEMP_EXT=ECHANGE['TEMP_EXT'],),)) +# +# --- calcul thermique --- +# + if RESU_THER!=None : self.DeclareOut('resuth',RESU_THER) + mcsimp={} + if INCREMENT['NUME_INST_INIT']!=None : mcsimp['NUME_INIT']=INCREMENT['NUME_INST_INIT'] + if INCREMENT['NUME_INST_FIN' ]!=None : mcsimp['NUME_FIN' ]=INCREMENT['NUME_INST_FIN' ] + mcfact=_F(LIST_INST=INCREMENT['LIST_INST'],**mcsimp) + resuth = THER_LINEAIRE( MODELE = __modthe , + CHAM_MATER = affmat , + TEMP_INIT = _F(STATIONNAIRE='OUI',), + EXCIT = _F(CHARGE=__chther,), + INCREMENT = mcfact, ) +# + if CHARGE!=None : self.DeclareOut('chmeth',CHARGE) + chmeth = AFFE_CHAR_MECA( MODELE = modele , + TEMP_CALCULEE = resuth ) +# +# --- commande AFFE_CHAR_MECA --- +# condition aux limites +# + if EQUILIBRE['NOEUD']=='P1_CORP' : + NENCAS = EQUILIBRE['NOEUD'] + AEFOCO = 'EXCORP2' + ATORCO = 'P2_CORP' + LINTC = 'L_INT_C2' + elif EQUILIBRE['NOEUD']=='P2_CORP' : + NENCAS = EQUILIBRE['NOEUD'] + AEFOCO = 'EXCORP1' + ATORCO = 'P1_CORP' + LINTC = 'L_INT_C1' + __conlim = AFFE_CHAR_MECA( MODELE = modele , + LIAISON_ELEM = ( _F( OPTION ='3D_POU' , + GROUP_MA_1='EXCORP1', + GROUP_NO_2='P1_CORP'), + _F( OPTION ='3D_POU' , + GROUP_MA_1='EXCORP2' , + GROUP_NO_2='P2_CORP'), + _F( OPTION ='3D_POU' , + GROUP_MA_1='EXTUBU', + GROUP_NO_2='P_TUBU'), ), + DDL_IMPO = _F( GROUP_NO = NENCAS , + DX = 0.0 , + DY = 0.0 , + DZ = 0.0 , + DRX = 0.0 , + DRY = 0.0 , + DRZ = 0.0 , ) ) +# +# --- commande AFFE_CHAR_MECA --- +# chargement mecanique : pres_rep, effet de fond +# + motscles={} + if (PRES_REP['PRES_LEVRE']=='OUI') and (TYPE_MAILLAGE[-4:]=='_DEB') : + motscles['PRES_REP' ]= _F(GROUP_MA=APPRES, PRES=PRES_REP['PRES']) + else : + motscles['PRES_REP' ]= _F(GROUP_MA=APPRES[0],PRES=PRES_REP['PRES']) + if PRES_REP['EFFE_FOND' ]!=None : + motscles['EFFE_FOND' ]=(_F(GROUP_MA ='EXTUBU ', + GROUP_MA_INT='L_INT_TU', + PRES =PRES_REP['PRES']), + _F(GROUP_MA =AEFOCO, + GROUP_MA_INT=LINTC, + PRES =PRES_REP['PRES'])) + __chpres = AFFE_CHAR_MECA( MODELE = modele ,**motscles) +# +# --- commande AFFE_CHAR_MECA --- +# chargement mecanique : torseur sur le corps +# + if TORS_CORP!=None: + __chtrc = [None]*6 + i=0 + for tors in TORS_CORP : + mcsimp={} + if tors['FX']!=None : mcsimp['FX']=tors['FX'] + if tors['FY']!=None : mcsimp['FY']=tors['FY'] + if tors['FZ']!=None : mcsimp['FZ']=tors['FZ'] + if tors['MX']!=None : mcsimp['MX']=tors['MX'] + if tors['MY']!=None : mcsimp['MY']=tors['MY'] + if tors['MZ']!=None : mcsimp['MZ']=tors['MZ'] + mcfact=_F(GROUP_NO=ATORCO,**mcsimp) + __chtrc[i] = AFFE_CHAR_MECA( MODELE = modele , + FORCE_NODALE = mcfact , ) + i=i+1 +# +# --- commande AFFE_CHAR_MECA --- +# chargement mecanique : torseur sur la tubulure +# + if TORS_TUBU!=None: + __chtrt = [None]*6 + i=0 + for tors in TORS_TUBU : + mcsimp={} + if tors['FX']!=None : mcsimp['FX']=tors['FX'] + if tors['FY']!=None : mcsimp['FY']=tors['FY'] + if tors['FZ']!=None : mcsimp['FZ']=tors['FZ'] + if tors['MX']!=None : mcsimp['MX']=tors['MX'] + if tors['MY']!=None : mcsimp['MY']=tors['MY'] + if tors['MZ']!=None : mcsimp['MZ']=tors['MZ'] + mcfact=_F(GROUP_NO='P_TUBU ',**mcsimp) + __chtrt[i] = AFFE_CHAR_MECA( MODELE = modele , + FORCE_NODALE = mcfact , ) + i=i+1 +# +# --- commande STAT_NON_LINE --- +# + motscles={} +# + mcfex=[] # mot clé facteur EXCIT + mcfex.append(_F(CHARGE=__conlim,)) + if ECHANGE!=None : + mcfex.append(_F(CHARGE=chmeth,)) + if PRES_REP['FONC_MULT']!=None : + mcfex.append(_F(CHARGE=__chpres,FONC_MULT=PRES_REP['FONC_MULT'])) + else : + mcfex.append(_F(CHARGE=__chpres,)) + if TORS_CORP!=None: + i=0 + for tors in TORS_CORP : + if tors['FONC_MULT']!=None : + mcfex.append(_F(CHARGE=__chtrc[i],FONC_MULT=tors['FONC_MULT'])) + else : + mcfex.append(_F(CHARGE=__chtrc[i],)) + i=i+1 + if TORS_TUBU!=None: + i=0 + for tors in TORS_TUBU : + if tors['FONC_MULT']!=None : + mcfex.append(_F(CHARGE=__chtrt[i],FONC_MULT=tors['FONC_MULT'])) + else : + mcfex.append(_F(CHARGE=__chtrt[i],)) + i=i+1 + motscles['EXCIT'] =mcfex +# + mcfci=[] # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets + if COMP_INCR!=None : + mcfci.append(_F(TOUT ='OUI' ,RELATION=COMP_INCR['RELATION'])) + mcfci.append( _F(GROUP_MA=NOMNOE,RELATION='ELAS')) + motscles['COMP_INCR'] =mcfci +# + if COMP_ELAS!=None : + motscles['COMP_ELAS'] =_F(GROUP_MA=GRMAIL[:-2] ,RELATION=COMP_ELAS['RELATION']) +# + dSolveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste) + for i in dSolveur.keys(): + if dSolveur[i]==None : del dSolveur[i] +# + dConverg=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste) + for i in dConverg.keys(): + if dConverg[i]==None : del dConverg[i] +# + dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste) + for i in dNewton.keys(): + if dNewton[i]==None : del dNewton[i] +# + dRechlin=RECH_LINEAIRE[0].cree_dict_valeurs(RECH_LINEAIRE[0].mc_liste) + for i in dRechlin.keys(): + if dRechlin[i]==None : del dRechlin[i] +# + dIncrem=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste) + for i in dIncrem.keys(): + if dIncrem[i]==None : del dIncrem[i] +# + if TITRE!=None : + motscles['TITRE' ] =TITRE + motscles ['SOLVEUR' ] =dSolveur + motscles ['CONVERGENCE' ] =dConverg + motscles ['NEWTON' ] =dNewton + motscles ['RECH_LINEAIRE'] =dRechlin + motscles ['INCREMENT' ] =dIncrem + self.DeclareOut('nomres',self.sd) + nomres = STAT_NON_LINE( MODELE = modele , + CHAM_MATER = affmat , + CARA_ELEM = carael , + INFO = INFO , **motscles) +# + nomres = CALC_ELEM( reuse = nomres, + RESULTAT = nomres , + TOUT_ORDRE = 'OUI' , + OPTION = ('SIEF_ELNO_ELGA','VARI_ELNO_ELGA','EQUI_ELNO_SIGM') , + INFO = INFO ,) +# +#----------------------------------------------------------------------- + if TYPE_MAILLAGE[:4]=='SAIN' : +#----------------------------------------------------------------------- +# +# --- post traitement : POST_RELEVE_T --- azimuts droits +# +# ---- champs de contrainte SI, SII ET SIII ---- +# + if TYPE_MAILLAGE=='SAIN_GROS' : NBAZIM = 40 + else : NBAZIM = 48 + mcfact=[] + TYPSOU=None + if TUBULURE!=None : TYPSOU = TUBULURE['TYPE'] + for i in range(1,NBAZIM+1,PAS_AZIMUT): + if i<10 : NUME = '0'+str(i) + else : NUME = str(i) + mcsimp={} + if TYPSOU=='TYPE_1': + mcsimp['REPERE' ]='CYLINDRIQUE', + mcsimp['ORIGINE']=( 0.0 , 0.0 , 0.0 ) + mcsimp['AXE_Z' ]=( 0.0 , 0.0 , 1.0 ) + INTITD = 'AZI_'+NUME+'_D-REP_CYL' + else: + mcsimp['REPERE' ]='LOCAL' + mcsimp['VECT_Y' ]=( 0.0 , 0.0 , 1.0 ) + INTITD = 'AZI_'+NUME+'_D-REP_LOC' + mcsimp['INTITULE' ]=INTITD + mcsimp['GROUP_NO' ]='LD'+str(i) + mcfact.append( _F( RESULTAT = nomres, + TOUT_ORDRE ='OUI', + NOM_CHAM ='SIEF_ELNO_ELGA', + PRECISION =55.E-1, + TOUT_CMP ='OUI', + OPERATION ='EXTRACTION',**mcsimp)) + __noposd=POST_RELEVE_T(ACTION = mcfact, + TITRE = '-- TRAITEMENT DES AZIMUTS DROITS --') +# +# --- IMPR_TABLE dans un repere cylindrique ou local +# des champs de contrainte SI, SII ET SIII +# + if TYPSOU=='TYPE_1' : nompara=IMPRT1 + else : nompara=IMPRT2 + IMPR_TABLE(TABLE = __noposd, + NOM_PARA = nompara ) +# +# ---- Pm, Pm+Pb sur les lignes de depouillement ---- +# + if mc_AFFE_MATERIAU[0]['RCCM']=='OUI': + mcfact=[] + for i in range(1,NBAZIM+1,PAS_AZIMUT): + if i<10 : NUME = '0'+str(i) + else : NUME = str(i) + mcsimp={} + mcsimp['INTITULE' ]='LD'+str(i) + mcsimp['GROUP_NO' ]='LD'+str(i) + mcsimp['RESULTAT' ]=nomres + mcsimp['TOUT_ORDRE' ]='OUI' + mcsimp['NOM_CHAM' ]='SIEF_ELNO_ELGA' + mcsimp['PRECISION' ]=55.E-1 + mcsimp['TOUT_CMP' ]='OUI' + mcsimp['OPERATION' ]='EXTRACTION' + mcfact.append( _F(**mcsimp) ) + __prelsd=POST_RELEVE_T(ACTION=mcfact) + __pmpbsd=POST_RCCM(OPTION = 'PM_PB', + TYPE_RESU_MECA = 'EVOLUTION', + TYPE_RESU = 'VALE_MAX', + MATER = MRCCM, + TRANSITOIRE = _F(TABL_RESU_MECA = __prelsd,), + TITRE = '-- TRAITEMENT DES AZIMUTS DROITS --',) + IMPR_TABLE(TABLE = __pmpbsd, ) +# +# ---- champ de temperature, si il a ete calcule, sur les lignes de depouillement ---- +# + if ECHANGE!=None : + mcfact=[] + for i in range(1,NBAZIM+1,PAS_AZIMUT): + if i<10 : NUME = '0'+str(i) + else : NUME = str(i) + mcsimp={} + mcsimp['GROUP_NO' ]='LD'+str(i) + mcsimp['RESULTAT' ]=resuth + mcsimp['TOUT_ORDRE' ]='OUI' + mcsimp['NOM_CHAM' ]='TEMP' + mcsimp['PRECISION' ]=55.E-1 + mcsimp['TOUT_CMP' ]='OUI' + mcsimp['INTITULE' ]='AZI_'+NUME+'_D' + mcsimp['OPERATION' ]='EXTRACTION' + mcfact.append( _F(**mcsimp) ) + __rthazd=POST_RELEVE_T(ACTION=mcfact) + IMPR_TABLE(TABLE = __rthazd, ) +# +# ---- parametres caracterisant la distribution de temperature, +# si elle a ete calculee, dans l epaisseur du ligament ---- +# + mcfact=[] + for i in range(1,NBAZIM+1,PAS_AZIMUT): + if i<10 : NUME = '0'+str(i) + else : NUME = str(i) + mcsimp={} + mcsimp['GROUP_NO' ]='LD'+str(i) + mcsimp['RESULTAT' ]=resuth + mcsimp['TOUT_ORDRE' ]='OUI' + mcsimp['NOM_CHAM' ]='TEMP' + mcsimp['PRECISION' ]=55.E-1 + mcsimp['TOUT_CMP' ]='OUI' + mcsimp['INTITULE' ]='AZI_'+NUME+'_D' + mcsimp['OPERATION' ]='MOYENNE' + mcfact.append( _F(**mcsimp) ) + __rmothd=POST_RELEVE_T(ACTION=mcfact) + IMPR_TABLE(TABLE = __rmothd, ) +# +#----------------------------------------------------------------------- +# +# --- post traitement : POST_RELEVE_T --- azimuts inclines +# --- champs de contrainte SI, SII ET SIII ---- +# + mcfact=[] + for i in range(1,NBAZIM+1,PAS_AZIMUT): + if i<10 : NUME = '0'+str(i) + else : NUME = str(i) + mcsimp={} + mcsimp['GROUP_NO' ]='LI'+str(i) + mcsimp['RESULTAT' ]=nomres + mcsimp['TOUT_ORDRE' ]='OUI' + mcsimp['NOM_CHAM' ]='SIEF_ELNO_ELGA' + mcsimp['PRECISION' ]=55.E-1 + mcsimp['TOUT_CMP' ]='OUI' + mcsimp['REPERE' ]='LOCAL' + mcsimp['VECT_Y' ]=( 0.0 , 0.0 , 1.0 ) + mcsimp['INTITULE' ]='AZI_'+NUME+'_I-REP_LOC' + mcsimp['OPERATION' ]='EXTRACTION' + mcfact.append( _F(**mcsimp) ) + __noposi=POST_RELEVE_T(ACTION=mcfact) + IMPR_TABLE(TABLE = __noposi, ) +# +# ---- Pm, Pm+Pb sur les lignes de depouillement ---- +# + if mc_AFFE_MATERIAU[0]['RCCM']=='OUI': + mcfact=[] + for i in range(1,NBAZIM+1,PAS_AZIMUT): + if i<10 : NUME = '0'+str(i) + else : NUME = str(i) + mcsimp={} + mcsimp['INTITULE' ]='LI'+str(i) + mcsimp['GROUP_NO' ]='LI'+str(i) + mcsimp['RESULTAT' ]=nomres + mcsimp['TOUT_ORDRE' ]='OUI' + mcsimp['NOM_CHAM' ]='SIEF_ELNO_ELGA' + mcsimp['PRECISION' ]=55.E-1 + mcsimp['TOUT_CMP' ]='OUI' + mcsimp['OPERATION' ]='EXTRACTION' + mcfact.append( _F(**mcsimp) ) + __prelsi=POST_RELEVE_T(ACTION=mcfact) + __pmpbsi=POST_RCCM(OPTION = 'PM_PB', + TYPE_RESU_MECA = 'EVOLUTION', + TYPE_RESU = 'VALE_MAX', + MATER = MRCCM, + TRANSITOIRE = _F(TABL_RESU_MECA = __prelsi,), + TITRE = '-- TRAITEMENT DES AZIMUTS INCLINES --',) + IMPR_TABLE(TABLE = __pmpbsi, ) +# +# ---- champs de temperature,si il a ete calcule, sur les lignes de depouillement ---- +# + if ECHANGE!=None : + mcfact=[] + for i in range(1,NBAZIM+1,PAS_AZIMUT): + if i<10 : NUME = '0'+str(i) + else : NUME = str(i) + mcsimp={} + mcsimp['GROUP_NO' ]='LI'+str(i) + mcsimp['RESULTAT' ]=resuth + mcsimp['TOUT_ORDRE' ]='OUI' + mcsimp['NOM_CHAM' ]='TEMP' + mcsimp['PRECISION' ]=55.E-1 + mcsimp['TOUT_CMP' ]='OUI' + mcsimp['INTITULE' ]='AZI_'+NUME+'_I' + mcsimp['OPERATION' ]='EXTRACTION' + mcfact.append( _F(**mcsimp) ) + __rthazi=POST_RELEVE_T(ACTION=mcfact) + IMPR_TABLE(TABLE = __rthazi, + NOM_PARA = IMPRT3 ) +# +# ---- parametres caracterisant la distribution de temperature, +# si elle a ete calculee, dans l epaisseur du ligament ---- +# + mcfact=[] + for i in range(1,NBAZIM+1,PAS_AZIMUT): + if i<10 : NUME = '0'+str(i) + else : NUME = str(i) + mcsimp={} + mcsimp['GROUP_NO' ]='LI'+str(i) + mcsimp['RESULTAT' ]=resuth + mcsimp['TOUT_ORDRE' ]='OUI' + mcsimp['NOM_CHAM' ]='TEMP' + mcsimp['PRECISION' ]=55.E-1 + mcsimp['TOUT_CMP' ]='OUI' + mcsimp['INTITULE' ]='AZI_'+NUME+'_I' + mcsimp['OPERATION' ]='MOYENNE' + mcfact.append( _F(**mcsimp) ) + __rmothi=POST_RELEVE_T(ACTION=mcfact) + IMPR_TABLE(TABLE = __rmothi, ) +# +#----------------------------------------------------------------------- + elif TYPE_MAILLAGE[:4]=='FISS' : +#----------------------------------------------------------------------- +# + NOMGRO=[] + NOMGRE=[] + TABMA8=[] + NOMMA =[] + if TYPE_MAILLAGE in ('FISS_COUR_DEB','FISS_LONG_DEB','FISS_AXIS_DEB','FISS_COUR_NONDEB') : + NBFIS = 1 + NOMGRO.append(('P_FON1' ,'P_FIS1' ),) + NOMGRE.append(('P_FON2' ,'P_FIS2' ),) + TABMA8.append('FONDFISS') + if TYPE_MAILLAGE in ('FISS_COUR_DEB','FISS_LONG_DEB') : FERME=0 + else : + FERME=1 + NOMMA.append('MAIL_ORI') + elif TYPE_MAILLAGE in ('FISS_LONG_NONDEB','FISS_AXIS_NONDEB') : + NBFIS = 2 + NOMGRO.append(('P_FON1' ,'P_FIS1' ),) + NOMGRE.append(('P_FON2' ,'P_FIS2' ),) + NOMGRO.append(('PI_FON1','PI_FIS1'),) + NOMGRE.append(('PI_FON2','PI_FIS2'),) + TABMA8.append('FOND_SUP') + TABMA8.append('FOND_INF') + if TYPE_MAILLAGE=='FISS_LONG_NONDEB' : FERME=0 + else : + FERME=1 + NOMMA.append('MA_ORI_S') + NOMMA.append('MA_ORI_I') +# + if ECHANGE!=None: +# +# ---- champs de temperature en fond de fissure +# si il a ete calcule, cas 1 fond de fissure ---- +# + if NBFIS==1: + __rthfis=POST_RELEVE_T(ACTION=_F(GROUP_NO ='FONDFISS', + RESULTAT =resuth, + TOUT_ORDRE ='OUI', + NOM_CHAM ='TEMP', + PRECISION =55.E-1, + TOUT_CMP ='OUI', + INTITULE ='FONDFISS', + OPERATION ='EXTRACTION',)) + IMPR_TABLE(TABLE = __rthfis, ) +# +# ---- champs de temperature en fond de fissure +# si il a ete calcule, cas 2 fonds de fissure ---- +# + elif NBFIS==2: +# + __rthfis1=POST_RELEVE_T(ACTION=_F(GROUP_NO ='FOND_SUP', + RESULTAT =resuth, + TOUT_ORDRE ='OUI', + NOM_CHAM ='TEMP', + PRECISION =55.E-1, + TOUT_CMP ='OUI', + INTITULE ='FOND_SUP', + OPERATION ='EXTRACTION',)) + IMPR_TABLE(TABLE = __rthfis1, ) + __rthfis2=POST_RELEVE_T(ACTION=_F(GROUP_NO ='FOND_INF', + RESULTAT =resuth, + TOUT_ORDRE ='OUI', + NOM_CHAM ='TEMP', + PRECISION =55.E-1, + TOUT_CMP ='OUI', + INTITULE ='FOND_INF', + OPERATION ='EXTRACTION',)) + IMPR_TABLE(TABLE = __rthfis2, ) +# +# boucle sur le nombre de fond de fissure +# + fond3d = [None]*2 + for j in range(NBFIS): + if FOND_FISS_1!=None : self.DeclareOut('fond3d_0',FOND_FISS_1) + if FOND_FISS_2!=None : self.DeclareOut('fond3d_1',FOND_FISS_2) +# +# --- commande DEFI_FOND_FISS --- +# + motscles={} + if not FERME: + motscles['FOND_FISS']=_F(GROUP_MA =TABMA8[j], + GROUP_NO_ORIG=NOMGRO[j][0], + GROUP_NO_EXTR=NOMGRE[j][0],) + motscles['VECT_GRNO_ORIG']=NOMGRO[j] + motscles['VECT_GRNO_EXTR']=NOMGRE[j] + else: + if TYPE_MAILLAGE.find('AXIS')!=-1 : grnoorig=NOMGRE[j][0] +# si AXIS, P_FON1 est remplace par P_FON2 pour +# fermer le fond de fissure + else : grnoorig=NOMGRO[j][0] + motscles['FOND_FERME']=_F(GROUP_MA =TABMA8[j], + GROUP_NO_ORIG=grnoorig, + GROUP_MA_ORIG=NOMMA[j],) + fond3d[j]=DEFI_FOND_FISS( MAILLAGE = MAILLAGE, + LEVRE_SUP = _F(GROUP_MA='LEVRCORP',), + LEVRE_INF = _F(GROUP_MA='LEVRTUBU',),**motscles) + if THETA_3D!=None: + for tht3d in THETA_3D : +# +# --- commande CALC_THETA --- +# + __theta = CALC_THETA( MODELE = modele, + FOND_FISS = fond3d[j], + THETA_3D = _F( TOUT = 'OUI', + MODULE = 1.0 , + R_INF = tht3d['R_INF'], + R_SUP = tht3d['R_SUP'], ) ) +# +# --- commande CALC_G_THETA_T --- +# + montit = 'G_THETA AVEC R_INF = '+str(tht3d['R_INF'])+' ET R_SUP = '+str(tht3d['R_SUP']) + motscles={} + if COMP_ELAS!=None: motscles['COMP_ELAS']= _F(TOUT = 'OUI', + RELATION = COMP_ELAS['RELATION'],) + if COMP_INCR!=None: motscles['COMP_INCR']= _F(RELATION = COMP_INCR['RELATION'],) + __gtheta = CALC_G_THETA_T( MODELE = modele, + CHAM_MATER = affmat, + THETA = __theta, + RESULTAT = nomres, + TOUT_ORDRE = 'OUI', + TITRE = montit,**motscles) + IMPR_TABLE(TABLE = __gtheta, ) +# +# recherche du g max +# + if OPTION=='CALC_G_MAX' : + if BORNES!=None: + mcfact=[] + for born in BORNES : + mcfact.append(_F( NUME_ORDRE = born['NUME_ORDRE'] , + VALE_MIN = born['VALE_MIN' ] , + VALE_MAX = born['VALE_MAX' ] ) ) + __gbil = CALC_G_THETA_T( MODELE = modele, + CHAM_MATER = affmat, + THETA = __theta, + RESULTAT = nomres, + TOUT_ORDRE = 'OUI', + COMP_ELAS = _F(TOUT = 'OUI', + RELATION = COMP_ELAS['RELATION'],), + TITRE = montit, + OPTION = OPTION, + BORNES = mcfact,) + IMPR_TABLE(TABLE = __gbil, ) +# +# --- commande CALC_G_LOCAL_T --- +# + montit = 'G_LOCAL AVEC R_INF = '+str(tht3d['R_INF'])+' ET R_SUP = '+str(tht3d['R_SUP']) + motscles={} + if COMP_ELAS!=None: motscles['COMP_ELAS' ]= _F(TOUT = 'OUI', + RELATION = COMP_ELAS['RELATION'],) + if FERME: + motscles['LISSAGE_THETA']= 'LAGRANGE' + motscles['LISSAGE_G' ]= 'LAGRANGE' + __glocal = CALC_G_LOCAL_T( MODELE = modele, + CHAM_MATER = affmat, + FOND_FISS = fond3d[j], + RESULTAT = nomres, + TOUT_ORDRE = 'OUI', + R_INF = tht3d['R_INF'], + R_SUP = tht3d['R_SUP'], + TITRE = montit,**motscles) +# +# recherche du g max local +# + if OPTION=='CALC_G_MAX_LOCAL' : + if BORNES!=None: + motscles={} + mcfact=[] + if FERME: + motscles['LISSAGE_THETA']= 'LAGRANGE' + motscles['LISSAGE_G' ]= 'LAGRANGE' + for born in BORNES : + mcfact.append(_F( NUME_ORDRE = born['NUME_ORDRE'] , + VALE_MIN = born['VALE_MIN' ] , + VALE_MAX = born['VALE_MAX' ] ) ) + motscles['BORNES']=mcfact + __glbil = CALC_G_LOCAL_T( MODELE = modele, + CHAM_MATER = affmat, + FOND_FISS = fond3d[j], + RESULTAT = nomres, + TOUT_ORDRE = 'OUI', + COMP_ELAS = _F(TOUT = 'OUI', + RELATION = COMP_ELAS['RELATION'],), + TITRE = montit, + OPTION = 'CALC_G_MAX', + R_INF = tht3d['R_INF'], + R_SUP = tht3d['R_SUP'],**motscles) + IMPR_TABLE(TABLE = __glbil, ) +# +# --- commande IMPR_RESU --- +# + if IMPRESSION!=None: + mcfresu =[] + motscles={} + motsclei={} + if IMPRESSION['FORMAT'] in ('IDEAS','CASTEM') : + ncham =[] + if IMPRESSION['NOM_CHAM']!=None : + if type(IMPRESSION['NOM_CHAM']) in (types.TupleType,types.ListType) : ncham= IMPRESSION['NOM_CHAM'] + else : ncham=[IMPRESSION['NOM_CHAM'],] + if len(ncham)==3 : motscles['NOM_CHAM' ]=('DEPL','EQUI_ELNO_SIGM') + elif (len(ncham)==1) and (ncham[0][:4]!='TEMP') : + motscles['NOM_CHAM' ]= ncham[0]['NOM_CHAM'] + elif (len(ncham)==2) and (ncham[0][:4]!='TEMP') and (ncham[1][:4]!='TEMP') : + motscles['NOM_CHAM' ]=(ncham[0]['NOM_CHAM'],ncham[1]['NOM_CHAM']) + elif (len(ncham)==2) and (ncham[0][:4]=='TEMP') : + motscles['NOM_CHAM' ]= ncham[1]['NOM_CHAM'] + elif (len(ncham)==2) and (ncham[1][:4]=='TEMP') : + motscles['NOM_CHAM' ]= ncham[0]['NOM_CHAM'] + if IMPRESSION['TOUT_ORDRE']!=None : + motscles['TOUT_ORDRE']= IMPRESSION['TOUT_ORDRE'] + elif IMPRESSION['NUME_ORDRE']!=None : + motscles['NUME_ORDRE']= IMPRESSION['NUME_ORDRE'] + elif IMPRESSION['INST']!=None : + motscles['INST' ]= IMPRESSION['INST'] + if IMPRESSION['FORMAT']=='IDEAS' : + motsclei['VERSION' ]= IMPRESSION['VERSION'] + if IMPRESSION['FORMAT']=='CASTEM' : + motsclei['NIVE_GIBI' ]= IMPRESSION['NIVE_GIBI'] + mcfresu.append(_F(MAILLAGE=MAILLAGE,RESULTAT=nomres,**motscles)) + if ECHANGE!=None: + motscles={} + if IMPRESSION['FORMAT'] in ('IDEAS','CASTEM') : + if len(ncham)==3 : motscles['NOM_CHAM' ]=('TEMP',) + elif (len(ncham)==1) and (ncham[0][:4]=='TEMP') : + motscles['NOM_CHAM' ]= ncham[0]['NOM_CHAM'] + elif (len(ncham)==2) and (ncham[0][:4]=='TEMP') : + motscles['NOM_CHAM' ]= ncham[0]['NOM_CHAM'] + elif (len(ncham)==2) and (ncham[1][:4]=='TEMP') : + motscles['NOM_CHAM' ]= ncham[1]['NOM_CHAM'] + if IMPRESSION['TOUT_ORDRE']!=None : + motscles['TOUT_ORDRE']= IMPRESSION['TOUT_ORDRE'] + elif IMPRESSION['NUME_ORDRE']!=None : + motscles['NUME_ORDRE']= IMPRESSION['NUME_ORDRE'] + elif IMPRESSION['INST']!=None : + motscles['INST' ]= IMPRESSION['INST'] + if IMPRESSION['FORMAT']=='IDEAS' : + motsclei['VERSION' ]= IMPRESSION['VERSION'] + if IMPRESSION['FORMAT']=='CASTEM' : + motsclei['NIVE_GIBI' ]= IMPRESSION['NIVE_GIBI'] + mcfresu.append(_F(RESULTAT=nomres,**motscles)) + IMPR_RESU( MODELE = modele, + RESU = mcfresu, + FORMAT=IMPRESSION['FORMAT'],**motsclei) +# + return ier diff --git a/Aster/Cata/cataSTA81/Macro/macr_aspic_mail_ops.py b/Aster/Cata/cataSTA81/Macro/macr_aspic_mail_ops.py new file mode 100644 index 00000000..11af02c8 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_aspic_mail_ops.py @@ -0,0 +1,910 @@ +#@ MODIF macr_aspic_mail_ops Macro DATE 19/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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 math import sqrt,cos,sin,pi,pow,tan + +# Ecriture du fichier GIBI principal (dgib) - ASPID0 +def write_file_dgib_ASPID0(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H, + ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, THETA, TYPELE, + ITYPSO, DPENE, NIVMAG, loc_datg) : + + import aster +# Ouverture du fichier d'entrée de commandes + fdgib=open(nomFichierDATG,'w') + POIVIR = ' ; \n' + texte='****************************************************************\n' + texte=texte+'opti echo 0 ; \n' + texte=texte+'epT1 = '+str(EPT1) +POIVIR + texte=texte+'DeT1 = '+str(DET1) +POIVIR + texte=texte+'d1 = '+str(D1) +POIVIR + texte=texte+'d2 = '+str(D2) +POIVIR + texte=texte+'epT2 = '+str(EPT2) +POIVIR + texte=texte+'DeT2 = '+str(DET2) +POIVIR + texte=texte+'Zmax = '+str(ZMAX) +POIVIR + texte=texte+'type_s = '+str(ITYPSO) +POIVIR + texte=texte+'d_pene = '+str(DPENE) +POIVIR + texte=texte+'h = '+str(H) +POIVIR + texte=texte+'angl_s = '+str(ALPHA) +POIVIR + texte=texte+'jeu = '+str(JEU) +POIVIR + texte=texte+'epC = '+str(EPC) +POIVIR + texte=texte+'DeC = '+str(DEC) +POIVIR + texte=texte+'Xmax = '+str(XMAX) +POIVIR + texte=texte+'typmai = MOT '+TYPMAI +POIVIR + texte=texte+'theta = '+str(THETA) +POIVIR + texte=texte+'typele = MOT '+TYPELE +POIVIR + texte=texte+'typ_eque = MOT '+'SAINE' +POIVIR + texte=texte+'nivmag = '+str(NIVMAG) +POIVIR + texte=texte+'* \n' + texte=texte+'opti donn ' + texte=texte+"'"+loc_datg+'aspic.datg'+"';\n" + aster.affiche('MESSAGE',texte) + fdgib.write(texte) + fdgib.close() + +# Ecriture du fichier GIBI principal (dgib) - ASPID1 +def write_file_dgib_ASPID1(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H, + ALPHA, JEU, EPC, DEC, XMAX, TYPMAI,THETA, + A,C,EPS, RC0, NS,NC,NT,POSI, NDT,FETIRF,FETIRP, + TFISS,ZETA,ITYPSO,DPENE, NIVMAG, loc_datg) : + + import aster +# Ouverture du fichier d'entrée de commandes + fdgib=open(nomFichierDATG,'w') + POIVIR = ' ; \n' + texte='****************************************************************\n' + texte=texte+'opti echo 0 ; \n' + texte=texte+'epT1 = '+str(EPT1) +POIVIR + texte=texte+'DeT1 = '+str(DET1) +POIVIR + texte=texte+'d1 = '+str(D1) +POIVIR + texte=texte+'d2 = '+str(D2) +POIVIR + texte=texte+'epT2 = '+str(EPT2) +POIVIR + texte=texte+'DeT2 = '+str(DET2) +POIVIR + texte=texte+'Zmax = '+str(ZMAX) +POIVIR + texte=texte+'type_s = '+str(ITYPSO) +POIVIR + texte=texte+'d_pene = '+str(DPENE) +POIVIR + texte=texte+'h = '+str(H) +POIVIR + texte=texte+'angl_s = '+str(ALPHA) +POIVIR + texte=texte+'jeu = '+str(JEU) +POIVIR + texte=texte+'epC = '+str(EPC) +POIVIR + texte=texte+'DeC = '+str(DEC) +POIVIR + texte=texte+'Xmax = '+str(XMAX) +POIVIR + texte=texte+'typmai = MOT '+TYPMAI +POIVIR + texte=texte+'theta = '+str(THETA) +POIVIR + texte=texte+'a = '+str(A) +POIVIR + texte=texte+'c = '+str(C) +POIVIR + texte=texte+'zeta = '+str(ZETA) +POIVIR + texte=texte+'eps = '+str(EPS) +POIVIR + texte=texte+'rc0 = '+str(RC0) +POIVIR + texte=texte+'ns = '+str(NS) +POIVIR + texte=texte+'nc = '+str(NC) +POIVIR + texte=texte+'nt = '+str(NT) +POIVIR + texte=texte+'dir_fiss = MOT '+POSI +POIVIR + texte=texte+'pos_fiss = MOT '+TFISS +POIVIR + texte=texte+'ndt = '+str(NDT) +POIVIR + texte=texte+'f_etir_f = '+str(FETIRF) +POIVIR + texte=texte+'f_etir_p = '+str(FETIRP) +POIVIR + texte=texte+'typ_eque = MOT '+'FISS_LON' +POIVIR + texte=texte+'nivmag = '+str(NIVMAG) +POIVIR + texte=texte+'* \n' + texte=texte+'opti donn ' + texte=texte+"'"+loc_datg+'aspic_v2.datg'+"';\n" + aster.affiche('MESSAGE',texte) + fdgib.write(texte) + fdgib.close() + +# Ecriture du fichier GIBI principal (dgib) - ASPID2 +def write_file_dgib_ASPID2(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, + H, ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, + THETA, A, C, EPS, RC0, RC1, RC2, RC3, + ALP,BETA, NS, NC, NT, POSI ,NDT,NSDT,TFISS, + ZETA,ITYPSO,DPENE, NIVMAG, loc_datg) : +# + import aster + CALPHA = cos(ALPHA*pi/180.) + SALPHA = sin(ALPHA*pi/180.) + CTHETA = cos(THETA*pi/180.) + STHETA = sin(THETA*pi/180.) +# + AOLD = A +# + if (ITYPSO == 1) : +# PIQUAGE TYPE 1 + if (POSI == 'DROIT') : +# PIQUAGE DROIT + if (TFISS == 'DEB_INT') : +# POSITION INTERNE + SGAMMA = STHETA * (DET1/2.0)/( (DEC/2.0) -EPC) + SGAMME = STHETA * (DET1/2.0)/( (DEC/2.0) ) + RAPPA = sqrt(1.0 - pow(SGAMMA,2)) + RAPPE = sqrt(1.0 - pow(SGAMME,2)) + AP = A - (1.0 - RAPPA)*A + RAPP = (AP/EPC*RAPPE) + (1.0-(AP/EPC))*RAPPA + XA = (DET1/2.0) * CTHETA + YA = (DET1/2.0) * STHETA + ZA = ((DEC/2.0) -EPC) * sqrt(1.0 - pow(SGAMMA,2)) + ZA0 = (DEC/2.0) - EPC + XA0 = DET1/2.0 + XN0 = XA0 + YN0 = 0.0 + ZN0 = ZA0 + A + XN = XN0 * CTHETA + YN = XN0 * STHETA + SGAMN = YN / ZN0 + ZN = ZN0 * sqrt(1.0 - (SGAMN*SGAMN)) + D0N0 = sqrt( pow((XA0 - XN0),2) + pow((ZA0 - ZN0),2) ) + DN = sqrt( pow((XA - XN),2) + pow((YA - YN),2) + pow((ZA - ZN),2) ) + RAPP = D0N0 / DN + ECART = (1.0 - RAPP) * D0N0 + A = A - ECART + elif (TFISS == 'DEB_EXT') : +# POSITION EXTERNE + SGAMME = STHETA * (DET1/2.0)/ (DEC/2.0) + RAPPE = sqrt(1.0 - pow(SGAMME,2)) + A = A -(1.0 - RAPPE)*A + + elif (POSI == 'INCLINE') : +# PIQUAGE INCLINE + SGAMMA = STHETA * (DET1/2.0)/ ( (DEC/2.0) -EPC) + XA = (DET1/2.0) * CTHETA + YA = (DET1/2.0) * STHETA + ZA = ((DEC/2.0) - EPC) * sqrt(1.0 - pow(SGAMMA,2)) + ZA0 = (DEC/2.0) - EPC + ZD0 = DEC/2.0 + XA0 = DET1/2.0 + XD0 = XA0 + (tan(ALPHA*pi/180.0) * EPC) + A0D0 = sqrt( pow((ZD0 - ZA0),2) + pow((XD0 - XA0),2) ) + EPSIL = STHETA * tan(ALPHA*pi/180.0) + PHI = (EPSIL * ZA) - YA + DELTA = pow(PHI,2) - ((1 + pow(EPSIL,2))*(pow(PHI,2) - (pow((DEC/2.0),2)*pow(EPSIL,2)))) + if (STHETA > 0) : + YD = ( sqrt(DELTA) - PHI) / (1.0 + pow(EPSIL,2)) + else : + YD = ( -1.0*sqrt(DELTA) - PHI) / (1.0 + pow(EPSIL,2)) + + ZD = sqrt(pow((DEC/2.0),2) - pow(YD,2)) + + if ( (abs(THETA - 0.0) < 1.e-3) or ((abs(THETA - 180.0)) < 1.e-3) ) : + XD = CTHETA * XD0 + else : + XD = YD / tan(THETA*pi/180.0) + + AD = sqrt( pow((XA - XD),2) + pow((YA - YD),2) + pow((ZA - ZD),2) ) + RAPP = A0D0 / AD + + if (TFISS == 'DEB_EXT') : + XN0 = XD0 - A*SALPHA + YN0 = 0.0 + ZN0 = ZD0 - A*CALPHA + XN = XN0 * CTHETA + YN = XN0 * STHETA + DNXY = sqrt(pow(XD,2) + pow(YD,2)) - sqrt(pow(XN,2) + pow(YN,2)) + DNXY0 = XD0 - XN0 + RAPP = DNXY/DNXY0 + # Correction necessaire dans le cas theta et/ou alpha grand + if (RAPP < 0.5) : + DXY = sqrt(pow(XD,2) + pow(YD,2) ) + XN = XN * DXY/XD0 + YN = YN * DXY/XD0 + SGAMN = YN / ZN0 + ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2)) + D0N0 = sqrt( pow((XD0 - XN0),2) + pow((ZD0 - ZN0),2) ) + DN = sqrt( pow((XD - XN),2) + pow((YD - YN),2) + pow((ZD - ZN),2) ) + RAPP = D0N0 / DN + ECART = (RAPP - 1.0) * D0N0 + A = A + ECART + + if (TFISS == 'DEB_INT') : + XN0 = XA0 + A*SALPHA + YN0 = 0.0 + ZN0 = ZA0 + A*CALPHA + XN = XN0 * CTHETA + YN = XN0 * STHETA + SGAMN = YN / ZN0 + ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2)) + D0N0 = sqrt( pow((XA0 - XN0),2) + pow((ZA0 - ZN0),2) ) + DN = sqrt( pow((XA - XN),2) + pow((YA - YN),2) + pow((ZA - ZN),2) ) + RAPP = D0N0 / DN + ECART = (RAPP - 1.0) * D0N0 + A = A + ECART + + elif (ITYPSO == 2) : +# PIQUAGE TYPE 2 + if (POSI == 'DROIT') : +# PIQUAGE DROIT + SGAMMI = STHETA * ((DET1/2.0) - EPT1)/(DEC/2.0) + XI = ((DET1/2.0) - EPT1) * CTHETA + YI = ((DET1/2.0) - EPT1) * STHETA + ZI = (DEC/2.0) * sqrt(1.0 - pow(SGAMMI,2)) + XI0 = (DET1/2.0) -EPT1 + YI0 = 0.0 + ZI0 = (DEC/2.0) + + SGAMMA = STHETA * (DET1/2.0)/((DEC/2.0) -EPC) + YA = (DET1/2.0) * STHETA + ZA = ((DEC/2.0) - EPC) * sqrt(1.0 - pow(SGAMMA,2)) + TGALP = H / EPC + EPSIL = STHETA * TGALP + PHI = (EPSIL * ZA) - YA + DELTA = pow(PHI,2) - (1.0 + pow(EPSIL,2))*(pow(PHI,2) - pow((DEC/2.0),2)*pow(EPSIL,2)) + if (STHETA > 0) : + YD = (sqrt(DELTA) - PHI) / (1.0 + pow(EPSIL,2)) + else : + YD = (-1.0*sqrt(DELTA) - PHI) / (1.0 + pow(EPSIL,2)) + + ZD = sqrt( pow((DEC/2.0),2) - pow(YD,2) ) + if ( (abs(THETA - 0.0) < 1.0e-3) or + (abs(THETA - 180.0) < 1.0e-3) or + (abs(THETA + 180.0) < 1.0e-3) or + (abs(THETA + 90.0) < 1.0e-3) or + (abs(THETA - 90.0) < 1.0e-3) ) : + XD = CTHETA * ((DET1/2.0) + H) + else : + XD = YD / (tan(THETA*pi/180.0)) + + XD0 = (DET1/2.0) + H + YD0 = 0.0 + ZD0 = (DEC/2.0) + + if (TFISS == 'DEB_EXT') : + XN0 = XD0 - A + YN0 = 0.0 + ZN0 = ZI0 + XN = XN0 * CTHETA + YN = XN0 * STHETA + DZID = abs(ZI - ZD) + DXYID = sqrt( pow((XD - XI),2) + pow((YD - YI),2) ) + DXYIN = sqrt( pow((XN - XI),2) + pow((YN - YI),2) ) + DZIN = (DXYIN * DZID) / DXYID + ZN = ZI - DZIN + D0N0 = sqrt( pow((XD0 - XN0),2) + pow((ZD0 - ZN0),2) ) + DN = sqrt( pow((XD - XN),2) + pow((YD - YN),2) + pow((ZD - ZN),2) ) + RAPP = D0N0 / DN + ECART = DN - D0N0 + A = A - ECART + + if (TFISS == 'DEB_INT') : + XN0 = XI0 + A + YN0 = 0.0 + ZN0 = ZI0 + XN = XN0 * CTHETA + YN = XN0 * STHETA + SGAMN = YN / ZN0 + ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2)) + I0N0 = sqrt( pow((XI0 - XN0),2) + pow((ZI0 - ZN0),2) ) + IN = sqrt( pow((XI - XN),2) + pow((YI - YN),2) + pow((ZI - ZN),2) ) + RAPP = I0N0 / IN + ECART = I0N0 * ( 1.0 - RAPP ) + A = A - ECART + + elif (POSI == 'INCLINE') : +# PIQUAGE INCLINE + TGALPHA = SALPHA/CALPHA + REPB = (DEC/2.0) + JEU + (EPT1*TGALPHA) + SGAMB = (STHETA * DET1/2.0 ) / REPB + CGAMB = sqrt(1.0 - pow(SGAMB,2)) + XB = (DET1/2.0) * CTHETA + YB = (DET1/2.0) * STHETA + ZB = ( (DEC/2.0) + JEU + (EPT1*TGALPHA) ) * CGAMB + XB0 = (DET1/2.0) + YB0 = 0.0 + ZB0 = (DEC/2.0) + JEU + (EPT1*TGALPHA) +# + RIT1 = (DET1/2.0) - EPT1 + REPG = (DEC/2.0) + JEU + SGAMG = ((STHETA ) * RIT1) / REPG + CGAMG = sqrt(1.0 - pow(SGAMG,2)) + XG = RIT1 * CTHETA + YG = RIT1 * STHETA + ZG = ((DEC/2.0) + JEU) * CGAMG + XG0 = RIT1 + YG0 = 0.0 + ZG0 = (DEC/2.0) + JEU +# + if (TFISS == 'DEB_INT') : + XN0 = XG0 + A*CALPHA + YN0 = 0.0 + ZN0 = ZG0 + A*SALPHA + XN = XN0 * CTHETA + YN = XN0 * STHETA + SGAMN = YN / ZN0 + ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2)) + G0N0 = sqrt( pow((XG0 - XN0),2) + pow((ZG0 - ZN0),2) ) + GN = sqrt( pow((XG - XN),2) + pow((YG - YN),2) + pow((ZG - ZN),2) ) + RAPP = G0N0 / GN + ECART = (RAPP - 1.0) * G0N0 + A = A + ECART + + if (TFISS == 'DEB_EXT') : + XN0 = XB0 - A*CALPHA + YN0 = 0.0 + ZN0 = ZB0 - A*SALPHA + XN = XN0 * CTHETA + YN = XN0 * STHETA + SGAMN = YN / ZN0 + ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2)) + B0N0 = sqrt( pow((XB0 - XN0),2) + pow((ZB0 - ZN0),2) ) + BN = sqrt( pow((XB - XN),2) + pow((YB - YN),2) + pow((ZB - ZN),2) ) + RAPP = B0N0 / BN + ECART = (RAPP - 1.0) * B0N0 + A = A + ECART + + message= ' CORRECTION PROFONDEUR DEFAUT \n' + message=message+ ' PROFONDEUR SUR PIQUAGE : %.2f \n'%AOLD + message=message+ ' PROFONDEUR SUR EQUERRE : %.2f \n'%A + aster.affiche('MESSAGE',message) + +# Ouverture du fichier d'entrée de commandes + + fdgib=open(nomFichierDATG,'w') + POIVIR = ' ; \n' + texte='****************************************************************\n' + texte=texte+'opti echo 0 ; \n' + texte=texte+'epT1 = '+str(EPT1) +POIVIR + texte=texte+'DeT1 = '+str(DET1) +POIVIR + texte=texte+'d1 = '+str(D1) +POIVIR + texte=texte+'d2 = '+str(D2) +POIVIR + texte=texte+'epT2 = '+str(EPT2) +POIVIR + texte=texte+'DeT2 = '+str(DET2) +POIVIR + texte=texte+'Zmax = '+str(ZMAX) +POIVIR + texte=texte+'type_s = '+str(ITYPSO) +POIVIR + texte=texte+'d_pene = '+str(DPENE) +POIVIR + texte=texte+'h = '+str(H) +POIVIR + texte=texte+'angl_s = '+str(ALPHA) +POIVIR + texte=texte+'jeu = '+str(JEU) +POIVIR + texte=texte+'epC = '+str(EPC) +POIVIR + texte=texte+'DeC = '+str(DEC) +POIVIR + texte=texte+'Xmax = '+str(XMAX) +POIVIR + texte=texte+'typmai = MOT '+TYPMAI +POIVIR + texte=texte+'theta = '+str(THETA) +POIVIR + texte=texte+'a = '+str(A) +POIVIR + texte=texte+'c = '+str(C) +POIVIR + texte=texte+'zeta = '+str(ZETA) +POIVIR + texte=texte+'eps = '+str(EPS) +POIVIR + texte=texte+'rc0 = '+str(RC0) +POIVIR + texte=texte+'rc1 = '+str(RC1) +POIVIR + texte=texte+'rc2 = '+str(RC2) +POIVIR + texte=texte+'rc3 = '+str(RC3) +POIVIR + texte=texte+'alpha = '+str(ALP) +POIVIR + texte=texte+'beta = '+str(BETA) +POIVIR + texte=texte+'ns = '+str(NS) +POIVIR + texte=texte+'nc = '+str(NC) +POIVIR + texte=texte+'nt = '+str(NT) +POIVIR + texte=texte+'dir_fiss = MOT '+POSI +POIVIR + texte=texte+'pos_fiss = MOT '+TFISS +POIVIR + texte=texte+'ndt = '+str(NDT) +POIVIR + texte=texte+'nsdt = '+str(NSDT) +POIVIR + texte=texte+'typ_eque = MOT '+'FISS_COU' +POIVIR + texte=texte+'nivmag = '+str(NIVMAG) +POIVIR + texte=texte+'* \n' + texte=texte+'list epc ;\n' + texte=texte+'opti donn ' + texte=texte+"'"+loc_datg+'aspic.datg'+"';\n" + aster.affiche('MESSAGE',texte) + fdgib.write(texte) + fdgib.close() + +def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, + SOUDURE,CORPS,FISS_SOUDURE,IMPRESSION,INFO, + **args): + """ + Ecriture de la macro MACR_ASPIC_MAIL + """ + from Accas import _F + import types + import aster + from Utilitai.Utmess import UTMESS + ier=0 + +# On importe les definitions des commandes a utiliser dans la macro + EXEC_LOGICIEL =self.get_cmd('EXEC_LOGICIEL') + PRE_GIBI =self.get_cmd('PRE_GIBI') + LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE') + DEFI_GROUP =self.get_cmd('DEFI_GROUP') + MODI_MAILLAGE =self.get_cmd('MODI_MAILLAGE') + AFFE_MODELE =self.get_cmd('AFFE_MODELE') + CREA_MAILLAGE =self.get_cmd('CREA_MAILLAGE') + IMPR_RESU =self.get_cmd('IMPR_RESU') + +# La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + TYPELE = TYPE_ELEM + NIVMAG = EXEC_MAILLAGE['NIVE_GIBI'] +# +# --- raffinement maillage --- +# + TYPMAI = RAFF_MAIL + GROS = (TYPMAI=='GROS') + if GROS : NBAZIT = 40 + else : NBAZIT = 48 +# +# --- caracteristiques de la tubulure --- +# + EPT1 = TUBULURE['E_BASE' ] + DET1 = TUBULURE['DEXT_BASE'] + D1 = TUBULURE['L_BASE' ] + D2 = TUBULURE['L_CHANF' ] + EPT2 = TUBULURE['E_TUBU' ] + DET2 = TUBULURE['DEXT_TUBU'] + ZMAX = TUBULURE['Z_MAX' ] + TYPSOU= TUBULURE['TYPE' ] + DPENE = TUBULURE['L_PENETR' ] + if TYPSOU=='TYPE_2' and DPENE>0.0 : + UTMESS('F', "MACR_ASPIC_MAIL", "les piquages penetrants sont autorises uniquement avec les soudures de type 1") + if TYPSOU=='TYPE_2' : + ITYPSO = 2 + else : + ITYPSO = 1 +# +# --- caracteristiques de la soudure --- +# + H = SOUDURE['H_SOUD' ] + ALPHA = SOUDURE['ANGL_SOUD'] + JEU = SOUDURE['JEU_SOUD' ] +# +# --- caracteristiques du corps --- +# + EPC = CORPS ['E_CORP' ] + DEC = CORPS ['DEXT_CORP'] + XMAX = CORPS ['X_MAX' ] + EPSI = 1.E-03 + RMB = ( DET1 - EPT1 ) / 2.0 + VAL1 = 1.5 * sqrt( RMB**3 / EPT1 ) + VAL3 = 3.0 * sqrt( RMB * EPT1 ) + RMT = ( DET2 - EPT2 ) / 2.0 + VAL2 = 1.5 * sqrt( RMT**3 / EPT2 ) + VAL4 = 3.0 * sqrt( RMT * EPT2 ) + LZMAX = max ( VAL1 , VAL2, VAL3, VAL4 ) + ZMAXC = LZMAX + ( DEC/2.0 ) + D1 + D2 + LOK = ( abs(ZMAX-ZMAXC) <= EPSI * abs(ZMAXC) ) + if not LOK : + message= ' erreur donnees \n' + message=message+ ' Z_MAX FOURNIE : %.2f \n'%ZMAX + message=message+ ' Z_MAX CALCULEE : %.2f \n'%ZMAXC + UTMESS('F', "MACR_ASPIC_MAIL", message) + RMC = ( DEC - EPC ) / 2.0 + VAL1 = 1.5 * sqrt( RMC**3 / EPC ) + VAL2 = 3.0 * sqrt( RMC * EPC ) + LXMAX = max( VAL1 , VAL2 ) + XMAXC = LXMAX + ( DET1 / 2.0 ) + LOK = ( abs(XMAX-XMAXC) <= EPSI * abs(XMAXC) ) + if not LOK : + message= ' erreur donnees \n' + message=message+ ' Z_MAX FOURNIE : %.2f \n'%ZMAX + message=message+ ' Z_MAX CALCULEE : %.2f \n'%ZMAXC + UTMESS('F', "MACR_ASPIC_MAIL", message) + message= ' MACR_ASPIC_MAIL / X_MAX CALCULEE : %.2f \n'%XMAX + message=message+ ' MACR_ASPIC_MAIL / Z_MAX CALCULEE : %.2f \n'%XMAXC + aster.affiche('MESSAGE',message) +# +# --- caracteristiques de la fissure --- +# + SAIN = 0 + FISLON = 0 + FISCOU = 0 + THETA = 0.0 + TFISS = None + if FISS_SOUDURE==None : + SAIN = 1 + else : + if FISS_SOUDURE['TYPE']=='LONGUE' : FISLON = 1 + elif FISS_SOUDURE['TYPE']=='COURTE' : FISCOU = 1 + THETA = FISS_SOUDURE['AZIMUT' ] + EPS = FISS_SOUDURE['ANGL_OUVERTURE'] + AXIS = FISS_SOUDURE['AXIS' ] + POSI = FISS_SOUDURE['POSITION' ] + TFISS = FISS_SOUDURE['FISSURE' ] + A = FISS_SOUDURE['PROFONDEUR' ] + if FISS_SOUDURE['LONGUEUR' ]!=None : + C = FISS_SOUDURE['LONGUEUR' ] + N1 = 1 + else : N1 = 0 + if (TFISS=='DEB_INT') and (POSI=='INCLINE') and (DPENE>0.0) and (JEU>0.0) : + message= ' erreur donnees \n' + message=message+ ' dans le cas de fissures \n' + message=message+ ' inclinees debouchant en peau interne avec \n' + message=message+ ' piquage penetrant le jeu doit etre nul \n' + UTMESS('F', "MACR_ASPIC_MAIL", message) + ZETA = 0.5 + if TFISS not in ('DEB_INT','DEB_EXT') : + if FISS_SOUDURE['LIGA_INT']==None : + message= ' erreur donnees \n' + message=message+ ' dans le cas de fissures internes\n' + message=message+ ' (NON_DEB) le ligament inferieur est obligatoire \n' + UTMESS('F', "MACR_ASPIC_MAIL", message) + LIGA = FISS_SOUDURE['LIGA_INT'] + if POSI=='DROIT' : + if ITYPSO==1 : ZETA = (A+LIGA)/(EPC+H) + else : ZETA = (A+LIGA)/(EPT1+H) + else : + if ITYPSO==1 : ZETA = (A+LIGA)*cos(ALPHA*pi/180.0)/EPC + else : ZETA = (A+LIGA)*cos(ALPHA*pi/180.0)/EPT1 + if ZETA < 0.1 : + UTMESS('F', "MACR_ASPIC_MAIL", "dans le cas de fissures internes (NON_DEB) le ligament est trop petit ") + if ZETA > 0.9 : + UTMESS('F', "MACR_ASPIC_MAIL", "dans le cas de fissures internes (NON_DEB) le ligament est trop grand ") + if LIGA < 0.1*EPC : + UTMESS('F', "MACR_ASPIC_MAIL", "dans le cas de fissures internes (NON_DEB) le ligament est trop petit ") + if (LIGA + 2.0*A) > 0.9*EPC : + UTMESS('F', "MACR_ASPIC_MAIL", "dans le cas de fissures internes (NON_DEB) le ligament est trop grand ") + if N1==0 : + if FISCOU : + UTMESS('F', "MACR_ASPIC_MAIL", "dans le cas de fissures courte il faut preciser la longueur") + if AXIS=='NON' : + UTMESS('F', "MACR_ASPIC_MAIL", "dans le cas de la fissure longue il faut preciser la longueur ou axis=oui ") + C = 0.0 + else : + if AXIS=='OUI' : UTMESS('A', "MACR_ASPIC_MAIL", "fissure axisymetrique : le mot clef ne doit pas etre renseigne") + C = 0.5 * C + LEQU=2.*(pi*(DEC-EPC)-DET1+2.*EPT1) +# +# LPIQ est une valeur qui depend theoriquement de la fissure. la valeur +# ci-dessous est approchee car elle ne sert qu'a calculer les facteurs d'etirement +# + LPIQ=pi*(DET1) + if AXIS=='OUI' : C=100.0*LPIQ + RAPL=LEQU/LPIQ + if FISCOU : + RAP=A/C + CAS1=RAP<0.3499 + CAS3=RAP>0.4999 + CAS2= not (CAS1 or CAS3) + if CAS1 : ALP=0.8 + if CAS2 : ALP=0.4 + if CAS3 : ALP=0.0 + BETA=1.0 + if GROS and not CAS1 : + NDT=1 + NSDT=2 + else : + NDT=2 + NSDT=4 +# + if FISLON : + if GROS : + NDT=2 + FETIRF=30.*RAPL + FETIRP=60.*RAPL + else : + NDT=3 + FETIRF=15.*RAPL + FETIRP=30.*RAPL +# + RC0 = FISS_SOUDURE['RAYON_TORE'] + if (FISCOU and RC0==None) : + if GROS : RC0=0.12 + else : RC0=0.10 + if CAS1 : RC0=0.08 + RC0=RC0*A + if (FISLON and RC0==None) : RC0=A/(NDT+1) +# + RC1 = FISS_SOUDURE['COEF_MULT_RC1'] + if (FISCOU and RC1==None) : + if GROS : RC1=1.2 + else : RC1=1.0 +# + RC2 = FISS_SOUDURE['COEF_MULT_RC2'] + if (FISCOU and RC2==None) : + if GROS : RC2=1.4 + else : RC2=1.2 +# + RC3 = FISS_SOUDURE['COEF_MULT_RC3'] + if (FISCOU and RC3==None) : + if GROS : + if CAS1 : RC3=2.5 + else : RC3=1.0 # valeur non utilisee + else : + if CAS3 : RC3=2.2 + else : RC3=2.0 +# + NT = FISS_SOUDURE['NB_TRANCHE'] + if (FISCOU and NT==None) : + if GROS : NT = 8 + else : NT = 16 + if CAS1 : NT = NT*2 + if (FISLON and NT==None) : NT=0 +# + NS = FISS_SOUDURE['NB_SECTEUR'] + if (FISCOU and NS==None) : + if GROS : NS = 2 + else : NS = 4 + if (FISLON and NS==None) : + if GROS : NS = 2 + else : NS = 4 +# + NC = FISS_SOUDURE['NB_COURONNE'] + if (FISCOU and NC==None) : + if GROS : NC = 3 + else : NC = 4 + if (FISLON and NC==None) : + if GROS : NC = 3 + else : NC = 4 +# + loc_gibi=aster.repout() + logiel = EXEC_MAILLAGE['LOGICIEL' ] + UNITD = EXEC_MAILLAGE['UNITE_DATG'] + UNITS = EXEC_MAILLAGE['UNITE_MGIB'] + if logiel=='GIBI98' : logiel = loc_gibi+'gibi98' + elif logiel=='GIBI2000': logiel = loc_gibi+'gibi2000' + else : + UTMESS('F', "MACR_ASPIC_MAIL", "seuls gibi98 et gibi2000 sont appelables ") +# +# --- ecriture sur le fichier .datg de la procedure --- +# +# Nom du fichier de commandes pour GIBI + nomFichierDATG = 'fort.'+str(UNITD) +# Nom du fichier de maillage GIBI + nomFichierGIBI = 'fort.'+str(UNITS) + loc_datg = aster.repdex() + if SAIN : write_file_dgib_ASPID0(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H, + ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, THETA, TYPELE, + ITYPSO, DPENE, NIVMAG,loc_datg) + if FISLON : write_file_dgib_ASPID1(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H, + ALPHA, JEU, EPC, DEC, XMAX, TYPMAI,THETA, + A,C,EPS, RC0,NS,NC,NT,POSI, NDT,FETIRF,FETIRP, + TFISS,ZETA,ITYPSO,DPENE, NIVMAG,loc_datg) + if FISCOU : write_file_dgib_ASPID2(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, + H, ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, + THETA, A, C, EPS, RC0, RC1, RC2, RC3, + ALP,BETA, NS, NC, NT, POSI ,NDT,NSDT,TFISS, + ZETA,ITYPSO,DPENE, NIVMAG,loc_datg) +# + EXEC_LOGICIEL( LOGICIEL = logiel , + ARGUMENT = ( _F(NOM_PARA=nomFichierDATG), + _F(NOM_PARA=nomFichierGIBI), ), ) +# + PRE_GIBI() +# + __MAPROV=LIRE_MAILLAGE(INFO=INFO) +# + motscles={} + motscles['CREA_GROUP_MA']=[] + l_CREA_GROUP_NO=[] + if SAIN : + l_CREA_GROUP_NO.append('S_LAT1') + l_CREA_GROUP_NO.append('S_LAT2') + else : + l_CREA_GROUP_NO.append('S_LAT1_C') + l_CREA_GROUP_NO.append('S_LAT2_C') + l_CREA_GROUP_NO.append('S_LAT1_T') + l_CREA_GROUP_NO.append('S_LAT2_T') + if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='LONGUE') : + l_CREA_GROUP_NO.append('PFONDINF') + l_CREA_GROUP_NO.append('PFONDSUP') + else : + l_CREA_GROUP_NO.append('PFONDFIS') + if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='COURTE') : + motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FONDFISS', + NOM = 'MAIL_ORI', + POSITION = 'INIT' )) + if (TFISS[:4]=='DEB_') and (AXIS=='OUI') : + motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FONDFISS', + NOM = 'MAIL_ORI', + POSITION = 'INIT' )) + if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='LONGUE') : + motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FOND_SUP', + NOM = 'MA_ORI_S', + POSITION = 'INIT' )) + motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FOND_INF', + NOM = 'MA_ORI_I', + POSITION = 'INIT' )) + l_CREA_GROUP_NO.append('S_FOND1') + l_CREA_GROUP_NO.append('S_FOND2') + l_CREA_GROUP_NO.append('EQUERRE') + motscles['CREA_GROUP_NO']=_F(GROUP_MA=l_CREA_GROUP_NO) +# + __MAPROV=DEFI_GROUP(reuse =__MAPROV, + MAILLAGE=__MAPROV, + **motscles ) +# + if not SAIN : + motscles={} + motscles['CREA_GROUP_NO']=[] + if not (TFISS=='NON_DEB') : + motscles['CREA_GROUP_NO'].append(_F(GROUP_MA = 'FONDFISS',)) + if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='LONGUE') : + motscles['CREA_GROUP_NO'].append(_F(GROUP_MA = ('FOND_SUP','FOND_INF',),)) + __MAPROV=DEFI_GROUP(reuse =__MAPROV, + MAILLAGE=__MAPROV, + **motscles ) +# + __MAPROV=MODI_MAILLAGE(reuse =__MAPROV, + MAILLAGE=__MAPROV, + EQUE_PIQUA=_F( GROUP_NO = 'EQUERRE' , + E_BASE = EPT1 , + DEXT_BASE = DET1 , + L_BASE = D1 , + L_CHANF = D2 , + TYPE = TYPSOU, + H_SOUD = H , + ANGL_SOUD = ALPHA , + JEU_SOUD = JEU , + E_CORP = EPC , + DEXT_CORP = DEC , + AZIMUT = THETA , + RAFF_MAIL = TYPMAI, + X_MAX = XMAX , ) + ) +# + __MODELE=AFFE_MODELE( MAILLAGE=__MAPROV, + AFFE=_F( GROUP_MA = ('EQUERRE','PEAUINT','EXCORP1','EXCORP2','EXTUBU'), + PHENOMENE = 'MECANIQUE' , + MODELISATION = '3D' , ) + ) +# + motscles={} + if TFISS=='DEB_INT' : + motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU','LEVRTUBU','LEVRCORP'),) + else : + motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU',),) + __MAPROV=MODI_MAILLAGE(reuse =__MAPROV, + MAILLAGE=__MAPROV, + MODELE =__MODELE, + **motscles + ) +# + if SAIN : + __MAPROV=DEFI_GROUP(reuse = __MAPROV, + MAILLAGE = __MAPROV, + CREA_GROUP_NO = _F(GROUP_MA=('NIDXT','NEDXT','NIIXT','NEIXT')) ) +# + for i in range(1,NBAZIT+1): + prec = EPC / 5.0 + __MAPROV=DEFI_GROUP(reuse = __MAPROV, + MAILLAGE = __MAPROV, + CREA_GROUP_NO = ( _F( NOM = 'NID'+str(i) , + GROUP_NO = 'NIDXT' , + NUME_INIT = i , + NUME_FIN = i ,), + _F( NOM = 'NED'+str(i) , + GROUP_NO = 'NEDXT' , + NUME_INIT = i , + NUME_FIN = i ,), + _F( NOM = 'NII'+str(i) , + GROUP_NO = 'NIIXT' , + NUME_INIT = i , + NUME_FIN = i ,), + _F( NOM = 'NEI'+str(i) , + GROUP_NO = 'NEIXT' , + NUME_INIT = i , + NUME_FIN = i ,), + _F( NOM = 'LDN'+str(i) , + GROUP_MA = 'LD' +str(i) ,), + _F( NOM = 'LD' +str(i) , + GROUP_NO = 'LDN'+str(i) , + OPTION = 'SEGM_DROI_ORDO', + PRECISION = prec , + CRITERE = 'ABSOLU' , + GROUP_NO_ORIG = 'NID'+str(i), + GROUP_NO_EXTR = 'NED'+str(i),), + _F( NOM = 'LIN'+str(i) , + GROUP_MA = 'LI' +str(i) ,), + _F( NOM = 'LI' +str(i) , + GROUP_NO = 'LIN'+str(i) , + OPTION = 'SEGM_DROI_ORDO', + PRECISION = prec , + CRITERE = 'ABSOLU' , + GROUP_NO_ORIG = 'NII'+str(i), + GROUP_NO_EXTR = 'NEI'+str(i),),)) +# +# +# --- commande CREA_MAILLAGE --- +# + self.DeclareOut('nomres',self.sd) + nomres=CREA_MAILLAGE( MAILLAGE=__MAPROV, + CREA_POI1 = ( _F( NOM_GROUP_MA = 'P1_CORP ' , + GROUP_NO = 'P1_CORP ' , ), + _F( NOM_GROUP_MA = 'P2_CORP ' , + GROUP_NO = 'P2_CORP ' , ), + _F( NOM_GROUP_MA = 'P_TUBU ' , + GROUP_NO = 'P_TUBU ' , ),) + ) +# + if IMPRESSION!=None: + for impr in IMPRESSION : +# + motscles={} + if impr['FORMAT']=='IDEAS' : motscles['VERSION'] =impr['VERSION'] + if impr['FORMAT']=='CASTEM' : motscles['NIVE_GIBI']=impr['NIVE_GIBI'] + if impr['UNITE']!=None : motscles['UNITE'] =impr['UNITE'] + impr_resu = _F( MAILLAGE = nomres,) +# + IMPR_RESU( RESU = impr_resu, + FORMAT = impr['FORMAT'],**motscles ) +# +# +# --- Verification profondeur fissure (courte débouchante) --- +# + if FISCOU and not (TFISS=='NON_DEB') : + nomres=DEFI_GROUP( reuse=nomres, + MAILLAGE=nomres, + CREA_GROUP_NO=(_F( GROUP_MA = 'LEVRTUBU',), + _F( NOM = 'FONDORDO', + GROUP_MA = 'FONDFISS', + OPTION = 'NOEUD_ORDO',),),); + + nommail=nomres.nom + coord =aster.getvectjev(nommail.ljust(8)+'.COORDO .VALE') + collgrno=aster.getcolljev(nommail.ljust(8)+'.GROUPENO') + + grfo=collgrno['FONDORDO'] + Nbno = len(grfo) + listx = [None]*Nbno + listy = [None]*Nbno + listz = [None]*Nbno + k = 0 + for node in grfo: + listx[k] = coord[3*(node-1)] + listy[k] = coord[3*(node-1)+1] + listz[k] = coord[3*(node-1)+2] + k = k+1 + + XAB = listx[Nbno-1] - listx[0] + YAB = listy[Nbno-1] - listy[0] + ZAB = listz[Nbno-1] - listz[0] + AB = sqrt(XAB*XAB + YAB*YAB +ZAB*ZAB) + d = 0 + for k in range(0,Nbno) : + XAM = listx[k] - listx[0] + YAM = listy[k] - listy[0] + ZAM = listz[k] - listz[0] + Xvect = YAB*ZAM-ZAB*YAM + Yvect = ZAB*XAM-XAB*ZAM + Zvect = XAB*YAM-YAB*XAM + AM = sqrt(Xvect*Xvect+ Yvect*Yvect +Zvect*Zvect) + dk = AM/AB + if dk > d : + XC = listx[k] + YC = listy[k] + ZC = listz[k] + d = max(dk, d) + + grlev=collgrno['LEVRTUBU'] + Nbnol = len(grlev) + listxl = [None]*Nbnol + listyl = [None]*Nbnol + listzl = [None]*Nbnol + k = 0 + for node in grlev: + listxl[k] = coord[3*(node-1)] + listyl[k] = coord[3*(node-1)+1] + listzl[k] = coord[3*(node-1)+2] + k = k+1 + dist = 0 + for k in range(0,Nbnol) : + XAM = listxl[k] - listx[0] + YAM = listyl[k] - listy[0] + ZAM = listzl[k] - listz[0] + Scal = (XAB*XAM + YAB*YAM + ZAB*ZAM)/(AB*AB) + if (abs(Scal) < 0.51) and (abs(Scal) > 0.49) : + Xk = listxl[k] -XC + Yk = listyl[k] -YC + Zk = listzl[k] -ZC + dk = sqrt(Xk**2+ Yk**2 +Zk**2) + dist = max(dk, dist) + + texte=" PROFONDEUR DE LA FISSURE DANS LE MAILLAGE : %.2f \n"%dist + aster.affiche('MESSAGE',texte) +# + return ier + + diff --git a/Aster/Cata/cataSTA81/Macro/macr_cabri_calc_ops.py b/Aster/Cata/cataSTA81/Macro/macr_cabri_calc_ops.py new file mode 100644 index 00000000..a829425f --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_cabri_calc_ops.py @@ -0,0 +1,542 @@ +#@ MODIF macr_cabri_calc_ops Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2003 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, + 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 + + + # 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',),),), + MODELE=modmeca,); + + + + # Affectation des materiaux + if CHAM_MATER != None: + self.DeclareOut('_cham',CHAM_MATER) + 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'], + TEMP_REF = mat['TEMP_REF'],) ) + else: + # Creation de mots-cles pour les AFFE_CHAR_MECA + motscles['AFFE'].append(_F(TOUT='OUI', + MATER = mat['MATER'], + TEMP_REF = mat['TEMP_REF'],) ) + + _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,), + TEMP_INIT=_F(VALE=temp_ini,), + TITRE='CABRI THERMIQUE &DATE &HEURE',); + + ################################################################# + ########## 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']=="DEFO_THER": + self.DeclareOut('cl_me9',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,); + # Deformation thermique + cl_me9=AFFE_CHAR_MECA( MODELE=modmeca, + TEMP_CALCULEE=resuther, + 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=_cham, + 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_me9,), + _F(CHARGE=cl_me10,), + _F(CHARGE=cl_me11,), + ), + SOLVEUR = solveur, + COMP_INCR =_F(RELATION=relation,), + NEWTON = newton, + INCREMENT = increment, + CONVERGENCE = convergence, + TITRE='CABRI THERMOM\xe9CANIQUE &DATE &HEURE',); + else: + resumeca=STAT_NON_LINE(MODELE=modmeca, + CHAM_MATER=_cham, + 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_me9,), + _F(CHARGE=cl_me10,), + _F(CHARGE=cl_me11,), + ), + SOLVEUR = solveur, + COMP_ELAS =_F(RELATION=relation,), + NEWTON = newton, + INCREMENT = increment, + CONVERGENCE = convergence, + TITRE='CABRI THERMOM\xe9CANIQUE &DATE &HEURE',); + + return ier + diff --git a/Aster/Cata/cataSTA81/Macro/macr_cabri_mail_dat.py b/Aster/Cata/cataSTA81/Macro/macr_cabri_mail_dat.py new file mode 100644 index 00000000..7d673257 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_cabri_mail_dat.py @@ -0,0 +1,630 @@ +#@ MODIF macr_cabri_mail_dat Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2003 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/cataSTA81/Macro/macr_cabri_mail_ops.py b/Aster/Cata/cataSTA81/Macro/macr_cabri_mail_ops.py new file mode 100644 index 00000000..92154545 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_cabri_mail_ops.py @@ -0,0 +1,461 @@ +#@ MODIF macr_cabri_mail_ops Macro DATE 07/02/2005 AUTEUR MABBAS M.ABBAS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2003 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=(_F(NOM_PARA=fichier_datg), + _F(NOM_PARA=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 Macro.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/cataSTA81/Macro/macr_cara_poutre_ops.py b/Aster/Cata/cataSTA81/Macro/macr_cara_poutre_ops.py new file mode 100644 index 00000000..73323770 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_cara_poutre_ops.py @@ -0,0 +1,810 @@ +#@ MODIF macr_cara_poutre_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2003 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. +# ====================================================================== +# RESPONSABLE JMBHH01 J.M.PROIX + +def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, + GROUP_MA,ORIG_INER,**args): + """ + Ecriture de la macro MACR_CARA_POUTRE + """ + import types + from Accas import _F + from Utilitai.Utmess import UTMESS + 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 + LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE') + DEFI_GROUP =self.get_cmd('DEFI_GROUP') + CREA_MAILLAGE =self.get_cmd('CREA_MAILLAGE') + AFFE_MODELE =self.get_cmd('AFFE_MODELE') + DEFI_MATERIAU =self.get_cmd('DEFI_MATERIAU') + AFFE_MATERIAU =self.get_cmd('AFFE_MATERIAU') + DEFI_FONCTION =self.get_cmd('DEFI_FONCTION') + DEFI_CONSTANTE =self.get_cmd('DEFI_CONSTANTE') + AFFE_CHAR_THER =self.get_cmd('AFFE_CHAR_THER') + AFFE_CHAR_THER_F=self.get_cmd('AFFE_CHAR_THER_F') + THER_LINEAIRE =self.get_cmd('THER_LINEAIRE') + CALC_VECT_ELEM =self.get_cmd('CALC_VECT_ELEM') + CALC_MATR_ELEM =self.get_cmd('CALC_MATR_ELEM') + NUME_DDL =self.get_cmd('NUME_DDL') + ASSE_VECTEUR =self.get_cmd('ASSE_VECTEUR') + POST_ELEM =self.get_cmd('POST_ELEM') + CALC_ELEM =self.get_cmd('CALC_ELEM') + INTE_MAIL_2D =self.get_cmd('INTE_MAIL_2D') + POST_RELEVE_T =self.get_cmd('POST_RELEVE_T') + IMPR_TABLE =self.get_cmd('IMPR_TABLE') + IMPR_CO =self.get_cmd('IMPR_CO') + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # Le concept sortant (de type tabl_cara_geom) est nommé 'nomres' dans + # le contexte de la macro + + self.DeclareOut('nomres',self.sd) + +# if GROUP_MA_BORD and GROUP_MA: +# if not LIAISON: +# UTMESS('F', "MACR_CARA_POUTRE", "Avec GROUP_MA, il faut obligatoirement preciser LIAISON, LONGUEUR ET MATERIAU") +# + __nomlma=LIRE_MAILLAGE(UNITE=UNITE_MAILLAGE,) + + __nomamo=AFFE_MODELE(MAILLAGE=__nomlma, + AFFE=_F(TOUT='OUI', + PHENOMENE='MECANIQUE', + MODELISATION='D_PLAN',), ) + + __nomdma=DEFI_MATERIAU(ELAS=_F(E=1.0,NU=0.,RHO=1.0),) + + + __nomama=AFFE_MATERIAU(MAILLAGE=__nomlma, + AFFE=_F(TOUT='OUI', + MATER=__nomdma,), ) + +# --- CALCUL DES CARACTERISTIQUES GEOMETRIQUES DE LA SECTION : +# ------------------------------------------------------ + + motsimps={} + if GROUP_MA : motsimps['GROUP_MA'] = GROUP_MA + if SYME_X : motsimps['SYME_X'] = SYME_X + if SYME_Y : motsimps['SYME_Y'] = SYME_Y + motsimps['ORIG_INER'] = ORIG_INER + mfact=_F(TOUT='OUI',**motsimps) + nomres=POST_ELEM(MODELE=__nomamo, + CHAM_MATER=__nomama, + CARA_GEOM=mfact ) + +# nb : si GROUP_MA n existe pas : le mot clé est ignoré + +# +# ================================================================== +# --- = CALCUL DE LA CONSTANTE DE TORSION SUR TOUT LE MAILLAGE = +# --- = OU DU CENTRE DE TORSION/CISAILLEMENT = +# --- = DES COEFFICIENTS DE CISAILLEMENT = +# --- = ET DE L INERTIE DE GAUCHISSEMENT = +# --- = DU RAYON DE TORSION SUR TOUT LE MAILLAGE +# --- = ON CREE UN MODELE PLAN 2D THERMIQUE REPRESENTANT LA SECTION = +# --- = DE LA POUTRE CAR ON A A RESOUDRE DES E.D.P. AVEC DES LAPLACIENS= +# ================================================================== + + if GROUP_MA_BORD and not GROUP_MA: +# --- TRANSFORMATION DES GROUP_MA EN GROUP_NO SUR-LESQUELS +# --- ON POURRA APPLIQUER DES CONDITIONS DE TEMPERATURE IMPOSEE : +# --------------------------------------------------------- + motscles={} + if type(GROUP_MA_BORD)==types.StringType: + motscles['CREA_GROUP_NO']=_F(GROUP_MA=GROUP_MA_BORD,) + else: + motscles['CREA_GROUP_NO']=[] + for grma in GROUP_MA_BORD: + motscles['CREA_GROUP_NO'].append(_F(GROUP_MA=grma,)) + __nomlma=DEFI_GROUP(reuse=__nomlma, + MAILLAGE=__nomlma, + **motscles) + + + +# --- CREATION D UN MAILLAGE IDENTIQUE AU PREMIER A CECI PRES +# --- QUE LES COORDONNEES SONT EXPRIMEES DANS LE REPERE PRINCIPAL +# --- D INERTIE DONT L ORIGINE EST LE CENTRE DE GRAVITE DE LA SECTION : +# --------------------------------------------------------------- + + __nomapi=CREA_MAILLAGE(MAILLAGE=__nomlma, + REPERE=_F(TABLE=nomres, + NOM_ORIG='CDG', ), ) + +# --- AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE +# --- LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE : +# ------------------------------------------------------ + + __nomoth=AFFE_MODELE(MAILLAGE=__nomapi, + AFFE=_F(TOUT='OUI', + PHENOMENE='THERMIQUE', + MODELISATION='PLAN',), ) + +# --- POUR LA CONSTRUCTION DU LAPLACIEN, ON DEFINIT UN +# --- PSEUDO-MATERIAU DONT LES CARACTERISTIQUES THERMIQUES SONT : +# --- LAMBDA = 1, RHO*CP = 0 : +# ---------------------- + + __nomath=DEFI_MATERIAU(THER=_F(LAMBDA=1.0,RHO_CP=0.,),) + +# --- DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT : +# --------------------------------------------------------- + + __chmath=AFFE_MATERIAU(MAILLAGE=__nomapi, + AFFE=_F(TOUT='OUI', + MATER=__nomath,), ) + +# +# ------------------------------------------------------------ +# --- - CALCUL DE LA CONSTANTE DE TORSION PAR RESOLUTION - +# --- - D UN LAPLACIEN AVEC UN TERME SOURCE EGAL A -2 - +# --- - L INCONNUE ETANT NULLE SUR LE CONTOUR DE LA SECTION : - +# --- - LAPLACIEN(PHI) = -2 DANS LA SECTION - +# --- - PHI = 0 SUR LE CONTOUR : - +# ------------------------------------------------------------ +# +# --- ON IMPOSE LA VALEUR 0 A L INCONNUE SCALAIRE SUR LE CONTOUR +# --- DE LA SECTION +# --- ET ON A UN TERME SOURCE EGAL A -2 DANS TOUTE LA SECTION : +# ------------------------------------------------------- + + motscles={} + if args.has_key('GROUP_MA_INTE'): + if args['GROUP_MA_INTE'] != None : + motscles['LIAISON_UNIF']=_F(GROUP_MA=args['GROUP_MA_INTE'],DDL='TEMP'), + __chart1=AFFE_CHAR_THER(MODELE=__nomoth, + TEMP_IMPO =_F(GROUP_NO=GROUP_MA_BORD, + TEMP=0. ), + SOURCE =_F(TOUT='OUI', + SOUR=2.0), + **motscles ) + +# --- POUR CHAQUE TROU DE LA SECTION : +# --- .ON A IMPOSE QUE PHI EST CONSTANT SUR LE CONTOUR INTERIEUR +# --- EN FAISANT LE LIAISON_UNIF DANS LE AFFE_CHAR_THER PRECEDENT +# --- .ON IMPOSE EN PLUS D(PHI)/DN = 2*AIRE(TROU)/L(TROU) +# --- OU D/DN DESIGNE LA DERIVEE PAR RAPPORT A LA +# --- NORMALE ET L DESIGNE LA LONGUEUR DU BORD DU TROU : +# ------------------------------------------------------- + + if args.has_key('GROUP_MA_INTE'): + lgmaint=args['GROUP_MA_INTE'] + if lgmaint != None : + __tbaire=POST_ELEM(MODELE=__nomoth, + AIRE_INTERNE=_F(GROUP_MA_BORD=args['GROUP_MA_INTE'],), ) + + motscles={} + motscles['FLUX_REP']=[] + + if type(lgmaint)==types.StringType: + motscles['FLUX_REP']=_F(GROUP_MA=args['GROUP_MA_INTE'],CARA_TORSION=__tbaire) + else: + motscles['FLUX_REP']=[] + for grma in lgmaint: + motscles['FLUX_REP'].append(_F(GROUP_MA=grma,CARA_TORSION=__tbaire),) + __chart2=AFFE_CHAR_THER(MODELE=__nomoth,**motscles) + +# --- RESOLUTION DE LAPLACIEN(PHI) = -2 +# --- AVEC PHI = 0 SUR LE CONTOUR : +# ---------------------------------------- + + motscles={} + motscles['EXCIT']=[_F(CHARGE=__chart1,),] + if args.has_key('GROUP_MA_INTE'): + if lgmaint != None : + motscles['EXCIT'].append(_F(CHARGE=__chart2,)) + __tempe1=THER_LINEAIRE(MODELE=__nomoth, + CHAM_MATER=__chmath, + SOLVEUR=_F(STOP_SINGULIER='NON',), + **motscles ) + +# +# ---------------------------------------------- +# --- - CALCUL DU CENTRE DE TORSION/CISAILLEMENT - +# --- - ET DES COEFFICIENTS DE CISAILLEMENT : - +# ---------------------------------------------- +# +# --- POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR +# --- UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE +# --- PAR UNE FONCTION EGALE A Y : +# -------------------------- + + __fnsec1=DEFI_FONCTION(NOM_PARA='X', + VALE=(0.,0.,10.,10.), + PROL_DROITE='LINEAIRE', + PROL_GAUCHE='LINEAIRE', + ) + + __fnsec0=DEFI_CONSTANTE(VALE=0.,) + +# --- LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION +# --- DE LAPLACE EST PRIS EGAL A Y DANS TOUTE LA SECTION : +# -------------------------------------------------- + + + motscles={} + if args.has_key('NOEUD'): + motscles['TEMP_IMPO']=(_F(NOEUD=args['NOEUD'],TEMP=__fnsec0)) + __chart2=AFFE_CHAR_THER_F(MODELE=__nomoth, + SOURCE=_F(TOUT='OUI', + SOUR=__fnsec1,), + **motscles ) + +# --- RESOLUTION DE LAPLACIEN(PHI) = -Y +# --- AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : +# ------------------------------------------------ + + __tempe2=THER_LINEAIRE(MODELE=__nomoth, + CHAM_MATER=__chmath, + EXCIT=_F(CHARGE=__chart2,), + SOLVEUR=_F(STOP_SINGULIER='NON',), + ) + +# --- POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR +# --- UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE +# --- PAR UNE FONCTION EGALE A Z : +# -------------------------- + + __fnsec2=DEFI_FONCTION(NOM_PARA='Y', + VALE=(0.,0.,10.,10.), + PROL_DROITE='LINEAIRE', + PROL_GAUCHE='LINEAIRE', + ) + +# --- LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION +# --- DE LAPLACE EST PRIS EGAL A Z DANS TOUTE LA SECTION : +# -------------------------------------------------- + + motscles={} + if args.has_key('NOEUD'): + motscles['TEMP_IMPO']=_F(NOEUD=args['NOEUD'],TEMP=__fnsec0) + __chart3=AFFE_CHAR_THER_F(MODELE=__nomoth, + SOURCE=_F(TOUT='OUI', + SOUR=__fnsec2,), + **motscles) + +# --- RESOLUTION DE LAPLACIEN(PHI) = -Z +# --- AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : +# ------------------------------------------------ + + __tempe3=THER_LINEAIRE(MODELE=__nomoth, + CHAM_MATER=__chmath, + EXCIT=_F(CHARGE=__chart3,), + SOLVEUR=_F(STOP_SINGULIER='NON',), + ) + +# --- CALCUL DU RAYON DE TORSION : +# -------------------------- + +# CALCUL DU RAYON DE TORSION EXTERNE : rtext + + __tempe1=CALC_ELEM(reuse=__tempe1, + RESULTAT=__tempe1, + MODELE=__nomoth, + CHAM_MATER=__chmath, + TOUT_ORDRE='OUI', + OPTION='FLUX_ELNO_TEMP', + ) + + __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, + DEFI_CHEMIN=_F(GROUP_MA=GROUP_MA_BORD), + INFO=2,) + + __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', + CHEMIN=__chem, + RESULTAT=__tempe1, + NOM_CHAM='FLUX_ELNO_TEMP', + TRAC_NOR='OUI', + NOM_CMP=('FLUX','FLUY'), + OPERATION='MOYENNE')) + + __m1=abs(__flun['TRAC_NOR',3]) + __m2=abs(__flun['TRAC_NOR',4]) + __rtext=max(__m1,__m2) + + # CALCUL DU RAYON DE TORSION : rt + # rt = max ( rtext , 2*AIRE(TROU)/L(TROU) ) + + if args.has_key('GROUP_MA_INTE'): + if args['GROUP_MA_INTE'] != None : + if type(args['GROUP_MA_INTE'])==types.StringType : + l_group_ma_inte=[args['GROUP_MA_INTE'],] + else: + l_group_ma_inte=args['GROUP_MA_INTE'] + for i in range(0,len(l_group_ma_inte)): + __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, + DEFI_CHEMIN=_F(GROUP_MA=l_group_ma_inte[i]), + INFO=2,) + __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', + CHEMIN=__chem, + RESULTAT=__tempe1, + NOM_CHAM='FLUX_ELNO_TEMP', + TRAC_NOR='OUI', + NOM_CMP=('FLUX','FLUY'), + OPERATION='MOYENNE')) + __m1=(abs(__flun['TRAC_NOR',3])+abs(__flun['TRAC_NOR',4]))/2. + if __m1 > __rtext : + __rtext=__m1 + + __rt=__rtext + +# --- CALCUL DE LA CONSTANTE DE TORSION : +# --------------------------------- + + motscles={} + if args.has_key('GROUP_MA_INTE'): + lgmaint=args['GROUP_MA_INTE'] + if lgmaint != None : + motscles['CARA_POUTRE']=_F(CARA_GEOM=nomres, + LAPL_PHI=__tempe1, + RT=__rt, + TOUT='OUI', + OPTION='CARA_TORSION', + GROUP_MA_INTE=args['GROUP_MA_INTE'],) + else: + motscles['CARA_POUTRE']=_F(CARA_GEOM=nomres, + LAPL_PHI=__tempe1, + RT=__rt, + TOUT='OUI', + OPTION='CARA_TORSION', ) + nomres=POST_ELEM(reuse=nomres, + MODELE=__nomoth, + CHAM_MATER=__chmath, + **motscles ) + + +# --- CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU +# --- CENTRE DE CISAILLEMENT/TORSION : +# ------------------------------ + + nomres=POST_ELEM(reuse=nomres, + MODELE=__nomoth, + CHAM_MATER=__chmath, + CARA_POUTRE=_F(CARA_GEOM=nomres, + LAPL_PHI_Y=__tempe2, + LAPL_PHI_Z=__tempe3, + TOUT='OUI', + OPTION='CARA_CISAILLEMENT',), ) + + +# +# ------------------------------------------------------------ +# --- - CALCUL DE L INERTIE DE GAUCHISSEMENT PAR RESOLUTION DE - +# --- - LAPLACIEN(OMEGA) = 0 DANS LA SECTION - +# --- - AVEC D(OMEGA)/D(N) = Z*NY-Y*NZ SUR LE - +# --- - CONTOUR DE LA SECTION - +# --- - NY ET NZ SONT LES COMPOSANTES DU VECTEUR N NORMAL - +# --- - A CE CONTOUR - +# --- - ET SOMME_S(OMEGA.DS) = 0 - +# --- - OMEGA EST LA FONCTION DE GAUCHISSEMENT - +# --- - L INERTIE DE GAUCHISSEMENT EST SOMME_S(OMEGA**2.DS) - +# ------------------------------------------------------------ +# +# --- CREATION D UN MAILLAGE DONT LES COORDONNEES SONT EXPRIMEES +# --- DANS LE REPERE PRINCIPAL D INERTIE MAIS AVEC COMME ORIGINE +# --- LE CENTRE DE TORSION DE LA SECTION, ON VA DONC UTILISER +# --- LE MAILLAGE DE NOM NOMAPI DONT LES COORDONNEES SONT +# --- EXPRIMEES DANS LE REPERE PRINCIPAL D'INERTIE, L'ORIGINE +# --- ETANT LE CENTRE DE GRAVITE DE LA SECTION (QUI EST DONC +# --- A CHANGER) : +# ---------- + + __nomapt=CREA_MAILLAGE(MAILLAGE=__nomapi, + REPERE=_F(TABLE=nomres, + NOM_ORIG='TORSION',) ) + +# --- AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE +# --- LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE : +# ------------------------------------------------------ + + __nomot2=AFFE_MODELE(MAILLAGE=__nomapt, + AFFE=_F(TOUT='OUI', + PHENOMENE='THERMIQUE', + MODELISATION='PLAN', ) ) + +# --- DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT : +# --------------------------------------------------------- + + __chmat2=AFFE_MATERIAU(MAILLAGE=__nomapt, + AFFE=_F(TOUT='OUI', + MATER=__nomath, ), ) + +# --- POUR LE CALCUL DE L INERTIE DE GAUCHISSEMENT, ON VA DEFINIR +# --- LA COMPOSANTE SELON Y DU FLUX A IMPOSER SUR LE CONTOUR +# --- PAR UNE FONCTION EGALE A -X : +# --------------------------- + + __fnsec3=DEFI_FONCTION(NOM_PARA='X', + VALE=(0.,0.,10.,-10.), + PROL_DROITE='LINEAIRE', + PROL_GAUCHE='LINEAIRE', + ) + +# --- POUR LE CALCUL DE L INERTIE DE GAUCHISSEMENT, ON VA DEFINIR +# --- LA COMPOSANTE SELON X DU FLUX A IMPOSER SUR LE CONTOUR +# --- PAR UNE FONCTION EGALE A Y : +# -------------------------- + + __fnsec4=DEFI_FONCTION(NOM_PARA='Y', + VALE=(0.,0.,10.,10.), + PROL_DROITE='LINEAIRE', + PROL_GAUCHE='LINEAIRE', + ) + +# --- DANS LE BUT D IMPOSER LA RELATION LINEAIRE ENTRE DDLS +# --- SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION +# --- VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE +# --- N = 0, N ETANT L EFFORT NORMAL) +# --- ON CALCULE LE VECTEUR DE CHARGEMENT DU A UN TERME SOURCE EGAL +# --- A 1., LES TERMES DE CE VECTEUR SONT EGAUX A +# --- SOMME_SECTION(NI.DS) ET SONT DONC LES COEFFICIENTS DE +# --- LA RELATION LINEAIRE A IMPOSER. +# --- ON DEFINIT DONC UN CHARGEMENT DU A UN TERME SOURCE EGAL A 1 : +# ----------------------------------------------------------- + + __chart4=AFFE_CHAR_THER(MODELE=__nomot2, + SOURCE=_F(TOUT='OUI', + SOUR=1.0), ) + +# --- ON CALCULE LE VECT_ELEM DU AU CHARGEMENT PRECEDENT +# --- IL S AGIT DES VECTEURS ELEMENTAIRES DONT LE TERME +# --- AU NOEUD COURANT I EST EGAL A SOMME_SECTION(NI.DS) : +# -------------------------------------------------- + + __vecel=CALC_VECT_ELEM(CHARGE=__chart4, + OPTION='CHAR_THER' + ) + +# --- ON CALCULE LE MATR_ELEM DES MATRICES ELEMENTAIRES +# --- DE CONDUCTIVITE UNIQUEMENT POUR GENERER LE NUME_DDL +# --- SUR-LEQUEL S APPUIERA LE CHAMNO UTILISE POUR ECRIRE LA +# --- RELATION LINEAIRE ENTRE DDLS : +# ---------------------------- + + __matel=CALC_MATR_ELEM(MODELE=__nomot2, + CHAM_MATER=__chmat2, + CHARGE=__chart4, + OPTION='RIGI_THER',) + +# --- ON DEFINIT LE NUME_DDL ASSOCIE AU MATR_ELEM DEFINI +# --- PRECEDEMMENT POUR CONSTRUIRE LE CHAMNO UTILISE POUR ECRIRE LA +# --- RELATION LINEAIRE ENTRE DDLS : +# ---------------------------- + + __numddl=NUME_DDL(MATR_RIGI=__matel, + METHODE='LDLT', ) + +# --- ON CONSTRUIT LE CHAMNO QUI VA ETRE UTILISE POUR ECRIRE LA +# --- RELATION LINEAIRE ENTRE DDLS : +# ---------------------------- + + __chamno=ASSE_VECTEUR(VECT_ELEM=__vecel, + NUME_DDL=__numddl, ) + +# --- ON IMPOSE LA RELATION LINEAIRE ENTRE DDLS +# --- SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION +# --- VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE +# --- N = 0, N ETANT L EFFORT NORMAL) +# --- POUR IMPOSER CETTE RELATION ON PASSE PAR LIAISON_CHAMNO, +# --- LES TERMES DU CHAMNO (I.E. SOMME_SECTION(NI.DS)) +# --- SONT LES COEFFICIENTS DE LA RELATION LINEAIRE : +# --------------------------------------------- + + __chart5=AFFE_CHAR_THER(MODELE=__nomot2, + LIAISON_CHAMNO=_F(CHAM_NO=__chamno, + COEF_IMPO=0.), ) + +# --- LE CHARGEMENT EST UN FLUX REPARTI NORMAL AU CONTOUR +# --- DONT LES COMPOSANTES SONT +Z (I.E. +Y) ET -Y (I.E. -X) +# --- SELON LA DIRECTION NORMALE AU CONTOUR : +# ------------------------------------- + + __chart6=AFFE_CHAR_THER_F(MODELE=__nomot2, + FLUX_REP=_F(GROUP_MA=GROUP_MA_BORD, + FLUX_X =__fnsec4, + FLUX_Y =__fnsec3,), ) + +# --- RESOLUTION DE LAPLACIEN(OMEGA) = 0 +# --- AVEC D(OMEGA)/D(N) = Z*NY-Y*NZ SUR LE CONTOUR DE LA SECTION +# --- ET SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION +# --- VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE +# --- N = 0, N ETANT L EFFORT NORMAL) : +# ------------------------------- + + __tempe4=THER_LINEAIRE(MODELE=__nomot2, + CHAM_MATER=__chmat2, + EXCIT=(_F(CHARGE=__chart5,), + _F(CHARGE=__chart6,),), + SOLVEUR=_F(METHODE='LDLT', + RENUM='SANS', + STOP_SINGULIER='NON',), ) + +# --- CALCUL DE L INERTIE DE GAUCHISSEMENT : +# ------------------------------------- + + nomres=POST_ELEM(reuse=nomres, + MODELE=__nomot2, + CHAM_MATER=__chmat2, + CARA_POUTRE=_F(CARA_GEOM=nomres, + LAPL_PHI=__tempe4, + TOUT='OUI', + OPTION='CARA_GAUCHI'), ) + + +# +# ================================================================== +# --- = CALCUL DE LA CONSTANTE DE TORSION SUR CHAQUE GROUPE = +# --- = ET DU RAYON DE TORSION SUR CHAQUE GROUPE = +# --- = DU CENTRE DE TORSION/CISAILLEMENT = +# --- = DES COEFFICIENTS DE CISAILLEMENT = +# ================================================================== + + +# + + + if GROUP_MA_BORD and GROUP_MA: + + if type(GROUP_MA_BORD)==types.StringType : + l_group_ma_bord=[GROUP_MA_BORD,] + else: + l_group_ma_bord= GROUP_MA_BORD + if type(GROUP_MA)==types.StringType : + l_group_ma=[GROUP_MA,] + else: + l_group_ma= GROUP_MA + + if args.has_key('NOEUD'): + if type(args['NOEUD'])==types.StringType : + l_noeud=[args['NOEUD'],] + else: + l_noeud= args['NOEUD'] + + if len(l_group_ma)!=len(l_group_ma_bord): + UTMESS('F', "MACR_CARA_POUTRE", "GROUP_MA et GROUP_MA_BORD incoherents") + if args.has_key('NOEUD') and (len(l_group_ma)!=len(l_noeud)): + UTMESS('F', "MACR_CARA_POUTRE", "GROUP_MA et NOEUD incoherents") + + for i in range(0,len(l_group_ma_bord)): + +# --- TRANSFORMATION DES GROUP_MA EN GROUP_NO SUR-LESQUELS +# --- ON POURRA APPLIQUER DES CONDITIONS DE TEMPERATURE IMPOSEE : +# --------------------------------------------------------- + + __nomlma=DEFI_GROUP(reuse=__nomlma, + MAILLAGE=__nomlma, + CREA_GROUP_NO=_F(GROUP_MA=l_group_ma_bord[i],) ) + + +# --- CREATION D UN MAILLAGE IDENTIQUE AU PREMIER A CECI PRES +# --- QUE LES COORDONNEES SONT EXPRIMEES DANS LE REPERE PRINCIPAL +# --- D INERTIE DONT L ORIGINE EST LE CENTRE DE GRAVITE DE LA SECTION : +# --------------------------------------------------------------- + + __nomapi=CREA_MAILLAGE(MAILLAGE=__nomlma, + REPERE=_F(TABLE=nomres, + NOM_ORIG='CDG', + GROUP_MA=l_group_ma[i], ), ) + +# --- AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE +# --- LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE : +# ------------------------------------------------------ + + __nomoth=AFFE_MODELE(MAILLAGE=__nomapi, + AFFE=_F(GROUP_MA=l_group_ma[i], + PHENOMENE='THERMIQUE', + MODELISATION='PLAN', ) ) + +# --- POUR LA CONSTRUCTION DU LAPLACIEN, ON DEFINIT UN +# --- PSEUDO-MATERIAU DONT LES CARACTERISTIQUES THERMIQUES SONT : +# --- LAMBDA = 1, RHO*CP = 0 : +# ---------------------- + + __nomath=DEFI_MATERIAU(THER=_F(LAMBDA=1.0, + RHO_CP=0.0, ), ) + +# --- DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT : +# --------------------------------------------------------- + + __chmath=AFFE_MATERIAU(MAILLAGE=__nomapi, + AFFE=_F(TOUT='OUI', + MATER=__nomath ), ) + +# +# ------------------------------------------------------------ +# --- - CALCUL DE LA CONSTANTE DE TORSION PAR RESOLUTION - +# --- - D UN LAPLACIEN AVEC UN TERME SOURCE EGAL A -2 - +# --- - L INCONNUE ETANT NULLE SUR LE CONTOUR DE LA SECTION : - +# --- - LAPLACIEN(PHI) = -2 DANS LA SECTION - +# --- - PHI = 0 SUR LE CONTOUR : - +# ------------------------------------------------------------ +# +# --- ON IMPOSE LA VALEUR 0 A L INCONNUE SCALAIRE SUR LE CONTOUR +# --- DE LA SECTION +# --- ET ON A UN TERME SOURCE EGAL A -2 DANS TOUTE LA SECTION : +# ------------------------------------------------------- + + __chart1=AFFE_CHAR_THER(MODELE=__nomoth, + TEMP_IMPO=_F(GROUP_NO=l_group_ma_bord[i], + TEMP=0.0 ), + SOURCE=_F(TOUT='OUI', + SOUR=2.0 ) ) + +# --- RESOLUTION DE LAPLACIEN(PHI) = -2 +# --- AVEC PHI = 0 SUR LE CONTOUR : +# ---------------------------------------- + + __tempe1=THER_LINEAIRE(MODELE=__nomoth, + CHAM_MATER=__chmath, + EXCIT=_F(CHARGE=__chart1, ), + SOLVEUR=_F(STOP_SINGULIER='NON',) ) + +# +# ---------------------------------------------- +# --- - CALCUL DU CENTRE DE TORSION/CISAILLEMENT - +# --- - ET DES COEFFICIENTS DE CISAILLEMENT : - +# ---------------------------------------------- +# +# --- POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR +# --- UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE +# --- PAR UNE FONCTION EGALE A Y : +# -------------------------- + + __fnsec1=DEFI_FONCTION(NOM_PARA='X', + VALE=(0.,0.,10.,10.), + PROL_DROITE='LINEAIRE', + PROL_GAUCHE='LINEAIRE', ) + + __fnsec0=DEFI_CONSTANTE(VALE=0.,) + +# --- LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION +# --- DE LAPLACE EST PRIS EGAL A Y DANS TOUTE LA SECTION : +# -------------------------------------------------- + + __chart2=AFFE_CHAR_THER_F(MODELE=__nomoth, + TEMP_IMPO=_F(NOEUD=l_noeud[i], + TEMP=__fnsec0), + SOURCE=_F(TOUT='OUI', + SOUR=__fnsec1) ) + +# --- RESOLUTION DE LAPLACIEN(PHI) = -Y +# --- AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : +# ------------------------------------------------ + + __tempe2=THER_LINEAIRE(MODELE=__nomoth, + CHAM_MATER=__chmath, + EXCIT=_F(CHARGE=__chart2, ), + SOLVEUR=_F(STOP_SINGULIER='NON',) ) + +# --- POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR +# --- UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE +# --- PAR UNE FONCTION EGALE A Z : +# -------------------------- + + __fnsec2=DEFI_FONCTION(NOM_PARA='Y', + VALE=(0.,0.,10.,10.), + PROL_DROITE='LINEAIRE', + PROL_GAUCHE='LINEAIRE', ) + +# --- LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION +# --- DE LAPLACE EST PRIS EGAL A Z DANS TOUTE LA SECTION : +# -------------------------------------------------- + + __chart3=AFFE_CHAR_THER_F(MODELE=__nomoth, + TEMP_IMPO=_F(NOEUD=l_noeud[i], + TEMP=__fnsec0), + SOURCE=_F(TOUT='OUI', + SOUR=__fnsec2) ) + +# --- RESOLUTION DE LAPLACIEN(PHI) = -Z +# --- AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : +# ------------------------------------------------ + + __tempe3=THER_LINEAIRE(MODELE=__nomoth, + CHAM_MATER=__chmath, + EXCIT=_F(CHARGE=__chart3, ), + SOLVEUR=_F(STOP_SINGULIER='NON',) ) + +# --- CALCUL DU RAYON DE TORSION : +# -------------------------- + +# CALCUL DU RAYON DE TORSION EXTERNE : rtext + + __tempe1=CALC_ELEM(reuse=__tempe1, + RESULTAT=__tempe1, + MODELE=__nomoth, + CHAM_MATER=__chmath, + TOUT_ORDRE='OUI', + OPTION='FLUX_ELNO_TEMP', + ) + + __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, + DEFI_CHEMIN=_F(GROUP_MA=l_group_ma_bord[i]), + INFO=2,) + + __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', + CHEMIN=__chem, + RESULTAT=__tempe1, + NOM_CHAM='FLUX_ELNO_TEMP', + TRAC_NOR='OUI', + NOM_CMP=('FLUX','FLUY'), + OPERATION='MOYENNE')) + + __m1=abs(__flun['TRAC_NOR',3]) + __m2=abs(__flun['TRAC_NOR',4]) + __rtext=max(__m1,__m2) + +# CALCUL DU RAYON DE TORSION : rt +# rt = max ( rtext , 2*AIRE(TROU)/L(TROU) ) + + if args.has_key('GROUP_MA_INTE'): + if args['GROUP_MA_INTE'] != None : + if type(args['GROUP_MA_INTE'])==types.StringType : + l_group_ma_inte=[args['GROUP_MA_INTE'],] + else: + l_group_ma_inte=args['GROUP_MA_INTE'] + for j in range(0,len(l_group_ma_inte)): + __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, + DEFI_CHEMIN=_F(GROUP_MA=l_group_ma_inte[j]), + INFO=2,) + __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', + CHEMIN=__chem, + RESULTAT=__tempe1, + NOM_CHAM='FLUX_ELNO_TEMP', + TRAC_NOR='OUI', + NOM_CMP=('FLUX','FLUY'), + OPERATION='MOYENNE')) + __m1=(abs(__flun['TRAC_NOR',3])+abs(__flun['TRAC_NOR',4]))/2. + if __m1 > __rtext : + __rtext=__m1 + + __rt=__rtext + +# --- CALCUL DE LA CONSTANTE DE TORSION : +# --------------------------------- + + nomres=POST_ELEM(reuse=nomres, + MODELE=__nomoth, + CHAM_MATER=__chmath, + CARA_POUTRE=_F(CARA_GEOM=nomres, + LAPL_PHI=__tempe1, + RT=__rt, + GROUP_MA=l_group_ma[i], + OPTION='CARA_TORSION' ), ) + +# --- CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU +# --- CENTRE DE CISAILLEMENT/TORSION : +# ------------------------------ + + nomres=POST_ELEM(reuse=nomres, + MODELE=__nomoth, + CHAM_MATER=__chmath, + CARA_POUTRE=_F(CARA_GEOM=nomres, + LAPL_PHI_Y=__tempe2, + LAPL_PHI_Z=__tempe3, + GROUP_MA=l_group_ma[i], + LONGUEUR=args['LONGUEUR'], + MATERIAU=args['MATERIAU'], + LIAISON =args['LIAISON'], + OPTION='CARA_CISAILLEMENT' ), ) + IMPR_TABLE(TABLE=nomres) + + return ier diff --git a/Aster/Cata/cataSTA81/Macro/macr_ecla_pg_ops.py b/Aster/Cata/cataSTA81/Macro/macr_ecla_pg_ops.py new file mode 100644 index 00000000..8bfada76 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_ecla_pg_ops.py @@ -0,0 +1,71 @@ +#@ MODIF macr_ecla_pg_ops Macro DATE 09/11/2004 AUTEUR VABHHTS J.PELLET +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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_ecla_pg_ops(self,RESULTAT,MAILLAGE,RESU_INIT,MODELE_INIT, + TOUT, GROUP_MA, MAILLE, + SHRINK, TAILLE_MIN, + NOM_CHAM, TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE, INST, LIST_INST, PRECISION, CRITERE, + **args): + """ + Ecriture de la macro macr_ecla_pg + """ + import os, string + from Accas import _F + from Noyau.N_utils import AsType + ier=0 + + # On importe les definitions des commandes a utiliser dans la macro + CREA_MAILLAGE =self.get_cmd('CREA_MAILLAGE') + CREA_RESU =self.get_cmd('CREA_RESU') + + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + + # Appel à CREA_MAILLAGE : + motscles={} + if TOUT : motscles['TOUT'] =TOUT + if GROUP_MA : motscles['GROUP_MA'] =GROUP_MA + if MAILLE : motscles['MAILLE'] =MAILLE + + self.DeclareOut('ma2',MAILLAGE) + ma2=CREA_MAILLAGE(ECLA_PG=_F( MODELE = MODELE_INIT, NOM_CHAM=NOM_CHAM, + SHRINK = SHRINK, TAILLE_MIN=TAILLE_MIN, **motscles )); + + + + # Appel à CREA_RESU : + typ2=AsType(RESU_INIT).__name__ + if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE + if NUME_ORDRE : motscles['NUME_ORDRE'] =NUME_ORDRE + if LIST_ORDRE : motscles['LIST_ORDRE'] =LIST_ORDRE + if LIST_INST : motscles['LIST_INST'] =LIST_INST + if INST : motscles['INST'] =INST + if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE + + self.DeclareOut('resu2',RESULTAT) + resu2=CREA_RESU( OPERATION='ECLA_PG', TYPE_RESU=string.upper(typ2), + ECLA_PG=_F( MODELE_INIT= MODELE_INIT, RESU_INIT=RESU_INIT, NOM_CHAM=NOM_CHAM, + MAILLAGE= ma2, **motscles )); + return ier +############################################################################################ + diff --git a/Aster/Cata/cataSTA81/Macro/macr_fiab_impr_ops.py b/Aster/Cata/cataSTA81/Macro/macr_fiab_impr_ops.py new file mode 100644 index 00000000..08ac8d10 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_fiab_impr_ops.py @@ -0,0 +1,110 @@ +#@ MODIF macr_fiab_impr_ops Macro DATE 24/01/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS +# +def macr_fiab_impr_ops(self, INFO, + TABLE_CIBLE, NOM_PARA_CIBLE, GRADIENTS, **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. +# + """ Macro-commande réalisant l'impression des valeurs pour le logiciel de fiabilite. """ +# +# On charge les modules nécessaires + from Accas import _F +# +#____________________________________________________________________ +# +# 1. Préalables +#____________________________________________________________________ +# + erreur = 0 +# +# 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 +# + DEFI_FICHIER = self.get_cmd("DEFI_FICHIER") + IMPR_TABLE = self.get_cmd("IMPR_TABLE") +# +# 1.3. ==> Des constantes +# Atention : le numéro d'unité utilisé ici et celui +# utlisé dans le python d'échange lance_aster_5 +# doivent correspondre. +# + Unite_Fichier_ASTER_vers_FIABILITE = 91 + Nom_Symbolique_Fichier_ASTER_vers_FIABILITE = "ASTER_vers_FIABILITE" + FORMAT_R="1PE17.10" +#____________________________________________________________________ +# +# 2. Définition d'un fichier d'échange +#____________________________________________________________________ +# + DEFI_FICHIER ( ACTION= "ASSOCIER", +# FICHIER = Nom_Symbolique_Fichier_ASTER_vers_FIABILITE, + UNITE = Unite_Fichier_ASTER_vers_FIABILITE, + TYPE = "ASCII", + INFO = INFO ) +#____________________________________________________________________ +# +# 4. Ecriture de la valeur cible +#____________________________________________________________________ +# + IMPR_TABLE ( TABLE = TABLE_CIBLE, + NOM_PARA = NOM_PARA_CIBLE, + UNITE = Unite_Fichier_ASTER_vers_FIABILITE, + FORMAT_R = FORMAT_R, + INFO = INFO ) +#____________________________________________________________________ +# +# 5. Ecritures des gradients +#____________________________________________________________________ +# + if GRADIENTS is not None : +# + for val in GRADIENTS : +# + IMPR_TABLE ( TABLE = val["TABLE"], + SENSIBILITE = val["PARA_SENSI"], + NOM_PARA = (val["NOM_PARA"]), + UNITE = Unite_Fichier_ASTER_vers_FIABILITE, + FORMAT_R = FORMAT_R, + INFO = INFO ) +#____________________________________________________________________ +# +# 6. Libération du fichier d'échange +#____________________________________________________________________ +# + DEFI_FICHIER ( ACTION= "LIBERER", + UNITE = Unite_Fichier_ASTER_vers_FIABILITE, + INFO = INFO ) +# +#-------------------------------------------------------------------- +# 7. C'est fini ! +#-------------------------------------------------------------------- +# + return erreur diff --git a/Aster/Cata/cataSTA81/Macro/macr_fiabilite_ops.py b/Aster/Cata/cataSTA81/Macro/macr_fiabilite_ops.py new file mode 100644 index 00000000..62a10eba --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_fiabilite_ops.py @@ -0,0 +1,324 @@ +#@ MODIF macr_fiabilite_ops Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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. +# ====================================================================== + + +# RESPONSABLE GNICOLAS G.NICOLAS +# +def macr_fiabilite_ops(self, INFO, + LOGICIEL, VERSION, + UNITE_ESCL, MESS_ASTER, + SEUIL, SEUIL_TYPE, + VARIABLE, + **args ) : +# +# args est le dictionnaire des arguments optionnels +# 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. +### print args +### print args.keys() +### if len (args.keys())>0 : print args.keys()[0] +# + """ Macro-commande réalisant le pilotage du logiciel de fiabilite. """ +# +# On charge les modules nécessaires + from Accas import _F + from Macro import fiabilite_mefisto + import aster + import os + import string + import sys + import Numeric +# +#____________________________________________________________________ +# +# 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") + DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL") +# +# 1.3 ==> Le nom du programme de fiabilite à lancer +# + repertoire_outils = aster.repout() + fiabilite = repertoire_outils + "fiabilite" +# +# 1.4 ==> Initialisations +# + erreur = 0 + erreur_partiel = [0] + Rep_Calc_ASTER = os.getcwd() + Nom_Exec_ASTER = sys.executable +# + messages_erreur = { 0 : "Tout va bien", + 1 : "Impossible de créer le répertoire de travail pour le logiciel de fiabilité.", + 2 : "Probleme d'ouverture du fichier.", + 10 : "Erreur dans le choix du logiciel de fiabilité.", + 11 : "Erreur dans la création des données pour le logiciel de fiabilité.", + 100 : "Erreur." } +# + while not erreur : +# +#____________________________________________________________________ +# +# 2. Répertoires et fichiers +#____________________________________________________________________ +# +# 2.1. ==> Création du répertoire pour l'exécution du logiciel de fiabilité +# + Nom_Rep_local = "tmp_fiabilite" + Rep_Calc_LOGICIEL_local = os.path.join(".",Nom_Rep_local) + Rep_Calc_LOGICIEL_global = os.path.join(Rep_Calc_ASTER,Nom_Rep_local) +# + try : + os.mkdir(Rep_Calc_LOGICIEL_global) + 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 fiabilité : "+Rep_Calc_LOGICIEL_global) + erreur = erreur + 1 + break +# +# 2.2. ==> On crée un fichier annexe pour transmettre des données à la procédure +# de lancement des calculs ASTER par le LOGICIEL. +# Ce fichier est créé dans le répertoire d'exécution du logiciel de fiabilité. +# On fait ainsi car les arguments passés ont du mal à transiter via l'exécutable. +# On stocke : +# 1. Le niveau d'information +# 2. L'unité logique associée au jeu de commandes déterministes +# 3. La gestion des sorties ASTER +# 4. Le nom de l'exécutable ASTER +# 5. Le type de seuil du problème (maximum ou minimum) +# + fic_Info_ASTER = os.path.join(Rep_Calc_LOGICIEL_global,"InfoExecASTER") + try : + f_execAster = open(fic_Info_ASTER, "w") + except os.error,erreur_partiel : + self.cr.warn("Fichier : "+fic_Info_ASTER) + self.cr.warn("Code d'erreur de open : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1]) + erreur = 2 + break +# + f_execAster.write(str(INFO)+"\n") + f_execAster.write(str(UNITE_ESCL)+"\n") + f_execAster.write(str(MESS_ASTER)+"\n") + f_execAster.write(str(Nom_Exec_ASTER)+"\n") + f_execAster.write(str(SEUIL_TYPE)) + f_execAster.close() + fichier = open (fic_Info_ASTER,"r") +# + if INFO >= 2 : + print "\nContenu du fichier " + fic_Info_ASTER," :" + les_lignes = fichier.readlines() + fichier.close() + print les_lignes, "\n" +# +#____________________________________________________________________ +# +# 3. Les variables par defaut +#____________________________________________________________________ +# +# 3.1. ==> Dictionnaire des valeurs physiques et liées à la loi +# + valeurs_lois = { } +# + for m in VARIABLE : +# + v_moy_physique = None + v_moy_loi = None + v_min_loi = None + v_max_loi = None + sigma_loi = None +# +# 3.1.1. ==> loi uniforme : transfert des min et max +# on définit une moyennne comme étant la médiane des extremes. +# + if m["LOI"] == "UNIFORME" : + v_moy_physique = 0.5 * ( m["VALE_MIN"] + m["VALE_MAX"] ) + v_min_loi = m["VALE_MIN"] + v_max_loi = m["VALE_MAX"] +# +# 3.1.2. ==> loi normale : transfert des moyennne et écart-type. +# + elif m["LOI"] == "NORMALE" : + v_moy_loi = m["VALE_MOY"] + v_moy_physique = v_moy_loi + sigma_loi = m["ECART_TYPE"] +# +# 3.1.3. ==> loi lognormale : identité du min, conversion pour le reste +# + elif m["LOI"] == "LOGNORMALE" : + v_min_loi = m["VALE_MIN"] + if m["VALE_MOY_PHY"] is None : + v_moy_loi = m["VALE_MOY"] + sigma_loi = m["ECART_TYPE"] + aux = Numeric.exp(0.5*sigma_loi*sigma_loi+v_moy_loi) + v_moy_physique = v_min_loi + aux + else : + v_moy_physique = m["VALE_MOY_PHY"] + aux = m["ECART_TYPE_PHY"]/(m["VALE_MOY_PHY"]-m["VALE_MIN"]) + aux1 = 1. + aux*aux + aux2 = Numeric.sqrt(aux1) + v_moy_loi = Numeric.log((m["VALE_MOY_PHY"]-m["VALE_MIN"])/aux2) + aux2 = Numeric.log(aux1) + sigma_loi = Numeric.sqrt(aux2) +# +# 3.1.4. ==> loi normale tronquée : transfert des moyenne, mini/maxi et écart-type +# on définit une moyennne comme étant la médiane des extremes. +# + else : + v_moy_loi = m["VALE_MOY"] + v_min_loi = m["VALE_MIN"] + v_max_loi = m["VALE_MAX"] + sigma_loi = m["ECART_TYPE"] + v_moy_physique = 0.5 * ( m["VALE_MIN"] + m["VALE_MAX"] ) +# + d = { } + d["v_moy_physique"] = v_moy_physique + d["v_moy_loi"] = v_moy_loi + d["v_min_loi"] = v_min_loi + d["v_max_loi"] = v_max_loi + d["sigma_loi"] = sigma_loi + valeurs_lois[m] = d +# +#____________________________________________________________________ +# +# 4. Création des fichiers pour le logiciel de fiabilite +#____________________________________________________________________ +# + if ( LOGICIEL == "MEFISTO" ) : +# +# 4.1. ==> MEFISTO +# + erreur = fiabilite_mefisto.fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global, + INFO, VERSION, + SEUIL, SEUIL_TYPE, + VARIABLE, + valeurs_lois, + **args ) +# +# 4.2. ==> Erreur si autre logiciel +# + else : +# + self.cr.warn("Logiciel de fiabilité : "+LOGICIEL) + erreur = 10 +# +# 4.3. ==> Arret en cas d'erreur +# + if erreur : + break +# +#____________________________________________________________________ +# +# 5. Ecriture de la commande d"exécution du logiciel de fiabilité +# +# Remarque : dans la donnée de la version du logiciel de fiabilité, 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=string.replace(VERSION,"_",".") + VERSION=string.replace(VERSION,"N","n") +# + EXEC_LOGICIEL ( ARGUMENT = (_F(NOM_PARA=Rep_Calc_LOGICIEL_global), # nom du repertoire + _F(NOM_PARA=LOGICIEL), # nom du logiciel de fiabilité + _F(NOM_PARA=VERSION), # version du logiciel de fiabilité + ), + LOGICIEL = fiabilite + ) +# +#-------------------------------------------------------------------- +# 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]) +# +# 6.2. ==> Si tout va bien, on crée une liste de réels pour le retour +# A terme, il serait intéressant d'y mettre les résultats +# de l'analyse fiabiliste. Pour le moment, on se contente de +# mettre une valeur nulle qui permet de faire un test dans +# les commandes appelantes. +# + aux = [float(erreur)] +# + self.DeclareOut("nomres",self.sd) + nomres = DEFI_LIST_REEL( VALE = aux , INFO = 1 ) +# + return +# +########################## Fin de la fonction################################## +# +########################## Auto-test################################## +# +if __name__ == "__main__" : +# + import os + import sys + import tempfile +# + Rep_Calc_LOGICIEL_global = tempfile.mktemp() + os.mkdir(Rep_Calc_LOGICIEL_global) +# + classe = None + INFO = 2 + LOGICIEL = "MEFISTO" + VERSION = "V3_2" + UNITE_ESCL = 38 + MESS_ASTER = "DERNIER" + SEUIL = 1789. + SEUIL_TYPE = "MAXIMUM" + VARIABLE = [] + args = {} +# + lr8 = macr_fiabilite_ops(classe, INFO, + LOGICIEL, VERSION, + UNITE_ESCL, MESS_ASTER, + SEUIL, SEUIL_TYPE, + VARIABLE, + **args ) +### print "lr8 = ", lr8 + Liste = os.listdir(Rep_Calc_LOGICIEL_global) +# + for nomfic in Liste : + fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic) + os.chmod (fic_total,0755) + os.remove (fic_total) + os.rmdir (Rep_Calc_LOGICIEL_global) +# + sys.exit("blabla") diff --git a/Aster/Cata/cataSTA81/Macro/macr_lign_coupe_ops.py b/Aster/Cata/cataSTA81/Macro/macr_lign_coupe_ops.py new file mode 100644 index 00000000..389998c4 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_lign_coupe_ops.py @@ -0,0 +1,366 @@ +#@ MODIF macr_lign_coupe_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + + + +######################################################################## +# script PYTHON de creation d un maillage de ligne de coupe + +def crea_mail_lig_coup(dimension,lignes,groups): + + import os,sys,copy + from Utilitai.Utmess import UTMESS + +# construction du maillage au format Aster des segments de lignes de coupe + + nblig=len(lignes) + nbngr=len(groups) + + resu='TITRE\n' + titre='Maillage ligne de coupe'+'\n' + resu=resu+'FINSF\n' + resu=resu+'COOR_'+str(dimension)+'D\n' + +# creation des noeuds + nbno=0 + for i in range(nblig): + pt1 = lignes[i][0] + pt2 = lignes[i][1] + nbp_lig_coupe = lignes[i][2] + for j in range(nbp_lig_coupe): + if dimension==2: + x=pt1[0]+j*(pt2[0]-pt1[0])/(nbp_lig_coupe-1) + y=pt1[1]+j*(pt2[1]-pt1[1])/(nbp_lig_coupe-1) + nbno=nbno+1 + noeud=' N'+str(nbno)+' '+str(x)+' '+str(y)+'\n' + resu=resu+noeud + elif dimension==3: + x=pt1[0]+j*(pt2[0]-pt1[0])/(nbp_lig_coupe-1) + y=pt1[1]+j*(pt2[1]-pt1[1])/(nbp_lig_coupe-1) + z=pt1[2]+j*(pt2[2]-pt1[2])/(nbp_lig_coupe-1) + nbno=nbno+1 + noeud=' N'+str(nbno)+' '+str(x)+' '+str(y)+' '+str(z)+'\n' + resu=resu+noeud + for i in range(nbngr): + for pt in groups[i][1:]: + if dimension==2: + nbno=nbno+1 + noeud=' N'+str(nbno)+' '+str(pt[0])+' '+str(pt[1])+'\n' + resu=resu+noeud + elif dimension==3: + nbno=nbno+1 + noeud=' N'+str(nbno)+' '+str(pt[0])+' '+str(pt[1])+' '+str(pt[2])+'\n' + resu=resu+noeud + resu=resu+'FINSF\n' + +# creation des mailles + nbma=0 + for i in range(nblig): + nbp_lig_coupe = lignes[i][2] + resu=resu+'SEG2\n' + for j in range(nbp_lig_coupe-1): + nbma=nbma+1 + maille=' M'+str(nbma)+' N'+str(nbma+i)+' N'+str(nbma+1+i)+'\n' + resu=resu+maille + resu=resu+'FINSF\n' + for i in range(nbngr): + resu=resu+'SEG2\n' + for pt in groups[i][1:-1]: + nbma=nbma+1 + maille=' M'+str(nbma)+' N'+str(nbma+nblig+i)+' N'+str(nbma+nblig+1+i)+'\n' + resu=resu+maille + resu=resu+'FINSF\n' + +# creation des groupes de mailles (1 par ligne de coupe) + nbma=0 + for i in range(nblig): + resu=resu+'GROUP_MA\n' + resu=resu+' LICOU'+str(i+1) + nbp_lig_coupe = lignes[i][2] + for j in range(nbp_lig_coupe-1): + nbma=nbma+1 + resu=resu+' M'+str(nbma)+'\n' + resu=resu+'\n' + resu=resu+'FINSF\n' + for i in range(nbngr): + resu=resu+'GROUP_MA\n' + resu=resu+groups[i][0] + nbp_lig_coupe = len(groups[i])-1 + for j in range(nbp_lig_coupe-1): + nbma=nbma+1 + resu=resu+' M'+str(nbma)+'\n' + resu=resu+'\n' + resu=resu+'FINSF\n' + resu=resu+'FIN\n' + + return resu + + +######################################################################## +def macr_lign_coupe_ops(self,RESULTAT,UNITE_MAILLAGE,LIGN_COUPE,NOM_CHAM,MODELE,**args): + """ + Ecriture de la macro MACR_LIGN_COUPE + """ + import os,string,types + from Accas import _F + from Noyau.N_utils import AsType + import aster,math + from Utilitai.UniteAster import UniteAster + from Utilitai.Utmess import UTMESS + ier=0 + + # On importe les definitions des commandes a utiliser dans la macro + LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE') + DEFI_GROUP =self.get_cmd('DEFI_GROUP') + AFFE_MODELE =self.get_cmd('AFFE_MODELE') + PROJ_CHAMP =self.get_cmd('PROJ_CHAMP') + POST_RELEVE_T =self.get_cmd('POST_RELEVE_T') + CREA_TABLE =self.get_cmd('CREA_TABLE') + MODI_REPERE =self.get_cmd('MODI_REPERE') + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + nomresu=RESULTAT.nom + l_modele=aster.getvectjev(nomresu.ljust(19)+'.MODL') + n_modele=string.strip(l_modele[0]) + if n_modele=='' : + if MODELE==None: + UTMESS('F', "MACR_LIGN_COUPE", "nom du modele absent dans le concept resultat "+nomresu) + else : n_modele=MODELE.nom + l_mailla=aster.getvectjev(n_modele.ljust(8)+'.MODELE .NOMA') + n_mailla=string.strip(l_mailla[0]) + dime=aster.getvectjev(n_mailla.ljust(8)+'.DIME')[5] + collgrno=aster.getcolljev(n_mailla.ljust(8)+'.GROUPENO') + + lignes=[] + groups=[] + minidim=dime + for m in LIGN_COUPE : + if m['NB_POINTS'] !=None : + lignes.append((m['COOR_ORIG'],m['COOR_EXTR'],m['NB_POINTS'])) + minidim=min(minidim,len(m['COOR_ORIG']),len(m['COOR_EXTR'])) + elif m['GROUP_NO']!=None : + ngrno=m['GROUP_NO'].ljust(8).upper() + if ngrno not in collgrno.keys() : + UTMESS('F', "MACR_LIGN_COUPE", "le group_no "+ngrno+" n est pas dans le maillage "+n_mailla) + grpn=collgrno[ngrno] + l_coor_group=[ngrno,] + for node in grpn: + l_coor_group.append(aster.getvectjev(n_mailla.ljust(8)+'.COORDO .VALE',3*(node-1),3)) + groups.append(l_coor_group) + + if minidim!=dime: + UTMESS('F', "MACR_LIGN_COUPE", "dimensions de maillage et de coordonnees incoherentes") + + + # Création du maillage des NB_POINTS segments entre COOR_ORIG et COOR_EXTR + # ainsi que des segments reliant les noeuds issus des group_no demandés + # par appel au script python crea_mail_lig_coup + # le maillage est ensuite recopié dans l unité logique UNITE_MAILLAGE + + resu_mail=crea_mail_lig_coup(dime,lignes,groups) + UL = UniteAster() + nomFichierSortie = UL.Nom(UNITE_MAILLAGE) + fproc=open(nomFichierSortie,'w') + fproc.write(resu_mail) + fproc.close() + UL.EtatInit(UNITE_MAILLAGE) + + # Lecture du maillage de seg2 contenant toutes les lignes de coupe + + __macou=LIRE_MAILLAGE(UNITE=UNITE_MAILLAGE,); + + motscles={} + iocc=1 + motscles['CREA_GROUP_NO']=[] + for m in LIGN_COUPE : + if m['NB_POINTS'] !=None : + motscles['CREA_GROUP_NO'].append(_F(GROUP_MA='LICOU'+str(iocc),) ) + iocc=iocc+1 + elif m['GROUP_NO']!=None : + motscles['CREA_GROUP_NO'].append(_F(GROUP_MA=m['GROUP_NO'].ljust(8).upper(),) ) + __macou=DEFI_GROUP( reuse =__macou , MAILLAGE=__macou , **motscles ); + + if AsType(RESULTAT).__name__ in ('evol_elas','evol_noli') : + __mocou=AFFE_MODELE(MAILLAGE=__macou, + AFFE=_F(TOUT='OUI', + PHENOMENE='MECANIQUE', + MODELISATION='BARRE',),); + elif AsType(RESULTAT).__name__ in ('evol_ther',) : + __mocou=AFFE_MODELE(MAILLAGE=__macou, + AFFE=_F(TOUT='OUI', + PHENOMENE='THERMIQUE', + MODELISATION='PLAN',),); + + __recou=PROJ_CHAMP(METHODE='ELEM', + RESULTAT=RESULTAT, + MODELE_1=self.jdc.current_context[n_modele], + MODELE_2=__mocou, + TYPE_CHAM='NOEU', + NOM_CHAM=NOM_CHAM,); + + # Expression des contraintes aux noeuds ou des déplacements dans le repere local + __remodr=__recou + if AsType(RESULTAT).__name__ in ('evol_elas','evol_noli') : + for m in LIGN_COUPE : + if m['VECT_Y'] !=None : + epsi=0.00000001 + # --- determination des angles nautiques + cx1=m['COOR_EXTR'][0]-m['COOR_ORIG'][0] + cx2=m['COOR_EXTR'][1]-m['COOR_ORIG'][1] + cx3=0. + if dime == 3: + cx3=m['COOR_EXTR'][2]-m['COOR_ORIG'][2] + nvx=math.sqrt(cx1**2+cx2**2+cx3**2) + if abs(nvx) < epsi: + UTMESS('F', "MACR_LIGN_COUPE", "definition incorrecte de la ligne de coupe") + cx1=cx1/nvx + cx2=cx2/nvx + cx3=cx3/nvx + cy1=m['VECT_Y'][0] + cy2=m['VECT_Y'][1] + cy3=0. + if dime == 3: + cy3=m['VECT_Y'][2] + nvy=math.sqrt(cy1**2+cy2**2+cy3**2) + if abs(nvy) < epsi: + UTMESS('F', "MACR_LIGN_COUPE", "valeurs incorrectes pour VECT_Y") + cy1=cy1/nvy + cy2=cy2/nvy + cy3=cy3/nvy + if ((abs(cx1-cy1) epsi : + cz1=cx2*cy3-cx3*cy2 + cz2=cx3*cy1-cx1*cy3 + cz3=cx1*cy2-cx2*cy1 + nvz=math.sqrt(cz1**2+cz2**2+cz3**2) + cz1=cz1/nvz + cz2=cz2/nvz + cz3=cz3/nvz + cy1=cz2*cx3-cz3*cx2 + cy2=cz3*cx1-cz1*cx3 + cy3=cz1*cx2-cz2*cx1 + nvy=math.sqrt(cy1**2+cy2**2+cy3**2) + cy1=cy1/nvy + cy2=cy2/nvy + cy3=cy3/nvy + UTMESS('A','MACR_LIGN_COUPE','LE VECTEUR Y N EST PAS ORTHOGONAL A LA LIGNE DE COUPE' + +'LE VECTEUR Y A ETE ORTHONORMALISE POUR VOUS') + UTMESS('A','MACR_LIGN_COUPE','VECT_Y=('+str(cy1)+','+str(cy2)+','+str(cy3)+')') + else: + cz1=cx2*cy3-cx3*cy2 + cz2=cx3*cy1-cx1*cy3 + cz3=cx1*cy2-cx2*cy1 + beta=0. + gamma=0. + if dime ==2: + alpha = math.atan2(cx2,cx1) + else: + if cx1**2 + cx2**2 > epsi : + alpha=math.atan2(cx2,cx1) + beta=math.asin(cx3) + gamma=math.atan2(cy3,cz3) + else: + alpha=math.atan2(cy1,cz1) + beta=math.asin(cx3) + gamma=0. + alpha=alpha*180/math.pi + beta=beta*180/math.pi + gamma=gamma*180/math.pi + + # --- MODI_REPERE + motscles={} + motscles['MODI_CHAM']=[] + motscles['DEFI_REPERE']=[] + # MODI_CHAM + if NOM_CHAM == 'DEPL': + if dime == 2: + LCMP=['DX','DY'] + TYPE_CHAM='VECT_2D' + elif dime ==3 : + LCMP=['DX','DY','DZ'] + TYPE_CHAM='VECT_3D' + motscles['MODI_CHAM'].append(_F(NOM_CHAM=NOM_CHAM,NOM_CMP=LCMP,TYPE_CHAM=TYPE_CHAM),) + elif NOM_CHAM in ('SIGM_NOEU_DEPL','SIGM_NOEU_SIEF','SIGM_NOEU_ELGA','SIGM_NOEU_COQU'): + if dime == 2: + LCMP=['SIXX','SIYY','SIZZ','SIXY'] + TYPE_CHAM='TENS_2D' + elif dime ==3 : + LCMP=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'] + TYPE_CHAM='TENS_3D' + motscles['MODI_CHAM'].append(_F(NOM_CHAM=NOM_CHAM,NOM_CMP=LCMP,TYPE_CHAM=TYPE_CHAM),) + # DEFI_REPERE + ANGL_NAUT=[] + ANGL_NAUT.append(alpha) + if dime ==3: + ANGL_NAUT.append(beta) + ANGL_NAUT.append(gamma) + motscles['DEFI_REPERE'].append(_F(REPERE='UTILISATEUR',ANGL_NAUT=ANGL_NAUT),) + __remodr=MODI_REPERE(RESULTAT=__recou,**motscles) + + + + # Production d'une table pour toutes les lignes de coupe + + ioc2=0 + mcACTION=[] + for m in LIGN_COUPE : + if m['NB_POINTS'] !=None : + ioc2=ioc2+1 + groupe='LICOU'+str(ioc2) + if m['INTITULE'] !=None : intitl=m['INTITULE'] + else : intitl='l.coupe'+str(ioc2) + elif m['GROUP_NO']!=None : + groupe=m['GROUP_NO'].ljust(8).upper() + if m['INTITULE'] !=None : intitl=m['INTITULE'] + else : intitl=groupe + mcACTION.append( _F(INTITULE = intitl, + RESULTAT = __remodr, + GROUP_NO = groupe, + NOM_CHAM = NOM_CHAM, + TOUT_CMP = 'OUI', + OPERATION = 'EXTRACTION', ) ) + + __tabitm=POST_RELEVE_T(ACTION=mcACTION,); + + # on repasse par les tables python pour supprimer les paramètres inutiles + # NOEUD (car il est propre au maillage de la ligne) et RESU + + self.DeclareOut('nomres',self.sd) + dictab=__tabitm.EXTR_TABLE() + listpara=dictab.para + listpara.remove('NOEUD') + listpara.remove('RESU') + + coltab=[] + for key in listpara : + val=dictab[key].values()[key] + if type(val[0])==types.IntType : + coltab.append(_F(PARA=key,LISTE_I=val)) + elif type(val[0])==types.FloatType : + coltab.append(_F(PARA=key,LISTE_R=val)) + elif type(val[0])==types.StringType : + coltab.append(_F(PARA=key,LISTE_K=val,TYPE_K='K16')) + nomres=CREA_TABLE(LISTE=coltab) + + return ier diff --git a/Aster/Cata/cataSTA81/Macro/macr_recal_ops.py b/Aster/Cata/cataSTA81/Macro/macr_recal_ops.py new file mode 100644 index 00000000..325320a1 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/macr_recal_ops.py @@ -0,0 +1,156 @@ +#@ MODIF macr_recal_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + + + +def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC, + ITER_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI, + GRAPHIQUE, **args ): + """Macro commande réalisant le recalage de modèles Aster""", + # Initialisation du compteur d'erreurs + ier=0 + # On essaie d'importer Numeric -> ERREUR FATALE + from Utilitai.Utmess import UTMESS + try: + import Numeric + except ImportError: + UTMESS('F', "MACR_RECAL", "Le module Numeric de Python n'a pu etre chargé") + # On essaie d'importer Gnuplot -> PAS DE GRAPHIQUE + try: + import Gnuplot + gnuplot=1 + except ImportError: + gnuplot=0 + import string + import copy + import types + import Macro + from Cata import cata + from Cata.cata import DEFI_LIST_REEL + from Macro.recal import gestion,transforme_list_Num,calcul_F,graphique + from Macro import reca_message + from Macro import reca_algo + from Macro import reca_interp + # La macro compte pour 1 dans l'execution des commandes + self.set_icmd(1) + + self.DeclareOut('nomres',self.sd) + + #_______________________________________________ + # + # GESTION DE L'OPTION FACULTATIVE POUR LES POIDS + #_______________________________________________ + if( POIDS == None): + POIDS=Numeric.ones(len(RESU_EXP)) + + #_____________________________________________ + # + # GESTION DES ERREURS DE SYNTAXE + #_____________________________________________ + texte_erreur = gestion(UNITE_ESCL,LIST_PARA,RESU_CALC,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU) + if (texte_erreur != ""): + UTMESS('F', "MACR_RECAL", texte_erreur) + + #_____________________________________________ + # + # DECLARATION DE TOUTES LES COMMANDES ASTER + #_____________________________________________ + for k,v in cata.__dict__.items() : + if type(v)==types.InstanceType: + if v.__class__.__name__ in ('OPER','MACRO'): + self.current_context[k]= v + self.current_context['_F']=cata.__dict__['_F'] + + #_____________________________________________ + # + # INITIALISATIONS + #_____________________________________________ + iter = 0 + restant,temps_iter=0.,0. + restant,temps_iter,err=reca_algo.temps_CPU(self,restant,temps_iter) + para,val,borne_inf,borne_sup = transforme_list_Num(LIST_PARA,RESU_EXP) + val_init = copy.copy(val) + L_init = calcul_F(self,UNITE_ESCL,para,val,RESU_CALC) + #instance de la classe gérant l'affichage des resultats du calcul de l'optimisation + Mess = reca_message.Message(para,RESU_EXP,copy.copy(val_init),UNITE_RESU) + #instances des classes pour le calcul de l'erreur et le dimensionnemnt/adim + Simul = reca_interp.Sim_exp(RESU_EXP,POIDS) + Dim = reca_algo.Dimension(copy.copy(val_init),para) + L_J_init,erreur = Simul.multi_interpole(L_init, RESU_CALC) + J_init = Simul.norme_J(copy.copy(L_J_init),copy.copy(L_J_init),UNITE_RESU) + J = J_init + A = Simul.sensibilite(self,UNITE_ESCL,L_init,val,para,RESU_CALC,PARA_DIFF_FINI,UNITE_RESU) + A = Dim.adim_sensi(A) + l = reca_algo.lambda_init(Numeric.matrixmultiply(Numeric.transpose(A),A)) + gradient_init =reca_algo.calcul_gradient(A,erreur) #utile pour le test de convergence, on prend les valeurs dimensionnées + residu = reca_algo.test_convergence(gradient_init,erreur,A,Numeric.zeros(len(gradient_init),Numeric.Float)) + Mess.affiche_result_iter(iter,J,val,residu,Numeric.array([]),UNITE_RESU) + # On teste un manque de temps CPU + restant,temps_iter,err=reca_algo.temps_CPU(self,restant,temps_iter) + if (err==1): + ier=ier+1 + return ier + + #_____________________________________________ + # + # BOUCLE PRINCIPALE DE L'ALGORITHME + #_____________________________________________ + epsilon = 10.*RESI_GLOB_RELA + while((residu > RESI_GLOB_RELA) & (iter10000): + l=abs(10000.*emin-emax)/10001. + return l + +#----------------------------------------- + + +def temps_CPU(self,restant_old,temps_iter_old): + # Fonction controlant le temps CPU restant + CPU=INFO_EXEC_ASTER(LISTE_INFO = ("CPU_RESTANT",)) + TEMPS=CPU['CPU_RESTANT',1] + DETRUIRE(CONCEPT=_F(NOM='CPU'),INFO=1) + err=0 + # Indique une execution interactive + if (TEMPS>1.E+9): + return 0.,0.,0 + # Indique une execution en batch + else: + restant=TEMPS + # Initialisation + if (restant_old==0.): + temps_iter=-1. + else: + # Première mesure + if (temps_iter_old==-1.): + temps_iter=(restant_old-restant) + # Mesure courante + else: + temps_iter=(temps_iter_old + (restant_old-restant))/2. + if ((temps_iter>0.96*restant)or(restant<0.)): + err=1 + UTMESS('F', "MACR_RECAL", 'Arret de MACR_RECAL par manque de temps CPU') + return restant,temps_iter,err + + + + +def Levenberg_bornes(self,val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out): + # on resoud le système par contraintes actives: + # Q.dval + s + d =0 + # soumis à : + # borne_inf < dval < borne_sup + # 0 < s + # s.(borne_inf - dval)=0 + # s.(borne_sup - dval)=0 + dim = len(val) + id = Numeric.identity(dim) + # Matrice du système + Q=Numeric.matrixmultiply(Numeric.transpose(A),A) +l*id + # Second membre du système + d=Numeric.matrixmultiply(Numeric.transpose(A),erreur) + # Ens. de liaisons actives + Act=Numeric.array([]) + k=0 + done=0 + # Increment des parametres + dval=Numeric.zeros(dim,Numeric.Float) + while done <1 : + k=k+1 + I=Numeric.ones(dim) + for i in Act: + I[i]=0 + I=Numeric.nonzero(Numeric.greater(I,0)) + s=Numeric.zeros(dim,Numeric.Float) + for i in Act: + # test sur les bornes (on stocke si on est en butée haute ou basse) + if (val[i]+dval[i]>=borne_sup[i]): + dval[i]=borne_sup[i]-val[i] + s[i]=1. + if (val[i]+dval[i]<=borne_inf[i]): + dval[i]=borne_inf[i]-val[i] + s[i]=-1. + if (len(I)!=0): + # xi=-Q(I)-1.(d(I)+Q(I,Act).dval(Act)) + xi=-LinearAlgebra.solve_linear_equations(take(take(Q,I),I,1),(take(d,I)+Numeric.dot(take(take(Q,I),Act,1),take(Dim.adim(dval),Act)))) + for i in Numeric.arange(len(I)): + dval[I[i]]=xi[i]*val_init[I[i]] + if (len(Act)!=0): + # s(Av)=-d(Act)-Q(Act,:).dval + sa=-take(d,Act)-Numeric.dot(take(Q,Act),Dim.adim(dval)) + for i in range(len(Act)): + if (s[Act[i]]==-1.): + s[Act[i]]=-sa[i] + else: + s[Act[i]]=sa[i] + # Nouvel ens. de liaisons actives + Act=Numeric.concatenate((Numeric.nonzero(Numeric.greater(dval,borne_sup-val)),Numeric.nonzero(Numeric.less(dval,borne_inf-val)),Numeric.nonzero(Numeric.greater(s,0.)))) + done=(max(val+dval-borne_sup)<=0)&(min(val+dval-borne_inf)>=0)&(min(s)>=0.0) + # Pour éviter le cyclage + if (k>50): + try: + l=l*2 + Q=Numeric.matrixmultiply(Numeric.transpose(A),A) +l*id + k=0 + except: + res=open(os.getcwd()+'/fort.'+str(ul_out),'a') + res.write('\n\nQ = \n'+Numeric.array2string(Q-l*id,array_output=1,separator=',')) + res.write('\n\nd = '+Numeric.array2string(d,array_output=1,separator=',')) + res.write('\n\nval = '+Numeric.array2string(val,array_output=1,separator=',')) + res.write('\n\nval_ini= '+Numeric.array2string(val_init,array_output=1,separator=',')) + res.write('\n\nborne_inf= '+Numeric.array2string(borne_inf,array_output=1,separator=',')) + res.write('\n\nborne_sup= '+Numeric.array2string(borne_sup,array_output=1,separator=',')) + UTMESS('F', "MACR_RECAL", "Erreur dans l'algorithme de bornes de MACR_RECAL") + return + newval=copy.copy(val+dval) + return newval,s,l,Act + + +def actualise_lambda(l,val,new_val,A,erreur,new_J,old_J): + dim = len(val) + id = Numeric.identity(dim) + # Matrice du système + Q=Numeric.matrixmultiply(Numeric.transpose(A),A) +l*id + # Second membre du système + d=Numeric.matrixmultiply(Numeric.transpose(A),erreur) + old_Q=old_J + new_Q=old_J+0.5*Numeric.dot(Numeric.transpose(new_val-val),Numeric.dot(Q,new_val-val))+Numeric.dot(Numeric.transpose(new_val-val),d) + # Ratio de la décroissance réelle et de l'approx. quad. + try: + R=(old_J-new_J)/(old_Q-new_Q) + if (R<0.25): + l = l*10. + elif (R>0.75): + l = l/15. + except ZeroDivisionError: + if (old_J>new_J): + l = l*10. + else: + l = l/10. + return l + + +def test_convergence(gradient_init,erreur,A,s): + gradient = calcul_gradient(A,erreur)+s + epsilon = Numeric.dot(gradient,gradient)/Numeric.dot(gradient_init,gradient_init) + epsilon = epsilon**0.5 + return epsilon + + +# fonction appellée quand la convergence est atteinte +# on calcule le Hessien et les valeurs propres et vecteurs +# propre associés au Hessien +# A = sensibilite +# At*A = hessien +def calcul_etat_final(para,A,iter,max_iter,prec,residu,Messg,ul_out): + if ((iter < max_iter) or (residu < prec)): + Hessien = Numeric.matrixmultiply(Numeric.transpose(A),A) + valeurs_propres,vecteurs_propres = LinearAlgebra.eigenvectors(Hessien) + sensible=Numeric.nonzero(Numeric.greater(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-1)) + insensible=Numeric.nonzero(Numeric.less(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-2)) + Messg.affiche_calcul_etat_final(para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible,ul_out) + + + + + diff --git a/Aster/Cata/cataSTA81/Macro/reca_interp.py b/Aster/Cata/cataSTA81/Macro/reca_interp.py new file mode 100644 index 00000000..0d04cc21 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/reca_interp.py @@ -0,0 +1,181 @@ +#@ MODIF reca_interp Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +import os +import Numeric +import Macro +from Macro.recal import calcul_F +from Utilitai.Utmess import UTMESS + +#=========================================================================================== + + +# INTERPOLATION, CALCUL DE SENSIBILITE, ETC.... + +#-------------------------------------- +class Sim_exp : + + def __init__ (self,result_exp,poids) : + self.resu_exp = result_exp + self.poids = poids + +# Distance verticale d'un point M à une ligne brisée composée de n points + + def DistVertAdimPointLigneBrisee (self, M, points) : + # M = Point (2 colonnes, 1 ligne) + # points = Tableau de n points (2 colonnes, n lignes) + # on suppose qu'il existe au moins 2 points, + # et que les points sont classés selon les abscisses croissantes + n = len(points) + if ( M[0] < points[0][0] ) or ( M[0] > points[n-1][0] ) : + return 0. + i = 1 + while M[0] > points[i][0] : + i = i+1 + y_proj_vert = (M[0]-points[i-1][0]) * (points[i][1]-points[i-1][1]) / (points[i][0]-points[i-1][0]) + points[i-1][1] + d = (M[1] - y_proj_vert) + # Attention: la distance n'est pas normalisée + # Attention: problème si points[0][0] = points[1][0] = M[0] + # Attention: problème si M[1] = 0 + return d + + +# La Fonction Interpole ,interpole une et une seule F_calc sur F_exp et renvoie l'erreur seulement + def Interpole (self, F_calc,experience,poids) : #ici on passe en argument "une" experience + n = 0 + resu_num = F_calc + n_exp = len(experience) # nombre de points sur la courbe expérimentale num.i + stockage = Numeric.ones(n_exp, Numeric.Float) # matrice de stockage des erreurs en chaque point + for j in xrange(n_exp) : + d = self.DistVertAdimPointLigneBrisee(experience[j], resu_num) + try: + stockage[n] = d/experience[j][1] + except ZeroDivisionError: + stockage[n] = d + n = n + 1 # on totalise le nombre de points valables + err = Numeric.ones(n, Numeric.Float) + for i in xrange(n) : + err[i] = poids*stockage[i] + return err + + #cette fonction appelle la fonction interpole et retourne les sous fonctionnelle J et l'erreur + def multi_interpole(self,L_F, reponses): #on interpole toutes les reponses une à une en appelent la methode interpole + L_erreur=[] + for i in range(len(reponses)): + err = self.Interpole(L_F[i],self.resu_exp[i],self.poids[i]) + L_erreur.append(err) + #on transforme L_erreur en tab num + dim=[] + J=[] + for i in range(len(L_erreur)): + dim.append(len(L_erreur[i])) + dim_totale = Numeric.sum(dim) + L_J = self.calcul_J(L_erreur) + a=0 + erreur = Numeric.zeros((dim_totale),Numeric.Float) + for n in range(len(L_erreur)): + for i in range(dim[n]): + erreur[i+a] = L_erreur[n][i] + a = dim[n] + del(L_erreur) #on vide la liste puisqu'on n'en a plus besoin + return L_J,erreur + + #cette fonction retourne seulement l'erreur ,je l'appelle dans la methode sensibilité + #on interpole toutes les reponses une à une en appelent la methode interpole + def multi_interpole_sensib(self,L_F,reponses): + L_erreur=[] + for i in range(len(reponses)): + err = self.Interpole(L_F[i],self.resu_exp[i],self.poids[i]) + L_erreur.append(err) + #on transforme L_erreur en tab num + return L_erreur + + def calcul_J(self,L_erreur): + L_J = [] + for i in range(len(L_erreur)): + total = 0 + for j in range(len(L_erreur[i])): + total = total + L_erreur[i][j]**2 + L_J.append(total) + return L_J + + def norme_J(self,L_J_init,L_J,unite_resu): + #cette fonction calcul une valeur normée de J + for i in range(len(L_J)): + try: + L_J[i] = L_J[i]/L_J_init[i] + except ZeroDivisionError: + message= 'Problème de division par zéro dans la normalisation de la fonctionnelle.\n' + message=message+'Une des valeurs de la fonctionnelle initiale est nulle ou inférieure à la précision machine : %.2f \n'%L_J_init + fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') + fic.write(message) + fic.close() + UTMESS('F', "MACR_RECAL", message) + + J = Numeric.sum(L_J) + J = J/len(L_J) + return J + + def sensibilite(self,objet,UL,F,val,para,reponses,pas,unite_resu): + F_interp=self.multi_interpole_sensib(F, reponses) #F_interp est une liste contenant des tab num des reponses interpolés + L_A=[] #creation de la liste des matrices de sensibilités + for i in range(len(reponses)): + L_A.append(Numeric.zeros((len(self.resu_exp[i]),len(val)),Numeric.Float) ) + #calcul de la sensibilité + fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') + fic.write('\nCalcul de la sensibilité par rapport à :') + fic.close() + for k in range(len(val)): #pour une colone de A + h = val[k]*pas + val[k] = val[k] + h + F_perturbe = calcul_F(objet,UL,para,val,reponses) + fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') + fic.write(' '+para[k]) + fic.close() + F_perturbe_interp =self.multi_interpole_sensib(F_perturbe, reponses) + val[k] = val[k] - h + for j in range(len(reponses)): + for i in range(len(self.resu_exp[j])): + try: + L_A[j][i,k] = -1*(F_interp[j][i] - F_perturbe_interp[j][i])/h + except ZeroDivisionError: + message= 'Probleme de division par zéro dans le calcul de la matrice de sensiblité\n ' + message=message+'Le parametre '+para[k]+'est nul ou plus petit que la précision machine \n' + fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') + fic.write(message) + fic.close() + UTMESS('F', "MACR_RECAL", message) + #on construit la matrice de sensiblité sous forme d'un tab num + dim =[] + for i in range(len(L_A)): + dim.append(len(L_A[i])) + dim_totale = Numeric.sum(dim) + a=0 + A = Numeric.zeros((dim_totale,len(val)),Numeric.Float) + for n in range(len(L_A)): + for k in range(len(val)): + for i in range(dim[n]): + A[i+a][k] = L_A[n][i,k] + a=dim[n] + del(L_A) #on ecrase tout ce qu'il y a dans L_A puisqu'on n'en a plus besoin + return A + + + diff --git a/Aster/Cata/cataSTA81/Macro/reca_message.py b/Aster/Cata/cataSTA81/Macro/reca_message.py new file mode 100644 index 00000000..0691b785 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/reca_message.py @@ -0,0 +1,115 @@ +#@ MODIF reca_message Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +import os,Numeric + +#=========================================================================================== + + +# AFFICHAGE DES MESSAGES + +class Message : + """classe gérant l'affichage des messages concernant le déroulement de l'optmisation """ + #Constructeur de la classe + def __init__(self,para,val_init,resu_exp,ul_out): + self.nom_para = para + self.res_exp = resu_exp + res=open(os.getcwd()+'/fort.'+str(ul_out),'a') + res.write(' MACR_RECAL V1.1 \n\n\n') + res.close() + + + def affiche_result_iter(self,iter,J,val,residu,Act,ul_out): + res=open(os.getcwd()+'/fort.'+str(ul_out),'a') + res.write('\n=======================================================\n') + res.write('Iteration '+str(iter)+' :\n') + res.write('\n=> Fonctionnelle = '+str(J)) + res.write('\n=> Résidu = '+str(residu)) + res.write('\n=> Paramètres = ') + for i in range(len(val)): + res.write('\n '+ self.nom_para[i]+' = '+str(val[i]) ) + if (len(Act)!=0): + if (len(Act)==1): + res.write('\n\n Le paramètre ') + else: + res.write('\n\n Les paramètres ') + for i in Act: + res.write(self.nom_para[i]+' ') + if (len(Act)==1): + res.write('\n est en butée sur un bord de leur domaine admissible.') + else: + res.write('\n sont en butée sur un bord de leur domaine admissible.') + res.write('\n=======================================================\n\n') + res.close() + + def affiche_etat_final_convergence(self,iter,max_iter,prec,residu,Act,ul_out): + res=open(os.getcwd()+'/fort.'+str(ul_out),'a') + if ((iter < max_iter) or (residu < prec)): + res.write('\n=======================================================\n') + res.write(' CONVERGENCE ATTEINTE ') + if (len(Act)!=0): + res.write("\n\n ATTENTION : L'OPTIMUM EST ATTEINT AVEC ") + res.write("\n DES PARAMETRES EN BUTEE SUR LE BORD ") + res.write("\n DU DOMAINE ADMISSIBLE ") + res.write('\n=======================================================\n') + res.close() + else: + res.write("\n=======================================================\n") + res.write(' CONVERGENCE NON ATTEINTE ') + res.write("\n Le nombre maximal d'itération ("+str(max_iter)+") a été dépassé") + res.write('\n=======================================================\n') + res.close() + + def affiche_calcul_etat_final(self,para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible,ul_out): + res=open(os.getcwd()+'/fort.'+str(ul_out),'a') + res.write('\n\nValeurs propres du Hessien:\n') + res.write(str( valeurs_propres)) + res.write('\n\nVecteurs propres associés:\n') + res.write(str( vecteurs_propres)) + res.write('\n\n --------') + res.write('\n\nOn peut en déduire que :') + # Paramètres sensibles + if (len(sensible)!=0): + res.write('\n\nLes combinaisons suivantes de paramètres sont prépondérantes pour votre calcul :\n') + k=0 + for i in sensible: + k=k+1 + colonne=vecteurs_propres[:,i] + numero=Numeric.nonzero(Numeric.greater(abs(colonne/max(abs(colonne))),1.E-1)) + res.write('\n '+str(k)+') ') + for j in numero: + res.write('%+3.1E ' %colonne[j]+'* '+para[j]+' ') + res.write('\n associée à la valeur propre %3.1E \n' %valeurs_propres[i]) + # Paramètres insensibles + if (len(insensible)!=0): + res.write('\n\nLes combinaisons suivantes de paramètres sont insensibles pour votre calcul :\n') + k=0 + for i in insensible: + k=k+1 + colonne=vecteurs_propres[:,i] + numero=Numeric.nonzero(Numeric.greater(abs(colonne/max(abs(colonne))),1.E-1)) + res.write('\n '+str(k)+') ') + for j in numero: + res.write('%+3.1E ' %colonne[j]+'* '+para[j]+' ') + res.write('\n associée à la valeur propre %3.1E \n' %valeurs_propres[i]) + res.close() + + + diff --git a/Aster/Cata/cataSTA81/Macro/recal.py b/Aster/Cata/cataSTA81/Macro/recal.py new file mode 100644 index 00000000..a147479e --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/recal.py @@ -0,0 +1,379 @@ +#@ MODIF recal Macro DATE 11/07/2005 AUTEUR PABHHHH N.TARDIEU +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + + + + +import string +import copy +import Numeric +import types +import Gnuplot +import Cata +from Cata.cata import INCLUDE,DETRUIRE +from Accas import _F + +import os + + +#_____________________________________________ +# +# DIVERS UTILITAIRES POUR LA MACRO +#_____________________________________________ + + +# Transforme les donneés entrées par l'utilsateur en tableau Numeric +def transforme_list_Num(parametres,res_exp): + dim_para = len(parametres) #donne le nb de parametres + val_para = Numeric.zeros(dim_para,Numeric.Float) + borne_inf = Numeric.zeros(dim_para,Numeric.Float) + borne_sup = Numeric.zeros(dim_para,Numeric.Float) + para = [] + for i in range(dim_para): + para.append(parametres[i][0]) + val_para[i] = parametres[i][1] + borne_inf[i] = parametres[i][2] + borne_sup[i] = parametres[i][3] + return para,val_para,borne_inf,borne_sup + +def mes_concepts(list_concepts=[],base=None): + # Fonction qui liste les concepts créés + for e in base.etapes: + if e.nom in ('INCLUDE','MACR_RECAL',) : + list_concepts=list(mes_concepts(list_concepts=list_concepts,base=e)) + elif (e.sd != None) and (e.parent.nom=='INCLUDE') : + nom_concept=e.sd.get_name() + if not(nom_concept in list_concepts): + list_concepts.append( nom_concept ) + return tuple(list_concepts) + + +def detr_concepts(self): + liste_concepts=mes_concepts(base=self.parent) + for e in liste_concepts: + nom = string.strip(e) + DETRUIRE( CONCEPT =self.g_context['_F'](NOM = nom),INFO=1) + if self.jdc.g_context.has_key(nom) : del self.jdc.g_context[nom] + del(liste_concepts) + + +def calcul_F(self,UL,para,val,reponses): + fic = open('fort.'+str(UL),'r') + #On stocke le contenu de fort.UL dans la variable fichier qui est un string + fichier=fic.read() + #On stocke le contenu initial de fort.UL dans la variable fichiersauv + fichiersauv=copy.copy(fichier) + fic.close() + + #Fichier_Resu est une liste ou l'on va stocker le fichier modifié + #idée générale :on délimite des 'blocs' dans fichier + #on modifie ou non ces blocs suivant les besoins + #on ajoute ces blocs dans la liste Fichier_Resu + Fichier_Resu=[] + + try: + #cherche l'indice de DEBUT() + index_deb=string.index(fichier,'DEBUT(') + while( fichier[index_deb]!='\n'): + index_deb=index_deb+1 + #on restreind fichier en enlevant 'DEBUT();' + fichier = fichier[index_deb+1:] + except : + #on va dans l'except si on a modifié le fichier au moins une fois + pass + + try: + #cherche l'indice de FIN() + index_fin = string.index(fichier,'FIN(') + #on restreind fichier en enlevant 'FIN();' + fichier = fichier[:index_fin] + except : pass + #-------------------------------------------------------------------------------- + #on cherche à délimiter le bloc des parametres dans le fichier + #Tout d'abord on cherche les indices d'apparition des paras dans le fichier + #en effet l'utilisateur n'est pas obligé de rentrer les paras dans optimise + #avec le meme ordre de son fichier de commande + index_para = Numeric.zeros(len(para)) + for i in range(len(para)): + index_para[i] = string.index(fichier,para[i]) + #On range les indices par ordre croissant afin de déterminer + #les indice_max et indice_min + index_para = Numeric.sort(index_para) + index_first_para = index_para[0] + index_last_para = index_para[len(index_para)-1] + + + #on va délimiter les blocs intermédiaires entre chaque para "utiles" à l'optimsation + bloc_inter ='\n' + for i in range(len(para)-1): + j = index_para[i] + k = index_para[i+1] + while(fichier[j]!= '\n'): + j=j+1 + bloc_inter=bloc_inter + fichier[j:k] + '\n' + + #on veut se placer sur le premier retour chariot que l'on trouve sur la ligne du dernier para + i = index_last_para + while(fichier[i] != '\n'): + i = i + 1 + index_last_para = i + #on délimite les blocs suivants: + pre_bloc = fichier[:index_first_para] #fichier avant premier parametre + post_bloc = fichier[ index_last_para+ 1:] #fichier après dernier parametre + + #on ajoute dans L tous ce qui est avant le premier paramètre + Fichier_Resu.append(pre_bloc) + Fichier_Resu.append('\n') + #On ajoute la nouvelle valeur des parametres + dim_para=len(para) + for j in range(dim_para): + Fichier_Resu.append(para[j]+'='+str(val[j]) + ';' + '\n') + #On ajoute à Fichier_Resu tous ce qui est entre les parametres + Fichier_Resu.append(bloc_inter) + + Fichier_Resu.append(post_bloc) + #-------------------------------------------------------------------------------- + #on va ajouter la fonction d'extraction du numarray de la table par la méthode Array + #et on stocke les réponses calculées dans la liste Lrep + #qui va etre retournée par la fonction calcul_F + self.g_context['Lrep'] = [] + Fichier_Resu.append('Lrep=[]'+'\n') + for i in range(len(reponses)): + Fichier_Resu.append('t'+str(reponses[i][0])+'='+str(reponses[i][0])+'.EXTR_TABLE()'+'\n') + Fichier_Resu.append('_F_ = '+'t'+str(reponses[i][0])+'.Array('+"'"+str(reponses[i][1])+"'"+','+"'"+str(reponses[i][2])+"'"+')'+'\n') + Fichier_Resu.append('Lrep.append(_F_)'+'\n') + + #ouverture du fichier fort.3 et mise a jour de celui ci + x=open('fort.'+str(UL),'w') + x.writelines('from Accas import _F \nfrom Cata.cata import * \n') + x.writelines(Fichier_Resu) + x.close() + del(Fichier_Resu) + del(pre_bloc) + del(post_bloc) + del(fichier) + + INCLUDE(UNITE = UL) + detr_concepts(self) + # on remet le fichier dans son etat initial + x=open('fort.'+str(UL),'w') + x.writelines(fichiersauv) + x.close() + return self.g_context['Lrep'] + +#_____________________________________________ +# +# IMPRESSIONS GRAPHIQUES +#_____________________________________________ + +def graphique(L_F,res_exp,reponses,iter,UL_out,interactif): + graphe=[] + impr=Gnuplot.Gnuplot() + Gnuplot.GnuplotOpts.prefer_inline_data=1 + impr('set data style linespoints') + impr('set grid') + impr('set pointsize 2.') + impr('set terminal postscript color') + impr('set output "fort.'+str(UL_out)+'"') + for i in range(len(L_F)): + if interactif: + graphe.append(Gnuplot.Gnuplot(persist=0)) + graphe[i]('set data style linespoints') + graphe[i]('set grid') + graphe[i]('set pointsize 2.') + graphe[i].xlabel(reponses[i][1]) + graphe[i].ylabel(reponses[i][2]) + graphe[i].title(reponses[i][0]+' Iteration '+str(iter)) + graphe[i].plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental')) + graphe[i]('pause 5') +# + impr.xlabel(reponses[i][1]) + impr.ylabel(reponses[i][2]) + impr.title(reponses[i][0]+' Iteration '+str(iter)) + impr.plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental')) + + +#_____________________________________________ +# +# CONTROLE DES ENTREES UTILISATEUR +#_____________________________________________ + +def erreur_de_type(code_erreur,X): + #code_erreur ==0 --> X est une liste + #code erreur ==1 --> X est un char + #code erreur ==2 --> X est un float + #test est un boolean (test = 0 défaut et 1 si un test if est verifier + txt="" + if(code_erreur == 0 ): + if type(X) is not types.ListType: + txt="\nCette entrée: " +str(X)+" n'est pas une liste valide" + if(code_erreur == 1 ): + if type(X) is not types.StringType: + txt="\nCette entrée: " +str(X)+" n'est pas une chaine de caractère valide ; Veuillez la ressaisir en lui appliquant le type char de python" + if(code_erreur == 2 ): + if type(X) is not types.FloatType: + txt="\nCette entrée: " +str(X)+" n'est pas une valeur float valide ; Veuillez la ressaisir en lui appliquant le type float de python" + return txt + + +def erreur_dimension(PARAMETRES,REPONSES): +#On verifie que la dimension de chaque sous_liste de parametre est 4 +#et que la dimension de chaque sous_liste de REPONSES est 3 + txt="" + for i in range(len(PARAMETRES)): + if (len(PARAMETRES[i]) != 4): + txt=txt + "\nLa sous-liste de la variable paramètre numéro " + str(i+1)+" n'est pas de longueur 4" + for i in range(len(REPONSES)): + if (len(REPONSES[i]) != 3): + txt=txt + "\nLa sous-liste de la variable réponse numéro " + str(i+1)+" n'est pas de longueur 3" + return txt + + +def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP): + # X et Y sont deux arguments qui doivent avoir la meme dimension + # pour éviter l'arret du programme + txt="" + if( len(REPONSES) != len(RESU_EXP)): + txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux" + return txt + +def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP): + # POIDS et Y sont deux arguments qui doivent avoir la meme dimension + # pour éviter l'arret du programme + txt="" + if( len(POIDS) != len(RESU_EXP)): + txt="\nVous avez entré " +str(len(POIDS))+ " poids et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de poids que de résultats expérimentaux" + return txt + + +def verif_fichier(UL,PARAMETRES,REPONSES): +#On verifie les occurences des noms des PARAMETRES et REPONSES +#dans le fichier de commande ASTER + txt="" + fichier = open('fort.'+str(UL),'r') + fic=fichier.read() + for i in range(len(PARAMETRES)): + if((string.find(fic,PARAMETRES[i][0])==-1) or ((string.find(fic,PARAMETRES[i][0]+'=')==-1) and (string.find(fic,PARAMETRES[i][0]+' ')==-1))): + txt=txt + "\nLe paramètre "+PARAMETRES[i][0]+" que vous avez entré pour la phase d'optimisation n'a pas été trouvé dans votre fichier de commandes ASTER" + for i in range(len(REPONSES)): + if((string.find(fic,REPONSES[i][0])==-1) or ((string.find(fic,REPONSES[i][0]+'=')==-1) and (string.find(fic,REPONSES[i][0]+' ')==-1))): + txt=txt + "\nLa réponse "+REPONSES[i][0]+" que vous avez entrée pour la phase d'optimisation n'a pas été trouvée dans votre fichier de commandes ASTER" + return txt + + +def verif_valeurs_des_PARAMETRES(PARAMETRES): +#On verifie que pour chaque PARAMETRES de l'optimisation +# les valeurs entrées par l'utilisateur sont telles que : +# val_infPARAMETRES[i][3]): + txt=txt + "\nLa borne inférieure "+str(PARAMETRES[i][2])+" de "+PARAMETRES[i][0]+ "est plus grande que sa borne supérieure"+str(PARAMETRES[i][3]) + #verification de l'encadrement de val_init + for i in range(len(PARAMETRES)): + if( (PARAMETRES[i][1] < PARAMETRES[i][2]) or (PARAMETRES[i][1] > PARAMETRES[i][3])): + txt=txt + "\nLa valeur initiale "+str(PARAMETRES[i][1])+" de "+PARAMETRES[i][0]+ " n'est pas dans l'intervalle [borne_inf,born_inf]=["+str(PARAMETRES[i][2])+" , "+str(PARAMETRES[i][3])+"]" + #verification que val_init !=0 + for i in range(len(PARAMETRES)): + if (PARAMETRES[i][1] == 0. ): + txt=txt + "\nProblème de valeurs initiales pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur initiale nulle mais un ordre de grandeur." + #verification que borne_sup !=0 + for i in range(len(PARAMETRES)): + if (PARAMETRES[i][3] == 0. ): + txt=txt + "\nProblème de borne supérieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle." + #verification que borne_inf !=0 + for i in range(len(PARAMETRES)): + if (PARAMETRES[i][2] == 0. ): + txt=txt + "\nProblème de borne inférieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle." + return txt + + +def verif_UNITE(GRAPHIQUE,UNITE_RESU): + # On vérifie que les unités de résultat et + # de graphique sont différentes + txt="" + GRAPHE_UL_OUT=GRAPHIQUE['UNITE'] + if (GRAPHE_UL_OUT==UNITE_RESU): + txt=txt + "\nLes unités logiques des fichiers de résultats graphiques et de résultats d'optimisation sont les memes." + return txt + + + +def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU): + #Cette methode va utiliser les methodes de cette classe declarée ci_dessus + #test est un boolean: test=0 -> pas d'erreur + # test=1 -> erreur détectée + + texte="" + #On vérifie d'abord si PARAMETRES, REPONSES, RESU_EXP sont bien des listes au sens python + #test de PARAMETRES + texte = texte + erreur_de_type(0,PARAMETRES) + #test de REPONSES + texte = texte + erreur_de_type(0,REPONSES) + #test de RESU_EXP + texte = texte + erreur_de_type(0,RESU_EXP) + + #On vérifie si chaque sous liste de PARAMETRES, REPONSES, possède le type adéquat + #test des sous_listes de PARAMETRES + for i in range(len(PARAMETRES)): + texte = texte + erreur_de_type(0,PARAMETRES[i]) + #test des sous_listes de REPONSES + for i in range(len(REPONSES)): + texte = texte + erreur_de_type(0,REPONSES[i]) + + #On verifie si la dimension de chaque sous-liste de : PARAMETRES, REPONSES + #il faut que:la dimension d'une sous-liste de PARAMETRES = 4 + #et que la dimension d'une sous liste de REPONSES = 3 + texte = texte + erreur_dimension(PARAMETRES,REPONSES) + + #on verifie que l'on a autant de réponses que de résultats expérimentaux + texte = texte + compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP) + #on verifie que l'on a autant de poids que de résultats expérimentaux + texte = texte + compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP) + + #on verifie les types des arguments de chaque sous liste de PARAMETRES et REPONSES + #verification du type stringet type float des arguments de PARAMETRES + for i in range(len(PARAMETRES)): + texte = texte + erreur_de_type(1,PARAMETRES[i][0]) + for k in [1,2,3]: + texte = texte + erreur_de_type(2,PARAMETRES[i][k]) + + #verification du type string pour les arguments de REPONSES + for i in range(len(REPONSES)): + for j in range(len(REPONSES[i])): + texte = texte + erreur_de_type(1,REPONSES[i][j]) + + #verification du fichier de commndes ASTER + texte = texte + verif_fichier(UL,PARAMETRES,REPONSES) + + #verifiaction des valeurs des PARAMETRES entrées par l'utilisteur + texte = texte + verif_valeurs_des_PARAMETRES(PARAMETRES) + + #verifiaction des unités logiques renseignées par l'utilisateur + texte = texte + verif_UNITE(GRAPHIQUE,UNITE_RESU) + + return texte + + diff --git a/Aster/Cata/cataSTA81/Macro/stanley_ops.py b/Aster/Cata/cataSTA81/Macro/stanley_ops.py new file mode 100644 index 00000000..a7ff6531 --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/stanley_ops.py @@ -0,0 +1,66 @@ +#@ MODIF stanley_ops Macro DATE 14/06/2005 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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 stanley_ops(self,RESULTAT,MODELE,CHAM_MATER,CARA_ELEM,**args): + + """ + Importation et lancement de Stanley + """ + + import os,string + import aster + from Accas import _F + from Noyau.N_utils import AsType + from Utilitai.Utmess import UTMESS + + ier=0 + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + + # On ne lance Stanley que si la variable DISPLAY est définie + if os.environ.has_key('DISPLAY'): + + import Stanley + from Stanley import stanley + + if (RESULTAT and MODELE and CHAM_MATER): + _MAIL = aster.getvectjev( string.ljust(MODELE.nom,8) + '.MODELE .NOMA ' ) + _MAIL = string.strip(_MAIL[0]) + MAILLAGE = self.jdc.g_context[_MAIL] + if CARA_ELEM: + stanley.STANLEY(RESULTAT,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM) + else: + stanley.STANLEY(RESULTAT,MAILLAGE,MODELE,CHAM_MATER,None) + else: + stanley.PRE_STANLEY() + + else: + UTMESS('A','STANLEY', + """Aucune variable d'environnement DISPLAY définie ! + STANLEY ne pourra pas fonctionner. On l'ignore. + + Si vous etes en Interactif, cochez le bouton Suivi Interactif + dans ASTK.""") + + return ier diff --git a/Aster/Cata/cataSTA81/Macro/test_fichier_ops.py b/Aster/Cata/cataSTA81/Macro/test_fichier_ops.py new file mode 100644 index 00000000..13487d1f --- /dev/null +++ b/Aster/Cata/cataSTA81/Macro/test_fichier_ops.py @@ -0,0 +1,245 @@ +#@ MODIF test_fichier_ops Macro DATE 19/09/2005 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 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 sys +import os.path +import re +import string +import math +import md5 + +#------------------------------------------------------------------------------- +def test_fichier_ops(self, UNITE, FICHIER, NB_CHIFFRE, EPSILON, VALE_K, INFO, **args): + """ + Macro TEST_FICHIER permettant de tester la non-regression d'un fichier + 'a une tolerance' pres pour les nombres reels en calculant + le md5sum. + """ + import aster + from Accas import _F + ier=0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # On importe les definitions des commandes a utiliser dans la macro + # Le nom de la variable doit etre obligatoirement le nom de la commande + INFO_EXEC_ASTER = self.get_cmd('INFO_EXEC_ASTER') + DETRUIRE = self.get_cmd('DETRUIRE') + CREA_TABLE = self.get_cmd('CREA_TABLE') + TEST_TABLE = self.get_cmd('TEST_TABLE') + + import os.path + import re + from types import StringType + + import aster + from Macro.test_fichier_ops import md5file + from Utilitai.Utmess import UTMESS + + # vérifie la syntaxe des expressions régulières fournies + l_regexp=[] + if args['EXPR_IGNORE']: + if type(args['EXPR_IGNORE']) is StringType: + lexp = [args['EXPR_IGNORE']] + else: + lexp = args['EXPR_IGNORE'] + for exp in lexp: + try: + obj=re.compile(exp) + except re.error, s: + UTMESS('F', 'TEST_FICHIER', + ' %s pour %s' % (str(s), repr(exp))) + else: + l_regexp.append(exp) + if len(l_regexp) < len(lexp): + self.cr.fatal(' Expression régulière invalide (voir )') + + + is_ok=0 + + # vérifier que le fichier a été fermé + tinfo__ = INFO_EXEC_ASTER(LISTE_INFO='ETAT_UNITE', FICHIER=FICHIER) + + if tinfo__['ETAT_UNITE',1].find('OUVERT')>-1: + UTMESS('A', 'TEST_FICHIER', + "LE FICHIER N'A PAS ETE FERME :\n%s" % FICHIER) + + # fichier correctement fermé + else: + # calcule le md5sum du fichier + ier, mdsum = md5file(FICHIER, NB_CHIFFRE, EPSILON, l_regexp, INFO) + if ier != 0: + if ier==4: + texte_erreur='Fichier inexistant : '+FICHIER + else: + texte_erreur='Erreur dans md5file, code retour = '+str(ier) + texte_erreur=' '+texte_erreur + # aujourd'hui, je ne sais pas déclencher autre chose que ... + self.cr.fatal(texte_erreur) + return ier + + # comparaison a la reference + if INFO > 0 : + aster.affiche('MESSAGE',' %-20s : %32s\n' % ('REFERENCE',VALE_K)) + + if mdsum == VALE_K: + is_ok=1 + + # produit le TEST_TABLE + tab1__=CREA_TABLE(LISTE=(_F(PARA='TEST', + TYPE_K='K8', + LISTE_K='VALEUR ',), + _F(PARA='BOOLEEN', + LISTE_I=is_ok,),),) + if args['REFERENCE'] == 'NON_REGRESSION': + TEST_TABLE(UNITE=UNITE, + TABLE=tab1__, + FILTRE=_F(NOM_PARA='TEST', + VALE_K='VALEUR ',), + NOM_PARA='BOOLEEN', + VALE_I=1, + PRECISION=1.e-3, + CRITERE='ABSOLU', + REFERENCE=args['REFERENCE'], + VERSION=args['VERSION'],) + else: + TEST_TABLE(UNITE=UNITE, + TABLE=tab1__, + FILTRE=_F(NOM_PARA='TEST', + VALE_K='VALEUR ',), + NOM_PARA='BOOLEEN', + VALE_I=1, + PRECISION=1.e-3, + CRITERE='ABSOLU', + REFERENCE=args['REFERENCE'],) + + DETRUIRE(CONCEPT=_F(NOM=('tinfo__','tab1__'),), + ALARME='NON',INFO=1,) + return ier + + +#------------------------------------------------------------------------------- +def md5file(fich, nbch, epsi, regexp_ignore=[], info=0, output=None): + """ + Cette methode retourne le md5sum d'un fichier en arrondissant les nombres + reels a la valeur significative. + IN : + fich : nom du fichier + nbch : nombre de decimales significatives + epsi : valeur en deca de laquelle on prend 0 + regexp_ignore : liste d'expressions régulières permettant d'ignorer + certaines lignes + output : pour rediriger l'interprétation du fichier (INFO=2) + dans le fichier de nom `output`. + OUT : + code retour : 0 si ok, >0 sinon + md5sum + + NE PAS AJOUTER D'IMPORT QUI RENDRAIT CETTE FONCTION + INUTILISABLE EN DEHORS DE CODE_ASTER. + """ + if output<>None: + try: + sys.stdout=open(output, 'w') + except IOError, msg: + print "Erreur d'écriture sur %s : %s" % (fout, msg) + + # 1 Mo 10 Mo 100 Mo + # v0 2.6 s 20.4 s 196.6 s + # v1 2.0 s 10.3 s 94.9 s (pas de distinction entier/reel) + # remplacer le try/except par if re.search(...), 80% plus lent + if not os.path.isfile(fich): + return 4, '' + f=open(fich,'r') + format_float='%'+str(nbch+7)+'.'+str(nbch)+'g' + m=md5.new() + i=0 + for ligne in f: + i=i+1 + if info>=2: + print 'LIGNE',i, + keep=True + for exp in regexp_ignore: + if re.search(exp,ligne): + keep=False + if info>=2: + print ' >>>>>>>>>> IGNOREE <<<<<<<<<<', + break + if keep: + # découpe des nombres collés : 1.34E-142-1.233D+09 + ligne=re.sub('([0-9]+)\-','\g<1> -',ligne) + # conversion des DOUBLE fortran en 'E' + ligne=re.sub('([0-9]+)[dD]([\-\+]{0,1}[0-9]+)','\g<1>E\g<2>',ligne) + r=string.split(ligne) + for x in r: + try: + if abs(float(x))=2: + print (' %'+str(nbch+7)+'s') % s, + m.update(s) + if info>=2: + print + f.close() + md5sum=m.hexdigest() + + affich_resu=True + if info>=1: + while affich_resu: + form=' %-20s : %32s' + print form % ('Fichier',fich) + print form % ('Nombre de lignes',str(i)) + print form % ('Format des reels',format_float) + print form % ('Epsilon',str(epsi)) + print form % ('md5sum',md5sum) + if output==None: + affich_resu=False + else: + sys.stdout=sys.__stdout__ + output=None + return 0, md5sum + + +#------------------------------------------------------------------------------- +if __name__ == '__main__': + from optparse import OptionParser, OptionGroup + + p=OptionParser(usage='usage: %s a_tester [options]' % sys.argv[0]) + p.add_option('-n', '--nbch', + action='store', dest='nbch', type='int', default=6, + help='nombre de chiffres significatifs') + p.add_option('-e', '--epsilon', + action='store', dest='epsi', type='float', default=1.e-14, + help='epsilon en dessous duquel on considère les nombres nuls') + p.add_option('-o', '--output', + action='store', dest='output', type='string', default='output.txt', + help='fichier de sortie') + opts, args = p.parse_args() + + if len(args)<1: + p.print_usage() + sys.exit(1) + + print 'Lignes retenues dans %s' % opts.output + iret = md5file(args[0], opts.nbch, opts.epsi, info=2, output=opts.output) diff --git a/Aster/editeur.ini b/Aster/editeur.ini index 6d8a07b1..32cfbe11 100644 --- a/Aster/editeur.ini +++ b/Aster/editeur.ini @@ -23,7 +23,7 @@ import os import prefs rep_cata = os.path.join(prefs.REPINI,'Cata') -rep_homard = os.path.join(prefs.REPINI,'../Homard') +#rep_homard = os.path.join(prefs.REPINI,'../Homard') rep_Pmw = os.path.join(prefs.REPINI,'../Pmw') # Accès à la documentation Aster @@ -38,13 +38,16 @@ rep_travail = "/tmp" initialdir=os.curdir # Choix des catalogues -rep_mat="materiau" +rep_mat="//home/noyret/Install_Eficas/materiau" catalogues = ( #('ASTER','v5',os.path.join(rep_cata,'cataSTA5'),'asterv5'), - ('ASTER','v6',os.path.join(rep_cata,'cataSTA6'),'python6'), + #('ASTER','v6',os.path.join(rep_cata,'cataSTA6'),'python6'), #('ASTER','v73',os.path.join(rep_cata,'cataSTA73'),'python','defaut'), - ('ASTER','v74',os.path.join(rep_cata,'cataSTA74'),'python'), - ('ASTER','v8',os.path.join(rep_cata,'cataSTA8'),'python','defaut'), + #('ASTER','v74',os.path.join(rep_cata,'cataSTA74'),'python'), + #('ASTER','v8',os.path.join(rep_cata,'cataSTA8'),'python','defaut'), + ('ASTER','v81',os.path.join(rep_cata,'cataSTA81'),'python','defaut'), + #('ASTER','v75',os.path.join(rep_cata,'cataSTA75'),'python','defaut'), + #('HOMARD','v1',os.path.join(rep_homard,'homard_cata_V73.py'),'homard'), ) diff --git a/Aster/properties.py b/Aster/properties.py index 302cea10..6aabead2 100644 --- a/Aster/properties.py +++ b/Aster/properties.py @@ -1,4 +1,4 @@ -#@ MODIF properties Accas DATE 01/06/2005 AUTEUR gcbhhhh M.ADMINISTRATEUR +#@ MODIF properties Accas DATE 28/09/2005 AUTEUR gcbhhhh M.ADMINISTRATEUR # CONFIGURATION MANAGEMENT OF EDF VERSION # RESPONSABLE D6BHHHH J-P.LEFEBVRE # ====================================================================== @@ -20,5 +20,5 @@ # IDENTIFICATION DU GESTIONNAIRE DE COMMANDE ACCAS A PARTIR # DE LA VERSION DU CODE_ASTER ASSOCIE #---------------------------------------------------------------------- -version = "8.0.23" -date = "01/06/2005" +version = "8.1.16" +date = "28/09/2005"