def find_segments(doc, key, use_segment_table = True):
key_pieces = key.split(':')
while len(key_pieces) < 3:
key_pieces.append('*')
filter_func = lambda x: str(x.ifos) == key_pieces[0] and (str(x.name) == key_pieces[1] or key_pieces[1] == '*') and (str(x.version) == key_pieces[2] or key_pieces[2] == '*')
# Find all segment definers matching the critieria
seg_def_table = table.get_table(doc, lsctables.SegmentDefTable.tableName)
seg_defs = filter(filter_func, seg_def_table)
seg_def_ids = map(lambda x: str(x.segment_def_id), seg_defs)
# Find all segments belonging to those definers
if use_segment_table:
seg_table = table.get_table(doc, lsctables.SegmentTable.tableName)
seg_entries = filter(lambda x: str(x.segment_def_id) in seg_def_ids, seg_table)
else:
seg_sum_table = table.get_table(doc, lsctables.SegmentSumTable.tableName)
seg_entries = filter(lambda x: str(x.segment_def_id) in seg_def_ids, seg_sum_table)
# Combine into a segmentlist
ret = segmentlist(map(lambda x: segment(x.start_time, x.end_time), seg_entries))
ret.coalesce()
return ret
def get_segment_summary_times(scienceFile, segmentName):
"""
This function will find the times for which the segment_summary is set
for the flag given by segmentName.
Parameters
-----------
scienceFile : SegFile
The segment file that we want to use to determine this.
segmentName : string
The DQ flag to search for times in the segment_summary table.
Returns
---------
summSegList : glue.segments.segmentlist
The times that are covered in the segment summary table.
"""
# Parse the segmentName
segmentName = segmentName.split(':')
if not len(segmentName) in [2, 3]:
raise ValueError("Invalid channel name %s." % (segmentName))
ifo = segmentName[0]
channel = segmentName[1]
version = ''
if len(segmentName) == 3:
version = int(segmentName[2])
# Load the filename
xmldoc = utils.load_filename(
scienceFile.cache_entry.path,
gz=scienceFile.cache_entry.path.endswith("gz"),
contenthandler=ContentHandler)
# Get the segment_def_id for the segmentName
segmentDefTable = table.get_table(xmldoc, "segment_definer")
for entry in segmentDefTable:
if (entry.ifos == ifo) and (entry.name == channel):
if len(segmentName) == 2 or (entry.version == version):
segDefID = entry.segment_def_id
break
else:
raise ValueError("Cannot find channel %s in segment_definer table."\
%(segmentName))
# Get the segmentlist corresponding to this segmentName in segment_summary
segmentSummTable = table.get_table(xmldoc, "segment_summary")
summSegList = segments.segmentlist([])
for entry in segmentSummTable:
if entry.segment_def_id == segDefID:
segment = segments.segment(entry.start_time, entry.end_time)
summSegList.append(segment)
summSegList.coalesce()
return summSegList
def get_segment_summary_times(scienceFile, segmentName):
"""
This function will find the times for which the segment_summary is set
for the flag given by segmentName.
Parameters
-----------
scienceFile : SegFile
The segment file that we want to use to determine this.
segmentName : string
The DQ flag to search for times in the segment_summary table.
Returns
---------
summSegList : glue.segments.segmentlist
The times that are covered in the segment summary table.
"""
# Parse the segmentName
segmentName = segmentName.split(':')
if not len(segmentName) in [2,3]:
raise ValueError("Invalid channel name %s." %(segmentName))
ifo = segmentName[0]
channel = segmentName[1]
version = ''
if len(segmentName) == 3:
version = int(segmentName[2])
# Load the filename
xmldoc = utils.load_filename(scienceFile.cache_entry.path,
gz=scienceFile.cache_entry.path.endswith("gz"),
contenthandler=ContentHandler)
# Get the segment_def_id for the segmentName
segmentDefTable = table.get_table(xmldoc, "segment_definer")
for entry in segmentDefTable:
if (entry.ifos == ifo) and (entry.name == channel):
if len(segmentName) == 2 or (entry.version==version):
segDefID = entry.segment_def_id
break
else:
raise ValueError("Cannot find channel %s in segment_definer table."\
%(segmentName))
# Get the segmentlist corresponding to this segmentName in segment_summary
segmentSummTable = table.get_table(xmldoc, "segment_summary")
summSegList = segments.segmentlist([])
for entry in segmentSummTable:
if entry.segment_def_id == segDefID:
segment = segments.segment(entry.start_time, entry.end_time)
summSegList.append(segment)
summSegList.coalesce()
return summSegList
def get_segment_definer_comments(xml_file, include_version=True):
"""Returns a dict with the comment column as the value for each segment"""
from pycbc_glue.ligolw.ligolw import LIGOLWContentHandler as h
lsctables.use_in(h)
# read segment definer table
xmldoc, digest = ligolw_utils.load_fileobj(xml_file,
gz=xml_file.name.endswith(".gz"),
contenthandler=h)
seg_def_table = table.get_table(xmldoc,
lsctables.SegmentDefTable.tableName)
# put comment column into a dict
comment_dict = {}
for seg_def in seg_def_table:
if include_version:
full_channel_name = ':'.join([str(seg_def.ifos),
str(seg_def.name),
str(seg_def.version)])
else:
full_channel_name = ':'.join([str(seg_def.ifos),
str(seg_def.name)])
comment_dict[full_channel_name] = seg_def.comment
return comment_dict
def get_segment_definer_comments(xml_file, include_version=True):
"""Returns a dict with the comment column as the value for each segment"""
from pycbc_glue.ligolw.ligolw import LIGOLWContentHandler as h
lsctables.use_in(h)
# read segment definer table
xmldoc, _ = ligolw_utils.load_fileobj(xml_file,
gz=xml_file.name.endswith(".gz"),
contenthandler=h)
seg_def_table = table.get_table(xmldoc,
lsctables.SegmentDefTable.tableName)
# put comment column into a dict
comment_dict = {}
for seg_def in seg_def_table:
if include_version:
full_channel_name = ':'.join([str(seg_def.ifos),
str(seg_def.name),
str(seg_def.version)])
else:
full_channel_name = ':'.join([str(seg_def.ifos),
str(seg_def.name)])
comment_dict[full_channel_name] = seg_def.comment
return comment_dict
def select_segments_by_definer(segment_file, segment_name=None, ifo=None):
""" Return the list of segments that match the segment name
Parameters
----------
segment_file: str
path to segment xml file
segment_name: str
Name of segment
ifo: str, optional
Returns
-------
seg: list of segments
"""
from pycbc_glue.ligolw.ligolw import LIGOLWContentHandler as h
lsctables.use_in(h)
indoc = ligolw_utils.load_filename(segment_file, False, contenthandler=h)
segment_table = table.get_table(indoc, 'segment')
seg_def_table = table.get_table(indoc, 'segment_definer')
def_ifos = seg_def_table.getColumnByName('ifos')
def_names = seg_def_table.getColumnByName('name')
def_ids = seg_def_table.getColumnByName('segment_def_id')
valid_id = []
for def_ifo, def_name, def_id in zip(def_ifos, def_names, def_ids):
if ifo and ifo != def_ifo:
continue
if segment_name and segment_name != def_name:
continue
valid_id += [def_id]
start = numpy.array(segment_table.getColumnByName('start_time'))
start_ns = numpy.array(segment_table.getColumnByName('start_time_ns'))
end = numpy.array(segment_table.getColumnByName('end_time'))
end_ns = numpy.array(segment_table.getColumnByName('end_time_ns'))
start, end = start + 1e-9 * start_ns, end + 1e-9 * end_ns
did = segment_table.getColumnByName('segment_def_id')
keep = numpy.array([d in valid_id for d in did])
if sum(keep) > 0:
return start_end_to_segments(start[keep], end[keep])
else:
return segmentlist([])
def select_segments_by_definer(segment_file, segment_name=None, ifo=None):
""" Return the list of segments that match the segment name
Parameters
----------
segment_file: str
path to segment xml file
segment_name: str
Name of segment
ifo: str, optional
Returns
-------
seg: list of segments
"""
from pycbc_glue.ligolw.ligolw import LIGOLWContentHandler as h; lsctables.use_in(h)
indoc = ligolw_utils.load_filename(segment_file, False, contenthandler=h)
segment_table = table.get_table(indoc, 'segment')
seg_def_table = table.get_table(indoc, 'segment_definer')
def_ifos = seg_def_table.getColumnByName('ifos')
def_names = seg_def_table.getColumnByName('name')
def_ids = seg_def_table.getColumnByName('segment_def_id')
valid_id = []
for def_ifo, def_name, def_id in zip(def_ifos, def_names, def_ids):
if ifo and ifo != def_ifo:
continue
if segment_name and segment_name != def_name:
continue
valid_id += [def_id]
start = numpy.array(segment_table.getColumnByName('start_time'))
start_ns = numpy.array(segment_table.getColumnByName('start_time_ns'))
end = numpy.array(segment_table.getColumnByName('end_time'))
end_ns = numpy.array(segment_table.getColumnByName('end_time_ns'))
start, end = start + 1e-9 * start_ns, end + 1e-9 * end_ns
did = segment_table.getColumnByName('segment_def_id')
keep = numpy.array([d in valid_id for d in did])
if sum(keep) > 0:
return start_end_to_segments(start[keep], end[keep])
else:
return segmentlist([])
def run_segment_operation(outdoc, filenames, segments, use_segment_table, operation, result_name = 'RESULT', preserve = True):
"""
Performs an operation (intersect or union) across a set of segments.
That is, given a set of files each with segment definers DMT-FLAG1,
DMT-FLAG2 etc and a list of segments DMT-FLAG1,DMT-FLAG1 this returns
RESULT = (table 1's DMT-FLAG1 union table 2's DMT-FLAG1 union ...)
operation
(table 1's DMT-FLAG2 union table 2's DMT-FLAG2 union ...)
operation
etc
"""
proc_id = table.get_table(outdoc, lsctables.ProcessTable.tableName)[0].process_id
if preserve:
indoc = ligolw_add.ligolw_add(outdoc, filenames)
else:
indoc = ligolw_add.ligolw_add(ligolw.Document(), filenames)
# Start with a segment covering all of time, then
# intersect with each of the fields of interest
keys = segments.split(',')
if operation == INTERSECT:
sgmntlist = pycbc_glue.segments.segmentlist([pycbc_glue.segments.segment(-pycbc_glue.segments.infinity(), pycbc_glue.segments.infinity())])
for key in keys:
sgmntlist &= find_segments(indoc, key, use_segment_table)
elif operation == UNION:
sgmntlist = pycbc_glue.segments.segmentlist([])
for key in keys:
sgmntlist |= find_segments(indoc, key, use_segment_table)
elif operation == DIFF:
sgmntlist = find_segments(indoc, keys[0], use_segment_table)
for key in keys[1:]:
sgmntlist -= find_segments(indoc, key, use_segment_table)
else:
raise NameError("%s is not a known operation (intersect, union or diff)" % operation)
# Add a segment definer and segments
seg_def_id = add_to_segment_definer(outdoc, proc_id, '', result_name, 1)
if use_segment_table:
add_to_segment(outdoc, proc_id, seg_def_id, sgmntlist)
else:
add_to_segment_summary(outdoc, proc_id, seg_def_id, sgmntlist)
return outdoc, abs(sgmntlist)
def add_to_segment(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()
segment.start_time = seg[0]
segment.start_time_ns = 0
segment.end_time = seg[1]
segment.end_time_ns = 0
segtable.append(segment)
def add_to_segment_definer(xmldoc, proc_id, ifo, name, version, comment=''):
try:
seg_def_table = table.get_table(xmldoc, lsctables.SegmentDefTable.tableName)
except:
seg_def_table = lsctables.New(lsctables.SegmentDefTable, columns = ["process_id", "segment_def_id", "ifos", "name", "version", "comment"])
xmldoc.childNodes[0].appendChild(seg_def_table)
seg_def_id = seg_def_table.get_next_id()
segment_definer = lsctables.SegmentDef()
segment_definer.process_id = proc_id
segment_definer.segment_def_id = seg_def_id
segment_definer.ifos = ifo
segment_definer.name = name
segment_definer.version = version
segment_definer.comment = comment
seg_def_table.append(segment_definer)
return seg_def_id
def add_to_segment_summary(xmldoc, proc_id, seg_def_id, sgmtlist, comment=''):
try:
seg_sum_table = table.get_table(xmldoc, lsctables.SegmentSumTable.tableName)
except:
seg_sum_table = lsctables.New(lsctables.SegmentSumTable, columns = ["process_id", "segment_def_id", "segment_sum_id", "start_time", "start_time_ns", "end_time", "end_time_ns", "comment"])
xmldoc.childNodes[0].appendChild(seg_sum_table)
for seg in sgmtlist:
segment_sum = lsctables.SegmentSum()
segment_sum.process_id = proc_id
segment_sum.segment_def_id = seg_def_id
segment_sum.segment_sum_id = seg_sum_table.get_next_id()
segment_sum.start_time = seg[0]
segment_sum.start_time_ns = 0
segment_sum.end_time = seg[1]
segment_sum.end_time_ns = 0
segment_sum.comment = comment
seg_sum_table.append(segment_sum)
def start_end_from_segments(segment_file):
"""
Return the start and end time arrays from a segment file.
Parameters
----------
segment_file: xml segment file
Returns
-------
start: numpy.ndarray
end: numpy.ndarray
"""
from pycbc_glue.ligolw.ligolw import LIGOLWContentHandler as h; lsctables.use_in(h)
indoc = ligolw_utils.load_filename(segment_file, False, contenthandler=h)
segment_table = table.get_table(indoc, lsctables.SegmentTable.tableName)
start = numpy.array(segment_table.getColumnByName('start_time'))
start_ns = numpy.array(segment_table.getColumnByName('start_time_ns'))
end = numpy.array(segment_table.getColumnByName('end_time'))
end_ns = numpy.array(segment_table.getColumnByName('end_time_ns'))
return start + start_ns * 1e-9, end + end_ns * 1e-9
def start_end_from_segments(segment_file):
"""
Return the start and end time arrays from a segment file.
Parameters
----------
segment_file: xml segment file
Returns
-------
start: numpy.ndarray
end: numpy.ndarray
"""
from pycbc_glue.ligolw.ligolw import LIGOLWContentHandler as h; lsctables.use_in(h)
indoc = ligolw_utils.load_filename(segment_file, False, contenthandler=h)
segment_table = table.get_table(indoc, lsctables.SegmentTable.tableName)
start = numpy.array(segment_table.getColumnByName('start_time'))
start_ns = numpy.array(segment_table.getColumnByName('start_time_ns'))
end = numpy.array(segment_table.getColumnByName('end_time'))
end_ns = numpy.array(segment_table.getColumnByName('end_time_ns'))
return start + start_ns * 1e-9, end + end_ns * 1e-9
def ReadSimInspiralFromFiles(fileList, verbose=False):
"""
Read the simInspiral tables from a list of files
@param fileList: list of input files
@param verbose: print ligolw_add progress
"""
simInspiralTriggers = None
lsctables.use_in(ExtractSimInspiralTableLIGOLWContentHandler)
for thisFile in fileList:
doc = utils.load_filename(thisFile, gz=(thisFile or "stdin").endswith(".gz"), verbose=verbose, contenthandler=ExtractSimInspiralTableLIGOLWContentHandler)
# extract the sim inspiral table
try: simInspiralTable = \
table.get_table(doc, lsctables.SimInspiralTable.tableName)
except: simInspiralTable = None
if simInspiralTriggers and simInspiralTable:
simInspiralTriggers.extend(simInspiralTable)
elif not simInspiralTriggers:
simInspiralTriggers = simInspiralTable
return simInspiralTriggers
import pylab
from pycbc_glue.ligolw import table, utils, lsctables
from sys import argv
import numpy
pycbc_file = argv[1]
lal_file = argv[2]
pdoc = utils.load_filename(pycbc_file)
ldoc = utils.load_filename(lal_file)
ptrig = table.get_table(pdoc, lsctables.SnglInspiralTable.tableName)
ltrig = table.get_table(ldoc, lsctables.SnglInspiralTable.tableName)
t = table.get_table(pdoc, lsctables.FilterTable.tableName)
start = t[0].start_time
psnr = ptrig.get_column('snr')
pchi = ptrig.get_column('chisq')
pmc = ptrig.get_column('mchirp')
psig = ptrig.get_column('sigmasq')
pend_time = (ptrig.get_column('end_time') - start)+ 1e-9 * ptrig.get_column('end_time_ns')
lsnr = ltrig.get_column('snr')
lchi = ltrig.get_column('chisq')
lmc = ltrig.get_column('mchirp')
lsig = ltrig.get_column('sigmasq')
lend_time = (ltrig.get_column('end_time') - start) + 1e-9 * ltrig.get_column('end_time_ns')
def find_nearest(v1, v2):
i1 = []
def output_sngl_inspiral_table(outputFile, tempBank, metricParams,
ethincaParams, programName="", optDict = None,
outdoc=None, **kwargs):
"""
Function that converts the information produced by the various pyCBC bank
generation codes into a valid LIGOLW xml file containing a sngl_inspiral
table and outputs to file.
Parameters
-----------
outputFile : string
Name of the file that the bank will be written to
tempBank : iterable
Each entry in the tempBank iterable should be a sequence of
[mass1,mass2,spin1z,spin2z] in that order.
metricParams : metricParameters instance
Structure holding all the options for construction of the metric
and the eigenvalues, eigenvectors and covariance matrix
needed to manipulate the space.
ethincaParams: {ethincaParameters instance, None}
Structure holding options relevant to the ethinca metric computation
including the upper frequency cutoff to be used for filtering.
NOTE: The computation is currently only valid for non-spinning systems
and uses the TaylorF2 approximant.
programName (key-word-argument) : string
Name of the executable that has been run
optDict (key-word argument) : dictionary
Dictionary of the command line arguments passed to the program
outdoc (key-word argument) : ligolw xml document
If given add template bank to this representation of a xml document and
write to disk. If not given create a new document.
kwargs : key-word arguments
All other key word arguments will be passed directly to
ligolw_process.register_to_xmldoc
"""
if optDict is None:
optDict = {}
if outdoc is None:
outdoc = ligolw.Document()
outdoc.appendChild(ligolw.LIGO_LW())
# get IFO to put in search summary table
ifos = []
if 'channel_name' in optDict.keys():
if optDict['channel_name'] is not None:
ifos = [optDict['channel_name'][0:2]]
proc_id = ligolw_process.register_to_xmldoc(outdoc, programName, optDict,
ifos=ifos, **kwargs).process_id
sngl_inspiral_table = convert_to_sngl_inspiral_table(tempBank, proc_id)
# Calculate Gamma components if needed
if ethincaParams is not None:
if ethincaParams.doEthinca:
for sngl in sngl_inspiral_table:
# Set tau_0 and tau_3 values needed for the calculation of
# ethinca metric distances
(sngl.tau0,sngl.tau3) = pnutils.mass1_mass2_to_tau0_tau3(
sngl.mass1, sngl.mass2, metricParams.f0)
fMax_theor, GammaVals = calculate_ethinca_metric_comps(
metricParams, ethincaParams,
sngl.mass1, sngl.mass2, spin1z=sngl.spin1z,
spin2z=sngl.spin2z, full_ethinca=ethincaParams.full_ethinca)
# assign the upper frequency cutoff and Gamma0-5 values
sngl.f_final = fMax_theor
for i in xrange(len(GammaVals)):
setattr(sngl, "Gamma"+str(i), GammaVals[i])
# If Gamma metric components are not wanted, assign f_final from an
# upper frequency cutoff specified in ethincaParams
elif ethincaParams.cutoff is not None:
for sngl in sngl_inspiral_table:
sngl.f_final = pnutils.frequency_cutoff_from_name(
ethincaParams.cutoff,
sngl.mass1, sngl.mass2, sngl.spin1z, sngl.spin2z)
# set per-template low-frequency cutoff
if 'f_low_column' in optDict and 'f_low' in optDict and \
optDict['f_low_column'] is not None:
for sngl in sngl_inspiral_table:
setattr(sngl, optDict['f_low_column'], optDict['f_low'])
outdoc.childNodes[0].appendChild(sngl_inspiral_table)
# get times to put in search summary table
start_time = 0
end_time = 0
if 'gps_start_time' in optDict.keys() and 'gps_end_time' in optDict.keys():
start_time = optDict['gps_start_time']
end_time = optDict['gps_end_time']
# make search summary table
search_summary_table = lsctables.New(lsctables.SearchSummaryTable)
search_summary = return_search_summary(start_time, end_time,
len(sngl_inspiral_table), ifos, **kwargs)
search_summary_table.append(search_summary)
outdoc.childNodes[0].appendChild(search_summary_table)
# write the xml doc to disk
proctable = table.get_table(outdoc, lsctables.ProcessTable.tableName)
ligolw_utils.write_filename(outdoc, outputFile,
gz=outputFile.endswith('.gz'))
import pylab
from pycbc_glue.ligolw import table, utils, lsctables
from sys import argv
import numpy
pycbc_file = argv[1]
lal_file = argv[2]
pdoc = utils.load_filename(pycbc_file)
ldoc = utils.load_filename(lal_file)
ptrig = table.get_table(pdoc, lsctables.SnglInspiralTable.tableName)
ltrig = table.get_table(ldoc, lsctables.SnglInspiralTable.tableName)
t = table.get_table(pdoc, lsctables.FilterTable.tableName)
start = t[0].start_time
psnr = ptrig.get_column('snr')
pchi = ptrig.get_column('chisq')
pmc = ptrig.get_column('mchirp')
psig = ptrig.get_column('sigmasq')
pend_time = (ptrig.get_column('end_time') -
start) + 1e-9 * ptrig.get_column('end_time_ns')
lsnr = ltrig.get_column('snr')
lchi = ltrig.get_column('chisq')
lmc = ltrig.get_column('mchirp')
lsig = ltrig.get_column('sigmasq')
lend_time = (ltrig.get_column('end_time') -
start) + 1e-9 * ltrig.get_column('end_time_ns')
def __init__(self, filename, approximant=None, parameters=None,
**kwds):
self.has_compressed_waveforms = False
ext = os.path.basename(filename)
if ext.endswith(('.xml', '.xml.gz', '.xmlgz')):
self.filehandler = None
self.indoc = ligolw_utils.load_filename(
filename, False, contenthandler=LIGOLWContentHandler)
self.table = table.get_table(
self.indoc, lsctables.SnglInspiralTable.tableName)
self.table = pycbc.io.WaveformArray.from_ligolw_table(self.table,
columns=parameters)
# inclination stored in xml alpha3 column
names = list(self.table.dtype.names)
names = tuple([n if n != 'alpha3' else 'inclination' for n in names])
# low frequency cutoff in xml alpha6 column
names = tuple([n if n!= 'alpha6' else 'f_lower' for n in names])
self.table.dtype.names = names
elif ext.endswith(('hdf', '.h5')):
self.indoc = None
f = h5py.File(filename, 'r')
self.filehandler = f
try:
fileparams = map(str, f.attrs['parameters'])
except KeyError:
# just assume all of the top-level groups are the parameters
fileparams = map(str, f.keys())
logging.info("WARNING: no parameters attribute found. "
"Assuming that %s " %(', '.join(fileparams)) +
"are the parameters.")
# use WaveformArray's syntax parser to figure out what fields
# need to be loaded
if parameters is None:
parameters = fileparams
common_fields = list(pycbc.io.WaveformArray(1,
names=parameters).fieldnames)
add_fields = list(set(parameters) &
(set(fileparams) - set(common_fields)))
# load
dtype = []
data = {}
for key in common_fields+add_fields:
data[str(key)] = f[key][:]
dtype.append((str(key), data[key].dtype))
num = f[fileparams[0]].size
self.table = pycbc.io.WaveformArray(num, dtype=dtype)
for key in data:
self.table[key] = data[key]
# add the compressed waveforms, if they exist
self.has_compressed_waveforms = 'compressed_waveforms' in f
else:
raise ValueError("Unsupported template bank file extension %s" %(
ext))
# if approximant is specified, override whatever was in the file
# (if anything was in the file)
if approximant is not None:
# get the approximant for each template
apprxs = self.parse_approximant(approximant)
if 'approximant' not in self.table.fieldnames:
self.table = self.table.add_fields(apprxs, 'approximant')
else:
self.table['approximant'] = apprxs
self.extra_args = kwds
self.ensure_hash()
omicron_times = []
omicron_snr = []
omicron_freq = []
for era in eras:
# Generate list of all Omicron SnglBurst xml trigger files
file_list = glob.glob(args.omicron_dir +
'/%s/%s_Omicron/%s/%s-%s_Omicron-*.xml.gz' %
(args.ifo, args.omicron_channel, era, args.ifo,
args.omicron_channel.replace('-', '_')))
# Parse trigger files into SNR, time, and frequency for Omicron triggers
for file in file_list:
omicron_xml = utils.load_filename(file,
contenthandler=DefaultContentHandler)
snglburst_table = table.get_table(omicron_xml,
lsctables.SnglBurstTable.tableName)
for row in snglburst_table:
if (row.snr > args.omicron_snr_thresh
and omicron_start_time < row.peak_time < omicron_end_time):
omicron_times.append(row.peak_time +
row.peak_time_ns * 10**(-9))
omicron_snr.append(row.snr)
omicron_freq.append(row.peak_frequency)
# Generate inspiral waveform and calculate f(t) to plot on top of Omicron triggers
hp, hc = get_td_waveform(approximant='SEOBNRv2',
mass1=m1,
mass2=m2,
spin1x=0,
spin1y=0,
def run_file_operation(outdoc, filenames, use_segment_table, operation, preserve = True):
"""
Performs an operation (intersect or union) across a set of files.
That is, given a set of files each with segment definers DMT-FLAG1,
DMT-FLAG2 etc the result is a file where
DMT-FLAG1 = (file 1's DMT-FLAG1 operation file 2's DMT-FLAG1 operation ...)
DMT-FLAG2 = (file 1's DMT-FLAG2 operation file 2's DMT-FLAG2 operation ...)
etc
"""
proc_id = table.get_table(outdoc, lsctables.ProcessTable.tableName)[0].process_id
# load up the files into individual documents
xmldocs = [ligolw_add.ligolw_add(ligolw.Document(), [fname]) for fname in filenames]
# Get the list of dinstinct segment_definers across all docs
segment_definers = {}
def register_definer(seg_def):
key = (seg_def.ifos, seg_def.name, seg_def.version)
segment_definers[key] = True
return key
for xmldoc in xmldocs:
seg_def_table = table.get_table(xmldoc, lsctables.SegmentDefTable.tableName)
map (register_definer, seg_def_table)
# For each unique segment definer, find the intersection
for ifo, name, version in segment_definers:
if operation == INTERSECT:
# If I were feeling especially functional-ist I'd write this
# with reduce()
result = pycbc_glue.segments.segmentlist([pycbc_glue.segments.segment(-pycbc_glue.segments.infinity(), pycbc_glue.segments.infinity())])
for xmldoc in xmldocs:
result &= find_segments(xmldoc, '%s:%s:%d' % (ifo, name, version), use_segment_table)
elif operation == UNION:
result = pycbc_glue.segments.segmentlist([])
for xmldoc in xmldocs:
result |= find_segments(xmldoc, '%s:%s:%d' % (ifo, name, version), use_segment_table)
elif operation == DIFF:
result = find_segments(xmldocs[0], '%s:%s:%d' % (ifo, name, version), use_segment_table)
for xmldoc in xmldocs[1:]:
result -= find_segments(xmldoc, '%s:%s:%d' % (ifo, name, version), use_segment_table)
else:
raise NameError ("%s is not a known operation (intersect, union or diff)" % operation)
# Add a segment definer for the result
seg_def_id = add_to_segment_definer(outdoc, proc_id, ifo, name, version)
# Add the segments
if use_segment_table:
add_to_segment(outdoc, proc_id, seg_def_id, result)
else:
add_to_segment_summary(outdoc, proc_id, seg_def_id, result)
# If we're preserving, also load up everything into the output document.
if preserve:
# Add them to the output document
map(lambda x: outdoc.appendChild(x.childNodes[0]), xmldocs)
# Merge the ligolw elements and tables
ligolw_add.merge_ligolws(outdoc)
ligolw_add.merge_compatible_tables(outdoc)
return outdoc, abs(result)
# Grab all relevant Omicron trigger files
omicron_times = []
omicron_snr = []
omicron_freq = []
for era in eras:
# Generate list of all Omicron SnglBurst xml trigger files
file_list = glob.glob(args.omicron_dir +
'/%s/%s_Omicron/%s/%s-%s_Omicron-*.xml.gz'
%(args.ifo,args.omicron_channel,era,args.ifo,args.omicron_channel.replace('-','_')))
# Parse trigger files into SNR, time, and frequency for Omicron triggers
for file in file_list:
omicron_xml = utils.load_filename(file, contenthandler=DefaultContentHandler)
snglburst_table = table.get_table(omicron_xml, lsctables.SnglBurstTable.tableName)
for row in snglburst_table:
if (row.snr > args.omicron_snr_thresh and
omicron_start_time < row.peak_time < omicron_end_time):
omicron_times.append(row.peak_time + row.peak_time_ns * 10**(-9))
omicron_snr.append(row.snr)
omicron_freq.append(row.peak_frequency)
# Generate inspiral waveform and calculate f(t) to plot on top of Omicron triggers
hp, hc = get_td_waveform(approximant='SEOBNRv2', mass1=m1, mass2=m2,
spin1x=0, spin1y=0, spin1z=s1z,
spin2x=0, spin2y=0, spin2z=s2z,
delta_t=(1./32768.), f_lower=30)
def __init__(self, filename, approximant=None, parameters=None, **kwds):
self.has_compressed_waveforms = False
ext = os.path.basename(filename)
if ext.endswith(('.xml', '.xml.gz', '.xmlgz')):
self.filehandler = None
self.indoc = ligolw_utils.load_filename(
filename, False, contenthandler=LIGOLWContentHandler)
self.table = table.get_table(self.indoc,
lsctables.SnglInspiralTable.tableName)
self.table = pycbc.io.WaveformArray.from_ligolw_table(
self.table, columns=parameters)
# inclination stored in xml alpha3 column
names = list(self.table.dtype.names)
names = tuple(
[n if n != 'alpha3' else 'inclination' for n in names])
# low frequency cutoff in xml alpha6 column
names = tuple([n if n != 'alpha6' else 'f_lower' for n in names])
self.table.dtype.names = names
elif ext.endswith(('hdf', '.h5')):
self.indoc = None
f = h5py.File(filename, 'r')
self.filehandler = f
try:
fileparams = map(str, f.attrs['parameters'])
except KeyError:
# just assume all of the top-level groups are the parameters
fileparams = map(str, f.keys())
logging.info("WARNING: no parameters attribute found. "
"Assuming that %s " % (', '.join(fileparams)) +
"are the parameters.")
# use WaveformArray's syntax parser to figure out what fields
# need to be loaded
if parameters is None:
parameters = fileparams
common_fields = list(
pycbc.io.WaveformArray(1, names=parameters).fieldnames)
add_fields = list(
set(parameters) & (set(fileparams) - set(common_fields)))
# load
dtype = []
data = {}
for key in common_fields + add_fields:
data[str(key)] = f[key][:]
dtype.append((str(key), data[key].dtype))
num = f[fileparams[0]].size
self.table = pycbc.io.WaveformArray(num, dtype=dtype)
for key in data:
self.table[key] = data[key]
# add the compressed waveforms, if they exist
self.has_compressed_waveforms = 'compressed_waveforms' in f
else:
raise ValueError("Unsupported template bank file extension %s" %
(ext))
# if approximant is specified, override whatever was in the file
# (if anything was in the file)
if approximant is not None:
# get the approximant for each template
apprxs = self.parse_approximant(approximant)
if 'approximant' not in self.table.fieldnames:
self.table = self.table.add_fields(apprxs, 'approximant')
else:
self.table['approximant'] = apprxs
self.extra_args = kwds
self.ensure_hash()
def __init__(self, sim_file, **kwds):
self.indoc = ligolw_utils.load_filename(
sim_file, False, contenthandler=LIGOLWContentHandler)
self.table = table.get_table(self.indoc,
lsctables.SimInspiralTable.tableName)
self.extra_args = kwds
def output_sngl_inspiral_table(outputFile,
tempBank,
metricParams,
ethincaParams,
programName="",
optDict=None,
outdoc=None,
**kwargs):
"""
Function that converts the information produced by the various pyCBC bank
generation codes into a valid LIGOLW xml file containing a sngl_inspiral
table and outputs to file.
Parameters
-----------
outputFile : string
Name of the file that the bank will be written to
tempBank : iterable
Each entry in the tempBank iterable should be a sequence of
[mass1,mass2,spin1z,spin2z] in that order.
metricParams : metricParameters instance
Structure holding all the options for construction of the metric
and the eigenvalues, eigenvectors and covariance matrix
needed to manipulate the space.
ethincaParams: {ethincaParameters instance, None}
Structure holding options relevant to the ethinca metric computation
including the upper frequency cutoff to be used for filtering.
NOTE: The computation is currently only valid for non-spinning systems
and uses the TaylorF2 approximant.
programName (key-word-argument) : string
Name of the executable that has been run
optDict (key-word argument) : dictionary
Dictionary of the command line arguments passed to the program
outdoc (key-word argument) : ligolw xml document
If given add template bank to this representation of a xml document and
write to disk. If not given create a new document.
kwargs : key-word arguments
All other key word arguments will be passed directly to
ligolw_process.register_to_xmldoc
"""
if optDict is None:
optDict = {}
if outdoc is None:
outdoc = ligolw.Document()
outdoc.appendChild(ligolw.LIGO_LW())
# get IFO to put in search summary table
ifos = []
if 'channel_name' in optDict.keys():
if optDict['channel_name'] is not None:
ifos = [optDict['channel_name'][0:2]]
proc_id = ligolw_process.register_to_xmldoc(outdoc,
programName,
optDict,
ifos=ifos,
**kwargs).process_id
sngl_inspiral_table = convert_to_sngl_inspiral_table(tempBank, proc_id)
# Calculate Gamma components if needed
if ethincaParams is not None:
if ethincaParams.doEthinca:
for sngl in sngl_inspiral_table:
# Set tau_0 and tau_3 values needed for the calculation of
# ethinca metric distances
(sngl.tau0, sngl.tau3) = pnutils.mass1_mass2_to_tau0_tau3(
sngl.mass1, sngl.mass2, metricParams.f0)
fMax_theor, GammaVals = calculate_ethinca_metric_comps(
metricParams,
ethincaParams,
sngl.mass1,
sngl.mass2,
spin1z=sngl.spin1z,
spin2z=sngl.spin2z,
full_ethinca=ethincaParams.full_ethinca)
# assign the upper frequency cutoff and Gamma0-5 values
sngl.f_final = fMax_theor
for i in xrange(len(GammaVals)):
setattr(sngl, "Gamma" + str(i), GammaVals[i])
# If Gamma metric components are not wanted, assign f_final from an
# upper frequency cutoff specified in ethincaParams
elif ethincaParams.cutoff is not None:
for sngl in sngl_inspiral_table:
sngl.f_final = pnutils.frequency_cutoff_from_name(
ethincaParams.cutoff, sngl.mass1, sngl.mass2, sngl.spin1z,
sngl.spin2z)
# set per-template low-frequency cutoff
if 'f_low_column' in optDict and 'f_low' in optDict and \
optDict['f_low_column'] is not None:
for sngl in sngl_inspiral_table:
setattr(sngl, optDict['f_low_column'], optDict['f_low'])
outdoc.childNodes[0].appendChild(sngl_inspiral_table)
# get times to put in search summary table
start_time = 0
end_time = 0
if 'gps_start_time' in optDict.keys() and 'gps_end_time' in optDict.keys():
start_time = optDict['gps_start_time']
end_time = optDict['gps_end_time']
# make search summary table
search_summary_table = lsctables.New(lsctables.SearchSummaryTable)
search_summary = return_search_summary(start_time, end_time,
len(sngl_inspiral_table), ifos,
**kwargs)
search_summary_table.append(search_summary)
outdoc.childNodes[0].appendChild(search_summary_table)
# write the xml doc to disk
proctable = table.get_table(outdoc, lsctables.ProcessTable.tableName)
ligolw_utils.write_filename(outdoc,
outputFile,
gz=outputFile.endswith('.gz'))
def __init__(self, sim_file, **kwds):
self.indoc = ligolw_utils.load_filename(
sim_file, False, contenthandler=LIGOLWContentHandler)
self.table = table.get_table(self.indoc, lsctables.SimInspiralTable.tableName)
self.extra_args = kwds
