def _run(self):
"""SPEC_OSCI"""
import aster_fonctions
f_in = self._lf[0]
l_freq, l_amor = self._dat['FREQ'], self._dat['AMOR']
kw = self.kw
l_fonc_f = []
# construction de la nappe
vale_para = l_amor
para = {
'INTERPOL': ['LIN', 'LOG'],
'NOM_PARA_FONC': 'FREQ',
'NOM_PARA': 'AMOR',
'PROL_DROITE': 'EXCLU',
'PROL_GAUCHE': 'EXCLU',
'NOM_RESU': kw['NATURE']
}
para_fonc = {
'INTERPOL': ['LOG', 'LOG'],
'NOM_PARA': 'FREQ',
'PROL_DROITE': 'CONSTANT',
'PROL_GAUCHE': 'EXCLU',
'NOM_RESU': kw['NATURE']
}
if kw['NATURE'] == 'DEPL':
ideb = 0
elif kw['NATURE'] == 'VITE':
ideb = 1
else:
ASSERT(kw['NATURE'] == 'ACCE')
ideb = 2
if kw['METHODE'] == 'RICE':
# appel à DSP2SRO
ASSERT(kw['NATURE_FONC'] == 'DSP')
deuxpi = 2. * math.pi
f_dsp = t_fonction(f_in.vale_x * deuxpi, f_in.vale_y / deuxpi,
f_in.para)
for iamor in l_amor:
spectr = DSP2SRO(f_dsp, iamor, kw['DUREE'], l_freq, ideb)
vale_y = spectr.vale_y / kw['NORME']
l_fonc_f.append(t_fonction(l_freq, vale_y, para_fonc))
elif kw['METHODE'] == 'NIGAM':
# appel à SPEC_OSCI
ASSERT(kw['NATURE_FONC'] == 'ACCE')
spectr = aster_fonctions.SPEC_OSCI(f_in.vale_x, f_in.vale_y,
l_freq, l_amor)
for iamor in range(len(l_amor)):
vale_y = spectr[iamor, ideb, :] / kw['NORME']
l_fonc_f.append(t_fonction(l_freq, vale_y, para_fonc))
elif kw['METHODE'] == 'HARMO':
# appel à ACCE2DSP
ASSERT(kw['NATURE_FONC'] == 'ACCE')
for iamor in l_amor:
spectr = ACCE2SRO(f_in, iamor, l_freq, ideb)
vale_y = spectr.vale_y / kw['NORME']
l_fonc_f.append(t_fonction(l_freq, vale_y, para_fonc))
self.resu = t_nappe(vale_para, l_fonc_f, para)
def _build_data(self):
"""Read keywords to build the data"""
# CalcFonctionOper._build_list_fonc(self)
kw = self.kw
if self.kw['NAPPE'] != None:
self._build_list_fonc(mcsimp='NAPPE')
elif self.kw['FONCTION'] != None:
self._build_list_fonc(mcsimp='FONCTION')
elif self.kw['TABLE'] != None:
lf_in = self._get_mcsimp('TABLE')
para_fonc = {
'PROL_DROITE': 'EXCLU',
'INTERPOL': ['LIN', 'LIN'],
'PROL_GAUCHE': 'EXCLU',
'NOM_RESU': 'TOUTRESU',
'NOM_PARA': 'FREQ'
}
para_napp = {
'PROL_DROITE': 'EXCLU',
'INTERPOL': ['LIN', 'LIN'],
'PROL_GAUCHE': 'EXCLU',
'NOM_RESU': 'TOUTRESU',
'NOM_PARA': 'AMOR',
'NOM_PARA_FONC': 'FREQ'
}
# conversion des tables en nappes
l_nappe = []
for tab in lf_in:
nom_para = tab.get_nom_para()
# print nom_para
if kw['LIST_AMOR'] != None:
amor = kw['LIST_AMOR']
else:
amor = range(1, len(nom_para))
# error
if 'FREQ' not in nom_para:
print 'error'
nom_para.remove('FREQ')
# print dir(tab.EXTR_TABLE())
dico = tab.EXTR_TABLE().values()
l_fonc_f = []
for para in nom_para:
freq = dico['FREQ']
# print freq
vale = dico[para]
# print vale
l_fonc_f.append(t_fonction(freq, vale, para_fonc))
# print 'fonction'
l_nappe.append(t_nappe(amor, l_fonc_f, para_napp))
# print 'nappe',l_nappe
self._lf = l_nappe
def _run(self):
"""MOYENNE"""
if self.typres is nappe_sdaster:
nap0 = self._lf[0]
vale_para = nap0.vale_para
para = nap0.para
l_fonc_f = []
for i in range(len(vale_para)):
self.ctxt.f = [nap.l_fonc[i].nom for nap in self._lf]
lfr = moyenne([nap.l_fonc[i] for nap in self._lf])
l_fonc_f.append(lfr)
self.resu = t_nappe(vale_para, l_fonc_f, para)
else:
self.resu = moyenne(self._lf)
def _run(self):
"""FRACTILE"""
fract = self.kw['FRACT']
if self.typres is nappe_sdaster:
nap0 = self._lf[0]
vale_para = nap0.vale_para
para = nap0.para
l_fonc_f = []
for i in range(len(vale_para)):
self.ctxt.f = [nap.l_fonc[i].nom for nap in self._lf]
lfr = fractile([nap.l_fonc[i] for nap in self._lf], fract)
l_fonc_f.append(lfr)
self.resu = t_nappe(vale_para, l_fonc_f, para)
else:
self.resu = fractile(self._lf, fract)
def _run(self):
"""ENVELOPPE"""
crit = self.kw['CRITERE']
if self.typres is nappe_sdaster:
nap0 = self._lf[0]
vale_para = nap0.vale_para
para = nap0.para
l_fonc_f = []
for i in range(len(vale_para)):
env = nap0.l_fonc[i]
for nap in self._lf[1:]:
self.ctxt.f = nap.l_fonc[i].nom
env = enveloppe([env, nap.l_fonc[i]], crit)
l_fonc_f.append(env)
self.resu = t_nappe(vale_para, l_fonc_f, para)
else:
self.resu = enveloppe(self._lf, crit)
def convert(self):
"""
Retourne un objet de la classe t_nappe, représentation python de la nappe
"""
from Cata_Utils.t_fonction import t_fonction, t_nappe
para = self.Parametres()
vale = self.Valeurs()
l_fonc = []
i = 0
for pf in para[1]:
para_f = {'INTERPOL': pf['INTERPOL_FONC'],
'PROL_DROITE': pf['PROL_DROITE_FONC'],
'PROL_GAUCHE': pf['PROL_GAUCHE_FONC'],
'NOM_PARA': para[0]['NOM_PARA_FONC'],
'NOM_RESU': para[0]['NOM_RESU'],
}
l_fonc.append(t_fonction(vale[1][i][0], vale[1][i][1], para_f))
i += 1
return t_nappe(vale[0], l_fonc, para[0], nom=self.nom)
def _run(self):
"""LISS_ENVELOP"""
kw = self.kw
l_sp_nappe = []
# formatage selon les donnes d'entrees
if kw['FONCTION'] != None:
f_in = self._lf[0]
if kw['LIST_AMOR'] != None:
amor = kw['LIST_AMOR'][0]
else:
amor = 0.
sp_nappe = LISS.nappe(listFreq=f_in.vale_x,
listeTable=[f_in.vale_y],
listAmor=[amor],
entete="")
para_fonc = f_in.para
para = f_in.para.copy()
# print 'para',para
para['NOM_PARA'] = 'AMOR'
para['NOM_PARA_FONC'] = para_fonc['NOM_PARA']
l_sp_nappe = [sp_nappe]
elif kw['NAPPE'] != None or kw['TABLE'] != None:
for i_nappe in range(len(self._lf)):
f_in = self._lf[i_nappe]
sp_nappe = LISS.nappe(
listFreq=f_in.l_fonc[0].vale_x,
listeTable=[f.vale_y for f in f_in.l_fonc],
listAmor=f_in.vale_para,
entete="")
# verification que les nappes ont les memes amortissements
if i_nappe == 0:
l_amor = f_in.vale_para
l_amor.sort()
erreur_amor = 0
else:
if len(l_amor) == len(f_in.vale_para):
l_amor2 = f_in.vale_para.copy()
l_amor2.sort()
d_amor = l_amor - l_amor2
if max(abs(d_amor)) > 1e-6: erreur_amor = 1
else:
erreur_amor = 1
if erreur_amor:
UTMESS('F', 'FONCT0_74')
l_sp_nappe.append(sp_nappe)
para_fonc = f_in.l_fonc[0].para
para = f_in.para
if kw['OPTION'] == 'CONCEPTION':
sp_lisse = LISS.liss_enveloppe(l_sp_nappe,
option=kw['OPTION'],
fmin=kw['FREQ_MIN'],
fmax=kw['FREQ_MAX'],
l_freq=list(kw['LIST_FREQ']),
nb_pts=kw['NB_FREQ_LISS'],
zpa=kw['ZPA'],
precision=1e-3,
critere='RELATIF')
else:
sp_lisse = LISS.liss_enveloppe(l_sp_nappe,
option=kw['OPTION'],
coef_elarg=kw['ELARG'],
fmin=kw['FREQ_MIN'],
fmax=kw['FREQ_MAX'],
l_freq=list(kw['LIST_FREQ']),
nb_pts=kw['NB_FREQ_LISS'],
zpa=kw['ZPA'],
precision=1e-3,
critere='RELATIF')
l_fonc_f = []
for spec in sp_lisse.listSpec:
l_fonc_f.append(
t_fonction(sp_lisse.listFreq, spec.dataVal, para_fonc))
self.resu = t_nappe(sp_lisse.listAmor, l_fonc_f, para)