def ligolw_burca( xmldoc, process_id, EventListType, CoincTables, coinc_definer_row, event_comparefunc, thresholds, ntuple_comparefunc = lambda events, offset_vector: False, min_instruments = 2, verbose = False ): # # validate input # if min_instruments < 1: raise ValueError("min_instruments (=%d) must be >= 1" % min_instruments) # # prepare the coincidence table interface. # if verbose: print >>sys.stderr, "indexing ..." coinc_tables = CoincTables(xmldoc) coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, coinc_definer_row.search, coinc_definer_row.search_coinc_type, create_new = True, description = coinc_definer_row.description) sngl_burst_table = lsctables.SnglBurstTable.get_table(xmldoc) sngl_index = dict((row.event_id, row) for row in sngl_burst_table) # # build the event list accessors, populated with events from those # processes that can participate in a coincidence # eventlists = snglcoinc.EventListDict(EventListType, sngl_burst_table, instruments = set(coinc_tables.time_slide_table.getColumnByName("instrument"))) # # construct offset vector assembly graph # time_slide_graph = snglcoinc.TimeSlideGraph(coinc_tables.time_slide_index, verbose = verbose) # # retrieve all coincidences, apply the final n-tuple compare func # and record the survivors # for node, coinc in time_slide_graph.get_coincs(eventlists, event_comparefunc, thresholds, verbose = verbose): if len(coinc) < min_instruments: continue ntuple = tuple(sngl_index[id] for id in coinc) if not ntuple_comparefunc(ntuple, node.offset_vector): coinc_tables.append_coinc(*coinc_tables.coinc_rows(process_id, node.time_slide_id, coinc_def_id, ntuple)) # # done # return xmldoc
def ligolw_burca( xmldoc, process_id, EventListType, CoincTables, coinc_definer_row, event_comparefunc, thresholds, ntuple_comparefunc = lambda events, offset_vector: False, verbose = False ): # # prepare the coincidence table interface. # if verbose: print >>sys.stderr, "indexing ..." coinc_tables = CoincTables(xmldoc) coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, coinc_definer_row.search, coinc_definer_row.search_coinc_type, create_new = True, description = coinc_definer_row.description) sngl_index = dict((row.event_id, row) for row in lsctables.SnglBurstTable.get_table(xmldoc)) # # build the event list accessors, populated with events from those # processes that can participate in a coincidence # eventlists = snglcoinc.make_eventlists(xmldoc, EventListType, lsctables.SnglBurstTable.tableName) # # construct offset vector assembly graph # time_slide_graph = snglcoinc.TimeSlideGraph(coinc_tables.time_slide_index, verbose = verbose) # # retrieve all coincidences, apply the final n-tuple compare func # and record the survivors # for node, coinc in time_slide_graph.get_coincs(eventlists, event_comparefunc, thresholds, verbose = verbose): ntuple = tuple(sngl_index[id] for id in coinc) if not ntuple_comparefunc(ntuple, node.offset_vector): coinc_tables.append_coinc(process_id, node.time_slide_id, coinc_def_id, ntuple) # # remove time offsets from events # del eventlists.offsetvector # # done # return xmldoc
def burca(xmldoc, process_id, EventListType, CoincTables, coinc_definer_row, thresholds, ntuple_comparefunc=lambda events, offset_vector: False, min_instruments=2, verbose=False): # # validate input # if min_instruments < 1: raise ValueError("min_instruments (=%d) must be >= 1" % min_instruments) # # prepare the coincidence table interface. # if verbose: print >> sys.stderr, "indexing ..." coinc_tables = CoincTables(xmldoc) coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, coinc_definer_row.search, coinc_definer_row.search_coinc_type, create_new=True, description=coinc_definer_row.description) # # build the event list accessors, populated with events from those # processes that can participate in a coincidence # eventlists = snglcoinc.EventListDict( EventListType, lsctables.SnglBurstTable.get_table(xmldoc), instruments=set( coinc_tables.time_slide_table.getColumnByName("instrument"))) # # construct offset vector assembly graph # time_slide_graph = snglcoinc.TimeSlideGraph( coinc_tables.time_slide_index, min_instruments=min_instruments, verbose=verbose) # # retrieve all coincidences, apply the final n-tuple compare func # and record the survivors # for node, coinc in time_slide_graph.get_coincs(eventlists, thresholds, verbose=verbose): if not ntuple_comparefunc(coinc, node.offset_vector): coinc_tables.append_coinc(*coinc_tables.coinc_rows( process_id, node.time_slide_id, coinc_def_id, coinc)) # # done # return xmldoc
def ligolw_thinca(xmldoc, process_id, coinc_definer_row, event_comparefunc, thresholds, ntuple_comparefunc=default_ntuple_comparefunc, effective_snr_factor=250.0, veto_segments=None, trigger_program=u"inspiral", likelihood_func=None, likelihood_params_func=None, verbose=False, max_dt=None): # # prepare the coincidence table interface. # if verbose: print >> sys.stderr, "indexing ..." coinc_tables = InspiralCoincTables( xmldoc, vetoes=veto_segments, program=trigger_program, likelihood_func=likelihood_func, likelihood_params_func=likelihood_params_func) coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, coinc_definer_row.search, coinc_definer_row.search_coinc_type, create_new=True, description=coinc_definer_row.description) sngl_index = dict((row.event_id, row) for row in lsctables.SnglInspiralTable.get_table(xmldoc)) # # build the event list accessors, populated with events from those # processes that can participate in a coincidence. apply vetoes by # removing events from the lists that fall in vetoed segments # eventlists = snglcoinc.make_eventlists( xmldoc, InspiralEventList, lsctables.SnglInspiralTable.tableName) if veto_segments is not None: for eventlist in eventlists.values(): iterutils.inplace_filter( (lambda event: event.ifo not in veto_segments or event.end not in veto_segments[event.ifo]), eventlist) # # set the \Delta t parameter on all the event lists # if max_dt is None: max_dt = inspiral_max_dt(lsctables.SnglInspiralTable.get_table(xmldoc), thresholds) if verbose: print >> sys.stderr, "event bisection search window will be %.16g s" % max_dt for eventlist in eventlists.values(): eventlist.set_dt(max_dt) # # replicate the ethinca parameter for every possible instrument # pair # thresholds = replicate_threshold(thresholds, set(eventlists)) # # construct offset vector assembly graph # time_slide_graph = snglcoinc.TimeSlideGraph(coinc_tables.time_slide_index, verbose=verbose) # # retrieve all coincidences, apply the final n-tuple compare func # and record the survivors # for node, coinc in time_slide_graph.get_coincs(eventlists, event_comparefunc, thresholds, verbose=verbose): coinc = tuple(sngl_index[event_id] for event_id in coinc) if not ntuple_comparefunc(coinc, node.offset_vector): coinc_tables.append_coinc(process_id, node.time_slide_id, coinc_def_id, coinc, effective_snr_factor) # # remove time offsets from events # del eventlists.offsetvector # # done # return xmldoc
def __init__(self, xmldoc, b_b_def, sb_b_def, si_b_def, sb_c_e_def, sb_c_n_def, si_c_e_def, si_c_n_def, process, livetime_program): # # store the process row # self.process = process # # locate the sngl_burst, time_slide and injection tables # self.snglbursttable = lsctables.SnglBurstTable.get_table(xmldoc) try: self.simbursttable = lsctables.SimBurstTable.get_table(xmldoc) except ValueError: self.simbursttable = None try: self.siminspiraltable = lsctables.SimInspiralTable.get_table(xmldoc) except ValueError: self.siminspiraltable = None try: timeslidetable = lsctables.TimeSlideTable.get_table(xmldoc) except ValueError: timeslidetable = None if timeslidetable is not None: self.offsetvectors = timeslidetable.as_dict() else: self.offsetvectors = {} # # store the longest duration of a burst event # if self.snglbursttable: self.longestduration = max(self.snglbursttable.getColumnByName("duration")) else: self.longestduration = 0.0 # # get a segmentlistdict indicating the times when the jobs # that produced burst events could have produced output # self.seglists = ligolw_search_summary.segmentlistdict_fromsearchsummary(xmldoc, livetime_program).coalesce() # # FIXME: in the future, the sim_inspiral table should # indicate time slide at which the injection was done, like # the sim_burst table does. for now, fake it by giving # each one a time_slide_id attribute. this is the only # reason why a place-holder class is required for the # SimInspiral row type; that class can be deleted when # this is no longer needed # if self.siminspiraltable is not None: time_slide_id = ligolw_time_slide.get_time_slide_id(xmldoc, {}.fromkeys(self.seglists, 0.0), create_new = process, superset_ok = True, nonunique_ok = False) for sim in self.siminspiraltable: sim.time_slide_id = time_slide_id # # get coinc_definer rows for sim_* <--> sngl_burst coincs # for whichever sim_* tables are present; this creates a # coinc_definer table if the document doesn't have one # if self.simbursttable is not None: self.sb_b_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, sb_b_def.search, sb_b_def.search_coinc_type, create_new = True, description = sb_b_def.description) else: self.sb_b_coinc_def_id = None if self.siminspiraltable is not None: self.si_b_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, si_b_def.search, si_b_def.search_coinc_type, create_new = True, description = si_b_def.description) else: self.si_b_coinc_def_id = None # # get coinc_def_id's for sngl_burst <--> sngl_burst, and # both kinds of sim_* <--> coinc_event coincs. set all to # None if this document does not contain any sngl_burst # <--> sngl_burst coincs. # try: b_b_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, b_b_def.search, b_b_def.search_coinc_type, create_new = False) except KeyError: b_b_coinc_def_id = None self.sb_c_e_coinc_def_id = None self.sb_c_n_coinc_def_id = None self.si_c_e_coinc_def_id = None self.si_c_n_coinc_def_id = None else: if self.simbursttable is not None: self.sb_c_e_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, sb_c_e_def.search, sb_c_e_def.search_coinc_type, create_new = True, description = sb_c_e_def.description) self.sb_c_n_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, sb_c_n_def.search, sb_c_n_def.search_coinc_type, create_new = True, description = sb_c_n_def.description) else: self.sb_c_e_coinc_def_id = None self.sb_c_n_coinc_def_id = None if self.siminspiraltable is not None: self.si_c_e_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, si_c_e_def.search, si_c_e_def.search_coinc_type, create_new = True, description = si_c_e_def.description) self.si_c_n_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, si_c_n_def.search, si_c_n_def.search_coinc_type, create_new = True, description = si_c_n_def.description) else: self.si_c_e_coinc_def_id = None self.si_c_n_coinc_def_id = None # # get coinc table, create one if needed # try: self.coinctable = lsctables.CoincTable.get_table(xmldoc) except ValueError: self.coinctable = lsctables.New(lsctables.CoincTable) xmldoc.childNodes[0].appendChild(self.coinctable) self.coinctable.sync_next_id() # # get coinc_map table, create one if needed # try: self.coincmaptable = lsctables.CoincMapTable.get_table(xmldoc) except ValueError: self.coincmaptable = lsctables.New(lsctables.CoincMapTable) xmldoc.childNodes[0].appendChild(self.coincmaptable) # # index the document # # index sngl_burst table index = dict((row.event_id, row) for row in self.snglbursttable) # find IDs of burst<-->burst coincs self.coincs = dict((row.coinc_event_id, []) for row in self.coinctable if row.coinc_def_id == b_b_coinc_def_id) # construct event list for each burst<-->burst coinc for row in self.coincmaptable: try: self.coincs[row.coinc_event_id].append(index[row.event_id]) except KeyError: pass del index # sort the event list for each coin by peak time and # convert to tuples for speed for coinc_event_id, events in self.coincs.items(): events.sort(lambda a, b: cmp(a.peak_time, b.peak_time) or cmp(a.peak_time_ns, b.peak_time_ns)) self.coincs[coinc_event_id] = tuple(events) # convert dictionary to a list of (coinc_event_id, events) # tuples and create a coinc_event_id to offset vector # look-up table self.coincs = self.coincs.items() self.coincoffsets = dict((row.coinc_event_id, self.offsetvectors[row.time_slide_id]) for row in self.coinctable if row.coinc_def_id == b_b_coinc_def_id) # # represent the sngl_burst table as a dictionary indexed by # instrument whose values are the event lists for those # instruments sorted by peak time. sort the coincs list by # the peak time of the first (earliest) event in each coinc # (recall that the event tuple for each coinc has been # time-ordered) # self.snglbursttable = dict((instrument, sorted((event for event in self.snglbursttable if event.ifo == instrument), lambda a, b: cmp(a.peak_time, b.peak_time) or cmp(a.peak_time_ns, b.peak_time_ns))) for instrument in set(self.snglbursttable.getColumnByName("ifo"))) self.coincs.sort(lambda (id_a, events_a), (id_b, events_b): cmp(events_a[0].peak_time, events_b[0].peak_time) or cmp(events_a[0].peak_time_ns, events_b[0].peak_time_ns))
def __init__(self, xmldoc, bbdef, sbdef, scndef, process, sngl_type, sim_type, get_sngl_time): # # store the process row # self.process = process # # locate the sngl_inspiral and sim_inspiral tables # self.sngltable = sngl_type.get_table(xmldoc) try: self.simtable = sim_type.get_table(xmldoc) except ValueError: self.simtable = lsctables.SimInspiralTable.get_table(xmldoc) print >> sys.stderr, "No SimRingdownTable, use SimInspiralTable instead!" # # construct the zero-lag time slide needed to cover the # instruments listed in all the triggers, then determine # its ID (or create it if needed) # # FIXME: in the future, the sim_inspiral table should # indicate time slide at which the injection was done # self.tisi_id = ligolw_tisi.get_time_slide_id(xmldoc, {}.fromkeys( self.sngltable.getColumnByName("ifo"), 0.0), create_new=process) # # get coinc_definer row for sim_type <--> sngl_type # coincs; this creates a coinc_definer table if the # document doesn't have one # self.sb_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, sbdef.search, sbdef.search_coinc_type, create_new=True, description=sbdef.description) # # get coinc_def_id's for sngl_type <--> sngl_type, and # the sim_type <--> coinc_event coincs. set all # to None if this document does not contain any sngl_type # <--> sngl_type coincs. # try: bb_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, bbdef.search, bbdef.search_coinc_type, create_new=False) except KeyError: bb_coinc_def_id = None self.scn_coinc_def_id = None else: self.scn_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, scndef.search, scndef.search_coinc_type, create_new=True, description=scndef.description) # # get coinc table, create one if needed # try: self.coinctable = lsctables.CoincTable.get_table(xmldoc) except ValueError: self.coinctable = lsctables.New(lsctables.CoincTable) xmldoc.childNodes[0].appendChild(self.coinctable) self.coinctable.sync_next_id() # # get coinc_map table, create one if needed # try: self.coincmaptable = lsctables.CoincMapTable.get_table(xmldoc) except ValueError: self.coincmaptable = lsctables.New(lsctables.CoincMapTable) xmldoc.childNodes[0].appendChild(self.coincmaptable) # # index the document # # FIXME: type<-->type coincs should be organized by time # slide ID, but since injections are only done at zero lag # for now this is ignored. # # index sngl_type table index = {} for row in self.sngltable: index[row.event_id] = row # find IDs of type<-->type coincs self.coincs = {} for coinc in self.coinctable: if coinc.coinc_def_id == bb_coinc_def_id: self.coincs[coinc.coinc_event_id] = [] # construct event list for each type<-->type coinc for row in self.coincmaptable: if row.coinc_event_id in self.coincs: self.coincs[row.coinc_event_id].append(index[row.event_id]) del index # sort each event list by end/start time and convert to tuples # for speed for coinc_event_id, events in self.coincs.iteritems(): events.sort(key=get_sngl_time) self.coincs[coinc_event_id] = tuple(events) # convert dictionary to a list self.coincs = self.coincs.items() # # FIXME Is this true for inspirals too? # sort sngl_type table by end/start time, and sort the coincs # list by the end/start time of the first (earliest) event in # each coinc (recall that the event tuple for each coinc # has been time-ordered) # self.sngltable.sort(key=get_sngl_time) self.coincs.sort(key=lambda (id, a): get_sngl_time(a[0])) # # set the window for type_near_time(). this window # is the amount of time such that if an injection's end # time and a inspiral event's end time differ by more than # this it is *impossible* for them to match one another. # # FIXME I'll just make the windows 1.0 s self.search_time_window = 1.0 self.coinc_time_window = 1.0
def __init__(self, xmldoc, bbdef, sbdef, scndef, process, sngl_type, sim_type, get_sngl_time): # # store the process row # self.process = process # # locate the sngl_inspiral and sim_inspiral tables # self.sngltable = sngl_type.get_table(xmldoc) try: self.simtable = sim_type.get_table(xmldoc) except ValueError: self.simtable = lsctables.SimInspiralTable.get_table(xmldoc) print >>sys.stderr,"No SimRingdownTable, use SimInspiralTable instead!" # # construct the zero-lag time slide needed to cover the # instruments listed in all the triggers, then determine # its ID (or create it if needed) # # FIXME: in the future, the sim_inspiral table should # indicate time slide at which the injection was done # self.tisi_id = ligolw_tisi.get_time_slide_id(xmldoc, {}.fromkeys(self.sngltable.getColumnByName("ifo"), 0.0), create_new = process) # # get coinc_definer row for sim_type <--> sngl_type # coincs; this creates a coinc_definer table if the # document doesn't have one # self.sb_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, sbdef.search, sbdef.search_coinc_type, create_new = True, description = sbdef.description) # # get coinc_def_id's for sngl_type <--> sngl_type, and # the sim_type <--> coinc_event coincs. set all # to None if this document does not contain any sngl_type # <--> sngl_type coincs. # try: bb_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, bbdef.search, bbdef.search_coinc_type, create_new = False) except KeyError: bb_coinc_def_id = None self.scn_coinc_def_id = None else: self.scn_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, scndef.search, scndef.search_coinc_type, create_new = True, description = scndef.description) # # get coinc table, create one if needed # try: self.coinctable = lsctables.CoincTable.get_table(xmldoc) except ValueError: self.coinctable = lsctables.New(lsctables.CoincTable) xmldoc.childNodes[0].appendChild(self.coinctable) self.coinctable.sync_next_id() # # get coinc_map table, create one if needed # try: self.coincmaptable = lsctables.CoincMapTable.get_table(xmldoc) except ValueError: self.coincmaptable = lsctables.New(lsctables.CoincMapTable) xmldoc.childNodes[0].appendChild(self.coincmaptable) # # index the document # # FIXME: type<-->type coincs should be organized by time # slide ID, but since injections are only done at zero lag # for now this is ignored. # # index sngl_type table index = {} for row in self.sngltable: index[row.event_id] = row # find IDs of type<-->type coincs self.coincs = {} for coinc in self.coinctable: if coinc.coinc_def_id == bb_coinc_def_id: self.coincs[coinc.coinc_event_id] = [] # construct event list for each type<-->type coinc for row in self.coincmaptable: if row.coinc_event_id in self.coincs: self.coincs[row.coinc_event_id].append(index[row.event_id]) del index # sort each event list by end/start time and convert to tuples # for speed for coinc_event_id, events in self.coincs.iteritems(): events.sort(key=get_sngl_time) self.coincs[coinc_event_id]=tuple(events) # convert dictionary to a list self.coincs = self.coincs.items() # # FIXME Is this true for inspirals too? # sort sngl_type table by end/start time, and sort the coincs # list by the end/start time of the first (earliest) event in # each coinc (recall that the event tuple for each coinc # has been time-ordered) # self.sngltable.sort(key=get_sngl_time) self.coincs.sort(key=lambda(id,a): get_sngl_time(a[0])) # # set the window for type_near_time(). this window # is the amount of time such that if an injection's end # time and a inspiral event's end time differ by more than # this it is *impossible* for them to match one another. # # FIXME I'll just make the windows 1.0 s self.search_time_window = 1.0 self.coinc_time_window = 1.0
def ligolw_thinca( xmldoc, process_id, coinc_definer_row, event_comparefunc, thresholds, ntuple_comparefunc = default_ntuple_comparefunc, effective_snr_factor = 250.0, veto_segments = None, trigger_program = u"inspiral", likelihood_func = None, likelihood_params_func = None, verbose = False, max_dt = None ): # # prepare the coincidence table interface. # if verbose: print >>sys.stderr, "indexing ..." coinc_tables = InspiralCoincTables(xmldoc, vetoes = veto_segments, program = trigger_program, likelihood_func = likelihood_func, likelihood_params_func = likelihood_params_func) coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, coinc_definer_row.search, coinc_definer_row.search_coinc_type, create_new = True, description = coinc_definer_row.description) sngl_index = dict((row.event_id, row) for row in lsctables.SnglInspiralTable.get_table(xmldoc)) # # build the event list accessors, populated with events from those # processes that can participate in a coincidence. apply vetoes by # removing events from the lists that fall in vetoed segments # eventlists = snglcoinc.make_eventlists(xmldoc, InspiralEventList, lsctables.SnglInspiralTable.tableName) if veto_segments is not None: for eventlist in eventlists.values(): iterutils.inplace_filter((lambda event: event.ifo not in veto_segments or event.get_end() not in veto_segments[event.ifo]), eventlist) # # set the \Delta t parameter on all the event lists # if max_dt is None: max_dt = inspiral_max_dt(lsctables.SnglInspiralTable.get_table(xmldoc), thresholds) if verbose: print >>sys.stderr, "event bisection search window will be %.16g s" % max_dt for eventlist in eventlists.values(): eventlist.set_dt(max_dt) # # replicate the ethinca parameter for every possible instrument # pair # thresholds = replicate_threshold(thresholds, set(eventlists)) # # construct offset vector assembly graph # time_slide_graph = snglcoinc.TimeSlideGraph(coinc_tables.time_slide_index, verbose = verbose) # # retrieve all coincidences, apply the final n-tuple compare func # and record the survivors # for node, coinc in time_slide_graph.get_coincs(eventlists, event_comparefunc, thresholds, verbose = verbose): coinc = tuple(sngl_index[event_id] for event_id in coinc) if not ntuple_comparefunc(coinc, node.offset_vector): coinc_tables.append_coinc(process_id, node.time_slide_id, coinc_def_id, coinc, effective_snr_factor) # # remove time offsets from events # del eventlists.offsetvector # # done # return xmldoc
def __init__(self, xmldoc, bbdef, sbdef, scedef, scndef, process, end_time_bisect_window): # # store the process row # self.process = process # # locate the sngl_inspiral and sim_inspiral tables # self.snglinspiraltable = lsctables.SnglInspiralTable.get_table(xmldoc) self.siminspiraltable = lsctables.SimInspiralTable.get_table(xmldoc) # # get the offset vectors from the document # self.offsetvectors = lsctables.TimeSlideTable.get_table( xmldoc).as_dict() # # get out segment lists for programs that generated # triggers (currently only used for time_slide vector # construction) # seglists = lsctables.SearchSummaryTable.get_table( xmldoc).get_out_segmentlistdict( set(self.snglinspiraltable.getColumnByName( "process_id"))).coalesce() # # construct the zero-lag time slide needed to cover the # instruments listed in all the triggers, then determine # its ID (or create it if needed) # # FIXME: in the future, the sim_inspiral table should # indicate time slide at which the injection was done # self.tisi_id = ligolw_time_slide.get_time_slide_id(xmldoc, {}.fromkeys( seglists, 0.0), create_new=process) # # get coinc_definer row for sim_inspiral <--> sngl_inspiral # coincs; this creates a coinc_definer table if the # document doesn't have one # self.sb_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, sbdef.search, sbdef.search_coinc_type, create_new=True, description=sbdef.description) # # get coinc_def_id's for sngl_inspiral <--> sngl_inspiral, and # both kinds of sim_inspiral <--> coinc_event coincs. set all # to None if this document does not contain any sngl_inspiral # <--> sngl_inspiral coincs. # try: ii_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, bbdef.search, bbdef.search_coinc_type, create_new=False) except KeyError: ii_coinc_def_id = None self.sce_coinc_def_id = None self.scn_coinc_def_id = None else: self.sce_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, scedef.search, scedef.search_coinc_type, create_new=True, description=scedef.description) self.scn_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, scndef.search, scndef.search_coinc_type, create_new=True, description=scndef.description) # # get coinc table, create one if needed # try: self.coinctable = lsctables.CoincTable.get_table(xmldoc) except ValueError: self.coinctable = lsctables.New(lsctables.CoincTable) xmldoc.childNodes[0].appendChild(self.coinctable) self.coinctable.sync_next_id() # # get coinc_map table, create one if needed # try: self.coincmaptable = lsctables.CoincMapTable.get_table(xmldoc) except ValueError: self.coincmaptable = lsctables.New(lsctables.CoincMapTable) xmldoc.childNodes[0].appendChild(self.coincmaptable) # # index the document # # FIXME: inspiral<-->inspiral coincs should be organized by time # slide ID, but since injections are only done at zero lag # for now this is ignored. # # index the sngl_inspiral table index = dict((row.event_id, row) for row in self.snglinspiraltable) # find IDs of inspiral<-->inspiral coincs self.sngls = dict((row.coinc_event_id, []) for row in self.coinctable if row.coinc_def_id == ii_coinc_def_id) # construct event list for each inspiral<-->inspiral coinc for row in self.coincmaptable: try: self.sngls[row.coinc_event_id].append(index[row.event_id]) except KeyError: pass del index # construct a sngl-->coincs look-up table self.coincs = dict((event.event_id, set()) for events in self.sngls.values() for event in events) for row in self.coincmaptable: if row.event_id in self.coincs and row.coinc_event_id in self.sngls: self.coincs[row.event_id].add(row.coinc_event_id) # create a coinc_event_id to offset vector look-up table self.coincoffsets = dict( (row.coinc_event_id, self.offsetvectors[row.time_slide_id]) for row in self.coinctable if row.coinc_def_id == ii_coinc_def_id) # # sort sngl_inspiral table by end time, and sort the coincs # list by the end time of the first (earliest) event in # each coinc (recall that the event tuple for each coinc # has been time-ordered) # self.snglinspiraltable.sort(lambda a, b: cmp(a.end_time, b.end_time) or cmp(a.end_time_ns, b.end_time_ns)) # # set the window for inspirals_near_endtime(). this window # is the amount of time such that if an injection's end # time and a inspiral event's end time differ by more than # this it is *impossible* for them to match one another. # self.end_time_bisect_window = LIGOTimeGPS(end_time_bisect_window)
def __init__(self, xmldoc, b_b_def, sb_b_def, si_b_def, sb_c_e_def, sb_c_n_def, si_c_e_def, si_c_n_def, process, livetime_program): # # store the process row # self.process = process # # locate the sngl_burst, time_slide and injection tables # self.snglbursttable = lsctables.SnglBurstTable.get_table(xmldoc) try: self.simbursttable = lsctables.SimBurstTable.get_table(xmldoc) except ValueError: self.simbursttable = None try: self.siminspiraltable = lsctables.SimInspiralTable.get_table( xmldoc) except ValueError: self.siminspiraltable = None try: timeslidetable = lsctables.TimeSlideTable.get_table(xmldoc) except ValueError: timeslidetable = None if timeslidetable is not None: self.offsetvectors = timeslidetable.as_dict() else: self.offsetvectors = {} # # store the longest duration of a burst event # if self.snglbursttable: self.longestduration = max( self.snglbursttable.getColumnByName("duration")) else: self.longestduration = 0.0 # # get a segmentlistdict indicating the times when the jobs # that produced burst events could have produced output # self.seglists = ligolw_search_summary.segmentlistdict_fromsearchsummary( xmldoc, livetime_program).coalesce() # # FIXME: in the future, the sim_inspiral table should # indicate time slide at which the injection was done, like # the sim_burst table does. for now, fake it by giving # each one a time_slide_id attribute. this is the only # reason why a place-holder class is required for the # SimInspiral row type; that class can be deleted when # this is no longer needed # if self.siminspiraltable is not None: time_slide_id = ligolw_time_slide.get_time_slide_id( xmldoc, {}.fromkeys(self.seglists, 0.0), create_new=process, superset_ok=True, nonunique_ok=False) for sim in self.siminspiraltable: sim.time_slide_id = time_slide_id # # get coinc_definer rows for sim_* <--> sngl_burst coincs # for whichever sim_* tables are present; this creates a # coinc_definer table if the document doesn't have one # if self.simbursttable is not None: self.sb_b_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, sb_b_def.search, sb_b_def.search_coinc_type, create_new=True, description=sb_b_def.description) else: self.sb_b_coinc_def_id = None if self.siminspiraltable is not None: self.si_b_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, si_b_def.search, si_b_def.search_coinc_type, create_new=True, description=si_b_def.description) else: self.si_b_coinc_def_id = None # # get coinc_def_id's for sngl_burst <--> sngl_burst, and # both kinds of sim_* <--> coinc_event coincs. set all to # None if this document does not contain any sngl_burst # <--> sngl_burst coincs. # try: b_b_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, b_b_def.search, b_b_def.search_coinc_type, create_new=False) except KeyError: b_b_coinc_def_id = None self.sb_c_e_coinc_def_id = None self.sb_c_n_coinc_def_id = None self.si_c_e_coinc_def_id = None self.si_c_n_coinc_def_id = None else: if self.simbursttable is not None: self.sb_c_e_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, sb_c_e_def.search, sb_c_e_def.search_coinc_type, create_new=True, description=sb_c_e_def.description) self.sb_c_n_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, sb_c_n_def.search, sb_c_n_def.search_coinc_type, create_new=True, description=sb_c_n_def.description) else: self.sb_c_e_coinc_def_id = None self.sb_c_n_coinc_def_id = None if self.siminspiraltable is not None: self.si_c_e_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, si_c_e_def.search, si_c_e_def.search_coinc_type, create_new=True, description=si_c_e_def.description) self.si_c_n_coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, si_c_n_def.search, si_c_n_def.search_coinc_type, create_new=True, description=si_c_n_def.description) else: self.si_c_e_coinc_def_id = None self.si_c_n_coinc_def_id = None # # get coinc table, create one if needed # try: self.coinctable = lsctables.CoincTable.get_table(xmldoc) except ValueError: self.coinctable = lsctables.New(lsctables.CoincTable) xmldoc.childNodes[0].appendChild(self.coinctable) self.coinctable.sync_next_id() # # get coinc_map table, create one if needed # try: self.coincmaptable = lsctables.CoincMapTable.get_table(xmldoc) except ValueError: self.coincmaptable = lsctables.New(lsctables.CoincMapTable) xmldoc.childNodes[0].appendChild(self.coincmaptable) # # index the document # # index sngl_burst table index = dict((row.event_id, row) for row in self.snglbursttable) # find IDs of burst<-->burst coincs self.coincs = dict((row.coinc_event_id, []) for row in self.coinctable if row.coinc_def_id == b_b_coinc_def_id) # construct event list for each burst<-->burst coinc for row in self.coincmaptable: try: self.coincs[row.coinc_event_id].append(index[row.event_id]) except KeyError: pass del index # sort the event list for each coin by peak time and # convert to tuples for speed for coinc_event_id, events in self.coincs.items(): events.sort(key=lambda event: event.peak) self.coincs[coinc_event_id] = tuple(events) # convert dictionary to a list of (coinc_event_id, events) # tuples and create a coinc_event_id to offset vector # look-up table self.coincs = self.coincs.items() self.coincoffsets = dict( (row.coinc_event_id, self.offsetvectors[row.time_slide_id]) for row in self.coinctable if row.coinc_def_id == b_b_coinc_def_id) # # represent the sngl_burst table as a dictionary indexed by # instrument whose values are the event lists for those # instruments sorted by peak time. sort the coincs list by # the peak time of the first (earliest) event in each coinc # (recall that the event tuple for each coinc has been # time-ordered) # self.snglbursttable = dict( (instrument, sorted((event for event in self.snglbursttable if event.ifo == instrument), key=lambda event: event.peak)) for instrument in set(self.snglbursttable.getColumnByName("ifo"))) self.coincs.sort( key=lambda coinc_id_events: coinc_id_events[1][0].peak)
def __init__(self, xmldoc, bbdef, sbdef, scedef, scndef, process, end_time_bisect_window): # # store the process row # self.process = process # # locate the sngl_inspiral and sim_inspiral tables # self.snglinspiraltable = lsctables.SnglInspiralTable.get_table(xmldoc) self.siminspiraltable = lsctables.SimInspiralTable.get_table(xmldoc) # # get the offset vectors from the document # self.offsetvectors = lsctables.TimeSlideTable.get_table(xmldoc).as_dict() # # get out segment lists for programs that generated # triggers (currently only used for time_slide vector # construction) # seglists = lsctables.SearchSummaryTable.get_table(xmldoc).get_out_segmentlistdict(set(self.snglinspiraltable.getColumnByName("process_id"))).coalesce() # # construct the zero-lag time slide needed to cover the # instruments listed in all the triggers, then determine # its ID (or create it if needed) # # FIXME: in the future, the sim_inspiral table should # indicate time slide at which the injection was done # self.tisi_id = ligolw_time_slide.get_time_slide_id(xmldoc, {}.fromkeys(seglists, 0.0), create_new = process) # # get coinc_definer row for sim_inspiral <--> sngl_inspiral # coincs; this creates a coinc_definer table if the # document doesn't have one # self.sb_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, sbdef.search, sbdef.search_coinc_type, create_new = True, description = sbdef.description) # # get coinc_def_id's for sngl_inspiral <--> sngl_inspiral, and # both kinds of sim_inspiral <--> coinc_event coincs. set all # to None if this document does not contain any sngl_inspiral # <--> sngl_inspiral coincs. # try: ii_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, bbdef.search, bbdef.search_coinc_type, create_new = False) except KeyError: ii_coinc_def_id = None self.sce_coinc_def_id = None self.scn_coinc_def_id = None else: self.sce_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, scedef.search, scedef.search_coinc_type, create_new = True, description = scedef.description) self.scn_coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, scndef.search, scndef.search_coinc_type, create_new = True, description = scndef.description) # # get coinc table, create one if needed # try: self.coinctable = lsctables.CoincTable.get_table(xmldoc) except ValueError: self.coinctable = lsctables.New(lsctables.CoincTable) xmldoc.childNodes[0].appendChild(self.coinctable) self.coinctable.sync_next_id() # # get coinc_map table, create one if needed # try: self.coincmaptable = lsctables.CoincMapTable.get_table(xmldoc) except ValueError: self.coincmaptable = lsctables.New(lsctables.CoincMapTable) xmldoc.childNodes[0].appendChild(self.coincmaptable) # # index the document # # FIXME: inspiral<-->inspiral coincs should be organized by time # slide ID, but since injections are only done at zero lag # for now this is ignored. # # index the sngl_inspiral table index = dict((row.event_id, row) for row in self.snglinspiraltable) # find IDs of inspiral<-->inspiral coincs self.sngls = dict((row.coinc_event_id, []) for row in self.coinctable if row.coinc_def_id == ii_coinc_def_id) # construct event list for each inspiral<-->inspiral coinc for row in self.coincmaptable: try: self.sngls[row.coinc_event_id].append(index[row.event_id]) except KeyError: pass del index # construct a sngl-->coincs look-up table self.coincs = dict((event.event_id, set()) for events in self.sngls.values() for event in events) for row in self.coincmaptable: if row.event_id in self.coincs and row.coinc_event_id in self.sngls: self.coincs[row.event_id].add(row.coinc_event_id) # create a coinc_event_id to offset vector look-up table self.coincoffsets = dict((row.coinc_event_id, self.offsetvectors[row.time_slide_id]) for row in self.coinctable if row.coinc_def_id == ii_coinc_def_id) # # sort sngl_inspiral table by end time, and sort the coincs # list by the end time of the first (earliest) event in # each coinc (recall that the event tuple for each coinc # has been time-ordered) # self.snglinspiraltable.sort(lambda a, b: cmp(a.end_time, b.end_time) or cmp(a.end_time_ns, b.end_time_ns)) # # set the window for inspirals_near_endtime(). this window # is the amount of time such that if an injection's end # time and a inspiral event's end time differ by more than # this it is *impossible* for them to match one another. # self.end_time_bisect_window = LIGOTimeGPS(end_time_bisect_window)
def ligolw_thinca(xmldoc, process_id, coinc_definer_row, thresholds, ntuple_comparefunc=InspiralCoincTables.ntuple_comparefunc, veto_segments=None, trigger_program=u"inspiral", likelihood_func=None, likelihood_params_func=None, min_instruments=2, min_log_L=None, verbose=False): # # validate input # if min_instruments < 1: raise ValueError("min_instruments (=%d) must be >= 1" % min_instruments) if min_log_L is not None and likelihood_func is None: raise ValueError("must supply likelihood_func to impose min_log_L cut") # # prepare the coincidence table interface. # if verbose: print("indexing ...", file=sys.stderr) coinc_tables = InspiralCoincTables( xmldoc, vetoes=veto_segments, program=trigger_program, likelihood_func=likelihood_func, likelihood_params_func=likelihood_params_func) coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, coinc_definer_row.search, coinc_definer_row.search_coinc_type, create_new=True, description=coinc_definer_row.description) instruments = set( coinc_tables.time_slide_table.getColumnByName("instrument")) # # replicate the coincidence window parameter for every possible # instrument pair # thresholds = replicate_threshold(thresholds, instruments) # # build the event list accessors. apply vetoes by excluding events # from the lists that fall in vetoed segments # sngl_inspiral_table = lsctables.SnglInspiralTable.get_table(xmldoc) if veto_segments is not None: sngl_inspiral_table = (event for event in sngl_inspiral_table if event.ifo not in veto_segments or event.end not in veto_segments[event.ifo]) eventlists = snglcoinc.EventListDict(InspiralEventList, sngl_inspiral_table, instruments=instruments) # # construct offset vector assembly graph # time_slide_graph = snglcoinc.TimeSlideGraph( coinc_tables.time_slide_index, min_instruments=min_instruments, verbose=verbose) # # retrieve all coincidences, apply the final n-tuple compare func # and record the survivors # for node, coinc in time_slide_graph.get_coincs(eventlists, thresholds, verbose=verbose): if not ntuple_comparefunc(coinc, node.offset_vector): coinc, coincmaps, coinc_inspiral = coinc_tables.coinc_rows( process_id, node.time_slide_id, coinc_def_id, coinc) if min_log_L is None or coinc.likelihood >= min_log_L: coinc_tables.append_coinc(coinc, coincmaps, coinc_inspiral) # # done # return xmldoc
def ligolw_burca(xmldoc, process_id, EventListType, CoincTables, coinc_definer_row, event_comparefunc, thresholds, ntuple_comparefunc=lambda events, offset_vector: False, verbose=False): # # prepare the coincidence table interface. # if verbose: print >> sys.stderr, "indexing ..." coinc_tables = CoincTables(xmldoc) coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, coinc_definer_row.search, coinc_definer_row.search_coinc_type, create_new=True, description=coinc_definer_row.description) sngl_index = dict((row.event_id, row) for row in lsctables.SnglBurstTable.get_table(xmldoc)) # # build the event list accessors, populated with events from those # processes that can participate in a coincidence # eventlists = snglcoinc.make_eventlists(xmldoc, EventListType, lsctables.SnglBurstTable.tableName) # # construct offset vector assembly graph # time_slide_graph = snglcoinc.TimeSlideGraph(coinc_tables.time_slide_index, verbose=verbose) # # retrieve all coincidences, apply the final n-tuple compare func # and record the survivors # for node, coinc in time_slide_graph.get_coincs(eventlists, event_comparefunc, thresholds, verbose=verbose): ntuple = tuple(sngl_index[id] for id in coinc) if not ntuple_comparefunc(ntuple, node.offset_vector): coinc_tables.append_coinc(process_id, node.time_slide_id, coinc_def_id, ntuple) # # remove time offsets from events # del eventlists.offsetvector # # done # return xmldoc
def ligolw_thinca(xmldoc, process_id, coinc_definer_row, event_comparefunc, thresholds, max_dt, ntuple_comparefunc=default_ntuple_comparefunc, veto_segments=None, trigger_program=u"inspiral", likelihood_func=None, likelihood_params_func=None, min_instruments=2, min_log_L=None, verbose=False): # # validate input # if min_instruments < 1: raise ValueError("min_instruments (=%d) must be >= 1" % min_instruments) if min_log_L is not None and likelihood_func is None: raise ValueError("must supply likelihood_func to impose min_log_L cut") # # prepare the coincidence table interface. # if verbose: print >> sys.stderr, "indexing ..." coinc_tables = InspiralCoincTables( xmldoc, vetoes=veto_segments, program=trigger_program, likelihood_func=likelihood_func, likelihood_params_func=likelihood_params_func) coinc_def_id = ligolw_coincs.get_coinc_def_id( xmldoc, coinc_definer_row.search, coinc_definer_row.search_coinc_type, create_new=True, description=coinc_definer_row.description) sngl_inspiral_table = lsctables.SnglInspiralTable.get_table(xmldoc) sngl_index = dict((row.event_id, row) for row in sngl_inspiral_table) # # build the event list accessors, populated with events from those # processes that can participate in a coincidence. apply vetoes by # removing events from the lists that fall in vetoed segments # eventlists = snglcoinc.EventListDict( InspiralEventList, sngl_inspiral_table, instruments=set( coinc_tables.time_slide_table.getColumnByName("instrument"))) if veto_segments is not None: for eventlist in eventlists.values(): iterutils.inplace_filter( (lambda event: event.ifo not in veto_segments or event.end not in veto_segments[event.ifo]), eventlist) # # set the \Delta t parameter on all the event lists # if verbose: print >> sys.stderr, "event bisection search window will be %.16g s" % max_dt for eventlist in eventlists.values(): eventlist.set_dt(max_dt) # # replicate the ethinca parameter for every possible instrument # pair # thresholds = replicate_threshold(thresholds, eventlists) # # construct offset vector assembly graph # time_slide_graph = snglcoinc.TimeSlideGraph(coinc_tables.time_slide_index, verbose=verbose) # # retrieve all coincidences, apply the final n-tuple compare func # and record the survivors # for node, coinc in time_slide_graph.get_coincs(eventlists, event_comparefunc, thresholds, verbose=verbose): if len(coinc) < min_instruments: continue coinc = tuple(sngl_index[event_id] for event_id in coinc) if not ntuple_comparefunc(coinc, node.offset_vector): coinc, coincmaps, coinc_inspiral = coinc_tables.coinc_rows( process_id, node.time_slide_id, coinc_def_id, coinc) if min_log_L is None or coinc.likelihood >= min_log_L: coinc_tables.append_coinc(coinc, coincmaps, coinc_inspiral) # # done # return xmldoc
def ligolw_thinca( xmldoc, process_id, coinc_definer_row, thresholds, ntuple_comparefunc = InspiralCoincTables.ntuple_comparefunc, seglists = None, veto_segments = None, likelihood_func = None, min_instruments = 2, min_log_L = None, verbose = False ): # # validate input # if min_instruments < 1: raise ValueError("min_instruments (=%d) must be >= 1" % min_instruments) if min_log_L is not None and likelihood_func is None: raise ValueError("must supply likelihood_func to impose min_log_L cut") # # prepare the coincidence table interface. # if verbose: print("indexing ...", file=sys.stderr) coinc_tables = InspiralCoincTables(xmldoc, likelihood_func = likelihood_func) coinc_def_id = ligolw_coincs.get_coinc_def_id(xmldoc, coinc_definer_row.search, coinc_definer_row.search_coinc_type, create_new = True, description = coinc_definer_row.description) instruments = set(coinc_tables.time_slide_table.getColumnByName("instrument")) # # replicate the coincidence window parameter for every possible # instrument pair # thresholds = replicate_threshold(thresholds, instruments) # # build the event list accessors. apply vetoes by excluding events # from the lists that fall in vetoed segments # sngl_inspiral_table = lsctables.SnglInspiralTable.get_table(xmldoc) if veto_segments is not None: sngl_inspiral_table = (event for event in sngl_inspiral_table if event.ifo not in veto_segments or event.end not in veto_segments[event.ifo]) if seglists is not None: # don't do in-place seglists = seglists - veto_segments eventlists = snglcoinc.EventListDict(InspiralEventList, sngl_inspiral_table, instruments = instruments) # # construct offset vector assembly graph # time_slide_graph = snglcoinc.TimeSlideGraph(coinc_tables.time_slide_index, min_instruments = min_instruments, verbose = verbose) # # retrieve all coincidences, apply the final n-tuple compare func # and record the survivors # for node, coinc in time_slide_graph.get_coincs(eventlists, thresholds, verbose = verbose): if not ntuple_comparefunc(coinc, node.offset_vector): coinc, coincmaps, coinc_inspiral = coinc_tables.coinc_rows(process_id, node.time_slide_id, coinc_def_id, coinc, seglists = seglists) if min_log_L is None or coinc.likelihood >= min_log_L: coinc_tables.append_coinc(coinc, coincmaps, coinc_inspiral) # # done # return xmldoc