def _snr_series_by_sngl_inspiral(cls, doc):
for elem in doc.getElementsByTagName(LIGO_LW.tagName):
try:
if elem.Name != lal.COMPLEX8TimeSeries.__name__:
continue
array.get_array(elem, 'snr')
event_id = param.get_pyvalue(elem, 'event_id')
except (AttributeError, ValueError):
continue
else:
yield event_id, lal.series.parse_COMPLEX8TimeSeries(elem)
def read_xmldoc(xmldoc, root_name=u"gstlal_inspiral_bank_SNRs"):
if root_name is not None:
root, = (
elem
for elem in xmldoc.getElementsByTagName(ligolw.LIGO_LW.tagName)
if elem.hasAttribute(u"Name") if elem.Name == root_name)
snrdict = defaultdict(list)
autocorrelation_dict = defaultdict(list)
for elem in (elem
for elem in root.getElementsByTagName(ligolw.LIGO_LW.tagName)
if elem.hasAttribute(u"Name") and elem.Name == "bank_SNR"):
# get the time series
for snr_acf_elem in (
elem
for elem in elem.getElementsByTagName(ligolw.LIGO_LW.tagName)
if elem.hasAttribute(u"Name")
and elem.Name == "SNR_and_Autocorrelation"):
snr_elem = snr_acf_elem.getElementsByTagName(
ligolw.LIGO_LW.tagName)[0]
if snr_elem.Name == u"REAL4TimeSeries":
tseries = lal.series.parse_REAL4TimeSeries(snr_elem)
snrdict[tseries.name.split("_")[0]].append(tseries)
autocorrelation_dict[tseries.name.split("_")[0]].append(
ligolw_array.get_array(snr_acf_elem,
"autocorrelation_bank").array)
elif snr_elem.Name == u"REAL8TimeSeries":
tseries = lal.series.parse_REAL8TimeSeries(snr_elem)
snrdict[tseries.name.split("_")[0]].append(tseries)
autocorrelation_dict[tseries.name.split("_")[0]].append(
ligolw_array.get_array(snr_acf_elem,
"autocorrelation_bank").array)
elif snr_elem.Name == u"COMPLEX8TimeSeries":
tseries = lal.series.parse_COMPLEX8TimeSeries(snr_elem)
snrdict[tseries.name.split("_")[0]].append(tseries)
autocorrelation_dict[tseries.name.split("_")[0]].append(
ligolw_array.get_array(snr_acf_elem,
"autocorrelation_bank").array)
elif snr_elem.Name == u"COMPLEX16TimeSeries":
tseries = lal.series.parse_COMPLEX16TimeSeries(snr_elem)
snrdict[tseries.name.split("_")[0]].append(tseries)
autocorrelation_dict[tseries.name.split("_")[0]].append(
ligolw_array.get_array(snr_acf_elem,
"autocorrelation_bank").array)
assert snrdict is not None, "xmldoc contains no LAL Series or LAL Series is unsupported"
return snrdict, autocorrelation_dict
def from_xml(cls, xml, name):
# need to cast start and stop to floats, otherwise they are
# numpy.float64 objects and confuse things
return cls(
ratebin((float(start), float(stop)), count=int(count))
for (start, stop,
count) in ligolw_array.get_array(xml, u"%s:ratebinlist" %
name).array[:])
def from_url(cls, url, verbose=False):
xmldoc = ligolw_utils.load_url(url,
contenthandler=ContentHandler,
verbose=verbose)
banks = []
for root in (
elem
for elem in xmldoc.getElementsByTagName(ligolw.LIGO_LW.tagName)
if elem.hasAttribute("Name")
and elem.Name == "gstlal_template_bank"):
bank = cls.__new__(cls)
bank.bank_id = ligolw_param.get_pyvalue(root, "bank_id")
bank.sample_rate = ligolw_param.get_pyvalue(root, "sample_rate")
bank.processed_psd = None
bank.sngl_inspiral_table = lsctables.SnglInspiralTable.get_table(
root)
bank.template_bank_filename = ligolw_param.get_pyvalue(
root, "template_bank_filename")
bank.sigmasq = ligolw_array.get_array(root, "sigmasq").array
bank.templates = ligolw_array.get_array(root, "templates").array
bank.autocorrelation_bank = ligolw_array.get_array(
root, "autocorrelation_bank").array
bank.autocorrelation_mask = ligolw_array.get_array(
root, "autocorrelation_mask").array
bank.horizon_factors = dict(
(row.template_id, sigmasq**.5) for row, sigmasq in zip(
bank.sngl_inspiral_table, bank.sigmasq))
banks.append(bank)
min_template_id, horizon_distance_func = svd_bank.horizon_distance_func(
banks)
horizon_norm, = (bank.horizon_factors[row.template_id]
for row in bank.sngl_inspiral_table for bank in banks
if row.template_id == min_template_id)
for bank in banks:
bank.horizon_distance_func = horizon_distance_func
bank.horizon_factors = dict(
(tid, f / horizon_norm)
for (tid, f) in bank.horizon_factors.items())
return banks
def read_banks(filename, contenthandler, verbose=False):
"""Read SVD banks from a LIGO_LW xml file."""
# Load document
xmldoc = ligolw_utils.load_url(filename,
contenthandler=contenthandler,
verbose=verbose)
banks = []
# FIXME in principle this could be different for each bank included in
# this file, but we only put one in the file for now
# FIXME, right now there is only one instrument so we just pull out the
# only psd there is
try:
raw_psd = list(lal.series.read_psd_xmldoc(xmldoc).values())[0]
except ValueError:
# the bank file does not contain psd ligolw element.
raw_psd = None
for root in (
elem
for elem in xmldoc.getElementsByTagName(ligolw.LIGO_LW.tagName)
if elem.hasAttribute(u"Name")
and elem.Name == "gstlal_svd_bank_Bank"):
# Create new SVD bank object
bank = Bank.__new__(Bank)
# Read sngl inspiral table
bank.sngl_inspiral_table = lsctables.SnglInspiralTable.get_table(root)
bank.sngl_inspiral_table.parentNode.removeChild(
bank.sngl_inspiral_table)
# Read root-level scalar parameters
bank.filter_length = ligolw_param.get_pyvalue(root, 'filter_length')
bank.gate_threshold = ligolw_param.get_pyvalue(root, 'gate_threshold')
bank.logname = ligolw_param.get_pyvalue(root, 'logname') or None
bank.snr_threshold = ligolw_param.get_pyvalue(root, 'snr_threshold')
bank.template_bank_filename = ligolw_param.get_pyvalue(
root, 'template_bank_filename')
bank.bank_id = ligolw_param.get_pyvalue(root, 'bank_id')
try:
bank.newdeltaF = ligolw_param.get_pyvalue(root, 'new_deltaf')
bank.working_f_low = ligolw_param.get_pyvalue(
root, 'working_f_low')
bank.f_low = ligolw_param.get_pyvalue(root, 'f_low')
bank.sample_rate_max = ligolw_param.get_pyvalue(
root, 'sample_rate_max')
except ValueError:
pass
# Read root-level arrays
bank.autocorrelation_bank = ligolw_array.get_array(
root,
'autocorrelation_bank_real').array + 1j * ligolw_array.get_array(
root, 'autocorrelation_bank_imag').array
bank.autocorrelation_mask = ligolw_array.get_array(
root, 'autocorrelation_mask').array
bank.sigmasq = ligolw_array.get_array(root, 'sigmasq').array
# prepare the horizon distance factors
bank.horizon_factors = dict(
(row.template_id, sigmasq**.5)
for row, sigmasq in zip(bank.sngl_inspiral_table, bank.sigmasq))
if raw_psd is not None:
# reproduce the whitening psd and attach a reference to the psd
bank.processed_psd = cbc_template_fir.condition_psd(
raw_psd,
bank.newdeltaF,
minfs=(bank.working_f_low, bank.f_low),
maxfs=(bank.sample_rate_max / 2.0 * 0.90,
bank.sample_rate_max / 2.0))
# Read bank fragments
bank.bank_fragments = []
for el in (node for node in root.childNodes
if node.tagName == ligolw.LIGO_LW.tagName):
frag = BankFragment(rate=ligolw_param.get_pyvalue(el, 'rate'),
start=ligolw_param.get_pyvalue(el, 'start'),
end=ligolw_param.get_pyvalue(el, 'end'))
# Read arrays
frag.chifacs = ligolw_array.get_array(el, 'chifacs').array
try:
frag.mix_matrix = ligolw_array.get_array(el,
'mix_matrix').array
except ValueError:
frag.mix_matrix = None
frag.orthogonal_template_bank = ligolw_array.get_array(
el, 'orthogonal_template_bank').array
try:
frag.singular_values = ligolw_array.get_array(
el, 'singular_values').array
except ValueError:
frag.singular_values = None
try:
frag.sum_of_squares_weights = ligolw_array.get_array(
el, 'sum_of_squares_weights').array
except ValueError:
frag.sum_of_squares_weights = None
bank.bank_fragments.append(frag)
banks.append(bank)
template_id, func = horizon_distance_func(banks)
horizon_norm = None
for bank in banks:
if template_id in bank.horizon_factors:
assert horizon_norm is None
horizon_norm = bank.horizon_factors[template_id]
for bank in banks:
bank.horizon_distance_func = func
bank.horizon_factors = dict(
(tid, f / horizon_norm)
for (tid, f) in bank.horizon_factors.items())
xmldoc.unlink()
return banks
def from_xml(cls, xml, name):
return cls(
map(
tuple,
ligolw_array.get_array(xml,
u"%s:nearestleaftree" % name).array[:]))