def RECU_VECT_GENE_C(self, vecteur):
""" envoie les valeurs d'un tableau numpy dans un vecteur generalise
complexe definie dans jeveux
Attributs ne retourne rien """
if not self.accessible():
raise AsException(
"Erreur dans vect_asse_gene_c.RECU_VECT_GENE en PAR_LOT='OUI'")
import numpy
numpy.asarray(vecteur)
ncham = self.get_name()
ncham = ncham + (8 - len(ncham)) * ' '
desc = self.sdj.DESC.get()
# On teste si le DESC de la matrice existe
if not desc:
raise AsException("L'objet vecteur {0!r} n'existe pas".format(
self.sdj.DESC.nomj()))
desc = numpy.array(desc)
# On teste si la taille de la matrice jeveux et python est identique
if desc[1] != numpy.shape(vecteur)[0]:
raise AsException("La taille du vecteur python est incorrecte")
tmpr = vecteur.real
tmpc = vecteur.imag
aster.putvectjev(ncham + (19 - len(ncham)) * ' ' + '.VALE', len(tmpr),
tuple(range(1,
len(tmpr) + 1)), tuple(tmpr), tuple(tmpc),
1)
return
def champ_detoile_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME, Ctot0, Nl, Kt, a1, a2, a3, **args):
# macro pour calculer le chargement thermique specfique a la diffusion H2
INFO = args.get('INFO')
# On importe les definitions des commandes a utiliser dans la macro
# Recuperation du modele a partir du resultat
moth = RESU_H2.getModel()
# Recuperation du maillage a partir du resultat
mesh = moth.getMesh()
# Recuperation du modele mecanique a partir du resultat
mome = RESUMECA.getModel()
# 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=mesh,
AFFE=(_F(VALE=0., GROUP_MA=GRMAVOL, NOM_CMP='X1',),))
# 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.getName()
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)
return NEUTG
def changeJeveuxValues(self, nbval, indices, reel, imag, num=1):
"""Modify values of existing data structures"""
nomj = self.nomj()
if aster.jeveux_exists(nomj):
obj_simple = aster.jeveux_getattr(nomj, 'XOUS')[1].strip() == 'S'
if obj_simple:
assert num == 1, """For vectors last argument must be set to 1"""
# aster.putvectjev can be used for vectors (num=1) and collections
aster.putvectjev(nomj, nbval, indices, reel, imag, num)
def RECU_MATR_GENE(self,matrice) :
""" envoie les valeurs d'un tableau numpy dans des matrices
generalisees reelles definies dans jeveux
Attributs ne retourne rien """
import numpy
if not self.accessible():
raise AsException("Erreur dans matr_asse_gene_c.RECU_MATR_GENE en PAR_LOT='OUI'")
numpy.asarray(matrice)
ncham=self.get_name()
desc = self.sdj.DESC.get()
# On teste si le DESC de la matrice existe
if not desc:
raise AsException("L'objet matrice {0!r} n'existe pas"
.format(self.sdj.DESC.nomj()))
desc = numpy.array(desc)
numpy.asarray(matrice)
# On teste si la dimension de la matrice python est 2
if (len(numpy.shape(matrice)) != 2) :
raise AsException("La dimension de la matrice est incorrecte ")
# On teste si la taille de la matrice jeveux et python est identique
if (tuple([desc[1],desc[1]]) != numpy.shape(matrice)) :
raise AsException("La taille de la matrice est incorrecte ")
# Si le stockage est plein
if desc[2]==2 :
taille=desc[1]*desc[1]/2.0+desc[1]/2.0
tmpr=numpy.zeros([int(taille)])
tmpc=numpy.zeros([int(taille)])
for j in range(desc[1]+1):
for i in range(j):
k=j*(j-1)/2+i
tmpr[k]=matrice[j-1,i].real
tmpc[k]=matrice[j-1,i].imag
aster.putvectjev('%-19s.VALM' % ncham, len(tmpr), tuple((\
range(1,len(tmpr)+1))),tuple(tmpr),tuple(tmpc),1)
# Si le stockage est diagonal
elif desc[2]==1 :
tmpr=numpy.zeros(desc[1])
tmpc=numpy.zeros(desc[1])
for j in range(desc[1]):
tmpr[j]=matrice[j,j].real
tmpc[j]=matrice[j,j].imag
aster.putvectjev('%-19s.VALM' % ncham,len(tmpr),tuple((\
range(1,len(tmpr)+1))),tuple(tmpr),tuple(tmpc),1)
# Sinon on arrete tout
else:
raise KeyError
return
def RECU_MATR_GENE(self, typmat, matrice):
""" envoie les valeurs d'un tableau numpy dans des matrices generalisees
reelles definies dans jeveux
typmat='MASS_GENE' pour obtenir la matrice de masse generalisee
typmat='RIGI_GENE' pour obtenir la matrice de raideur generalisee
typmat='AMOR_GENE' pour obtenir la matrice d'amortissement generalisee
Attributs ne retourne rien """
import numpy
if not self.accessible():
raise AsException(
"Erreur dans macr_elem_dyna.RECU_MATR_GENE en PAR_LOT='OUI'")
nommacr = self.get_name()
if (typmat == 'MASS_GENE'):
macr_elem = self.sdj.MAEL_MASS
elif (typmat == 'RIGI_GENE'):
macr_elem = self.sdj.MAEL_RAID
elif (typmat == 'AMOR_GENE'):
macr_elem = self.sdj.MAEL_AMOR
else:
raise AsException("Le type de la matrice est incorrect")
nom_vale = macr_elem.VALE.nomj()
desc = macr_elem.DESC.get()
# On teste si le DESC de la matrice existe
if not desc:
raise AsException("L'objet matrice {0!r} n'existe pas".format(
macr_elem.DESC.nomj()))
desc = numpy.array(desc)
numpy.asarray(matrice)
# On teste si la matrice python est de dimension 2
if (len(numpy.shape(matrice)) <> 2):
raise AsException("La dimension de la matrice est incorrecte")
# On teste si les tailles de la matrice jeveux et python sont identiques
if (tuple([desc[1], desc[1]]) <> numpy.shape(matrice)):
raise AsException("La dimension de la matrice est incorrecte")
taille = desc[1] * desc[1] / 2.0 + desc[1] / 2.0
tmp = numpy.zeros([int(taille)])
for j in range(desc[1] + 1):
for i in range(j):
k = j * (j - 1) / 2 + i
tmp[k] = matrice[j - 1, i]
aster.putvectjev(nom_vale, len(tmp), tuple((range(1,
len(tmp) + 1))),
tuple(tmp), tuple(tmp), 1)
def RECU_MATR_GENE(self,matrice) :
NP.asarray(matrice)
ncham=self.getName()
desc = self.sdj.DESC.get()
# On teste si le DESC de la matrice existe
if not desc:
raise AsException("L'objet matrice {0!r} n'existe pas"
.format(self.sdj.DESC.nomj()))
desc = NP.array(desc)
NP.asarray(matrice)
# On teste si la dimension de la matrice python est 2
if (len(NP.shape(matrice)) != 2) :
raise AsException("La dimension de la matrice est incorrecte ")
# On teste si la taille de la matrice jeveux et python est identique
if (tuple([desc[1],desc[1]]) != NP.shape(matrice)) :
raise AsException("La taille de la matrice est incorrecte ")
# Si le stockage est plein
if desc[2]==2 :
taille=desc[1]*desc[1]/2.0+desc[1]/2.0
tmpr=NP.zeros([int(taille)])
tmpc=NP.zeros([int(taille)])
for j in range(desc[1]+1):
for i in range(j):
k=j*(j-1) // 2+i
tmpr[k]=matrice[j-1,i].real
tmpc[k]=matrice[j-1,i].imag
aster.putvectjev('%-19s.VALM' % ncham, len(tmpr), tuple((\
list(range(1,len(tmpr)+1)))),tuple(tmpr),tuple(tmpc),1)
# Si le stockage est diagonal
elif desc[2]==1 :
tmpr=NP.zeros(desc[1])
tmpc=NP.zeros(desc[1])
for j in range(desc[1]):
tmpr[j]=matrice[j,j].real
tmpc[j]=matrice[j,j].imag
aster.putvectjev('%-19s.VALM' % ncham,len(tmpr),tuple((\
list(range(1,len(tmpr)+1)))),tuple(tmpr),tuple(tmpc),1)
# Sinon on arrete tout
else:
raise KeyError
return
def RECU_VECT_GENE_C(self,vecteur):
numpy.asarray(vecteur)
ncham=self.getName()
ncham=ncham+(8-len(ncham))*' '
desc = self.sdj.DESC.get()
# On teste si le DESC de la matrice existe
if not desc:
raise AsException("L'objet vecteur {0!r} n'existe pas"
.format(self.sdj.DESC.nomj()))
desc = numpy.array(desc)
# On teste si la taille de la matrice jeveux et python est identique
if desc[1] != numpy.shape(vecteur)[0] :
raise AsException("La taille du vecteur python est incorrecte")
tmpr=vecteur.real
tmpc=vecteur.imag
aster.putvectjev(ncham+(19-len(ncham))*' '+'.VALE',
len(tmpr),
tuple(range(1, len(tmpr)+1)),
tuple(tmpr),
tuple(tmpc),
1)
return
def RECU_MATR_GENE(self, typmat, matrice):
nommacr = self.getName()
if (typmat == 'MASS_GENE'):
macr_elem = self.sdj.MAEL_MASS
elif (typmat == 'RIGI_GENE'):
macr_elem = self.sdj.MAEL_RAID
elif (typmat == 'AMOR_GENE'):
macr_elem = self.sdj.MAEL_AMOR
else:
raise AsException("Le type de la matrice est incorrect")
nom_vale = macr_elem.VALE.nomj()
desc = macr_elem.DESC.get()
# On teste si le DESC de la matrice existe
if not desc:
raise AsException("L'objet matrice {0!r} n'existe pas".format(
macr_elem.DESC.nomj()))
desc = numpy.array(desc)
numpy.asarray(matrice)
# On teste si la matrice python est de dimension 2
if (len(numpy.shape(matrice)) != 2):
raise AsException("La dimension de la matrice est incorrecte")
# On teste si les tailles de la matrice jeveux et python sont identiques
if (tuple([desc[1], desc[1]]) != numpy.shape(matrice)):
raise AsException("La dimension de la matrice est incorrecte")
taille = desc[1] * desc[1] / 2.0 + desc[1] / 2.0
tmp = numpy.zeros([int(taille)])
for j in range(desc[1] + 1):
for i in range(j):
k = j * (j - 1) // 2 + i
tmp[k] = matrice[j - 1, i]
aster.putvectjev(nom_vale, len(tmp),
tuple((list(range(1,
len(tmp) + 1)))), tuple(tmp),
tuple(tmp), 1)
def compute_result(self):
L_VEC = self.compute_harm_gene()
__dyge0 = self.create_host_sd()
nbmodt = self.mat_gene_params['NBMODT']
tup_re = []
tup_im = []
tup_re1 = []
tup_im1 = []
tup_re2 = []
tup_im2 = []
# boucle sur les 3 directions : sommation directionnelle
n_dire = len(list(self.excit_params.keys()))
for i, dire in enumerate(self.excit_params.keys()):
VEC = L_VEC[i]
# ATTENTION: on sort le champ en déplacement:
# c'est équivalent au champ en acceleration
# car on a applique un signal en ACCE pour fosi en acce
# > cela evite de diviser par w2 pour integrer l'acceleration
# (erreurs numeriques au point 0)
# > on remplace donc le champ en acceleration
# si tous les point on été calculés: pas d'interpolation
_, vale_re, vale_im = self.excit_params[dire].Valeurs()
if self.calc_params.get('FREQ_MAX') is None:
inul = 0
for k, freqk in enumerate(self.liste_freq_sig):
omegk = 2.0 * pi * freqk
coef_a = (vale_re[k] + vale_im[k] * 1.j)
VEC_comp = VEC[k] * coef_a
if i == 0:
tup_re.append(VEC_comp.real)
tup_im.append(VEC_comp.imag)
else:
tup_re[k] += VEC_comp.real
tup_im[k] += VEC_comp.imag
# traitement des vitesses et déplacements apres sommation des directions pour l'acceleration
if i == n_dire-1:
if freqk > 1.e-6 :
tup_re1.append((-1.0)*tup_re[k]/(omegk*omegk))
tup_im1.append((-1.0)*tup_im[k]/(omegk*omegk))
tup_re2.append(tup_im[k]/omegk)
tup_im2.append((-1.0)*tup_re[k]/omegk)
if inul == 1 :
inul = 2
elif inul == 2 :
tup_re1[k-2] = (2.0)*tup_re1[k-1]-tup_re1[k]
tup_im1[k-2] = (2.0)*tup_im1[k-1]-tup_im1[k]
tup_re2[k-2] = (2.0)*tup_re2[k-1]-tup_re2[k]
tup_im2[k-2] = (2.0)*tup_im2[k-1]-tup_im2[k]
inul = 0
else:
inul = 1
tup_re1.append(VEC_comp.real*0.)
tup_im1.append(VEC_comp.imag*0.)
tup_re2.append(VEC_comp.real*0.)
tup_im2.append(VEC_comp.imag*0.)
else:
inul = 0
for k, freqk in enumerate(self.liste_freq_sig):
coef_a = (vale_re[k] + vale_im[k] * 1.j)
omegk = 2.0 * pi * freqk
if freqk >= self.calc_params.get('FREQ_MAX'):
# interpolation du vecteur POD VEC(NB_FREQ, nbmodt)
if i == 0:
tup_re.append(VEC[-1].real * 0.0)
tup_im.append(VEC[-1].imag * 0.0)
else:
vale_i = NP.searchsorted(self.liste_freq, freqk)
if vale_i == 0:
VEC_comp = VEC[0] * coef_a
if i == 0:
tup_re.append(VEC_comp.real)
tup_im.append(VEC_comp.imag)
else:
tup_re[k] += VEC_comp.real
tup_im[k] += VEC_comp.imag
else:
dfp = (freqk - self.liste_freq[vale_i - 1]) / (
self.liste_freq[vale_i] - self.liste_freq[vale_i - 1])
VEC_comp = coef_a * (VEC[vale_i - 1] +
dfp * (VEC[vale_i] - VEC[vale_i - 1]))
if i == 0:
tup_re.append(VEC_comp.real)
tup_im.append(VEC_comp.imag)
else:
tup_re[k] += VEC_comp.real
tup_im[k] += VEC_comp.imag
# traitement des vitesses et déplacements apres sommation des directions pour l'acceleration
if i == n_dire-1:
if freqk > 1.e-6 :
tup_re1.append((-1.0)*tup_re[k]/(omegk*omegk))
tup_im1.append((-1.0)*tup_im[k]/(omegk*omegk))
tup_re2.append(tup_im[k]/omegk)
tup_im2.append((-1.0)*tup_re[k]/omegk)
if inul == 1 :
inul = 2
elif inul == 2 :
tup_re1[k-2] = (2.0)*tup_re1[k-1]-tup_re1[k]
tup_im1[k-2] = (2.0)*tup_im1[k-1]-tup_im1[k]
tup_re2[k-2] = (2.0)*tup_re2[k-1]-tup_re2[k]
tup_im2[k-2] = (2.0)*tup_im2[k-1]-tup_im2[k]
inul = 0
else:
inul = 1
tup_re1.append(VEC_comp.real*0.)
tup_im1.append(VEC_comp.imag*0.)
tup_re2.append(VEC_comp.real*0.)
tup_im2.append(VEC_comp.imag*0.)
# il peut y avoir des blancs à la fin du noms qui ont été enlevés par le python
resu_name = __dyge0.getName()+(19-len(__dyge0.getName()))*' '
# affectation des valeurs
for k in range(len(self.liste_freq_sig)):
# 1 2 3
# 8901234567890123456789012
aster.putvectjev(resu_name + '.DEPL ', nbmodt, tuple(
range(nbmodt * k + 1, nbmodt * (k + 1) + 1)), tuple(tup_re1[k]), tuple(tup_im1[k]), 1)
aster.putvectjev(resu_name + '.VITE ', nbmodt, tuple(
range(nbmodt * k + 1, nbmodt * (k + 1) + 1)), tuple(tup_re2[k]), tuple(tup_im2[k]), 1)
aster.putvectjev(resu_name + '.ACCE ', nbmodt, tuple(
range(nbmodt * k + 1, nbmodt * (k + 1) + 1)), tuple(tup_re[k]), tuple(tup_im[k]), 1)
if self.INFO == 2:
aster.affiche('MESSAGE','START REST_SPEC_TEMP' )
dyha = REST_SPEC_TEMP(RESU_GENE = __dyge0, SYMETRIE='NON',
#METHODE = 'PROL_ZERO' ,
TOUT_CHAM='OUI',
#NOM_CHAM='ACCE'
)
return dyha
def char_grad_impo_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME, Ctot0, CHARGRD0, Vh, R, T, **args):
# macro pour calculer le chargement thermique specfique a la diffusion H2
INFO = args.get('INFO')
# On importe les definitions des commandes a utiliser dans la macro
# Recuperation du modele a partir du resultat
moth = RESU_H2.getModel()
# Recuperation du maillage a partir du resultat
mesh = moth.getMesh()
# Recuperation du modele mecanique a partir du resultat
mome = RESUMECA.getModel()
# 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=mesh, 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.getName().ljust(8) + '.CHTH.GRAIN.VALE'
nomlima = CHARGRD0.getName().ljust(8) + '.CHTH.GRAIN.LIMA'
nomdesc = CHARGRD0.getName().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)
connex = mesh.sdj.CONNEX.get()
groupma = mesh.sdj.GROUPEMA.get()[GRMAVOL.ljust(24)]
# print "tabdesc",tabdesc
# print "tablima",dicolima
for izone in list(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 char_source_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME, Ctot0, Nl, Kt, a1, a2, a3, **args):
# macro pour calculer le chargement thermique specfique a la diffusion H2
INFO = args.get('INFO')
# On importe les definitions des commandes a utiliser dans la macro
dt = TFIN - TINIT
# Recuperation du modele thermique a partir du resultat
moth = RESU_H2.getModel()
# Recuperation du maillage a partir du resultat
mesh = moth.getMesh()
# Recuperation du modele mecanique a partir du resultat
mome = RESUMECA.getModel()
# 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', INFO=INFO)
__EPEQN = PROJ_CHAMP(
METHODE='COLLOCATION',
RESULTAT=__EPEQN2,
MODELE_1=mome,
MODELE_2=moth,
NOM_CHAM='VARI_NOEU',
TOUT_ORDRE='OUI')
__VINT0 = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_VAR2_R',
RESULTAT=__EPEQN, NOM_CHAM='VARI_NOEU', INST=TINIT, INFO=INFO)
__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=mesh,
AFFE=(_F(VALE=0., GROUP_MA=GRMAVOL, NOM_CMP='X1',),))
# 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
# print 'node_th=',node_th
lp_t0 = __VINT0.EXTR_COMP('V1', [], 1)
p_t0 = lp_t0.valeurs
node_me = lp_t0.noeud
p_t1 = __VINT1.EXTR_COMP('V1', [], 0).valeurs
nbnode = len(node_th)
assert(nbnode == len(node_me))
source = NP.zeros(nbnode)
bidon = NP.zeros(nbnode)
for ino, node in enumerate(node_th):
Cl = c_t0[ino]
p0 = p_t0[ino]
p1 = p_t1[ino]
dpdt = (p1 - p0) / dt
# avec INCLUDE : ne trouve pas SOURCE, mais en important la macro,
# cela marche
source[ino] = SOURCE(Cl, p1, dpdt, Ctot0, Nl, Kt, a1, a2, a3)
nomvect = '%-19s.VALE' % __chtmp.getName()
aster.putvectjev(nomvect, nbnode, tuple(
range(1, nbnode + 1)), tuple(source), tuple(bidon), 1)
__NEUTG = CREA_CHAMP(OPERATION='DISC', TYPE_CHAM='ELGA_NEUT_R',
MODELE=moth, PROL_ZERO='OUI', CHAM_GD=__chtmp, INFO=INFO)
__CHSOUR = CREA_CHAMP(
OPERATION='ASSE', TYPE_CHAM='ELGA_SOUR_R', MODELE=moth, INFO=INFO, PROL_ZERO='OUI',
ASSE=(_F(CHAM_GD=__NEUTG, GROUP_MA=GRMAVOL, NOM_CMP='X1', NOM_CMP_RESU='SOUR',),))
chth = AFFE_CHAR_THER(MODELE=moth, INFO=INFO,
SOURCE=_F(SOUR_CALCULEE=__CHSOUR,),
)
return chth
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)
