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)
