def filter_events_on_sync_time(data, st=None, mintime=0, maxtime=int(500e3),
channel=0, marker = False):
"""
delete all events (photons only) whose arrival times (= times after sync) are out of limits.
note that the time unit is ps!
"""
if len(data) == 0:
return np.zeros((0, 3), dtype='u8'), np.array([], dtype='u8')
mintime = int(mintime)
maxtime = int(maxtime)
t0 = time.time()
print '* filtering time of channel-{:d} events ({:d}--{:d} ps)...'.format(channel, mintime, maxtime),
delete_idxs = T2_tools.get_outofwindow_event_idxs(data, st, mintime, maxtime, channel, marker)
print 'delete {} records...'.format(len(delete_idxs)),
data = np.delete(data, delete_idxs, axis=0)
if st != None:
st = np.delete(st, delete_idxs)
t1 = time.time() - t0
print 'done ({:.2f} s).'.format(t1)
if st != None:
return data, st
else:
return data
def get_sync_time(data):
"""
Get for each record the time (in ps) since the last sync.
"""
if len(data) == 0:
return np.zeros((0, 3), dtype='u8')
t0 = time.time()
print '* get times relative to previous syncs... ',
st = T2_tools.get_sync_time_ps(data)
t1 = time.time() - t0
print 'done ({:.2f} s).'.format(t1)
return st
def coincidences(data, max_tau=(5*11.6e6 + 1e6)):
taus = T2_tools.get_coincidence_intervals(data, max_tau)
# make a histogram with one bin per 10us (interval between fake photons)
# such that expected coincidence intervals are centered in the bin
h,e = np.histogram(taus * 1e-3, bins=np.arange(6)*11.6e3 - 11.6e3/2)
print
print 'Coincidence intervals'
print 'bin edges (ns): '
print e
print 'events: '
print h
print
def delete_solitary_syncs(data):
"""
Delete all sync events that are followed directly by the next sync event,
i.e., are useless.
"""
if len(data) == 0:
return np.zeros((0, 3), dtype='u8')
t0 = time.time()
print '* delete solitary syncs... ',
idxs = T2_tools.delete_solitary_syncs(data)
data = np.delete(data, idxs, axis=0)
t1 = time.time() - t0
print 'done ({:.2f} s).'.format(t1)
return data
def measurement_loop(self):
self.HH.start_T2_mode()
self.HH.calibrate()
rawdata_idx = 1
t_ofl = 0
t_lastsync = 0
# note: for the live data, 32 bit is enough ('u4') since timing uses overflows.
dset_hhtime = self.h5data.create_dataset('HH_time-{}'.format(rawdata_idx),
(0,), 'u8', maxshape=(None,))
dset_hhchannel = self.h5data.create_dataset('HH_channel-{}'.format(rawdata_idx),
(0,), 'u1', maxshape=(None,))
dset_hhspecial = self.h5data.create_dataset('HH_special-{}'.format(rawdata_idx),
(0,), 'u1', maxshape=(None,))
dset_hhsynctime = self.h5data.create_dataset('HH_sync_time-{}'.format(rawdata_idx),
(0,), 'u8', maxshape=(None,))
current_dset_length = 0
self.HH.StartMeas(int(MSMT_TIME*1e3))
while self.HH.get_MeasRunning():
_length, _data = self.HH.get_TTTR_Data()
if _length > 0:
_t, _c, _s = self._HH_decode(_data[:_length])
hhtime, hhchannel, hhspecial, sync_time, newlength, t_ofl, t_lastsync = \
T2_tools.LDE_live_filter(_t, _c, _s, t_ofl, t_lastsync)
if newlength > 0:
dset_hhtime.resize((current_dset_length+newlength,))
dset_hhchannel.resize((current_dset_length+newlength,))
dset_hhspecial.resize((current_dset_length+newlength,))
dset_hhsynctime.resize((current_dset_length+newlength,))
dset_hhtime[current_dset_length:] = hhtime
dset_hhchannel[current_dset_length:] = hhchannel
dset_hhspecial[current_dset_length:] = hhspecial
dset_hhsynctime[current_dset_length:] = sync_time
current_dset_length += newlength
self.h5data.flush()
def convert_to_real_time(data, delete_ofls=True):
"""
Change the event time of each record into the actual time (since starting)
the measurment, given in ps.
"""
if len(data) == 0:
return np.zeros((0, 3), dtype='u8')
t0 = time.time()
print '* convert event time to real time... ',
data = T2_tools.convert_to_real_time_ps(data)
t1 = time.time() - t0
print 'done ({:.2f} s).'.format(t1)
if delete_ofls:
t0 = time.time()
print '* delete overflows... ',
data = np.delete(data, np.where(data[:,1]==63)[0], axis=0)
t1 = time.time() - t0
print 'done ({:.2f} s).'.format(t1)
return data
def delete_all_syncs(data, st=None):
"""
Delete all sync events. We can do this after all sufficient pre-filtering has been done,
after that all relevant timing information is in absolute time and sync time.
"""
if len(data) == 0:
return np.zeros((0, 3), dtype='u8'), np.array([], dtype='u8')
t0 = time.time()
print '* delete all syncs... ',
delete_idxs = T2_tools.get_sync_idxs(data)
data = np.delete(data, delete_idxs, axis=0)
if st != None:
st = np.delete(st, delete_idxs)
t1 = time.time() - t0
print 'done ({:.2f} s).'.format(t1)
if st != None:
return data, st
else:
return data