def run(self): proc_name = self.name while True: next_task = self._template_task_queue.get() if next_task is None: # This poison pil means shutdown LOGGER.info("{}: Exiting".format(proc_name)) break template_results = list() f_low = next_task["f_low"] delta_t = next_task["delta_t"] template = next_task["template"] sample_index = next_task["sample_index"] template_index = next_task["template_index"] det_string = next_task["det_string"] strain_sample = next_task["strain_sample"] sample_type = next_task["sample_type"] delta_f = next_task["delta_f"] template_start_time = next_task["template_start_time"] print("Generating SNR time series: " + det_string + " - sample" + str(sample_index) + ", template" + str(template_index)) template_time_series = TimeSeries(template, delta_t=delta_t, epoch=0, dtype=None, copy=True) template_freq_series = template_time_series.to_frequencyseries( delta_f=delta_f) strain_sample_time_series = TimeSeries(strain_sample, delta_t=delta_t, epoch=0, dtype=None, copy=True) strain_freq_series = strain_sample_time_series.to_frequencyseries( delta_f=delta_f) template_freq_series.resize(len(strain_freq_series)) # Time shift the template so that the SNR peak matches the merger time template_freq_series = template_freq_series.cyclic_time_shift( template_start_time) # Compute SNR time-series from optimal matched filtering template snr_series = matched_filter(template_freq_series, strain_freq_series.astype(complex), psd=None, low_frequency_cutoff=f_low) template_results.append({ "snr_strain": np.array(abs(snr_series)), "sample_index": sample_index, "template_index": template_index, "det_string": det_string, "sample_type": sample_type, }) if len(template_results) >= 1: for result in template_results: self._template_result_queue.put(result) # Add a poison pill self._template_result_queue.put(None)
def run(self): proc_name = self.name while True: # Get next task to be completed from the queue next_task = self._task_queue.get() if next_task is None: # This poison pil means shutdown LOGGER.info("{}: Exiting".format(proc_name)) break results = list() # Initialise parameters from task queue to generate SNR time-series mass1 = next_task["mass1"] mass2 = next_task["mass2"] spin1z = next_task["spin1z"] spin2z = next_task["spin2z"] ra = next_task["ra"] dec = next_task["dec"] coa_phase = next_task["coa_phase"] inclination = next_task["inclination"] polarization = next_task["polarization"] injection_snr = next_task["injection_snr"] f_low = next_task["f_low"] approximant = next_task["approximant"] delta_t = next_task["delta_t"] index = next_task["index"] det_string = next_task["det_string"] strain_sample = next_task["strain_sample"] print("Generating optimal SNR time series: " + det_string + " - sample" + str(index)) # Convert sample to PyCBC time series strain_time_series = TimeSeries(strain_sample, delta_t=delta_t, epoch=0, dtype=None, copy=True) # Convert sample to PyCBC frequency series strain_freq_series = strain_time_series.to_frequencyseries() # Generate optimal matched filtering template template_hp, template_hc = get_td_waveform( approximant=approximant, mass1=mass1, mass2=mass2, spin1z=spin1z, spin2z=spin2z, ra=ra, dec=dec, coa_phase=coa_phase, inclination=inclination, f_lower=f_low, delta_t=delta_t, ) # Convert template to PyCBC frequency series template_freq_series_hp = template_hp.to_frequencyseries( delta_f=strain_freq_series.delta_f) # Resize template to work with the sample template_freq_series_hp.resize(len(strain_freq_series)) # Time shift the template so that the SNR peak matches the merger time template_freq_series_hp = template_freq_series_hp.cyclic_time_shift( template_freq_series_hp.start_time) # Compute SNR time-series from optimal matched filtering template snr_series = matched_filter(template_freq_series_hp, strain_freq_series.astype(complex), psd=None, low_frequency_cutoff=f_low) results.append({ "snr_strain": np.array(abs(snr_series)), "mass1": mass1, "mass2": mass2, "spin1z": spin1z, "spin2z": spin2z, "ra": ra, "dec": dec, "coa_phase": coa_phase, "inclination": inclination, "polarization": polarization, "injection_snr": injection_snr, "index": index, "det_string": det_string, # Unsure I need this for when I store files, using it and index to provide store locations later on }) # Put the results on the results queue if len(results) >= 1: for result in results: self._result_queue.put(result) # Add a poison pill self._result_queue.put(None)
from pycbc.types.timeseries import TimeSeries from pycbc.types.frequencyseries import FrequencySeries from pycbc.filter import match import numpy import matplotlib.pyplot as plt data = numpy.sin(numpy.arange(0, 100, 100 / (4096.0 * 64))) # data += numpy.random.normal(scale=.01, size=data.shape) # plt.plot(data) # plt.show() filtD = TimeSeries(data, dtype=numpy.float64, delta_t=1.0 / 4096) frequency_series_filt = filtD.to_frequencyseries() dt_fraction = .5 filtD_offset_subsample = ( frequency_series_filt * numpy.exp(2j * numpy.pi * frequency_series_filt.sample_frequencies * frequency_series_filt.delta_t * dt_fraction)) o, _ = match(filtD, filtD_offset_subsample, subsample_interpolation=True) print(1 - o) # assert numpy.isclose(1, o, rtol=0, atol=1e-8)