def Calc_champ(champ, contexte, numeros, phenomene, options=None):
para = {
'reuse': contexte.resultat,
'RESULTAT': contexte.resultat,
'MODELE': contexte.modele,
#'OPTION' : champ.nom,
'CHAM_MATER': contexte.cham_mater,
'NUME_ORDRE': tuple(numeros),
phenomene: champ.nom
}
if contexte.cara_elem:
para['CARA_ELEM'] = contexte.cara_elem
# Options supplementaires passees a la commande
if options:
for cle in options.keys():
para[cle] = options[cle]
# Lancement de la commande
try:
CALC_CHAMP(**para)
except aster.error, err:
UTMESS('A', 'STANLEY_4', valk=[str(err)])
def dechargePSC(self, RESU):
from code_aster.Cata.Commands import (CALC_CHAMP, POST_RELEVE_T,
DEFI_FONCTION, AFFE_CHAR_MECA)
coeur = self.coeur
CALC_CHAMP(
reuse=RESU,
RESULTAT=RESU,
INST=coeur.temps_simu['T8'],
FORCE=('FORC_NODA', ),
)
__SPRING = POST_RELEVE_T(ACTION=_F(
INTITULE='FORCES',
GROUP_NO=('PMNT_S'),
RESULTAT=RESU,
NOM_CHAM='FORC_NODA',
NOM_CMP=('DX', ),
REPERE='GLOBAL',
OPERATION='EXTRACTION',
), )
tab2 = __SPRING.EXTR_TABLE()
valeurs = tab2.values()
inst = valeurs['INST'][-1]
fx = valeurs['DX']
noeuds = valeurs['NOEUD']
listarg = []
for el in zip(fx, noeuds):
listarg.append(_F(NOEUD=el[1], FX=el[0]))
assert (inst == coeur.temps_simu['T8'])
_LI2 = DEFI_FONCTION(
NOM_PARA='INST',
PROL_DROITE='CONSTANT',
VALE=(coeur.temps_simu['T8'], 1., coeur.temps_simu['T8b'], 0.),
)
_F_EMB2 = AFFE_CHAR_MECA(
MODELE=self.model,
FORCE_NODALE=listarg,
)
return (_LI2, _F_EMB2)
def compute_nodal_reaction_from_field_on_group(field,
model,
mat,
group,
charg,
char_cine=None):
"""
Compute nodal reaction from a displacement field on a specific group.
Input:
-field: aster displacement field
-model: aster model,
-mat: assigned material on a mesh
-char_cine: dirichlet boundary conditions
-group: group where the nodal reaction has to be computed
Output:
-asterField instance
"""
### Create result concept from the displacement field
#resu = create_resu(field,model,mat,char_cine)
if char_cine:
resu = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_ELAS',
NOM_CHAM='DEPL',
EXCIT=_F(CHARGE=charg),
AFFE=_F(
CHAM_GD=field,
MODELE=model,
CHAM_MATER=mat,
INST=0.,
))
else:
resu = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_ELAS',
NOM_CHAM='DEPL',
AFFE=_F(
CHAM_GD=field,
MODELE=model,
CHAM_MATER=mat,
INST=0.,
))
resu = CALC_CHAMP(
FORCE='REAC_NODA',
reuse=resu,
MODELE=model,
CHAM_MATER=mat,
EXCIT=_F(CHARGE=charg),
TOUT='OUI',
RESULTAT=resu,
)
AsterIter = AsterCount.__next__()
o[AsterIter] = CREA_CHAMP(
OPERATION='EXTR',
NOM_CHAM='REAC_NODA',
TYPE_CHAM='NOEU_DEPL_R',
RESULTAT=resu,
INST=0.,
)
nodalrea = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='NOEU_DEPL_R',
MODELE=model,
ASSE=_F(CHAM_GD=o[AsterIter], GROUP_MA=group),
)
DETRUIRE(CONCEPT=(_F(NOM=nodalrea), _F(NOM=resu)))
return o[AsterIter]
def char_grad_impo_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME,
Ctot0, CHARGRD0, Vh, R, T, INFO, **args):
# macro pour calculer le chargement thermique specfique a la diffusion H2
import numpy as NP
import aster
from code_aster.Cata.Syntax import _F
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant dans le contexte de la macro
self.DeclareOut('chth', self.sd)
# On importe les definitions des commandes a utiliser dans la macro
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
AFFE_CHAR_THER = self.get_cmd('AFFE_CHAR_THER')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
CALC_CHAM_ELEM = self.get_cmd('CALC_CHAM_ELEM')
dt = TFIN - TINIT
# Recuperation du modele a partir du resultat
iret, ibid, __n_modele = aster.dismoi('MODELE', RESU_H2.nom, 'RESULTAT',
'F')
__n_modele = __n_modele.rstrip()
__MOTH = self.get_concept(__n_modele)
# Recuperation du maillage a partir du resultat
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', RESU_H2.nom, 'RESULTAT',
'F')
__MAIL = self.get_concept(nom_ma.strip())
# Recuperation du modele mecanique a partir du resultat
iret, ibid, nom_momec = aster.dismoi('MODELE', RESUMECA.nom, 'RESULTAT',
'F')
__MOME = self.get_concept(nom_momec.rstrip())
# extraction du champ de cl instant -
__C20 = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_TEMP_R',
RESULTAT=RESU_H2,
NOM_CHAM='TEMP',
INST=TINIT,
INFO=INFO)
# on suppose que les noeuds du maillage thermique et mecaniqeu sont les
# memes (pour eviter un PROJ_CHAMP)
lc_t0 = __C20.EXTR_COMP('TEMP', [], 1)
c_t0 = lc_t0.valeurs
node_th = lc_t0.noeud
nbnode = len(node_th)
# contruction du terme Grad SigmaH
# trace de sigma aux noeuds
__SIEQN2 = CALC_CHAMP(INST=TFIN,
RESULTAT=RESUMECA,
CRITERES='SIEQ_NOEU',
INFO=INFO)
__SIEQN = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=__SIEQN2,
MODELE_1=__MOME,
MODELE_2=__MOTH,
NOM_CHAM='SIEQ_NOEU',
TOUT_ORDRE='OUI')
__SIEQ = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_SIEF_R',
RESULTAT=__SIEQN,
NOM_CHAM='SIEQ_NOEU',
INST=TFIN,
INFO=INFO)
# on renome la CMP pour pouvoir calculer le flux "thermique"
__TRSIG = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='NOEU_TEMP_R',
MODELE=__MOTH,
ASSE=(_F(CHAM_GD=__SIEQ,
GROUP_MA=GRMAVOL,
NOM_CMP='TRSIG',
NOM_CMP_RESU='TEMP',
COEF_R=1. / 3.), ),
INFO=INFO)
# calcul du gradient de Trace(Sigma)
__MAT1 = DEFI_MATERIAU(THER=_F(LAMBDA=-1., RHO_CP=0.))
__CMT1 = AFFE_MATERIAU(
MAILLAGE=__MAIL,
AFFE=_F(
TOUT='OUI',
MATER=__MAT1,
),
)
__GRSH = CALC_CHAM_ELEM(MODELE=__MOTH,
CHAM_MATER=__CMT1,
GROUP_MA=GRMAVOL,
OPTION='FLUX_ELGA',
TEMP=__TRSIG)
gradsighe = __GRSH.EXTR_COMP('FLUX', [], 1)
gradsighx = gradsighe.valeurs
gradsighy = __GRSH.EXTR_COMP('FLUY', [], 0).valeurs
if (DIME == 3):
gradsighz = __GRSH.EXTR_COMP('FLUZ', [], 0).valeurs
fx = NP.zeros(nbnode)
fy = NP.zeros(nbnode)
if (DIME == 3):
fz = NP.zeros(nbnode)
for ino, node in enumerate(node_th):
cl = c_t0[ino]
grsigx = gradsighx[ino]
grsigy = gradsighy[ino]
if (DIME == 3):
grsigz = gradsighz[ino]
fx[ino], fx[ino], fz[ino] = FLUX(cl, grsigx, grsigy, DIME, grsigz,
Vh, R, T)
else:
grsigz = 0.
fx[ino], fx[ino] = FLUX(cl, grsigx, grsigy, DIME, grsigz, Vh, R, T)
# pour gagner du temps on evite la construction du mot-cle PRE_GRAD_TEMP
nomvale = CHARGRD0.nom.ljust(8) + '.CHTH.GRAIN.VALE'
nomlima = CHARGRD0.nom.ljust(8) + '.CHTH.GRAIN.LIMA'
nomdesc = CHARGRD0.nom.ljust(8) + '.CHTH.GRAIN.DESC'
tabvale = aster.getvectjev(nomvale)
tabdesc = aster.getvectjev(nomdesc)
dicolima = aster.getcolljev(nomlima)
nbrvale = len(tabvale)
champ = NP.zeros(nbrvale)
bidon = NP.zeros(nbrvale)
nommai = __MAIL.sdj.NOMMAI.get()
connex = __MAIL.sdj.CONNEX.get()
groupma = __MAIL.sdj.GROUPEMA.get()[GRMAVOL.ljust(24)]
nbzone = tabdesc[1]
# print "tabdesc",tabdesc
# print "tablima",dicolima
for izone in dicolima.keys():
# chaque maille du groupe est affectee
for index, ima in enumerate(dicolima[izone]):
if ima == 0:
break
if ima in groupma:
# ATTENTION : dans Python, les tableaux commencent a 0
# mais dans la connectivite, les noeuds commencent a 1!
lnoeu = NP.array(connex[ima]) - 1
nbno = len(lnoeu)
# calcul de la moyenne par maille de fx
lflux = fx[lnoeu]
flux = NP.add.reduce(lflux)
flux = flux / nbno
lfluy = fy[lnoeu]
fluy = NP.add.reduce(lfluy)
fluy = fluy / nbno
numa = index
# print 'essai, numa, ima',numa, ima, groupma, lnoeu, nbno
champ[9 * (numa - 1) + 1] = -flux
champ[9 * (numa - 1) + 2] = -fluy
aster.putvectjev(nomvale, nbrvale, tuple(range(1, nbrvale + 1)),
tuple(champ), tuple(bidon), 1)
def champ_detoile_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME,
Ctot0, Nl, Kt, a1, a2, a3, INFO, **args):
# macro pour calculer le chargement thermique specfique a la diffusion H2
import numpy as NP
import aster
from code_aster.Cata.Syntax import _F
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant dans le contexte de la macro
self.DeclareOut('NEUTG', self.sd)
# On importe les definitions des commandes a utiliser dans la macro
DETRUIRE = self.get_cmd('DETRUIRE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
# Recuperation du modele a partir du resultat
iret, ibid, __n_modele = aster.dismoi('MODELE', RESU_H2.nom, 'RESULTAT',
'F')
__n_modele = __n_modele.rstrip()
__MOTH = self.get_concept(__n_modele)
# Recuperation du maillage a partir du resultat
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', RESU_H2.nom, 'RESULTAT',
'F')
__MAIL = self.get_concept(nom_ma.strip())
# Recuperation du modele mecanique a partir du resultat
iret, ibid, nom_momec = aster.dismoi('MODELE', RESUMECA.nom, 'RESULTAT',
'F')
__MOME = self.get_concept(nom_momec.rstrip())
# extraction du champ de Cl instant -
__C20 = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_TEMP_R',
RESULTAT=RESU_H2,
NOM_CHAM='TEMP',
INST=TINIT,
INFO=INFO)
__EPEQN2 = CALC_CHAMP(INST=(TINIT, TFIN),
RESULTAT=RESUMECA,
VARI_INTERNE='VARI_NOEU')
__EPEQN = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=__EPEQN2,
MODELE_1=__MOME,
MODELE_2=__MOTH,
NOM_CHAM='VARI_NOEU',
TOUT_ORDRE='OUI')
__VINT1 = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_VAR2_R',
RESULTAT=__EPEQN,
NOM_CHAM='VARI_NOEU',
INST=TFIN,
INFO=INFO)
# recopie du champ C20 pour initialiser le futur champ source
__chtmp = CREA_CHAMP(OPERATION='AFFE',
TYPE_CHAM='NOEU_NEUT_R',
MAILLAGE=__MAIL,
AFFE=(_F(
VALE=0.,
GROUP_MA=GRMAVOL,
NOM_CMP='X1',
), ))
nomcham = __chtmp.sdj.nomj()
# on suppose que les noeuds du maillage thermique et mecaniqeu sont les
# memes (pour eviter un PROJ_CHAMP)
lc_t0 = __C20.EXTR_COMP('TEMP', [], 1)
c_t0 = lc_t0.valeurs
node_th = lc_t0.noeud
lp_t1 = __VINT1.EXTR_COMP('V1', [], 1)
p_t1 = lp_t1.valeurs
node_me = lp_t1.noeud
nbnode = len(node_th)
assert (nbnode == len(node_me))
detoile = NP.zeros(nbnode)
bidon = NP.zeros(nbnode)
for ino, node in enumerate(node_th):
Cl = c_t0[ino]
p1 = p_t1[ino]
detoile[ino] = DETOILE(Cl, p1, Ctot0, Nl, Kt, a1, a2, a3)
nomvect = '%-19s.VALE' % __chtmp.nom
aster.putvectjev(nomvect, nbnode, tuple(range(1, nbnode + 1)),
tuple(detoile), tuple(bidon), 1)
NEUTG = CREA_CHAMP(OPERATION='DISC',
TYPE_CHAM='ELNO_NEUT_R',
MODELE=__MOTH,
PROL_ZERO='OUI',
CHAM_GD=__chtmp,
INFO=INFO)
def tr_a2e_vmis_john_cook(__VARICO, ico, gr_ma, mod, __VARI, nume_ordre, resu):
"""
Transformation pour VMIS_JOHN_COOK ASTER vers EPX
"""
CALC_CHAMP(reuse=resu,
RESULTAT=resu,
CRITERES='SIEQ_ELGA',
NUME_ORDRE=nume_ordre)
CALC_CHAMP(reuse=resu,
CHAM_UTIL=_F(NOM_CHAM='SIEF_ELGA',
CRITERE='TRACE',
NUME_CHAM_RESU=1),
NUME_ORDRE=nume_ordre,
RESULTAT=resu)
__TRACE = CREA_CHAMP(
OPERATION='EXTR',
TYPE_CHAM='ELGA_NEUT_R',
RESULTAT=resu,
NOM_CHAM='UT01_ELGA',
PROL_ZERO='OUI',
NUME_ORDRE=nume_ordre,
)
__VMIS = CREA_CHAMP(
OPERATION='EXTR',
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=resu,
NOM_CHAM='SIEQ_ELGA',
NUME_ORDRE=nume_ordre,
)
#cel =numpy.sqrt(E_b*(1-Nu_b)/(rho_b*(1+Nu_b)*(1-2*Nu_b)))
__AFFE = CREA_CHAMP(
OPERATION='AFFE',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=mod,
PROL_ZERO='OUI',
AFFE=(
_F(
GROUP_MA=gr_ma,
NOM_CMP=('X1', 'X2', 'X3', 'X4', 'X5'),
#VALE=(1.0E-6, cel, 0.,0.,0.)),
VALE=(1.0E-6, 0., 0., 0., 0.)), ))
__VARICO[ico] = CREA_CHAMP(
OPERATION='ASSE',
MODELE=mod,
TYPE_CHAM='ELGA_VARI_R',
PROL_ZERO='OUI',
ASSE=(
_F(
CHAM_GD=__TRACE,
GROUP_MA=gr_ma,
NOM_CMP='X1',
NOM_CMP_RESU='V1',
COEF_R=1.0 / 3,
),
_F(
CHAM_GD=__VMIS,
GROUP_MA=gr_ma,
NOM_CMP='VMIS',
NOM_CMP_RESU='V2',
),
_F(
CHAM_GD=__VARI,
GROUP_MA=gr_ma,
NOM_CMP='V1',
NOM_CMP_RESU='V3',
),
_F(
CHAM_GD=__VMIS,
GROUP_MA=gr_ma,
NOM_CMP='VMIS',
NOM_CMP_RESU='V4',
),
_F(
CHAM_GD=__AFFE,
GROUP_MA=gr_ma,
NOM_CMP=('X1', 'X2', 'X3', 'X4', 'X5'),
NOM_CMP_RESU=('V4', 'V5', 'V6', 'V7', 'V8'),
CUMUL='OUI',
),
),
)