def get_waveforms(fn_mwk, fn_nev, npts=N_SNIPPET_PTS, c_v=VOLT_CONV,
verbose=True):
wv = {}
wvsq = {}
nelec = cl.defaultdict(int)
iimg0 = None
# -- collect snippets for each image presentation
# override_elecs: process only these electrodes. 1-based.
for arg in ss.getspk(fn_mwk, fn_nev):
# -- preps
wav = np.array(arg['wav']['unsorted']) * c_v # unsorted raw snippet
wavsq = wav * wav
ch = arg['ch']; t_rel = arg['t_rel']
t0 = arg['t_imgonset']; iid = arg['imgid']; iimg = arg['iimg']
if verbose:
if iimg0 == None: iimg0 = iimg
if iimg != iimg0:
n = nelec[1]
print 'At: %d ([1]: %f)' % (iimg, np.mean(np.sqrt(wvsq[1]/n - wv[1]*wv[1]/n/n)))
iimg0 = iimg
# -- main
nelec[ch] += 1
if not wv.has_key(ch): wv[ch] = wav
else: wv[ch] += wav
if not wvsq.has_key(ch): wvsq[ch] = wavsq
else: wvsq[ch] += wavsq
for ch in nelec:
wv[ch] /= nelec[ch]
wvsq[ch] /= nelec[ch]
return wv, wvsq
def get_firrate(fn_mwk, fn_out, proc_cluster=PROC_CLUSTER, max_clus=MAX_CLUS, \
movie_begin_fname=None, **kwargs):
"""Get spiking data around stimuli presented."""
# some housekeeping things...
kwargs['verbose'] = 2
t_start0 = kwargs['t_start0']
t_stop0 = kwargs['t_stop0']
# all_spike[chn_id][img_id]: when the neurons spiked?
all_spike = {}
all_foffset = {}
clus_info = {}
frame_onset = {}
movie_iid = None
movie_onsets = []
movie_onset0 = 0
for info in getspk(fn_mwk, fn_nev=None, **kwargs):
# -- get the metadata. this must be called before other clauses
if info['type'] == 'preamble':
actvelecs = info['actvelecs']
t_adjust = info['t_adjust']
# -- do some housekeeping things once per each img
elif info['type'] == 'begin':
t0 = info['t_imgonset']
iid = info['imgid']
# process movie if requested
if movie_begin_fname is not None:
# begin new clip?
if movie_begin_fname in iid:
# was there previous clip?
if movie_iid is not None:
if movie_iid not in frame_onset:
frame_onset[movie_iid] = []
frame_onset[movie_iid].append(movie_onsets)
# init for new clip
movie_onsets = []
iid = movie_iid = iid.replace(movie_begin_fname, '')
movie_onset0 = t0
movie_onsets.append(0)
elif movie_iid is not None:
movie_onsets.append(t0 - movie_onset0)
continue
# prepare the t_rel & foffset
actvunits = {}
t_rel = {}
foffset = {}
for ch in actvelecs:
# if no clustering info is used...
if not proc_cluster:
t_rel[ch] = []
foffset[ch] = []
continue
# if clustering info is used...
cids = range(max_clus)
actvunits[ch] = cids
for cid in cids:
t_rel[(ch, cid)] = []
foffset[(ch, cid)] = []
# -- put actual spiking info
elif info['type'] == 'spike':
ch = info['ch']
if proc_cluster:
cid = info['cluster_id']
key = (ch, cid)
else:
key = ch
t_rel[key].append(int(info['t_rel']))
foffset[key].append(int(info['pos']))
# update the clus_info and n_cluster
if proc_cluster and key not in clus_info:
cvalue = info['cluster_value']
clus_info[key] = cvalue
if cvalue['nclusters'] > max_clus:
raise ValueError, '*** Unit %s: max_cluster(=%d) is '\
'smaller than the actual number of clusters(=%d)!'\
% (str(key), max_clus, cvalue['nclusters'])
# -- finalize info for the image
elif info['type'] == 'end':
for el in actvelecs:
if proc_cluster:
cids = actvunits[el]
else:
cids = [-1]
for cid in cids:
if proc_cluster:
key = (el, cid)
else:
key = el
if key not in all_spike:
# not using defaultdict here:
# all_spike[key] = defaultdict(list)
all_spike[key] = {}
all_foffset[key] = {}
if iid not in all_spike[key]:
all_spike[key][iid] = []
all_foffset[key][iid] = []
all_spike[key][iid].append(t_rel[key])
all_foffset[key][iid].append(foffset[key])
# -- done!
# flush movie data
if movie_iid is not None:
if movie_iid not in frame_onset:
frame_onset[movie_iid] = []
frame_onset[movie_iid].append(movie_onsets)
# finished calculation....
f = open(fn_out, 'w')
out = {'all_spike': all_spike,
't_start': t_start0,
't_stop': t_stop0,
't_adjust': t_adjust,
'actvelecs': actvelecs}
if proc_cluster:
out['clus_info'] = clus_info
out['max_clus'] = max_clus
if movie_begin_fname is not None:
out['frame_onset'] = frame_onset
pk.dump(out, f)
# put all_foffset into the 2nd half to speed up reading
out2 = {'all_foffset': all_foffset}
pk.dump(out2, f)
f.close()
def get_waveform(fn_mwk, fn_nev, fn_out, movie_begin_fname=None, \
n_samples=DEFAULT_SAMPLES_PER_SPK, n_max_spks=DEFAULT_MAX_SPKS, \
**kwargs):
"""Get waveform data around stimuli presented for later spike sorting.
This will give completely different output file format.
NOTE: this function is memory intensive! Will require approximately
as much memory as the size of the files."""
# -- some housekeeping things...
kwargs['verbose'] = 2
kwargs['only_new_t'] = True
t_start0 = kwargs['t_start0']
t_stop0 = kwargs['t_stop0']
# these two are unused
kwargs.pop('proc_cluster', None)
kwargs.pop('max_clus', None)
iid2idx = {}
idx2iid = []
ch2idx = {}
idx2ch = []
n_spks = 0
# does "n_spks_lim" reach "n_max_spks"?
b_warn_max_spks_lim = False
# list of image presentations without spikes
l_empty_spks = []
for info in getspk(fn_mwk, fn_nev=fn_nev, **kwargs):
# -- get the metadata. this must be called before other clauses
if info['type'] == 'preamble':
actvelecs = info['actvelecs']
t_adjust = info['t_adjust']
chn_info = info['chn_info']
n_spks_lim = min(info['n_packets'], n_max_spks)
print '* n_spks_lim =', n_spks_lim
for ch in sorted(actvelecs):
makeavail(ch, ch2idx, idx2ch)
# Data for snippets ===
# Msnp: snippet data
# Msnp_tabs: when it spiked (absolute time)
# Msnp_ch: which channel ID spiked?
# Msnp_pos: corresponding file position
Msnp = np.empty((n_spks_lim, n_samples), dtype='int16')
Msnp_tabs = np.empty(n_spks_lim, dtype='uint64')
Msnp_ch = np.empty(n_spks_lim, dtype='uint32')
Msnp_pos = np.empty(n_spks_lim, dtype='uint64')
# Data for images ===
# Mimg: image indices in the order of presentations
# Mimg_tabs: image onset time (absolute)
Mimg = []
Mimg_tabs = []
# -- do some housekeeping things once per each img
if info['type'] == 'begin':
t_abs = info['t_imgonset']
iid = info['imgid']
i_img = info['i_img']
makeavail(iid, iid2idx, idx2iid)
Mimg.append(iid2idx[iid])
Mimg_tabs.append(t_abs)
b_no_spks = True
# process movie if requested
if movie_begin_fname is not None:
raise NotImplementedError('Movies are not supported yet.')
# -- put actual spiking info
elif info['type'] == 'spike':
wav = info['wavinfo']['waveform']
t_abs = info['t_abs']
i_ch = ch2idx[info['ch']]
pos = info['pos']
Msnp[n_spks] = wav
Msnp_tabs[n_spks] = t_abs
Msnp_ch[n_spks] = i_ch
Msnp_pos[n_spks] = pos
b_no_spks = False
n_spks += 1
if n_spks >= n_spks_lim:
warnings.warn('n_spks exceedes n_spks_lim! '\
'Aborting further additions.')
b_warn_max_spks_lim = True
break
elif info['type'] == 'end':
if not b_no_spks:
continue
# if there's no spike at all, list the stim
warnings.warn('No spikes are there! ')
l_empty_spks.append(i_img)
# -- done!
# finished calculation....
Msnp = Msnp[:n_spks]
Msnp_tabs = Msnp_tabs[:n_spks]
Msnp_ch = Msnp_ch[:n_spks]
Msnp_pos = Msnp_pos[:n_spks]
Mimg = np.array(Mimg, dtype='uint32')
Mimg_tabs = np.array(Mimg_tabs, dtype='uint64')
filters = tbl.Filters(complevel=4, complib='blosc')
t_int16 = tbl.Int16Atom()
t_uint32 = tbl.UInt32Atom()
t_uint64 = tbl.UInt64Atom()
h5o = tbl.openFile(fn_out, 'w')
CMsnp = h5o.createCArray(h5o.root, 'Msnp', t_int16, \
Msnp.shape, filters=filters)
CMsnp_tabs = h5o.createCArray(h5o.root, 'Msnp_tabs', t_uint64, \
Msnp_tabs.shape, filters=filters)
CMsnp_ch = h5o.createCArray(h5o.root, 'Msnp_ch', t_uint32, \
Msnp_ch.shape, filters=filters)
CMsnp_pos = h5o.createCArray(h5o.root, 'Msnp_pos', t_uint64, \
Msnp_pos.shape, filters=filters)
CMsnp[...] = Msnp
CMsnp_tabs[...] = Msnp_tabs
CMsnp_ch[...] = Msnp_ch
CMsnp_pos[...] = Msnp_pos
h5o.createArray(h5o.root, 'Mimg', Mimg)
h5o.createArray(h5o.root, 'Mimg_tabs', Mimg_tabs)
meta = h5o.createGroup('/', 'meta', 'Metadata')
h5o.createArray(meta, 't_start0', t_start0)
h5o.createArray(meta, 't_stop0', t_stop0)
h5o.createArray(meta, 't_adjust', t_adjust)
h5o.createArray(meta, 'chn_info_pk', pk.dumps(chn_info))
h5o.createArray(meta, 'kwargs_pk', pk.dumps(kwargs))
h5o.createArray(meta, 'idx2iid', idx2iid)
h5o.createArray(meta, 'iid2idx_pk', pk.dumps(iid2idx))
h5o.createArray(meta, 'idx2ch', idx2ch)
h5o.createArray(meta, 'ch2idx_pk', pk.dumps(ch2idx))
# some error signals
h5o.createArray(meta, 'b_warn_max_spks_lim', b_warn_max_spks_lim)
if len(l_empty_spks) > 0:
h5o.createArray(meta, 'l_empty_spks', l_empty_spks)
h5o.close()
