def _run(self):
"""DSP"""
kw = self.kw
f_in = self._lf[0]
vale_freq = f_in.vale_x
vale_sro = f_in.vale_y
f_min = f_in.vale_x[0]
f_in = t_fonction(NP.insert(vale_freq, 0, 0.0),
NP.insert(vale_sro, 0, 0.0),
para=f_in.para)
deuxpi = 2. * math.pi
freq_coup = kw['FREQ_COUP']
SRO_args = {
'DUREE_PHASE_FORTE': kw['DUREE'],
'FREQ_COUP': freq_coup,
'NORME': kw['NORME'],
'AMORT': kw['AMOR_REDUIT'],
'FMIN': f_min,
'FONC_SPEC': f_in
}
if kw['FREQ_PAS'] != None:
SRO_args['PAS'] = kw['FREQ_PAS']
elif kw['LIST_FREQ'] != None:
l_freq = kw['LIST_FREQ'].Valeurs()
if l_freq[0] <= 0.0:
UTMESS('F', 'FONCT0_43')
SRO_args['LIST_FREQ'] = l_freq
SRO_args['PAS'] = None
f_dsp, f_sro_ref = SRO2DSP(**SRO_args)
self.resu = t_fonction(f_dsp.vale_x / deuxpi,
f_dsp.vale_y * deuxpi,
para=f_in.para)
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 iter_SRO(f_dsp, f_sro, amort, TS):
# ---------------------------------------------
# IN : f_in: DSP [rad/s], sro : spectre cible [Hz],
# amort: amortissement sro, TS: duree phase forte, meme disretisation
# OUT : f_out: dsp apres iterations pour fitter au mieux le spectre sro
# ---------------------------------------------
para_dsp = f_dsp.para
freq_dsp = f_dsp.vale_x
vale_dsp = f_dsp.vale_y
freq_sro = f_sro.vale_x
vale_sro_ref = f_sro.vale_y
nbvale = len(freq_dsp)
Niter = 10
ii = 0
while ii < Niter:
ii = ii + 1
f_sroi = DSP2SRO(f_dsp, amort, TS, freq_sro)
valesro = f_sroi.vale_y
# calcul de la correction des DSP
nz = NP.nonzero(valesro)
factm = NP.ones(nbvale)
factm[nz] = vale_sro_ref[nz] / valesro[nz]
vale_dspi = vale_dsp * factm**2
vale_dsp = vale_dspi
f_dsp = t_fonction(freq_dsp, vale_dsp, para=para_dsp)
f_out = f_dsp
return f_out
def _run(self):
"""CORR_ACCE"""
f_in = self._lf[0]
kw = self.kw
para = f_in.para.copy()
assert kw['METHODE'] in ('FILTRAGE', 'POLYNOME')
if kw['METHODE'] == 'POLYNOME':
# suppression de la tendance de l accelero
fres = f_in.suppr_tend()
# calcul de la vitesse
fres = fres.trapeze(0.)
# calcul de la tendance de la vitesse : y = a1*x +a0
fres = fres.suppr_tend()
if self.kw['CORR_DEPL'] == 'OUI':
# suppression de la tendance deplacement
# calcul du deplacement : integration
fres = fres.trapeze(0.)
# calcul de la tendance du déplacement : y = a1*x +a0
fres = fres.suppr_tend()
# regeneration de la vitesse : derivation
fres = fres.derive()
# regeneration de l accelero : derivation
self.resu = fres.derive()
self.resu.para = para
elif kw['METHODE'] == 'FILTRAGE':
dt = f_in.vale_x[1] - f_in.vale_x[0]
acce_filtre = acce_filtre_CP(
f_in.vale_y,
dt,
kw['FREQ_FILTRE'],
)
self.resu = t_fonction(f_in.vale_x, acce_filtre, para)
def _run(self):
"""COHERENCE"""
Mm = self.kw['NB_FREQ_LISS']
FREQ_COUP = self.kw['FREQ_COUP']
para = {
'INTERPOL': ['LIN', 'LIN'],
'NOM_PARA': 'FREQ',
'PROL_DROITE': 'CONSTANT',
'PROL_GAUCHE': 'EXCLU',
'NOM_RESU': 'ACCE'
}
nap1 = self._lf[0]
assert nap1.para['NOM_PARA'] == 'NUME_ORDRE'
vale_para1 = nap1.vale_para
nap2 = self.kw['NAPPE_2']
vale_para2, lfonc2 = nap2.Valeurs()
assert len(vale_para1) == len(
vale_para2), 'NAPPE_1 and NAPPE_2 must have same length.'
assert set(vale_para2) == set(
vale_para1), 'Data lists are not ordered as pairs.'
acce1 = []
acce2 = []
for ii, fonc2 in enumerate(lfonc2):
lt = nap1.l_fonc[ii].vale_x
fonc1 = nap1.l_fonc[ii].vale_y
assert len(lt) == len(
fonc2[0]
), 'Signals with same length required for NUME_ORDRE ' + str(
vale_para1[ii])
assert (fonc2[0][1] -
fonc2[0][0]) == (lt[1] - lt[0]), 'same time steps required'
if self.kw['OPTION'] == "DUREE_PHASE_FORTE":
if ii == 0:
p1 = self.kw['BORNE_INF']
p2 = self.kw['BORNE_SUP']
N1, N2 = f_phase_forte(lt, fonc1, p1, p2)
UTMESS('I', 'SEISME_79', valr=(lt[N1], lt[N2]))
acce2.append(fonc2[1][N1:N2])
acce1.append(fonc1[N1:N2])
else:
acce2.append(fonc2[1])
acce1.append(fonc1)
acce1 = NP.array(acce1)
acce2 = NP.array(acce2)
dt = lt[1] - lt[0]
lfreq, fcohe = calc_cohefromdata(acce1, acce2, dt, Mm)
N1 = NP.searchsorted(lfreq, 0.0)
N2 = len(lfreq)
if FREQ_COUP != None:
if lfreq[-1] > FREQ_COUP:
N2 = NP.searchsorted(lfreq, FREQ_COUP)
print self.kw['FREQ_COUP'], N2
f_cohe = fcohe[N1:N2]
l_freq = lfreq[N1:N2]
self.resu = t_fonction(l_freq, f_cohe.real, para)
def ACCE2SROM(self, f_in, xig, l_freq, ideb, METHODE_SRO):
if METHODE_SRO == "NIGAM":
spectr = aster_fonctions.SPEC_OSCI(f_in.vale_x, f_in.vale_y, l_freq,
[xig])
vale_sro = spectr[0, ideb, :]
f_out = t_fonction(l_freq, vale_sro, para=self.para_sro)
elif METHODE_SRO == "HARMO":
f_out = ACCE2SRO(f_in, xig, l_freq, ideb=2)
else:
print "ERROR METHODE SRO"
return f_out
def RAND_DSP(MAT_CHOL, Nbf, f_dsp):
# ---------------------------------------------------------
# IN : f_dsp: DSP mediane
# MAT_CHOL : chol(COV) pour la liste Periods
# OUT: f_rand_dsp = f_dsp*rand_vec: realisation DSP aleatoire
# ---------------------------------------------------------
vale_dsp = f_dsp.vale_y
freq_dsp = f_dsp.vale_x
alpha2 = RAND_VEC(MAT_CHOL, Nbf, para=2.0)
rand_dsp = vale_dsp * alpha2
f_rand_dsp = t_fonction(freq_dsp, rand_dsp, para=f_dsp.para)
return f_rand_dsp
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 dsp_filtre_CP(f_in, fcorner, amoc=1.0):
# ---------------------------------------------------------
# IN : f_in: DSP (frequence rad/s),
# fcorner : corner frequency Hz,
# amoc: amortissement, l_freq: list of frequencies in Hz
# OUT: f_out: DSP filtre (frequence rad/s),
# attention: il faut de preference 2**N
# ---------------------------------------------------------
wcp = fcorner * 2. * pi
vale_freq = f_in.vale_x
vale_dsp = f_in.vale_y
HW = 1. / \
((wcp ** 2 - vale_freq ** 2) ** 2 +
4. * (amoc ** 2) * (wcp ** 2) * vale_freq ** 2)
dsp_out = vale_freq**4 * vale_dsp * HW
f_out = t_fonction(vale_freq, dsp_out, para=f_in.para)
return f_out
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 ACCE2SRO(f_in, xig, l_freq, ideb=2):
# ---------------------------------------------------------
# IN : f_in: ACCELEROGRAMME (signal temporel)
# xig: amortissement, l_freq: list of frequencies in Hz
# OUT: f_out: SRO for l_freq (Hz)
# attention: il faut de preference en 2**N
# ---------------------------------------------------------
para_sro = {
'INTERPOL': ['LIN', 'LIN'],
'NOM_PARA': 'FREQ',
'PROL_DROITE': 'CONSTANT',
'PROL_GAUCHE': 'EXCLU',
'NOM_RESU': 'ACCE',
}
vale_t = f_in.vale_x
vale_acce = f_in.vale_y
N = len(vale_t)
dt = vale_t[1] - vale_t[0]
# discrectisation
OM = pi / dt
dw = 2. * OM / N
N2 = N / 2 + 1
ws0 = NP.arange(0.0, (N2 + 1) * dw, dw)
ws = ws0[:N2]
vale_sro = []
im = csqrt(-1)
acce_in = NP.fft.fft(NP.array(vale_acce))
for fi in l_freq:
w_0 = fi * 2. * pi
hw2 = 1. / ((w_0**2 - ws**2) + 2. * xig * im * w_0 * ws)
liste_pairs = zip(hw2, acce_in[:N2])
Yw = [a * b for a, b in liste_pairs]
if is_even(N): # nombre pair
ni = 1
else: # nombre impair
ni = 0
for kk in range(N2 + 1, N + 1):
Yw.append(Yw[N2 - ni - 1].conjugate())
ni = ni + 1
acce_out = NP.fft.ifft(Yw).real
vale_sro.append(w_0**ideb * max(abs(acce_out)))
f_out = t_fonction(l_freq, vale_sro, para=para_sro)
return f_out
def _run(self):
"""REGR_POLYNOMIALE"""
f_in = self._lf[0]
deg = self.kw['DEGRE']
coef = NP.polyfit(f_in.vale_x, f_in.vale_y, deg)
if coef is None:
raise FonctionError("La régression polynomiale n'a pas convergé.")
# interpolation sur une liste d'abscisses
absc = f_in.vale_x
if self.args['LIST_PARA'] is not None:
absc = self.args['LIST_PARA'].Valeurs()
vale = NP.polyval(coef, absc)
# paramètres
para = f_in.para.copy()
para['INTERPOL'] = ['LIN', 'LIN']
self.resu = t_fonction(absc, vale, para)
coef_as_str = os.linesep.join([' a[%d] = %f' % (i, ci) \
for i, ci in enumerate(coef)])
UTMESS('I', 'FONCT0_57', coef_as_str)
def DSP2FR(f_dsp_refe, FC):
# ---------------------------------------------------------
# IN : f_spec: SRO cible en fonction de la frequence en Hz
#
# OUT: f_out: DSP FR fonction de la frequence(rad/s)
# ---------------------------------------------------------
from Utilitai.optimize import fmin
para_dsp = f_dsp_refe.para
lfreq = f_dsp_refe.vale_x
vale_dsp = f_dsp_refe.vale_y
m0, m1, m2, vop, deltau = Rice2(lfreq, vale_dsp)
# parametres initiales
# w0= vop*2.*pi
xi0 = deltau**(2. / 1.2) * pi / 4.
dsp_FR_ini = calc_dsp_FR(lfreq, vop, xi0, (vop * 2. * pi)**2,
4. * vop * pi * xi0, FC)
const_ini = 2. * NP.trapz(dsp_FR_ini, lfreq)
R0 = (vop * 2. * pi)**2 * sqrt(m0) / sqrt(const_ini)
R2 = 4. * vop * pi * xi0 * sqrt(m0) / sqrt(const_ini)
x0 = [R0, R2]
para_opt = fmin(f_opt_FR1, x0, args=(f_dsp_refe, vop, xi0, FC))
R0 = abs(para_opt[0])
R2 = abs(para_opt[1])
x0 = [vop, xi0]
para_opt = fmin(f_opt_FR2, x0, args=(f_dsp_refe, R0, R2, FC))
vop = para_opt[0]
xi0 = para_opt[1]
x0 = [R0, R2]
para_opt = fmin(f_opt_FR1, x0, args=(f_dsp_refe, vop, xi0, FC))
R0 = abs(para_opt[0])
R2 = abs(para_opt[1])
dsp_FR_fin = calc_dsp_FR(lfreq, vop, xi0, R0, R2, FC)
FIT = NP.ones(len(lfreq))
nz = NP.nonzero(dsp_FR_fin)
FIT[nz] = vale_dsp[nz] / dsp_FR_fin[nz]
f_fit = t_fonction(lfreq, FIT, para=para_dsp)
return vop, xi0, R0, R2, f_fit
def DSP2SRO(f_in, xig, TSM, liste_freq, ideb=2):
# ---------------------------------------------
# IN: f_in: DSP, function of frequency (rad/s),
# TSM: duree pase forte, xig: damping ratio
# liste_freq: list of freq SRO (Hz)
# OUT: f_out: SRO, function of frequency (Hz), same norm. as DSP
# ---------------------------------------------
para_dsp = f_in.para
vale_dsp_in = f_in.vale_y
vale_sro = []
vale_freq = f_in.vale_x
vale_freq2 = vale_freq**2
for f_0 in liste_freq:
if f_0 == 0.0:
vale_sro.append(0.0)
else:
w_0 = f_0 * 2. * pi
vale_dsp_rep = vale_dsp_in / \
((w_0 ** 2 - vale_freq2) ** 2 +
4. * xig ** 2 * w_0 ** 2 * vale_freq2)
npeakm, m0i = peakm(0.5, TSM, vale_freq, vale_dsp_rep)
vale_sro.append(w_0**ideb * npeakm * sqrt(m0i))
f_out = t_fonction(liste_freq, vale_sro, para=para_dsp)
return f_out
def itersimcortir_SRO(self, FONC_DSP, data_cohe, NB_TIR, **SRO_args):
# ---------------------------------------------
# IN : FONC_DSP: DSP [rad/s], FONC_SPEC: spectre cible [Hz],
# amort: amortissement sro, meme disretisation
# type_mod: type de fonction de modulation niter: nombre d'iterations,
# FMIN: fequence min pour fit et filtrage ("corner frequency" Hz)
# OUT : f_out: accelerogramme apres iterations pour fitter au mieux le spectre cible
# ---------------------------------------------
# dsp in
FMIN = SRO_args['FMIN']
amort = SRO_args['AMORT']
dico_err = SRO_args['DICO_ERR']
NB_ITER = SRO_args['NB_ITER']
dim = data_cohe['DIM']
# dsp initiale
para_dsp = FONC_DSP.para
freq_dsp = FONC_DSP.vale_x
vale_dsp = FONC_DSP.vale_y
nbfreq2 = len(freq_dsp)
nbfreq = 2 * nbfreq2
# sro cible
freq_sro = freq_dsp / (2. * pi)
vale_sro_ref = SRO_args['FONC_SPEC'].evalfonc(freq_sro).vale_y
# fonction de modulation
hmod = self.modulator.fonc_modul.vale_y
dt = self.sampler.DT
# FMIN pour le calcul de l'erreur relative
FMINM = max(FMIN, 0.1)
FC = max(self.FREQ_FILTRE, FMINM)
N1 = NP.searchsorted(freq_sro, FMINM) + 1
FRED = freq_sro[N1:]
ZPA = vale_sro_ref[-1]
vpsum = sum([err_listes[0] for err_listes in dico_err.values()])
coef_ZPA = dico_err['ERRE_ZPA'][0] / vpsum
coef_MAX = dico_err['ERRE_MAX'][0] / vpsum
coef_RMS = dico_err['ERRE_RMS'][0] / vpsum
# rv = NP.random.normal(0.0, 1., nbfreq) + \
# 1j * NP.random.normal(0.0, 1., nbfreq)
list_rv = []
ntir = 0
while ntir < NB_TIR:
rv = []
for kk in range(dim):
rv.append(
NP.random.normal(0.0, 1., nbfreq) +
1j * NP.random.normal(0.0, 1., nbfreq))
list_rv.append(rv)
ntir = ntir + 1
# INITIALISATION
errmult = []
l_dsp = [FONC_DSP]
liste_valesro = []
liste_Xt = []
for nbtir in range(NB_TIR):
Xt = DSP2ACCE_ND(FONC_DSP, data_cohe, list_rv[nbtir])
liste_Xt.extend(Xt)
for acce in liste_Xt:
acce = acce * hmod # modulation
if self.FREQ_FILTRE > 0.0:
acce = acce_filtre_CP(acce, dt, self.FREQ_FILTRE)
f_acce = t_fonction(self.sampler.liste_temps,
acce,
para=self.modulator.para_fonc_modul)
f_sroi = ACCE2SROM(self, f_acce, amort, freq_sro, 2,
SRO_args['METHODE_SRO'])
liste_valesro.append(f_sroi.vale_y)
if SRO_args['TYPE_ITER'] == 'SPEC_MEDIANE':
valesro = NP.median(NP.array(liste_valesro), axis=0)
elif SRO_args['TYPE_ITER'] == 'SPEC_MOYENNE':
valesro = NP.mean(NP.array(liste_valesro), axis=0)
l_sro = [valesro]
err_zpa, err_max, err_min, err_rms, freq_err = erre_spectre(
FRED, valesro[N1:], vale_sro_ref[N1:])
# erreur multiobjectif
err_ZPA = coef_ZPA * err_zpa
err_MAX = coef_MAX * err_max
err_RMS = coef_RMS * err_rms
errmult.append(sqrt(1. / 3. * (err_ZPA**2 + err_MAX**2 + err_RMS**2)))
if self.INFO == 2:
UTMESS('I', 'SEISME_43', valr=(err_zpa, err_max, err_rms, errmult[-1]))
# ITERATIONS
for kk in range(NB_ITER):
# CALCUL CORRECTION des DSP et mise a jour f_dsp
nz = NP.nonzero(valesro)
factm = NP.ones(nbfreq2)
factm[nz] = vale_sro_ref[nz] / valesro[nz]
vale_dspi = vale_dsp * factm**2
# vale_dsp[N1:]= vale_dspi[N1:]
vale_dsp = vale_dspi
f_dsp = t_fonction(freq_dsp, vale_dsp, para=para_dsp)
f_dsp = dsp_filtre_CP(f_dsp, FC)
l_dsp.append(f_dsp)
# ITERATION DSP ACCE
liste_valesro = []
liste_Xt = []
for nbtir in range(NB_TIR):
Xt = DSP2ACCE_ND(f_dsp, data_cohe, list_rv[nbtir])
liste_Xt.extend(Xt)
for acce in liste_Xt:
acce = acce * hmod # modulation
if self.FREQ_FILTRE > 0.0:
acce = acce_filtre_CP(acce, dt, self.FREQ_FILTRE)
f_acce = t_fonction(self.sampler.liste_temps,
acce,
para=self.modulator.para_fonc_modul)
f_sroi = ACCE2SROM(self, f_acce, amort, freq_sro, 2,
SRO_args['METHODE_SRO'])
liste_valesro.append(f_sroi.vale_y)
if SRO_args['TYPE_ITER'] == 'SPEC_MEDIANE':
valesro = NP.median(NP.array(liste_valesro), axis=0)
elif SRO_args['TYPE_ITER'] == 'SPEC_MOYENNE':
valesro = NP.mean(NP.array(liste_valesro), axis=0)
# CALCUL DES ERREURS
l_sro.append(valesro)
err_zpa, err_max, err_min, err_rms, freq_err = erre_spectre(
FRED, valesro[N1:], vale_sro_ref[N1:])
# erreur multionjectif
err_ZPA = coef_ZPA * err_zpa
err_MAX = coef_MAX * err_max
err_RMS = coef_RMS * err_rms
errmult.append(sqrt(1. / 3. * (err_ZPA**2 + err_MAX**2 + err_RMS**2)))
if self.INFO == 2:
UTMESS('I', 'SEISME_42', vali=(kk + 1, NB_ITER), valr=errmult[-1])
# OPTIMUM
ind_opt = NP.argmin(NP.array(errmult))
f_dsp_opt = l_dsp[ind_opt]
valesro_opt = l_sro[ind_opt]
err_zpa, err_max, err_min, err_rms, freq_err = erre_spectre(
FRED, valesro_opt[N1:], vale_sro_ref[N1:])
dico_err['ERRE_ZPA'].append(err_zpa)
dico_err['ERRE_MAX'].append(err_max)
dico_err['ERRE_RMS'].append(err_rms)
if self.INFO == 2:
UTMESS('I',
'SEISME_41',
vali=ind_opt,
valr=(errmult[ind_opt], err_max, freq_err[0], err_min,
freq_err[1], err_zpa, err_rms))
for keys, listev in dico_err.items():
tole = listev[1] * 100.
erre = abs(listev[-1])
if abs(erre) > tole:
nbi = ind_opt
UTMESS('A', 'SEISME_36', vali=nbi, valk=keys, valr=(erre, tole))
return f_dsp_opt, list_rv
def info_fonction_ops(self, RMS, NOCI_SEISME, MAX, NORME, ECART_TYPE, INFO,
**args):
"""
Ecriture de la macro INFO_FONCTION
"""
ier = 0
from Cata_Utils.t_fonction import t_fonction, t_fonction_c, t_nappe
import math
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
import numpy as NP
from Utilitai.Table import Table
# On importe les definitions des commandes a utiliser dans la macro
CREA_TABLE = self.get_cmd('CREA_TABLE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
CALC_FONCTION = self.get_cmd('CALC_FONCTION')
# Comptage commandes + déclaration concept sortant
self.set_icmd(1)
self.DeclareOut('C_out', self.sd)
# type de traitement
#
if (MAX != None):
# liste des t_fonction
l_cofonc = MAX['FONCTION']
if type(l_cofonc) not in (list, tuple):
l_cofonc = [
l_cofonc,
]
l_fonc = [concept.convert() for concept in l_cofonc]
# intervalles
mc_interv = MAX['INTERVALLE']
with_intervalle = mc_interv is not None
interv = []
if with_intervalle:
nbv = len(mc_interv)
if nbv % 2 != 0:
UTMESS('F', 'FONCT0_55')
tint = NP.array(mc_interv)
tint.shape = (nbv / 2, 2)
dx = tint[:, 1] - tint[:, 0]
if min(dx) < 0.:
UTMESS('F', 'FONCT0_56')
interv = tint.tolist()
# vérifications de cohérence
typobj = set()
npara = set()
nparf = set()
nresu = set()
l_nom = []
for tf in l_fonc:
typobj.add(tf.__class__)
npara.add(tf.para['NOM_PARA'])
nparf.add(tf.para.get('NOM_PARA_FONC'))
nresu.add(tf.para['NOM_RESU'])
l_nom.append(tf.nom)
if len(typobj) > 1:
# types (fonction, fonction_c, nappe) non homogènes
UTMESS('F', 'FONCT0_37')
is_nappe = typobj.pop() is t_nappe
if len(npara) > 1:
# NOM_PARA non homogènes
UTMESS('F', 'FONCT0_38', valk=' '.join(npara))
if len(nparf) > 1:
# NOM_PARA_FONC non homogènes
UTMESS('F', 'FONCT0_38', valk=' '.join(nparf))
if len(nresu) > 1:
# NOM_RESU non homogènes
UTMESS('F', 'FONCT0_39', valk=' '.join(nresu))
# nom des paramètres et leurs types
k_para = npara.pop()
k_parf = nparf.pop()
k_ordo = nresu.pop()
k_min = k_para + "_MIN"
k_max = k_para + "_MAX"
ordered_params = ['FONCTION', 'TYPE']
ordered_type = ['K8', 'K8']
if with_intervalle:
ordered_params.extend(['INTERVALLE', k_min, k_max])
ordered_type.extend(['I', 'R', 'R'])
ordered_params.append(k_para)
ordered_type.append('R')
if is_nappe:
ordered_params.append(k_parf)
ordered_type.append('R')
ordered_params.append(k_ordo)
ordered_type.append('R')
# boucle sur les fonctions, intervalles, min/max, extrema
_type = {'min': 'MINI', 'max': 'MAXI'}
_PREC = 1.e-6
tab = Table(para=ordered_params, typ=ordered_type)
for tf in l_fonc:
if not with_intervalle:
if not is_nappe:
interv = [
[float(min(tf.vale_x)),
float(max(tf.vale_x))],
]
else:
interv = [
[-1.e-300, 1.e300],
]
for num_int, bornes in enumerate(interv):
x1, x2 = bornes
if not is_nappe:
stf = tf.cut(x1, x2, _PREC, nom=tf.nom)
else:
stf = tf
extrema = stf.extreme()
for key in ('min', 'max'):
nb = len(extrema[key])
for i in range(nb):
line = {
'FONCTION': tf.nom,
'TYPE': _type[key],
k_para: extrema[key][i][0]
}
if is_nappe:
line.update({
k_parf: extrema[key][i][1],
k_ordo: extrema[key][i][2]
})
else:
line.update({k_ordo: extrema[key][i][1]})
if with_intervalle:
line.update({
'INTERVALLE': num_int + 1,
k_min: x1,
k_max: x2
})
tab.append(line)
tab.titr = "Extrema de " + ', '.join(l_nom)
# table résultat
dprod = tab.dict_CREA_TABLE()
C_out = CREA_TABLE(**dprod)
#
if (ECART_TYPE != None):
__ff = ECART_TYPE['FONCTION'].convert()
if ECART_TYPE['INST_INIT'] != None:
tini = ECART_TYPE['INST_INIT']
else:
tini = __ff.vale_x[0]
if ECART_TYPE['INST_FIN'] != None:
tfin = ECART_TYPE['INST_FIN']
else:
tfin = __ff.vale_x[-1]
__ff = __ff.cut(tini, __ff.vale_x[-1], ECART_TYPE['PRECISION'],
ECART_TYPE['CRITERE'])
__ff = __ff.cut(__ff.vale_x[0], tfin, ECART_TYPE['PRECISION'],
ECART_TYPE['CRITERE'])
if ECART_TYPE['METHODE'] == 'SIMPSON':
__ex = __ff.simpson(0.)
if ECART_TYPE['METHODE'] == 'TRAPEZE':
__ex = __ff.trapeze(0.)
fmoy = __ex.vale_y[-1] / (__ff.vale_x[-1] - __ff.vale_x[0])
__ff = __ff + (-1 * fmoy)
__ff = __ff * __ff
if ECART_TYPE['METHODE'] == 'SIMPSON':
__ez = __ff.simpson(0.)
if ECART_TYPE['METHODE'] == 'TRAPEZE':
__ez = __ff.trapeze(0.)
sigma = math.sqrt(__ez.vale_y[-1] / (__ff.vale_x[-1] - __ff.vale_x[0]))
C_out = CREA_TABLE(LISTE=(
_F(LISTE_K=ECART_TYPE['FONCTION'].nom, PARA='FONCTION'),
_F(LISTE_K=ECART_TYPE['METHODE'], PARA='METHODE'),
_F(LISTE_R=fmoy, PARA='MOYENNE'),
_F(LISTE_R=sigma, PARA='ECART_TYPE'),
_F(LISTE_R=tini, PARA='INST_INIT'),
_F(LISTE_R=tfin, PARA='INST_FIN'),
))
#
if (RMS != None):
RMS = list(RMS)
sigm = []
tmpi = []
tmpf = []
nomf = []
meth = []
for i_rms in RMS:
__ff = i_rms['FONCTION'].convert()
if i_rms['INST_INIT'] != None:
tini = i_rms['INST_INIT']
else:
tini = __ff.vale_x[0]
if i_rms['INST_FIN'] != None:
tfin = i_rms['INST_FIN']
else:
tfin = __ff.vale_x[-1]
__ff = __ff.cut(tini, __ff.vale_x[-1], i_rms['PRECISION'],
i_rms['CRITERE'])
__ff = __ff.cut(__ff.vale_x[0], tfin, i_rms['PRECISION'],
i_rms['CRITERE'])
__ff = __ff * __ff
if i_rms['METHODE'] == 'SIMPSON':
__ez = __ff.simpson(0.)
if i_rms['METHODE'] == 'TRAPEZE':
__ez = __ff.trapeze(0.)
sigm.append(
math.sqrt(__ez.vale_y[-1] /
(__ff.vale_x[-1] - __ff.vale_x[0])))
tmpi.append(tini)
tmpf.append(tfin)
nomf.append(i_rms['FONCTION'].nom)
meth.append(i_rms['METHODE'])
C_out = CREA_TABLE(LISTE=(
_F(LISTE_K=nomf, PARA='FONCTION'),
_F(LISTE_K=meth, PARA='METHODE'),
_F(LISTE_R=tmpi, PARA='INST_INIT'),
_F(LISTE_R=tmpf, PARA='INST_FIN'),
_F(LISTE_R=sigm, PARA='RMS'),
))
#
if (NORME != None):
__ff = NORME['FONCTION'].convert()
norme = []
for __fi in __ff.l_fonc:
norme.append(__fi.normel2())
nom = [
NORME['FONCTION'].nom,
] * len(norme)
C_out = CREA_TABLE(LISTE=(
_F(LISTE_R=norme, PARA='NORME'),
_F(LISTE_K=nom, PARA='FONCTION'),
))
#
if (NOCI_SEISME != None):
l_table = []
if NOCI_SEISME['SPEC_OSCI'] != None:
# cas intensité spectrale d'une nappe de SRO
# la seule option licite est INTE_SPEC
# intensite spectrale, il est prudent de verifier la norme de la nappe sur laquelle \
# porte le calcul, ceci peut etre une source d erreurs.''')
UTMESS('I', 'FONCT0_40')
amor = NOCI_SEISME['AMOR_REDUIT']
fini = NOCI_SEISME['FREQ_INIT']
ffin = NOCI_SEISME['FREQ_FIN']
__sp = NOCI_SEISME['SPEC_OSCI'].convert()
vale_x = __sp.l_fonc[0].vale_x
vale_y = [__sp(amor, f) for f in vale_x]
para = __sp.l_fonc[0].para
__srov = t_fonction(vale_x, vale_y, para)
if NOCI_SEISME['NATURE'] == 'DEPL':
__srov.vale_y = (__srov.vale_y / __srov.vale_x) * 2. * math.pi
elif NOCI_SEISME['NATURE'] == 'VITE':
__srov.vale_y = __srov.vale_y / __srov.vale_x / __srov.vale_x
elif NOCI_SEISME['NATURE'] == 'ACCE':
__srov.vale_y = __srov.vale_y / __srov.vale_x / __srov.vale_x
__srov.vale_y = __srov.vale_y / __srov.vale_x / 2. / math.pi
__srov = __srov.cut(fini, ffin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
insp = __srov.trapeze(0.).vale_y[-1]
l_table.append(_F(LISTE_R=fini, PARA='FREQ_INIT'))
l_table.append(_F(LISTE_R=ffin, PARA='FREQ_FIN'))
l_table.append(_F(LISTE_R=amor, PARA='AMOR_REDUIT'))
l_table.append(_F(LISTE_R=insp, PARA='INTE_SPECT'))
if NOCI_SEISME['FONCTION'] != None:
# cas fonction
l_table.append(
_F(LISTE_K=NOCI_SEISME['FONCTION'].nom, PARA='FONCTION'))
__ac = NOCI_SEISME['FONCTION'].convert()
option = NOCI_SEISME['OPTION']
if NOCI_SEISME['INST_INIT'] != None:
tdeb = NOCI_SEISME['INST_INIT']
else:
tdeb = __ac.vale_x[0]
if NOCI_SEISME['INST_FIN'] != None:
tfin = NOCI_SEISME['INST_FIN']
else:
tfin = __ac.vale_x[-1]
# calcul de la vitesse :
__vi = __ac.trapeze(NOCI_SEISME['COEF'])
# calcul du déplacement :
__de = __vi.trapeze(NOCI_SEISME['COEF'])
# calcul de |acceleration| :
__aa = __ac.abs()
# calcul de integrale(|acceleration|) :
# on "coupe" la fonction entre tdeb et tfin
__ac = __ac.cut(tdeb, tfin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
__vi = __vi.cut(tdeb, tfin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
__de = __de.cut(tdeb, tfin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
__aa = __aa.cut(tdeb, tfin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
if NOCI_SEISME['FREQ'] != None:
l_freq = NOCI_SEISME['FREQ']
elif NOCI_SEISME['LIST_FREQ'] != None:
l_freq = NOCI_SEISME['LIST_FREQ'].Valeurs()
else:
# fréquences par défaut
l_freq = []
for i in range(56):
l_freq.append(0.2 + 0.050 * i)
for i in range(8):
l_freq.append(3.0 + 0.075 * i)
for i in range(14):
l_freq.append(3.6 + 0.100 * i)
for i in range(24):
l_freq.append(5.0 + 0.125 * i)
for i in range(28):
l_freq.append(8.0 + 0.250 * i)
for i in range(6):
l_freq.append(15.0 + 0.500 * i)
for i in range(4):
l_freq.append(18.0 + 1.000 * i)
for i in range(10):
l_freq.append(22.0 + 1.500 * i)
if option in ('TOUT', 'MAXI', 'ACCE_SUR_VITE'):
# calcul du max des valeurs absolues
maxa_ac = __ac.abs().extreme()['max'][0][1]
maxa_vi = __vi.abs().extreme()['max'][0][1]
maxa_de = __de.abs().extreme()['max'][0][1]
l_table.append(_F(LISTE_R=maxa_ac, PARA='ACCE_MAX'))
l_table.append(_F(LISTE_R=maxa_vi, PARA='VITE_MAX'))
l_table.append(_F(LISTE_R=maxa_de, PARA='DEPL_MAX'))
l_table.append(
_F(LISTE_R=maxa_ac / maxa_vi, PARA='ACCE_SUR_VITE'))
if option in ('TOUT', 'INTE_ARIAS'):
__a2 = __ac * __ac
inte_arias = __a2.trapeze(0.).vale_y[-1]
inte_arias = inte_arias * math.pi / \
NOCI_SEISME['PESANTEUR'] / 2.
l_table.append(_F(LISTE_R=inte_arias, PARA='INTE_ARIAS'))
if option in ('TOUT', 'POUV_DEST'):
__v2 = __vi * __vi
pouv_dest = __v2.trapeze(0.).vale_y[-1]
pouv_dest = pouv_dest * \
(math.pi) ** 3 / NOCI_SEISME['PESANTEUR'] / 2.
l_table.append(_F(LISTE_R=pouv_dest, PARA='POUV_DEST'))
if option in ('TOUT', 'VITE_ABSO_CUMU'):
__vc = __aa.trapeze(0.)
vite_abso = __vc.vale_y[-1]
l_table.append(_F(LISTE_R=vite_abso, PARA='VITE_ABSO_CUMU'))
if option in ('TOUT', 'ASA'):
amor = NOCI_SEISME['AMOR_REDUIT']
freq_osci = NOCI_SEISME['FREQ_FOND']
ratio = NOCI_SEISME['RATIO']
freq_pas = NOCI_SEISME['FREQ_PAS']
f_ini = (1 - ratio) * freq_osci
liste_freq = NP.arange(f_ini, freq_osci + freq_pas, freq_pas)
__so = CALC_FONCTION(SPEC_OSCI=_F(
NATURE='ACCE',
NATURE_FONC='ACCE',
FONCTION=NOCI_SEISME['FONCTION'],
METHODE='NIGAM',
NORME=NOCI_SEISME['NORME'],
FREQ=liste_freq,
AMOR_REDUIT=(amor, )), )
__srov = __so.convert().l_fonc[0]
ASA_R = 1. / \
(ratio * freq_osci) * NP.trapz(
__srov.vale_y, __srov.vale_x)
l_table.append(_F(LISTE_R=ASA_R, PARA='ASA'))
l_table.append(_F(LISTE_R=ratio, PARA='RATIO'))
if option == 'ASA':
l_table.append(_F(LISTE_R=amor, PARA='AMOR_REDUIT'))
if option in ('TOUT', 'INTE_SPEC'):
amor = NOCI_SEISME['AMOR_REDUIT']
fini = NOCI_SEISME['FREQ_INIT']
ffin = NOCI_SEISME['FREQ_FIN']
__so = CALC_FONCTION(SPEC_OSCI=_F(
NATURE='VITE',
NATURE_FONC='ACCE',
FONCTION=NOCI_SEISME['FONCTION'],
METHODE='NIGAM',
NORME=NOCI_SEISME['NORME'],
FREQ=l_freq,
AMOR_REDUIT=(amor, )), )
__srov = __so.convert().l_fonc[0]
__srov = __srov.cut(fini, ffin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
__srov.vale_y = __srov.vale_y / __srov.vale_x / __srov.vale_x
insp = __srov.trapeze(0.).vale_y[-1]
l_table.append(_F(LISTE_R=fini, PARA='FREQ_INIT'))
l_table.append(_F(LISTE_R=ffin, PARA='FREQ_FIN'))
l_table.append(_F(LISTE_R=amor, PARA='AMOR_REDUIT'))
l_table.append(_F(LISTE_R=insp, PARA='INTE_SPECT'))
if option in ('TOUT', 'DUREE_PHAS_FORT'):
__a2 = __ac * __ac
__i2 = __a2.trapeze(0.)
arias = __i2.vale_y[-1] * math.pi / NOCI_SEISME[
'PESANTEUR'] / 2.
valinf = arias * NOCI_SEISME['BORNE_INF']
valsup = arias * NOCI_SEISME['BORNE_SUP']
for i in range(len(__i2.vale_x)):
ariask = __i2.vale_y[i] * math.pi / NOCI_SEISME[
'PESANTEUR'] / 2.
if ariask >= valinf:
break
for j in range(len(__i2.vale_x) - 1, -1, -1):
ariask = __i2.vale_y[j] * math.pi / NOCI_SEISME[
'PESANTEUR'] / 2.
if ariask <= valsup:
break
dphfor = __i2.vale_x[j] - __i2.vale_x[i]
l_table.append(_F(LISTE_R=dphfor, PARA='DUREE_PHAS_FORT'))
C_out = CREA_TABLE(LISTE=l_table)
if INFO > 1:
IMPR_TABLE(UNITE=6, TABLE=C_out)
return ier
def SRO2DSP(FREQ_COUP,
DUREE_PHASE_FORTE,
FONC_SPEC,
AMORT,
FMIN,
NORME,
PAS=None,
LIST_FREQ=None,
**args):
# ---------------------------------------------
# f_in : SRO cible, frequency given in (Hz)
# f_out: DSP compatible avec SRO, frequency list lw in (rad/s)
# ---------------------------------------------
wmax = FREQ_COUP * 2. * pi
f_in = FONC_SPEC
fmin = max(FMIN, 0.05)
wmin = fmin * 2. * pi
# wmin=1.001
freq0 = 0.0
freqi = freq0
DSP = [0.0]
lw = [freq0]
lf = [freq0]
lsro = [0.0]
# Sa_min=float(f_in.evalfonc([fmin]).vale_y*NORME)
# nupi=peak(0.5, TSM, fmin , AMORT)
# DSP_min=Sa_min**2*2.*AMORT/(wmin*nupi**2)
# dsp_p= DSP_min/ wmin
ii = 0
while freqi < wmax:
if PAS != None:
freqi = freqi + PAS * 2. * pi
else:
if ii < len(LIST_FREQ):
freqi = LIST_FREQ[ii] * 2. * pi
ii = ii + 1
else:
freqi = wmax
if freqi <= wmin:
assert freqi > 0.0
fi = freqi / 2. / pi
# valsro=float(f_in.evalfonc([fi]).vale_y*NORME)
# lsro.append(valsro)
lsro.append(0.0)
# valg = freqi*dsp_p
DSP.append(0.0)
else:
fi = freqi / 2. / pi
valsro = float(f_in.evalfonc([fi]).vale_y * NORME)
lsro.append(valsro)
nupi = peak(0.5, DUREE_PHASE_FORTE, fi, AMORT)
nup2 = nupi**2
v1 = 1. / (freqi * (pi / (2. * AMORT) - 2.))
v2 = (valsro**2) / nup2
v3 = 2. * NP.trapz(NP.array(DSP), NP.array(lw))
v4 = v1 * (v2 - v3)
valg = max(v4, 0.)
DSP.append(valg)
lw.append(freqi)
lf.append(freqi / 2. / pi)
f_out = t_fonction(lw, DSP, para=f_in.para)
# iteration sans simulation: formule de rice
f_iter_sro_ref = t_fonction(lf, lsro, para=f_in.para)
# PSA for frequency list lw (rad/s), physical units (not g)!!
f_dsp = iter_SRO(f_out, f_iter_sro_ref, AMORT, DUREE_PHASE_FORTE)
return f_dsp, f_iter_sro_ref
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)
