def filter_psd(self, segment_duration, delta_f, flow): """ Calculate the power spectral density of this time series. Use the `pycbc.psd.welch` method to estimate the psd of this time segment. The psd is then truncated in the time domain to the segment duration and interpolated to the requested sample frequency. Parameters ---------- segment_duration: float Duration in seconds to use for each sample of the spectrum. delta_f : float Frequency spacing to return psd at. flow : float The low frequency cutoff to apply when truncating the inverse spectrum. Returns ------- psd : FrequencySeries Frequency series containing the estimated PSD. """ from pycbc.psd import interpolate, inverse_spectrum_truncation p = self.psd(segment_duration) samples = int(round(p.sample_rate * segment_duration)) p = interpolate(p, delta_f) return inverse_spectrum_truncation(p, samples, low_frequency_cutoff=flow, trunc_method='hann')
def setUp(self): ###### Get data for references analysis of 170817 m = Merger("GW170817") ifos = ['H1', 'V1', 'L1'] self.psds = {} self.data = {} for ifo in ifos: print("Processing {} data".format(ifo)) # Download the gravitational wave data for GW170817 url = "https://dcc.ligo.org/public/0146/P1700349/001/" url += "{}-{}1_LOSC_CLN_4_V1-1187007040-2048.gwf" fname = download_file(url.format(ifo[0], ifo[0]), cache=True) ts = read_frame(fname, "{}:LOSC-STRAIN".format(ifo), start_time=int(m.time - 260), end_time=int(m.time + 40)) ts = highpass(ts, 15.0) ts = resample_to_delta_t(ts, 1.0 / 2048) ts = ts.time_slice(m.time - 112, m.time + 16) self.data[ifo] = ts.to_frequencyseries() psd = interpolate(ts.psd(4), ts.delta_f) psd = inverse_spectrum_truncation(psd, int(4 * psd.sample_rate), trunc_method='hann', low_frequency_cutoff=20.0) self.psds[ifo] = psd self.static = { 'mass1': 1.3757, 'mass2': 1.3757, 'f_lower': 20.0, 'approximant': "TaylorF2", 'polarization': 0, 'ra': 3.44615914, 'dec': -0.40808407, 'tc': 1187008882.42840, } self.variable = ( 'distance', 'inclination', ) self.flow = {'H1': 25, 'L1': 25, 'V1': 25} inclination_prior = SinAngle(inclination=None) distance_prior = Uniform(distance=(10, 100)) tc_prior = Uniform(tc=(m.time - 0.1, m.time + 0.1)) self.prior = JointDistribution(self.variable, inclination_prior, distance_prior) ###### Expected answers # Answer taken from marginalized gaussian model self.q1 = {'distance': 42.0, 'inclination': 2.5} self.a1 = 541.8235746138382 # answer taken from brute marginize pol + phase self.a2 = 542.581 self.pol_samples = 200
def whiten(self, segment_duration, max_filter_duration, trunc_method='hann', remove_corrupted=True, low_frequency_cutoff=None, return_psd=False, **kwds): """ Return a whitened time series Parameters ---------- segment_duration: float Duration in seconds to use for each sample of the spectrum. max_filter_duration : int Maximum length of the time-domain filter in seconds. trunc_method : {None, 'hann'} Function used for truncating the time-domain filter. None produces a hard truncation at `max_filter_len`. remove_corrupted : {True, boolean} If True, the region of the time series corrupted by the whitening is excised before returning. If false, the corrupted regions are not excised and the full time series is returned. low_frequency_cutoff : {None, float} Low frequency cutoff to pass to the inverse spectrum truncation. This should be matched to a known low frequency cutoff of the data if there is one. return_psd : {False, Boolean} Return the estimated and conditioned PSD that was used to whiten the data. kwds : keywords Additional keyword arguments are passed on to the `pycbc.psd.welch` method. Returns ------- whitened_data : TimeSeries The whitened time series """ from pycbc.psd import inverse_spectrum_truncation, interpolate # Estimate the noise spectrum psd = self.psd(segment_duration, **kwds) psd = interpolate(psd, self.delta_f) max_filter_len = int(max_filter_duration * self.sample_rate) # Interpolate and smooth to the desired corruption length psd = inverse_spectrum_truncation(psd, max_filter_len=max_filter_len, low_frequency_cutoff=low_frequency_cutoff, trunc_method=trunc_method) # Whiten the data by the asd white = (self.to_frequencyseries() / psd**0.5).to_timeseries() if remove_corrupted: white = white[int(max_filter_len/2):int(len(self)-max_filter_len/2)] if return_psd: return white, psd return white
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 whiten(self, segment_duration, max_filter_duration, trunc_method='hann', remove_corrupted=True, low_frequency_cutoff=None, return_psd=False, **kwds): """ Return a whitened time series Parameters ---------- segment_duration: float Duration in seconds to use for each sample of the spectrum. max_filter_duration : int Maximum length of the time-domain filter in seconds. trunc_method : {None, 'hann'} Function used for truncating the time-domain filter. None produces a hard truncation at `max_filter_len`. remove_corrupted : {True, boolean} If True, the region of the time series corrupted by the whitening is excised before returning. If false, the corrupted regions are not excised and the full time series is returned. low_frequency_cutoff : {None, float} Low frequency cutoff to pass to the inverse spectrum truncation. This should be matched to a known low frequency cutoff of the data if there is one. return_psd : {False, Boolean} Return the estimated and conditioned PSD that was used to whiten the data. kwds : keywords Additional keyword arguments are passed on to the `pycbc.psd.welch` method. Returns ------- whitened_data : TimeSeries The whitened time series """ from pycbc.psd import inverse_spectrum_truncation, interpolate # Estimate the noise spectrum psd = self.psd(segment_duration, **kwds) psd = interpolate(psd, self.delta_f) max_filter_len = int(max_filter_duration * self.sample_rate) # Interpolate and smooth to the desired corruption length psd = inverse_spectrum_truncation(psd, max_filter_len=max_filter_len, low_frequency_cutoff=low_frequency_cutoff, trunc_method=trunc_method) # Whiten the data by the asd white = (self.to_frequencyseries() / psd**0.5).to_timeseries() if remove_corrupted: white = white[int(max_filter_len/2):int(len(self)-max_filter_len/2)] if return_psd: return white, psd return white
def setUp(self, *args): self.context = _context self.scheme = _scheme self.tolerance = 1e-6 xr = numpy.random.uniform(low=-1, high=1.0, size=2**20) xi = numpy.random.uniform(low=-1, high=1.0, size=2**20) self.x = Array(xr + xi * 1.0j, dtype=complex64) self.z = zeros(2**20, dtype=float32) for i in range(0, 4): trusted_accum(self.z, self.x) m = Merger("GW170814") ifos = ['H1', 'L1', 'V1'] data = {} psd = {} for ifo in ifos: # Read in and condition the data and measure PSD ts = m.strain(ifo).highpass_fir(15, 512) data[ifo] = resample_to_delta_t(ts, 1.0 / 2048).crop(2, 2) p = data[ifo].psd(2) p = interpolate(p, data[ifo].delta_f) p = inverse_spectrum_truncation(p, int(2 * data[ifo].sample_rate), low_frequency_cutoff=15.0) psd[ifo] = p hp, _ = get_fd_waveform(approximant="IMRPhenomD", mass1=31.36, mass2=31.36, f_lower=20.0, delta_f=data[ifo].delta_f) hp.resize(len(psd[ifo])) # For each ifo use this template to calculate the SNR time series snr = {} snr_unnorm = {} norm = {} corr = {} for ifo in ifos: snr_unnorm[ifo], corr[ifo], norm[ifo] = \ matched_filter_core(hp, data[ifo], psd=psd[ifo], low_frequency_cutoff=20) snr[ifo] = snr_unnorm[ifo] * norm[ifo] self.snr = snr self.snr_unnorm = snr_unnorm self.norm = norm self.corr = corr self.hp = hp self.data = data self.psd = psd self.ifos = ifos
def scale(template, noise, SNR): template_size = len(template) template.resize(time_duration * f_sample) psd = noise.psd(1) psd = interpolate(psd, template.delta_f) sigma = matchedfilter.sigma(template, psd=psd, low_frequency_cutoff=f_min) amplitude = SNR / (sigma) template *= amplitude template.resize(template_size) return template, amplitude
def setUp(self,*args): self.context = _context self.scheme = _scheme self.tolerance = 1e-6 xr = numpy.random.uniform(low=-1, high=1.0, size=2**20) xi = numpy.random.uniform(low=-1, high=1.0, size=2**20) self.x = Array(xr + xi * 1.0j, dtype=complex64) self.z = zeros(2**20, dtype=float32) for i in range(0, 4): trusted_accum(self.z, self.x) m = Merger("GW170814") ifos = ['H1', 'L1', 'V1'] data = {} psd = {} for ifo in ifos: # Read in and condition the data and measure PSD ts = m.strain(ifo).highpass_fir(15, 512) data[ifo] = resample_to_delta_t(ts, 1.0/2048).crop(2, 2) p = data[ifo].psd(2) p = interpolate(p, data[ifo].delta_f) p = inverse_spectrum_truncation(p, 2 * data[ifo].sample_rate, low_frequency_cutoff=15.0) psd[ifo] = p hp, _ = get_fd_waveform(approximant="IMRPhenomD", mass1=31.36, mass2=31.36, f_lower=20.0, delta_f=data[ifo].delta_f) hp.resize(len(psd[ifo])) # For each ifo use this template to calculate the SNR time series snr = {} snr_unnorm = {} norm = {} corr = {} for ifo in ifos: snr_unnorm[ifo], corr[ifo], norm[ifo] = \ matched_filter_core(hp, data[ifo], psd=psd[ifo], low_frequency_cutoff=20) snr[ifo] = snr_unnorm[ifo] * norm[ifo] self.snr = snr self.snr_unnorm = snr_unnorm self.norm = norm self.corr = corr self.hp = hp self.data = data self.psd = psd self.ifos = ifos
def signal_whiten(psd, signal, segment_duration, max_filter_duration, trunc_method='hann', low_frequency_cutoff=None): # Estimate the noise spectrum, no need for segment_duration, because we already get in line 193. psd = interpolate(psd, signal.delta_f) max_filter_len = int(max_filter_duration * signal.sample_rate) # Interpolate and smooth to the desired corruption length psd = inverse_spectrum_truncation(psd, max_filter_len=max_filter_len, low_frequency_cutoff=low_frequency_cutoff, trunc_method=trunc_method) # Whiten the data by the asd white = (signal.to_frequencyseries() / psd**0.5).to_timeseries() return white
def whiten_data(strain_list, psd, low_freq_cutoff=20.0): org_type = type(strain_list) if not org_type == list: strain_list = [strain_list] #set to strain[0].delta_f DF = 1.0 / strain_list[0].delta_t / ( 4 * strain_list[0].sample_rate ) #This is the definition of delta_f from the TimeSeries.whiten in the welchs method. #set to len(strain_list[0]) / 2 + 1 F_LEN = int(4 * strain_list[0].sample_rate / 2 + 1) get_hyper_waveform_defaults low_freq_diff = 20 if low_freq_cutoff > low_freq_diff: tmp_psd = aLIGOZeroDetHighPower(length=F_LEN, delta_f=DF, low_freq_cutoff=low_freq_cutoff - low_freq_diff) else: tmp_psd = aLIGOZeroDetHighPower(length=F_LEN, delta_f=DF, low_freq_cutoff=0) for i in range(len(strain_list)): max_filter_len = int( 4 * strain_list[i].sample_rate) #To replicate TimeSeries.whiten tmp_psd_2 = interpolate( tmp_psd, strain_list[i].delta_f) #To replicate TimeSeries.whiten tmp_psd_2 = inverse_spectrum_truncation( tmp_psd_2, max_filter_len=max_filter_len, low_frequency_cutoff=low_freq_cutoff, trunc_method='hann') strain_list[i] = (strain_list[i].to_frequencyseries() / tmp_psd_2**0.5).to_timeseries() strain_list[i] = strain_list[i][int(float(max_filter_len) / 2):int( len(strain_list[i]) - float(max_filter_len) / 2)] #To replicate TimeSeries.whiten if not org_type == list: return (strain_list[0]) else: return (strain_list)
def whiten_data_new(strain_list, low_freq_cutoff=20., max_filter_duration=4., psd=None): org_type = type(strain_list) if not org_type == list: strain_list = [strain_list] ret = [] for strain in strain_list: df = strain.delta_f f_len = int(len(strain) / 2) + 1 if psd is None: psd = aLIGOZeroDetHighPower(length=f_len, delta_f=df, low_freq_cutoff=low_freq_cutoff - 2.) else: if not len(psd) == f_len: msg = 'Length of PSD does not match data.' raise ValueError(msg) elif not psd.delta_f == df: psd = interpolate(psd, df) max_filter_len = int( max_filter_duration * strain.sample_rate) #Cut out the beginning and end psd = inverse_spectrum_truncation(psd, max_filter_len=max_filter_len, low_frequency_cutoff=low_freq_cutoff, trunc_method='hann') f_strain = strain.to_frequencyseries() kmin = int(low_freq_cutoff / df) f_strain.data[:kmin] = 0 f_strain.data[-1] = 0 f_strain.data[kmin:] /= psd[kmin:]**0.5 strain = f_strain.to_timeseries() ret.append(strain[max_filter_len:len(strain) - max_filter_len]) if not org_type == list: return (ret[0]) else: return (ret)
frange = [1230, 1240] # frequency range (Hz) taurange = [0.06, 0.07] # Quality factor ranges mm = 0.03 # maximum mismatch tb = ringdown.RingdownTemplateBank(frange, taurange=taurange, mm=mm) flow = lowcutoff # get the initial chunk of data to matched filter - let's get four seconds # after ignoring the first two seconds due to the filter response respbuffer = 2 chunkdur = 4 inidata = pycbcdata.crop(respbuffer, duration - (respbuffer + chunkdur)) initilde = inidata.to_frequencyseries() # get the psd using the whole data segment (using 128 / 16 length segments) psd = pycbcdata.filter_psd(128 / 16, (8 / samplerate), flow) psd = interpolate(psd, initilde.delta_f) # perform matched filtering for i, waveform in enumerate( tb.generate_waveforms(domain="frequency", deltaf=initilde.delta_f)): hp, hc = waveform hp.resize(len(initilde)) snr = pycbc.filter.matched_filter(hp, initilde, psd=psd, low_frequency_cutoff=flow) # remove regions corrupted by filter wraparound (see https://pycbc.org/pycbc/latest/html/gw150914.html#calculate-the-signal-to-noise) snr = snr[len(snr) // 4:len(snr) * 3 // 4]
injected_ts_highpass = highpass(signal_and_noise, 0.01) #crop to avoid filter wraparound conditioned = injected_ts_highpass.crop(2,2) #display to check for excessive wraparound -> increase crop length # plt.figure() # plt.plot(conditioned.sample_times, conditioned, label='conditioned data for matched filter') # plt.xlabel('times (s)') # plt.ylabel('Noise + hidden signal strain amplitude') # plt.legend()ju # plt.show() #make sure noise psd is of same delta_f as the noise data timeseries signal_and_noise_psd = welch_function.pycbc_welch(conditioned, 15) grace_psd = psd.interpolate(welch_function.pycbc_welch(merged_noise_ts.copy(), 15), conditioned.delta_f) #grace_psd = psd.interpolate(welch_function.pycbc_welch(signal_and_noise.copy(), 15), conditioned.delta_f) #sig_n_c = signal_and_noise_psd.copy() #grace_psd = psd.interpolate(sig_n_c, conditioned.delta_f) plt.figure() plt.loglog(grace_psd.sample_frequencies, np.sqrt(grace_psd), label='noise model asd with no signal') plt.loglog(signal_and_noise_psd.sample_frequencies, np.sqrt(signal_and_noise_psd), label='signal and noise asd') plt.loglog(grace_freqs, grace_asd, label='gracefo asd') plt.legend() plt.xlabel('frequency (Hz)') plt.ylabel('strain amplitude spectral density (1/sqrt(Hz))') plt.grid() #plt.show()
def snr_distance_plotter_wf_self_generating(mass1, mass2, f_lower_bound, dt, theta, distance_array, noise_psd): snr_values_pycbc_welch = [] snr_values_fft = [] snr_values_scipy_welch = [] for r in distance_array: times, plus_strain, cross_strain = q_c_py2.obs_time_inspiral_strain( mass1, mass2, f_lower_bound, dt, r, theta) h_ts = types.timeseries.TimeSeries(plus_strain, dt) #find psd via welch------------------------------------------------------------------------------------------- h_fs_pycbc = welch_function.pycbc_welch( h_ts.copy(), 15) #15 is number of segments used #interpolate the larger df of the two to match h_fs_pycbc = psd.interpolate(h_fs_pycbc, noise_psd.delta_f) #calculate snr psd_ratio_pycbc_welch = (4.0 * h_fs_pycbc) / (noise_psd) snr_squared_pycbc_welch = psd_ratio_pycbc_welch.sum() snr_estimate_pycbc_welch = np.sqrt(snr_squared_pycbc_welch) #add to snr list snr_values_pycbc_welch.append(snr_estimate_pycbc_welch) #find psd via fft-------------------------------------------------------------------------------------------- #take fft and calculate psd freqs = np.fft.fftfreq(np.size(h_ts)) mask = freqs > 0 raw_fft_h_ts = np.fft.fft(h_ts.copy()) psd_of_h_ts = 2.0 * (np.abs(raw_fft_h_ts / float(np.size(h_ts))))**2.0 #turn psd to frequencyseries with df of fftfreqs fft_psd = types.frequencyseries.FrequencySeries( psd_of_h_ts[mask], delta_f=(1.0 / float(h_ts.duration))) fft_psd = psd.interpolate(fft_psd, noise_psd.delta_f) psd_ratio_fft = (4.0 * fft_psd) / (noise_psd[:-2]) snr_squared_fft = psd_ratio_fft.sum() snr_estimate_fft = np.sqrt(snr_squared_fft) snr_values_fft.append(snr_estimate_fft) #find psd via scipy welch------------------------------------------------------------------------------------ f_s = 10 #sampling frequency frequency_array, sp_welch_psd = welch_function.scipy_welch( h_ts.copy(), f_s, 15) #15 to match the pycbc welch segment # sp_welch_psd = types.frequencyseries.FrequencySeries( sp_welch_psd, delta_f=(frequency_array[1] - frequency_array[0])) sp_welch_psd = psd.interpolate(sp_welch_psd, noise_psd.delta_f) psd_ratio_sp_welch = (4.0 * sp_welch_psd) / (noise_psd) snr_squared_sp_welch = psd_ratio_sp_welch.sum() snr_estimate_sp_welch = np.sqrt(snr_squared_sp_welch) snr_values_scipy_welch.append(snr_estimate_sp_welch) plt.loglog(distance_array, snr_values_fft, label='fft') plt.loglog(distance_array, snr_values_pycbc_welch, label='pycbc welch') plt.loglog(distance_array, snr_values_scipy_welch, label='scipy welch') plt.grid() plt.xlabel('distance in pc') plt.ylabel('snr') plt.legend(loc="upper right") plt.show() return snr_values_pycbc_welch, snr_values_fft, snr_values_scipy_welch #Note to self, build function that takes in the waveform as an input parameter instead of generating it
from pycbc.filter import highpass_fir, lowpass_fir from pycbc.psd import welch, interpolate from pycbc.types import TimeSeries try: from urllib.request import urlretrieve except ImportError: # python < 3 from urllib import urlretrieve # Read data and remove low frequency content fname = 'H-H1_LOSC_4_V2-1126259446-32.gwf' url = "https://www.gw-openscience.org/GW150914data/" + fname urlretrieve(url, filename=fname) h1 = highpass_fir(read_frame(fname, 'H1:LOSC-STRAIN'), 15.0, 8) # Calculate the noise spectrum and whiten psd = interpolate(welch(h1), 1.0 / 32) white_strain = (h1.to_frequencyseries() / psd ** 0.5 * psd.delta_f).to_timeseries() # remove some of the high and low frequencies smooth = highpass_fir(white_strain, 25, 8) smooth = lowpass_fir(white_strain, 250, 8) #strech out and shift the frequency upwards to aid human hearing fdata = smooth.to_frequencyseries() fdata.roll(int(1200 / fdata.delta_f)) smooth = TimeSeries(fdata.to_timeseries(), delta_t=1.0/1024) #Take slice around signal smooth = smooth[len(smooth)/2 - 1500:len(smooth)/2 + 3000] smooth.save_to_wav('gw150914_h1_chirp.wav')
def generate_sample(static_arguments, event_tuple, waveform_params=None): """ Generate a single sample (or example) by taking a piece of LIGO background noise (real or synthetic, depending on `event_tuple`), optionally injecting a simulated waveform (depending on `waveform_params`) and post-processing the result (whitening, band-passing). Args: static_arguments (dict): A dictionary containing global technical parameters for the sample generation, for example the target_sampling_rate of the output. event_tuple (tuple): A tuple `(event_time, file_path)`, which specifies the GPS time at which to make an injection and the path of the HDF file which contains said GPS time. If `file_path` is `None`, synthetic noise will be used instead and the `event_time` only serves as a seed for the corresponding (random) noise generator. waveform_params (dict): A dictionary containing the randomly sampled parameters that are passed as inputs to the waveform model (e.g., the masses, spins, position, ...). Returns: A tuple `(sample, injection_parameters)`, which contains the generated `sample` itself (a dict with keys `{'event_time', 'h1_strain', 'l1_strain'}`), and the `injection_parameters`, which are either `None` (in case no injection was made), or a dict containing the `waveform_params` and some additional parameters (e.g., single detector SNRs). """ # ------------------------------------------------------------------------- # Define shortcuts for some elements of self.static_arguments # ------------------------------------------------------------------------- # Read out frequency-related arguments original_sampling_rate = static_arguments['original_sampling_rate'] target_sampling_rate = static_arguments['target_sampling_rate'] f_lower = static_arguments['f_lower'] delta_f = static_arguments['delta_f'] fd_length = static_arguments['fd_length'] # Get the width of the noise sample that we either select from the raw # HDF files, or generate synthetically noise_interval_width = static_arguments['noise_interval_width'] # Get how many seconds before and after the event time to use seconds_before_event = static_arguments['seconds_before_event'] seconds_after_event = static_arguments['seconds_after_event'] # Get the event time and the dict containing the HDF file path event_time, hdf_file_paths = event_tuple # ------------------------------------------------------------------------- # Get the background noise (either from data or synthetically) # ------------------------------------------------------------------------- # If the event_time is None, we generate synthetic noise if hdf_file_paths is None: # Create an artificial PSD for the noise # TODO: Is this the best choice for this task? psd = aLIGOZeroDetHighPower(length=fd_length, delta_f=delta_f, low_freq_cutoff=f_lower) # Actually generate the noise using the PSD and LALSimulation noise = dict() for i, det in enumerate(('H1', 'L1')): # Compute the length of the noise sample in time steps noise_length = noise_interval_width * target_sampling_rate # Generate the noise for this detector noise[det] = noise_from_psd(length=noise_length, delta_t=(1.0 / target_sampling_rate), psd=psd, seed=(2 * event_time + i)) # Manually fix the noise start time to match the fake event time. # However, for some reason, the correct setter method seems broken? start_time = event_time - noise_interval_width / 2 # noinspection PyProtectedMember noise[det]._epoch = LIGOTimeGPS(start_time) # Otherwise we select the noise from the corresponding HDF file else: kwargs = dict(hdf_file_paths=hdf_file_paths, gps_time=event_time, interval_width=noise_interval_width, original_sampling_rate=original_sampling_rate, target_sampling_rate=target_sampling_rate, as_pycbc_timeseries=True) noise = get_strain_from_hdf_file(**kwargs) # ------------------------------------------------------------------------- # If applicable, make an injection # ------------------------------------------------------------------------- # If no waveform parameters are given, we are not making an injection. # In this case, there are no detector signals and no injection # parameters, and the strain is simply equal to the noise if waveform_params is None: detector_signals = None output_signals = None injection_parameters = None output_signals = None strain = noise # Otherwise, we need to simulate a waveform for the given waveform_params # and add it into the noise to create the strain else: # --------------------------------------------------------------------- # Simulate the waveform with the given injection parameters # --------------------------------------------------------------------- # Actually simulate the waveform with these parameters waveform = get_waveform(static_arguments=static_arguments, waveform_params=waveform_params) # Get the detector signals by projecting on the antenna patterns detector_signals = \ get_detector_signals(static_arguments=static_arguments, waveform_params=waveform_params, event_time=event_time, waveform=waveform) # Store the output_signal output_signals = {} output_signals = detector_signals.copy() # --------------------------------------------------------------------- # Add the waveform into the noise as is to calculate the NOMF-SNR # --------------------------------------------------------------------- # Store the dummy strain, the PSDs and the SNRs for the two detectors strain_ = {} psds = {} snrs = {} # Calculate these quantities for both detectors for det in ('H1', 'L1'): # Add the simulated waveform into the noise to get the dummy strain strain_[det] = noise[det].add_into(detector_signals[det]) # Estimate the Power Spectral Density from the dummy strain, this 1 is the psd segment duration of the strain psds[det] = strain_[det].psd(1) psds[det] = interpolate(psds[det], delta_f=delta_f) # Use the PSD estimate to calculate the optimal matched # filtering SNR for this injection and this detector snrs[det] = sigma(htilde=detector_signals[det], psd=psds[det], low_frequency_cutoff=f_lower) # Calculate the network optimal matched filtering SNR for this # injection (which we need for scaling to the chosen injection SNR) nomf_snr = np.sqrt(snrs['H1']**2 + snrs['L1']**2) # --------------------------------------------------------------------- # Add the waveform into the noise with the chosen injection SNR # --------------------------------------------------------------------- # Compute the rescaling factor #injection_snr = waveform_params['injection_snr'] injection_snr = static_arguments['injection_snr'] scale_factor = 1.0 * injection_snr / nomf_snr strain = {} for det in ('H1', 'L1'): # Add the simulated waveform into the noise, using a scaling # factor to ensure that the resulting NOMF-SNR equals the chosen # injection SNR strain[det] = noise[det].add_into(scale_factor * detector_signals[det]) output_signals[det] = scale_factor * output_signals[det] # --------------------------------------------------------------------- # Store some information about the injection we just made # --------------------------------------------------------------------- # Store the information we have computed ourselves injection_parameters = {'scale_factor': scale_factor, 'h1_snr': snrs['H1'], 'l1_snr': snrs['L1']} # Also add the waveform parameters we have sampled for key, value in waveform_params.iteritems(): injection_parameters[key] = value # ------------------------------------------------------------------------- # Whiten and bandpass the strain (also for noise-only samples) # ------------------------------------------------------------------------- for det in ('H1', 'L1'): # Get the whitening parameters segment_duration = static_arguments['whitening_segment_duration'] max_filter_duration = static_arguments['whitening_max_filter_duration'] # Whiten the strain (using the built-in whitening of PyCBC) # We don't need to remove the corrupted samples here, because we # crop the strain later on strain[det] = \ strain[det].whiten(segment_duration=segment_duration, max_filter_duration=max_filter_duration, remove_corrupted=False) if waveform_params is not None: output_signals[det] = \ signal_whiten(psd = psds[det], signal = output_signals[det], segment_duration = segment_duration, max_filter_duration = max_filter_duration) # Get the limits for the bandpass bandpass_lower = static_arguments['bandpass_lower'] bandpass_upper = static_arguments['bandpass_upper'] # Apply a high-pass to remove everything below `bandpass_lower`; # If bandpass_lower = 0, do not apply any high-pass filter. if bandpass_lower != 0: strain[det] = strain[det].highpass_fir(frequency=bandpass_lower, remove_corrupted=False, order=512) if waveform_params is not None: output_signals[det] = output_signals[det].highpass_fir(frequency=bandpass_lower, remove_corrupted=False, order=512) # Apply a low-pass filter to remove everything above `bandpass_upper`. # If bandpass_upper = sampling rate, do not apply any low-pass filter. if bandpass_upper != target_sampling_rate: strain[det] = strain[det].lowpass_fir(frequency=bandpass_upper, remove_corrupted=False, order=512) if waveform_params is not None: output_signals[det] = output_signals[det].lowpass_fir(frequency=bandpass_upper, remove_corrupted=False, order=512) # ------------------------------------------------------------------------- # Cut strain (and signal) time series to the pre-specified length # ------------------------------------------------------------------------- for det in ('H1', 'L1'): # Define some shortcuts for slicing a = event_time - seconds_before_event b = event_time + seconds_after_event # Cut the strain to the desired length strain[det] = strain[det].time_slice(a, b) # If we've made an injection, also cut the simulated signal if waveform_params is not None: # Cut the detector signals to the specified length detector_signals[det] = detector_signals[det].time_slice(a, b) output_signals[det] = output_signals[det].time_slice(a, b) # Also add the detector signals to the injection parameters injection_parameters['h1_signal'] = \ np.array(detector_signals['H1']) injection_parameters['l1_signal'] = \ np.array(detector_signals['L1']) injection_parameters['h1_output_signal'] = \ np.array(output_signals['H1']) injection_parameters['l1_output_signal'] = \ np.array(output_signals['L1']) # ------------------------------------------------------------------------- # Collect all available information about this sample and return results # ------------------------------------------------------------------------- # The whitened strain is numerically on the order of O(1), so we can save # it as a 32-bit float (unlike the original signal, which is down to # O(10^-{30}) and thus requires 64-bit floats). sample = {'event_time': event_time, 'h1_strain': np.array(strain['H1']).astype(np.float32), 'l1_strain': np.array(strain['L1']).astype(np.float32)} return sample, injection_parameters
from pycbc.filter import highpass_fir, lowpass_fir, matched_filter from pycbc.waveform import get_fd_waveform from pycbc.psd import welch, interpolate import urllib import pylab for ifo in ['H1', 'L1']: # Read data and remove low frequency content fname = '%s-%s_LOSC_4_V2-1126259446-32.gwf' % (ifo[0], ifo) url = "https://losc.ligo.org/s/events/GW150914/" + fname urllib.urlretrieve(url, filename=fname) h1 = read_frame(fname, '%s:LOSC-STRAIN' % ifo) h1 = highpass_fir(h1, 15, 8) # Calculate the noise spectrum psd = interpolate(welch(h1), 1.0 / h1.duration) # whiten white_strain = (h1.to_frequencyseries() / psd ** 0.5 * psd.delta_f).to_timeseries() # remove some of the high and low smooth = highpass_fir(white_strain, 35, 8) smooth = lowpass_fir(white_strain, 300, 8) # time shift and flip L1 if ifo == 'L1': smooth *= -1 smooth.roll(int(.007 / smooth.delta_t)) pylab.plot(smooth.sample_times, smooth, label=ifo)
from pycbc.frame import read_frame from pycbc.filter import highpass_fir, matched_filter from pycbc.waveform import get_fd_waveform from pycbc.psd import welch, interpolate import urllib # 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
def whiten_data(strain_list, low_freq_cutoff=20., max_filter_duration=4., psd=None): """Returns the data whitened by the PSD. Arguments --------- strain_list : list of pycbc.TimeSeries or pycbc.TimeSeries The data that should be whitened. low_freq_cutoff : {float, 20.} The lowest frequency that is considered during calculations. It must be >= than the lowest frequency where the PSD is not zero. Unit: hertz max_filter_duration : {float, 4.} The duration to which the PSD is truncated to in the time-domain. The amount of time is removed from both the beginning and end of the input data to avoid wrap-around errors. Unit: seconds psd : {None or pycbc.FrequencySeries, None} The PSD that should be used to whiten the data. If set to None the pycbc.psd.aLIGOZeroDetHighPower PSD will be used. If a PSD is provided which does not fit the delta_f of the data, it will be interpolated to fit. Returns ------- list of pycbc.TimeSeries or TimeSeries Depending on the input type it will return a list of TimeSeries or a single TimeSeries. The data contained in this time series is the whitened input data, where the inital and final seconds as specified by max_filter_duration are removed. """ org_type = type(strain_list) if not org_type == list: strain_list = [strain_list] ret = [] for strain in strain_list: df = strain.delta_f f_len = int(len(strain) / 2) + 1 if psd is None: psd = aLIGOZeroDetHighPower(length=f_len, delta_f=df, low_freq_cutoff=low_freq_cutoff - 2.) else: if not len(psd) == f_len: msg = 'Length of PSD does not match data.' raise ValueError(msg) elif not psd.delta_f == df: psd = interpolate(psd, df) max_filter_len = int( max_filter_duration * strain.sample_rate) #Cut out the beginning and end psd = inverse_spectrum_truncation(psd, max_filter_len=max_filter_len, low_frequency_cutoff=low_freq_cutoff, trunc_method='hann') f_strain = strain.to_frequencyseries() kmin = int(low_freq_cutoff / df) f_strain.data[:kmin] = 0 f_strain.data[-1] = 0 f_strain.data[kmin:] /= psd[kmin:]**0.5 strain = f_strain.to_timeseries() ret.append(strain[max_filter_len:len(strain) - max_filter_len]) if not org_type == list: return (ret[0]) else: return (ret)
hp, hc = get_td_waveform(approximant='SEOBNRv4_opt', mass1=mass, mass2=mass, delta_t=delta_t, f_lower=25, distance=100) noise = generate_noise(time_duration, delta_f, delta_t, f_min) merger_time = (1 / 4096) * hp.numpy().argmax() snr = 20 hp_size = len(hp) hp.resize(time_duration * f_sample) psd = noise.psd(4) psd = interpolate(psd, hp.delta_f) sigma = matchedfilter.sigma(hp, psd=psd, low_frequency_cutoff=f_min) Amplitude = snr / (sigma) hp *= Amplitude hp.resize(hp_size) merger_time = 69 merger_index = int(69 / delta_t) + 1 start_index = merger_index + len(hp) waveform = TimeSeries(numpy.zeros(len(noise)), delta_t=delta_t, \ dtype=real_same_precision_as(noise)) waveform[merger_index:start_index] = hp signal = noise + waveform
# Read the detector data and remove low frequencycontent strain[ifo] = highpass(ts,15) # Remove time corrupted by the high pass filter strain[ifo] = strain[ifo].crop(4,4) # Also create a frequency domain version of the data stilde[ifo] = strain[ifo].to_frequencyseries() #print (strain.delta_t) pylab.plot(strain['H1'].sample_times, strain['H1']) pylab.xlabel('Time (s)') pylab.show() from pycbc.psd import interpolate, inverse_spectrum_truncation psds = {} for ifo in ['L1','H1']: # Calculate a psd from the data. We'll use 2s segments in a median -welch style estimate# We then interpolate the PSD to the desired frequencystep. psds[ifo] = interpolate(strain[ifo].psd(2), stilde[ifo].delta_f) # We explicitly control how much data will be corruptedbyoverwhitening the data later on# In this case we choose 2 seconds. psds[ifo] = inverse_spectrum_truncation(psds[ifo],int(2*strain[ifo].sample_rate),low_frequency_cutoff=15.0,trunc_method='hann') pylab.loglog(psds[ifo].sample_frequencies, psds[ifo],label=ifo) pylab.xlim(20,1024) pylab.ylim(1e-47,1e-42) pylab.legend() from pycbc.waveform import get_fd_waveform from pycbc.filter import matched_filter from pycbc.conversions import mass1_from_mchirp_q import numpy # 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
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
def get_chirp_time_region(trigger_params, psd, miss_match, f_lower=30., f_max=2048., f_ref=30.): central_param = copy.deepcopy(trigger_params) # if central_param['approximant'] == 'SPAtmplt': central_param['approximant'] == 'TaylorF2RedSpin' # if not ('tau0' and 'tau3' in central_param): # t0, t3 = pnu.mass1_mass2_to_tau0_tau3(central_param['mass1'], central_param['mass2'], f_ref) # else: # t0 = central_param['tau0'] # t3 = central_param['tau3'] # for tau0 boundary newt0, newt3 = temp_tau0_tau3_with_valid_dtau0(central_param['tau0'], central_param['tau3'], f_ref) temp_param0 = temp_param_from_central_param(central_param, newt0, newt3, f_ref) # for tau3 boundary newt0, newt3 = temp_tau0_tau3_with_valid_dtau3(central_param['tau0'], central_param['tau3'], f_ref) temp_param3 = temp_param_from_central_param(central_param, newt0, newt3, f_ref) tlen = pnu.nearest_larger_binary_number( max([central_param['tau0'], temp_param0['tau0'], temp_param3['tau0']])) df = 1.0 / tlen flen = int(f_max / df) + 1 # hp = pt.zeros(flen, dtype=pt.complex64) # hp0 = pt.zeros(flen, dtype=pt.complex64) # hp3 = pt.zeros(flen, dtype=pt.complex64) # print central_param['approximant'] # if central_param['approximant'] == 'SPAtmplt': # central_param['approximant'] == 'TaylorF2RedSpin' # hp = pw.get_waveform_filter(hp, central_param, delta_f=df, f_lower=f_lower, f_ref=f_ref, f_final=f_max) # hp0 = pw.get_waveform_filter(hp0, temp_param0, delta_f=df, f_lower=f_lower, f_ref=f_ref, f_final=f_max) # hp3 = pw.get_waveform_filter(hp3, temp_param3, delta_f=df, f_lower=f_lower, f_ref=f_ref, f_final=f_max) # else: hp, hc = pw.get_fd_waveform(central_param, delta_f=df, f_lower=f_lower, f_ref=f_ref, f_final=f_max) hp0, hc0 = pw.get_fd_waveform(temp_param0, delta_f=df, f_lower=f_lower, f_ref=f_ref, f_final=f_max) hp3, hc3 = pw.get_fd_waveform(temp_param3, delta_f=df, f_lower=f_lower, f_ref=f_ref, f_final=f_max) # FIXME: currently will using aLIGOZeroDetHighPower # FIXME: add how to make sure, psd numerical problems of psd if psd is not None: ipsd = pp.interpolate(psd, df) else: ipsd = None # ipsd = pp.aLIGOZeroDetHighPower(flen, df, f_lower) # ipsd = pp.interpolate(ipsd, df) # ipsd.data[-1] = 2.0*ipsd.data[-2] # ipsd = ipsd.astype(hp.dtype) mat0, _ = pf.match(hp, hp0, ipsd, f_lower, f_max) mat3, _ = pf.match(hp, hp3, ipsd, f_lower, f_max) # print mat0, mat3, miss_match # print central_param['tau0'], central_param['tau3'] # print temp_param0['tau0'], temp_param0['tau3'] # print temp_param3['tau0'], temp_param3['tau3'] # print float(temp_param0['tau0'])-float(central_param['tau0']) # print temp_param3['tau3']-central_param['tau3'] dtau0_range = miss_match * (temp_param0['tau0'] - central_param['tau0']) / (1.0 - mat0) dtau3_range = miss_match * (temp_param3['tau3'] - central_param['tau3']) / (1.0 - mat3) # print dtau0_range, dtau3_range return dtau0_range, dtau3_range
# template = np.roll(template, (np.size(template) - np.size(hp_ts) )) # template = types.timeseries.TimeSeries(template, delta_t=dt) plt.figure() plt.plot(template.sample_times, template, label='template rotated for filter') plt.grid() plt.legend() plt.show() noise_psd = welch_function.pyc_welch(merged_noise_ts.copy(), seg_size) #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)
from pycbc.frame import read_frame from pycbc.filter import highpass_fir, lowpass_fir from pycbc.psd import welch, interpolate from pycbc.types import TimeSeries 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 = highpass_fir(read_frame(fname, 'H1:LOSC-STRAIN'), 15.0, 8) # Calculate the noise spectrum and whiten psd = interpolate(welch(h1), 1.0 / 32) white_strain = (h1.to_frequencyseries() / psd ** 0.5 * psd.delta_f).to_timeseries() # remove some of the high and low frequencies smooth = highpass_fir(white_strain, 25, 8) smooth = lowpass_fir(white_strain, 250, 8) #strech out and shift the frequency upwards to aid human hearing fdata = smooth.to_frequencyseries() fdata.roll(int(1200 / fdata.delta_f)) smooth = TimeSeries(fdata.to_timeseries(), delta_t=1.0/1024) #Take slice around signal smooth = smooth[len(smooth)/2 - 1500:len(smooth)/2 + 3000] smooth.save_to_wav('gw150914_h1_chirp.wav')
# ========================= # = Precondition the data = # ========================= # Remove low frequency noise hoft = highpass(hoft, 15.0) hoft = resample_to_delta_t(hoft, 1./2048.) # Remove 2 seconds from the start and the end to protect against edge effects conditioned = hoft.crop(2, 2) # Calculate PSD of data psd = conditioned.psd(4) psd = interpolate(psd, conditioned.delta_f) psd = inverse_spectrum_truncation(psd, 4 * conditioned.sample_rate, low_frequency_cutoff=15) psdlist[i] = psd # Generate a zeros frequency series the same length as the psd filter = FrequencySeries(numpy.zeros(len(psd)), 1, dtype=numpy.complex128) # Generate the waveform filter with given params filter = get_waveform_filter(filter, approximant=params.apx, mass1=m1, mass2=m2, sp1z=params.sp1z,