def make_strain_from_inj_object(self, inj, delta_t, detector_name, distance_scale=1, ts=None): if ts is None: ts = load_timeseries(inj.filename) self.set_ref_time(inj, ts) # slice and taper ts = self.slice_and_taper(inj, ts) # shift reference to the detector time ts._epoch += inj['{}_gps_time'.format(detector_name).lower()] # resample ts = resample_to_delta_t(ts, delta_t, method='ldas') # apply any phase shift try: phase_shift = inj[ '{}_phase_shift'.format(detector_name).lower()] except ValueError: phase_shift = 0 if phase_shift: fs = ts.to_frequencyseries() fs *= np.exp(1j*phase_shift) ts = fs.to_timeseries() # apply any scaling try: amp_scale = inj[ '{}_amp_scale'.format(detector_name).lower()] except ValueError: amp_scale = 1. amp_scale /= distance_scale ts *= amp_scale return ts
def _gen_slices(self, index_range): X = [ np.zeros( (len(index_range), len(self.ts) * 8, self.final_data_samples)) for i in range(2) ] for in_batch, idx in enumerate(index_range): for detector in range(len(self.ts)): low, up = idx #white_full_signal = self.ts[detector][low:up].whiten(4, 4) white_full_signal = whiten_data(self.ts[detector][low:up], psd=self.psd) max_idx = len(white_full_signal) min_idx = max_idx - int( float(self.num_samples) / float(self.resample_rates[0]) / self.dt) for i, sr in enumerate(self.resample_rates): X[0][in_batch][i * len(self.ts) + detector] = resample_to_delta_t( white_full_signal[min_idx:max_idx], 1.0 / sr) if not i + 1 == len(self.resample_rates): t_dur = float(self.num_samples) / float( self.resample_rates[i + 1]) sample_dur = int(t_dur / self.dt) max_idx = min_idx min_idx -= sample_dur #print("{}: in_batch: {}".format(detector, in_batch)) return ([X[0].transpose(0, 2, 1), X[1].transpose(0, 2, 1)])
def resampleado(strain,hh,grafica,fs,fs_ligo): template = types.TimeSeries(initial_array=hh, delta_t=1.0/fs , epoch=0) # Downsampling the data to 4096Hz || 8192Hz || 16KHz strain = resample_to_delta_t(strain, 1.0/fs) if grafica == 1: pylab.figure('Fig_strain') pylab.title('Strain resampled') pylab.plot(strain.sample_times, strain) pylab.xlabel('Time (s)') pylab.grid() pylab.show() pylab.figure('Fig_template') pylab.title('Template resampled') pylab.plot(template.sample_times, template) pylab.grid() pylab.xlabel('Time (s)') pylab.show() return template, strain
def get_waveform(approximant, phase_order, amplitude_order, template_params, start_frequency, sample_rate, length, filter_rate): if approximant in td_approximants(): hplus, hcross = get_td_waveform(template_params, approximant=approximant, phase_order=phase_order, delta_t=1.0 / sample_rate, f_lower=start_frequency, amplitude_order=amplitude_order) hvec = generate_detector_strain(template_params, hplus, hcross) if filter_rate != sample_rate: delta_t = 1.0 / filter_rate hvec = resample_to_delta_t(hvec, delta_t) elif approximant in fd_approximants(): delta_f = filter_rate / length if hasattr(template_params, "spin1z") and hasattr( template_params, "spin2z"): if template_params.spin1z <= -0.9 or template_params.spin1z >= 0.9: template_params.spin1z *= 0.99999999 if template_params.spin2z <= -0.9 or template_params.spin2z >= 0.9: template_params.spin2z *= 0.99999999 if True: print("\n spin1z = %f, spin2z = %f, chi = %f" % (template_params.spin1z, template_params.spin2z, lalsimulation.SimIMRPhenomBComputeChi( template_params.mass1 * lal.LAL_MSUN_SI, template_params.mass2 * lal.LAL_MSUN_SI, template_params.spin1z, template_params.spin2z)), file=sys.stderr) print("spin1x = %f, spin1y = %f" % (template_params.spin1x, template_params.spin1y), file=sys.stderr) print("spin2x = %f, spin2y = %f" % (template_params.spin2x, template_params.spin2y), file=sys.stderr) print("m1 = %f, m2 = %f" % (template_params.mass1, template_params.mass2), file=sys.stderr) hvec = get_fd_waveform(template_params, approximant=approximant, phase_order=phase_order, delta_f=delta_f, f_lower=start_frequency, amplitude_order=amplitude_order)[0] if True: print("filter_N = %d in get waveform" % filter_N, "\n type(hvec) in get_waveform:", type(hvec), file=sys.stderr) print(hvec, file=sys.stderr) print(hvec[0], file=sys.stderr) print(hvec[1], file=sys.stderr) print(isinstance(hvec, FrequencySeries), file=sys.stderr) htilde = make_padded_frequency_series(hvec, filter_N) return htilde
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 resample_and_whiten(self, data, dt): to_resample = data.whiten(4, 4) if dt == self.dt: return (np.array(to_resample.data[-1 * self.final_data_samples:])) else: return (np.array( resample_to_delta_t(to_resample, dt).data[-1 * self.final_data_samples:]))
def resampleado(strain, hh, grafica): template = types.TimeSeries(initial_array=hh, delta_t=1.0 / 8192, epoch=0) # Downsampling the data to 4096Hz || 8192Hz || 16KHz strain = resample_to_delta_t(strain, 1.0 / 8192) template = resample_to_delta_t(template, 1.0 / 8192) if grafica == 1: pylab.figure(figsize=[15, 5]) pylab.title('strain resampled') pylab.plot(strain.sample_times, strain) pylab.xlabel('Time (s)') pylab.show()
def _lalsim_td_waveform(**p): fail_tolerant_waveform_generation lal_pars = _check_lal_pars(p) #nonGRparams can be straightforwardly added if needed, however they have to # be invoked one by one try: hp1, hc1 = lalsimulation.SimInspiralChooseTDWaveform( float(pnutils.solar_mass_to_kg(p['mass1'])), float(pnutils.solar_mass_to_kg(p['mass2'])), float(p['spin1x']), float(p['spin1y']), float(p['spin1z']), float(p['spin2x']), float(p['spin2y']), float(p['spin2z']), pnutils.megaparsecs_to_meters(float(p['distance'])), float(p['inclination']), float(p['coa_phase']), float(p['long_asc_nodes']), float(p['eccentricity']), float(p['mean_per_ano']), float(p['delta_t']), float(p['f_lower']), float(p['f_ref']), lal_pars, _lalsim_enum[p['approximant']]) except RuntimeError: if not fail_tolerant_waveform_generation: raise # For some cases failure modes can occur. Here we add waveform-specific # instructions to try to work with waveforms that are known to fail. if 'SEOBNRv3' in p['approximant']: # Try doubling the sample time and redoing. # Don't want to get stuck in a loop though! if 'delta_t_orig' not in p: p['delta_t_orig'] = p['delta_t'] p['delta_t'] = p['delta_t'] / 2. if p['delta_t_orig'] / p['delta_t'] > 9: raise hp, hc = _lalsim_td_waveform(**p) p['delta_t'] = p['delta_t_orig'] hp = resample_to_delta_t(hp, hp.delta_t*2) hc = resample_to_delta_t(hc, hc.delta_t*2) return hp, hc raise #lal.DestroyDict(lal_pars) hp = TimeSeries(hp1.data.data[:], delta_t=hp1.deltaT, epoch=hp1.epoch) hc = TimeSeries(hc1.data.data[:], delta_t=hc1.deltaT, epoch=hc1.epoch) return hp, hc
def _lalsim_td_waveform(**p): flags = lalsimulation.SimInspiralCreateWaveformFlags() lalsimulation.SimInspiralSetSpinOrder(flags, p['spin_order']) lalsimulation.SimInspiralSetTidalOrder(flags, p['tidal_order']) ########### def rulog2(val): return 2.0**numpy.ceil(numpy.log2(float(val))) f_final = rulog2(seobnrrom_final_frequency(**p)) f_nyq = 0.5 / p['delta_t'] if f_final > f_nyq: print 'Final frequecny {0} is greater than given nyquist frequecny {1}'.format( f_final, f_nyq) p['delta_t'] = 0.5 / f_final ########## if p['numrel_data']: lalsimulation.SimInspiralSetNumrelData(flags, str(p['numrel_data'])) hp1, hc1 = lalsimulation.SimInspiralChooseTDWaveform( float(p['coa_phase']), float(p['delta_t']), float(pnutils.solar_mass_to_kg(p['mass1'])), float(pnutils.solar_mass_to_kg(p['mass2'])), float(p['spin1x']), float(p['spin1y']), float(p['spin1z']), float(p['spin2x']), float(p['spin2y']), float(p['spin2z']), float(p['f_lower']), float(p['f_ref']), pnutils.megaparsecs_to_meters(float(p['distance'])), float(p['inclination']), float(p['lambda1']), float(p['lambda2']), flags, None, int(p['amplitude_order']), int(p['phase_order']), _lalsim_enum[p['approximant']]) hp = TimeSeries(hp1.data.data[:], delta_t=hp1.deltaT, epoch=hp1.epoch) hc = TimeSeries(hc1.data.data[:], delta_t=hc1.deltaT, epoch=hc1.epoch) if f_final > f_nyq: p['delta_t'] = 0.5 / f_nyq print "Need to resample at delta_t {0}".format(p['delta_t']) hp = resample_to_delta_t(hp, p['delta_t']) hc = resample_to_delta_t(hc, p['delta_t']) return hp, hc
def resample(ts): time_slices = [ TimeSeries(ts.data[len(ts) - int(i * ts.sample_rate):], delta_t=ts.delta_t) for i in [1, 2, 4, 8, 16, 32, 64] ] res_slices = [] for i, t in enumerate(time_slices): res_slices.append(list(resample_to_delta_t(t, 1.0 / 2**(12 - i)))) #The following line was added to make it suite my current setup res_slices.append(list(np.zeros(len(res_slices[-1])))) del time_slices return (res_slices)
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 get_nrsub_strain(strain): nr = {} for ifo in ifos: nr[ifo] = load_timeseries('fig1-waveform-%s.txt' % ifo[0]) * 1e-21 nr[ifo] = resample_to_delta_t(nr[ifo], strain[ifo].delta_t) nr[ifo].start_time += event_time ts2 = {} for ifo in ifos: ts2[ifo] = strain[ifo].copy() spart = ts2[ifo].time_slice(nr[ifo].start_time, nr[ifo].end_time) nr[ifo].start_time = spart.start_time spart -= nr[ifo] return ts2
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 resample_data(strain_list, sample_rates): if not type(strain_list) == list: strain_list = [strain_list] ret = np.zeros((len(strain_list) * len(sample_rates), 4096)) for i, dat in enumerate(strain_list): for j, sr in enumerate(sample_rates): idx = i * len(sample_rates) + j ret[idx] = np.array( resample_to_delta_t(dat, 1.0 / sr).data[-4096:]) ret = ret.transpose() return (ret)
def resample(self, delta_t): """ Resample this time series to the new delta_t Parameters ----------- delta_t: float The time step to resample the times series to. Returns ------- resampled_ts: pycbc.types.TimeSeries The resample timeseries at the new time interval delta_t. """ from pycbc.filter import resample_to_delta_t return resample_to_delta_t(self, delta_t)
def apply(self, strain, detector_name, distance_scale=1, injection_sample_rate=None, inj_filter_rejector=None): if inj_filter_rejector is not None: raise NotImplementedError("IncoherentFromFile injections do not " "support inj_filter_rejector") if injection_sample_rate is not None: delta_t = 1. / injection_sample_rate else: delta_t = strain.delta_t injections = self.table for inj in injections: # Check if we should inject or not... # loading the time series like this is a bit brute-force, since # we really only need to know the delta_t and length of the # timeseries if the ref_point is anything but absmax, but that # would require adding logic to figure out how to get that metadata # based on the filetype and ref_point ts = self.loadts(inj) # set the ref time self.set_ref_time(inj, ts) # determine if we inject or not based on the times try: injtime = inj['{}_gps_time'.format(detector_name).lower()] except ValueError: injtime = -np.inf if np.isnan(injtime): # nan means don't inject injtime = -np.inf start_time = injtime + ts.start_time end_time = injtime + ts.end_time inject = (start_time < strain.end_time and end_time > strain.start_time) if inject: ts = self.make_strain_from_inj_object( inj, delta_t, detector_name, distance_scale=distance_scale, ts=ts) if ts.delta_t != strain.delta_t: ts = resample_to_delta_t(ts, strain.delta_t, method='ldas') strain.inject(ts, copy=False)
def _gen_slices(self, index_range): """Slice, whiten and re-sample the input data. Arguments --------- index_range : numpy.array Array of shape (num_samples, 2), where each row contains the start- and stop-index of the slice. Returns ------- list of arrays A list containing the input for the network. Each array is of shape (num_samples, 2048, 2). """ #Number of different sample rates num_channels = len(self.resample_rates) #Number of detectors num_detectors = len(self.ts) #Setup return data X = [ np.zeros((len(index_range), num_detectors * num_channels, self.final_data_samples)) for i in range(2) ] X_ret = [ np.zeros( (num_detectors, self.final_data_samples, len(index_range))) for i in range(2 * num_channels) ] #Slice the time-series for in_batch, idx in enumerate(index_range): for detector in range(num_detectors): low, up = idx #Whiten each slice white_full_signal = whiten_data(self.ts[detector][low:up], psd=self.psd) #Re-sample each slice max_idx = len(white_full_signal) min_idx = max_idx - int( float(self.final_data_samples) / float(self.resample_rates[0]) / self.dt) for i, sr in enumerate(self.resample_rates): X[0][in_batch][i * num_detectors + detector] = resample_to_delta_t( white_full_signal[min_idx:max_idx], 1.0 / sr) if not i + 1 == num_channels: t_dur = float(self.final_data_samples) / float( self.resample_rates[i + 1]) sample_dur = int(t_dur / self.dt) max_idx = min_idx min_idx -= sample_dur #Change formatting for i in range(2): X[i] = X[i].transpose(1, 2, 0) for i in range(num_channels): X_ret[2 * i][0] = X[0][2 * i] X_ret[2 * i][1] = X[0][2 * i + 1] X_ret[2 * i + 1][0] = X[1][2 * i] X_ret[2 * i + 1][1] = X[1][2 * i + 1] return ([x.transpose(2, 1, 0) for x in X_ret])
def apply(self, strain, detector_name, distance_scale=1, simulation_ids=None, inj_filter_rejector=None, injection_sample_rate=None): """Add injection (as seen by a particular detector) to a time series. Parameters ---------- strain : TimeSeries Time series to inject signals into, of type float32 or float64. detector_name : string Name of the detector used for projecting injections. distance_scale: float, optional Factor to scale the distance of an injection with. The default (=1) is no scaling. simulation_ids: iterable, optional If given, only inject signals with the given simulation IDs. inj_filter_rejector: InjFilterRejector instance, optional Not implemented. If not ``None``, a ``NotImplementedError`` will be raised. injection_sample_rate: float, optional The sample rate to generate the signal before injection Returns ------- None Raises ------ NotImplementedError If an ``inj_filter_rejector`` is provided. TypeError For invalid types of `strain`. """ if inj_filter_rejector is not None: raise NotImplementedError("Ringdown injections do not support " "inj_filter_rejector") if strain.dtype not in (float32, float64): raise TypeError("Strain dtype must be float32 or float64, not " \ + str(strain.dtype)) lalstrain = strain.lal() # pick lalsimulation injection function add_injection = injection_func_map[strain.dtype] delta_t = strain.delta_t if injection_sample_rate is not None: delta_t = 1.0 / injection_sample_rate injections = self.table if simulation_ids: injections = injections[list(simulation_ids)] for ii in range(injections.size): injection = injections[ii] signal = self.make_strain_from_inj_object( injection, delta_t, detector_name, distance_scale=distance_scale) signal = resample_to_delta_t(signal, strain.delta_t, method='ldas') signal = signal.astype(strain.dtype) signal_lal = signal.lal() add_injection(lalstrain, signal_lal, None) strain.data[:] = lalstrain.data.data[:]
def apply(self, strain, detector_name, f_lower=None, distance_scale=1, simulation_ids=None, inj_filter_rejector=None, injection_sample_rate=None,): """Add injections (as seen by a particular detector) to a time series. Parameters ---------- strain : TimeSeries Time series to inject signals into, of type float32 or float64. detector_name : string Name of the detector used for projecting injections. f_lower : {None, float}, optional Low-frequency cutoff for injected signals. If None, use value provided by each injection. distance_scale: {1, float}, optional Factor to scale the distance of an injection with. The default is no scaling. simulation_ids: iterable, optional If given, only inject signals with the given simulation IDs. inj_filter_rejector: InjFilterRejector instance; optional, default=None If given send each injected waveform to the InjFilterRejector instance so that it can store a reduced representation of that injection if necessary. injection_sample_rate: float, optional The sample rate to generate the signal before injection Returns ------- None Raises ------ TypeError For invalid types of `strain`. """ if strain.dtype not in (float32, float64): raise TypeError("Strain dtype must be float32 or float64, not " \ + str(strain.dtype)) lalstrain = strain.lal() earth_travel_time = lal.REARTH_SI / lal.C_SI t0 = float(strain.start_time) - earth_travel_time t1 = float(strain.end_time) + earth_travel_time # pick lalsimulation injection function add_injection = injection_func_map[strain.dtype] delta_t = strain.delta_t if injection_sample_rate is not None: delta_t = 1.0 / injection_sample_rate injections = self.table if simulation_ids: injections = injections[list(simulation_ids)] injected_ids = [] for ii, inj in enumerate(injections): f_l = inj.f_lower if f_lower is None else f_lower # roughly estimate if the injection may overlap with the segment # Add 2s to end_time to account for ringdown and light-travel delay end_time = inj.tc + 2 inj_length = tau0_from_mass1_mass2(inj.mass1, inj.mass2, f_l) # Start time is taken as twice approx waveform length with a 1s # safety buffer start_time = inj.tc - 2 * (inj_length + 1) if end_time < t0 or start_time > t1: continue signal = self.make_strain_from_inj_object(inj, delta_t, detector_name, f_lower=f_l, distance_scale=distance_scale) signal = resample_to_delta_t(signal, strain.delta_t, method='ldas') if float(signal.start_time) > t1: continue signal = signal.astype(strain.dtype) signal_lal = signal.lal() add_injection(lalstrain, signal_lal, None) injected_ids.append(ii) if inj_filter_rejector is not None: inj_filter_rejector.generate_short_inj_from_inj(signal, ii) strain.data[:] = lalstrain.data.data[:] injected = copy.copy(self) injected.table = injections[np.array(injected_ids).astype(int)] if inj_filter_rejector is not None: if hasattr(inj_filter_rejector, 'injected'): prev_p = inj_filter_rejector.injection_params prev_id = inj_filter_rejector.injection_ids injected = np.concatenate([prev_p, injected]) injected_ids = np.concatenate([prev_id, injected_ids]) inj_filter_rejector.injection_params = injected inj_filter_rejector.injection_ids = injected_ids return injected
def detect_loud_glitches(strain, psd_duration=4., psd_stride=2., psd_avg_method='median', low_freq_cutoff=30., threshold=50., cluster_window=5., corrupted_time=4., high_freq_cutoff=None, output_intermediates=False): """Automatic identification of loud transients for gating purposes.""" logging.info('Autogating: tapering strain') fade_size = corrupted_time * strain.sample_rate w = numpy.arange(fade_size) / float(fade_size) strain[0:fade_size] *= Array(w, dtype=strain.dtype) strain[(len(strain)-fade_size):] *= Array(w[::-1], dtype=strain.dtype) if output_intermediates: strain.save_to_wav('strain_conditioned.wav') # don't waste time trying to optimize a single FFT pycbc.fft.fftw.set_measure_level(0) logging.info('Autogating: estimating PSD') psd = pycbc.psd.welch(strain, seg_len=int(psd_duration*strain.sample_rate), seg_stride=int(psd_stride*strain.sample_rate), avg_method=psd_avg_method) psd = pycbc.psd.interpolate(psd, 1./strain.duration) psd = pycbc.psd.inverse_spectrum_truncation( psd, int(psd_duration * strain.sample_rate), low_frequency_cutoff=low_freq_cutoff, trunc_method='hann') logging.info('Autogating: time -> frequency') strain_tilde = FrequencySeries(numpy.zeros(len(strain) / 2 + 1), delta_f=psd.delta_f, dtype=complex_same_precision_as(strain)) pycbc.fft.fft(strain, strain_tilde) logging.info('Autogating: whitening') if high_freq_cutoff: kmax = int(high_freq_cutoff / strain_tilde.delta_f) strain_tilde[kmax:] = 0. norm = high_freq_cutoff - low_freq_cutoff else: norm = strain.sample_rate/2. - low_freq_cutoff strain_tilde /= (psd * norm) ** 0.5 kmin = int(low_freq_cutoff / strain_tilde.delta_f) strain_tilde[0:kmin] = 0. # FIXME downsample here rather than post-FFT logging.info('Autogating: frequency -> time') pycbc.fft.ifft(strain_tilde, strain) pycbc.fft.fftw.set_measure_level(pycbc.fft.fftw._default_measurelvl) if high_freq_cutoff: strain = resample_to_delta_t(strain, 0.5 / high_freq_cutoff, method='ldas') logging.info('Autogating: stdev of whitened strain is %.4f', numpy.std(strain)) if output_intermediates: strain.save_to_wav('strain_whitened.wav') mag = abs(strain) if output_intermediates: mag.save('strain_whitened_mag.npy') mag = numpy.array(mag, dtype=numpy.float32) # remove strain corrupted by filters at the ends corrupted_idx = int(corrupted_time * strain.sample_rate) mag[0:corrupted_idx] = 0 mag[-1:-corrupted_idx-1:-1] = 0 logging.info('Autogating: finding loud peaks') indices = numpy.where(mag > threshold)[0] cluster_idx = pycbc.events.findchirp_cluster_over_window( indices, mag[indices], int(cluster_window*strain.sample_rate)) times = [idx * strain.delta_t + strain.start_time \ for idx in indices[cluster_idx]] return times
"""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 detect_loud_glitches(strain, psd_duration=4., psd_stride=2., psd_avg_method='median', low_freq_cutoff=30., threshold=50., cluster_window=5., corrupt_time=4., high_freq_cutoff=None, output_intermediates=False): """Automatic identification of loud transients for gating purposes. This function first estimates the PSD of the input time series using the FindChirp Welch method. Then it whitens the time series using that estimate. Finally, it computes the magnitude of the whitened series, thresholds it and applies the FindChirp clustering over time to the surviving samples. Parameters ---------- strain : TimeSeries Input strain time series to detect glitches over. psd_duration : {float, 4} Duration of the segments for PSD estimation in seconds. psd_stride : {float, 2} Separation between PSD estimation segments in seconds. psd_avg_method : {string, 'median'} Method for averaging PSD estimation segments. low_freq_cutoff : {float, 30} Minimum frequency to include in the whitened strain. threshold : {float, 50} Minimum magnitude of whitened strain for considering a transient to be present. cluster_window : {float, 5} Length of time window to cluster surviving samples over, in seconds. corrupt_time : {float, 4} Amount of time to be discarded at the beginning and end of the input time series. high_frequency_cutoff : {float, None} Maximum frequency to include in the whitened strain. If given, the input series is downsampled accordingly. If omitted, the Nyquist frequency is used. output_intermediates : {bool, False} Save intermediate time series for debugging. Returns ------- """ logging.info('Autogating: tapering strain') taper_length = corrupt_time * strain.sample_rate w = numpy.arange(taper_length) / float(taper_length) strain[0:taper_length] *= pycbc.types.Array(w, dtype=strain.dtype) strain[(len(strain)-taper_length):] *= pycbc.types.Array(w[::-1], dtype=strain.dtype) # don't waste time trying to optimize a single FFT pycbc.fft.fftw.set_measure_level(0) if high_freq_cutoff: logging.info('Autogating: downsampling strain') strain = resample_to_delta_t(strain, 0.5 / high_freq_cutoff, method='ldas') if output_intermediates: strain.save_to_wav('strain_conditioned.wav') corrupt_length = int(corrupt_time * strain.sample_rate) # zero-pad strain to a power-of-2 length strain_pad_length = next_power_of_2(len(strain)) pad_start = strain_pad_length/2 - len(strain)/2 pad_end = pad_start + len(strain) strain_pad = pycbc.types.TimeSeries( pycbc.types.zeros(strain_pad_length, dtype=strain.dtype), delta_t=strain.delta_t, copy=False, epoch=strain.start_time-pad_start/strain.sample_rate) strain_pad[pad_start:pad_end] = strain[:] logging.info('Autogating: estimating PSD') psd = pycbc.psd.welch(strain[corrupt_length:(len(strain)-corrupt_length)], seg_len=int(psd_duration * strain.sample_rate), seg_stride=int(psd_stride * strain.sample_rate), avg_method=psd_avg_method, require_exact_data_fit=False) psd = pycbc.psd.interpolate(psd, 1./strain_pad.duration) psd = pycbc.psd.inverse_spectrum_truncation( psd, int(psd_duration * strain.sample_rate), low_frequency_cutoff=low_freq_cutoff, trunc_method='hann') kmin = int(low_freq_cutoff / psd.delta_f) psd[0:kmin] = numpy.inf if high_freq_cutoff: kmax = int(high_freq_cutoff / psd.delta_f) psd[kmax:] = numpy.inf logging.info('Autogating: time -> frequency') strain_tilde = pycbc.types.FrequencySeries( pycbc.types.zeros(len(strain_pad) / 2 + 1, dtype=pycbc.types.complex_same_precision_as(strain)), delta_f=psd.delta_f, copy=False) pycbc.fft.fft(strain_pad, strain_tilde) logging.info('Autogating: whitening') if high_freq_cutoff: norm = high_freq_cutoff - low_freq_cutoff else: norm = strain.sample_rate/2. - low_freq_cutoff strain_tilde *= (psd * norm) ** (-0.5) logging.info('Autogating: frequency -> time') pycbc.fft.ifft(strain_tilde, strain_pad) pycbc.fft.fftw.set_measure_level(pycbc.fft.fftw._default_measurelvl) if output_intermediates: strain_pad[pad_start:pad_end].save_to_wav('strain_whitened.wav') logging.info('Autogating: computing magnitude') mag = abs(strain_pad[pad_start:pad_end]) if output_intermediates: mag.save('strain_whitened_mag.npy') mag = mag.numpy() # remove strain corrupted by filters at the ends mag[0:corrupt_length] = 0 mag[-1:-corrupt_length-1:-1] = 0 logging.info('Autogating: finding loud peaks') indices = numpy.where(mag > threshold)[0] cluster_idx = pycbc.events.findchirp_cluster_over_window( indices, numpy.array(mag[indices]), int(cluster_window*strain.sample_rate)) times = [idx * strain.delta_t + strain.start_time \ for idx in indices[cluster_idx]] return times
def generate(file_path, duration, seed=0, signal_separation=200, signal_separation_interval=20, min_mass=1.2, max_mass=1.6, f_lower=20, srate=4096, padding=256, tstart=0): """Function that generates test data with injections. Arguments --------- file_path : str The path at which the data should be stored. duration : int or float Duration of the output file in seconds. seed : {int, 0}, optional A seed to use for generating injection parameters and noise. signal_separation : {int or float, 200}, optional The average duration between two injections. signal_separation_interval : {int or float, 20}, optional The duration between two signals will be signal_separation + t, where t is drawn uniformly from the interval [-signal_separation_interval, signal_separation_interval]. min_mass : {float, 1.2}, optional The minimal mass at which injections will be made (in solar masses). max_mass : {float, 1.6}, optional The maximum mass at which injections will be made (in solar masses). f_lower : {int or float, 20}, optional Noise will be generated down to the specified frequency. Below they will be set to zero. (The waveforms are generated with a lower frequency cutofff of 25 Hertz) srate : {int, 4096}, optional The sample rate at which the data is generated. padding : {int or float, 256}, optional Duration in the beginning and end of the data that does not contain any injections. tstart : {int or float, 0}, optional The inital time of the data. """ np.random.seed(seed) size = (duration // signal_separation) #Generate injection times random_time_samples = int(round(float(signal_separation_interval) * float(srate))) signal_separation_samples = int(round(float(signal_separation) * float(srate))) time_samples = randint(signal_separation_samples - random_time_samples, signal_separation_samples + random_time_samples, size=size) time_samples = time_samples.cumsum() times = time_samples / float(srate) times = times[np.where(np.logical_and(times > padding, times < duration - padding))[0]] size = len(times) #Generate parameters cphase = uniform(0, np.pi*2.0, size=size) ra = uniform(0, 2 * np.pi, size=size) dec = np.arccos(uniform(-1., 1., size=size)) - np.pi/2 inc = np.arccos(uniform(-1., 1., size=size)) pol = uniform(0, 2 * np.pi, size=size) dist = power(3, size) * 400 m1 = uniform(min_mass, max_mass, size=size) m2 = uniform(min_mass, max_mass, size=size) #Save parameters to file. stat_file_path, ext = os.path.splitext(file_path) stat_file_path = stat_file_path + '_stats' + ext with h5py.File(stat_file_path, 'w') as f: f['times'] = times f['cphase'] = cphase f['ra'] = ra f['dec'] = dec f['inc'] = inc f['pol'] = pol f['dist'] = dist f['mass1'] = m1 f['mass2'] = m2 f['seed'] = seed p = aLIGOZeroDetHighPower(2 * int(duration * srate), 1.0/64, f_lower) #Generate noise data = {} for i, ifo in enumerate(['H1', 'L1']): data[ifo] = colored_noise(p, int(tstart), int(tstart + duration), seed=seed + i, low_frequency_cutoff=f_lower) data[ifo] = resample_to_delta_t(data[ifo], 1.0/srate) # make waveforms and add them into the noise for i in range(len(times)): hp, hc = get_td_waveform(approximant="TaylorF2", mass1=m1[i], mass2=m2[i], f_lower=25, delta_t=1.0/srate, inclination=inc[i], coa_phase=cphase[i], distance=dist[i]) hp.start_time += times[i] + int(tstart) hc.start_time += times[i] + int(tstart) for ifo in ['H1', 'L1']: ht = Detector(ifo).project_wave(hp, hc, ra[i], dec[i], pol[i]) time_diff = float(ht.start_time - data[ifo].start_time) sample_diff = int(round(time_diff / data[ifo].delta_t)) ht.prepend_zeros(sample_diff) ht.start_time = data[ifo].start_time data[ifo] = data[ifo].add_into(ht) #Save the data for ifo in ['H1', 'L1']: data[ifo].save(file_path, group='%s' % (ifo))
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)") pylab.xlim(40, 2000) pylab.ylabel(" (Strain/rhz * DYN_RANGE_FAC)^2 " ) pylab.legend()
def detect_loud_glitches(strain, psd_duration=4., psd_stride=2., psd_avg_method='median', low_freq_cutoff=30., threshold=50., cluster_window=5., corrupt_time=4., high_freq_cutoff=None, output_intermediates=False): """Automatic identification of loud transients for gating purposes. This function first estimates the PSD of the input time series using the FindChirp Welch method. Then it whitens the time series using that estimate. Finally, it computes the magnitude of the whitened series, thresholds it and applies the FindChirp clustering over time to the surviving samples. Parameters ---------- strain : TimeSeries Input strain time series to detect glitches over. psd_duration : {float, 4} Duration of the segments for PSD estimation in seconds. psd_stride : {float, 2} Separation between PSD estimation segments in seconds. psd_avg_method : {string, 'median'} Method for averaging PSD estimation segments. low_freq_cutoff : {float, 30} Minimum frequency to include in the whitened strain. threshold : {float, 50} Minimum magnitude of whitened strain for considering a transient to be present. cluster_window : {float, 5} Length of time window to cluster surviving samples over, in seconds. corrupt_time : {float, 4} Amount of time to be discarded at the beginning and end of the input time series. high_frequency_cutoff : {float, None} Maximum frequency to include in the whitened strain. If given, the input series is downsampled accordingly. If omitted, the Nyquist frequency is used. output_intermediates : {bool, False} Save intermediate time series for debugging. Returns ------- """ logging.info('Autogating: tapering strain') taper_length = corrupt_time * strain.sample_rate w = numpy.arange(taper_length) / float(taper_length) strain[0:taper_length] *= pycbc.types.Array(w, dtype=strain.dtype) strain[(len(strain) - taper_length):] *= pycbc.types.Array( w[::-1], dtype=strain.dtype) # don't waste time trying to optimize a single FFT pycbc.fft.fftw.set_measure_level(0) if high_freq_cutoff: logging.info('Autogating: downsampling strain') strain = resample_to_delta_t(strain, 0.5 / high_freq_cutoff, method='ldas') if output_intermediates: strain.save_to_wav('strain_conditioned.wav') corrupt_length = int(corrupt_time * strain.sample_rate) # zero-pad strain to a power-of-2 length strain_pad_length = next_power_of_2(len(strain)) pad_start = strain_pad_length / 2 - len(strain) / 2 pad_end = pad_start + len(strain) strain_pad = pycbc.types.TimeSeries(pycbc.types.zeros(strain_pad_length, dtype=strain.dtype), delta_t=strain.delta_t, copy=False, epoch=strain.start_time - pad_start / strain.sample_rate) strain_pad[pad_start:pad_end] = strain[:] logging.info('Autogating: estimating PSD') psd = pycbc.psd.welch(strain[corrupt_length:(len(strain) - corrupt_length)], seg_len=int(psd_duration * strain.sample_rate), seg_stride=int(psd_stride * strain.sample_rate), avg_method=psd_avg_method, require_exact_data_fit=False) psd = pycbc.psd.interpolate(psd, 1. / strain_pad.duration) psd = pycbc.psd.inverse_spectrum_truncation( psd, int(psd_duration * strain.sample_rate), low_frequency_cutoff=low_freq_cutoff, trunc_method='hann') kmin = int(low_freq_cutoff / psd.delta_f) psd[0:kmin] = numpy.inf if high_freq_cutoff: kmax = int(high_freq_cutoff / psd.delta_f) psd[kmax:] = numpy.inf logging.info('Autogating: time -> frequency') strain_tilde = pycbc.types.FrequencySeries(pycbc.types.zeros( len(strain_pad) / 2 + 1, dtype=pycbc.types.complex_same_precision_as(strain)), delta_f=psd.delta_f, copy=False) pycbc.fft.fft(strain_pad, strain_tilde) logging.info('Autogating: whitening') if high_freq_cutoff: norm = high_freq_cutoff - low_freq_cutoff else: norm = strain.sample_rate / 2. - low_freq_cutoff strain_tilde *= (psd * norm)**(-0.5) logging.info('Autogating: frequency -> time') pycbc.fft.ifft(strain_tilde, strain_pad) pycbc.fft.fftw.set_measure_level(pycbc.fft.fftw._default_measurelvl) if output_intermediates: strain_pad[pad_start:pad_end].save_to_wav('strain_whitened.wav') logging.info('Autogating: computing magnitude') mag = abs(strain_pad[pad_start:pad_end]) if output_intermediates: mag.save('strain_whitened_mag.npy') mag = mag.numpy() # remove strain corrupted by filters at the ends mag[0:corrupt_length] = 0 mag[-1:-corrupt_length - 1:-1] = 0 logging.info('Autogating: finding loud peaks') indices = numpy.where(mag > threshold)[0] cluster_idx = pycbc.events.findchirp_cluster_over_window( indices, numpy.array(mag[indices]), int(cluster_window * strain.sample_rate)) times = [idx * strain.delta_t + strain.start_time \ for idx in indices[cluster_idx]] return times
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 # Generate a zeros frequency series the same length as the psd filter = FrequencySeries(numpy.zeros(len(psd)), 1, dtype=numpy.complex128)
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))))
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
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
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 calc_filt_psd_variation(strain, segment, short_segment, psd_long_segment, psd_duration, psd_stride, psd_avg_method, low_freq, high_freq): """ Calculates time series of PSD variability This function first splits the segment up into 512 second chunks. It then calculates the PSD over this 512 second. The PSD is used to to create a filter that is the composition of three filters: 1. Bandpass filter between f_low and f_high. 2. Weighting filter which gives the rough response of a CBC template. 3. Whitening filter. Next it makes the convolution of this filter with the stretch of data. This new time series is given to the "mean_square" function, which computes the mean square of the timeseries within an 8 seconds window, once per second. The result, which is the variance of the S/N in that stride for the Parseval theorem, is then stored in a timeseries. Parameters ---------- strain : TimeSeries Input strain time series to estimate PSDs segment : {float, 8} Duration of the segments for the mean square estimation in seconds. short_segment : {float, 0.25} Duration of the short segments for the outliers removal. psd_long_segment : {float, 512} Duration of the long segments for PSD estimation in seconds. psd_duration : {float, 8} Duration of FFT segments for long term PSD estimation, in seconds. psd_stride : {float, 4} Separation between FFT segments for long term PSD estimation, in seconds. psd_avg_method : {string, 'median'} Method for averaging PSD estimation segments. low_freq : {float, 20} Minimum frequency to consider the comparison between PSDs. high_freq : {float, 480} Maximum frequency to consider the comparison between PSDs. Returns ------- psd_var : TimeSeries Time series of the variability in the PSD estimation """ # Calculate strain precision if strain.precision == 'single': fs_dtype = numpy.float32 elif strain.precision == 'double': fs_dtype = numpy.float64 # Convert start and end times immediately to floats start_time = numpy.float(strain.start_time) end_time = numpy.float(strain.end_time) # Resample the data strain = resample_to_delta_t(strain, 1.0 / 2048) srate = int(strain.sample_rate) # Fix the step for the PSD estimation and the time to remove at the # edge of the time series. step = 1.0 strain_crop = 8.0 # Find the times of the long segments times_long = numpy.arange( start_time, end_time, psd_long_segment - 2 * strain_crop - segment + step) # Set up the empty time series for the PSD variation estimate ts_duration = end_time - start_time - 2 * strain_crop - segment + 1 psd_var = TimeSeries(zeros(int(numpy.floor(ts_duration / step))), delta_t=step, copy=False, epoch=start_time + strain_crop + segment) # Create a bandpass filter between low_freq and high_freq filt = sig.firwin(4 * srate, [low_freq, high_freq], pass_zero=False, window='hann', nyq=srate / 2) filt.resize(int(psd_duration * srate)) # Fourier transform the filter and take the absolute value to get # rid of the phase. Save the filter as a frequency series. filt = abs(rfft(filt)) my_filter = FrequencySeries(filt, delta_f=1. / psd_duration, dtype=fs_dtype) ind = 0 for tlong in times_long: # Calculate PSD for long segment if tlong + psd_long_segment <= float(end_time): astrain = strain.time_slice(tlong, tlong + psd_long_segment) plong = pycbc.psd.welch( astrain, seg_len=int(psd_duration * strain.sample_rate), seg_stride=int(psd_stride * strain.sample_rate), avg_method=psd_avg_method) else: astrain = strain.time_slice(tlong, end_time) plong = pycbc.psd.welch( strain.time_slice(end_time - psd_long_segment, end_time), seg_len=int(psd_duration * strain.sample_rate), seg_stride=int(psd_stride * strain.sample_rate), avg_method=psd_avg_method) # Make the weighting filter - bandpass, which weight by f^-7/6, # and whiten. The normalization is chosen so that the variance # will be one if this filter is applied to white noise which # already has a variance of one. freqs = FrequencySeries(plong.sample_frequencies, delta_f=plong.delta_f, epoch=plong.epoch, dtype=fs_dtype) fweight = freqs**(-7. / 6.) * my_filter / numpy.sqrt(plong) fweight[0] = 0. norm = (sum(abs(fweight)**2) / (len(fweight) - 1.))**-0.5 fweight = norm * fweight fwhiten = numpy.sqrt(2. / srate) / numpy.sqrt(plong) fwhiten[0] = 0. full_filt = sig.hann(int(psd_duration * srate)) * numpy.roll( irfft(fwhiten * fweight), int(psd_duration / 2) * srate) # Convolve the filter with long segment of data wstrain = TimeSeries(sig.fftconvolve(astrain, full_filt, mode='same'), delta_t=strain.delta_t, epoch=astrain.start_time) wstrain = wstrain[int(strain_crop * srate):-int(strain_crop * srate)] # compute the mean square of the chunk of data delta_t = wstrain.end_time.gpsSeconds - wstrain.start_time.gpsSeconds variation = mean_square(wstrain, delta_t, short_segment, segment) # Store variation value for i, val in enumerate(variation): psd_var[ind + i] = val ind = ind + len(variation) return psd_var
# 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)")
dt = np.loadtxt('And1815fr1kpc_equ.txt', usecols=(0)) hp = np.loadtxt('And1815fr1kpc_equ.txt', usecols=(1)) hc = np.loadtxt('And1815fr1kpc_equ.txt', usecols=(2)) h = hc + hp fs = 8192 pylab.figure('Original') pylab.plot(dt, h) pylab.grid() pylab.show() template = types.TimeSeries(initial_array=h, delta_t=1.0 / 2048, epoch=0) pylab.figure('Original') pylab.plot(template.sample_times, template) pylab.grid() pylab.show() template = resample_to_delta_t(template, 1.0 / 1024) pylab.figure('Original') pylab.plot(template.sample_times, template) pylab.grid() pylab.show() interpolacion(h, dt, 1, fs)
def _gen_slices(self, index_range): num_channels = 7 num_detectors = 2 X = [ np.zeros((len(index_range), len(self.ts) * num_channels, self.final_data_samples)) for i in range(2) ] X_ret = [ np.zeros((len(self.ts), self.final_data_samples, len(index_range))) for i in range(num_detectors * num_channels) ] for in_batch, idx in enumerate(index_range): for detector in range(len(self.ts)): low, up = idx #Using whiten_data works white_full_signal = whiten_data_new(self.ts[detector][low:up]) #white_full_signal = self.ts[detector][low:up].whiten(4, 4) max_idx = len(white_full_signal) min_idx = max_idx - int( float(self.num_samples) / float(self.resample_rates[0]) / self.dt) for i, sr in enumerate(self.resample_rates): X[0][in_batch][i * len(self.ts) + detector] = resample_to_delta_t( white_full_signal[min_idx:max_idx], 1.0 / sr) if not i + 1 == len(self.resample_rates): t_dur = float(self.num_samples) / float( self.resample_rates[i + 1]) sample_dur = int(t_dur / self.dt) max_idx = min_idx min_idx -= sample_dur #print("{}: in_batch: {}".format(detector, in_batch)) X[0] = X[0].transpose(1, 2, 0) X[1] = X[1].transpose(1, 2, 0) X_ret[0][0] = X[0][0] X_ret[0][1] = X[0][1] X_ret[1][0] = X[1][0] X_ret[1][1] = X[1][1] X_ret[2][0] = X[0][2] X_ret[2][1] = X[0][3] X_ret[3][0] = X[1][2] X_ret[3][1] = X[1][3] X_ret[4][0] = X[0][4] X_ret[4][1] = X[0][5] X_ret[5][0] = X[1][4] X_ret[5][1] = X[1][5] X_ret[6][0] = X[0][6] X_ret[6][1] = X[0][7] X_ret[7][0] = X[1][6] X_ret[7][1] = X[1][7] X_ret[8][0] = X[0][8] X_ret[8][1] = X[0][9] X_ret[9][0] = X[1][8] X_ret[9][1] = X[1][9] X_ret[10][0] = X[0][10] X_ret[10][1] = X[0][11] X_ret[11][0] = X[1][10] X_ret[11][1] = X[1][11] X_ret[12][0] = X[0][12] X_ret[12][1] = X[0][13] X_ret[13][0] = X[1][12] X_ret[13][1] = X[1][13] return ([x.transpose(2, 1, 0) for x in X_ret])
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