def LIST_PARA(self):
if not self.accessible():
raise AsException(
"Erreur dans resultat.LIST_PARA en PAR_LOT='OUI'")
return aster.GetResu(self.get_name(), "PARAMETRES")
def post_coque_ops(self, RESULTAT, COOR_POINT, CHAM, NUME_ORDRE=None , INST=None,
**args):
"""
macro post_coque
"""
# On importe les definitions des commandes a utiliser dans la macro
MasquerAlarme('MODELISA4_9')
assert RESULTAT.getType() in ('EVOL_ELAS', 'EVOL_NOLI',)
dico = aster.GetResu(RESULTAT.getName(), "CHAMPS")
dico2 = aster.GetResu(RESULTAT.getName(), "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]
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 = aster.GetResu(RESULTAT.getName(), "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 tabout
def LIST_NOM_CMP(self):
if not self.accessible():
raise AsException(
"Erreur dans resultat.LIST_NOM_CMP en PAR_LOT='OUI'")
return aster.GetResu(self.get_name(), "COMPOSANTES")
def LIST_VARI_ACCES(self):
if not self.accessible():
raise AsException(
"Erreur dans resultat.LIST_VARI_ACCES en PAR_LOT='OUI'")
return aster.GetResu(self.get_name(), "VARI_ACCES")
def LIST_VARI_ACCES(self):
return aster.GetResu(self.getName(), "VARI_ACCES")
def LIST_PARA(self):
return aster.GetResu(self.getName(), "PARAMETRES")
def dyna_visco_modes_calc(self,
TYPE_MODE,
freq1,
nmode,
RESI_RELA,
i,
j,
MATER_ELAS_FO,
e0,
eta0,
__asseMg,
__asseKgr,
__asseKg,
__listKv,
trKg,
ltrv,
TYPE_RESU,
reuse='non',
**args):
"""
Macro-command DYNA_VISCO,
function to compute with iterations one eigenmode,
and store it
"""
dfreq = freq1
while abs(dfreq) >= RESI_RELA * freq1:
if i > 10:
nmode = nmode + 5
i = 0
if TYPE_MODE == 'REEL':
__asseKw = __asseKgr
elif TYPE_MODE == 'BETA_REEL':
__asseKw = __asseKg
betab = NP.real(trKg)
betah = NP.imag(trKg)
elif TYPE_MODE == 'COMPLEXE':
__asseKw = __asseKg
else:
assert False
ny = 0
for y in MATER_ELAS_FO:
e = float(y['E'](freq1))
eta = float(y['AMOR_HYST'](freq1))
if TYPE_MODE == 'REEL':
__asseKw = COMB_MATR_ASSE(COMB_R=(
_F(MATR_ASSE=__asseKw, COEF_R=1.),
_F(MATR_ASSE=__listKv[ny], COEF_R=e / e0[ny] - 1.),
), )
if TYPE_MODE in ['BETA_REEL', 'COMPLEXE']:
__asseKw = COMB_MATR_ASSE(COMB_C=(
_F(MATR_ASSE=__asseKw, COEF_R=1.),
_F(
MATR_ASSE=__listKv[ny],
COEF_C=(complex(e / e0[ny] - 1.,
eta * e / e0[ny] - eta0[ny])),
),
), )
if TYPE_MODE == 'BETA_REEL':
betab = betab + (e / e0[ny] - 1.) * ltrv[ny]
betah = betah + (eta * e / e0[ny] - eta0[ny]) * ltrv[ny]
ny = ny + 1
if TYPE_MODE == 'BETA_REEL':
__asseKw = COMB_MATR_ASSE(COMB_R=(
_F(MATR_ASSE=__asseKw, PARTIE='REEL', COEF_R=1.),
_F(MATR_ASSE=__asseKw, PARTIE='IMAG', COEF_R=betah / betab),
), )
# IMPR_CO(CONCEPT=_F(NOM=__asseKw))
__modtmp = CALC_MODES(
MATR_RIGI=__asseKw,
MATR_MASS=__asseMg,
OPTION='CENTRE',
CALC_FREQ=_F(
FREQ=freq1,
NMAX_FREQ=nmode,
),
VERI_MODE=_F(
STOP_ERREUR='OUI',
SEUIL=1.e-3,
STURM='NON',
),
)
freq2 = aster.GetResu(__modtmp.getName(), "VARI_ACCES")['FREQ']
dfreq = abs(freq1 - freq2[0])
__numod = 0
for ii in range(1, nmode):
__new_dfreq = abs(freq1 - freq2[ii])
if __new_dfreq < dfreq:
dfreq = __new_dfreq
__numod = ii
freq1 = freq2[__numod]
if TYPE_MODE == 'COMPLEXE':
amor_red1 = aster.GetResu(__modtmp.getName(),
"PARAMETRES")['AMOR_REDUIT'][__numod]
if __numod + 1 == nmode:
nmode = nmode + 5
dfreq = freq1
i = i + 1
if TYPE_MODE in ['REEL', 'BETA_REEL']:
type_cham = 'NOEU_DEPL_R'
elif TYPE_MODE == 'COMPLEXE':
type_cham = 'NOEU_DEPL_C'
else:
assert False
# extract the modal shape
__unmod = CREA_CHAMP(
OPERATION='EXTR',
NOM_CHAM='DEPL',
TYPE_CHAM=type_cham,
RESULTAT=__modtmp,
NUME_ORDRE=__numod + 1,
)
motcles = {}
if TYPE_MODE in ['REEL', 'BETA_REEL']:
type_resu = 'MODE_MECA'
motcles['AFFE'] = _F(CHAM_GD=__unmod, NUME_MODE=j + 1, FREQ=freq1)
elif TYPE_MODE == 'COMPLEXE':
type_resu = 'MODE_MECA_C'
motcles['AFFE'] = _F(CHAM_GD=__unmod,
NUME_MODE=j + 1,
FREQ=freq1,
AMOR_REDUIT=amor_red1)
else:
assert False
if reuse == 'oui':
motcles['reuse'] = args['co_reuse']
motcles['RESULTAT'] = args['co_reuse']
# fill the concept containing the eigenmodes
_modes = CREA_RESU(OPERATION='AFFE',
TYPE_RESU=type_resu,
NOM_CHAM='DEPL',
MATR_MASS=__asseMg,
**motcles)
freq1 = freq2[__numod + 1]
DETRUIRE(CONCEPT=_F(NOM=__modtmp, ), )
return _modes, freq1, nmode
def LIST_CHAMPS(self):
return aster.GetResu(self.getName(), "CHAMPS")
def post_bordet_ops(self,
RESULTAT,
PARAM,
TEMP,
TOUT=None,
GROUP_MA=None,
INST=None,
PRECISION=None,
CRITERE=None,
NUME_ORDRE=None,
PROBA_NUCL=None,
COEF_MULT=None,
**args):
"""Corps de POST_BORDET"""
# On importe les definitions des commandes a utiliser dans la macro
#
# Recuperation du modele a partir du resultat
model = RESULTAT.getModel()
n_modele = model.getName()
if model is None or n_modele == "#PLUSIEURS":
UTMESS('F', 'RUPTURE1_58')
# Dimension du modele
ndim = model.getMesh().getDimension()
if ndim == 23:
UTMESS('F', 'RUPTURE1_57')
#
# Definition des formules pour le calcul de sigy plus tard
#
__MAXI = FORMULE(NOM_PARA=('T1'), VALE="""max(T1,0.)""")
#
# Calcul des grandeurs dont on a besoin : contrainte principale, def plastique et volume du pt de gauss
#
# Volume point de gauss
__VOL_PG = CALC_CHAM_ELEM(
MODELE=model,
TOUT='OUI',
OPTION='COOR_ELGA',
)
if GROUP_MA:
GROUP_MA = list(GROUP_MA)
vol = __VOL_PG.EXTR_COMP('W', GROUP_MA)
elif TOUT:
vol = __VOL_PG.EXTR_COMP('W', [])
# contrainte principale max et deformation plastique
__RESU = CALC_CHAMP(
RESULTAT=RESULTAT,
CRITERES='SIEQ_ELGA',
DEFORMATION='EPSP_ELGA',
)
# Recuperation de la liste des instants et des ordres de calcul
list_ordre = aster.GetResu(__RESU.getName(), "VARI_ACCES")['NUME_ORDRE']
list_inst = aster.GetResu(__RESU.getName(), "VARI_ACCES")['INST']
#
# On va travailler en ordre ; si l'utilisateur entre un instant, on va le
# transformer en ordre
entree_instant = None
if INST:
if CRITERE == 'ABSOLU':
prec = PRECISION
elif CRITERE == 'RELATIF':
prec = PRECISION * INST
entree_instant = True
n = 0
trouv = None
while (n < len(list_inst) and not trouv):
if (list_inst[n] + prec >= INST) and (list_inst[n] - prec <= INST):
instant = list_inst[n]
trouv = True
n = n + 1
if not trouv:
UTMESS('F',
'RUPTURE1_53',
valr=INST,
valk='utilise pour le calcul de Bordet')
if entree_instant == True:
index_ordre = list_inst.index(instant)
nume_ordre = list_ordre[index_ordre]
elif NUME_ORDRE:
nume_ordre = NUME_ORDRE
if nume_ordre not in list_ordre:
UTMESS('F',
'RUPTURE0_51',
vali=int(nume_ordre),
valk='utilise pour le calcul de Bordet')
#
# Pour Bordet, il nous faut les champs a tous les instants jusqu'a
# l'instant considere
EP = [[None for j in range(6)] for i in range(nume_ordre + 1)
] # tenseur des deformations plastiques
EPEQ = [[None for j in range(0)] for i in range(nume_ordre + 1)
] # deformation plastique equivalente
EPEQM = [0.] * (nume_ordre + 1)
#deformation plastique equivalente a l'instant precedent
PRIN = [None] * (nume_ordre + 1)
EQ_BAR = [None] * (nume_ordre + 1)
EQ_PT = [None] * (nume_ordre + 1)
EQ_PT2 = [None] * (nume_ordre + 1)
PR_BAR = [None] * (nume_ordre + 1)
DEP = [None] * (nume_ordre + 1)
BORDTI = 0. # valeur sans l'exposant final, sommee sur les instants
BORDTT = [0.] * (nume_ordre + 1)
# valeur avec l'exposant, que l'on stocke dans la table a
# chaque instant
PROBA = [0.] * (nume_ordre + 1) # Probabilite de rupture par clivage
# LISTE DES PARAMETRES
sig0 = PARAM['SEUIL_REFE']
sigth = PARAM['SIG_CRIT']
sigref = PARAM['SIGM_REFE']
m = PARAM['M']
V0 = PARAM['VOLU_REFE']
if PROBA_NUCL == 'OUI':
ep0 = PARAM['DEF_PLAS_REFE']
elif PROBA_NUCL == 'NON':
ep0 = 0
c_mult = COEF_MULT
#
# On va constuire des champs a chaque instant
#
if list_ordre[0] == 0:
fin_ordre = nume_ordre + 1
elif list_ordre[0] != 0:
fin_ordre = nume_ordre
for ordre in range(list_ordre[0], fin_ordre):
#
# Temperature a extraire : soit une fonction du temps, soit un reel
#
if type(TEMP) == fonction_sdaster:
tempe = TEMP(list_inst[ordre])
elif type(TEMP) != fonction_sdaster:
tempe = TEMP
def fseuil(epsi):
return PARAM['SEUIL_CALC'](epsi, tempe)
#self.update_const_context({'fseuil': fseuil})
__NPY = FORMULE(NOM_PARA=('EPSI'),
VALE="""fseuil(EPSI)""",
fseuil=fseuil)
#
# On met ces grandeurs dans des champs specifiques
#
__S_TOT = CREA_CHAMP(
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=__RESU,
OPERATION='EXTR',
NUME_ORDRE=ordre,
NOM_CHAM='SIEQ_ELGA',
)
__EPSP = CREA_CHAMP(
TYPE_CHAM='ELGA_EPSI_R',
RESULTAT=__RESU,
OPERATION='EXTR',
NUME_ORDRE=ordre,
NOM_CHAM='EPSP_ELGA',
)
# On recupere la valeur des champs au niveau des groupes qui nous
# interessent
if GROUP_MA:
PRIN[ordre] = __S_TOT.EXTR_COMP('PRIN_3', GROUP_MA, 0).valeurs
# Pour la deformation plastique, on construit de quoi calculer sa
# norme de VMises
EP[ordre][0] = __EPSP.EXTR_COMP('EPXX', GROUP_MA, 0).valeurs
EP[ordre][1] = __EPSP.EXTR_COMP('EPYY', GROUP_MA, 0).valeurs
EP[ordre][2] = __EPSP.EXTR_COMP('EPZZ', GROUP_MA, 0).valeurs
EP[ordre][3] = __EPSP.EXTR_COMP('EPXY', GROUP_MA, 0).valeurs
if ndim == 3:
EP[ordre][4] = __EPSP[ordre].EXTR_COMP('EPXZ', GROUP_MA,
0).valeurs
EP[ordre][5] = __EPSP[ordre].EXTR_COMP('EPYZ', GROUP_MA,
0).valeurs
elif TOUT:
PRIN[ordre] = __S_TOT.EXTR_COMP('PRIN_3', [], 0).valeurs
EP[ordre][0] = __EPSP.EXTR_COMP('EPXX', [], 0).valeurs
EP[ordre][1] = __EPSP.EXTR_COMP('EPYY', [], 0).valeurs
EP[ordre][2] = __EPSP.EXTR_COMP('EPZZ', [], 0).valeurs
EP[ordre][3] = __EPSP.EXTR_COMP('EPXY', [], 0).valeurs
if ndim == 3:
EP[ordre][4] = __EPSP.EXTR_COMP('EPXZ', [], 0).valeurs
EP[ordre][5] = __EPSP.EXTR_COMP('EPYZ', [], 0).valeurs
nval = len(PRIN[ordre])
nval2 = len(EP[ordre][0])
if nval2 != nval:
UTMESS('F', 'RUPTURE1_54')
if ndim == 3:
EPEQ[ordre] = NP.sqrt(
2. / 3. * (EP[ordre][0]**2 + EP[ordre][1]**2 +
EP[ordre][2]**2 + 2. * EP[ordre][3]**2 +
2. * EP[ordre][4]**2 + 2. * EP[ordre][5]**2))
elif ndim == 2:
EPEQ[ordre] = NP.sqrt(2. / 3. *
(EP[ordre][0]**2 + EP[ordre][1]**2 +
EP[ordre][2]**2 + 2. * EP[ordre][3]**2))
# Construction des champs barre et des champs de vitesse
EQ_PT2[list_ordre[0]] = NP.zeros([nval])
EPEQ[ordre] = NP.array(EPEQ[ordre])
if ordre != list_ordre[0]:
dt = list_inst[ordre] - list_inst[ordre - 1]
if dt == 0:
UTMESS('F', 'RUPTURE1_55')
EPEQM[ordre] = EPEQ[ordre - 1]
EQ_BAR[ordre] = (EPEQ[ordre] + EPEQ[ordre - 1]) / 2.
EQ_PT2[ordre] = (EPEQ[ordre] - EPEQ[ordre - 1]) / (2 * dt)
EQ_PT[ordre] = EQ_PT2[ordre - 1] + EQ_PT2[ordre]
DEP[ordre] = EPEQ[ordre] - EPEQ[ordre - 1]
PR_BAR[ordre] = (PRIN[ordre] + PRIN[ordre - 1]) / 2.
if type(PARAM['SEUIL_CALC']) == fonction_sdaster:
sigy = PARAM['SEUIL_CALC'](tempe)
elif type(PARAM['SEUIL_CALC']) == nappe_sdaster:
EQ_PT[ordre] = list(EQ_PT[ordre])
__TAB = CREA_TABLE(LISTE=(_F(
PARA='EPSI',
LISTE_R=EQ_PT[ordre],
), ), )
__TAB = CALC_TABLE(
TABLE=__TAB,
reuse=__TAB,
ACTION=_F(OPERATION='OPER',
FORMULE=__NPY,
NOM_PARA='TSIGY'),
)
sigy = __TAB.EXTR_TABLE().values()['TSIGY']
sigy = NP.array(sigy)
T1 = sigy / sig0 * (PR_BAR[ordre]**m - sigth**m)
T1 = list(T1)
__TABT1 = CREA_TABLE(LISTE=(_F(
PARA='T1',
LISTE_R=T1,
), ))
__TABT1 = CALC_TABLE(
TABLE=__TABT1,
reuse=__TABT1,
ACTION=_F(OPERATION='OPER', FORMULE=__MAXI, NOM_PARA='T1BIS'),
)
T1 = __TABT1.EXTR_TABLE().values()['T1BIS']
T1 = NP.array(T1)
if PROBA_NUCL == 'OUI':
T2 = NP.exp(-sigy / sig0 * EQ_BAR[ordre] / ep0)
elif PROBA_NUCL == 'NON':
T2 = 1.
T3 = DEP[ordre]
T4 = vol.valeurs / V0
BORDTI = BORDTI + NP.cumsum(T1 * T2 * T3 * T4)[-1]
BORDTT[ordre] = (c_mult * BORDTI)**(1 / m)
if sigref(tempe) != 0.:
PROBA[ordre] = 1 - NP.exp(-(BORDTT[ordre] / sigref(tempe))**m)
elif sigref(tempe) == 0.:
UTMESS('F', 'RUPTURE1_56', valr=list_inst[ordre])
tabout = CREA_TABLE(LISTE=(
_F(PARA='INST', LISTE_R=list_inst[0:nume_ordre + 1]),
_F(
PARA='SIG_BORDET',
LISTE_R=BORDTT,
),
_F(
PARA='PROBA_BORDET',
LISTE_R=PROBA,
),
), )
return tabout
def post_liquefaction_ops(self, AXE, RESULTAT, CRITERE, **args):
### On importe les definitions des commandes a utiliser dans la macro
### RECUPERATION DU MODELE A PARTIR DU RESULTAT
if CRITERE != 'P_SIGM':
INST_REF = args['INST_REF']
RESU_REF = args['RESU_REF']
# modele
__model = RESULTAT.getModel()
### Pour les 3 criteres , les formules sont X4=(X3-X1)/X2
### X4 est le resultat, X2 le denominateur.
### On commence par calculer X1 et X2 pour les 3 cas
if CRITERE != 'P_SIGM':
### Extraction du champ SIEF_ELGA a la fin de l'etat reference INST_REF
__sigini = CREA_CHAMP(
OPERATION='EXTR',
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=RESU_REF,
NOM_CHAM='SIEF_ELGA',
INST=INST_REF,
)
### Séparation des cas car le dénominateur (X2) est différent.
### Calcul de la pression de référence et de la contrainte de référence
### Transformation des champs SIP(tref) et SIYY(tref) en champs de type NEUT
if AXE == 'X':
__sig1 = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
PROL_ZERO='OUI',
MODELE=__model,
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigini,
NOM_CMP=('SIPXX', 'SIXX', 'SIYY', 'SIZZ'),
NOM_CMP_RESU=('X1', 'X2', 'X5', 'X6'),
),
)
### Le choix des noms X5 et X6 a ete fait pour avoir X1,X2,X3 et X4 commun aux cas
elif AXE == 'Y':
__sig1 = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
PROL_ZERO='OUI',
MODELE=__model,
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigini,
NOM_CMP=('SIPYY', 'SIYY', 'SIXX', 'SIZZ'),
NOM_CMP_RESU=('X1', 'X2', 'X5', 'X6'),
),
)
elif AXE == 'Z':
__sig1 = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
PROL_ZERO='OUI',
MODELE=__model,
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigini,
NOM_CMP=('SIPZZ', 'SIZZ', 'SIXX', 'SIYY'),
NOM_CMP_RESU=('X1', 'X2', 'X5', 'X6'),
),
)
### Formule pour evaluer le critere de liquefaction (qui vaut 0 si jamais SIYY(tref) vaut 0)
### CAS DP_SIGV_REF
if CRITERE == 'DP_SIGV_REF':
def fmul(x, y, z, v, w):
if abs(y) <= 1e-12:
resu = 0.0
else:
resu = (z - x) / y
return resu
### CAS DP_SIGM_REF
if CRITERE == 'DP_SIGM_REF':
def fmul(x, y, z, v, w):
if abs(y + v + w) <= 1e-12:
resu = 0.0
else:
resu = (z - x) / ((y + v + w) / 3.)
return resu
### CAS DP
if CRITERE == 'DP':
def fmul(x, y, z, v, w):
resu = (z - x)
return resu
__fmul = FORMULE(NOM_PARA=('X1', 'X2', 'X3', 'X5', 'X6'),
VALE='fmul0(X1,X2,X3,X5,X6)',
fmul0=fmul)
__chfmu = CREA_CHAMP(
OPERATION='AFFE',
TYPE_CHAM='ELGA_NEUT_F',
MODELE=__model,
PROL_ZERO='OUI',
AFFE=_F(TOUT='OUI', NOM_CMP='X4', VALE_F=__fmul),
)
### Acces aux numeros d'ordre de RESULTAT pour l'indicage de la boucle
__dico = aster.GetResu(RESULTAT.getName(), "VARI_ACCES")
__numo = __dico['NUME_ORDRE']
__n = __numo[-1]
### Initialisation des variables de la boucle
__liqq = [None] * (__n + 1)
__sigf = [None] * (__n + 1)
__siff = [None] * (__n + 1)
if CRITERE != 'P_SIGM':
for i, ordre in enumerate(__numo):
### Extraction du champ SIEF_ELGA
__sigt = CREA_CHAMP(
OPERATION='EXTR',
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=RESULTAT,
NOM_CHAM='SIEF_ELGA',
NUME_ORDRE=ordre,
)
### Transformation du champ SIP(t) en champ de type NEUT
if AXE == 'X':
__sig2 = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=__model,
PROL_ZERO='OUI',
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigt,
NOM_CMP=('SIPXX', ),
NOM_CMP_RESU=('X3', ),
),
)
elif AXE == 'Y':
__sig2 = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=__model,
PROL_ZERO='OUI',
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigt,
NOM_CMP=('SIPYY', ),
NOM_CMP_RESU=('X3', ),
),
)
elif AXE == 'Z':
__sig2 = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=__model,
PROL_ZERO='OUI',
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigt,
NOM_CMP=('SIPZZ', ),
NOM_CMP_RESU=('X3', ),
),
)
### Assemblage de SIP(t0),SIYY(t0) et SIP(t) dans le meme champ SIG
__sig = CREA_CHAMP(
OPERATION='ASSE',
MODELE=__model,
TYPE_CHAM='ELGA_NEUT_R',
ASSE=(
_F(CHAM_GD=__sig1, TOUT='OUI', CUMUL='OUI', COEF_R=1.),
_F(CHAM_GD=__sig2, TOUT='OUI', CUMUL='OUI', COEF_R=1.),
),
)
### Calcul du critere de liquefaction
__liqq[i] = CREA_CHAMP(
OPERATION='EVAL',
TYPE_CHAM='ELGA_NEUT_R',
CHAM_F=__chfmu,
CHAM_PARA=(__sig, ),
)
### Creation d'un champ contenant le resultat du calcul
__sigf[i] = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=__model,
PROL_ZERO='OUI',
ASSE=_F(
TOUT='OUI',
CHAM_GD=__liqq[i],
NOM_CMP=('X4', ),
NOM_CMP_RESU=('X4', ),
),
)
elif CRITERE == 'P_SIGM':
def fmul0(y, z, v, w):
if abs(y + v + w) <= 1e-12:
resu = 0.0
else:
resu = (z) / ((y + v + w) / 3.)
return resu
__fmul = FORMULE(NOM_PARA=('X2', 'X3', 'X5', 'X6'),
VALE='fmul0(X2,X3,X5,X6)',
fmul0=fmul0)
__chfmu = CREA_CHAMP(
OPERATION='AFFE',
TYPE_CHAM='ELGA_NEUT_F',
MODELE=__model,
PROL_ZERO='OUI',
AFFE=_F(TOUT='OUI', NOM_CMP='X4', VALE_F=__fmul),
)
for i, ordre in enumerate(__numo):
### Extraction du champ SIEF_ELGA
__sigt = CREA_CHAMP(
OPERATION='EXTR',
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=RESULTAT,
NOM_CHAM='SIEF_ELGA',
NUME_ORDRE=ordre,
)
### Transformation du champ SIP(t) en champ de type NEUT
if AXE == 'X':
__sig = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=__model,
PROL_ZERO='OUI',
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigt,
NOM_CMP=('SIXX', 'SIPXX', 'SIYY', 'SIZZ'),
NOM_CMP_RESU=('X2', 'X3', 'X5', 'X6'),
),
)
elif AXE == 'Y':
__sig = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=__model,
PROL_ZERO='OUI',
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigt,
NOM_CMP=('SIYY', 'SIPYY', 'SIXX', 'SIZZ'),
NOM_CMP_RESU=('X2', 'X3', 'X5', 'X6'),
),
)
elif AXE == 'Z':
__sig = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=__model,
PROL_ZERO='OUI',
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigt,
NOM_CMP=('SIZZ', 'SIPZZ', 'SIXX', 'SIYY'),
NOM_CMP_RESU=('X2', 'X3', 'X5', 'X6'),
),
)
### Calcul du critere de liquefaction
__liqq[i] = CREA_CHAMP(
OPERATION='EVAL',
TYPE_CHAM='ELGA_NEUT_R',
CHAM_F=__chfmu,
CHAM_PARA=(__sig, ),
)
### Creation d'un champ contenant le resultat du calcul
__sigf[i] = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=__model,
PROL_ZERO='OUI',
ASSE=_F(
TOUT='OUI',
CHAM_GD=__liqq[i],
NOM_CMP=('X4', ),
NOM_CMP_RESU=('X4', ),
),
)
for i, ordre in enumerate(__numo):
### Transformer le champ SIGF de type NEUT en champ de type SIEF_ELGA (sous la variable SIP)
if AXE == 'X':
__siff[i] = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_SIEF_R',
PROL_ZERO='OUI',
MODELE=__model,
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigf[i],
NOM_CMP=('X4', ),
NOM_CMP_RESU=('SIPXX', ),
),
)
if AXE == 'Y':
__siff[i] = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_SIEF_R',
PROL_ZERO='OUI',
MODELE=__model,
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigf[i],
NOM_CMP=('X4', ),
NOM_CMP_RESU=('SIPYY', ),
),
)
if AXE == 'Z':
__siff[i] = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELGA_SIEF_R',
PROL_ZERO='OUI',
MODELE=__model,
ASSE=_F(
TOUT='OUI',
CHAM_GD=__sigf[i],
NOM_CMP=('X4', ),
NOM_CMP_RESU=('SIPZZ', ),
),
)
###-------------
### FIN BOUCLE
###-------------
# Acces aux instants de RESULTAT pour creer la nouvelle SD resultat LIQ
__numo2 = __dico['INST']
__liste = []
for k, linst in enumerate(__numo2):
__liste.append(_F(
CHAM_GD=__siff[k],
MODELE=__model,
INST=linst,
), )
LIQ = CREA_RESU(
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='SIEF_ELGA',
AFFE=(__liste),
)
return LIQ
def post_decollement_ops(self, RESULTAT, NOM_CHAM, NOM_CMP, GROUP_MA, INFO,
**args):
"""
Corps de la macro POST_DECOLLEMENT
"""
# On importe les definitions des commandes a utiliser dans la macro
# on recupere le concept maillage
MAILLAGE = RESULTAT.getModel().getMesh()
# 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 = aster.GetResu(RESULTAT.getName(), "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 C_out
def dyna_visco_modes(self, TYPE_RESU, TYPE_MODE, list_FREQ, fmax, RESI_RELA,
MATER_ELAS_FO, __asseKg, __asseKgr, __asseMg, trKg,
__listKv, e0, eta0, ltrv, **args):
"""
Macro-command DYNA_VISCO,
function to compute the eigenmodes of the structure
"""
i = 0
nmode = 5
# EIGENMODES COMPUTATION
freq1 = list_FREQ[0]
# search for the 1st eigenfrequency
j = 0
[_modes, freq1,
nmode] = dyna_visco_modes_calc(self, TYPE_MODE, freq1, nmode, RESI_RELA,
i, j, MATER_ELAS_FO, e0, eta0, __asseMg,
__asseKgr, __asseKg, __listKv, trKg, ltrv,
TYPE_RESU, **args)
# search for following eigenfrequencies
while freq1 <= fmax:
j = j + 1
[_modes, freq1, nmode] = dyna_visco_modes_calc(self,
TYPE_MODE,
freq1,
nmode,
RESI_RELA,
i,
j,
MATER_ELAS_FO,
e0,
eta0,
__asseMg,
__asseKgr,
__asseKg,
__listKv,
trKg,
ltrv,
TYPE_RESU,
reuse='oui',
co_reuse=_modes,
**args)
if TYPE_MODE in ['REEL', 'BETA_REEL']:
__modes_temp = EXTR_MODE(FILTRE_MODE=_F(MODE=_modes,
TOUT_ORDRE='OUI'), )
DETRUIRE(CONCEPT=_F(NOM=_modes))
_modes = DEFI_BASE_MODALE(ORTHO_BASE=_F(
BASE=__modes_temp,
MATRICE=__asseMg,
), )
#########################################################
# PRINTING OF THE EIGENMODES
UTMESS('I', 'DYNAVISCO_3')
eigenfreq = aster.GetResu(_modes.getName(), "VARI_ACCES")['FREQ']
if TYPE_MODE in ['REEL', 'BETA_REEL']:
UTMESS('I', 'DYNAVISCO_4')
if TYPE_MODE == 'COMPLEXE':
eigendamping = aster.GetResu(_modes.getName(),
"PARAMETRES")['AMOR_REDUIT']
UTMESS('I', 'DYNAVISCO_6')
for k in range(0, len(eigenfreq)):
if TYPE_MODE in ['REEL', 'BETA_REEL']:
UTMESS('I', 'DYNAVISCO_5', vali=k + 1, valr=eigenfreq[k])
if TYPE_MODE == 'COMPLEXE':
UTMESS('I',
'DYNAVISCO_7',
vali=k + 1,
valr=(eigenfreq[k], eigendamping[k]))
return _modes
def post_czm_fiss_ops(self, OPTION, RESULTAT, **args):
"""Corps de POST_CZM_FISS"""
#
# calcul de la longueur d'une fissure cohesive 2D
#
if OPTION == "LONGUEUR":
# Mots cles specifiques au bloc "LONGUEUR"
GROUP_MA = args['GROUP_MA']
POINT_ORIG = args['POINT_ORIG']
VECT_TANG = args['VECT_TANG']
# On importe les definitions des commandes a utiliser dans la macro
# Recuperation du nom du modele
__MODEL = RESULTAT.getModel()
if __MODEL is None:
UTMESS('F', 'RUPTURE0_18')
# Calcul des coordonnees des points de Gauss
__CHAMEL = CALC_CHAM_ELEM(MODELE=__MODEL,
GROUP_MA=GROUP_MA,
OPTION='COOR_ELGA')
__CORX = __CHAMEL.EXTR_COMP('X', list(GROUP_MA), 1)
__CORY = __CHAMEL.EXTR_COMP('Y', list(GROUP_MA), 1)
xg = __CORX.valeurs
yg = __CORY.valeurs
nbpg = len(xg)
xmin = min(xg)
ymin = min(yg)
xmax = max(xg)
ymax = max(yg)
# A = coef dir et B=ordo orig de la droite des pg
A = (ymax - ymin) / (xmax - xmin)
B = ymax - A * xmax
# Vecteur des points de gauss (qui va du point min au point max) et sa
# norme
vx = xmax - xmin
vy = ymax - ymin
nv = (vx**2 + vy**2)**0.5
# vecteur directeur dans la direction ou l'on calcule la longueur
xdir = VECT_TANG[0]
ydir = VECT_TANG[1]
ndir = (xdir**2 + ydir**2)**0.5
# point de reference a partir duquel on calcule la longueur
xref = POINT_ORIG[0]
yref = POINT_ORIG[1]
# angle entre le vecteur des points de gauss et le vecteur donne par
# l'utilisateur
alpha = acos((xdir * vx + ydir * vy) / (ndir * nv))
# petit parametre de tolerence
eps = 0.0001
# cas ou le point de reference n'est pas aligne avec les points de
# Gauss
if (abs(yref - A * xref - B) >= eps):
UTMESS('F',
'POST0_45',
valk=list(GROUP_MA),
valr=(xmin, xmax, ymin, ymax))
# cas ou le vecteur n'est pas colineaire a la droite des points de
# Gauss
if (abs(alpha) >= eps) and (abs(alpha - pi) >= eps):
UTMESS('F',
'POST0_46',
valk=list(GROUP_MA),
valr=(xmin, xmax, ymin, ymax))
# Calcul de la distance signee des points de Gauss au point de
# reference
disg = distance(xg, yg, xref, yref, xdir, ydir)
ming = min(disg)
maxg = max(disg)
__INST = aster.GetResu(RESULTAT.getName(), "VARI_ACCES")['INST']
nbinst = len(__INST)
Lfis = [0] * (nbinst)
Ltot = [0] * (nbinst)
Lcoh = [0] * (nbinst)
__VI = [0] * (nbinst)
for j in range(0, nbinst):
__VI[j] = CREA_CHAMP(
TYPE_CHAM='ELGA_VARI_R',
OPERATION='EXTR',
RESULTAT=RESULTAT,
NOM_CHAM='VARI_ELGA',
NUME_ORDRE=j,
)
__VI3 = __VI[j].EXTR_COMP('V3', list(GROUP_MA), 1)
mat_v3 = __VI3.valeurs
nbpg = len(mat_v3)
# Evaluation du nombre de points de gauss dans chaque etat
cpt0 = 0
cpt1 = 0
cpt2 = 0
max0 = ming
min0 = maxg
max1 = ming
min1 = maxg
max2 = ming
min2 = maxg
for i in range(0, nbpg):
if (disg[i] >= 0.0):
if mat_v3[i] == 1.: # si c'est un pdg en zone cohesive
cpt1 = cpt1 + 1
max1 = max(max1, disg[i])
min1 = min(min1, disg[i])
else:
if mat_v3[i] == 2.: # si c'est un pdg en fissure
cpt2 = cpt2 + 1
max2 = max(max2, disg[i])
min2 = min(min2, disg[i])
else:
if mat_v3[i] == 0.: # si c'est un pdg sain
cpt0 = cpt0 + 1
max0 = max(max0, disg[i])
min0 = min(min0, disg[i])
# verification qu'entre min1 et max1 on a que des mailles 1
for i in range(0, nbpg):
if (cpt1 != 0):
if (disg[i] >= min1) and (disg[i] <= max1):
if (mat_v3[i] != 1.):
UTMESS('A', 'POST0_48')
# Verification qu'il y a bien des points de Gauss sur la
# demi-droite definie par l'utilisateur
if (cpt0 + cpt1 + cpt2 == 0):
UTMESS('F',
'POST0_47',
valk=list(GROUP_MA),
valr=(xmin, xmax, ymin, ymax))
# Verification de la taille de la zone cohesive
if (cpt2 != 0) and (cpt1 <= 3):
UTMESS('A', 'POST0_49')
# Evaluation des longueurs
if (cpt1 == 0) and (cpt2 == 0):
Ltot[j] = min0
Lfis[j] = min0
else:
if (cpt1 != 0) and (cpt2 == 0):
Ltot[j] = (min0 + max1) / 2.0
Lfis[j] = min1
else:
if (cpt1 == 0) and (cpt2 != 0):
Ltot[j] = (min0 + max2) / 2.0
Lfis[j] = (min0 + max2) / 2.0
else:
Ltot[j] = (min0 + max1) / 2.0
Lfis[j] = (min1 + max2) / 2.0
Lcoh[j] = Ltot[j] - Lfis[j]
DETRUIRE(CONCEPT=_F(NOM=__VI[j]))
TABLE_OUT = CREA_TABLE(LISTE=(
_F(LISTE_R=__INST, PARA='INST'),
_F(LISTE_R=Lfis, PARA='LONG_FIS'),
_F(LISTE_R=Ltot, PARA='LONG_TOT'),
_F(LISTE_R=Lcoh, PARA='LONG_COH'),
), )
return TABLE_OUT
#
# calcul de la triaxialite dans les elements massifs voisins de l'interface cohesive
#
elif OPTION == "TRIAXIALITE":
CARTE_OUT = POST_VOISIN_CZM(RESULTAT=RESULTAT)
return CARTE_OUT