def add_to_segment_ns(xmldoc, proc_id, seg_def_id, sgmtlist):
try:
segtable = table.get_table(xmldoc, lsctables.SegmentTable.tableName)
except:
segtable = lsctables.New(lsctables.SegmentTable,
columns=[
"process_id", "segment_def_id",
"segment_id", "start_time",
"start_time_ns", "end_time", "end_time_ns"
])
xmldoc.childNodes[0].appendChild(segtable)
for seg in sgmtlist:
segment = lsctables.Segment()
segment.process_id = proc_id
segment.segment_def_id = seg_def_id
segment.segment_id = segtable.get_next_id()
seconds, nanoseconds = output_microseconds(seg[0])
segment.start_time = seconds
segment.start_time_ns = nanoseconds
seconds, nanoseconds = output_microseconds(seg[1])
segment.end_time = seconds
segment.end_time_ns = nanoseconds
segtable.append(segment)
def add_to_segment(xmldoc, proc_id, seg_def_id, sgmtlist):
try:
segtable = lsctables.SegmentTable.get_table(xmldoc)
except:
segtable = lsctables.New(lsctables.SegmentTable, columns = ["process_id", "segment_def_id", "segment_id", "start_time", "start_time_ns", "end_time", "end_time_ns"])
xmldoc.childNodes[0].appendChild(segtable)
for seg in sgmtlist:
segment = lsctables.Segment()
segment.process_id = proc_id
segment.segment_def_id = seg_def_id
segment.segment_id = segtable.get_next_id()
segment.start_time = seg[0]
segment.start_time_ns = 0
segment.end_time = seg[1]
segment.end_time_ns = 0
segtable.append(segment)
def ReadMultiInspiralTimeSlidesFromFiles(fileList,
generate_output_tables=False):
"""
Read time-slid multiInspiral tables from a list of files
@param fileList: list of input files
"""
if not fileList:
return multiInspiralTable(), None
multis = None
timeSlides = []
segmentDict = {}
for thisFile in fileList:
doc = utils.load_filename(thisFile,
gz=(thisFile or "stdin").endswith(".gz"),
contenthandler=lsctables.use_in(
ligolw.LIGOLWContentHandler))
# Extract the time slide table
timeSlideTable = table.get_table(doc,
lsctables.TimeSlideTable.tableName)
slideMapping = {}
currSlides = {}
# NOTE: I think some of this is duplicated in the glue definition of the
# time slide table. Probably should move over to that
for slide in timeSlideTable:
currID = int(slide.time_slide_id)
if currID not in currSlides.keys():
currSlides[currID] = {}
currSlides[currID][slide.instrument] = slide.offset
elif slide.instrument not in currSlides[currID].keys():
currSlides[currID][slide.instrument] = slide.offset
for slideID, offsetDict in currSlides.items():
try:
# Is the slide already in the list and where?
offsetIndex = timeSlides.index(offsetDict)
slideMapping[slideID] = offsetIndex
except ValueError:
# If not then add it
timeSlides.append(offsetDict)
slideMapping[slideID] = len(timeSlides) - 1
# Get the mapping table
segmentMap = {}
timeSlideMapTable = table.get_table(
doc, lsctables.TimeSlideSegmentMapTable.tableName)
for entry in timeSlideMapTable:
segmentMap[int(entry.segment_def_id)] = int(entry.time_slide_id)
# Extract the segment table
segmentTable = table.get_table(doc, lsctables.SegmentTable.tableName)
for entry in segmentTable:
currSlidId = segmentMap[int(entry.segment_def_id)]
currSeg = entry.get()
if not segmentDict.has_key(slideMapping[currSlidId]):
segmentDict[slideMapping[currSlidId]] = segments.segmentlist()
segmentDict[slideMapping[currSlidId]].append(currSeg)
segmentDict[slideMapping[currSlidId]].coalesce()
# extract the multi inspiral table
try:
multiInspiralTable = table.get_table(
doc, lsctables.MultiInspiralTable.tableName)
# Remap the time slide IDs
for multi in multiInspiralTable:
newID = slideMapping[int(multi.time_slide_id)]
multi.time_slide_id = ilwd.ilwdchar(\
"time_slide:time_slide_id:%d" % (newID))
if multis: multis.extend(multiInspiralTable)
else: multis = multiInspiralTable
# except: multiInspiralTable = None
except:
raise
if not generate_output_tables:
return multis, timeSlides, segmentDict
else:
# Make a new time slide table
timeSlideTab = lsctables.New(lsctables.TimeSlideTable)
for slideID, offsetDict in enumerate(timeSlides):
for instrument in offsetDict.keys():
currTimeSlide = lsctables.TimeSlide()
currTimeSlide.instrument = instrument
currTimeSlide.offset = offsetDict[instrument]
currTimeSlide.time_slide_id = ilwd.ilwdchar(\
"time_slide:time_slide_id:%d" % (slideID))
currTimeSlide.process_id = ilwd.ilwdchar(\
"process:process_id:%d" % (0))
timeSlideTab.append(currTimeSlide)
# Make a new mapping table
timeSlideSegMapTab = lsctables.New(lsctables.TimeSlideSegmentMapTable)
for i in range(len(timeSlides)):
currMapEntry = lsctables.TimeSlideSegmentMap()
currMapEntry.time_slide_id = ilwd.ilwdchar(\
"time_slide:time_slide_id:%d" % (i))
currMapEntry.segment_def_id = ilwd.ilwdchar(\
"segment_def:segment_def_id:%d" % (i))
timeSlideSegMapTab.append(currMapEntry)
# Make a new segment table
newSegmentTable = lsctables.New(lsctables.SegmentTable)
segmentIDCount = 0
for i in range(len(timeSlides)):
currSegList = segmentDict[i]
for seg in currSegList:
currSegment = lsctables.Segment()
currSegment.segment_id = ilwd.ilwdchar(\
"segment:segment_id:%d" %(segmentIDCount))
segmentIDCount += 1
currSegment.segment_def_id = ilwd.ilwdchar(\
"segment_def:segment_def_id:%d" % (i))
currSegment.process_id = ilwd.ilwdchar(\
"process:process_id:%d" % (0))
currSegment.set(seg)
currSegment.creator_db = -1
currSegment.segment_def_cdb = -1
newSegmentTable.append(currSegment)
return multis,timeSlides,segmentDict,timeSlideTab,newSegmentTable,\
timeSlideSegMapTab
def write_to_xmldoc(flags, xmldoc, process_id=None):
"""Write this `DataQualityFlag` to the given LIGO_LW Document
"""
if isinstance(flags, DataQualityFlag):
flags = {flags.name: flags}
# write SegmentDefTable
try:
segdeftab = lsctables.SegmentDefTable.get_table(xmldoc)
except ValueError:
segdeftab = lsctables.New(lsctables.SegmentDefTable,
columns=[
'ifos', 'name', 'version', 'comment',
'insertion_time', 'segment_def_id',
'process_id'
])
xmldoc.childNodes[-1].appendChild(segdeftab)
# make SegmentSumTable
try:
segsumtab = lsctables.SegmentSumTable.get_table(xmldoc)
except ValueError:
segsumtab = lsctables.New(lsctables.SegmentSumTable,
columns=[
'segment_def_id', 'start_time',
'start_time_ns', 'end_time',
'end_time_ns', 'comment',
'segment_sum_id', 'process_id'
])
xmldoc.childNodes[-1].appendChild(segsumtab)
# write SegmentTable
try:
segtab = lsctables.SegmentTable.get_table(xmldoc)
except ValueError:
segtab = lsctables.New(lsctables.SegmentTable,
columns=[
'process_id', 'segment_id',
'segment_def_id', 'start_time',
'start_time_ns', 'end_time', 'end_time_ns'
])
xmldoc.childNodes[-1].appendChild(segtab)
# write flags to tables
for flag in flags.itervalues():
# segment definer
segdef = lsctables.SegmentDef()
segdef.set_ifos([flag.ifo])
segdef.name = flag.tag
segdef.version = flag.version
segdef.comment = flag.description
segdef.insertion_time = int(
Time(datetime.datetime.now(), scale='utc').gps)
segdef.segment_def_id = lsctables.SegmentDefTable.get_next_id()
segdef.process_id = process_id
segdeftab.append(segdef)
# write segment summary (known segments)
for vseg in flag.known:
segsum = lsctables.SegmentSum()
segsum.segment_def_id = segdef.segment_def_id
segsum.set(map(LIGOTimeGPS, map(float, vseg)))
segsum.comment = None
segsum.segment_sum_id = lsctables.SegmentSumTable.get_next_id()
segsum.process_id = process_id
segsumtab.append(segsum)
# write segment table (active segments)
for aseg in flag.active:
seg = lsctables.Segment()
seg.segment_def_id = segdef.segment_def_id
seg.set(map(LIGOTimeGPS, map(float, aseg)))
seg.segment_id = lsctables.SegmentTable.get_next_id()
seg.process_id = process_id
segtab.append(seg)
return xmldoc
good_segs.append([s, e])
if opts.t_lag != 0: ### transform all segments from [start, end] -> [start+t_lag, end+t_lag]
logger.info(
' shifting all segments: [s, e]->[s+%.6f, e+%.6f]' %
(opts.t_lag, opts.t_lag))
segs = np.array(segs) + opts.t_lag
### take intersection of segs and scisegs
logger.info('taking intersection of vetosegs and scisegs')
segs = event.andsegments([scisegs, segs])
logger.info(' writing segments to SegmentTable')
### add segments to table
for s, e in segs:
seg_row = lsctables.Segment()
seg_row.segment_id = segtab.get_next_id()
seg_row.process_id = proc_id
seg_row.segment_def_id = segdef_id
seg_row.start_time = int(s)
seg_row.start_time_ns = (s - seg_row.start_time) * 1e9
seg_row.end_time = int(e)
seg_row.end_time_ns = (e - seg_row.end_time) * 1e9
segtab.append(seg_row)
logger.info('Done: generating segments for %s' % classifier)
### write to disk
