def prepare_input(self):
"""run prepare data"""
matr_rigi = self.mat_gene_params['MATR_RIGI']
bamo = matr_rigi.getModalBasis()
ddlgene = matr_rigi.getGeneralizedDOFNumbering()
nom_bamo = bamo.getName()
self.mat_gene_params['NUME_DDL'] = ddlgene
self.mat_gene_params['BASE'] = bamo
nom_mail = bamo.getDOFNumbering().getMesh().getName()
self.cohe_params['MAILLAGE'] = nom_mail
_, nbmodt, _ = aster.dismoi('NB_MODES_TOT', nom_bamo,'RESULTAT','F')
_, nbmodd, _ = aster.dismoi('NB_MODES_DYN', nom_bamo,'RESULTAT','F')
_, nbmods, _ = aster.dismoi('NB_MODES_STA', nom_bamo,'RESULTAT','F')
self.mat_gene_params['NBMODD'] = nbmodd
self.mat_gene_params['NBMODS'] = nbmods
self.mat_gene_params['NBMODT'] = nbmodt
_, noe_interf = get_group_nom_coord(
self.interf_params['GROUP_NO_INTERF'], nom_mail)
self.cohe_params['DIST'] = calc_dist2(noe_interf)
self.cohe_params['NOEUDS_INTERF'] = noe_interf
self.interf_params['NBNO'] = len(noe_interf)
if self.INFO==2:
texte1 = 'NOMBRE DE MODES: ' + str(nbmodt)
texte2 = 'MODES DYNAMIQUES: ' + str(nbmodd)
texte3 = 'MODES STATIQUES: ' + str(nbmods)
aster.affiche('MESSAGE', texte1)
aster.affiche('MESSAGE', texte2 + ' - ' + texte3)
if self.case != 'TRANS':
aster.affiche('MESSAGE', 'COMPOSANTE ' + self.NOM_CMP)
else:
aster.affiche('MESSAGE', 'COMPOSANTES ' + ','.join(self.list_NOM_CMP))
aster.affiche('MESSAGE', 'NBNO INTERFACE: ' + str(len(noe_interf)))
def char_grad_ini_ops(self, RESU_H2, GRMAVOL, DIME, INFO, **args):
import aster
from code_aster.Cata.Syntax import _F
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant dans le contexte de la macro
self.DeclareOut('chth', self.sd)
grad = []
# On boucle sur les mailles du groupe de mailles GRMAVOL
# Recuperation du modele a partir du resultat
iret, ibid, __n_modele = aster.dismoi('MODELE', RESU_H2.nom, 'RESULTAT',
'F')
__n_modele = __n_modele.rstrip()
__MOTH = self.get_concept(__n_modele)
# Recuperation du maillage a partir du resultat
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', RESU_H2.nom, 'RESULTAT',
'F')
__MAIL = self.get_concept(nom_ma.strip())
nommai = __MAIL.sdj.NOMMAI.get()
connex = __MAIL.sdj.CONNEX.get()
groupma = __MAIL.sdj.GROUPEMA.get()[GRMAVOL.ljust(24)]
for 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)
# ajout dans le mot-cle facteur PRE_GRAD_TEMP
nom_maille = nommai[ima - 1]
mon_dico = {}
mon_dico["MAILLE"] = nom_maille
mon_dico["FLUX_X"] = 0.
mon_dico["FLUX_Y"] = 0.
if DIME == 3:
mon_dico["FLUX_Z"] = 0.
grad.append(mon_dico)
chth = AFFE_CHAR_THER(
MODELE=__MOTH,
INFO=INFO,
PRE_GRAD_TEMP=grad,
)
def get_modele(self):
"""Recherche le modele associe au resultat. Routine generique pour les dyna_harmo et mode_meca"""
if not self.modele:
if aster.jeveux_exists(self.nom.ljust(19) + '.NOVA'):
iret, ibid, modele_name = aster.dismoi('MODELE', self.nom,
'RESULTAT', 'F')
modele_name = modele_name.rstrip()
if modele_name[0:1] != "#":
self.modele_name = modele_name
self.modele = self.objects.modeles[self.modele_name]
return
# Si cela ne marche pas, on passe par le maillage
if not self.modele:
self.get_maillage()
for m, _mod in self.objects.modeles.items():
if not _mod.maya_name:
_mod.get_maillage()
if _mod.maya_name == self.maya_name:
self.modele_name = m
self.modele = _mod
if not self.modele:
self.mess.disp_mess(
"On ne trouve pas le modele associe au resultat " + self.nom)
UTMESS('A', 'CALCESSAI0_8', valk=(self.nom))
def get_nom_maillage_sdfiss(FISS):
""" retourne le nom du maillage associe au concept FISS"""
import aster
from Utilitai.Utmess import UTMESS
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', FISS.nom, 'FISS_XFEM', 'F')
return nom_ma.strip()
def get_nume(self):
"""Recuperation de la numerotation et du nume_ddl"""
indi = aster.getvectjev(self.nom.ljust(19) + '.INDI')
if indi:
iret, ibid, toto = aster.dismoi('NUME_DDL', self.nom, 'RESU_DYNA',
'C')
self.nume_name = toto.strip()
if self.nume_name:
self.nume = self.objects.nume_ddl[self.nume_name]
def set_from_resu(self, what, resu):
"""Extract a parameter from a result"""
assert what in ('mesh', 'model')
key, typ = {
'mesh': ('NOM_MAILLA', maillage_sdaster),
'model': ('NOM_MODELE', modele_sdaster)
}[what]
nom_co = aster.dismoi(key, resu.nom, 'RESULTAT', 'F')[2].strip()
return self.macro.get_concept_by_type(nom_co, typ)
def get_matrices(self):
""" recuperation des matrices du REFD et du nume_ddl"""
indi = aster.getvectjev(self.nom.ljust(19) + '.INDI')
if indi:
iret, ibid, self.kass_name = aster.dismoi('REF_RIGI_PREM',
self.nom, 'RESU_DYNA',
'C')
iret, ibid, self.mass_name = aster.dismoi('REF_MASS_PREM',
self.nom, 'RESU_DYNA',
'C')
iret, ibid, self.cass_name = aster.dismoi('REF_AMOR_PREM',
self.nom, 'RESU_DYNA',
'C')
try:
self.kass = self.objects.matrices[self.kass_name]
self.mass = self.objects.matrices[self.mass_name]
self.cass = self.objects.matrices[self.cass_name]
except KeyError:
pass
def get_modele_support(self):
"""Recherche dans les resultats des objects CALC_ESSAI le modele mecanique
du support. Remarque: ce resultat contient des modes mecaniques
bidons. Une fois le modele trouve, la matrice de masse, ainsi que
la caracteristique des elements et le champ de materiaux sont
conserves en references.
"""
for name, resu in list(self.objects.resultats.items()):
if aster.jeveux_exists(name.ljust(19) + '.NOVA'):
iret, ibid, modele_name = aster.dismoi(
'MODELE', name, 'RESULTAT', 'F')
modele_name = modele_name.rstrip()
if modele_name[0:1] == "#":
continue
else:
continue
modllu = modele_name
if modllu == self.support_modele.nom:
support_modele = resu.obj
iret, ibid, nom_raideur = aster.dismoi(
'REF_RIGI_PREM', support_modele.nom, 'RESU_DYNA', 'F')
nom_raideur = nom_raideur.strip()
if nom_raideur == self.matr_rig.nom:
iret, ibid, nom_masse = aster.dismoi(
'REF_MASS_PREM', support_modele.nom, 'RESU_DYNA', 'F')
nom_masse = nom_masse.strip()
matr_masse = self.objects.get_matr(nom_masse)
iret, ibid, nume_name = aster.dismoi(
'NUME_DDL', support_modele.nom, 'RESU_DYNA', 'F')
nume_name = nume_name.strip()
numesup = self.objects.nume_ddl[nume_name]
iret, ibid, var_carelem = aster.dismoi(
'CARA_ELEM', name, 'RESULTAT', 'F')
var_carelem = var_carelem.strip()
iret, ibid, var_chmat = aster.dismoi(
'CHAM_MATER', name, 'RESULTAT', 'F')
var_chmat = var_chmat.strip()
break
else:
self.mess.disp_mess("Impossible de trouver le mode meca calcule "
"du modele support")
return
self.support_modele_res = support_modele
self.nume_support_modele = numesup
self.matr_masse = matr_masse
# Caracteristique de l'element et champ de materiaux
# Utiliser pendant la condensation avec MACR_ELEM_STAT
self.cara_elem = self.objects.get_cara_elem(var_carelem)
self.cham_mater = self.objects.get_cham_mater(var_chmat)
def prepare_input(self):
"""run prepare data"""
v_refa_rigi = self.mat_gene_params['MATR_RIGI'].sdj.REFA.get()
nom_bamo = v_refa_rigi[0]
nom_ddlgene = v_refa_rigi[1]
self.mat_gene_params['NUME_DDL'] = self.macro.get_concept(nom_ddlgene)
self.mat_gene_params['BASE'] = self.macro.get_concept(nom_bamo)
ir, ib, nume_ddl = aster.dismoi('NUME_DDL', nom_bamo, 'RESU_DYNA', 'F')
ir, ib, nom_mail = aster.dismoi('NOM_MAILLA', nume_ddl, 'NUME_DDL',
'F')
self.cohe_params['MAILLAGE'] = nom_mail
ir, nbmodt, ib = aster.dismoi('NB_MODES_TOT', nom_bamo, 'RESULTAT',
'F')
ir, nbmodd, ib = aster.dismoi('NB_MODES_DYN', nom_bamo, 'RESULTAT',
'F')
ir, nbmods, ib = aster.dismoi('NB_MODES_STA', nom_bamo, 'RESULTAT',
'F')
self.mat_gene_params['NBMODD'] = nbmodd
self.mat_gene_params['NBMODS'] = nbmods
self.mat_gene_params['NBMODT'] = nbmodt
l_nom, noe_interf = get_group_nom_coord(
self.interf_params['GROUP_NO_INTERF'], nom_mail)
self.cohe_params['DIST'] = calc_dist2(noe_interf)
self.cohe_params['NOEUDS_INTERF'] = noe_interf
self.interf_params['NBNO'] = len(noe_interf)
if self.INFO == 2:
texte1 = 'NOMBRE DE MODES: ' + str(nbmodt)
texte2 = 'MODES DYNAMIQUES: ' + str(nbmodd)
texte3 = 'MODES STATIQUES: ' + str(nbmods)
aster.affiche('MESSAGE', texte1)
aster.affiche('MESSAGE', texte2 + ' - ' + texte3)
if self.case != 'TRANS':
aster.affiche('MESSAGE', 'COMPOSANTE ' + self.NOM_CMP)
else:
aster.affiche('MESSAGE',
'COMPOSANTES ' + ','.join(self.list_NOM_CMP))
aster.affiche('MESSAGE', 'NBNO INTERFACE: ' + str(len(noe_interf)))
def __init__(self, UNITE_MED, MODELE, CARA_ELEM, CHAM_MATER, COMPORTEMENT,
EXCIT, INFO):
"""
Initialisation
"""
import med_aster
self.UNITE_MED = UNITE_MED
self.MODELE = MODELE
self.CARA_ELEM = CARA_ELEM
self.CHAM_MATER = CHAM_MATER
self.COMPORTEMENT = COMPORTEMENT
self.EXCIT = EXCIT
self.INFO = INFO
self.fichier_med = 'fort.%s' % UNITE_MED
dic_champ_med = med_aster.get_nom_champ_med(self.fichier_med)
if type(dic_champ_med) is not dict:
UTMESS('F', 'PLEXUS_50', vali=UNITE_MED)
# Récuperation des concepts de la base
macro = CONTEXT.get_current_step()
#
# Recherche dans le jdc la création du concept CARA_ELEM
if (self.CARA_ELEM != None):
FindEtape = False
self.CARA_ELEM_CONCEPT = self.CARA_ELEM
nomsd = self.CARA_ELEM.get_name()
jdc = CONTEXT.get_current_step().jdc
for UneEtape in jdc.etapes:
if (UneEtape.nom == 'AFFE_CARA_ELEM') and (UneEtape.sdnom
== nomsd):
self.CARA_ELEM = UneEtape
FindEtape = True
break
#
if (not FindEtape):
UTMESS('F', 'PLEXUS_20', valk=[nomsd, 'CARA_ELEM'])
#
else:
self.CARA_ELEM_CONCEPT = None
#
# récuperation du maillage
nom_MODELE = self.MODELE.get_name()
iret, ibid, nomsd = aster.dismoi('NOM_MAILLA', nom_MODELE, 'MODELE',
'F')
nomsd = nomsd.strip()
self.MAILLAGE = macro.get_concept(nomsd)
def extr_matr_elim_lagr(self, matr_asse):
import aster
import numpy as NP
matr_lagr=matr_asse.EXTR_MATR() # function EXTR_MATR available in the official source code
#-----------------------------------------------------#
#-- --#
#-- Elimination des degres de libertes de Lagranges --#
#-- --#
#-- c.f. doc R4.06.02 - section 2.5 --#
#-- + commentaires dans sdll123a.comm --#
#-- --#
#-----------------------------------------------------#
iret,ibid,nom_nume = aster.dismoi('NOM_NUME_DDL',matr_asse.nom,'MATR_ASSE','F')
Nume=aster.getvectjev(nom_nume.ljust(8)+' .NUME.DELG ' )
ind_lag1=[]
ind_nolag=[]
for i1 in range(len(Nume)) :
if Nume[i1] > -0.5 :
ind_nolag.append(i1)
if (Nume[i1] < -0.5) & (Nume[i1] > -1.5):
ind_lag1.append(i1)
nlag1=len(ind_lag1)
nnolag=len(ind_nolag)
Z=NP.zeros((nnolag-nlag1,nnolag))
C=NP.vstack((matr_lagr[ind_lag1][:,ind_nolag],Z))
Q,R = NP.linalg.qr(NP.transpose(C))
dR=[]
for i1 in range(len(R)) :
dR.append(NP.abs(R[i1,i1]))
mdR=NP.max(dR)
indz=[]
for i1 in range(len(R)) :
if NP.abs(R[i1,i1]) <= mdR*1.e-16 :
indz.append(i1)
matr_sans_lagr=NP.dot(NP.transpose(Q[:][:,indz]),NP.dot(matr_lagr[ind_nolag][:,ind_nolag],Q[:][:,indz]))
#-- Fin elimination
return matr_sans_lagr
def CHAINAGE_INIT(self, args, motscles):
MODELE_MECA = args['MODELE_MECA']
MODELE_HYDR = args['MODELE_HYDR']
# On importe les definitions des commandes a utiliser dans la macro
CREA_MAILLAGE = self.get_cmd('CREA_MAILLAGE')
PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
MATR_MH = PROJ_CHAMP(METHODE='COLLOCATION',
MODELE_1=MODELE_MECA,
MODELE_2=MODELE_HYDR,
PROJECTION='NON',
**motscles)
iret, ibid, nom_mail = aster.dismoi('NOM_MAILLA', MODELE_HYDR.nom,
'MODELE', 'F')
nom_mail = nom_mail.strip()
__maillage_h = self.get_concept(nom_mail)
_maillin = CREA_MAILLAGE(MAILLAGE=__maillage_h,
QUAD_LINE=_F(TOUT='OUI', ),
**motscles)
MATR_HM1 = PROJ_CHAMP(METHODE='COLLOCATION',
MODELE_1=MODELE_HYDR,
MAILLAGE_2=_maillin,
PROJECTION='NON',
**motscles)
MATR_HM2 = PROJ_CHAMP(METHODE='COLLOCATION',
MAILLAGE_1=_maillin,
MODELE_2=MODELE_MECA,
PROJECTION='NON',
**motscles)
return MATR_MH, MATR_HM1, MATR_HM2
def get_matrices(self):
"""Recherche des nume_ddl qui dependent de ce modele
NB : attention, si plusieurs nume_ddl en dependent, seul le premier
deviendra self.nume_ddl. C'est utile pour les modeles experimentaux
pour lesquels le ddl est pipo.
"""
if self.mass is None or self.kass is None:
for matr_name, matr in list(self.objects.matrices.items()):
iret, ibid, nom_modele = aster.dismoi('NOM_MODELE', matr_name,
'MATR_ASSE', 'F')
if nom_modele.strip() == self.nom.strip():
if matr.sdj.REFA.get()[3].strip() == 'RIGI_MECA':
self.kass = matr
self.kass_name = matr_name
if matr.sdj.REFA.get()[3].strip() == 'MASS_MECA':
self.mass = matr
self.mass_name = matr_name
if self.mass is None or self.kass is None:
self.mess.disp_mess(
"On ne trouve pas de matrices associees au modele" + self.nom)
self.mess.disp_mess(
"Certains calculs ne seront pas realisables (MAC_MODE)")
return
def post_newmark_ops(self, **args):
"""
Macro commande pour évaluer la stabilité d'un ouvrage en remblai
(digue / barrage) au séisme par la méthode simplifiée de Newmark.
Uniquement possible pour une modélisation 2D.
"""
MasquerAlarme('MODELE1_63')
MasquerAlarme('MODELE1_64')
##sys.stdout.flush() pour vider les #prints
args = _F(args)
ONLY_FS = False
if args['RESULTAT'] is not None:
RESULTAT = args['RESULTAT']
__model = None
### RECUPERATION DU MAILLAGE DANS LE RESULTAT DYNAMIQUE
try:
__model = RESULTAT.getModel()
except:
raise NameError("No model")
__mail = __model.getMesh()
dim = __mail.getDimension()
if dim == 3:
UTMESS('F', 'POST0_51')
## possiblement à gérer par la suite le cas de plusieurs champs matériaux dans
## le RESULTAT
__ch_mat = RESULTAT.getMaterialField()
else:
ONLY_FS = True
if args['RESULTAT_PESANTEUR'] is not None:
RESULTAT_PESANTEUR = args['RESULTAT_PESANTEUR']
__modST = None
try:
__modST = RESULTAT_PESANTEUR.getModel()
except:
raise NameError("No model")
### RECUPERATION DU MAILLAGE DANS LE RESULTAT STATIQUE
if ONLY_FS:
__mail = __modST.getMesh()
dim = __mail.getDimension()
if dim == 3:
UTMESS('F', 'POST0_51')
else:
__mailST = __modST.getMesh()
dim = __mailST.getDimension()
if dim == 3:
UTMESS('F', 'POST0_51')
### RECUPERATION COEFFICIENT KY
if args['KY'] is not None:
ky = args['KY']
### gravité
g = 9.81
## accélération limite
ay = ky * g
### GROUP_MA DANS LE MODELE
grpma = args['GROUP_MA_CALC']
__mail = DEFI_GROUP(
reuse=__mail,
MAILLAGE=__mail,
CREA_GROUP_MA=_F(
NOM='ALL',
#TYPE_MAILLE = '2D',
UNION=grpma,
),
)
### RECUPERATION DES POSITIONS DU CERCLE DE GLISSEMENT
if args['RAYON'] is not None:
TYPE = 'CERCLE'
r = args['RAYON']
posx = args['CENTRE_X']
posy = args['CENTRE_Y']
else:
TYPE = "MAILLAGE"
__mail_1 = args['MAILLAGE_GLIS']
__mail_1 = DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
CREA_GROUP_MA=_F(
NOM='ALL',
#TYPE_MAILLE = '2D',
TOUT='OUI',
),
)
DEFI_GROUP(reuse=__mail_1,
MAILLAGE=__mail_1,
CREA_GROUP_NO=_F(NOM='DOMAIN_',
OPTION='INCLUSION',
MAILLAGE_INCL=__mail,
GROUP_MA_INCL='ALL',
GROUP_MA='ALL',
CAS_FIGURE='2D'))
DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
CREA_GROUP_MA=_F(
NOM='DOMAIN_',
OPTION='APPUI',
TYPE_APPUI='AU_MOINS_UN',
GROUP_NO='DOMAIN_',
),
),
if args['GROUP_MA_GLIS'] is not None:
__mail_1 = DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
CREA_GROUP_MA=_F(
NOM='RUPTURE',
UNION=args['GROUP_MA_GLIS'],
),
)
else:
__mail_1 = DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
CREA_GROUP_MA=_F(
NOM='RUPTURE',
TYPE_MAILLE='2D',
TOUT='OUI',
),
)
if args['GROUP_MA_LIGNE'] is not None:
ma_ligne = args['GROUP_MA_LIGNE']
#### Utlisateur n'a pas fournit GROUP_MA_LIGNE : On considere toutes les
#### mailles SEG2 et SEG3 du maillage
else:
seg = []
_, _, yaseg2 = aster.dismoi('EXI_SEG2', __mail_1.getName(),
'MAILLAGE', 'F')
if yaseg2 == 'OUI':
seg.append('LIGNE_2')
__mail_2 = DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
CREA_GROUP_MA=_F(
NOM='LIGNE_2',
TYPE_MAILLE=('SEG2'),
TOUT='OUI',
),
)
_, _, yaseg3 = aster.dismoi('EXI_SEG3', __mail_1.getName(),
'MAILLAGE', 'F')
if yaseg3 == 'OUI':
seg.append('LIGNE_3')
__mail_1 = DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
CREA_GROUP_MA=_F(
NOM='LIGNE_3',
TYPE_MAILLE=('SEG3'),
TOUT='OUI',
),
)
ma_ligne = seg
DEFI_GROUP(reuse=__mail_1,
MAILLAGE=__mail_1,
CREA_GROUP_NO=_F(NOM='LIGNE_',
OPTION='INCLUSION',
MAILLAGE_INCL=__mail,
GROUP_MA_INCL='ALL',
GROUP_MA=ma_ligne,
CAS_FIGURE='2D'))
DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
CREA_GROUP_MA=_F(
NOM='LIGNE_',
OPTION='APPUI',
TYPE_APPUI='SOMMET',
GROUP_NO='LIGNE_',
),
),
# Orientation des mailles surfaciques
__mail_1 = MODI_MAILLAGE(
reuse=__mail_1,
MAILLAGE=__mail_1,
ORIE_PEAU_2D=_F(GROUP_MA=('LIGNE_', ), ),
)
##### ON RESTREINT LE MAILLAGE PATCH A LA ZONE COMMUNE AVEC LE MAILLAGE DU
##### RESULTAT A CONSIDERER
__mail_2 = CREA_MAILLAGE(
MAILLAGE=__mail_1, #INFO=2,
RESTREINT=_F(
GROUP_MA=('LIGNE_', 'DOMAIN_', 'RUPTURE'),
GROUP_NO=(
'LIGNE_',
'DOMAIN_',
),
),
)
#IMPR_RESU(RESU=_F(MAILLAGE = __mail_2,),FORMAT='MED',UNITE=23)
__mail_L = CREA_MAILLAGE(
MAILLAGE=__mail_2, #INFO=2,
RESTREINT=_F(
GROUP_MA=('LIGNE_', ),
GROUP_NO=('LIGNE_', ),
),
)
###############################################################################
####
#### CALCUL DU FACTEUR DE SECURITE STATIQUE
####
###############################################################################
if args['RESULTAT_PESANTEUR'] is not None:
#### ASSERT A CREER SI MODELE D'ORIGINE PLUS COMPLEXE QUE D_PLAN
##### MODELE SUR LE MAILLAGE PATCH
__MODST = AFFE_MODELE(
MAILLAGE=__mail_2,
AFFE=(_F(
TOUT='OUI',
PHENOMENE='MECANIQUE',
MODELISATION='D_PLAN',
), ),
VERI_JACOBIEN='NON',
)
__MODL = AFFE_MODELE(
MAILLAGE=__mail_L,
AFFE=(_F(
TOUT='OUI',
PHENOMENE='MECANIQUE',
MODELISATION='D_PLAN',
), ),
VERI_JACOBIEN='NON',
)
# CREATION D'UN MATERIAU BIDON POUR CREA_RESU
__MATBID = DEFI_MATERIAU(ELAS=_F(E=1., NU=0.3, RHO=1.))
__MATST = AFFE_MATERIAU(
MAILLAGE=__mail_2,
AFFE=_F(
MATER=__MATBID,
TOUT='OUI',
),
)
# OBTENTION DU CHAMP DES CONTRAINTES STATIQUE SUR LE MODELE AUXILAIRE
# CREATION D'UN RESULTAT AVEC MATERIAU BIDON POUR CALCUL DE SIRO_ELEM
__instFS = RESULTAT_PESANTEUR.LIST_PARA()['INST'][-1]
__CSTPGO = CREA_CHAMP(
OPERATION='EXTR',
NOM_CHAM='SIEF_ELGA',
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=RESULTAT_PESANTEUR,
INST=__instFS,
)
__CSTPGF = PROJ_CHAMP(
METHODE='ECLA_PG',
CHAM_GD=__CSTPGO,
MODELE_1=__modST,
MODELE_2=__MODST,
CAS_FIGURE='2D',
PROL_ZERO='OUI',
# DISTANCE_MAX=0.1,
)
#### CREATION DU RESULTAT STATIQUE AVEC CHAMP SIEF_ELGA PROJETE SUR LE MAILLAGE PATCH
__recoST = CREA_RESU(
OPERATION='AFFE',
TYPE_RESU='DYNA_TRANS',
NOM_CHAM='SIEF_ELGA',
AFFE=(_F(
MODELE=__MODST,
CHAM_MATER=__MATST,
CHAM_GD=__CSTPGF,
INST=0.,
), ),
)
__recoST = CALC_CHAMP(
reuse=__recoST,
RESULTAT=__recoST,
GROUP_MA='LIGNE_',
MODELE=__MODST,
CONTRAINTE=('SIRO_ELEM', ),
)
#### EXTRACTION DES COMPOSANTES DE SIRO_ELEM DU CALCUL STATIQUE
__CSIST = CREA_CHAMP(
OPERATION='EXTR',
NOM_CHAM='SIRO_ELEM',
TYPE_CHAM='ELEM_SIEF_R',
RESULTAT=__recoST,
NUME_ORDRE=1,
)
SIGN_stat = __CSIST.EXTR_COMP('SIG_N', [])
SIGTN_stat = __CSIST.EXTR_COMP('SIG_TN', [])
##### CHAMPS PHI ET COHESION POUR CALCUL DE STABILITE STATIQUE
__chPHNO = PROJ_CHAMP(
METHODE='COLLOCATION',
CHAM_GD=args['CHAM_PHI'],
MAILLAGE_1=__mail,
MAILLAGE_2=__mail_2,
PROL_ZERO='OUI',
# DISTANCE_MAX=0.1,
)
__chPHEL = CREA_CHAMP(
OPERATION='DISC',
CHAM_GD=__chPHNO,
MODELE=__MODST,
TYPE_CHAM='ELEM_NEUT_R',
PROL_ZERO='OUI',
)
__chCONO = PROJ_CHAMP(
METHODE='COLLOCATION',
CHAM_GD=args['CHAM_COHESION'],
MAILLAGE_1=__mail,
MAILLAGE_2=__mail_2,
PROL_ZERO='OUI',
# DISTANCE_MAX=0.1,
)
__chCOEL = CREA_CHAMP(
OPERATION='DISC',
CHAM_GD=__chCONO,
MODELE=__MODST,
TYPE_CHAM='ELEM_NEUT_R',
PROL_ZERO='OUI',
#INFO=2,
)
__chCPEL = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='ELEM_NEUT_R',
MODELE=__MODST,
PROL_ZERO='OUI',
ASSE=(
_F(
GROUP_MA='LIGNE_',
CHAM_GD=__chPHEL,
CUMUL='OUI',
COEF_R=1.,
),
_F(
GROUP_MA='LIGNE_',
CHAM_GD=__chCOEL,
CUMUL='OUI',
COEF_R=1.,
),
),
)
##### CHAMP DES VALEURS PHI ET COHESION SUR LA LIGNE DE GLISSEMENT
__chCPLG = PROJ_CHAMP(
METHODE='COLLOCATION',
CHAM_GD=__chCPEL,
MODELE_1=__MODST,
MODELE_2=__MODL,
CAS_FIGURE='1.5D',
PROL_ZERO='OUI',
INFO=2,
# DISTANCE_MAX=0.1,
)
##### CALCUL DU FACTEUR DE SECURITE STATIQUE LOCAL
__FstS = FORMULE(VALE='get_local_FS(SIG_N,SIG_TN,X1,X2)',
NOM_PARA=('SIG_N', 'SIG_TN', 'X1', 'X2'),
get_local_FS=get_local_FS)
__chSTSF = CREA_CHAMP(
OPERATION='AFFE',
TYPE_CHAM='ELEM_NEUT_F',
MODELE=__MODST,
PROL_ZERO='OUI',
AFFE=_F(
GROUP_MA='LIGNE_',
NOM_CMP='X1',
VALE_F=__FstS,
),
)
__chSTSR = CREA_CHAMP(
TYPE_CHAM='ELEM_NEUT_R',
OPERATION='EVAL',
CHAM_F=__chSTSF,
CHAM_PARA=(__CSIST, __chCPEL),
INFO=1,
)
__chSTSL = PROJ_CHAMP(
METHODE='COLLOCATION',
CHAM_GD=__chSTSR,
MODELE_1=__MODST,
MODELE_2=__MODL,
CAS_FIGURE='1.5D',
PROL_ZERO='OUI',
INFO=2,
# DISTANCE_MAX=0.1,
)
####### CALCUL DU FACTEUR DE SECURITE STATIQUE GLOBAL
phiL = __chCPLG.EXTR_COMP('X1', [])
cohesionL = __chCPLG.EXTR_COMP('X2', [])
available_shear, static_shear = get_static_shear(
SIGN_stat.valeurs, SIGTN_stat.valeurs, phiL.valeurs,
cohesionL.valeurs)
available_shear_v, static_shear_v = get_static_shear_vector(
SIGN_stat.valeurs, SIGTN_stat.valeurs, phiL.valeurs,
cohesionL.valeurs)
FSp = available_shear / (static_shear)
FSpL = []
for k in range(len(available_shear_v)):
try:
FSpL.append(available_shear_v[k] / (static_shear_v[k]))
except:
FSpL.append(0.)
#### PREPARATION TABLE DU FACTEUR DE SECURITE
if args['RESULTAT'] is None:
tabini = Table(para=["INST", "FS"], typ=["R", "R"])
if args['RESULTAT'] is None:
tabini.append({'INST': 0.0, 'FS': FSp})
self.register_result(__chSTSL, args["CHAM_FS"])
dprod = tabini.dict_CREA_TABLE()
tabout = CREA_TABLE(**dprod)
###############################################################################
####
#### CALCUL POUR RESULTAT DYNAMIQUE
####
###############################################################################
if args['RESULTAT'] is not None:
##### OPERATIONS SUR LE MAILLAGE DYNAMIQUE POUR CALCUL DU CENTRE DE MASSE DE LA ZONE
##### QUI GLISSE
### AJOUT DU GROUPE GLISSE DANS LE MAILLAGE
if TYPE == 'CERCLE':
__mail = DEFI_GROUP(
reuse=__mail,
MAILLAGE=__mail,
CREA_GROUP_MA=_F(
NOM='GLISSE_',
#TYPE_MAILLE = '2D',
OPTION='SPHERE',
POINT=(posx, posy),
RAYON=r),
)
### Si maillage de la zone de rupture fourni, il faut pouvoir trouver les mailles
elif TYPE == 'MAILLAGE':
DEFI_GROUP(reuse=__mail,
MAILLAGE=__mail,
CREA_GROUP_NO=_F(NOM='GLISSE_',
OPTION='INCLUSION',
MAILLAGE_INCL=__mail_2,
GROUP_MA_INCL='RUPTURE',
GROUP_MA='ALL',
CAS_FIGURE='2D'))
__mail = DEFI_GROUP(reuse=__mail,
MAILLAGE=__mail,
CREA_GROUP_MA=_F(
NOM='GLISSE_',
OPTION='APPUI',
TYPE_APPUI='AU_MOINS_UN',
GROUP_NO='GLISSE_',
))
__mail = DEFI_GROUP(
reuse=__mail,
MAILLAGE=__mail,
CREA_GROUP_MA=_F(
NOM='GLISSE',
#TYPE_MAILLE = '2D',
INTERSEC=('GLISSE_', 'ALL'),
),
)
__mail = DEFI_GROUP(reuse=__mail,
MAILLAGE=__mail,
CREA_GROUP_NO=_F(GROUP_MA='GLISSE'))
#### Calcul de la masse de la zone qui glisse à partir du GROUP_MA 'GLISSE'
__tabmas = POST_ELEM(
RESULTAT=RESULTAT,
MASS_INER=_F(GROUP_MA='GLISSE'),
)
masse = __tabmas['MASSE', 1]
cdgx = __tabmas['CDG_X', 1]
cdgy = __tabmas['CDG_Y', 1]
##############################################################################
## METHODE : CALCUL DE L'ACCELERATION MOYENNE A PARTIR DE LA RESULTANTE
## LE LONG DE LA SURFACE DE GLISSEMENT
##############################################################################
#### Il faut que SIEF_ELGA soit prélablement calculé par l'utilisateur
__RESU3 = CALC_CHAMP(
RESULTAT=RESULTAT,
MODELE=__model,
CHAM_MATER=__ch_mat,
FORCE=('FORC_NODA'),
#CONTRAINTE = ('SIEF_ELGA',),
)
##### Calcul de la résultante sur la ligne de glissement du calcul dynamique
if TYPE == 'CERCLE':
__tabFLI = MACR_LIGN_COUPE(
RESULTAT=__RESU3,
NOM_CHAM='FORC_NODA',
LIGN_COUPE=_F(TYPE='ARC',
OPERATION='EXTRACTION',
RESULTANTE=('DX', 'DY'),
NB_POINTS=1000,
CENTRE=(posx, posy),
COOR_ORIG=(posx - r, posy),
ANGLE=360.),
)
elif TYPE == 'MAILLAGE':
### CHAMP FORC_NODA POUR CALCUL RESULTANTE
__recou = PROJ_CHAMP(
METHODE='COLLOCATION',
RESULTAT=__RESU3,
MAILLAGE_1=__mail,
MAILLAGE_2=__mail_2,
TYPE_CHAM='NOEU',
NOM_CHAM=('FORC_NODA'),
PROL_ZERO='OUI',
# DISTANCE_MAX=0.1,
)
#### TABLE AVEC RESULTANTE CALCUL DYNAMIQUE DANS LE REPERE GLOBAL
#### UTILISE POUR CALCUL DE L'ACCELERATION MOYENNE
__tabitm = POST_RELEVE_T(ACTION=_F(
INTITULE='RESU',
OPERATION='EXTRACTION',
GROUP_NO='LIGNE_',
RESULTANTE=('DX', 'DY'),
RESULTAT=__recou,
NOM_CHAM='FORC_NODA',
), )
dictab = __tabitm.EXTR_TABLE()
if 'RESU' in dictab.para:
del dictab['RESU']
if 'NOEUD' in dictab.para:
del dictab['NOEUD']
dprod = dictab.dict_CREA_TABLE()
__tabFLI = CREA_TABLE(**dprod)
# IMPR_TABLE(TABLE = __tabFLI,UNITE=10)
################################################################################
####
#### CALCUL FACTEUR DE SECURITE EN DYNAMIQUE (uniquemnt si RESULTAT_PESANTEUR est fourni)
#### Dans ce cas, il faut qu'une phase statique prélable au calcul dynamique soit
#### réalisé, afin que les contraintes du résultat dynamique intégrent les
#### contraintes statiques
####
################################################################################
##### CETTE PARTIE MARCHE UNIQUMENT AVEC MAILLAGE PATCH POUR L'INSTANT
if args['RESULTAT_PESANTEUR'] is not None:
### BOUCLE POUR CREATION DU RESULTAT DYNAMIQUE PROJETE DANS LES PG
### DU MODELE AUXILIAIRE (MAILLAGE PATCH)
__MODYN = AFFE_MODELE(
MAILLAGE=__mail_2,
AFFE=(_F(
TOUT='OUI',
PHENOMENE='MECANIQUE',
MODELISATION='D_PLAN',
), ),
VERI_JACOBIEN='NON',
)
# CREATION D'UN MATERIAU BIDON POUR CREA_RESU
__MATBIDD = DEFI_MATERIAU(ELAS=_F(E=1., NU=0.3, RHO=1.))
__MATDYN = AFFE_MATERIAU(
MAILLAGE=__mail_2,
AFFE=_F(
MATER=__MATBIDD,
TOUT='OUI',
),
)
__instSD = RESULTAT.LIST_PARA()['INST']
__CSDPGI = CREA_CHAMP(
OPERATION='EXTR',
NOM_CHAM='SIEF_ELGA',
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=RESULTAT,
INST=__instSD[0],
)
__CSDPGF = PROJ_CHAMP(
METHODE='ECLA_PG',
CHAM_GD=__CSDPGI,
MODELE_1=__model,
MODELE_2=__MODYN,
CAS_FIGURE='2D',
PROL_ZERO='OUI',
# DISTANCE_MAX=0.1,
)
#### CREATION DU RESULTAT DYNAMIQUE AVEC CHAMP SIEF_ELGA PROJETE SUR LE MAILLAGE PATCH
__recoSD = CREA_RESU(
OPERATION='AFFE',
TYPE_RESU='DYNA_TRANS',
NOM_CHAM='SIEF_ELGA',
AFFE=(_F(
MODELE=__MODYN,
CHAM_MATER=__MATDYN,
CHAM_GD=__CSDPGF,
INST=__instSD[0],
), ),
)
DETRUIRE(INFO=1, CONCEPT=_F(NOM=(__CSDPGI, __CSDPGF)))
for inst in __instSD[1:]:
__CSDPGI = CREA_CHAMP(
OPERATION='EXTR',
NOM_CHAM='SIEF_ELGA',
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=RESULTAT,
INST=inst,
)
__CSDPGF = PROJ_CHAMP(
METHODE='ECLA_PG',
CHAM_GD=__CSDPGI,
MODELE_1=__model,
MODELE_2=__MODYN,
CAS_FIGURE='2D',
PROL_ZERO='OUI',
# DISTANCE_MAX=0.1,
)
__recoSD = CREA_RESU(
reuse=__recoSD,
RESULTAT=__recoSD,
OPERATION='AFFE',
TYPE_RESU='DYNA_TRANS',
NOM_CHAM='SIEF_ELGA',
AFFE=(_F(
MODELE=__MODYN,
CHAM_MATER=__MATDYN,
CHAM_GD=__CSDPGF,
INST=inst,
), ),
)
DETRUIRE(INFO=1, CONCEPT=_F(NOM=(__CSDPGI, __CSDPGF)))
#### CALCUL DES CHAMPS SIRO_ELEM DANS LA LIGNE DE RUPTURE
#### UTILISE POUR ESTIMATION DES CONTRAINTES RESISTANTES ET MOBILISEES
__recoSD = CALC_CHAMP(
reuse=__recoSD,
RESULTAT=__recoSD,
GROUP_MA='LIGNE_',
MODELE=__MODYN,
CONTRAINTE=('SIRO_ELEM', ),
)
#### TABLE AVEC CONTRAINTES CALCUL DYNAMIQUE DANS LA LIGNE DE RUPTURE DANS LE REPERE LOCAL
#### UTILISE POUR CALCUL DE LA CONTRAINTE DE CISAILLEMENT MOBILISEE
SIGN_dyn = []
SIGT_dyn = []
for inst in __instSD:
#print ("Instant de calcul = "+str(inst))
__CSISD = CREA_CHAMP(
OPERATION='EXTR',
NOM_CHAM='SIRO_ELEM',
TYPE_CHAM='ELEM_SIEF_R',
RESULTAT=__recoSD,
INST=inst,
)
SIGN_dyna = __CSISD.EXTR_COMP('SIG_N', [])
SIGTN_dyna = __CSISD.EXTR_COMP('SIG_TN', [])
SIGN_dyn.append(SIGN_dyna)
SIGT_dyn.append(SIGTN_dyna)
DETRUIRE(INFO=1, CONCEPT=_F(NOM=(__CSISD, )))
#### CALCUL DE LA CONTRAINTE DE CISAILLEMENT MOBILISEE DU CALCUL DYNAMIQUE
dynamic_shear = get_dynamic_shear(SIGT_dyn, __instSD)
dynamic_shear_v = get_dynamic_shear_vector(SIGT_dyn, __instSD)
##### CALCUL DU FACTEUR DE SECURITE
FSp = available_shear / (static_shear - dynamic_shear)
FSpL = []
for k in range(len(available_shear_v)):
try:
FSpL.append(available_shear_v[k] /
(static_shear_v[k] - dynamic_shear_v[k]))
except:
FSpL.append(0.)
tabini = Table(para=["INST", "FS"], typ=["R", "R"])
#### PRPARATION TABLE DU FACTEUR DE SECURITE DYNAMIQUE
for j in range(len(__instSD)):
tabini.append({'INST': __instSD[j], 'FS': FSp[j]})
dprod = tabini.dict_CREA_TABLE()
__TFS = CREA_TABLE(**dprod)
################################################################################
####
#### CACUL DE L'ACCELERATION MOYENNE A PARTIR DE LA RESULTANTE ET DE LA MASSE
#### DE LA ZONE DE GLISSEMENT
####
################################################################################
fresu = __tabFLI.EXTR_TABLE()
forcex = fresu.values()['DX']
forcey = fresu.values()['DY']
time = fresu.values()['INST']
accyFLI = np.array(forcey) / masse
accxFLI = np.array(forcex) / masse
__accyFL = DEFI_FONCTION(NOM_RESU='ACCE_MOY',
NOM_PARA='INST',
ABSCISSE=time,
ORDONNEE=list(accyFLI)),
__accxFL = DEFI_FONCTION(NOM_RESU='ACCE_MOY',
NOM_PARA='INST',
ABSCISSE=time,
ORDONNEE=list(accxFLI)),
###############################################################################
## METHODE DE CORRECTION DE L'ACCELERATION POUR CALCUL DES DÉPLACEMENTS
## IRREVERSIBLES
##############################################################################
acc = accyFLI
## Calcul de l'accéleration corrigée par ay
## on compte les valeurs de a>ay de manière à disposer
## du même nombre de valeurs a<ay. Cela servira pour calculer correctement
## les vitesses et les déplacements résiduels.
## Partie à modifier si kh variable
accA = np.zeros(len(time))
count = 0
for i in range(len(time)):
if acc[i] > ay:
accA[i] = acc[i] - ay
count = count + 1
else:
if count > 0:
accA[i] = acc[i] - ay
count = count - 1
else:
count = 0
# Accélération corigée par ay
__accAF = DEFI_FONCTION(NOM_RESU='ACCE',
NOM_PARA='INST',
ABSCISSE=time,
ORDONNEE=list(accA)),
__vitAFa = CALC_FONCTION(INTEGRE=_F(FONCTION=__accAF, ))
### Etape de correction de la vitesse à partir de
### l'accéleration. Cette étape permet d'aboutir au signal en vitesse
### avec uniquement v >0 pour intégration vers les déplacements résiduels
vitAFv = __vitAFa.Ordo()
vitA = np.zeros(len(time))
ind = [False] * len(time)
eps = 1e-9
for i in range(len(time) - 1):
if (vitAFv[i + 1] - vitAFv[i]) > eps or (vitAFv[i + 1] -
vitAFv[i]) < (-1.) * eps:
vitA[i] = vitAFv[i]
ind[i] = True
initial = True
vini = 0.
for i in range(len(time)):
if ind[i]:
vitA[i] = vitA[i] - vini
initial = False
else:
initial = True
vini = vitAFv[i]
##print vini
for i in range(len(time)):
if vitA[i] < 0:
vitA[i] = 0.
__vitAF = DEFI_FONCTION(NOM_RESU='VITE',
NOM_PARA='INST',
ABSCISSE=time,
ORDONNEE=list(vitA)),
__deplAF = CALC_FONCTION(INTEGRE=_F(FONCTION=__vitAF, ))
## CREATION DE LA TABLE DE SORTIE
__tabaAF = CREA_TABLE(FONCTION=_F(FONCTION=__accAF), )
__tabvAF = CREA_TABLE(FONCTION=_F(FONCTION=__vitAF), )
__tabdAF = CREA_TABLE(FONCTION=_F(FONCTION=__deplAF), )
tabout = CREA_TABLE(FONCTION=_F(FONCTION=__accyFL), )
act_table = []
act_table.append(_F(OPERATION='COMB', TABLE=__tabaAF,
NOM_PARA='INST'), )
act_table.append(_F(OPERATION='COMB', TABLE=__tabvAF,
NOM_PARA='INST'), )
act_table.append(_F(OPERATION='COMB', TABLE=__tabdAF,
NOM_PARA='INST'), )
tabout = CALC_TABLE(reuse=tabout, TABLE=tabout, ACTION=act_table)
if args['RESULTAT_PESANTEUR'] is not None:
tabout = CALC_TABLE(
TABLE=tabout,
ACTION=_F(OPERATION='COMB', TABLE=__TFS, NOM_PARA='INST'),
)
##### NETTOYAGE DES GROUPES DE MAILLE GENERES
__mail = DEFI_GROUP(
reuse=__mail,
MAILLAGE=__mail,
DETR_GROUP_MA=_F(NOM=('ALL', ), ),
)
if args['RESULTAT'] is not None:
__mail = DEFI_GROUP(
reuse=__mail,
MAILLAGE=__mail,
DETR_GROUP_MA=_F(NOM=(
'GLISSE_',
'GLISSE',
), ),
DETR_GROUP_NO=_F(NOM=('GLISSE', ), ),
)
if TYPE == 'MAILLAGE':
__mail = DEFI_GROUP(
reuse=__mail,
MAILLAGE=__mail,
DETR_GROUP_NO=_F(NOM=('GLISSE_'), ),
)
__mail_1 = DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
DETR_GROUP_MA=_F(NOM=('RUPTURE', 'ALL'), ),
)
__mail_1 = DEFI_GROUP(reuse=__mail_1,
MAILLAGE=__mail_1,
DETR_GROUP_NO=_F(NOM=(
'LIGNE_',
'DOMAIN_',
), ),
DETR_GROUP_MA=_F(NOM=(
'LIGNE_',
'DOMAIN_',
), ))
if args['GROUP_MA_LIGNE'] is None:
if yaseg2 == 'OUI':
__mail_1 = DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
DETR_GROUP_NO=_F(NOM=('LIGNE_2', ), ),
)
if yaseg3 == 'OUI':
__mail_1 = DEFI_GROUP(
reuse=__mail_1,
MAILLAGE=__mail_1,
DETR_GROUP_NO=_F(NOM=('LIGNE_3', ), ),
)
RetablirAlarme('MODELE1_63')
RetablirAlarme('MODELE1_64')
return tabout
def post_erreur_ops(self, OPTION, CHAM_GD, MODELE, GROUP_MA, **args):
"""
Macro POST_ERREUR permettant de calculer les erreurs en termes de
norme en énergie, norme L2 du déplacement et norme L2 de la pression
de contact
"""
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
# récupération du phenomene
_, _, phenomene = aster.dismoi('PHENOMENE', MODELE.getName(), 'MODELE',
'F')
# seul le phénomène mécanique est pris en charge
if (phenomene != 'MECANIQUE'):
UTMESS('F', 'PREPOST_11')
# le modele comporte-t-il des fissures X-FEM ?
_, nfismo, _ = aster.dismoi('NB_FISS_XFEM', MODELE.getName(), 'MODELE',
'F')
lxfem = nfismo > 0
# récupération du maillage inclus dans le modele
__MA = MODELE.getMesh()
# récupération de la dimension géométrique
dime = __MA.getDimension()
# extraction des coordonnées des noeuds du maillage
__CHXN = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_GEOM_R',
NOM_CHAM='GEOMETRIE',
MAILLAGE=__MA,
INFO=1)
# calcul des coordonnées des points d'intégration des éléments du maillage
__CHXG = CREA_CHAMP(
OPERATION='DISC',
TYPE_CHAM='ELGA_GEOM_R',
PROL_ZERO='OUI',
CHAM_GD=__CHXN,
MODELE=MODELE,
)
# si un seul GROUP_MA, on le convertit en liste
# if type(GROUP_MA) not in (list, tuple):
# GROUP_MA = [GROUP_MA]
# recuperation du nombre de groupes
nb_group = len(GROUP_MA)
# creation de la fonction nulle
if (dime == 3):
__ZERO = FORMULE(NOM_PARA=('X', 'Y', 'Z'), VALE='0.')
else:
__ZERO = FORMULE(NOM_PARA=('X', 'Y'), VALE='0.')
if (OPTION == 'DEPL_RELA'):
# 1. création du champ de fonctions solution analytiques au points d'intégration
l_DDL = ('DX', 'DY', 'DZ')
# récuparation de la liste des fonctions correspondant à DX, DY, DZ
# si l'utilisateur n'a pas renseigné une fonction, on prend la fonction nulle
# on associe chaque composantes du vecteur des deplacements (DX, DY, DZ)
# a la liste de fonctions donnees par l'utlisateur. Si l'uilisateur n'a pas renseigné une
# composante, elle sera pas prise en compte dans l'evaluation de la solution analytique
# dictionnaire associant une composante a la liste de fonctions correspondantes
ddl2func = {}
# dictionnaire associant une composante a un indice pour avoir par exemple :
# DX -> X1, DY -> X2
ddl2ind = {}
i = 1
# boucle sur la liste des composantes (DX, DY, DZ)
for ddl in l_DDL:
# recuperation de la liste de fonctions associees a la composante courante
l_ddl = None
if ddl in args:
l_ddl = args[ddl]
# mise a jour des mappings si la liste existe
if l_ddl is not None:
# assertion : l'utilisateur associe une et une seule fonction pour chaque groupe
if len(l_ddl) != nb_group:
UTMESS('F', 'PREPOST_12', valk=ddl)
ddl2func[ddl] = l_ddl
ddl2ind[ddl] = i
i = i + 1
# si l'utilisateur n'a fourni aucune composante, on construit un champ nul
if not ddl2func:
ddl = l_DDL[0]
ddl2func[ddl] = [__ZERO] * nb_group
ddl2ind[ddl] = 1
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur la liste des composantes (DX, DY, DZ)
for ddl in ddl2func:
l_ddl = ddl2func[ddl]
ind = ddl2ind[ddl]
# boucle sur la liste des groupes
for ig, group in enumerate(GROUP_MA):
# creation du mot-clef facteur pour le groupe
# et la composante courante
d_affe = {}
d_affe['GROUP_MA'] = group
d_affe['NOM_CMP'] = 'X' + str(ind)
d_affe['VALE_F'] = l_ddl[ig]
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_affe))
__UanaFG = CREA_CHAMP(
OPERATION='AFFE',
TYPE_CHAM='ELGA_NEUT_F',
MODELE=MODELE,
PROL_ZERO='OUI',
AFFE=l_F,
)
# 2. Evaluation de la solution analytique aux points d'intégration
__UanaG = CREA_CHAMP(
OPERATION='EVAL',
TYPE_CHAM='ELGA_NEUT_R',
CHAM_F=__UanaFG,
CHAM_PARA=__CHXG,
)
# 3. Conversion du champ solution analytique en champ de déplacement
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur la liste des composantes (DX, DY, DZ)
for ddl in ddl2func:
ind = ddl2ind[ddl]
# boucle sur la liste des groupes
for ig, group in enumerate(GROUP_MA):
# creation du mot-clef facteur pour le groupe
# et le ddl courants
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = __UanaG
d_asse['NOM_CMP'] = 'X' + str(ind)
d_asse['NOM_CMP_RESU'] = ddl
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
__UanaR = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELGA_DEPL_R',
MODELE=MODELE,
PROL_ZERO='OUI',
ASSE=l_F)
# 4. création d'un champ contenant les déplacements calculés sur les groupes considérés
# cette etape est facile a faire en FEM, mais parait plus delicate en X-FEM ; elle est
# donc laisse de cote pour le moment
# 5. discrétisation des déplacements calculés aux points d'intégration
if not lxfem:
__UcalG = CREA_CHAMP(
OPERATION='DISC',
TYPE_CHAM='ELGA_DEPL_R',
MODELE=MODELE,
PROL_ZERO='OUI',
CHAM_GD=CHAM_GD,
)
else:
cham_mater = None
if 'CHAM_MATER' in args:
cham_mater = args['CHAM_MATER']
# dans le cas X-FEM, on assemble le champ de deplacement aux points de Gauss pour
# se ramener un champ de la forme (DX, DY, H1X, H1Y, ..., E1X, E1Y, ...) a la forme
# (DX, DY, DZ)
if cham_mater is None:
__UcalG = CREA_CHAMP(
OPERATION='ASSE_DEPL',
TYPE_CHAM='ELGA_DEPL_R',
PROL_ZERO='OUI',
CHAM_GD=CHAM_GD,
MODELE=MODELE,
)
else:
__UcalG = CREA_CHAMP(
OPERATION='ASSE_DEPL',
TYPE_CHAM='ELGA_DEPL_R',
PROL_ZERO='OUI',
CHAM_MATER=cham_mater,
CHAM_GD=CHAM_GD,
MODELE=MODELE,
)
# 6. création du champ différence entre les déplacements calculés et analytiques
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur les groupes
for ig, group in enumerate(GROUP_MA):
# boucles sur les ddl DX, DY et DZ
for i in range(dime):
# creation du mot-clef facteur pour le groupe
# et le ddl courants
# * traitement des déplacements calculés
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = __UcalG
d_asse['CUMUL'] = 'OUI'
d_asse['COEF_R'] = 1.
d_asse['NOM_CMP'] = l_DDL[i]
d_asse['NOM_CMP_RESU'] = l_DDL[i]
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
# * traitement des déplacements analytiques
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = __UanaR
d_asse['CUMUL'] = 'OUI'
d_asse['COEF_R'] = -1.
d_asse['NOM_CMP'] = l_DDL[i]
d_asse['NOM_CMP_RESU'] = l_DDL[i]
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
__UdiffG = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELGA_DEPL_R',
MODELE=MODELE,
PROL_ZERO='OUI',
ASSE=l_F)
# calcul de la norme L2 du deplacement pour la solution analytique et le champ difference, pour chaque groupe
l_ref_norm = []
l_diff_norm = []
ref_norm_tot = 0.
diff_norm_tot = 0.
for group in GROUP_MA:
# 8. calcul de la norme L2 du champ de déplacement analytique
__TanaDEP = POST_ELEM(NORME=(_F(
TYPE_NORM='L2',
GROUP_MA=group,
CHAM_GD=__UanaR,
MODELE=MODELE,
), ))
# extraction de la norme L2 du champ de déplacement analytique
tab = __TanaDEP.EXTR_TABLE()
col_ref = getattr(tab, 'VALE_NORM')
l_ref = col_ref.values()
ref = l_ref[0]
# ajout de la contribution du groupe courant a la liste des normes L2 des champs de déplacement analytiques
l_ref_norm.append(ref)
# ajout e la contribution du groupe courant a la norme L2 du deplacement analytique totale
ref_norm_tot += ref**2
# 9. calcul de la norme L2 du champ de déplacement différence
__TdiffDEP = POST_ELEM(NORME=(_F(
TYPE_NORM='L2',
GROUP_MA=group,
CHAM_GD=__UdiffG,
MODELE=MODELE,
), ))
# extraction de la norme L2 du champ de déplacement difference
tab = __TdiffDEP.EXTR_TABLE()
col_diff = getattr(tab, 'VALE_NORM')
l_diff = col_diff.values()
diff = l_diff[0]
# ajout de la contribution du groupe courant a la liste des normes L2 des champs de déplacement difference
l_diff_norm.append(diff)
# ajout e la contribution du groupe courant a la norme L2 du deplacement difference totale
diff_norm_tot += diff**2
# liberation des objets temporaires pour la prochaine iteration
DETRUIRE(CONCEPT=_F(NOM=__TanaDEP), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__TdiffDEP), INFO=1)
# ajout de normes en energie pour l'ensemble des groupes
ref_norm_tot = math.sqrt(ref_norm_tot)
l_ref_norm.append(ref_norm_tot)
diff_norm_tot = math.sqrt(diff_norm_tot)
l_diff_norm.append(diff_norm_tot)
# creation de la variable TITRE
TITRE = "ERREUR EN NORME L2 DU DEPLACEMENT"
# destruction des objets temporaires pour le calcul de l'erreur en deplacement
DETRUIRE(CONCEPT=_F(NOM=__UanaFG), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__UanaG), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__UanaR), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__UcalG), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__UdiffG), INFO=1)
if (OPTION == 'ENER_RELA'):
#Extraction du nom de materiau
CHAM_MATER = args['CHAM_MATER']
#Extraction du type de deformation
DEFORMATION = args['DEFORMATION']
# 1. création du champ de fonctions solution analytiques au points d'intégration
l_SIGM = ('SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ')
# récuparation de la liste des fonctions correspondant à SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ
# si l'utilisateur n'a pas renseigné une fonction, on prend la fonction nulle
# on associe chaque composantes du tenseur des contraintes (SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ)
# a la liste de fonxtions donnees par l'utlisateur. Si l'uilisateur n'a pas renseigné une
# composante, elle sera pas prise en compte dans l'evaluation de la solution analytique
# dictionnaire associant une composante a la liste de fonctions coreespondantes
sig2func = {}
# dictionnaire associant une composante a un indice pour avoir par exemple :
# SIXX -> X1, SIYY -> X2
sig2ind = {}
i = 1
# boucle sur la liste des composantes (SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ)
for sig in l_SIGM:
# recuperation de la liste de fonctions associees a la composante courante
l_sig = None
if sig in args:
l_sig = args[sig]
# mise a jour des mappings si la liste existe
if l_sig is not None:
# assertion : l'utilisateur associe une et une seule fonction pour chaque groupe
if len(l_sig) != nb_group:
UTMESS('F', 'PREPOST_12', valk=sig)
sig2func[sig] = l_sig
sig2ind[sig] = i
i = i + 1
# si l'utilisateur n'a fourni aucune composante, on construit un champ nul
if not sig2func:
sig = l_SIGM[0]
sig2func[sig] = [__ZERO] * nb_group
sig2ind[sig] = 1
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur la liste des composantes (SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ)
for sig in sig2func:
l_sig = sig2func[sig]
ind = sig2ind[sig]
# boucle sur la liste des groupes
for ig, group in enumerate(GROUP_MA):
# creation du mot-clef facteur pour le groupe
# et la composante courante
d_affe = {}
d_affe['GROUP_MA'] = group
d_affe['NOM_CMP'] = 'X' + str(ind)
d_affe['VALE_F'] = l_sig[ig]
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_affe))
l_F = tuple(l_F)
__SI_ana_F = CREA_CHAMP(
OPERATION='AFFE',
TYPE_CHAM='ELGA_NEUT_F',
MODELE=MODELE,
PROL_ZERO='OUI',
AFFE=l_F,
)
# 2. Evaluation de la solution analytique aux points d'intégration
__SanaCHAM = CREA_CHAMP(
OPERATION='EVAL',
TYPE_CHAM='ELGA_NEUT_R',
CHAM_F=__SI_ana_F,
CHAM_PARA=__CHXG,
)
# 3. Conversion du champ solution analytique en champ de contrainte
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur la liste des composantes (SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ)
for sig in sig2func:
ind = sig2ind[sig]
# boucle sur la liste des groupes
for ig, group in enumerate(GROUP_MA):
# creation du mot-clef facteur pour le groupe
# et le SIGM courants
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = __SanaCHAM
d_asse['NOM_CMP'] = 'X' + str(ind)
d_asse['NOM_CMP_RESU'] = sig
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
__SI_ana_R = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELGA_SIEF_R',
MODELE=MODELE,
PROL_ZERO='OUI',
ASSE=l_F)
# 4. création du champ différence entre les contraintes calculés et analytiques
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur les groupes
for ig, group in enumerate(GROUP_MA):
# boucles sur les composantes: SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ
for i in range(2 * dime):
# creation du mot-clef facteur pour le groupe
# et le SIGM courants
# * traitement des contraintes calculés
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = CHAM_GD
d_asse['CUMUL'] = 'OUI'
d_asse['COEF_R'] = 1.
d_asse['NOM_CMP'] = l_SIGM[i]
d_asse['NOM_CMP_RESU'] = l_SIGM[i]
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
# * traitement des contraintes analytiques
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = __SI_ana_R
d_asse['CUMUL'] = 'OUI'
d_asse['COEF_R'] = -1.
d_asse['NOM_CMP'] = l_SIGM[i]
d_asse['NOM_CMP_RESU'] = l_SIGM[i]
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
__SI_diff = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELGA_SIEF_R',
MODELE=MODELE,
PROL_ZERO='OUI',
ASSE=l_F)
# 5. création d'un champ de deplacement nul partout
# ce champ de deplacement est essentiel pour calculer les normes, mais n'aucun impact sur les resultats
l_DDL = ('DX', 'DY', 'DZ')
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur les groupes
for ig, group in enumerate(GROUP_MA):
# boucles sur les ddl DX, DY et DZ
for i in range(dime):
# creation du mot-clef facteur pour le groupe
# et le ddl courants
d_affe = {}
d_affe['GROUP_MA'] = group
d_affe['NOM_CMP'] = l_DDL[i]
d_affe['VALE'] = 0.
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_affe))
__U = CREA_CHAMP(OPERATION='AFFE',
TYPE_CHAM='NOEU_DEPL_R',
MAILLAGE=__MA,
AFFE=l_F)
# 6. création d'un champ resultat a partir de champ de contrainte analytique
__SIanaRES = CREA_RESU(
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='SIEF_ELGA',
COMPORTEMENT=(_F(
RELATION='ELAS',
DEFORMATION=DEFORMATION,
), ),
AFFE=_F(
CHAM_GD=__SI_ana_R,
MODELE=MODELE,
CHAM_MATER=CHAM_MATER,
INST=(1.0),
),
)
__SIanaRES = CREA_RESU(
reuse=__SIanaRES,
RESULTAT=__SIanaRES,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='DEPL',
COMPORTEMENT=(_F(
RELATION='ELAS',
DEFORMATION=DEFORMATION,
), ),
AFFE=_F(
CHAM_GD=__U,
MODELE=MODELE,
CHAM_MATER=CHAM_MATER,
INST=(1.0),
),
)
# 7. création d'un champ resultat a partir de champ de contrainte difference
__SI_DIFFR = CREA_RESU(
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='SIEF_ELGA',
COMPORTEMENT=(_F(
RELATION='ELAS',
DEFORMATION=DEFORMATION,
), ),
AFFE=_F(
CHAM_GD=__SI_diff,
MODELE=MODELE,
CHAM_MATER=CHAM_MATER,
INST=(1.0),
),
)
__SI_DIFFR = CREA_RESU(
reuse=__SI_DIFFR,
RESULTAT=__SI_DIFFR,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='DEPL',
COMPORTEMENT=(_F(
RELATION='ELAS',
DEFORMATION=DEFORMATION,
), ),
AFFE=_F(
CHAM_GD=__U,
MODELE=MODELE,
CHAM_MATER=CHAM_MATER,
INST=(1.0),
),
)
# 8. calcul de l'energie a partir du champ de contraintes analytique
__TanaSIG = POST_ELEM(
RESULTAT=__SIanaRES,
ENER_ELAS=_F(GROUP_MA=GROUP_MA),
)
# 9. calcul de l'energie a partir du champ de contraintes difference
__TdiffSIG = POST_ELEM(
RESULTAT=__SI_DIFFR,
ENER_ELAS=_F(GROUP_MA=GROUP_MA),
)
#creation de la table finale
tab = __TanaSIG.EXTR_TABLE()
col_ref = getattr(tab, 'TOTALE')
l_ref = col_ref.values()
tab = __TdiffSIG.EXTR_TABLE()
col_diff = getattr(tab, 'TOTALE')
l_diff = col_diff.values()
# assertion: les longueurs de l_ref et l_diff sont egales au nombre de groupes
ASSERT(len(l_ref) == nb_group and len(l_diff) == nb_group)
# calcul des normes en energie pour chaque groupe
l_ref_norm = []
l_diff_norm = []
for i in range(nb_group):
l_ref_norm.append(math.sqrt(l_ref[i]))
l_diff_norm.append(math.sqrt(l_diff[i]))
# ajout de normes en energie pour l'ensemble des groupes
ref_norm_tot = math.sqrt(sum(l_ref))
l_ref_norm.append(ref_norm_tot)
diff_norm_tot = math.sqrt(sum(l_diff))
l_diff_norm.append(diff_norm_tot)
# ajout des energies pour l'ensemble des groupes
l_ref.append(sum(l_ref))
l_diff.append(sum(l_diff))
# creation de la variable TITRE
TITRE = "ERREUR EN NORME ENERGIE"
# destruction des objets temporaires pour le calcul de l'erreur en energie
DETRUIRE(CONCEPT=_F(NOM=__SI_ana_F), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__SanaCHAM), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__SI_ana_R), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__SI_diff), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__U), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__SIanaRES), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__SI_DIFFR), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__TanaSIG), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__TdiffSIG), INFO=1)
if (OPTION == 'LAGR_RELA'):
# le calcul de la norme L2 de la pression de contact sur une fissure XFEM n'est
# pas encore diponible
if lxfem:
UTMESS('F', 'XFEM_14')
# 1. création du champ de fonctions solution analytiques au points d'intégration
# récuparation de la liste des fonctions correspondant à LAGS_C
# si l'utilisateur n'a pas renseigné une fonction, on prend la fonction nulle
l_LAGS = args['LAGS_C']
if l_LAGS is None:
l_LAGS = [__ZERO] * nb_group
# assertion : ici, on a une et une seule fonction LAGS_C pour chaque groupe
if len(l_LAGS) != nb_group:
UTMESS('F', 'PREPOST_12', valk="LAGS_C")
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur les groupes
for ig, group in enumerate(GROUP_MA):
# récupération de la fonction LAGS_C pour le groupe courant
LAGS = l_LAGS[ig]
# creation du mot-clef facteur pour le groupe
# courant
d_affe = {}
d_affe['GROUP_MA'] = group
d_affe['NOM_CMP'] = 'X3'
d_affe['VALE_F'] = LAGS
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_affe))
__PanaFG = CREA_CHAMP(
OPERATION='AFFE',
TYPE_CHAM='ELGA_NEUT_F',
MODELE=MODELE,
PROL_ZERO='OUI',
AFFE=l_F,
)
# 2. Evaluation de la solution analytique aux points d'intégration
__PanaG = CREA_CHAMP(
OPERATION='EVAL',
TYPE_CHAM='ELGA_NEUT_R',
CHAM_F=__PanaFG,
CHAM_PARA=__CHXG,
)
# 3. Conversion du champ solution analytique en champ de déplacement
# N.B.: L'intégration de la pression asocciée au ddl LAG_C donne 0 !
# On l'associe donc à un autre ddl choisi arbitrairement : DZ.
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur les groupes
for ig, group in enumerate(GROUP_MA):
# creation du mot-clef facteur pour le groupe
# et le ddl courants
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = __PanaG
d_asse['NOM_CMP'] = 'X3'
d_asse['NOM_CMP_RESU'] = 'DZ'
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
__PanaR = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELGA_DEPL_R',
MODELE=MODELE,
PROL_ZERO='OUI',
ASSE=l_F)
# 4. création d'un champ contenant les déplacements calculés sur les groupes considérés
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur les groupes
for ig, group in enumerate(GROUP_MA):
# creation du mot-clef facteur pour le groupe
# et le ddl courants
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = CHAM_GD
d_asse['NOM_CMP_RESU'] = 'X3'
d_asse['NOM_CMP'] = 'LAGS_C'
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
__PcalN = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='NOEU_NEUT_R',
MAILLAGE=__MA,
ASSE=l_F)
# 5. discrétisation des déplacements calculés aux points d'intégration
__PcalG = CREA_CHAMP(
OPERATION='DISC',
TYPE_CHAM='ELGA_NEUT_R',
MODELE=MODELE,
PROL_ZERO='OUI',
CHAM_GD=__PcalN,
)
# 6. création du champ différence entre les déplacements calculés et analytiques
# construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP
l_F = []
# boucle sur les groupes
for ig, group in enumerate(GROUP_MA):
# * traitement des déplacements calculés
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = __PcalG
d_asse['CUMUL'] = 'OUI'
d_asse['COEF_R'] = 1.
d_asse['NOM_CMP'] = 'X3'
d_asse['NOM_CMP_RESU'] = 'DZ'
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
# * traitement des déplacements analytiques
d_asse = {}
d_asse['GROUP_MA'] = group
d_asse['CHAM_GD'] = __PanaG
d_asse['CUMUL'] = 'OUI'
d_asse['COEF_R'] = -1.
d_asse['NOM_CMP'] = 'X3'
d_asse['NOM_CMP_RESU'] = 'DZ'
# stockage du mot-clef facteur dans la liste
l_F.append(_F(**d_asse))
__PdiffG = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELGA_DEPL_R',
MODELE=MODELE,
PROL_ZERO='OUI',
ASSE=l_F)
# calcul de la norme L2 du deplacement pour la solution analytique et le champ difference, pour chaque groupe
l_ref_norm = []
l_diff_norm = []
ref_norm_tot = 0.
diff_norm_tot = 0.
for group in GROUP_MA:
# 8. calcul de la norme L2 du champ de déplacement analytique
__TanaP = POST_ELEM(NORME=(_F(
TYPE_NORM='L2',
GROUP_MA=group,
CHAM_GD=__PanaR,
MODELE=MODELE,
), ))
# extraction de la norme L2 du champ de déplacement analytique
tab = __TanaP.EXTR_TABLE()
col_ref = getattr(tab, 'VALE_NORM')
l_ref = col_ref.values()
ref = l_ref[0]
# ajout de la contribution du groupe courant a la liste des normes L2 des champs de déplacement analytiques
l_ref_norm.append(ref)
# ajout e la contribution du groupe courant a la norme L2 du deplacement analytique totale
ref_norm_tot += ref**2
# 9. calcul de la norme L2 du champ de déplacement différence
__TdiffP = POST_ELEM(NORME=(_F(
TYPE_NORM='L2',
GROUP_MA=group,
CHAM_GD=__PdiffG,
MODELE=MODELE,
), ))
# extraction de la norme L2 du champ de déplacement difference
tab = __TdiffP.EXTR_TABLE()
col_diff = getattr(tab, 'VALE_NORM')
l_diff = col_diff.values()
diff = l_diff[0]
# ajout de la contribution du groupe courant a la liste des normes L2 des champs de déplacement difference
l_diff_norm.append(diff)
# ajout e la contribution du groupe courant a la norme L2 du deplacement difference totale
diff_norm_tot += diff**2
# liberation des objets temporaires pour la prochaine iteration
DETRUIRE(CONCEPT=_F(NOM=__TanaP), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__TdiffP), INFO=1)
# ajout de normes en energie pour l'ensemble des groupes
ref_norm_tot = math.sqrt(ref_norm_tot)
l_ref_norm.append(ref_norm_tot)
diff_norm_tot = math.sqrt(diff_norm_tot)
l_diff_norm.append(diff_norm_tot)
# creation de la variable TITRE
TITRE = "ERREUR EN NORME L2 DE LA PRESSION"
# destruction des objets temporaires pour le calcul de l'erreur en deplacement
DETRUIRE(CONCEPT=_F(NOM=__PanaFG), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__PanaG), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__PanaR), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__PcalN), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__PcalG), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__PdiffG), INFO=1)
# ici, quelle que soit la norme considérée, les objets suivants sont définis :
# * l_diff_norm : liste des normes du champ différence, pour chaque groupe +
# norme du champ différence sur l'union des groupes
# creation de la liste GROUP_MA + "TOTAL"
l_group = list(GROUP_MA)
l_group.append("TOTAL")
if (OPTION == 'ENER_RELA'):
tabout = CREA_TABLE(
LISTE=(
_F(LISTE_K=l_group, PARA="GROUP_MA"),
_F(
LISTE_R=l_diff,
PARA="DIFFERENCE",
),
_F(
LISTE_R=l_ref,
PARA="REFERENCE",
),
),
TITRE=TITRE,
)
else:
tabout = CREA_TABLE(
LISTE=(
_F(LISTE_K=l_group, PARA="GROUP_MA"),
_F(
LISTE_R=l_diff_norm,
PARA="DIFFERENCE",
),
_F(
LISTE_R=l_ref_norm,
PARA="REFERENCE",
),
),
TITRE=TITRE,
)
# on ne calcule l'erreur relative que si la reference est non nulle
if ref_norm_tot > 1.e-16:
__Terr = CREA_TABLE(LISTE=(
_F(LISTE_K=("TOTAL"), PARA="GROUP_MA"),
_F(LISTE_R=(diff_norm_tot /
ref_norm_tot), PARA="ERREUR RELATIVE")))
tabout = CALC_TABLE(
reuse=tabout,
TABLE=tabout,
ACTION=_F(OPERATION="COMB", TABLE=__Terr, NOM_PARA="GROUP_MA"),
TITRE=TITRE,
)
# destruction des objets temporaires generiques
# N.B.: __MA est une reference au maillage, il ne faut pas le detruire !
DETRUIRE(CONCEPT=_F(NOM=__CHXN), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__CHXG), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__ZERO), INFO=1)
return tabout
if RESU_ET:
self.DeclareOut("__resuet", RESU_ET)
__resuet = REST_GENE_PHYS(RESU_GENE=__PROJ,
TOUT_ORDRE='OUI',
NOM_CHAM=NOM_CHAM)
# Restriction des modes mesures etendus sur le maillage capteur
# -------------------------------------------------------------
if RESU_RD:
self.DeclareOut("__resurd", RESU_RD)
nume = None
if NUME_DDL:
nume = NUME_DDL
if not nume:
iret, ibid, tmp = aster.dismoi('NUME_DDL', self.nom, 'RESU_DYNA', 'C')
if iret == 0:
tmp = tmp.strip()
if tmp:
nume = self.get_concept(tmp)
else:
UTMESS('A', 'CALCESSAI0_5')
__resurd = PROJ_CHAMP(
METHODE='COLLOCATION',
RESULTAT=__resuet,
MODELE_1=MOD_CALCUL,
MODELE_2=MOD_MESURE,
NOM_CHAM=NOM_CHAM,
TOUT_ORDRE='OUI',
NUME_DDL=nume,
VIS_A_VIS=_F(
def check(self):
"""Vérification des règles impossible à écrire dans le .capy"""
# tâches à la demande
if self['TYPE_RESU'] in ('HARM_GENE', 'TRAN_GENE', 'TABLE', 'CHARGE'):
self.set('_calc_impe', True)
self.set('_calc_forc', True)
elif self['TYPE_RESU'] in ('FICHIER', 'TABLE_CONTROL'):
if self.get('UNITE_RESU_IMPE') is not None:
self.set('_calc_impe', True)
if self.get('UNITE_RESU_FORC') is not None:
self.set('_calc_forc', True)
else:
if self['EXCIT_SOL'] is not None:
self.set('_calc_forc', True)
self.set('_hasPC', self.get('GROUP_MA_CONTROL') is not None)
self.set('_hasSL', self.get('GROUP_MA_SOL_SOL') is not None)
# unités logiques
if self.get('UNITE_RESU_IMPE') is None:
self.set('_exec_Miss', True)
self['UNITE_RESU_IMPE'] = self.UL.Libre(
action='ASSOCIER',
ascii=self._keywords['TYPE'] == 'ASCII',
new=True)
elif self['TYPE_RESU'] in ('TABLE_CONTROL', ):
self.set('_exec_Miss', True)
if self.get('UNITE_RESU_FORC') is None:
self.set('_exec_Miss', True)
self['UNITE_RESU_FORC'] = self.UL.Libre(action='ASSOCIER',
new=True)
elif self['TYPE_RESU'] in ('TABLE_CONTROL', ):
self.set('_exec_Miss', True)
# fréquences
if self['TYPE_RESU'] not in ('CHARGE', ):
if (self['LIST_FREQ'] is not None and self['TYPE_RESU']
not in ('FICHIER', 'HARM_GENE', 'TABLE_CONTROL')):
UTMESS('F', 'MISS0_17')
# récupération des infos sur les modes
if self['BASE_MODALE']:
basemo = self['BASE_MODALE'].getName()
elif self['MACR_ELEM_DYNA']:
basemo = self['MACR_ELEM_DYNA'].sdj.MAEL_REFE.get()[0]
else:
ASSERT(False)
res = aster.dismoi('NB_MODES_TOT', basemo, 'RESULTAT', 'C')
ASSERT(res[0] == 0)
self['NBM_TOT'] = res[1]
res = aster.dismoi('NB_MODES_STA', basemo, 'RESULTAT', 'C')
ASSERT(res[0] == 0)
self['NBM_STA'] = res[1]
res = aster.dismoi('NB_MODES_DYN', basemo, 'RESULTAT', 'C')
ASSERT(res[0] == 0)
self['NBM_DYN'] = res[1]
# si base modale, vérifier/compléter les amortissements réduits
if self['BASE_MODALE']:
if self['AMOR_REDUIT']:
self.set('AMOR_REDUIT', force_list(self['AMOR_REDUIT']))
nval = len(self['AMOR_REDUIT'])
if nval < self['NBM_DYN']:
# complète avec le dernier
nadd = self['NBM_DYN'] - nval
self._keywords['AMOR_REDUIT'].extend([
self['AMOR_REDUIT'][-1],
] * nadd)
nval = self['NBM_DYN']
if nval < self['NBM_DYN'] + self['NBM_STA']:
# on ajoute 0.
self._keywords['AMOR_REDUIT'].append(0.)
# la règle ENSEMBLE garantit que les 3 GROUP_MA_xxx sont tous absents
# ou tous présents
if self['ISSF'] != 'NON':
if self['GROUP_MA_FLU_STR'] is None:
UTMESS('F', 'MISS0_22')
if self['MATER_FLUIDE'] is None:
UTMESS('F', 'MISS0_23')
def macro_elas_mult_ops(self, MODELE, CHAM_MATER, CARA_ELEM, NUME_DDL,
CHAR_MECA_GLOBAL, LIAISON_DISCRET,
CAS_CHARGE, SOLVEUR, **args):
"""
Ecriture de la macro MACRO_ELAS_MULT
"""
ier = 0
import types
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
# On met le mot cle NUME_DDL dans une variable locale pour le proteger
numeddl = NUME_DDL
# On importe les definitions des commandes a utiliser dans la macro
CALC_MATR_ELEM = self.get_cmd('CALC_MATR_ELEM')
NUME_DDL = self.get_cmd('NUME_DDL')
ASSE_MATRICE = self.get_cmd('ASSE_MATRICE')
FACTORISER = self.get_cmd('FACTORISER')
CALC_VECT_ELEM = self.get_cmd('CALC_VECT_ELEM')
ASSE_VECTEUR = self.get_cmd('ASSE_VECTEUR')
RESOUDRE = self.get_cmd('RESOUDRE')
CREA_RESU = self.get_cmd('CREA_RESU')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
CALCUL = self.get_cmd('CALCUL')
EXTR_TABLE = self.get_cmd('EXTR_TABLE')
DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant (de type mult_elas ou fourier_elas) est nommé
# 'nomres' dans le contexte de la macro
self.DeclareOut('nomres', self.sd)
ielas = 0
ifour = 0
for m in CAS_CHARGE:
if m['NOM_CAS']:
ielas = 1 # mot clé NOM_CAS présent sous CAS_CHARGE
tyresu = 'MULT_ELAS'
else:
ifour = 1 # mot clé MODE_FOURIER présent sous CAS_CHARGE
tyresu = 'FOURIER_ELAS'
if ielas == 1 and ifour == 1:
UTMESS('F', 'ELASMULT0_1')
if (numeddl in self.sdprods) or (numeddl == None):
# Si le concept numeddl est dans self.sdprods ou n est pas nommé
# il doit etre produit par la macro
# il faudra donc appeler la commande NUME_DDL
lnume = 1
else:
lnume = 0
if ielas == 1:
motscles = {}
if CHAR_MECA_GLOBAL:
motscles['CHARGE'] = CHAR_MECA_GLOBAL
if CHAM_MATER:
motscles['CHAM_MATER'] = CHAM_MATER
if CARA_ELEM:
motscles['CARA_ELEM'] = CARA_ELEM
__nomrig = CALC_MATR_ELEM(
OPTION='RIGI_MECA', MODELE=MODELE, **motscles)
if lnume:
# On peut passer des mots cles egaux a None. Ils sont ignores
motscles = {}
if numeddl != None:
self.DeclareOut('num', numeddl)
num = NUME_DDL(MATR_RIGI=__nomrig, **motscles)
else:
_num = NUME_DDL(MATR_RIGI=__nomrig, **motscles)
num = _num
else:
num = numeddl
__nomras = ASSE_MATRICE(MATR_ELEM=__nomrig, NUME_DDL=num)
__nomras = FACTORISER(reuse=__nomras, MATR_ASSE=__nomras,
NPREC =SOLVEUR['NPREC'],
STOP_SINGULIER =SOLVEUR['STOP_SINGULIER'],
METHODE =SOLVEUR['METHODE'],
RENUM =SOLVEUR['RENUM'],
)
#
# boucle sur les items de CAS_CHARGE
nomchn = []
lcharg = []
iocc = 0
for m in CAS_CHARGE:
iocc = iocc + 1
# calcul de lcharg : liste des listes de char_meca (mots clé CHAR_MECA
# et CHAR_MECA_GLOBAL)
xx1 = m['CHAR_MECA']
if type(xx1) != type((1,)):
xx1 = (xx1,)
xx2 = CHAR_MECA_GLOBAL
if type(xx2) != type((1,)):
xx2 = (xx2,)
lchar1 = []
for chargt in (xx1 + xx2):
if chargt:
lchar1.append(chargt)
lcharg.append(lchar1)
assert len(lchar1) > 0
if ifour:
motscles = {}
if CHAR_MECA_GLOBAL:
motscles['CHARGE'] = CHAR_MECA_GLOBAL
if CHAM_MATER:
motscles['CHAM_MATER'] = CHAM_MATER
if CARA_ELEM:
motscles['CARA_ELEM'] = CARA_ELEM
motscles['MODE_FOURIER'] = m['MODE_FOURIER']
__nomrig = CALC_MATR_ELEM(
OPTION='RIGI_MECA', MODELE=MODELE, **motscles)
if lnume:
_num = NUME_DDL(MATR_RIGI=__nomrig, )
num = _num
lnume = 0
__nomras = ASSE_MATRICE(MATR_ELEM=__nomrig, NUME_DDL=num)
__nomras = FACTORISER(reuse=__nomras, MATR_ASSE=__nomras,
NPREC =SOLVEUR['NPREC'],
STOP_SINGULIER =SOLVEUR['STOP_SINGULIER'],
METHODE =SOLVEUR['METHODE'],
RENUM =SOLVEUR['RENUM'],
)
if m['VECT_ASSE'] == None:
motscles = {}
l_calc_varc = False
if CHAM_MATER:
motscles['CHAM_MATER'] = CHAM_MATER
iret, ibid, answer = aster.dismoi('EXI_VARC', CHAM_MATER.nom, 'CHAM_MATER', 'F')
if answer == 'OUI':
l_calc_varc = True
if CARA_ELEM:
motscles['CARA_ELEM'] = CARA_ELEM
if ifour:
motscles['MODE_FOURIER'] = m['MODE_FOURIER']
if len(lchar1) > 0:
motscles['CHARGE'] = lchar1
__nomvel = CALC_VECT_ELEM(OPTION='CHAR_MECA', **motscles)
# chargement du aux variables de commandes
if l_calc_varc :
motscles = {}
if CARA_ELEM:
motscles['CARA_ELEM'] = CARA_ELEM
if ifour:
motscles['MODE_FOURIER'] = m['MODE_FOURIER']
__list1=DEFI_LIST_REEL(DEBUT=0.0,
INTERVALLE=_F(JUSQU_A=1.0,
NOMBRE=1,),);
if CHAR_MECA_GLOBAL :
excit = []
for ch in CHAR_MECA_GLOBAL:
excit.append({'CHARGE' : ch})
__cont1=CALCUL(OPTION=('FORC_VARC_ELEM_P'),
MODELE=MODELE,
CHAM_MATER = CHAM_MATER,
INCREMENT=_F(LIST_INST=__list1,
NUME_ORDRE=1),
EXCIT=excit,
COMPORTEMENT=_F(RELATION='ELAS',),
**motscles
)
else:
__cont1=CALCUL(OPTION=('FORC_VARC_ELEM_P'),
MODELE=MODELE,
CHAM_MATER = CHAM_MATER,
INCREMENT=_F(LIST_INST=__list1,
NUME_ORDRE=1),
COMPORTEMENT=_F(RELATION='ELAS',),
**motscles
)
__vvarcp=EXTR_TABLE(TYPE_RESU='VECT_ELEM_DEPL_R',
TABLE=__cont1,
NOM_PARA='NOM_SD',
FILTRE=_F(NOM_PARA='NOM_OBJET',
VALE_K='FORC_VARC_ELEM_P'),)
__nomasv = ASSE_VECTEUR(VECT_ELEM=(__nomvel,__vvarcp), NUME_DDL=num)
else:
__nomasv = ASSE_VECTEUR(VECT_ELEM=(__nomvel,), NUME_DDL=num)
else:
__nomasv = m['VECT_ASSE']
__nomchn = RESOUDRE(
MATR=__nomras, CHAM_NO=__nomasv, TITRE=m['SOUS_TITRE'])
nomchn.append(__nomchn)
# fin de la boucle sur les items de CAS_CHARGE
#
motscles = {}
iocc = 0
motscle2 = {}
if CHAM_MATER:
motscle2['CHAM_MATER'] = CHAM_MATER
iret, ibid, nom_ma = aster.dismoi('EXI_VARC', CHAM_MATER.nom, 'CHAM_MATER', 'F')
print 'toto:',nom_ma
if CARA_ELEM:
motscle2['CARA_ELEM'] = CARA_ELEM
if ielas:
motscles['AFFE'] = []
for m in CAS_CHARGE:
if len(lcharg[iocc]) > 0:
motscles['AFFE'].append(_F(MODELE=MODELE,
CHAM_GD=nomchn[iocc],
NOM_CAS=m['NOM_CAS'],
CHARGE=lcharg[iocc],
**motscle2))
else:
motscles['AFFE'].append(_F(MODELE=MODELE,
CHAM_GD=nomchn[iocc],
NOM_CAS=m['NOM_CAS'],
**motscle2))
iocc = iocc + 1
else:
motscles['AFFE'] = []
for m in CAS_CHARGE:
if len(lcharg[iocc]) > 0:
motscles['AFFE'].append(_F(MODELE=MODELE,
CHAM_GD=nomchn[iocc],
NUME_MODE=m['MODE_FOURIER'],
TYPE_MODE=m['TYPE_MODE'],
CHARGE=lcharg[iocc],
**motscle2))
else:
motscles['AFFE'].append(_F(MODELE=MODELE,
CHAM_GD=nomchn[iocc],
NUME_MODE=m['MODE_FOURIER'],
TYPE_MODE=m['TYPE_MODE'],
**motscle2))
iocc = iocc + 1
if self.reuse:
motscles['reuse'] = self.reuse
nomres = CREA_RESU(
OPERATION='AFFE', TYPE_RESU=tyresu, NOM_CHAM='DEPL', **motscles)
#
# boucle sur les items de CAS_CHARGE pour SIEF_ELGA
iocc = 0
for m in CAS_CHARGE:
iocc = iocc + 1
if m['OPTION'] == 'SIEF_ELGA':
motscles = {}
if ielas:
motscles['NOM_CAS'] = m['NOM_CAS']
else:
motscles['NUME_MODE'] = m['MODE_FOURIER']
CALC_CHAMP(reuse=nomres,
RESULTAT=nomres,
CONTRAINTE='SIEF_ELGA',
**motscles)
# fin de la boucle sur les items de CAS_CHARGE
#
return ier
def calc_gp_ops(self, **args):
"""Corps de CALC_GP"""
MasquerAlarme('CALCCHAMP_1')
global DEFI_GROUP
# On importe les definitions des commandes a utiliser dans la macro
#
#
# RECUPERATION DU MODELE, DU MAILLAGE ET DU MATERIAU A PARTIR DU RESULTAT
#
__RESU = args['RESULTAT']
# modele
__model = __RESU.getModel()
# Dimension du modele
ndim = __model.getMesh().getDimension()
#
# maillage
__maillage = __model.getMesh()
#
__cham_mater = __RESU.getMaterialField()
#
# RECUPERATION DES DONNEES DE SYMETRIE ET DU FOND DE FISSURE
#
# mult=Coefficient multiplicatif suivant la symetrie du probleme
mult = 1.
if 'TRANCHE_2D' in args:
TRANCHE_2D = args['TRANCHE_2D']
if ndim != 2:
UTMESS('F', 'RUPTURE1_19', ['TRANCHE_2D', '2D'])
# symetrie
if args['SYME'] == 'OUI':
mult = 2.
else:
TRANCHE_3D = args['TRANCHE_3D']
if ndim != 3:
UTMESS('F', 'RUPTURE1_19', ['TRANCHE_3D', '3D'])
# liste des noeuds du fond de fissure
l_noeuds_fissure = args['FOND_FISS'].sdj.FOND_NOEU.get()
# normale au plan de la fissure
lnormale = args['FOND_FISS'].sdj.NORMALE.get()
if (lnormale is None):
UTMESS('F', 'POST0_39')
# symetrie
_, _, syme = aster.dismoi('SYME', args['FOND_FISS'].getName(),
'FOND_FISS', 'F')
if syme == 'OUI':
mult = 2
#
# VERIFICATION DE LA LISTE DES INSTANTS
#
# Verification que les instants demandes sont bien dans le resultat
# Construction des instants de calcul par la meme occasion
list_inst = __RESU.LIST_VARI_ACCES()['INST']
l_inst_final = []
for inst in args['LIST_INST'].getValues():
if args['CRITERE'] == 'ABSOLU':
prec = args['PRECISION']
elif args['CRITERE'] == 'RELATIF':
prec = args['PRECISION'] * inst
match = [
x for x in list_inst if ((x + prec >= inst) and (x - prec <= inst))
]
if len(match) == 0:
UTMESS('F', 'RUPTURE0_38', valr=inst)
if len(match) >= 2:
UTMESS('F', 'RUPTURE0_39', valr=inst)
l_inst_final.append(match[0])
nb_inst = len(l_inst_final)
__linstr8 = DEFI_LIST_REEL(VALE=l_inst_final)
#
# PREPARATION DES SORTIES SI GPMAX
#
# Definition du concept sortant systematique dans le contexte de la macro
# L'eventuel champ de copeaux est cree plus tard si besoin
# Definition de la sortie facultative GP_MAX
GPMAX = None
if 'GPMAX' in args:
GPMAX = args['GPMAX']
# Creation des colonnes de la table de sortie gpmax
tabinstmax = []
tabcopmax = []
tabenelmax = []
tablcopmax = []
tabgpmax = []
#
#
# CALCUL DES GP
#
#
# 1/ CAS 2D
#
if ndim == 2:
#
# 1.1/ CAS OU L UTILISATEUR A DEFINI DES GROUPES DE MAILLE COPEAU
# IL SUFFIT ALORS DE CALCULER L ENERGIE DANS CES GROUPES ET D EN DEDUIRE LE GP
#
if TRANCHE_2D['ZONE_MAIL'] == 'OUI':
lgroupma = TRANCHE_2D['GROUP_MA']
lcopeau = TRANCHE_2D['TAILLE'].getValues()
if len(lgroupma) != len(lcopeau):
UTMESS('F', 'RUPTURE1_21')
nbcop = len(lcopeau)
tabmax = [0] * nbcop * nb_inst
tabcop = lgroupma * nb_inst
tablcop = lcopeau * nb_inst
__enertemp = POST_ELEM(MODELE=__model,
RESULTAT=__RESU,
LIST_INST=__linstr8,
ENER_ELTR=_F(GROUP_MA=lgroupma))
enerel = __enertemp.EXTR_TABLE()
enerel_TOTALE = createListFromTableWithoutUnion(enerel, "TOTALE")
tabenel = [mult * x for x in enerel_TOTALE]
tabgp = [tabenel[x] / tablcop[x] for x in range(len(tabenel))]
tabinst = createListFromTableWithoutUnion(enerel, "INST")
for i in range(nb_inst):
maxinst = max(tabgp[i * nbcop:(i + 1) * nbcop])
index1 = tabgp[i * nbcop:(i + 1) * nbcop].index(maxinst)
index = index1 + i * nbcop
tabmax[index] = 1
if GPMAX is not None:
tabinstmax.append(tabinst[index])
tabcopmax.append(tabcop[index])
tabenelmax.append(tabenel[index])
tablcopmax.append(tablcop[index])
tabgpmax.append(tabgp[index])
#
# 1.2/ CAS OU L UTILISATEUR N A PAS DEFINI DES GROUPES DE MAILLE COPEAU
# IL FAUT CREER UN DES COPEAUX PAR ENSEMBLE DE POINTS DE GAUSS ET JOUER AVEC
#
elif TRANCHE_2D['ZONE_MAIL'] == 'NON':
nbcop = TRANCHE_2D['NB_ZONE']
theta = TRANCHE_2D['ANGLE']
taille = TRANCHE_2D['TAILLE']
nom_cmp = ['X%d' % k for k in range(1, nbcop + 1)]
nom_cop = ['COPS_%d' % k for k in range(1, nbcop + 1)]
# champ de geometrie et de points de gauss (coordonnees des points de gauss)
__CHXN = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_GEOM_R',
NOM_CHAM='GEOMETRIE',
MAILLAGE=__maillage)
__CHXG = CREA_CHAMP(OPERATION='DISC',
TYPE_CHAM='ELGA_GEOM_R',
MODELE=__model,
CHAM_GD=__CHXN)
ccos = cos(theta * pi / 180.)
ssin = sin(theta * pi / 180.)
# construction du champ copeau pour visualisation par utilisateur s'il le
# souhaite
if TRANCHE_2D['CHAMP_VISU'] != 0:
__seuil = [None for i in range(nbcop)]
for cop in range(nbcop):
__seuil[cop] = FORMULE(
VALE=
'''SEUIL(X,Y,origine[0],origine[1],rayon,taille,%d,ccos,ssin)'''
% (cop + 1),
NOM_PARA=('X', 'Y'),
origine=TRANCHE_2D['CENTRE'],
rayon=TRANCHE_2D['RAYON'],
taille=taille,
theta=theta,
SEUIL=SEUIL,
ccos=ccos,
ssin=ssin,
)
__formule_seuil = CREA_CHAMP(
TYPE_CHAM='ELGA_NEUT_F',
MODELE=__model,
OPERATION='AFFE',
PROL_ZERO='OUI',
AFFE=_F(
TOUT='OUI',
NOM_CMP=nom_cmp,
VALE_F=__seuil,
),
)
chp_cop = CREA_CHAMP(
TYPE_CHAM='ELGA_NEUT_R',
OPERATION='EVAL',
CHAM_F=__formule_seuil,
CHAM_PARA=(__CHXG),
)
self.register_result(chp_cop, TRANCHE_2D['CHAMP_VISU'])
# calcul des energies et du gp
__ener = [None for cop in range(nbcop)]
for cop in range(nbcop):
__ener[cop] = FORMULE(
VALE=
'''NRJ(TOTALE,X,Y,origine[0],origine[1],rayon,taille,%d,ccos,ssin)'''
% (cop + 1),
NOM_PARA=('TOTALE', 'X', 'Y'),
origine=TRANCHE_2D['CENTRE'],
rayon=TRANCHE_2D['RAYON'],
taille=taille,
NRJ=NRJ,
ccos=ccos,
ssin=ssin,
)
__formule_ener = CREA_CHAMP(
TYPE_CHAM='ELGA_NEUT_F',
MODELE=__model,
OPERATION='AFFE',
PROL_ZERO='OUI',
AFFE=_F(
TOUT='OUI',
NOM_CMP=nom_cmp,
VALE_F=__ener,
),
)
__RESU = CALC_CHAMP(
reuse=__RESU,
RESULTAT=__RESU,
LIST_INST=__linstr8,
ENERGIE=('ENEL_ELGA'),
)
tabmax = [0] * nbcop * nb_inst
tabcop = nom_cop * nb_inst
tablcop = [taille * (cop + 1) for cop in range(nbcop)] * nb_inst
tabinst = []
tabenel = []
tabgp = []
for i, inst in enumerate(l_inst_final):
__energa = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='ELGA_ENER_R',
NOM_CHAM='ENEL_ELGA',
RESULTAT=__RESU,
INST=inst)
__resinter = CREA_CHAMP(
TYPE_CHAM='ELGA_NEUT_R',
OPERATION='EVAL',
CHAM_F=__formule_ener,
CHAM_PARA=(__energa, __CHXG),
)
__tabnrj = POST_ELEM(
CHAM_GD=__resinter,
MODELE=__model,
CHAM_MATER=__cham_mater,
INTEGRALE=_F(TOUT='OUI',
NOM_CHAM='ENEL_ELGA',
NOM_CMP=nom_cmp,
DEJA_INTEGRE='NON',
TYPE_MAILLE='2D'),
)
tabenerel = __tabnrj.EXTR_TABLE().values()
tabinst = tabinst + [inst] * nbcop
enerel = [
mult * tabenerel['INTE_X%d' % (cop + 1)][0]
for cop in range(nbcop)
]
tabenel += enerel
gp = [
enerel[cop] / (taille * (cop + 1)) for cop in range(nbcop)
]
tabgp += gp
maxinst = max(tabgp[i * nbcop:(i + 1) * nbcop])
index1 = tabgp[i * nbcop:(i + 1) * nbcop].index(maxinst)
index = index1 + i * nbcop
tabmax[index] = 1
if GPMAX is not None:
tabinstmax.append(tabinst[index])
tabcopmax.append(tabcop[index])
tabenelmax.append(tabenel[index])
tablcopmax.append(tablcop[index])
tabgpmax.append(tabgp[index])
#
# 2/ CAS 3D
#
elif ndim == 3:
# type des mailles
ltyma = aster.getvectjev("&CATA.TM.NOMTM")
# liste des copeaux
l_copo_tot = []
for tmpocc in TRANCHE_3D:
dMCT = tmpocc.cree_dict_valeurs(tmpocc.mc_liste)
l_copo_tot += dMCT['GROUP_MA']
# le nombre de copeaux est suppose identique sur toutes les tranches
nbcoptot = len(l_copo_tot)
nbcop = nbcoptot // len(TRANCHE_3D)
# calcul de la surface des mailles appartenant au plan de symetrie de
# l'entaille
mesure = Calcul_mesure_3D(__maillage, nbcop, l_copo_tot, ltyma,
l_noeuds_fissure[0], lnormale)
# calcul des energies et du gp
__enertemp = POST_ELEM(
MODELE=__model,
RESULTAT=__RESU,
LIST_INST=__linstr8,
ENER_ELTR=_F(GROUP_MA=l_copo_tot),
TITRE='Energie elastique de traction',
)
enerel = __enertemp.EXTR_TABLE()
tabcop = createListFromTableWithoutUnion(enerel, "LIEU")
enerel_TOTALE = createListFromTableWithoutUnion(enerel, "TOTALE")
tabenel = [mult * x for x in enerel_TOTALE]
tabinst = createListFromTableWithoutUnion(enerel, "INST")
tablcop = mesure * nb_inst
tabgp = [tabenel[x] / tablcop[x] for x in range(len(tabenel))]
tabmax = [0] * nbcoptot * nb_inst
for i in range(nb_inst):
maxinst = max(tabgp[nbcoptot * i:nbcoptot * (i + 1)])
index1 = tabgp[nbcoptot * i:nbcoptot * (i + 1)].index(maxinst)
index = index1 + i * nbcoptot
tabmax[index] = 1
if GPMAX is not None:
tabinstmax.append(tabinst[index])
tabcopmax.append(tabcop[index])
tabenelmax.append(tabenel[index])
tablcopmax.append(tablcop[index])
tabgpmax.append(tabgp[index])
#
#
# CREATION DE LA TABLE DE SORTIE
#
tabout = CREA_TABLE(LISTE=(
_F(PARA='INST', LISTE_R=tabinst),
_F(
PARA='ZONE',
LISTE_K=tabcop,
),
_F(
PARA='ENER ELAS',
LISTE_R=tabenel,
),
_F(
PARA='DELTA L',
LISTE_R=tablcop,
),
_F(
PARA='GP',
LISTE_R=tabgp,
),
_F(
PARA='MAX_INST',
LISTE_I=tabmax,
),
), )
if GPMAX is not None:
tabgpmax = CREA_TABLE(LISTE=(
_F(PARA='INST', LISTE_R=tabinstmax),
_F(
PARA='ZONE',
LISTE_K=tabcopmax,
),
_F(
PARA='ENER ELAS',
LISTE_R=tabenelmax,
),
_F(
PARA='DELTA L',
LISTE_R=tablcopmax,
),
_F(
PARA='GP',
LISTE_R=tabgpmax,
),
), )
self.register_result(tabgpmax, GPMAX)
RetablirAlarme('CALCCHAMP_1')
return tabout
def CHAINAGE_HYDR_MECA(self, args, motscles):
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_RESU = self.get_cmd('CREA_RESU')
PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
INST = None
if args.has_key('INST'):
if args['INST'] != None:
INST = args['INST']
b_type_resu_cham_no = False
TYPE_RESU = args['TYPE_RESU']
if (TYPE_RESU == "CHAM_NO"):
b_type_resu_cham_no = True
RESU_HYDR = args['RESU_HYDR']
MODELE_MECA = args['MODELE_MECA']
MATR_HM1 = args['MATR_HM1']
MATR_HM2 = args['MATR_HM2']
para = RESU_HYDR.LIST_PARA()
smo = set(para['MODELE'])
# normalement, il ne doit y avoir qu'un modèle ...
if len(smo) <> 1:
UTMESS('F', 'CHAINAGE_10')
nom_mo_re = list(smo)[0]
__modele = self.get_concept(nom_mo_re)
#
# Nom du modèle obtenu à partir du résultat : nom_modele_1
#
iret, ibid, nom_modele_1 = aster.dismoi('MODELISATION', __modele.nom,
'MODELE', 'F')
nom_modele_1 = nom_modele_1.strip()
iret, ibid, yathm1 = aster.dismoi('EXI_THM', __modele.nom, 'MODELE', 'F')
#
# A l'heure actuelle, les modélisations autorisées pour
# faire du chaînage sont :
#
# Pour la mécanique :
#
# => D_PLAN, D_PLAN_SI, D_PLAN_GRAD_SIGM
# => 3D, 3D_SI
#
# Pour l'hydraulique :
#
# => D_PLAN_HS
# => 3D_HS
# => les modélisations HM saturées à intégration sélective :
# D_PLAN_HMS, 3D_HMS
#
mod_mec_autorise = ['D_PLAN', 'D_PLAN_SI', 'D_PLAN_GRAD_SIGM']
mod_hyd_autorise = ['D_PLAN_HS', 'D_PLAN_HMS']
#
# Nom du modèle 2 fourni en entrée : nom_modele_2
#
iret, ibid, nom_modele_2 = aster.dismoi('MODELISATION', MODELE_MECA.nom,
'MODELE', 'F')
nom_modele_2 = nom_modele_2.strip()
linst_resultat = RESU_HYDR.LIST_VARI_ACCES()['INST']
#
# INST est rentré en argument par l'utilisateur
# instp et instm sont les 2 derniers instants présents dans
# le résultat donné en entrée
#
instp = linst_resultat[-1]
instm = None
inst0 = linst_resultat[0]
if (inst0 < instp):
# Dans ce cas, on a au moins 2 "vrais" instants dans RESULTAT : instp et
# instm
instm = linst_resultat[-2]
b_inst_initial = False
else:
# Dans ce cas, on a instp = 0 et instm n'existe pas
# On particularise ce cas pour le chaînage HYDR_MECA, mais pas pour le chaînage
# MECA_HYDR où le traitement est plus simple. En effet, cette situation correspond
# à un chaînage HM au premier pas de temps. Il suffit de ne pas donner de variable de
# commande !
b_inst_initial = True
inst_coincident = False
if (INST != None):
if (INST < instp):
UTMESS('F', 'CHAINAGE_6', valr=[INST], valk=[RESU_HYDR.nom])
if abs(instp - INST) < prec:
inst_coincident = True
#
# On vérifie que le résultat donné en entrée
# (hydraulique) est défini
# sur un modèle pour lequel on sait faire du chaînage
#
# A l'heure actuelle, les modélisations autorisées sont :
# => D_PLAN_HS
#
# On répondra plus tard aux demandes d'évolution pour l'insaturé
# et pour le 3D
#
if not (nom_modele_1 in mod_hyd_autorise):
UTMESS('F', 'CHAINAGE_3', valk=[nom_modele_1, 'de départ'])
#
# On récupère le nom du maillage hydraulique à partir du modèle
# hydraulique
#
iret, ibid, nom_mail = aster.dismoi('NOM_MAILLA', __modele.nom, 'MODELE',
'F')
nom_mail = nom_mail.strip()
__maillage_h = self.get_concept(nom_mail)
#
# On vérifie que le résultat donné en sortie
# (mécanique) est défini
# sur un modèle pour lequel on sait faire du chaînage
#
# A l'heure actuelle, les modélisations autorisées sont :
# => D_PLAN, D_PLAN_SI
# => 3D, 3D_SI
#
if not (nom_modele_2 in mod_mec_autorise):
UTMESS('F', 'CHAINAGE_4', valk=[nom_modele_2, 'd arrivée'])
__prep = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
RESULTAT=RESU_HYDR,
NOM_CHAM='DEPL',
INST=instp,
**motscles)
__prepmec = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='ASSE',
MAILLAGE=__maillage_h,
ASSE=(_F(
TOUT='OUI',
CHAM_GD=__prep,
NOM_CMP='PRE1',
NOM_CMP_RESU='PTOT',
), ),
**motscles)
if b_type_resu_cham_no:
__proch = PROJ_CHAMP(CHAM_GD=__prepmec,
MATR_PROJECTION=MATR_HM1,
**motscles)
nomres = PROJ_CHAMP(CHAM_GD=__proch,
MATR_PROJECTION=MATR_HM2,
**motscles)
else:
if not (b_inst_initial):
__prem = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
RESULTAT=RESU_HYDR,
NOM_CHAM='DEPL',
INST=instm,
**motscles)
__premmec = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='ASSE',
MAILLAGE=__maillage_h,
ASSE=(_F(
TOUT='OUI',
CHAM_GD=__prem,
NOM_CMP='PRE1',
NOM_CMP_RESU='PTOT',
), ),
**motscles)
else:
__premmec = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='AFFE',
MAILLAGE=__maillage_h,
AFFE=(_F(
TOUT='OUI',
VALE=0.,
NOM_CMP='PTOT',
), ),
**motscles)
if inst_coincident:
__ptotre = CREA_RESU(
OPERATION='AFFE',
TYPE_RESU='EVOL_VARC',
NOM_CHAM='PTOT',
AFFE=(
_F(
CHAM_GD=__premmec,
INST=instm,
),
_F(
CHAM_GD=__prepmec,
INST=instp,
),
),
)
else:
#
# l'incrément de pression à l'instant t_i=INST est donné par
# les valeurs à t_(i-2)=instm et t_(i-1)=instp
#
__ptotre = CREA_RESU(
OPERATION='AFFE',
TYPE_RESU='EVOL_VARC',
NOM_CHAM='PTOT',
AFFE=(
_F(
CHAM_GD=__premmec,
INST=instp,
),
_F(
CHAM_GD=__prepmec,
INST=INST,
),
),
)
__projres = PROJ_CHAMP(RESULTAT=__ptotre,
MATR_PROJECTION=MATR_HM1,
**motscles)
nomres = PROJ_CHAMP(RESULTAT=__projres,
MATR_PROJECTION=MATR_HM2,
**motscles)
def force_iss_vari(self, imod, MATR_GENE, NOM_CMP, ISSF, INFO, UNITE_RESU_FORC,
UNITE_RESU_IMPE, PRECISION, INTERF, MATR_COHE, TYPE, fini,
PAS, fmax):
"""Force sismique variable en ISS"""
import os
import numpy as NP
from numpy import linalg
from math import pi, ceil, sqrt, floor, log, tanh
import aster_core
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Table import Table
from Utilitai.Utmess import UTMESS
from Utilitai.signal_correlation_utils import (CALC_COHE,
get_group_nom_coord,
calc_dist2)
from code_aster.Cata.Syntax import _F
from code_aster.Cata.Commands import (DETRUIRE, LIRE_IMPE_MISS,
LIRE_FORC_MISS, CREA_CHAMP,
COMB_MATR_ASSE, DYNA_VIBRA)
#--------------------------------------------------------------------------------
NB_FREQ = 1 + int((fmax - fini) / PAS)
FREQ_INIT = fini
from SD.sd_maillage import sd_maillage
from SD.sd_nume_ddl_gd import sd_nume_ddl_gd
from SD.sd_nume_ddl_gene import sd_nume_ddl_gene
from SD.sd_mode_meca import sd_mode_meca
from SD.sd_resultat import sd_resultat
from SD.sd_cham_gene import sd_cham_gene
GROUP_NO_INTER = INTERF['GROUP_NO_INTERF']
# MAILLAGE NUME_DDL
nom_bamo = MATR_GENE['BASE']
resultat = MATR_GENE['BASE']
nom_bam2 = nom_bamo.nom
#iret,ibid,nume_ddl = aster.dismoi('NUME_DDL',nom_bamo.nom,'RESU_DYNA','F')
iret, ibid, nume_ddl = aster.dismoi('NUME_DDL', nom_bam2, 'RESU_DYNA', 'F')
iret, ibid, nom_mail = aster.dismoi('NOM_MAILLA', nume_ddl, 'NUME_DDL',
'F')
# MODELE, DDLGENE
nume_ddlgene = MATR_GENE['NUME_DDL_GENE']
# iret,ibid,nom_modele = aster.dismoi('NOM_MODELE',nume_ddl,'NUME_DDL','F')
# nbnot, nbl, nbma, nbsm, nbsmx, dime = maillage.DIME.get()
# coordonnees des noeuds
# l_coordo = maillage.COORDO.VALE.get()
# t_coordo = NP.array(l_coordo)
# t_coordo.shape = nbnot, 3
l_nom, noe_interf = get_group_nom_coord(GROUP_NO_INTER, nom_mail)
# del nume_ddl, nom_mail, nom_modele
# MODES
iret, nbmodd, kbid = aster.dismoi('NB_MODES_DYN', nom_bam2, 'RESULTAT',
'F')
iret, nbmods, kbid = aster.dismoi('NB_MODES_STA', nom_bam2, 'RESULTAT',
'F')
iret, nbmodt, kbid = aster.dismoi('NB_MODES_TOT', nom_bam2, 'RESULTAT',
'F')
FSIST = NP.zeros((NB_FREQ, nbmodt)) + 0j
nbno, nbval = noe_interf.shape
if INFO == 2:
texte = 'NOMBRE DE MODES: ' + str(
nbmodt) + ' MODES DYNAMIQUES: ' + str(
nbmodd) + ' MODES STATIQUES: ' + str(nbmods)
aster.affiche('MESSAGE', texte)
aster.affiche('MESSAGE', 'COMPOSANTE ' + NOM_CMP)
aster.affiche('MESSAGE', 'NBNO INTERFACE : ' + str(nbno))
# ----- boucle sur les modes statiques
for mods in range(0, nbmods):
nmo = nbmodd + mods + 1
__CHAM = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
NUME_ORDRE=nmo,
RESULTAT=resultat,
NOM_CHAM='DEPL')
MCMP2 = __CHAM.EXTR_COMP(' ', [GROUP_NO_INTER], 0).valeurs
if mods == 0:
NCMP2 = __CHAM.EXTR_COMP(' ', [GROUP_NO_INTER], topo=1).comp
nddi = len(MCMP2)
PHI = NP.zeros((nddi, nbmods))
PHI[:, mods] = MCMP2
PHIT = NP.transpose(PHI)
PPHI = NP.dot(PHIT, PHI)
# MODEL fonction de cohérence
MODEL = MATR_COHE['TYPE']
print 'MODEL :', MODEL
Data_Cohe = {}
Data_Cohe['TYPE'] = MODEL
Data_Cohe['MAILLAGE'] = nom_mail
Data_Cohe['GROUP_NO_INTERF'] = GROUP_NO_INTER
Data_Cohe['NOEUDS_INTERF'] = noe_interf
Data_Cohe['DIST'] = calc_dist2(noe_interf)
if MODEL == 'MITA_LUCO':
Data_Cohe['VITE_ONDE'] = MATR_COHE['VITE_ONDE']
Data_Cohe['PARA_ALPHA'] = MATR_COHE['PARA_ALPHA']
#---------------------------------------------------------------------
# BOUCLE SUR LES FREQUENCES
for k in range(NB_FREQ):
freqk = FREQ_INIT + PAS * k
if INFO == 2:
aster.affiche('MESSAGE', 'FREQUENCE DE CALCUL: ' + str(freqk))
COHE = CALC_COHE(freqk * 2. * pi, **Data_Cohe)
#---------------------------------------------------------
# On desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas
aster_core.matfpe(-1)
eig, vec = linalg.eig(COHE)
vec = NP.transpose(vec) # les vecteurs sont en colonne dans numpy
aster_core.matfpe(1)
eig = eig.real
vec = vec.real
# on rearrange selon un ordre decroissant
eig = NP.where(eig < 1.E-10, 0.0, eig)
order = (NP.argsort(eig)[::-1])
eig = NP.take(eig, order)
vec = NP.take(vec, order, 0)
#-----------------------
# Nombre de modes POD a retenir
etot = NP.sum(eig**2)
ener = 0.0
nbme = 0
while nbme < nbno:
ener = eig[nbme]**2 + ener
prec = ener / etot
nbme = nbme + 1
if INFO == 2:
aster.affiche(
'MESSAGE',
'VALEUR PROPRE ' + str(nbme) + ' : ' + str(eig[nbme - 1]))
if prec > PRECISION:
break
if INFO == 2:
aster.affiche('MESSAGE',
'NOMBRE DE MODES POD RETENUS : ' + str(nbme))
aster.affiche('MESSAGE',
'PRECISION (ENERGIE RETENUE) : ' + str(prec))
PVEC = NP.zeros((nbme, nbno))
for k1 in range(0, nbme):
PVEC[k1, 0:nbno] = NP.sqrt(eig[k1]) * vec[k1]
#----Impedances + force sismique.-----------------------------------------------------------------
if k > 0:
DETRUIRE(CONCEPT=_F(NOM=(__impe, __fosi)), INFO=1)
__impe = LIRE_IMPE_MISS(
BASE=resultat,
TYPE=TYPE,
NUME_DDL_GENE=nume_ddlgene,
UNITE_RESU_IMPE=UNITE_RESU_IMPE,
ISSF=ISSF,
FREQ_EXTR=freqk,
)
# on cree __fosi pour RECU_VECT_GENE_C plus loin
__fosi = LIRE_FORC_MISS(
BASE=resultat,
NUME_DDL_GENE=nume_ddlgene,
NOM_CMP=NOM_CMP,
NOM_CHAM='DEPL',
UNITE_RESU_FORC=UNITE_RESU_FORC,
ISSF=ISSF,
FREQ_EXTR=freqk,
)
# -------------- impedance--------------------------------
MIMPE = __impe.EXTR_MATR_GENE()
# extraction de la partie modes interface
KRS = MIMPE[nbmodd:nbmodt, nbmodd:nbmodt]
# -------------- force sismique-------------------------------
FSISM = __fosi.EXTR_VECT_GENE_C()
FS0 = FSISM[
nbmodd:nbmodt][:] # extraction de la partie modes interface
U0 = NP.dot(linalg.inv(KRS), FS0)
# projection pour obtenir UO en base physique
XI = NP.dot(PHI, U0)
XPI = XI
# # facteur de correction pour tous les modes (on somme) >> c'est faux
SI0 = 0.0
for k1 in range(0, nbme):
XOe = abs(NP.sum(PVEC[k1])) / nbno
SI0 = SI0 + XOe**2
SI = sqrt(SI0)
for idd in range(0, nddi): #nddi: nombre de ddl interface
if NCMP2[idd][0:2] == NOM_CMP:
XPI[idd] = SI * XI[idd]
# retour en base modale
QPI = NP.dot(PHIT, XPI)
U0 = NP.dot(linalg.inv(PPHI), QPI)
FS = NP.dot(KRS, U0)
FSISM[nbmodd:nbmodt][:] = FS
FSIST[k, nbmods:nbmodt] = FSISM[0:nbmodd][:]
FSIST[k, 0:nbmods] = FS
return FSIST
def calc_modes_amelioration(self, modes, TYPE_RESU, INFO, **args):
"""
Macro-command CALC_MODES, file for improving the quality of the eigenmodes
"""
args = _F(args)
SOLVEUR = args.get("SOLVEUR")
VERI_MODE = args.get("VERI_MODE")
TITRE = args.get("TITRE")
# import the definitions of the commands to use in the macro-command
# The name of the variable has to be the name of the command
##############################################################################
# 1. CHECK IF THE COMPUTATION WITH MODE_ITER_INV CAN BE PERFORMED
if TYPE_RESU == 'DYNAMIQUE':
type_vp = 'FREQ'
matr_A = 'MATR_RIGI'
matr_B = 'MATR_MASS'
elif TYPE_RESU == 'MODE_FLAMB':
type_vp = 'CHAR_CRIT'
matr_A = 'MATR_RIGI'
matr_B = 'MATR_RIGI_GEOM'
elif TYPE_RESU == 'GENERAL':
type_vp = 'CHAR_CRIT'
matr_A = 'MATR_A'
matr_B = 'MATR_B'
# 1.1 check if the input matrices are symetric and real
lsym = True
lreel = True
iret, ibid, type_matr_A = aster.dismoi('TYPE_MATRICE',
args[matr_A].getName(), 'MATR_ASSE',
'F')
if not type_matr_A == 'SYMETRI':
lsym = False
if isinstance(args[matr_A], AssemblyMatrixDisplacementComplex) or\
isinstance(args[matr_A], GeneralizedAssemblyMatrixComplex):
lreel = False
iret, ibid, type_matr_B = aster.dismoi('TYPE_MATRICE',
args[matr_B].getName(), 'MATR_ASSE',
'F')
if not type_matr_B == 'SYMETRI':
lsym = False
if TYPE_RESU == 'DYNAMIQUE':
if args['MATR_AMOR'] is not None:
iret, ibid, type_matr_C = aster.dismoi('TYPE_MATRICE',
args['MATR_AMOR'].getName(),
'MATR_ASSE', 'F')
if not type_matr_C == 'SYMETRI':
lsym = False
if not lsym:
UTMESS('I', 'MODAL_15')
return modes
if not lreel:
UTMESS('I', 'MODAL_16', valk=matr_A)
return modes
# 1.2 detect too closed eigen values (gap < CALC_* / SEUIL_*)
list_vp = modes.LIST_PARA()[type_vp] # list of the eigen values
seuil_vp = args['CALC_' + type_vp]['SEUIL_' + type_vp]
# One reproduces here the detection performed in the routine vpgsmm.F90
seuilr = 100. * seuil_vp
seuilp = seuil_vp
ltest = False
for k in range(0, len(list_vp) - 1):
if (abs(list_vp[k]) < seuilr):
ltest = abs(list_vp[k + 1]) < seuilr
else:
if (abs(list_vp[k + 1]) >= seuilr):
ltest = abs(2. * (list_vp[k] - list_vp[k + 1]) /
(list_vp[k] + list_vp[k + 1])) < seuilp
if ltest:
UTMESS('I', 'MODAL_17', valk=modes.getName())
return modes
##############################################################################
# 2. PERFORM THE IMPROVEMENT OF THE MODES WITH MODE_ITER_INV / OPTION='PROCHE'
DETRUIRE(CONCEPT=_F(NOM=modes), INFO=1)
motcles = {}
matrices = {}
# read the input matrices
if TYPE_RESU == 'DYNAMIQUE':
type_vp = 'FREQ'
matrices['MATR_RIGI'] = args['MATR_RIGI']
matrices['MATR_MASS'] = args['MATR_MASS']
if args['MATR_AMOR'] is not None:
matrices['MATR_AMOR'] = args['MATR_AMOR']
elif TYPE_RESU == 'MODE_FLAMB':
type_vp = 'CHAR_CRIT'
matrices['MATR_RIGI'] = args['MATR_RIGI']
matrices['MATR_RIGI_GEOM'] = args['MATR_RIGI_GEOM']
elif TYPE_RESU == 'GENERAL':
type_vp = 'CHAR_CRIT'
matrices['MATR_A'] = args['MATR_A']
matrices['MATR_B'] = args['MATR_B']
motcles.update(matrices)
#################################################################
motcles_calc_vp = {}
motcles_calc_vp[type_vp] = list_vp
motcles['CALC_' + type_vp] = _F(OPTION='PROCHE', **motcles_calc_vp)
#################################################################
# read the keyword SOLVEUR (linear solver)
solveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
if 'TYPE_RESU' in solveur: # because TYPE_RESU is a keyword with a 'global' position
solveur.pop('TYPE_RESU')
if 'OPTION' in solveur: # because OPTION is a keyword with a 'global' position
solveur.pop('OPTION')
if 'FREQ' in solveur: # because FREQ can be a keyword with a 'global' position
solveur.pop('FREQ')
motcles['SOLVEUR'] = _F(**solveur) # if this line is commented,
# one will use the default keywords for SOLVEUR
#################################################################
# read the keyword VERI_MODE
#
sturm = VERI_MODE['STURM']
if sturm in ('GLOBAL', 'LOCAL', 'OUI'):
# for MODE_ITER_INV, value for STURM can be only OUI or NON. Other
# values are equivalent to OUI
motveri = 'OUI'
elif sturm in ('NON'):
# for keyword AMELIORATION
motveri = 'NON'
else:
assert (False) # Pb parametrage STURM )
motcles['VERI_MODE'] = _F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'],
SEUIL=VERI_MODE['SEUIL'],
STURM=motveri,
PREC_SHIFT=VERI_MODE['PREC_SHIFT'])
#################################################################
if TITRE is not None:
motcles['TITRE'] = TITRE
#################################################################
modes = MODE_ITER_INV(TYPE_RESU=TYPE_RESU, INFO=INFO, **motcles)
return modes
def observation_ops(self,
PROJECTION=None,
MODELE_1=None,
MODELE_2=None,
RESULTAT=None,
MATR_RIGI=None,
MATR_MASS=None,
MODI_REPERE=None,
NOM_CHAM=None,
FILTRE=None,
EPSI_MOYENNE=None,
**args):
"""
Ecriture de la macro MACRO_OBSERVATION
"""
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# on transforme le mc MODI_REPERE pour ne pas le confondre avec l'operateur
# du meme nom
MODIF_REPERE = MODI_REPERE
# importation de commandes
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
from code_aster.Cata.DataStructure import (mode_meca, dyna_harmo,
evol_elas, dyna_trans)
MODI_REPERE = self.get_cmd('MODI_REPERE')
PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_RESU = self.get_cmd('CREA_RESU')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
DETRUIRE = self.get_cmd('DETRUIRE')
# dans **args, on range les options de PROJ_CHAMP facultatives, et dont on
# ne sert pas par la suite
mcfact = args
if not isinstance(NOM_CHAM, tuple):
NOM_CHAM = [NOM_CHAM]
TYPE_CHAM = None
RESU = None
if isinstance(RESULTAT, evol_elas):
TYPE_RESU = 'EVOL_ELAS'
if isinstance(RESULTAT, dyna_trans):
TYPE_RESU = 'DYNA_TRANS'
if isinstance(RESULTAT, dyna_harmo):
TYPE_RESU = 'DYNA_HARMO'
if isinstance(RESULTAT, mode_meca):
TYPE_RESU = 'MODE_MECA'
self.DeclareOut('RESU', self.sd)
# recuperation du maillage associe au modele numerique
_maillag = aster.getvectjev(MODELE_1.nom.ljust(8) + '.MODELE .LGRF')
maillage = _maillag[0].strip()
mayanum = self.get_concept(maillage)
# modele numerique 2D ou 3D
typmod = mayanum.sdj.DIME.get()
typmod = typmod[5]
# recuperation du maillage associe au modele experimental
_maillag = aster.getvectjev(MODELE_2.nom.ljust(8) + '.MODELE .LGRF')
maillage = _maillag[0].strip()
mayaexp = self.get_concept(maillage)
# cham_mater et cara_elem pour le resultat a projeter
iret, ibid, nom_cara_elem = aster.dismoi('CARA_ELEM', RESULTAT.nom,
'RESULTAT', 'F')
if len(nom_cara_elem) > 0:
assert nom_cara_elem.strip() != "#PLUSIEURS", nom_cara_elem
if nom_cara_elem.strip() == "#AUCUN":
cara_elem = None
else:
cara_elem = self.get_concept(nom_cara_elem.strip())
else:
cara_elem = None
iret, ibid, nom_cham_mater = aster.dismoi('CHAM_MATER', RESULTAT.nom,
'RESULTAT', 'F')
if len(nom_cham_mater) > 0:
assert nom_cham_mater.strip() != "#PLUSIEURS", nom_cham_mater
if nom_cham_mater.strip() == "#AUCUN":
cham_mater = None
else:
cham_mater = self.get_concept(nom_cham_mater.strip())
else:
cham_mater = None
# afreq pour les frequences propres
if isinstance(RESULTAT, mode_meca):
# frequences propres
from code_aster.Cata.Commands import RECU_TABLE
__freq = RECU_TABLE(
CO=RESULTAT,
NOM_PARA='FREQ',
)
afreq = __freq.EXTR_TABLE().Array('NUME_ORDRE', 'FREQ')
# noms des matrices
if MATR_RIGI != None or MATR_MASS != None:
# recherche du nume_ddl associe
iret, ibid, nom_nume_ddl = aster.dismoi('NOM_NUME_DDL',
MATR_RIGI.nom, 'MATR_ASSE',
'F')
NUME_DDL = self.get_concept(nom_nume_ddl)
# coherence avec le nom associe a MODELE_2 :
iret, ibid, nom_modele = aster.dismoi('NOM_MODELE', nom_nume_ddl,
'NUME_DDL', 'F')
if nom_modele.strip() != MODELE_2.nom.strip():
UTMESS('F', 'CALCESSAI0_10')
else:
UTMESS('A', 'CALCESSAI0_9')
NUME_DDL = None
else:
afreq = None
NUME_DDL = None
indice = range(len(RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE']))
#***********************************************
# PHASE DE CALCUL DE LA DEFORMATION MOYENNE AUX NOEUDS
# CHAMP CALCULE SUR LE MODELE NUMERIQUE
#***********************************************
resu_epsi = None
if EPSI_MOYENNE != None:
for nomcham in NOM_CHAM:
if nomcham == 'EPSI_NOEU':
if isinstance(RESULTAT, dyna_harmo):
TYPE_CHAM = 'NOEU_EPSI_C'
else:
TYPE_CHAM = 'NOEU_EPSI_R'
if TYPE_CHAM == None:
UTMESS('F', 'UTILITAI8_24', valk=['NOEU_EPSI', nomcham])
else:
num_ordr = RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE']
if isinstance(RESULTAT, evol_elas):
list_inst = RESULTAT.LIST_VARI_ACCES()['INST']
if isinstance(RESULTAT, dyna_trans):
list_inst = RESULTAT.LIST_VARI_ACCES()['INST']
if isinstance(RESULTAT, dyna_harmo):
list_freq = RESULTAT.LIST_VARI_ACCES()['FREQ']
liste = []
# il faut calculer le champ complet
if typmod == 2:
nom_cmps = [
'EPXX',
'EPYY',
'EPZZ',
'EPXY',
]
else:
nom_cmps = [
'EPXX',
'EPYY',
'EPZZ',
'EPXY',
'EPXZ',
'EPYZ',
]
argsi = {
'ACTION': [],
}
lnoeuds = {}
nb_mcfact = 0
seuil = []
masque = []
for epsi_moye in EPSI_MOYENNE:
mcfactr = {}
mcfacti = {}
l_noeud = None
val_masque = []
seuil_lu = epsi_moye['SEUIL_VARI']
if type(seuil_lu) == tuple:
val_seuil = seuil_lu[0]
else:
val_seuil = seuil_lu
seuil.append(val_seuil)
masque_lu = epsi_moye['MASQUE']
if type(masque_lu) != tuple:
val_masque.append(masque_lu)
else:
val_masque = masque_lu
masque.append(val_masque)
for typ in ['NOEUD', 'GROUP_NO', 'MAILLE', 'GROUP_MA']:
if epsi_moye[typ] != None:
l_noeud = find_no(mayanum, {typ: epsi_moye[typ]})
nb_mcfact = nb_mcfact + 1
for i in range(len(l_noeud)):
l_noeud[i] = l_noeud[i].strip()
lnoeuds[str(nb_mcfact)] = l_noeud
if l_noeud == None:
UTMESS('F', 'MODELISA3_13', valk=['EPSI_MOYENNE'])
if TYPE_CHAM[-1:] == 'C':
mcfactr = {
'NOM_CMP': nom_cmps,
'OPERATION': 'EXTRACTION',
'INTITULE': str('R' + str(nb_mcfact)),
'FORMAT_C': 'REEL',
'NOEUD': l_noeud,
'NOM_CHAM': 'EPSI_NOEU',
'RESULTAT': RESULTAT,
'NUME_ORDRE': num_ordr,
}
argsi['ACTION'].append(mcfactr)
mcfacti = {
'NOM_CMP': nom_cmps,
'OPERATION': 'EXTRACTION',
'INTITULE': str('I' + str(nb_mcfact)),
'FORMAT_C': 'IMAG',
'NOEUD': l_noeud,
'NOM_CHAM': 'EPSI_NOEU',
'RESULTAT': RESULTAT,
'NUME_ORDRE': num_ordr,
}
argsi['ACTION'].append(mcfacti)
else:
mcfactr = {
'NOM_CMP': nom_cmps,
'OPERATION': 'EXTRACTION',
'INTITULE': str(nb_mcfact),
'NOEUD': l_noeud,
'NOM_CHAM': 'EPSI_NOEU',
'RESULTAT': RESULTAT,
'NUME_ORDRE': num_ordr,
}
argsi['ACTION'].append(mcfactr)
_tepsi = POST_RELEVE_T(**argsi)
table = _tepsi.EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=_tepsi), INFO=1)
mcfact2 = {}
__chame = [None] * len(indice)
for ind in indice:
argsa = {
'AFFE': [],
}
for mcfacta in range(nb_mcfact):
l_noeud_mcfact = lnoeuds[str(mcfacta + 1)]
l_vmoye = []
l_cmp_vari = []
seuil_mc = seuil[mcfacta]
masque_mc = masque[mcfacta]
for cmp in nom_cmps:
lur = 0
lui = 0
l_valr = []
l_vali = []
l_valc = []
l_val = []
for row in table.rows:
if TYPE_CHAM[-1:] == 'C':
if row['INTITULE'].strip() == str('R' + str(mcfacta + 1)) \
and row['NUME_ORDRE'] == num_ordr[ind]:
l_valr.append(row[cmp])
lur = 1
elif row['INTITULE'].strip() == str('I' + str(mcfacta + 1)) \
and row['NUME_ORDRE'] == num_ordr[ind]:
l_vali.append(row[cmp])
lui = 1
else:
if row['INTITULE'].strip() == str(mcfacta + 1) \
and row['NUME_ORDRE'] == num_ordr[ind]:
l_val.append(row[cmp])
if TYPE_CHAM[-1:] == 'C':
if lur and lui:
if len(l_valr) != len(l_vali):
UTMESS('F', 'POSTRELE_59')
for i in range(len(l_valr)):
l_valc.append(complex(
l_valr[i], l_vali[i]))
lur = 0
lui = 0
else:
UTMESS('F', 'POSTRELE_59')
# on regarde a la fois la partie reelle et la partie imag
# pour les complexes
vmoyer = sum(l_valr) / len(l_valr)
vmoyei = sum(l_vali) / len(l_vali)
vmoye = sum(l_valc) / len(l_valc)
vminr = min(l_valr)
vmini = min(l_vali)
vmaxr = max(l_valr)
vmaxi = max(l_vali)
if vmoyer > 0:
if (vmaxr > vmoyer *
(1. + seuil_mc)) or (vminr < vmoyer *
(1 - seuil_mc)):
l_cmp_vari.append(cmp)
if vmoyei > 0:
if (vmaxi > vmoyei *
(1. + seuil_mc)) or (vmini < vmoyei *
(1 - seuil_mc)):
l_cmp_vari.append(cmp)
if vmoyer < 0:
if (vminr > vmoyer *
(1. - seuil_mc)) or (vmaxr < vmoyer *
(1 + seuil_mc)):
l_cmp_vari.append(cmp)
if vmoyei < 0:
if (vmini > vmoyei *
(1. - seuil_mc)) or (vmaxi < vmoyei *
(1 + seuil_mc)):
l_cmp_vari.append(cmp)
else:
vmoye = sum(l_val) / len(l_val)
vmin = min(l_val)
vmax = max(l_val)
if vmoye > 0:
if (vmax > vmoye *
(1. + seuil_mc)) or (vmin < vmoye *
(1 - seuil_mc)):
l_cmp_vari.append(cmp)
if vmoye < 0:
if (vmin > vmoye *
(1. - seuil_mc)) or (vmax < vmoye *
(1 + seuil_mc)):
l_cmp_vari.append(cmp)
l_vmoye.append(vmoye)
if len(l_cmp_vari) > 0:
for cmp in nom_cmps:
vu = 0
for cmp_vari in l_cmp_vari:
if cmp_vari not in masque_mc:
if cmp == cmp_vari and not vu:
if EPSI_MOYENNE[mcfacta][
'MAILLE'] != None:
entite = str(
'MAILLE : ' +
str(EPSI_MOYENNE[mcfacta]
['MAILLE']))
if EPSI_MOYENNE[mcfacta][
'GROUP_MA'] != None:
entite = str(
'GROUP_MA : ' +
str(EPSI_MOYENNE[mcfacta]
['GROUP_MA']))
UTMESS('A',
'OBSERVATION_8',
vali=[num_ordr[ind]],
valr=[seuil_mc],
valk=[entite, cmp])
vu = 1
if TYPE_CHAM[-1:] == 'C':
mcfactc = {
'NOM_CMP': nom_cmps,
'NOEUD': l_noeud_mcfact,
'VALE_C': l_vmoye,
}
else:
mcfactc = {
'NOM_CMP': nom_cmps,
'NOEUD': l_noeud_mcfact,
'VALE': l_vmoye,
}
argsa['AFFE'].append(mcfactc)
__chame[ind] = CREA_CHAMP(OPERATION='AFFE',
MODELE=MODELE_1,
TYPE_CHAM=TYPE_CHAM,
OPTION='EPSI_NOEU',
**argsa)
if isinstance(RESULTAT, mode_meca):
mcfact2 = {
'CHAM_GD': __chame[ind],
'MODELE': MODELE_1,
'NUME_MODE': int(afreq[ind, 0]),
'FREQ': afreq[ind, 1],
}
if isinstance(RESULTAT, evol_elas):
mcfact2 = {
'CHAM_GD': __chame[ind],
'MODELE': MODELE_1,
'INST': list_inst[ind],
}
if isinstance(RESULTAT, dyna_trans):
mcfact2 = {
'CHAM_GD': __chame[ind],
'MODELE': MODELE_1,
'INST': list_inst[ind],
}
if isinstance(RESULTAT, dyna_harmo):
mcfact2 = {
'CHAM_GD': __chame[ind],
'MODELE': MODELE_1,
'FREQ': list_freq[ind],
}
if cham_mater is not None:
mcfact2['CHAM_MATER'] = cham_mater
if cara_elem is not None:
mcfact2['CARA_ELEM'] = cara_elem
liste.append(mcfact2)
resu_epsi = 'EPSI_NOEU'
RESU = CREA_RESU(
OPERATION='AFFE',
TYPE_RESU=TYPE_RESU,
NOM_CHAM='EPSI_NOEU',
AFFE=liste,
)
#***********************************************
# BOUCLE SUR LES NOM_CHAM
#***********************************************
for nomcham in NOM_CHAM:
if nomcham == 'DEPL' or nomcham == 'VITE' or nomcham == 'ACCE':
if isinstance(RESULTAT, dyna_harmo):
TYPE_CHAM = 'NOEU_DEPL_C'
else:
TYPE_CHAM = 'NOEU_DEPL_R'
elif nomcham == 'EPSI_NOEU':
if isinstance(RESULTAT, dyna_harmo):
TYPE_CHAM = 'NOEU_EPSI_C'
else:
TYPE_CHAM = 'NOEU_EPSI_R'
else:
UTMESS('F', 'ELEMENTS4_48', valk=[nomcham])
#***********************************************
# PHASE DE PROJECTION
#***********************************************
if PROJECTION == 'OUI':
if resu_epsi and nomcham == 'EPSI_NOEU':
__proj = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=RESU,
MODELE_1=MODELE_1,
MODELE_2=MODELE_2,
NOM_CHAM=nomcham,
**mcfact)
else:
__proj = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=RESULTAT,
MODELE_1=MODELE_1,
MODELE_2=MODELE_2,
NOM_CHAM=nomcham,
**mcfact)
modele = MODELE_2
else:
if resu_epsi and nomcham == 'EPSI_NOEU':
__proj = RESU
else:
__proj = RESULTAT
modele = MODELE_1
#***********************************************
# PHASE DE CHANGEMENT DE REPERE
#***********************************************
# Le changement de repere se fait dans les routines exterieures
# crea_normale et crea_repere
# On range dans le mcfact MODI_REPERE une liste de modifications. ex :
# MODI_REPERE = ( _F( GROUP_NO = toto,
# REPERE = 'NORMALE' ),
# CONDITION = (1.0,0.0,0.0),
# NOM_PARA = 'X')
# _F( NOEUD = ('a','z','e'...),
# REPERE = 'CYLINDRIQUE',
# ORIGINE = (0.,0.,0.),
# AXE_Z = (0.,1.,0.), ),
# _F( GROUP_NO = titi,
# REPERE = 'UTILISATEUR',
# ANGL_NAUT = (alpha, beta, gamma), )
# )
if MODIF_REPERE != None:
num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE']
for modif_rep in MODIF_REPERE:
modi_rep = modif_rep.val
type_cham = modif_rep['TYPE_CHAM']
nom_cmp = modif_rep['NOM_CMP']
if type_cham == 'TENS_2D':
nomchamx = 'EPSI_NOEU'
elif type_cham == 'TENS_3D':
nomchamx = 'EPSI_NOEU'
else:
nomchamx = 'DEPL'
if nomcham == nomchamx:
mcfact1 = {
'NOM_CMP': nom_cmp,
'TYPE_CHAM': type_cham,
'NOM_CHAM': nomcham
}
mcfact2 = {}
if modi_rep['REPERE'] == 'DIR_JAUGE':
vect_x = None
vect_y = None
if modi_rep.has_key('VECT_X'):
vect_x = modi_rep['VECT_X']
if modi_rep.has_key('VECT_Y'):
vect_y = modi_rep['VECT_Y']
# il faut des mailles pour les tenseurs d'ordre 2
for typ in [
'MAILLE',
'GROUP_MA',
]:
if modi_rep.has_key(typ):
if PROJECTION == 'OUI':
maya = mayaexp
else:
maya = mayanum
list_ma = find_ma(maya, {typ: modi_rep[typ]})
angl_naut = crea_repere_xy(vect_x, vect_y)
mcfact2.update({
'MAILLE': list_ma,
'ANGL_NAUT': angl_naut
})
argsm = {'MODI_CHAM': mcfact1, 'AFFE': mcfact2}
__bidon = MODI_REPERE(RESULTAT=__proj,
REPERE='UTILISATEUR',
NUME_ORDRE=num_ordr,
**argsm)
DETRUIRE(CONCEPT=_F(NOM=__proj), INFO=1)
__proj = __bidon
if modi_rep['REPERE'] == 'NORMALE':
# Cas ou l'utilisateur choisit de creer les reperes locaux
# selon la normale. On fait un changement de repere local
# par noeud
for option in [
'VECT_X', 'VECT_Y', 'CONDITION_X',
'CONDITION_Y'
]:
if modi_rep.has_key(option):
vect = {option: modi_rep[option]}
if len(vect) != 1:
UTMESS('E', 'UTILITAI7_9')
chnorm = crea_normale(self, MODELE_1, MODELE_2,
NUME_DDL, cham_mater, cara_elem)
modele = MODELE_2
chnormx = chnorm.EXTR_COMP('DX', [], 1)
ind_noeuds = chnormx.noeud
nom_allno = [
mayaexp.sdj.NOMNOE.get()[k - 1] for k in ind_noeuds
]
# on met les noeuds conernes sous forme de liste et on va
# chercher les noeuds des mailles pour 'MAILLE' et
# 'GROUP_MA'
for typ in ['NOEUD', 'GROUP_NO', 'MAILLE', 'GROUP_MA']:
if modi_rep.has_key(typ):
list_no_exp = find_no(mayaexp,
{typ: modi_rep[typ]})
# boucle sur les noeuds pour modifier les reperes.
__bid = [None] * (len(list_no_exp) + 1)
__bid[0] = __proj
k = 0
for nomnoe in list_no_exp:
ind_no = nom_allno.index(nomnoe)
angl_naut = crea_repere(chnorm, ind_no, vect)
mcfact2.update({
'NOEUD': nomnoe,
'ANGL_NAUT': angl_naut
})
argsm = {'MODI_CHAM': mcfact1, 'AFFE': mcfact2}
__bid[k + 1] = MODI_REPERE(RESULTAT=__bid[k],
REPERE='UTILISATEUR',
TOUT_ORDRE='OUI',
CRITERE='RELATIF',
**argsm)
k = k + 1
__proj = __bid[-1:][0]
if modi_rep['REPERE'] == 'UTILISATEUR' or modi_rep[
'REPERE'] == 'CYLINDRIQUE':
if type_cham == 'TENS_2D' or type_cham == 'TENS_3D':
for typ in [
'MAILLE',
'GROUP_MA',
]:
if modi_rep.has_key(typ):
mcfact2.update({typ: modi_rep[typ]})
else:
for typ in [
'NOEUD', 'GROUP_NO', 'MAILLE', 'GROUP_MA'
]:
if modi_rep.has_key(typ):
mcfact2.update({typ: modi_rep[typ]})
if modi_rep['REPERE'] == 'CYLINDRIQUE':
origine = modi_rep['ORIGINE']
axe_z = modi_rep['AXE_Z']
mcfact2.update({
'ORIGINE': origine,
'AXE_Z': axe_z
})
elif modi_rep['REPERE'] == 'UTILISATEUR':
angl_naut = modi_rep['ANGL_NAUT']
mcfact2.update({'ANGL_NAUT': angl_naut})
argsm = {
'MODI_CHAM': mcfact1,
'REPERE': modi_rep['REPERE'],
'AFFE': mcfact2
}
__bidon = MODI_REPERE(RESULTAT=__proj,
CRITERE='RELATIF',
**argsm)
DETRUIRE(CONCEPT=_F(NOM=__proj), INFO=1)
__proj = __bidon
#*************************************************
# Phase de selection des DDL de mesure
#*************************************************
resu_filtre = None
if FILTRE != None:
num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE']
__chamf = [None] * len(indice)
if isinstance(RESULTAT, evol_elas):
list_inst = __proj.LIST_VARI_ACCES()['INST']
if isinstance(RESULTAT, dyna_trans):
list_inst = __proj.LIST_VARI_ACCES()['INST']
if isinstance(RESULTAT, dyna_harmo):
list_freq = __proj.LIST_VARI_ACCES()['FREQ']
liste = []
for ind in indice:
mcfact2 = {}
filtres = []
__chamex = CREA_CHAMP(
TYPE_CHAM=TYPE_CHAM,
OPERATION='EXTR',
RESULTAT=__proj,
NOM_CHAM=nomcham,
NUME_ORDRE=num_ordr[ind],
)
for mcfiltre in FILTRE:
filtre = mcfiltre.val
try:
nomchamx = filtre['NOM_CHAM']
except KeyError:
nomchamx = None
if nomchamx == None or nomchamx == nomcham:
mcfact1 = {}
atraiter = None
if filtre['DDL_ACTIF'][0][
0] == 'E' and nomcham == 'EPSI_NOEU':
atraiter = nomcham
elif filtre['DDL_ACTIF'][0][
0] == 'D' and nomcham == 'DEPL':
atraiter = nomcham
elif filtre['DDL_ACTIF'][0][
0] == 'D' and nomcham == 'VITE':
atraiter = nomcham
elif filtre['DDL_ACTIF'][0][
0] == 'D' and nomcham == 'ACCE':
atraiter = nomcham
if atraiter:
for typ in [
'NOEUD', 'GROUP_NO', 'MAILLE', 'GROUP_MA'
]:
if filtre.has_key(typ):
mcfact1.update({typ: filtre[typ]})
mcfact1.update({
'NOM_CMP': filtre['DDL_ACTIF'],
'CHAM_GD': __chamex
})
filtres.append(mcfact1)
if len(filtres) > 0:
if nomcham == 'DEPL' or nomcham == 'VITE' or nomcham == 'ACCE':
__chamf[ind] = CREA_CHAMP(TYPE_CHAM=TYPE_CHAM,
OPERATION='ASSE',
MODELE=modele,
ASSE=filtres)
elif nomcham == 'EPSI_NOEU':
__chamf[ind] = CREA_CHAMP(
TYPE_CHAM=TYPE_CHAM,
OPERATION='ASSE',
MODELE=modele,
ASSE=filtres,
)
else:
valk = []
valk.append(nomcham)
valk.append('DEPL VITE ACCE')
valk.append('EPSI_NOEU')
UTMESS('F', 'OBSERVATION_6', valk)
argsr = {}
if isinstance(RESULTAT, mode_meca):
mcfact2 = {
'CHAM_GD': __chamf[ind],
'MODELE': modele,
'NUME_MODE': int(afreq[ind, 0]),
'FREQ': afreq[ind, 1],
}
# on recopie les matrices associees au MODELE_2 dans le resultat final
# NB : ce n'est peut-etre pas propre, car ces matrices ne
# veulent plus rien dire si on a filtre des DDL !!!!!
argsr = {
'MATR_RIGI': MATR_RIGI,
'MATR_MASS': MATR_MASS
}
if isinstance(RESULTAT, evol_elas):
mcfact2 = {
'CHAM_GD': __chamf[ind],
'MODELE': modele,
'INST': list_inst[ind],
}
if isinstance(RESULTAT, dyna_trans):
mcfact2 = {
'CHAM_GD': __chamf[ind],
'MODELE': modele,
'INST': list_inst[ind],
}
if isinstance(RESULTAT, dyna_harmo):
mcfact2 = {
'CHAM_GD': __chamf[ind],
'MODELE': MODELE_2,
'FREQ': list_freq[ind],
}
if cham_mater is not None:
mcfact2['CHAM_MATER'] = cham_mater
if cara_elem is not None:
mcfact2['CARA_ELEM'] = cara_elem
liste.append(mcfact2)
DETRUIRE(CONCEPT=_F(NOM=__chamex), INFO=1)
if len(filtres) > 0 and len(liste) > 0:
resu_filtre = nomcham
if RESU:
RESU = CREA_RESU(reuse=RESU,
OPERATION='AFFE',
TYPE_RESU=TYPE_RESU,
NOM_CHAM=nomcham,
AFFE=liste,
**argsr)
else:
RESU = CREA_RESU(OPERATION='AFFE',
TYPE_RESU=TYPE_RESU,
NOM_CHAM=nomcham,
AFFE=liste,
**argsr)
#*************************************************
# Recopie de __proj dans RESU si celle-ci
# n'a pas encore ete faite via FILTRE
#*************************************************
if resu_filtre == None:
RESU = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=__proj,
MODELE_1=modele,
MODELE_2=modele,
NUME_DDL=NUME_DDL,
NOM_CHAM=nomcham,
**mcfact)
return ier
def post_czm_fiss_ops(self, OPTION, RESULTAT, **args):
"""Corps de POST_CZM_FISS"""
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
#
# calcul de la longueur d'une fissure cohesive 2D
#
if OPTION == "LONGUEUR":
# Nom de la sortie
self.DeclareOut('TABLE_OUT', self.sd)
# Mots cles specifiques au bloc "LONGUEUR"
GROUP_MA = args['GROUP_MA']
POINT_ORIG = args['POINT_ORIG']
VECT_TANG = args['VECT_TANG']
# On importe les definitions des commandes a utiliser dans la macro
CALC_CHAM_ELEM = self.get_cmd('CALC_CHAM_ELEM')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_TABLE = self.get_cmd('CREA_TABLE')
EXTR_COMP = self.get_cmd('EXTR_COMP')
DETRUIRE = self.get_cmd('DETRUIRE')
# Recuperation du nom du modele
iret, ibid, n_modele = aster.dismoi('MODELE', RESULTAT.nom, 'RESULTAT',
'F')
n_modele = n_modele.rstrip()
if len(n_modele) == 0:
UTMESS('F', 'RUPTURE0_18')
__MODEL = self.get_concept(n_modele)
# Calcul des coordonnees des points de Gauss
__CHAMEL = CALC_CHAM_ELEM(MODELE=__MODEL,
GROUP_MA=GROUP_MA,
OPTION='COOR_ELGA')
__CORX = __CHAMEL.EXTR_COMP('X', list(GROUP_MA), 1)
__CORY = __CHAMEL.EXTR_COMP('Y', list(GROUP_MA), 1)
xg = __CORX.valeurs
yg = __CORY.valeurs
nbpg = len(xg)
xmin = min(xg)
ymin = min(yg)
xmax = max(xg)
ymax = max(yg)
# A = coef dir et B=ordo orig de la droite des pg
A = (ymax - ymin) / (xmax - xmin)
B = ymax - A * xmax
# Vecteur des points de gauss (qui va du point min au point max) et sa
# norme
vx = xmax - xmin
vy = ymax - ymin
nv = (vx**2 + vy**2)**0.5
# vecteur directeur dans la direction ou l'on calcule la longueur
xdir = VECT_TANG[0]
ydir = VECT_TANG[1]
ndir = (xdir**2 + ydir**2)**0.5
# point de reference a partir duquel on calcule la longueur
xref = POINT_ORIG[0]
yref = POINT_ORIG[1]
# angle entre le vecteur des points de gauss et le vecteur donne par
# l'utilisateur
alpha = acos((xdir * vx + ydir * vy) / (ndir * nv))
# petit parametre de tolerence
eps = 0.0001
# cas ou le point de reference n'est pas aligne avec les points de
# Gauss
if (abs(yref - A * xref - B) >= eps):
UTMESS('F',
'POST0_45',
valk=list(GROUP_MA),
valr=(xmin, xmax, ymin, ymax))
# cas ou le vecteur n'est pas colineaire a la droite des points de
# Gauss
if (abs(alpha) >= eps) and (abs(alpha - pi) >= eps):
UTMESS('F',
'POST0_46',
valk=list(GROUP_MA),
valr=(xmin, xmax, ymin, ymax))
# Calcul de la distance signee des points de Gauss au point de
# reference
disg = distance(xg, yg, xref, yref, xdir, ydir)
ming = min(disg)
maxg = max(disg)
__INST = RESULTAT.LIST_VARI_ACCES()['INST']
nbinst = len(__INST)
Lfis = [0] * (nbinst)
Ltot = [0] * (nbinst)
Lcoh = [0] * (nbinst)
__VI = [0] * (nbinst)
for j in range(0, nbinst):
__VI[j] = CREA_CHAMP(
TYPE_CHAM='ELGA_VARI_R',
OPERATION='EXTR',
RESULTAT=RESULTAT,
NOM_CHAM='VARI_ELGA',
NUME_ORDRE=j,
)
__VI3 = __VI[j].EXTR_COMP('V3', list(GROUP_MA), 1)
mat_v3 = __VI3.valeurs
nbpg = len(mat_v3)
# Evaluation du nombre de points de gauss dans chaque etat
cpt0 = 0
cpt1 = 0
cpt2 = 0
max0 = ming
min0 = maxg
max1 = ming
min1 = maxg
max2 = ming
min2 = maxg
for i in range(0, nbpg):
if (disg[i] >= 0.0):
if mat_v3[i] == 1.: # si c'est un pdg en zone cohesive
cpt1 = cpt1 + 1
max1 = max(max1, disg[i])
min1 = min(min1, disg[i])
else:
if mat_v3[i] == 2.: # si c'est un pdg en fissure
cpt2 = cpt2 + 1
max2 = max(max2, disg[i])
min2 = min(min2, disg[i])
else:
if mat_v3[i] == 0.: # si c'est un pdg sain
cpt0 = cpt0 + 1
max0 = max(max0, disg[i])
min0 = min(min0, disg[i])
# verification qu'entre min1 et max1 on a que des mailles 1
for i in range(0, nbpg):
if (cpt1 != 0):
if (disg[i] >= min1) and (disg[i] <= max1):
if (mat_v3[i] != 1.):
UTMESS('A', 'POST0_48')
# Verification qu'il y a bien des points de Gauss sur la
# demi-droite definie par l'utilisateur
if (cpt0 + cpt1 + cpt2 == 0):
UTMESS('F',
'POST0_47',
valk=list(GROUP_MA),
valr=(xmin, xmax, ymin, ymax))
# Verification de la taille de la zone cohesive
if (cpt2 != 0) and (cpt1 <= 3):
UTMESS('A', 'POST0_49')
# Evaluation des longueurs
if (cpt1 == 0) and (cpt2 == 0):
Ltot[j] = min0
Lfis[j] = min0
else:
if (cpt1 != 0) and (cpt2 == 0):
Ltot[j] = (min0 + max1) / 2.0
Lfis[j] = min1
else:
if (cpt1 == 0) and (cpt2 != 0):
Ltot[j] = (min0 + max2) / 2.0
Lfis[j] = (min0 + max2) / 2.0
else:
Ltot[j] = (min0 + max1) / 2.0
Lfis[j] = (min1 + max2) / 2.0
Lcoh[j] = Ltot[j] - Lfis[j]
DETRUIRE(CONCEPT=_F(NOM=__VI[j]))
TABLE_OUT = CREA_TABLE(LISTE=(
_F(LISTE_R=__INST, PARA='INST'),
_F(LISTE_R=Lfis, PARA='LONG_FIS'),
_F(LISTE_R=Ltot, PARA='LONG_TOT'),
_F(LISTE_R=Lcoh, PARA='LONG_COH'),
), )
#
# calcul de la triaxialite dans les elements massifs voisins de l'interface cohesive
#
elif OPTION == "TRIAXIALITE":
self.DeclareOut('CARTE_OUT', self.sd)
CARTE_OUT = POST_VOISIN_CZM(RESULTAT=RESULTAT)
return ier
def raff_xfem_ops(self, FISSURE, TYPE, **args):
"""
Macro RAFF_XFEM
Calcule un indicateur permettant de caracteriser une zone qui sera raffinee.
L'indicateur est soit la distance (au fond de fissure pour les fissures,
a l'interface pour les interfaces), soit un indicateur binaire qui vaut
1 dans la zone d'interet
"""
import aster
import string
import copy
import math
from types import ListType, TupleType
from code_aster.Cata.Syntax import _F
from SD.sd_xfem import sd_fiss_xfem
EnumTypes = (ListType, TupleType)
macro = 'RAFF_XFEM'
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant
self.DeclareOut('chamout', self.sd)
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
FORMULE = self.get_cmd('FORMULE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
DETRUIRE = self.get_cmd('DETRUIRE')
from Contrib.raff_xfem_zone import RAFF_XFEM_ZONE
IMPR_CO = self.get_cmd('IMPR_CO')
assert (TYPE in ('DISTANCE', 'ZONE'))
# recuperation de la liste des fissures/interfaces
nbfiss = len(FISSURE)
# on recupere le concept maillage "associe a la sd"
nom_ma = get_nom_maillage_sdfiss(FISSURE[0])
MA = self.get_concept(nom_ma)
# on verifie que toutes les fissures/interfaces sont rattachees au meme
# maillage
for i in range(1, nbfiss):
nom_ma_i = get_nom_maillage_sdfiss(FISSURE[i])
if nom_ma_i != nom_ma:
UTMESS('F',
'XFEM2_10',
valk=(FISSURE[0].nom, nom_ma, FISSURE[i].nom, nom_ma_i))
# indicateur de type 'DISTANCE'
if TYPE == 'DISTANCE':
# formule distance pour une fissure: -r
__MDISTF = FORMULE(NOM_PARA=('X1', 'X2'), VALE='-1.*sqrt(X1**2+X2**2)')
# formule distance pour une interface: -r = -|lsn|
__MDISTI = FORMULE(NOM_PARA=('X1'), VALE='-1.*sqrt(X1**2)')
__CERR = [None] * nbfiss
list_err = []
list_nom_cmp = []
for_max = 'max('
for i in range(0, nbfiss):
fiss = FISSURE[i]
# recuperation du type de discontinuite :'FISSURE' ou 'INTERFACE'
# si FISSURE : l'erreur est la distance au fond de fissure
# si INTERFACE : l'erreur est la distance a l'interface
iret, ibid, typ_ds = aster.dismoi('TYPE_DISCONTINUITE', fiss.nom,
'FISS_XFEM', 'F')
typ_ds = typ_ds.rstrip()
# extraction des champs level sets
__CHLN = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
OPERATION='EXTR',
NOM_CHAM='LNNO',
FISSURE=fiss)
if typ_ds == 'FISSURE':
__CHLTB = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
OPERATION='EXTR',
NOM_CHAM='LTNO',
FISSURE=fiss)
# on renomme le composante X1 en X2
__CHLT = CREA_CHAMP(
TYPE_CHAM='NOEU_NEUT_R',
OPERATION='ASSE',
MAILLAGE=MA,
ASSE=_F(
TOUT='OUI',
CHAM_GD=__CHLTB,
NOM_CMP='X1',
NOM_CMP_RESU='X2',
),
)
DETRUIRE(CONCEPT=_F(NOM=__CHLTB), INFO=1)
# On affecte à chaque noeud du maillage MA la formule __MDISTF ou
# __MDISTI
if typ_ds == 'FISSURE':
__CHFOR = CREA_CHAMP(
TYPE_CHAM='NOEU_NEUT_F',
OPERATION='AFFE',
MAILLAGE=MA,
AFFE=_F(
TOUT='OUI',
NOM_CMP='X1',
VALE_F=__MDISTF,
),
)
elif typ_ds == 'INTERFACE':
__CHFOR = CREA_CHAMP(
TYPE_CHAM='NOEU_NEUT_F',
OPERATION='AFFE',
MAILLAGE=MA,
AFFE=_F(
TOUT='OUI',
NOM_CMP='X1',
VALE_F=__MDISTI,
),
)
# on evalue en tout noeud le champ de formules
if typ_ds == 'FISSURE':
__CERRB = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
OPERATION='EVAL',
CHAM_F=__CHFOR,
CHAM_PARA=(
__CHLN,
__CHLT,
))
DETRUIRE(CONCEPT=_F(NOM=__CHLT), INFO=1)
elif typ_ds == 'INTERFACE':
__CERRB = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
OPERATION='EVAL',
CHAM_F=__CHFOR,
CHAM_PARA=(__CHLN, ))
DETRUIRE(CONCEPT=_F(NOM=__CHLN), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__CHFOR), INFO=1)
# champ d'Erreur de la fissure i
__CERR[i] = CREA_CHAMP(
TYPE_CHAM='NOEU_NEUT_R',
OPERATION='ASSE',
MAILLAGE=MA,
ASSE=_F(
TOUT='OUI',
CHAM_GD=__CERRB,
NOM_CMP='X1',
NOM_CMP_RESU='X' + str(i + 1),
),
)
list_err.append(__CERR[i])
list_nom_cmp.append('X' + str(i + 1))
for_max = for_max + 'X' + str(i + 1) + ','
DETRUIRE(CONCEPT=_F(NOM=__CERRB), INFO=1)
# si nbfiss = 1, c'est directement X1
# si nbfiss > 1 : on prend le max des erreurs de chaque fissure
for_max = for_max + ')'
if nbfiss == 1:
__Erreur = FORMULE(NOM_PARA=(list_nom_cmp), VALE='X1')
else:
__Erreur = FORMULE(NOM_PARA=(list_nom_cmp), VALE=for_max)
# Définition de l'erreur en chaque noeud du maillage
__CHFORM = CREA_CHAMP(
TYPE_CHAM='NOEU_NEUT_F',
OPERATION='AFFE',
MAILLAGE=MA,
AFFE=_F(
TOUT='OUI',
NOM_CMP='X1',
VALE_F=__Erreur,
),
)
# champ de sortie
chamout = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
OPERATION='EVAL',
CHAM_F=__CHFORM,
CHAM_PARA=(list_err))
for i in range(0, nbfiss):
DETRUIRE(CONCEPT=_F(NOM=__CERR[i]), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__MDISTF), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__MDISTI), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__Erreur), INFO=1)
DETRUIRE(CONCEPT=_F(NOM=__CHFORM), INFO=1)
# indicateur de type 'ZONE'
elif TYPE == 'ZONE':
__CERR = [None] * nbfiss
list_asse = []
for i in range(0, nbfiss):
__CERR[i] = RAFF_XFEM_ZONE(FISSURE=FISSURE[i], RAYON=args['RAYON'])
list_asse.append({
'CHAM_GD': __CERR[i],
'COEF_R': 1.,
'CUMUL': 'OUI',
'TOUT': 'OUI'
})
# champ de sortie
chamout = CREA_CHAMP(TYPE_CHAM='CART_NEUT_R',
OPERATION='ASSE',
MAILLAGE=MA,
ASSE=list_asse)
return
def champ_detoile_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME,
Ctot0, Nl, Kt, a1, a2, a3, INFO, **args):
# macro pour calculer le chargement thermique specfique a la diffusion H2
import numpy as NP
import aster
from code_aster.Cata.Syntax import _F
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant dans le contexte de la macro
self.DeclareOut('NEUTG', self.sd)
# On importe les definitions des commandes a utiliser dans la macro
DETRUIRE = self.get_cmd('DETRUIRE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
# Recuperation du modele a partir du resultat
iret, ibid, __n_modele = aster.dismoi('MODELE', RESU_H2.nom, 'RESULTAT',
'F')
__n_modele = __n_modele.rstrip()
__MOTH = self.get_concept(__n_modele)
# Recuperation du maillage a partir du resultat
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', RESU_H2.nom, 'RESULTAT',
'F')
__MAIL = self.get_concept(nom_ma.strip())
# Recuperation du modele mecanique a partir du resultat
iret, ibid, nom_momec = aster.dismoi('MODELE', RESUMECA.nom, 'RESULTAT',
'F')
__MOME = self.get_concept(nom_momec.rstrip())
# extraction du champ de Cl instant -
__C20 = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_TEMP_R',
RESULTAT=RESU_H2,
NOM_CHAM='TEMP',
INST=TINIT,
INFO=INFO)
__EPEQN2 = CALC_CHAMP(INST=(TINIT, TFIN),
RESULTAT=RESUMECA,
VARI_INTERNE='VARI_NOEU')
__EPEQN = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=__EPEQN2,
MODELE_1=__MOME,
MODELE_2=__MOTH,
NOM_CHAM='VARI_NOEU',
TOUT_ORDRE='OUI')
__VINT1 = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_VAR2_R',
RESULTAT=__EPEQN,
NOM_CHAM='VARI_NOEU',
INST=TFIN,
INFO=INFO)
# recopie du champ C20 pour initialiser le futur champ source
__chtmp = CREA_CHAMP(OPERATION='AFFE',
TYPE_CHAM='NOEU_NEUT_R',
MAILLAGE=__MAIL,
AFFE=(_F(
VALE=0.,
GROUP_MA=GRMAVOL,
NOM_CMP='X1',
), ))
nomcham = __chtmp.sdj.nomj()
# on suppose que les noeuds du maillage thermique et mecaniqeu sont les
# memes (pour eviter un PROJ_CHAMP)
lc_t0 = __C20.EXTR_COMP('TEMP', [], 1)
c_t0 = lc_t0.valeurs
node_th = lc_t0.noeud
lp_t1 = __VINT1.EXTR_COMP('V1', [], 1)
p_t1 = lp_t1.valeurs
node_me = lp_t1.noeud
nbnode = len(node_th)
assert (nbnode == len(node_me))
detoile = NP.zeros(nbnode)
bidon = NP.zeros(nbnode)
for ino, node in enumerate(node_th):
Cl = c_t0[ino]
p1 = p_t1[ino]
detoile[ino] = DETOILE(Cl, p1, Ctot0, Nl, Kt, a1, a2, a3)
nomvect = '%-19s.VALE' % __chtmp.nom
aster.putvectjev(nomvect, nbnode, tuple(range(1, nbnode + 1)),
tuple(detoile), tuple(bidon), 1)
NEUTG = CREA_CHAMP(OPERATION='DISC',
TYPE_CHAM='ELNO_NEUT_R',
MODELE=__MOTH,
PROL_ZERO='OUI',
CHAM_GD=__chtmp,
INFO=INFO)
def post_bordet_ops(self, TOUT, GROUP_MA, INST, PRECISION, CRITERE, NUME_ORDRE,
PROBA_NUCL, RESULTAT, PARAM, TEMP, COEF_MULT, **args):
"""Corps de POST_BORDET"""
import numpy as NP
import aster
from code_aster.Cata.Syntax import _F
from code_aster.Cata.DataStructure import fonction_sdaster, nappe_sdaster
from Utilitai.Utmess import UTMESS
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# On importe les definitions des commandes a utiliser dans la macro
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CALC_CHAM_ELEM = self.get_cmd('CALC_CHAM_ELEM')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
CREA_TABLE = self.get_cmd('CREA_TABLE')
FORMULE = self.get_cmd('FORMULE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
#
# Definition du concept sortant dans le contexte de la macro
self.DeclareOut('tabout', self.sd)
#
# Recuperation du modele a partir du resultat
iret, ibid, n_modele = aster.dismoi('MODELE', RESULTAT.nom, 'RESULTAT',
'F')
n_modele = n_modele.rstrip()
if len(n_modele) == 0 or n_modele == "#PLUSIEURS":
UTMESS('F', 'RUPTURE1_58')
model = self.get_concept(n_modele)
# Dimension du modele
iret, ndim, rbid = aster.dismoi('DIM_GEOM', model.nom, 'MODELE', 'F')
if iret == 1 or ndim == 23:
UTMESS('F', 'RUPTURE1_57')
#
# Definition des formules pour le calcul de sigy plus tard
#
__MAXI = FORMULE(NOM_PARA=('T1'), VALE="""max(T1,0.)""")
#
# Calcul des grandeurs dont on a besoin : contrainte principale, def plastique et volume du pt de gauss
#
# Volume point de gauss
__VOL_PG = CALC_CHAM_ELEM(
MODELE=model,
TOUT='OUI',
OPTION='COOR_ELGA',
)
if GROUP_MA:
GROUP_MA = list(GROUP_MA)
vol = __VOL_PG.EXTR_COMP('W', GROUP_MA)
elif TOUT:
vol = __VOL_PG.EXTR_COMP('W', [])
# contrainte principale max et deformation plastique
__RESU = CALC_CHAMP(
RESULTAT=self['RESULTAT'],
CRITERES='SIEQ_ELGA',
DEFORMATION='EPSP_ELGA',
)
# Recuperation de la liste des instants et des ordres de calcul
list_ordre = __RESU.LIST_VARI_ACCES()['NUME_ORDRE']
list_inst = __RESU.LIST_VARI_ACCES()['INST']
#
# On va travailler en ordre ; si l'utilisateur entre un instant, on va le
# transformer en ordre
entree_instant = None
if INST:
if CRITERE == 'ABSOLU':
prec = PRECISION
elif CRITERE == 'RELATIF':
prec = PRECISION * INST
entree_instant = True
n = 0
trouv = None
while (n < len(list_inst) and not trouv):
if (list_inst[n] + prec >= INST) and (list_inst[n] - prec <= INST):
instant = list_inst[n]
trouv = True
n = n + 1
if not trouv:
UTMESS('F',
'RUPTURE1_53',
valr=INST,
valk='utilise pour le calcul de Bordet')
if entree_instant == True:
index_ordre = list_inst.index(instant)
nume_ordre = list_ordre[index_ordre]
elif NUME_ORDRE:
nume_ordre = NUME_ORDRE
if nume_ordre not in list_ordre:
UTMESS('F',
'RUPTURE0_51',
vali=int(nume_ordre),
valk='utilise pour le calcul de Bordet')
#
# Pour Bordet, il nous faut les champs a tous les instants jusqu'a
# l'instant considere
EP = [[None for j in range(6)] for i in range(nume_ordre + 1)
] # tenseur des deformations plastiques
EPEQ = [[None for j in range(0)] for i in range(nume_ordre + 1)
] # deformation plastique equivalente
EPEQM = [0.] * (nume_ordre + 1)
#deformation plastique equivalente a l'instant precedent
PRIN = [None] * (nume_ordre + 1)
EQ_BAR = [None] * (nume_ordre + 1)
EQ_PT = [None] * (nume_ordre + 1)
EQ_PT2 = [None] * (nume_ordre + 1)
PR_BAR = [None] * (nume_ordre + 1)
DEP = [None] * (nume_ordre + 1)
BORDTI = 0. # valeur sans l'exposant final, sommee sur les instants
BORDTT = [0.] * (nume_ordre + 1)
# valeur avec l'exposant, que l'on stocke dans la table a
# chaque instant
PROBA = [0.] * (nume_ordre + 1) # Probabilite de rupture par clivage
# LISTE DES PARAMETRES
sig0 = PARAM['SEUIL_REFE']
sigth = PARAM['SIG_CRIT']
sigref = PARAM['SIGM_REFE']
m = PARAM['M']
V0 = PARAM['VOLU_REFE']
if PROBA_NUCL == 'OUI':
ep0 = PARAM['DEF_PLAS_REFE']
elif PROBA_NUCL == 'NON':
ep0 = 0
c_mult = COEF_MULT
#
# On va constuire des champs a chaque instant
#
if list_ordre[0] == 0:
fin_ordre = nume_ordre + 1
elif list_ordre[0] != 0:
fin_ordre = nume_ordre
for ordre in range(list_ordre[0], fin_ordre):
#
# Temperature a extraire : soit une fonction du temps, soit un reel
#
if type(TEMP) == fonction_sdaster:
tempe = TEMP(list_inst[ordre])
elif type(TEMP) != fonction_sdaster:
tempe = TEMP
def fseuil(epsi):
return PARAM['SEUIL_CALC'](epsi, tempe)
self.update_const_context({'fseuil': fseuil})
__NPY = FORMULE(NOM_PARA=('EPSI'), VALE="""fseuil(EPSI)""")
#
# On met ces grandeurs dans des champs specifiques
#
__S_TOT = CREA_CHAMP(
TYPE_CHAM='ELGA_SIEF_R',
RESULTAT=__RESU,
OPERATION='EXTR',
NUME_ORDRE=ordre,
NOM_CHAM='SIEQ_ELGA',
)
__EPSP = CREA_CHAMP(
TYPE_CHAM='ELGA_EPSI_R',
RESULTAT=__RESU,
OPERATION='EXTR',
NUME_ORDRE=ordre,
NOM_CHAM='EPSP_ELGA',
)
# On recupere la valeur des champs au niveau des groupes qui nous
# interessent
if GROUP_MA:
PRIN[ordre] = __S_TOT.EXTR_COMP('PRIN_3', GROUP_MA, 0).valeurs
# Pour la deformation plastique, on construit de quoi calculer sa
# norme de VMises
EP[ordre][0] = __EPSP.EXTR_COMP('EPXX', GROUP_MA, 0).valeurs
EP[ordre][1] = __EPSP.EXTR_COMP('EPYY', GROUP_MA, 0).valeurs
EP[ordre][2] = __EPSP.EXTR_COMP('EPZZ', GROUP_MA, 0).valeurs
EP[ordre][3] = __EPSP.EXTR_COMP('EPXY', GROUP_MA, 0).valeurs
if ndim == 3:
EP[ordre][4] = EPSP[ordre].EXTR_COMP('EPXZ', GROUP_MA,
0).valeurs
EP[ordre][5] = EPSP[ordre].EXTR_COMP('EPYZ', GROUP_MA,
0).valeurs
elif TOUT:
PRIN[ordre] = __S_TOT.EXTR_COMP('PRIN_3', [], 0).valeurs
EP[ordre][0] = __EPSP.EXTR_COMP('EPXX', [], 0).valeurs
EP[ordre][1] = __EPSP.EXTR_COMP('EPYY', [], 0).valeurs
EP[ordre][2] = __EPSP.EXTR_COMP('EPZZ', [], 0).valeurs
EP[ordre][3] = __EPSP.EXTR_COMP('EPXY', [], 0).valeurs
if ndim == 3:
EP[ordre][4] = __EPSP.EXTR_COMP('EPXZ', [], 0).valeurs
EP[ordre][5] = __EPSP.EXTR_COMP('EPYZ', [], 0).valeurs
nval = len(PRIN[ordre])
nval2 = len(EP[ordre][0])
if nval2 != nval:
UTMESS('F', 'RUPTURE1_54')
if ndim == 3:
EPEQ[ordre] = NP.sqrt(
2. / 3. * (EP[ordre][0]**2 + EP[ordre][1]**2 +
EP[ordre][2]**2 + 2. * EP[ordre][3]**2 +
2. * EP[ordre][4]**2 + 2. * EP[ordre][5]**2))
elif ndim == 2:
EPEQ[ordre] = NP.sqrt(2. / 3. *
(EP[ordre][0]**2 + EP[ordre][1]**2 +
EP[ordre][2]**2 + 2. * EP[ordre][3]**2))
# Construction des champs barre et des champs de vitesse
EQ_PT2[list_ordre[0]] = NP.zeros([nval])
EPEQ[ordre] = NP.array(EPEQ[ordre])
if ordre != list_ordre[0]:
dt = list_inst[ordre] - list_inst[ordre - 1]
if dt == 0:
UTMESS('F', 'RUPTURE1_55')
EPEQM[ordre] = EPEQ[ordre - 1]
EQ_BAR[ordre] = (EPEQ[ordre] + EPEQ[ordre - 1]) / 2.
EQ_PT2[ordre] = (EPEQ[ordre] - EPEQ[ordre - 1]) / (2 * dt)
EQ_PT[ordre] = EQ_PT2[ordre - 1] + EQ_PT2[ordre]
DEP[ordre] = EPEQ[ordre] - EPEQ[ordre - 1]
PR_BAR[ordre] = (PRIN[ordre] + PRIN[ordre - 1]) / 2.
if type(PARAM['SEUIL_CALC']) == fonction_sdaster:
sigy = PARAM['SEUIL_CALC'](tempe)
elif type(PARAM['SEUIL_CALC']) == nappe_sdaster:
EQ_PT[ordre] = list(EQ_PT[ordre])
__TAB = CREA_TABLE(LISTE=(_F(
PARA='EPSI',
LISTE_R=EQ_PT[ordre],
), ), )
__TAB = CALC_TABLE(
TABLE=__TAB,
reuse=__TAB,
ACTION=_F(OPERATION='OPER',
FORMULE=__NPY,
NOM_PARA='TSIGY'),
)
sigy = __TAB.EXTR_TABLE().values()['TSIGY']
sigy = NP.array(sigy)
T1 = sigy / sig0 * (PR_BAR[ordre]**m - sigth**m)
T1 = list(T1)
__TABT1 = CREA_TABLE(LISTE=(_F(
PARA='T1',
LISTE_R=T1,
), ))
__TABT1 = CALC_TABLE(
TABLE=__TABT1,
reuse=__TABT1,
ACTION=_F(OPERATION='OPER', FORMULE=__MAXI, NOM_PARA='T1BIS'),
)
T1 = __TABT1.EXTR_TABLE().values()['T1BIS']
T1 = NP.array(T1)
if PROBA_NUCL == 'OUI':
T2 = NP.exp(-sigy / sig0 * EQ_BAR[ordre] / ep0)
elif PROBA_NUCL == 'NON':
T2 = 1.
T3 = DEP[ordre]
T4 = vol.valeurs / V0
BORDTI = BORDTI + NP.cumsum(T1 * T2 * T3 * T4)[-1]
BORDTT[ordre] = (c_mult * BORDTI)**(1 / m)
if sigref(tempe) != 0.:
PROBA[ordre] = 1 - NP.exp(-(BORDTT[ordre] / sigref(tempe))**m)
elif sigref(tempe) == 0.:
UTMESS('F', 'RUPTURE1_56', valr=list_inst[ordre])
tabout = CREA_TABLE(LISTE=(
_F(PARA='INST', LISTE_R=list_inst[0:nume_ordre + 1]),
_F(
PARA='SIG_BORDET',
LISTE_R=BORDTT,
),
_F(
PARA='PROBA_BORDET',
LISTE_R=PROBA,
),
), )
return ier
def char_grad_impo_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME,
Ctot0, CHARGRD0, Vh, R, T, INFO, **args):
# macro pour calculer le chargement thermique specfique a la diffusion H2
import numpy as NP
import aster
from code_aster.Cata.Syntax import _F
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant dans le contexte de la macro
self.DeclareOut('chth', self.sd)
# On importe les definitions des commandes a utiliser dans la macro
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
AFFE_CHAR_THER = self.get_cmd('AFFE_CHAR_THER')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
CALC_CHAM_ELEM = self.get_cmd('CALC_CHAM_ELEM')
dt = TFIN - TINIT
# Recuperation du modele a partir du resultat
iret, ibid, __n_modele = aster.dismoi('MODELE', RESU_H2.nom, 'RESULTAT',
'F')
__n_modele = __n_modele.rstrip()
__MOTH = self.get_concept(__n_modele)
# Recuperation du maillage a partir du resultat
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', RESU_H2.nom, 'RESULTAT',
'F')
__MAIL = self.get_concept(nom_ma.strip())
# Recuperation du modele mecanique a partir du resultat
iret, ibid, nom_momec = aster.dismoi('MODELE', RESUMECA.nom, 'RESULTAT',
'F')
__MOME = self.get_concept(nom_momec.rstrip())
# extraction du champ de cl instant -
__C20 = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_TEMP_R',
RESULTAT=RESU_H2,
NOM_CHAM='TEMP',
INST=TINIT,
INFO=INFO)
# on suppose que les noeuds du maillage thermique et mecaniqeu sont les
# memes (pour eviter un PROJ_CHAMP)
lc_t0 = __C20.EXTR_COMP('TEMP', [], 1)
c_t0 = lc_t0.valeurs
node_th = lc_t0.noeud
nbnode = len(node_th)
# contruction du terme Grad SigmaH
# trace de sigma aux noeuds
__SIEQN2 = CALC_CHAMP(INST=TFIN,
RESULTAT=RESUMECA,
CRITERES='SIEQ_NOEU',
INFO=INFO)
__SIEQN = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=__SIEQN2,
MODELE_1=__MOME,
MODELE_2=__MOTH,
NOM_CHAM='SIEQ_NOEU',
TOUT_ORDRE='OUI')
__SIEQ = CREA_CHAMP(OPERATION='EXTR',
TYPE_CHAM='NOEU_SIEF_R',
RESULTAT=__SIEQN,
NOM_CHAM='SIEQ_NOEU',
INST=TFIN,
INFO=INFO)
# on renome la CMP pour pouvoir calculer le flux "thermique"
__TRSIG = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='NOEU_TEMP_R',
MODELE=__MOTH,
ASSE=(_F(CHAM_GD=__SIEQ,
GROUP_MA=GRMAVOL,
NOM_CMP='TRSIG',
NOM_CMP_RESU='TEMP',
COEF_R=1. / 3.), ),
INFO=INFO)
# calcul du gradient de Trace(Sigma)
__MAT1 = DEFI_MATERIAU(THER=_F(LAMBDA=-1., RHO_CP=0.))
__CMT1 = AFFE_MATERIAU(
MAILLAGE=__MAIL,
AFFE=_F(
TOUT='OUI',
MATER=__MAT1,
),
)
__GRSH = CALC_CHAM_ELEM(MODELE=__MOTH,
CHAM_MATER=__CMT1,
GROUP_MA=GRMAVOL,
OPTION='FLUX_ELGA',
TEMP=__TRSIG)
gradsighe = __GRSH.EXTR_COMP('FLUX', [], 1)
gradsighx = gradsighe.valeurs
gradsighy = __GRSH.EXTR_COMP('FLUY', [], 0).valeurs
if (DIME == 3):
gradsighz = __GRSH.EXTR_COMP('FLUZ', [], 0).valeurs
fx = NP.zeros(nbnode)
fy = NP.zeros(nbnode)
if (DIME == 3):
fz = NP.zeros(nbnode)
for ino, node in enumerate(node_th):
cl = c_t0[ino]
grsigx = gradsighx[ino]
grsigy = gradsighy[ino]
if (DIME == 3):
grsigz = gradsighz[ino]
fx[ino], fx[ino], fz[ino] = FLUX(cl, grsigx, grsigy, DIME, grsigz,
Vh, R, T)
else:
grsigz = 0.
fx[ino], fx[ino] = FLUX(cl, grsigx, grsigy, DIME, grsigz, Vh, R, T)
# pour gagner du temps on evite la construction du mot-cle PRE_GRAD_TEMP
nomvale = CHARGRD0.nom.ljust(8) + '.CHTH.GRAIN.VALE'
nomlima = CHARGRD0.nom.ljust(8) + '.CHTH.GRAIN.LIMA'
nomdesc = CHARGRD0.nom.ljust(8) + '.CHTH.GRAIN.DESC'
tabvale = aster.getvectjev(nomvale)
tabdesc = aster.getvectjev(nomdesc)
dicolima = aster.getcolljev(nomlima)
nbrvale = len(tabvale)
champ = NP.zeros(nbrvale)
bidon = NP.zeros(nbrvale)
nommai = __MAIL.sdj.NOMMAI.get()
connex = __MAIL.sdj.CONNEX.get()
groupma = __MAIL.sdj.GROUPEMA.get()[GRMAVOL.ljust(24)]
nbzone = tabdesc[1]
# print "tabdesc",tabdesc
# print "tablima",dicolima
for izone in dicolima.keys():
# chaque maille du groupe est affectee
for index, ima in enumerate(dicolima[izone]):
if ima == 0:
break
if ima in groupma:
# ATTENTION : dans Python, les tableaux commencent a 0
# mais dans la connectivite, les noeuds commencent a 1!
lnoeu = NP.array(connex[ima]) - 1
nbno = len(lnoeu)
# calcul de la moyenne par maille de fx
lflux = fx[lnoeu]
flux = NP.add.reduce(lflux)
flux = flux / nbno
lfluy = fy[lnoeu]
fluy = NP.add.reduce(lfluy)
fluy = fluy / nbno
numa = index
# print 'essai, numa, ima',numa, ima, groupma, lnoeu, nbno
champ[9 * (numa - 1) + 1] = -flux
champ[9 * (numa - 1) + 2] = -fluy
aster.putvectjev(nomvale, nbrvale, tuple(range(1, nbrvale + 1)),
tuple(champ), tuple(bidon), 1)
def macro_elas_mult_ops(self,
MODELE,
CAS_CHARGE,
CHAM_MATER=None,
CARA_ELEM=None,
NUME_DDL=None,
CHAR_MECA_GLOBAL=None,
LIAISON_DISCRET=None,
SOLVEUR=None,
**args):
"""
Ecriture de la macro MACRO_ELAS_MULT
"""
args = _F(args)
if args['reuse'] is not None:
changed = args.get('RESULTAT')
if changed is None:
UTMESS('F', 'SUPERVIS2_79', valk='RESULTAT')
ielas = 0
ifour = 0
for m in CAS_CHARGE:
if m['NOM_CAS']:
ielas = 1 # mot clé NOM_CAS présent sous CAS_CHARGE
tyresu = 'MULT_ELAS'
else:
ifour = 1 # mot clé MODE_FOURIER présent sous CAS_CHARGE
tyresu = 'FOURIER_ELAS'
if ielas == 1 and ifour == 1:
UTMESS('F', 'ELASMULT0_1')
if NUME_DDL in self.sdprods or NUME_DDL is None:
# Si le concept NUME_DDL est dans self.sdprods ou n est pas nommé
# il doit etre produit par la macro
# il faudra donc appeler la commande NUME_DDL
lnume = 1
else:
lnume = 0
if ielas == 1:
motscles = {}
if CHAR_MECA_GLOBAL:
motscles['CHARGE'] = CHAR_MECA_GLOBAL
if CHAM_MATER:
motscles['CHAM_MATER'] = CHAM_MATER
if CARA_ELEM:
motscles['CARA_ELEM'] = CARA_ELEM
__nomrig = CALC_MATR_ELEM(OPTION='RIGI_MECA',
MODELE=MODELE,
**motscles)
if lnume:
# On peut passer des mots cles egaux a None. Ils sont ignores
motscles = {}
if NUME_DDL is not None:
num = NUME_DDL_CMD(MATR_RIGI=__nomrig, **motscles)
self.register_result(num, NUME_DDL)
else:
_num = NUME_DDL_CMD(MATR_RIGI=__nomrig, **motscles)
num = _num
else:
num = NUME_DDL
__nomras = ASSE_MATRICE(MATR_ELEM=__nomrig, NUME_DDL=num)
if (SOLVEUR['METHODE'] == "MUMPS"):
__nomras = FACTORISER(
reuse=__nomras,
MATR_ASSE=__nomras,
NPREC=SOLVEUR['NPREC'],
STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'],
METHODE="MUMPS",
PCENT_PIVOT=SOLVEUR['PCENT_PIVOT'],
RENUM=SOLVEUR['RENUM'],
TYPE_RESOL=SOLVEUR['TYPE_RESOL'],
PRETRAITEMENTS=SOLVEUR['PRETRAITEMENTS'],
ELIM_LAGR=SOLVEUR['ELIM_LAGR'],
GESTION_MEMOIRE=SOLVEUR['GESTION_MEMOIRE'],
ACCELERATION=SOLVEUR['ACCELERATION'],
LOW_RANK_SEUIL=SOLVEUR['LOW_RANK_SEUIL'],
)
else:
__nomras = FACTORISER(
reuse=__nomras,
MATR_ASSE=__nomras,
NPREC=SOLVEUR['NPREC'],
STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'],
METHODE=SOLVEUR['METHODE'],
RENUM=SOLVEUR['RENUM'],
)
#
# boucle sur les items de CAS_CHARGE
nomchn = []
lcharg = []
iocc = 0
for m in CAS_CHARGE:
iocc = iocc + 1
# calcul de lcharg : liste des listes de char_meca (mots clé CHAR_MECA
# et CHAR_MECA_GLOBAL)
xx1 = m['CHAR_MECA']
if type(xx1) not in (tuple, list):
xx1 = (xx1, )
xx2 = CHAR_MECA_GLOBAL
if type(xx2) not in (tuple, list):
xx2 = (xx2, )
lchar1 = []
for chargt in (tuple(xx1) + tuple(xx2)):
if chargt:
lchar1.append(chargt)
lcharg.append(lchar1)
assert len(lchar1) > 0
if ifour:
motscles = {}
if CHAR_MECA_GLOBAL:
motscles['CHARGE'] = CHAR_MECA_GLOBAL
if CHAM_MATER:
motscles['CHAM_MATER'] = CHAM_MATER
if CARA_ELEM:
motscles['CARA_ELEM'] = CARA_ELEM
motscles['MODE_FOURIER'] = m['MODE_FOURIER']
__nomrig = CALC_MATR_ELEM(OPTION='RIGI_MECA',
MODELE=MODELE,
**motscles)
if lnume:
_num = NUME_DDL_CMD(MATR_RIGI=__nomrig, )
num = _num
lnume = 0
__nomras = ASSE_MATRICE(MATR_ELEM=__nomrig, NUME_DDL=num)
if (SOLVEUR['METHODE'] == "MUMPS"):
__nomras = FACTORISER(
reuse=__nomras,
MATR_ASSE=__nomras,
NPREC=SOLVEUR['NPREC'],
STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'],
METHODE="MUMPS",
PCENT_PIVOT=SOLVEUR['PCENT_PIVOT'],
RENUM=SOLVEUR['RENUM'],
TYPE_RESOL=SOLVEUR['TYPE_RESOL'],
PRETRAITEMENTS=SOLVEUR['PRETRAITEMENTS'],
ELIM_LAGR=SOLVEUR['ELIM_LAGR'],
GESTION_MEMOIRE=SOLVEUR['GESTION_MEMOIRE'],
ACCELERATION=SOLVEUR['ACCELERATION'],
LOW_RANK_SEUIL=SOLVEUR['LOW_RANK_SEUIL'],
)
else:
__nomras = FACTORISER(
reuse=__nomras,
MATR_ASSE=__nomras,
NPREC=SOLVEUR['NPREC'],
STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'],
METHODE=SOLVEUR['METHODE'],
RENUM=SOLVEUR['RENUM'],
)
if m['VECT_ASSE'] is None:
motscles = {}
l_calc_varc = False
if CHAM_MATER:
motscles['CHAM_MATER'] = CHAM_MATER
iret, ibid, answer = aster.dismoi('EXI_VARC',
CHAM_MATER.getName(),
'CHAM_MATER', 'F')
if answer == 'OUI':
l_calc_varc = True
if CARA_ELEM:
motscles['CARA_ELEM'] = CARA_ELEM
if ifour:
motscles['MODE_FOURIER'] = m['MODE_FOURIER']
if len(lchar1) > 0:
motscles['CHARGE'] = lchar1
__nomvel = CALC_VECT_ELEM(OPTION='CHAR_MECA', **motscles)
# chargement du aux variables de commandes
if l_calc_varc:
motscles = {}
if CARA_ELEM:
motscles['CARA_ELEM'] = CARA_ELEM
if ifour:
motscles['MODE_FOURIER'] = m['MODE_FOURIER']
__list1 = DEFI_LIST_REEL(
DEBUT=0.0,
INTERVALLE=_F(
JUSQU_A=1.0,
NOMBRE=1,
),
)
if CHAR_MECA_GLOBAL:
excit = []
for ch in CHAR_MECA_GLOBAL:
excit.append({'CHARGE': ch})
__cont1 = CALCUL(OPTION=('FORC_VARC_ELEM_P'),
MODELE=MODELE,
CHAM_MATER=CHAM_MATER,
INCREMENT=_F(LIST_INST=__list1,
NUME_ORDRE=1),
EXCIT=excit,
COMPORTEMENT=_F(RELATION='ELAS', ),
**motscles)
else:
__cont1 = CALCUL(OPTION=('FORC_VARC_ELEM_P'),
MODELE=MODELE,
CHAM_MATER=CHAM_MATER,
INCREMENT=_F(LIST_INST=__list1,
NUME_ORDRE=1),
COMPORTEMENT=_F(RELATION='ELAS', ),
**motscles)
__vvarcp = EXTR_TABLE(
TYPE_RESU='VECT_ELEM_DEPL_R',
TABLE=__cont1,
NOM_PARA='NOM_SD',
FILTRE=_F(NOM_PARA='NOM_OBJET', VALE_K='FORC_VARC_ELEM_P'),
)
__nomasv = ASSE_VECTEUR(VECT_ELEM=(__nomvel, __vvarcp),
NUME_DDL=num)
else:
__nomasv = ASSE_VECTEUR(VECT_ELEM=(__nomvel, ), NUME_DDL=num)
else:
__nomasv = m['VECT_ASSE']
if (SOLVEUR['METHODE'] == "MUMPS"):
__nomchn = RESOUDRE(MATR=__nomras,
CHAM_NO=__nomasv,
TITRE=m['SOUS_TITRE'],
RESI_RELA=SOLVEUR['RESI_RELA'],
POSTTRAITEMENTS=SOLVEUR['POSTTRAITEMENTS'])
else:
__nomchn = RESOUDRE(MATR=__nomras,
CHAM_NO=__nomasv,
TITRE=m['SOUS_TITRE'])
nomchn.append(__nomchn)
# fin de la boucle sur les items de CAS_CHARGE
#
motscles = {}
iocc = 0
motscle2 = {}
if CHAM_MATER:
motscle2['CHAM_MATER'] = CHAM_MATER
if CARA_ELEM:
motscle2['CARA_ELEM'] = CARA_ELEM
if ielas:
motscles['AFFE'] = []
for m in CAS_CHARGE:
if len(lcharg[iocc]) > 0:
motscles['AFFE'].append(
_F(MODELE=MODELE,
CHAM_GD=nomchn[iocc],
NOM_CAS=m['NOM_CAS'],
CHARGE=lcharg[iocc],
**motscle2))
else:
motscles['AFFE'].append(
_F(MODELE=MODELE,
CHAM_GD=nomchn[iocc],
NOM_CAS=m['NOM_CAS'],
**motscle2))
iocc = iocc + 1
else:
motscles['AFFE'] = []
for m in CAS_CHARGE:
if len(lcharg[iocc]) > 0:
motscles['AFFE'].append(
_F(MODELE=MODELE,
CHAM_GD=nomchn[iocc],
NUME_MODE=m['MODE_FOURIER'],
TYPE_MODE=m['TYPE_MODE'],
CHARGE=lcharg[iocc],
**motscle2))
else:
motscles['AFFE'].append(
_F(MODELE=MODELE,
CHAM_GD=nomchn[iocc],
NUME_MODE=m['MODE_FOURIER'],
TYPE_MODE=m['TYPE_MODE'],
**motscle2))
iocc = iocc + 1
if args.get("reuse"):
motscles['reuse'] = args.get("reuse")
motscles['RESULTAT'] = args.get("reuse")
nomres = CREA_RESU(OPERATION='AFFE',
TYPE_RESU=tyresu,
NOM_CHAM='DEPL',
**motscles)
#
# boucle sur les items de CAS_CHARGE pour SIEF_ELGA
iocc = 0
for m in CAS_CHARGE:
iocc = iocc + 1
if m['OPTION'] == 'SIEF_ELGA':
motscles = {}
if ielas:
motscles['NOM_CAS'] = m['NOM_CAS']
else:
motscles['NUME_MODE'] = m['MODE_FOURIER']
CALC_CHAMP(reuse=nomres,
RESULTAT=nomres,
CONTRAINTE='SIEF_ELGA',
**motscles)
# fin de la boucle sur les items de CAS_CHARGE
#
return nomres
def post_decollement_ops(self, RESULTAT, NOM_CHAM, NOM_CMP, GROUP_MA, INFO, **args):
"""
Corps de la macro POST_DECOLLEMENT
"""
ier = 0
import aster
import os
import string
import types
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
# On importe les definitions des commandes a utiliser dans la macro
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
POST_ELEM = self.get_cmd('POST_ELEM')
CREA_TABLE = self.get_cmd('CREA_TABLE')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
DEFI_GROUP = self.get_cmd('DEFI_GROUP')
DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU')
CREA_RESU = self.get_cmd('CREA_RESU')
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
# Comptage commandes + déclaration concept sortant
self.set_icmd(1)
self.DeclareOut('C_out', self.sd)
# on recupere le concept maillage
iret, ibid, nom_mo = aster.dismoi('MODELE', RESULTAT.nom, 'RESULTAT', 'F')
if nom_mo == '#AUCUN' :
iret, ibid, numddl = aster.dismoi('NUME_DDL', RESULTAT.nom, 'RESU_DYNA', 'F')
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', numddl, 'NUME_DDL', 'F')
else :
iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', nom_mo.strip(), 'MODELE', 'F')
MAILLAGE = self.get_concept(nom_ma.strip())
# Creation du groupe de noeuds 'PDECOL'
DEFI_GROUP(reuse=MAILLAGE, MAILLAGE=MAILLAGE,
DETR_GROUP_NO=_F(NOM='PDECOL',),
CREA_GROUP_NO=_F(GROUP_MA=GROUP_MA, NOM='PDECOL'),
ALARME='NON',)
# le modele 3D ne va contenir que des mailles de peau : on masque les
# alarmes
MasquerAlarme('CALCULEL2_63')
MasquerAlarme('CALCULEL2_64')
# model restreint au GROUP_MA
__model = AFFE_MODELE(MAILLAGE=MAILLAGE,
AFFE=_F(GROUP_MA=GROUP_MA, PHENOMENE='MECANIQUE',
MODELISATION='3D'),)
# le modele 3D ne va contenir que des mailles de peau : on retablit les
# alarmes
RetablirAlarme('CALCULEL2_63')
RetablirAlarme('CALCULEL2_64')
# Calcul de la surface du GROUP_MA : __surf
__unit = CREA_CHAMP(
OPERATION='AFFE', TYPE_CHAM='NOEU_NEUT_R', MODELE=__model,
AFFE=_F(GROUP_NO='PDECOL', NOM_CMP='X1', VALE=1.0),)
__chpg0 = CREA_CHAMP(
PROL_ZERO='OUI', MODELE=__model, OPERATION='DISC', TYPE_CHAM='ELGA_NEUT_R',
CHAM_GD=__unit)
__mater0 = DEFI_MATERIAU(ELAS=_F(E=210000000.0, NU=0.3),)
__chmat0 = AFFE_MATERIAU(
MODELE=__model, MAILLAGE=MAILLAGE, AFFE=_F(TOUT='OUI', MATER=__mater0),)
__resu0 = CREA_RESU(
OPERATION='AFFE', TYPE_RESU='EVOL_ELAS', NOM_CHAM='VARI_ELGA',
AFFE=_F(CHAM_MATER=__chmat0, MODELE=__model, CHAM_GD=__chpg0, INST=0.0),)
__tbSurf0 = POST_ELEM(RESULTAT=__resu0, INST=0.0, MODELE=__model,
INTEGRALE=_F(NOM_CHAM='VARI_ELGA', NOM_CMP='X1', GROUP_MA=GROUP_MA, TYPE_MAILLE='2D'),)
__surf = __tbSurf0.EXTR_TABLE().values()['INTE_X1'][0]
__linst = RESULTAT.LIST_VARI_ACCES()['INST']
# Calcul de la surface des noeuds décollés
__pct = []
for inst in __linst:
__dep = CREA_CHAMP(
OPERATION='EXTR', RESULTAT=RESULTAT, TYPE_CHAM='NOEU_' + NOM_CHAM[:4] + '_R',
INST=inst, NOM_CHAM=NOM_CHAM)
__tb1 = POST_RELEVE_T(
ACTION=_F(
OPERATION='EXTRACTION', GROUP_NO='PDECOL', INTITULE=GROUP_MA,
CHAM_GD=__dep, NOM_CMP=NOM_CMP),)
__col = fctZeroUn(__tb1.EXTR_TABLE().values()[NOM_CMP])
__tb2 = CREA_TABLE(
LISTE=(
_F(LISTE_K=__tb1.EXTR_TABLE().values()['NOEUD'], PARA='NOEUD'),
_F(LISTE_R=__col, PARA='X1'),),)
__ch = CREA_CHAMP(
OPERATION='EXTR', TYPE_CHAM='NOEU_NEUT_R', TABLE=__tb2, MAILLAGE=MAILLAGE)
__chg = CREA_CHAMP(
MODELE=__model, OPERATION='DISC', TYPE_CHAM='ELGA_NEUT_R',
PROL_ZERO='OUI', CHAM_GD=__ch)
__resu = CREA_RESU(
OPERATION='AFFE', TYPE_RESU='EVOL_ELAS', NOM_CHAM='VARI_ELGA',
AFFE=_F(CHAM_MATER=__chmat0, MODELE=__model, CHAM_GD=__chg, INST=0.0),)
__tb3 = POST_ELEM(RESULTAT=__resu, INST=0.0, MODELE=__model,
INTEGRALE=_F(NOM_CHAM='VARI_ELGA', NOM_CMP='X1', GROUP_MA=GROUP_MA, TYPE_MAILLE='2D'),)
__su2 = __tb3.EXTR_TABLE().values()['INTE_X1'][0]
__pct.append(100.0 * __su2 / __surf)
C_out = CREA_TABLE(LISTE=(_F(LISTE_R=__linst, PARA='INST'),
_F(LISTE_R=__pct, PARA='%DECOL'),),)
if INFO > 1:
IMPR_TABLE(UNITE=6,
TABLE=C_out)
return ier
