def _build_series(series, dim_names, comment, delta_name, delta_unit):
from glue.ligolw import array as ligolw_array
Attributes = ligolw.sax.xmlreader.AttributesImpl
elem = ligolw.LIGO_LW(
Attributes({u"Name": unicode(series.__class__.__name__)}))
if comment is not None:
elem.appendChild(ligolw.Comment()).pcdata = comment
elem.appendChild(ligolw.Time.from_gps(series.epoch, u"epoch"))
elem.appendChild(ligolw_param.Param.from_pyvalue(u"f0", series.f0,
unit=u"s^-1"))
delta = getattr(series, delta_name)
if numpy.iscomplexobj(series.data.data):
data = numpy.row_stack((numpy.arange(len(series.data.data)) * delta,
series.data.data.real, series.data.data.imag))
else:
data = numpy.row_stack((numpy.arange(len(series.data.data)) * delta,
series.data.data))
a = ligolw_array.Array.build(series.name, data, dim_names=dim_names)
a.Unit = str(series.sampleUnits)
dim0 = a.getElementsByTagName(ligolw.Dim.tagName)[0]
dim0.Unit = delta_unit
dim0.Start = series.f0
dim0.Scale = delta
elem.appendChild(a)
return elem
def gen_likelihood_control(coinc_params_distributions,
seglists,
name=u"ligolw_burca_tailor",
comment=u""):
xmldoc = ligolw.Document()
node = xmldoc.appendChild(ligolw.LIGO_LW())
process = ligolw_process.register_to_xmldoc(xmldoc,
program=process_program_name,
paramdict={},
version=__version__,
cvs_repository="lscsoft",
cvs_entry_time=__date__,
comment=comment)
coinc_params_distributions.process_id = process.process_id
ligolw_search_summary.append_search_summary(xmldoc,
process,
ifos=seglists.keys(),
inseg=seglists.extent_all(),
outseg=seglists.extent_all())
node.appendChild(coinc_params_distributions.to_xml(name))
ligolw_process.set_process_end_time(process)
return xmldoc
def _build_series(series, dim_names, comment, delta_name, delta_unit):
elem = ligolw.LIGO_LW(
Attributes({u"Name": unicode(series.__class__.__name__)}))
if comment is not None:
elem.appendChild(ligolw.Comment()).pcdata = comment
# FIXME: make Time class smart so we don't have to build it by
# hand
elem.appendChild(
ligolw.Time(Attributes({
u"Name": u"epoch",
u"Type": u"GPS"
}))).pcdata = unicode(series.epoch)
elem.appendChild(ligolw_param.from_pyvalue(u"f0", series.f0, unit=u"s^-1"))
delta = getattr(series, delta_name)
if np.iscomplexobj(series.data.data):
data = np.row_stack((np.arange(len(series.data.data)) * delta,
series.data.data.real, series.data.data.imag))
else:
data = np.row_stack(
(np.arange(len(series.data.data)) * delta, series.data.data))
a = ligolw_array.from_array(series.name, data, dim_names=dim_names)
a.Unit = lal.UnitToString(series.sampleUnits)
dim0 = a.getElementsByTagName(ligolw.Dim.tagName)[0]
dim0.Unit = delta_unit
dim0.Start = series.f0
dim0.Scale = delta
elem.appendChild(a)
return elem
def to_xml(self, name):
xml = ligolw.LIGO_LW(
{u"Name": u"%s:%s" % (name, self.ligo_lw_name_suffix)})
xml.appendChild(self.numerator.to_xml("numerator"))
xml.appendChild(self.denominator.to_xml("denominator"))
xml.appendChild(self.candidates.to_xml("candidates"))
return xml
def create_xmldoc(tables):
"""
Creates an xmldoc from the list of given LIGOLW tables.
"""
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
for table in tables:
xmldoc.childNodes[0].appendChild(table)
return xmldoc
def make_psd_xmldoc(psddict):
Attributes = ligolw.sax.xmlreader.AttributesImpl
xmldoc = ligolw.Document()
root_name = u"psd"
lw = xmldoc.appendChild(ligolw.LIGO_LW(Attributes({u"Name": root_name})))
for instrument, psd in psddict.items():
xmlseries = _build_series(psd, (u"Frequency,Real", u"Frequency"), None,
'deltaF', 's^-1')
fs = lw.appendChild(xmlseries)
fs.appendChild(ligolw_param.from_pyvalue(u"instrument", instrument))
return xmldoc
def ligolw_copy_process(xmldoc_src, xmldoc_dest):
"""
We want to copy over process and process_params tables to eventually
merge them.
"""
proc = lsctables.ProcessTable.get_table(xmldoc_src)
pp = lsctables.ProcessParamsTable.get_table(xmldoc_src)
xmldoc_dest.appendChild(ligolw.LIGO_LW())
xmldoc_dest.childNodes[-1].appendChild(proc)
xmldoc_dest.childNodes[-1].appendChild(pp)
def write_to_xml(cells,
intr_prms,
pin_prms={},
fvals=None,
fname=None,
verbose=False):
"""
Write a set of cells, with dimensions corresponding to intr_prms to an XML file as sim_inspiral rows.
"""
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
procrow = process.append_process(xmldoc, program=sys.argv[0])
procid = procrow.process_id
process.append_process_params(
xmldoc, procrow, process.process_params_from_dict(opts.__dict__))
rows = ["simulation_id", "process_id", "numrel_data"]
# Override eff_lambda to with psi0, its shoehorn column
if "eff_lambda" in intr_prms:
intr_prms[intr_prms.index("eff_lambda")] = "psi0"
if "deff_lambda" in intr_prms:
intr_prms[intr_prms.index("deff_lambda")] = "psi3"
rows += list(intr_prms)
rows += list(pin_prms)
if fvals is not None:
rows.append("alpha1")
sim_insp_tbl = lsctables.New(lsctables.SimInspiralTable, rows)
for itr, intr_prm in enumerate(cells):
sim_insp = sim_insp_tbl.RowType()
# FIXME: Need better IDs
sim_insp.numrel_data = "INTR_SET_%d" % itr
sim_insp.simulation_id = ilwd.ilwdchar(
"sim_inspiral:sim_inspiral_id:%d" % itr)
sim_insp.process_id = procid
if fvals:
sim_insp.alpha1 = fvals[itr]
for p, v in zip(intr_prms, intr_prm._center):
setattr(sim_insp, p, v)
for p, v in pin_prms.iteritems():
setattr(sim_insp, p, v)
sim_insp_tbl.append(sim_insp)
xmldoc.childNodes[0].appendChild(sim_insp_tbl)
if fname is None:
channel_name = ["H=H", "L=L"]
ifos = "".join([o.split("=")[0][0] for o in channel_name])
#start = int(event_time)
start = 0
fname = "%s-MASS_POINTS-%d-1.xml.gz" % (ifos, start)
utils.write_filename(xmldoc, fname, gz=True, verbose=verbose)
def new_doc(comment=None, **kwargs):
doc = ligolw.Document()
doc.appendChild(ligolw.LIGO_LW())
process = ligolw_process.register_to_xmldoc(doc,
program=u"ligolw_tisi",
paramdict=kwargs,
version=__version__,
cvs_repository=u"lscsoft",
cvs_entry_time=__date__,
comment=comment)
timeslidetable = lsctables.New(lsctables.TimeSlideTable)
doc.childNodes[0].appendChild(timeslidetable)
return doc, process
def build_COMPLEX16FrequencySeries(series, comment = None):
elem = ligolw.LIGO_LW(Attributes({u"Name": u"COMPLEX16FrequencySeries"}))
if comment is not None:
elem.appendChild(ligolw.Comment()).pcdata = comment
elem.appendChild(ligolw.Time.from_gps(series.epoch, Name = u"epoch"))
elem.appendChild(ligolw_param.from_pyvalue(u"f0", series.f0, unit = LALUnit("s^-1")))
data = series.data
data = numpy.row_stack((numpy.arange(0, len(data)) * series.deltaF, numpy.real(data), numpy.imag(data)))
a = ligolw_array.from_array(series.name, data, dim_names = (u"Frequency", u"Frequency,Real,Imaginary"))
a.Unit = series.sampleUnits
dim0 = a.getElementsByTagName(ligolw.Dim.tagName)[0]
dim0.Unit = LALUnit("s^-1")
dim0.Start = series.f0
dim0.Scale = series.deltaF
elem.appendChild(a)
return elem
def write_rows(rows, table_type, filename):
"""
Create an empty LIGO_LW XML document, add a table of table_type,
insert the given rows, then write the document to a file.
"""
# prepare a new XML document
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
tbl = lsctables.New(table_type)
xmldoc.childNodes[-1].appendChild(tbl)
# insert our rows
tbl.extend(rows)
# write out the document
utils.write_filename(xmldoc, filename)
def setUp(self):
available_detectors = get_available_detectors()
available_detectors = [a[0] for a in available_detectors]
self.assertTrue('H1' in available_detectors)
self.assertTrue('L1' in available_detectors)
self.assertTrue('V1' in available_detectors)
self.detectors = [Detector(d) for d in ['H1', 'L1', 'V1']]
self.sample_rate = 4096.
self.earth_time = lal.REARTH_SI / lal.C_SI
# create a few random injections
self.injections = []
start_time = float(lal.GPSTimeNow())
taper_choices = ('TAPER_NONE', 'TAPER_START', 'TAPER_END',
'TAPER_STARTEND')
for i, taper in zip(xrange(20), itertools.cycle(taper_choices)):
inj = MyInjection()
inj.end_time = start_time + 40000 * i + \
numpy.random.normal(scale=3600)
random = numpy.random.uniform
inj.mass1 = random(low=1., high=20.)
inj.mass2 = random(low=1., high=20.)
inj.distance = random(low=0.9, high=1.1) * 1e6 * lal.PC_SI
inj.latitude = numpy.arccos(random(low=-1, high=1))
inj.longitude = random(low=0, high=2 * lal.PI)
inj.inclination = numpy.arccos(random(low=-1, high=1))
inj.polarization = random(low=0, high=2 * lal.PI)
inj.taper = taper
self.injections.append(inj)
# create LIGOLW document
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
# create sim inspiral table, link it to document and fill it
sim_table = lsctables.New(lsctables.SimInspiralTable)
xmldoc.childNodes[-1].appendChild(sim_table)
for i in xrange(len(self.injections)):
row = sim_table.RowType()
self.injections[i].fill_sim_inspiral_row(row)
row.process_id = 'process:process_id:0'
row.simulation_id = 'sim_inspiral:simulation_id:%d' % i
sim_table.append(row)
# write document to temp file
self.inj_file = tempfile.NamedTemporaryFile(suffix='.xml')
ligolw_utils.write_fileobj(xmldoc, self.inj_file)
def make_psd_xmldoc(psddict, xmldoc=None):
"""Add a set of PSDs to a LIGOLW XML document. If the document is not
given, a new one is created first.
"""
xmldoc = ligolw.Document() if xmldoc is None else xmldoc.childNodes[0]
# the PSDs must be children of a LIGO_LW with name "psd"
root_name = u"psd"
Attributes = ligolw.sax.xmlreader.AttributesImpl
lw = xmldoc.appendChild(ligolw.LIGO_LW(Attributes({u"Name": root_name})))
for instrument, psd in psddict.items():
xmlseries = _build_series(psd, (u"Frequency,Real", u"Frequency"), None,
'deltaF', 's^-1')
fs = lw.appendChild(xmlseries)
fs.appendChild(LIGOLWParam.from_pyvalue(u'instrument', instrument))
return xmldoc
def __getitem__(self, coinc_event_id):
"""
Construct and return an XML document containing the
sngl_inspiral<-->sngl_inspiral coinc carrying the given
coinc_event_id.
"""
newxmldoc = ligolw.Document()
ligolw_elem = newxmldoc.appendChild(ligolw.LIGO_LW())
# when making these, we can't use .copy() method of Table
# instances because we need to ensure we have a Table
# subclass, not a DBTable subclass
new_process_table = ligolw_elem.appendChild(lsctables.New(lsctables.ProcessTable, self.process_table.columnnames))
new_process_params_table = ligolw_elem.appendChild(lsctables.New(lsctables.ProcessParamsTable, self.process_params_table.columnnames))
new_search_summary_table = ligolw_elem.appendChild(lsctables.New(lsctables.SearchSummaryTable, self.search_summary_table.columnnames))
new_sngl_inspiral_table = ligolw_elem.appendChild(lsctables.New(lsctables.SnglInspiralTable, self.sngl_inspiral_table.columnnames))
new_coinc_def_table = ligolw_elem.appendChild(lsctables.New(lsctables.CoincDefTable, self.coinc_def_table.columnnames))
new_coinc_event_table = ligolw_elem.appendChild(lsctables.New(lsctables.CoincTable, self.coinc_event_table.columnnames))
new_coinc_inspiral_table = ligolw_elem.appendChild(lsctables.New(lsctables.CoincInspiralTable, self.coinc_inspiral_table.columnnames))
new_coinc_event_map_table = ligolw_elem.appendChild(lsctables.New(lsctables.CoincMapTable, self.coinc_event_map_table.columnnames))
new_time_slide_table = ligolw_elem.appendChild(lsctables.New(lsctables.TimeSlideTable, self.time_slide_table.columnnames))
new_coinc_def_table.append(self.coinc_def)
coinc_event = self.coinc_event_index[coinc_event_id]
new_coinc_event_table.append(coinc_event)
new_coinc_inspiral_table.append(self.coinc_inspiral_index[coinc_event_id])
map(new_coinc_event_map_table.append, self.coinc_event_map_index[coinc_event_id])
map(new_time_slide_table.append, self.time_slide_index[coinc_event.time_slide_id])
for row in new_coinc_event_map_table:
new_sngl_inspiral_table.append(self.sngl_inspiral_index[row.event_id])
for process_id in set(new_sngl_inspiral_table.getColumnByName("process_id")) | set(new_coinc_event_table.getColumnByName("process_id")) | set(new_time_slide_table.getColumnByName("process_id")):
# process row is required
new_process_table.append(self.process_index[process_id])
try:
map(new_process_params_table.append, self.process_params_index[process_id])
except KeyError:
# process_params rows are optional
pass
try:
new_search_summary_table.append(self.search_summary_index[process_id])
except KeyError:
# search_summary rows are optional
pass
return newxmldoc
def create_xml(ts_data,psd_segment_length,window_fraction,event_list,station,setname="MagneticFields"):
__program__ = 'pyburst_excesspower'
start_time = LIGOTimeGPS(int(ts_data.start_time))
end_time = LIGOTimeGPS(int(ts_data.end_time))
inseg = segment(start_time,end_time)
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
ifo = 'H1'#channel_name.split(":")[0]
straindict = psd.insert_psd_option_group.__dict__
proc_row = register_to_xmldoc(xmldoc, __program__,straindict, ifos=[ifo],version=git_version.id, cvs_repository=git_version.branch, cvs_entry_time=git_version.date)
outseg = determine_output_segment(inseg, psd_segment_length, ts_data.sample_rate, window_fraction)
ss = append_search_summary(xmldoc, proc_row, ifos=(station,), inseg=inseg, outseg=outseg)
for sb in event_list:
sb.process_id = proc_row.process_id
sb.search = proc_row.program
sb.ifo, sb.channel = station, setname
xmldoc.childNodes[0].appendChild(event_list)
fname = make_filename(station, inseg)
utils.write_filename(xmldoc, fname, gz=fname.endswith("gz"))
def multi_segments_to_file(seg_list, filename, names, ifos):
""" Save segments to an xml file
Parameters
----------
seg_list: glue.segments.segmentlist
List of segment lists to write to disk
filename : str
name of the output file
names :
name of each segment list
ifos :
list of ifos
Returns
-------
File : Return a pycbc.core.File reference to the file
"""
from pycbc.workflow.core import File
# create XML doc and add process table
outdoc = ligolw.Document()
outdoc.appendChild(ligolw.LIGO_LW())
process = ligolw_utils.process.register_to_xmldoc(outdoc, argv[0], {})
for segs, ifo, name in zip(seg_list, ifos, names):
fsegs = [(lal.LIGOTimeGPS(seg[0]), lal.LIGOTimeGPS(seg[1])) \
for seg in segs]
# add segments, segments summary, and segment definer tables using glue library
with ligolw_segments.LigolwSegments(outdoc, process) as xmlsegs:
xmlsegs.insert_from_segmentlistdict({ifo: fsegs}, name)
# write file
ligolw_utils.write_filename(outdoc, filename)
# return a File instance
url = urlparse.urlunparse(
['file', 'localhost', filename, None, None, None])
f = File(ifo, name, segs, file_url=url, tags=[name])
f.PFN(os.path.abspath(filename), site='local')
return f
def make_tseries_xmldoc(psddict, xmldoc=None):
"""
Construct an XML document tree representation of a dictionary of
frequency series objects containing complex data. See also
read_tseries_xmldoc() for a function to parse the resulting XML
documents.
If xmldoc is None (the default), then a new XML document is created
and the frequency series dictionary added to it. If xmldoc is not None
then the frequency series dictionary is appended to the children of that
element inside a new LIGO_LW element.
"""
if xmldoc is None:
xmldoc = ligolw.Document()
lw = xmldoc.appendChild(ligolw.LIGO_LW())
for instrument, psd in psddict.items():
fs = lw.appendChild(build_REAL8TimeSeries(psd))
if instrument is not None:
fs.appendChild(param.from_pyvalue(u"instrument", instrument))
return xmldoc
def make_psd_xmldoc(psddict, xmldoc = None, root_name = u"psd"):
"""
Construct an XML document tree representation of a dictionary of
frequency series objects containing PSDs. See also read_psd_xmldoc()
for a function to parse the resulting XML documents.
If xmldoc is None (the default), then a new XML document is created and
the PSD dictionary added to it inside a LIGO_LW element. If xmldoc is
not None then the PSD dictionary is appended to the children of that
element inside a new LIGO_LW element. In both cases, the LIGO_LW
element's Name attribute is set to root_name. This will be looked for
by read_psd_xmldoc() when parsing the PSD document.
"""
if xmldoc is None:
xmldoc = ligolw.Document()
lw = xmldoc.appendChild(ligolw.LIGO_LW(Attributes({u"Name": root_name})))
for instrument, psd in psddict.items():
fs = lw.appendChild(build_REAL8FrequencySeries(psd))
if instrument is not None:
fs.appendChild(ligolw_param.Param.from_pyvalue(u"instrument", instrument))
return xmldoc
def write(filename, samples, write_params=None, static_args=None):
"""Writes the injection samples to the given xml.
Parameters
----------
filename : str
The name of the file to write to.
samples : io.FieldArray
FieldArray of parameters.
write_params : list, optional
Only write the given parameter names. All given names must be keys
in ``samples``. Default is to write all parameters in ``samples``.
static_args : dict, optional
Dictionary mapping static parameter names to values. These are
written to the ``attrs``.
"""
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
simtable = lsctables.New(lsctables.SimInspiralTable)
xmldoc.childNodes[0].appendChild(simtable)
if static_args is None:
static_args = {}
if write_params is None:
write_params = samples.fieldnames
for ii in range(samples.size):
sim = lsctables.SimInspiral()
# initialize all elements to None
for col in sim.__slots__:
setattr(sim, col, None)
for field in write_params:
data = samples[ii][field]
set_sim_data(sim, field, data)
# set any static args
for (field, value) in static_args.items():
set_sim_data(sim, field, value)
simtable.append(sim)
ligolw_utils.write_filename(xmldoc,
filename,
gz=filename.endswith('gz'))
def build_REAL8FrequencySeries(series, comment = None):
elem = ligolw.LIGO_LW(Attributes({u"Name": u"REAL8FrequencySeries"}))
if comment is not None:
elem.appendChild(ligolw.Comment()).pcdata = comment
elem.appendChild(ligolw.Time.from_gps(series.epoch, Name = u"epoch"))
elem.appendChild(ligolw_param.from_pyvalue(u"f0", series.f0, unit = LALUnit("s^-1")))
data = series.data
try:
# Support both the pylal-wrapped class, and the direct lal class
datalength = data.length
data = data.data
except:
datalength = len(data)
data = numpy.row_stack((numpy.arange(0, datalength) * series.deltaF, data))
a = ligolw_array.from_array(series.name, data, dim_names = (u"Frequency", u"Frequency,Real"))
a.Unit = series.sampleUnits
dim0 = a.getElementsByTagName(ligolw.Dim.tagName)[0]
dim0.Unit = LALUnit("s^-1")
dim0.Start = series.f0
dim0.Scale = series.deltaF
elem.appendChild(a)
return elem
def create_empty_sim_inspiral_xml(geocent_end_time=0.0):
""" Creates a string of a LIGOLW XML file with an empty sim_inspiral table.
Parameters
----------
geocent_end_time: float
The geocentric end time to add to row in sim_inspiral table.
Retuns
----------
file_contents: str
A string that contains a LIGOLW XML file with an empty
sim_inspiral table.
"""
# create a new sim_inspiral table
cols = lsctables.SimInspiralTable.validcolumns.keys()
sim_table = lsctables.New(lsctables.SimInspiralTable, cols)
# create new LIGOLW XML document and add the new sim_inspiral table
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
xmldoc.childNodes[0].appendChild(sim_table)
# add a row with the geocentric end time column filled
sim = create_empty_sim_inspiral_row()
sim.geocent_end_time = int(geocent_end_time)
sim.geocent_end_time_ns = int(geocent_end_time % 1 * 1e9)
sim_table.append(sim)
# get XML content as a str
fp = StringIO.StringIO()
xmldoc.write(fp)
fp.seek(0)
file_contents = fp.read()
fp.close()
return file_contents
def _build_series(series, dim_names, comment, delta_name, delta_unit):
Attributes = ligolw.sax.xmlreader.AttributesImpl
elem = ligolw.LIGO_LW(
Attributes({'Name': str(series.__class__.__name__)}))
if comment is not None:
elem.appendChild(ligolw.Comment()).pcdata = comment
elem.appendChild(ligolw.Time.from_gps(series.epoch, 'epoch'))
elem.appendChild(LIGOLWParam.from_pyvalue('f0', series.f0, unit='s^-1'))
delta = getattr(series, delta_name)
if numpy.iscomplexobj(series.data.data):
data = numpy.row_stack((numpy.arange(len(series.data.data)) * delta,
series.data.data.real, series.data.data.imag))
else:
data = numpy.row_stack((numpy.arange(len(series.data.data)) * delta,
series.data.data))
a = LIGOLWArray.build(series.name, data, dim_names=dim_names)
a.Unit = str(series.sampleUnits)
dim0 = a.getElementsByTagName(ligolw.Dim.tagName)[0]
dim0.Unit = delta_unit
dim0.Start = series.f0
dim0.Scale = delta
elem.appendChild(a)
return elem
def tosegmentxml(file, segs):
"""
Write the glue.segments.segmentlist object segs to file object file in xml
format with appropriate tables.
"""
# generate empty document
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
xmldoc.childNodes[-1].appendChild(lsctables.New(lsctables.ProcessTable))
xmldoc.childNodes[-1].appendChild(
lsctables.New(lsctables.ProcessParamsTable))
# append process to table
process = ligolw_process.append_process(xmldoc,\
program='pylal.dq.dqSegmentUtils',\
version=__version__,\
cvs_repository='lscsoft',\
cvs_entry_time=__date__)
gpssegs = segments.segmentlist()
for seg in segs:
gpssegs.append(
segments.segment(LIGOTimeGPS(seg[0]), LIGOTimeGPS(seg[1])))
# append segs and seg definer
segments_tables = ligolw_segments.LigolwSegments(xmldoc)
segments_tables.add(ligolw_segments.LigolwSegmentList(active=gpssegs))
# finalise
segments_tables.coalesce()
segments_tables.optimize()
segments_tables.finalize(process)
ligolw_process.set_process_end_time(process)
# write file
with utils.SignalsTrap():
utils.write_fileobj(xmldoc, file, gz=False)
def make_random_document(num_procs, num_seg_defs, num_segs, num_seg_sums,
start_time, end_time, max_len):
"""Create a ligolw document with random segments and segment_summary"""
doc = ligolw.Document()
doc.appendChild(ligolw.LIGO_LW())
# Add some processes
proc_ids = []
seg_def_ids = {}
segment_map = {}
segment_sum_map = {}
for count in range(num_procs):
proc_id = append_process(doc, "Test program %d" % count).process_id
proc_ids.append(proc_id)
seg_def_ids[proc_id] = []
# Add some segment definers
for count in range(num_seg_defs):
proc_id = proc_ids[int(uniform(0, num_procs))]
seg_def_id = add_to_segment_definer(doc, proc_id, "H1",
"TEST_SEG_%d" % count, 1)
seg_def_ids[proc_id].append(seg_def_id)
# Add some segments
sgmntlst = random_segments(start_time, end_time, num_segs, max_len)
add_to_segment(doc, proc_id, seg_def_id, sgmntlst)
sgmntlst.coalesce()
segment_map["TEST_SEG_%d" % count] = sgmntlst
# Add some segment summaries
sgmntlst = random_segments(start_time, end_time, num_segs, max_len)
add_to_segment_summary(doc, proc_id, seg_def_id, sgmntlst)
sgmntlst.coalesce()
segment_sum_map["TEST_SEG_%d" % count] = sgmntlst
return doc, segment_map, segment_sum_map
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 to_coinc_xml_object(self, file_name):
outdoc = ligolw.Document()
outdoc.appendChild(ligolw.LIGO_LW())
ifos = list(self.sngl_files.keys())
proc_id = ligolw_process.register_to_xmldoc(
outdoc,
'pycbc', {},
ifos=ifos,
comment='',
version=pycbc_version.git_hash,
cvs_repository='pycbc/' + pycbc_version.git_branch,
cvs_entry_time=pycbc_version.date).process_id
search_summ_table = lsctables.New(lsctables.SearchSummaryTable)
coinc_h5file = self.coinc_file.h5file
try:
start_time = coinc_h5file['segments']['coinc']['start'][:].min()
end_time = coinc_h5file['segments']['coinc']['end'][:].max()
except KeyError:
start_times = []
end_times = []
for ifo_comb in coinc_h5file['segments']:
if ifo_comb == 'foreground_veto':
continue
seg_group = coinc_h5file['segments'][ifo_comb]
start_times.append(seg_group['start'][:].min())
end_times.append(seg_group['end'][:].max())
start_time = min(start_times)
end_time = max(end_times)
num_trigs = len(self.sort_arr)
search_summary = return_search_summary(start_time, end_time, num_trigs,
ifos)
search_summ_table.append(search_summary)
outdoc.childNodes[0].appendChild(search_summ_table)
sngl_inspiral_table = lsctables.New(lsctables.SnglInspiralTable)
coinc_def_table = lsctables.New(lsctables.CoincDefTable)
coinc_event_table = lsctables.New(lsctables.CoincTable)
coinc_inspiral_table = lsctables.New(lsctables.CoincInspiralTable)
coinc_event_map_table = lsctables.New(lsctables.CoincMapTable)
time_slide_table = lsctables.New(lsctables.TimeSlideTable)
# Set up time_slide table
time_slide_id = lsctables.TimeSlideID(0)
for ifo in ifos:
time_slide_row = lsctables.TimeSlide()
time_slide_row.instrument = ifo
time_slide_row.time_slide_id = time_slide_id
time_slide_row.offset = 0
time_slide_row.process_id = proc_id
time_slide_table.append(time_slide_row)
# Set up coinc_definer table
coinc_def_id = lsctables.CoincDefID(0)
coinc_def_row = lsctables.CoincDef()
coinc_def_row.search = "inspiral"
coinc_def_row.description = \
"sngl_inspiral<-->sngl_inspiral coincidences"
coinc_def_row.coinc_def_id = coinc_def_id
coinc_def_row.search_coinc_type = 0
coinc_def_table.append(coinc_def_row)
bank_col_names = ['mass1', 'mass2', 'spin1z', 'spin2z']
bank_col_vals = {}
for name in bank_col_names:
bank_col_vals[name] = self.get_bankfile_array(name)
coinc_event_names = ['ifar', 'time', 'fap', 'stat']
coinc_event_vals = {}
for name in coinc_event_names:
if name == 'time':
coinc_event_vals[name] = self.get_end_time()
else:
coinc_event_vals[name] = self.get_coincfile_array(name)
sngl_col_names = [
'snr', 'chisq', 'chisq_dof', 'bank_chisq', 'bank_chisq_dof',
'cont_chisq', 'cont_chisq_dof', 'end_time', 'template_duration',
'coa_phase', 'sigmasq'
]
sngl_col_vals = {}
for name in sngl_col_names:
sngl_col_vals[name] = self.get_snglfile_array_dict(name)
sngl_event_count = 0
for idx in range(len(self.sort_arr)):
# Set up IDs and mapping values
coinc_id = lsctables.CoincID(idx)
# Set up sngls
# FIXME: As two-ifo is hardcoded loop over all ifos
sngl_combined_mchirp = 0
sngl_combined_mtot = 0
net_snrsq = 0
for ifo in ifos:
# If this ifo is not participating in this coincidence then
# ignore it and move on.
if not sngl_col_vals['snr'][ifo][1][idx]:
continue
event_id = lsctables.SnglInspiralID(sngl_event_count)
sngl_event_count += 1
sngl = return_empty_sngl()
sngl.event_id = event_id
sngl.ifo = ifo
net_snrsq += sngl_col_vals['snr'][ifo][0][idx]**2
for name in sngl_col_names:
val = sngl_col_vals[name][ifo][0][idx]
if name == 'end_time':
sngl.set_end(LIGOTimeGPS(val))
else:
setattr(sngl, name, val)
for name in bank_col_names:
val = bank_col_vals[name][idx]
setattr(sngl, name, val)
sngl.mtotal, sngl.eta = pnutils.mass1_mass2_to_mtotal_eta(
sngl.mass1, sngl.mass2)
sngl.mchirp, _ = pnutils.mass1_mass2_to_mchirp_eta(
sngl.mass1, sngl.mass2)
sngl.eff_distance = (sngl.sigmasq)**0.5 / sngl.snr
sngl_combined_mchirp += sngl.mchirp
sngl_combined_mtot += sngl.mtotal
sngl_inspiral_table.append(sngl)
# Set up coinc_map entry
coinc_map_row = lsctables.CoincMap()
coinc_map_row.table_name = 'sngl_inspiral'
coinc_map_row.coinc_event_id = coinc_id
coinc_map_row.event_id = event_id
coinc_event_map_table.append(coinc_map_row)
sngl_combined_mchirp = sngl_combined_mchirp / len(ifos)
sngl_combined_mtot = sngl_combined_mtot / len(ifos)
# Set up coinc inspiral and coinc event tables
coinc_event_row = lsctables.Coinc()
coinc_inspiral_row = lsctables.CoincInspiral()
coinc_event_row.coinc_def_id = coinc_def_id
coinc_event_row.nevents = len(ifos)
coinc_event_row.instruments = ','.join(ifos)
coinc_inspiral_row.set_ifos(ifos)
coinc_event_row.time_slide_id = time_slide_id
coinc_event_row.process_id = proc_id
coinc_event_row.coinc_event_id = coinc_id
coinc_inspiral_row.coinc_event_id = coinc_id
coinc_inspiral_row.mchirp = sngl_combined_mchirp
coinc_inspiral_row.mass = sngl_combined_mtot
coinc_inspiral_row.set_end(
LIGOTimeGPS(coinc_event_vals['time'][idx]))
coinc_inspiral_row.snr = net_snrsq**0.5
coinc_inspiral_row.false_alarm_rate = coinc_event_vals['fap'][idx]
coinc_inspiral_row.combined_far = 1. / coinc_event_vals['ifar'][idx]
# Transform to Hz
coinc_inspiral_row.combined_far = \
coinc_inspiral_row.combined_far / YRJUL_SI
coinc_event_row.likelihood = coinc_event_vals['stat'][idx]
coinc_inspiral_row.minimum_duration = 0.
coinc_event_table.append(coinc_event_row)
coinc_inspiral_table.append(coinc_inspiral_row)
outdoc.childNodes[0].appendChild(coinc_def_table)
outdoc.childNodes[0].appendChild(coinc_event_table)
outdoc.childNodes[0].appendChild(coinc_event_map_table)
outdoc.childNodes[0].appendChild(time_slide_table)
outdoc.childNodes[0].appendChild(coinc_inspiral_table)
outdoc.childNodes[0].appendChild(sngl_inspiral_table)
ligolw_utils.write_filename(outdoc, file_name)
cart_grid2 /= lal.LAL_MSUN_SI
#np.savetxt("m1_m2_pts.txt", cart_grid2)
Njobs = int(np.ceil(len(cart_grid2) / float(pts_per_job)))
cart_grid3 = np.array_split(cart_grid2, Njobs)
for i in range(Njobs):
fname = "m1_m2_pts_%i.txt" % i
np.savetxt(fname, cart_grid3[i])
elapsed = elapsed_time() - elapsed
print("Time to distribute points, split and write to file:", elapsed)
#dag_utils.write_integrate_likelihood_extrinsic_sub('test')
#dag_utils.write_extrinsic_marginalization_dag(cart_grid2, 'test.sub')
xmldoc = ligolw.Document()
xmldoc.childNodes.append(ligolw.LIGO_LW())
#proc_id = process.register_to_xmldoc(xmldoc, sys.argv[0], opts.__dict__)
proc_id = process.register_to_xmldoc(xmldoc, sys.argv[0], {})
proc_id = proc_id.process_id
xmldoc.childNodes[0].appendChild(write_sngl_params(cart_grid3, proc_id))
utils.write_filename(xmldoc, "m1m2_grid.xml.gz", gz=True)
#
# N.B. Below here, the real code will divy up cart_grid into blocks of intrinsic
# parameters and compute the marginalized likelihood on each point
# in intrinsic parameter space
#
# For testing purposes, simply evaluate the overlap on cart_grid and plot
# to confirm it is placing points in the expected ellipsoid with the
# proper distribution, and the overlap behaves properly.
#
print "RUNNING DATAFIND"
datafinds, scienceSegs = _workflow.setup_datafind_workflow(
workflow, scienceSegs, dfDir, segsList)
# This is needed to know what times will be analysed by daily ahope
# Template bank stuff
banks = _workflow.setup_tmpltbank_workflow(workflow, scienceSegs, datafinds,
dfDir)
# Do matched-filtering
insps = _workflow.setup_matchedfltr_workflow(workflow, scienceSegs, datafinds,
banks, dfDir)
# Now construct the summary XML file
outdoc = ligolw.Document()
outdoc.appendChild(ligolw.LIGO_LW())
# FIXME: PROGRAM NAME and dictionary of opts should be variables defined up above
proc_id = ligolw_process.register_to_xmldoc(outdoc, 'dayhopetest',
vars(args)).process_id
for ifo in workflow.ifos:
# Lets get the segment lists we need
segIfoFiles = segsList.find_output_with_ifo(ifo)
# SCIENCE
sciSegFile = segIfoFiles.find_output_with_tag('SCIENCE')
assert (len(sciSegFile) == 1)
sciSegFile = sciSegFile[0]
sciSegs = sciSegFile.segmentList
# SCIENCE_OK
sciokSegFile = segIfoFiles.find_output_with_tag('SCIENCE_OK')
assert (len(sciokSegFile) == 1)
sciokSegFile = sciokSegFile[0]
def make_exttrig_file(cp, ifos, sci_seg, out_dir):
'''
Make an ExtTrig xml file containing information on the external trigger
Parameters
----------
cp : pycbc.workflow.configuration.WorkflowConfigParser object
The parsed configuration options of a pycbc.workflow.core.Workflow.
ifos : str
String containing the analysis interferometer IDs.
sci_seg : glue.segments.segment
The science segment for the analysis run.
out_dir : str
The output directory, destination for xml file.
Returns
-------
xml_file : pycbc.workflow.File object
The xml file with external trigger information.
'''
# Initialise objects
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
tbl = lsctables.New(lsctables.ExtTriggersTable)
cols = tbl.validcolumns
xmldoc.childNodes[-1].appendChild(tbl)
row = tbl.appendRow()
# Add known attributes for this GRB
setattr(row, "event_ra", float(cp.get("workflow", "ra")))
setattr(row, "event_dec", float(cp.get("workflow", "dec")))
setattr(row, "start_time", int(cp.get("workflow", "trigger-time")))
setattr(row, "event_number_grb", str(cp.get("workflow", "trigger-name")))
# Fill in all empty rows
for entry in cols.keys():
if not hasattr(row, entry):
if cols[entry] in ['real_4', 'real_8']:
setattr(row, entry, 0.)
elif cols[entry] == 'int_4s':
setattr(row, entry, 0)
elif cols[entry] == 'lstring':
setattr(row, entry, '')
elif entry == 'process_id':
row.process_id = ilwd.ilwdchar("external_trigger:process_id:0")
elif entry == 'event_id':
row.event_id = ilwd.ilwdchar("external_trigger:event_id:0")
else:
print >> sys.stderr, "Column %s not recognized" % (entry)
raise ValueError
# Save file
xml_file_name = "triggerGRB%s.xml" % str(cp.get("workflow",
"trigger-name"))
xml_file_path = os.path.join(out_dir, xml_file_name)
utils.write_filename(xmldoc, xml_file_path)
xml_file_url = urlparse.urljoin("file:",
urllib.pathname2url(xml_file_path))
xml_file = File(ifos, xml_file_name, sci_seg, file_url=xml_file_url)
xml_file.PFN(xml_file_url, site="local")
return xml_file
def table_to_document(table):
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
xmldoc.childNodes[0].appendChild(table)
return xmldoc
