def from_xml(cls, xml, name):
xml = cls.get_xml_root(xml, name)
self = cls(
instruments=lsctables.instrumentsproperty.get(
ligolw_param.get_pyvalue(xml, u"instruments")),
delta_t=ligolw_param.get_pyvalue(xml, u"delta_t"),
snr_threshold=ligolw_param.get_pyvalue(xml, u"snr_threshold"),
num_templates=ligolw_param.get_pyvalue(xml, u"num_templates"),
min_instruments=ligolw_param.get_pyvalue(xml, u"min_instruments"))
for key in self.densities:
self.densities[key] = rate.BinnedLnPDF.from_xml(xml, key)
return self
def read_psd_xmldoc(xmldoc, root_name=u"psd"):
"""
Parse a dictionary of PSD frequency series objects from an XML
document. See also make_psd_xmldoc() for the construction of XML
documents from a dictionary of PSDs. Interprets an empty frequency
series for an instrument as None.
The XML document tree is searched for a LIGO_LW element whose Name
attribute is root_name (default is "psd"). If root_name is None all
REAL8Frequency series objects below xmldoc are included in the return
value.
"""
if root_name is not None:
xmldoc, = (
elem
for elem in xmldoc.getElementsByTagName(ligolw.LIGO_LW.tagName)
if elem.hasAttribute(u"Name") and elem.Name == root_name)
result = dict(
(ligolw_param.get_pyvalue(elem, u"instrument"),
parse_REAL8FrequencySeries(elem))
for elem in xmldoc.getElementsByTagName(ligolw.LIGO_LW.tagName)
if elem.hasAttribute(u"Name") and elem.Name == u"REAL8FrequencySeries")
# interpret empty frequency series as None
for instrument in result:
if len(result[instrument].data.data) == 0:
result[instrument] = None
return result
def from_xml(cls, xml, name):
xml = cls.get_xml_root(xml, name)
self = cls(
lsctables.instrumentsproperty.get(
ligolw_param.get_pyvalue(xml, "instruments")))
for key in self.densities:
self.densities[key] = rate.BinnedLnPDF.from_xml(xml, key)
return self
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 psd_instrument_dict(elem):
out = {}
for lw in elem.getElementsByTagName(u"LIGO_LW"):
if not lw.hasAttribute(u"Name"):
continue
if lw.getAttribute(u"Name") != u"REAL8FrequencySeries":
continue
ifo = param.get_pyvalue(lw, u"instrument")
out[ifo] = lalseries.parse_REAL8FrequencySeries(lw)
return out
def from_xml(cls, xml, name):
# find the root of the XML tree containing the
# serialization of this object
xml = cls.get_xml_root(xml, name)
# create a mostly uninitialized instance
self = cls(None)
# populate from XML
self.noise_lr_lnpdf = rate.BinnedLnPDF.from_xml(xml, u"noise_lr_lnpdf")
self.signal_lr_lnpdf = rate.BinnedLnPDF.from_xml(
xml, u"signal_lr_lnpdf")
self.zero_lag_lr_lnpdf = rate.BinnedLnPDF.from_xml(
xml, u"zero_lag_lr_lnpdf")
self.segments = ligolw_param.get_pyvalue(xml, u"segments").strip()
self.segments = segmentsUtils.from_range_strings(
self.segments.split(",") if self.segments else [], float)
self.template_ids = frozenset(
map(int,
ligolw_param.get_pyvalue(xml, u"template_ids").split(",")))
return self
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 from_xml(cls, xml, name = u"string_cusp"):
# find the root of the XML tree containing the
# serialization of this object
xml = cls.get_xml_root(xml, name)
# create a mostly uninitialized instance
self = cls(None)
# popuate from XML
self.noise_lr_lnpdf = rate.BinnedLnPDF.from_xml(xml, u"noise_lr_lnpdf")
self.signal_lr_lnpdf = rate.BinnedLnPDF.from_xml(xml, u"signal_lr_lnpdf")
self.candidates_lr_lnpdf = rate.BinnedLnPDF.from_xml(xml, u"candidates_lr_lnpdf")
self.segments = ligolw_param.get_pyvalue(xml, u"segments").strip()
self.segments = segmentsUtils.from_range_strings(self.segments.split(",") if self.segments else [], float)
return self
def __init__(self,
bank_xmldoc,
psd,
rate,
f_low,
f_high=None,
autocorrelation_length=None,
verbose=False):
self.bank_id = None
self.sample_rate = rate
self.template_bank_filename = None
self.processed_psd = None
self.horizon_factors = None
self.horizon_distance_func = lambda psd, snr: [100, None]
self.sngl_inspiral_table = lsctables.SnglInspiralTable.get_table(
bank_xmldoc)
# Until the correct way to set the time_slice for multiple templates is known, generating more than one
# template is forbidden. #FIXME: it looks like allowing this, the SNRs is unaffected
# assert len(self.sngl_inspiral_table) == 1
# FIXME: still correct if we have more than one templates?
template = min(self.sngl_inspiral_table, key=lambda row: row.mchirp)
self.template_duration = lalsim.SimInspiralChirpTimeBound(
f_low, template.mass1 * lal.MSUN_SI, template.mass2 * lal.MSUN_SI,
0., 0.)
self.time_slice = numpy.array([(rate, 0, self.template_duration)],
dtype=[("rate", "int"),
("begin", "float"),
("end", "float")])
self.templates, self.autocorrelation_bank, self.autocorrelation_mask, self.sigmasq, self.processed_psd = generate_templates(
self.sngl_inspiral_table,
ligolw_param.get_pyvalue(bank_xmldoc, "approximant"),
psd,
f_low,
self.time_slice,
f_high=f_high,
autocorrelation_length=autocorrelation_length,
verbose=verbose)
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): xml = cls.get_xml_root(xml, name) self = cls(lsctables.instrumentsproperty.get(ligolw_param.get_pyvalue(xml, "instruments"))) for key in self.densities: self.densities[key] = rate.BinnedLnPDF.from_xml(xml, key) return self