def estimate_beta_band(session,area,bw=8,epoch=None,doplot=False):
'''
return betapeak-0.5*bw,betapeak+0.5*bw
'''
print 'THIS IS NOT THE ONE YOU WANT TO USE'
print 'IT IS EXPERIMENTAL COHERENCE BASED IDENTIFICATION OF BETA'
assert 0
if epoch is None: epoch = (6,-1000,3000)
allco = []
if not area is None:
chs = get_good_channels(session,area)[:2]
for a in chs:
for b in chs:
if a==b: continue
for tr in get_good_trials(session):
x = get_filtered_lfp(session,area,a,tr,epoch,None,300)
y = get_filtered_lfp(session,area,b,tr,epoch,None,300)
co,fr = cohere(x,y,Fs=1000,NFFT=256)
allco.append(co)
else:
for area in areas:
chs = get_good_channels(session,area)[:2]
for a in chs:
for b in chs:
if a==b: continue
for tr in get_good_trials(session):
x = get_filtered_lfp(session,area,a,tr,epoch,None,300)
y = get_filtered_lfp(session,area,b,tr,epoch,None,300)
co,fr = cohere(x,y,Fs=1000,NFFT=256)
allco.append(co)
allco = array(allco)
m = mean(allco,0)
sem = std(allco,0)/sqrt(shape(allco)[0])
# temporary in lieu of multitaper
smooth = ceil(float(bw)/(diff(fr)[0]))
smoothed = convolve(m,ones(smooth)/smooth,'same')
use = (fr<=56)&(fr>=5)
betafr = (fr<=30-0.5*bw)&(fr>=15+0.5*bw)
betapeak = fr[betafr][argmax(smoothed[betafr])]
if doplot:
clf()
plot(fr[use],m[use],lw=2,color='k')
plot(fr[use],smoothed[use],lw=1,color='r')
plot(fr[use],(m+sem)[use],lw=1,color='k')
plot(fr[use],(m-sem)[use],lw=1,color='k')
positivey()
xlim(*rangeover(fr[use]))
shade([[betapeak-0.5*bw],[betapeak+0.5*bw]])
draw()
return betapeak-0.5*bw,betapeak+0.5*bw
def get_high_low_beta_firing_rates(session,area,unit,epoch,fa,fb):
Fs=1000
'''
Computes the unit firing rates during high and low beta events for
the given task epoch. Good trials only. Defaults to Fs = 1000
returns threshold, event_rate, nonevent_rate
'''
threshold,events = get_high_beta_events(session,area,get_unit_channel(session,area,unit),epoch,lowf=fa,highf=fb)
spikes = get_spikes_session_filtered_by_epoch(session,area,unit,epoch)
n_total_spikes = len(spikes)
n_total_times = len(get_good_trials(session))*(epoch[-1]-epoch[-2])
events = array(events)
if shape(events)[0]==0:
print 'NO EVENTS!!!!!!!'
return threshold, NaN, Fs*float(n_total_spikes)/n_total_times
# linear time solution exists but quadratic time solution is quicker to code.
n_event_spikes = sum((events[:,1][:,None]>=spikes[None,:])
&(events[:,0][:,None]<=spikes[None,:]))
n_nonevent_spikes = n_total_spikes-n_event_spikes
n_event_times = sum(events[:,1]-events[:,0])
n_nonevent_times = n_total_times - n_event_times
event_rate = Fs*float(n_event_spikes)/n_event_times
nonevent_rate = Fs*float(n_nonevent_spikes)/n_nonevent_times
print session,area,unit,epoch,event_rate,nonevent_rate, threshold
return threshold, event_rate, nonevent_rate
def get_beta_peak(session,area,epoch,fa,fb):
# determine beta peak
Fs=1000
allspec=[]
for trial in get_good_trials(session):
x = get_all_raw_lfp(session, area, trial, epoch)
f,mts = multitaper_spectrum(x,5,Fs)
allspec.append(mts)
allspec = arr(allspec)
Ntr,Nch,Nti = shape(allspec)
meanspec = mean(allspec,axis=(0,1))
peaks,vals = local_maxima(meanspec)
betapeaks = peaks[(f[peaks]>fa)&(f[peaks]<fb)]
betapeak = f[betapeaks][argmax(meanspec[betapeaks])]
return betapeak
def get_high_and_low_beta_spikes(session,area,unit,epoch,fa,fb):
'''
threshold, event_spikes, nonevent_spikes = get_high_and_low_beta_spikes(session,area,unit,epoch,ishighbeta)
'''
threshold,events = get_high_beta_events(session,area,get_unit_channel(session,area,unit),epoch,lowf=fa,highf=fb)
spikes = get_spikes_session_filtered_by_epoch(session,area,unit,epoch)
n_total_spikes = len(spikes)
n_total_times = len(get_good_trials(session))*(epoch[-1]-epoch[-2])
events = array(events)
if shape(events)[0]==0:
print 'NO EVENTS!!!!!!!'
return threshold, NaN, Fs*float(n_total_spikes)/n_total_times
event_spikes = (events[:,1][:,None]>=spikes[None,:])\
&(events[:,0][:,None]<=spikes[None,:])
is_in_event = sum(event_spikes,0)
return threshold, spikes[is_in_event==1], spikes[is_in_event==0]
def get_high_beta_events(session,area,channel,epoch,
MINLEN = 40, # ms
BOXLEN = 50, # ms
THSCALE = 1.5, # sigma (standard deviations)
lowf = 10.0, # Hz
highf = 45.0, # Hz
pad = 200, # ms
clip = True,
audit = False
):
'''
get_high_beta_events(session,area,channel,epoch) will identify periods of
elevated beta-frequency power for the given channel.
Thresholds are selected per-channel based on all available trials.
The entire trial time is used when estimating the average beta power.
To avoid recomputing, we extract beta events for all trials at once.
By default events that extend past the edge of the specified epoch will
be clipped. Passing clip=False will discard these events.
returns the event threshold, and a list of event start and stop
times relative to session time (not per-trial or epoch time)
passing audit=True will enable previewing each trial and the isolated
beta events.
>>> thr,events = get_high_beta_events('SPK120925','PMd',50,(6,-1000,0))
'''
# get LFP data
signal = get_raw_lfp_session(session,area,channel)
# esimate threshold for beta events
beta_trials = [get_filtered_lfp(session,area,channel,t,(6,-1000,0),lowf,highf) for t in get_good_trials(session)]
threshold = np.std(beta_trials)*THSCALE
print 'threshold=',threshold
N = len(signal)
event,start,stop = epoch
all_events = []
all_high_beta_times = []
for trial in get_good_trials(session):
evt = get_trial_event(session,area,trial,event)
trialstart = get_trial_event(session,area,trial,4)
epochstart = evt + start + trialstart
epochstop = evt + stop + trialstart
tstart = max(0,epochstart-pad)
tstop = min(N,epochstop +pad)
filtered = bandfilter(signal[tstart:tstop],lowf,highf)
envelope = abs(hilbert(filtered))
smoothed = convolve(envelope,ones(BOXLEN)/float(BOXLEN),'same')
E = array(get_edges(smoothed>threshold))+tstart
E = E[:,(diff(E,1,0)[0]>=MINLEN)
& (E[0,:]<epochstop )
& (E[1,:]>epochstart)]
if audit: print E
if clip:
E[0,:] = np.maximum(E[0,:],epochstart)
E[1,:] = np.minimum(E[1,:],epochstop )
else:
E = E[:,(E[1,:]<=epochstop)&(E[0,:]>=epochstart)]
if audit:
clf()
axvspan(epochstart,epochstop,color=(0,0,0,0.25))
plot(arange(tstart,tstop),filtered,lw=0.7,color='k')
plot(arange(tstart,tstop),envelope,lw=0.7,color='r')
plot(arange(tstart,tstop),smoothed,lw=0.7,color='b')
ylim(-80,80)
for a,b in E.T:
axvspan(a,b,color=(1,0,0,0.5))
axhline(threshold,color='k',lw=1.5)
xlim(tstart,tstop)
draw()
wait()
all_events.extend(E.T)
assert all(diff(E,0,1)>=MINLEN)
return threshold, all_events
