def recu_coor_z(noma, group, typ_group, tole_r):
import aster
from Utilitai.Utmess import UTMESS
collcnx = aster.getcolljev(noma.nom.ljust(8) + '.CONNEX')
coord = aster.getvectjev(noma.nom.ljust(8) + '.COORDO .VALE')
cnom = aster.getvectjev(noma.nom.ljust(8) + '.NOMNOE')
coor_z = []
if typ_group == 'group_ma':
nomgrma = group
collgrma = aster.getcolljev(noma.nom.ljust(8) + '.GROUPEMA')
if nomgrma.ljust(24) not in collgrma:
UTMESS("F", "MISS0_26", valk=group)
else:
numa = collgrma[nomgrma.ljust(24)]
for ima in numa:
n = collcnx[ima][0]
uzmin = round(coord[3 * (n - 1) + 2], tole_r)
uzmax = round(coord[3 * (n - 1) + 2], tole_r)
for i in range(len(collcnx[ima])):
n = collcnx[ima][i]
uzmin = min(uzmin, round(coord[3 * (n - 1) + 2], tole_r))
uzmax = max(uzmax, round(coord[3 * (n - 1) + 2], tole_r))
if uzmin not in coor_z:
coor_z.append(uzmin)
if uzmax not in coor_z:
coor_z.append(uzmax)
elif typ_group == 'group_no':
collgrno = aster.getcolljev(noma.nom.ljust(8) + '.GROUPENO')
nomgrno = group
if nomgrno.ljust(24) not in collgrno:
UTMESS("F", "MISS0_26", valk=group)
else:
grpn = collgrno[nomgrno.ljust(24)]
l_coor_group = []
i = 0
for node in grpn:
l_coor_group.append(
aster.getvectjev(
noma.nom.ljust(8) + '.COORDO .VALE', 3 * (node - 1),
3))
uz = round(l_coor_group[i][2], tole_r)
i += 1
if uz not in coor_z:
coor_z.append(uz)
else:
assert 0, 'recu_coor_z : erreur argument typ_group'
prov = sorted(coor_z)
coor_z = prov[::-1]
return coor_z
def LIST_LIAIS_STRUCT(self):
""" retourne la liste des liaisons entre sous structures du modele generalise sous la forme :
[ (ss1, nom_liais1, ss2 , nom_liais2), ...] """
nommodgen = self.getName()
ncham = nommodgen + (8 - len(nommodgen)) * ' '
lidf = aster.getcolljev(ncham + (14 - len(ncham)) * ' ' + '.MODG.LIDF')
return [([(lidf[ind][indb]) for indb in range(4)]) for ind in lidf]
def LIST_SOUS_STRUCT(self):
""" retourne la liste des sous structures du modele generalise
la liste des macro-elements sous-jacents"""
nommodgen = self.getName()
ncham = nommodgen + (8 - len(nommodgen)) * ' '
ssno = aster.getvectjev(ncham + (14 - len(ncham)) * ' ' + '.MODG.SSNO')
ssme = aster.getcolljev(ncham + (14 - len(ncham)) * ' ' + '.MODG.SSME')
return [([ssno[ind], ssme[ind + 1]]) for ind in range(len(ssno))]
def LIST_LIAIS_STRUCT(self):
""" retourne la liste des liaisons entre sous structures du modele generalise sous la forme :
[ (ss1, nom_liais1, ss2 , nom_liais2), ...] """
if not self.accessible():
raise AsException(
"Erreur dans modele_gene.LIST_LIAIS_STRUCT en PAR_LOT='OUI'")
nommodgen = self.get_name()
ncham = nommodgen + (8 - len(nommodgen)) * ' '
lidf = aster.getcolljev(ncham + (14 - len(ncham)) * ' ' + '.MODG.LIDF')
return [([(lidf[ind][indb]) for indb in range(4)]) for ind in lidf]
def get(self):
nomj = self.nomj()
if aster.jeveux_exists(nomj):
obj_simple = aster.jeveux_getattr(nomj, 'XOUS')[1].strip() == 'S'
if obj_simple:
return aster.getvectjev(nomj)
else:
return aster.getcolljev(nomj)
else:
return None
def LIST_SOUS_STRUCT(self):
""" retourne la liste des sous structures du modele generalise
la liste des macro-elements sous-jacents"""
if not self.accessible():
raise AsException(
"Erreur dans modele_gene.LIST_SOUS_STRUCT en PAR_LOT='OUI'")
nommodgen = self.get_name()
ncham = nommodgen + (8 - len(nommodgen)) * ' '
ssno = aster.getvectjev(ncham + (14 - len(ncham)) * ' ' + '.MODG.SSNO')
ssme = aster.getcolljev(ncham + (14 - len(ncham)) * ' ' + '.MODG.SSME')
return [([ssno[ind], ssme[ind + 1]]) for ind in range(len(ssno))]
def Valeurs(surface):
# TODO : dirty workarround for this macro, until Surface.getValues()
# implementaiton in c++
nsd = '%-19s' % surface.getName()
dicv = aster.getcolljev(nsd + '.VALE')
lpar = aster.getvectjev(nsd + '.PARA')
lval = []
for k in range(len(dicv)):
lbl = dicv[k + 1]
dim = len(lbl) // 2
lval.append([lbl[0:dim], lbl[dim:2 * dim]])
return [list(lpar), lval]
def LIST_GROUP_MA(self) :
""" retourne la liste des groupes de mailles sous la forme :
[ (gma1, nb mailles gma1, dime max des mailles gma1), ...] """
if not self.accessible():
raise AsException("Erreur dans maillage.LIST_GROUP_MA en PAR_LOT='OUI'")
ltyma = aster.getvectjev("&CATA.TM.NOMTM")
catama = aster.getcolljev("&CATA.TM.TMDIM")
dic_gpma = self.sdj.GROUPEMA.get()
if dic_gpma is None:
return []
dimama = [catama[ltyma[ma-1].ljust(24)][0] for ma in self.sdj.TYPMAIL.get()]
ngpma = []
for grp in dic_gpma.keys():
dim = max([dimama[ma-1] for ma in dic_gpma[grp]])
ngpma.append((grp.strip(), len(dic_gpma[grp]),dim))
return ngpma
def LIST_GROUP_MA(self):
""" retourne la liste des groupes de mailles sous la forme :
[ (gma1, nb mailles gma1, dime max des mailles gma1), ...] """
ltyma = aster.getvectjev("&CATA.TM.NOMTM")
catama = aster.getcolljev("&CATA.TM.TMDIM")
dic_gpma = self.sdj.GROUPEMA.get()
if dic_gpma is None:
return []
dimama = [
catama[ltyma[ma - 1].ljust(24)][0]
for ma in self.sdj.TYPMAIL.get()
]
ngpma = []
for grp in list(dic_gpma.keys()):
dim = max([dimama[ma - 1] for ma in dic_gpma[grp]])
ngpma.append((grp.strip(), len(dic_gpma[grp]), dim))
return ngpma
def Valeurs(self):
"""
Retourne la liste des valeurs du parametre,
et une liste de couples (abscisses,ordonnees) de chaque fonction.
"""
from Utilitai.Utmess import UTMESS
if not self.accessible():
raise AsException(
"Erreur dans nappe.Valeurs en PAR_LOT='OUI'")
nsd = '%-19s' % self.get_name()
dicv = aster.getcolljev(nsd + '.VALE')
# les cles de dicv sont 1,...,N (indice du parametre)
lpar = aster.getvectjev(nsd + '.PARA')
if lpar == None:
UTMESS('F', 'SDVERI_2', valk=[nsd + '.PARA'])
lval = []
for k in range(len(dicv)):
lbl = dicv[k + 1]
dim = len(lbl) / 2
lval.append([lbl[0:dim], lbl[dim:2 * dim]])
return [list(lpar), lval]
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 extr_matr(matr):
nommatr = str(matr.nom).strip()
lenm = len(nommatr)
nommatr = nommatr+' '*(8-lenm)
nrefa = nommatr+' .REFA'
vrefa = aster.getvectjev(nrefa)
numeddl = str(vrefa[1]).strip()
lenn = len(numeddl)
numeddl = numeddl+' '*(14-lenn)
typm = str(vrefa[8]).strip()
# on recupere les valeurs de la matrice
nvalm = nommatr+' .VALM'
vvalm = aster.getcolljev(nvalm)
# print(vvalm[1])
nsmdi = numeddl+'.SMOS.SMDI'
nsmhc = numeddl+'.SMOS.SMHC'
vsmdi = aster.getvectjev(nsmdi)
vsmhc = aster.getvectjev(nsmhc)
valm1 = vvalm[1]
if(typm == 'MS'):
# Si la matrice est symétrique
valm2 = vvalm[1]
else:
# Si la matrice est non-symétrique
valm2 = vvalm[2]
# Taille de la matrice avec cdl
neq = len(vsmdi)
# print(neq)
# Nombre de termes non-nuls
nterm = len(vsmhc)
# print(nterm)
# Creation de la matrice AVEC cdl
matriceg = zeros([neq, neq])
j = 0
for k in range(nterm):
matriceg[vsmhc[k]-1][j] = valm1[k]
matriceg[j][vsmhc[k]-1] = valm2[k]
if((vsmdi[j]-1) == k):
j = j+1
# print(matriceg)
# Création du vecteur ind : 1 si ddl phys 0 sinon
# Cas CDL = AFFE_CHAR_CINE
nccid = nommatr+' .CCID'
vccid = aster.getvectjev(nccid)
# print(vccid)
# Cas CDL = AFFE_CHAR_MECA
ndeeq = numeddl+'.NUME.DEEQ'
vdeeq = aster.getvectjev(ndeeq)
# print('vdeeq')
# print(vdeeq)
ind = zeros(neq)
# Cas CDL = AFFE_CHAR_CINE
if(vccid is not None):
ind = ones(neq)-vccid[0:neq]
# print(ind)
nd = neq-vccid[neq]
# print(nd)
# Cas CDL = AFFE_CHAR_MECA
elif(vdeeq is not None):
for k in range(neq):
if(vdeeq[-1+2*k+2] > 0):
ind[k] = 1
elif(vdeeq[-1+2*k+2] < 0):
ind[k] = 0
j = 0
tcmp = -vdeeq[-1+2*k+2]
while((vdeeq[-1+2*j+1] != vdeeq[-1+2*k+1]) or (vdeeq[-1+2*j+2] != tcmp)):
j = j+1
ind[j] = 0
# print(ind)
nd = 0
for k in range(neq):
if(ind[k] == 1):
nd = nd+1
# Creation de la matrice SANS cdl
matrice = zeros([nd, nd])
ii = 0
for i in range(neq):
jj = 0
if(ind[i] == 1):
for j in range(neq):
if(ind[j] == 1):
# print(i,ind[i],ii)
# print(j,ind[j],jj)
matrice[ii][jj] = matriceg[i][j]
jj = jj+1
ii = ii+1
# print(matrice)
# Creation du vecteur [N1DX ... N?D?] de taille nd
vectddl = ['']*nd
comp = ['DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ',]
i = 0
for k in range(neq):
if(ind[k] == 1):
vectddl[i] = 'N'+str(vdeeq[2*k]).strip()+comp[vdeeq[2*k+1]-1].strip()
i = i+1
if(vccid is not None):
inds = ind
else:
inds = zeros(len(ind))
i = 0
for k in range(neq):
if(vdeeq[2*k+1] > 0):
inds[i] = ind[i]
i = i+1
inds = inds[0:i]
return [vectddl, inds, matrice]
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 defi_sol_miss_ops(self, MATERIAU, COUCHE, COUCHE_AUTO, TITRE, INFO,
**args):
"""Macro DEFI_SOL_MISS :
définir les caractéristiques du sol pour un calcul MISS3D
"""
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
from Utilitai.Table import Table
CREA_TABLE = self.get_cmd("CREA_TABLE")
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant (de type table_sdaster) est tabout
self.DeclareOut("tabout", self.sd)
# 1. Création des dictionnaires des MATERIAUX
l_mate = []
for Mi in MATERIAU:
dM = Mi.cree_dict_valeurs(Mi.mc_liste)
l_mate.append(dM)
nb_mate = len(l_mate)
# 2. Création des dictionnaires des COUCHES
l_couche = []
n_substr = 0
n_epais = 0
# Mode manuel :
if COUCHE != None:
for Ci in COUCHE:
dC = Ci.cree_dict_valeurs(Ci.mc_liste)
if dC.get("SUBSTRATUM") == "OUI":
n_substr += 1
if dC.get("EPAIS") != None:
n_epais += 1
l_couche.append(dC)
if n_substr != 1:
UTMESS("F", "MISS0_3")
if n_epais == 0:
UTMESS("F", "MISS0_21")
nb_couche = len(l_couche)
print 'l_couche=', l_couche
# Mode automatique pour les couches :
grma_interf = None
arg_grno = False
arg_grma = False
if COUCHE_AUTO != None:
ll_mate = []
l_epais = []
enfonce = False
homogene = False
l_z0 = False
Z0 = 0.
max_z_input = 0.
min_z_input = 0.
# tole_r sert à arrondir les valeurs pour les tests
tole_r = 5
l_pt_ctrl = False
coor_z_input = []
decalage_auto = False
# Lecture des arguments :
for Ci in COUCHE_AUTO:
dC = Ci.cree_dict_valeurs(Ci.mc_liste)
if dC.get("HOMOGENE") == "OUI":
homogene = True
if dC.get("MAILLAGE"):
noma = dC.get("MAILLAGE")
if dC.get("SURF") == "NON":
enfonce = True
if dC.get("GROUP_MA") or dC.get("GROUP_NO"):
collcnx = aster.getcolljev(noma.nom.ljust(8) + '.CONNEX')
coord = aster.getvectjev(
noma.nom.ljust(8) + '.COORDO .VALE')
cnom = aster.getvectjev(noma.nom.ljust(8) + '.NOMNOE')
if dC.get("GROUP_MA"):
arg_grma = True
nomgrma = dC.get("GROUP_MA")
coor_z_input = recu_coor_z(noma, nomgrma, 'group_ma',
tole_r)
else:
arg_grno = True
nomgrno = dC.get("GROUP_NO")
coor_z_input = recu_coor_z(noma, nomgrno, 'group_no',
tole_r)
max_z_input = coor_z_input[0]
min_z_input = coor_z_input[-1]
if dC.get("NUME_MATE"):
ll_mate = dC.get("NUME_MATE")
if dC.get("EPAIS_PHYS"):
if homogene:
l_epais.append(dC.get("EPAIS_PHYS")[0])
else:
l_epais = dC.get("EPAIS_PHYS")
if dC.get("NUME_MATE_SUBSTRATUM"):
nume_substr = dC.get("NUME_MATE_SUBSTRATUM")
if dC.get("NOMBRE_RECEPTEUR"):
nb_recept = dC.get("NOMBRE_RECEPTEUR")
if (nb_recept % 2 <> 0):
UTMESS("F", "MISS0_27")
if dC.get("GROUP_MA_INTERF"):
grma_interf = dC.get("GROUP_MA_INTERF")
if dC.get("Z0"):
Z0 = dC.get("Z0")
l_z0 = True
if not l_z0 and enfonce:
Z0 = max_z_input
if not enfonce:
max_z_input = Z0
print 'La cote Z vaut : ', Z0
if dC.get("TOLERANCE"):
tole_verif = dC.get("TOLERANCE")
if dC.get("DECALAGE_AUTO") == "OUI":
decalage_auto = True
if dC.get("GROUP_MA_CONTROL"):
nomgrmactrl = dC.get("GROUP_MA_CONTROL")
l_pt_ctrl = True
coor_z_ctrl = recu_coor_z(noma, nomgrmactrl, 'group_ma',
tole_r)
print 'Cotes verticales des points de controle=', coor_z_ctrl
if coor_z_ctrl[0] > Z0:
UTMESS("F", "MISS0_28", valr=Z0)
if homogene:
max_z_input = Z0
ll_mate.append(1)
l_mate.append(l_mate[0])
nb_mate += 1
coor_z_sol = [
max_z_input,
]
for ep in l_epais:
coor_z_sol.append(coor_z_sol[-1] - ep)
# Typage des couches : 1 si couche de sol, 2 si point de controle
type_couche = [1] * len(coor_z_sol)
if enfonce:
# Verification si il y a vraiment enfoncement
if len(coor_z_sol) == 1:
UTMESS("F", "MISS0_29")
# Verification entre base de l'interface et couches de sol
print 'coor_z_sol=', coor_z_sol
if len(l_epais) <> len(ll_mate):
UTMESS("F", "MISS0_30")
if l_pt_ctrl:
if coor_z_ctrl[-1] < coor_z_sol[-1]:
UTMESS("F", "MISS0_32")
# Liste regroupant les cotes des points de controles et des couches de sol
coor_z_sol_ctrl = []
for zz in coor_z_sol:
coor_z_sol_ctrl.append(zz)
for zz in coor_z_ctrl:
if zz not in coor_z_sol_ctrl:
coor_z_sol_ctrl.append(zz)
prov = sorted(coor_z_sol_ctrl)
coor_z_sol_ctrl = prov[::-1]
type_couche = [1]
l_epais = []
ll_mate2 = []
zz_sup = Z0
jj = 0
for zz in coor_z_sol_ctrl[1:]:
if zz in coor_z_ctrl:
if zz in coor_z_sol:
UTMESS("F", "MISS0_33")
else:
type_couche.append(2)
else:
type_couche.append(1)
pp = zz_sup - zz
l_epais.append(pp)
zz_sup = zz
ll_mate2.append(ll_mate[jj])
if zz in coor_z_sol:
jj += 1
ll_mate = ll_mate2
# Verification avec l'interface FEM-BEM
nb_noeud = 0
verif = False
if ((grma_interf != None) and enfonce and (COUCHE_AUTO != None)):
coor_z_interf = recu_coor_z(noma, grma_interf, 'group_ma', tole_r)
max_z_interf = coor_z_interf[0]
min_z_interf = coor_z_interf[-1]
l_z_sol = [
max_z_interf,
]
for ep in l_epais:
l_z_sol.append(l_z_sol[-1] - ep)
nb_noeud = len(coor_z_input)
if (max_z_input < max_z_interf) or (min_z_input > min_z_interf):
UTMESS("F", "MISS0_34")
verif = True
denom = 1.
for z_input in coor_z_input:
verif1 = False
for z_interf in coor_z_interf:
if (abs(z_interf) > 1.):
denom = abs(z_interf)
if ((abs(z_input - z_interf) / denom) <= tole_verif):
verif1 = True
verif = (verif and verif1)
if (not verif):
if arg_grma:
UTMESS("F", "MISS0_34")
else:
UTMESS("A", "MISS0_35")
if l_pt_ctrl:
for zz in coor_z_ctrl:
if zz > min_z_input:
UTMESS("F", "MISS0_36")
#Generation table sol en mode auto
if (COUCHE_AUTO != None):
couche = {}
nbc = 0
idc = 1
nbsscouche = 0
if enfonce:
l_noeud = coor_z_input
# Liste des epaisseurs de sol
l_z_ep = []
for zz in l_z_sol:
l_z_ep.append(Z0 - zz)
for pt in range(nb_noeud - 1):
idc += 1
enfonc_sup = l_noeud[0] - l_noeud[pt]
if enfonc_sup > l_z_ep[len(l_z_ep) - 1]:
UTMESS("F", "MISS0_37")
ep_ss_couche = (l_noeud[pt] - l_noeud[pt + 1]) / nb_recept
for nc in range(nb_recept):
couche = {}
enfonc_ss_c_haut = l_noeud[0] - l_noeud[pt] + (
nc * ep_ss_couche)
enfonc_ss_c_bas = enfonc_ss_c_haut + ep_ss_couche
i = 0
ind_mat_sup = 0
ind_mat_inf = 0
if not homogene:
while enfonc_ss_c_haut > l_z_ep[i]:
i += 1
while l_z_ep[ind_mat_sup] <= enfonc_ss_c_haut:
ind_mat_sup += 1
ind_mat_inf = ind_mat_sup
ind_mat_sup = ind_mat_sup - 1
while enfonc_ss_c_bas >= l_z_ep[ind_mat_inf]:
ind_mat_inf += 1
nb_mat_couche = ind_mat_inf - ind_mat_sup
if homogene:
id_mate = ll_mate[0]
elif ind_mat_sup < (ind_mat_inf - 2):
#Cas plus de deux materiaux dans la sous-couche
print ' Cas plus de deux materiaux dans la sous-couche'
ep_mat_h = []
ep_mat_b = []
ep_mat = [
(l_z_ep[ind_mat_sup + 1] - enfonc_ss_c_haut),
]
for ind_mat in range((ind_mat_sup + 1),
(ind_mat_inf - 1)):
zz1 = l_z_ep[ind_mat] - enfonc_ss_c_haut
zz2 = enfonc_ss_c_bas - l_z_ep[ind_mat]
ep_mat_h.append(zz1)
ep_mat_b.append(zz2)
ep_mat.append(enfonc_ss_c_bas -
l_z_ep[ind_mat_inf - 1])
err_ep = abs(sum(ep_mat) - ep_ss_couche) / ep_ss_couche
if (err_ep > tole_verif):
UTMESS("F", "MISS0_38")
ep1 = ep_mat[0]
ii = 1
id_mate = ll_mate[ind_mat_sup]
for ii in range(1, (len(ep_mat) - 1)):
if (ep_mat[ii] > ep1):
ep1 = ep_mat[ii]
id_mate = ll_mate[ind_mat_sup + ii]
elif ind_mat_sup == (ind_mat_inf - 2):
#Cas deux materiaux dans la sous-couche
zz1 = l_z_ep[ind_mat_sup + 1] - enfonc_ss_c_haut
zz2 = enfonc_ss_c_bas - l_z_ep[ind_mat_sup + 1]
if zz2 > zz1:
id_mate = ll_mate[ind_mat_sup + 1]
else:
id_mate = ll_mate[ind_mat_sup]
elif ind_mat_sup == (ind_mat_inf - 1):
#Cas un seul materiau
id_mate = ll_mate[ind_mat_sup]
else:
assert False, "Erreur dans la contruction des sous-couches"
couche["SUBSTRATUM"] = None
couche["NUME_MATE"] = id_mate
couche["EPAIS"] = ep_ss_couche
couche["RECEPTEUR"] = "OUI"
couche["SOURCE"] = "NON"
if nc == nb_recept / 2:
couche["SOURCE"] = "OUI"
l_couche.append(couche)
idc += 1
enfonc_ss_c_bas = l_noeud[0] - l_noeud[pt + 1]
# Fin des sous-couches
# Couche a la base de l'interface
ii = 0
epais = -1.
if len(l_z_ep) > 1:
while enfonc_ss_c_bas >= l_z_ep[ii]:
ii += 1
epais = l_z_ep[ii] - enfonc_ss_c_bas
else:
if l_z_ep[ii] <= enfonc_ss_c_bas:
UTMESS("F", "MISS0_39")
else:
epais = l_z_ep[ii] - enfonc_ss_c_bas
couche = {}
couche["EPAIS"] = epais
couche["SUBSTRATUM"] = None
if not homogene:
couche["NUME_MATE"] = ll_mate[ii - 1]
else:
couche["NUME_MATE"] = ll_mate[0]
couche["EPAIS"] = epais
couche["SOURCE"] = "OUI"
couche["RECEPTEUR"] = "OUI"
idc += 1
l_couche.append(couche)
# Couches strictement sous l'interface
while ii < len(l_epais):
couche = {}
couche["SUBSTRATUM"] = None
couche["NUME_MATE"] = ll_mate[ii]
couche["EPAIS"] = l_epais[ii]
couche["SOURCE"] = "NON"
couche["RECEPTEUR"] = "NON"
if type_couche[ii] == 2:
# Cas des points de controle
couche["RECEPTEUR"] = "OUI"
couche["SOURCE"] = "OUI"
l_couche.append(couche)
idc += 1
ii += 1
# Substratum
couche = {}
couche["SUBSTRATUM"] = "OUI"
couche["SOURCE"] = "NON"
couche["RECEPTEUR"] = "NON"
if homogene:
couche["NUME_MATE"] = ll_mate[0] + 1
else:
couche["NUME_MATE"] = nume_substr
couche["EPAIS"] = None
l_couche.append(couche)
else:
# Cas superficiel
couche = {}
ii = 0
couche["SOURCE"] = "OUI"
couche["RECEPTEUR"] = "OUI"
couche["NUME_MATE"] = ll_mate[ii]
couche["EPAIS"] = l_epais[ii]
couche["SUBSTRATUM"] = None
l_couche.append(couche)
ii = 1
for nc in range(1, len(l_epais)):
couche = {}
couche["SUBSTRATUM"] = None
couche["NUME_MATE"] = ll_mate[ii]
couche["EPAIS"] = l_epais[ii]
couche["RECEPTEUR"] = "NON"
couche["SOURCE"] = "NON"
if type_couche[ii] == 2:
# Cas des points de controle
couche["RECEPTEUR"] = "OUI"
couche["SOURCE"] = "OUI"
l_couche.append(couche)
idc += 1
ii += 1
couche = {}
couche["SUBSTRATUM"] = "OUI"
couche["SOURCE"] = "NON"
couche["RECEPTEUR"] = "NON"
if homogene:
couche["NUME_MATE"] = ll_mate[0] + 1
else:
couche["NUME_MATE"] = nume_substr
couche["EPAIS"] = None
l_couche.append(couche)
if ((COUCHE_AUTO != None) and enfonce):
# Verification entre base de l'interface et couches de sol
min_z_input_r = round(min_z_input, tole_r)
prof = Z0
ii = 0
for couche in l_couche[:-2]:
prof = prof - couche["EPAIS"]
prof = round(prof, tole_r)
print 'ii=', ii
print 'prof=', prof
if prof == min_z_input_r:
if decalage_auto:
UTMESS("A", "MISS0_40", valr=(prof, couche["EPAIS"]))
couche["NUME_MATE"] = l_couche[ii + 1]["NUME_MATE"]
else:
UTMESS("A", "MISS0_41")
ii += 1
print 'l_couche mod=', l_couche
# 3. définition de la table
# para/typ pré-trie les colonnes
tab = Table(para=[
"NUME_COUCHE", "EPAIS", "RHO", "E", "NU", "AMOR_HYST", "RECEPTEUR",
"SOURCE", "NUME_MATE", "SUBSTRATUM"
],
typ=["I", "R", "R", "R", "R", "R", "K8", "K8", "I", "K8"])
idc = 0
for couche in l_couche:
idc += 1
id_mate = couche["NUME_MATE"]
if id_mate > nb_mate:
UTMESS("F", "MISS0_4", vali=(idc, nb_mate, id_mate))
id_mate = id_mate - 1
couche["NUME_COUCHE"] = idc
couche.update(l_mate[id_mate])
if couche.get("SUBSTRATUM") is None:
del couche["SUBSTRATUM"]
if couche["EPAIS"] is None:
couche["EPAIS"] = 0.
tab.append(couche)
# 4. surcharge par le titre fourni
if TITRE != None:
if type(TITRE) not in (list, tuple):
TITRE = [TITRE]
tab.titr = os.linesep.join(TITRE)
if INFO == 2:
print tab
# 5. création de la table
dprod = tab.dict_CREA_TABLE()
tabout = CREA_TABLE(**dprod)
def sdu_nb_ec(numgd):
"""retourne le nombre d'entiers codés pour décrire les composantes de la grandeur (numgd)"""
assert numgd > 0 and numgd < 1000, numgd
descrigd = aster.getcolljev('&CATA.GD.DESCRIGD')
return descrigd[numgd][-1 + 3]
def sdu_licmp_gd(numgd):
"""retourne la liste des cmps de la grandeur de numéro (numgd)"""
nomgd = sdu_nom_gd(numgd)
nocmp = aster.getcolljev('&CATA.GD.NOMCMP')
return nocmp[nomgd.ljust(24)]
def macr_cara_poutre_ops(self,
MAILLAGE=None,
SYME_Y=None,
SYME_Z=None,
GROUP_MA_BORD=None,
GROUP_MA=None,
ORIG_INER=None,
TABLE_CARA=None,
**args):
"""
Ecriture de la macro MACR_CARA_POUTRE
"""
#
# On importe les définitions des commandes a utiliser dans la macro
# Le nom de la variable doit être obligatoirement le nom de la commande
#
ImprTable = False
#
UNITE = args.get("UNITE") or 20
if (MAILLAGE is not None):
__nomlma = COPIER(CONCEPT=MAILLAGE)
else:
__nomlma = LIRE_MAILLAGE(UNITE=UNITE, FORMAT=args.get('FORMAT'))
#
# Dans les tables on retrouve une ligne avec __nomlma.nom. Soit :
# - on remplace __nomlma.nom par NomMaillageNew.
# - on supprime la ligne
NomMaillage = (None, __nomlma.getName())
if ('NOM' in args):
NomMaillage = (args.get('NOM'), __nomlma.getName())
#
#
__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 caractéristiques géométriques 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)
#
# Création d'un modèle plan 2D thermique représentant la section
# de la poutre car on doit résoudre des E.D.P. avec des laplaciens
#
# Calcul de la constante de torsion sur tout le maillage
# du centre de torsion/cisaillement des coefficients de cisaillement
# de l inertie de gauchissement
# du rayon de torsion
#
if GROUP_MA_BORD and not GROUP_MA:
# Transformation des GROUP_MA en GROUP_NO sur lesquels
# on pourra appliquer des conditions de température imposée
#
# les groupes doivent exister
collgrma = aster.getcolljev('%-8s.GROUPEMA' % __nomlma.getName())
collgrma = list(map(lambda x: x.strip(), collgrma))
if type(GROUP_MA_BORD) == str:
l_group_ma_bord = [
GROUP_MA_BORD,
]
else:
l_group_ma_bord = GROUP_MA_BORD
for igr in l_group_ma_bord:
if (not igr.strip() in collgrma):
UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA_BORD'])
if 'GROUP_MA_INTE' in args:
if args.get('GROUP_MA_INTE') is not None:
if type(args.get('GROUP_MA_INTE')) is str:
l_group_ma_inte = [
args.get('GROUP_MA_INTE'),
]
else:
l_group_ma_inte = args.get('GROUP_MA_INTE')
for igr in l_group_ma_inte:
if (not igr.strip() in collgrma):
UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA_INTE'])
#
motscles = {}
if type(GROUP_MA_BORD) == str:
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)
# Création d'un maillage identique au premier a ceci près
# que les coordonnées sont exprimées dans le repère 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 phénomène 'thermique' au modèle en vue de
# la construction d un opérateur laplacien sur ce modèle
__nomoth = AFFE_MODELE(
MAILLAGE=__nomapi,
AFFE=_F(
TOUT='OUI',
PHENOMENE='THERMIQUE',
MODELISATION='PLAN',
),
)
# Pour la construction du laplacien, on définit un matériau dont les
# caractéristiques thermiques sont : lambda = 1, rho*cp = 0
__nomath = DEFI_MATERIAU(THER=_F(
LAMBDA=1.0,
RHO_CP=0.,
), )
# Définition d'un CHAM_MATER à partir du matériau précédent
__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 'GROUP_MA_INTE' in args:
if args.get('GROUP_MA_INTE') is not None:
motscles['LIAISON_UNIF'] = _F(
GROUP_MA=args.get('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 'GROUP_MA_INTE' in args:
lgmaint = args.get('GROUP_MA_INTE')
if lgmaint is not None:
__tbaire = POST_ELEM(
MODELE=__nomoth,
AIRE_INTERNE=_F(GROUP_MA_BORD=args.get('GROUP_MA_INTE'), ),
)
motscles = {}
motscles['FLUX_REP'] = []
if type(lgmaint) == str:
motscles['FLUX_REP'] = _F(
GROUP_MA=args.get('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 'GROUP_MA_INTE' in args:
if lgmaint is not 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 ÉQUATION
# DE LAPLACE EST PRIS ÉGAL A Y DANS TOUTE LA SECTION :
mctimpo = {}
if args.get('NOEUD') is not None:
if len(args.get('NOEUD')) != 1:
UTMESS('F', 'POUTRE0_3')
nthno = args['NOEUD'][0].strip()
# nthno est-il dans le maillage ?
nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomlma.getName())
nomnoe = list(map(lambda x: x.strip(), nomnoe))
if (not nthno in nomnoe):
UTMESS('F', 'POUTRE0_9', valk=nthno)
mctimpo['TEMP_IMPO'] = (_F(NOEUD=nthno, TEMP=__fnsec0))
elif args.get('GROUP_NO') is not None:
if len(args.get('GROUP_NO')) != 1:
UTMESS('F', 'POUTRE0_3')
grthno = args.get('GROUP_NO')[0]
#grthno = grthno[0]
collgrno = aster.getcolljev('%-8s.GROUPENO' % __nomapi.getName())
nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomapi.getName())
# Plantage si grthno n'existe pas dans le maillage
try:
l_no = collgrno[grthno.ljust(24)]
except:
UTMESS('F', 'POUTRE0_8', valk=grthno)
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 'GROUP_MA_INTE' in args:
if args.get('GROUP_MA_INTE') is not None:
if type(args.get('GROUP_MA_INTE')) is str:
l_group_ma_inte = [
args.get('GROUP_MA_INTE'),
]
else:
l_group_ma_inte = args.get('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 = {}
lgmaint = args.get('GROUP_MA_INTE')
if lgmaint is not None:
motscles['CARA_POUTRE'] = _F(
CARA_GEOM=__cageo,
LAPL_PHI=__tempe1,
RT=__rt,
TOUT='OUI',
OPTION='CARA_TORSION',
GROUP_MA_INTE=args.get('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 :
__tabtmp = 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 len(l_group_ma) != len(l_group_ma_bord):
UTMESS('F', 'POUTRE0_1')
#
# les groupes doivent exister
collgrma = aster.getcolljev('%-8s.GROUPEMA' % __nomlma.getName())
collgrma = list(map(lambda x: x.strip(), collgrma))
for igr in l_group_ma_bord:
if (not igr.strip() in collgrma):
UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA_BORD'])
#
for igr in GROUP_MA:
if (not igr.strip() in collgrma):
UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA'])
#
if 'GROUP_MA_INTE' in args:
if args.get('GROUP_MA_INTE') is not None:
if type(args.get('GROUP_MA_INTE')) is str:
l_group_ma_inte = [
args.get('GROUP_MA_INTE'),
]
else:
l_group_ma_inte = args.get('GROUP_MA_INTE')
for igr in l_group_ma_inte:
if (not igr.strip() in collgrma):
UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA_INTE'])
if args.get('NOEUD') is not None:
l_noeud = list(map(lambda x: x.strip(), args['NOEUD']))
if (len(l_group_ma) != len(l_noeud)):
UTMESS('F', 'POUTRE0_2')
# Les noeuds doivent faire partie du maillage
nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomlma.getName())
nomnoe = list(map(lambda x: x.strip(), nomnoe))
for ino in l_noeud:
if (not ino in nomnoe):
UTMESS('F', 'POUTRE0_9', valk=ino)
elif args.get('GROUP_NO') is not None:
collgrno = aster.getcolljev('%-8s.GROUPENO' % __nomlma.getName())
nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomlma.getName())
l_nu_no = []
for grno in args.get('GROUP_NO'):
try:
l_nu_no.extend(collgrno[grno.ljust(24)])
except:
UTMESS('F', 'POUTRE0_8', valk=grno)
l_noeud = [nomnoe[no_i - 1] for no_i in l_nu_no]
if (len(l_group_ma) != len(l_noeud)): UTMESS('F', 'POUTRE0_5')
# Si len(l_group_ma_bord) > 1, alors il faut donner : 'LONGUEUR', 'MATERIAU', 'LIAISON'
if (len(l_group_ma_bord) > 1):
if (not args.get('LONGUEUR') or not args.get('MATERIAU')
or not args.get('LIAISON')):
UTMESS('F', 'POUTRE0_6')
else:
if (args.get('LONGUEUR') or args.get('MATERIAU')
or args.get('LIAISON')):
UTMESS('A', 'POUTRE0_7')
__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 'GROUP_MA_INTE' in args:
if args.get('GROUP_MA_INTE') is not None:
if type(args.get('GROUP_MA_INTE')) is str:
l_group_ma_inte = [
args.get('GROUP_MA_INTE'),
]
else:
l_group_ma_inte = args.get('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 :
if (len(l_group_ma_bord) > 1):
__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.get('LONGUEUR'),
MATERIAU=args.get('MATERIAU'),
LIAISON=args.get('LIAISON'),
OPTION='CARA_CISAILLEMENT',
),
)
else:
__nomtmp = DEFI_MATERIAU(ELAS=_F(E=1.0, NU=0.123, RHO=1.0), )
__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=123.0,
MATERIAU=__nomtmp,
LIAISON='ENCASTREMENT',
OPTION='CARA_CISAILLEMENT',
),
)
#
#
dprod = __catp2.EXTR_TABLE().dict_CREA_TABLE()
# On remplace dans le TITRE le nom du concept __catp2.getName() par self.sd.getName()
if ('TITRE' in list(dprod.keys())):
conceptOld = __catp2.getName()
# FIXME
conceptNew = conceptOld #self.sd.getName()
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())
#
dprod['TYPE_TABLE'] = 'TABLE_CONTAINER'
__tabtmp = CREA_TABLE(**dprod)
#
if not GROUP_MA_BORD:
__tabtmp = POST_ELEM(MODELE=__nomamo,
CHAM_MATER=__nomama,
CARA_GEOM=mfact)
#
# mise au propre de la table
#
# On enlève la ligne avec LIEU='-' et donc les colonnes TYPE_OBJET, NOM_SD
# on utilise TYPE_TABLE pour forcer le type à table_sdaster et plus table_container
nomres = CALC_TABLE(
TABLE=__tabtmp,
TYPE_TABLE='TABLE',
ACTION=_F(OPERATION='FILTRE', NOM_PARA='LIEU', CRIT_COMP='NON_VIDE'),
)
NomMaillageNew, NomMaillageOld = NomMaillage
# Suppression de la référence à NomMaillageOld, remplacé par NOM = NomMaillageNew
# Si TABLE_CARA == "OUI" et GROUP_MA la ligne est supprimée
if not (TABLE_CARA == "OUI" and GROUP_MA):
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:
# 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()
DETRUIRE(CONCEPT=_F(NOM=nomres), INFO=1)
nomres = CREA_TABLE(**TabTmp)
#
# On retourne une table exploitable par AFFE_CARA_ELEM, avec seulement les
# caractéristiques nécessaires
if (TABLE_CARA == "OUI"):
#
if GROUP_MA_BORD and not GROUP_MA:
nomres = CALC_TABLE(
TABLE=nomres,
reuse=nomres,
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=nomres,
reuse=nomres,
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=nomres,
reuse=nomres,
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(
TABLE=nomres,
reuse=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(
TABLE=nomres,
reuse=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(
TABLE=nomres,
reuse=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 nomres
def calc_spectre_ipm_ops(
self, EQUIPEMENT, CALCUL, RESU, MAILLAGE=None, RESULTAT=None, GROUP_NO=None,
AMOR_SPEC=None, LIST_INST=None, FREQ=None, LIST_FREQ=None, NORME=None, TOLE_INIT=None, CORR_INIT=None, **args):
EnumType = (list, tuple)
# On importe les definitions des commandes a utiliser dans la macro
if AMOR_SPEC is not None and type(AMOR_SPEC) not in EnumType:
AMOR_SPEC = (AMOR_SPEC,)
# construction de la liste des noeuds à traiter
planch_nodes = {}
planch_param = {}
if (MAILLAGE):
dic_gpno = aster.getcolljev(MAILLAGE.getName().ljust(8) + ".GROUPENO")
l_nodes = aster.getvectjev(MAILLAGE.getName().ljust(8) + ".NOMNOE")
l_plancher = []
#
dplancher = []
for j in EQUIPEMENT:
dplancher.append(j.cree_dict_valeurs(j.mc_liste))
#
for plancher in dplancher:
liste_no = []
clefs = list(plancher.keys())
if 'NOEUD' in clefs:
if plancher['NOEUD'] is not None:
if type(plancher['NOEUD']) is str:
liste_no.append(plancher['NOEUD'])
else:
for noeud in plancher['NOEUD']:
liste_no.append(noeud)
if ('GROUP_NO' in clefs):
if plancher['GROUP_NO'] is not None:
assert (MAILLAGE is not None)
if type(plancher['GROUP_NO']) is str:
noms_no = [l_nodes[n - 1].strip()
for n in dic_gpno[plancher['GROUP_NO'].ljust(24)]]
liste_no = liste_no + noms_no
else:
for group_no in plancher['GROUP_NO']:
noms_no = [l_nodes[n - 1].strip()
for n in dic_gpno[group_no.ljust(24)]]
liste_no = liste_no + noms_no
planch_nodes[plancher['NOM']] = liste_no
l_plancher.append(plancher['NOM'])
if plancher['AMOR_EQUIP'] is not None and type(plancher['AMOR_EQUIP']) not in EnumType:
AMOR_EQUI = (plancher['AMOR_EQUIP'],)
else:
AMOR_EQUI = plancher['AMOR_EQUIP']
if plancher['AMOR_SUPPORT'] is not None and type(plancher['AMOR_SUPPORT']) not in EnumType:
AMOR_SUPP = (plancher['AMOR_SUPPORT'],)
else:
AMOR_SUPP = plancher['AMOR_SUPPORT']
if plancher['RAPPORT_MASSE_TOTALE'] is not None and type(plancher['RAPPORT_MASSE_TOTALE']) not in EnumType:
RAP_MAS = (plancher['RAPPORT_MASSE_TOTALE'],)
else:
RAP_MAS = plancher['RAPPORT_MASSE_TOTALE']
if plancher['FREQ_SUPPORT'] is not None and type(plancher['FREQ_SUPPORT']) not in EnumType:
FREQ_SUPP = (plancher['FREQ_SUPPORT'],)
else:
FREQ_SUPP = plancher['FREQ_SUPPORT']
FREQ_EQUI = plancher['FREQ_EQUIP']
RAP_MAS_COEF = plancher['COEF_MASS_EQUIP']
# verification de la longueur des listes
if (len(AMOR_EQUI) != len(FREQ_EQUI) or len(AMOR_EQUI) != len(RAP_MAS_COEF)):
UTMESS('F', 'SPECTRAL0_14')
# verification somme des rapport de masses
pi = math.pi
sum = NP.sum(RAP_MAS_COEF)
if abs(sum - 1) > 1e-4:
UTMESS('F', 'SPECTRAL0_15')
planch_param[plancher['NOM']] = {'AMOR_EQUI': AMOR_EQUI, 'AMOR_SUPP': AMOR_SUPP[
0], 'FREQ_EQUI': FREQ_EQUI, 'FREQ_SUPP': FREQ_SUPP[0], 'RAP_MAS_COEF': RAP_MAS_COEF, 'RAP_MAS': RAP_MAS[0]}
dico_global = {}
# ---------------------------------------------------------------------------------------------
# boucle 1 sur les planchers
for plancher in l_plancher:
AMOR_EQUI = planch_param[plancher]['AMOR_EQUI']
AMOR_SUPP = planch_param[plancher]['AMOR_SUPP']
FREQ_EQUI = planch_param[plancher]['FREQ_EQUI']
FREQ_SUPP = planch_param[plancher]['FREQ_SUPP']
RAP_MAS_COEF = planch_param[plancher]['RAP_MAS_COEF']
RAP_MAS = planch_param[plancher]['RAP_MAS']
# -----------------------------------------------------------------------------------------
# boucle 2 sur les noeuds du plancher
for node in planch_nodes[plancher]:
# ---------------------------------------------------------------------------------
# boucle 3 sur les résultats
for resu in RESU :
if resu['TABLE'] is not None :
# 2 formats de table possible. Avec les colonnes :
# INST NOEUD NOM_CHAM NOM_CMP VALE
# INST NOEUD NOM_CHAM DX DY DZ
# récupération du nom des colonnes de la table
nomcol = resu['TABLE'].get_nom_para()
#
lst1 = ('INST','NOEUD','NOM_CHAM','NOM_CMP','VALE')
ok1 = True
for para in lst1: ok1 = ok1 and (para in nomcol)
#
lst2 = ('INST','NOEUD','NOM_CHAM','DZ',)
ok2 = True
for para in lst2: ok2 = ok2 and (para in nomcol)
#
if ( not ok1 ^ ok2 ):
print(nomcol)
assert (ok1 ^ ok2)
#
if ( ok1 ):
__ACCE_E=RECU_FONCTION(
TABLE=resu['TABLE'],
PARA_X = 'INST', PARA_Y = 'VALE', INTERPOL= 'LIN',
FILTRE = ( _F(NOM_PARA='NOEUD', VALE_K=node),
_F(NOM_PARA='NOM_CHAM', VALE_K='ACCE' ),
_F(NOM_PARA='NOM_CMP', VALE_K='DZ' ),),
)
#
if ( ok2 ):
__ACCE_E=RECU_FONCTION(
TABLE=resu['TABLE'], PARA_X = 'INST', PARA_Y = 'DZ', INTERPOL= 'LIN',
FILTRE = ( _F(NOM_PARA='NOEUD', VALE_K=node),
_F(NOM_PARA='NOM_CHAM', VALE_K='ACCE' ),),
)
# Etape 2: Combinaisons
if CALCUL=='RELATIF' :
# Combinaison avec fonction d'accélération
motscles={}
if LIST_INST is not None : motscles['LIST_PARA']=LIST_INST
__ACCE_E=CALC_FONCTION(
COMB=( _F(FONCTION=__ACCE_E, COEF= 1.0 ),
_F(FONCTION=resu['ACCE_Z'], COEF= 1.0),),
**motscles
)
val_Acc = NP.array( __ACCE_E.Ordo() )
init = abs(val_Acc[0])/max(abs(val_Acc))
if init>TOLE_INIT:
if CORR_INIT=="OUI":
UTMESS('A','SPECTRAL0_16', valr=(init, TOLE_INIT))
val_Acc[0]=0
__ACCE_E = DEFI_FONCTION(ABSCISSE =__ACCE_E.Absc(),ORDONNEE =val_Acc, NOM_PARA='INST' )
else:
UTMESS('F','SPECTRAL0_16', valr=(init, TOLE_INIT))
freq1 = FREQ_SUPP
# frequence modèle A
omega1=freq1*2.*pi
# frequence modèle B
omega1_=omega1*(1+RAP_MAS)**0.5
# calcul de la fft de l'accelero d entree
# methode 2: CALC_FONCTION pour FFT
_FFTE = CALC_FONCTION(FFT = _F(FONCTION = __ACCE_E, METHODE='COMPLET'))
FFT = NP.array(_FFTE.Ordo()) +complex(0.,1.)*NP.array(_FFTE.OrdoImg())
X = NP.array(_FFTE.Valeurs()[0])
#
RES=[]
cNum = [0]*len(FFT)
cDenom = [0]*len(FFT)
# boucle 4 sur les equipements
for i in range(len(FREQ_EQUI)):
omega = FREQ_EQUI[i]*2.*pi
Delta = -(2.*pi*X[0:len(FFT)])**2 + 2.*complex(0.,1.)*2.*pi*X[0:len(FFT)]*omega*AMOR_EQUI[i] + omega**2
cNum = cNum + RAP_MAS*RAP_MAS_COEF[i]*(Delta+(2.*pi*X[0:len(FFT)])**2)/Delta
cDenom = cDenom + RAP_MAS*RAP_MAS_COEF[i]*(Delta+(2.*pi*X[0:len(FFT)])**2) - RAP_MAS*RAP_MAS_COEF[i]*(Delta+(2.*pi*X[0:len(FFT)])**2)**2/Delta
# Modele B
Delta1_ = -(2.*pi*X[0:len(FFT)])**2 + 2.*complex(0.,1.)*2.*pi*X[0:len(FFT)]*omega1_*AMOR_SUPP*(1+RAP_MAS)**0.5 + omega1_**2
# Modele A
Delta1 = -(2.*pi*X[0:len(FFT)])**2 + 2.*complex(0.,1.)*2.*pi*X[0:len(FFT)]*omega1*AMOR_SUPP + omega1**2
# Calcul de la fonction de transfert
c = (1.+(2.*pi*X[0:len(FFT)])**2*( 1 + cNum)/(Delta1_ + cDenom))/(1+(2.*pi*X[0:len(FFT)])**2/Delta1)
RES = FFT*c
#
# methode 2: CALC_FONCTION pour FFT
val_c=[]
for i in range(len(X)//2):
val_c+=[X[i],RES[i].real,RES[i].imag]
__FRESULT = DEFI_FONCTION(VALE_C =val_c, NOM_PARA='FREQ' )
__ACCEAcor = CALC_FONCTION(FFT = _F(FONCTION = __FRESULT, METHODE='COMPLET', SYME='NON'))
#
# calcul de spectres corriges
motscles={}
if FREQ is not None : motscles['FREQ'] =FREQ
if LIST_FREQ is not None : motscles['LIST_FREQ']=LIST_FREQ
__Spec=[None]*len(AMOR_SPEC)
for amor in range(len(AMOR_SPEC)): # eviter la boucle ??
__Spec[amor] = CALC_FONCTION(
SPEC_OSCI = _F( FONCTION = __ACCEAcor,
AMOR_REDUIT = AMOR_SPEC[amor],
NORME = NORME ,
**motscles) ,
NOM_PARA='FREQ', )
#****************************************************
dico_global['FREQ ' + plancher] = Valeurs(__Spec[amor])[1][0][0]
for amor in range(len(AMOR_SPEC)):
if len(planch_nodes[plancher])>1:
nom = 'IPM '+ plancher + ' ' +node + ' ' + str(int(AMOR_SPEC[amor]*100)) + '%'
else:
nom = 'IPM '+ plancher + ' ' + str(int(AMOR_SPEC[amor]*100)) + '%'
dico_global[nom] = Valeurs(__Spec[amor])[1][0][1]
lListe = []
lkeys = list(dico_global.keys())
lkeys.sort()
for key in lkeys:
lListe.append(_F(LISTE_R=dico_global[key], PARA=key))
tab = CREA_TABLE(
LISTE=lListe, TITRE='Calcul des spectres avec IPM' + '\n #')
return tab
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 crea_resu_local(self, dime, NOM_CHAM, m, resin, mail, nomgrma):
from Utilitai.Utmess import UTMESS
from math import pi, sqrt, atan2, asin
import aster
from code_aster.Cata.Syntax import _F
MODI_REPERE = self.get_cmd('MODI_REPERE')
epsi = 0.00000001
if NOM_CHAM == 'DEPL':
if dime == 2:
LCMP = ['DX', 'DY']
TYPE_CHAM = 'VECT_2D'
elif dime == 3:
LCMP = ['DX', 'DY', 'DZ']
TYPE_CHAM = 'VECT_3D'
elif NOM_CHAM in ('SIGM_NOEU', 'SIEF_ELNO', 'SIGM_ELNO'):
if dime == 2:
LCMP = ['SIXX', 'SIYY', 'SIZZ', 'SIXY']
TYPE_CHAM = 'TENS_2D'
elif dime == 3:
LCMP = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ']
TYPE_CHAM = 'TENS_3D'
elif NOM_CHAM in ('FLUX_ELNO', 'FLUX_NOEU',):
if dime == 2:
LCMP = ['FLUX', 'FLUY', ]
TYPE_CHAM = 'VECT_2D'
elif dime == 3:
LCMP = ['FLUX', 'FLUY', 'FLUZ', ]
TYPE_CHAM = 'VECT_3D'
else:
assert 0
else:
assert 0
if m['TYPE'] == 'SEGMENT' and m['REPERE'] != 'CYLINDRIQUE':
if m['REPERE'] == 'LOCAL':
# --- determination des angles nautiques
cx1 = m['COOR_EXTR'][0] - m['COOR_ORIG'][0]
cx2 = m['COOR_EXTR'][1] - m['COOR_ORIG'][1]
cx3 = 0.
if dime == 3:
cx3 = m['COOR_EXTR'][2] - m['COOR_ORIG'][2]
nvx = sqrt(cx1 ** 2 + cx2 ** 2 + cx3 ** 2)
if abs(nvx) < epsi:
UTMESS('F', 'POST0_1')
cx1 = cx1 / nvx
cx2 = cx2 / nvx
cx3 = cx3 / nvx
if m['VECT_Y']:
cy1 = m['VECT_Y'][0]
cy2 = m['VECT_Y'][1]
cy3 = 0.
if dime == 3:
cy3 = m['VECT_Y'][2]
else:
UTMESS('F', 'POST0_50')
nvy = sqrt(cy1 ** 2 + cy2 ** 2 + cy3 ** 2)
if abs(nvy) < epsi:
UTMESS('F', 'POST0_2')
cy1 = cy1 / nvy
cy2 = cy2 / nvy
cy3 = cy3 / nvy
if ((abs(cx1 - cy1) < epsi and abs(cx2 - cy2) < epsi and abs(cx3 - cy3) < epsi) or
(abs(cx1 + cy1) < epsi and abs(cx2 + cy2) < epsi and abs(cx3 + cy3) < epsi)):
UTMESS('F', 'POST0_3')
if abs(cx1 * cy1 + cx2 * cy2 + cx3 * cy3) > epsi:
cz1 = cx2 * cy3 - cx3 * cy2
cz2 = cx3 * cy1 - cx1 * cy3
cz3 = cx1 * cy2 - cx2 * cy1
nvz = sqrt(cz1 ** 2 + cz2 ** 2 + cz3 ** 2)
cz1 = cz1 / nvz
cz2 = cz2 / nvz
cz3 = cz3 / nvz
cy1 = cz2 * cx3 - cz3 * cx2
cy2 = cz3 * cx1 - cz1 * cx3
cy3 = cz1 * cx2 - cz2 * cx1
nvy = sqrt(cy1 ** 2 + cy2 ** 2 + cy3 ** 2)
cy1 = cy1 / nvy
cy2 = cy2 / nvy
cy3 = cy3 / nvy
UTMESS('A', 'POST0_4', valr=[cy1, cy2, cy3])
else:
cz1 = cx2 * cy3 - cx3 * cy2
cz2 = cx3 * cy1 - cx1 * cy3
cz3 = cx1 * cy2 - cx2 * cy1
beta = 0.
gamma = 0.
if dime == 2:
alpha = atan2(cx2, cx1)
else:
if cx1 ** 2 + cx2 ** 2 > epsi:
alpha = atan2(cx2, cx1)
beta = -asin(cx3)
gamma = atan2(cy3, cz3)
else:
alpha = atan2(-cy1, cy2)
beta = -asin(cx3)
gamma = 0.
alpha = alpha * 180 / pi
beta = beta * 180 / pi
gamma = gamma * 180 / pi
elif m['REPERE'] == 'UTILISATEUR':
alpha = m['ANGL_NAUT'][0]
beta = m['ANGL_NAUT'][1]
gamma = m['ANGL_NAUT'][2]
motscles = {}
motscles['MODI_CHAM'] = []
motscles['AFFE'] = []
motscles['MODI_CHAM'].append(
_F(NOM_CHAM=NOM_CHAM, NOM_CMP=LCMP, TYPE_CHAM=TYPE_CHAM),)
ANGL_NAUT = []
ANGL_NAUT.append(alpha)
if dime == 3:
ANGL_NAUT.append(beta)
ANGL_NAUT.append(gamma)
motscles['AFFE'].append(_F(ANGL_NAUT=ANGL_NAUT),)
__remodr = MODI_REPERE(
RESULTAT=resin, REPERE='UTILISATEUR', **motscles)
if m['TYPE'] == 'ARC':
if m['REPERE'] == 'CYLINDRIQUE':
motscles = {}
motscles['MODI_CHAM'] = []
motscles['AFFE'] = []
motscles['MODI_CHAM'].append(
_F(NOM_CHAM=NOM_CHAM, NOM_CMP=LCMP, TYPE_CHAM=TYPE_CHAM),)
ORIGINE = []
ORIGINE.append(m['CENTRE'][0])
ORIGINE.append(m['CENTRE'][1])
if dime == 3:
ORIGINE.append(m['CENTRE'][2])
AXE_Z = []
AXE_Z.append(m['DNOR'][0])
AXE_Z.append(m['DNOR'][1])
AXE_Z.append(m['DNOR'][2])
motscles['AFFE'].append(_F(ORIGINE=ORIGINE, AXE_Z=AXE_Z),)
elif dime == 2:
motscles['AFFE'].append(_F(ORIGINE=ORIGINE,),)
__remodr = MODI_REPERE(
RESULTAT=resin, REPERE='CYLINDRIQUE', **motscles)
else:
UTMESS('F', 'POST0_5', valk=[m['TYPE'], m['REPERE']])
if m['TYPE'][:5] == 'GROUP' or m['TYPE'] == 'SEGMENT':
if m['TYPE'][:5] == 'GROUP' and m['REPERE'] == 'LOCAL':
# determination du repère local (v1,v2,v3)
# ---------------------------------------
noma = mail.nom
collgrma = aster.getcolljev(noma.ljust(8) + '.GROUPEMA')
collcnx = aster.getcolljev(noma.ljust(8) + '.CONNEX')
coord = aster.getvectjev(noma.ljust(8) + '.COORDO .VALE')
cnom = aster.getvectjev(noma.ljust(8) + '.NOMNOE')
numa = collgrma[nomgrma.ljust(24)]
dictu = {}
# initialisations
for ima in numa:
n1 = collcnx[ima][0]
n2 = collcnx[ima][1]
dictu[n1] = []
dictu[n2] = []
# determination du vecteur tangent (v1) + normalisation
for ima in numa:
vectu1 = []
vectu2 = []
n1 = collcnx[ima][0]
n2 = collcnx[ima][1]
ux = coord[3 * (n2 - 1)] - coord[3 * (n1 - 1)]
uy = coord[3 * (n2 - 1) + 1] - coord[3 * (n1 - 1) + 1]
vectu1.append(ux)
vectu1.append(uy)
vectu2.append(ux)
vectu2.append(uy)
if dime == 3:
uz = coord[3 * (n2 - 1) + 2] - coord[3 * (n1 - 1) + 2]
vectu1.append(uz)
vectu2.append(uz)
dictu[n1].append(vectu1)
dictu[n2].append(vectu2)
for i in dictu:
if len(dictu[i]) == 2:
dictu[i][0][0] = dictu[i][0][0] + dictu[i][1][0]
dictu[i][0][1] = dictu[i][0][1] + dictu[i][1][1]
if dime == 3:
dictu[i][0][2] = dictu[i][0][2] + dictu[i][1][2]
del dictu[i][1]
for i in dictu:
if dime == 2:
norm = sqrt(dictu[i][0][0] ** 2 + dictu[i][0][1] ** 2)
dictu[i][0][0] = dictu[i][0][0] / norm
dictu[i][0][1] = dictu[i][0][1] / norm
elif dime == 3:
norm = sqrt(
dictu[i][0][0] ** 2 + dictu[i][0][1] ** 2 + dictu[i][0][2] ** 2)
dictu[i][0][0] = dictu[i][0][0] / norm
dictu[i][0][1] = dictu[i][0][1] / norm
dictu[i][0][2] = dictu[i][0][2] / norm
# determination du vecteur normal (v2):
# on projete VECT_Y sur le plan orthogonal au vecteur v1.
# (ce vecteur normal est obtenu par 2 produits vectoriels successifs en 3D)
if dime == 3:
norm = sqrt(m['VECT_Y'][0] ** 2 + m[
'VECT_Y'][1] ** 2 + m['VECT_Y'][2] ** 2)
tmpy = [m['VECT_Y'][0] / norm, m[
'VECT_Y'][1] / norm, m['VECT_Y'][2] / norm]
j = 0
__resu = [None] * (len(dictu) + 1)
__resu[0] = resin
for i in dictu:
j = j + 1
vecty = []
if dime == 2:
vecty.append(-dictu[i][0][1])
vecty.append(dictu[i][0][0])
dictu[i].append(vecty)
elif dime == 3:
# v3= v1 vectoriel vect_y
vectz = []
vectz.append(
dictu[i][0][1] * tmpy[2] - dictu[i][0][2] * tmpy[1])
vectz.append(
dictu[i][0][2] * tmpy[0] - dictu[i][0][0] * tmpy[2])
vectz.append(
dictu[i][0][0] * tmpy[1] - dictu[i][0][1] * tmpy[0])
normz = sqrt(vectz[0] ** 2 + vectz[1] ** 2 + vectz[2] ** 2)
vectz[0] = vectz[0] / normz
vectz[1] = vectz[1] / normz
vectz[2] = vectz[2] / normz
vecty.append(
vectz[1] * dictu[i][0][2] - vectz[2] * dictu[i][0][1])
vecty.append(
vectz[2] * dictu[i][0][0] - vectz[0] * dictu[i][0][2])
vecty.append(
vectz[0] * dictu[i][0][1] - vectz[1] * dictu[i][0][0])
normy = sqrt(vecty[0] ** 2 + vecty[1] ** 2 + vecty[2] ** 2)
vecty[0] = vecty[0] / normy
vecty[1] = vecty[1] / normy
vecty[2] = vecty[2] / normy
dictu[i].append(vecty)
dictu[i].append(vectz)
cx1 = dictu[i][0][0]
cx2 = dictu[i][0][1]
cy1 = dictu[i][1][0]
cy2 = dictu[i][1][1]
if dime == 3:
cx3 = dictu[i][0][2]
cy3 = dictu[i][1][2]
cz1 = dictu[i][2][0]
cz2 = dictu[i][2][1]
cz3 = dictu[i][2][2]
# determination des angles nautiques (alpha,beta,gamma)
# ----------------------------------------------------
beta = 0.
gamma = 0.
if dime == 2:
alpha = atan2(cx2, cx1)
else:
if cx1 ** 2 + cx2 ** 2 > epsi:
alpha = atan2(cx2, cx1)
beta = -asin(cx3)
gamma = atan2(cy3, cz3)
else:
alpha = atan2(-cy1, cy2)
beta = -asin(cx3)
gamma = 0.
alpha = alpha * 180 / pi
beta = beta * 180 / pi
gamma = gamma * 180 / pi
motscles = {}
motscles['MODI_CHAM'] = []
motscles['AFFE'] = []
noeu = dictu.keys()
motscles['MODI_CHAM'].append(
_F(NOM_CHAM=NOM_CHAM, NOM_CMP=LCMP, TYPE_CHAM=TYPE_CHAM,),)
ANGL_NAUT = []
ANGL_NAUT.append(alpha)
if dime == 3:
ANGL_NAUT.append(beta)
ANGL_NAUT.append(gamma)
motscles['AFFE'].append(
_F(ANGL_NAUT=ANGL_NAUT, NOEUD=cnom[noeu[j - 1] - 1]),)
__resu[j] = MODI_REPERE(
RESULTAT=__resu[j - 1], REPERE='UTILISATEUR', **motscles)
__remodr = __resu[j]
motscles = {}
motscles['MODI_CHAM'] = []
motscles['AFFE'] = []
motscles['MODI_CHAM'].append(
_F(NOM_CHAM=NOM_CHAM, NOM_CMP=LCMP, TYPE_CHAM=TYPE_CHAM),)
if m['REPERE'] == 'CYLINDRIQUE':
if dime == 3:
motscles['AFFE'].append(
_F(ORIGINE=m['ORIGINE'], AXE_Z=m['AXE_Z']),)
elif dime == 2:
motscles['AFFE'].append(_F(ORIGINE=m['ORIGINE'],),)
__remodr = MODI_REPERE(
RESULTAT=resin, REPERE='CYLINDRIQUE', **motscles)
elif m['REPERE'] == 'UTILISATEUR':
alpha = m['ANGL_NAUT'][0]
beta = m['ANGL_NAUT'][1]
gamma = m['ANGL_NAUT'][2]
ANGL_NAUT = []
ANGL_NAUT.append(alpha)
if dime == 3:
ANGL_NAUT.append(beta)
ANGL_NAUT.append(gamma)
motscles['AFFE'].append(_F(ANGL_NAUT=ANGL_NAUT),)
__remodr = MODI_REPERE(
RESULTAT=resin, REPERE='UTILISATEUR', **motscles)
return __remodr
def macr_spectre_ops(self, **args):
"""
Ecriture de la macro MACR_SPECTRE
"""
MAILLAGE = args.get("MAILLAGE")
PLANCHER = args.get("PLANCHER")
NOM_CHAM = args.get("NOM_CHAM")
CALCUL = args.get("CALCUL")
RESU = args.get("RESU")
IMPRESSION = args.get("IMPRESSION")
FREQ = args.get("FREQ")
LIST_FREQ = args.get("LIST_FREQ")
LIST_INST = args.get("LIST_INST")
AMOR_SPEC = args.get("AMOR_SPEC")
EnumType = (list, tuple)
# On importe les definitions des commandes a utiliser dans la macro
# construction de la liste des noeuds à traiter
planch_nodes = {}
if (MAILLAGE):
dic_gpno = aster.getcolljev(MAILLAGE.getName().ljust(8) + ".GROUPENO")
l_nodes = aster.getvectjev(MAILLAGE.getName().ljust(8) + ".NOMNOE")
l_plancher = []
l_batiment = []
l_commentaire = []
#
dplancher = []
for j in PLANCHER:
dplancher.append(j.cree_dict_valeurs(j.mc_liste))
#
for plancher in dplancher:
liste_no = []
clefs = list(plancher.keys())
if ('NOEUD' in clefs):
if plancher['NOEUD'] is not None:
if type(plancher['NOEUD']) == str:
liste_no.append(plancher['NOEUD'])
else:
for noeud in plancher['NOEUD']:
liste_no.append(noeud)
if ('GROUP_NO' in clefs):
if plancher['GROUP_NO'] is not None:
assert (MAILLAGE is not None)
if type(plancher['GROUP_NO']) == str:
noms_no = [
l_nodes[n - 1].strip()
for n in dic_gpno[plancher['GROUP_NO'].ljust(24)]
]
liste_no = liste_no + noms_no
else:
for group_no in plancher['GROUP_NO']:
noms_no = [
l_nodes[n - 1].strip()
for n in dic_gpno[group_no.ljust(24)]
]
liste_no = liste_no + noms_no
planch_nodes[plancher['NOM']] = liste_no
l_plancher.append(plancher['NOM'])
l_batiment.append(plancher['BATIMENT'])
l_commentaire.append(plancher['COMMENTAIRE'])
if AMOR_SPEC is not None and type(AMOR_SPEC) not in EnumType:
AMOR_SPEC = (AMOR_SPEC, )
#
if NOM_CHAM == 'ACCE':
dico_glob = {}
if NOM_CHAM == 'DEPL':
dico_glob = {
'DX_max': [],
'DY_max': [],
'DZ_max': [],
'DH_max': [],
}
#
# ---------------------------------------------------------------------------------------------
# boucle 1 sur les planchers
for plancher in l_plancher:
#
if NOM_CHAM == 'ACCE':
__moy_x = [None] * len(planch_nodes[plancher])
__moy_y = [None] * len(planch_nodes[plancher])
__moy_z = [None] * len(planch_nodes[plancher])
if NOM_CHAM == 'DEPL':
dicDmax = {}
# -----------------------------------------------------------------------------------------
# boucle 2 sur les noeuds du plancher
indexn = 0
for node in planch_nodes[plancher]:
# -------------------------------------------------------------------------------------
# boucle 3 sur les directions (X,Y,Z)
for dd in ('X', 'Y', 'Z'):
# ---------------------------------------------------------------------------------
# boucle 4 sur les résultats
l_fonc = []
for resu in RESU:
# Etape 1: Récupération des fonctions
motscles = {}
if resu['RESU_GENE'] is not None:
if CALCUL == 'ABSOLU' and args.get(
'MULT_APPUI') is not None:
motscles['MULT_APPUI'] = args['MULT_APPUI']
#
motscles['RESU_GENE'] = resu['RESU_GENE']
__spo = RECU_FONCTION(NOM_CHAM=NOM_CHAM,
TOUT_ORDRE='OUI',
NOM_CMP='D' + dd,
INTERPOL='LIN',
PROL_GAUCHE='CONSTANT',
PROL_DROITE='CONSTANT',
NOEUD=node,
**motscles)
elif args.get('MULT_APPUI') is not None:
UTMESS('F', 'SPECTRAL0_13')
#
if resu['RESULTAT'] is not None:
motscles['RESULTAT'] = resu['RESULTAT']
__spo = RECU_FONCTION(NOM_CHAM=NOM_CHAM,
TOUT_ORDRE='OUI',
NOM_CMP='D' + dd,
INTERPOL='LIN',
PROL_GAUCHE='CONSTANT',
PROL_DROITE='CONSTANT',
NOEUD=node,
**motscles)
#
if resu['TABLE'] is not None:
# 2 formats de table possible. Avec les colonnes :
# INST NOEUD NOM_CHAM NOM_CMP VALE
# INST NOEUD NOM_CHAM DX DY DZ
# récupération du nom des colonnes de la table
nomcol = resu['TABLE'].get_nom_para()
#
lst1 = ('INST', 'NOEUD', 'NOM_CHAM', 'NOM_CMP', 'VALE')
ok1 = True
for para in lst1:
ok1 = ok1 and (para in nomcol)
#
lst2 = (
'INST',
'NOEUD',
'NOM_CHAM',
'D' + dd,
)
ok2 = True
for para in lst2:
ok2 = ok2 and (para in nomcol)
#
if (not ok1 ^ ok2):
print(nomcol)
assert (ok1 ^ ok2)
#
if (ok1):
__spo = RECU_FONCTION(
TABLE=resu['TABLE'],
PARA_X='INST',
PARA_Y='VALE',
INTERPOL='LIN',
FILTRE=(
_F(NOM_PARA='NOEUD', VALE_K=node),
_F(NOM_PARA='NOM_CHAM', VALE_K=NOM_CHAM),
_F(NOM_PARA='NOM_CMP', VALE_K='D' + dd),
),
)
#
if (ok2):
__spo = RECU_FONCTION(
TABLE=resu['TABLE'],
PARA_X='INST',
PARA_Y='D' + dd,
INTERPOL='LIN',
FILTRE=(
_F(NOM_PARA='NOEUD', VALE_K=node),
_F(NOM_PARA='NOM_CHAM', VALE_K=NOM_CHAM),
),
)
#
# Etape 2: Combinaisons
if NOM_CHAM == 'ACCE':
# Accelerations relatives
if CALCUL == 'RELATIF':
# Combinaison avec fonction d'accélération
motscles = {}
if LIST_INST is not None:
motscles['LIST_PARA'] = LIST_INST
__spo = CALC_FONCTION(COMB=(
_F(FONCTION=__spo, COEF=1.0),
_F(FONCTION=resu['ACCE_' + dd], COEF=1.0),
),
**motscles)
# Etape 3: Calcul des spectres d'oscillateur
motscles = {}
if FREQ is not None:
motscles['FREQ'] = FREQ
if LIST_FREQ is not None:
motscles['LIST_FREQ'] = LIST_FREQ
__spo = CALC_FONCTION(
SPEC_OSCI=_F(FONCTION=__spo,
AMOR_REDUIT=AMOR_SPEC,
NORME=args['NORME'],
**motscles))
l_fonc.append(__spo)
elif NOM_CHAM == 'DEPL':
if CALCUL == 'ABSOLU':
# On retranche les deplacements d entrainement
motscles = {}
if LIST_INST is not None:
motscles['LIST_PARA'] = LIST_INST
__spo = CALC_FONCTION(COMB=(
_F(FONCTION=__spo, COEF=1.0),
_F(FONCTION=resu['DEPL_' + dd], COEF=-1.0),
),
**motscles)
l_fonc.append(__spo)
# fin boucle 4 sur les résultats
# ---------------------------------------------------------------------------------
#
# calcul de la moyenne sur les resultats à noeud et direction
# fixes
nbresu = len(RESU)
if NOM_CHAM == 'ACCE':
mcfCMBx = []
mcfCMBy = []
mcfCMBz = []
for spo in l_fonc:
mcfCMBx.append(
_F(
FONCTION=spo,
COEF=1. / float(nbresu),
))
mcfCMBy.append(
_F(
FONCTION=spo,
COEF=1. / float(nbresu),
))
mcfCMBz.append(
_F(
FONCTION=spo,
COEF=1. / float(nbresu),
))
motscles = {}
if LIST_FREQ is not None:
motscles['LIST_PARA'] = LIST_FREQ
if dd == 'X':
__moy_x[indexn] = CALC_FONCTION(COMB=mcfCMBx,
**motscles)
if dd == 'Y':
__moy_y[indexn] = CALC_FONCTION(COMB=mcfCMBy,
**motscles)
if dd == 'Z':
__moy_z[indexn] = CALC_FONCTION(COMB=mcfCMBz,
**motscles)
#
elif NOM_CHAM == 'DEPL':
moy = 0.
for spo in l_fonc:
fspo = spo.convert()
aspo = fspo.abs()
vmax = aspo.extreme()['max']
moy = moy + vmax[-1][-1]
dicDmax[(node, dd)] = moy / nbresu
# fin boucle 3 sur les directions
# -------------------------------------------------------------------------------------
#
# impressions en chaque noeud
if NOM_CHAM == 'ACCE' and IMPRESSION is not None:
if IMPRESSION['TOUT'] == 'OUI':
__moyxa = [None] * len(AMOR_SPEC)
__moyya = [None] * len(AMOR_SPEC)
__moyza = [None] * len(AMOR_SPEC)
for i in range(len(AMOR_SPEC)):
__moyxa[i] = RECU_FONCTION(NAPPE=__moy_x[indexn],
VALE_PARA_FONC=AMOR_SPEC[i])
__moyya[i] = RECU_FONCTION(NAPPE=__moy_y[indexn],
VALE_PARA_FONC=AMOR_SPEC[i])
__moyza[i] = RECU_FONCTION(NAPPE=__moy_z[indexn],
VALE_PARA_FONC=AMOR_SPEC[i])
motscles = {}
dI = IMPRESSION[0].cree_dict_valeurs(
IMPRESSION[0].mc_liste)
if 'PILOTE' in dI:
motscles['PILOTE'] = IMPRESSION['PILOTE']
if IMPRESSION['FORMAT'] != 'TABLEAU':
motscles['ECHELLE_X'] = 'LOG'
if IMPRESSION['TRI'] == 'AMOR_SPEC':
for i in range(len(AMOR_SPEC)):
TITRE = 'Spectres / Plancher = ' + plancher + \
' / amor=' + \
str(AMOR_SPEC[i]) + ' / noeud=' + node
IMPR_FONCTION(FORMAT=IMPRESSION['FORMAT'],
UNITE=IMPRESSION['UNITE'],
COURBE=(
_F(
FONCTION=__moyxa[i],
LEGENDE='X',
),
_F(
FONCTION=__moyya[i],
LEGENDE='Y',
),
_F(
FONCTION=__moyza[i],
LEGENDE='Z',
),
),
TITRE=TITRE,
**motscles)
elif IMPRESSION['TRI'] == 'DIRECTION':
for dd in ('X', 'Y', 'Z'):
TITRE = 'Spectres / Plancher = ' + plancher + \
' / direction = ' + dd + ' / noeud = ' + node
legende = 'amor=' + str(AMOR_SPEC[i])
if dd == 'X':
l_fonc = [
_F(
FONCTION=__moyxa[i],
LEGENDE=legende,
) for i in range(len(AMOR_SPEC))
]
if dd == 'Y':
l_fonc = [
_F(
FONCTION=__moyya[i],
LEGENDE=legende,
) for i in range(len(AMOR_SPEC))
]
if dd == 'Z':
l_fonc = [
_F(
FONCTION=__moyza[i],
LEGENDE=legende,
) for i in range(len(AMOR_SPEC))
]
IMPR_FONCTION(FORMAT=IMPRESSION['FORMAT'],
UNITE=IMPRESSION['UNITE'],
COURBE=l_fonc,
TITRE=TITRE,
**motscles)
# increment de l'indice de noeud
indexn = indexn + 1
# fin boucle 2 sur les noeuds du plancher
# -----------------------------------------------------------------------------------------
#
# Etape 4: Calcul des enveloppes des spectres ou des deplacements max
if NOM_CHAM == 'ACCE':
mcslx = []
mcsly = []
mcslz = []
indexn = 0
for node in planch_nodes[plancher]:
mcslx.append(__moy_x[indexn])
mcsly.append(__moy_y[indexn])
mcslz.append(__moy_z[indexn])
indexn = indexn + 1
__snx = CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcslx))
__sny = CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcsly))
__snz = CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcslz))
__snh = CALC_FONCTION(ENVELOPPE=_F(FONCTION=(__snx, __sny)))
elif NOM_CHAM == 'DEPL':
DRmX = max(
[dicDmax[(node, 'X')] for node in planch_nodes[plancher]])
DRmY = max(
[dicDmax[(node, 'Y')] for node in planch_nodes[plancher]])
DRmZ = max(
[dicDmax[(node, 'Z')] for node in planch_nodes[plancher]])
DRmH = max([DRmX, DRmY])
#
# Renseignement de la table finale des résultats
if NOM_CHAM == 'ACCE':
nbind = len(AMOR_SPEC)
for i in range(nbind):
dico_glob['FREQ'] = __snx.Valeurs()[1][i][0]
dico_glob['eX_%d_%s' %
(i, plancher)] = __snx.Valeurs()[1][i][1]
dico_glob['eY_%d_%s' %
(i, plancher)] = __sny.Valeurs()[1][i][1]
dico_glob['eZ_%d_%s' %
(i, plancher)] = __snz.Valeurs()[1][i][1]
dico_glob['eH_%d_%s' %
(i, plancher)] = __snh.Valeurs()[1][i][1]
elif NOM_CHAM == 'DEPL':
dico_glob['DX_max'].append(DRmX)
dico_glob['DY_max'].append(DRmY)
dico_glob['DZ_max'].append(DRmZ)
dico_glob['DH_max'].append(DRmH)
#
# Etape 5: Impression des courbes
if NOM_CHAM == 'ACCE' and IMPRESSION is not None:
motscles = {}
dI = IMPRESSION[0].cree_dict_valeurs(IMPRESSION[0].mc_liste)
if 'PILOTE' in dI:
motscles['PILOTE'] = IMPRESSION['PILOTE']
if IMPRESSION['FORMAT'] != 'TABLEAU':
motscles['ECHELLE_X'] = 'LOG'
__snxa = [None] * len(AMOR_SPEC)
__snya = [None] * len(AMOR_SPEC)
__snza = [None] * len(AMOR_SPEC)
__snha = [None] * len(AMOR_SPEC)
for i in range(nbind):
__snxa[i] = RECU_FONCTION(
NAPPE=__snx,
VALE_PARA_FONC=AMOR_SPEC[i],
)
__snya[i] = RECU_FONCTION(
NAPPE=__sny,
VALE_PARA_FONC=AMOR_SPEC[i],
)
__snza[i] = RECU_FONCTION(
NAPPE=__snz,
VALE_PARA_FONC=AMOR_SPEC[i],
)
__snha[i] = RECU_FONCTION(
NAPPE=__snh,
VALE_PARA_FONC=AMOR_SPEC[i],
)
if IMPRESSION['TRI'] == 'AMOR_SPEC':
for i in range(nbind):
TITRE = 'Spectres moyens / Plancher = ' + \
plancher + ' / amor=' + str(AMOR_SPEC[i])
IMPR_FONCTION(FORMAT=IMPRESSION['FORMAT'],
UNITE=IMPRESSION['UNITE'],
COURBE=(
_F(
FONCTION=__snxa[i],
LEGENDE='X',
),
_F(
FONCTION=__snya[i],
LEGENDE='Y',
),
_F(
FONCTION=__snza[i],
LEGENDE='Z',
),
_F(
FONCTION=__snha[i],
LEGENDE='H',
),
),
TITRE=TITRE,
**motscles)
elif IMPRESSION['TRI'] == 'DIRECTION':
for dd in ('X', 'Y', 'Z', 'H'):
TITRE = 'Spectres moyens / Plancher = ' + \
plancher + ' / direction = ' + dd
legende = 'amor=' + str(AMOR_SPEC[i])
l_fonc = []
if dd == 'X':
l_fonc = [
_F(
FONCTION=__snxa[i],
LEGENDE=legende,
) for i in range(len(AMOR_SPEC))
]
if dd == 'Y':
l_fonc = [
_F(
FONCTION=__snya[i],
LEGENDE=legende,
) for i in range(len(AMOR_SPEC))
]
if dd == 'Z':
l_fonc = [
_F(
FONCTION=__snza[i],
LEGENDE=legende,
) for i in range(len(AMOR_SPEC))
]
if dd == 'H':
l_fonc = [
_F(
FONCTION=__snha[i],
LEGENDE=legende,
) for i in range(len(AMOR_SPEC))
]
IMPR_FONCTION(FORMAT=IMPRESSION['FORMAT'],
UNITE=IMPRESSION['UNITE'],
COURBE=l_fonc,
TITRE=TITRE,
**motscles)
# fin boucle 1 sur les planchers
# ---------------------------------------------------------------------------------------------
#
# Etape6 : Renseignement de la table finale des résultats
lListe = []
nb_amor = 0
if NOM_CHAM == 'DEPL':
titre = 'Calcul des spectres enveloppes'
elif NOM_CHAM == 'ACCE':
titre = 'Calcul des spectres enveloppes par planchers'
infos_amor = {}
infos_amor['NUME_AMOR'] = []
infos_amor['AMOR'] = []
nb_amor = len(AMOR_SPEC)
for i in range(len(AMOR_SPEC)):
infos_amor['NUME_AMOR'].append(i)
infos_amor['AMOR'].append(AMOR_SPEC[i])
nb_plancher = len(l_plancher)
lkeys = list(dico_glob.keys())
lkeys.sort()
for key in lkeys:
nb_lignes = len(dico_glob[key])
lListe.append(
_F(LISTE_R=dico_glob[key],
PARA=key,
NUME_LIGN=list(
range(nb_amor + nb_plancher + 1,
nb_amor + nb_plancher + nb_lignes + 1))))
if NOM_CHAM == 'ACCE':
lListe.append(
_F(LISTE_I=infos_amor['NUME_AMOR'],
PARA='NUME_AMOR',
NUME_LIGN=list(range(nb_plancher + 1,
nb_plancher + nb_amor + 1))))
lListe.append(
_F(LISTE_R=infos_amor['AMOR'],
PARA='AMOR',
NUME_LIGN=list(range(nb_plancher + 1,
nb_plancher + nb_amor + 1))))
lListe.append(_F(LISTE_K=l_plancher, TYPE_K='K24', PARA='NOM'))
l_bat = [i for i in l_batiment if i is not None]
l_com = [i for i in l_commentaire if i is not None]
if l_bat != []:
l_bat2 = ['-' if i is None else i for i in l_batiment]
lListe.append(_F(LISTE_K=l_bat2, TYPE_K='K24', PARA='BATIMENT'))
if l_com != []:
l_com2 = ['-' if i is None else i for i in l_commentaire]
lListe.append(_F(LISTE_K=l_com2, TYPE_K='K24', PARA='COMMENTAIRE'))
tab = CREA_TABLE(LISTE=lListe, TITRE=titre)
return tab
def macr_lign_coupe_ops(self,
LIGN_COUPE,
RESULTAT=None,
CHAM_GD=None,
NOM_CHAM=None,
MODELE=None,
**args):
"""
Ecriture de la macro MACR_LIGN_COUPE
"""
# La valeur par défaut n'est pas dans le catalogue, sinon le mot-clé devient
# obligatoire dans AsterStudy
UNITE_MAILLAGE = args.get("UNITE_MAILLAGE")
if not UNITE_MAILLAGE:
logical_unit = LogicalUnitFile.new_free(access=FileAccess.New)
UNITE_MAILLAGE = logical_unit.unit
# On importe les definitions des commandes a utiliser dans la macro
#
MasquerAlarme('ALGORITH12_43')
MasquerAlarme('CALCULEL2_63')
MasquerAlarme('CALCULEL2_64')
MasquerAlarme('MODELISA5_53')
MasquerAlarme('MODELE1_58')
MasquerAlarme('MODELE1_63')
MasquerAlarme('MODELE1_64')
mcORDR = {}
Model = MODELE
Mesh = None
l_mode_meca_sans_modele = False
if RESULTAT is not None:
if 'NUME_ORDRE' in args:
mcORDR['NUME_ORDRE'] = args['NUME_ORDRE']
elif 'NUME_MODE' in args:
mcORDR['NUME_MODE'] = args['NUME_MODE']
elif 'LIST_ORDRE' in args:
mcORDR['LIST_ORDRE'] = args['LIST_ORDRE']
elif 'INST' in args:
mcORDR['INST'] = args['INST']
mcORDR['CRITERE'] = args['CRITERE']
mcORDR['PRECISION'] = args['PRECISION']
elif 'LIST_INST' in args:
mcORDR['LIST_INST'] = args['LIST_INST']
mcORDR['CRITERE'] = args['CRITERE']
mcORDR['PRECISION'] = args['PRECISION']
else:
mcORDR['TOUT_ORDRE'] = 'OUI'
type_resu = RESULTAT.getType().lower()
model = RESULTAT.getModel()
if (model is None) or (model.getName() in ('', '#AUCUN')):
if MODELE is None:
if (type_resu != 'mode_meca'):
UTMESS('F', 'POST0_9', valk=RESULTAT.getName())
# 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
Mesh = RESULTAT.getMesh()
UTMESS('I', 'POST0_23', valk=RESULTAT.getName())
else:
Mesh = model.getMesh()
if Model is None:
Model = model
if Mesh is None:
raise Exception("Empty mesh")
elif CHAM_GD is not None:
mcORDR['TOUT_ORDRE'] = 'OUI'
if Model is None:
UTMESS('F', 'POST0_10')
# récupération de la grandeur du champ
n_cham = CHAM_GD.getName()
catagd = aster.getvectjev("&CATA.GD.NOMGD")
desc = aster.getvectjev('%-19s.DESC' % n_cham)
if desc is not 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 : ' + nomgd
# 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
# Maillage sur lequel s'appuie le résultat à projeter
if Mesh is None:
Mesh = Model.getMesh()
# le maillage est-il 2D ou 3D ?
n_mailla = Mesh.getName()
dime = Mesh.getDimension()
collgrma = aster.getcolljev(n_mailla.ljust(8) + '.GROUPEMA')
collgrno = aster.getcolljev(n_mailla.ljust(8) + '.GROUPENO')
typma = aster.getvectjev(n_mailla.ljust(8) + '.TYPMAIL')
ltyma = aster.getvectjev("&CATA.TM.NOMTM")
lignes = []
groups = []
arcs = []
minidim = dime
for m in LIGN_COUPE:
if m['TYPE'] == 'SEGMENT':
coor_orig = get_coor(m, 'ORIG', collgrno, n_mailla)
coor_extr = get_coor(m, 'EXTR', collgrno, n_mailla)
lignes.append((coor_orig, coor_extr, m['NB_POINTS']))
minidim = min(minidim, len(coor_orig), len(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 list(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 list(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.getName().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)
nomFichierSortie = LogicalUnitFile.filename_from_unit(UNITE_MAILLAGE)
with open(nomFichierSortie, 'w') as fproc:
fproc.write(os.linesep.join(resu_mail))
# Lecture du maillage de seg2 contenant toutes les lignes de coupe
__macou = LIRE_MAILLAGE(
FORMAT='ASTER',
UNITE=UNITE_MAILLAGE,
)
LogicalUnitFile.release_from_number(UNITE_MAILLAGE)
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)
# issue27543 : l'utilisation d'un modèle n'est pas utile et elle
# engendrait dans le cas thermique l'émission des alarmes MODELE1_3 et MODELE1_53
# Dans le cas où il y aurait besoin de réintroduire les modèles, j'ai remplacé
# la modélisation PLAN par COQUE (laissée en commentaire) ce qui permet également
# de supprimer les alarmes.
motscles = {}
motscles.update(mcORDR)
motscles['VIS_A_VIS'] = []
if 'VIS_A_VIS' in args:
for v in args['VIS_A_VIS']:
if v['GROUP_MA_1'] is not None:
motscles['VIS_A_VIS'].append(
_F(GROUP_MA_1=v['GROUP_MA_1'], TOUT_2='OUI'), )
elif v['MAILLE_1'] is not 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):
__recou = PROJ_CHAMP(
METHODE='COLLOCATION',
RESULTAT=RESULTAT,
MODELE_1=Model,
DISTANCE_MAX=m['DISTANCE_MAX'],
# issue27543 #MODELE_2=__mocou,
MAILLAGE_2=__macou,
TYPE_CHAM='NOEU',
NOM_CHAM=NOM_CHAM,
**motscles)
else:
__recou = PROJ_CHAMP(
METHODE='COLLOCATION',
RESULTAT=RESULTAT,
MAILLAGE_1=Mesh,
DISTANCE_MAX=m['DISTANCE_MAX'],
# issue27543 #MODELE_2=__mocou,
MAILLAGE_2=__macou,
TYPE_CHAM='NOEU',
NOM_CHAM=NOM_CHAM,
**motscles)
__remodr = __recou
icham = 0
ioc2 = 0
mcACTION = []
if RESULTAT.getType().lower() in ('evol_ther', 'evol_elas', 'evol_noli',
'mode_meca', 'evol_varc', 'comb_fourier',
'mult_elas', 'fourier_elas',
'dyna_trans'):
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'] is not None:
motscles['NOM_CMP'] = m['NOM_CMP']
if m['TRAC_NOR'] is not None:
motscles['TRAC_NOR'] = m['TRAC_NOR']
elif m['TRAC_DIR'] is not None:
motscles['TRAC_DIR'] = m['TRAC_DIR']
motscles['DIRECTION'] = m['DIRECTION']
elif m['INVARIANT'] is not None:
motscles['INVARIANT'] = m['INVARIANT']
elif m['RESULTANTE'] is not None:
motscles['RESULTANTE'] = m['RESULTANTE']
if m['MOMENT'] is not None:
motscles['MOMENT'] = m['MOMENT']
motscles['POINT'] = m['POINT']
elif m['ELEM_PRINCIPAUX'] is not 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'] is not 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
dictab = __tabitm.EXTR_TABLE()
# Ajout de la colonne theta
if len(arcgma) > 0 and 'ABSC_CURV' in dictab.para:
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()
# Remove TITRE key from the dictionary so that the newly created table uses
# the user-given concept name in its title
dprod.pop('TITRE')
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 nomres
