def get_waveforms(self): """The waveforms generated using the current parameters. If the waveforms haven't been generated yet, they will be generated, resized to the same length as the data, and cached. If the ``highpass_waveforms`` attribute is set, a highpass filter will also be applied to the waveforms. Returns ------- dict : Dictionary of detector names -> FrequencySeries. """ if self._current_wfs is None: params = self.current_params wfs = self.waveform_generator.generate(**params) for det, h in wfs.items(): # make the same length as the data h.resize(len(self.data[det])) # apply high pass if self.highpass_waveforms: h = highpass(h.to_timeseries(), frequency=self.highpass_waveforms ).to_frequencyseries() wfs[det] = h self._current_wfs = wfs return self._current_wfs
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 get_waveforms(self): if self._current_wfs is None: params = self.current_params wfs = self.waveform_generator.generate(**params) for det, (hp, hc) in wfs.items(): # make the same length as the data hp.resize(len(self.data[det])) hc.resize(len(self.data[det])) # apply high pass if self.highpass_waveforms: hp = highpass(hp.to_timeseries(), frequency=self.highpass_waveforms ).to_frequencyseries() hc = highpass(hc.to_timeseries(), frequency=self.highpass_waveforms ).to_frequencyseries() wfs[det] = (hp, hc) self._current_wfs = wfs return self._current_wfs
def get_GWSC_Full_strain(pth, tstart, tend): """This function, require the strain .gwf name, without the detector definition (H-H1,L-L1), and loads the entire frame file downloaded from GW OSC, applies a high-pass filter at 15 Hz, then return the whole data without cutting that """ strain = {} for ifo in ifos: fname = '%s-%s_%s' % (ifo[0], ifo, pth) channel_name = '%s:GWOSC-4KHZ_R1_STRAIN' % ifo strain[ifo] = read_frame(fname, channel_name, tstart, tend) strain[ifo] = highpass(strain[ifo], 15.0) return strain
def get_raw_strain(window=512): """This function loads the entire frame file downloaded from GW OSC, applies a high-pass filter at 15 Hz, then keeps the data around ``event_time`` +/-``window``. The ``event_time`` is from above; the default window is 512 (s). """ strain = {} for ifo in ifos: fname = '%s-%s_LOSC_4_V2-1126257414-4096.gwf' % (ifo[0], ifo) channel_name = '%s:LOSC-STRAIN' % ifo strain[ifo] = read_frame(fname, channel_name) strain[ifo] = highpass(strain[ifo], 15.0) strain[ifo] = strain[ifo].time_slice(event_time-window/2, event_time+window/2) return strain
def get_LSC_NoNan_strain(pth, tev, tstart, tend, window): """This function, require the strain .gwf name, without the detector definition (H-H1,L-L1), and loads the entire frame file downloaded from GW OSC, applies a high-pass filter at 15 Hz, then keeps the data around ``event_time`` +/-``window``. The ``event_time`` is from above; the default window is 512 (s). """ strain = {} for ifo in ifos: fname = '%s-%s_%s' % (ifo[0], ifo, pth) channel_name = '%s:LOSC-STRAIN' % ifo strain[ifo] = read_frame(fname, channel_name, tstart, tend) strain[ifo] = highpass(strain[ifo], 15.0) strain[ifo] = strain[ifo].time_slice(tev - window / 2, tev + window / 2) return strain
def from_cli(opt, dyn_range_fac=1, precision='single'): """Parses the CLI options related to strain data reading and conditioning. Parameters ---------- opt : object Result of parsing the CLI with OptionParser, or any object with the required attributes (gps-start-time, gps-end-time, strain-high-pass, pad-data, sample-rate, (frame-cache or frame-files), channel-name, fake-strain, fake-strain-seed, gating_file). dyn_range_fac: {float, 1}, optional A large constant to reduce the dynamic range of the strain. Returns ------- strain : TimeSeries The time series containing the conditioned strain data. """ if opt.frame_cache or opt.frame_files: if opt.frame_cache: frame_source = opt.frame_cache if opt.frame_files: frame_source = opt.frame_files logging.info("Reading Frames") strain = read_frame(frame_source, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) if opt.zpk_z and opt.zpk_p and opt.zpk_k: logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Applying zpk filter") z = numpy.array(opt.zpk_z) p = numpy.array(opt.zpk_p) k = float(opt.zpk_k) strain = filter_zpk(strain.astype(numpy.float64), z, p, k) if opt.normalize_strain: logging.info("Dividing strain by constant") l = opt.normalize_strain strain = strain / l if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2]) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2]) logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) if precision == 'single': logging.info("Converting to float32") strain = (strain * dyn_range_fac).astype(float32) if opt.gating_file is not None: logging.info("Gating glitches") gate_params = numpy.loadtxt(opt.gating_file) if len(gate_params.shape) == 1: gate_params = [gate_params] strain = gate_data( strain, gate_params, data_start_time=(opt.gps_start_time - opt.pad_data)) logging.info("Resampling data") strain = resample_to_delta_t(strain, 1.0/opt.sample_rate, method='ldas') logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Remove Padding") start = opt.pad_data*opt.sample_rate end = len(strain)-opt.sample_rate*opt.pad_data strain = strain[start:end] if opt.fake_strain: logging.info("Generating Fake Strain") duration = opt.gps_end_time - opt.gps_start_time tlen = duration * opt.sample_rate pdf = 1.0/128 plen = int(opt.sample_rate / pdf) / 2 + 1 logging.info("Making PSD for strain") strain_psd = psd.from_string(opt.fake_strain, plen, pdf, opt.low_frequency_cutoff) logging.info("Making colored noise") strain = pycbc.noise.noise_from_psd(tlen, 1.0/opt.sample_rate, strain_psd, seed=opt.fake_strain_seed) strain._epoch = lal.LIGOTimeGPS(opt.gps_start_time) if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2]) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2]) if precision == 'single': logging.info("Converting to float32") strain = (dyn_range_fac * strain).astype(float32) if opt.injection_file: strain.injections = injections return strain
# Check that the median bias is the same print "%s segments" % nsegs print "BIAS pycbc", pycbc.psd.median_bias(nsegs) print "BIAS lal", lal.RngMedBias(nsegs) # Check the psd norm print "PYCBC psd norm", 2.0 / float(sample_rate) / ( w_pycbc.squared_norm().sum()) / pycbc.psd.median_bias(nsegs) # Same strain preparation for lal and pycbc psd estimation strain = read_frame("LER2.lcf", "H1:LDAS-STRAIN", start_time=start_time - pad_data, duration=duration + pad_data * 2) strain = highpass(strain, frequency=30) strain *= pycbc.DYN_RANGE_FAC strain = TimeSeries(strain, delta_t=strain.delta_t, epoch=strain.start_time, dtype=float32) strain = resample_to_delta_t(strain, 1.0 / sample_rate) strain = strain[int(pad_data * 1.0 / strain.delta_t):len(strain) - int(1.0 / strain.delta_t * pad_data)] psd_pycbc = pycbc.psd.welch(strain, seg_len=seg_len, seg_stride=stride) psd_lal = lal_psd_estimate(seg_len, strain) print psd_pycbc[-1] print psd_lal[-1]
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)
def highpass_raw_strain(strain2): for ifo in ifos: strain2[ifo] = highpass(strain2[ifo], 15.0) return strain2
pylab.xlabel('Time (s)') pylab.xlim(params.tc - params.plotzoom, params.tc + params.plotzoom) pylab.ylim([0, 30]) for filename in infile: # Load in data files file = cwd + '/' + filename hoft = pycbc.types.timeseries.load_timeseries(file) # ========================= # = 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
def from_cli(opt, dyn_range_fac=1, precision='single'): """Parses the CLI options related to strain data reading and conditioning. Parameters ---------- opt : object Result of parsing the CLI with OptionParser, or any object with the required attributes (gps-start-time, gps-end-time, strain-high-pass, pad-data, sample-rate, (frame-cache or frame-files), channel-name, fake-strain, fake-strain-seed, gating_file). dyn_range_fac: {float, 1}, optional A large constant to reduce the dynamic range of the strain. Returns ------- strain : TimeSeries The time series containing the conditioned strain data. """ gating_info = {} if opt.frame_cache or opt.frame_files or opt.frame_type: if opt.frame_cache: frame_source = opt.frame_cache if opt.frame_files: frame_source = opt.frame_files logging.info("Reading Frames") if opt.frame_type: strain = query_and_read_frame(opt.frame_type, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) else: strain = read_frame(frame_source, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) if opt.zpk_z and opt.zpk_p and opt.zpk_k: logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Applying zpk filter") z = numpy.array(opt.zpk_z) p = numpy.array(opt.zpk_p) k = float(opt.zpk_k) strain = filter_zpk(strain.astype(numpy.float64), z, p, k) if opt.normalize_strain: logging.info("Dividing strain by constant") l = opt.normalize_strain strain = strain / l if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) if precision == 'single': logging.info("Converting to float32") strain = (strain * dyn_range_fac).astype(float32) if opt.gating_file is not None: logging.info("Gating glitches") gate_params = numpy.loadtxt(opt.gating_file) if len(gate_params.shape) == 1: gate_params = [gate_params] strain = gate_data(strain, gate_params) gating_info['file'] = \ [gp for gp in gate_params \ if (gp[0] + gp[1] + gp[2] >= strain.start_time) \ and (gp[0] - gp[1] - gp[2] <= strain.end_time)] if opt.autogating_threshold is not None: # the + 0 is for making a copy glitch_times = detect_loud_glitches( strain + 0., threshold=opt.autogating_threshold, cluster_window=opt.autogating_cluster, low_freq_cutoff=opt.strain_high_pass, high_freq_cutoff=opt.sample_rate/2, corrupted_time=opt.pad_data+opt.autogating_pad) gate_params = [[gt, opt.autogating_width, opt.autogating_taper] \ for gt in glitch_times] if len(glitch_times) > 0: logging.info('Autogating at %s', ', '.join(['%.3f' % gt for gt in glitch_times])) strain = gate_data(strain, gate_params) gating_info['auto'] = gate_params logging.info("Resampling data") strain = resample_to_delta_t(strain, 1.0/opt.sample_rate, method='ldas') logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Remove Padding") start = opt.pad_data*opt.sample_rate end = len(strain)-opt.sample_rate*opt.pad_data strain = strain[start:end] if opt.fake_strain: logging.info("Generating Fake Strain") duration = opt.gps_end_time - opt.gps_start_time tlen = duration * opt.sample_rate pdf = 1.0/128 plen = int(opt.sample_rate / pdf) / 2 + 1 logging.info("Making PSD for strain") strain_psd = pycbc.psd.from_string(opt.fake_strain, plen, pdf, opt.low_frequency_cutoff) logging.info("Making colored noise") strain = pycbc.noise.noise_from_psd(tlen, 1.0/opt.sample_rate, strain_psd, seed=opt.fake_strain_seed) strain._epoch = lal.LIGOTimeGPS(opt.gps_start_time) if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if precision == 'single': logging.info("Converting to float32") strain = (dyn_range_fac * strain).astype(float32) if opt.injection_file or opt.sgburst_injection_file: strain.injections = injections strain.gating_info = gating_info return strain
w_pycbc = Array(numpy.hanning(seg_len).astype(float32)) w_lal = lal.CreateHannREAL4Window(seg_len) print "hann props pycbc", w_pycbc.sum(), w_pycbc.squared_norm().sum() print "hann props lal", w_lal.sum, w_lal.sumofsquares # Check that the median bias is the same print "%s segments" % nsegs print "BIAS pycbc", pycbc.psd.median_bias(nsegs) print "BIAS lal", lal.RngMedBias(nsegs) # Check the psd norm print "PYCBC psd norm", 2.0 / float(sample_rate) / (w_pycbc.squared_norm().sum()) / pycbc.psd.median_bias(nsegs) # Same strain preparation for lal and pycbc psd estimation strain = read_frame("LER2.lcf", "H1:LDAS-STRAIN", start_time=start_time-pad_data, duration=duration+pad_data*2) strain = highpass(strain, frequency=30) strain *= pycbc.DYN_RANGE_FAC strain = TimeSeries(strain, delta_t=strain.delta_t, epoch=strain.start_time, dtype=float32) strain = resample_to_delta_t(strain, 1.0/sample_rate) strain = strain[int(pad_data*1.0/strain.delta_t):len(strain)-int(1.0/strain.delta_t*pad_data)] psd_pycbc = pycbc.psd.welch(strain, seg_len=seg_len, seg_stride=stride) psd_lal = lal_psd_estimate(seg_len, strain) print psd_pycbc[-1] print psd_lal[-1] pylab.figure(1) pylab.loglog(psd_pycbc.sample_frequencies.numpy(), psd_pycbc.numpy(), label="PyCBC") pylab.loglog(psd_lal.sample_frequencies.numpy(), psd_lal.numpy(), label="LAL") pylab.xlabel("Frequency (Hz)")
"""Cleaning and applying highpass filter. Downsample to 2048 Hz to make the data analysis more convenient. Power density of the noise is higher than the signal. At higher frequency the amplitude of the noise is lower. And then graph.""" from pycbc.catalog import Merger from pycbc.filter import resample_to_delta_t, highpass from pycbc.catalog import Merger from pycbc.filter import resample_to_delta_t, highpass merger = Merger("GW170817") strain, stilde = {}, {} # tuple of directories: strain and stilde=cleaned data for ifo in ['L1', 'H1']: # We'll download the data and select 256 seconds that includes the event time ts = merger.strain(ifo) # Remove the low frequency content and downsample the data to 2048Hz strain[ifo] = resample_to_delta_t(highpass(ts, 15.0), 1.0/2048) #remove the begining and ending spikes from the data strain[ifo] = strain[ifo].crop(2, 2) # remove 2 first and 2 last seconds # Also create a frequency domain version of the data stilde[ifo] = strain[ifo].to_frequencyseries() #print (strain.delta_t) pylab.plot(strain['L1'].sample_times, strain['L1']) pylab.xlabel('Time (s)') pylab.show() """***part 2*** Then the power spectral density is plotted. """
def from_cli(opt, dyn_range_fac=1, precision='single'): """Parses the CLI options related to strain data reading and conditioning. Parameters ---------- opt : object Result of parsing the CLI with OptionParser, or any object with the required attributes (gps-start-time, gps-end-time, strain-high-pass, pad-data, sample-rate, (frame-cache or frame-files), channel-name, fake-strain, fake-strain-seed, gating_file). dyn_range_fac: {float, 1}, optional A large constant to reduce the dynamic range of the strain. Returns ------- strain : TimeSeries The time series containing the conditioned strain data. """ gating_info = {} if opt.frame_cache or opt.frame_files or opt.frame_type: if opt.frame_cache: frame_source = opt.frame_cache if opt.frame_files: frame_source = opt.frame_files logging.info("Reading Frames") if opt.frame_type: strain = query_and_read_frame(opt.frame_type, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) else: strain = read_frame(frame_source, opt.channel_name, start_time=opt.gps_start_time-opt.pad_data, end_time=opt.gps_end_time+opt.pad_data) if opt.zpk_z and opt.zpk_p and opt.zpk_k: logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Applying zpk filter") z = numpy.array(opt.zpk_z) p = numpy.array(opt.zpk_p) k = float(opt.zpk_k) strain = filter_zpk(strain.astype(numpy.float64), z, p, k) if opt.normalize_strain: logging.info("Dividing strain by constant") l = opt.normalize_strain strain = strain / l if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) if precision == 'single': logging.info("Converting to float32") strain = (strain * dyn_range_fac).astype(pycbc.types.float32) if opt.gating_file is not None: logging.info("Gating glitches") gate_params = numpy.loadtxt(opt.gating_file) if len(gate_params.shape) == 1: gate_params = [gate_params] strain = gate_data(strain, gate_params) gating_info['file'] = \ [gp for gp in gate_params \ if (gp[0] + gp[1] + gp[2] >= strain.start_time) \ and (gp[0] - gp[1] - gp[2] <= strain.end_time)] if opt.autogating_threshold is not None: # the + 0 is for making a copy glitch_times = detect_loud_glitches( strain + 0., threshold=opt.autogating_threshold, cluster_window=opt.autogating_cluster, low_freq_cutoff=opt.strain_high_pass, high_freq_cutoff=opt.sample_rate/2, corrupt_time=opt.pad_data+opt.autogating_pad) gate_params = [[gt, opt.autogating_width, opt.autogating_taper] \ for gt in glitch_times] if len(glitch_times) > 0: logging.info('Autogating at %s', ', '.join(['%.3f' % gt for gt in glitch_times])) strain = gate_data(strain, gate_params) gating_info['auto'] = gate_params logging.info("Resampling data") strain = resample_to_delta_t(strain, 1.0/opt.sample_rate, method='ldas') logging.info("Highpass Filtering") strain = highpass(strain, frequency=opt.strain_high_pass) logging.info("Remove Padding") start = opt.pad_data*opt.sample_rate end = len(strain)-opt.sample_rate*opt.pad_data strain = strain[start:end] if opt.fake_strain: logging.info("Generating Fake Strain") duration = opt.gps_end_time - opt.gps_start_time tlen = duration * opt.sample_rate pdf = 1.0/128 plen = int(opt.sample_rate / pdf) / 2 + 1 logging.info("Making PSD for strain") strain_psd = pycbc.psd.from_string(opt.fake_strain, plen, pdf, opt.low_frequency_cutoff) logging.info("Making colored noise") strain = pycbc.noise.noise_from_psd(tlen, 1.0/opt.sample_rate, strain_psd, seed=opt.fake_strain_seed) strain._epoch = lal.LIGOTimeGPS(opt.gps_start_time) if opt.injection_file: logging.info("Applying injections") injections = InjectionSet(opt.injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if opt.sgburst_injection_file: logging.info("Applying sine-Gaussian burst injections") injections = SGBurstInjectionSet(opt.sgburst_injection_file) injections.apply(strain, opt.channel_name[0:2], distance_scale=opt.injection_scale_factor) if precision == 'single': logging.info("Converting to float32") strain = (dyn_range_fac * strain).astype(pycbc.types.float32) if opt.injection_file or opt.sgburst_injection_file: strain.injections = injections if opt.taper_data: logging.info("Tapering data") # Use auto-gating stuff for this, a one-sided gate is a taper pd_taper_window = opt.taper_data gate_params = [(strain.start_time, 0., pd_taper_window)] gate_params.append( (strain.end_time, 0., pd_taper_window) ) gate_data(strain, gate_params) strain.gating_info = gating_info return strain
plt.figure() plt.plot(random_waveform.sample_times, random_waveform, label='wf injection location') plt.legend() plt.xlabel('Time (s)') plt.grid() plt.show() injected_array = np.array(merged_noise_tsc) + np.array(random_waveform) signal_and_noise = types.timeseries.TimeSeries(injected_array, delta_t=merged_noise_tsc.delta_t) ## 6 - Matched filter - condition the noise curve and prepare psd ----------------------------------- # # 6.1 Prepatory steps and creating the match template------------------------------------------------- #Highpass the noise curve with injected waveform above 1e-2 Hz injected_ts_highpass = highpass(signal_and_noise, 0.01) #crop to avoid filter wraparound conditioned = injected_ts_highpass.crop(2,2) #template template = hp_ts.copy() template.resize(np.size(conditioned)) #template = template.cyclic_time_shift(conditioned.duration) # 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()
# %matplotlib inline import pylab from pycbc.filter import highpass from pycbc.catalog import Merger from pycbc.frame import read_frame merger = Merger("GW170817") import numpy as np import pycbc.types strain, stilde = {}, {} for ifo in['H1','L1']: # We'll download the data and select 256 secondsthat includes the event time ts =read_frame("{}-{}_LOSC_CLN_4_V1-1187007040-2048.gwf".format(ifo[0],ifo),'{}:LOSC-STRAIN'.format(ifo),start_time=merger.time -224,end_time=merger.time +32,check_integrity=False) # 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.