def Matched_Filter(fp, fc, data_p, data_c, flen, delta_f, flow): p_s_d = psd.aLIGOZeroDetHighPower(flen, delta_f, flow) SNRp = filter.matched_filter(fp, data_p, psd=p_s_d, low_frequency_cutoff=flow) SNRc = filter.matched_filter(fc, data_c, psd=p_s_d, low_frequency_cutoff=flow) return SNRp, SNRc
def next(self): nseries = [] stats = [] for i in range(self.batch): stat = {} n = self.noise.next() p = self.param.draw() hp, _ = get_fd_waveform(p, delta_f=n.delta_f, f_lower=self.noise.flow, **self.param.static) hp.resize(len(n)) sg = sigma(hp, psd=self.noise.psd, low_frequency_cutoff=self.noise.flow) n += hp.cyclic_time_shift(p.tc) / sg * p.snr # Collect some standard stats we might want msnr = matched_filter(hp, n, psd=self.noise.psd, low_frequency_cutoff=self.noise.flow) msnr = msnr.time_slice(p.tc - 1, p.tc + 1) params = {k: p[k] for k in p.dtype.names} idx = msnr.abs_arg_max() csnr = msnr[idx] params['csnr'] = csnr params['rsnr'] = csnr.real params['isnr'] = csnr.imag params['snr'] = abs(csnr) params['time'] = float(msnr.start_time + idx * msnr.delta_t) nseries.append(n) stats.append(params) self.current_params = stats return nseries, self.current_params
def cache_segment_snrs(self, template, stilde, psd): key = (template.params.template_hash, stilde._epoch, hash(psd)) # key = (template.params.template_hash, hash(stilde), hash(psd)) if key not in self._segment_snrs_cache: mat = pf.matched_filter(template, stilde, psd, self.f_low) self._segment_snrs_cache[key] = mat return self._segment_snrs_cache[key]
def coalign_waveforms(h1, h2, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None, resize=True): """ Return two time series which are aligned in time and phase. The alignment is only to the nearest sample point and all changes to the phase are made to the first input waveform. Waveforms should not be split accross the vector boundary. If it is, please use roll or cyclic time shift to ensure that the entire signal is contiguous in the time series. Parameters ---------- h1: pycbc.types.TimeSeries The first waveform to align. h2: pycbc.types.TimeSeries The second waveform to align. psd: {None, pycbc.types.FrequencySeries} A psd to weight the alignment low_frequency_cutoff: {None, float} The low frequency cutoff to weight the matching in Hz. high_frequency_cutoff: {None, float} The high frequency cutoff to weight the matching in Hz. resize: Optional, {True, boolean} If true, the vectors will be resized to match each other. If false, they must be the same length and even in length Returns ------- h1: pycbc.types.TimeSeries The shifted waveform to align with h2 h2: pycbc.type.TimeSeries The resized (if necessary) waveform to align with h1. """ from pycbc.filter import matched_filter mlen = ceilpow2(max(len(h1), len(h2))) h1 = h1.copy() h2 = h2.copy() if resize: h1.resize(mlen) h2.resize(mlen) elif len(h1) != len(h2) or len(h2) % 2 != 0: raise ValueError("Time series must be the same size and even if you do " "not allow resizing") snr = matched_filter(h1, h2, psd=psd, low_frequency_cutoff=low_frequency_cutoff, high_frequency_cutoff=high_frequency_cutoff) _, l = snr.abs_max_loc() rotation = snr[l] / abs(snr[l]) h1 = (h1.to_frequencyseries() * rotation).to_timeseries() h1.roll(l) h1 = TimeSeries(h1, delta_t=h2.delta_t, epoch=h2.start_time) return h1, h2
def make(conditioned, template, fc, mc, hc, grafica): # We use 4 second samles of our time series in Welch method. psd = conditioned.psd(4) # Now that we have the psd we need to interpolate it to match our data # and then limit the filter length of 1 / PSD. After this, we can # directly use this PSD to filter the data in a controlled manner psd = interpolate(psd, conditioned.delta_f) psd = inverse_spectrum_truncation(psd, 4 * conditioned.sample_rate, low_frequency_cutoff=fc) psd_o = psd snr = matched_filter(template, conditioned, psd=psd, low_frequency_cutoff=fc) sigmasq = sigma(template, psd, low_frequency_cutoff=fc) #print 'Rho_0' #print sigmasq # Remove time corrupted by the template filter and the psd filter # We remove 4 seonds at the beginning and end for the PSD filtering # And we remove 4 additional seconds at the beginning to account for # the template length (this is somewhat generous for # so short a template). A longer signal such as from a BNS, would # require much more padding at the beginning of the vector. snr = snr.crop(4, 4) if grafica == 1: pylab.figure('Matched_filter_output') pylab.title('Matched filter output') pylab.grid() pylab.plot(snr.sample_times, abs(snr)) pylab.ylabel('Signal-to-noise ratio') pylab.xlabel('Time (s)') pylab.show() peak = abs(snr).numpy().argmax() snrp = snr[peak] time = snr.sample_times[peak] #print 'Tiempo de SNR máximo' #print time #print 'SNR recuperado' #print abs(snrp) return snr, psd, peak, time, snrp, psd_o, sigmasq
def next(self): images = [] targets = [] for i in range(self.batch): n = self.noise.next() p = self.param.draw() hp, _ = get_fd_waveform(p, delta_f=n.delta_f, f_lower=self.noise.flow, **self.param.static) hp.resize(len(n)) sg = sigma(hp, psd=self.noise.psd, low_frequency_cutoff=self.noise.flow) n += hp.cyclic_time_shift(p.tc) / sg * p.snr msnr = matched_filter(hp, n, psd=self.noise.psd, low_frequency_cutoff=self.noise.flow) snr = abs(msnr.crop(self.whitening_truncation, self.whitening_truncation)).max() n = n.to_timeseries() w = n.whiten(self.whitening_truncation, self.whitening_truncation) dt = self.duration / float(self.image_dim[0]) fhigh = self.noise.sample_rate * 0.3 t, f, p = w.qtransform(dt, logfsteps=self.image_dim[1], frange=(self.noise.flow, fhigh), qrange=(self.q, self.q), return_complex=True) kmin = int((w.duration / 2 - self.duration / 2) / dt) kmax = kmin + int(self.duration / dt) p = p[:, kmin:kmax].transpose() amp = numpy.abs(p) p = numpy.stack([p.real, p.imag, amp], axis=2) images.append(p) targets.append(snr) return numpy.stack(images, axis=0), numpy.array(targets)
def mathched_filtering(self,m1,m2,f_highPass = 15,\ fft_crop = 2,\ psd_interval = 4,\ genWave_f_lowerbound = 20,\ snrCrop = 4): #done to avoid loading the data every time when used in a loop if self.mergerStrain == None: #this methode takes in a duration instead of a time interval #This automatically pulls strain data centered around the #gps time stamp instead of you specifing it yourself. self.mergerStrain = self.getMergerStrain() merger = Merger(self.event_id) ''' There is an issue for how the strain data is read using this methode when being used with the filter.highpass methode Need to find a conversion so that a custome time interval can be used when selecting a data set ''' #changing from the class wide strain array to a local one at the same #time of performing the highpass filtering. strain = filter.highpass(self.mergerStrain, f_highPass) strain = filter.resample_to_delta_t(strain, 1.0 / 2048) #removing discontinuities errors that form at the end due to resampling conditioned = strain.crop(fft_crop, fft_crop) #crops off the first #and last two seconds #generating the psd, thats used in the matched filtering methode #the psd is used to weight "the frequency components of the #potential signal and data by the noise amplitude" psd = conditioned.psd(psd_interval) #this matches the psd to our conditioned strain data psd = pycbc.psd.interpolate(psd, conditioned.delta_f) #this generated a 1/psd that is used to further filter the data psd = pycbc.psd.inverse_spectrum_truncation(psd,\ psd_interval*conditioned.sample_rate,\ low_frequency_cutoff=f_highPass) #Generating matched filtering waveform hp, hc = get_td_waveform(approximant="SEOBNRv4_opt", mass1=m1, mass2=m2, delta_t=conditioned.delta_t, f_lower=genWave_f_lowerbound) #Resizing the matched filtering wave form to the size of the our data hp.resize(len(conditioned)) #shifting the moldeled wave form to the aproximant location of the #merger event template = hp.cyclic_time_shift(hp.start_time) #generating the signal to noise ratio data set snr = filter.matched_filter(template, conditioned, psd=psd, low_frequency_cutoff=genWave_f_lowerbound) #cropping out the problamatic data points. There are discontinuitie #errors at the ends of the interval snr = snr.crop(snrCrop + psd_interval, snrCrop) snrPeakIndex = abs(snr).numpy().argmax() snrPeak = abs(snr)[snrPeakIndex] snrPeakTime = snr.sample_times[snrPeakIndex] # # Shift the template to the peak time # dt = snrPeakTime - conditioned.start_time # aligned = template.cyclic_time_shift(dt) # # # scale the template so that it would have SNR 1 in this data # aligned /= sigma(aligned, psd=psd, low_frequency_cutoff=20.0) # # # Scale the template amplitude and phase to the peak value # aligned = (aligned.to_frequencyseries() * snrPeak).to_timeseries() # aligned.start_time = conditioned.start_time # We do it this way so that we can whiten both the template and the data white_data = (conditioned.to_frequencyseries() / psd**0.5).to_timeseries() white_data = white_data.highpass_fir(f_highPass * 2, 512).lowpass_fir(230, 512) # Select the time around the merger white_data = white_data.time_slice(merger.time - .1, merger.time + .1) outputFormater = namedtuple('signal_to_noise_ratio_data',\ ['snr','snrPeakIndex','snrPeak','snrPeakTime','white_data']) #returning the signal to noise ratio return outputFormater(snr, snrPeakIndex, snrPeak, snrPeakTime, white_data)
import numpy from pycbc.filter import matched_filter snr = matched_filter(hp, zoom.to_pycbc(), psd=psd.to_pycbc(), low_frequency_cutoff=15) snrts = TimeSeries.from_pycbc(snr).abs()
def run(self): proc_name = self.name while True: # Get next task to be completed from the queue next_task = self._task_queue.get() if next_task is None: # This poison pil means shutdown LOGGER.info("{}: Exiting".format(proc_name)) break results = list() # Initialise parameters from task queue to generate SNR time-series mass1 = next_task["mass1"] mass2 = next_task["mass2"] spin1z = next_task["spin1z"] spin2z = next_task["spin2z"] ra = next_task["ra"] dec = next_task["dec"] coa_phase = next_task["coa_phase"] inclination = next_task["inclination"] polarization = next_task["polarization"] injection_snr = next_task["injection_snr"] f_low = next_task["f_low"] approximant = next_task["approximant"] delta_t = next_task["delta_t"] index = next_task["index"] det_string = next_task["det_string"] strain_sample = next_task["strain_sample"] print("Generating optimal SNR time series: " + det_string + " - sample" + str(index)) # Convert sample to PyCBC time series strain_time_series = TimeSeries(strain_sample, delta_t=delta_t, epoch=0, dtype=None, copy=True) # Convert sample to PyCBC frequency series strain_freq_series = strain_time_series.to_frequencyseries() # Generate optimal matched filtering template template_hp, template_hc = get_td_waveform( approximant=approximant, mass1=mass1, mass2=mass2, spin1z=spin1z, spin2z=spin2z, ra=ra, dec=dec, coa_phase=coa_phase, inclination=inclination, f_lower=f_low, delta_t=delta_t, ) # Convert template to PyCBC frequency series template_freq_series_hp = template_hp.to_frequencyseries( delta_f=strain_freq_series.delta_f) # Resize template to work with the sample template_freq_series_hp.resize(len(strain_freq_series)) # Time shift the template so that the SNR peak matches the merger time template_freq_series_hp = template_freq_series_hp.cyclic_time_shift( template_freq_series_hp.start_time) # Compute SNR time-series from optimal matched filtering template snr_series = matched_filter(template_freq_series_hp, strain_freq_series.astype(complex), psd=None, low_frequency_cutoff=f_low) results.append({ "snr_strain": np.array(abs(snr_series)), "mass1": mass1, "mass2": mass2, "spin1z": spin1z, "spin2z": spin2z, "ra": ra, "dec": dec, "coa_phase": coa_phase, "inclination": inclination, "polarization": polarization, "injection_snr": injection_snr, "index": index, "det_string": det_string, # Unsure I need this for when I store files, using it and index to provide store locations later on }) # Put the results on the results queue if len(results) >= 1: for result in results: self._result_queue.put(result) # Add a poison pill self._result_queue.put(None)
def run(self): proc_name = self.name while True: next_task = self._template_task_queue.get() if next_task is None: # This poison pil means shutdown LOGGER.info("{}: Exiting".format(proc_name)) break template_results = list() f_low = next_task["f_low"] delta_t = next_task["delta_t"] template = next_task["template"] sample_index = next_task["sample_index"] template_index = next_task["template_index"] det_string = next_task["det_string"] strain_sample = next_task["strain_sample"] sample_type = next_task["sample_type"] delta_f = next_task["delta_f"] template_start_time = next_task["template_start_time"] print("Generating SNR time series: " + det_string + " - sample" + str(sample_index) + ", template" + str(template_index)) template_time_series = TimeSeries(template, delta_t=delta_t, epoch=0, dtype=None, copy=True) template_freq_series = template_time_series.to_frequencyseries( delta_f=delta_f) strain_sample_time_series = TimeSeries(strain_sample, delta_t=delta_t, epoch=0, dtype=None, copy=True) strain_freq_series = strain_sample_time_series.to_frequencyseries( delta_f=delta_f) template_freq_series.resize(len(strain_freq_series)) # Time shift the template so that the SNR peak matches the merger time template_freq_series = template_freq_series.cyclic_time_shift( template_start_time) # Compute SNR time-series from optimal matched filtering template snr_series = matched_filter(template_freq_series, strain_freq_series.astype(complex), psd=None, low_frequency_cutoff=f_low) template_results.append({ "snr_strain": np.array(abs(snr_series)), "sample_index": sample_index, "template_index": template_index, "det_string": det_string, "sample_type": sample_type, }) if len(template_results) >= 1: for result in template_results: self._template_result_queue.put(result) # Add a poison pill self._template_result_queue.put(None)
import urllib # Read data and remove low frequency content fname = 'H-H1_LOSC_4_V2-1126259446-32.gwf' url = "https://losc.ligo.org/s/events/GW150914/" + fname urllib.urlretrieve(url, filename=fname) h1 = read_frame('H-H1_LOSC_4_V2-1126259446-32.gwf', 'H1:LOSC-STRAIN') h1 = highpass_fir(h1, 15, 8) # Calculate the noise spectrum psd = interpolate(welch(h1), 1.0 / 32) # Generate a template to filter with hp, hc = get_fd_waveform(approximant="IMRPhenomD", mass1=40, mass2=32, f_lower=20, delta_f=1.0/32) hp.resize(len(h1) / 2 + 1) # Calculate the complex (two-phase SNR) snr = matched_filter(hp, h1, psd=psd, low_frequency_cutoff=20.0) # Remove regions corrupted by filter wraparound snr = snr[len(snr) / 4: len(snr) * 3 / 4] import pylab pylab.plot(snr.sample_times, abs(snr)) pylab.ylabel('signal-to-noise') pylab.xlabel('GPS Time (s)') pylab.show()
Snr_list = [] for i in range(len(mass1)): #Generate a waveform with a given component mass; assumed equal mass, nonspinning m = mass1[i] # Solar masses hp, hc = get_td_waveform(approximant="TaylorT4", mass1=m, mass2=m, delta_t=strain[ifo].delta_t, f_lower=25.0) # We will resize the vector to match our data hp.resize(len(strain[ifo])) template = hp.cyclic_time_shift(hp.start_time) snr = matched_filter(template, strain[ifo], psd=psds[ifo], low_frequency_cutoff=15.0) # Remove time corrupted by the template filter and the psd filter # We remove 4 seonds at the beginning and end for the PSD filtering # And we remove 4 additional seconds at the beginning to account for # the template length (this is somewhat generous for # so short a template). A longer signal such as from a BNS, would # require much more padding at the beginning of the vector. snr_H1 = snr.crop(4 + 4, 4) Snr_list.append(max(abs(snr_H1))) snrs[ifo] = Snr_list
#grace_psd = psd.inverse_spectrum_truncation(noise_psd, int((dt*seg_size) * conditioned.sample_rate), low_frequency_cutoff=0.01) grace_psd = psd.interpolate(noise_psd, conditioned.delta_f) plt.figure() plt.loglog(noise_psd.sample_frequencies, np.sqrt(noise_psd), label='noise model asd') plt.loglog(grace_psd.sample_frequencies, np.sqrt(grace_psd), label='interpolated noise curve') plt.grid() plt.legend() plt.show() #matched_filter snr1 = matched_filter(template, conditioned, psd=grace_psd, low_frequency_cutoff=0.01) snr1 = snr1.crop(10, 10) #Viewing matched filter snr timeseries plt.figure() plt.plot(snr1.sample_times, abs(snr1), label='abs snr') plt.ylabel('Signal-to-noise') plt.xlabel('Time (s)') plt.grid() plt.legend() plt.show() # print('hp_ts.size' , np.size(hp_ts)) # if seg_size > np.size(hp_ts):
def coalign_waveforms(h1, h2, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None, resize=True): """ Return two time series which are aligned in time and phase. The alignment is only to the nearest sample point and all changes to the phase are made to the first input waveform. Waveforms should not be split accross the vector boundary. If it is, please use roll or cyclic time shift to ensure that the entire signal is contiguous in the time series. Parameters ---------- h1: pycbc.types.TimeSeries The first waveform to align. h2: pycbc.types.TimeSeries The second waveform to align. psd: {None, pycbc.types.FrequencySeries} A psd to weight the alignment low_frequency_cutoff: {None, float} The low frequency cutoff to weight the matching in Hz. high_frequency_cutoff: {None, float} The high frequency cutoff to weight the matching in Hz. resize: Optional, {True, boolean} If true, the vectors will be resized to match each other. If false, they must be the same length and even in length Returns ------- h1: pycbc.types.TimeSeries The shifted waveform to align with h2 h2: pycbc.type.TimeSeries The resized (if necessary) waveform to align with h1. """ from pycbc.filter import matched_filter mlen = ceilpow2(max(len(h1), len(h2))) h1 = h1.copy() h2 = h2.copy() if resize: h1.resize(mlen) h2.resize(mlen) elif len(h1) != len(h2) or len(h2) % 2 != 0: raise ValueError( "Time series must be the same size and even if you do " "not allow resizing") snr = matched_filter(h1, h2, psd=psd, low_frequency_cutoff=low_frequency_cutoff, high_frequency_cutoff=high_frequency_cutoff) _, l = snr.abs_max_loc() rotation = snr[l] / abs(snr[l]) h1 = (h1.to_frequencyseries() * rotation).to_timeseries() h1.roll(l) h1 = TimeSeries(h1, delta_t=h2.delta_t, epoch=h2.start_time) return h1, h2
print "Match between map and injected is %.2f" % m ax.set_xlim(xmin, xmax) ax.set_ylim(ylim) ax.text(xmin, ylim[0], 'Match=%.2f' % m, ha='left', va='bottom', fontsize=12) ax.set_ylabel('{} whitened strain'.format(ifo)) if ii == 2: ax.set_xlabel('GPS time - {} (s)'.format(gps_time)) ## Find and save SNR snr = matched_filter( ti, y, psd=psd, low_frequency_cutoff=20.0 ) ## Should be SNR between injected waveform and whitened data snr_map = matched_filter(ts, y, psd=psd, low_frequency_cutoff=20.0 ) ## SNR between MAP waveform and whitened data # Remove regions corrupted by filter wraparound snr = snr[len(snr) / 4:len(snr) * 3 / 4] snr_map = snr[len(snr_map) / 4:len(snr_map) * 3 / 4] snr_list.append(snr) snr_list.append(snr_map) ''' savename=opts.output_file print savename figname=savename[:-2]+"_SNR" ## Plot and save SNRs print "saving SNR figures"
def fake_noisyGW(tab_waveform, seed, run, fs): nbr_sec = 15 nbr_sec_begin = 7 nbr_sec_end = 8 NFFT = 1 * fs fmin = 15 fmax = 200000 print("########################") print("creation of noisy signal") tab_whiten = [] tab_snr = [] random.seed(seed) for i in tqdm(range(0, len(tab_waveform))): #creation of the fake noise seed_local = random.randint(1, 1000) fake_noise = fake_gaussian_noise(nbr_sec, seed_local, fs, fmin) # injection of GW into the noise noisyGW = np.empty([len(fake_noise)]) # creation of the template (for SNR) template = np.zeros([len(fake_noise) ]) # idem pure_GW but with GW in the end(for SNR) # creation of pureGW (no use exept plot) pureGW = np.zeros([len(fake_noise)]) #pure GW in nbr_sec of 0 # injection of GW into noise k = 0 for j in range(0, len(fake_noise)): if j >= fs * nbr_sec_begin and j < fs * nbr_sec_end: noisyGW[j] = fake_noise[j] + tab_waveform[i][0][k] pureGW[j] = tab_waveform[i][0][k] k = k + 1 else: noisyGW[j] = fake_noise[j] pureGW[j] = 0 # creation of the template k = 0 for j in range(0, len(fake_noise)): if j < len(fake_noise) - len(tab_waveform[i][0]): template[j] = 0 else: template[j] = tab_waveform[i][0][k] k += 1 ########## the calcule of the SNR ############## # First we have to calculate the SNR (the following step is neccessary) # we calculate the SNR of noisy GW noisyGW_timeseries = TimeSeries(noisyGW, delta_t=tab_waveform[i][17]) # we need to calculate again the psd # we use just 4 sec of data to calulate psd (weltch method) psd = noisyGW_timeseries.psd(4) # we need to interpolate our psd on all data psd = interpolate(psd, noisyGW_timeseries.delta_f) # we need to inform that the noise was creat with a lowfrequency cutoff psd = inverse_spectrum_truncation(psd, 4 * noisyGW_timeseries.sample_rate, low_frequency_cutoff=fmin) #Second we calcule the SNR # we calculate the SNR template_timeseries = TimeSeries(template, delta_t=tab_waveform[i][17]) noisyGW_timeseries = TimeSeries(noisyGW, delta_t=tab_waveform[i][17]) if template.max(0) == 0: snrp = 0 tab_snr = tab_snr + [snrp] else: snr = matched_filter(template_timeseries, noisyGW_timeseries, psd=psd, low_frequency_cutoff=fmin) # 4+1 sec remove at the begining of SNR and 4 seconde remove at the end # +1 is because the length of the template is one sec snr = snr.crop(4 + 1, 4) peak = abs(snr).numpy().argmax() snrp = snr[peak] tab_snr = tab_snr + [abs(snrp)] # on fait le withening # I) methode pycbc # data and then flattening the frequency response. # (1) The first option sets the duration in seconds of each # sample of the data used as part of the PSD estimate. # (2) The second option sets the duration of the filter to apply #whitened = noisyGW_timeseries.whiten(15, 4) # on fait aussi un bandpass #whitened_bp = whitened.highpass_fir(30, 512).lowpass_fir(250, 512) # le whitening pycbc donne meme chose mais modifie la longueur # par facilite je reprends l autre whitening # II) method numpy Pxx, freqs = mlab.psd(noisyGW, Fs=freq, NFFT=NFFT, noverlap=NFFT / 2, window=np.blackman(NFFT)) # We will use interpolations of the ASDs computed above for whitening: psd_numpy = interp1d(freqs, Pxx) whitened = whitening(noisyGW, psd_numpy, tab_waveform[i][17]) # We need to suppress the high frequencies with some bandpassing: high_freq = 600. low_freq = fmin bb, ab = butter(4, [low_freq * 2. / fs, high_freq * 2. / fs], btype='band') whitened_bp = filtfilt(bb, ab, whitened) # Select the secon containing the GW withen_bp_onesec = np.empty([fs]) for j in range(0, len(withen_bp_onesec)): withen_bp_onesec[j] = whitened_bp[nbr_sec_begin * fs + j] tab_whiten = tab_whiten + [withen_bp_onesec] ''' ###################################################################### ### PLOT this is no necessary is just to be sure everithing is OK ### # just some plot to see if everything looks fine temps = np.empty([len(fake_noise)]) for tps in range(0, len(fake_noise)): temps[tps] = tps temps_onesec = np.empty([len(tab_waveform[i][0])]) for tps in range(0, len(tab_waveform[i][0])): temps_onesec[tps] = tps # noisy GW plt.figure("noisyGW") plt.plot(temps, noisyGW, 'b') plt.plot(temps, pureGW, 'r') plt.show() # template plt.figure("template") plt.plot(temps, template, 'r') plt.show() # the GW plt.figure("template") plt.plot(temps_onesec, tab_waveform[i][0], 'r') plt.show() # psd plt.figure("psd") plt.loglog(psd.sample_frequencies, psd) pylab.xlim(10, 2048) pylab.show() # SNR plt.figure("SNR") pylab.plot(snr.sample_times, abs(snr)) pylab.grid() pylab.show() # Whitening whitened_bp = TimeSeries(whitened_bp, delta_t=tab_waveform[i][17]) plt.figure("whitening") pylab.plot(whitened_bp.sample_times, whitened_bp) #pylab.xlim(7,8) pylab.grid() pylab.show() #whitening onesec whiten_bp_onesec_timeseries = TimeSeries(withen_bp_onesec, delta_t=tab_waveform[i][17]) plt.figure("whitening_one_sec") pylab.plot(whiten_bp_onesec_timeseries.sample_times, whiten_bp_onesec_timeseries) pylab.xlim(0.6, 1.0) pylab.grid() pylab.show() ################################################################### ''' tab_snr = np.asarray(tab_snr) tab_whiten = np.asarray(tab_whiten) # we create the big array (with all the parameters,...) tab_waveformnoisy = copy.deepcopy(tab_waveform) for i in range(0, len(tab_waveformnoisy)): tab_waveformnoisy[i][0] = tab_whiten[i] return tab_waveformnoisy, tab_snr
pylab.xlabel('Time (s)') pylab.ylabel('Strain') pylab.title('Injected Waveform') zoom_signal = signal.time_slice(merger_time - 0.5, merger_time + 0.5) zoom_waveform = waveform.time_slice(merger_time - 0.5, merger_time + 0.5) pylab.figure(figsize=(10, 5)) pylab.plot(zoom_signal.sample_times, zoom_signal, label='Signal') pylab.plot(zoom_waveform.sample_times, zoom_waveform, label='Waveform') pylab.xlabel('Time (s)') pylab.ylabel('Strain') pylab.title('Zoomed View') pylab.legend() hp.resize(time_duration * f_sample) snr = matched_filter(hp, signal, psd=psd, low_frequency_cutoff=20) pylab.figure(figsize=[10, 4]) pylab.plot(snr.sample_times, abs(snr)) pylab.ylabel('Signal-to-noise') pylab.xlabel('Time (s)') pylab.show() peak = abs(snr).numpy().argmax() snrp = snr[peak] time = snr.sample_times[peak] print("We found a signal at {}s with SNR {}".format(time, abs(snrp))) '''' from synthesizer import GWsynthesizer hp, hc = get_td_waveform(approximant='SEOBNRv4_opt', mass1=mass, mass2=mass, delta_t= delta_t, f_lower = 25, distance=100)
# match_roll = np.roll(match_template, -np.size(match_template)/4 ) # match_template = types.timeseries.TimeSeries(match_roll, delta_t=conditioned.delta_t) # plt.figure() # plt.plot(match_template.sample_times, match_template, label='match template rolled') # plt.xlabel('time (s)') # plt.legend() # plt.show() #Check properties and Perform the Matched filtering # print('match template, conditioned data, grace_psd:', 'sizes:', np.size(match_template), np.size(conditioned), np.size(grace_psd), # 'dt:', match_template.delta_t, conditioned.delta_t, grace_psd.delta_t, # 'df:', match_template.delta_f, conditioned.delta_f, grace_psd.delta_f) # 6.2 - Perform the matched filter via pycbc's filter module------------------------------------------------------------------------- snr1 = matched_filter(match_template, conditioned, psd=grace_psd) #psd=signal_and_noise_psd) snr1 = snr1.crop(10, 10) #Viewing matched filter snr timeseries #plt.figure() #plt.plot(snr1.sample_times, abs(snr1), label='abs snr') #plt.ylabel('Signal-to-noise') #plt.xlabel('Time (s)') #plt.grid() #plt.legend() #plt.show() #Below here is my shit doesn't work and I'm trying to see why section :)
# Read data and remove low frequency content fname = 'H-H1_LOSC_4_V2-1126259446-32.gwf' url = "https://www.gw-openscience.org/GW150914data/" + fname urllib.urlretrieve(url, filename=fname) h1 = read_frame('H-H1_LOSC_4_V2-1126259446-32.gwf', 'H1:LOSC-STRAIN') h1 = highpass_fir(h1, 15, 8) # Calculate the noise spectrum psd = interpolate(welch(h1), 1.0 / h1.duration) # Generate a template to filter with hp, hc = get_fd_waveform(approximant="IMRPhenomD", mass1=40, mass2=32, f_lower=20, delta_f=1.0 / h1.duration) hp.resize(len(h1) / 2 + 1) # Calculate the complex (two-phase SNR) snr = matched_filter(hp, h1, psd=psd, low_frequency_cutoff=20.0) # Remove regions corrupted by filter wraparound snr = snr[len(snr) / 4:len(snr) * 3 / 4] import pylab pylab.plot(snr.sample_times, abs(snr)) pylab.ylabel('signal-to-noise') pylab.xlabel('GPS Time (s)') pylab.show()
def worker(kwargs): #print("Worker here!") #print("Args: {}".format(kwargs)) full_kwargs = dict(kwargs) kwargs = dict(kwargs) opt_arg = {} opt_keys = [ 'snr', 'gw_prob', 'random_starting_time', 'resample_delta_t', 't_len', 'resample_t_len', 'time_offset', 'whiten_len', 'whiten_cutoff', 't_from_right', 'no_gw_snr' ] for key in opt_keys: try: opt_arg[key] = kwargs.get(key) del kwargs[key] except KeyError: print("The necessary argument '%s' was not supplied in '%s'" % (key, str(__file__))) projection_arg = {} projection_arg['end_time'] = 1337 * 137 * 42 projection_arg['declination'] = 0.0 projection_arg['right_ascension'] = 0.0 projection_arg['polarization'] = 0.0 projection_arg['detectors'] = ['L1', 'H1'] projection_arg, kwargs = filter_keys(projection_arg, kwargs) T_SAMPLES = int(opt_arg['t_len'] / kwargs['delta_t']) DELTA_F = 1.0 / opt_arg['t_len'] F_LEN = int(2.0 / (DELTA_F * kwargs['delta_t'])) gw_present = bool(random() < opt_arg['gw_prob']) psd = generate_psd(**full_kwargs) #TODO: Generate the seed for this prior to parallelizing noise_list = [ noise_from_psd(length=T_SAMPLES, delta_t=kwargs['delta_t'], psd=psd, seed=randint(0, 100000)) for d in projection_arg['detectors'] ] #print("Pre GW generation") if gw_present: #Generate waveform #print("Pre waveform") hp, hc = get_td_waveform(**kwargs) #Project it onto the considered detectors (This could be handeled using) #a list, to make room for more detectors #print("Pre projection") strain_list = detector_projection(TimeSeries(hp), TimeSeries(hc), **projection_arg) #Enlarge the signals bya adding zeros infront and after. Take care of a #random timeshift while still keeping the relative timeshift between #detectors #TODO: This should also be set outside if opt_arg['random_starting_time']: t_offset = opt_arg['time_offset'] else: t_offset = 0.0 #print("Pre embedding in zero") set_temp_offset(strain_list, opt_arg['t_len'], t_offset, opt_arg['t_from_right']) #Rescale the templates to match wanted SNR strain_list = rescale_to_snr(strain_list, opt_arg['snr'], psd, kwargs['f_lower']) else: strain_list = [ TimeSeries(np.zeros(len(n)), n.delta_t) for n in noise_list ] opt_arg['snr'] = opt_arg['no_gw_snr'] #print("post generating") total_white = [] matched_snr_sq = [] #print("Pre loop") tmp_white = [] for i, noise in enumerate(noise_list): #print("Loop i: {}".format(i)) #Add strain to noise noise._epoch = strain_list[i]._epoch #print("Post epoch, pre adding") total = TimeSeries(noise + strain_list[i]) #print("Post adding, pre whiten") #Whiten the total data, downsample and crop the data total_white.append( total.whiten(opt_arg['whiten_len'], opt_arg['whiten_cutoff'], low_frequency_cutoff=kwargs['f_lower'])) #print("Post whiten and appending, pre resampling") if isinstance(opt_arg['resample_delta_t'], tuple): if isinstance(opt_arg['resample_t_len'], tuple) and len( opt_arg['resample_delta_t']) == len( opt_arg['resample_t_len']): rdt = opt_arg['resample_delta_t'] resample_samples = [ int(opt_arg['resample_t_len'][idx] / kwargs['delta_t']) for idx in range(len(rdt)) ] for idx, sam in enumerate(resample_samples): #print("Sam: {}".format(sam)) #print("Len list: {}".format(len(total_white[i]))) #print(i) #print("Resample delta t: {}".format(rdt[idx])) #print("resample_t_len: {}".format(opt_arg['resample_t_len'][idx])) #print("") tmp_white.append( resample_to_delta_t( total_white[i][len(total_white[i]) - sam:], rdt[idx])) else: raise ValueError( "The options 'resample_delta_t' and 'resample_t_len' have to either both be floats or tuples of floats of the same length." ) #Error or handle else: total_white[i] = resample_to_delta_t(total_white[i], opt_arg['resample_delta_t']) #print("Post resampling, pre cropping") mid_point = (total_white[i].end_time + total_white[i].start_time) / 2 total_white[i] = total_white[i].time_slice( mid_point - opt_arg['resample_t_len'] / 2, mid_point + opt_arg['resample_t_len'] / 2) #print("Post cropping, pre matched filtering") #print("Strain list: {}\ntotal: {}\nPSD: {}".format(strain_list[i], total, psd)) #test = matched_filter(strain_list[i], total, psd=psd, low_frequency_cutoff=kwargs['f_lower']) #print("Can calc") #Calculate matched filter snr if gw_present: matched_snr_sq.append( max( abs( matched_filter( strain_list[i], total, psd=psd, low_frequency_cutoff=kwargs['f_lower'])))**2) else: #TODO: Implement matched filtering against template bank matched_snr_sq.append(opt_arg['no_gw_snr']**2 / len(noise_list)) #print("Post matched filtering, WTF!") if not len(tmp_white) == 0: total_white = tmp_white del total del strain_list #Calculate the total SNR of all detectors calc_snr = np.sqrt(sum(matched_snr_sq)) del matched_snr_sq #out_wav = [] #for i, dat in enumerate(total_white): #print("Length of total_white[{}]: {}".format(i, len(dat))) #for i in range(len(total_white[0])): ##print("Length of {}: {}".format(i, len(total_white[i]))) #tmp = [] #for j, dat in enumerate(total_white): #sys.stdout.write("\ri = {}| j = {} ".format(i, j)) #sys.stdout.flush() #tmp.append(dat[i]) #sys.stdout.write('\n') #sys.stdout.flush() ##print("\n") #out_wav.append(tmp) out_wav = [[dat[i] for dat in total_white] for i in range(len(total_white[0]))] #print("Pre return") return ((np.array(out_wav), np.array([opt_arg['snr'], int(gw_present) ]), np.array(calc_snr), np.array(str(kwargs)), np.array(str(opt_arg))))
from pycbc.waveform import get_fd_waveform hp, _ = get_fd_waveform(approximant="IMRPhenomD", mass1=40, mass2=32, f_lower=20, f_final=2048, delta_f=psd.df.value) # At this point we are ready to calculate the SNR, so we import the # :func:`pycbc.filter.matched_filter # <pycbc.filter.matchedfilter.matched_filter>` method, and pass it # our template, the data, and the PSD: from pycbc.filter import matched_filter snr = matched_filter(hp, zoom.to_pycbc(), psd=psd.to_pycbc(), low_frequency_cutoff=15) snrts = TimeSeries.from_pycbc(snr).abs() # .. note:: # # Here we have used the :meth:`~TimeSeries.to_pycbc` methods of the # `~gwpy.timeseries.TimeSeries` and `~gwpy.frequencyseries.FrequencySeries` # objects to convert from GWpy objects to something that PyCBC functions # can understand, and then used the :meth:`~TimeSeries.from_pycbc` method # to convert back to a GWpy object. # We can plot the SNR `TimeSeries` around the region of interest: plot = snrts.plot() ax = plot.gca() ax.set_xlim(1126259461, 1126259463)
# We will try different component masses and see whichgives us thelargest masses = numpy.arange(1.3,1.5,.01) # Variables to store when we've found the max hmax, smax, tmax, mmax, nsnr = None, {}, {},0,0 snrs = [] for m in masses: #Generate a waveform with a given component mass;assumed equal mass,nonspinning hp, hc = get_fd_waveform(approximant="TaylorF2", mass1=m, mass2=m, f_lower=20, delta_f=stilde[ifo].delta_f) hp.resize(len(stilde[ifo])) # Matched filter the data and find the peak max_snr, max_time = {}, {} for ifo in ['L1','H1']: snr = matched_filter(hp, stilde[ifo], psd=psds[ifo],low_frequency_cutoff=20.0) # The complex SNR at the peak snr = snr.time_slice(merger.time -1, merger.time+1) _, idx = snr.abs_max_loc() max_snr[ifo] = snr[idx] # The time of the peak max_time[ifo] = float(idx) / snr.sample_rate+ snr.start_time network_snr = (abs(numpy.array(list(max_snr.values())))**2.0).sum()**0.5 snrs.append(max_snr) # Keep track of only the loudest peak if network_snr > nsnr: tmax, hmax, mmax, smax = max_time, hp, m, max_snr nsnr = network_snr # See the SNR as a function of the component mass.Notice where this peaksas it gives us # an estimate of what the parameters of the sourcesystem are. Note thatmasses # here are in the *detector* frame, so if the sourceis located far away,it will in# fact correspond to a lighter system due to cosmologicalredshift.