def _read_omicron_trigs(omicron_files, span):
trigs1 = SnglBurstTable.read(omicron_files[0], format='ligolw')
trigs = table.new_from_template(trigs1)
for omicron_file in omicron_files:
trigs2 = table.new_from_template(trigs1)
trigs2 = SnglBurstTable.read(omicron_file, format='ligolw')
trigs.extend(filter(lambda row: row.get_peak() in span, trigs2))
times = []
print('%d found' % len(trigs))
times = trigs.get_peak()
s = times.size
return trigs, times, s
def vetoed(self, seglist, time_slide_table=None):
"""Return a MultiInspiralTable with those row from self lying
inside (i.e. vetoed by) any elements of seglist.
If time_slide_table is not None, any time shifts will be undone and each
detector checked individually
"""
seglist = type(seglist)(map(float, seglist))
vetoed = table.new_from_template(self)
if time_slide_table:
slides = time_slide_table.as_dict()
for id_, vector in slides.iteritems():
idx = str(id_).split(":")[-1]
slides["multi_inspiral:time_slide_id:%s" % idx] = vector
del slides[id_]
slides = get_slide_vectors(time_slide_table)
for row in self:
ifos = row.get_ifos()
for i, ifo in enumerate(ifos):
ifo_time = (float(row.get_end()) -
slides[str(row.time_slide_id)][ifo])
if ifo_time in seglist:
vetoed.append(row)
break
else:
for row in self:
time = float(row.get_end())
if time in seglist:
vetoed.append(row)
return vetoed
def apply_null_snr_veto(mi_table, null_snr=6.0, snr=20.0, grad=0.2,\
return_index=False):
"""Veto events in a MultiInspiralTable based on their null SNR.
@param mi_table
a MultiInspiralTable from which to veto events
@param null_snr
the value of null SNR on which to threshold
@param snr
the value of coherent SNR on above which to grade the null SNR
threshold
@param grad
the rate at which to increase the null SNR threshold above snr
@param return_index
boolean to return the index array of non-vetoed elements rather
than a new table containing the elements themselves
@returns
a new MultiInspiralTable with those events not vetoed OR
the indices of the original mi_table not vetoed if return_index=True
"""
mi_snr = mi_table.get_column("snr")
mi_null_snr = mi_table.get_null_snr()
# apply gradient to threshold for high SNR
null_thresh = numpy.ones(len(mi_table)) * null_snr
grade = mi_snr >= snr
null_thresh[grade] += (mi_snr[grade] - snr)*5.0
# apply veto
keep = mi_null_snr < null_thresh
if return_index:
return keep
else:
out = table.new_from_template(mi_table)
out.extend(numpy.asarray(mi_table)[keep])
return out
def vetoed(self, seglist, time_slide_table=None):
"""Return a MultiInspiralTable with those row from self lying
inside (i.e. vetoed by) any elements of seglist.
If time_slide_table is not None, any time shifts will be undone and each
detector checked individually
"""
seglist = type(seglist)(map(float, seglist))
vetoed = table.new_from_template(self)
if time_slide_table:
slides = time_slide_table.as_dict()
for id_,vector in slides.iteritems():
idx = str(id_).split(":")[-1]
slides["multi_inspiral:time_slide_id:%s" % idx] = vector
del slides[id_]
slides = get_slide_vectors(time_slide_table)
for row in self:
ifos = row.get_ifos()
for i,ifo in enumerate(ifos):
ifo_time = (float(row.get_end()) -
slides[str(row.time_slide_id)][ifo])
if ifo_time in seglist:
vetoed.append(row)
break
else:
for row in self:
time = float(row.get_end())
if time in seglist:
vetoed.append(row)
return vetoed
def apply_auto_veto(mi_table, snr=6.0, chisq_index=4.0, return_index=False):
"""Veto events in a MultiInspiralTable based on their auto chisq-
weighted (new) coherent SNR.
@param mi_table
a MultiInspiralTable from which to veto events
@param snr
the value of coherent new SNR on which to threshold
@param chisq_index
the index \f$\iota\f$ used in the newSNR calculation:
\f[\rho_{\mbox{new}} =
\frac{\rho}{\left[\frac{1}{2}
\left(1 + \left(\frac{\chi^2}{n_\mbox{dof}}\right)^{\iota/3}
\right)\right]^{1/\iota}}
\f]
@param return_index
boolean to return the index array of non-vetoed elements rather
than a new table containing the elements themselves
@returns
a new MultiInspiralTable with those events not vetoed OR
the indices of the original mi_table not vetoed if return_index=True
"""
cont_new_snr = numpy.asarray(mi_table.get_new_snr(column="cont_chisq"))
keep = cont_new_snr >= snr
if return_index:
return keep
else:
out = table.new_from_template(mi_table)
out.extend(numpy.asarray(mi_table)[keep])
return out
def apply_null_snr_veto(mi_table, null_snr=6.0, snr=20.0, grad=0.2,\
return_index=False):
"""Veto events in a MultiInspiralTable based on their null SNR.
@param mi_table
a MultiInspiralTable from which to veto events
@param null_snr
the value of null SNR on which to threshold
@param snr
the value of coherent SNR on above which to grade the null SNR
threshold
@param grad
the rate at which to increase the null SNR threshold above snr
@param return_index
boolean to return the index array of non-vetoed elements rather
than a new table containing the elements themselves
@returns
a new MultiInspiralTable with those events not vetoed OR
the indices of the original mi_table not vetoed if return_index=True
"""
mi_snr = mi_table.get_column("snr")
mi_null_snr = mi_table.get_null_snr()
# apply gradient to threshold for high SNR
null_thresh = numpy.ones(len(mi_table)) * null_snr
grade = mi_snr >= snr
null_thresh[grade] += (mi_snr[grade] - snr) * 5.0
# apply veto
keep = mi_null_snr < null_thresh
if return_index:
return keep
else:
out = table.new_from_template(mi_table)
out.extend(numpy.asarray(mi_table)[keep])
return out
def apply_auto_veto(mi_table, snr=6.0, chisq_index=4.0, return_index=False):
"""Veto events in a MultiInspiralTable based on their auto chisq-
weighted (new) coherent SNR.
@param mi_table
a MultiInspiralTable from which to veto events
@param snr
the value of coherent new SNR on which to threshold
@param chisq_index
the index \f$\iota\f$ used in the newSNR calculation:
\f[\rho_{\mbox{new}} =
\frac{\rho}{\left[\frac{1}{2}
\left(1 + \left(\frac{\chi^2}{n_\mbox{dof}}\right)^{\iota/3}
\right)\right]^{1/\iota}}
\f]
@param return_index
boolean to return the index array of non-vetoed elements rather
than a new table containing the elements themselves
@returns
a new MultiInspiralTable with those events not vetoed OR
the indices of the original mi_table not vetoed if return_index=True
"""
cont_new_snr = numpy.asarray(mi_table.get_new_snr(column="cont_chisq"))
keep = cont_new_snr >= snr
if return_index:
return keep
else:
out = table.new_from_template(mi_table)
out.extend(numpy.asarray(mi_table)[keep])
return out
def plot_trig_rates(trigs, spans, channel, files=None, files_to_combine=None):
if files is not None and files_to_combine is not None:
final_trigs_to_plot = {}
durations = {'combined': 0}
combined_trigs = table.new_from_template(trigs[files[0]])
for f in files_to_combine:
combined_trigs.extend(trigs[f])
for f in trigs.keys():
if f not in files_to_combine:
final_trigs_to_plot[f] = trigs[f]
durations[f] = abs(spans[f])
else:
durations['combined'] += abs(spans[f])
final_trigs_to_plot['combined'] = combined_trigs
trigs = final_trigs_to_plot
else:
durations = {}
for span in spans.keys():
durations[span] = abs(spans[span])
First = 1
bins = numpy.logspace(0, 2, num=200)
for key in durations.keys():
# print(len(trigs[key]))
try:
label = str(spans[key][0]) + '-' + str(spans[key][-1])
except KeyError:
label = 'combined locks'
if First:
plot = trigs[key].hist('snr', logbins=True,
log=True,
histtype='step',
weights=1. / abs(durations[key]),
label=label,
bins=bins,
cumulative=-1
)
ax = plot.gca()
First = 0
continue
snrs = trigs[key].get_column('snr')
ax.hist(snrs, logbins=True, log=True, histtype='step',
weights=1. / abs(durations[key]), label=label,
bins=bins, cumulative=-1)
ax.set_yscale('log')
ax.set_ylabel('Trigger Rate [Hz]')
ax.set_title(channel.replace('_', '\_'))
ax.legend()
ax.set_ylim(1e-4, 1)
ax.set_xscale('log')
ax.set_xlim(5, 100)
plot.save(channel + 'LOCK-TRIG-RATES')
def getsngls(self, ifo):
"""
Return the sngls for a specific ifo.
@param ifo: ifo for which to retrieve the single inspirals.
"""
from glue.ligolw import table
try: ifoTrigs = table.new_from_template(self.sngl_table)
except: ifoTrigs = lsctables.New(lsctables.SnglInspiralTable)
for coinc in self:
if hasattr(coinc,ifo):
ifoTrigs.append(getattr(coinc,ifo))
return ifoTrigs
def getsngls(self, ifo):
"""
Return the sngls for a specific ifo.
@param ifo: ifo for which to retrieve the single inspirals.
"""
from glue.ligolw import table
try: ifoTrigs = table.new_from_template(self.sngl_table)
except: ifoTrigs = lsctables.New(lsctables.SnglInspiralTable)
for coinc in self:
if hasattr(coinc,ifo):
ifoTrigs.append(getattr(coinc,ifo))
return ifoTrigs
def parseTimeDelayDegeneracy(self, ifos, gpstime=lal.GPSTimeNow(),\
dt=0.0005):
# get detectors
detectors = [inject.cached_detector.get(inject.prefix_to_name[ifo])\
for ifo in ifos]
timeDelays = []
degenerate = []
new = table.new_from_template(self)
for n, row in enumerate(self):
# get all time delays for this point
timeDelays.append([])
for i in xrange(len(ifos)):
for j in xrange(i + 1, len(ifos)):
timeDelays[n].append(date.XLALArrivalTimeDiff(\
detectors[i].location,\
detectors[j].location,\
row.longitude,\
row.latitude,\
LIGOTimeGPS(gpstime)))
# skip the first point
if n == 0:
degenerate.append(False)
new.append(row)
continue
else:
degenerate.append(True)
# test this point against all others
for i in xrange(0, n):
# if check point is degenerate, skip
if degenerate[i]:
continue
# check each time delay individually
for j in xrange(0, len(timeDelays[n])):
# if this time delay is non-degenerate the point is valid
if np.fabs(timeDelays[i][j] - timeDelays[n][j]) >= dt:
degenerate[n] = False
break
else:
degenerate[n] = True
if degenerate[n]:
break
if not degenerate[n]:
new.append(row)
return new
def parseTimeDelayDegeneracy(self, ifos, gpstime=lal.GPSTimeNow(),\
dt=0.0005):
# get detectors
detectors = [inject.cached_detector.get(inject.prefix_to_name[ifo])\
for ifo in ifos]
timeDelays = []
degenerate = []
new = table.new_from_template(self)
for n,row in enumerate(self):
# get all time delays for this point
timeDelays.append([])
for i in xrange(len(ifos)):
for j in xrange(i+1, len(ifos)):
timeDelays[n].append(date.XLALArrivalTimeDiff(\
detectors[i].location,\
detectors[j].location,\
row.longitude,\
row.latitude,\
LIGOTimeGPS(gpstime)))
# skip the first point
if n==0:
degenerate.append(False)
new.append(row)
continue
else:
degenerate.append(True)
# test this point against all others
for i in xrange(0,n):
# if check point is degenerate, skip
if degenerate[i]:
continue
# check each time delay individually
for j in xrange(0, len(timeDelays[n])):
# if this time delay is non-degenerate the point is valid
if np.fabs(timeDelays[i][j]-timeDelays[n][j]) >= dt:
degenerate[n] = False
break
else:
degenerate[n] = True
if degenerate[n]:
break
if not degenerate[n]:
new.append(row)
return new
def apply_sngl_snr_veto(mi_table, snrs=[4.0, 4.0], return_index=False):
"""Veto events in a MultiInspiralTable based on their single-detector
snr in the most sensitive detectors.
@param mi_table
a MultiInspiralTable from which to veto events
@param snrs
an X-element list of single-detector SNRs on which to threshold
for the X most sensitive detectors (in sensitivity order)
@param return_index
boolean to return the index array of non-vetoed elements rather
than a new table containing the elements themselves
@returns
a new MultiInspiralTable with those events not vetoed OR
the indices of the original mi_table not vetoed if return_index=True
"""
if len(mi_table) == 0:
if return_index:
return numpy.zeros(0).astype(bool)
else:
return mi_table
# parse table
ifos = lsctables.instrument_set_from_ifos(mi_table[0].ifos)
if "H1" in ifos and "H2" in ifos:
ifos.remove("H2")
mi_sngl_snr = numpy.asarray([numpy.asarray(mi_table.get_sngl_snr(ifo))
for ifo in ifos])
if len(snrs) > len(ifos):
raise ValueError("%s single-detector thresholds given, but only %d "
"detectors found." % (len(snrs), len(ifos)))
# set snrs
snr_array = numpy.zeros(len(ifos))
snr_array[:len(snrs)] = snrs
snr_array.sort()
# order sngl_snrs for each event
mi_sngl_snr.sort(axis=0)
# test thresholds
keep = (mi_sngl_snr.T > snr_array).all(axis=1)
if return_index:
return keep
else:
out = table.new_from_template(mi_table)
out.extend(numpy.asarray(mi_table)[keep])
return out
def get_all_vco_triggers(ifo,
seg,
frames=False,
fit=True,
channel='GDS-CALIB_STRAIN',
file=None):
st = int(seg[0])
et = int(seg[1])
st2 = st
First = 1
# break into 1000s, run into memory issues otherwise
amps = []
while (et > st2):
dur = min(et - st2, 1000)
if file:
vco = TimeSeries.read(file)
vco = vco + 76e6
else:
vco = generate_fast_vco(ifo,
Segment(st2, st2 + dur),
frames=frames,
fit=fit)
trigs = SnglBurstTable.fetch(
"%s:%s" % (ifo, channel),
'omicron',
st2,
st2 + dur,
filt=lambda x: st2 <= x.get_peak() < st2 + dur)
if First:
trigs2 = table.new_from_template(trigs)
First = 0
trigs2.extend(trigs)
vtrigs = get_vco_trigs(vco, trigs, channel=channel)
for vtrig in vtrigs:
amps.append(vtrig)
st2 += 1000
central_freqs = trigs2.get_column('peak_frequency')
snrs = trigs2.get_column('snr')
sts = trigs2.get_column('time_peak')
amps = np.asarray(amps)
amps = amps[~(np.isnan(amps))]
central_freqs = central_freqs[~(np.isnan(amps))]
snrs = snrs[~(np.isnan(amps))]
return amps, central_freqs, snrs, sts
def apply_sngl_snr_veto(mi_table, snrs=[4.0, 4.0], return_index=False):
"""Veto events in a MultiInspiralTable based on their single-detector
snr in the most sensitive detectors.
@param mi_table
a MultiInspiralTable from which to veto events
@param snrs
an X-element list of single-detector SNRs on which to threshold
for the X most sensitive detectors (in sensitivity order)
@param return_index
boolean to return the index array of non-vetoed elements rather
than a new table containing the elements themselves
@returns
a new MultiInspiralTable with those events not vetoed OR
the indices of the original mi_table not vetoed if return_index=True
"""
if len(mi_table) == 0:
if return_index:
return numpy.zeros(0).astype(bool)
else:
return mi_table
# parse table
ifos = lsctables.instrument_set_from_ifos(mi_table[0].ifos)
if "H1" in ifos and "H2" in ifos:
ifos.remove("H2")
mi_sngl_snr = numpy.asarray(
[numpy.asarray(mi_table.get_sngl_snr(ifo)) for ifo in ifos])
if len(snrs) > len(ifos):
raise ValueError("%s single-detector thresholds given, but only %d "
"detectors found." % (len(snrs), len(ifos)))
# set snrs
snr_array = numpy.zeros(len(ifos))
snr_array[:len(snrs)] = snrs
snr_array.sort()
# order sngl_snrs for each event
mi_sngl_snr.sort(axis=0)
# test thresholds
keep = (mi_sngl_snr.T > snr_array).all(axis=1)
if return_index:
return keep
else:
out = table.new_from_template(mi_table)
out.extend(numpy.asarray(mi_table)[keep])
return out
def return_sim_inspirals(self,statistic = None,thresh = 0):
"""
Method to return the sim_inspiral table associated to the coincs.
If thresh is specified, only return sims from those coincs whose stat
exceeds thresh (or is under thresh if statistic == far).
@param statistic: the statistic to use
@param thresh: the threshold on the statistic
"""
from glue.ligolw import table
try: simInspirals = table.new_from_template(self.sim_table)
except: simInspirals = lsctables.New(lsctables.SimInspiralTable)
for coinc in self:
if statistic == 'far':
if (hasattr(coinc,"sim")) and \
(((coinc.stat <= thresh) and (coinc.stat >= 0)) or (thresh < 0)):
simInspirals.append(coinc.sim)
else:
if (hasattr(coinc,"sim")) and (coinc.stat >= thresh):
simInspirals.append(coinc.sim)
return simInspirals
def return_sim_inspirals(self,statistic = None,thresh = 0):
"""
Method to return the sim_inspiral table associated to the coincs.
If thresh is specified, only return sims from those coincs whose stat
exceeds thresh (or is under thresh if statistic == far).
@param statistic: the statistic to use
@param thresh: the threshold on the statistic
"""
from glue.ligolw import table
try: simInspirals = table.new_from_template(self.sim_table)
except: simInspirals = lsctables.New(lsctables.SimInspiralTable)
for coinc in self:
if statistic == 'far':
if (hasattr(coinc,"sim")) and \
(((coinc.stat <= thresh) and (coinc.stat >= 0)) or (thresh < 0)):
simInspirals.append(coinc.sim)
else:
if (hasattr(coinc,"sim")) and (coinc.stat >= thresh):
simInspirals.append(coinc.sim)
return simInspirals
def _hist_triggers(trigs, amp, times, nbins=100, bin_low=1, bin_high=1):
bin_size = (amp.max() - amp.min()) / float(nbins)
bins = numpy.arange(amp.min(), amp.max() + bin_size, bin_size)
hist = numpy.zeros(bins.size)
hist_indices = {}
for i in range(bins.size - 1):
hist_indices[str(i)] = []
for j in range(times.size):
if amp[j] > bins[i] and amp[j] < bins[i + 1]:
hist[i] += 1
hist_indices[str(i)].append(j)
idx = numpy.where(hist == hist.max())[0]
if len(idx) > 1:
idx = idx[0]
high = 79 + bins[idx + bin_high] / 1e3
low = 79 + bins[idx - bin_low] / 1e3
print('we expect whistles occur between %s and %s MHz'
% (low, high))
new_trigs = table.new_from_template(trigs)
for i in range(len(trigs)):
if amp[i] > bins[idx - bin_low] and amp[i] < bins[idx + bin_high]:
new_trigs.extend(trigs[i:i + 1])
times = []
snrs = []
freqs = []
for trig in new_trigs:
peak = trig.get_peak()
snrs.append(trig.snr)
freqs.append(trig.peak_frequency)
times.append(peak.seconds + peak.nanoseconds * 1e-9)
f = open(
'L1-TRIG-TIMES-' + str(span[0]) + '-' + str(span[-1]) + '.txt', 'w')
for time, snr, freq in zip(times, snrs, freqs):
f.write('%f\t%f\t%f\n' % (time, snr, freq))
f.close()
return new_trigs, hist
def apply_snr_veto(mi_table, snr=6.0, return_index=False):
"""Veto events in a MultiInspiralTable based on their (coherent) SNR
value.
@param mi_table
a MultiInspiralTable from which to veto events
@param snr
the value of coherent SNR on which to threshold
@param return_index
boolean to return the index array of non-vetoed elements rather
than a new table containing the elements themselves
@returns
a new MultiInspiralTable with those events not vetoed OR
the indices of the original mi_table not vetoed if return_index=True
"""
mi_snr = numpy.asarray(mi_table.get_column("snr"))
keep = mi_snr >= snr
if return_index:
return keep
else:
out = table.new_from_template(mi_table)
out.extend(numpy.asarray(mi_table)[keep])
return out
def apply_snr_veto(mi_table, snr=6.0, return_index=False):
"""Veto events in a MultiInspiralTable based on their (coherent) SNR
value.
@param mi_table
a MultiInspiralTable from which to veto events
@param snr
the value of coherent SNR on which to threshold
@param return_index
boolean to return the index array of non-vetoed elements rather
than a new table containing the elements themselves
@returns
a new MultiInspiralTable with those events not vetoed OR
the indices of the original mi_table not vetoed if return_index=True
"""
mi_snr = numpy.asarray(mi_table.get_column("snr"))
keep = mi_snr >= snr
if return_index:
return keep
else:
out = table.new_from_template(mi_table)
out.extend(numpy.asarray(mi_table)[keep])
return out
def get_all_vco_triggers(ifo, seg, frames=False, fit=True, channel="GDS-CALIB_STRAIN", file=None):
st = int(seg[0])
et = int(seg[1])
st2 = st
First = 1
# break into 1000s, run into memory issues otherwise
amps = []
while et > st2:
dur = min(et - st2, 1000)
if file:
vco = TimeSeries.read(file)
vco = vco + 76e6
else:
vco = generate_fast_vco(ifo, Segment(st2, st2 + dur), frames=frames, fit=fit)
trigs = SnglBurstTable.fetch(
"%s:%s" % (ifo, channel), "omicron", st2, st2 + dur, filt=lambda x: st2 <= x.get_peak() < st2 + dur
)
if First:
trigs2 = table.new_from_template(trigs)
First = 0
trigs2.extend(trigs)
vtrigs = get_vco_trigs(vco, trigs, channel=channel)
for vtrig in vtrigs:
amps.append(vtrig)
st2 += 1000
central_freqs = trigs2.get_column("peak_frequency")
snrs = trigs2.get_column("snr")
sts = trigs2.get_column("time_peak")
amps = np.asarray(amps)
amps = amps[~(np.isnan(amps))]
central_freqs = central_freqs[~(np.isnan(amps))]
snrs = snrs[~(np.isnan(amps))]
return amps, central_freqs, snrs, sts
def table_from_file(f,
tablename,
columns=None,
filt=None,
contenthandler=None,
nproc=1,
verbose=False):
"""Read a `~glue.ligolw.table.Table` from a LIGO_LW file.
Parameters
----------
f : `file`, `str`, `CacheEntry`, `list`, `Cache`
object representing one or more files. One of
- an open `file`
- a `str` pointing to a file path on disk
- a formatted `~lal.utils.CacheEntry` representing one file
- a `list` of `str` file paths
- a formatted `~glue.lal.Cache` representing many files
tablename : `str`
name of the table to read.
columns : `list`, optional
list of column name strings to read, default all.
filt : `function`, optional
function by which to `filter` events. The callable must accept as
input a row of the table event and return `True`/`False`.
contenthandler : `~glue.ligolw.ligolw.LIGOLWContentHandler`
SAX content handler for parsing LIGO_LW documents.
Returns
-------
table : `~glue.ligolw.table.Table`
`Table` of data with given columns filled
"""
from glue.ligolw.ligolw import Document
from glue.ligolw import (table, lsctables)
from glue.ligolw.utils.ligolw_add import ligolw_add
# find table class
tableclass = lsctables.TableByName[table.Table.TableName(tablename)]
# get content handler
if contenthandler is None:
contenthandler = get_partial_contenthandler(tableclass)
# allow cache multiprocessing
if nproc != 1:
return tableclass.read(f,
columns=columns,
contenthandler=contenthandler,
nproc=nproc,
format='cache')
lsctables.use_in(contenthandler)
# set columns to read
if columns is not None:
_oldcols = tableclass.loadcolumns
tableclass.loadcolumns = columns
# generate Document and populate
files = file_list(f)
xmldoc = Document()
ligolw_add(xmldoc,
files,
non_lsc_tables_ok=True,
contenthandler=contenthandler,
verbose=verbose)
# extract table
out = tableclass.get_table(xmldoc)
if verbose:
gprint('%d rows found in %s table' % (len(out), out.tableName))
# filter output
if filt:
if verbose:
gprint('filtering rows ...', end=' ')
try:
out_ = out.copy()
except AttributeError:
out_ = table.new_from_template(out)
out_.extend(filter(filt, out))
out = out_
if verbose:
gprint('%d rows remaining\n' % len(out))
# reset loadcolumns and return
if columns is not None:
tableclass.loadcolumns = _oldcols
return out
def rotate(self, R):
rotated = table.new_from_template(self)
for row in self:
rotated.append(row.rotate(R))
return rotated
def cluster_multi_inspirals(mi_table, dt, loudest_by="snr"):
"""Cluster a MultiInspiralTable with a given ranking statistic and
clustering window.
This method separates the table rows into time bins, returning those
row that are
* loudest in their own bin, and
* louder than those events in the preceeding and following bins
that are within the clustering time window
@return: a new MultiInspiralTable containing those clustered events
@param mi_table:
MultiInspiralTable to cluster
@param dt:
width (seconds) of clustering window
@keyword loudest_by:
column by which to rank events, default: 'snr'
@type mi_table: glue.ligolw.lsctables.MultiInspiralTable
@type dt: float
@type loudest_by: string
@rtype: glue.ligolw.lsctables.MultiInspiralTable
"""
cluster_table = table.new_from_template(mi_table)
if not len(mi_table):
return cluster_table
# get data
end_time = numpy.asarray(mi_table.get_end()).astype(float)
if hasattr(mi_table, "get_%s" % loudest_by):
stat = numpy.asarray(getattr(mi_table, "get_%s" % loudest_by)())
else:
stat = numpy.asarray(mi_table.get_column(loudest_by))
# get times
start = round(end_time.min())
end = round(end_time.max() + 1)
# generate bins
num_bins = int((end - start) // dt + 1)
time_bins = []
loudest_stat = numpy.zeros(num_bins)
loudest_time = numpy.zeros(num_bins)
for n in range(num_bins):
time_bins.append([])
# bin triggers
for i, (t, s) in enumerate(itertools.izip(end_time, stat)):
bin_ = int(float(t - start) // dt)
time_bins[bin_].append(i)
if s > loudest_stat[bin_]:
loudest_stat[bin_] = s
loudest_time[bin_] = t
# loop over all bins
for i, bin_ in enumerate(time_bins):
if len(bin_) < 1:
continue
first = i == 0
last = i == (num_bins - 1)
prev = i - 1
next_ = i + 1
check_prev = (not first and len(time_bins[prev]) > 0)
check_next = (not last and len(time_bins[next_]) > 0)
# pick loudest event in bin
idx = bin_[stat[bin_].argmax()]
s = stat[idx]
t = end_time[idx]
# trigger was loudest in it's bin, search loudest event
# in previous bin
if (check_prev and (t - loudest_time[prev]) < dt
and s < loudest_stat[prev]):
continue
# Same for the next bin
if (check_next and (loudest_time[next_] - t) < dt
and s < loudest_stat[next_]):
continue
loudest = True
# trigger was loudest in it's bin, search previous bin
if check_prev and not (t - loudest_time[prev]) < dt:
for idx2 in time_bins[prev]:
t2 = end_time[idx2]
if (t - end_time[idx2]) < dt and s < stat[idx2]:
loudest = False
break
if not loudest:
continue
# if still loudest, check the next bin
if check_next and not (loudest_time[next_] - t) < dt:
for idx2 in time_bins[next_]:
if (end_time[idx2] - t) < dt and s < stat[idx2]:
loudest = False
break
if not loudest:
continue
# this was the loudest trigger in its vicinity,
# keep it and move to the next bin
cluster_table.append(mi_table[idx])
return cluster_table
def cluster_multi_inspirals(mi_table, dt, loudest_by="snr"):
"""Cluster a MultiInspiralTable with a given ranking statistic and
clustering window.
This method separates the table rows into time bins, returning those
row that are
* loudest in their own bin, and
* louder than those events in the preceeding and following bins
that are within the clustering time window
@return: a new MultiInspiralTable containing those clustered events
@param mi_table:
MultiInspiralTable to cluster
@param dt:
width (seconds) of clustering window
@keyword loudest_by:
column by which to rank events, default: 'snr'
@type mi_table: glue.ligolw.lsctables.MultiInspiralTable
@type dt: float
@type loudest_by: string
@rtype: glue.ligolw.lsctables.MultiInspiralTable
"""
cluster_table = table.new_from_template(mi_table)
if not len(mi_table):
return cluster_table
# get data
end_time = numpy.asarray(mi_table.get_end()).astype(float)
if hasattr(mi_table, "get_%s" % loudest_by):
stat = numpy.asarray(getattr(mi_table, "get_%s" % loudest_by)())
else:
stat = numpy.asarray(mi_table.get_column(loudest_by))
# get times
start = round(end_time.min())
end = round(end_time.max()+1)
# generate bins
num_bins = int((end-start)//dt + 1)
time_bins = []
loudest_stat = numpy.zeros(num_bins)
loudest_time = numpy.zeros(num_bins)
for n in range(num_bins):
time_bins.append([])
# bin triggers
for i,(t,s) in enumerate(itertools.izip(end_time, stat)):
bin_ = int(float(t-start)//dt)
time_bins[bin_].append(i)
if s > loudest_stat[bin_]:
loudest_stat[bin_] = s
loudest_time[bin_] = t
# loop over all bins
for i,bin_ in enumerate(time_bins):
if len(bin_)<1:
continue
first = i==0
last = i==(num_bins-1)
prev = i-1
next_ = i+1
check_prev = (not first and len(time_bins[prev]) > 0)
check_next = (not last and len(time_bins[next_]) > 0)
# pick loudest event in bin
idx = bin_[stat[bin_].argmax()]
s = stat[idx]
t = end_time[idx]
# trigger was loudest in it's bin, search loudest event
# in previous bin
if (check_prev and (t - loudest_time[prev]) < dt and
s < loudest_stat[prev]):
continue
# Same for the next bin
if (check_next and (loudest_time[next_] - t) < dt and
s < loudest_stat[next_]):
continue
loudest=True
# trigger was loudest in it's bin, search previous bin
if check_prev and not (t - loudest_time[prev]) < dt:
for idx2 in time_bins[prev]:
t2 = end_time[idx2]
if (t - end_time[idx2]) < dt and s < stat[idx2]:
loudest = False
break
if not loudest:
continue
# if still loudest, check the next bin
if check_next and not (loudest_time[next_] - t) < dt:
for idx2 in time_bins[next_]:
if (end_time[idx2] - t) < dt and s < stat[idx2]:
loudest = False
break
if not loudest:
continue
# this was the loudest trigger in its vicinity,
# keep it and move to the next bin
cluster_table.append(mi_table[idx])
return cluster_table
def table_from_file(f, tablename, columns=None, filt=None,
contenthandler=None, nproc=1, verbose=False):
"""Read a `~glue.ligolw.table.Table` from a LIGO_LW file.
Parameters
----------
f : `file`, `str`, `CacheEntry`, `list`, `Cache`
object representing one or more files. One of
- an open `file`
- a `str` pointing to a file path on disk
- a formatted `~glue.lal.CacheEntry` representing one file
- a `list` of `str` file paths
- a formatted `~glue.lal.Cache` representing many files
tablename : `str`
name of the table to read.
columns : `list`, optional
list of column name strings to read, default all.
filt : `function`, optional
function by which to `filter` events. The callable must accept as
input a row of the table event and return `True`/`False`.
contenthandler : `~glue.ligolw.ligolw.LIGOLWContentHandler`
SAX content handler for parsing LIGO_LW documents.
Returns
-------
table : `~glue.ligolw.table.Table`
`Table` of data with given columns filled
"""
# find table class
tableclass = lsctables.TableByName[table.StripTableName(tablename)]
# get content handler
if contenthandler is None:
contenthandler = get_partial_contenthandler(tableclass)
# allow cache multiprocessing
if nproc != 1:
return tableclass.read(f, columns=columns,
contenthandler=contenthandler,
nproc=nproc, format='cache')
# set columns to read
if columns is not None:
_oldcols = tableclass.loadcolumns
tableclass.loadcolumns = columns
# generate Document and populate
files = [fp.name if isinstance(fp, (file, GzipFile)) else
fp for fp in file_list(f)]
xmldoc = Document()
ligolw_add(xmldoc, files, non_lsc_tables_ok=True,
contenthandler=contenthandler, verbose=verbose)
# extract table
try:
out = tableclass.get_table(xmldoc)
except ValueError:
out = lsctables.New(tableclass, columns=columns)
if verbose:
gprint('%d rows found in %s table' % (len(out), out.tableName))
if filt:
if verbose:
gprint('filtering rows ...', end=' ')
try:
out_ = out.copy()
except AttributeError:
out_ = table.new_from_template(out)
out_.extend(filter(filt, out))
out = out_
if verbose:
gprint('%d rows remaining\n' % len(out))
if columns is not None:
tableclass.loadcolumns = _oldcols
return out
def rotate(self, R):
rotated = table.new_from_template(self)
for row in self:
rotated.append(row.rotate(R))
return rotated
exttrig_config_file, grb_ifolist, onSourceSegment, offSourceSegment = exttrig_dataquery.exttrig_dataquery(grb_name, grb_time, grb_ra, grb_dec, opts.offset, opts.config_file, opts.extend, opts.useold, opts.make_plots, opts.make_xml)
##############################################################################
# create the config parser object and exttrig_dataquery ini file
cp = dcConfigParser()
cp.read(exttrig_config_file)
ext_trigs = grbsummary.load_external_triggers('grb%s.xml'%opts.name[0])
if ext_trigs is None:
print("No external triggers found. Nothing to do.", file=sys.stderr)
sys.exit()
if len(opts.name) > 0:
temp_list = filter(lambda row: row.event_number_grb in opts.name, ext_trigs)
ext_trigs = table.new_from_template(ext_trigs)
ext_trigs.extend(temp_list)
if len(ext_trigs) != len(opts.name):
missing = set(opts.name) - set([row.event_number_grb for row in ext_trigs])
raise ValueError("could not find the following requested GRBs: " \
+ "".join(missing))
if opts.verbose:
print("Will construct workflows to analyze:", \
", ".join(["GRB" + trig.event_number_grb for trig in ext_trigs]))
if opts.do_coh_PTF:
for program in ['coh_PTF_inspiral','coh_PTF_spin_checker']:
if not opts.ipn:
cp.set(program,'right-ascension',str(ext_trigs[0].event_ra))
def frominjectionfile(file, type, ifo=None, start=None, end=None):
"""
Read generic injection file object file containing injections of the given
type string. Returns an 'Sim' lsctable of the corresponding type.
Arguments:
file : file object
type : [ "inspiral" | "burst" | "ringdown" ]
Keyword arguments:
ifo : [ "G1" | "H1" | "H2" | "L1" | "V1" ]
"""
# read type
type = type.lower()
# read injection xml
xml = re.compile('(xml$|xml.gz$)')
if re.search(xml,file.name):
xmldoc,digest = utils.load_fileobj(file)
injtable = table.get_table(xmldoc,'sim_%s:table' % (type))
# read injection txt
else:
cchar = re.compile('[#%<!()_\[\]{}:;\'\"]+')
#== construct new Sim{Burst,Inspiral,Ringdown}Table
injtable = lsctables.New(lsctables.__dict__['Sim%sTable' % (type.title())])
if type=='inspiral':
columns = ['geocent_end_time.geocent_end_time_ns',\
'h_end_time.h_end_time_ns',\
'l_end_time.l_end_time_ns',\
'v_end_time.v_end_time_ns',\
'distance']
for line in file.readlines():
if re.match(cchar,line):
continue
# set up siminspiral object
inj = lsctables.SimInspiral()
# split data
sep = re.compile('[\s,=]+')
data = sep.split(line)
# set attributes
inj.geocent_end_time = int(data[0].split('.')[0])
inj.geocent_end_time_ns = int(data[0].split('.')[1])
inj.h_end_time = int(data[1].split('.')[0])
inj.h_end_time_ns = int(data[1].split('.')[1])
inj.l_end_time = int(data[2].split('.')[0])
inj.l_end_time_ns = int(data[2].split('.')[1])
inj.v_end_time = int(data[3].split('.')[0])
inj.v_end_time_ns = int(data[3].split('.')[1])
inj.distance = float(data[4])
injtable.append(inj)
if type=='burst':
if file.readlines()[0].startswith('filestart'):
# if given parsed burst file
file.seek(0)
snrcol = { 'G1':23, 'H1':19, 'L1':21, 'V1':25 }
for line in file.readlines():
inj = lsctables.SimBurst()
# split data
sep = re.compile('[\s,=]+')
data = sep.split(line)
# set attributes
# gps time
if 'burstgps' in data:
idx = data.index('burstgps')+1
geocent = LIGOTimeGPS(data[idx])
inj.time_geocent_gps = geocent.seconds
inj.time_geocent_gps_ns = geocent.nanoseconds
else:
continue
#inj.waveform = data[4]
#inj.waveform_number = int(data[5])
# frequency
if 'freq' in data:
idx = data.index('freq')+1
inj.frequency = float(data[idx])
else:
continue
# SNR a.k.a. amplitude
if ifo and 'snr%s' % ifo in data:
idx = data.index('snr%s' % ifo)+1
inj.amplitude = float(data[idx])
elif 'rmsSNR' in data:
idx = data.index('rmsSNR')+1
inj.amplitude = float(data[idx])
else:
continue
if 'phi' in data:
idx = data.index('phi' )+1
inj.ra = float(data[idx])*24/(2*math.pi)
if 'theta' in data:
idx = data.index('theta' )+1
inj.ra = 90-(float(data[idx])*180/math.pi)
if ifo and 'hrss%s' % ifo in data:
idx = data.index('hrss%s' % ifo)+1
inj.hrss = float(data[idx])
elif 'hrss' in data:
idx = data.index('hrss')+1
inj.hrss = float(data[idx])
# extra columns to be added when I know how
#inj.q = 0
#inj.q = float(data[11])
#h_delay = LIGOTimeGPS(data[41])
#inj.h_peak_time = inj.time_geocent_gps+h_delay.seconds
#inj.h_peak_time_ns = inj.time_geocent_gps_ns+h_delay.nanoseconds
#l_delay = LIGOTimeGPS(data[43])
#inj.l_peak_time = inj.time_geocent_gps+l_delay.seconds
#inj.l_peak_time_ns = inj.time_geocent_gps_ns+l_delay.nanoseconds
#v_delay = LIGOTimeGPS(data[43])
#inj.v_peak_time = inj.time_geocent_gps+v_delay.seconds
#inj.v_peak_time_ns = inj.time_geocent_gps_ns+v_delay.nanoseconds
injtable.append(inj)
else:
# if given parsed burst file
file.seek(0)
for line in file.readlines():
inj = lsctables.SimBurst()
# split data
sep = re.compile('[\s,]+')
data = sep.split(line)
# set attributes
geocent = LIGOTimeGPS(data[0])
inj.time_geocent_gps = geocent.seconds
inj.time_geocent_gps_ns = geocent.nanoseconds
injtable.append(inj)
injections = table.new_from_template(injtable)
if not start: start = 0
if not end: end = 9999999999
span = segments.segmentlist([ segments.segment(start, end) ])
get_time = dqTriggerUtils.def_get_time(injections.tableName)
injections.extend(inj for inj in injtable if get_time(inj) in span)
return injections
