def unit(u_, Data0, cc, blockID):
# number of time bins to include in the LFP array
nlfpsamp = 0
for tt, trial in enumerate(Data0['trial'][0][0][0]):
thislfpsamp = trial['LFP'].shape[1]
if thislfpsamp>nlfpsamp:
nlfpsamp = thislfpsamp
ntrials = Data0['trial'][0][0][0].size # find number of trials
nstimID = Data0['trial'][0][0][0][0]['Epoch_Value'][0].size
# initialze LFP, spike times, spike trials, spike waveform
lfp = np.ndarray((0, nlfpsamp), dtype = 'float32')
spktimes = np.ndarray(0)
spktrials = np.ndarray(0)
spkwaveform = np.ndarray((0, 22))
# initialize frequency and attenuation IDs
stimID = np.ndarray((0, nstimID), dtype = 'float32')
ttt = 0 # valid trial counter
for tt in range(ntrials):
trial = Data0['trial'][0][0][0][tt]
thisstimID = np.float32(trial['Epoch_Value'][0])
# if not ((blockID.startswith('b')) and (thisstimID[0] < 2)):
# get the LFP for this trial and pad it with nans so it can fit in a matrix (since
# some of the trials have +/-1 data point for LFP)
lfpchannel = trial['LFP'][cc]
lfpchannel = np.concatenate((lfpchannel, np.zeros(nlfpsamp - len(lfpchannel)) * np.nan))
lfp = np.vstack((lfp, lfpchannel))
spktime = trial['CH'][0][cc]['latency']
if np.prod(spktime.shape) > 0:
spktimes = np.append(spktimes, spktime)
spktrials = np.append(spktrials, np.ones(spktime.size) * ttt)
spkwaveform = np.concatenate((spkwaveform, trial['CH'][0][cc]['spkwaveform'].T), 0)
# add to Epoch_Value
stimID = np.vstack((stimID, thisstimID))
ttt += 1 # increment valid trial counter
# end if valid ID
# end trial loop
if spktimes.size == 0: # if no spikes
print 'No spikes detected for this unit.'
spktimes = np.array([np.nan])
spktrials = np.array([np.nan])
spkwaveform = np.array([np.nan])
rast = np.array([np.nan])
else:
# filter out unwanted trials
remID = np.array([np.nan, np.nan])
if blockID.startswith('b'):
remID = np.array([1., 70.])
elif blockID.startswith('r'):
remID = np.array([0., 0.])
spktimes, spktrials, spkwaveform, lfp, stimID = \
remove_trials(spktimes, spktrials, spkwaveform, lfp, stimID, remID)
# create raster
ntrials = stimID.shape[0]
nbins = np.ceil(1000 * spktimes.max())+1
rast = Spikes.calc_rast(spktimes, spktrials, ntrials, nbins)
# save out to file
u_.create_dataset('chan', data = cc)
u_.create_dataset('blockID', data = blockID)
# add stimulus ID datasets to this stimset on this unit
u_.create_dataset('stimID', data = stimID)
u_.create_dataset('lfp', data = lfp, compression = 'gzip')
u_.create_dataset('spktimes', data = spktimes, compression = 'gzip')
u_.create_dataset('spktrials', data = spktrials, compression = 'gzip')
u_.create_dataset('spkwaveform', data = spkwaveform, compression = 'gzip')
u_.create_dataset('rast', data = rast, compression = 'gzip')
if blockID.startswith('b'):
rf = RF.calc_rf(rast, stimID)
u_.create_dataset('rf', data = rf, compression = 'gzip')
def rr_make_contactsheets():
'''
loop through all the sessions and plot the rrtfs
'''
fig = plt.figure(figsize = (30, 18));
txt_suptitle = fig.suptitle('')
ax_cfrrtf = fig.add_axes((0.76, 0.76, 0.24, 0.23));
ax_cfvs = ax_cfrrtf.twinx();
ax_cfcircpsthall = fig.add_axes((0.62, (11/14.)-0.02, 0.1, (1/7.)+0.04), polar = True)
ax_cfcircpsthall.set_xticklabels(''); ax_cfcircpsthall.set_yticklabels('');
ax_rf = fig.add_axes((0.67, 0.51, 0.33, 0.23));
ax_rfrast = fig.add_axes((0.67, 0.25, 0.33, 0.24));
ax_rfrast.set_xticklabels('');
ax_rfpsth = fig.add_axes((0.67, 0.01, 0.33, 0.24));
ax_cfrr = [fig.add_axes((0.03, 1-((i+1)/7.), 0.35, 1/7.)) for i in np.arange(nrrs)]
ax_cfalignedpsth = [fig.add_axes((0.38, 1-((i+1)/7.), 0.17, 1/7.)) for i in np.arange(nrrs)]
ax_cfcircpsth = [fig.add_axes((0.53, 1-((i+1)/7.), 0.1, 1/7.), polar = True) for i in np.arange(nrrs)]
# ax_noiserr = [fig.add_subplot(nrrs, 3, i) for i in np.arange(1, 3*nrrs, 3)]
for sessionpath in sessionpaths:
session = os.path.split(sessionpath)[1]
unitinfos = fileconversion.get_session_unitinfo(sessionpath, onlycomplete = ('RF', 'RR', 'VOC'))
for unitkey in unitinfos.keys():
txt_suptitle.set_text('%s %s' % (session, unitkey))
unitinfo = unitinfos[unitkey]
rf_ix = unitinfo['stimtype'].index('RF')
f_rf = h5py.File(unitinfo['fpath'][rf_ix], 'r')
rf_rast = f_rf['rast'].value
rf_stimparams = f_rf['stimID'].value
cf_ix = f_rf['cf'].value
f_rf.close()
cf = ix2freq[20:][int(cf_ix)]
''' calculate and plot RF, psth, and sorted raster'''
rf = RF.calc_rf(rf_rast, rf_stimparams)
rf_psth = Spikes.calc_psth(rf_rast)
RF.plot_rf(rf, cf = cf_ix, axes_on = False, ax = ax_rf) # plot RF
ax_rf.axvline(cf_ix, color = 'r', lw = 1.5)
Spikes.plot_sorted_raster(rf_rast, rf_stimparams, ax = ax_rfrast) # plot raster
ax_rfpsth.plot(t_rf, Spikes.exp_smoo(rf_psth, tau = 0.005)) # plot PSTH
''' calcualte and plot RRTFs for CF and noise stimuli '''
rr_ix = unitinfo['stimtype'].index('RR')
f_rr = h5py.File(unitinfo['fpath'][rr_ix], 'r')
rr_rast = f_rr['rast'].value
rr_stimparams = f_rr['stimID'].value
f_rr.close()
# find the played CF
rr_ufreqs = np.unique(rr_stimparams[:, 0])
urrs = np.unique(rr_stimparams[:, 1])
npips = (urrs*4).astype(int)
rr_freq, rr_ufreq_ix, _ = misc.closest(rr_ufreqs, cf, log = True)
ax_rf.axvline(RF.calc_freq2ix(rr_freq), color = 'g', lw = 1.5)
# calculate the PSTHs for each repetition rate
tmp = Spikes.calc_psth_by_stim(rr_rast, rr_stimparams)
rr_cfpth = tmp[0][rr_ufreq_ix, :, :]
# rrtf_noisepsth = tmp[0][0, :, :]
# plot the aligned psths
RR.aligned_psth_separate_all(rr_rast, rr_stimparams, rr_freq, npips, axs = ax_cfalignedpsth)
[a.set_yticklabels('') for a in ax_cfalignedpsth]
[a.set_xticklabels('') for a in ax_cfalignedpsth[:-1]]
# plot circular psths
r, V, theta = RR.circ_psth_all(rr_rast, rr_stimparams, rr_freq, npips, axs = ax_cfcircpsth)
[a.set_yticklabels('') for a in ax_cfcircpsth]
[a.set_xticklabels('') for a in ax_cfcircpsth]
# plot all circular summed vector strengths
ax_cfcircpsthall.plot(theta, V, '.-')
[ax_cfcircpsthall.plot([0, th], [0, v], color = 'b', alpha = 1-(i/10.)) for i, (th, v) in enumerate(zip(theta, V))]
# plot RRTF
rrtf = RR.calc_rrtf_all(rr_rast, rr_stimparams, rr_freq, urrs, npips)
ax_cfrrtf.plot(rrtf, '.-', ms = 10)
ax_cfvs.plot(V*np.cos(theta), 'g.-', ms = 10)
for tick in ax_cfvs.yaxis.get_major_ticks():
tick.set_pad(-5)
tick.label2.set_horizontalalignment('right')
# plot repetition rate PSTHs
for i in xrange(nrrs):
# RR.plot_rrtf(t_rrtf, rrtf_noisepsth[i, :], urrs[i], int(4*urrs[i]), onset = 0.05, duration = 0.025, ax = ax_noiserr[i])
RR.plot_rrtf(t_rrtf, rr_cfpth[i, :], urrs[i], int(4*urrs[i]), onset = 0.05, duration = 0.025, ax = ax_cfrr[i])
# ax_noiserr[0].set_title('Noise RRTFs')
ax_cfrr[0].set_title('CF RRTFs (%.0f kHz)' % (cf/1000))
# [a.set_xlim(0, 4.5) for a in ax_noiserr]
[a.set_xlim(0, 4.5) for a in ax_cfrr]
misc.sameyaxis(ax_cfrr+ax_cfalignedpsth)
figsavepath = os.path.join(studydir, 'Sheets', 'RRTFs', '%s_%s_RRTF.png' % (session, unitkey))
print figsavepath
fig.savefig(figsavepath)
[a.cla() for a in fig.get_axes()] # clear all axes
def characterize(sesss = sesss, experiment = 'Fmr1_RR', pplot = True, verbose = False):
if type(sesss) == str:
sesss = [sesss]
# set up figure
figsize = (12, 12)
fig = plt.figure(figsize = figsize)
# loop through sesss
for sess in sesss:
DB = np.empty(0, dtype = dtype)
print '%s\n%s\n\n' % (sess, '-'*50)
# build the output directory path
savedir = os.path.join(basedir, experiment, 'Sessions', sess, 'analysis')
if not os.path.exists(savedir):
os.mkdir(savedir)
# WT or KO / CTL or EXP
gen, exp, date = sess.split('_')
# find the RF blocks
pens = glob.glob(os.path.join(basedir, experiment, 'Sessions', sess, 'fileconversion', 'RF*.h5'))
# load the cfs for this sess
cfs = np.loadtxt(os.path.join(basedir, experiment, 'Sessions', sess, 'cfs.txt'), ndmin = 1)
# loop through blocks in this sess
for pen in pens:
absol, relat = os.path.split(pen)
blockname = os.path.splitext(relat)[0]
# get unit number from filename
unitnum = np.int32(p.findall(relat))[0] # unit number
ix = cfs[:, 0] == unitnum
if ix.sum() > 0:
cf_man = cfs[ix, 1][0]
if verbose:
print pen
# load the RF block
f = h5py.File(pen, 'r')
spktimes = f['spktimes'].value
# if not np.isnan(spktimes[0]):
'''--------RF--------'''
# load the RF block to get the RF
rf = f['rf'].value; rast = f['rast'].value; spktimes = f['spktimes'].value; stimparams = f['stimID'].value; spktrials = f['spktrials'].value; coord = f['coord'].value; ntrials = f['rast'].shape[0]; f.close()
# calculate the psth (spk/s*trial, normalized by number of trials
psth = Spikes.calc_psth(rast, normed = True) # spk/s
# baseline firing rate
base_mean = psth[:stim_on].mean() # spk/s
# response onset/offset
psth_smoo = Spikes.exp_smoo(psth, tau = 0.003)
resp_on, resp_off = Spikes.calc_on_off(psth_smoo, stim_on = stim_on)
# rewindowed RF
rf_rewin = RF.calc_rf(rast, stimparams, resp_on = resp_on + stim_on - 3, resp_off = resp_off + stim_on + 3, normed = True)
# thresholded RF
rf_thresh = rf_rewin.copy()
rf_threshold = np.percentile(rf_thresh, 66)# upper quartile
rf_peak = rf_rewin.max()
rf_thresh[rf_thresh < rf_threshold] = 0
# find maximum RF cluster
(rf_clust, clust_sizes) = RF.findmaxcluster(rf_thresh, cf = cf_man, include_diagonal = False)
# if clust_sizes.max() < 10: # if it's a tiny RF, set it to nans
# rf_clust = np.empty(rf_clust.shape) * np.nan
rf_mask = rf_clust > 0
# find evoked psth
ev_psth = RF.calc_evoked_psth(rast, stimparams, rf_mask)
ev_psth_smoo = Spikes.exp_smoo(ev_psth, tau = 0.003)
ev_resp_on, ev_resp_off = Spikes.calc_on_off(ev_psth_smoo, stim_on = stim_on)
ev_mean = ev_psth[ev_resp_on : ev_resp_off].mean()
# bandwidth and threshold
bw, bw_lr, _, thresh = RF.calc_bw_cf_thresh(rf_mask)
# center of mass
com = RF.calc_rf_com(rf_clust)
tip_top = np.max([thresh-2, 0])
tip_bottom = thresh
com_tip = RF.calc_rf_com(rf_clust[tip_top:tip_bottom, :])
'''PLOT'''
if pplot:
rf1_ax = fig.add_subplot(221)
rf2_ax = fig.add_subplot(222)
psth1_ax = fig.add_subplot(223)
psth2_ax = fig.add_subplot(224)
RF.plot_RF(rf, bw_lr = bw_lr, thresh = thresh, cf = cf_man, ax = rf1_ax)
RF.plot_RF(rf_clust, bw_lr = bw_lr, thresh = thresh, cf = cf_man, ax = rf2_ax)
rf2_ax.axvline(com, color = 'g', ls = '--')
rf2_ax.axvline(com_tip, color = 'b', ls = '--')
psth1_ax.plot(psth_smoo)
psth2_ax.plot(ev_psth_smoo)
psth1_ax.axvline(resp_on+stim_on, color = 'r', ls = '--')
psth1_ax.axvline(resp_off+stim_on, color = 'r', ls = '--')
figpath = os.path.join(savedir, blockname + '.png')
fig.savefig(figpath);
fig.clf()
'''PLOT'''
DB.resize(DB.size + 1)
DB[-1] = np.array((gen, exp, sess, unitnum, \
psth[:333], ev_psth[:333], \
rf, rf_clust, \
cf_man, com, com_tip, \
bw, bw_lr, thresh, coord, \
resp_on, resp_off, ev_resp_on, ev_resp_off, \
base_mean, ev_mean), dtype = dtype)
# end unit loop
np.savez(os.path.join(basedir, experiment, 'Sessions', sess, sess + '_RF.npz'), DB = DB)
if verbose:
print '\n'*4