def macro_bascule_schema_ops(self, MODELE, CHAM_MATER, CARA_ELEM, INCR_IMPL,
INCR_EXPL, SCHEMA_TEMPS_IMPL, SCHEMA_TEMPS_EXPL,
SCHEMA_TEMPS_EQUI, COMPORTEMENT_IMPL,
COMPORTEMENT_EXPL, CONVERGENCE, EXCIT, NEWTON,
ETAT_INIT, LIST_INST_BASCULE, SCHEMA_INIT,
EQUILIBRAGE, SOLVEUR, ARCHIVAGE, OBSERVATION,
ENERGIE, **args):
ier = 0
import copy
import aster
import string
import types
from code_aster.Cata.Syntax import _F
from Noyau.N_utils import AsType
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
# On importe les definitions des commandes a utiliser dans la macro
DYNA_NON_LINE = self.get_cmd('DYNA_NON_LINE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant (de type evol_noli) est nommé
# 'nomres' dans le contexte de la macro
self.DeclareOut('nomres', self.sd)
#
motscles = {}
motscles['MODELE'] = MODELE
motscles['CHAM_MATER'] = CHAM_MATER
if CARA_ELEM != None:
motscles['CARA_ELEM'] = CARA_ELEM
#
dexct = []
for j in EXCIT:
dexct.append(j.cree_dict_valeurs(j.mc_liste))
for i in dexct[-1].keys():
if dexct[-1][i] == None:
del dexct[-1][i]
#
dComp_incri = []
for j in COMPORTEMENT_IMPL:
dComp_incri.append(j.cree_dict_valeurs(j.mc_liste))
for i in dComp_incri[-1].keys():
if dComp_incri[-1][i] == None:
del dComp_incri[-1][i]
#
dComp_incre = []
for j in COMPORTEMENT_EXPL:
dComp_incre.append(j.cree_dict_valeurs(j.mc_liste))
for i in dComp_incre[-1].keys():
if dComp_incre[-1][i] == None:
del dComp_incre[-1][i]
#
dincri = []
for j in INCR_IMPL:
dincri.append(j.cree_dict_valeurs(j.mc_liste))
for i in dincri[-1].keys():
if dincri[-1][i] == None:
del dincri[-1][i]
#
dincre = []
for j in INCR_EXPL:
dincre.append(j.cree_dict_valeurs(j.mc_liste))
for i in dincre[-1].keys():
if dincre[-1][i] == None:
del dincre[-1][i]
#
dschi = []
for j in SCHEMA_TEMPS_IMPL:
dschi.append(j.cree_dict_valeurs(j.mc_liste))
for i in dschi[-1].keys():
if dschi[-1][i] == None:
del dschi[-1][i]
#
dsche = []
for j in SCHEMA_TEMPS_EXPL:
dsche.append(j.cree_dict_valeurs(j.mc_liste))
for i in dsche[-1].keys():
if dsche[-1][i] == None:
del dsche[-1][i]
#
dscheq = []
for j in SCHEMA_TEMPS_EQUI:
dscheq.append(j.cree_dict_valeurs(j.mc_liste))
for i in dscheq[-1].keys():
if dscheq[-1][i] == None:
del dscheq[-1][i]
#
dnew = []
for j in NEWTON:
dnew.append(j.cree_dict_valeurs(j.mc_liste))
for i in dnew[-1].keys():
if dnew[-1][i] == None:
del dnew[-1][i]
#
dconv = []
for j in CONVERGENCE:
dconv.append(j.cree_dict_valeurs(j.mc_liste))
for i in dconv[-1].keys():
if dconv[-1][i] == None:
del dconv[-1][i]
#
dini = []
for j in ETAT_INIT:
dini.append(j.cree_dict_valeurs(j.mc_liste))
for i in dini[-1].keys():
if dini[-1][i] == None:
del dini[-1][i]
#
dequi = []
for j in EQUILIBRAGE:
dequi.append(j.cree_dict_valeurs(j.mc_liste))
for i in dequi[-1].keys():
if dequi[-1][i] == None:
del dequi[-1][i]
#
dsolv = []
for j in SOLVEUR:
dsolv.append(j.cree_dict_valeurs(j.mc_liste))
for i in dsolv[-1].keys():
if dsolv[-1][i] == None:
del dsolv[-1][i]
#
dobs = []
if type(OBSERVATION) is not types.NoneType:
for j in OBSERVATION:
dobs.append(j.cree_dict_valeurs(j.mc_liste))
for i in dobs[-1].keys():
if dobs[-1][i] == None:
del dobs[-1][i]
#
darch = []
if type(ARCHIVAGE) is not types.NoneType:
for j in ARCHIVAGE:
darch.append(j.cree_dict_valeurs(j.mc_liste))
for i in darch[-1].keys():
if darch[-1][i] == None:
del darch[-1][i]
#
dener = []
if type(ENERGIE) is not types.NoneType:
for j in ENERGIE:
dener.append(j.cree_dict_valeurs(j.mc_liste))
for i in dener[-1].keys():
if dener[-1][i] == None:
del dener[-1][i]
#
__L0 = LIST_INST_BASCULE['VALE']
dincri1 = copy.copy(dincri)
dincri1[-1]['INST_FIN'] = __L0[0]
#
__dtimp = dequi[-1]['PAS_IMPL']
__dtexp = dequi[-1]['PAS_EXPL']
#
__dim = (-1) * len(dComp_incri)
__lis = range(0, __dim, -1)
__non_lin = 'NON'
for i in __lis:
if (dComp_incri[i]['RELATION'] != 'DIS_CHOC'
and dComp_incri[i]['RELATION'] != 'ELAS'):
__non_lin = 'OUI'
break
#
#
# alarme de DYNA_NON_LINE si les mot-cles de COMPORTEMENT sont renseignes
# a tort
MasquerAlarme('COMPOR4_70')
if SCHEMA_INIT == 'IMPLICITE':
dincri1 = copy.copy(dincri)
dincri1[-1]['INST_FIN'] = __L0[0]
nomres = DYNA_NON_LINE(EXCIT=dexct,
COMPORTEMENT=dComp_incri,
INCREMENT=dincri1,
SCHEMA_TEMPS=dschi,
NEWTON=dnew,
CONVERGENCE=dconv,
SOLVEUR=dsolv,
ENERGIE=dener,
OBSERVATION=dobs,
ARCHIVAGE=darch,
ETAT_INIT=dini,
**motscles)
__prc = 'IMPLICITE'
#
if SCHEMA_INIT == 'EXPLICITE':
dincre1 = copy.copy(dincre)
dincre1[-1]['INST_FIN'] = __L0[0]
nomres = DYNA_NON_LINE(MASS_DIAG='OUI',
EXCIT=dexct,
COMPORTEMENT=dComp_incre,
INCREMENT=dincre1,
SCHEMA_TEMPS=dsche,
NEWTON=dnew,
CONVERGENCE=dconv,
SOLVEUR=dsolv,
ENERGIE=dener,
OBSERVATION=dobs,
ARCHIVAGE=darch,
ETAT_INIT=dini,
**motscles)
__prc = 'EXPLICITE'
#
__nb = len(__L0)
j = 1
while 1:
#
if __prc == 'IMPLICITE':
__Ue = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='DEPL',
INST=__L0[j - 1],
)
#
__Ve = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='VITE',
INST=__L0[j - 1],
)
#
__Ae = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='ACCE',
INST=__L0[j - 1],
)
#
__Ce = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='ELGA_SIEF_R',
NOM_CHAM='SIEF_ELGA',
INST=__L0[j - 1],
)
#
__Vae = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='ELGA_VARI_R',
NOM_CHAM='VARI_ELGA',
INST=__L0[j - 1],
)
dincre1 = copy.copy(dincre)
dincre1[-1]['INST_INIT'] = __L0[j - 1]
if (j < __nb):
dincre1[-1]['INST_FIN'] = __L0[j]
else:
del dincre1[-1]['INST_FIN']
nomres = DYNA_NON_LINE(reuse=nomres,
EXCIT=dexct,
ETAT_INIT=_F(
DEPL=__Ue,
VITE=__Ve,
ACCE=__Ae,
SIGM=__Ce,
VARI=__Vae,
),
COMPORTEMENT=dComp_incre,
INCREMENT=dincre1,
SCHEMA_TEMPS=dsche,
SOLVEUR=dsolv,
ENERGIE=dener,
OBSERVATION=dobs,
ARCHIVAGE=darch,
NEWTON=dnew,
CONVERGENCE=dconv,
**motscles)
#
__prc = 'EXPLICITE'
bool = (j != (__nb))
if (not bool):
break
j = j + 1
#
if __prc == 'EXPLICITE':
# calcul sur la zone de recouvrement
print('Calcul d' 'une solution explicite stabilisée')
__U1 = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='DEPL',
INST=__L0[j - 1],
)
#
__V1 = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='VITE',
INST=__L0[j - 1],
)
#
__A1 = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='ACCE',
INST=__L0[j - 1],
)
#
__C1 = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='ELGA_SIEF_R',
NOM_CHAM='SIEF_ELGA',
INST=__L0[j - 1],
)
#
__Va1 = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='ELGA_VARI_R',
NOM_CHAM='VARI_ELGA',
INST=__L0[j - 1],
)
#
__lrec = DEFI_LIST_REEL(
DEBUT=__L0[j - 1],
INTERVALLE=_F(JUSQU_A=(__L0[j - 1]) + (10 * (__dtexp)),
PAS=__dtexp),
)
schema_equi = dscheq[-1]['SCHEMA']
if (schema_equi == 'TCHAMWA') or (schema_equi == 'DIFF_CENT'):
masse_diago = 'OUI'
else:
masse_diago = 'NON'
__u_rec = DYNA_NON_LINE(MASS_DIAG=masse_diago,
EXCIT=dexct,
ETAT_INIT=_F(
DEPL=__U1,
VITE=__V1,
ACCE=__A1,
SIGM=__C1,
VARI=__Va1,
),
COMPORTEMENT=dComp_incre,
INCREMENT=_F(LIST_INST=__lrec,
INST_INIT=__L0[j - 1],
INST_FIN=(__L0[j - 1]) +
(10 * (__dtexp))),
SCHEMA_TEMPS=dscheq,
SOLVEUR=dsolv,
ENERGIE=dener,
OBSERVATION=dobs,
ARCHIVAGE=darch,
NEWTON=dnew,
CONVERGENCE=dconv,
**motscles)
#
__Ui = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=__u_rec,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='DEPL',
INST=(__L0[j - 1]) + (10 * (__dtexp)),
)
#
__Vi = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=__u_rec,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='VITE',
INST=(__L0[j - 1]) + (10 * (__dtexp)),
)
#
__Ai = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=__u_rec,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='ACCE',
INST=(__L0[j - 1]) + (10 * (__dtexp)),
)
#
# equilibrage du premier pas implicite
print('Equilibrage du pas explicite stabilisée')
dincri1 = copy.copy(dincri)
dincri1[-1]['INST_FIN'] = ((__L0[j - 1]) + (10 * (__dtexp)))
dincri1[-1]['INST_INIT'] = (__L0[j - 1])
nomres = DYNA_NON_LINE(reuse=nomres,
EXCIT=dexct,
ETAT_INIT=_F(
DEPL=__Ui,
VITE=__Vi,
ACCE=__Ai,
SIGM=__C1,
VARI=__Va1,
),
COMPORTEMENT=dComp_incri,
INCREMENT=dincri1,
SCHEMA_TEMPS=dschi,
SOLVEUR=dsolv,
ENERGIE=dener,
OBSERVATION=dobs,
ARCHIVAGE=darch,
NEWTON=dnew,
CONVERGENCE=dconv,
**motscles)
#
__Ui = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='DEPL',
INST=(__L0[j - 1]) + (10 * (__dtexp)),
)
#
__Vi = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='VITE',
INST=(__L0[j - 1]) + (10 * (__dtexp)),
)
#
__Ai = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='ACCE',
INST=(__L0[j - 1]) + (10 * (__dtexp)),
)
#
__Ci = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='ELGA_SIEF_R',
NOM_CHAM='SIEF_ELGA',
INST=(__L0[j - 1]) + (10 * (__dtexp)),
)
#
__Vai = CREA_CHAMP(
OPERATION='EXTR',
PRECISION=1.E-7,
RESULTAT=nomres,
TYPE_CHAM='ELGA_VARI_R',
NOM_CHAM='VARI_ELGA',
INST=(__L0[j - 1]) + (10 * (__dtexp)),
)
#
print('Calcul implicite après équilibrage')
dincri1 = copy.copy(dincri)
dincri1[-1]['INST_INIT'] = ((__L0[j - 1]) + (10 * (__dtexp)))
if (j < __nb):
dincri1[-1]['INST_FIN'] = __L0[j]
else:
del dincri1[-1]['INST_FIN']
nomres = DYNA_NON_LINE(reuse=nomres,
EXCIT=dexct,
ETAT_INIT=_F(
DEPL=__Ui,
VITE=__Vi,
ACCE=__Ai,
SIGM=__Ci,
VARI=__Vai,
),
COMPORTEMENT=dComp_incri,
INCREMENT=dincri1,
SCHEMA_TEMPS=dschi,
SOLVEUR=dsolv,
ENERGIE=dener,
OBSERVATION=dobs,
ARCHIVAGE=darch,
NEWTON=dnew,
CONVERGENCE=dconv,
**motscles)
#
__prc = 'IMPLICITE'
bool = (j != (__nb))
if (not bool):
break
j = j + 1
#
RetablirAlarme('COMPOR4_70')
return ier
def test_compor_ops(self, OPTION, NEWTON, CONVERGENCE, COMPORTEMENT,
LIST_MATER, VARI_TEST, INFO, **args):
# seule l'option "THER", c'est à dire le test thermomecanique est programmé à ce jour
# ajouter l'option MECA (tests comp001,002), l'option HYDR, etc..
from code_aster.Cata.Syntax import _F
import numpy as NP
from Contrib.veri_matr_tang import VERI_MATR_TANG
from Utilitai.Utmess import MasquerAlarme, RetablirAlarme
self.update_const_context({'ERREUR': ERREUR})
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant (de type fonction) est nomme U dans
# le contexte de la macro
if COMPORTEMENT:
self.DeclareOut('U', self.sd)
# On importe les definitions des commandes a utiliser dans la macro
CALC_TABLE = self.get_cmd('CALC_TABLE')
DEFI_CONSTANTE = self.get_cmd('DEFI_CONSTANTE')
DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
DEFI_LIST_INST = self.get_cmd('DEFI_LIST_INST')
DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU')
DETRUIRE = self.get_cmd('DETRUIRE')
FORMULE = self.get_cmd('FORMULE')
DEBUG = self.get_cmd('DEBUG')
IMPR_FONCTION = self.get_cmd('IMPR_FONCTION')
SIMU_POINT_MAT = self.get_cmd('SIMU_POINT_MAT')
TEST_TABLE = self.get_cmd('TEST_TABLE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
motscles = {}
if COMPORTEMENT:
motscles['COMPORTEMENT'] = COMPORTEMENT.List_F()
motscles['CONVERGENCE'] = CONVERGENCE.List_F()
motscles['NEWTON'] = NEWTON.List_F()
if OPTION == "THER":
epsi = 1.E-10
MATER = args['MATER']
ALPHA = args['ALPHA']
YOUNG = args['YOUNG']
TEMP_INIT = args['TEMP_INIT']
TEMP_FIN = args['TEMP_FIN']
NB_VARI = args['NB_VARI']
if args['INST_FIN'] != None:
INST_FIN = args['INST_FIN']
NCAL = len(LIST_MATER)
__LINST0 = DEFI_LIST_REEL(
DEBUT=0.,
INTERVALLE=(_F(
JUSQU_A=INST_FIN,
NOMBRE=NCAL,
), ),
)
__LINST = DEFI_LIST_INST(
METHODE='MANUEL',
DEFI_LIST=_F(LIST_INST=__LINST0,
# PAS_MINI=1.0E-12
),
ECHEC=_F(EVENEMENT='ERREUR',
ACTION='DECOUPE',
SUBD_METHODE='MANUEL',
SUBD_PAS=10),
# ADAPTATION=_F(EVENEMENT='SEUIL'),
)
__TIMP = DEFI_FONCTION(NOM_PARA='INST',
NOM_RESU='TEMP',
VALE=(0., TEMP_INIT, INST_FIN, TEMP_FIN))
__zero = DEFI_CONSTANTE(VALE=0.)
if args['SUPPORT'] != None:
motscles['SUPPORT'] = args['SUPPORT']
__U = SIMU_POINT_MAT(MATER=MATER,
INFO=INFO,
AFFE_VARC=(_F(NOM_VARC='TEMP',
VALE_FONC=__TIMP,
VALE_REF=TEMP_INIT), ),
INCREMENT=_F(LIST_INST=__LINST, ),
EPSI_IMPOSE=_F(EPXX=__zero, ),
**motscles)
# On ne garde pas les valeurs initiales (NUME_ORDRE = 0 exclu)
__U = CALC_TABLE(
reuse=__U,
TABLE=__U,
ACTION=(_F(
OPERATION='FILTRE',
NOM_PARA='INST',
CRIT_COMP='GT',
VALE=0.,
), ),
)
SXM = 0.
EXM = 0.
time = 0.
__RES = [None] * (NCAL)
if (NB_VARI > 0):
Vim = NP.zeros(NB_VARI)
for i in range(NCAL):
timem = time
time = timem + INST_FIN / NCAL
Ti = TEMP_INIT + time / INST_FIN * (TEMP_FIN - TEMP_INIT)
Tm = TEMP_INIT + timem / INST_FIN * (TEMP_FIN - TEMP_INIT)
# deformation mecanique imposee correspondant a la deformation
# thermique du premier calcul
__epsimp = DEFI_CONSTANTE(VALE=-ALPHA(Ti) * (Ti - TEMP_INIT))
# variation des coef du COMPORtement avec la temperature
# correction eventuelle des valeurs initiales du temps ti
if i > 0:
SXM = SXM * (YOUNG(Ti) / YOUNG(Tm))
# cas particuliers
if COMPORTEMENT.List_F()[0]['RELATION'] == 'VMIS_CINE_LINE':
if args['D_SIGM_EPSI'] != None:
D_SIGM_EPSI = args['D_SIGM_EPSI']
else:
raise 'erreur'
Vim[0:5] = Vim[0:5] * D_SIGM_EPSI(Ti) / D_SIGM_EPSI(Tm)
if COMPORTEMENT.List_F()[0]['RELATION'] == 'VMIS_ECMI_LINE':
if args['C_PRAG'] != None:
C_PRAG = args['C_PRAG']
else:
raise 'erreur'
Vim[2:7] = Vim[2:7] * C_PRAG(Ti) / C_PRAG(Tm)
if COMPORTEMENT.List_F()[0]['RELATION'] == 'VMIS_ECMI_TRAC':
if args['C_PRAG'] != None:
C_PRAG = args['C_PRAG']
else:
raise 'erreur'
Vim[2:7] = Vim[2:7] * C_PRAG(Ti) / C_PRAG(Tm)
__list0 = DEFI_LIST_REEL(
DEBUT=timem,
INTERVALLE=(_F(
JUSQU_A=time,
NOMBRE=1,
), ),
)
__list = DEFI_LIST_INST(
METHODE='MANUEL',
DEFI_LIST=_F(LIST_INST=__list0,
# PAS_MINI=1.0E-12
),
ECHEC=_F(
EVENEMENT='ERREUR',
ACTION='DECOUPE',
SUBD_METHODE='MANUEL',
),
# ADAPTATION=_F(EVENEMENT='SEUIL'),
)
if (NB_VARI > 0):
__RES[i] = SIMU_POINT_MAT(
INFO=INFO,
MATER=LIST_MATER[i],
INCREMENT=_F(LIST_INST=__list, ),
EPSI_IMPOSE=_F(EPXX=__epsimp),
SIGM_INIT=_F(SIXX=SXM),
VARI_INIT=_F(VALE=[Vim[j] for j in range(NB_VARI)]),
EPSI_INIT=_F(EPXX=EXM,
EPYY=0.,
EPZZ=0.,
EPXY=0.,
EPXZ=0.,
EPYZ=0.),
**motscles)
else:
__RES[i] = SIMU_POINT_MAT(INFO=INFO,
MATER=LIST_MATER[i],
INCREMENT=_F(LIST_INST=__list, ),
EPSI_IMPOSE=_F(EPXX=__epsimp),
SIGM_INIT=_F(SIXX=SXM),
EPSI_INIT=_F(EPXX=EXM,
EPYY=0.,
EPZZ=0.,
EPXY=0.,
EPXZ=0.,
EPYZ=0.),
**motscles)
# On ne teste pas les valeurs initiales (NUME_ORDRE = 0 exclu)
__RES[i] = CALC_TABLE(
reuse=__RES[i],
TABLE=__RES[i],
ACTION=(_F(
OPERATION='FILTRE',
NOM_PARA='INST',
CRIT_COMP='EQ',
VALE=time,
), ),
)
# recuperation des valeurs initiales du futur pas de temps dans la
# table resultat
EXM = __RES[i]['EPXX', 1]
SXM = __RES[i]['SIXX', 1]
if (NB_VARI > 0):
for j in range(NB_VARI):
Vim[j] = __RES[i]['V' + str(j + 1), 1]
DETRUIRE(CONCEPT=_F(NOM=__epsimp), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__list), INFO=1)
# On ne peut pas faire de non régression puisqu'on ne connait pas ici
# la valeur obtenue sur la machine de référence
MasquerAlarme('TEST0_12')
TEST_TABLE(
TABLE=__RES[i],
NOM_PARA='VMIS',
VALE_CALC=0.0,
VALE_REFE=__U['VMIS', i + 1],
TOLE_MACHINE=1.e-3,
FILTRE=_F(NOM_PARA='INST', VALE=time),
REFERENCE='AUTRE_ASTER',
)
TEST_TABLE(
TABLE=__RES[i],
NOM_PARA='TRACE',
VALE_CALC=0.0,
VALE_REFE=__U['TRACE', i + 1],
TOLE_MACHINE=1.e-3,
FILTRE=_F(NOM_PARA='INST', VALE=time),
REFERENCE='AUTRE_ASTER',
)
if (NB_VARI > 0):
if VARI_TEST <> None:
for j in range(len(VARI_TEST)):
nomvari = VARI_TEST[j]
if abs(__U[nomvari, i + 1]) > epsi:
TEST_TABLE(
TABLE=__RES[i],
NOM_PARA=nomvari,
VALE_CALC=0.0,
VALE_REFE=__U[nomvari, i + 1],
TOLE_MACHINE=1.e-3,
FILTRE=_F(NOM_PARA='INST', VALE=time),
REFERENCE='AUTRE_ASTER',
)
else:
for j in range(NB_VARI):
nomvari = 'V' + str(j + 1)
if abs(__U[nomvari, i + 1]) > epsi:
TEST_TABLE(
TABLE=__RES[i],
NOM_PARA=nomvari,
VALE_CALC=0.0,
VALE_REFE=__U[nomvari, i + 1],
TOLE_MACHINE=1.e-3,
FILTRE=_F(NOM_PARA='INST', VALE=time),
REFERENCE='AUTRE_ASTER',
)
RetablirAlarme('TEST0_12')
for i in range(NCAL):
DETRUIRE(CONCEPT=_F(NOM=__RES[i]), INFO=1)
elif OPTION == "MECA":
TEST_TANGENTE = args['TEST_TANGENTE']
LIST_NPAS = args['LIST_NPAS']
YOUNG = args['YOUNG']
POISSON = args['POISSON']
# Discretisation du calcul
if args['LIST_NPAS'] != None:
LIST_NPAS = args['LIST_NPAS']
else:
LIST_NPAS = 4 * [1] + [1, 5, 25]
Ncal = len(LIST_NPAS)
# les differents calculs effectues et les precisions sur chaque
# TEST_RESU
label_cal = ['_Pa_', '_Th_', '_sym_', '_rot_'] + (Ncal - 4) * ['_N']
if args['LIST_TOLE'] != None:
LIST_TOLE = args['LIST_TOLE']
else:
LIST_TOLE = 4 * [1.E-10] + [1.E-1] + (Ncal - 5) * [1.E-2] + [1.E-8]
if args['PREC_ZERO'] != None:
PREC_ZERO = args['PREC_ZERO']
else:
PREC_ZERO = len(VARI_TEST) * [1.E-10]
prec_tgt = LIST_TOLE[-1]
# parametres vitesse de sollicitation
t_0 = 1.0
if COMPORTEMENT:
if COMPORTEMENT.List_F()[0]['RELATION'][0:4] == 'VISC':
vitesse = 1.e-5
t_0 = 5.e-2 / (8.0 * vitesse)
# liste d'archivage
__tempsar = DEFI_LIST_REEL(VALE=[t_0 * i for i in range(9)], )
if args['MODELISATION'] != None:
modelisation = args['MODELISATION']
else:
modelisation = "3D"
if modelisation == "3D":
#
# TEST 3D
#
eps_imp = CHAR3D(self, POISSON, YOUNG, __tempsar, INFO)
ch_param2 = list(VARI_TEST)
ch_param = ch_param2 + \
['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ']
elif modelisation == "C_PLAN":
#
# TEST 2D C_PLAN
#
eps_imp = CHAR2D(self, POISSON, YOUNG, __tempsar, INFO)
# les quantites (invariants...) sur lequels portent les calculs
# d'erreur et les test_resu
ch_param2 = list(VARI_TEST)
ch_param = ch_param2 + ['SIXX', 'SIYY', 'SIZZ', 'SIXY']
#
# Discretisation et calcul
#
__RES = [None] * Ncal
__RSI = [None] * len(ch_param)
# pointeur materiau
P_imat = [0] + [1] + (Ncal - 2) * [1]
# pointeur deformation
nomdef, symdef, rotdef = [0, 1, 2], [1, 0, 2], [3, 4, 5]
P_idef = [nomdef, nomdef, symdef, rotdef]
for i in range(Ncal - 4):
P_idef.append(nomdef)
ldicoeps = []
dicoeps = {}
dicoeps['EPXX'] = eps_imp[0]
dicoeps['EPYY'] = eps_imp[1]
dicoeps['EPZZ'] = eps_imp[2]
dicoeps['EPXY'] = eps_imp[3]
if modelisation == "3D":
dicoeps['EPXZ'] = eps_imp[4]
dicoeps['EPYZ'] = eps_imp[5]
ldicoeps.append(dicoeps)
motscles['EPSI_IMPOSE'] = ldicoeps
if args['SUPPORT'] != None:
if modelisation == "C_PLAN":
motscles['MODELISATION'] = 'C_PLAN'
motscles['SUPPORT'] = 'ELEMENT'
else:
motscles['SUPPORT'] = args['SUPPORT']
# Boucle sur l'ensemble des calculs
for i in range(Ncal):
N = LIST_NPAS[i]
imat = P_imat[i]
idef = P_idef[i]
__temps = DEFI_LIST_REEL(
DEBUT=0.0,
INTERVALLE=(
_F(
JUSQU_A=t_0,
NOMBRE=N,
),
_F(
JUSQU_A=2.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=3.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=4.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=5.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=6.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=7.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=8.0 * t_0,
NOMBRE=N,
),
),
)
__DEFLIST = DEFI_LIST_INST(
DEFI_LIST=_F(LIST_INST=__temps, ),
ECHEC=_F(
EVENEMENT='ERREUR',
ACTION='DECOUPE',
SUBD_METHODE='MANUEL',
SUBD_PAS=10,
SUBD_NIVEAU=10,
),
)
# Resout le pb a deformation imposee
__RES[i] = SIMU_POINT_MAT(INFO=INFO,
MATER=LIST_MATER[imat],
ARCHIVAGE=_F(LIST_INST=__tempsar),
INCREMENT=_F(LIST_INST=__DEFLIST, ),
**motscles)
# On renomme les composantes en fonction de l'ordre de discretisation
RENOMME(self, i, LIST_NPAS, label_cal, ch_param, __RES, __RSI)
DETRUIRE(CONCEPT=_F(NOM=__temps, ), INFO=1)
# TEST_RESU sur les erreurs relatives
# les quantites (invariants...) sur lequels portent les calculs
# d'erreur et les test_resu
__RSI = TEST_ECART(self, ch_param2, label_cal, LIST_NPAS, Ncal,
ch_param, __RSI, LIST_TOLE, PREC_ZERO)
# On ne peut pas faire de non régression puisqu'on ne connait pas ici
# la valeur obtenue sur la machine de référence
MasquerAlarme('TEST0_12')
for ch in ch_param2:
i = ch_param2.index(ch)
if INFO == 2:
IMPR_TABLE(TABLE=__RSI[i])
for j in range(Ncal):
ch_cal = ch + label_cal[j] + str(LIST_NPAS[j])
ch_err = 'ER_' + ch_cal
TEST_TABLE(
TABLE=__RSI[i],
NOM_PARA=ch_err,
TYPE_TEST='MAX',
VALE_CALC=0.,
VALE_REFE=0.,
CRITERE='ABSOLU',
TOLE_MACHINE=LIST_TOLE[j],
PRECISION=LIST_TOLE[j],
REFERENCE='ANALYTIQUE',
)
RetablirAlarme('TEST0_12')
#
# Test de la matrice tangente sur le calcul le plus fin
#
if TEST_TANGENTE == 'OUI':
N = LIST_NPAS[Ncal - 1]
__Linst = DEFI_LIST_REEL(
DEBUT=0.0,
INTERVALLE=(
_F(
JUSQU_A=t_0,
NOMBRE=N,
),
_F(
JUSQU_A=2.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=3.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=4.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=5.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=6.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=7.0 * t_0,
NOMBRE=N,
),
_F(
JUSQU_A=8.0 * t_0,
NOMBRE=N,
),
),
)
if COMPORTEMENT:
motscles['COMPORTEMENT'][0]['TYPE_MATR_TANG'] = 'VERIFICATION'
if args['VERI_MATR_OPTION'] is not None:
motscles['COMPORTEMENT'][0]['VALE_PERT_RELA'] = args[
'VERI_MATR_OPTION'].List_F()[0]['VALE_PERT_RELA']
__DEFLIS2 = DEFI_LIST_INST(
DEFI_LIST=_F(LIST_INST=__Linst, ),
ECHEC=_F(
EVENEMENT='ERREUR',
ACTION='DECOUPE',
SUBD_METHODE='MANUEL',
SUBD_PAS=10,
SUBD_NIVEAU=10,
),
)
# Resout le pb a deformation imposee
DEBUG(SDVERI='NON')
U = SIMU_POINT_MAT(INFO=INFO,
MATER=LIST_MATER[imat],
ARCHIVAGE=_F(LIST_INST=__tempsar),
INCREMENT=_F(LIST_INST=__DEFLIS2, ),
**motscles)
DEBUG(SDVERI='OUI')
motscles = {}
if args['VERI_MATR_OPTION'] is not None:
motscles['PRECISION'] = args['VERI_MATR_OPTION'].List_F(
)[0]['PRECISION']
motscles['PREC_ZERO'] = args['VERI_MATR_OPTION'].List_F(
)[0]['PREC_ZERO']
__DIFFMAT = VERI_MATR_TANG(**motscles)
# On ne peut pas faire de non régression puisqu'on ne connait pas ici
# la valeur obtenue sur la machine de référence
MasquerAlarme('TEST0_12')
TEST_TABLE(
TABLE=__DIFFMAT,
NOM_PARA='MAT_DIFF',
TYPE_TEST='MAX',
VALE_CALC=0.,
VALE_REFE=0.,
CRITERE='ABSOLU',
TOLE_MACHINE=prec_tgt,
PRECISION=prec_tgt,
REFERENCE='ANALYTIQUE',
)
RetablirAlarme('TEST0_12')
if INFO == 2:
IMPR_TABLE(TABLE=__DIFFMAT)
return ier
def calc_ecrevisse_ops(self,
CHARGE_MECA,
CHARGE_THER1,
CHARGE_THER2,
TABLE,
DEBIT,
MODELE_MECA,
MODELE_THER,
RESULTAT,
FISSURE,
ECOULEMENT,
MODELE_ECRE,
CONVERGENCE,
LOGICIEL,
VERSION,
ENTETE,
IMPRESSION,
INFO,
COURBES,
**args):
"""
Procedure de couplage Aster-Ecrevisse
Recuperation du profil de la fissure , appel de MACR_ECRE_CALC,
creation des tableaux de resultats et des chargements pour AsterGeneration par Aster
"""
import os
import string
import types
import shutil
import aster
from code_aster.Cata.Syntax import _F
from Noyau.N_utils import AsType
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from Utilitai.Table import Table, merge
from copy import copy
from math import atan, pi, sqrt, atan2, degrees, sin, cos
ier = 0
# Concepts sortant
self.DeclareOut('__TAB', TABLE)
self.DeclareOut('__ECR_F1', CHARGE_THER1)
self.DeclareOut('__ECR_F2', CHARGE_THER2)
self.DeclareOut('__ECR_P', CHARGE_MECA)
self.DeclareOut('__DEB', DEBIT)
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Parametres debug
debug = False
# Fonctionnalitees cachees :
# 1- oldVersion : "=True" permet de retourner un chargement thermique defini selon l'ancien mode (flux thermique)
# ATTENTION!! L'ancienne version ne marche que avec la fissure orientee dans la direction Y,
# et avec le point initila en y=0!!
# 2- chargeLin : "=True" permet d'appliquer le chargement d'Ecrevisse avec interpolation lineaire sur le mailles,
# et non constant par maille, comme c'est par defaut
oldVersion = False
chargeLin = False
# Parametres developpeur
tmp_ecrevisse = "tmp_ecrevisse"
# Info
info2 = (INFO == 2)
InfoAster = 1
if debug:
info2 = True
# IMPORTATION DE COMMANDES ASTER
DEFI_GROUP = self.get_cmd("DEFI_GROUP")
POST_RELEVE_T = self.get_cmd("POST_RELEVE_T")
IMPR_TABLE = self.get_cmd("IMPR_TABLE")
DETRUIRE = self.get_cmd("DETRUIRE")
IMPR_CO = self.get_cmd("IMPR_CO")
DEFI_FONCTION = self.get_cmd("DEFI_FONCTION")
CREA_TABLE = self.get_cmd("CREA_TABLE")
IMPR_TABLE = self.get_cmd("IMPR_TABLE")
CO = self.get_cmd("CO")
AFFE_CHAR_THER_F = self.get_cmd("AFFE_CHAR_THER_F")
AFFE_CHAR_MECA_F = self.get_cmd("AFFE_CHAR_MECA_F")
DEFI_FICHIER = self.get_cmd("DEFI_FICHIER")
DEFI_CONSTANTE = self.get_cmd("DEFI_CONSTANTE")
from Contrib.macr_ecre_calc import MACR_ECRE_CALC
# RECUPERATION DES MOTS-CLES FACTEURS
dRESULTAT = RESULTAT[0].cree_dict_valeurs(RESULTAT[0].mc_liste)
for i in dRESULTAT.keys():
if dRESULTAT[i] == None:
del dRESULTAT[i]
dECOULEMENT = ECOULEMENT[0].cree_dict_valeurs(ECOULEMENT[0].mc_liste)
for i in dECOULEMENT.keys():
if dECOULEMENT[i] == None:
del dECOULEMENT[i]
dMODELE_ECRE = MODELE_ECRE[0].cree_dict_valeurs(MODELE_ECRE[0].mc_liste)
for i in dMODELE_ECRE.keys():
if dMODELE_ECRE[i] == None:
dMODELE_ECRE[i] = None # del dMODELE_ECRE[i]
dCONVERGENCE = CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
for i in dCONVERGENCE.keys():
if dCONVERGENCE[i] == None:
del dCONVERGENCE[i]
# INSTANTS
_l_inst = dRESULTAT['MECANIQUE'].LIST_VARI_ACCES()
if dRESULTAT.has_key('INST'):
Inst_Ecrevisse = dRESULTAT['INST']
else:
pass
# INITIATION DES CHARGEMENTS ECREVISSE --> ASTER :
# liste des mots cles facteurs de PRES_REP pour chaque fissure
l_PRES_REP = []
if oldVersion:
# liste des mots cles facteurs de FLUX_REP pour le flux F1/F2
# de chaque fissure (soit sur les deux levres :GROUP_MA[0],
# GROUP_MA[1])
l_FLUX_REP_F1 = []
l_FLUX_REP_F2 = []
else:
# liste des mots cles facteurs de ECHANGE pour le flux F1/F2
# de chaque fissure (soit sur les deux levres :GROUP_MA[0],
# GROUP_MA[1])
l_ECHANGE_F1 = []
l_ECHANGE_F2 = []
# ON CREE LES GROUP_NO ORDONNES DES LEVRES DE FISSURE
# Liste des noms des groupes de noeuds du maillage :
_lgno = map(lambda x: x[0], MODELE_MECA['MAILLAGE'].LIST_GROUP_NO())
for k, fissure in enumerate(FISSURE):
dFISSURE = fissure.cree_dict_valeurs(fissure.mc_liste)
for i in dFISSURE.keys():
if dFISSURE[i] == None:
del dFISSURE[i]
# On cree les group_no correspondant aux group_ma des levres de la
# fissure dans le cas ou ils n'existent pas deja
if not dFISSURE['GROUP_MA'][0] in _lgno:
DEFI_GROUP(reuse=MODELE_MECA['MAILLAGE'],
MAILLAGE=MODELE_MECA['MAILLAGE'],
CREA_GROUP_NO=_F(GROUP_MA=(dFISSURE['GROUP_MA'][0]),),)
if not dFISSURE['GROUP_MA'][1] in _lgno:
DEFI_GROUP(reuse=MODELE_MECA['MAILLAGE'],
MAILLAGE=MODELE_MECA['MAILLAGE'],
CREA_GROUP_NO=_F(GROUP_MA=(dFISSURE['GROUP_MA'][1]),),)
# Test sur le nombre de caracteres du nom des group_ma
if (len(dFISSURE['GROUP_MA'][0]) > 7 or len(dFISSURE['GROUP_MA'][1]) > 7):
sys.exit(1)
# Creation des group_no ordonnes des levres des fissures
_nom_gno_1 = '_' + dFISSURE['GROUP_MA'][0]
if not _nom_gno_1 in _lgno:
DEFI_GROUP(reuse=MODELE_MECA['MAILLAGE'],
MAILLAGE=MODELE_MECA['MAILLAGE'],
CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
NOM=_nom_gno_1,
GROUP_NO=dFISSURE['GROUP_MA'][0],
GROUP_NO_ORIG=dFISSURE[
'GROUP_NO_ORIG'][0],
GROUP_NO_EXTR=dFISSURE[
'GROUP_NO_EXTR'][0],
PRECISION=0.01,
CRITERE='RELATIF',),
INFO=InfoAster,)
_nom_gno_2 = '_' + dFISSURE['GROUP_MA'][1]
if not _nom_gno_2 in _lgno:
DEFI_GROUP(reuse=MODELE_MECA['MAILLAGE'],
MAILLAGE=MODELE_MECA['MAILLAGE'],
CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
NOM=_nom_gno_2,
GROUP_NO=dFISSURE['GROUP_MA'][1],
GROUP_NO_ORIG=dFISSURE[
'GROUP_NO_ORIG'][1],
GROUP_NO_EXTR=dFISSURE[
'GROUP_NO_EXTR'][1],
PRECISION=0.01,
CRITERE='RELATIF',),
INFO=InfoAster,)
# EXTRACTIONS DE QUANTITES NECESSAIRES DES RESULTATS THERMIQUE ET MECANIQUE
# On cree les chargements Aster --> Ecrevisse :
# ouverture de fissure et temperature sur le materiau
# premiere levre de fissure
_T_DPL = POST_RELEVE_T(ACTION=_F(INTITULE='DEP_FIS1',
GROUP_NO=_nom_gno_1,
RESULTAT=dRESULTAT['MECANIQUE'],
NOM_CHAM='DEPL',
NOM_CMP=('DX', 'DY',),
INST=Inst_Ecrevisse,
OPERATION='EXTRACTION',),
)
_T_TEMP = POST_RELEVE_T(ACTION=_F(INTITULE='TEMP_FI1',
GROUP_NO=_nom_gno_1,
RESULTAT=dRESULTAT['THERMIQUE'],
NOM_CHAM='TEMP',
TOUT_CMP='OUI',
INST=Inst_Ecrevisse,
OPERATION='EXTRACTION',),)
# deuxieme levre de la fissure
_T_DPL_B = POST_RELEVE_T(ACTION=_F(INTITULE='DEP_FIS2',
GROUP_NO=_nom_gno_2,
RESULTAT=dRESULTAT['MECANIQUE'],
NOM_CHAM='DEPL',
NOM_CMP=('DX', 'DY',),
INST=Inst_Ecrevisse,
OPERATION='EXTRACTION',),)
_T_TEMPB = POST_RELEVE_T(ACTION=_F(INTITULE='TEMP_FI2',
GROUP_NO=_nom_gno_2,
RESULTAT=dRESULTAT['THERMIQUE'],
NOM_CHAM='TEMP',
TOUT_CMP='OUI',
INST=Inst_Ecrevisse,
OPERATION='EXTRACTION',),)
if (debug):
print '_T_DPL ==================================================='
print _T_DPL.EXTR_TABLE()
print '_T_DPL_B ================================================='
print _T_DPL_B.EXTR_TABLE()
print '_T_TEMP ================================================='
print _T_TEMP.EXTR_TABLE()
print '_T_TEMP_B ==============================================='
print _T_TEMPB.EXTR_TABLE()
# Extraction des tables Temperatures + deplacement levres fissure
_tbl_temp = _T_TEMP.EXTR_TABLE()
_tbl_dpl = _T_DPL.EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=(_T_DPL, _T_TEMP,)), INFO=1)
_tbl_dpl_b = _T_DPL_B.EXTR_TABLE()
_tbl_temp_b = _T_TEMPB.EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=(_T_DPL_B, _T_TEMPB,)), INFO=1)
# --Determination des cotes a donner a ecrevisse--
# a partir des resultats mecanique et thermique :
_l_tang = _tbl_dpl.values()['ABSC_CURV']
_l_tang_b = _tbl_dpl_b.values()['ABSC_CURV']
try:
_l_absz_m = map(lambda x, y: 0.5 * (x + y), _l_tang, _l_tang_b)
except TypeError:
UTMESS('F', 'ECREVISSE0_40')
#
_l_tang_t = _tbl_temp.values()['ABSC_CURV']
_l_tang_t_b = _tbl_temp_b.values()['ABSC_CURV']
_l_absz_t = map(lambda x, y: 0.5 * (x + y), _l_tang_t, _l_tang_t_b)
# Coordonnees des points des levres (initiales et a l instant actuel
_X0 = _tbl_dpl.values()['COOR_X']
_Y0 = _tbl_dpl.values()['COOR_Y']
_X0_b = _tbl_dpl_b.values()['COOR_X']
_Y0_b = _tbl_dpl_b.values()['COOR_Y']
_X = [x + y for (x, y) in zip(_tbl_dpl.values()['DX'], _X0)]
_Y = [x + y for (x, y) in zip(_tbl_dpl.values()['DY'], _Y0)]
_X_b = [x + y for (x, y) in zip(_tbl_dpl_b.values()['DX'], _X0_b)]
_Y_b = [x + y for (x, y) in zip(_tbl_dpl_b.values()['DY'], _Y0_b)]
# Determination de la direction de la fissure
(DIR_FISS, DIR_PREV, beta, theta, _xi,
_yi) = dirfiss(_X, _Y, _X_b, _Y_b)
if oldVersion:
(DIR_FISS, DIR_PREV, beta, theta, _xi,
_yi) = dirfiss(_X0, _Y0, _X0_b, _Y0_b)
if (DIR_FISS == 'GEN') and oldVersion:
UTMESS('F', 'ECREVISSE0_23', valr=[theta])
# --Calcul de l ouverture de fissure--
# une fissure refermee a une ouverture
# egale a l'ouverture remanente
(_l_ouv0, _l_gli0) = ouvFiss(DIR_FISS, beta, _X0, _Y0, _X0_b, _Y0_b)
for i in range(len(_l_ouv0)):
if _l_ouv0[i] < dFISSURE['OUVERT_REMANENTE']:
UTMESS('A', 'ECREVISSE0_39')
(_l_ouv, _l_gli) = ouvFiss(DIR_FISS, beta, _X, _Y, _X_b, _Y_b)
if dFISSURE['OUVERT_REMANENTE']:
_l_ouv = map(
lambda x: max(dFISSURE['OUVERT_REMANENTE'], x), _l_ouv)
if info2:
nbOuvRem = _l_ouv.count(dFISSURE['OUVERT_REMANENTE'])
if nbOuvRem != 0:
UTMESS('I', 'ECREVISSE0_41', valr=[nbOuvRem])
# Controle sur l entite du glissement entre les levres
DeltaMaille = [abs(y - x)
for (x, y) in zip(_l_absz_m[1:len(_l_absz_m)], _l_absz_m[0:len(_l_absz_m) - 1])]
for i in range(len(DeltaMaille)):
deltamai = DeltaMaille[i]
if (deltamai <= _l_gli[i]) or (deltamai <= _l_gli[i + 1]):
UTMESS('A', 'ECREVISSE0_38')
break
# -- Calcul de la temperature sur le materiau (levres de la fissure) --
# on fait la moyenne des temperatures des deux levres
_l_t2 = _tbl_temp.values()['TEMP']
_l_t2_b = _tbl_temp_b.values()['TEMP']
_l_temp_aster = map(lambda x, y: 0.5 * (x + y), _l_t2_b, _l_t2)
# Infos / Debug : fichier .mess ou .resu
if (info2):
UTMESS('I', 'ECREVISSE0_1', valk=["Premiere levre"],
valr=[Inst_Ecrevisse, min(_l_tang_t), max(_l_tang_t), min(_l_t2), max(_l_t2), min(_l_tang), max(_l_tang)])
UTMESS('I', 'ECREVISSE0_1', valk=["Deuxieme levre"],
valr=[Inst_Ecrevisse, min(_l_tang_t_b), max(_l_tang_t_b), min(_l_t2_b), max(_l_t2_b), min(_l_tang_b), max(_l_tang_b)])
UTMESS('I', 'ECREVISSE0_2',
valr=[Inst_Ecrevisse, min(_l_absz_t), max(_l_absz_t), min(_l_temp_aster), max(_l_temp_aster), min(_l_absz_m), max(_l_absz_m), min(_l_ouv), max(_l_ouv), min(_l_gli), max(_l_gli)])
if (debug):
print "\n INFORMATIONS DE DEBUG: "
print 'Inst_Ecrevisse=', Inst_Ecrevisse
print 'theta:', theta
print 'beta:', beta
print 'DIR_FISS:', DIR_FISS
print 'DIR_PREV:', DIR_PREV
print 'point initial de la fissure: (xi,yi) :', _xi, _yi
print len(_X0), '_X0 =', _X0
print len(_X0_b), '_X0_b=', _X0_b
print len(_Y0), '_Y0 =', _Y0
print len(_Y0_b), '_Y0_b=', _Y0_b
print len(_X), '_X =', _X
print len(_Y), '_Y =', _Y
print len(_X_b), '_X_b =', _X_b
print len(_Y_b), '_Y_b =', _Y_b
print 'Controle sur les abszisses curvilignes (mecaniques/thermiques) '
print '_l_absz_m==_l_absz_t?', _l_absz_m == _l_absz_t
print '_l_absz_m=', len(_l_absz_m), _l_absz_m
print '_l_absz_t=', len(_l_absz_t), _l_absz_t
print '_l_temp_aster=', len(_l_temp_aster), _l_temp_aster
print '_l_ouv=', len(_l_ouv), _l_ouv
print '_l_gli=', len(_l_gli), _l_gli
print '_l_tang=', _l_tang
print '_l_tang_b=', _l_tang
# ----------------------------------------------------------------------------
# PREPARATION ET LANCEMENT D ECREVISSE
# TESTS de non divergence, les messages sont assez explicites :
# Si toutes les listes sont bien definies
if len(_l_absz_m) * len(_l_ouv) * len(_l_absz_t) * len(_l_temp_aster) == 0:
UTMESS('F', 'ECREVISSE0_3', valr=[Inst_Ecrevisse])
__TAB = None
break
# Si les ouvertures ne sont pas trop faibles
elif min(_l_ouv) < 1e-20:
UTMESS('F', 'ECREVISSE0_4', valr=[Inst_Ecrevisse, min(_l_ouv)])
__TAB = None
break
elif max(_l_t2) > 700:
UTMESS('F', 'ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2)])
__TAB = None
break
elif max(_l_t2_b) > 700:
UTMESS('F', 'ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2_b)])
__TAB = None
break
elif min(_l_t2) < 0:
UTMESS('F', 'ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2)])
__TAB = None
break
elif min(_l_t2_b) < 0:
UTMESS('F', 'ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2_b)])
__TAB = None
break
elif abs(float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE'])) < 5:
UTMESS('F', 'ECREVISSE0_7', valr=[Inst_Ecrevisse, abs(
float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE']))])
__TAB = None
break
# On lance Ecrevisse!
else:
UTMESS('I', 'ECREVISSE0_8', valr=[Inst_Ecrevisse])
# On efface le rep
try:
for fic in os.listdir(os.path.join(os.getcwd(), tmp_ecrevisse)):
try:
os.remove(
os.path.join(os.getcwd(), tmp_ecrevisse) + '/' + fic)
except:
pass
except:
pass
# Recalcul des cotes par rapport a la tortuoiste
tort = dFISSURE['TORTUOSITE']
try:
_l_absz_m = [x / tort for x in _l_absz_m]
_l_absz_t = [x / tort for x in _l_absz_t]
except ZeroDivisionError:
UTMESS('F', 'ECREVISSE0_42')
if dFISSURE.has_key('LISTE_COTES_BL'):
__LISTE_COTES_BL = dFISSURE['LISTE_COTES_BL']
else:
__LISTE_COTES_BL = (0., max(_l_absz_m))
# Mot-cle ECOULEMENT
txt = {}
txt = {'PRES_ENTREE': dECOULEMENT['PRES_ENTREE'],
'PRES_SORTIE': dECOULEMENT['PRES_SORTIE'],
'FLUIDE_ENTREE': dECOULEMENT['FLUIDE_ENTREE'],
}
if int(dECOULEMENT['FLUIDE_ENTREE']) in [1, 3, 4, 6]:
txt['TEMP_ENTREE'] = dECOULEMENT['TEMP_ENTREE']
if int(dECOULEMENT['FLUIDE_ENTREE']) in [2, 5]:
txt['TITR_MASS'] = dECOULEMENT['TITR_MASS']
if int(dECOULEMENT['FLUIDE_ENTREE']) in [4, 5]:
txt['PRES_PART'] = dECOULEMENT['PRES_PART']
# Traitement des cas ou les mots cles reynold, xminch, etc... ne doivent pas apparaitre
# Mot-cle MODELE_ECRE
txt2 = {}
txt2['ECOULEMENT'] = dMODELE_ECRE['ECOULEMENT']
if dMODELE_ECRE['ECOULEMENT'] == 'GELE':
txt2['PRESS_EBULLITION'] = dMODELE_ECRE['PRESS_EBULLITION']
txt2['FROTTEMENT'] = dMODELE_ECRE['FROTTEMENT']
if int(dMODELE_ECRE['FROTTEMENT']) in [-4, -3, -2, -1]:
txt2['REYNOLDS_LIM'] = dMODELE_ECRE['REYNOLDS_LIM']
txt2['FROTTEMENT_LIM'] = dMODELE_ECRE['FROTTEMENT_LIM']
txt2['TRANSFERT_CHAL'] = dMODELE_ECRE['TRANSFERT_CHAL']
if int(dMODELE_ECRE['TRANSFERT_CHAL']) < 0:
txt2['XMINCH'] = dMODELE_ECRE['XMINCH']
txt2['XMAXCH'] = dMODELE_ECRE['XMAXCH']
try:
if dMODELE_ECRE['IVENAC'] in [0, 1]:
txt2['IVENAC'] = dMODELE_ECRE['IVENAC']
else:
txt2['IVENAC'] = 0
except:
txt2['IVENAC'] = 0
motscle2 = {'ECOULEMENT': txt, 'MODELE_ECRE': txt2}
DETRUIRE(OBJET=_F(CHAINE='_TAB2'), INFO=1)
DETRUIRE(OBJET=_F(CHAINE='_DEB2'), INFO=1)
__TAB_i = CO('_TAB2')
__DEB_i = CO('_DEB2')
MACR_ECRE_CALC(TABLE=__TAB_i,
DEBIT=__DEB_i,
ENTETE=ENTETE,
COURBES=COURBES,
IMPRESSION=IMPRESSION,
INFO=INFO,
LOGICIEL=LOGICIEL,
VERSION=VERSION,
FISSURE=_F(LONGUEUR=max(_l_absz_m),
ANGLE=theta,
RUGOSITE=dFISSURE[
'RUGOSITE'],
ZETA=dFISSURE[
'ZETA'],
SECTION=dFISSURE[
'SECTION'],
LISTE_COTES_AH=_l_absz_m,
LISTE_VAL_AH=_l_ouv,
LISTE_COTES_BL=__LISTE_COTES_BL,
LISTE_VAL_BL=dFISSURE[
'LISTE_VAL_BL'],
),
TEMPERATURE=_F(GRADIENT='FOURNI',
LISTE_COTES_TEMP=_l_absz_t,
LISTE_VAL_TEMP=_l_temp_aster,
),
CONVERGENCE=_F(
KGTEST=dCONVERGENCE['KGTEST'],
ITER_GLOB_MAXI=dCONVERGENCE[
'ITER_GLOB_MAXI'],
CRIT_CONV_DEBI=dCONVERGENCE[
'CRIT_CONV_DEBI'],
),
**motscle2
)
#-------------------------------------------------------------
# EXTRACTION DES RESULTATS D ECREVISSE
# Creation de la table
__TABFISS_i = __TAB_i.EXTR_TABLE()
nb_lignes_table = len(__TABFISS_i["COTES"])
# Re-definition des cotes utilisateur (on elimine l effet de la
# tortuosite)
_lst_c = __TABFISS_i.COTES.values()
_l_cotes = [x * tort for x in _lst_c]
dictTab = __TABFISS_i.dict_CREA_TABLE()['LISTE']
__TABFISS_i = CREA_TABLE(LISTE=(
_F(PARA="COTES", LISTE_R=_l_cotes,),
_F(PARA="FLUX", LISTE_R=dictTab[
1]['LISTE_R'],),
_F(PARA="PRESSION", LISTE_R=dictTab[
2]['LISTE_R'],),
_F(PARA="TEMP", LISTE_R=dictTab[
3]['LISTE_R'],),
_F(PARA="COEF_CONV", LISTE_R=dictTab[
4]['LISTE_R'],),
),)
DETRUIRE(OBJET=_F(CHAINE='__TAB_i'), INFO=1)
DETRUIRE(OBJET=_F(CHAINE='__DEB_i'), INFO=1)
if (debug):
os.system(
'ls -al ' + os.path.join(os.getcwd(), tmp_ecrevisse))
if dFISSURE['PREFIXE_FICHIER']:
pref_fic = dFISSURE['PREFIXE_FICHIER']
else:
pref_fic = 'FISSURE' + str(k + 1)
# Ecriture du fichier debits en fonction du temps:
# try:
# on lit le fichier debit produit par ecrevisse
# f_ast = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
#_txt = f_ast.read()
# f_ast.close()
# nomfic = str(pref_fic) + '_debits'
# on concatene
# fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic, 'a')
# fw.write( str(Inst_Ecrevisse) + ' ' + _txt )
# fw.close()
# On recopie le fichier debits pour reprise ulterieure
# nomfic2 = 'debits_dernier'
# fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic2, 'w')
# fw.write( _txt )
# fw.close()
# except Exception, e:
# print e
# CREATION DES COURBES:
if COURBES != "AUCUNE":
# Pour masquer certaines alarmes
MasquerAlarme('TABLE0_6')
nomfic = os.path.join(os.getcwd(), 'REPE_OUT', str(
pref_fic) + '_flux' + '_' + str(Inst_Ecrevisse))
if not os.path.isfile(nomfic):
acces = 'NEW'
else:
acces = 'APPEND'
DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55,
TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
IMPR_TABLE(FORMAT='XMGRACE',
TABLE=__TABFISS_i,
UNITE=55,
PILOTE=COURBES,
NOM_PARA=('COTES', 'FLUX',),
TITRE='Flux de chaleur a l\'instant %s' % Inst_Ecrevisse,
LEGENDE_X='Abscisse curviligne (m)',
LEGENDE_Y='Flux (W/m2)',
COULEUR = 1,
MARQUEUR = 1,
)
DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
nomfic = os.path.join(os.getcwd(), 'REPE_OUT', str(
pref_fic) + '_temperature' + '_' + str(Inst_Ecrevisse))
if not os.path.isfile(nomfic):
acces = 'NEW'
else:
acces = 'APPEND'
DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55,
TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
IMPR_TABLE(FORMAT='XMGRACE',
TABLE=__TABFISS_i,
UNITE=55,
PILOTE=COURBES,
NOM_PARA=('COTES', 'TEMP',),
TITRE='Temperature a l\'instant %s' % Inst_Ecrevisse,
LEGENDE_X='Abscisse curviligne (m)',
LEGENDE_Y='Temperature (degres C)',
COULEUR = 2,
MARQUEUR = 2,
)
DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
nomfic = os.path.join(os.getcwd(), 'REPE_OUT', str(
pref_fic) + '_coeffconv' + '_' + str(Inst_Ecrevisse))
if not os.path.isfile(nomfic):
acces = 'NEW'
else:
acces = 'APPEND'
DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55,
TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
IMPR_TABLE(FORMAT='XMGRACE',
TABLE=__TABFISS_i,
UNITE=55,
PILOTE=COURBES,
NOM_PARA=('COTES', 'COEF_CONV',),
TITRE='Coefficient de convection a l\'instant %s' % Inst_Ecrevisse,
LEGENDE_X='Abscisse curviligne (m)',
LEGENDE_Y='Coefficient de convection (W/m2/K)',
COULEUR = 3,
MARQUEUR = 3,
)
DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
nomfic = os.path.join(os.getcwd(), 'REPE_OUT', str(
pref_fic) + '_pression' + '_' + str(Inst_Ecrevisse))
if not os.path.isfile(nomfic):
acces = 'NEW'
else:
acces = 'APPEND'
DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55,
TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
IMPR_TABLE(FORMAT='XMGRACE',
TABLE=__TABFISS_i,
UNITE=55,
PILOTE=COURBES,
NOM_PARA=('COTES', 'PRESSION',),
TITRE='Pression a l\'instant %s' % Inst_Ecrevisse,
LEGENDE_X='Abscisse curviligne (m)',
LEGENDE_Y='Pression (Pa)',
COULEUR = 4,
MARQUEUR = 4,
)
DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
# Pour la gestion des alarmes
RetablirAlarme('TABLE0_6')
# On recopie dans REPE_OUT les fichiers resultats d'Ecrevisse
tmp_ecrevisse_absolu = os.path.join(os.getcwd(), tmp_ecrevisse)
repe_out_absolu = os.path.join(os.getcwd(), 'REPE_OUT')
for file in os.listdir(tmp_ecrevisse_absolu):
if not file in ['ecrevisse', 'ecrevisse.sh']:
old_file = os.path.join(tmp_ecrevisse_absolu, file)
new_file = os.path.join(repe_out_absolu, str(
pref_fic) + '_' + file + '_' + str(Inst_Ecrevisse))
shutil.copy(old_file, new_file)
# Creation de la table resultat sur toutes les fissures :
# Nom de la fissure
nom_fiss = dFISSURE['GROUP_MA'][0] + "-" + dFISSURE['GROUP_MA'][1]
__TABFISS_i = __TABFISS_i.EXTR_TABLE()
__DEBFISS_i = __DEB_i.EXTR_TABLE()
__TABFISS_i["FISSURE"] = [nom_fiss] * nb_lignes_table
__DEBFISS_i["FISSURE"] = [nom_fiss]
if k == 0:
__TABFISS_tot = __TABFISS_i
__DEBFISS_tot = __DEBFISS_i
else:
__TABFISS_tot = merge(__TABFISS_tot, __TABFISS_i)
__DEBFISS_tot = merge(__DEBFISS_tot, __DEBFISS_i)
if (debug):
os.system(
'ls -al ' + os.path.join(os.getcwd(), tmp_ecrevisse))
#--------------------------------------------------------------
# CREATIONS DES CHARGEMENTS ASTER
# Recuperation des valeurs dans la table (voir si il y a plus
# simple)
_lst_c = __TABFISS_i.COTES.values()
_lst_f = __TABFISS_i.FLUX.values()
_lst_p = __TABFISS_i.PRESSION.values()
_lst_t = __TABFISS_i.TEMP.values()
_lst_cc = __TABFISS_i.COEF_CONV.values()
try:
a = len(_lst_c)
except:
_lst_c = []
_lst_f = []
_lst_p = []
_lst_t = []
_lst_cc = []
try:
if _lst_c[1] == 0:
_lst_c = []
_lst_f = []
_lst_p = []
_lst_t = []
_lst_cc = []
except:
pass
# ------------------------------------------------------
# Extraction des conditions limites du calcul Ecrevisse
#
if len(_lst_c) >= 2:
if not chargeLin:
nbCotes = len(_l_absz_m)
nbCotesEcre = nbCotes - 1
# epsilon pour le decalage :
# le chargement est uniforme par maille
if _X0[1] >= _X0[0]:
epsx = 1.e-8
else:
epsx = -1.e-8
if _Y0[1] >= _Y0[0]:
epsy = 1.e-8
else:
epsy = -1.e-8
_lst_x0 = []
_lst_y0 = []
_lst_x0_b = []
_lst_y0_b = []
ly = []
ly2 = []
ly3 = []
ly4 = []
_lst_x0.append(_X0[0])
_lst_y0.append(_Y0[0])
_lst_x0_b.append(_X0_b[0])
_lst_y0_b.append(_Y0_b[0])
ly.append(_lst_f[0])
ly2.append(_lst_p[0])
ly3.append(_lst_t[0])
ly4.append(_lst_cc[0])
for i in range(nbCotes - 2):
x = _X0[i + 1]
y = _Y0[i + 1]
toto1 = x - epsx
toto2 = x + epsx
_lst_x0.append(x - epsx)
_lst_x0.append(x + epsx)
_lst_y0.append(y - epsy)
_lst_y0.append(y + epsy)
x = _X0_b[i + 1]
y = _Y0_b[i + 1]
_lst_x0_b.append(x - epsx)
_lst_x0_b.append(x + epsx)
_lst_y0_b.append(y - epsy)
_lst_y0_b.append(y + epsy)
ly.append(_lst_f[i])
ly.append(_lst_f[i + 1])
ly2.append(_lst_p[i])
ly2.append(_lst_p[i + 1])
ly3.append(_lst_t[i])
ly3.append(_lst_t[i + 1])
ly4.append(_lst_cc[i])
ly4.append(_lst_cc[i + 1])
_lst_x0.append(_X0[nbCotes - 1])
_lst_y0.append(_Y0[nbCotes - 1])
_lst_x0_b.append(_X0_b[nbCotes - 1])
_lst_y0_b.append(_Y0_b[nbCotes - 1])
ly.append(_lst_f[nbCotesEcre - 1])
ly2.append(_lst_p[nbCotesEcre - 1])
ly3.append(_lst_t[nbCotesEcre - 1])
ly4.append(_lst_cc[nbCotesEcre - 1])
_lst_f = ly
_lst_p = ly2
_lst_t = ly3
_lst_cc = ly4
else:
_lst_x0 = [(x1 + x2) * 0.5 for (x1, x2) in zip(
_X0[0:len(_X0) - 1], _X0[1:len(_X0)])]
_lst_y0 = [(x1 + x2) * 0.5 for (x1, x2) in zip(
_Y0[0:len(_Y0) - 1], _Y0[1:len(_Y0)])]
_lst_x0_b = [(x1 + x2) * 0.5 for (x1, x2) in zip(
_X0_b[0:len(_X0_b) - 1], _X0_b[1:len(_X0_b)])]
_lst_y0_b = [(x1 + x2) * 0.5 for (x1, x2) in zip(
_Y0_b[0:len(_Y0_b) - 1], _Y0_b[1:len(_Y0_b)])]
_lst_x0.append(_X0[-1])
_lst_x0_b.append(_X0_b[-1])
_lst_y0.append(_Y0[-1])
_lst_y0_b.append(_Y0_b[-1])
# ANCIENNE VERSION (TRANSMISSION DES FLUX THERMIQUES
if(oldVersion):
alpha = round(theta)
if DIR_FISS == 'X':
levre1pos = ((_Y0[0] - _yi) >= 0.)
if alpha == -90.:
_lst_x0.reverse()
_lst_p.reverse()
_lst_f.reverse()
_lst_dir = _lst_x0
else:
levre1pos = ((_X0[0] - _xi) >= 0.)
if abs(alpha) == 180.:
_lst_y0.reverse()
_lst_p.reverse()
_lst_f.reverse()
_lst_dir = _lst_y0
# Creation des listes pour les chargements aster :
# (x1, y1, x2, y2, ...)
_tmp1 = []
_tmp2 = []
_tmp3 = []
for i in range(len(_lst_p)):
_tmp1.append(_lst_dir[i])
_tmp2.append(_lst_dir[i])
_tmp3.append(_lst_dir[i])
_tmp2.append(_lst_p[i])
if levre1pos:
#_tmp1.append( -1*_lst_f[i] )
#_tmp3.append( _lst_f[i] )
_tmp1.append(_lst_f[i])
_tmp3.append(-1 * _lst_f[i])
else:
#_tmp1.append( _lst_f[i] )
#_tmp3.append( -1*_lst_f[i] )
_tmp1.append(-1 * _lst_f[i])
_tmp3.append(_lst_f[i])
# Flux en provenance d'Ecrevisse
_L_F1 = DEFI_FONCTION(NOM_PARA=DIR_FISS,
VALE=_tmp1,
PROL_GAUCHE='LINEAIRE',
PROL_DROITE='LINEAIRE')
_L_F2 = DEFI_FONCTION(NOM_PARA=DIR_FISS,
VALE=_tmp3,
PROL_GAUCHE='LINEAIRE',
PROL_DROITE='LINEAIRE')
if DIR_FISS == 'X':
l_FLUX_REP_F1.append(
_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
FLUX_Y=_L_F1,))
l_FLUX_REP_F2.append(
_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
FLUX_Y=_L_F2,))
else:
l_FLUX_REP_F1.append(
_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
FLUX_X=_L_F1,))
l_FLUX_REP_F2.append(
_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
FLUX_X=_L_F2,))
# Pressions en provenance d'Ecrevisse
_L_P = DEFI_FONCTION(NOM_PARA=DIR_FISS,
VALE=_tmp2,
PROL_GAUCHE='LINEAIRE',
PROL_DROITE='LINEAIRE')
l_PRES_REP.append(
_F(GROUP_MA=(dFISSURE[
'GROUP_MA'][0], dFISSURE['GROUP_MA'][1]),
PRES=_L_P,))
# NOUVELLE VERSION
else:
# Creation des deux listes (x1, y1, x2, y2, ...)
# On cree trois/six listes :
# Les valeurs sont constant par maille sur les levres de la fissure,
# _tmp1/_tmp2 = temperature
# _tmp3/_tmp4 = coefficient d echange
# _tmp5/_tmp6 = pression
_tmp1 = []
_tmp2 = []
_tmp3 = []
_tmp4 = []
_tmp5 = []
_tmp6 = []
for i in range(len(_lst_f)):
ix = copy(i)
iy = copy(i)
if _X0[1] < _X0[0]:
ix = len(_lst_f) - 1 - i
if _Y0[1] < _Y0[0]:
iy = len(_lst_f) - 1 - i
if (DIR_PREV == 'X'):
_tmp1.append(_lst_x0[ix])
_tmp1.append(_lst_t[ix])
_tmp3.append(_lst_x0[ix])
_tmp3.append(_lst_cc[ix])
_tmp5.append(_lst_x0[ix])
_tmp5.append(_lst_p[ix])
_tmp2.append(_lst_x0_b[ix])
_tmp2.append(_lst_t[ix])
_tmp4.append(_lst_x0_b[ix])
_tmp4.append(_lst_cc[ix])
_tmp6.append(_lst_x0_b[ix])
_tmp6.append(_lst_p[ix])
else:
_tmp1.append(_lst_y0[iy])
_tmp1.append(_lst_t[iy])
_tmp3.append(_lst_y0[iy])
_tmp3.append(_lst_cc[iy])
_tmp5.append(_lst_y0[iy])
_tmp5.append(_lst_p[iy])
_tmp2.append(_lst_y0_b[iy])
_tmp2.append(_lst_t[iy])
_tmp4.append(_lst_y0_b[iy])
_tmp4.append(_lst_cc[iy])
_tmp6.append(_lst_y0_b[iy])
_tmp6.append(_lst_p[iy])
# Couplage thermique : Temperature et coefficients
# d'echange en provenance d'Ecrevisse
_L_T1 = DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp1,
PROL_GAUCHE='LINEAIRE',
PROL_DROITE='LINEAIRE')
_L_T2 = DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp2,
PROL_GAUCHE='LINEAIRE',
PROL_DROITE='LINEAIRE')
_L_CC1 = DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp3,
PROL_GAUCHE='LINEAIRE',
PROL_DROITE='LINEAIRE')
_L_CC2 = DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp4,
PROL_GAUCHE='LINEAIRE',
PROL_DROITE='LINEAIRE')
l_ECHANGE_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
TEMP_EXT=_L_T1,
COEF_H=_L_CC2))
l_ECHANGE_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
TEMP_EXT=_L_T2,
COEF_H=_L_CC2))
# Couplage mecanique : Pressions en provenance d'Ecrevisse
_L_P1 = DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp5,
PROL_GAUCHE='LINEAIRE',
PROL_DROITE='LINEAIRE')
_L_P2 = DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp6,
PROL_GAUCHE='LINEAIRE',
PROL_DROITE='LINEAIRE')
l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0]),
PRES=_L_P1,))
l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][1]),
PRES=_L_P2,))
# Fin extraction des conditions limites du calcul Ecrevisse
# ----------------------------------------------------------
if debug:
print ('FISSURE-' + str(k + 1))
print '_lst_c:', len(_lst_c), _lst_c
print '_lst_f:', len(_lst_f), _lst_f
print '_lst_p:', len(_lst_p), _lst_p
print '_lst_t:', len(_lst_t), _lst_t
print '_lst_cc:', len(_lst_cc), _lst_cc
print '_lst_x0:', len(_lst_x0), _lst_x0
print '_lst_x0_b :', len(_lst_x0_b), _lst_x0_b
print '_lst_y0:', len(_lst_y0), _lst_y0
print '_lst_y0_b :', len(_lst_y0_b), _lst_y0_b
print '_tmp1 :', len(_tmp1), _tmp1
print '_tmp2 :', len(_tmp2), _tmp2
print '_tmp3 :', len(_tmp3), _tmp3
if (not oldVersion):
print '_tmp4 :', len(_tmp4), _tmp4
print '_tmp5 :', len(_tmp5), _tmp5
print '_tmp6 :', len(_tmp6), _tmp6
# Fin du boucle sur la fissure for k
# Assemblage des concepts sortants
if(oldVersion):
__ECR_F1 = AFFE_CHAR_THER_F(MODELE=MODELE_THER,
FLUX_REP=l_FLUX_REP_F1)
__ECR_F2 = AFFE_CHAR_THER_F(MODELE=MODELE_THER,
FLUX_REP=l_FLUX_REP_F2)
else:
__ECR_F1 = AFFE_CHAR_THER_F(MODELE=MODELE_THER,
ECHANGE=l_ECHANGE_F1)
__ECR_F2 = AFFE_CHAR_THER_F(MODELE=MODELE_THER,
ECHANGE=l_ECHANGE_F2)
__ECR_P = AFFE_CHAR_MECA_F(MODELE=MODELE_MECA,
PRES_REP=l_PRES_REP)
# Table resultat
try:
dprod = __TABFISS_tot.dict_CREA_TABLE()
__TAB = CREA_TABLE(**dprod)
debprod = __DEBFISS_tot.dict_CREA_TABLE()
__DEB = CREA_TABLE(**debprod)
except:
UTMESS('F', 'ECREVISSE0_9', valr=[Inst_Ecrevisse])
def calc_precont_ops(self, reuse, MODELE, CHAM_MATER, CARA_ELEM, EXCIT,
CABLE_BP, CABLE_BP_INACTIF, COMPORTEMENT, ETAT_INIT,
METHODE, ENERGIE, RECH_LINEAIRE, CONVERGENCE, INCREMENT,
SOLVEUR, INFO, TITRE, **args):
"""
Ecriture de la macro CALC_PRECONT
"""
import copy
import aster
import string
import types
from code_aster.Cata.Syntax import _F
from code_aster.Cata.DataStructure import listr8_sdaster, list_inst
from Noyau.N_utils import AsType
from Noyau.N_types import is_sequence
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
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_CHAMP = self.get_cmd('CALC_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')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
DETRUIRE = self.get_cmd('DETRUIRE')
# 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)
# alarme de STAT_NON_LINE si les mot-cles de COMPORTEMENT sont renseignes
# a tort
MasquerAlarme('COMPOR4_70')
# -------------------------------------------------------------
# 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']
if type(__L0) == listr8_sdaster:
# cas où liste definie par DEFI_LIST_REEL
__L1 = __L0.Valeurs()
elif type(__L0) == list_inst:
# cas où liste definie par DEFI_LIST_INST
tmp = __L0.get_name().ljust(8) + '.LIST.' + 'DITR'.ljust(18)
__L1 = aster.getvectjev(tmp)
# 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]
else:
dEtatInit = None
# Teste si INST_INIT est donné ou bien recalcule __TMIN
if dIncrement['INST_INIT'] == None:
if self.reuse == None:
__TMIN = __L1[0]
else:
__dico = self.reuse.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', 'CABLE0_1')
# Preparation de la liste d'instant __L2 allant de __TMIN a __TMAX
# et preparation des instants supplementaire __TINT et __TINT2
__L2 = []
for m in __L1:
if m >= __TMIN and m <= __TMAX:
__L2.append(m)
if len(__L2) < 2:
UTMESS('F', 'CABLE0_4')
__TINT = (9. * __L2[-1] + __L2[-2]) / 10.
__TINT2 = (9.5 * __L2[-1] + .5 * __L2[-2]) / 10.
# cas ADHERENT ou non
ii = 0
typ_ma = []
for mcabl in CABLE_BP:
__TCAB1 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_GL')
table_cable = __TCAB1.EXTR_TABLE()
__adher = table_cable.ADHERENT.values()[0]
__typ_ma = table_cable.TYPE_MAILLE.values()[0]
typ_ma.append(__typ_ma)
if ii == 0:
adher = __adher
elif ii != 0 and __adher != adher:
UTMESS('F', 'CABLE0_3')
ii += 1
# DETRUIRE(CONCEPT=_F(NOM=__TCAB1))
adher = adher.strip()
if (adher == 'OUI'):
# finalisation liste instants
__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
# -------------------------------------------------------
motscle4 = {}
motscle5 = {}
if METHODE == 'NEWTON':
motscle4['NEWTON'] = args['NEWTON'].List_F()
motscle5['NEWTON'] = args['NEWTON'].List_F()
# for j in dNewton.keys():
# if dNewton[j]==None : del dNewton[j]
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 ENERGIE:
dEnergie = ENERGIE[0].cree_dict_valeurs(ENERGIE[0].mc_liste)
motscle4['ENERGIE'] = dEnergie
motscle5['ENERGIE'] = dEnergie
# 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 not is_sequence(CABLE_BP):
CABLE_BP0 = CABLE_BP
CABLE_BP = []
CABLE_BP.append(CABLE_BP0)
if type(CABLE_BP_INACTIF) is not types.NoneType:
if not is_sequence(CABLE_BP_INACTIF):
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'] = []
set_GROUP_MA_A_SEG2 = set()
set_GROUP_MA_A_SEG3 = set()
for ica, mcabl in enumerate(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')
table_cable = __TCAB.EXTR_TABLE()
col_nom_cable = table_cable.NOM_CABLE
__typ_ma = typ_ma[ica]
if __typ_ma.strip() == 'SEG2':
set_GROUP_MA_A_SEG2.update(col_nom_cable.values())
elif __typ_ma.strip() == 'SEG3':
set_GROUP_MA_A_SEG3.update(col_nom_cable.values())
else:
raise Exception('type inconnu')
__GROUP_MA_A_SEG2 = list(set_GROUP_MA_A_SEG2)
__GROUP_MA_A_SEG3 = list(set_GROUP_MA_A_SEG3)
# 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
set_GROUP_MA_I_SEG2 = set()
set_GROUP_MA_I_SEG3 = set()
if CABLE_BP_INACTIF:
motscle6 = {}
motscle6['RELA_CINE_BP'] = []
for mcabl in CABLE_BP_INACTIF:
__TCA0 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_BP')
__TCA2 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_GL')
col_nom_cable = __TCA0.EXTR_TABLE().NOM_CABLE
__typ_ma = __TCA2.EXTR_TABLE().TYPE_MAILLE.values()[0]
if __typ_ma.strip() == 'SEG2':
set_GROUP_MA_I_SEG2.update(col_nom_cable.values())
elif __typ_ma.strip() == 'SEG3':
set_GROUP_MA_I_SEG3.update(col_nom_cable.values())
else:
raise Exception('type inconnu')
# 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_I_SEG2 = list(set_GROUP_MA_I_SEG2)
__GROUP_MA_I_SEG3 = list(set_GROUP_MA_I_SEG3)
__GROUP_MA_CABLES_SEG2 = __GROUP_MA_A_SEG2 + __GROUP_MA_I_SEG2
__GROUP_MA_CABLES_SEG3 = __GROUP_MA_A_SEG3 + __GROUP_MA_I_SEG3
# 1.4 Creation des mots-clés facteurs COMPORTEMENT
# pour étape 2 (dComp_incr0) et étape 3 (dComp_incr1)
# ------------------------------------------------------
dComp_incr = []
for j in COMPORTEMENT:
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)
PARM_THETA = 0.
for j in range(len(COMPORTEMENT)):
if dComp_incr[j]['RELATION'] == 'ELAS':
PARM_THETA = dComp_incr[j]['PARM_THETA']
if PARM_THETA == 0:
PARM_THETA = dComp_incr[0]['PARM_THETA']
dComp_incrElas = []
affe_mo = []
if __GROUP_MA_A_SEG3 != []:
comp_seg3 = {
'RELATION': 'KIT_CG',
'GROUP_MA': __GROUP_MA_A_SEG3,
'PARM_THETA': PARM_THETA
}
comp_seg3['RELATION_KIT'] = (
'ELAS',
'CABLE_GAINE_FROT',
)
dComp_incrElas.append(comp_seg3)
affe_mo.append({
'GROUP_MA': __GROUP_MA_A_SEG3,
'PHENOMENE': 'MECANIQUE',
'MODELISATION': 'CABLE_GAINE',
})
if __GROUP_MA_A_SEG2 != []:
dComp_incrElas.append({
'RELATION': 'ELAS',
'TOUT': 'OUI',
'PARM_THETA': PARM_THETA
})
affe_mo.append({
'GROUP_MA': __GROUP_MA_A_SEG2,
'PHENOMENE': 'MECANIQUE',
'MODELISATION': 'BARRE',
})
if __GROUP_MA_CABLES_SEG3 != []:
dComp_incr0.append(
_F(
RELATION='KIT_CG',
RELATION_KIT=(
'SANS',
'CABLE_GAINE_FROT',
),
GROUP_MA=__GROUP_MA_CABLES_SEG3,
))
if __GROUP_MA_I_SEG3:
dComp_incr1.append(
_F(
RELATION='KIT_CG',
RELATION_KIT=(
'SANS',
'CABLE_GAINE_FROT',
),
GROUP_MA=__GROUP_MA_I_SEG3,
))
if __GROUP_MA_CABLES_SEG2 != []:
dComp_incr0.append(
_F(
RELATION='SANS',
GROUP_MA=__GROUP_MA_CABLES_SEG2,
))
if __GROUP_MA_I_SEG2:
dComp_incr1.append(
_F(
RELATION='SANS',
GROUP_MA=__GROUP_MA_I_SEG2,
))
# 1.5 Modele contenant uniquement les cables de precontrainte
# ---------------------------------------------------------
__MOD = string.ljust(MODELE.nom, 8)
__MOD1 = __MOD + '.MODELE .LGRF '
__LMAIL = aster.getvectjev(__MOD1)
__MAIL = string.strip(__LMAIL[0])
objma = self.get_sd_avant_etape(__MAIL, self)
__M_CA = AFFE_MODELE(MAILLAGE=objma, AFFE=affe_mo)
# 1.6 Blocage de tous les noeuds des cables actifs
# --------------------------------------------------
__GROUP_MA_A = __GROUP_MA_A_SEG2 + __GROUP_MA_A_SEG3
_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),
),
COMPORTEMENT=dComp_incrElas,
INCREMENT=_F(LIST_INST=__LST0, PRECISION=__prec),
SOLVEUR=dSolveur,
INFO=INFO,
TITRE=TITRE,
)
__EV1 = CALC_CHAMP(
reuse=__EV1,
RESULTAT=__EV1,
# GROUP_MA = __GROUP_MA_A,
FORCE='FORC_NODA')
__REA = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
RESULTAT=__EV1,
NOM_CHAM='FORC_NODA',
INST=__TMAX)
__REAC0 = CREA_CHAMP(
TYPE_CHAM='NOEU_DEPL_R',
OPERATION='AFFE',
MODELE=MODELE,
AFFE=_F(TOUT='OUI',
NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS',
'SITY'),
VALE=(0., 0., 0., 0., 0., 0., 0., 0.)),
)
__REAC = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='ASSE',
MODELE=MODELE,
ASSE=(
_F(TOUT='OUI', CHAM_GD=__REAC0, COEF_R=1.),
_F(GROUP_MA=__GROUP_MA_A,
CHAM_GD=__REA,
COEF_R=-1.),
))
_F_CA = AFFE_CHAR_MECA(MODELE=MODELE, 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), )
if self.reuse:
motscle4['reuse'] = self.reuse
RES = STAT_NON_LINE(MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=dComp_incr0,
INCREMENT=dIncrement,
ETAT_INIT=dEtatInit,
METHODE=METHODE,
CONVERGENCE=dConvergence,
RECH_LINEAIRE=dRech_lin,
SOLVEUR=dSolveur,
ARCHIVAGE=_F(INST=__TINT),
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit1,
**motscle4)
# 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,
COMPORTEMENT=dComp_incr1,
INCREMENT=_F(LIST_INST=__LST, PRECISION=__prec),
METHODE=METHODE,
# NEWTON =dNewton,
# IMPLEX=dImplex,
RECH_LINEAIRE=dRech_lin,
CONVERGENCE=dConvergence,
SOLVEUR=dSolveur,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit2,
**motscle5)
elif adher == 'NON':
motscle4 = {}
motscle2 = {}
motscle2 = {}
motscle2['DDL_IMPO'] = []
motscle2['RELA_CINE_BP'] = []
motscle2a = {}
motscle2a['DDL_IMPO'] = []
motscle2a['RELA_CINE_BP'] = []
motscle2b = {}
motscle2b['DDL_IMPO'] = []
motscle2b['RELA_CINE_BP'] = []
motscle5 = {}
motscle5['DDL_IMPO'] = []
motscle5['RELA_CINE_BP'] = []
motscle3 = {}
motscle3['AFFE'] = [
_F(TOUT='OUI',
NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'),
VALE=(0., 0., 0., 0., 0., 0., 0., 0.))
]
motscle3a = {}
motscle3a['AFFE'] = [
_F(TOUT='OUI',
NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'),
VALE=(0., 0., 0., 0., 0., 0., 0., 0.))
]
motscle3b = {}
motscle3b['AFFE'] = [
_F(TOUT='OUI',
NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'),
VALE=(0., 0., 0., 0., 0., 0., 0., 0.))
]
motscle6 = {}
motscle6['DDL_IMPO'] = []
__ActifActif = False
if self.reuse:
motscle4['reuse'] = self.reuse
# assert (len(CABLE_BP) == 1)
# traitement des cables inactifs
if type(CABLE_BP_INACTIF) is not types.NoneType:
if not is_sequence(CABLE_BP_INACTIF):
CABLE_BP_INACTIF0 = CABLE_BP_INACTIF
CABLE_BP_INACTIF = []
CABLE_BP_INACTIF.append(CABLE_BP_INACTIF0)
else:
CABLE_BP_INACTIF = []
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',
))
for mcabl in CABLE_BP:
__TCAB1 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_GL')
motscle2['RELA_CINE_BP'].append(
_F(
CABLE_BP=mcabl,
SIGM_BPEL='NON',
RELA_CINE='OUI',
))
motscle5['RELA_CINE_BP'].append(
_F(
CABLE_BP=mcabl,
SIGM_BPEL='NON',
RELA_CINE='OUI',
))
nb_cable = len(__TCAB1.EXTR_TABLE().NOM_ANCRAGE1.values())
table_cable = __TCAB1.EXTR_TABLE()
for icable in xrange(nb_cable):
__typ_ancr = (table_cable.TYPE_ANCRAGE1.values()[icable],
table_cable.TYPE_ANCRAGE2.values()[icable])
__typ_noeu = (table_cable.TYPE_NOEUD1.values()[icable],
table_cable.TYPE_NOEUD2.values()[icable])
__nom_noeu = (table_cable.NOM_ANCRAGE1.values()[icable],
table_cable.NOM_ANCRAGE2.values()[icable])
__tension = table_cable.TENSION.values()[icable]
__recul = table_cable.RECUL_ANCRAGE.values()[icable]
__recul_exists = (__recul != 0)
__sens = table_cable.SENS.values()[icable]
actif = 0
ancr1_passif = 1
for j in range(2):
if string.strip(__typ_ancr[j]) == 'PASSIF':
if j == 0:
ancr1_passif = -1
if string.strip(__typ_noeu[j]) == 'NOEUD':
motscle2['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]), GLIS=0.))
if __recul_exists:
motscle5['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
GLIS=0.))
else:
motscle2['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=0.))
if __recul_exists:
motscle5['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=0.))
else:
actif += 1
if string.strip(__typ_noeu[j]) == 'NOEUD':
motscle3['AFFE'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=ancr1_passif * __sens * __tension *
(-1)**(j + 1)))
if j == 0:
motscle3b['AFFE'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=__sens * __tension *
(-1)**(j + 1)))
motscle2a['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
GLIS=0.))
else:
motscle3a['AFFE'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=ancr1_passif * __sens * __tension *
(-1)**(j + 1)))
motscle2b['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
GLIS=0.))
if __recul_exists:
motscle5['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
GLIS=ancr1_passif * __sens * __recul *
(-1)**(j)))
else:
motscle3['AFFE'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=ancr1_passif * __sens * __tension *
(-1)**(j + 1)))
if j == 0:
motscle3b['AFFE'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=__sens * __tension *
(-1)**(j + 1)))
motscle2a['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=0.))
else:
motscle3a['AFFE'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=ancr1_passif * __sens * __tension *
(-1)**(j + 1)))
motscle2b['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=0.))
if __recul_exists:
motscle5['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=ancr1_passif * __sens * __recul *
(-1)**(j)))
if (actif == 2):
__ActifActif = True
# DETRUIRE(CONCEPT=_F(NOM=__TCAB1))
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]
assert (len(motscle3) > 0)
if __ActifActif:
dExcit1a = copy.copy(dExcit)
dExcit1b = copy.copy(dExcit)
if CABLE_BP_INACTIF:
_C_CI = AFFE_CHAR_MECA(MODELE=MODELE, **motscle6)
dExcit1a.append(_F(CHARGE=_C_CI, ))
dExcit1b.append(_F(CHARGE=_C_CI, ))
__CH1a = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='AFFE',
MODELE=MODELE,
**motscle3a)
__CH1b = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='AFFE',
MODELE=MODELE,
**motscle3b)
_C_CAc = AFFE_CHAR_MECA(MODELE=MODELE,
VECT_ASSE=__CH1a,
**motscle2)
_C_CAd = AFFE_CHAR_MECA(MODELE=MODELE,
VECT_ASSE=__CH1b,
**motscle2)
_C_CAa = AFFE_CHAR_MECA(MODELE=MODELE, **motscle2a)
_C_CAb = AFFE_CHAR_MECA(MODELE=MODELE, **motscle2b)
dExcit1a.append(_F(CHARGE=_C_CAa, TYPE_CHARGE='DIDI'))
dExcit1b.append(_F(CHARGE=_C_CAb, TYPE_CHARGE='DIDI'))
dExcit1a.append(_F(CHARGE=_C_CAc))
dExcit1b.append(_F(CHARGE=_C_CAd))
__L2[-1:-1] = [__TINT]
else:
dExcit1 = copy.copy(dExcit)
if CABLE_BP_INACTIF:
_C_CI = AFFE_CHAR_MECA(MODELE=MODELE, **motscle6)
dExcit1.append(_F(CHARGE=_C_CI, ))
__CH1 = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='AFFE',
MODELE=MODELE,
**motscle3)
_C_CA = AFFE_CHAR_MECA(MODELE=MODELE, VECT_ASSE=__CH1, **motscle2)
dExcit1.append(_F(CHARGE=_C_CA, TYPE_CHARGE='DIDI'), )
_C_RA = AFFE_CHAR_MECA(MODELE=MODELE, **motscle5)
dExcit2 = copy.copy(dExcit)
dExcit2.append(_F(CHARGE=_C_RA, TYPE_CHARGE='DIDI'), )
if CABLE_BP_INACTIF:
dExcit2.append(_F(CHARGE=_C_CI, ))
if __recul_exists:
__L2[-1:-1] = [__TINT2]
__LST = DEFI_LIST_REEL(VALE=__L2, )
for i in dIncrement.keys():
if dIncrement[i] == None:
del dIncrement[i]
dIncrement['LIST_INST'] = __LST
else:
if __ActifActif:
__LST = DEFI_LIST_REEL(VALE=__L2, )
for i in dIncrement.keys():
if dIncrement[i] == None:
del dIncrement[i]
dIncrement['LIST_INST'] = __LST
else:
dIncrement = INCREMENT
if __ActifActif:
dIncrement['INST_FIN'] = __TINT
RES = STAT_NON_LINE(
MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=COMPORTEMENT,
# INCREMENT=INCREMENT,
INCREMENT=dIncrement,
NEWTON=_F(REAC_ITER=1),
ETAT_INIT=ETAT_INIT,
METHODE=METHODE,
CONVERGENCE=CONVERGENCE,
RECH_LINEAIRE=RECH_LINEAIRE,
SOLVEUR=SOLVEUR,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit1a,
**motscle4)
if __recul_exists:
dIncrement['INST_FIN'] = __TINT2
else:
dIncrement['INST_FIN'] = __TMAX
RES = STAT_NON_LINE(
reuse=RES,
ETAT_INIT=_F(EVOL_NOLI=RES),
MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=COMPORTEMENT,
# INCREMENT=INCREMENT,
INCREMENT=dIncrement,
NEWTON=_F(REAC_ITER=1),
METHODE=METHODE,
CONVERGENCE=CONVERGENCE,
RECH_LINEAIRE=RECH_LINEAIRE,
SOLVEUR=SOLVEUR,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit1b,
)
else:
if __recul_exists:
dIncrement['INST_FIN'] = __TINT2
RES = STAT_NON_LINE(
MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=COMPORTEMENT,
# INCREMENT=INCREMENT,
INCREMENT=dIncrement,
NEWTON=_F(REAC_ITER=1),
METHODE=METHODE,
ETAT_INIT=ETAT_INIT,
CONVERGENCE=CONVERGENCE,
RECH_LINEAIRE=RECH_LINEAIRE,
SOLVEUR=SOLVEUR,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit1,
**motscle4)
if __recul_exists:
RES = STAT_NON_LINE(
reuse=RES,
ETAT_INIT=_F(EVOL_NOLI=RES),
MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=COMPORTEMENT,
# INCREMENT=INCREMENT,
INCREMENT=_F(LIST_INST=__LST, PRECISION=__prec),
NEWTON=_F(REAC_ITER=1),
# ETAT_INIT = ETAT_INIT,
METHODE=METHODE,
CONVERGENCE=CONVERGENCE,
RECH_LINEAIRE=RECH_LINEAIRE,
SOLVEUR=SOLVEUR,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit2,
)
else:
raise Exception(
"erreur de programmation, adher different de OUI et NON")
RetablirAlarme('COMPOR4_70')
return ier
def post_decollement_ops(self, RESULTAT, NOM_CHAM, NOM_CMP, GROUP_MA, INFO, **args):
"""
Corps de la macro POST_DECOLLEMENT
"""
ier = 0
import aster
import os
import string
import types
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
# On importe les definitions des commandes a utiliser dans la macro
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
POST_ELEM = self.get_cmd('POST_ELEM')
CREA_TABLE = self.get_cmd('CREA_TABLE')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
DEFI_GROUP = self.get_cmd('DEFI_GROUP')
DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU')
CREA_RESU = self.get_cmd('CREA_RESU')
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
# Comptage commandes + déclaration concept sortant
self.set_icmd(1)
self.DeclareOut('C_out', self.sd)
# on recupere le concept maillage
iret, ibid, nom_mo = aster.dismoi('MODELE', RESULTAT.nom, 'RESULTAT', 'F')
if nom_mo == '#AUCUN' :
iret, ibid, numddl = aster.dismoi('NUME_DDL', RESULTAT.nom, 'RESU_DYNA', 'F')
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', numddl, 'NUME_DDL', 'F')
else :
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', nom_mo.strip(), 'MODELE', 'F')
MAILLAGE = self.get_concept(nom_ma.strip())
# Creation du groupe de noeuds 'PDECOL'
DEFI_GROUP(reuse=MAILLAGE, MAILLAGE=MAILLAGE,
DETR_GROUP_NO=_F(NOM='PDECOL',),
CREA_GROUP_NO=_F(GROUP_MA=GROUP_MA, NOM='PDECOL'),
ALARME='NON',)
# le modele 3D ne va contenir que des mailles de peau : on masque les
# alarmes
MasquerAlarme('CALCULEL2_63')
MasquerAlarme('CALCULEL2_64')
# model restreint au GROUP_MA
__model = AFFE_MODELE(MAILLAGE=MAILLAGE,
AFFE=_F(GROUP_MA=GROUP_MA, PHENOMENE='MECANIQUE',
MODELISATION='3D'),)
# le modele 3D ne va contenir que des mailles de peau : on retablit les
# alarmes
RetablirAlarme('CALCULEL2_63')
RetablirAlarme('CALCULEL2_64')
# Calcul de la surface du GROUP_MA : __surf
__unit = CREA_CHAMP(
OPERATION='AFFE', TYPE_CHAM='NOEU_NEUT_R', MODELE=__model,
AFFE=_F(GROUP_NO='PDECOL', NOM_CMP='X1', VALE=1.0),)
__chpg0 = CREA_CHAMP(
PROL_ZERO='OUI', MODELE=__model, OPERATION='DISC', TYPE_CHAM='ELGA_NEUT_R',
CHAM_GD=__unit)
__mater0 = DEFI_MATERIAU(ELAS=_F(E=210000000.0, NU=0.3),)
__chmat0 = AFFE_MATERIAU(
MODELE=__model, MAILLAGE=MAILLAGE, AFFE=_F(TOUT='OUI', MATER=__mater0),)
__resu0 = CREA_RESU(
OPERATION='AFFE', TYPE_RESU='EVOL_ELAS', NOM_CHAM='VARI_ELGA',
AFFE=_F(CHAM_MATER=__chmat0, MODELE=__model, CHAM_GD=__chpg0, INST=0.0),)
__tbSurf0 = POST_ELEM(RESULTAT=__resu0, INST=0.0, MODELE=__model,
INTEGRALE=_F(NOM_CHAM='VARI_ELGA', NOM_CMP='X1', GROUP_MA=GROUP_MA, TYPE_MAILLE='2D'),)
__surf = __tbSurf0.EXTR_TABLE().values()['INTE_X1'][0]
__linst = RESULTAT.LIST_VARI_ACCES()['INST']
# Calcul de la surface des noeuds décollés
__pct = []
for inst in __linst:
__dep = CREA_CHAMP(
OPERATION='EXTR', RESULTAT=RESULTAT, TYPE_CHAM='NOEU_' + NOM_CHAM[:4] + '_R',
INST=inst, NOM_CHAM=NOM_CHAM)
__tb1 = POST_RELEVE_T(
ACTION=_F(
OPERATION='EXTRACTION', GROUP_NO='PDECOL', INTITULE=GROUP_MA,
CHAM_GD=__dep, NOM_CMP=NOM_CMP),)
__col = fctZeroUn(__tb1.EXTR_TABLE().values()[NOM_CMP])
__tb2 = CREA_TABLE(
LISTE=(
_F(LISTE_K=__tb1.EXTR_TABLE().values()['NOEUD'], PARA='NOEUD'),
_F(LISTE_R=__col, PARA='X1'),),)
__ch = CREA_CHAMP(
OPERATION='EXTR', TYPE_CHAM='NOEU_NEUT_R', TABLE=__tb2, MAILLAGE=MAILLAGE)
__chg = CREA_CHAMP(
MODELE=__model, OPERATION='DISC', TYPE_CHAM='ELGA_NEUT_R',
PROL_ZERO='OUI', CHAM_GD=__ch)
__resu = CREA_RESU(
OPERATION='AFFE', TYPE_RESU='EVOL_ELAS', NOM_CHAM='VARI_ELGA',
AFFE=_F(CHAM_MATER=__chmat0, MODELE=__model, CHAM_GD=__chg, INST=0.0),)
__tb3 = POST_ELEM(RESULTAT=__resu, INST=0.0, MODELE=__model,
INTEGRALE=_F(NOM_CHAM='VARI_ELGA', NOM_CMP='X1', GROUP_MA=GROUP_MA, TYPE_MAILLE='2D'),)
__su2 = __tb3.EXTR_TABLE().values()['INTE_X1'][0]
__pct.append(100.0 * __su2 / __surf)
C_out = CREA_TABLE(LISTE=(_F(LISTE_R=__linst, PARA='INST'),
_F(LISTE_R=__pct, PARA='%DECOL'),),)
if INFO > 1:
IMPR_TABLE(UNITE=6,
TABLE=C_out)
return ier
def asse_champs_gauss(self, dic_champ_cont, dic_champ_var_int, dic_transfo,
resu):
"""
Transformation et assemblage des champs aux points de Gauss.
"""
from code_aster.Cata.Commands import LIRE_CHAMP, CREA_CHAMP, DETRUIRE
from code_aster.Cata.Commands import CREA_RESU, MODI_REPERE
info_mode_epx = self.info_mode_epx
info_comp_epx = self.info_comp_epx
dic_mc_cara = self.dic_mc_cara
ll = len(dic_champ_cont.keys()) - 1
nb_SIG1 = len(dic_champ_cont['SANS'].keys()) + ll
ll = len(dic_champ_var_int.keys()) - 1
nb_ECR1 = len(dic_champ_var_int['SANS'].keys()) + ll
itot = len(resu.LIST_PARA()['INST'])
__EFFG = [None] * itot
__ECRG = [None] * itot
__SIG1 = [None] * nb_SIG1
__ECR1 = [None] * nb_ECR1
dicAffe = []
dicAffe3 = []
lc = {
'INFO': self.INFO,
'UNITE': self.UNITE_MED,
'MODELE': self.MODELE,
'MAILLAGE': self.MAILLAGE,
'PROL_ZERO': 'OUI',
}
cc = {
'INFO': self.INFO,
'MODELE': self.MODELE,
'PROL_ZERO': 'OUI',
'OPERATION': 'ASSE',
}
MasquerAlarme('MED_4')
for i in xrange(itot):
lc['NUME_PT'] = resu.LIST_PARA()['NUME_ORDRE'][i]
dicAsse = []
dicAsse3 = []
dicDetr = []
# CONTRAINTES
lc['TYPE_CHAM'] = 'ELGA_SIEF_R'
for mc_cara in dic_champ_cont.keys():
j = 0
if mc_cara == 'SANS':
for champ in dic_champ_cont[mc_cara].keys():
mode_epx = dic_champ_cont[mc_cara][champ]
nom_cmp = info_mode_epx[mode_epx]['NOM_CMP']
nom_cmp_med = info_mode_epx[mode_epx]['NOM_CMP_MED']
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__SIG1[j] = LIRE_CHAMP(**lcc)
dicDetr.append({'NOM': __SIG1[j]})
dicAsse.append({
'TOUT': 'OUI',
'CHAM_GD': __SIG1[j],
'NOM_CMP': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
j += 1
else:
nb_champ_cara = len(dic_champ_cont[mc_cara].keys())
dicDetr_cara = []
if nb_champ_cara == 1:
champ = dic_champ_cont[mc_cara].keys()[0]
mode_epx = dic_champ_cont[mc_cara][champ]
nom_cmp = info_mode_epx[mode_epx]['NOM_CMP']
nom_cmp_med = info_mode_epx[mode_epx]['NOM_CMP_MED']
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__SIG_AS = LIRE_CHAMP(**lcc)
else:
__SIG = [None] * nb_champ_cara
dicAsse_cara = []
for k, champ in enumerate(
dic_champ_cont[mc_cara].keys()):
mode_epx = dic_champ_cont[mc_cara][champ]
nom_cmp = info_mode_epx[mode_epx]['NOM_CMP']
nom_cmp_med = info_mode_epx[mode_epx][
'NOM_CMP_MED']
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__SIG[k] = LIRE_CHAMP(**lcc)
dicAsse_cara.append({
'TOUT': 'OUI',
'CHAM_GD': __SIG[k],
'NOM_CMP': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
dicDetr_cara.append({'NOM': __SIG[k]})
# assemblage
ccc = cc.copy()
ccc.update(
TYPE_CHAM='ELGA_SIEF_R',
ASSE=dicAsse_cara,
)
__SIG_AS = CREA_CHAMP(**ccc)
dicDetr_cara.append({'NOM': __SIG_AS})
cham_para = (dic_mc_cara[mc_cara]['CH_CARA'], __SIG_AS)
cham_fonc = dic_mc_cara[mc_cara]['CH_FONC']
# EVAL : passage des contraintes aux efforts
__SIG1[j] = CREA_CHAMP(
OPERATION='EVAL',
TYPE_CHAM='ELGA_NEUT_R',
CHAM_F=cham_fonc,
CHAM_PARA=cham_para,
)
dicDetr.append({'NOM': __SIG1[j]})
nom_cmp = dic_mc_cara[mc_cara]['NOM_CMP']
nom_cmp_f = dic_mc_cara[mc_cara]['NOM_CMP_F']
dicAsse.append({
'TOUT': 'OUI',
'CHAM_GD': __SIG1[j],
'NOM_CMP': nom_cmp_f,
'NOM_CMP_RESU': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
DETRUIRE(CONCEPT=dicDetr_cara, INFO=1)
j += 1
# VARIABLES INTERNES
lc['TYPE_CHAM'] = 'ELGA_VARI_R'
for compo in dic_champ_var_int.keys():
j = 0
if compo == 'SANS':
for champ in dic_champ_var_int[compo].keys():
loi = dic_champ_var_int[compo][champ]
nb_var_aster = info_comp_epx[loi]['NB_VAR_ASTER']
nom_cmp = info_comp_epx[loi][
'VAR_ASTER'][:nb_var_aster]
nom_cmp_med = info_comp_epx[loi][
'VAR_EPX'][:nb_var_aster]
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__ECR1[j] = LIRE_CHAMP(**lcc)
dicAsse3.append({
'TOUT': 'OUI',
'CHAM_GD': __ECR1[j],
'NOM_CMP': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
dicDetr.append({'NOM': __ECR1[j]})
j += 1
else:
nb_champ_transfo = len(dic_champ_var_int[compo].keys())
dicDetr_transfo = []
if nb_champ_transfo == 1:
champ = dic_champ_var_int[compo].keys()[0]
loi = dic_champ_var_int[compo][champ]
nb_var_epx = info_comp_epx[loi]['NB_VAR_EPX']
nom_cmp = info_comp_epx[loi]['VAR_ASTER'][:nb_var_epx]
nom_cmp_med = info_comp_epx[loi][
'VAR_EPX'][:nb_var_epx]
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__ECR_AS = LIRE_CHAMP(**lcc)
else:
__ECR = [None] * nb_champ_transfo
dicAsse_transfo = []
for k, champ in enumerate(
dic_champ_var_int[compo].keys()):
loi = dic_champ_var_int[compo][champ]
nb_var_epx = info_comp_epx[loi]['NB_VAR_EPX']
nom_cmp = info_comp_epx[loi][
'VAR_ASTER'][:nb_var_epx]
nom_cmp_med = info_comp_epx[loi][
'VAR_EPX'][:nb_var_epx]
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__ECR[k] = LIRE_CHAMP(**lcc)
dicAsse_transfo.append({
'TOUT': 'OUI',
'CHAM_GD': __ECR[k],
'NOM_CMP': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
dicDetr_transfo.append({'NOM': __ECR[k]})
# assemblage
ccc = cc.copy()
ccc.update(
TYPE_CHAM='ELGA_VARI_R',
ASSE=dicAsse_transfo,
)
__ECR_AS = CREA_CHAMP(**ccc)
dicDetr_transfo.append({'NOM': __ECR_AS})
cham_para = __ECR_AS
cham_fonc = dic_transfo[compo]['CH_FONC']
# EVAL : transormation EPX -> Aster
try:
__ECR1[j] = CREA_CHAMP(
OPERATION='EVAL',
TYPE_CHAM='ELGA_NEUT_R',
CHAM_F=cham_fonc,
CHAM_PARA=cham_para,
)
dicDetr.append({'NOM': __ECR1[j]})
except:
compor_aster = self.info_comp_epx[compo][
'COMPOR_ASTER']
UTMESS('F', 'PLEXUS_57', valk=compor_aster)
nom_cmp = dic_transfo[compo]['NOM_CMP']
nom_cmp_f = dic_transfo[compo]['NOM_CMP_F']
dicAsse3.append({
'TOUT': 'OUI',
'CHAM_GD': __ECR1[j],
'NOM_CMP': nom_cmp_f,
'NOM_CMP_RESU': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
DETRUIRE(CONCEPT=dicDetr_transfo, INFO=1)
j += 1
if dicAsse != []:
ccc = cc.copy()
ccc.update(
TYPE_CHAM='ELGA_SIEF_R',
ASSE=dicAsse,
)
__EFFG[i] = CREA_CHAMP(**ccc)
dic = {
'MODELE': self.MODELE,
'INST': resu.LIST_PARA()['INST'][i],
}
if self.CHAM_MATER is not None:
dic['CHAM_MATER'] = self.CHAM_MATER
if self.CARA_ELEM_CONCEPT is not None:
dic['CARA_ELEM'] = self.CARA_ELEM_CONCEPT
dic['CHAM_GD'] = __EFFG[i]
dicAffe.append(dic)
if dicAsse3 != []:
ccc = cc.copy()
ccc.update(TYPE_CHAM='ELGA_VARI_R', ASSE=dicAsse3)
__ECRG[i] = CREA_CHAMP(**ccc)
dic2 = dic.copy()
dic2['CHAM_GD'] = __ECRG[i]
dicAffe3.append(dic2)
if dicDetr != []:
DETRUIRE(CONCEPT=dicDetr, INFO=1)
RetablirAlarme('MED_4')
MasquerAlarme('COMPOR2_26')
MasquerAlarme('COMPOR2_23')
if dicAffe != []:
resu = CREA_RESU(
reuse=resu,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='SIEF_ELGA',
AFFE=dicAffe,
)
if dicAffe3 != []:
resu = CREA_RESU(
reuse=resu,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='VARI_ELGA',
AFFE=dicAffe3,
)
RetablirAlarme('COMPOR2_26')
RetablirAlarme('COMPOR2_23')
if self.modi_repere['COQUE']:
from code_aster.Cata.Commands import MODI_REPERE
MODI_REPERE(RESULTAT=resu,
reuse=resu,
REPERE='COQUE_INTR_UTIL',
MODI_CHAM=_F(TYPE_CHAM='COQUE_GENE',
NOM_CHAM='SIEF_ELGA',
NOM_CMP=('NXX', 'NYY', 'NXY', 'MXX',
'MYY', 'MXY', 'QX', 'QY')))
def calc_gp_ops(self, **args):
"""Corps de CALC_GP"""
from numpy import *
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
MasquerAlarme('CALCCHAMP_1')
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
global DEFI_GROUP
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_TABLE = self.get_cmd('CREA_TABLE')
POST_ELEM = self.get_cmd('POST_ELEM')
FORMULE = self.get_cmd('FORMULE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
DEFI_GROUP = self.get_cmd('DEFI_GROUP')
#
#
# RECUPERATION DU MODELE, DU MAILLAGE ET DU MATERIAU A PARTIR DU RESULTAT
#
__RESU = self['RESULTAT']
# modele
iret, ibid, n_modele = aster.dismoi('MODELE', __RESU.nom, 'RESULTAT', 'F')
n_modele = n_modele.rstrip()
if len(n_modele) == 0 or n_modele == "#PLUSIEURS":
UTMESS('F', 'RUPTURE1_58')
__model = self.get_concept(n_modele)
# Dimension du modele
iret, ndim, rbid = aster.dismoi('DIM_GEOM', __model.nom, 'MODELE', 'F')
#
# maillage
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', __RESU.nom, 'RESULTAT',
'F')
__maillage = self.get_concept(nom_ma.strip())
#
# champ materiau (inutile mais permet d eviter des alarmes)
iret, ibid, nom_cham_mater = aster.dismoi('CHAM_MATER', __RESU.nom,
'RESULTAT', 'F')
__cham_mater = self.get_concept(nom_cham_mater.strip())
#
# RECUPERATION DES DONNEES DE SYMETRIE ET DU FOND DE FISSURE
#
# mult=Coefficient multiplicatif suivant la symetrie du probleme
mult = 1.
if self['TRANCHE_2D'] != None:
TRANCHE_2D = self['TRANCHE_2D']
if ndim != 2:
UTMESS('F', 'RUPTURE1_19', ['TRANCHE_2D', '2D'])
# symetrie
if self['SYME'] == 'OUI':
mult = 2.
else:
TRANCHE_3D = self['TRANCHE_3D']
if ndim != 3:
UTMESS('F', 'RUPTURE1_19', ['TRANCHE_3D', '3D'])
# liste des noeuds du fond de fissure
l_noeuds_fissure = self['FOND_FISS'].sdj.FOND_NOEU.get()
if l_noeuds_fissure == None:
# Cas double fond de fissure : par convention les noeuds sont ceux de
# fond_inf
l_noeuds_fissure = self['FOND_FISS'].sdj.FONDINF_NOEU.get()
# normale au plan de la fissure
lnormale = self['FOND_FISS'].sdj.NORMALE.get()
if (lnormale == None):
UTMESS('F', 'POST0_39')
# symetrie
iret, ibid, syme = aster.dismoi('SYME', self['FOND_FISS'].nom,
'FOND_FISS', 'F')
if syme == 'OUI':
mult = 2
#
# VERIFICATION DE LA LISTE DES INSTANTS
#
# Verification que les instants demandes sont bien dans le resultat
# Construction des instants de calcul par la meme occasion
list_inst = __RESU.LIST_VARI_ACCES()['INST']
l_inst_final = []
for inst in self['LIST_INST'].Valeurs():
if self['CRITERE'] == 'ABSOLU':
prec = self['PRECISION']
elif self['CRITERE'] == 'RELATIF':
prec = self['PRECISION'] * inst
match = [
x for x in list_inst if ((x + prec >= inst) and (x - prec <= inst))
]
if len(match) == 0:
UTMESS('F', 'RUPTURE0_38', valr=inst)
if len(match) >= 2:
UTMESS('F', 'RUPTURE0_39', valr=inst)
l_inst_final.append(match[0])
nb_inst = len(l_inst_final)
__linstr8 = DEFI_LIST_REEL(VALE=l_inst_final)
#
# PREPARATION DES SORTIES SI GPMAX
#
# Definition du concept sortant systematique dans le contexte de la macro
# L'eventuel champ de copeaux est cree plus tard si besoin
self.DeclareOut('tabout', self.sd)
# Definition de la sortie facultative GP_MAX
GPMAX = self['GPMAX']
if GPMAX != None:
self.DeclareOut('tabgpmax', GPMAX)
# Creation des colonnes de la table de sortie gpmax
tabinstmax = []
tabcopmax = []
tabenelmax = []
tablcopmax = []
tabgpmax = []
#
#
# CALCUL DES GP
#
#
# 1/ CAS 2D
#
if ndim == 2:
#
# 1.1/ CAS OU L UTILISATEUR A DEFINI DES GROUPES DE MAILLE COPEAU
# IL SUFFIT ALORS DE CALCULER L ENERGIE DANS CES GROUPES ET D EN DEDUIRE LE GP
#
if TRANCHE_2D['ZONE_MAIL'] == 'OUI':
lgroupma = TRANCHE_2D['GROUP_MA']
lcopeau = TRANCHE_2D['TAILLE'].Valeurs()
if len(lgroupma) != len(lcopeau):
UTMESS('F', 'RUPTURE1_21')
nbcop = len(lcopeau)
tabmax = [0] * nbcop * nb_inst
tabcop = lgroupma * nb_inst
tablcop = lcopeau * nb_inst
__enertemp = POST_ELEM(MODELE=__model,
RESULTAT=__RESU,
LIST_INST=__linstr8,
ENER_ELTR=_F(GROUP_MA=lgroupma))
enerel = __enertemp.EXTR_TABLE()
tabenel = [mult * x for x in enerel.TOTALE.values()]
tabgp = [tabenel[x] / tablcop[x] for x in range(len(tabenel))]
tabinst = enerel.INST.values()
for i in range(nb_inst):
maxinst = max(tabgp[i * nbcop:(i + 1) * nbcop])
index1 = tabgp[i * nbcop:(i + 1) * nbcop].index(maxinst)
index = index1 + i * nbcop
tabmax[index] = 1
if GPMAX != None:
tabinstmax.append(tabinst[index])
tabcopmax.append(tabcop[index])
tabenelmax.append(tabenel[index])
tablcopmax.append(tablcop[index])
tabgpmax.append(tabgp[index])
#
# 1.2/ CAS OU L UTILISATEUR N A PAS DEFINI DES GROUPES DE MAILLE COPEAU
# IL FAUT CREER UN DES COPEAUX PAR ENSEMBLE DE POINTS DE GAUSS ET JOUER AVEC
#
elif TRANCHE_2D['ZONE_MAIL'] == 'NON':
nbcop = TRANCHE_2D['NB_ZONE']
theta = TRANCHE_2D['ANGLE']
taille = TRANCHE_2D['TAILLE']
# Manipulation obligatoire pour pouvoir se servir des grandeurs dans les
# formules
self.update_const_context({'origine': TRANCHE_2D['CENTRE']})
self.update_const_context({'rayon': TRANCHE_2D['RAYON']})
self.update_const_context({'taille': taille})
self.update_const_context({'theta': theta})
self.update_const_context({'NRJ': NRJ})
nom_cmp = ['X%d' % k for k in range(1, nbcop + 1)]
nom_cop = ['COPS_%d' % k for k in range(1, nbcop + 1)]
# champ de geometrie et de points de gauss (coordonnees des points de gauss)
__CHXN = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_GEOM_R',
NOM_CHAM='GEOMETRIE',
MAILLAGE=__maillage)
__CHXG = CREA_CHAMP(OPERATION='DISC',
TYPE_CHAM='ELGA_GEOM_R',
MODELE=__model,
CHAM_GD=__CHXN)
# construction du champ copeau pour visualisation par utilisateur s'il le
# souhaite
if TRANCHE_2D['CHAMP_VISU'] != 0:
self.DeclareOut('chp_cop', TRANCHE_2D['CHAMP_VISU'])
self.update_const_context({'SEUIL': SEUIL})
self.update_const_context({'ccos': cos(theta * pi / 180.)})
self.update_const_context({'ssin': sin(theta * pi / 180.)})
__seuil = [None for i in range(nbcop)]
for cop in range(nbcop):
__seuil[cop] = FORMULE(
VALE=
'''SEUIL(X,Y,origine[0],origine[1],rayon,taille,%d,ccos,ssin)'''
% (cop + 1),
NOM_PARA=('X', 'Y'),
)
__formule_seuil = CREA_CHAMP(
TYPE_CHAM='ELGA_NEUT_F',
MODELE=__model,
OPERATION='AFFE',
PROL_ZERO='OUI',
AFFE=_F(
TOUT='OUI',
NOM_CMP=nom_cmp,
VALE_F=__seuil,
),
)
chp_cop = CREA_CHAMP(
TYPE_CHAM='ELGA_NEUT_R',
OPERATION='EVAL',
CHAM_F=__formule_seuil,
CHAM_PARA=(__CHXG),
)
# calcul des energies et du gp
__ener = [None for cop in range(nbcop)]
for cop in range(nbcop):
__ener[cop] = FORMULE(
VALE=
'''NRJ(TOTALE,X,Y,origine[0],origine[1],rayon,taille,%d,ccos,ssin)'''
% (cop + 1),
NOM_PARA=('TOTALE', 'X', 'Y'),
)
__formule_ener = CREA_CHAMP(
TYPE_CHAM='ELGA_NEUT_F',
MODELE=__model,
OPERATION='AFFE',
PROL_ZERO='OUI',
AFFE=_F(
TOUT='OUI',
NOM_CMP=nom_cmp,
VALE_F=__ener,
),
)
__RESU = CALC_CHAMP(
reuse=__RESU,
RESULTAT=__RESU,
LIST_INST=__linstr8,
ENERGIE=('ENEL_ELGA'),
)
tabmax = [0] * nbcop * nb_inst
tabcop = nom_cop * nb_inst
tablcop = [taille * (cop + 1) for cop in range(nbcop)] * nb_inst
tabinst = []
tabenel = []
tabgp = []
for i, inst in enumerate(l_inst_final):
__energa = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='ELGA_ENER_R',
NOM_CHAM='ENEL_ELGA',
RESULTAT=__RESU,
INST=inst)
__resinter = CREA_CHAMP(
TYPE_CHAM='ELGA_NEUT_R',
OPERATION='EVAL',
CHAM_F=__formule_ener,
CHAM_PARA=(__energa, __CHXG),
)
__tabnrj = POST_ELEM(
CHAM_GD=__resinter,
MODELE=__model,
CHAM_MATER=__cham_mater,
INTEGRALE=_F(TOUT='OUI',
NOM_CHAM='ENEL_ELGA',
NOM_CMP=nom_cmp,
DEJA_INTEGRE='NON',
TYPE_MAILLE='2D'),
)
tabenerel = __tabnrj.EXTR_TABLE().values()
tabinst = tabinst + [inst] * nbcop
enerel = [
mult * tabenerel['INTE_X%d' % (cop + 1)][0]
for cop in range(nbcop)
]
tabenel += enerel
gp = [
enerel[cop] / (taille * (cop + 1)) for cop in range(nbcop)
]
tabgp += gp
maxinst = max(tabgp[i * nbcop:(i + 1) * nbcop])
index1 = tabgp[i * nbcop:(i + 1) * nbcop].index(maxinst)
index = index1 + i * nbcop
tabmax[index] = 1
if GPMAX != None:
tabinstmax.append(tabinst[index])
tabcopmax.append(tabcop[index])
tabenelmax.append(tabenel[index])
tablcopmax.append(tablcop[index])
tabgpmax.append(tabgp[index])
#
# 2/ CAS 3D
#
elif ndim == 3:
# type des mailles
ltyma = aster.getvectjev("&CATA.TM.NOMTM")
# liste des copeaux
l_copo_tot = []
for tmpocc in TRANCHE_3D:
dMCT = tmpocc.cree_dict_valeurs(tmpocc.mc_liste)
l_copo_tot += dMCT['GROUP_MA']
# le nombre de copeaux est suppose identique sur toutes les tranches
nbcoptot = len(l_copo_tot)
nbcop = nbcoptot / len(TRANCHE_3D)
# calcul de la surface des mailles appartenant au plan de symetrie de
# l'entaille
mesure = Calcul_mesure_3D(__maillage, nbcop, l_copo_tot, ltyma,
l_noeuds_fissure[0], lnormale)
# calcul des energies et du gp
__enertemp = POST_ELEM(
MODELE=__model,
RESULTAT=__RESU,
LIST_INST=__linstr8,
ENER_ELTR=_F(GROUP_MA=l_copo_tot),
TITRE='Energie elastique de traction',
)
enerel = __enertemp.EXTR_TABLE()
tabcop = enerel.LIEU.values()
tabenel = [mult * x for x in enerel.TOTALE.values()]
tabinst = enerel.INST.values()
tablcop = mesure * nb_inst
tabgp = [tabenel[x] / tablcop[x] for x in range(len(tabenel))]
tabmax = [0] * nbcoptot * nb_inst
for i in range(nb_inst):
maxinst = max(tabgp[nbcoptot * i:nbcoptot * (i + 1)])
index1 = tabgp[nbcoptot * i:nbcoptot * (i + 1)].index(maxinst)
index = index1 + i * nbcoptot
tabmax[index] = 1
if GPMAX != None:
tabinstmax.append(tabinst[index])
tabcopmax.append(tabcop[index])
tabenelmax.append(tabenel[index])
tablcopmax.append(tablcop[index])
tabgpmax.append(tabgp[index])
#
#
# CREATION DE LA TABLE DE SORTIE
#
tabout = CREA_TABLE(LISTE=(
_F(PARA='INST', LISTE_R=tabinst),
_F(
PARA='ZONE',
LISTE_K=tabcop,
),
_F(
PARA='ENER ELAS',
LISTE_R=tabenel,
),
_F(
PARA='DELTA L',
LISTE_R=tablcop,
),
_F(
PARA='GP',
LISTE_R=tabgp,
),
_F(
PARA='MAX_INST',
LISTE_I=tabmax,
),
), )
if GPMAX != None:
tabgpmax = CREA_TABLE(LISTE=(
_F(PARA='INST', LISTE_R=tabinstmax),
_F(
PARA='ZONE',
LISTE_K=tabcopmax,
),
_F(
PARA='ENER ELAS',
LISTE_R=tabenelmax,
),
_F(
PARA='DELTA L',
LISTE_R=tablcopmax,
),
_F(
PARA='GP',
LISTE_R=tabgpmax,
),
), )
RetablirAlarme('CALCCHAMP_1')
return ier
def macr_lign_coupe_ops(self, RESULTAT, CHAM_GD, UNITE_MAILLAGE, LIGN_COUPE,
NOM_CHAM, MODELE, **args):
"""
Ecriture de la macro MACR_LIGN_COUPE
"""
from code_aster.Cata.Syntax import _F
from Noyau.N_utils import AsType
import aster
import math
from Utilitai.UniteAster import UniteAster
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
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')
CREA_RESU = self.get_cmd('CREA_RESU')
COPIER = self.get_cmd('COPIER')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
#
MasquerAlarme('ALGORITH12_43')
MasquerAlarme('CALCULEL2_63')
MasquerAlarme('CALCULEL2_64')
MasquerAlarme('MODELISA5_53')
MasquerAlarme('MODELE1_58')
MasquerAlarme('MODELE1_63')
MasquerAlarme('MODELE1_64')
mcORDR = {}
l_mode_meca_sans_modele = False
if RESULTAT != None:
if args['NUME_ORDRE'] != None:
mcORDR['NUME_ORDRE'] = args['NUME_ORDRE']
elif args['NUME_MODE'] != None:
mcORDR['NUME_MODE'] = args['NUME_MODE']
elif args['LIST_ORDRE'] != None:
mcORDR['LIST_ORDRE'] = args['LIST_ORDRE']
elif args['INST'] != None:
mcORDR['INST'] = args['INST']
elif args['INST'] != None:
mcORDR['INST'] = args['INST']
elif args['LIST_INST'] != None:
mcORDR['LIST_INST'] = args['LIST_INST']
else:
mcORDR['TOUT_ORDRE'] = 'OUI'
nomresu = RESULTAT.nom
type_resu = AsType(RESULTAT).__name__
iret, ibid, n_modele = aster.dismoi('MODELE', nomresu, 'RESULTAT', 'F')
n_modele = n_modele.strip()
if n_modele in ('', '#AUCUN'):
if MODELE == None:
if (type_resu != 'mode_meca'):
UTMESS('F', 'POST0_9', valk=nomresu)
# si le résultat en entrée est un mode_meca et qu'il ne contient pas de modèle (il est obtenu par sous-structuration, par exemple)
# on passe le message fatal et on récupérera directement le
# maillage (ou squelette)
else:
l_mode_meca_sans_modele = True
UTMESS('I', 'POST0_23', valk=nomresu)
else:
n_modele = MODELE.nom
iret, ibid, l_mailla = aster.dismoi(
'NOM_MAILLA', nomresu, 'RESULTAT', 'F')
elif CHAM_GD != None:
mcORDR['TOUT_ORDRE'] = 'OUI'
if MODELE == None:
UTMESS('F', 'POST0_10')
else:
n_modele = MODELE.nom
# récupération de la grandeur du champ
n_cham = CHAM_GD.nom
catagd = aster.getvectjev("&CATA.GD.NOMGD")
desc = aster.getvectjev('%-19s.DESC' % n_cham)
if desc != None:
nomgd = catagd[desc[0] - 1]
else:
celd = aster.getvectjev('%-19s.CELD' % n_cham)
nomgd = catagd[celd[0] - 1]
# détermination du type de résultat à créer
if nomgd[:6] == 'TEMP_R':
TYPE_RESU = 'EVOL_THER'
if not NOM_CHAM:
NOM_CHAM = 'TEMP'
elif nomgd[:6] == 'DEPL_R':
TYPE_RESU = 'EVOL_ELAS'
if not NOM_CHAM:
NOM_CHAM = 'DEPL'
elif nomgd[:6] == 'NEUT_R':
TYPE_RESU = 'EVOL_VARC'
if not NOM_CHAM:
NOM_CHAM = 'NEUT'
elif nomgd[:6] == 'EPSI_R':
TYPE_RESU = 'EVOL_ELAS'
elif nomgd[:6] == 'VAR2_R':
TYPE_RESU = 'EVOL_NOLI'
elif nomgd[:6] == 'VARI_R':
TYPE_RESU = 'EVOL_NOLI'
elif nomgd[:6] == 'SIEF_R':
if not NOM_CHAM:
TYPE_RESU = 'EVOL_ELAS'
NOM_CHAM = 'DEPL'
elif NOM_CHAM[:4] == 'SIGM':
TYPE_RESU = 'EVOL_ELAS'
elif NOM_CHAM[:4] == 'SIEF':
TYPE_RESU = 'EVOL_NOLI'
else:
assert 0, 'grandeur imprevue : ' + nomgf
# création d'un concept résultat à partir du champ CHAM_GD
__resuch = CREA_RESU(OPERATION='AFFE',
NOM_CHAM=NOM_CHAM, TYPE_RESU=TYPE_RESU,
AFFE=_F(CHAM_GD=CHAM_GD, INST=0.),)
RESULTAT = __resuch
iret, ibid, l_mailla = aster.dismoi('NOM_MAILLA', n_cham, 'CHAMP', 'F')
# Maillage sur lequel s'appuie le résultat à projeter
n_mailla = l_mailla.strip()
# le maillage est-il 2D ou 3D ?
iret, dime, kbid = aster.dismoi('DIM_GEOM', n_mailla, 'MAILLAGE', 'F')
collgrma = aster.getcolljev(n_mailla.ljust(8) + '.GROUPEMA')
typma = aster.getvectjev(n_mailla.ljust(8) + '.TYPMAIL')
connex = aster.getcolljev(n_mailla.ljust(8) + '.CONNEX')
ltyma = aster.getvectjev("&CATA.TM.NOMTM")
lignes = []
groups = []
arcs = []
minidim = dime
for m in LIGN_COUPE:
if m['TYPE'] == 'SEGMENT':
lignes.append((m['COOR_ORIG'], m['COOR_EXTR'], m['NB_POINTS']))
minidim = min(minidim, len(m['COOR_ORIG']), len(m['COOR_EXTR']))
if minidim != dime:
UTMESS('F', 'POST0_11')
elif m['TYPE'] == 'ARC':
minidim = min(minidim, len(m['COOR_ORIG']), len(m['CENTRE']))
if minidim != dime:
UTMESS('F', 'POST0_11')
if dime == 2:
arcs.append(
(m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'],))
elif dime == 3:
if str(m['DNOR']) == 'None':
UTMESS('F', 'POST0_12')
arcs.append(
(m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'], m['DNOR']))
elif m['TYPE'] == 'GROUP_NO':
ngrno = m['GROUP_NO'].ljust(24)
collgrno = aster.getcolljev(n_mailla.ljust(8) + '.GROUPENO')
if ngrno not in collgrno.keys():
UTMESS('F', 'POST0_13', valk=[ngrno, 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)
elif m['TYPE'] == 'GROUP_MA':
ngrma = m['GROUP_MA'].ljust(24)
if ngrma not in collgrma.keys():
UTMESS('F', 'POST0_14', valk=[ngrma, n_mailla])
grpm = collgrma[ngrma]
for ma in grpm:
if ltyma[typma[ma - 1] - 1][:3] != 'SEG':
nomma = aster.getvectjev(n_mailla.ljust(8) + '.NOMMAI')
UTMESS('F', 'POST0_15', valk=[ngrma, nomma[ma - 1]])
__mailla = COPIER(CONCEPT=m['MAILLAGE'])
m2 = m.cree_dict_valeurs(m.mc_liste)
argsup = {}
if m2.get('GROUP_NO_ORIG'):
argsup['GROUP_NO_ORIG'] = m2.get('GROUP_NO_ORIG')
if m2.get('GROUP_NO_EXTR'):
argsup['GROUP_NO_EXTR'] = m2.get('GROUP_NO_EXTR')
if m2.get('NOEUD_ORIG'):
argsup['NOEUD_ORIG'] = m2.get('NOEUD_ORIG')
if m2.get('NOEUD_EXTR'):
argsup['NOEUD_EXTR'] = m2.get('NOEUD_EXTR')
if m2.get('VECT_ORIE'):
argsup['VECT_ORIE'] = m2.get('VECT_ORIE')
__mailla = DEFI_GROUP(reuse=__mailla, MAILLAGE=__mailla,
DETR_GROUP_NO=_F(NOM=str(m['GROUP_MA'])),
CREA_GROUP_NO=_F(OPTION='NOEUD_ORDO', NOM=str(m['GROUP_MA']),
GROUP_MA=m['GROUP_MA'], ORIGINE='SANS', **argsup))
collgrno = aster.getcolljev(__mailla.nom.ljust(8) + '.GROUPENO')
grpn = collgrno[str(m['GROUP_MA']).ljust(24)]
l_coor_group = [ngrma, ]
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 arcs != [] and (lignes != [] or groups != []):
UTMESS('F', 'POST0_16')
# 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, arcgma, angles, nbno = crea_mail_lig_coup(
dime, lignes, groups, arcs)
UL = UniteAster()
nomFichierSortie = UL.Nom(UNITE_MAILLAGE)
fproc = open(nomFichierSortie, 'w')
fproc.write(os.linesep.join(resu_mail))
fproc.close()
UL.EtatInit(UNITE_MAILLAGE)
# Lecture du maillage de seg2 contenant toutes les lignes de coupe
__macou = LIRE_MAILLAGE(FORMAT='ASTER',UNITE=UNITE_MAILLAGE,)
# distance min entre 2 points de la ligne de coupe (utile pour PROJ_CHAMP)
dmin = dist_min_deux_points(__macou)
motscles = {}
iocc = 1
motscles['CREA_GROUP_NO'] = []
for m in LIGN_COUPE:
if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'):
motscles['CREA_GROUP_NO'].append(
_F(GROUP_MA=m[m['TYPE']].ljust(24),))
else:
motscles['CREA_GROUP_NO'].append(_F(GROUP_MA='LICOU' + str(iocc),))
iocc = iocc + 1
__macou = DEFI_GROUP(reuse=__macou, MAILLAGE=__macou, **motscles)
if AsType(RESULTAT).__name__ in ('evol_elas', 'evol_noli', 'mode_meca',
'comb_fourier', 'mult_elas', 'fourier_elas'):
__mocou = AFFE_MODELE(MAILLAGE=__macou,
AFFE=_F(TOUT='OUI',
PHENOMENE='MECANIQUE',
MODELISATION='BARRE',),
DISTRIBUTION=_F(METHODE='CENTRALISE'),
)
elif AsType(RESULTAT).__name__ in ('evol_ther', 'evol_varc',):
__mocou = AFFE_MODELE(MAILLAGE=__macou,
AFFE=_F(TOUT='OUI',
PHENOMENE='THERMIQUE',
MODELISATION='PLAN',),)
motscles = {}
motscles['VIS_A_VIS'] = []
motscles[mcORDR.keys()[0]] = mcORDR.values()[0]
if args['VIS_A_VIS'] != None:
for v in args['VIS_A_VIS']:
if v['GROUP_MA_1'] != None:
motscles['VIS_A_VIS'].append(
_F(GROUP_MA_1=v['GROUP_MA_1'], TOUT_2='OUI'),)
elif v['MAILLE_1'] != None:
motscles['VIS_A_VIS'].append(
_F(MAILLE_1=v['MAILLE_1'], TOUT_2='OUI'),)
if NOM_CHAM[5:9] == 'ELGA':
UTMESS('A', 'POST0_18', valk=[NOM_CHAM, ])
if (l_mode_meca_sans_modele == False):
# on utilise le modèle pour projeter le champ
if n_modele in self.get_global_contexte().keys():
MODELE_1 = self.get_global_contexte()[n_modele]
else:
MODELE_1 = self.jdc.current_context[n_modele]
__recou = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=RESULTAT,
MODELE_1=MODELE_1,
DISTANCE_MAX=m['DISTANCE_MAX'],
MODELE_2=__mocou,
TYPE_CHAM='NOEU',
NOM_CHAM=NOM_CHAM, **motscles)
else:
# on utilise directement le maillage (ou squelette) pour projeter le
# champ
if n_mailla in self.get_global_contexte().keys():
MAILLAGE_1 = self.get_global_contexte()[n_mailla]
else:
MAILLAGE_1 = self.jdc.current_context[n_mailla]
__recou = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=RESULTAT,
MAILLAGE_1=MAILLAGE_1,
DISTANCE_MAX=m['DISTANCE_MAX'],
MODELE_2=__mocou,
TYPE_CHAM='NOEU',
NOM_CHAM=NOM_CHAM, **motscles)
__remodr = __recou
icham = 0
ioc2 = 0
mcACTION = []
angtab = []
if AsType(RESULTAT).__name__ in ('evol_ther', 'evol_elas', 'evol_noli', 'mode_meca', 'evol_varc',
'comb_fourier', 'mult_elas', 'fourier_elas'):
if NOM_CHAM in ('DEPL', 'SIEF_ELNO', 'SIGM_NOEU', 'SIGM_ELNO', 'FLUX_ELNO', 'FLUX_NOEU'):
icham = 1
iocc = 0
for m in LIGN_COUPE:
iocc = iocc + 1
motscles = {}
motscles['OPERATION'] = m['OPERATION']
if m['NOM_CMP'] != None:
motscles['NOM_CMP'] = m['NOM_CMP']
if m['TRAC_NOR'] != None:
motscles['TRAC_NOR'] = m['TRAC_NOR']
elif m['TRAC_DIR'] != None:
motscles['TRAC_DIR'] = m['TRAC_DIR']
motscles['DIRECTION'] = m['DIRECTION']
elif m['INVARIANT'] != None:
motscles['INVARIANT'] = m['INVARIANT']
elif m['RESULTANTE'] != None:
motscles['RESULTANTE'] = m['RESULTANTE']
elif m['ELEM_PRINCIPAUX'] != None:
motscles['ELEM_PRINCIPAUX'] = m['ELEM_PRINCIPAUX']
else:
motscles['TOUT_CMP'] = 'OUI'
# on définit le groupe de noeud pour post_releve_t
if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'):
groupe = m[m['TYPE']].ljust(8)
nomgrma = groupe
else:
ioc2 = ioc2 + 1
groupe = 'LICOU' + str(ioc2)
nomgrma = ' '
newgrp = 'LICOF' + str(ioc2)
crea_grp_matiere(
self, groupe, newgrp, iocc, m, __remodr, NOM_CHAM, LIGN_COUPE, __macou)
groupe = newgrp
# on definit l'intitulé
if m['INTITULE'] != None:
intitl = m['INTITULE']
elif m['TYPE'] in ('GROUP_NO', 'GROUP_MA'):
intitl = groupe
else:
intitl = 'l.coupe' + str(ioc2)
# Expression des contraintes aux noeuds ou des déplacements dans le
# repere local
if m['REPERE'] != 'GLOBAL':
if icham == 1:
if m['REPERE'] == 'POLAIRE':
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__remodr,
REPERE=m['REPERE'],
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
else:
__remodr = crea_resu_local(
self, dime, NOM_CHAM, m, __recou, __macou, nomgrma)
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__remodr,
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
else:
UTMESS('A', 'POST0_17', valk=[NOM_CHAM, m['REPERE']])
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__recou,
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
# Expression des contraintes aux noeuds ou des déplacements dans le
# repere global
else:
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__recou,
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
else:
assert 0
__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()
# Ajout de la colonne theta
if len(arcgma) > 0:
coltab = []
val = dictab['ABSC_CURV'].values()['ABSC_CURV']
nbi = len(val) / nbno
nba = len(angles)
tmp = []
for k in range(nba):
for j in range(nbi):
for i in range(len(angles[k])):
tmp.append(angles[k][i])
dictab['ANGLE'] = tmp
if 'RESU' in dictab.para:
del dictab['RESU']
if 'NOEUD' in dictab.para:
del dictab['NOEUD']
dprod = dictab.dict_CREA_TABLE()
nomres = CREA_TABLE(**dprod)
RetablirAlarme('ALGORITH12_43')
RetablirAlarme('CALCULEL2_63')
RetablirAlarme('CALCULEL2_64')
RetablirAlarme('MODELISA5_53')
RetablirAlarme('MODELE1_58')
RetablirAlarme('MODELE1_63')
RetablirAlarme('MODELE1_64')
return ier
def macr_ecrevisse_ops(self, reuse, CONV_CRITERE, TABLE, TEMPER, DEBIT,
MODELE_MECA, MODELE_THER, FISSURE, ECOULEMENT,
LIST_INST, MODELE_ECRE, CONVERGENCE_ECREVISSE, COURBES,
LOGICIEL, VERSION, ENTETE, IMPRESSION, CHAM_MATER,
TEMP_INIT, CARA_ELEM, CONTACT, EXCIT_MECA, EXCIT_THER,
COMPORTEMENT, NEWTON, CONVERGENCE, ETAT_INIT, ENERGIE,
INFO, **args):
"""
Procédure de couplage Code_Aster-Ecrevisse.
Exécution pour tous les pas de temps des calculs thermiques, mécaniques puis hydrauliques.
Découpage/Génération par Aster du fichier de données d'Ecrevisse et lancement d'Ecrevisse.
"""
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from Utilitai.Table import Table, merge
from code_aster.Cata.Syntax import _F
import aster_core
import os
import aster
import copy
ier = 0
#
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Parametres debug
debug = False
# Info
InfoAster = 1
info2 = (INFO == 2)
if debug:
info2 = True
# IMPORTATION DE COMMANDES ASTER
DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL")
THER_LINEAIRE = self.get_cmd("THER_LINEAIRE")
PROJ_CHAMP = self.get_cmd("PROJ_CHAMP")
DETRUIRE = self.get_cmd("DETRUIRE")
AFFE_MATERIAU = self.get_cmd("AFFE_MATERIAU")
STAT_NON_LINE = self.get_cmd("STAT_NON_LINE")
from Contrib.calc_ecrevisse import CALC_ECREVISSE
CO = self.get_cmd("CO")
CREA_TABLE = self.get_cmd("CREA_TABLE")
# Concepts sortants
# TABLE creees par concatenation des tables sorties par CALC_ECREVISSE a
# chaque iteration
self.DeclareOut('TABL_RES', TABLE)
self.DeclareOut('DEB_RES', DEBIT)
# Concepts sortant: les resultats de STAT_NON_LINE et de THER_LINEAIRE valides
# vis-a-vis du calcul ecrevisse
self.DeclareOut('RTHERM', TEMPER)
self.DeclareOut('MECANIC', self.sd)
# alarme de STAT_NON_LINE si les mot-cles de COMPORTEMENT sont renseignes
# a tort
MasquerAlarme('COMPOR4_70')
IsPoursuite = False
IsInit = True
# Traitement de l'etat initial en cas de poursuite
if ETAT_INIT:
dEtatInit = ETAT_INIT[0].cree_dict_toutes_valeurs()
EVINIT = dEtatInit['EVOL_NOLI']
_THINIT = dEtatInit['EVOL_THER']
nume_ordre = dEtatInit['NUME_ORDRE']
IsPoursuite = True
else:
dEtatInit = None
# Valeur par defaut du mot cle LOGICIEL
# if not LOGICIEL: LOGICIEL =
# os.path.join(aster_core.get_option('repout'), 'ecrevisse')
# RECUPERATION DES MOTS-CLES FACTEURS
l_dFISSURE = []
for fissure in FISSURE:
dFISSURE = fissure.cree_dict_toutes_valeurs()
l_dFISSURE.append(dFISSURE)
dECOULEMENT = ECOULEMENT[0].cree_dict_toutes_valeurs()
# on ne supprime pas les valeurs None
dMODELE_ECRE = MODELE_ECRE[0].cree_dict_valeurs(MODELE_ECRE[0].mc_liste)
dCONVERGENCE_ECREVISSE = CONVERGENCE_ECREVISSE[0].cree_dict_toutes_valeurs(
)
dCOMPORTEMENT = COMPORTEMENT[0].cree_dict_toutes_valeurs()
dNEWTON = NEWTON[0].cree_dict_toutes_valeurs()
dCONVERGENCE = CONVERGENCE[0].cree_dict_toutes_valeurs()
# Recuperation des infos pour la convergence de la macro
dMacr_Conv = CONV_CRITERE[0].cree_dict_toutes_valeurs()
motclefsCALC_ECREVISSE = {}
motclefsCALC_ECREVISSE['COURBES'] = COURBES,
# --------------------------------------------------------------------------
# Debut de la macro
# Si LIST_INST est un DEFI_LIST_REEL :
liste_inst = LIST_INST.Valeurs()
if (debug):
print 'liste des instants liste_inst = ', liste_inst
# Drapeaux pour les 1ers calculs et les 1eres definitions
# si l'execution d'Ecrevisse n'a pas plantee ou a ete realisee
EcrevisseExe = False
# Table python devant contenir toutes les tables Ecrevisse
T_TABL_RES = None
T_DEB_RES = None
# Precision demandee pour converger sur le critere de la macro
# Nombre de decoupages succesifs d'un pas de temps
# Pas de temps en dessous duquel on ne decoupe plus
if dMacr_Conv.has_key('SUBD_NIVEAU'):
MacrNbDecoupage = dMacr_Conv['SUBD_NIVEAU']
if dMacr_Conv.has_key('SUBD_PAS_MINI'):
MacrPasMini = dMacr_Conv['SUBD_PAS_MINI']
MacrTempRef = dMacr_Conv['TEMP_REF']
MacrPresRef = dMacr_Conv['PRES_REF']
MacrCritere = dMacr_Conv['CRITERE']
if dMacr_Conv.has_key('PREC_CRIT'):
MacrPrecisCritere = dMacr_Conv['PREC_CRIT']
else:
MacrPrecisCritere = None
if dMacr_Conv.has_key('NUME_ORDRE_MIN'):
MacrNumeOrdre = dMacr_Conv['NUME_ORDRE_MIN']
#
# il faut 2 pas au minimum dans la liste
if (len(liste_inst) < 2):
UTMESS('F', 'ECREVISSE0_20', vali=[2])
if (not IsPoursuite):
nume_ordre = 0
else:
# Dans le cas d'une poursuite :
# On reconstruit une nouvelle liste d'instant composee de l'ancienne liste
# jusqu'a l'instant recherche, puis de la nouvelle a partir de cet instant
# ainsi le nume_ordre de la nouvelle liste correspond au nume_ordre de
# l'ancienne
__dico1 = _THINIT.LIST_VARI_ACCES()
_list_precedente = __dico1['INST']
_list_numordre_prec = __dico1['NUME_ORDRE']
try:
idx_last = _list_numordre_prec.index(nume_ordre)
except:
UTMESS('F', 'ECREVISSE0_25', vali=nume_ordre)
_inst_init = _list_precedente[idx_last]
new_list = _list_precedente[0:idx_last + 1]
try:
# si l'instant est dans la liste, on recupere l'index
_idx = liste_inst.index(_inst_init)
_idx += 1
except:
# on cherche le plus proche
_idx = 0
found = False
if _inst_init >= liste_inst[-1]:
UTMESS('F', 'ECREVISSE0_26', valr=[liste_inst[-1], _inst_init])
for t in liste_inst:
if t > _inst_init:
found = True
break
_idx += 1
# liste precedent jusqu'a l'instant a recalculer (inclus, ca permet de gerer
# le cas ou l'instant a recalculer n'est pas dans la nouvelle liste : il sera ajoute)
# on lui ajoute la nouvelle liste a partir du l'instant a recalculer
new_list.extend(liste_inst[_idx:])
liste_inst = copy.copy(new_list)
#
# Debut boucle sur la liste d'instant
#
FinBoucle = False
while (not FinBoucle):
inst = liste_inst[nume_ordre]
if (debug):
print 'Instant debut boucle', inst
# On boucle jusqu'a convergence
NbIter = 0
while True:
if ((not IsPoursuite) or EcrevisseExe):
# Le temps que l'on traite
inst_p_un = liste_inst[nume_ordre + 1]
IsInitEcre = False
# Construction de la liste des pas
__pas = DEFI_LIST_REEL(VALE=liste_inst, )
if (debug):
print '=====> ===== ===== ===== <===='
print 'Iteration numero : ', NbIter
print 'Instant : ', inst
print 'Instant+1 : ', inst_p_un
print 'nume_ordre : ', nume_ordre + 1
print 'Donnee Ecrevisse : ', EcrevisseExe
# ---------------------
# THERMIQUE
# ---------------------
# Recuperation des chargements thermiques
_dEXCIT_THER = []
if EXCIT_THER:
for excit_i in EXCIT_THER:
dEXCIT_THER_i = excit_i.cree_dict_toutes_valeurs()
_dEXCIT_THER.append(dEXCIT_THER_i)
# Definition des chargements thermiques venant d Ecrevisse
if (EcrevisseExe):
_dEXCIT_THER.append(_F(CHARGE=FLU1ECR0))
_dEXCIT_THER.append(_F(CHARGE=FLU2ECR0))
# Definition de l'etat initial
motclefs = {}
if (nume_ordre == 0):
motclefs['ETAT_INIT'] = [
_F(VALE=TEMP_INIT, NUME_ORDRE=nume_ordre)
]
if (debug):
print 'thermique initialise avec tref'
else:
if (IsInit):
# if (IsPoursuite) :
motclefs['reuse'] = _THINIT
motclefs['ETAT_INIT'] = [
_F(EVOL_THER=_THINIT, NUME_ORDRE=nume_ordre)
]
if (debug):
print 'thermique initialise avec etat_initial'
else:
motclefs['reuse'] = RTHERM
motclefs['ETAT_INIT'] = [
_F(EVOL_THER=RTHERM, NUME_ORDRE=nume_ordre)
]
if (debug):
print 'thermique initialise avec instant precedent'
if (debug):
print '====> THER_LINEAIRE <===='
print ' Les charges thermiques'
print EXCIT_THER
if IsPoursuite:
_THINIT = THER_LINEAIRE(MODELE=MODELE_THER,
CHAM_MATER=CHAM_MATER,
EXCIT=_dEXCIT_THER,
INCREMENT=_F(
LIST_INST=__pas,
NUME_INST_INIT=nume_ordre,
NUME_INST_FIN=nume_ordre + 1,
),
INFO=InfoAster,
**motclefs)
_RTHMPJ = PROJ_CHAMP(
RESULTAT=_THINIT,
MODELE_1=MODELE_THER,
MODELE_2=MODELE_MECA,
METHODE='COLLOCATION',
VIS_A_VIS=_F(
TOUT_1='OUI',
TOUT_2='OUI',
),
INFO=2,
)
RTHERM = _THINIT
else:
RTHERM = THER_LINEAIRE(MODELE=MODELE_THER,
CHAM_MATER=CHAM_MATER,
EXCIT=_dEXCIT_THER,
INCREMENT=_F(
LIST_INST=__pas,
NUME_INST_INIT=nume_ordre,
NUME_INST_FIN=nume_ordre + 1,
),
INFO=InfoAster,
**motclefs)
# Projection du champ thermique, a tous les instants
# sinon pas de deformations thermiques
_RTHMPJ = PROJ_CHAMP(
RESULTAT=RTHERM,
MODELE_1=MODELE_THER,
MODELE_2=MODELE_MECA,
METHODE='COLLOCATION',
VIS_A_VIS=_F(
TOUT_1='OUI',
TOUT_2='OUI',
),
INFO=2,
)
# Definition du materiau pour la mecanique
# note : on doit le faire a chaque fois car le nom de concept _RTHMPJ
# est different a chaque passage
motclefmater = {}
motclefmater['AFFE'] = []
for j in CHAM_MATER['AFFE']:
motclefmater['AFFE'].append(j.cree_dict_toutes_valeurs())
motclefmater['MAILLAGE'] = CHAM_MATER['MAILLAGE']
# Set external state variables
motclefmater['AFFE_VARC'] = []
motclefmater['AFFE_VARC'] = [
_F(NOM_VARC='TEMP', VALE_REF=TEMP_INIT, EVOL=_RTHMPJ)
]
__MATMEC = AFFE_MATERIAU(**motclefmater)
# ---------------------
# MECANIQUE
# ---------------------
_dEXCIT_MECA = []
# Recuperation des chargements mecaniques
if EXCIT_MECA:
for excit_i in EXCIT_MECA:
dEXCIT_MECA_i = excit_i.cree_dict_toutes_valeurs()
_dEXCIT_MECA.append(dEXCIT_MECA_i)
# Definition des chargements venant d'Ecrevisse
if (EcrevisseExe):
_dEXCIT_MECA.append(_F(CHARGE=MECAECR0))
motclefs = {}
if (not IsPoursuite):
if (nume_ordre != 0):
motclefs['reuse'] = MECANIC
motclefs['ETAT_INIT'] = [
_F(EVOL_NOLI=MECANIC, NUME_ORDRE=nume_ordre)
]
if (debug):
print 'etat meca initial = pas precedent'
else:
if (debug):
print 'etat meca initial : vierge'
else:
motclefs['reuse'] = EVINIT
motclefs['ETAT_INIT'] = [
_F(EVOL_NOLI=EVINIT, NUME_ORDRE=nume_ordre)
]
if (debug):
print 'etat meca initial dReuseM', motclefs
if ENERGIE:
motclefs['ENERGIE'] = ENERGIE[0].cree_dict_valeurs(
ENERGIE[0].mc_liste)
if (debug):
print '====> STAT_NON_LINE <===='
if (debug):
print ' Les charges mecaniques'
print _dEXCIT_MECA
MECANIC = STAT_NON_LINE(MODELE=MODELE_MECA,
CHAM_MATER=__MATMEC,
CARA_ELEM=CARA_ELEM,
CONTACT=CONTACT,
EXCIT=_dEXCIT_MECA,
COMPORTEMENT=_F(**dCOMPORTEMENT),
INCREMENT=_F(
LIST_INST=__pas,
NUME_INST_INIT=nume_ordre,
NUME_INST_FIN=nume_ordre + 1,
),
NEWTON=_F(**dNEWTON),
CONVERGENCE=_F(**dCONVERGENCE),
INFO=InfoAster,
**motclefs)
# Destruction des concepts
# Thermique projete
# Liste des pas
DETRUIRE(CONCEPT=(
_F(NOM=_RTHMPJ),
_F(NOM=__pas),
), INFO=1)
else:
# CAS OU LA MACRO EST REENTRANTE : ON RELANCE ECREVISSE POUR CONNAITRE
# LES CHARGEMENT A UTILISER POUR LES PROBLEMES THERMIQUES ET
# MECANIQUES
inst_p_un = inst
IsInitEcre = True
# -----------------------------------------------------------------------
# ECREVISSE : ATTENTION SI REPRISE CALCUL, ON RECALCULE LE DERNIER INSTANT
# -------------------------------------------------------------------------
# Si Ecrevisse a deja ete fait une fois.
# ==> Efface les concepts qui sont en sortie
if (EcrevisseExe):
DETRUIRE(CONCEPT=(
_F(NOM=MECAECR1),
_F(NOM=FLU1ECR1),
_F(NOM=FLU2ECR1),
_F(NOM=TABLECR1),
_F(NOM=DEBIECR1),
),
INFO=1)
# On remplace FONC_XXX par la valeur XXX correspondante a l'instant
# inst_p_un
dECOULEMENT_ecrevisse = copy.copy(dECOULEMENT)
for fonc_name in [
"PRES_ENTREE_FO", "PRES_SORTIE_FO", "PRES_PART_FO",
"TITR_MASS_FO", "TEMP_ENTREE_FO"
]:
if dECOULEMENT.has_key(fonc_name):
fonc = dECOULEMENT_ecrevisse.pop(fonc_name)
vale_name = fonc_name.replace('_FO', '')
dECOULEMENT_ecrevisse[vale_name] = fonc(inst_p_un)
# Initialisation des concepts en sortie
MECAECR1 = CO('MECAECR1')
FLU1ECR1 = CO('FLU1ECR1')
FLU2ECR1 = CO('FLU2ECR1')
TABLECR1 = CO('TABLECR1')
DEBIECR1 = CO('DEBIECR1')
if (debug):
print '====> ECREVISSE entree dans CALC_ECREVISSE <===='
if (not IsPoursuite):
CALC_ECREVISSE(
CHARGE_MECA=MECAECR1,
CHARGE_THER1=FLU1ECR1,
CHARGE_THER2=FLU2ECR1,
TABLE=TABLECR1,
DEBIT=DEBIECR1,
MODELE_MECA=MODELE_MECA,
MODELE_THER=MODELE_THER,
ENTETE=ENTETE,
IMPRESSION=IMPRESSION,
INFO=INFO,
RESULTAT=_F(
THERMIQUE=RTHERM,
MECANIQUE=MECANIC,
INST=inst_p_un,
),
# chemin d acces a Ecrevisse
LOGICIEL=LOGICIEL,
VERSION=VERSION,
# donnees necessaire pour ecrevisse
# assurer la coherence des donnees en fonction
# de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
# activation eventuelle de TITR_VA et P_AIR
FISSURE=l_dFISSURE,
ECOULEMENT=_F(**dECOULEMENT_ecrevisse),
MODELE_ECRE=_F(**dMODELE_ECRE),
CONVERGENCE=_F(**dCONVERGENCE_ECREVISSE),
**motclefsCALC_ECREVISSE)
else:
CALC_ECREVISSE(
CHARGE_MECA=MECAECR1,
CHARGE_THER1=FLU1ECR1,
CHARGE_THER2=FLU2ECR1,
TABLE=TABLECR1,
DEBIT=DEBIECR1,
MODELE_MECA=MODELE_MECA,
MODELE_THER=MODELE_THER,
ENTETE=ENTETE,
IMPRESSION=IMPRESSION,
INFO=INFO,
RESULTAT=_F(
THERMIQUE=_THINIT,
MECANIQUE=EVINIT,
INST=inst_p_un,
),
# chemin d acces a Ecrevisse
LOGICIEL=LOGICIEL,
VERSION=VERSION,
# donnees necessaire pour ecrevisse
# assurer la coherence des donnees en fonction
# de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
# activation eventuelle de TITR_VA et P_AIR
FISSURE=l_dFISSURE,
ECOULEMENT=_F(**dECOULEMENT_ecrevisse),
MODELE_ECRE=_F(**dMODELE_ECRE),
CONVERGENCE=_F(**dCONVERGENCE_ECREVISSE),
**motclefsCALC_ECREVISSE)
if (debug):
print '====> ECREVISSE sortie de CALC_ECREVISSE <===='
# Recuperation des infos de la table resultat Ecrevisse
T_TABL_TMP1 = TABLECR1.EXTR_TABLE()
T_DEB_TMP1 = DEBIECR1.EXTR_TABLE()
# On ajoute deux colonnes supplementaires
# _nb_ligne = len(T_DEB_TMP1["DEBTOT"])
# T_DEB_TMP1["NUME_ORDRE"] = [nume_ordre+1]*_nb_ligne
# T_DEB_TMP1["INST"] = [inst_p_un]*_nb_ligne
# Le calcul Ecrevisse c'est bien passe ?
EcrevisseExe = (T_TABL_TMP1.values()['COTES'][0] != -1)
#
if (not EcrevisseExe):
# Destruction des concepts de sortie, et on arrete tout
DETRUIRE(CONCEPT=(
_F(NOM=MECAECR1),
_F(NOM=FLU1ECR1),
_F(NOM=FLU2ECR1),
_F(NOM=TABLECR1),
_F(NOM=DEBIECR1),
),
INFO=1)
if (not IsInit):
DETRUIRE(CONCEPT=(
_F(NOM=MECAECR0),
_F(NOM=FLU1ECR0),
_F(NOM=FLU2ECR0),
_F(NOM=TABLECR0),
_F(NOM=DEBIECR0),
),
INFO=1)
FinBoucle = True
break
#
# A t'on atteint la convergence
# TABLECR0 table Ecrevisse a inst
# TABLECR1 table Ecrevisse a inst_p_un
# --------------------
if (not IsInit):
# On recupere la liste des temperatures a t et t+1
lst_T_0 = T_TABL_TMP0.values()['TEMP']
lst_T_1 = T_TABL_TMP1.values()['TEMP']
# Le maximum des ecarts
lst_T_diff_01 = []
for v1, v2 in zip(lst_T_0, lst_T_1):
lst_T_diff_01.append(abs(v1 - v2))
max_T_diff_01 = max(lst_T_diff_01)
# On recupere la liste des pressions a t et t+1
lst_P_0 = T_TABL_TMP0.values()['PRESSION']
lst_P_1 = T_TABL_TMP1.values()['PRESSION']
# Le maximum des ecarts
lst_P_diff_01 = []
for v1, v2 in zip(lst_P_0, lst_P_1):
lst_P_diff_01.append(abs(v1 - v2))
max_P_diff_01 = max(lst_P_diff_01)
#
# "TEMP_PRESS","EXPLICITE","TEMP","PRESS"
ErreurT = (max_T_diff_01 / MacrTempRef)
ErreurP = (max_P_diff_01 / MacrPresRef)
ErreurG = (ErreurT**2 + ErreurP**2)**0.5
if (MacrCritere == 'TEMP'):
Erreur = ErreurT
elif (MacrCritere == 'PRESS'):
Erreur = ErreurP
else:
Erreur = ErreurG
if (MacrCritere != 'EXPLICITE'):
Convergence = (Erreur <= MacrPrecisCritere)
#
if info2:
# Info Critere
UTMESS('I',
'ECREVISSE0_35',
valr=inst_p_un,
valk=[MacrCritere, MacrPrecisCritere, Convergence])
# Info Convergence
UTMESS('I',
'ECREVISSE0_34',
valr=[
inst_p_un, ErreurT, max_T_diff_01, ErreurP,
max_P_diff_01, ErreurG
])
else:
Convergence = True
if info2:
UTMESS('I', 'ECREVISSE0_36', valr=[inst_p_un])
# --------------------
#
if (MacrCritere == 'EXPLICITE'):
Convergence = True
else:
if ((nume_ordre != 0) and (nume_ordre + 1 <= MacrNumeOrdre)):
UTMESS('A',
'ECREVISSE0_33',
vali=[nume_ordre + 1, MacrNumeOrdre],
valr=inst_p_un)
Convergence = True
if (Convergence):
nb_lignes_t1 = len(T_TABL_TMP1["COTES"])
# Ajout de deux colonnes supplementaires
# POUR LA TABLE ECREVISSE
T_TABL_TMP1["NUME_ORDRE"] = [nume_ordre + 1] * nb_lignes_t1
T_TABL_TMP1["INST"] = [inst_p_un] * nb_lignes_t1
# POUR LA TABLE DES DEBITS
nb_ligne_t2 = len(T_DEB_TMP1["DEBTOT"])
T_DEB_TMP1["NUME_ORDRE"] = [nume_ordre + 1] * nb_ligne_t2
T_DEB_TMP1["INST"] = [inst_p_un] * nb_ligne_t2
# Ajout des infos dans la table finale
if (IsInit):
T_TABL_RES = T_TABL_TMP1
T_DEB_RES = T_DEB_TMP1
else:
T_TABL_RES = merge(T_TABL_RES, T_TABL_TMP1)
T_DEB_RES = merge(T_DEB_RES, T_DEB_TMP1)
T_TABL_RES.titr = 'TABLE_SDASTER CHARGEMENT ECREVISSE'
T_DEB_RES.titr = 'TABLE_SDASTER DEBIT ECREVISSE'
#
# RAZ des compteurs de division
NbIter = 0
# On memorise les concepts valides
MECAECR0 = MECAECR1
FLU1ECR0 = FLU1ECR1
FLU2ECR0 = FLU2ECR1
TABLECR0 = TABLECR1
DEBIECR0 = DEBIECR1
#
T_TABL_TMP0 = T_TABL_TMP1
if (not IsInitEcre):
IsInit = False
if (info2):
UTMESS('I', 'ECREVISSE0_37', valr=[inst_p_un])
break
else:
NbIter += 1
# A t'on le droit de decouper, par rapport au nombre de
# division
if (NbIter > MacrNbDecoupage):
FinBoucle = True
UTMESS('A',
'ECREVISSE0_30',
valr=[inst, inst_p_un],
vali=[MacrNbDecoupage])
break
#
# on divise le pas de temps par 2
tmp = (inst + inst_p_un) * 0.5
# A t'on le droit de continuer, par rapport au pas de temps
# minimum
if ((tmp - inst) <= MacrPasMini):
FinBoucle = True
UTMESS('A',
'ECREVISSE0_31',
valr=[inst, inst_p_un, tmp, MacrPasMini])
break
#
if (info2):
UTMESS('A',
'ECREVISSE0_32',
valr=[inst, inst_p_un, tmp],
vali=[NbIter])
# on insere le nouveau temps dans la liste des instants avant
# "inst_p_un"
liste_inst.insert(nume_ordre + 1, tmp)
# Convergence atteinte, on passe au pas de temps suivant, s'il en reste
if IsInitEcre:
continue
elif (nume_ordre + 2 < len(liste_inst)):
nume_ordre += 1
else:
# On a fait tous les pas de temps
FinBoucle = True
#
# Fin boucle sur les pas de temps
#
# Creation du concept de la table en sortie
if (T_TABL_RES != None):
dprod = T_TABL_RES.dict_CREA_TABLE()
TABL_RES = CREA_TABLE(**dprod)
if (T_DEB_RES != None):
debprod = T_DEB_RES.dict_CREA_TABLE()
DEB_RES = CREA_TABLE(**debprod)
# Destruction des concepts temporaires
DETRUIRE(
CONCEPT=(
_F(NOM=MECAECR1),
_F(NOM=FLU1ECR1),
_F(NOM=FLU2ECR1),
_F(NOM=TABLECR1),
_F(NOM=DEBIECR1),
),
INFO=1,
)
if (nume_ordre != 0):
DETRUIRE(
CONCEPT=(
_F(NOM=MECAECR0),
_F(NOM=FLU1ECR0),
_F(NOM=FLU2ECR0),
_F(NOM=TABLECR0),
_F(NOM=DEBIECR0),
),
INFO=1,
)
RetablirAlarme('COMPOR4_70')
return ier
def calc_europlexus_ops(self, EXCIT, COMPORTEMENT, ARCHIVAGE, CALCUL,
CARA_ELEM=None, MODELE=None,
CHAM_MATER=None, FONC_PARASOL=None,
OBSERVATION=None, COURBE=None,
DOMAINES=None, INTERFACES=None,
ETAT_INIT=None, AMORTISSEMENT=None,
INFO=1, **args):
"""
Macro-commande CALC_EUROPLEXUS.
"""
#
# PREPARATION
#
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
global DEFI_FICHIER
DEFI_FICHIER = self.get_cmd('DEFI_FICHIER')
# Pour la gestion des Exceptions
prev_onFatalError = aster.onFatalError()
aster.onFatalError('EXCEPTION')
# Pour masquer certaines alarmes
from Utilitai.Utmess import MasquerAlarme, RetablirAlarme
MasquerAlarme('MED_1')
MasquerAlarme('ALGELINE4_43')
MasquerAlarme('JEVEUX_57')
# Ligne de commande d'Europlexus
EXEC = args['LOGICIEL']
# Version d'Europlexus
VERS = args['VERSION_EUROPLEXUS']
# Chemin du repertoire REPE_OUT de l'execution courante d'Aster
REPE_OUT = os.path.join(os.getcwd(), 'REPE_OUT')
# Chemin du repertoire temporaire pour l'execution d'EPX
# (un lien vers REPE_OUT)
REPE_epx = tempfile.mkdtemp(suffix='_epx')
os.rmdir(REPE_epx)
os.symlink(REPE_OUT, REPE_epx)
# Le concept sortant (de type evol_noli) est nomme 'resu'.
# Le nom de ce concept sera celui defini par l'utilisateur.
self.DeclareOut('resu', self.sd)
global resu
# On récupère ce nom pour le nommage des fichiers dans REPE_OUT.
nom_resu = self.sd.get_name()
#Commandes pour le cas parallele
rank, np = aster_core.MPI_CommRankSize()
# Creation d'un repertoire commun pour les echanges de donnees entre procs
user=getpass.getuser()
name_tmp = uuid.uuid4()
run = AsRunFactory()
os.mkdir('%s/EPX_%s'%(run['shared_tmp'],name_tmp))
rep_tmp='%s/EPX_%s'%(run['shared_tmp'],name_tmp)
#
# TRADUCTION DES INFORMATIONS
#
EPX = EUROPLEXUS(ETAT_INIT, MODELE, CARA_ELEM, CHAM_MATER, COMPORTEMENT,
FONC_PARASOL, EXCIT, OBSERVATION, ARCHIVAGE, COURBE,
CALCUL, AMORTISSEMENT, DOMAINES, INTERFACES, REPE='REPE_OUT',
EXEC=EXEC, VERS=VERS, INFO=INFO, REPE_epx=REPE_epx, NOM_RESU=nom_resu,
REPE_tmp=rep_tmp, NP=np, RANK=rank,
args=args)
#
# ERITURE DU FICHIER DE COMMANDE EUROPLEXUS
#
EPX.ecrire_fichier()
#
# LANCEMENT DU CALCUL
#
#Commandes pour le cas parallele
#rank, np = aster_core.MPI_CommRankSize()
if args['LANCEMENT'] == 'OUI':
if np > 1 :
# Commandes pour que le processeur 0 voit les autres processeurs
cwd = osp.join(os.getcwd(), 'REPE_OUT')
host = socket.gethostname()
path = "{}:{}".format(host, cwd)
alldirs = aster_core.MPI_GatherStr(path, 0)
if rank==0 :
# Execution d Europlexus
EPX.lancer_calcul()
# Envoie des donnees sur les autres processeurs
name_epx='%s/commandes_%s.epx'%(cwd,nom_resu)
name_msh='%s/commandes_%s.msh'%(cwd,nom_resu)
name_sau='%s/resu_%s.sau'%(cwd,nom_resu)
name_med='%s/champ_%s.med'%(cwd,nom_resu)
if COURBE is not None:
name_pun='%s/courbes_%s.pun'%(cwd,nom_resu)
for i in alldirs[1:] :
send_file(name_epx, i)
send_file(name_msh, i)
send_file(name_sau, i)
send_file(name_med, i)
if COURBE is not None:
send_file(name_pun, i)
else :
print "PROCESSOR 0 IS RUNNING EUROPLEXUS!"
aster_core.MPI_Barrier()
else :
EPX.lancer_calcul()
#
# COPIE DES RESULTATS EPX DANS LE CONCEPT ASTER
#
EPX.get_resu()
#
# RECUPERER LES CONCEPTS TABLE
#
if COURBE is not None:
global table
self.DeclareOut('table', args['TABLE_COURBE'])
EPX.get_table()
#
# MENAGE
#
# Pour la gestion des Exceptions
aster.onFatalError(prev_onFatalError)
# Pour la gestion des alarmes
RetablirAlarme('MED_1')
RetablirAlarme('ALGELINE4_43')
RetablirAlarme('JEVEUX_57')
# Suppression du lien symbolique
os.remove(REPE_epx)
# Suppression du repertoire temporaire
shutil.rmtree(rep_tmp)
return ier
def raff_gp_ops(self, **args):
"""Corps de RAFF_GP"""
from numpy import *
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
MasquerAlarme('CALCCHAMP_1')
# MasquerAlarme('HOMARD0_9')
#
# PREPARATION DES SORTIES
#
self.DeclareOut('MAOUT', self.sd)
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
#
# IMPORTATION DES COMMANDES ET MACRO UTILISEES
#
CO = self.get_cmd('CO')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
FORMULE = self.get_cmd('FORMULE')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
MACR_ADAP_MAIL = self.get_cmd('MACR_ADAP_MAIL')
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
DETRUIRE = self.get_cmd('DETRUIRE')
COPIER = self .get_cmd('COPIER')
#
#
# RECUPERATION DU MAILLAGE ET DES DONNEES UTILISATEUR
#
__MA0 = self['MAILLAGE_N']
nb_calc = self['NB_RAFF']
# Manipulation obligatoire pour pouvoir se servir des grandeurs dans les
# formules
TRANCHE_2D = self['TRANCHE_2D']
nbcop = TRANCHE_2D['NB_ZONE']
theta = TRANCHE_2D['ANGLE']
taille = TRANCHE_2D['TAILLE']
self.update_const_context({'origine': TRANCHE_2D['CENTRE']})
self.update_const_context({'rayon': TRANCHE_2D['RAYON']})
self.update_const_context({'taille': TRANCHE_2D['TAILLE']})
self.update_const_context({'theta': TRANCHE_2D['ANGLE']})
self.update_const_context({'nbcop': TRANCHE_2D['NB_ZONE']})
#
# INITIALISATIONS
#
__MA = [None] * (nb_calc + 1)
__MA[0] = __MA0
self.update_const_context({'SEUIL': SEUIL})
self.update_const_context({'ccos': cos(theta * pi / 180.)})
self.update_const_context({'ssin': sin(theta * pi / 180.)})
#
# C EST PARTI
#
for num_calc in range(0, nb_calc):
if num_calc % 3 == 0:
__seuil = FORMULE(
VALE='''SEUIL(X,Y,origine[0]-3.*rayon*ccos,origine[1]-3*rayon*ssin,3*rayon,taille,nbcop+4,ccos,ssin)''',
NOM_PARA=('X', 'Y'),)
elif num_calc % 3 == 1:
__seuil = FORMULE(
VALE='''SEUIL(X,Y,origine[0]-2.*rayon*ccos,origine[1]-2.*rayon*ssin,2.*rayon,taille,nbcop+2,ccos,ssin)''',
NOM_PARA=('X', 'Y'),)
elif num_calc % 3 == 2:
__seuil = FORMULE(
VALE='''SEUIL(X,Y,origine[0]-1.2*rayon*ccos,origine[1]-1.2*rayon*ssin,1.2*rayon,taille,nbcop,ccos,ssin)''',
NOM_PARA=('X', 'Y'),)
__MO = AFFE_MODELE(MAILLAGE=__MA[num_calc],
AFFE=_F(TOUT='OUI',
PHENOMENE='MECANIQUE',
MODELISATION='D_PLAN'),
)
# champ de geometrie et de points de gauss (coordonnees des points de gauss)
__CHXN = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_GEOM_R',
NOM_CHAM='GEOMETRIE',
MAILLAGE=__MA[num_calc])
__CHXG = CREA_CHAMP(OPERATION='DISC',
TYPE_CHAM='ELGA_GEOM_R',
MODELE=__MO,
CHAM_GD=__CHXN)
__f_seuil = CREA_CHAMP(TYPE_CHAM='ELGA_NEUT_F',
MODELE=__MO,
OPERATION='AFFE',
PROL_ZERO='OUI',
AFFE=_F(TOUT='OUI',
NOM_CMP='X1',
VALE_F=__seuil,),)
__COPEAUX = CREA_CHAMP(TYPE_CHAM='ELGA_NEUT_R',
OPERATION='EVAL',
CHAM_F=__f_seuil,
CHAM_PARA=(__CHXG),)
__MA[num_calc + 1] = CO('__MA_%d' % (num_calc + 1))
MACR_ADAP_MAIL(ADAPTATION='RAFFINEMENT',
CHAM_GD=__COPEAUX,
CRIT_RAFF_ABS=0.01,
MAILLAGE_N=__MA[num_calc],
MAILLAGE_NP1=__MA[num_calc + 1])
DETRUIRE(CONCEPT=(_F(NOM=__COPEAUX,),
_F(NOM=__MO,),
_F(NOM=__CHXN),
_F(NOM=__CHXG),
_F(NOM=__f_seuil),
_F(NOM=__seuil),
),
)
MAOUT = COPIER(CONCEPT=__MA[nb_calc])
RetablirAlarme('CALCCHAMP_1')
return ier
def macr_cara_poutre_ops(self, MAILLAGE, SYME_Y, SYME_Z, GROUP_MA_BORD,
GROUP_MA, ORIG_INER, TABLE_CARA, **args):
"""
Ecriture de la macro MACR_CARA_POUTRE
"""
import types
import string
from code_aster.Cata.Syntax import _F
import aster
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
#
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')
COPIER = self.get_cmd('COPIER')
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_CHAMP = self.get_cmd('CALC_CHAMP')
MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
CREA_TABLE = self.get_cmd('CREA_TABLE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
DETRUIRE = self.get_cmd('DETRUIRE')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant (de type table_sdaster) est nommé 'nomres' dans le
# contexte de la macro
self.DeclareOut('nomres', self.sd)
#
ImprTable = False
#
if (MAILLAGE != None):
__nomlma = COPIER(CONCEPT=MAILLAGE)
elif (args.has_key('UNITE') and args.has_key('FORMAT')):
__nomlma = LIRE_MAILLAGE(UNITE=args['UNITE'], FORMAT=args['FORMAT'])
else:
assert False, "Erreur dans les options UNITE, FORMAT, MAILLAGE"
#
# Dans les tables on retrouve une ligne avec __nomlma.nom. Soit :
# - on remplace __nomlma.nom par NomMaillageNew.
# - on supprime la ligne
NomMaillage = (None, __nomlma.get_name())
if (args.has_key('NOM')):
NomMaillage = (args['NOM'], __nomlma.get_name())
#
#
__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,
),
)
#
# L'utilisateur ne peut rien faire pour éviter ces "Alarmes" donc pas d'impression
MasquerAlarme('CHARGES2_87')
MasquerAlarme('CALCULEL_40')
# --------------------------------------------------------------
# --- CALCUL DES CARACTERISTIQUES GEOMETRIQUES DE LA SECTION
# --------------------------------------------------------------
motsimps = {}
if GROUP_MA:
motsimps['GROUP_MA'] = GROUP_MA
if SYME_Y:
motsimps['SYME_X'] = SYME_Y
if SYME_Z:
motsimps['SYME_Y'] = SYME_Z
motsimps['ORIG_INER'] = ORIG_INER
mfact = _F(TOUT='OUI', **motsimps)
__cageo = 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=__cageo,
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 :
mctimpo = {}
if args['NOEUD'] != None:
nthno = args['NOEUD']
if len(nthno) != 1:
UTMESS('F', 'POUTRE0_3')
mctimpo['TEMP_IMPO'] = (_F(NOEUD=nthno[0], TEMP=__fnsec0))
elif args['GROUP_NO'] != None:
grthno = args['GROUP_NO']
if len(grthno) != 1:
UTMESS('F', 'POUTRE0_3')
grthno = grthno[0]
collgrno = aster.getcolljev('%-8s.GROUPENO' % __nomapi.nom)
nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomapi.nom)
l_no = collgrno[string.ljust(grthno, 24)]
if len(l_no) != 1:
UTMESS('F', 'POUTRE0_3')
nthno = nomnoe[l_no[0] - 1]
mctimpo['TEMP_IMPO'] = (_F(NOEUD=nthno, TEMP=__fnsec0))
#
__chart2 = AFFE_CHAR_THER_F(MODELE=__nomoth,
SOURCE=_F(
TOUT='OUI',
SOUR=__fnsec1,
),
**mctimpo)
#------------------------------------------------------------
# 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,
SOURCE=_F(
TOUT='OUI',
SOUR=__fnsec2,
),
**mctimpo)
#------------------------------------------------------------
# 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_CHAMP(
reuse=__tempe1,
RESULTAT=__tempe1,
TOUT_ORDRE='OUI',
THERMIQUE='FLUX_ELNO',
)
__flun = MACR_LIGN_COUPE(RESULTAT=__tempe1,
NOM_CHAM='FLUX_ELNO',
LIGN_COUPE=_F(
TYPE='GROUP_MA',
MAILLAGE=__nomapi,
TRAC_NOR='OUI',
NOM_CMP=('FLUX', 'FLUY'),
OPERATION='MOYENNE',
INTITULE='FLUX_NORM',
GROUP_MA=GROUP_MA_BORD,
))
__nomapi = DEFI_GROUP(reuse=__nomapi,
MAILLAGE=__nomapi,
DETR_GROUP_NO=_F(NOM=GROUP_MA_BORD, ))
__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)):
__flun = MACR_LIGN_COUPE(RESULTAT=__tempe1,
NOM_CHAM='FLUX_ELNO',
LIGN_COUPE=_F(
TYPE='GROUP_MA',
MAILLAGE=__nomapi,
TRAC_NOR='OUI',
NOM_CMP=('FLUX', 'FLUY'),
OPERATION='MOYENNE',
INTITULE='FLUX_NORM',
GROUP_MA=l_group_ma_inte[i],
))
__nomapi = DEFI_GROUP(reuse=__nomapi,
MAILLAGE=__nomapi,
DETR_GROUP_NO=_F(
NOM=l_group_ma_inte[i], ))
__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=__cageo,
LAPL_PHI=__tempe1,
RT=__rt,
TOUT='OUI',
OPTION='CARA_TORSION',
GROUP_MA_INTE=args['GROUP_MA_INTE'],
)
else:
motscles['CARA_POUTRE'] = _F(
CARA_GEOM=__cageo,
LAPL_PHI=__tempe1,
RT=__rt,
TOUT='OUI',
OPTION='CARA_TORSION',
)
#
__cator = POST_ELEM(MODELE=__nomoth, CHAM_MATER=__chmath, **motscles)
#------------------------------------------------------------
# CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU
# CENTRE DE CISAILLEMENT/TORSION :
__cacis = POST_ELEM(
MODELE=__nomoth,
CHAM_MATER=__chmath,
CARA_POUTRE=_F(
CARA_GEOM=__cator,
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=__cacis,
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, )
# 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(
STOP_SINGULIER='NON',
METHODE='LDLT',
),
)
# CALCUL DE L INERTIE DE GAUCHISSEMENT :
nomres = POST_ELEM(
MODELE=__nomot2,
CHAM_MATER=__chmat2,
CARA_POUTRE=_F(CARA_GEOM=__cacis,
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:
# CALCUL DES CARACTERISTIQUES GEOMETRIQUES DE LA SECTION :
l_group_ma_bord = GROUP_MA_BORD
l_group_ma = GROUP_MA
l_noeud = None
if args['NOEUD'] != None:
l_noeud = args['NOEUD']
elif args['GROUP_NO'] != None:
collgrno = aster.getcolljev('%-8s.GROUPENO' % __nomlma.nom)
nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomlma.nom)
l_nu_no = []
for grno in args['GROUP_NO']:
l_nu_no.extend(collgrno[string.ljust(grno, 24)])
l_noeud = [nomnoe[no_i - 1] for no_i in l_nu_no]
if len(l_group_ma) != len(l_group_ma_bord):
UTMESS('F', 'POUTRE0_1')
if l_noeud != None and (len(l_group_ma) != len(l_noeud)):
UTMESS('F', 'POUTRE0_2')
__catp2 = __cageo
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,
DETR_GROUP_NO=_F(NOM=l_group_ma_bord[i], ),
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=__cageo,
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.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_CHAMP(
reuse=__tempe1,
RESULTAT=__tempe1,
TOUT_ORDRE='OUI',
THERMIQUE='FLUX_ELNO',
)
__flun = MACR_LIGN_COUPE(RESULTAT=__tempe1,
NOM_CHAM='FLUX_ELNO',
LIGN_COUPE=_F(
TYPE='GROUP_MA',
MAILLAGE=__nomapi,
TRAC_NOR='OUI',
NOM_CMP=('FLUX', 'FLUY'),
OPERATION='MOYENNE',
INTITULE='FLUX_NORM',
GROUP_MA=l_group_ma_bord[i],
))
__nomapi = DEFI_GROUP(reuse=__nomapi,
MAILLAGE=__nomapi,
DETR_GROUP_NO=_F(NOM=l_group_ma_bord[i], ))
__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)):
__flun = MACR_LIGN_COUPE(
RESULTAT=__tempe1,
NOM_CHAM='FLUX_ELNO',
LIGN_COUPE=_F(
TYPE='GROUP_MA',
MAILLAGE=__nomapi,
TRAC_NOR='OUI',
NOM_CMP=('FLUX', 'FLUY'),
OPERATION='MOYENNE',
INTITULE='FLUX_NORM',
GROUP_MA=l_group_ma_inte[i],
))
__nomapi = DEFI_GROUP(reuse=__nomapi,
MAILLAGE=__nomapi,
DETR_GROUP_NO=_F(
NOM=l_group_ma_inte[i], ))
__m1 = (abs(__flun['TRAC_NOR', 3]) +
abs(__flun['TRAC_NOR', 4])) / 2.0
if __m1 > __rtext: __rtext = __m1
__rt = __rtext
# CALCUL DE LA CONSTANTE DE TORSION :
__catp1 = POST_ELEM(
MODELE=__nomoth,
CHAM_MATER=__chmath,
CARA_POUTRE=_F(CARA_GEOM=__catp2,
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 :
__catp2 = POST_ELEM(
MODELE=__nomoth,
CHAM_MATER=__chmath,
CARA_POUTRE=_F(
CARA_GEOM=__catp1,
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',
),
)
#
#
dprod = __catp2.EXTR_TABLE().dict_CREA_TABLE()
# On remplace dans le TITRE le nom du concept __catp2.nom par
# self.sd.nom
if ('TITRE' in dprod.keys()):
conceptOld = __catp2.nom
conceptNew = self.sd.nom
for ii in range(len(dprod['TITRE'])):
zz = dprod['TITRE'][ii]
if (conceptOld.strip() in zz):
dprod['TITRE'][ii] = zz.replace(conceptOld.strip(),
conceptNew.strip())
#
nomres = CREA_TABLE(**dprod)
#
if not GROUP_MA_BORD:
nomres = POST_ELEM(MODELE=__nomamo,
CHAM_MATER=__nomama,
CARA_GEOM=mfact)
#
# On retourne une table exploitable par AFFE_CARA_ELEM, avec seulement les
# caractéristiques nécessaires
if (TABLE_CARA == "OUI"):
# si GROUP_MA : le concept NomMaillageOld ne fait plus partie de la table
# si pas GROUP_MA :
# si NOM : le nom du concept NomMaillageOld est remplacé par NomMaillageNew
# si pas NOM : le nom du concept NomMaillageOld est gardé
# On enlève la ligne avec LIEU='-'
nomres = CALC_TABLE(
reuse=nomres,
TABLE=nomres,
ACTION=_F(OPERATION='FILTRE',
NOM_PARA='LIEU',
CRIT_COMP='NON_VIDE'),
)
#
NomMaillageNew, NomMaillageOld = NomMaillage
if (GROUP_MA):
# Une ligne avec LIEU=NomMaillageOld ==> on la supprime
nomres = CALC_TABLE(
reuse=nomres,
TABLE=nomres,
ACTION=_F(OPERATION='FILTRE',
NOM_PARA='LIEU',
CRIT_COMP='NE',
VALE_K=NomMaillageOld),
)
TabTmp = nomres.EXTR_TABLE().dict_CREA_TABLE()
else:
# si NomMaillageNew est donné on remplace LIEU=NomMaillageOld par LIEU=NomMaillageNew
if (NomMaillageNew != None):
TabTmp = nomres.EXTR_TABLE()
for ii in range(len(TabTmp.rows)):
zz = TabTmp.rows[ii]['LIEU']
if (zz.strip() == NomMaillageOld):
TabTmp.rows[ii]['LIEU'] = NomMaillageNew
#
TabTmp = TabTmp.dict_CREA_TABLE()
else:
TabTmp = nomres.EXTR_TABLE().dict_CREA_TABLE()
#
__catp2 = CREA_TABLE(**TabTmp)
DETRUIRE(CONCEPT=_F(NOM=nomres), INFO=1)
#
if GROUP_MA_BORD and not GROUP_MA:
nomres = CALC_TABLE(
TABLE=__catp2,
ACTION=(_F(
OPERATION='EXTR',
NOM_PARA=('LIEU', 'A', 'IY', 'IZ', 'AY', 'AZ', 'EY', 'EZ',
'JX', 'JG', 'IYR2', 'IZR2', 'RY', 'RZ', 'RT',
'ALPHA', 'CDG_Y', 'CDG_Z'),
), ),
)
elif GROUP_MA_BORD and GROUP_MA:
nomres = CALC_TABLE(
TABLE=__catp2,
ACTION=(_F(
OPERATION='EXTR',
NOM_PARA=('LIEU', 'A', 'IY', 'IZ', 'AY', 'AZ', 'EY', 'EZ',
'JX', 'IYR2', 'IZR2', 'RY', 'RZ', 'RT', 'ALPHA',
'CDG_Y', 'CDG_Z'),
), ),
)
else:
nomres = CALC_TABLE(
TABLE=__catp2,
ACTION=(_F(
OPERATION='EXTR',
NOM_PARA=('LIEU', 'A', 'IY', 'IZ', 'IYR2', 'IZR2', 'RY',
'RZ', 'ALPHA', 'CDG_Y', 'CDG_Z'),
), ),
)
#
# Validation des résultats qui doivent toujours être >=0
TabTmp = nomres.EXTR_TABLE()
for ii in range(len(TabTmp.rows)):
ligne = TabTmp.rows[ii]
# on recherche la bonne ligne
if (ligne['LIEU'].strip() == NomMaillageNew):
paras = TabTmp.para
# Vérification des grandeurs qui doivent toujours rester positive
Lparas = (
'A',
'IY',
'IZ',
'AY',
'AZ',
'JX',
'JG',
)
iergd = 0
for unpara in Lparas:
if (unpara in paras):
if (ligne[unpara] <= 0): iergd += 1
if (iergd != 0):
if (not ImprTable): IMPR_TABLE(TABLE=nomres)
ImprTable = True
for unpara in Lparas:
if (unpara in paras):
if (ligne[unpara] <= 0):
UTMESS('E',
'POUTRE0_10',
valk=unpara,
valr=ligne[unpara])
UTMESS('F', 'POUTRE0_11')
#
# Vérification que le CDG est l'origine du maillage
cdgy = ligne['CDG_Y']
cdgz = ligne['CDG_Z']
dcdg = (cdgy * cdgy + cdgz * cdgz) / ligne['A']
if (dcdg > 1.0E-08):
if (not ImprTable): IMPR_TABLE(TABLE=nomres)
ImprTable = True
UTMESS('A', 'POUTRE0_12', valr=[cdgy, cdgz])
# Vérification que la section n'est pas tournée
alpha = ligne['ALPHA']
if (abs(alpha) > 0.001):
if (not ImprTable): IMPR_TABLE(TABLE=nomres)
ImprTable = True
UTMESS('A', 'POUTRE0_13', valr=[alpha, -alpha])
#
# On retourne une table contenant toutes les caractéristiques calculées
else:
if GROUP_MA_BORD and not GROUP_MA:
nomres = CALC_TABLE(
reuse=nomres,
TABLE=nomres,
ACTION=(_F(
OPERATION='EXTR',
NOM_PARA=(
'LIEU',
'ENTITE',
'A_M',
'CDG_Y_M',
'CDG_Z_M',
'IY_G_M',
'IZ_G_M',
'IYZ_G_M',
'Y_MAX',
'Z_MAX',
'Y_MIN',
'Z_MIN',
'R_MAX',
'A',
'CDG_Y',
'CDG_Z',
'IY_G',
'IZ_G',
'IYZ_G',
'IY',
'IZ',
'ALPHA',
'Y_P',
'Z_P',
'IY_P',
'IZ_P',
'IYZ_P',
'JX',
'AY',
'AZ',
'EY',
'EZ',
'PCTY',
'PCTZ',
'JG',
'KY',
'KZ',
'IYR2_G',
'IZR2_G',
'IYR2',
'IZR2',
'IYR2_P',
'IZR2_P',
'RY',
'RZ',
'RT',
),
), ),
)
elif GROUP_MA_BORD and GROUP_MA:
nomres = CALC_TABLE(
reuse=nomres,
TABLE=nomres,
ACTION=(_F(
OPERATION='EXTR',
NOM_PARA=(
'LIEU',
'ENTITE',
'A_M',
'CDG_Y_M',
'CDG_Z_M',
'IY_G_M',
'IZ_G_M',
'IYZ_G_M',
'Y_MAX',
'Z_MAX',
'Y_MIN',
'Z_MIN',
'R_MAX',
'A',
'CDG_Y',
'CDG_Z',
'IY_G',
'IZ_G',
'IYZ_G',
'IY',
'IZ',
'ALPHA',
'Y_P',
'Z_P',
'IY_P',
'IZ_P',
'IYZ_P',
'JX',
'AY',
'AZ',
'EY',
'EZ',
'PCTY',
'PCTZ',
'KY',
'KZ',
'IYR2_G',
'IZR2_G',
'IYR2',
'IZR2',
'IYR2_P',
'IZR2_P',
'RY',
'RZ',
'RT',
),
), ),
)
else:
nomres = CALC_TABLE(
reuse=nomres,
TABLE=nomres,
ACTION=(_F(
OPERATION='EXTR',
NOM_PARA=(
'LIEU',
'ENTITE',
'A_M',
'CDG_Y_M',
'CDG_Z_M',
'IY_G_M',
'IZ_G_M',
'IYZ_G_M',
'Y_MAX',
'Z_MAX',
'Y_MIN',
'Z_MIN',
'R_MAX',
'A',
'CDG_Y',
'CDG_Z',
'IY_G',
'IZ_G',
'IYZ_G',
'IY',
'IZ',
'ALPHA',
'Y_P',
'Z_P',
'IY_P',
'IZ_P',
'IYZ_P',
'IYR2_G',
'IZR2_G',
'IYR2',
'IZR2',
'IYR2_P',
'IZR2_P',
'RY',
'RZ',
),
), ),
)
#
if (not ImprTable): IMPR_TABLE(TABLE=nomres)
#
RetablirAlarme('CHARGES2_87')
RetablirAlarme('CALCULEL_40')
return ier
def var_int_a2e(compor_gr, resu, mod, nume_ordre):
"""
Transforme le champ VARI_ELGA pour correspondre aux attentes d'EPX
Renvoie un résultat contenant les champs DEPL, SIEF_ELGA et VARI_ELGA
transformé du NUME_ORDRE nume_ordre du résultat resu.
"""
from code_aster.Cata.Commands import CREA_RESU
# extraction des champs :
__DEPL = CREA_CHAMP(
OPERATION='EXTR',
TYPE_CHAM='NOEU_DEPL_R',
RESULTAT=resu,
NOM_CHAM='DEPL',
INST=nume_ordre,
)
__SIEF = CREA_CHAMP(
OPERATION='EXTR',
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=resu,
NOM_CHAM='SIEF_ELGA',
INST=nume_ordre,
)
__VARI = CREA_CHAMP(
OPERATION='EXTR',
TYPE_CHAM='ELGA_VARI_R',
RESULTAT=resu,
NOM_CHAM='VARI_ELGA',
INST=nume_ordre,
)
# transformation
nb_compor = len(compor_gr)
__VARICO = [None] * nb_compor
asse = []
for ico, compor in enumerate(compor_gr.keys()):
gr_ma = compor_gr[compor]
nb_var_epx = cata_compor[compor]['NB_VAR_EPX']
nom_cmp = ['V%i' % ii for ii in range(1, nb_var_epx + 1)]
if compor == 'VMIS_JOHN_COOK':
tr_a2e_vmis_john_cook(__VARICO, ico, gr_ma, mod, __VARI,
nume_ordre, resu)
else:
vale = [0.] * nb_var_epx
__VARICO[ico] = CREA_CHAMP(OPERATION='AFFE',
TYPE_CHAM='ELGA_VARI_R',
MODELE=MODELE,
PROL_ZERO='NON',
AFFE=(_F(GROUP_MA='CUBE',
NOM_CMP=nom_cmp,
VALE=vale), ))
UTMESS('A', 'PLEXUS_47', valk=compor)
asse.append({
'GROUP_MA': gr_ma,
'CHAM_GD': __VARICO[ico],
'NOM_CMP': nom_cmp,
'CUMUL': 'NON',
'COEF_R': 1.
})
if len(asse) == 0:
UTMESS('A', 'PLEXUS_48')
__VARITR = CREA_CHAMP(
OPERATION='ASSE',
MODELE=mod,
TYPE_CHAM='ELGA_VARI_R',
PROL_ZERO='OUI',
ASSE=asse,
)
# construction du concept resultat
MasquerAlarme('COMPOR2_23')
__res = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='DEPL',
AFFE=(_F(
CHAM_GD=__DEPL,
MODELE=mod,
INST=1.0,
), ))
__res = CREA_RESU(
reuse=__res,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='SIEF_ELGA',
AFFE=_F(
CHAM_GD=__SIEF,
MODELE=mod,
INST=1.0,
),
)
__res = CREA_RESU(
reuse=__res,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='VARI_ELGA',
AFFE=_F(
CHAM_GD=__VARITR,
MODELE=mod,
INST=1.0,
),
)
RetablirAlarme('COMPOR2_23')
return __res
def post_endo_fiss_ops(self, TABLE, OUVERTURE, NOM_CMP, NOM_CHAM, RECHERCHE,
**args):
import aster
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from code_aster.Cata.Syntax import _F
# --------------------------------------------------
# DEVELOPER OPTIONS
#
# "strong_flag" must be set to True if computing crack opening with the "strong" method
strong_flag = False
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
MasquerAlarme('CALCULEL5_48')
MasquerAlarme('ALGORITH12_43')
MasquerAlarme('CALCULEL2_12')
MasquerAlarme('CALCULEL5_7')
# --------------------------------------------------
# OUTPUT DECLARATION
#
self.DeclareOut('MAFISS', self.sd)
self.DeclareOut('tabRes', TABLE)
# --------------------------------------------------
# IMPORT OF ASTER COMMANDS
#
LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
CREA_TABLE = self.get_cmd('CREA_TABLE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CO = self.get_cmd('CO')
IMPR_RESU = self.get_cmd('IMPR_RESU')
RECU_TABLE = self.get_cmd('RECU_TABLE')
# --------------------------------------------------
# INPUT PARAMETERS
#
l_dRECHERCHE = []
for recherche in RECHERCHE:
dRECHERCHE = recherche.cree_dict_valeurs(recherche.mc_liste)
for i in dRECHERCHE.keys():
if dRECHERCHE[i] == None:
del dRECHERCHE[i]
l_dRECHERCHE.append(dRECHERCHE)
# --------------------------------------------------
# INPUT PARAMETERS, MESH AND MODEL
#
motscles = {}
for dRECHERCHE in l_dRECHERCHE:
if (OUVERTURE == 'OUI') and ('BORNE_MAX' not in dRECHERCHE.keys()):
UTMESS('F', 'POST0_44')
if args['CHAM_GD'] != None:
build = 'champ'
__ENDO = args['CHAM_GD']
inst = 1.
motscles['INST'] = inst
n_mail = __ENDO.sdj.REFE.get()[0].strip()
__mail = self.get_concept(n_mail)
else:
build = 'resu'
__RESUIN = args['RESULTAT']
nomresu = __RESUIN.nom
dicResu = __RESUIN.LIST_PARA()
dicVarAcc = __RESUIN.LIST_VARI_ACCES()
if args['NUME_ORDRE'] != None:
nume_ordre = args['NUME_ORDRE']
if nume_ordre not in dicVarAcc['NUME_ORDRE']:
UTMESS('F', 'POST0_41')
else:
inst = (dicVarAcc['INST'])[nume_ordre]
motscles['NUME_ORDRE'] = nume_ordre
else:
inst = args['INST']
motscles['INST'] = inst
nume_ordre = None
for champ_inst_index, champ_inst in enumerate(dicVarAcc['INST']):
if round(champ_inst, 12) == round(inst, 12):
nume_ordre = dicVarAcc['NUME_ORDRE'][champ_inst_index]
break
if nume_ordre is None:
UTMESS('F', 'POST0_41')
# Maillage pour projections
iret, ibid, n_mail = aster.dismoi('NOM_MAILLA', __RESUIN.nom,
'RESULTAT', 'F')
__mail = self.get_concept(n_mail)
dime = __mail.sdj.DIME.get()[5]
# --------------------------------------------------
# CONTROLS ON THE INPUT FIELDS
#
if build == 'resu':
ChampsResu = __RESUIN.LIST_CHAMPS()
lstChampsResu = ChampsResu.keys()
if (NOM_CHAM not in lstChampsResu):
UTMESS('F', 'POST0_42')
elif (nume_ordre not in ChampsResu[NOM_CHAM]):
UTMESS('F', 'POST0_41')
else:
pass
if build == 'champ' and OUVERTURE == 'OUI':
UTMESS('F', 'POST0_43')
if ('NOEU' in NOM_CHAM) or (NOM_CHAM == 'DEPL'):
typeChampTrajet = 'NOEU' + '_' + NOM_CHAM[0:4] + '_R'
if NOM_CHAM == 'VARI_NOEU':
typeChampTrajet = 'NOEU_VAR2_R'
else:
UTMESS('F', 'POST0_35')
# --------------------------------------------------
# QUANTITIES FOR THE 2D PROCEDURE
#
__TABG = RECU_TABLE(
CO=__mail,
NOM_TABLE='CARA_GEOM',
)
xmin = __TABG['X_MIN', 1]
xmax = __TABG['X_MAX', 1]
ymin = __TABG['Y_MIN', 1]
ymax = __TABG['Y_MAX', 1]
zmin = __TABG['Z_MIN', 1]
zmax = __TABG['Z_MAX', 1]
nbPrec = NP.finfo(NP.float).precision
delta_x = NP.round(xmax - xmin, nbPrec)
delta_y = NP.round(ymax - ymin, nbPrec)
delta_z = NP.round(zmax - zmin, nbPrec)
Ddim = [delta_x, delta_y, delta_z]
delta_min = min(Ddim)
if NP.round(delta_min, nbPrec - 2) != 0.:
UTMESS('F', 'POST0_34')
else:
idx_plan = Ddim.index(delta_min)
# PLAN == 'XY' :
if idx_plan == 2:
coorIni1 = 0
coorIni2 = 1
dnor = NP.array([0., 0., 1.], float)
dplan1 = NP.array([1., 0., 0.], float)
dplan2 = NP.array([0., 1., 0.], float)
# PLAN == 'XZ':
elif idx_plan == 1:
coorIni1 = 0
coorIni2 = 2
dnor = NP.array([0., 1., 0.], float)
dplan1 = NP.array([1., 0., 0.], float)
dplan2 = NP.array([0., 0., 1.], float)
# PLAN == 'YZ':
else:
coorIni1 = 1
coorIni2 = 2
dnor = NP.array([1., 0., 0.], float)
dplan1 = NP.array([0., 1., 0.], float)
dplan2 = NP.array([0., 0., 1.], float)
infoPlan = (coorIni1, coorIni2, dnor, dplan1, dplan2)
# --------------------------------------------------
# FIELD FOR CRACK PATH SEARCH
#
if build == 'resu':
__ENDO = CREA_CHAMP(TYPE_CHAM=typeChampTrajet,
OPERATION='EXTR',
RESULTAT=__RESUIN,
NOM_CHAM=NOM_CHAM,
**motscles)
# --------------------------------------------------
# LOOP ON THE FPZs (INSTANCES OF KEYWORD "RECHERCHE")
#
XcreteTot = []
YcreteTot = []
ZcreteTot = []
ConnTot = []
EndocreteTot = []
lstFissure = []
lstOuverture = []
lstErreur = []
lstNomFiss = []
for idxRech in range(len(l_dRECHERCHE)):
dRECHERCHE = l_dRECHERCHE[idxRech]
(CoxCrete, CoyCrete, CozCrete, EndoCrete,
Connex) = cherche_trajet(self, NOM_CMP, NOM_CHAM, dRECHERCHE, __ENDO,
__mail, typeChampTrajet, infoPlan, inst)
if OUVERTURE == 'OUI':
if strong_flag == False:
lstOuvFiss = calcul_ouverture(self, NOM_CHAM, NOM_CMP,
dRECHERCHE, __RESUIN, __mail,
infoPlan, inst, CoxCrete,
CoyCrete, CozCrete, dime,
strong_flag)
else:
lstOuvFiss, lstErr = calcul_ouverture(self, NOM_CHAM, NOM_CMP,
dRECHERCHE, __RESUIN,
__mail, infoPlan, inst,
nume_ordre, CoxCrete,
CoyCrete, CozCrete, dime,
strong_flag)
XcreteTot.append(CoxCrete)
YcreteTot.append(CoyCrete)
ZcreteTot.append(CozCrete)
EndocreteTot.append(EndoCrete)
ConnTot.append(Connex)
if 'GROUP_MA' in dRECHERCHE.keys():
nomFissure = dRECHERCHE['GROUP_MA']
else:
nomFissure = 'FISS' + str(idxRech + 1)
lstFissure = lstFissure + ([nomFissure] * len(CoxCrete))
lstNomFiss.append(nomFissure)
if OUVERTURE == 'OUI':
if '-' in lstOuvFiss:
UTMESS('A', 'POST0_33', nomFissure)
lstOuverture.append(lstOuvFiss)
if strong_flag == True:
lstErreur.append(lstErr)
lstX = []
lstY = []
lstZ = []
lstEndo = []
if OUVERTURE == 'OUI':
lstO = []
if strong_flag == True:
lstE = []
for i in range(len(XcreteTot)):
lstX = lstX + XcreteTot[i]
lstY = lstY + YcreteTot[i]
lstZ = lstZ + ZcreteTot[i]
lstEndo = lstEndo + EndocreteTot[i]
if OUVERTURE == 'OUI':
lstO = lstO + lstOuverture[i]
if strong_flag == True:
lstE = lstE + lstErreur[i]
# -----------------------------------------------------
# CREATION OF A TABLE TO STOCK CRACK PATH COORDINATES
# AND CRACK OPENING
#
if OUVERTURE == 'NON':
tabRes = CREA_TABLE(LISTE=(
_F(PARA='FISSURE', LISTE_K=lstFissure),
_F(PARA='COORX', LISTE_R=lstX),
_F(PARA='COORY', LISTE_R=lstY),
_F(PARA='COORZ', LISTE_R=lstZ),
_F(PARA='CHAMP', LISTE_R=lstEndo),
), )
else:
if strong_flag == False:
tabRes = CREA_TABLE(LISTE=(
_F(PARA='FISSURE', LISTE_K=lstFissure),
_F(PARA='COORX', LISTE_R=lstX),
_F(PARA='COORY', LISTE_R=lstY),
_F(PARA='COORZ', LISTE_R=lstZ),
_F(PARA='CHAMP', LISTE_R=lstEndo),
_F(PARA='OUVERTURE', LISTE_R=lstO),
), )
else: # STRONG Method
tabRes = CREA_TABLE(LISTE=(
_F(PARA='FISSURE', LISTE_K=lstFissure),
_F(PARA='COORX', LISTE_R=lstX),
_F(PARA='COORY', LISTE_R=lstY),
_F(PARA='COORZ', LISTE_R=lstZ),
_F(PARA='CHAMP', LISTE_R=lstEndo),
_F(PARA='OUVERTURE', LISTE_R=lstO),
_F(PARA='ERREUR', LISTE_R=lstE),
), )
# --------------------------------------------------
# CREATION OF DATA STRUCTURE "MESH"
#
resu_mail0 = crea_mail_lin(XcreteTot, YcreteTot, ZcreteTot, ConnTot,
lstNomFiss, dime)
nomFichierSortie = os.path.join(os.getcwd(), 'maillage.mail')
fproc = open(nomFichierSortie, 'w')
fproc.write(resu_mail0)
fproc.close()
UL = UniteAster()
uniteMail = UL.Libre(action='ASSOCIER', nom=nomFichierSortie)
MAFISS = LIRE_MAILLAGE(
FORMAT='ASTER',
UNITE=uniteMail,
)
UL.EtatInit(uniteMail)
RetablirAlarme('CALCULEL5_48')
RetablirAlarme('ALGORITH12_43')
RetablirAlarme('CALCULEL2_12')
RetablirAlarme('CALCULEL5_7')
return ier
def simu_point_mat_ops(self, MATER, INCREMENT, SIGM_IMPOSE, EPSI_IMPOSE,
SIGM_INIT, EPSI_INIT, VARI_INIT, NEWTON, CONVERGENCE,
MASSIF, ANGLE, COMPORTEMENT, INFO, ARCHIVAGE, SUPPORT,
**args):
"""Simulation de la reponse d'un point materiel"""
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
import math
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
AFFE_CARA_ELEM = self.get_cmd('AFFE_CARA_ELEM')
AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA')
AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU')
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
CALC_TABLE = self.get_cmd('CALC_TABLE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_RESU = self.get_cmd('CREA_RESU')
DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
MODI_MAILLAGE = self.get_cmd('MODI_MAILLAGE')
MODI_REPERE = self.get_cmd('MODI_REPERE')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
STAT_NON_LINE = self.get_cmd('STAT_NON_LINE')
IMPR_RESU = self.get_cmd('IMPR_RESU')
from Contrib.calc_point_mat import CALC_POINT_MAT
from code_aster.Cata.Syntax import _F
from Utilitai.UniteAster import UniteAster
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from Noyau.N_types import is_sequence
# alarme de STAT_NON_LINE si les mot-cles de COMPORTEMENT sont renseignes
# a tort
MasquerAlarme('COMPOR4_70')
# -- Tests de cohérence
__fonczero = DEFI_FONCTION(NOM_PARA='INST',
VALE=(0, 0, 10, 0),
PROL_DROITE='CONSTANT',
PROL_GAUCHE='CONSTANT')
EPS = {}
SIG = {}
itetra = 0
CMP_EPS = ['EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ']
CMP_SIG = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ']
if COMPORTEMENT:
lcomp = COMPORTEMENT.List_F()[0]
if SUPPORT != None:
if SUPPORT == 'ELEMENT':
itetra = 1
if itetra == 0:
if lcomp['DEFORMATION'] != 'PETIT':
if args.has_key('GRAD_IMPOSE'):
if args['GRAD_IMPOSE'] != None:
if lcomp['DEFORMATION'] != 'SIMO_MIEHE':
UTMESS('F', 'COMPOR2_22', valk=lcomp['DEFORMATION'])
itetra = 0
else:
itetra = 1
UTMESS('A', 'COMPOR2_1', valk=lcomp['DEFORMATION'])
#===============================================================
# cas ou il n'y a pas d'élement fini : appel à CALC_POINT_MAT
#===============================================================
if itetra == 0:
isig = 0
ieps = 0
igrd = 0
ic1c2 = 0
if SIGM_IMPOSE:
SIG = SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste)
isig = 1
if EPSI_IMPOSE:
EPS = EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste)
ieps = 1
if args.has_key('GRAD_IMPOSE'):
if args['GRAD_IMPOSE'] != None:
FIJ = args['GRAD_IMPOSE'][0].cree_dict_valeurs(
args['GRAD_IMPOSE'][0].mc_liste)
igrd = 1
if args.has_key('MATR_C1'):
if args['MATR_C1'] != None:
ic1c2 = 1
if args.has_key('MATR_C2'):
if args['MATR_C2'] != None:
ic1c2 = 1
motscles = {}
if igrd:
for i in FIJ.keys():
motscles[i] = FIJ[i]
elif ic1c2:
if args.has_key('MATR_C1'):
if args['MATR_C1'] != None:
motscles['MATR_C1'] = args['MATR_C1'].List_F()
if args.has_key('MATR_C2'):
if args['MATR_C2'] != None:
motscles['MATR_C2'] = args['MATR_C2'].List_F()
if args.has_key('VECT_IMPO'):
if args['VECT_IMPO'] != None:
motscles['VECT_IMPO'] = args['VECT_IMPO'].List_F()
else:
nbsig = 6
for index in range(nbsig):
iks = CMP_SIG[index]
ike = CMP_EPS[index]
inds = 0
inde = 0
if ieps:
if EPS[ike] != None:
inde = 1
if isig:
if SIG[iks] != None:
inds = 1
if inde * inds != 0:
UTMESS('F', 'COMPOR2_2', valk=iks)
if inde == 1:
motscles[ike] = EPS[ike]
elif inds == 1:
motscles[iks] = SIG[iks]
else:
motscles[iks] = __fonczero
# Etat initial
etatinit = 0
if SIGM_INIT != None:
motscles['SIGM_INIT'] = SIGM_INIT.List_F()
if EPSI_INIT != None:
motscles['EPSI_INIT'] = EPSI_INIT.List_F()
if VARI_INIT != None:
motscles['VARI_INIT'] = VARI_INIT.List_F()
if NEWTON != None:
motscles['NEWTON'] = NEWTON.List_F()
if CONVERGENCE != None:
motscles['CONVERGENCE'] = CONVERGENCE.List_F()
if MASSIF != None:
motscles['MASSIF'] = MASSIF.List_F()
if COMPORTEMENT:
motscles['COMPORTEMENT'] = COMPORTEMENT.List_F()
# -- Deroulement du calcul
motscles['INCREMENT'] = INCREMENT.List_F()
if args.has_key('FORMAT_TABLE'):
if args['FORMAT_TABLE'] != None:
motscles['FORMAT_TABLE'] = args['FORMAT_TABLE']
if args.has_key('OPER_TANGENT'):
if args['OPER_TANGENT'] != None:
motscles['OPER_TANGENT'] = args['OPER_TANGENT']
if args.has_key('NB_VARI_TABLE'):
if args['NB_VARI_TABLE'] != None:
motscles['NB_VARI_TABLE'] = args['NB_VARI_TABLE']
if ARCHIVAGE:
motscles['ARCHIVAGE'] = ARCHIVAGE.List_F()
# variables de commande
if args.has_key('AFFE_VARC'):
if args['AFFE_VARC'] != None:
lvarc = args['AFFE_VARC'].List_F()
nbvarc = len(lvarc)
lmotcle = []
for ivarc in range(nbvarc):
dico = {}
if (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'):
dico['NOM_VARC'] = 'ALPHPUR'
dico['VALE_FONC'] = lvarc[ivarc]['V1']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'ALPHBETA'
dico['VALE_FONC'] = lvarc[ivarc]['V2']
lmotcle.append(dico)
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'):
dico['NOM_VARC'] = 'PFERRITE'
dico['VALE_FONC'] = lvarc[ivarc]['V1']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'PPERLITE'
dico['VALE_FONC'] = lvarc[ivarc]['V2']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'PBAINITE'
dico['VALE_FONC'] = lvarc[ivarc]['V3']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'PMARTENS'
dico['VALE_FONC'] = lvarc[ivarc]['V4']
lmotcle.append(dico)
else:
dico['NOM_VARC'] = lvarc[ivarc]['NOM_VARC']
dico['VALE_FONC'] = lvarc[ivarc]['VALE_FONC']
if str(lvarc[ivarc]['NOM_VARC']) == 'TEMP' or str(
lvarc[ivarc]['NOM_VARC']) == 'SECH':
dico['VALE_REF'] = lvarc[ivarc]['VALE_REF']
lmotcle.append(dico)
motscles['AFFE_VARC'] = lmotcle
if lcomp['RELATION'] == 'META_LEMA_ANI':
UTMESS('F', 'COMPOR2_91', valk=lcomp['RELATION'])
self.DeclareOut('REPONSE', self.sd)
Titre = 'CALC_POINT_MAT'
if ARCHIVAGE != None:
# on ne prend en compte que ARCHIVAGE / LIST_INST
if ARCHIVAGE['LIST_INST'] != None:
__REP1 = CALC_POINT_MAT(INFO=INFO,
MATER=MATER,
ANGLE=ANGLE,
**motscles)
lr8 = ARCHIVAGE['LIST_INST']
lr = lr8.Valeurs()
REPONSE = CALC_TABLE(
TABLE=__REP1,
TITRE=Titre,
ACTION=_F(OPERATION='FILTRE',
NOM_PARA='INST',
VALE=lr,
PRECISION=ARCHIVAGE['PRECISION']),
)
else:
REPONSE = CALC_POINT_MAT(INFO=INFO,
MATER=MATER,
ANGLE=ANGLE,
**motscles)
else:
REPONSE = CALC_POINT_MAT(INFO=INFO,
MATER=MATER,
ANGLE=ANGLE,
**motscles)
#===============================================================
# cas ou on fait le calcul sur un TETRA4 A UN SEUL POINT DE GAUSS
#===============================================================
elif itetra == 1:
EPS = {}
SIG = {}
MODELISATION = "3D"
if args.has_key('MODELISATION'):
if args['MODELISATION'] != None:
MODELISATION = args['MODELISATION']
if MODELISATION == "3D":
nbsig = 6
CMP_EPS = ['EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ']
CMP_SIG = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ']
else:
nbsig = 3
CMP_EPS = ['EPXX', 'EPYY', 'EPXY']
CMP_SIG = ['SIXX', 'SIYY', 'SIXY']
if SIGM_IMPOSE:
SIG = SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste)
for i in SIG.keys():
if SIG[i] == None:
SIG[i] = __fonczero
else:
for i in range(nbsig):
SIG[CMP_SIG[i]] = __fonczero
if EPSI_IMPOSE:
EPS = EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste)
else:
for i in range(nbsig):
EPS[CMP_EPS[i]] = None
for index in range(nbsig):
iks = CMP_SIG[index]
ike = CMP_EPS[index]
if EPS[ike] != None and SIG[iks] != __fonczero:
UTMESS('F', 'COMPOR2_3', valk=str(iks) + ' ' + str(ike))
# -- Definition du maillage
if MODELISATION == "3D":
texte_ma = """
COOR_3D
P0 0.0 0.0 0.0
P1 1.0 0.0 0.0
P2 0.0 1.0 0.0
P3 0.0 0.0 1.0
FINSF
TRIA3
F1 P0 P3 P2
F2 P0 P1 P3
F3 P0 P2 P1
F4 P1 P2 P3
FINSF
TETRA4
VOLUME = P0 P1 P2 P3
FINSF
GROUP_MA
TOUT VOLUME
FINSF
GROUP_NO
TOUT P1 P2 P0 P3
FINSF
FIN
"""
else:
texte_ma = """
COOR_2D
P0 0.0 0.0
P1 1.0 0.0
P2 0.0 1.0
FINSF
SEG2
S1 P2 P0
S2 P0 P1
S3 P1 P2
FINSF
TRIA3
VOLUME = P0 P1 P2
FINSF
GROUP_MA
TOUT VOLUME
FINSF
GROUP_NO
TOUT P1 P2 P0
FINSF
FIN
"""
fi_mail = open('simu.mail', 'w')
fi_mail.write(texte_ma)
fi_mail.close()
UL = UniteAster()
umail = UL.Libre(action='ASSOCIER', nom='simu.mail')
__MA = LIRE_MAILLAGE(FORMAT='ASTER', UNITE=umail)
UL.EtatInit()
if MODELISATION == "3D":
__MO = AFFE_MODELE(MAILLAGE=__MA,
AFFE=_F(
MAILLE=('VOLUME', 'F1', 'F2', 'F3', 'F4'),
PHENOMENE='MECANIQUE',
MODELISATION='3D',
))
# ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations
# imposées.
if ANGLE != 0.:
__MA = MODI_MAILLAGE(
reuse=__MA,
MAILLAGE=__MA,
ROTATION=_F(POIN_1=(0., 0.), ANGLE=ANGLE),
)
c = math.cos(ANGLE * math.pi / 180.)
s = math.sin(ANGLE * math.pi / 180.)
__C_RIGIDE = AFFE_CHAR_MECA(
MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0., DZ=0.),
LIAISON_DDL=(
_F(NOEUD=('P1', 'P1', 'P2', 'P2'),
DDL=('DX', 'DY', 'DX', 'DY'),
COEF_MULT=(s, -c, c, s),
COEF_IMPO=0),
_F(NOEUD=('P1', 'P3', 'P3'),
DDL=('DZ', 'DX', 'DY'),
COEF_MULT=(-1.0, c, s),
COEF_IMPO=0),
_F(NOEUD=('P2', 'P3', 'P3'),
DDL=('DZ', 'DX', 'DY'),
COEF_MULT=(-1.0, -s, c),
COEF_IMPO=0),
),
)
else:
# -- Mouvement de corps rigide
__C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0',
DX=0,
DY=0,
DZ=0),
LIAISON_DDL=(
_F(NOEUD=('P2', 'P1'),
DDL=('DX', 'DY'),
COEF_MULT=(1, -1),
COEF_IMPO=0),
_F(NOEUD=('P3', 'P1'),
DDL=('DX', 'DZ'),
COEF_MULT=(1, -1),
COEF_IMPO=0),
_F(NOEUD=('P3', 'P2'),
DDL=('DY', 'DZ'),
COEF_MULT=(1, -1),
COEF_IMPO=0),
))
else:
# MODELISATION 2D
__MO = AFFE_MODELE(MAILLAGE=__MA,
AFFE=_F(MAILLE=('VOLUME', 'S1', 'S2', 'S3'),
PHENOMENE='MECANIQUE',
MODELISATION=MODELISATION))
# ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations
# imposées.
if ANGLE != 0.:
__MA = MODI_MAILLAGE(
reuse=__MA,
MAILLAGE=__MA,
ROTATION=_F(POIN_1=(0., 0.), ANGLE=ANGLE),
)
c = math.cos(ANGLE * math.pi / 180.)
s = math.sin(ANGLE * math.pi / 180.)
__C_RIGIDE = AFFE_CHAR_MECA(
MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0.),
LIAISON_DDL=(_F(NOEUD=('P1', 'P1', 'P2', 'P2'),
DDL=('DX', 'DY', 'DX', 'DY'),
COEF_MULT=(s, -c, c, s),
COEF_IMPO=0), ),
)
else:
__C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0', DX=0,
DY=0),
LIAISON_DDL=(_F(NOEUD=('P2', 'P1'),
DDL=('DX', 'DY'),
COEF_MULT=(1, -1),
COEF_IMPO=0), ))
# --MASSIF : orientation du materiau (monocristal, orthotropie)
if MASSIF:
ANGMAS = MASSIF[0].cree_dict_valeurs(MASSIF[0].mc_liste)
if ANGMAS["ANGL_REP"] == None:
__CARA = AFFE_CARA_ELEM(
MODELE=__MO,
MASSIF=_F(MAILLE='VOLUME',
ANGL_EULER=ANGMAS["ANGL_EULER"]),
)
else:
__CARA = AFFE_CARA_ELEM(
MODELE=__MO,
MASSIF=_F(MAILLE='VOLUME', ANGL_REP=ANGMAS["ANGL_REP"]),
)
# -- Chargement en deformation
__E = [None] * nbsig
__E[0] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1',
DX=1,
ANGL_NAUT=ANGLE))
__E[1] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P2',
DY=1,
ANGL_NAUT=ANGLE))
if MODELISATION == "3D":
__E[2] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P3',
DZ=1,
ANGL_NAUT=ANGLE))
__E[3] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1',
DY=1,
ANGL_NAUT=ANGLE))
__E[4] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1',
DZ=1,
ANGL_NAUT=ANGLE))
__E[5] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P2',
DZ=1,
ANGL_NAUT=ANGLE))
else:
c = math.cos(ANGLE * math.pi / 180.)
s = math.sin(ANGLE * math.pi / 180.)
__E[2] = AFFE_CHAR_MECA(
MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE),
)
# -- Chargement en contrainte
__S = [None] * nbsig
if MODELISATION == "3D":
r33 = 3**-0.5
__S[0] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F1', FX=-1),
_F(MAILLE='F4', FX=r33),
))
__S[1] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F2', FY=-1),
_F(MAILLE='F4', FY=r33),
))
__S[2] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F3', FZ=-1),
_F(MAILLE='F4', FZ=r33),
))
__S[3] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F1', FY=-1),
_F(MAILLE='F2', FX=-1),
_F(MAILLE='F4', FX=r33, FY=r33),
))
__S[4] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F1', FZ=-1),
_F(MAILLE='F3', FX=-1),
_F(MAILLE='F4', FX=r33, FZ=r33),
))
__S[5] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F2', FZ=-1),
_F(MAILLE='F3', FY=-1),
_F(MAILLE='F4', FY=r33, FZ=r33),
))
else:
r22 = 2**-0.5
__S[0] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_CONTOUR=(
_F(MAILLE='S1', FX=-1),
_F(MAILLE='S3', FX=r22),
))
__S[1] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_CONTOUR=(
_F(MAILLE='S2', FY=-1),
_F(MAILLE='S3', FY=r22),
))
__S[2] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_CONTOUR=(
_F(MAILLE='S1', FY=-1),
_F(MAILLE='S2', FX=-1),
_F(MAILLE='S3', FX=r22, FY=r22),
))
# -- Construction de la charge
l_char = [_F(CHARGE=__C_RIGIDE)]
for i in xrange(nbsig):
ike = CMP_EPS[i]
if EPS[ike]:
l_char.append(_F(CHARGE=__E[i], FONC_MULT=EPS[ike]))
for i in xrange(nbsig):
iks = CMP_SIG[i]
l_char.append(_F(CHARGE=__S[i], FONC_MULT=SIG[iks]))
# variables de commande
mcvarc = []
if args.has_key('AFFE_VARC'):
if args['AFFE_VARC'] != None:
lvarc = args['AFFE_VARC'].List_F()
nbvarc = len(lvarc)
for ivarc in range(nbvarc):
dico = {}
if (str(lvarc[ivarc]['NOM_VARC']) == 'SECH'):
typech = 'NOEU_TEMP_R'
labsc = lvarc[ivarc]['VALE_FONC'].Absc()
lordo = lvarc[ivarc]['VALE_FONC'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHV[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
MAILLAGE=__MA,
AFFE=_F(
MAILLE='VOLUME',
NOM_CMP='TEMP',
VALE=lordo[it],
),
),
dicoch = {}
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_VARC',
NOM_CHAM='TEMP',
AFFE=l_affe_cham)
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'):
typech = 'ELNO_NEUT_R'
labsc = lvarc[ivarc]['V1'].Absc()
lordo1 = lvarc[ivarc]['V1'].Ordo()
lordo2 = lvarc[ivarc]['V2'].Ordo()
lordo3 = lvarc[ivarc]['V3'].Ordo()
lordo4 = lvarc[ivarc]['V4'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
__CHN = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHN[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
PROL_ZERO='OUI',
MODELE=__MO,
AFFE=(
_F(
MAILLE='VOLUME',
NOM_CMP='X1',
VALE=lordo1[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X2',
VALE=lordo2[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X3',
VALE=lordo3[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X4',
VALE=lordo4[it],
),
),
),
dicoch = {}
__CHV[it] = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELNO_VARI_R',
MODELE=__MO,
PROL_ZERO='OUI',
ASSE=(
_F(CHAM_GD=__CHN[it],
NOM_CMP='X1',
NOM_CMP_RESU='V1',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X2',
NOM_CMP_RESU='V2',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X3',
NOM_CMP_RESU='V3',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X4',
NOM_CMP_RESU='V4',
GROUP_MA='TOUT'),
))
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_THER',
NOM_CHAM=str('META_ELNO'),
AFFE=l_affe_cham)
IMPR_RESU(FORMAT='RESULTAT', RESU=_F(RESULTAT=__EVOV))
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'):
typech = 'ELNO_NEUT_R'
labsc = lvarc[ivarc]['V1'].Absc()
lordo1 = lvarc[ivarc]['V1'].Ordo()
lordo2 = lvarc[ivarc]['V2'].Ordo()
lordo3 = lvarc[ivarc]['V3'].Ordo()
lordo4 = lvarc[ivarc]['V4'].Ordo()
lordo5 = lvarc[ivarc]['V5'].Ordo()
lordo6 = lvarc[ivarc]['V6'].Ordo()
lordo7 = lvarc[ivarc]['V7'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
__CHN = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHN[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
PROL_ZERO='OUI',
MODELE=__MO,
AFFE=(
_F(
MAILLE='VOLUME',
NOM_CMP='X1',
VALE=lordo1[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X2',
VALE=lordo2[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X3',
VALE=lordo3[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X4',
VALE=lordo4[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X5',
VALE=lordo5[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X6',
VALE=lordo6[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X7',
VALE=lordo7[it],
),
),
),
dicoch = {}
__CHV[it] = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELNO_VARI_R',
MODELE=__MO,
PROL_ZERO='OUI',
ASSE=(
_F(CHAM_GD=__CHN[it],
NOM_CMP='X1',
NOM_CMP_RESU='V1',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X2',
NOM_CMP_RESU='V2',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X3',
NOM_CMP_RESU='V3',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X4',
NOM_CMP_RESU='V4',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X5',
NOM_CMP_RESU='V5',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X6',
NOM_CMP_RESU='V6',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X7',
NOM_CMP_RESU='V7',
GROUP_MA='TOUT'),
))
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_THER',
NOM_CHAM=str('META_ELNO'),
AFFE=l_affe_cham)
IMPR_RESU(FORMAT='RESULTAT', RESU=_F(RESULTAT=__EVOV))
else:
typech = 'NOEU_' + str(lvarc[ivarc]['NOM_VARC']) + '_R'
labsc = lvarc[ivarc]['VALE_FONC'].Absc()
lordo = lvarc[ivarc]['VALE_FONC'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHV[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
MAILLAGE=__MA,
AFFE=_F(
MAILLE='VOLUME',
NOM_CMP=lvarc[ivarc]['NOM_VARC'],
VALE=lordo[it],
),
),
dicoch = {}
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_VARC',
NOM_CHAM=str(
lvarc[ivarc]['NOM_VARC']),
AFFE=l_affe_cham)
dico["MAILLE"] = 'VOLUME'
dico["EVOL"] = __EVOV
if (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'):
dico["NOM_VARC"] = "M_ZIRC"
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'):
dico["NOM_VARC"] = "M_ACIER"
else:
dico["NOM_VARC"] = lvarc[ivarc]['NOM_VARC']
if lvarc[ivarc]['VALE_REF'] != None:
dico["VALE_REF"] = lvarc[ivarc]['VALE_REF']
mcvarc.append(dico)
# -- Materiau et modele
if len(mcvarc) > 0:
__CHMAT = AFFE_MATERIAU(
MAILLAGE=__MA,
AFFE=_F(MAILLE='VOLUME', MATER=MATER),
AFFE_VARC=mcvarc,
)
else:
__CHMAT = AFFE_MATERIAU(MAILLAGE=__MA,
AFFE=_F(MAILLE='VOLUME', MATER=MATER))
# Etat initial
SIGINI = {}
VARINI = {}
LCSIG = []
LVSIG = []
init_dico = {}
etatinit = 0
# --contraintes initiales
if SIGM_INIT:
etatinit = 1
SIGINI = SIGM_INIT[0].cree_dict_valeurs(SIGM_INIT[0].mc_liste)
for i in SIGINI.keys():
if SIGINI[i] != None:
LCSIG.append(i)
LVSIG.append(SIGINI[i])
__SIG_INIT = CREA_CHAMP(MAILLAGE=__MA,
OPERATION='AFFE',
TYPE_CHAM='CART_SIEF_R',
AFFE=_F(
TOUT='OUI',
NOM_CMP=LCSIG,
VALE=LVSIG,
))
init_dico['SIGM'] = __SIG_INIT
# --variables internes initiales
if VARI_INIT:
etatinit = 1
lnomneu = []
lnomvar = []
VARINI = VARI_INIT[0].cree_dict_valeurs(VARI_INIT[0].mc_liste)
if (not is_sequence(VARINI['VALE'])):
VARINI['VALE'] = [
VARINI['VALE'],
]
nbvari = len(VARINI['VALE'])
for i in range(nbvari):
lnomneu.append('X' + str(i + 1))
lnomvar.append('V' + str(i + 1))
__NEUT = CREA_CHAMP(OPERATION='AFFE',
TYPE_CHAM='CART_N480_R',
MAILLAGE=__MA,
AFFE=_F(MAILLE='VOLUME',
NOM_CMP=lnomneu,
VALE=VARINI['VALE']))
__VAR_INIT = CREA_CHAMP(MODELE=__MO,
OPERATION='ASSE',
TYPE_CHAM='ELGA_VARI_R',
ASSE=_F(TOUT='OUI',
CHAM_GD=__NEUT,
NOM_CMP=lnomneu,
NOM_CMP_RESU=lnomvar))
init_dico['VARI'] = __VAR_INIT
# --deformations initiales
if EPSI_INIT:
etatinit = 1
EPSINI = {}
LCDEPL = []
LNDEPL = []
LVDEPL = []
LIST_AFFE = []
mon_dico = {}
mon_dico["NOEUD"] = 'P0'
mon_dico["NOM_CMP"] = ("DX", "DY", "DZ")
mon_dico["VALE"] = (0., 0., 0.)
LIST_AFFE.append(mon_dico)
EPSINI = EPSI_INIT[0].cree_dict_valeurs(EPSI_INIT[0].mc_liste)
mon_dico = {}
mon_dico["NOEUD"] = 'P1'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXX']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPYY']
LIST_AFFE.append(mon_dico)
if MODELISATION == "3D":
mon_dico = {}
mon_dico["NOEUD"] = 'P3'
mon_dico["NOM_CMP"] = 'DZ'
mon_dico["VALE"] = EPSINI['EPZZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P1'
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P1'
mon_dico["NOM_CMP"] = 'DZ'
mon_dico["VALE"] = EPSINI['EPXZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P3'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DZ'
mon_dico["VALE"] = EPSINI['EPYZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P3'
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPYZ']
LIST_AFFE.append(mon_dico)
else:
mon_dico = {}
mon_dico["NOEUD"] = 'P1',
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
__DEP_INI = CREA_CHAMP(MAILLAGE=__MA,
OPERATION='AFFE',
TYPE_CHAM='NOEU_DEPL_R',
AFFE=LIST_AFFE)
init_dico['DEPL'] = __DEP_INI
# -- Deroulement du calcul
motscles = {}
if COMPORTEMENT:
motscles['COMPORTEMENT'] = COMPORTEMENT.List_F()
if lcomp['RELATION'] == 'META_LEMA_ANI':
UTMESS('A', 'COMPOR2_92', valk=lcomp['RELATION'])
motscles['CONVERGENCE'] = CONVERGENCE.List_F()
motscles['NEWTON'] = NEWTON.List_F()
if args.has_key('RECH_LINEAIRE'):
if args['RECH_LINEAIRE'] != None:
motscles['RECH_LINEAIRE'] = args['RECH_LINEAIRE'].List_F()
motscles['INCREMENT'] = INCREMENT.List_F()
if ARCHIVAGE:
motscles['ARCHIVAGE'] = ARCHIVAGE.List_F()
if args.has_key('SUIVI_DDL'):
if args['SUIVI_DDL'] != None:
motscles['SUIVI_DDL'] = args['SUIVI_DDL'].List_F()
if etatinit == 1:
if MASSIF:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
CARA_ELEM=__CARA,
MODELE=__MO,
CHAM_MATER=__CHMAT,
ETAT_INIT=init_dico,
EXCIT=l_char,
**motscles)
else:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
MODELE=__MO,
CHAM_MATER=__CHMAT,
ETAT_INIT=init_dico,
EXCIT=l_char,
**motscles)
else:
if MASSIF:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
MODELE=__MO,
CARA_ELEM=__CARA,
CHAM_MATER=__CHMAT,
EXCIT=l_char,
**motscles)
else:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
MODELE=__MO,
CHAM_MATER=__CHMAT,
EXCIT=l_char,
**motscles)
if lcomp['DEFORMATION'] != 'PETIT':
nomepsi = 'EPSG_ELNO'
else:
nomepsi = 'EPSI_ELNO'
__EVOL1 = CALC_CHAMP(
reuse=__EVOL1,
RESULTAT=__EVOL1,
CONTRAINTE='SIGM_ELNO',
DEFORMATION=nomepsi,
VARI_INTERNE='VARI_ELNO',
)
if MODELISATION == "3D":
angles = (ANGLE, 0, 0)
__EVOL = MODI_REPERE(
RESULTAT=__EVOL1,
MODI_CHAM=(
_F(
NOM_CHAM='DEPL',
NOM_CMP=('DX', 'DY', 'DZ'),
TYPE_CHAM='VECT_3D',
),
_F(
NOM_CHAM='SIGM_ELNO',
NOM_CMP=('SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ',
'SIYZ'),
TYPE_CHAM='TENS_3D',
),
_F(
NOM_CHAM=nomepsi,
NOM_CMP=('EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ',
'EPYZ'),
TYPE_CHAM='TENS_3D',
),
),
REPERE='UTILISATEUR',
AFFE=_F(ANGL_NAUT=angles),
)
else:
angles = ANGLE
__EVOL = MODI_REPERE(
RESULTAT=__EVOL1,
MODI_CHAM=(
_F(
NOM_CHAM='DEPL',
NOM_CMP=('DX', 'DY'),
TYPE_CHAM='VECT_2D',
),
_F(
NOM_CHAM='SIGM_ELNO',
NOM_CMP=('SIXX', 'SIYY', 'SIZZ', 'SIXY'),
TYPE_CHAM='TENS_2D',
),
_F(
NOM_CHAM=nomepsi,
NOM_CMP=('EPXX', 'EPYY', 'EPZZ', 'EPXY'),
TYPE_CHAM='TENS_2D',
),
),
REPERE='UTILISATEUR',
AFFE=_F(ANGL_NAUT=angles),
)
# -- Recuperation des courbes
__REP_VARI = POST_RELEVE_T(ACTION=(_F(INTITULE='VARI_INT',
RESULTAT=__EVOL1,
NOM_CHAM='VARI_ELNO',
TOUT_CMP='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_EPSI = POST_RELEVE_T(ACTION=(_F(INTITULE='EPSILON',
RESULTAT=__EVOL,
NOM_CHAM=nomepsi,
TOUT_CMP='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_SIGM = POST_RELEVE_T(ACTION=(_F(INTITULE='SIGMA',
RESULTAT=__EVOL,
NOM_CHAM='SIGM_ELNO',
TOUT_CMP='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_INV = POST_RELEVE_T(ACTION=(_F(INTITULE='INV',
RESULTAT=__EVOL,
NOM_CHAM='SIGM_ELNO',
INVARIANT='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_INV = CALC_TABLE(TABLE=__REP_INV,
reuse=__REP_INV,
ACTION=_F(
OPERATION='EXTR',
NOM_PARA=('INST', 'TRACE', 'VMIS'),
))
self.DeclareOut('REPONSE', self.sd)
REPONSE = CALC_TABLE(TABLE=__REP_EPSI,
TITRE='TABLE ',
ACTION=(
_F(
OPERATION='COMB',
TABLE=__REP_SIGM,
NOM_PARA=('INST'),
),
_F(
OPERATION='COMB',
TABLE=__REP_INV,
NOM_PARA=('INST'),
),
_F(
OPERATION='COMB',
TABLE=__REP_VARI,
NOM_PARA=('INST'),
),
))
RetablirAlarme('COMPOR4_70')
return ier
def post_coque_ops(self, RESULTAT, COOR_POINT, CHAM, NUME_ORDRE, INST, **args):
"""
macro post_coque
"""
import aster
import os
import string
import Accas
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from Utilitai.Table import Table
from Noyau.N_utils import AsType
ier = 0
# On importe les definitions des commandes a utiliser dans la macro
MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_TABLE = self.get_cmd('CREA_TABLE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
MasquerAlarme('MODELISA4_9')
# Le concept sortant (de type table) est nomme
# 'tabout' dans le contexte de la macro
self.DeclareOut('tabout', self.sd)
assert AsType(RESULTAT).__name__ in (
'evol_elas',
'evol_noli',
)
dico = RESULTAT.LIST_CHAMPS()
dico2 = RESULTAT.LIST_VARI_ACCES()
# si ni INST ni NUME_ORDRE ne sont presents, on prend le premier
# instant calcule
if not INST and not NUME_ORDRE:
INST = dico2['INST'][0]
iret, ibid, n_modele = aster.dismoi('MODELE', RESULTAT.nom, 'RESULTAT',
'F')
MODEL = self.get_concept(n_modele)
if NUME_ORDRE:
if not NUME_ORDRE in dico2['NUME_ORDRE']:
UTMESS('F', 'POST0_25', vali=NUME_ORDRE)
else:
if not INST in dico2['INST']:
UTMESS('F', 'POST0_26', valr=INST)
#
if NUME_ORDRE:
if CHAM == 'EFFORT':
if not NUME_ORDRE in dico['EFGE_ELNO']:
if NUME_ORDRE in dico['DEPL']:
CALC_CHAMP(RESULTAT=RESULTAT,
reuse=RESULTAT,
CONTRAINTE='EFGE_ELNO',
NUME_ORDRE=NUME_ORDRE)
else:
UTMESS('F', 'POST0_19', vali=NUME_ORDRE)
elif CHAM == 'DEFORMATION':
if not NUME_ORDRE in dico['DEGE_ELNO']:
if NUME_ORDRE in dico['DEPL']:
CALC_CHAMP(RESULTAT=RESULTAT,
reuse=RESULTAT,
DEFORMATION='DEGE_ELNO',
NUME_ORDRE=NUME_ORDRE)
else:
UTMESS('F', 'POST0_19', vali=NUME_ORDRE)
dico = RESULTAT.LIST_CHAMPS()
# Appel MACR_LIGN_COUPE :
motscles = {}
if CHAM == 'EFFORT':
motscles['NOM_CHAM'] = 'EFGE_ELNO'
if CHAM == 'DEFORMATION':
motscles['NOM_CHAM'] = 'DEGE_ELNO'
if CHAM == 'EFFORT':
motscles['LIGN_COUPE'] = []
iocc = 0
for m in COOR_POINT:
iocc = iocc + 1
lst = m['COOR']
if len(lst) == 4 and lst[3] != 0.:
UTMESS('A', 'POST0_21', vali=iocc, valr=lst[3])
lst = lst[0:3]
motscles['LIGN_COUPE'].append(
_F(
TYPE='SEGMENT',
NB_POINTS=2,
COOR_ORIG=lst,
COOR_EXTR=lst,
DISTANCE_MAX=10.0,
), )
__tabl = MACR_LIGN_COUPE(RESULTAT=RESULTAT, **motscles)
if CHAM == 'DEFORMATION':
motscles['LIGN_COUPE'] = []
iocc = 0
for m in COOR_POINT:
iocc = iocc + 1
lst = m['COOR']
if len(lst) != 4:
UTMESS('F', 'POST0_22', vali=iocc)
else:
lst = lst[0:3]
motscles['LIGN_COUPE'].append(
_F(
TYPE='SEGMENT',
NB_POINTS=2,
COOR_ORIG=lst,
COOR_EXTR=lst,
DISTANCE_MAX=10.0,
), )
__tabl = MACR_LIGN_COUPE(RESULTAT=RESULTAT, **motscles)
tab2 = __tabl.EXTR_TABLE()
if NUME_ORDRE:
tab3 = (tab2.NUME_ORDRE == NUME_ORDRE)
else:
tab3 = (tab2.INST == INST)
tab2 = tab3
tab4 = Table()
ilig = 0
for ligne in tab2:
ilig = ilig + 1
if (ilig % 2) == 0:
tab4.append(ligne)
tab4 = tab4[tab2.para]
#
# on cree une table(dege) bidon qu'on va surcharger
#
if CHAM == 'DEFORMATION':
motscles['NOM_CHAM'] = 'DEGE_ELNO'
motscles['LIGN_COUPE'] = []
tabz = []
iocc = 0
for m in COOR_POINT:
iocc = iocc + 1
lst = m['COOR']
z = lst[3]
tabz.append(z)
lst = lst[0:3]
motscles['LIGN_COUPE'].append(
_F(
TYPE='SEGMENT',
NB_POINTS=2,
COOR_ORIG=lst,
COOR_EXTR=lst,
DISTANCE_MAX=10.0,
), )
__tabeps = MACR_LIGN_COUPE(RESULTAT=RESULTAT, **motscles)
__teps = CALC_TABLE(
TABLE=__tabeps,
ACTION=(
_F(OPERATION='RENOMME', NOM_PARA=('EXX', 'EPXX')),
_F(OPERATION='RENOMME', NOM_PARA=('EYY', 'EPYY')),
_F(OPERATION='RENOMME', NOM_PARA=('EXY', 'EPZZ')),
_F(OPERATION='RENOMME', NOM_PARA=('KXX', 'EPXY')),
_F(OPERATION='RENOMME', NOM_PARA=('KYY', 'EPXZ')),
_F(OPERATION='RENOMME', NOM_PARA=('KXY', 'EPYZ')),
_F(OPERATION='EXTR',
NOM_PARA=(
'INTITULE',
'NOM_CHAM',
'NUME_ORDRE',
'INST',
'ABSC_CURV',
'COOR_X',
'COOR_Y',
'COOR_Z',
'EPXX',
'EPYY',
'EPZZ',
'EPXY',
'EPXZ',
'EPYZ',
)),
),
)
tabep2 = __teps.EXTR_TABLE()
if NUME_ORDRE:
tabep3 = (tabep2.NUME_ORDRE == NUME_ORDRE)
else:
tabep3 = (tabep2.INST == INST)
tabep2 = tabep3
tabep4 = Table()
ilig = 0
for ligne in tabep2:
ilig = ilig + 1
if (ilig % 2) == 0:
tabep4.append(ligne)
tabep4 = tabep4[tabep2.para]
iligout = 0
for ligout in tabep4:
iligout = iligout + 1
iligin = 0
for ligin in tab4:
iligin = iligin + 1
if (iligout == iligin):
ligout['EPXX'] = ligin['EXX'] + ligin['KXX'] * tabz[iligout
- 1]
ligout['EPYY'] = ligin['EYY'] + ligin['KYY'] * tabz[iligout
- 1]
ligout['EPXY'] = ligin['EXY'] + ligin['KXY'] * tabz[iligout
- 1]
ligout['EPZZ'] = 0.0
ligout['EPXZ'] = ligin['GAX'] * 0.5
ligout['EPYZ'] = ligin['GAY'] * 0.5
if CHAM == 'EFFORT':
dprod = tab4.dict_CREA_TABLE()
elif CHAM == 'DEFORMATION':
dprod = tabep4.dict_CREA_TABLE()
tabout = CREA_TABLE(TYPE_TABLE='TABLE', **dprod)
RetablirAlarme('MODELISA4_9')
return ier