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)