def __init__(self, detection_threshold, cal_uncertainty, filter_width, open_box): self.detection_threshold = detection_threshold self.cal_uncertainty = cal_uncertainty self.filter_width = filter_width self.seglists = segments.segmentlistdict() self.vetoseglists = segments.segmentlistdict() self.found = [] self.n_diagnostics = 100 # keep 100 loudest missed and quietest found injections self.loudest_missed = [] self.quietest_found = [] self.all = [] self.open_box = open_box
def __init__(self, detection_threshold, cal_uncertainty, filter_width, open_box): self.detection_threshold = detection_threshold self.cal_uncertainty = cal_uncertainty self.filter_width = filter_width self.seglists = segments.segmentlistdict() self.vetoseglists = segments.segmentlistdict() self.found = [] self.n_diagnostics = 100 # keep 100 loudest missed and quietest found injections self.loudest_missed = [] self.quietest_found = [] self.all = [] self.open_box = open_box
def get_single_ifo_segments(connection, program_name="inspiral", usertag=None):
"""
Return a glue.segments.segmentlistdict object containing coalesced single-ifo
segments obtained from the search_summary table.
@param connection: sqlite connection for the input database
@param usertag: the usertag for the desired filter jobs e.g. ("FULL_DATA","PLAYGROUND")
"""
xmldoc = dbtables.get_xml(connection)
seglist_dict = segments.segmentlistdict()
# extract segments indexed by available instrument
for row in map(
dbtables.table.get_table(xmldoc, lsctables.SearchSummaryTable.tableName).row_from_cols,
connection.cursor().execute(
"""
SELECT search_summary.*
FROM search_summary
JOIN process_params ON (
process_params.process_id == search_summary.process_id)
WHERE
process_params.value == :1
AND process_params.program == :2
""",
(usertag, program_name),
),
):
instrument = row.get_ifos().pop()
if usertag == "FULL_DATA" or usertag == "PLAYGROUND":
try:
seglist_dict[instrument].append(row.get_out())
except KeyError:
seglist_dict[instrument] = [row.get_out()]
else:
buffer_time = 72
filtered_segment = segments.segment(row.get_in()[0] + buffer_time, row.get_in()[1] - buffer_time)
try:
seglist_dict[instrument].append(filtered_segment)
except KeyError:
seglist_dict[instrument] = [filtered_segment]
xmldoc.unlink()
seglist_dict = segments.segmentlistdict(
(key, segments.segmentlist(sorted(set(value)))) for key, value in seglist_dict.items()
)
return seglist_dict
def get_coinc_segments(segments_dict, offset_vect): """ Return the exclusive coinc segments for each (time-slide,on instruments) pair for time-slides done along a line (as opposed to rings). @param segments_dict: the glue.segments.segmentlistdict object which contains the single-ifo segments used to compute experiment durations @param offset_vect: the glue.offsetvector object that contains the time shifts for a given time-slide. The keys are the set of ifos being shifted. """ segments_dict.coalesce() on_ifos_dict, excluded_ifos_dict = get_allifo_combos(segments_dict, 2) # the keys for the coinc-segs dictionaries are the TS-ids & ifo-combos coinc_segs = segments.segmentlistdict() # shift the segment times according to the values in the offset vector for ifo, shift in offset_vect.items(): segments_dict.offsets[ifo] = shift for on_ifos_key, combo in on_ifos_dict.items(): # determine inclusive coincident segments for each time_slide coinc_segs[on_ifos_key] = segments_dict.intersection( combo ) # get lists of excluded ifos and associated keys for this coinc-time type excluded_ifos = excluded_ifos_dict[on_ifos_key] if excluded_ifos: # Make exclusive segments coinc_segs[on_ifos_key] -= segments_dict.union( excluded_ifos ) coinc_segs[on_ifos_key].coalesce() return coinc_segs
def get_veto_segments(self, connection):
if self.coinc_inspiral_table:
if self.opts.veto_segments_name is not None:
return db_thinca_rings.get_veto_segments(connection, opts.self.veto_segments_name)
# FIXME BURST CASE VETOS NOT HANDLED
else:
return segments.segmentlistdict()
def parse_config_file(options):
if options.verbose:
print >> sys.stderr, "reading %s ..." % options.config_file
config = ConfigParser.SafeConfigParser()
config.read(options.config_file)
options.tag = config.get("pipeline", "user_tag")
options.enable_clustering = config.getboolean("pipeline",
"enable_clustering")
seglistdict = segments.segmentlistdict()
tiling_phase = {}
for ifo in config.get("pipeline", "ifos").split():
seglistdict[ifo] = segmentsUtils.fromsegwizard(
file(config.get("pipeline", "seglist_%s" % ifo)),
coltype=LIGOTimeGPS).coalesce()
try:
offset = config.getfloat("pipeline", "tiling_phase_%s" % ifo)
except ConfigParser.NoOptionError:
offset = 0.0
if offset:
tiling_phase[ifo] = offset
options.psds_per_power = config.getint("pipeline", "psds_per_power")
options.psds_per_injection = config.getint("pipeline",
"psds_per_injection")
options.timing_params = power.TimingParameters(config)
return seglistdict, tiling_phase, config
def get_by_name(self, name, clip_to_valid = False):
"""
Retrieve the active segmentlists whose name equals name.
The result is a segmentlistdict indexed by instrument. All
segmentlist objects within it will be copies of the
contents of this object, modifications will not affect the
contents of this object. If clip_to_valid is True then the
segmentlists will be intersected with their respective
intervals of validity, otherwise they will be the verbatim
active segments.
NOTE: the intersection operation required by clip_to_valid
will yield undefined results unless the active and valid
segmentlist objects are coalesced.
"""
result = segments.segmentlistdict()
for seglist in self:
if seglist.name != name:
continue
segs = seglist.active
if clip_to_valid:
# do not use in-place intersection
segs = segs & seglist.valid
for instrument in seglist.instruments:
if instrument in result:
raise ValueError("multiple '%s' segmentlists for instrument '%s'" % (name, instrument))
result[instrument] = segments.segmentlist(segs)
if not result:
raise KeyError("no segmentlists named '%s'" % name)
return result
def fromsegmentxml(file, dict=False, id=None):
"""
Read a glue.segments.segmentlist from the file object file containing an
xml segment table.
Arguments:
file : file object
file object for segment xml file
Keyword Arguments:
dict : [ True | False ]
returns a glue.segments.segmentlistdict containing coalesced
glue.segments.segmentlists keyed by seg_def.name for each entry in the
contained segment_def_table. Default False
id : int
returns a glue.segments.segmentlist object containing only those
segments matching the given segment_def_id integer
"""
# load xmldocument and SegmentDefTable and SegmentTables
xmldoc, digest = utils.load_fileobj(file,
gz=file.name.endswith(".gz"),
contenthandler=lsctables.use_in(
ligolw.LIGOLWContentHandler))
seg_def_table = lsctables.SegmentDefTable.get_table(xmldoc)
seg_table = lsctables.SegmentTable.get_table(xmldoc)
if dict:
segs = segments.segmentlistdict()
else:
segs = segments.segmentlist()
seg_id = {}
for seg_def in seg_def_table:
seg_id[int(seg_def.segment_def_id)] = str(seg_def.name)
if dict:
segs[str(seg_def.name)] = segments.segmentlist()
for seg in seg_table:
if dict:
segs[seg_id[int(seg.segment_def_id)]]\
.append(segments.segment(seg.start_time, seg.end_time))
continue
if id and int(seg.segment_def_id) == id:
segs.append(segments.segment(seg.start_time, seg.end_time))
continue
segs.append(segments.segment(seg.start_time, seg.end_time))
if dict:
for seg_name in seg_id.values():
segs[seg_name] = segs[seg_name].coalesce()
else:
segs = segs.coalesce()
xmldoc.unlink()
return segs
def parse_config_file(options):
if options.verbose:
print >>sys.stderr, "reading %s ..." % options.config_file
config = ConfigParser.SafeConfigParser()
config.read(options.config_file)
options.tag = config.get("pipeline", "user_tag")
options.enable_clustering = config.getboolean("pipeline", "enable_clustering")
seglistdict = segments.segmentlistdict()
tiling_phase = {}
for ifo in config.get("pipeline", "ifos").split():
seglistdict[ifo] = segmentsUtils.fromsegwizard(file(config.get("pipeline", "seglist_%s" % ifo)), coltype = LIGOTimeGPS).coalesce()
try:
offset = config.getfloat("pipeline", "tiling_phase_%s" % ifo)
except ConfigParser.NoOptionError:
offset = 0.0
if offset:
tiling_phase[ifo] = offset
options.psds_per_power = config.getint("pipeline", "psds_per_power")
options.psds_per_injection = config.getint("pipeline", "psds_per_injection")
options.timing_params = power.TimingParameters(config)
return seglistdict, tiling_phase, config
def segmentlistdict_from_short_string(s, boundtype=int):
"""
Parse a string representation of a set of named segmentlists into a
segmentlistdict object. The string encoding is that generated by
segmentlistdict_to_short_string(). The optional boundtype argument
will be passed to from_range_strings() when parsing the segmentlist
objects from the string.
Example:
>>> segmentlistdict_from_short_string("H1=0:10,35,100:/L1=5:15,45:60")
{'H1': [segment(0, 10), segment(35, 35), segment(100, infinity)], 'L1': [segment(5, 15), segment(45, 60)]}
This function, and its inverse segmentlistdict_to_short_string(),
are intended to be used to allow small segmentlistdict objects to
be encoded in command line options and config files. For large
segmentlistdict objects or when multiple sets of segmentlists are
required, the LIGO Light Weight XML encoding available through the
glue.ligolw library should be used.
"""
d = segments.segmentlistdict()
for token in s.strip().split("/"):
key, ranges = token.strip().split("=")
d[key.strip()] = from_range_strings(ranges.strip().split(","),
boundtype=boundtype)
return d
def segmentlistdict_from_short_string(s, boundtype = int):
"""
Parse a string representation of a set of named segmentlists into a
segmentlistdict object. The string encoding is that generated by
segmentlistdict_to_short_string(). The optional boundtype argument
will be passed to from_range_strings() when parsing the segmentlist
objects from the string.
Example:
>>> segmentlistdict_from_short_string("H1=0:10,35,100:/L1=5:15,45:60")
{'H1': [segment(0, 10), segment(35, 35), segment(100, infinity)], 'L1': [segment(5, 15), segment(45, 60)]}
This function, and its inverse segmentlistdict_to_short_string(),
are intended to be used to allow small segmentlistdict objects to
be encoded in command line options and config files. For large
segmentlistdict objects or when multiple sets of segmentlists are
required, the LIGO Light Weight XML encoding available through the
glue.ligolw library should be used.
"""
d = segments.segmentlistdict()
for token in s.strip().split("/"):
key, ranges = token.strip().split("=")
d[key.strip()] = from_range_strings(ranges.strip().split(","), boundtype = boundtype)
return d
def get_by_name(self, name, clip_to_valid = False):
"""
Retrieve the active segmentlists whose name equals name.
The result is a segmentlistdict indexed by instrument. All
segmentlist objects within it will be copies of the
contents of this object, modifications will not affect the
contents of this object. If clip_to_valid is True then the
segmentlists will be intersected with their respective
intervals of validity, otherwise they will be the verbatim
active segments.
NOTE: the intersection operation required by clip_to_valid
will yield undefined results unless the active and valid
segmentlist objects are coalesced.
"""
result = segments.segmentlistdict()
for seglist in self:
if seglist.name != name:
continue
segs = seglist.active
if clip_to_valid:
# do not use in-place intersection
segs = segs & seglist.valid
for instrument in seglist.instruments:
if instrument in result:
raise ValueError("multiple '%s' segmentlists for instrument '%s'" % (name, instrument))
result[instrument] = segs.copy()
return result
def make_cache_entry(input_cache, description, path):
# summarize segment information
seglists = segments.segmentlistdict()
for c in input_cache:
seglists |= c.segmentlistdict
# obtain instrument list
instruments = seglists.keys()
if None in instruments:
instruments.remove(None)
instruments.sort()
# remove empty segment lists to allow extent_all() to work
for instrument in seglists.keys():
if not seglists[instrument]:
del seglists[instrument]
# make the URL
if path:
url = "file://localhost%s" % os.path.abspath(path)
else:
url = None
# construct a cache entry from the instruments and
# segments that remain
return CacheEntry("+".join(instruments) or None, description, seglists.extent_all(), url)
def segmentlistdict(self):
"""
A segmentlistdict object describing the instruments and time
spanned by this CacheEntry. A new object is constructed each time
this attribute is accessed (segments are immutable so there is no
reason to try to share a reference to the CacheEntry's internal
segment; modifications of one would not be reflected in the other
anyway).
Example:
>>> c = CacheEntry("H1 S5 815901601 576.5 file://localhost/home/kipp/tmp/1/H1-815901601-576.xml")
>>> c.segmentlistdict['H1']
[segment(LIGOTimeGPS(815901601, 0), LIGOTimeGPS(815902177, 500000000))]
The \"observatory\" column of the cache entry, which is frequently
used to store instrument names, is parsed into instrument names for
the dictionary keys using the same rules as
glue.ligolw.lsctables.instrument_set_from_ifos().
Example:
>>> c = CacheEntry("H1H2, S5 815901601 576.5 file://localhost/home/kipp/tmp/1/H1H2-815901601-576.xml")
>>> c.segmentlistdict['H1H2']
[segment(LIGOTimeGPS(815901601, 0), LIGOTimeGPS(815902177, 500000000))]
"""
# the import has to be done here to break the cyclic
# dependancy
from glue.ligolw.lsctables import instrument_set_from_ifos
instruments = instrument_set_from_ifos(self.observatory) or (None, )
return segments.segmentlistdict(
(instrument,
segments.segmentlist(self.segment is not None and [self.segment]
or [])) for instrument in instruments)
def segmentlistdict(self):
"""
A segmentlistdict object describing the instruments and time
spanned by this CacheEntry. A new object is constructed each time
this attribute is accessed (segments are immutable so there is no
reason to try to share a reference to the CacheEntry's internal
segment; modifications of one would not be reflected in the other
anyway).
Example:
>>> c = CacheEntry("H1 S5 815901601 576.5 file://localhost/home/kipp/tmp/1/H1-815901601-576.xml")
>>> c.segmentlistdict['H1']
[segment(LIGOTimeGPS(815901601, 0), LIGOTimeGPS(815902177, 500000000))]
The \"observatory\" column of the cache entry, which is frequently
used to store instrument names, is parsed into instrument names for
the dictionary keys using the same rules as
glue.ligolw.lsctables.instrumentsproperty.get().
Example:
>>> c = CacheEntry("H1H2, S5 815901601 576.5 file://localhost/home/kipp/tmp/1/H1H2-815901601-576.xml")
>>> c.segmentlistdict['H1H2']
[segment(LIGOTimeGPS(815901601, 0), LIGOTimeGPS(815902177, 500000000))]
"""
# the import has to be done here to break the cyclic
# dependancy
from glue.ligolw.lsctables import instrumentsproperty
instruments = instrumentsproperty.get(self.observatory) or (None,)
return segments.segmentlistdict((instrument, segments.segmentlist(self.segment is not None and [self.segment] or [])) for instrument in instruments)
def make_cache_entry(input_cache, description, path):
# summarize segment information
seglists = segments.segmentlistdict()
for c in input_cache:
seglists |= c.segmentlistdict
# obtain instrument list
instruments = seglists.keys()
if None in instruments:
instruments.remove(None)
instruments.sort()
# remove empty segment lists to allow extent_all() to work
for instrument in seglists.keys():
if not seglists[instrument]:
del seglists[instrument]
# make the URL
if path:
url = "file://localhost%s" % os.path.abspath(path)
else:
# FIXME: old version of CacheEntry allowed None for URL,
# new version doesn't. correct fix is to modify calling
# code to not try to initialize the output cache until
# after the input is known, but for now we'll just do this
# stupid hack.
url = "file://localhost/dev/null"
# construct a cache entry from the instruments and
# segments that remain
return CacheEntry("+".join(instruments) or None, description, seglists.extent_all(), url)
def get_veto_segments(connection, program_name, xmldoc=None, veto_segments_name=None): veto_segments = segments.segmentlistdict() #FIXME only handles thinca case if not veto_segments_name: return veto_segments if program_name == "thinca": veto_segments = db_thinca_rings.get_veto_segments(connection, veto_segments_name) if program_name == "rinca": veto_segments = ligolw_segments.segmenttable_get_by_name(xmldoc, veto_segments_name).coalesce() return veto_segments
def get_segments(connection, xmldoc, program_name): seglists = segments.segmentlistdict() if program_name == "thinca": seglists = db_thinca_rings.get_thinca_zero_lag_segments(connection, program_name) if program_name == "gstlal_inspiral" or program_name == "lalapps_ring": seglists = ligolw_search_summary.segmentlistdict_fromsearchsummary(xmldoc, program_name).coalesce() return seglists
def get_coinc_segments(segments_dict, offset_vect):
"""
Return the exclusive coinc segments for each (time-slide,on instruments) pair for
time-slides done along a line (as opposed to rings).
@param segments_dict: the glue.segments.segmentlistdict object which contains the
single-ifo segments used to compute experiment durations
@param offset_vect: the glue.offsetvector object that contains the time shifts
for a given time-slide. The keys are the set of ifos being shifted.
"""
segments_dict.coalesce()
on_ifos_dict, excluded_ifos_dict = get_allifo_combos(segments_dict, 2)
# the keys for the coinc-segs dictionaries are the TS-ids & ifo-combos
coinc_segs = segments.segmentlistdict()
# shift the segment times according to the values in the offset vector
for ifo, shift in offset_vect.items():
segments_dict.offsets[ifo] = shift
for on_ifos_key, combo in on_ifos_dict.items():
# determine inclusive coincident segments for each time_slide
coinc_segs[on_ifos_key] = segments_dict.intersection(combo)
# get lists of excluded ifos and associated keys for this coinc-time type
excluded_ifos = excluded_ifos_dict[on_ifos_key]
if excluded_ifos:
# Make exclusive segments
coinc_segs[on_ifos_key] -= segments_dict.union(excluded_ifos)
coinc_segs[on_ifos_key].coalesce()
return coinc_segs
def get_single_ifo_segments(connection, program_name="inspiral", usertag=None):
"""
Return a glue.segments.segmentlistdict object containing coalesced single-ifo
segments obtained from the search_summary table.
@param connection: sqlite connection for the input database
@param usertag: the usertag for the desired filter jobs e.g. ("FULL_DATA","PLAYGROUND")
"""
xmldoc = dbtables.get_xml(connection)
seglist_dict = segments.segmentlistdict()
# extract segments indexed by available instrument
for row in map(
dbtables.table.get_table(
xmldoc, lsctables.SearchSummaryTable.tableName).row_from_cols,
connection.cursor().execute(
"""
SELECT search_summary.*
FROM search_summary
JOIN process_params ON (
process_params.process_id == search_summary.process_id)
WHERE
process_params.value == :1
AND process_params.program == :2
""", (usertag, program_name))):
instrument = row.get_ifos().pop()
if usertag == "FULL_DATA" or usertag == "PLAYGROUND":
try:
seglist_dict[instrument].append(row.get_out())
except KeyError:
seglist_dict[instrument] = [row.get_out()]
else:
buffer_time = 72
filtered_segment = segments.segment(row.get_in()[0] + buffer_time,
row.get_in()[1] - buffer_time)
try:
seglist_dict[instrument].append(filtered_segment)
except KeyError:
seglist_dict[instrument] = [filtered_segment]
xmldoc.unlink()
seglist_dict = segments.segmentlistdict(
(key, segments.segmentlist(sorted(set(value))))
for key, value in seglist_dict.items())
return seglist_dict
def parse_command_line():
parser = OptionParser(
version="%prog CVS $Id$"
)
parser.add_option("-s", "--data-start", metavar = "GPSSECONDS", help = "set data segment start time")
parser.add_option("-e", "--data-end", metavar = "GPSSECONDS", help = "set data segment end time")
parser.add_option("-a", "--trig-start", metavar = "GPSSECONDS", help = "set analysis segment start time")
parser.add_option("-b", "--trig-end", metavar = "GPSSECONDS", help = "set analysis segment end time")
parser.add_option("-f", "--dag-name", metavar = "FILENAME", help = "set output .dag file name")
parser.add_option("-t", "--aux-dir", metavar = "PATH", help = "set auxiliary data directory")
parser.add_option("--condor-log-dir", metavar = "PATH", help = "set directory for Condor log")
parser.add_option("--config-file", metavar = "FILENAME", default = "online_power.ini", help = "set .ini config file name")
parser.add_option("--instrument", metavar = "INSTRUMENT", help = "set instrument name (default = value of instrument variable in [pipeline] section of .ini file)")
parser.add_option("--publish-dest", metavar = "PATH", help = "set directory for output triggers")
parser.add_option("--dmtmon-dest", metavar = "PATH", help = "set directory for DMT monitor output")
parser.add_option("--gsiscp-dest", metavar = "PATH", help = "set destination for gsiscp")
parser.add_option("--user-tag", metavar = "TAG", help = "set user tag on jobs that need it")
options, extra_args = parser.parse_args()
# data segment
options.data_seg = segments.segment(lal.LIGOTimeGPS(options.data_start), lal.LIGOTimeGPS(options.data_end))
try:
options.data_seglists = segments.segmentlistdict({options.instrument: segments.segmentlist([options.data_seg])})
except:
raise ValueError, "failure parsing -s and/or -e; try --help"
# trigger segment
options.trig_seg = segments.segment(lal.LIGOTimeGPS(options.trig_start), lal.LIGOTimeGPS(options.trig_end))
try:
options.trig_seglists = segments.segmentlistdict({options.instrument: segments.segmentlist([options.trig_seg])})
except:
raise ValueError, "failure parsing -a and/or -b; try --help"
if True in map(bool, (options.trig_seglists - options.data_seglists).itervalues()):
raise ValueError, "trigger segment not contained in data segment!"
# .dag name
try:
options.dag_name = os.path.splitext(options.dag_name)[0]
except:
raise ValueError, "failure parsing -f; try --help"
# config file
options.config_file = os.path.join(options.aux_dir, options.config_file)
return options
def get_veto_segments(self, connection):
if self.coinc_inspiral_table:
if self.opts.veto_segments_name is not None:
return db_thinca_rings.get_veto_segments(
connection, opts.self.veto_segments_name)
# FIXME BURST CASE VETOS NOT HANDLED
else:
return segments.segmentlistdict()
def __init__(self, x_instrument, y_instrument):
self.fig, self.axes = SnglBurstUtils.make_burst_plot("%s Offset (s)" % x_instrument, "%s Offset (s)" % y_instrument)
self.fig.set_size_inches(6,6)
self.x_instrument = x_instrument
self.y_instrument = y_instrument
self.tisi_rows = None
self.seglists = segments.segmentlistdict()
self.counts = None
def fromsegmentxml(file, dict=False, id=None):
"""
Read a glue.segments.segmentlist from the file object file containing an
xml segment table.
Arguments:
file : file object
file object for segment xml file
Keyword Arguments:
dict : [ True | False ]
returns a glue.segments.segmentlistdict containing coalesced
glue.segments.segmentlists keyed by seg_def.name for each entry in the
contained segment_def_table. Default False
id : int
returns a glue.segments.segmentlist object containing only those
segments matching the given segment_def_id integer
"""
# load xmldocument and SegmentDefTable and SegmentTables
xmldoc, digest = utils.load_fileobj(file, gz=file.name.endswith(".gz"))
seg_def_table = table.get_table(xmldoc, lsctables.SegmentDefTable.tableName)
seg_table = table.get_table(xmldoc, lsctables.SegmentTable.tableName)
if dict:
segs = segments.segmentlistdict()
else:
segs = segments.segmentlist()
seg_id = {}
for seg_def in seg_def_table:
seg_id[int(seg_def.segment_def_id)] = str(seg_def.name)
if dict:
segs[str(seg_def.name)] = segments.segmentlist()
for seg in seg_table:
if dict:
segs[seg_id[int(seg.segment_def_id)]]\
.append(segments.segment(seg.start_time, seg.end_time))
continue
if id and int(seg.segment_def_id)==id:
segs.append(segments.segment(seg.start_time, seg.end_time))
continue
segs.append(segments.segment(seg.start_time, seg.end_time))
if dict:
for seg_name in seg_id.values():
segs[seg_name] = segs[seg_name].coalesce()
else:
segs = segs.coalesce()
xmldoc.unlink()
return segs
def get_thinca_rings_by_available_instruments(connection,
program_name="thinca"):
"""
Return the thinca rings from the database at the given connection. The
rings are returned as a glue.segments.segmentlistdict indexed by the
set of instruments that were analyzed in that ring.
Example:
>>> seglists = get_thinca_rings_by_available_instruments(connection)
>>> print seglists.keys()
[frozenset(['H1', 'L1'])]
"""
# extract raw rings indexed by available instrument set
xmldoc = dbtables.get_xml(connection)
seglists = segments.segmentlistdict()
for row in map(
dbtables.table.get_table(
xmldoc, lsctables.SearchSummaryTable.tableName).row_from_cols,
connection.cursor().execute(
"""
SELECT
search_summary.*
FROM
search_summary
JOIN process ON (
process.process_id == search_summary.process_id
)
WHERE
process.program == ?
""", (program_name, ))):
available_instruments = frozenset(row.get_ifos())
try:
seglists[available_instruments].append(row.get_out())
except KeyError:
seglists[available_instruments] = [row.get_out()]
xmldoc.unlink()
# remove rings that are exact duplicates on the assumption that there are
# zero-lag and time-slide thinca jobs represented in the same document
return segments.segmentlistdict(
(key, segments.segmentlist(sorted(set(value))))
for key, value in seglists.items())
def get_segments(connection,
xmldoc,
table_name,
live_time_program,
veto_segments_name=None,
data_segments_name="datasegments"):
segs = segments.segmentlistdict()
if table_name == dbtables.lsctables.CoincInspiralTable.tableName:
if live_time_program == "gstlal_inspiral":
segs = ligolw_segments.segmenttable_get_by_name(
xmldoc, data_segments_name).coalesce()
segs &= ligolw_search_summary.segmentlistdict_fromsearchsummary(
xmldoc, live_time_program).coalesce()
elif live_time_program == "thinca":
segs = db_thinca_rings.get_thinca_zero_lag_segments(
connection, program_name=live_time_program).coalesce()
else:
raise ValueError(
"for burst tables livetime program must be one of gstlal_inspiral, thinca"
)
if veto_segments_name is not None:
veto_segs = db_thinca_rings.get_veto_segments(
connection, veto_segments_name)
segs -= veto_segs
return segs
elif table_name == dbtables.lsctables.CoincRingdownTable.tableName:
segs = ligolw_search_summary.segmentlistdict_fromsearchsummary(
xmldoc, live_time_program).coalesce()
if veto_segments_name is not None:
veto_segs = ligolw_segments.segmenttable_get_by_name(
xmldoc, veto_segments_name).coalesce()
segs -= veto_segs
return segs
elif table_name == dbtables.lsctables.MultiBurstTable.tableName:
if live_time_program == "omega_to_coinc":
segs = ligolw_search_summary.segmentlistdict_fromsearchsummary(
xmldoc, live_time_program).coalesce()
if veto_segments_name is not None:
veto_segs = ligolw_segments.segmenttable_get_by_name(
xmldoc, veto_segments_name).coalesce()
segs -= veto_segs
elif live_time_program == "waveburst":
segs = db_thinca_rings.get_thinca_zero_lag_segments(
connection, program_name=live_time_program).coalesce()
if veto_segments_name is not None:
veto_segs = db_thinca_rings.get_veto_segments(
connection, veto_segments_name)
segs -= veto_segs
else:
raise ValueError(
"for burst tables livetime program must be one of omega_to_coinc, waveburst"
)
return segs
else:
raise ValueError("table must be in " +
" ".join(allowed_analysis_table_names()))
def __init__(self, x_instrument, y_instrument):
self.fig, self.axes = SnglBurstUtils.make_burst_plot(
"%s Offset (s)" % x_instrument, "%s Offset (s)" % y_instrument)
self.fig.set_size_inches(6, 6)
self.x_instrument = x_instrument
self.y_instrument = y_instrument
self.tisi_rows = None
self.seglists = segments.segmentlistdict()
self.counts = None
def cache_to_seglistdict(cache): """ Construct a coalesced segmentlistdict object from a list of glue.lal.CacheEntry objects. """ s = segments.segmentlistdict() for c in cache: s |= c.segmentlistdict return s
def cache_to_seglistdict(cache):
"""
Construct a coalesced segmentlistdict object from a list of
glue.lal.CacheEntry objects.
"""
s = segments.segmentlistdict()
for c in cache:
s |= c.segmentlistdict
return s
def to_segmentlistdict(self): """ Return a segmentlistdict object describing the instruments and times spanned by the entries in this Cache. The return value is coalesced. """ d = segments.segmentlistdict() for entry in self: d |= entry.segmentlistdict return d
def to_segmentlistdict(self):
"""
Return a segmentlistdict object describing the instruments
and times spanned by the entries in this Cache. The return
value is coalesced.
"""
d = segments.segmentlistdict()
for entry in self:
d |= entry.segmentlistdict
return d
def ligolw_bucut(xmldoc, options, burst_test_func, veto_segments = segments.segmentlistdict(), del_non_coincs = False, del_skipped_injections = False, program = None, verbose = False): contents = DocContents(xmldoc, program) process = append_process(xmldoc, options) apply_filters(contents, burst_test_func, veto_segments, del_non_coincs = del_non_coincs, del_skipped_injections = del_skipped_injections, verbose = verbose) ligolw_process.set_process_end_time(process) seg = contents.outsegs.extent_all() ligolw_search_summary.append_search_summary(xmldoc, process, inseg = seg, outseg = seg, nevents = len(contents.snglbursttable)) return xmldoc
def segmenttable_get_by_name(xmldoc, name):
"""
Retrieve the segmentlists whose name equals name. The result is a
segmentlistdict indexed by instrument.
The output of this function is not coalesced, each segmentlist
contains the segments as found in the segment table.
NOTE: this is a light-weight version of the .get_by_name() method
of the LigolwSegments class intended for use when the full
machinery of that class is not required. Considerably less
document validation and error checking is performed by this
version. Consider using that method instead if your application
will be interfacing with the document via that class anyway.
"""
#
# find required tables
#
def_table = lsctables.SegmentDefTable.get_table(xmldoc)
seg_table = lsctables.SegmentTable.get_table(xmldoc)
#
# segment_def_id --> instrument names mapping but only for
# segment_definer entries bearing the requested name
#
instrument_index = dict((row.segment_def_id, row.instruments)
for row in def_table if row.name == name)
#
# populate result segmentlistdict object from segment_def_map table
# and index
#
instruments = set(instrument for instruments in instrument_index.values()
for instrument in instruments)
result = segments.segmentlistdict(
(instrument, segments.segmentlist()) for instrument in instruments)
for row in seg_table:
if row.segment_def_id in instrument_index:
seg = row.segment
for instrument in instrument_index[row.segment_def_id]:
result[instrument].append(seg)
#
# done
#
return result
def get_thinca_rings_by_available_instruments(connection, program_name = "thinca"):
"""
Return the thinca rings from the database at the given connection. The
rings are returned as a glue.segments.segmentlistdict indexed by the
set of instruments that were analyzed in that ring.
Example:
>>> seglists = get_thinca_rings_by_available_instruments(connection)
>>> print seglists.keys()
[frozenset(['H1', 'L1'])]
"""
# extract raw rings indexed by available instrument set
xmldoc = dbtables.get_xml(connection)
seglists = segments.segmentlistdict()
for row in map(dbtables.table.get_table(xmldoc, lsctables.SearchSummaryTable.tableName).row_from_cols, connection.cursor().execute("""
SELECT
search_summary.*
FROM
search_summary
JOIN process ON (
process.process_id == search_summary.process_id
)
WHERE
process.program == ?
""", (program_name,))):
available_instruments = frozenset(row.get_ifos())
try:
seglists[available_instruments].append(row.get_out())
except KeyError:
seglists[available_instruments] = [row.get_out()]
xmldoc.unlink()
# remove rings that are exact duplicates on the assumption that there are
# zero-lag and time-slide thinca jobs represented in the same document
return segments.segmentlistdict((key, segments.segmentlist(sorted(set(value)))) for key, value in seglists.items())
def __init__(self, ifo):
# set a string to idenity IFO
self.ifo = ifo
# a dict that holds all excitation segments
self.exc_dict = segments.segmentlistdict()
# a dict that holds all segments from the segdb
self.seg_dict = segments.segmentlistdict()
# a dict that holds all segments from bitmasked channels
self.bitmask_dict = segments.segmentlistdict()
# GraceDB information about hardware injection
self.gracedb_id = []
self.gracedb_time = []
# schedule information about hardware injection
self.schedule_time = None
self.schedule_type = None
self.schedule_scale_factor = None
self.schedule_prefix = None
def __init__(self, ifo):
# set a string to idenity IFO
self.ifo = ifo
# a dict that holds all excitation segments
self.exc_dict = segments.segmentlistdict()
# a dict that holds all segments from the segdb
self.seg_dict = segments.segmentlistdict()
# a dict that holds all segments from bitmasked channels
self.bitmask_dict = segments.segmentlistdict()
# GraceDB information about hardware injection
self.gracedb_id = []
self.gracedb_time = []
# schedule information about hardware injection
self.schedule_time = None
self.schedule_type = None
self.schedule_scale_factor = None
self.schedule_prefix = None
def segmenttable_get_by_name(xmldoc, name): """ Retrieve the segmentlists whose name equals name. The result is a segmentlistdict indexed by instrument. The output of this function is not coalesced, each segmentlist contains the segments as found in the segment table. NOTE: this is a light-weight version of the .get_by_name() method of the LigolwSegments class intended for use when the full machinery of that class is not required. Considerably less document validation and error checking is performed by this version. Consider using that method instead if your application will be interfacing with the document via that class anyway. """ # # find required tables # def_table = lsctables.SegmentDefTable.get_table(xmldoc) seg_table = lsctables.SegmentTable.get_table(xmldoc) # # segment_def_id --> instrument names mapping but only for # segment_definer entries bearing the requested name # instrument_index = dict((row.segment_def_id, row.instruments) for row in def_table if row.name == name) # # populate result segmentlistdict object from segment_def_map table # and index # instruments = set(instrument for instruments in instrument_index.values() for instrument in instruments) result = segments.segmentlistdict((instrument, segments.segmentlist()) for instrument in instruments) for row in seg_table: if row.segment_def_id in instrument_index: seg = row.segment for instrument in instrument_index[row.segment_def_id]: result[instrument].append(seg) # # done # return result
def get_rinca_zero_lag_segments(connection, program_name="rinca"):
"""
Return the rinca rings from the database at the given connection. The
rings are returned as a coalesced glue.segments.segmentlistdict indexed
by instrument.
Example:
>>> seglists = get_rinca_zero_lag_segments(connection)
>>> print seglists.keys()
['H1', 'L1']
This function is most useful if only zero-lag segments are desired
because it allows for more convenient manipulation of the segment lists
using the methods in glue.segments. If information about background
segments or the original ring boundaries is desired the data returned by
get_rinca_rings_by_available_instruments() is required.
"""
# extract the raw rings indexed by instrument
xmldoc = dbtables.get_xml(connection)
seglists = ligolw_search_summary.segmentlistdict_fromsearchsummary(
xmldoc, program_name)
xmldoc.unlink()
# remove rings that are exact duplicates on the assumption that there are
# zero-lag and time-slide rinca jobs represented in the same document
seglists = segments.segmentlistdict((key, segments.segmentlist(set(value)))
for key, value in seglists.items())
# coalesce the remaining segments making sure we don't loose livetime in
# the process
durations_before = abs(seglists)
seglists.coalesce()
if abs(seglists) != durations_before:
raise ValueError, "detected overlapping rinca rings"
# done
return seglists
def segmenttable_get_by_name(xmldoc, name): """ Retrieve the segments whose name matches those given. The result is a segmentlistdict indexed by instrument. The output of this function is not coalesced, each segmentlist contains the segments as found in the segment table. """ # # find required tables # def_table = lsctables.SegmentDefTable.get_table(xmldoc) seg_table = lsctables.SegmentTable.get_table(xmldoc) # # segment_def_id --> instrument names mapping but only for # segment_definer entries bearing the requested name # instrument_index = dict((row.segment_def_id, row.get_ifos()) for row in def_table if row.name == name) # # populate result segmentlistdict object from segment_def_map table # and index # instruments = set(instrument for instruments in instrument_index.values() for instrument in instruments) result = segments.segmentlistdict((instrument, segments.segmentlist()) for instrument in instruments) for row in seg_table: if row.segment_def_id in instrument_index: seg = row.get() for instrument in instrument_index[row.segment_def_id]: result[instrument].append(seg) # # done # return result
def extract_vetoes(veto_files, ifos):
"""Extracts vetoes from veto filelist"""
# Initialize vetoe containers
vetoes = segments.segmentlistdict()
for ifo in ifos:
vetoes[ifo] = segments.segmentlist()
# Construct veto list from veto filelist
if veto_files:
for file in veto_files:
ifo = os.path.basename(file)[:2]
if ifo in ifos:
# This returns a coalesced list of the vetoes
tmp_veto_segs = dqSegmentUtils.fromsegmentxml(open(file, 'r'))
for entry in tmp_veto_segs:
vetoes[ifo].append(entry)
for ifo in ifos:
vetoes[ifo].coalesce()
return vetoes
def DQSegments(time, data, dq_key):
"""
Returns a glue.segments.segmentlistdict of active segments for each bit
in a dq_key.
"""
segdict = segments.segmentlistdict()
for key in dq_key:
segdict[key] = segments.segmentlist()
# convert DQ bits into segments
for i in xrange(len(data)):
binary = _bits(data[i], len(dq_key))
seg = segments.segment(time[i], time[i] - 1)
for j, key in enumerate(dq_key):
if binary[j] == 1:
segdict[key].append(seg)
segdict = segdict.coalesce()
return segdict
def get_thinca_zero_lag_segments(connection, program_name = "thinca"):
"""
Return the thinca rings from the database at the given connection. The
rings are returned as a coalesced glue.segments.segmentlistdict indexed
by instrument.
Example:
>>> seglists = get_thinca_zero_lag_segments(connection)
>>> print seglists.keys()
['H1', 'L1']
This function is most useful if only zero-lag segments are desired
because it allows for more convenient manipulation of the segment lists
using the methods in glue.segments. If information about background
segments or the original ring boundaries is desired the data returned by
get_thinca_rings_by_available_instruments() is required.
"""
# extract the raw rings indexed by instrument
xmldoc = dbtables.get_xml(connection)
seglists = ligolw_search_summary.segmentlistdict_fromsearchsummary(xmldoc, program_name)
xmldoc.unlink()
# remove rings that are exact duplicates on the assumption that there are
# zero-lag and time-slide thinca jobs represented in the same document
seglists = segments.segmentlistdict((key, segments.segmentlist(set(value))) for key, value in seglists.items())
# coalesce the remaining segments making sure we don't loose livetime in
# the process
durations_before = abs(seglists)
seglists.coalesce()
if abs(seglists) != durations_before:
raise ValueError, "detected overlapping thinca rings"
# done
return seglists
def GetSegListFromSearchSummaries(fileList, verbose=False):
"""
Read segment lists from search summary tables
@param fileList: list of input files.
"""
required_tables = [lsctables.SearchSummaryTable, lsctables.ProcessTable]
segList = segments.segmentlistdict()
for thisFile in fileList:
doc = ReadTablesFromFiles([thisFile], required_tables, verbose)
try:
segs = ligolw_search_summary.segmentlistdict_fromsearchsummary(doc)
except:
raise ValueError, "Cannot extract segments from the SearchSummaryTable of %s" % thisFile
#Now add these segments to the existing list
segList.extend(segs)
for value in segList.values():
value.sort()
return segList
def DQSegments(time, data, dq_key):
"""
Returns a glue.segments.segmentlistdict of active segments for each bit
in a dq_key.
"""
segdict = segments.segmentlistdict()
for key in dq_key:
segdict[key] = segments.segmentlist()
# convert DQ bits into segments
for i in xrange(len(data)):
binary = _bits(data[i], len(dq_key))
seg = segments.segment(time[i], time[i]-1)
for j, key in enumerate(dq_key):
if binary[j] == 1:
segdict[key].append(seg)
segdict = segdict.coalesce()
return segdict
def GetSegListFromSearchSummaries(fileList, verbose=False):
"""
Read segment lists from search summary tables
@param fileList: list of input files.
"""
required_tables = [lsctables.SearchSummaryTable, lsctables.ProcessTable]
segList = segments.segmentlistdict()
for thisFile in fileList:
doc = ReadTablesFromFiles([thisFile], required_tables, verbose)
try:
segs = ligolw_search_summary.segmentlistdict_fromsearchsummary(doc)
except:
raise ValueError, "Cannot extract segments from the SearchSummaryTable of %s" % thisFile
#Now add these segments to the existing list
segList.extend(segs)
for value in segList.values():
value.sort()
return segList
def get_segments(connection, xmldoc, table_name, live_time_program, veto_segments_name = None, data_segments_name = "datasegments"):
from pylal import db_thinca_rings
segs = segments.segmentlistdict()
if table_name == dbtables.lsctables.CoincInspiralTable.tableName:
if live_time_program == "gstlal_inspiral":
segs = ligolw_segments.segmenttable_get_by_name(xmldoc, data_segments_name).coalesce()
segs &= ligolw_search_summary.segmentlistdict_fromsearchsummary(xmldoc, live_time_program).coalesce()
elif live_time_program == "thinca":
segs = db_thinca_rings.get_thinca_zero_lag_segments(connection, program_name = live_time_program).coalesce()
else:
raise ValueError("for burst tables livetime program must be one of gstlal_inspiral, thinca")
if veto_segments_name is not None:
veto_segs = db_thinca_rings.get_veto_segments(connection, veto_segments_name)
segs -= veto_segs
return segs
elif table_name == dbtables.lsctables.CoincRingdownTable.tableName:
segs = ligolw_search_summary.segmentlistdict_fromsearchsummary(xmldoc, live_time_program).coalesce()
if veto_segments_name is not None:
veto_segs = ligolw_segments.segmenttable_get_by_name(xmldoc, veto_segments_name).coalesce()
segs -= veto_segs
return segs
elif table_name == dbtables.lsctables.MultiBurstTable.tableName:
if live_time_program == "omega_to_coinc":
segs = ligolw_search_summary.segmentlistdict_fromsearchsummary(xmldoc, live_time_program).coalesce()
if veto_segments_name is not None:
veto_segs = ligolw_segments.segmenttable_get_by_name(xmldoc, veto_segments_name).coalesce()
segs -= veto_segs
elif live_time_program == "waveburst":
segs = db_thinca_rings.get_thinca_zero_lag_segments(connection, program_name = live_time_program).coalesce()
if veto_segments_name is not None:
veto_segs = db_thinca_rings.get_veto_segments(connection, veto_segments_name)
segs -= veto_segs
else:
raise ValueError("for burst tables livetime program must be one of omega_to_coinc, waveburst")
return segs
else:
raise ValueError("table must be in " + " ".join(allowed_analysis_table_names()))
def write_round_xml(vetosegs, vetotrigs, winner, ifo, opts):
"""
Write out the products from this round of hveto: veto segments and the vetoed triggers.
"""
# Create a new document
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
# Append the process information
procrow = utils.process.append_process(xmldoc, program="laldetchar-hveto")
utils.process.append_process_params(xmldoc, procrow, utils.process.process_params_from_dict(opts))
# Add the vetoed triggers
xmldoc.childNodes[0].childNodes.append(vetotrigs)
# Append the veto segments
segl = segmentlistdict()
segl[ifo] = vetosegs
lwsegs = ligolw_segments.LigolwSegments(xmldoc)
lwsegs.insert_from_segmentlistdict(segl, "hveto")
lwsegs.finalize(procrow)
return xmldoc
def write_round_xml(vetosegs, vetotrigs, winner, ifo, opts):
"""
Write out the products from this round of hveto: veto segments and the vetoed triggers.
"""
# Create a new document
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
# Append the process information
procrow = utils.process.append_process(xmldoc, program="laldetchar-hveto")
utils.process.append_process_params(
xmldoc, procrow, utils.process.process_params_from_dict(opts))
# Add the vetoed triggers
xmldoc.childNodes[0].childNodes.append(vetotrigs)
# Append the veto segments
segl = segmentlistdict()
segl[ifo] = vetosegs
lwsegs = ligolw_segments.LigolwSegments(xmldoc)
lwsegs.insert_from_segmentlistdict(segl, "hveto")
lwsegs.finalize(procrow)
return xmldoc
def tosegmentlistdict(timeseries, bitmask):
"""
Returns a glue.segments.segmentlistdict of active segments for each bit
in a bit-masked state vector TimeSeries.
"""
bits, flags = zip(*sorted(bitmask.items(), key=lambda (k, v): k))
segdict = segments.segmentlistdict()
for flag in flags:
segdict[flag] = segments.segmentlist()
# convert DQ bits into segments
tarray = arange(timeseries.data.length) * float(timeseries.deltaT) +\
float(timeseries.epoch)
for t, d in zip(tarray.astype(float), timeseries.data.data):
binary = _bits(d, bits[-1] + 1)
seg = segments.segment(t, t - timeseries.deltaT)
for bit, flag in zip(bits, flags):
if binary[bit] == 1:
segdict[flag].append(seg)
segdict.coalesce()
return segdict
def multi_ifo_compute_offsource_segment(analyzable_dict, on_source, **kwargs):
"""
Return the off-source segment determined for multiple IFO times along with
the IFO combo that determined that segment. Calls
compute_offsource_segment as necessary, passing all kwargs as necessary.
"""
# sieve down to relevant segments and IFOs; sort IFOs by sensitivity
new_analyzable_dict = segments.segmentlistdict()
for ifo, seglist in analyzable_dict.iteritems():
try:
ind = seglist.find(on_source)
except ValueError:
continue
new_analyzable_dict[ifo] = segments.segmentlist([seglist[ind]])
analyzable_ifos = new_analyzable_dict.keys()
analyzable_ifos.sort(sensitivity_cmp)
# now try getting off-source segments; start trying with all IFOs, then
# work our way to smaller and smaller subsets; exclude single IFOs.
test_combos = itertools.chain( \
*itertools.imap(lambda n: iterutils.choices(analyzable_ifos, n),
xrange(len(analyzable_ifos), 1, -1)))
off_source_segment = None
the_ifo_combo = []
for ifo_combo in test_combos:
trial_seglist = new_analyzable_dict.intersection(ifo_combo)
temp_segment = compute_offsource_segment(trial_seglist, on_source,
**kwargs)
if temp_segment is not None:
off_source_segment = temp_segment
the_ifo_combo = list(ifo_combo)
the_ifo_combo.sort()
break
return off_source_segment, the_ifo_combo
def multi_ifo_compute_offsource_segment(analyzable_dict, on_source, **kwargs):
"""
Return the off-source segment determined for multiple IFO times along with
the IFO combo that determined that segment. Calls
compute_offsource_segment as necessary, passing all kwargs as necessary.
"""
# sieve down to relevant segments and IFOs; sort IFOs by sensitivity
new_analyzable_dict = segments.segmentlistdict()
for ifo, seglist in analyzable_dict.iteritems():
try:
ind = seglist.find(on_source)
except ValueError:
continue
new_analyzable_dict[ifo] = segments.segmentlist([seglist[ind]])
analyzable_ifos = new_analyzable_dict.keys()
analyzable_ifos.sort(sensitivity_cmp)
# now try getting off-source segments; start trying with all IFOs, then
# work our way to smaller and smaller subsets; exclude single IFOs.
test_combos = itertools.chain( \
*itertools.imap(lambda n: iterutils.choices(analyzable_ifos, n),
xrange(len(analyzable_ifos), 1, -1)))
off_source_segment = None
the_ifo_combo = []
for ifo_combo in test_combos:
trial_seglist = new_analyzable_dict.intersection(ifo_combo)
temp_segment = compute_offsource_segment(trial_seglist, on_source,
**kwargs)
if temp_segment is not None:
off_source_segment = temp_segment
the_ifo_combo = list(ifo_combo)
the_ifo_combo.sort()
break
return off_source_segment, the_ifo_combo
power.init_job_types(config_parser)
#
# Using time slide information, construct segment lists describing times
# requiring trigger construction.
#
if options.verbose:
print >>sys.stderr, "Computing segments for which lalapps_power jobs are required ..."
background_time_slides = {}
background_seglistdict = segments.segmentlistdict()
if options.do_noninjections:
for filename in options.background_time_slides:
cache_entry = CacheEntry(None, None, None, "file://localhost" + os.path.abspath(filename))
background_time_slides[cache_entry] = timeslides.load_time_slides(filename, verbose = options.verbose, gz = filename.endswith(".gz")).values()
background_seglistdict |= compute_segment_lists(seglistdict, background_time_slides[cache_entry], options.minimum_gap, options.timing_params, full_segments = options.full_segments, verbose = options.verbose)
injection_time_slides = {}
injection_seglistdict = segments.segmentlistdict()
if options.do_injections:
for filename in options.injection_time_slides:
cache_entry = CacheEntry(None, None, None, "file://localhost" + os.path.abspath(filename))
injection_time_slides[cache_entry] = timeslides.load_time_slides(filename, verbose = options.verbose, gz = filename.endswith(".gz")).values()
injection_seglistdict |= compute_segment_lists(seglistdict, injection_time_slides[cache_entry], options.minimum_gap, options.timing_params, full_segments = options.full_segments, verbose = options.verbose)
#
# Define .sub files
#
power.init_job_types(config_parser)
#
# Using time slide information, construct segment lists describing times
# requiring trigger construction.
#
if options.verbose:
print >> sys.stderr, "Computing segments for which lalapps_power jobs are required ..."
background_time_slides = {}
background_seglistdict = segments.segmentlistdict()
if options.do_noninjections:
for filename in options.background_time_slides:
cache_entry = CacheEntry(
None, None, None, "file://localhost" + os.path.abspath(filename))
background_time_slides[cache_entry] = timeslides.load_time_slides(
filename, verbose=options.verbose,
gz=filename.endswith(".gz")).values()
background_seglistdict |= compute_segment_lists(
seglistdict,
background_time_slides[cache_entry],
options.minimum_gap,
options.timing_params,
full_segments=options.full_segments,
verbose=options.verbose)
def parse_command_line():
parser = OptionParser(version="%prog CVS $Id$")
parser.add_option("-s",
"--data-start",
metavar="GPSSECONDS",
help="set data segment start time")
parser.add_option("-e",
"--data-end",
metavar="GPSSECONDS",
help="set data segment end time")
parser.add_option("-a",
"--trig-start",
metavar="GPSSECONDS",
help="set analysis segment start time")
parser.add_option("-b",
"--trig-end",
metavar="GPSSECONDS",
help="set analysis segment end time")
parser.add_option("-f",
"--dag-name",
metavar="FILENAME",
help="set output .dag file name")
parser.add_option("-t",
"--aux-dir",
metavar="PATH",
help="set auxiliary data directory")
parser.add_option("--condor-log-dir",
metavar="PATH",
help="set directory for Condor log")
parser.add_option("--config-file",
metavar="FILENAME",
default="online_power.ini",
help="set .ini config file name")
parser.add_option(
"--instrument",
metavar="INSTRUMENT",
help=
"set instrument name (default = value of instrument variable in [pipeline] section of .ini file)"
)
parser.add_option("--publish-dest",
metavar="PATH",
help="set directory for output triggers")
parser.add_option("--dmtmon-dest",
metavar="PATH",
help="set directory for DMT monitor output")
parser.add_option("--gsiscp-dest",
metavar="PATH",
help="set destination for gsiscp")
parser.add_option("--user-tag",
metavar="TAG",
help="set user tag on jobs that need it")
options, extra_args = parser.parse_args()
# data segment
options.data_seg = segments.segment(lal.LIGOTimeGPS(options.data_start),
lal.LIGOTimeGPS(options.data_end))
try:
options.data_seglists = segments.segmentlistdict(
{options.instrument: segments.segmentlist([options.data_seg])})
except:
raise ValueError, "failure parsing -s and/or -e; try --help"
# trigger segment
options.trig_seg = segments.segment(lal.LIGOTimeGPS(options.trig_start),
lal.LIGOTimeGPS(options.trig_end))
try:
options.trig_seglists = segments.segmentlistdict(
{options.instrument: segments.segmentlist([options.trig_seg])})
except:
raise ValueError, "failure parsing -a and/or -b; try --help"
if True in map(bool, (options.trig_seglists -
options.data_seglists).itervalues()):
raise ValueError, "trigger segment not contained in data segment!"
# .dag name
try:
options.dag_name = os.path.splitext(options.dag_name)[0]
except:
raise ValueError, "failure parsing -f; try --help"
# config file
options.config_file = os.path.join(options.aux_dir, options.config_file)
return options
def __init__(self, opts, flist):
self.segments = segments.segmentlistdict()
self.non_inj_fnames = []
self.inj_fnames = []
self.found = {}
self.missed = {}
self.opts = opts
self.veto_segments = segments.segmentlistdict()
self.zero_lag_segments = {}
self.instruments = []
self.livetime = {}
self.multi_burst_table = None
self.coinc_inspiral_table = None
for f in flist:
if opts.verbose:
print("Gathering stats from: %s...." % (f, ), file=sys.stderr)
working_filename = dbtables.get_connection_filename(
f, tmp_path=opts.tmp_space, verbose=opts.verbose)
connection = sqlite3.connect(working_filename)
dbtables.DBTable_set_connection(connection)
xmldoc = dbtables.get_xml(connection)
# look for a sim table
try:
sim_inspiral_table = dbtables.lsctables.SimInspiralTable.get_table(
xmldoc)
self.inj_fnames.append(f)
sim = True
except ValueError:
self.non_inj_fnames.append(f)
sim = False
# FIGURE OUT IF IT IS A BURST OR INSPIRAL RUN
try:
self.multi_burst_table = dbtables.lsctables.MultiBurstTable.get_table(
xmldoc)
except ValueError:
self.multi_burst_table = None
try:
self.coinc_inspiral_table = dbtables.lsctables.CoincInspiralTable.get_table(
xmldoc)
except ValueError:
self.coinc_inspiral_table = None
if self.multi_burst_table and self.coinc_inspiral_table:
print("both burst and inspiral tables found. Aborting",
file=sys.stderr)
raise ValueError
if not sim:
self.get_instruments(connection)
self.segments += self.get_segments(connection, xmldoc)
#FIXME, don't assume veto segments are the same in every file!
self.veto_segments = self.get_veto_segments(connection)
dbtables.discard_connection_filename(f,
working_filename,
verbose=opts.verbose)
dbtables.DBTable_set_connection(None)
# remove redundant instruments
self.instruments = list(set(self.instruments))
# FIXME Do these have to be done by instruments?
self.segments -= self.veto_segments
# segments and livetime by instruments
for i in self.instruments:
self.zero_lag_segments[i] = self.segments.intersection(
i) - self.segments.union(set(self.segments.keys()) - i)
self.livetime[i] = float(abs(self.zero_lag_segments[i]))
JOIN coinc_event AS insp_coinc_event ON (insp_coinc_event.coinc_event_id == coinc_inspiral.coinc_event_id)
JOIN coinc_definer AS insp_coinc_definer ON (insp_coinc_definer.coinc_def_id == insp_coinc_event.coinc_def_id)
JOIN coinc_definer AS sim_coinc_definer ON (sim_coinc_definer.coinc_def_id == sim_coinc_event.coinc_def_id)
WHERE
insp_coinc_definer.search == 'inspiral'
AND sim_coinc_definer.search == 'inspiral'
AND insp_coinc_definer.search_coinc_type == 0
AND sim_coinc_definer.search_coinc_type == 2
AND mapC.table_name == 'coinc_event'
AND mapD.table_name == 'sim_inspiral'
"""):
injection_likelihood.append(likelihood)
injection_snr.append(snr)
#livetimes = db_thinca_rings.get_thinca_livetimes(db_thinca_rings.get_thinca_rings_by_available_instruments(connection,'thinca'), db_thinca_rings.get_veto_segments(connection, 'vetoes'), db_thinca_rings.get_background_offset_vectors(connection), verbose=True)
# above is the correct calculation of livetimes, but it takes a while. You can comment it out and uncomment the line below for an approximate calculation of livetime.
livetimes = db_thinca_rings.get_thinca_livetimes(db_thinca_rings.get_thinca_rings_by_available_instruments(connection,'thinca'), segments.segmentlistdict(), db_thinca_rings.get_background_offset_vectors(connection), verbose=True)
dbtables.put_connection_filename(filename, working_filename, verbose = True)
print "number of timeslides:", len(timeslide_likelihood)
print "number of zerolags:", len(zerolag_likelihood)
print "number of injections:", len(injection_likelihood)
all_likelihoods = numpy.array(timeslide_likelihood + zerolag_likelihood + injection_likelihood, dtype=float)
timeslide_likelihoods = numpy.array(timeslide_likelihood)
zerolag_likelihoods = numpy.array(zerolag_likelihood)
injection_likelihoods = numpy.array(injection_likelihood)
timeslide_snrs = numpy.array(timeslide_snr)
zerolag_snrs = numpy.array(zerolag_snr)
injection_snrs = numpy.array(injection_snr)
# set all zero likelihoods to the next lowest calculated likelihood, and all infinity likelihoods to the next highest, so plotting can work
plottable_likelihoods = all_likelihoods[~numpy.isinf(all_likelihoods) & (all_likelihoods > 0)]
min_likelihood = plottable_likelihoods.min()
