def nume_ddl_phy(resu):
"""Fabrication d'une numerotation des DDL actifs associes a une sd resultat
retourne ['N1_DX','N1_DY','N1_DZ','N2_DZ','N3_DZ'...] dans l'ordre alpha-numerique"""
from code_aster.Cata.Commands import CREA_CHAMP, DETRUIRE
__CHAMP0 = CREA_CHAMP(RESULTAT=resu.obj,
OPERATION='EXTR',
NUME_ORDRE=1,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='DEPL')
champy0 = __CHAMP0.EXTR_COMP(topo=1)
num_no = champy0.noeud
comp = champy0.comp
nb_ddl = len(comp)
# Recherche des noms des noeuds associes a leur numero
maya = resu.maya
nume = []
for ind in range(nb_ddl):
nom_no = maya.sdj.NOMNOE.get()[num_no[ind] - 1]
nume.append(nom_no.strip() + '_' + comp[ind].strip())
DETRUIRE(
CONCEPT=_F(NOM=(__CHAMP0, ), ),
INFO=1,
)
return nume
def temps_CPU(restant_old, temps_iter_old):
"""
Fonction controlant le temps restant
"""
__cpu = INFO_EXEC_ASTER(LISTE_INFO=("TEMPS_RESTANT",))
TEMPS = __cpu['TEMPS_RESTANT', 1]
DETRUIRE(CONCEPT=_F(NOM=__cpu), INFO=1)
err = 0
# Indique une execution interactive
if (TEMPS > 1.E+9):
return 0., 0., 0
# Indique une execution en batch
else:
restant = TEMPS
# Initialisation
if (restant_old == 0.):
temps_iter = -1.
else:
# Première mesure
if (temps_iter_old == -1.):
temps_iter = (restant_old - restant)
# Mesure courante
else:
temps_iter = (temps_iter_old + (restant_old - restant)) / 2.
if ((temps_iter > 0.96 * restant)or(restant < 0.)):
err = 1
msg = MessageLog.GetText('F', 'RECAL0_53')
raise CPU_Exception, msg
return restant, temps_iter, err
def LIRE_GMSH(self,
UNITE_GMSH=19,
UNITE_MAILLAGE=20,
MODI_QUAD='NON',
CREA_GROUP_NO='OUI'):
"""
Lecture du maillage (format Aster) a partir de sa definition
(format sup_gmsh)
UNITE_GMSH = Numero d'unite logique pour le fichier msh
UNITE_MAILLAGE = Numero d'unite logique pour le fichier mail
MODI_QUAD = 'OUI' si line->quad, 'NON' sinon
CREA_GROUP_NO = 'OUI' si on cree les group_no, 'NON' sinon
"""
nom_gmsh = 'fort.' + repr(UNITE_GMSH)
self.Create(nom_gmsh)
PRE_GMSH(UNITE_GMSH=UNITE_GMSH, UNITE_MAILLAGE=UNITE_MAILLAGE)
_SMESH00 = LIRE_MAILLAGE(FORMAT='ASTER', UNITE=UNITE_MAILLAGE)
DEFI_FICHIER(ACTION='LIBERER', UNITE=UNITE_GMSH)
DEFI_FICHIER(ACTION='LIBERER', UNITE=UNITE_MAILLAGE)
if MODI_QUAD == 'OUI' and self.order == 2:
raise Exception('The finite elements are already of second order')
if MODI_QUAD == 'OUI' and self.order <> 2:
_SMESH01 = CREA_MAILLAGE(MAILLAGE=_SMESH00,
LINE_QUAD=_F(TOUT='OUI'))
DETRUIRE(CONCEPT=_F(NOM=_SMESH00), INFO=1)
_SMESH00 = _SMESH01
_SMESH00 = self.Name(_SMESH00, CREA_GROUP_NO)
return _SMESH00
def compute_mecmode(NOM_CMP, GROUP_NO_INTER, resultat, nbmods, nbmodd):
dict_modes = {}
dict_modes['NUME_MODE'] = range(nbmods)
dict_modes['MCMP'] = []
dict_modes['som'] = []
dict_modes['maxm'] = []
for mods in range(nbmods):
nmo = nbmodd + mods + 1
__CHAM = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
NUME_ORDRE=nmo,
RESULTAT=resultat,
NOM_CHAM='DEPL')
MCMP = __CHAM.EXTR_COMP(NOM_CMP, [GROUP_NO_INTER]).valeurs
#on recupere la composante COMP (dx,dy,dz) des modes
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)
dict_modes['NCMP2'] = NCMP2
dict_modes['nddi'] = nddi
PHI = NP.zeros((nddi, nbmods))
PHI[:, mods] = MCMP2
som = NP.sum(MCMP)
max1 = NP.max(MCMP)
min1 = NP.min(MCMP)
maxm = NP.max([abs(max1), abs(min1)])
dict_modes['som'].append(som)
dict_modes['maxm'].append(maxm)
dict_modes['MCMP'].append(MCMP)
DETRUIRE(CONCEPT=_F(NOM=(__CHAM)), INFO=1)
dict_modes['PHI'] = PHI
return dict_modes
def get_unite_libre():
"""
Retoune une unité de fichier libre.
"""
from code_aster.Cata.Commands import DETRUIRE, INFO_EXEC_ASTER
_UL = INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE')
unite = _UL['UNITE_LIBRE', 1]
DETRUIRE(CONCEPT=(_F(NOM=_UL), ), INFO=1)
return unite
def del_weakref(self):
from code_aster.Cata.Commands import DETRUIRE
liste = ""
if len(self.weakref) != 0:
for obj in self.weakref:
DETRUIRE(CONCEPT=_F(NOM=obj), INFO=1)
liste = liste + ", " + obj.nom
self.weakref = []
self.mess.disp_mess("Destruction des objects temporaires " + liste)
def detr_concepts(self):
"""
Fonction qui detruit les concepts créés
"""
liste_concepts = mes_concepts(base=self.parent)
for e in liste_concepts:
nom = string.strip(e)
DETRUIRE(OBJET=self.g_context['_F'](CHAINE=nom), INFO=1)
if self.jdc.g_context.has_key(nom):
del self.jdc.g_context[nom]
del(liste_concepts)
def extr_temps(self):
"""Extraction des instants d'etude dans la Tempo qui contient
les temporels mesures"""
from code_aster.Cata.Commands import RECU_FONCTION
from code_aster.Cata.Commands import DETRUIRE
tabl_py = self.obj.EXTR_TABLE()
toto = tabl_py['FONCTION']
nom_fonc = toto.values()['FONCTION'][0]
__FONC = RECU_FONCTION(TABLE=self.obj,
NOM_PARA_TABL='FONCTION',
FILTRE=_F(NOM_PARA='FONCTION', VALE_K=nom_fonc))
temps = __FONC.Absc()
DETRUIRE(CONCEPT=_F(NOM=__FONC), INFO=1)
self.t = temps
self.tempo = 1
def Name(self, MA, CREA_GROUP_NO):
l_gma = []
l_mcf = []
for gma in self.physicals.keys():
l_gma.append(_F(NOM=gma))
l_mcf.append(_F(GROUP_MA=self.physicals[gma], NOM=gma))
_SMESH02 = COPIER(CONCEPT=MA)
DEFI_GROUP(
reuse=_SMESH02,
MAILLAGE=_SMESH02,
CREA_GROUP_MA=tuple(l_mcf),
DETR_GROUP_MA=tuple(l_gma),
)
DETRUIRE(CONCEPT=_F(NOM=MA), INFO=1)
if CREA_GROUP_NO == 'OUI':
DEFI_GROUP(
reuse=_SMESH02,
MAILLAGE=_SMESH02,
CREA_GROUP_NO=_F(TOUT_GROUP_MA='OUI'),
)
else:
# Traitement des GROUP_NO qui sont des points
info_gno = _SMESH02.LIST_GROUP_NO()
l_gno = []
for gno in info_gno:
if gno[1] == 1:
l_gno.append(gno[0])
l_gma = []
for gma in self.physicals.keys():
nom_gmsh = self.physicals[gma]
if nom_gmsh in l_gno:
l_gma.append(gma)
if l_gma:
DEFI_GROUP(
reuse=_SMESH02,
MAILLAGE=_SMESH02,
CREA_GROUP_NO=_F(GROUP_MA=tuple(l_gma)),
)
return _SMESH02
def Libre(self, nom=None, action='RESERVER'):
"""Réserve/associe et retourne une unité libre en y associant, s'il est
fourni, le fichier 'nom'.
"""
__tab = INFO_EXEC_ASTER(LISTE_INFO=('UNITE_LIBRE'))
unit = __tab['UNITE_LIBRE', 1]
DETRUIRE(CONCEPT=_F(NOM=__tab), INFO=1)
if nom == None:
nom = 'fort.' + str(unit)
# Si la clé existe, c'est que le fichier n'était pas libre
if self.infos.has_key(unit):
message = "Cette unité est déjà affectée au fichier %s" % \
self.infos[unit]['nom']
raise aster.error, "<F> <UniteAster.Libre> %s" % message
DEFI_FICHIER(ACTION=action, UNITE=unit, FICHIER=nom.strip())
self.infos[unit] = {}
self.infos[unit]['nom'] = nom.strip()
self.infos[unit]['etat'] = 'R'
self.infos[unit]['etat_init'] = 'F'
return unit
def _setinfo(self, ul):
"""Remplit les infos de l'unité 'ul'.
"""
# ul peut etre un entier Aster
try:
unit = ul.valeur
except:
unit = int(ul)
# Si la clé n'existe pas
ini = False
if not self.infos.has_key(unit):
self.infos[unit] = {}
self.infos[unit]['nom'] = ''
self.infos[unit]['etat'] = '?'
self.infos[unit]['etat_init'] = '?'
ini = True
__tab = INFO_EXEC_ASTER(UNITE=unit, LISTE_INFO=('ETAT_UNITE'))
# O:ouvert, F:fermé, R:réservé
self.infos[unit]['etat'] = __tab['ETAT_UNITE', 1].strip()[0]
if ini:
self.infos[unit]['etat_init'] = self.infos[unit]['etat']
# nom du fichier
if self.infos[unit]['etat'] in ['O', 'R']:
nomfich = ''.join([__tab['NOMFIC%d' % i, 1]
for i in range(1, 5)]).strip()
elif self.infos[unit]['etat'] == 'F':
nomfich = 'fort.' + str(unit)
else:
message = "Etat de l'unité inconnu : %s" % self.infos[unit]['etat']
print __tab.EXTR_TABLE()
raise aster.error, "<F> <UniteAster._setinfo> %s" % message
self.infos[unit]['nom'] = nomfich
# print 'DEBUG infos[unit] = ', self.infos[unit]
DETRUIRE(CONCEPT=_F(NOM=__tab), INFO=1)
def crea_champ(resu, ind_mod):
"""!Extrait les champs de deplacement d'une sd_resultat aster
a partir des DDL de mesure pour un mode donne.
Ces DDL sont identiques a ceux de la macro OBSERVATION
ayant servi a obtenir le resultat."""
from code_aster.Cata.Commands import CREA_CHAMP
from code_aster.Cata.Commands import DETRUIRE
__CHANO = CREA_CHAMP(
TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
RESULTAT=resu,
NOM_CHAM='DEPL',
NUME_ORDRE=ind_mod,
)
champy = __CHANO.EXTR_COMP(topo=1)
vale = champy.valeurs
DETRUIRE(
CONCEPT=_F(NOM=(__CHANO, ), ),
INFO=1,
)
return vale
def compute_freqk(self, k, RESU, VEC, dict_modes):
""" compute response for freqk - spec"""
nbmodt = self.mat_gene_params['NBMODT']
nbmodd = self.mat_gene_params['NBMODD']
freqk = self.FREQ_INIT + self.FREQ_PAS * k
__impe = LIRE_IMPE_MISS(
BASE=self.mat_gene_params['BASE'],
TYPE=self.calc_params['TYPE'],
NUME_DDL_GENE=self.mat_gene_params['NUME_DDL'],
UNITE_RESU_IMPE=self.calc_params['UNITE_RESU_IMPE'],
ISSF='NON',
FREQ_EXTR=freqk,
)
__fosi = LIRE_FORC_MISS(
BASE=self.mat_gene_params['BASE'],
NUME_DDL_GENE=self.mat_gene_params['NUME_DDL'],
NOM_CMP=dict_modes['NOM_CMP'],
NOM_CHAM='DEPL',
UNITE_RESU_FORC=self.calc_params['UNITE_RESU_FORC'],
ISSF='NON',
FREQ_EXTR=freqk,
)
__rito = COMB_MATR_ASSE(
COMB_C=(
_F(
MATR_ASSE=__impe,
COEF_C=1.0 + 0.j,
),
_F(
MATR_ASSE=self.mat_gene_params['MATR_RIGI'],
COEF_C=1.0 + 0.j,
),
),
SANS_CMP='LAGR',
)
# IMPEDANCE
MIMPE = __impe.EXTR_MATR_GENE()
# extraction de la partie modes interface
KRS = MIMPE[nbmodd:nbmodt, nbmodd:nbmodt]
# CALCUL FORCE SISMIQUE AVEC VARIABILITE
FSISM = __fosi.EXTR_VECT_GENE_C()
SP = NP.zeros((nbmodt, nbmodt))
for k1 in range(dict_modes['nbpod']):
# calcul de la force sismique mode POD par mode POD
FS = compute_force_vari(self, dict_modes, VEC[k1], KRS)
FSISM[nbmodd:nbmodt][:] = FS
# Calcul harmonique
__fosi.RECU_VECT_GENE_C(FSISM)
if self.mat_gene_params['MATR_AMOR'] is not None:
__dyge = DYNA_VIBRA(
TYPE_CALCUL='HARM',
BASE_CALCUL='GENE',
MATR_MASS=self.mat_gene_params['MATR_MASS'],
MATR_RIGI=__rito,
FREQ=freqk,
MATR_AMOR=self.mat_gene_params['MATR_AMOR'],
EXCIT=_F(
VECT_ASSE_GENE=__fosi,
COEF_MULT=1.0,
),
)
else:
__dyge = DYNA_VIBRA(
TYPE_CALCUL='HARM',
BASE_CALCUL='GENE',
MATR_MASS=self.mat_gene_params['MATR_MASS'],
MATR_RIGI=__rito,
FREQ=freqk,
EXCIT=_F(
VECT_ASSE_GENE=__fosi,
COEF_MULT=1.0,
),
)
# recuperer le vecteur modal depl calcule par dyge
RS = NP.array(__dyge.sdj.DEPL.get())
DETRUIRE(CONCEPT=_F(NOM=(__dyge)), INFO=1)
# stockage des matrices résultats: sum(s_q s_q* )
SP = SP + RS * NP.conj(RS[:, NP.newaxis])
SPEC = self.append_Vec(SP, k, RESU)
DETRUIRE(CONCEPT=_F(NOM=(__impe, __fosi, __rito)), INFO=1)
return SPEC
def extr_inte_spec(self, resu=None, intersp=1):
"""!Extraction d'une matrice inter-spectrale a partir d'une sd_interspectre
Verification de la coherence entre les ddl de l'inter-spectre et du concept resultat
- Si resi!= None, on peut associer les numeros d'ordre de l'IS a des DDL du resu,
- Si intersp = 1, on a un vrai inter-spectre. Si = 0, alors c'est une FRF ou une coherence
(exemple, CALC_SEPC calcule des FRF mais rend un concept de type inter-spectre).
Dans ce cas, on ne calcule pas la partie symetrique de la matrice."""
from code_aster.Cata.Commands import RECU_FONCTION, DETRUIRE
self.mess.disp_mess("Extraction de l'inter-spectre " + self.nom)
self.mess.disp_mess(" ")
coupl_ddl = self.extr_nume_ordr()
nb_fonc = len(coupl_ddl)
nb_freq = len(self.f)
nume_ordr_l = list(set([kk[0] for kk in coupl_ddl]))
nb_l = len(nume_ordr_l)
nume_ordr_c = list(set([kk[1] for kk in coupl_ddl]))
nb_c = len(nume_ordr_c)
if intersp:
if nb_l != nb_c:
self.mess.disp_mess("Inter-spectre non valide")
return
# Initialisation
self.matr_inte_spec = numpy.zeros((nb_freq, nb_l, nb_c), complex)
# Y a-t-il une numerotation associee a l'inter-spectre. Si oui
if resu:
self.set_model(resu)
self.nume_phy = nume_ddl_phy(resu)
nume = self.nume_phy
nb_mes = len(self.nume_phy)
# verification de la coherence entre la taille de l'inter-spectre et du DDL du resu
# TODO : retirer la verif ici et la mettre ailleurs
if nb_mes * (nb_mes + 1) / 2 != nb_fonc:
nb_mes_intsp = 0.5 * (-1 + numpy.sqrt(1 + 8 * nb_fonc))
self.mess.disp_mess(" Nombre de mesures de CPhi : " +
str(int(nb_mes)))
self.mess.disp_mess(
" Nombre de mesures de l'inter-spectre : " +
str(int(nb_mes_intsp)))
self.mess.disp_mess(" ")
raise TypeError
for nume_i, nume_j in coupl_ddl:
if not self.nume_phy or not self.isnume:
# rangement alpha-numerique des donnees de l'inter-spectre
ind_l = nume_ordr_l.index(nume_i)
ind_c = nume_ordr_c.index(nume_j)
__fonc = RECU_FONCTION(INTE_SPEC=self.obj,
NUME_ORDRE_I=nume_i,
NUME_ORDRE_J=nume_j)
elif self.nume_phy:
# rangement selon l'ordre des DDL donne par self.nume
ind_l = self.nume_phy.index(nume_i)
ind_c = self.nume_phy.index(nume_j)
if nume_i == nume_j:
__fonc = RECU_FONCTION(INTE_SPEC=self.obj,
NOEUD_I=nume_i.split('_')[0],
NOM_CMP_I=nume_i.split('_')[1])
else:
__fonc = RECU_FONCTION(INTE_SPEC=self.obj,
NOEUD_I=nume_i.split('_')[0],
NOM_CMP_I=nume_i.split('_')[1],
NOEUD_J=nume_j.split('_')[0],
NOM_CMP_J=nume_j.split('_')[1])
else:
self.mess.disp_mess(
u"Erreur dans l'extraction de l'inter-spectre : cas non-traite"
)
fonc_py = __fonc.convert('complex')
ordo = numpy.array(fonc_py.vale_y)
absc = numpy.array(fonc_py.vale_x)
if ind_l != ind_c:
self.matr_inte_spec[:, ind_l, ind_c] = ordo
self.matr_inte_spec[:, ind_c, ind_l] = numpy.conjugate(ordo)
else:
self.matr_inte_spec[:, ind_l, ind_c] = ordo
DETRUIRE(CONCEPT=_F(NOM=__fonc))
def liss_spectre_ops(self,
SPECTRE,
OPTION,
FREQ_MIN=None,
FREQ_MAX=None,
NB_FREQ_LISS=None,
ZPA=None,
**args):
"""
Ecriture de la macro LISS_SPECTRE
"""
ier = 0
# On importe les definitions des commandes a utiliser dans la macro
DEFI_NAPPE = self.get_cmd('DEFI_NAPPE')
CALC_FONCTION = self.get_cmd('CALC_FONCTION')
IMPR_FONCTION = self.get_cmd('IMPR_FONCTION')
DEFI_FICHIER = self.get_cmd('DEFI_FICHIER')
DETRUIRE = self.get_cmd('DETRUIRE')
# Comptage commandes + déclaration concept sortant
self.set_icmd(1)
macro = 'LISS_SPECTRE'
# Chemin du repertoire REPE_OUT de l'execution courante d'Aster
REPE_OUT = os.path.join(os.getcwd(), 'REPE_OUT')
# disponibilite de matplotlib
try:
import matplotlib
l_matplot = True
except:
UTMESS('A', 'SPECTRAL0_19')
l_matplot = False
directions = ['X', 'Y', 'Z', 'H']
dspectre = []
for j in SPECTRE:
dspectre.append(j.cree_dict_valeurs(j.mc_liste))
# premiere passe : evaluation du nombre de nappe a creer
nb_nappes = 0
for spec in dspectre:
if spec['TABLE'] is not None:
tab = spec['TABLE'].EXTR_TABLE()
planchers = recu_val(tab, 'NOM', stop=1)
nb_nappes += len(planchers) * len(directions)
print 'nb_nappes', nb_nappes
__NAPPE = nb_nappes * [None]
i_nappe = 0
dic_dir_planchers = {}
vale_amor_ref = None
nb_freq_max = 0
# deuxieme passe
for spec in dspectre:
if spec['ELARG'] is None:
elarg = 0.
else:
if OPTION == 'CONCEPTION':
UTMESS('A', 'SPECTRAL0_20')
elarg = spec['ELARG']
if spec['TABLE'] is not None:
tab = spec['TABLE'].EXTR_TABLE()
# recuperation des noms de planchers, batiments et commentaires
planchers = recu_val(tab, 'NOM', stop=1, typ='K')
batiments = recu_val(tab, 'BATIMENT', typ='K')
commentaires = recu_val(tab, 'COMMENTAIRE', typ='K')
nb_planchers = len(planchers)
# amortissements, frequences
nume_amor = recu_val(tab, 'NUME_AMOR', stop=1)
vale_amor = recu_val(tab, 'AMOR', stop=1)
vale_freq = recu_val(tab, 'FREQ', stop=1)
if len(vale_freq) > nb_freq_max: nb_freq_max = len(vale_freq)
if vale_amor_ref is None:
vale_amor_ref = vale_amor
else:
check_amor(vale_amor_ref, vale_amor)
# boucle sur les planchers
for ipl, pl in enumerate(planchers):
# boucle sur les directions
print pl
for dire in directions:
print dire
list_defi_fonc = []
# boucle sur les amortissements
for namo in nume_amor:
print namo
para = 'e%s_%s_%s' % (dire, namo, pl)
para2 = 'E%s_%s_%s' % (dire, namo, pl)
print para, para2
if para in tab.para:
l_vale = recu_val(tab, para)
elif para2 in tab.para:
l_vale = recu_val(tab, para2)
else:
continue
vale_fonc = []
for ifreq, freq in enumerate(vale_freq):
vale_fonc.extend([freq, l_vale[ifreq]])
dic_fonc = {
'PROL_DROITE': 'CONSTANT',
'PROL_GAUCHE': 'CONSTANT',
'VALE': vale_fonc
}
print 'vale_fonc', vale_fonc
list_defi_fonc.append(dic_fonc)
if list_defi_fonc != []:
dir_pl = '%s_%s' % (dire, pl)
if not dir_pl in dic_dir_planchers.keys():
dic_dir_planchers[dir_pl] = {
'liste_nappes': [],
'batiment': 'inconnu',
'commentaire': 'pas de commentaire',
'elargissement': [],
'direction': dire,
'plancher': pl
}
if dic_dir_planchers[dir_pl]['batiment'] == 'inconnu':
if batiments[ipl] != None and batiments[ipl] != '-':
dic_dir_planchers[dir_pl][
'batiment'] = batiments[ipl]
if dic_dir_planchers[dir_pl][
'commentaire'] == 'pas de commentaire':
if commentaires[ipl] != None and commentaires[
ipl] != '-':
dic_dir_planchers[dir_pl][
'commentaire'] = commentaires[ipl]
__NAPPE[i_nappe] = DEFI_NAPPE(
NOM_PARA='AMOR',
PARA=vale_amor,
NOM_PARA_FONC='FREQ',
NOM_RESU='ACCE',
PROL_DROITE='CONSTANT',
PROL_GAUCHE='CONSTANT',
DEFI_FONCTION=list_defi_fonc,
)
dic_dir_planchers[dir_pl]['liste_nappes'].append(
__NAPPE[i_nappe])
dic_dir_planchers[dir_pl]['elargissement'].append(
elarg)
# NAPPE
else:
nappe = spec['NAPPE']
dire = spec['DIRECTION']
pl = spec['NOM']
batiment = spec['BATIMENT']
commentaire = spec['COMMENTAIRE']
lpar, lval = nappe.Valeurs()
nb_freq = len(lval[0][0])
if nb_freq > nb_freq_max:
nb_freq_max = nb_freq
dir_pl = '%s_%s' % (dire, pl)
if not dir_pl in dic_dir_planchers.keys():
dic_dir_planchers[dir_pl] = {
'liste_nappes': [],
'batiment': 'inconnu',
'commentaire': 'pas de commentaire',
'elargissement': [],
'direction': dire,
'plancher': pl
}
if dic_dir_planchers[dir_pl]['batiment'] == 'inconnu':
if batiment != None:
dic_dir_planchers[dir_pl]['batiment'] = batiment
if dic_dir_planchers[dir_pl][
'commentaire'] == 'pas de commentaire':
if commentaire != None:
dic_dir_planchers[dir_pl]['commentaire'] = commentaire
dic_dir_planchers[dir_pl]['liste_nappes'].append(nappe)
dic_dir_planchers[dir_pl]['elargissement'].append(elarg)
unite = get_unite_libre()
for dir_pl in dic_dir_planchers.keys():
dico = dic_dir_planchers[dir_pl]
motscles = {}
if NB_FREQ_LISS is not None:
motscles['NB_FREQ_LISS'] = NB_FREQ_LISS
if FREQ_MIN is not None:
motscles['FREQ_MIN'] = FREQ_MIN
if FREQ_MAX is not None:
motscles['FREQ_MAX'] = FREQ_MAX
if ZPA is not None:
motscles['ZPA'] = ZPA
if OPTION == 'CONCEPTION':
__Naplis = CALC_FONCTION(LISS_ENVELOP=_F(
NAPPE=dico['liste_nappes'], OPTION=OPTION, **motscles))
else:
__Naplis = CALC_FONCTION(
LISS_ENVELOP=_F(NAPPE=dico['liste_nappes'],
OPTION=OPTION,
ELARG=dico['elargissement'],
**motscles))
# impression au format TABLEAU
nom_fic = dico['batiment'] + '_' + dico['plancher'] + '_' + dico[
'direction'] + '.txt'
chem_fic = os.path.join(REPE_OUT, nom_fic)
DEFI_FICHIER(ACTION='ASSOCIER', UNITE=unite, FICHIER=chem_fic)
IMPR_FONCTION(FORMAT='TABLEAU',
COURBE=_F(FONCTION=__Naplis),
UNITE=unite)
DEFI_FICHIER(ACTION='LIBERER', UNITE=unite)
# impression en PNG, format LISS_ENVELOPPE
if l_matplot:
nom_fic = dico['batiment'] + '_' + dico['plancher'] + '_' + dico[
'direction'] + '.png'
chem_fic = os.path.join(REPE_OUT, nom_fic)
DEFI_FICHIER(ACTION='ASSOCIER', UNITE=unite, FICHIER=chem_fic)
sous_titre = dico['plancher'] + dico['direction'] + ', ' + dico[
'commentaire']
IMPR_FONCTION(FORMAT='LISS_ENVELOP',
COURBE=_F(NAPPE_LISSEE=__Naplis, ),
TITRE=dico['batiment'],
SOUS_TITRE=sous_titre,
UNITE=unite,
**args)
DEFI_FICHIER(ACTION='LIBERER', UNITE=unite)
# verification
motscles = {}
motscles['NB_FREQ_LISS'] = nb_freq_max
if FREQ_MIN is not None:
motscles['FREQ_MIN'] = FREQ_MIN
if FREQ_MAX is not None:
motscles['FREQ_MAX'] = FREQ_MAX
if ZPA is not None:
motscles['ZPA'] = ZPA
if OPTION == 'CONCEPTION':
__Napver = CALC_FONCTION(LISS_ENVELOP=_F(
NAPPE=dico['liste_nappes'], OPTION=OPTION, **motscles))
else:
__Napver = CALC_FONCTION(
LISS_ENVELOP=_F(NAPPE=dico['liste_nappes'],
OPTION=OPTION,
ELARG=dico['elargissement'],
**motscles))
# impression au format TABLEAU
nom_fic = dico['batiment'] + '_' + dico['plancher'] + '_' + dico[
'direction'] + '_verif.txt'
chem_fic = os.path.join(REPE_OUT, nom_fic)
DEFI_FICHIER(ACTION='ASSOCIER', UNITE=unite, FICHIER=chem_fic)
IMPR_FONCTION(FORMAT='TABLEAU',
COURBE=_F(FONCTION=__Napver),
UNITE=unite)
DEFI_FICHIER(ACTION='LIBERER', UNITE=unite)
# impression en PNG, format LISS_ENVELOPPE
if l_matplot:
nom_fic = dico['batiment'] + '_' + dico['plancher'] + '_' + dico[
'direction'] + '_verif.png'
chem_fic = os.path.join(REPE_OUT, nom_fic)
DEFI_FICHIER(ACTION='ASSOCIER', UNITE=unite, FICHIER=chem_fic)
sous_titre = dico['plancher'] + dico['direction'] + ', ' + dico[
'commentaire']
IMPR_FONCTION(FORMAT='LISS_ENVELOP',
COURBE=_F(NAPPE_LISSEE=__Napver, ),
TITRE=dico['batiment'],
SOUS_TITRE=sous_titre,
UNITE=unite,
**args)
DEFI_FICHIER(ACTION='LIBERER', UNITE=unite)
DETRUIRE(CONCEPT=(
_F(NOM=__Naplis),
_F(NOM=__Napver),
), INFO=1)
return ier
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 asse_champs_gauss(self, dic_champ_cont, dic_champ_var_int, dic_transfo,
resu):
"""
Transformation et assemblage des champs aux points de Gauss.
"""
from code_aster.Cata.Commands import LIRE_CHAMP, CREA_CHAMP, DETRUIRE
from code_aster.Cata.Commands import CREA_RESU, MODI_REPERE
info_mode_epx = self.info_mode_epx
info_comp_epx = self.info_comp_epx
dic_mc_cara = self.dic_mc_cara
ll = len(dic_champ_cont.keys()) - 1
nb_SIG1 = len(dic_champ_cont['SANS'].keys()) + ll
ll = len(dic_champ_var_int.keys()) - 1
nb_ECR1 = len(dic_champ_var_int['SANS'].keys()) + ll
itot = len(resu.LIST_PARA()['INST'])
__EFFG = [None] * itot
__ECRG = [None] * itot
__SIG1 = [None] * nb_SIG1
__ECR1 = [None] * nb_ECR1
dicAffe = []
dicAffe3 = []
lc = {
'INFO': self.INFO,
'UNITE': self.UNITE_MED,
'MODELE': self.MODELE,
'MAILLAGE': self.MAILLAGE,
'PROL_ZERO': 'OUI',
}
cc = {
'INFO': self.INFO,
'MODELE': self.MODELE,
'PROL_ZERO': 'OUI',
'OPERATION': 'ASSE',
}
MasquerAlarme('MED_4')
for i in xrange(itot):
lc['NUME_PT'] = resu.LIST_PARA()['NUME_ORDRE'][i]
dicAsse = []
dicAsse3 = []
dicDetr = []
# CONTRAINTES
lc['TYPE_CHAM'] = 'ELGA_SIEF_R'
for mc_cara in dic_champ_cont.keys():
j = 0
if mc_cara == 'SANS':
for champ in dic_champ_cont[mc_cara].keys():
mode_epx = dic_champ_cont[mc_cara][champ]
nom_cmp = info_mode_epx[mode_epx]['NOM_CMP']
nom_cmp_med = info_mode_epx[mode_epx]['NOM_CMP_MED']
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__SIG1[j] = LIRE_CHAMP(**lcc)
dicDetr.append({'NOM': __SIG1[j]})
dicAsse.append({
'TOUT': 'OUI',
'CHAM_GD': __SIG1[j],
'NOM_CMP': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
j += 1
else:
nb_champ_cara = len(dic_champ_cont[mc_cara].keys())
dicDetr_cara = []
if nb_champ_cara == 1:
champ = dic_champ_cont[mc_cara].keys()[0]
mode_epx = dic_champ_cont[mc_cara][champ]
nom_cmp = info_mode_epx[mode_epx]['NOM_CMP']
nom_cmp_med = info_mode_epx[mode_epx]['NOM_CMP_MED']
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__SIG_AS = LIRE_CHAMP(**lcc)
else:
__SIG = [None] * nb_champ_cara
dicAsse_cara = []
for k, champ in enumerate(
dic_champ_cont[mc_cara].keys()):
mode_epx = dic_champ_cont[mc_cara][champ]
nom_cmp = info_mode_epx[mode_epx]['NOM_CMP']
nom_cmp_med = info_mode_epx[mode_epx][
'NOM_CMP_MED']
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__SIG[k] = LIRE_CHAMP(**lcc)
dicAsse_cara.append({
'TOUT': 'OUI',
'CHAM_GD': __SIG[k],
'NOM_CMP': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
dicDetr_cara.append({'NOM': __SIG[k]})
# assemblage
ccc = cc.copy()
ccc.update(
TYPE_CHAM='ELGA_SIEF_R',
ASSE=dicAsse_cara,
)
__SIG_AS = CREA_CHAMP(**ccc)
dicDetr_cara.append({'NOM': __SIG_AS})
cham_para = (dic_mc_cara[mc_cara]['CH_CARA'], __SIG_AS)
cham_fonc = dic_mc_cara[mc_cara]['CH_FONC']
# EVAL : passage des contraintes aux efforts
__SIG1[j] = CREA_CHAMP(
OPERATION='EVAL',
TYPE_CHAM='ELGA_NEUT_R',
CHAM_F=cham_fonc,
CHAM_PARA=cham_para,
)
dicDetr.append({'NOM': __SIG1[j]})
nom_cmp = dic_mc_cara[mc_cara]['NOM_CMP']
nom_cmp_f = dic_mc_cara[mc_cara]['NOM_CMP_F']
dicAsse.append({
'TOUT': 'OUI',
'CHAM_GD': __SIG1[j],
'NOM_CMP': nom_cmp_f,
'NOM_CMP_RESU': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
DETRUIRE(CONCEPT=dicDetr_cara, INFO=1)
j += 1
# VARIABLES INTERNES
lc['TYPE_CHAM'] = 'ELGA_VARI_R'
for compo in dic_champ_var_int.keys():
j = 0
if compo == 'SANS':
for champ in dic_champ_var_int[compo].keys():
loi = dic_champ_var_int[compo][champ]
nb_var_aster = info_comp_epx[loi]['NB_VAR_ASTER']
nom_cmp = info_comp_epx[loi][
'VAR_ASTER'][:nb_var_aster]
nom_cmp_med = info_comp_epx[loi][
'VAR_EPX'][:nb_var_aster]
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__ECR1[j] = LIRE_CHAMP(**lcc)
dicAsse3.append({
'TOUT': 'OUI',
'CHAM_GD': __ECR1[j],
'NOM_CMP': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
dicDetr.append({'NOM': __ECR1[j]})
j += 1
else:
nb_champ_transfo = len(dic_champ_var_int[compo].keys())
dicDetr_transfo = []
if nb_champ_transfo == 1:
champ = dic_champ_var_int[compo].keys()[0]
loi = dic_champ_var_int[compo][champ]
nb_var_epx = info_comp_epx[loi]['NB_VAR_EPX']
nom_cmp = info_comp_epx[loi]['VAR_ASTER'][:nb_var_epx]
nom_cmp_med = info_comp_epx[loi][
'VAR_EPX'][:nb_var_epx]
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__ECR_AS = LIRE_CHAMP(**lcc)
else:
__ECR = [None] * nb_champ_transfo
dicAsse_transfo = []
for k, champ in enumerate(
dic_champ_var_int[compo].keys()):
loi = dic_champ_var_int[compo][champ]
nb_var_epx = info_comp_epx[loi]['NB_VAR_EPX']
nom_cmp = info_comp_epx[loi][
'VAR_ASTER'][:nb_var_epx]
nom_cmp_med = info_comp_epx[loi][
'VAR_EPX'][:nb_var_epx]
lcc = lc.copy()
lcc.update(
NOM_MED=champ,
NOM_CMP=nom_cmp,
NOM_CMP_MED=nom_cmp_med,
)
__ECR[k] = LIRE_CHAMP(**lcc)
dicAsse_transfo.append({
'TOUT': 'OUI',
'CHAM_GD': __ECR[k],
'NOM_CMP': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
dicDetr_transfo.append({'NOM': __ECR[k]})
# assemblage
ccc = cc.copy()
ccc.update(
TYPE_CHAM='ELGA_VARI_R',
ASSE=dicAsse_transfo,
)
__ECR_AS = CREA_CHAMP(**ccc)
dicDetr_transfo.append({'NOM': __ECR_AS})
cham_para = __ECR_AS
cham_fonc = dic_transfo[compo]['CH_FONC']
# EVAL : transormation EPX -> Aster
try:
__ECR1[j] = CREA_CHAMP(
OPERATION='EVAL',
TYPE_CHAM='ELGA_NEUT_R',
CHAM_F=cham_fonc,
CHAM_PARA=cham_para,
)
dicDetr.append({'NOM': __ECR1[j]})
except:
compor_aster = self.info_comp_epx[compo][
'COMPOR_ASTER']
UTMESS('F', 'PLEXUS_57', valk=compor_aster)
nom_cmp = dic_transfo[compo]['NOM_CMP']
nom_cmp_f = dic_transfo[compo]['NOM_CMP_F']
dicAsse3.append({
'TOUT': 'OUI',
'CHAM_GD': __ECR1[j],
'NOM_CMP': nom_cmp_f,
'NOM_CMP_RESU': nom_cmp,
'CUMUL': 'OUI',
'COEF_R': 1.
})
DETRUIRE(CONCEPT=dicDetr_transfo, INFO=1)
j += 1
if dicAsse != []:
ccc = cc.copy()
ccc.update(
TYPE_CHAM='ELGA_SIEF_R',
ASSE=dicAsse,
)
__EFFG[i] = CREA_CHAMP(**ccc)
dic = {
'MODELE': self.MODELE,
'INST': resu.LIST_PARA()['INST'][i],
}
if self.CHAM_MATER is not None:
dic['CHAM_MATER'] = self.CHAM_MATER
if self.CARA_ELEM_CONCEPT is not None:
dic['CARA_ELEM'] = self.CARA_ELEM_CONCEPT
dic['CHAM_GD'] = __EFFG[i]
dicAffe.append(dic)
if dicAsse3 != []:
ccc = cc.copy()
ccc.update(TYPE_CHAM='ELGA_VARI_R', ASSE=dicAsse3)
__ECRG[i] = CREA_CHAMP(**ccc)
dic2 = dic.copy()
dic2['CHAM_GD'] = __ECRG[i]
dicAffe3.append(dic2)
if dicDetr != []:
DETRUIRE(CONCEPT=dicDetr, INFO=1)
RetablirAlarme('MED_4')
MasquerAlarme('COMPOR2_26')
MasquerAlarme('COMPOR2_23')
if dicAffe != []:
resu = CREA_RESU(
reuse=resu,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='SIEF_ELGA',
AFFE=dicAffe,
)
if dicAffe3 != []:
resu = CREA_RESU(
reuse=resu,
OPERATION='AFFE',
TYPE_RESU='EVOL_NOLI',
NOM_CHAM='VARI_ELGA',
AFFE=dicAffe3,
)
RetablirAlarme('COMPOR2_26')
RetablirAlarme('COMPOR2_23')
if self.modi_repere['COQUE']:
from code_aster.Cata.Commands import MODI_REPERE
MODI_REPERE(RESULTAT=resu,
reuse=resu,
REPERE='COQUE_INTR_UTIL',
MODI_CHAM=_F(TYPE_CHAM='COQUE_GENE',
NOM_CHAM='SIEF_ELGA',
NOM_CMP=('NXX', 'NYY', 'NXY', 'MXX',
'MYY', 'MXY', 'QX', 'QY')))
def make_mac_salome(mac, resu1, resu2, unite):
from code_aster.Cata.Commands import (LIRE_MAILLAGE, AFFE_MODELE,
CREA_CHAMP, DETRUIRE,
INFO_EXEC_ASTER, IMPR_RESU,
DEFI_FICHIER, CREA_RESU)
import random
# dimension du MAC
nb_l = mac.shape[0] - 1
nb_c = mac.shape[1] - 1
# fabrication d'un maillage au format aster
unite_mesh = make_mesh_mac(nb_l, nb_c)
__MA = LIRE_MAILLAGE(UNITE=unite_mesh, FORMAT='ASTER')
__MO = AFFE_MODELE(
MAILLAGE=__MA,
AFFE=(_F(TOUT='OUI', MODELISATION='PLAN_ELDI',
PHENOMENE='MECANIQUE'), ),
)
# affection avec CREA_CHAMP
# mcfact = []
# ii=0
# for ind_l in range(1,nb_l+1):
# for ind_c in range(1,nb_c+1):
# mcfact.append({'MAILLE':'M%s_%s' %(ind_l,ind_c),'NOM_CMP':'X1','VALE':toto[ii]})
# ii+=1
mcfact = []
# aller chercher les nume_ordre et les freq
nume_ordre_1 = resu1.get_modes_data()['NUME_ORDRE']
nume_ordre_2 = resu2.get_modes_data()['NUME_ORDRE']
nb_mod1 = len(nume_ordre_1)
nb_mod2 = len(nume_ordre_2)
freq1 = resu1.get_modes_data()['FREQ']
if not freq1:
freq1 = [0.0 for kk in range(nb_mod1)]
freq2 = resu2.get_modes_data()['FREQ']
if not freq2:
freq2 = [0.0 for kk in range(nb_mod2)]
for ind_l in range(1, nb_l + 1):
for ind_c in range(1, nb_c + 1):
mcfact.append({
'MAILLE': 'M%s_%s' % (ind_l, ind_c),
'NOM_CMP': 'ERREST',
'VALE': mac[ind_l, ind_c]
})
mcfact.append({
'MAILLE': 'M%s_%s' % (ind_l, ind_c),
'NOM_CMP': 'NUEST',
'VALE': nume_ordre_1[ind_l]
})
mcfact.append({
'MAILLE': 'M%s_%s' % (ind_l, ind_c),
'NOM_CMP': 'SIGCAL',
'VALE': freq1[ind_l]
})
mcfact.append({
'MAILLE': 'M%s_%s' % (ind_l, ind_c),
'NOM_CMP': 'TERMRE',
'VALE': nume_ordre_2[ind_c]
})
mcfact.append({
'MAILLE': 'M%s_%s' % (ind_l, ind_c),
'NOM_CMP': 'TERMR2 ',
'VALE': freq2[ind_c]
})
# __CHA = CREA_CHAMP( OPERATION= 'AFFE',
# TYPE_CHAM='CART_NEUT_R' , MAILLAGE = MAIL,
# AFFE=mcfact)
__CHA = CREA_CHAMP(OPERATION='AFFE',
MODELE=__MO,
PROL_ZERO='OUI',
TYPE_CHAM='ELEM_ERRE_R',
AFFE=mcfact)
IMPR_RESU(UNITE=unite, FORMAT='MED', RESU=_F(CHAM_GD=__CHA))
DETRUIRE(CONCEPT=_F(NOM=(
__MA,
__MO,
__CHA,
)))
DEFI_FICHIER(ACTION='LIBERER', UNITE=unite_mesh)
return
def calc_proj_resu(self, suffix, basename):
"""!Mancement de MACRO_EPXANS et export des resultats si demande
4 resultats sont crees, nommes basename + suffix, ou
suffix = ['_NX','_EX','_ET','_RD']"""
from code_aster.Cata.Syntax import CO
from code_aster.Cata.Commands import DETRUIRE, MACRO_EXPANS
self.mess.disp_mess("Debut de MACRO_EXPANS")
mdo = self.ce_objects
if not basename:
basename = 'tmp'
for suf in suffix:
if mdo.resultats.has_key(basename + suf):
# Destruction des concepts existants si ils existent deja
self.mess.disp_mess("destruction de " + basename + suf)
DETRUIRE(CONCEPT=_F(NOM=mdo.resultats[basename + suf].obj))
# res_ET et res_RD sont initialises automatiquement
res_ET = CO(basename + suffix[2])
res_RD = CO(basename + suffix[3])
# Preparation des donnees de mesure
nume = None
mcfact_mesure = {
'MODELE': self.resu_exp.modele.obj,
'MESURE': self.resu_exp.obj,
'NOM_CHAM': self.resu_exp.nom_cham
}
args = {}
# modif : la partie commentee ci-dessus devrait marcher bien comme ca
if self.mode_exp_list:
# res_EX est genere que si on a selectionne une partie des modes
res_EX = CO(basename + suffix[1])
args.update({'RESU_EX': res_EX})
mcfact_mesure.update({'NUME_ORDRE': tuple(self.mode_exp_list)})
if isinstance(self.resu_exp.obj, dyna_harmo):
nume = self.resu_exp.nume_ddl # aller chercher a la main le nume_ddl
# Preparation des donnees numeriques pour la base d'expansion
mcfact_calcul = {
'MODELE': self.resu_num.modele.obj,
'BASE': self.resu_num.obj
}
if self.mode_num_list:
# res_NX est genere que si on a selectionne une partie des modes
res_NX = CO(basename + suffix[0])
args.update({'RESU_NX': res_NX})
mcfact_calcul.update({'NUME_ORDRE': tuple(self.mode_num_list)})
# Parametres de resolution
parametres = self.param
try:
MACRO_EXPANS(MODELE_CALCUL=mcfact_calcul,
MODELE_MESURE=mcfact_mesure,
NUME_DDL=nume,
RESU_ET=res_ET,
RESU_RD=res_RD,
RESOLUTION=parametres,
**args)
except aster.error, err:
message = "ERREUR ASTER : " + \
mess.GetText('I', err.id_message, err.valk, err.vali, err.valr)
self.mess.disp_mess(message)
UTMESS('A', 'CALCESSAI0_7')
for suf in suffix:
# destruction : les concepts ont ete initialises, il faut les
# detruire, meme s'ils sont vides
DETRUIRE(CONCEPT=_F(NOM=(res_NX, res_EX, res_ET, res_RD)))
return
def compute_freqk(self, k, RESU, VEC, dict_modes):
""" compute response for freqk - trans"""
nbmodt = self.mat_gene_params['NBMODT']
nbmodd = self.mat_gene_params['NBMODD']
freqk = self.FREQ_INIT + self.FREQ_PAS * k
__impe = LIRE_IMPE_MISS(
BASE=self.mat_gene_params['BASE'],
TYPE=self.calc_params['TYPE'],
NUME_DDL_GENE=self.mat_gene_params['NUME_DDL'],
UNITE_RESU_IMPE=self.calc_params['UNITE_RESU_IMPE'],
ISSF='NON',
FREQ_EXTR=freqk,
)
__fosi = LIRE_FORC_MISS(
BASE=self.mat_gene_params['BASE'],
NUME_DDL_GENE=self.mat_gene_params['NUME_DDL'],
NOM_CMP=dict_modes['NOM_CMP'],
NOM_CHAM='DEPL',
UNITE_RESU_FORC=self.calc_params['UNITE_RESU_FORC'],
ISSF='NON',
FREQ_EXTR=freqk,
)
__rito = COMB_MATR_ASSE(
COMB_C=(
_F(
MATR_ASSE=__impe,
COEF_C=1.0 + 0.j,
),
_F(
MATR_ASSE=self.mat_gene_params['MATR_RIGI'],
COEF_C=1.0 + 0.j,
),
),
SANS_CMP='LAGR',
)
# IMPEDANCE
MIMPE = __impe.EXTR_MATR_GENE()
# extraction de la partie modes interface
KRS = MIMPE[nbmodd:nbmodt, nbmodd:nbmodt]
# CALCUL FORCE SISMIQUE
FSISM = __fosi.EXTR_VECT_GENE_C()
# extraction de la partie modes interface
FS = 0.0
for k1 in range(dict_modes['nbpod']):
FS = FS + compute_force_vari(self, dict_modes, VEC[k1], KRS)
FSISM[nbmodd:nbmodt][:] = FS
__fosi.RECU_VECT_GENE_C(FSISM)
# CALCUL ISS
if self.mat_gene_params['MATR_AMOR'] is not None:
__dyge = DYNA_VIBRA(
TYPE_CALCUL='HARM',
BASE_CALCUL='GENE',
MATR_MASS=self.mat_gene_params['MATR_MASS'],
MATR_RIGI=__rito,
FREQ=freqk,
MATR_AMOR=self.mat_gene_params['MATR_AMOR'],
EXCIT=_F(
VECT_ASSE_GENE=__fosi,
COEF_MULT=1.0,
),
)
else:
__dyge = DYNA_VIBRA(
TYPE_CALCUL='HARM',
BASE_CALCUL='GENE',
MATR_MASS=self.mat_gene_params['MATR_MASS'],
MATR_RIGI=__rito,
FREQ=freqk,
EXCIT=_F(
VECT_ASSE_GENE=__fosi,
COEF_MULT=1.0,
),
)
# recuperer le vecteur modal depl calcule par dyge
RS = NP.array(__dyge.sdj.DEPL.get())
DETRUIRE(CONCEPT=_F(NOM=(__dyge)), INFO=1)
VECRES = self.append_Vec(RS, k, RESU)
if k > 0:
DETRUIRE(CONCEPT=_F(NOM=(__impe, __fosi, __rito)), INFO=1)
return VECRES
VEC = calc_miss_vari(self)
return VEC
def compute_nodal_reaction_from_field_on_group(field,
model,
mat,
group,
charg,
char_cine=None):
"""
Compute nodal reaction from a displacement field on a specific group.
Input:
-field: aster displacement field
-model: aster model,
-mat: assigned material on a mesh
-char_cine: dirichlet boundary conditions
-group: group where the nodal reaction has to be computed
Output:
-asterField instance
"""
### Create result concept from the displacement field
#resu = create_resu(field,model,mat,char_cine)
if char_cine:
resu = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_ELAS',
NOM_CHAM='DEPL',
EXCIT=_F(CHARGE=charg),
AFFE=_F(
CHAM_GD=field,
MODELE=model,
CHAM_MATER=mat,
INST=0.,
))
else:
resu = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_ELAS',
NOM_CHAM='DEPL',
AFFE=_F(
CHAM_GD=field,
MODELE=model,
CHAM_MATER=mat,
INST=0.,
))
resu = CALC_CHAMP(
FORCE='REAC_NODA',
reuse=resu,
MODELE=model,
CHAM_MATER=mat,
EXCIT=_F(CHARGE=charg),
TOUT='OUI',
RESULTAT=resu,
)
AsterIter = AsterCount.__next__()
o[AsterIter] = CREA_CHAMP(
OPERATION='EXTR',
NOM_CHAM='REAC_NODA',
TYPE_CHAM='NOEU_DEPL_R',
RESULTAT=resu,
INST=0.,
)
nodalrea = CREA_CHAMP(
OPERATION='ASSE',
TYPE_CHAM='NOEU_DEPL_R',
MODELE=model,
ASSE=_F(CHAM_GD=o[AsterIter], GROUP_MA=group),
)
DETRUIRE(CONCEPT=(_F(NOM=nodalrea), _F(NOM=resu)))
return o[AsterIter]
def get_unite_logique(self):
_TUL = INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE')
self.unite_logique = _TUL['UNITE_LIBRE', 1]
DETRUIRE(CONCEPT=_F(NOM=(_TUL)), INFO=1)
pass
def calc_mac_mode(self, resu1, resu2, norme):
"""!Calcul de MAC entre deux bases modales compatibles"""
from code_aster.Cata.Commands import MAC_MODES, DETRUIRE
o1 = resu1.obj
o2 = resu2.obj
try:
__MAC = MAC_MODES(BASE_1=o1, BASE_2=o2, MATR_ASSE=norme, INFO=1)
except aster.error, err:
message = "ERREUR ASTER : " + \
mess.GetText('I', err.id_message, err.valk, err.vali, err.valr)
self.mess.disp_mess(message)
UTMESS('A', 'CALCESSAI0_3')
return
self.mess.disp_mess((" "))
mac = extract_mac_array(__MAC, 'MAC')
DETRUIRE(CONCEPT=_F(NOM=(__MAC, )), INFO=1)
return mac
def make_mac_salome(mac, resu1, resu2, unite):
from code_aster.Cata.Commands import (LIRE_MAILLAGE, AFFE_MODELE,
CREA_CHAMP, DETRUIRE,
INFO_EXEC_ASTER, IMPR_RESU,
DEFI_FICHIER, CREA_RESU)
import random
# dimension du MAC
nb_l = mac.shape[0] - 1
nb_c = mac.shape[1] - 1
# fabrication d'un maillage au format aster