def upload(self, fname, psds, low_frequency_cutoff, testing=True):
"""Upload this trigger to gracedb
Parameters
----------
fname: str
The name to give the xml file associated with this trigger
pds: dict of pybc.types.FrequencySeries
A ifo keyed dictionary of psds to be uploaded in association
with this trigger.
low_frequency_cutoff: float
The low frequency cutoff of the psds.
testing: bool
Switch to determine if the upload should be sent to gracedb as a
test trigger (True) or a production trigger (False)
"""
from ligo.gracedb.rest import GraceDb
import lal
import lal.series
self.save(fname)
if testing:
group = 'Test'
else:
group = 'CBC'
gracedb = GraceDb()
r = gracedb.createEvent(group, "pycbc", fname, "AllSky").json()
logging.info("Uploaded event %s.", r["graceid"])
if self.is_hardware_injection:
gracedb.writeLabel(r['graceid'], 'INJ')
logging.info("Tagging event %s as an injection", r["graceid"])
# Convert our psds to the xml psd format.
# FIXME: we should not use lal.series!!!
psds_lal = {}
for ifo in psds:
psd = psds[ifo]
kmin = int(low_frequency_cutoff / psd.delta_f)
fseries = lal.CreateREAL8FrequencySeries(
"psd", psd.epoch, low_frequency_cutoff, psd.delta_f,
lal.StrainUnit**2 / lal.HertzUnit,
len(psd) - kmin)
fseries.data.data = psd.numpy()[kmin:] / pycbc.DYN_RANGE_FAC**2.0
psds_lal[ifo] = fseries
psd_xmldoc = lal.series.make_psd_xmldoc(psds_lal)
ligolw_utils.write_filename(psd_xmldoc, "tmp_psd.xml.gz", gz=True)
gracedb.writeLog(r["graceid"],
"PyCBC PSD estimate from the time of event",
"psd.xml.gz",
open("tmp_psd.xml.gz", "rb").read(), "psd").json()
logging.info("Uploaded file psd.xml.gz to event %s.", r["graceid"])
def upload(self, fname, psds, low_frequency_cutoff, testing=True):
"""Upload this trigger to gracedb
Parameters
----------
fname: str
The name to give the xml file associated with this trigger
pds: dict of pybc.types.FrequencySeries
A ifo keyed dictionary of psds to be uploaded in association
with this trigger.
low_frequency_cutoff: float
The low frequency cutoff of the psds.
testing: bool
Switch to determine if the upload should be sent to gracedb as a
test trigger (True) or a production trigger (False)
"""
from ligo.gracedb.rest import GraceDb
import lal
import lal.series
self.save(fname)
if testing:
group = 'Test'
else:
group = 'CBC'
gracedb = GraceDb()
r = gracedb.createEvent(group, "pycbc", fname, "AllSky").json()
logging.info("Uploaded event %s.", r["graceid"])
if self.is_hardware_injection:
gracedb.writeLabel(r['graceid'], 'INJ')
logging.info("Tagging event %s as an injection", r["graceid"])
# Convert our psds to the xml psd format.
# FIXME: we should not use lal.series!!!
psds_lal = {}
for ifo in psds:
psd = psds[ifo]
kmin = int(low_frequency_cutoff / psd.delta_f)
fseries = lal.CreateREAL8FrequencySeries(
"psd", psd.epoch, low_frequency_cutoff, psd.delta_f,
lal.StrainUnit**2 / lal.HertzUnit, len(psd) - kmin)
fseries.data.data = psd.numpy()[kmin:] / pycbc.DYN_RANGE_FAC ** 2.0
psds_lal[ifo] = fseries
psd_xmldoc = lal.series.make_psd_xmldoc(psds_lal)
ligolw_utils.write_filename(psd_xmldoc, "tmp_psd.xml.gz", gz=True)
gracedb.writeLog(r["graceid"],
"PyCBC PSD estimate from the time of event",
"psd.xml.gz", open("tmp_psd.xml.gz", "rb").read(),
"psd").json()
logging.info("Uploaded file psd.xml.gz to event %s.", r["graceid"])
def upload(self, fname, gracedb_server=None, testing=True,
extra_strings=None):
"""Upload this trigger to gracedb
Parameters
----------
fname: str
The name to give the xml file associated with this trigger
gracedb_server: string, optional
URL to the GraceDB web API service for uploading the event.
If omitted, the default will be used.
testing: bool
Switch to determine if the upload should be sent to gracedb as a
test trigger (True) or a production trigger (False).
"""
from ligo.gracedb.rest import GraceDb
import matplotlib
matplotlib.use('Agg')
import pylab
# first of all, make sure the event is saved on disk
# as GraceDB operations can fail later
self.save(fname)
if self.snr_series is not None:
if fname.endswith('.xml.gz'):
snr_series_fname = fname.replace('.xml.gz', '.hdf')
else:
snr_series_fname = fname.replace('.xml', '.hdf')
snr_series_plot_fname = snr_series_fname.replace('.hdf',
'_snr.png')
psd_series_plot_fname = snr_series_fname.replace('.hdf',
'_psd.png')
pylab.figure()
for ifo in self.snr_series:
curr_snrs = self.snr_series[ifo]
curr_snrs.save(snr_series_fname, group='%s/snr' % ifo)
pylab.plot(curr_snrs.sample_times, abs(curr_snrs),
c=ifo_color(ifo), label=ifo)
if ifo in self.ifos:
snr = self.coinc_results['foreground/%s/%s' %
(ifo, 'snr')]
endt = self.coinc_results['foreground/%s/%s' %
(ifo, 'end_time')]
pylab.plot([endt], [snr], c=ifo_color(ifo), marker='x')
pylab.legend()
pylab.xlabel('GPS time (s)')
pylab.ylabel('SNR')
pylab.savefig(snr_series_plot_fname)
pylab.close()
pylab.figure()
for ifo in self.snr_series:
# Undo dynamic range factor
curr_psd = self.psds[ifo].astype(numpy.float64)
curr_psd /= pycbc.DYN_RANGE_FAC ** 2.0
curr_psd.save(snr_series_fname, group='%s/psd' % ifo)
# Can't plot log(0) so start from point 1
pylab.loglog(curr_psd.sample_frequencies[1:],
curr_psd[1:]**0.5, c=ifo_color(ifo), label=ifo)
pylab.legend()
pylab.xlim([20, 2000])
pylab.ylim([1E-24, 1E-21])
pylab.xlabel('Frequency (Hz)')
pylab.ylabel('ASD')
pylab.savefig(psd_series_plot_fname)
gid = None
try:
# try connecting to GraceDB
gracedb = GraceDb(gracedb_server) \
if gracedb_server is not None else GraceDb()
# create GraceDB event
group = 'Test' if testing else 'CBC'
r = gracedb.createEvent(group, "pycbc", fname, "AllSky").json()
gid = r["graceid"]
logging.info("Uploaded event %s", gid)
if self.is_hardware_injection:
gracedb.writeLabel(gid, 'INJ')
logging.info("Tagging event %s as an injection", gid)
# upload PSDs. Note that the PSDs are already stored in the
# original event file and we just upload a copy of that same file
# here. This keeps things as they were in O2 and can be removed
# after updating the follow-up infrastructure
psd_fname = 'psd.xml.gz' if fname.endswith('.gz') else 'psd.xml'
gracedb.writeLog(gid, "PyCBC PSD estimate from the time of event",
psd_fname, open(fname, "rb").read(), "psd")
logging.info("Uploaded PSDs for event %s", gid)
# add other tags and comments
gracedb.writeLog(
gid, "Using PyCBC code hash %s" % pycbc_version.git_hash)
extra_strings = [] if extra_strings is None else extra_strings
for text in extra_strings:
gracedb.writeLog(gid, text)
# upload SNR series in HDF format and plots
if self.snr_series is not None:
gracedb.writeLog(gid, 'SNR timeseries HDF file upload',
filename=snr_series_fname)
gracedb.writeLog(gid, 'SNR timeseries plot upload',
filename=snr_series_plot_fname,
tag_name=['background'],
displayName=['SNR timeseries'])
gracedb.writeLog(gid, 'PSD plot upload',
filename=psd_series_plot_fname,
tag_name=['psd'], displayName=['PSDs'])
except Exception as exc:
logging.error('Something failed during the upload/annotation of '
'event %s on GraceDB. The event may not have been '
'uploaded!', fname)
logging.error(str(exc))
return gid
def upload(self, fname, gracedb_server=None, testing=True,
extra_strings=None):
"""Upload this trigger to gracedb
Parameters
----------
fname: str
The name to give the xml file associated with this trigger
gracedb_server: string, optional
URL to the GraceDB web API service for uploading the event.
If omitted, the default will be used.
testing: bool
Switch to determine if the upload should be sent to gracedb as a
test trigger (True) or a production trigger (False).
"""
from ligo.gracedb.rest import GraceDb
import matplotlib
matplotlib.use('Agg')
import pylab
# first of all, make sure the event is saved on disk
# as GraceDB operations can fail later
self.save(fname)
if self.snr_series is not None:
if fname.endswith('.xml.gz'):
snr_series_fname = fname.replace('.xml.gz', '.hdf')
else:
snr_series_fname = fname.replace('.xml', '.hdf')
snr_series_plot_fname = snr_series_fname.replace('.hdf',
'_snr.png')
psd_series_plot_fname = snr_series_fname.replace('.hdf',
'_psd.png')
pylab.figure()
for ifo in sorted(self.snr_series):
curr_snrs = self.snr_series[ifo]
curr_snrs.save(snr_series_fname, group='%s/snr' % ifo)
pylab.plot(curr_snrs.sample_times, abs(curr_snrs),
c=ifo_color(ifo), label=ifo)
if ifo in self.ifos:
snr = self.coinc_results['foreground/%s/%s' %
(ifo, 'snr')]
endt = self.coinc_results['foreground/%s/%s' %
(ifo, 'end_time')]
pylab.plot([endt], [snr], c=ifo_color(ifo), marker='x')
pylab.legend()
pylab.xlabel('GPS time (s)')
pylab.ylabel('SNR')
pylab.savefig(snr_series_plot_fname)
pylab.close()
pylab.figure()
for ifo in sorted(self.snr_series):
# Undo dynamic range factor
curr_psd = self.psds[ifo].astype(numpy.float64)
curr_psd /= pycbc.DYN_RANGE_FAC ** 2.0
curr_psd.save(snr_series_fname, group='%s/psd' % ifo)
# Can't plot log(0) so start from point 1
pylab.loglog(curr_psd.sample_frequencies[1:],
curr_psd[1:]**0.5, c=ifo_color(ifo), label=ifo)
pylab.legend()
pylab.xlim([10, 1300])
pylab.ylim([3E-24, 1E-20])
pylab.xlabel('Frequency (Hz)')
pylab.ylabel('ASD')
pylab.savefig(psd_series_plot_fname)
pylab.close()
if self.probabilities is not None:
prob_fname = fname.replace('.xml.gz', '_probs.json')
prob_plot_fname = prob_fname.replace('.json', '.png')
prob_plot = {k: v for (k, v) in self.probabilities.items()
if v != 0.0}
labels, sizes = zip(*prob_plot.items())
colors = [source_color(label) for label in labels]
fig, ax = pylab.subplots()
ax.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
textprops={'fontsize': 15})
ax.axis('equal')
fig.savefig(prob_plot_fname)
pylab.close()
gid = None
try:
# try connecting to GraceDB
gracedb = GraceDb(gracedb_server) \
if gracedb_server is not None else GraceDb()
# create GraceDB event
group = 'Test' if testing else 'CBC'
r = gracedb.createEvent(group, "pycbc", fname, "AllSky").json()
gid = r["graceid"]
logging.info("Uploaded event %s", gid)
if self.is_hardware_injection:
gracedb.writeLabel(gid, 'INJ')
logging.info("Tagging event %s as an injection", gid)
# upload PSDs. Note that the PSDs are already stored in the
# original event file and we just upload a copy of that same file
# here. This keeps things as they were in O2 and can be removed
# after updating the follow-up infrastructure
psd_fname = 'psd.xml.gz' if fname.endswith('.gz') else 'psd.xml'
gracedb.writeLog(gid, "PyCBC PSD estimate from the time of event",
psd_fname, open(fname, "rb").read(), "psd")
logging.info("Uploaded PSDs for event %s", gid)
# add info for tracking code version
version_str = 'Using PyCBC version {}{} at {}'
version_str = version_str.format(
pycbc_version.version,
' (release)' if pycbc_version.release else '',
os.path.dirname(pycbc.__file__))
gracedb.writeLog(gid, version_str)
extra_strings = [] if extra_strings is None else extra_strings
for text in extra_strings:
gracedb.writeLog(gid, text, tag_name=['analyst_comments'])
# upload SNR series in HDF format and plots
if self.snr_series is not None:
gracedb.writeLog(gid, 'SNR timeseries HDF file upload',
filename=snr_series_fname)
gracedb.writeLog(gid, 'SNR timeseries plot upload',
filename=snr_series_plot_fname,
tag_name=['background'],
displayName=['SNR timeseries'])
gracedb.writeLog(gid, 'PSD plot upload',
filename=psd_series_plot_fname,
tag_name=['psd'], displayName=['PSDs'])
# upload source probabilities in json format and plot
if self.probabilities is not None:
gracedb.writeLog(gid, 'source probabilities JSON file upload',
filename=prob_fname, tag_name=['em_follow'])
logging.info('Uploaded source probabilities for event %s', gid)
gracedb.writeLog(gid, 'source probabilities plot upload',
filename=prob_plot_fname,
tag_name=['em_follow'])
logging.info('Uploaded source probabilities pie chart for '
'event %s', gid)
except Exception as exc:
logging.error('Something failed during the upload/annotation of '
'event %s on GraceDB. The event may not have been '
'uploaded!', fname)
logging.error(str(exc))
return gid
def upload(self, fname, gracedb_server=None, testing=True,
extra_strings=None):
"""Upload this trigger to gracedb
Parameters
----------
fname: str
The name to give the xml file associated with this trigger
gracedb_server: string, optional
URL to the GraceDB web API service for uploading the event.
If omitted, the default will be used.
testing: bool
Switch to determine if the upload should be sent to gracedb as a
test trigger (True) or a production trigger (False).
"""
from ligo.gracedb.rest import GraceDb
# first of all, make sure the event is saved on disk
# as GraceDB operations can fail later
self.save(fname)
if self.snr_series is not None:
if fname.endswith('.xml.gz'):
snr_series_fname = fname.replace('.xml.gz', '.hdf')
else:
snr_series_fname = fname.replace('.xml', '.hdf')
for ifo in self.snr_series:
self.snr_series[ifo].save(snr_series_fname,
group='%s/snr' % ifo)
self.psds[ifo].save(snr_series_fname,
group='%s/psd' % ifo)
gid = None
try:
# try connecting to GraceDB
gracedb = GraceDb(gracedb_server) \
if gracedb_server is not None else GraceDb()
# create GraceDB event
group = 'Test' if testing else 'CBC'
r = gracedb.createEvent(group, "pycbc", fname, "AllSky").json()
gid = r["graceid"]
logging.info("Uploaded event %s", gid)
if self.is_hardware_injection:
gracedb.writeLabel(gid, 'INJ')
logging.info("Tagging event %s as an injection", gid)
# upload PSDs. Note that the PSDs are already stored in the
# original event file and we just upload a copy of that same file
# here. This keeps things as they were in O2 and can be removed
# after updating the follow-up infrastructure
psd_fname = 'psd.xml.gz' if fname.endswith('.gz') else 'psd.xml'
gracedb.writeLog(gid, "PyCBC PSD estimate from the time of event",
psd_fname, open(fname, "rb").read(), "psd")
logging.info("Uploaded PSDs for event %s", gid)
# add other tags and comments
gracedb.writeLog(
gid, "Using PyCBC code hash %s" % pycbc_version.git_hash)
extra_strings = [] if extra_strings is None else extra_strings
for text in extra_strings:
gracedb.writeLog(gid, text)
# upload SNR series in HDF format
if self.snr_series is not None:
gracedb.writeFile(gid, snr_series_fname)
except Exception as exc:
logging.error('Something failed during the upload/annotation of '
'event %s on GraceDB. The event may not have been '
'uploaded!', fname)
logging.error(str(exc))
return gid
for event in dictionary:
if dictionary[event]['FAR'] <= FAR_thresh:
#if FAR threshold is exceeded, write trigtimes and timeslides to files
e_new += 1
rr_trigtimes.write('%s\n'%dictionary[event]['gpstime'])
rr_timeslides.write('%s\n'%" ".join([dictionary[event]['timeslides'][ifo] for ifo in ifos]))
#If event is 0-lag, write to GraceDb if enabled
if lag == '0lag' and gdb_flag:
#Save dictionary as json file
dic_path = rundir+'/GDB/%s.json'%('%s-%s'%(dictionary[event]['gpstime'],event))
with open(dic_path, 'wt') as fp:
json.dump(dictionary[event], fp)
#Upload dictionary to GraceDb
response = gdb.createEvent('Burst','LIB',dic_path, search='AllSky', filecontents=None)
#Parse GraceDb ID
response = json.loads(response.read())
gid = str(response["graceid"])
#Update GraceDb log with post-proc pages
# gdb.writeLog(gid, message="Preliminary results: f_0 = %s, Q = %s"%(dictionary[event]['frequency'],dictionary[event]['quality']))
gdb.writeLog(gid, message="Preliminary results: BSN = %s, BCI = %s, oSNR = %s"%(dictionary[event]['BSN'],dictionary[event]['BCI'],dictionary[event]['Omicron SNR']))
gdb.writeLog(gid, message="Follow-up results will be written: https://ldas-jobs.ligo.caltech.edu/~ryan.lynch/%s/%s/followup/%s/%s/%s/posplots.html"%(lib_label,lag,'%s_%s_%s'%("".join(ifos),actual_start,stride-overlap),'%s-%s'%(dictionary[event]['gpstime'],e_new),"".join(ifos)))
rr_trigtimes.close()
rr_timeslides.close()
#run pipeline to make dag for reruns
os.system('%s/lalinference_2ndpipe_beta.py %s/runfiles/LIB_%s_reruns_beta.ini -r %s/LIB_%s_rr/ -p /usr1/ryan.lynch/logs/ -g %s/PostProc/LIB_trigs/LIB_%s_times_rr_%s.txt'%(infodir, rundir, lag, rundir, lag, rundir, lag, "".join(ifos)))
def upload(
self,
fname,
psds,
low_frequency_cutoff,
testing=True,
extra_strings=None,
):
"""Upload this trigger to gracedb
Parameters
----------
fname: str
The name to give the xml file associated with this trigger
pds: dict of pybc.types.FrequencySeries
A ifo keyed dictionary of psds to be uploaded in association
with this trigger.
low_frequency_cutoff: float
The low frequency cutoff of the psds.
testing: bool
Switch to determine if the upload should be sent to gracedb as a
test trigger (True) or a production trigger (False)
"""
from ligo.gracedb.rest import GraceDb
self.save(fname)
extra_strings = [] if extra_strings is None else extra_strings
if testing:
group = 'Test'
else:
group = 'CBC'
gracedb = GraceDb()
r = gracedb.createEvent(group, "pycbc", fname, "AllSky").json()
logging.info("Uploaded event %s.", r["graceid"])
if self.is_hardware_injection:
gracedb.writeLabel(r['graceid'], 'INJ')
logging.info("Tagging event %s as an injection", r["graceid"])
psds_lal = {}
for ifo in psds:
psd = psds[ifo]
kmin = int(low_frequency_cutoff / psd.delta_f)
fseries = lal.CreateREAL8FrequencySeries(
"psd", psd.epoch, low_frequency_cutoff, psd.delta_f,
lal.StrainUnit**2 / lal.HertzUnit,
len(psd) - kmin)
fseries.data.data = psd.numpy()[kmin:] / pycbc.DYN_RANGE_FAC**2.0
psds_lal[ifo] = fseries
psd_xmldoc = make_psd_xmldoc(psds_lal)
ligolw_utils.write_filename(psd_xmldoc, "tmp_psd.xml.gz", gz=True)
gracedb.writeLog(r["graceid"],
"PyCBC PSD estimate from the time of event",
"psd.xml.gz",
open("tmp_psd.xml.gz", "rb").read(), "psd").json()
gracedb.writeLog(r["graceid"], "using pycbc code hash %s" %
pycbc_version.git_hash).json()
for text in extra_strings:
gracedb.writeLog(r["graceid"], text).json()
logging.info("Uploaded file psd.xml.gz to event %s.", r["graceid"])
if self.upload_snr_series:
snr_series_fname = fname + '.hdf'
for ifo in self.snr_series:
self.snr_series[ifo].save(snr_series_fname,
group='%s/snr' % ifo)
self.snr_series_psd[ifo].save(snr_series_fname,
group='%s/psd' % ifo)
GraceDb().writeFile(r['graceid'], snr_series_fname)
return r['graceid']
def upload(self,
fname,
gracedb_server=None,
testing=True,
extra_strings=None,
search='AllSky'):
"""Upload this trigger to gracedb
Parameters
----------
fname: str
The name to give the xml file associated with this trigger
gracedb_server: string, optional
URL to the GraceDB web API service for uploading the event.
If omitted, the default will be used.
testing: bool
Switch to determine if the upload should be sent to gracedb as a
test trigger (True) or a production trigger (False).
search: str
String going into the "search" field of the GraceDB event.
"""
from ligo.gracedb.rest import GraceDb
import matplotlib
matplotlib.use('Agg')
import pylab as pl
# first of all, make sure the event is saved on disk
# as GraceDB operations can fail later
self.save(fname)
gid = None
try:
# try connecting to GraceDB
gracedb = GraceDb(gracedb_server) \
if gracedb_server is not None else GraceDb()
# create GraceDB event
group = 'Test' if testing else 'CBC'
r = gracedb.createEvent(group, "pycbc", fname, search).json()
gid = r["graceid"]
logging.info("Uploaded event %s", gid)
if self.is_hardware_injection:
gracedb.writeLabel(gid, 'INJ')
logging.info("Tagging event %s as an injection", gid)
# add info for tracking code version
gracedb_tag_with_version(gracedb, gid)
extra_strings = [] if extra_strings is None else extra_strings
for text in extra_strings:
gracedb.writeLog(gid, text, tag_name=['analyst_comments'])
except Exception as exc:
logging.error(
'Something failed during the upload/annotation of '
'event %s on GraceDB. The event may not have been '
'uploaded!', fname)
logging.error(str(exc))
# plot the SNR timeseries and noise PSDs
if self.snr_series is not None:
if fname.endswith('.xml.gz'):
snr_series_fname = fname.replace('.xml.gz', '.hdf')
else:
snr_series_fname = fname.replace('.xml', '.hdf')
snr_series_plot_fname = snr_series_fname.replace(
'.hdf', '_snr.png')
asd_series_plot_fname = snr_series_fname.replace(
'.hdf', '_asd.png')
pl.figure()
ref_time = int(self.merger_time)
for ifo in sorted(self.snr_series):
curr_snrs = self.snr_series[ifo]
curr_snrs.save(snr_series_fname, group='%s/snr' % ifo)
pl.plot(curr_snrs.sample_times - ref_time,
abs(curr_snrs),
c=ifo_color(ifo),
label=ifo)
if ifo in self.ifos:
base = 'foreground/{}/'.format(ifo)
snr = self.coinc_results[base + 'snr']
mt = (self.coinc_results[base + 'end_time'] +
self.time_offset)
pl.plot([mt - ref_time], [snr],
c=ifo_color(ifo),
marker='x')
pl.legend()
pl.xlabel('GPS time from {:d} (s)'.format(ref_time))
pl.ylabel('SNR')
pl.savefig(snr_series_plot_fname)
pl.close()
generate_asd_plot(self.psds, asd_series_plot_fname)
# Additionally save the PSDs into the snr_series file
for ifo in sorted(self.psds):
# Undo dynamic range factor
curr_psd = self.psds[ifo].astype(numpy.float64)
curr_psd /= pycbc.DYN_RANGE_FAC**2.0
curr_psd.save(snr_series_fname, group='%s/psd' % ifo)
if self.probabilities is not None:
prob_fname = fname.replace('.xml.gz', '_probs.json')
prob_plot_fname = prob_fname.replace('.json', '.png')
prob_plot = {
k: v
for (k, v) in self.probabilities.items() if v != 0.0
}
labels, sizes = zip(*prob_plot.items())
colors = [source_color(label) for label in labels]
fig, ax = pl.subplots()
ax.pie(sizes,
labels=labels,
colors=colors,
autopct='%1.1f%%',
textprops={'fontsize': 15})
ax.axis('equal')
fig.savefig(prob_plot_fname)
pl.close()
# upload SNR series in HDF format and plots
if gid is not None and self.snr_series is not None:
try:
gracedb.writeLog(gid,
'SNR timeseries HDF file upload',
filename=snr_series_fname)
gracedb.writeLog(gid,
'SNR timeseries plot upload',
filename=snr_series_plot_fname,
tag_name=['background'],
displayName=['SNR timeseries'])
gracedb.writeLog(gid,
'ASD plot upload',
filename=asd_series_plot_fname,
tag_name=['psd'],
displayName=['ASDs'])
except Exception as exc:
logging.error('Failed to upload plots for %s', gid)
logging.error(str(exc))
# upload source probabilities in JSON format and plot
if gid is not None and self.probabilities is not None:
try:
gracedb.writeLog(gid,
'Source probabilities JSON file upload',
filename=prob_fname,
tag_name=['em_follow'])
logging.info('Uploaded source probabilities for event %s', gid)
gracedb.writeLog(gid,
'Source probabilities plot upload',
filename=prob_plot_fname,
tag_name=['em_follow'])
logging.info(
'Uploaded source probabilities pie chart for '
'event %s', gid)
except Exception as exc:
logging.error(
'Failed to upload source probability results for %s', gid)
logging.error(str(exc))
return gid
def upload(
self,
fname,
psds,
low_frequency_cutoff,
testing=True,
extra_strings=None,
):
"""Upload this trigger to gracedb
Parameters
----------
fname: str
The name to give the xml file associated with this trigger
pds: dict of pybc.types.FrequencySeries
A ifo keyed dictionary of psds to be uploaded in association
with this trigger.
low_frequency_cutoff: float
The low frequency cutoff of the psds.
testing: bool
Switch to determine if the upload should be sent to gracedb as a
test trigger (True) or a production trigger (False)
"""
from ligo.gracedb.rest import GraceDb
# first of all, make sure the event and PSDs are saved on disk
# as GraceDB operations can fail later
self.save(fname)
psds_lal = {}
for ifo in psds:
psd = psds[ifo]
kmin = int(low_frequency_cutoff / psd.delta_f)
fseries = lal.CreateREAL8FrequencySeries(
"psd", psd.epoch, low_frequency_cutoff, psd.delta_f,
lal.StrainUnit**2 / lal.HertzUnit,
len(psd) - kmin)
fseries.data.data = psd.numpy()[kmin:] / pycbc.DYN_RANGE_FAC**2.0
psds_lal[ifo] = fseries
psd_xmldoc = make_psd_xmldoc(psds_lal)
psd_xml_path = os.path.splitext(fname)[0] + '-psd.xml.gz'
ligolw_utils.write_filename(psd_xmldoc, psd_xml_path, gz=True)
if self.upload_snr_series:
snr_series_fname = os.path.splitext(fname)[0] + '.hdf'
for ifo in self.snr_series:
self.snr_series[ifo].save(snr_series_fname,
group='%s/snr' % ifo)
self.snr_series_psd[ifo].save(snr_series_fname,
group='%s/psd' % ifo)
# try connecting to GraceDB
try:
gracedb = GraceDb(self.gracedb_server) \
if self.gracedb_server is not None else GraceDb()
except Exception as exc:
logging.error('Cannot connect to GraceDB')
logging.error(str(exc))
logging.error('Carrying on, but event %s will NOT be uploaded!',
fname)
return None
# create GraceDB event
group = 'Test' if testing else 'CBC'
try:
r = gracedb.createEvent(group, "pycbc", fname, "AllSky").json()
except Exception as exc:
logging.error('Cannot create GraceDB event')
logging.error(str(exc))
logging.error('Carrying on, but event %s will NOT be uploaded!',
fname)
return None
logging.info("Uploaded event %s", r["graceid"])
if self.is_hardware_injection:
try:
gracedb.writeLabel(r['graceid'], 'INJ')
except Exception as exc:
logging.error("Cannot tag event %s as an injection",
r["graceid"])
logging.error(str(exc))
logging.info("Tagging event %s as an injection", r["graceid"])
# upload PSDs
try:
gracedb.writeLog(r["graceid"],
"PyCBC PSD estimate from the time of event",
"psd.xml.gz",
open(psd_xml_path, "rb").read(), "psd").json()
except Exception as exc:
logging.error("Cannot upload PSDs for event %s", r["graceid"])
logging.error(str(exc))
logging.info("Uploaded PSDs for event %s", r["graceid"])
# add other tags and comments
try:
gracedb.writeLog(
r["graceid"],
"Using PyCBC code hash %s" % pycbc_version.git_hash).json()
extra_strings = [] if extra_strings is None else extra_strings
for text in extra_strings:
gracedb.writeLog(r["graceid"], text).json()
except Exception as exc:
logging.error("Cannot write comments for event %s", r["graceid"])
logging.error(str(exc))
# upload SNR series in HDF format
if self.upload_snr_series:
try:
gracedb.writeFile(r['graceid'], snr_series_fname)
except Exception as exc:
logging.error("Cannot upload HDF SNR series for event %s",
r["graceid"])
logging.error(str(exc))
return r['graceid']
def upload(self, fname, psds, low_frequency_cutoff,
testing=True,
extra_strings=None,
):
"""Upload this trigger to gracedb
Parameters
----------
fname: str
The name to give the xml file associated with this trigger
pds: dict of pybc.types.FrequencySeries
A ifo keyed dictionary of psds to be uploaded in association
with this trigger.
low_frequency_cutoff: float
The low frequency cutoff of the psds.
testing: bool
Switch to determine if the upload should be sent to gracedb as a
test trigger (True) or a production trigger (False)
"""
from ligo.gracedb.rest import GraceDb
# first of all, make sure the event and PSDs are saved on disk
# as GraceDB operations can fail later
self.save(fname)
psds_lal = {}
for ifo in psds:
psd = psds[ifo]
kmin = int(low_frequency_cutoff / psd.delta_f)
fseries = lal.CreateREAL8FrequencySeries(
"psd", psd.epoch, low_frequency_cutoff, psd.delta_f,
lal.StrainUnit**2 / lal.HertzUnit, len(psd) - kmin)
fseries.data.data = psd.numpy()[kmin:] / pycbc.DYN_RANGE_FAC ** 2.0
psds_lal[ifo] = fseries
psd_xmldoc = make_psd_xmldoc(psds_lal)
psd_xml_path = os.path.splitext(fname)[0] + '-psd.xml.gz'
ligolw_utils.write_filename(psd_xmldoc, psd_xml_path, gz=True)
if self.upload_snr_series:
snr_series_fname = os.path.splitext(fname)[0] + '.hdf'
for ifo in self.snr_series:
self.snr_series[ifo].save(snr_series_fname,
group='%s/snr' % ifo)
self.snr_series_psd[ifo].save(snr_series_fname,
group='%s/psd' % ifo)
# try connecting to GraceDB
try:
gracedb = GraceDb(self.gracedb_server) \
if self.gracedb_server is not None else GraceDb()
except Exception as exc:
logging.error('Cannot connect to GraceDB')
logging.error(str(exc))
logging.error('Carrying on, but event %s will NOT be uploaded!', fname)
return None
# create GraceDB event
group = 'Test' if testing else 'CBC'
try:
r = gracedb.createEvent(group, "pycbc", fname, "AllSky").json()
except Exception as exc:
logging.error('Cannot create GraceDB event')
logging.error(str(exc))
logging.error('Carrying on, but event %s will NOT be uploaded!', fname)
return None
logging.info("Uploaded event %s", r["graceid"])
if self.is_hardware_injection:
try:
gracedb.writeLabel(r['graceid'], 'INJ')
except Exception as exc:
logging.error("Cannot tag event %s as an injection", r["graceid"])
logging.error(str(exc))
logging.info("Tagging event %s as an injection", r["graceid"])
# upload PSDs
try:
gracedb.writeLog(r["graceid"],
"PyCBC PSD estimate from the time of event",
"psd.xml.gz", open(psd_xml_path, "rb").read(),
"psd").json()
except Exception as exc:
logging.error("Cannot upload PSDs for event %s", r["graceid"])
logging.error(str(exc))
logging.info("Uploaded PSDs for event %s", r["graceid"])
# add other tags and comments
try:
gracedb.writeLog(r["graceid"],
"Using PyCBC code hash %s" % pycbc_version.git_hash).json()
extra_strings = [] if extra_strings is None else extra_strings
for text in extra_strings:
gracedb.writeLog(r["graceid"], text).json()
except Exception as exc:
logging.error("Cannot write comments for event %s", r["graceid"])
logging.error(str(exc))
# upload SNR series in HDF format
if self.upload_snr_series:
try:
gracedb.writeFile(r['graceid'], snr_series_fname)
except Exception as exc:
logging.error("Cannot upload HDF SNR series for event %s",
r["graceid"])
logging.error(str(exc))
return r['graceid']
