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