def check_material_def(test):
"""Check `AtLeastOne` rule in DEFI_MATERIAU.
Arguments
test (TestCase): Tester object that reports the results.
"""
print("\n>>> Checking for DEFI_MATERIAU rule...")
# in the case that there is several AtLeastOne rules (only one today),
# only keep those with a lot of keywords!
atleastone = [
rule for rule in DEFI_MATERIAU.rules
if isinstance(rule, AtLeastOne) and len(rule.ruleArgs) > 50
]
test.assertEqual(len(atleastone),
1,
msg="expect exactly one AtLeastOne/AU_MOINS_UN rule")
args = atleastone[0].ruleArgs if atleastone else []
inspect = InspectDEFI_MATERIAU()
DEFI_MATERIAU.accept(inspect)
kwds = set(inspect.lfact)
# add exceptions
kwds.add("COMP_THM")
missing = set(kwds).difference(args)
unknown = set(args).difference(kwds)
test.assertTrue(not unknown,
msg="unknown keyword in the AU_MOINS_UN rule: " +
", ".join(unknown))
test.assertTrue(not missing,
msg="These keywords must be added into the "
"AU_MOINS_UN rule: " + ", ".join(missing))
def Auxi(E=100000., Nu=0.3, fx=0., fy=0.):
### Lecture du maillage
asMeshA = LIRE_MAILLAGE(
FORMAT='MED',
UNITE=20, # Unité logique du fichier de maillage
NOM_MED='global', # Nom du maillage au sein du fichier
INFO=1,
)
# Nombre de noeuds physiques du maillage
nbNoeudA = asMeshA.sdj.DIME.get()[0]
dimA = 2 # Dimension du problème
### Affectation des modèles
modA = AFFE_MODELE(
MAILLAGE=asMeshG,
AFFE=(
_F(
GROUP_MA='AuxiG', # Modèle de la structure
PHENOMENE='MECANIQUE',
MODELISATION='C_PLAN',
), ))
### Définition des matériaux
matA = DEFI_MATERIAU(ELAS=_F(
E=100000.,
NU=0.3,
), )
### Affectation des matériaux
MatA = AFFE_MATERIAU(
MAILLAGE=asMeshG,
AFFE=(_F(
GROUP_MA='AuxiG',
MATER=matA,
), ),
)
# Calcul des matrices de rigidité élémentaires
matElemA = CALC_MATR_ELEM(OPTION='RIGI_MECA', MODELE=modA, CHAM_MATER=MatA)
# Calcul de la numérotation
numDDLA = NUME_DDL(MATR_RIGI=matElemA, )
# Assemblage de la matrice de rigidité
matAssA = ASSE_MATRICE(MATR_ELEM=matElemA,
NUME_DDL=numDDLA) #, CHAR_CINE=FixA)
return matAssA
def Global(E=100000., Nu=0., fx=5., fy=0.):
### Lecture du maillage
asMeshG = LIRE_MAILLAGE(
FORMAT='MED',
UNITE=20, # Unité logique du fichier de maillage
NOM_MED='global', # Nom du maillage au sein du fichier
INFO=1,
)
# Nombre de noeuds physiques du maillage
nbNoeudG = asMeshG.sdj.DIME.get()[0]
dimG = 2 # Dimension du problème
### Affectation des modèles
modG = AFFE_MODELE(
MAILLAGE=asMeshG,
AFFE=(
_F(
TOUT='OUI', # Modèle de la structure
PHENOMENE='MECANIQUE',
MODELISATION='C_PLAN',
), ))
### Définition des matériaux
matG = DEFI_MATERIAU(ELAS=_F(
E=E,
NU=Nu,
), )
### Affectation des matériaux
MatG = AFFE_MATERIAU(
MAILLAGE=asMeshG,
AFFE=(_F(
TOUT='OUI',
MATER=matG,
), ),
)
### Affectation des conditions limites
# Encastrement
# GROUP_MA => group of edges
FixG = AFFE_CHAR_CINE(MODELE=modG,
MECA_IMPO=(_F(GROUP_MA='Wd', DX=0., DY=0.), ))
# Effort imposé
FdG = AFFE_CHAR_MECA(
MODELE=modG,
FORCE_CONTOUR=_F(GROUP_MA='Fd', FX=fx, FY=fy),
#FORCE_ARETE = _F(GROUP_MA='Fd',FX=0,FY=10),
#PRES_REP = _F(GROUP_MA='Fd',PRES=10),
)
# Calcul des matrices de rigidité élémentaires
matElemG = CALC_MATR_ELEM(OPTION='RIGI_MECA', MODELE=modG, CHAM_MATER=MatG)
# Calcul de la numérotation
numDDLG = NUME_DDL(MATR_RIGI=matElemG, )
# Assemblage de la matrice de rigidité
matAssG = ASSE_MATRICE(MATR_ELEM=matElemG,
NUME_DDL=numDDLG,
CHAR_CINE=FixG)
# Calcul du second membre lié aux CL de Dirichlet
vcineG = CALC_CHAR_CINE(
NUME_DDL=numDDLG,
CHAR_CINE=FixG,
)
# Calcul du second membre lié aux CL de Neumann
vecElemG = CALC_VECT_ELEM(OPTION='CHAR_MECA', CHARGE=FdG, CHAM_MATER=MatG)
vneumG = ASSE_VECTEUR(VECT_ELEM=vecElemG, NUME_DDL=numDDLG)
# Factorisation de la matrice de rigidité et prise en compte des CL de
# Dirichlet éliminées
matAssG = FACTORISER(
reuse=matAssG,
MATR_ASSE=matAssG,
METHODE='MUMPS',
)
matAssPG = matAssG.EXTR_MATR(sparse='True')
matAssPG = sp.coo_matrix((matAssPG[0], (matAssPG[1], matAssPG[2])),
shape=(2 * nbNoeudG, 2 * nbNoeudG)).tocsc()
return matAssG, vcineG, vneumG, MatG, modG, numDDLG, matAssPG
def Local(E=50000., Nu=0., fx=0., fy=0.):
### Lecture du maillage
asMeshL = LIRE_MAILLAGE(
FORMAT='MED',
UNITE=21, # Unité logique du fichier de maillage
NOM_MED='local', # Nom du maillage au sein du fichier
INFO=1,
)
# Nombre de noeuds physiques du maillage
nbNoeudL = asMeshL.sdj.DIME.get()[0]
dim = 2 # Dimension du problème
### Affectation des modèles
modL = AFFE_MODELE(
MAILLAGE=asMeshL,
AFFE=(
_F(
TOUT='OUI', # Modèle de la structure
PHENOMENE='MECANIQUE',
MODELISATION='C_PLAN',
), ))
### Définition des matériaux
matL = DEFI_MATERIAU(ELAS=_F(
E=E,
NU=Nu,
), )
### Affectation des matériaux
MatL = AFFE_MATERIAU(
MAILLAGE=asMeshL,
AFFE=(_F(
TOUT='OUI',
MATER=matL,
), ),
)
# Effort imposé
FdL = AFFE_CHAR_MECA(
MODELE=modL,
FORCE_CONTOUR=_F(GROUP_MA='Wd', FX=fx, FY=fy),
)
# Char_cine nul
blank = AFFE_CHAR_CINE(MODELE=modL,
MECA_IMPO=_F(
GROUP_MA='Wd',
DX=0.,
DY=0.,
))
# Calcul des matrices de rigidité élémentaires
matElemL = CALC_MATR_ELEM(OPTION='RIGI_MECA', MODELE=modL, CHAM_MATER=MatL)
# Calcul de la numérotation
numDDLL = NUME_DDL(MATR_RIGI=matElemL)
matAssL = ASSE_MATRICE(
MATR_ELEM=matElemL,
NUME_DDL=numDDLL,
CHAR_CINE=blank,
)
# Calcul du second membre force
vecElemL = CALC_VECT_ELEM(OPTION='CHAR_MECA', CHARGE=FdL, CHAM_MATER=MatL)
vneumL = ASSE_VECTEUR(VECT_ELEM=vecElemL, NUME_DDL=numDDLL)
# Calcul du second membre cine nul
vblank = CALC_CHAR_CINE(
NUME_DDL=numDDLL,
CHAR_CINE=blank,
)
# Assemblage de la matrice de rigidité
matAssL = FACTORISER(
reuse=matAssL,
MATR_ASSE=matAssL,
METHODE='MUMPS',
)
return matAssL, vneumL, MatL, modL, numDDLL
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)