my_ctime = ctime_nproc[my_idx[0]] my_h1 = strain1_nproc[my_idx[0]] my_l1 = strain2_nproc[my_idx[0]] my_endtime = my_ctime[-1] ########################### data massage 3 ################################# # FILTERING/SIMULATING & FFTing THE DATA; PREPPING IT FOR MAPPING print 'filtering, ffting & saving the strains...' # Fourier space objects: Nt optimal timestream length; freqs frequency array at chosen fs Nt = len(my_h1) Nt = lf.bestFFTlength(Nt) freqs = np.fft.rfftfreq(2*Nt, 1./fs) freqs = freqs[:Nt/2+1] # frequency mask mask = (freqs>low_f) & (freqs < high_f) # repackage the strains & copy them (fool-proof); create empty array for the filtered, FFTed, correlated data strains = (my_h1,my_l1) strains_copy = (my_h1.copy(),my_l1.copy()) #calcualte psds from these
def filter(self,strain_in,low_f,high_f, hf_psd, simulate = False): fs=self.fs dt=1./fs '''WINDOWING & RFFTING.''' Nt = len(strain_in) Nt = lf.bestFFTlength(Nt) strain_in = strain_in[:Nt] strain_in_nowin = np.copy(strain_in) strain_in_nowin *= signal.tukey(Nt,alpha=0.05) strain_in *= np.blackman(Nt) freqs = np.fft.rfftfreq(2*Nt, dt) #print '=rfft=' hf = np.fft.rfft(strain_in, n=2*Nt)#, norm = 'ortho') hf_nowin = np.fft.rfft(strain_in_nowin, n=2*Nt)#, norm = 'ortho') #print '++' hf = hf[:Nt/2+1] hf_nowin = hf_nowin[:Nt/2+1] freqs = freqs[:Nt/2+1] '''the PSD. ''' #Pxx, frexx = mlab.psd(strain_in_nowin, Fs=fs, NFFT=2*fs,noverlap=fs/2,window=np.blackman(2*fs),scale_by_freq=True) #hf_psd = interp1d(frexx,Pxx) #hf_psd_data = abs(hf_nowin.copy()*np.conj(hf_nowin.copy())/(fs**2)) #if sim: return simulated noise # strain_in = sim noise #Norm #mask = (freqs>low_f) & (freqs < high_f) #norm = np.mean(hf_psd_data[mask])/np.mean(hf_psd(freqs)[mask]) #print norm #hf_psd=interp1d(frexx,Pxx*norm) '''NOTCHING. ''' hf_in = hf.copy() notch_fs = np.array([14.0,34.70, 35.30, 35.90, 36.70, 37.30, 40.95, 60.00, 120.00, 179.99, 304.99, 331.49, 510.02, 1009.99]) sigma_fs = np.array([.5,.5,.5,.5,.5,.5,.5,1.,1.,1.,1.,5.,5.,1.]) #np.array([0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.5,0.3,0.2]) samp_hz = fs**2*(len(hf))**(-1.)-6.68 #correction due to? pixels = np.arange(len(hf)) #hf_psd = abs(hf_win.copy())**2 #hf_psd_in = hf_psd.copy() i = 0 while i < len(notch_fs): notch_pix = int(notch_fs[i]*samp_hz) hf_nowin = hf_nowin*(1.-self.gaussian(pixels,notch_pix,sigma_fs[i]*samp_hz)) i+=1 #FITTING PSD. ffit(self,f,a,b,c,d,e) #cropping: #mask = np.ones(len(freqs),dtype=bool) #for (j,notch) in enumerate(notch_fs): # for (i,f) in enumerate(freqs): # if abs(f-notch) < 1.: mask[i] = False #low_f = 50. #high_f = 350. # for (f,hfi,bo) in zip(freqs[low_f*int(samp_hz):high_f*int(samp_hz)],hf_psd[low_f*int(samp_hz):high_f*int(samp_hz)],mask[low_f*int(samp_hz):high_f*int(samp_hz)]): # if bo == True: # freqscut.append(f) # hf_psdcut.append(hfi) #psd_params, psd_cov = curve_fit(self.ffit2,freqscut,hf_psdcut,p0=(40.,200.,3.21777e-44)) #fitted = np.array(self.ffit2(freqs[1:],psd_params[0],psd_params[1],psd_params[2])) #BPING HF gauss_lo = self.halfgaussian(pixels,low_f*samp_hz,samp_hz) gauss_hi = self.halfgaussian(pixels,high_f*samp_hz,samp_hz) hf_nbped = hf_nowin*(1.-gauss_lo)*(gauss_hi) # whitening: transform to freq domain, divide by asd # remember: interp_psd is strain/rtHz # white_hf = hf_nbped/(np.sqrt(hf_psd(freqs)/2./dt))#hf_psd_in[1:] # white_hf[0] = 0. # white_hf[-1:] = 0. #white_hf_bp = white_hf*self.g_butt(freqs,3) #hf_inv = np.fft.irfft(white_hf, n=Nt) # index = [idx, dect] # return hf_nbped#, hf_psd
def PSD_params(strain1, low_f, high_f, run_name): Nt = len(strain1) Nt = lf.bestFFTlength(Nt) fs = 4096 dt = 1. / fs freqs = np.fft.rfftfreq(Nt, 1. / fs) # frequency mask mask = (freqs > low_f) & (freqs < high_f) strain_in_1 = strain1 '''WINDOWING & RFFTING.''' Nt = len(strain_in_1) Nt = lf.bestFFTlength(Nt) strain_in = strain_in_1[:Nt] strain_in_cp = np.copy(strain_in) strain_in_nowin = np.copy(strain_in) strain_in_nowin *= signal.tukey(Nt, alpha=0.05) strain_in_cp *= signal.tukey(Nt, alpha=0.05) freqs = np.fft.rfftfreq(Nt, dt) hf_nowin = np.fft.rfft(strain_in_nowin, n=Nt, norm='ortho') #####!HERE! 03/03/18 ##### fstar = fs Psd_data = abs(hf_nowin.copy() * np.conj(hf_nowin.copy())) mask = (freqs > low_f) & (freqs < high_f) if high_f < 300. or low_f < 30.: masxx = (freqs > 30.) & (freqs < 300.) else: masxx = (freqs > low_f) & (freqs < high_f) freqs_cp = np.copy(freqs) Psd_cp = np.copy(Psd_data) freqs_cp = freqs_cp[masxx] Psd_cp = Psd_cp[masxx] freqs_notch, Psd_notch = Pdx_notcher(freqs_cp, Psd_cp, run_name) freqcp = np.copy(freqs_notch) Pscp = np.copy(Psd_notch) try: fit = curve_fit(PDX, freqcp, Pscp) #, bounds = ([0.,0.,0.],[2.,2.,2.])) psd_params = fit[0] except RuntimeError: print myid, "Error - curve_fit failed" psd_params = [10., 10., 10.] # plt.figure() # # plt.loglog(freqs[mask], np.abs(hf_nowin[mask])**2, label = 'nowin PSD') # plt.loglog(freqs[mask], hf_psd(freqs[mask])*1., label = 'mlab PSD') # # plt.loglog(frexcp, Pxcp, label = 'notchy PSD') # # plt.loglog(frexx[masxx],PDX(frexx,a,b,c)[masxx], label = 'notched pdx fit') # plt.legend() # plt.show() # plt.figure() # # plt.loglog(freqs[mask], np.abs(hf_nowin[mask])**2, label = 'nowin PSD') # plt.loglog(freqs[mask], hf_psd(freqs[mask])*1., label = 'mlab PSD') # # plt.loglog(frexcp, Pxcp, label = 'notchy PSD') # # plt.loglog(frexx[masxx],PDX(frexx,a,b,c)[masxx], label = 'notched pdx fit') # plt.legend() # plt.savefig('seg.png') return psd_params
def injector(self,strains_in,low_f,high_f, sim = False): fs=self.fs dt=1./fs Nt = len(strains_in[0]) Nt = lf.bestFFTlength(Nt) freqs = np.fft.rfftfreq(2*Nt, dt) freqs = freqs[:Nt/2+1] #print '+sim+' psds = [] faketot = [] if sim == True: #simulates streams for all detectors called when T.scope was initialised fakestreams = self.sim_tstreams(freqs) for (idx_det,strain_in) in enumerate(strains_in): '''WINDOWING & RFFTING.''' strain_in = strain_in[:Nt] strain_in_nowin = np.copy(strain_in) strain_in_nowin *= signal.tukey(Nt,alpha=0.05) strain_in *= np.blackman(Nt) hf = np.fft.rfft(strain_in, n=2*Nt)#, norm = 'ortho') hf_nowin = np.fft.rfft(strain_in_nowin, n=2*Nt)#, norm = 'ortho') hf = hf[:Nt/2+1] hf_nowin = hf_nowin[:Nt/2+1] '''the PSD. ''' Pxx, frexx = mlab.psd(strain_in_nowin, Fs=fs, NFFT=2*fs,noverlap=fs/2,window=np.blackman(2*fs),scale_by_freq=True) hf_psd = interp1d(frexx,Pxx) hf_psd_data = abs(hf_nowin.copy()*np.conj(hf_nowin.copy())/(fs**2)) #Norm mask = (freqs>low_f) & (freqs < high_f) norm = np.mean(hf_psd_data[mask])/np.mean(hf_psd(freqs)[mask]) #print norm hf_psd=interp1d(frexx,Pxx*norm) psds.append(hf_psd) #print frexx, Pxx, len(Pxx) #Pxx, frexx = mlab.psd(strain_in_win[:Nt], Fs = fs, NFFT = 4*fs, window = mlab.window_none) # plt.figure() # plt.loglog(freqs,np.sqrt(hf_psd_data), color = 'r') # plt.loglog(frexx,np.sqrt(Pxx), alpha = 0.5) # #plt.loglog(freqs,np.sqrt(hf_psd(freqs)), color = 'g') #(freqs) # #plt.ylim([-100.,100.]) # plt.savefig('pxx.png' ) if sim == True: rands = [np.random.normal(loc = 0., scale = 1. , size = len(hf_psd_data)),np.random.normal(loc = 0., scale = 1. , size = len(hf_psd_data))] fakenoise = rands[0]+1.j*rands[1] fake_psd = hf_psd(freqs)*self.fs**2 fakenoise = np.array(fakenoise*np.sqrt(fake_psd/2.))#np.sqrt(self.fs/2.)#part of the normalization fake = np.sum([fakenoise,fakestreams[idx_det]], axis=0) fake_inv = np.fft.irfft(fake , n=2*Nt)[:Nt] #print fakestreams[idx_det] faketot.append(fake_inv) #print '=\sim=' return faketot, psds