def band_select(spikeTimeStamps, eventOnsetTimes, amplitudes, bandwidths, timeRange, fullRange = [0.0, 2.0]):
numBands = np.unique(bandwidths)
numAmps = np.unique(amplitudes)
spikeArray = np.zeros((len(numBands), len(numAmps)))
errorArray = np.zeros_like(spikeArray)
trialsEachCond = behavioranalysis.find_trials_each_combination(bandwidths,
numBands,
amplitudes,
numAmps)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps,
eventOnsetTimes,
fullRange)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
baseTimeRange = [timeRange[1]+0.5, fullRange[1]]
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange)
baselineSpikeRate = np.mean(baseSpikeCountMat)/(baseTimeRange[1]-baseTimeRange[0])
plt.hold(True)
for amp in range(len(numAmps)):
trialsThisAmp = trialsEachCond[:,:,amp]
for band in range(len(numBands)):
trialsThisBand = trialsThisAmp[:,band]
if spikeCountMat.shape[0] != len(trialsThisBand):
spikeCountMat = spikeCountMat[:-1,:]
print "FIXME: Using bad hack to make event onset times equal number of trials"
thisBandCounts = spikeCountMat[trialsThisBand].flatten()
spikeArray[band, amp] = np.mean(thisBandCounts)
errorArray[band,amp] = stats.sem(thisBandCounts)
return spikeArray, errorArray, baselineSpikeRate
def at_best_freq(spikeTimeStamps, eventOnsetTimes, charFreq, frequencies, timeRange=[0.0,0.1], fullRange = [0.0, 0.7]):
atBestFreq = False
numFreqs = np.unique(frequencies)
spikeArray = np.zeros(len(numFreqs))
trialsEachCond = behavioranalysis.find_trials_each_type(frequencies, numFreqs)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps,
eventOnsetTimes,
fullRange)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
baseTimeRange = [timeRange[1]+0.2, fullRange[1]]
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange)
baselineSpikeRate = np.mean(baseSpikeCountMat)/(baseTimeRange[1]-baseTimeRange[0])
baselineSpikeSDev = np.std(baseSpikeCountMat)/(baseTimeRange[1]-baseTimeRange[0])
for freq in range(len(numFreqs)):
trialsThisFreq = trialsEachCond[:,freq]
if spikeCountMat.shape[0] != len(trialsThisFreq):
spikeCountMat = spikeCountMat[:-1,:]
print "FIXME: Using bad hack to make event onset times equal number of trials"
thisFreqCounts = spikeCountMat[trialsThisFreq].flatten()
spikeArray[freq] = np.mean(thisFreqCounts)/(timeRange[1]-timeRange[0])
bestFreqIndex = np.argmax(spikeArray)
bestFreq = numFreqs[bestFreqIndex]
minIndex = bestFreqIndex-1 if bestFreqIndex>0 else 0
maxIndex = bestFreqIndex+1 if bestFreqIndex<(len(numFreqs)-1) else len(numFreqs)-1
bestFreqs = [numFreqs[minIndex], numFreqs[maxIndex]]
if charFreq >= bestFreqs[0] and charFreq <= bestFreqs[1]:
if np.max(spikeArray) > (baselineSpikeRate + baselineSpikeSDev):
atBestFreq = True
return atBestFreq, bestFreq
def laser_response(spikeTimeStamps, eventOnsetTimes, timeRange=[0.0, 0.1], baseRange=[0.5, 0.6]):
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, eventOnsetTimes, [min(timeRange),max(baseRange)])
zStatsEachRange,pValueEachRange,maxZvalue = spikesanalysis.response_score(spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange, timeRange)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
baselineSpikeRate = np.mean(baseSpikeCountMat)/(baseRange[1]-baseRange[0])
laserSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
laserSpikeRate = np.mean(laserSpikeCountMat)/(timeRange[1]-timeRange[0])
return (laserSpikeRate > baselineSpikeRate and pValueEachRange[0] < 0.00001)
def calculate_tuning_curve_inputs(spikeTimeStamps, eventOnsetTimes, firstSort, secondSort, timeRange, baseRange=[-1.1,-0.1], errorType = 'sem', info='full'):
fullTimeRange = [min(min(timeRange),min(baseRange)), max(max(timeRange),max(baseRange))]
numFirst = np.unique(firstSort)
numSec = np.unique(secondSort)
duration = timeRange[1]-timeRange[0]
spikeArray = np.zeros((len(numFirst), len(numSec)))
errorArray = np.zeros_like(spikeArray)
trialsEachCond = behavioranalysis.find_trials_each_combination(firstSort,
numFirst,
secondSort,
numSec)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps,
eventOnsetTimes,
fullTimeRange)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
baselineSpikeRate = np.mean(baseSpikeCountMat)/(baseRange[1]-baseRange[0])
if errorType == 'sem':
baselineError = stats.sem(baseSpikeCountMat)/(baseRange[1]-baseRange[0])
elif errorType == 'std':
baselineError = np.std(baseSpikeCountMat)/(baseRange[1]-baseRange[0])
for sec in range(len(numSec)):
trialsThisSec = trialsEachCond[:,:,sec]
for first in range(len(numFirst)):
trialsThisFirst = trialsThisSec[:,first]
if spikeCountMat.shape[0] != len(trialsThisFirst):
spikeCountMat = spikeCountMat[:-1,:]
if any(trialsThisFirst):
thisFirstCounts = spikeCountMat[trialsThisFirst].flatten()
spikeArray[first,sec] = np.mean(thisFirstCounts)/duration
if errorType == 'sem':
errorArray[first,sec] = stats.sem(thisFirstCounts)/duration
elif errorType == 'std':
errorArray[first,sec] = np.std(thisFirstCounts)/duration
else:
spikeArray[first,sec] = np.nan
errorArray[first,sec] = np.nan
if info=='full':
tuningDict = {'responseArray':spikeArray,
'errorArray':errorArray,
'baselineSpikeRate':baselineSpikeRate,
'baselineSpikeError':baselineError,
'spikeCountMat':spikeCountMat,
'trialsEachCond':trialsEachCond}
elif info=='plotting':
tuningDict = {'responseArray':spikeArray,
'errorArray':errorArray,
'baselineSpikeRate':baselineSpikeRate,
'baselineSpikeError':baselineError}
else:
raise NameError('That is not an info type you degenerate')
return tuningDict
def onset_sustained_spike_proportion(spikeTimeStamps, eventOnsetTimes, onsetTimeRange=[0.0,0.05], sustainedTimeRange=[0.2,1.0]):
fullTimeRange = [onsetTimeRange[0], sustainedTimeRange[1]]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(spikeTimeStamps,
eventOnsetTimes,
fullTimeRange)
onsetSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, onsetTimeRange)
sustainedSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, sustainedTimeRange)
fullSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, fullTimeRange)
propOnset = 1.0*sum(onsetSpikeCountMat)/sum(fullSpikeCountMat)
propSustained = 1.0*sum(sustainedSpikeCountMat)/sum(fullSpikeCountMat)
return propOnset, propSustained
def laser_response(eventOnsetTimes, spikeTimeStamps, timeRange=[0.0, 0.1], baseRange=[-0.2, -0.1]):
fullTimeRange = [min(min(timeRange),min(baseRange)), max(max(timeRange),max(baseRange))]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(spikeTimeStamps,
eventOnsetTimes,
fullTimeRange)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
baselineSpikeRate = np.mean(baseSpikeCountMat)/(baseRange[1]-baseRange[0])
baselineSpikeRateSTD = np.std(baseSpikeCountMat)/(baseRange[1]-baseRange[0])
laserSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
laserSpikeRate = np.mean(laserSpikeCountMat)/(timeRange[1]-timeRange[0])
laserpVal = stats.ranksums(laserSpikeCountMat, baseSpikeCountMat)[1]
laserstdFromBase = (laserSpikeRate - baselineSpikeRate)/baselineSpikeRateSTD
return laserpVal, laserstdFromBase
def hist_sound_allFreq_switching():
rightward = bdata['choice']==bdata.labels['choice']['right']
leftward = bdata['choice']==bdata.labels['choice']['left']
invalid = bdata['outcome']==bdata.labels['outcome']['invalid']
correct = bdata['outcome']==bdata.labels['outcome']['correct']
correctRightward = rightward & correct
correctLeftward = leftward & correct
possibleFreq = np.unique(bdata['targetFrequency'])
Freq = possibleFreq[Frequency]
oneFreq = bdata['targetFrequency'] == Freq
trialsToUseRight = rightward & oneFreq
trialsToUseLeft = leftward & oneFreq
lowFreq = ((bdata['targetFrequency'] == possibleFreq[0]) & correct)
highFreq = ((bdata['targetFrequency'] == possibleFreq[2]) & correct)
trialsEachCond = np.c_[highFreq,trialsToUseLeft,trialsToUseRight,lowFreq]; colorEachCond = ['b','r','g','y']
timeVec = np.arange(timeRange[0],timeRange[-1],binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,timeVec)
smoothWinSize = 3
extraplots.plot_psth(spikeCountMat/binWidth,smoothWinSize,timeVec,trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,linestyle=None,linewidth=2,downsamplefactor=1)
plt.xlabel('Time from sound onset (s)')
plt.ylabel('Firing rate (spk/sec)')
def hist_movement_allFreq_switching(ax):
rightward = bdata['choice']==bdata.labels['choice']['right']
leftward = bdata['choice']==bdata.labels['choice']['left']
invalid = bdata['outcome']==bdata.labels['outcome']['invalid']
correct = bdata['outcome']==bdata.labels['outcome']['correct']
correctRightward = rightward & correct
correctLeftward = leftward & correct
possibleFreq = np.unique(bdata['targetFrequency'])
Freq = possibleFreq[Frequency]
oneFreq = bdata['targetFrequency'] == Freq
trialsToUseRight = rightward & oneFreq
trialsToUseLeft = leftward & oneFreq
lowFreq = ((bdata['targetFrequency'] == possibleFreq[0]) & correct)
highFreq = ((bdata['targetFrequency'] == possibleFreq[2]) & correct)
trialsEachCond = np.c_[lowFreq,trialsToUseRight,trialsToUseLeft,highFreq]; colorEachCond = ['y','g','r','b']
timeVec = np.arange(timeRange[0],timeRange[-1],binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromMovementOnset,indexLimitsEachMovementTrial,timeVec)
smoothWinSize = 3
extraplots.plot_psth(spikeCountMat/binWidth,smoothWinSize,timeVec,trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,linestyle=None,linewidth=2,downsamplefactor=1)
ax.axvline(x=0, ymin=0, ymax=1, color='r')
def hist_movement_psycurve(Frequency):
rightward = bdata['choice']==bdata.labels['choice']['right']
leftward = bdata['choice']==bdata.labels['choice']['left']
invalid = bdata['outcome']==bdata.labels['outcome']['invalid']
possibleFreq = np.unique(bdata['targetFrequency'])
Freq = possibleFreq[Frequency]
oneFreq = bdata['targetFrequency'] == Freq
trialsToUseRight = rightward & oneFreq
trialsToUseLeft = leftward & oneFreq
trialsEachCond = np.c_[trialsToUseLeft,trialsToUseRight]; colorEachCond = ['r','g']
timeVec = np.arange(timeRange[0],timeRange[-1],binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromMovementOnset,indexLimitsEachMovementTrial,timeVec)
smoothWinSize = 3
extraplots.plot_psth(spikeCountMat/binWidth,smoothWinSize,timeVec,trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,linestyle=None,linewidth=3,downsamplefactor=1)
plt.xlabel('Time from center poke out (s)')
plt.ylabel('Firing rate (spk/sec)')
'''
def hist_sound_block_switching():
correct = bdata['outcome']==bdata.labels['outcome']['correct']
possibleFreq = np.unique(bdata['targetFrequency'])
Freq = possibleFreq[Frequency]
oneFreq = bdata['targetFrequency'] == Freq
correctOneFreq = oneFreq & correct
trialsEachBlock = bdata.blocks['trialsEachBlock']
correctTrialsEachBlock = trialsEachBlock & correctOneFreq[:,np.newaxis]
correctBlockSizes = sum(correctTrialsEachBlock)
if (correctBlockSizes[-1] < minBlockSize): #Just a check to see if last block is too small to plot
blockSizes = sum(trialsEachBlock)
numBlocks = len(trialsEachBlock[0])
sumBlocks = sum(blockSizes)
newTrialsLastBlock = np.zeros((blockSizes[-1],numBlocks), dtype=np.bool)
correctTrialsEachBlock[(sumBlocks-blockSizes[-1]):] = newTrialsLastBlock #if the last block is too small, make the condition for the last trial all false
#correctTrialsEachBlock = trialsEachBlock & correctOneFreq[:,np.newaxis]
trialsEachCond = correctTrialsEachBlock;
if bdata['currentBlock'][0]==bdata.labels['currentBlock']['low_boundary']:
colorEachBlock = 4*['g','r']
else:
colorEachBlock = 4*['r','g']
timeVec = np.arange(timeRange[0],timeRange[-1],binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,timeVec)
smoothWinSize = 3
extraplots.plot_psth(spikeCountMat/binWidth,smoothWinSize,timeVec,trialsEachCond=trialsEachCond,
colorEachCond=colorEachBlock,linestyle=None,linewidth=2,downsamplefactor=1)
plt.xlabel('Time from sound onset (s)')
plt.ylabel('Firing rate (spk/sec)')
def laser_response(ephysData, baseRange = [-0.05,-0.04], responseRange = [0.0, 0.01]):
fullTimeRange = [baseRange[0], responseRange[1]]
eventOnsetTimes = ephysData['events']['laserOn']
spikeTimestamps = ephysData['spikeTimes']
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = \
spikesanalysis.eventlocked_spiketimes(spikeTimestamps,
eventOnsetTimes,
fullTimeRange)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
baseRange)
laserSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
responseRange)
[testStatistic, pVal] = stats.ranksums(laserSpikeCountMat, baseSpikeCountMat)
return testStatistic, pVal
def noise_raster(ephysData, gs):
plt.subplot(gs[0, 1])
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimeStamps = ephysData['spikeTimes']
timeRange = [-0.3, 0.6]
baseTimeRange = [-0.15, -0.05]
trialsEachCond = []
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, eventOnsetTimes, timeRange)
baseSpikeMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange)
base_avg = np.mean(baseSpikeMat) / (baseTimeRange[1] - baseTimeRange[0])
base_sem = stats.sem(baseSpikeMat) / (baseTimeRange[1] - baseTimeRange[0])
pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange,
trialsEachCond=trialsEachCond)
title = "Noise Bursts (Base FR: {} +/- {} spikes/s)".format(round(base_avg, 2), round(base_sem, 2))
#title = "Noise Bursts (Base FR: {} spikes/s)".format(round(base_avg, 2))
#title = "Noise Bursts"
xlabel = 'Time from sound onset (s)'
ylabel = 'Trial'
plt.title(title, fontsize = 'medium')
plt.xlabel(xlabel)
plt.ylabel(ylabel)
'''
def plot_sorted_psth(spikeTimeStamps, eventOnsetTimes, sortArray, timeRange=[-0.5,1], binsize = 50, lw=2, plotLegend=False, *args, **kwargs):
'''
Function to accept spike timestamps, event onset times, and a sorting array and plot a
PSTH sorted by the sorting array
Args:
binsize (float) = size of bins for PSTH in ms
'''
binsize = binsize/1000.0
# If a sort array is supplied, find the trials that correspond to each value of the array
if len(sortArray) > 0:
trialsEachCond = behavioranalysis.find_trials_each_type(
sortArray, np.unique(sortArray))
else:
trialsEachCond = []
# Align spiketimestamps to the event onset times for plotting
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, eventOnsetTimes, [timeRange[0]-binsize, timeRange[1]])
binEdges = np.around(np.arange(timeRange[0]-binsize, timeRange[1]+2*binsize, binsize), decimals=2)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges)
pPSTH = extraplots.plot_psth(spikeCountMat/binsize, 1, binEdges[:-1], trialsEachCond, *args, **kwargs)
plt.setp(pPSTH, lw=lw)
plt.hold(True)
zline = plt.axvline(0,color='0.75',zorder=-10)
plt.xlim(timeRange)
if plotLegend:
if len(sortArray)>0:
sortElems = np.unique(sortArray)
for ind, pln in enumerate(pPSTH):
pln.set_label(sortElems[ind])
# ax = plt.gca()
# plt.legend(mode='expand', ncol=3, loc='best')
plt.legend(ncol=3, loc='best')
def band_select_plot(spikeTimeStamps, eventOnsetTimes, amplitudes, bandwidths, timeRange, fullRange = [0.0, 2.0], title=None):
numBands = np.unique(bandwidths)
numAmps = np.unique(amplitudes)
spikeArray = np.zeros((len(numBands), len(numAmps)))
errorArray = np.zeros_like(spikeArray)
trialsEachCond = behavioranalysis.find_trials_each_combination(bandwidths,
numBands,
amplitudes,
numAmps)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps,
eventOnsetTimes,
fullRange)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
baseTimeRange = [timeRange[1]+0.5, fullRange[1]]
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange)
baselineSpikeRate = np.mean(baseSpikeCountMat)/(baseTimeRange[1]-baseTimeRange[0])
plt.hold(True)
for amp in range(len(numAmps)):
trialsThisAmp = trialsEachCond[:,:,amp]
for band in range(len(numBands)):
trialsThisBand = trialsThisAmp[:,band]
if spikeCountMat.shape[0] != len(trialsThisBand):
spikeCountMat = spikeCountMat[:-1,:]
print "FIXME: Using bad hack to make event onset times equal number of trials"
thisBandCounts = spikeCountMat[trialsThisBand].flatten()
spikeArray[band, amp] = np.mean(thisBandCounts)
errorArray[band,amp] = stats.sem(thisBandCounts)
xrange = range(len(numBands))
plt.plot(xrange, baselineSpikeRate*(timeRange[1]-timeRange[0])*np.ones(len(numBands)), color = '0.75', linewidth = 2)
plt.plot(xrange, spikeArray[:,0].flatten(), '-o', color = '#4e9a06', linewidth = 3)
plt.fill_between(xrange, spikeArray[:,0].flatten() - errorArray[:,0].flatten(),
spikeArray[:,0].flatten() + errorArray[:,0].flatten(), alpha=0.2, edgecolor = '#8ae234', facecolor='#8ae234')
plt.plot(range(len(numBands)), spikeArray[:,1].flatten(), '-o', color = '#5c3566', linewidth = 3)
plt.fill_between(xrange, spikeArray[:,1].flatten() - errorArray[:,1].flatten(),
spikeArray[:,1].flatten() + errorArray[:,1].flatten(), alpha=0.2, edgecolor = '#ad7fa8', facecolor='#ad7fa8')
ax = plt.gca()
ax.set_xticklabels(numBands)
plt.xlabel('bandwidth (octaves)')
plt.ylabel('Average num spikes')
#patch1 = mpatches.Patch(color='#5c3566', label='0.8')
#patch2 = mpatches.Patch(color='#4e9a06', label='0.2')
#plt.legend(handles=[patch1, patch2], bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
if title:
plt.title(title)
def stim_response(ephysData, baseRange = [-0.05,-0.04], responseRange = [0.0, 0.01], stimType = 'laser'):
fullTimeRange = [baseRange[0], responseRange[1]]
if stimType == 'laser':
eventOnsetTimes = ephysData['events']['laserOn']
elif stimType == 'sound':
eventOnsetTimes = get_sound_onset_times(ephysData, 'bandwidth')
spikeTimestamps = ephysData['spikeTimes']
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = \
spikesanalysis.eventlocked_spiketimes(spikeTimestamps,
eventOnsetTimes,
fullTimeRange)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
baseRange)
laserSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
responseRange)
[testStatistic, pVal] = stats.ranksums(laserSpikeCountMat, baseSpikeCountMat)
return testStatistic, pVal
def best_window_freq_tuning(spikeTimesFromEventOnset,indexLimitsEachTrial, trialsEachFreq, windowsToTry = [[0.0,0.1],[0.0,0.05],[0.1,0.15]]):
zscores = np.zeros((len(windowsToTry),trialsEachFreq.shape[1]))
for ind, window in enumerate(windowsToTry):
duration = window[1]-window[0]
baseTimeRange = [-0.1-duration, -0.1]
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, window)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange)
for ind2 in range(len(numFreqs)):
trialsThisFreq = trialsEachFreq[:,ind2]
spikeCountsThisFreq = spikeCountMat[trialsThisFreq]
baseCountsThisFreq = baseSpikeCountMat[trialsThisFreq]
zScore, pVal = stats.ranksums(spikeCountsThisFreq, baseCountsThisFreq)
zscores[ind,ind2] = zScore
maxInd = np.unravel_index(zscores.argmax(), zscores.shape)
windowToUse = windowsToTry[maxInd[0]]
return windowToUse
def sound_response_any_stimulus(eventOnsetTimes, spikeTimeStamps, bdata, timeRange=[0.0,1.0], baseRange=[-1.1,-0.1], sessionType='bandwidth', sessionIndex=None):
fullTimeRange = [min(min(timeRange),min(baseRange)), max(max(timeRange),max(baseRange))]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(spikeTimeStamps,
eventOnsetTimes,
fullTimeRange)
stimSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
baseSpikeCountMat = baseSpikeCountMat.flatten()
if sessionType == 'bandwidth':
firstSort = bdata['currentBand']
numFirst = np.unique(firstSort)
secondSort = bdata['currentAmp']
numSec = np.unique(secondSort)
elif sessionType == 'laserBandwidth':
firstSort = bdata['currentBand']
numFirst = np.unique(firstSort)
secondSort = bdata['laserTrial']
numSec = np.unique(secondSort)
totalConds = len(numFirst)*len(numSec)
trialsEachCond = behavioranalysis.find_trials_each_combination(firstSort,numFirst,secondSort,numSec)
minpVal = np.inf
for sec in range(len(numSec)):
trialsThisSec = trialsEachCond[:,:,sec]
for first in range(len(numFirst)):
trialsThisFirst = trialsThisSec[:,first]
if stimSpikeCountMat.shape[0] == len(trialsThisFirst)+1:
stimSpikeCountMat = stimSpikeCountMat[:-1,:]
#print "FIXME: Using bad hack to make event onset times equal number of trials"
elif stimSpikeCountMat.shape[0] != len(trialsThisFirst):
print "STOP NO THIS IS BAD"
raise ValueError
if any(trialsThisFirst):
thisFirstStimCounts = stimSpikeCountMat[trialsThisFirst].flatten()
pValThisFirst = stats.ranksums(thisFirstStimCounts, baseSpikeCountMat)[1]*totalConds
if pValThisFirst < minpVal:
minpVal = pValThisFirst
return minpVal
def laser_response(cell, timeRange=[0.0, 0.1], baseRange=[0.5, 0.6]):
cellInfo = get_cell_info(cell)
loader = dataloader.DataLoader(cell['subject'])
if len(cellInfo['laserIndex'])>0:
eventData = loader.get_session_events(cellInfo['ephysDirs'][cellInfo['laserIndex'][-1]])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][cellInfo['laserIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimestamps = spikeData.timestamps
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimestamps, eventOnsetTimes, [min(timeRange),max(baseRange)])
zStatsEachRange,pValueEachRange,maxZvalue = spikesanalysis.response_score(spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange, timeRange)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
baselineSpikeRate = np.mean(baseSpikeCountMat)/(baseRange[1]-baseRange[0])
laserSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
laserSpikeRate = np.mean(laserSpikeCountMat)/(timeRange[1]-timeRange[0])
laserResponse = (laserSpikeRate > baselineSpikeRate and pValueEachRange[0] < 0.00001)
else:
laserResponse = False
return laserResponse
def am_raster(bdata, ephysData, gs):
plt.subplot(gs[1, 1])
freqEachTrial = bdata['currentFreq']
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimeStamps = ephysData['spikeTimes']
timeRange = [-0.3, 0.6]
baseTimeRange = [-0.15, -0.05]
possiblefreqs = np.unique(freqEachTrial)
freqLabels = [round(x/1000, 1) for x in possiblefreqs]
trialsEachCond = behavioranalysis.find_trials_each_type(freqEachTrial, possiblefreqs)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, eventOnsetTimes, timeRange)
#print len(freqEachTrial), len(eventOnsetTimes)
baseSpikeMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange)
base_avg = np.mean(baseSpikeMat) / (baseTimeRange[1] - baseTimeRange[0])
base_sem = stats.sem(baseSpikeMat) / (baseTimeRange[1] - baseTimeRange[0])
# for freqInd, freq in enumerate(possiblefreqs):
# freq_spikecounts = spikeMat[trialsEachCond[:,freqInd]==True]
# freq_avg = np.mean(freq_spikecounts) / (soundTimeRange[1] - soundTimeRange[0])
# freq_avgs.append(freq_avg)
'''
try:
base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, baseIndexLimitsEachTrial)
except:
behavBaseIndexLimitsEachTrial = baseIndexLimitsEachTrial[0:2,:-1]
base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, behavBaseIndexLimitsEachTrial)
base_avg = np.mean(base_avgs)
base_frs = np.divide(base_avg, baseTimeRange[1] - baseTimeRange[0])
#print(base_avg)
'''
title = "Tuning Curve (Base FR: {} +/- {} spikes/s)".format(round(base_avg, 2), round(base_sem, 2))
#title = "Tuning Curve (Base FR: {} spikes/s)".format(round(base_avg, 2))
pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange,
trialsEachCond=trialsEachCond, labels=freqLabels)
xlabel = 'Time from sound onset (s)'
ylabel = 'Frequency (kHz)'
plt.title(title, fontsize = 'medium')
plt.xlabel(xlabel)
plt.ylabel(ylabel)
'''
def sound_response_any_stimulus(eventOnsetTimes, spikeTimeStamps, trialsEachCond, timeRange=[0.0,1.0], baseRange=[-1.1,-0.1]):
fullTimeRange = [min(min(timeRange),min(baseRange)), max(max(timeRange),max(baseRange))]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(spikeTimeStamps,
eventOnsetTimes,
fullTimeRange)
stimSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
minpVal = np.inf
maxzscore = -np.inf
for cond in range(trialsEachCond.shape[1]):
trialsThisCond = trialsEachCond[:,cond]
if stimSpikeCountMat.shape[0] == len(trialsThisCond)+1:
stimSpikeCountMat = stimSpikeCountMat[:-1,:]
if any(trialsThisCond):
thisFirstStimCounts = stimSpikeCountMat[trialsThisCond].flatten()
thisStimBaseSpikeCouns = baseSpikeCountMat[trialsThisCond].flatten()
thiszscore, pValThisFirst = stats.ranksums(thisFirstStimCounts, thisStimBaseSpikeCouns)
if pValThisFirst < minpVal:
minpVal = pValThisFirst
if thiszscore > maxzscore:
maxzscore = thiszscore
return maxzscore, minpVal
def modulation_index_switching():
global spikeTimesFromEventOnset
global indexLimitsEachTrial
global bdata
global titleText
stimulusRange = [0.0,0.1] #This is the length of the stimulus in seconds
Frequency = 1 #This is the middle frequency
rightward = bdata['choice']==bdata.labels['choice']['right']
leftward = bdata['choice']==bdata.labels['choice']['left']
invalid = bdata['outcome']==bdata.labels['outcome']['invalid']
correct = bdata['outcome']==bdata.labels['outcome']['correct']
correctRightward = rightward & correct
correctLeftward = leftward & correct
possibleFreq = np.unique(bdata['targetFrequency'])
oneFreq = bdata['targetFrequency'] == possibleFreq[Frequency]
trialsToUseRight = correctRightward & oneFreq
trialsToUseLeft = correctLeftward & oneFreq
trialsEachCond = [trialsToUseRight,trialsToUseLeft]
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,stimulusRange)
spikeCountEachTrial = spikeCountMat.flatten()
spikeAvgRight = sum(spikeCountEachTrial[trialsToUseRight])/float(sum(trialsToUseRight))
spikeAvgLeft = sum(spikeCountEachTrial[trialsToUseLeft])/float(sum(trialsToUseLeft))
if ((spikeAvgRight + spikeAvgLeft) == 0):
modInd = 0
else:
modInd = (spikeAvgRight - spikeAvgLeft)/(spikeAvgRight + spikeAvgLeft)
mod_sig = spikesanalysis.evaluate_modulation(spikeTimesFromEventOnset,indexLimitsEachTrial,stimulusRange,trialsEachCond)
titleText = 'Modulation Index: '+str(round(modInd,3))+', significance (p value): '+ str(round(mod_sig[1],3))
def hist_sound_psycurve(Frequency,ax):
rightward = bdata['choice']==bdata.labels['choice']['right']
leftward = bdata['choice']==bdata.labels['choice']['left']
invalid = bdata['outcome']==bdata.labels['outcome']['invalid']
possibleFreq = np.unique(bdata['targetFrequency'])
Freq = possibleFreq[Frequency]
oneFreq = bdata['targetFrequency'] == Freq
trialsToUseRight = rightward & oneFreq
trialsToUseLeft = leftward & oneFreq
trialsEachCond = np.c_[trialsToUseLeft,trialsToUseRight]; colorEachCond = ['r','g']
timeVec = np.arange(timeRange[0],timeRange[-1],binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,timeVec)
smoothWinSize = 3
extraplots.plot_psth(spikeCountMat/binWidth,smoothWinSize,timeVec,trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,linestyle=None,linewidth=3,downsamplefactor=1)
ax.axvspan(0.0, 0.1, color=[0.8,0.8,0.8], alpha=0.5, lw=0)
def plot_rew_change_per_cell(oneCell,trialLimit=[],alignment='sound'):
'''
Plots raster and PSTH for one cell during reward_change_freq_dis task, split by block; alignment parameter should be set to either 'sound', 'center-out', or 'side-in'.
'''
bdata = load_behav_per_cell(oneCell)
(spikeTimestamps,waveforms,eventOnsetTimes,eventData) = load_ephys_per_cell(oneCell)
# -- Check to see if ephys has skipped trials, if so remove trials from behav data
soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel)
soundOnsetTimeEphys = eventOnsetTimes[soundOnsetEvents]
soundOnsetTimeBehav = bdata['timeTarget']
# Find missing trials
missingTrials = behavioranalysis.find_missing_trials(soundOnsetTimeEphys,soundOnsetTimeBehav)
# Remove missing trials
bdata.remove_trials(missingTrials)
currentBlock = bdata['currentBlock']
blockTypes = [bdata.labels['currentBlock']['same_reward'],bdata.labels['currentBlock']['more_left'],bdata.labels['currentBlock']['more_right']]
#blockLabels = ['more_left', 'more_right']
if(not len(trialLimit)):
validTrials = np.ones(len(currentBlock),dtype=bool)
else:
validTrials = np.zeros(len(currentBlock),dtype=bool)
validTrials[trialLimit[0]:trialLimit[1]] = 1
trialsEachType = behavioranalysis.find_trials_each_type(currentBlock,blockTypes)
if alignment == 'sound':
soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
elif alignment == 'center-out':
soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
diffTimes=bdata['timeCenterOut']-bdata['timeTarget']
EventOnsetTimes+=diffTimes
elif alignment == 'side-in':
soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
diffTimes=bdata['timeSideIn']-bdata['timeTarget']
EventOnsetTimes+=diffTimes
freqEachTrial = bdata['targetFrequency']
possibleFreq = np.unique(freqEachTrial)
rightward = bdata['choice']==bdata.labels['choice']['right']
leftward = bdata['choice']==bdata.labels['choice']['left']
invalid = bdata['outcome']==bdata.labels['outcome']['invalid']
correct = bdata['outcome']==bdata.labels['outcome']['correct']
incorrect = bdata['outcome']==bdata.labels['outcome']['error']
######Split left and right trials into correct and incorrect categories to look at error trials#########
rightcorrect = rightward&correct&validTrials
leftcorrect = leftward&correct&validTrials
#righterror = rightward&incorrect&validTrials
#lefterror = leftward&incorrect&validTrials
rightcorrectBlockSameReward = rightcorrect&trialsEachType[:,0]
rightcorrectBlockMoreLeft = rightcorrect&trialsEachType[:,1]
rightcorrectBlockMoreRight = rightcorrect&trialsEachType[:,2]
leftcorrectBlockSameReward = leftcorrect&trialsEachType[:,0]
leftcorrectBlockMoreLeft = leftcorrect&trialsEachType[:,1]
leftcorrectBlockMoreRight = leftcorrect&trialsEachType[:,2]
trialsEachCond = np.c_[leftcorrectBlockMoreLeft,rightcorrectBlockMoreLeft,leftcorrectBlockMoreRight,rightcorrectBlockMoreRight,leftcorrectBlockSameReward,rightcorrectBlockSameReward]
colorEachCond = ['g','r','m','b','y','darkgray']
#trialsEachCond = np.c_[invalid,leftcorrect,rightcorrect,lefterror,righterror]
#colorEachCond = ['0.75','g','r','b','m']
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spikeTimestamps,EventOnsetTimes,timeRange)
###########Plot raster and PSTH#################
plt.figure()
ax1 = plt.subplot2grid((8,5), (0, 0), rowspan=4,colspan=5)
extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange,trialsEachCond=trialsEachCond,colorEachCond=colorEachCond,fillWidth=None,labels=None)
plt.ylabel('Trials')
plt.xlim(timeRange)
plt.title('{0}_{1}_TT{2}_c{3}_{4}'.format(oneCell.animalName,oneCell.behavSession,oneCell.tetrode,oneCell.cluster,alignment))
timeVec = np.arange(timeRange[0],timeRange[-1],binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,timeVec)
smoothWinSize = 3
ax2 = plt.subplot2grid((8,5), (4, 0),colspan=5,rowspan=2,sharex=ax1)
extraplots.plot_psth(spikeCountMat/binWidth,smoothWinSize,timeVec,trialsEachCond=trialsEachCond,colorEachCond=colorEachCond,linestyle=None,linewidth=3,downsamplefactor=1)
plt.xlabel('Time from {0} onset (s)'.format(alignment))
plt.ylabel('Firing rate (spk/sec)')
# -- Plot ISI histogram --
plt.subplot2grid((8,5), (6,0), rowspan=1, colspan=2)
spikesorting.plot_isi_loghist(spikeTimestamps)
plt.ylabel('c%d'%oneCell.cluster,rotation=0,va='center',ha='center')
plt.xlabel('')
# -- Plot waveforms --
plt.subplot2grid((8,5), (7,0), rowspan=1, colspan=3)
spikesorting.plot_waveforms(waveforms)
# -- Plot projections --
plt.subplot2grid((8,5), (6,2), rowspan=1, colspan=3)
spikesorting.plot_projections(waveforms)
# -- Plot events in time --
plt.subplot2grid((8,5), (7,3), rowspan=1, colspan=2)
spikesorting.plot_events_in_time(spikeTimestamps)
plt.subplots_adjust(wspace = 0.7)
#plt.show()
#fig_path =
#fig_name = 'TT{0}Cluster{1}{2}.png'.format(tetrode, cluster, '_2afc plot_each_type')
#full_fig_path = os.path.join(fig_path, fig_name)
#print full_fig_path
plt.gcf().set_size_inches((8.5,11))
frequenciesEachTrialA, arrayOfFrequenciesA)
ax14 = plt.subplot2grid((4, 8), (0, 3), colspan=2)
(pRaster, hcond,
zline) = extraplots.raster_plot(spikeTimesFromEventOnsetA,
indexLimitsEachTrialA,
timeRange,
trialsEachCondA,
labels=labelsForYaxis)
plt.setp(pRaster, ms=1)
plt.xlabel('Time From Event Onset [s]', fontsize=9)
plt.ylabel('Frequency [kHz]', fontsize=9)
"""
--- PSTH ---
"""
spikeCountMatFirstOddballA = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetA, firstOddballIndexLimitsA, timeVec)
spikeCountMatSecondOddballA = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetA, secondOddballIndexLimitsA, timeVec)
spikeCountMatThirdOddballA = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetA, thirdOddballIndexLimitsA, timeVec)
spikeCountMatFirstStdA = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetA, firstStandardIndexLimitsA, timeVec)
spikeCountMatSecondStdA = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetA, secondStandardIndexLimitsA, timeVec)
spikeCountMatThirdStdA = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetA, thirdStandardIndexLimitsA, timeVec)
ax9 = plt.subplot2grid((4, 8), (3, 2))
extraplots.plot_psth(spikeCountMatFirstOddballA / binWidth,
smoothWinSizePsth,
timeVec,
def cluster_color_psth(self, sessionList, plotType=None, site=-1, experiment=-1, tuningTimeRange = [0.0,0.1]):
'''
Display cluster waveforms and a PSTH or tuning curve for each cluster.
Performs multisession clustering for each tetrode recorded at the site.
Args:
sessionList (list of indices): The indices of the sessions to be included in the multisession clustering.
plotType (list of str): A list the same length as sessionList, containing the type of plot for that session.
Current valid plotTypes are: 'psth', 'tuning'
site (index): The index of the site to pull sessions from.
experiment (index): The index of the experiment to get the site from.
tuningTimeRange (list of float): List containing [start, stop] times relative to event onset over which to
average spikes for tuning curve.
Returns nothing, but .clu files and multisession cluster reports will be created.
'''
if not isinstance(sessionList, list):
sessionList = list(sessionList)
if plotType is None:
plotType = ['psth']*len(sessionList)
#Cluster the site, all tetrodes
#TODO: Make sure this function is using nice new cms with numclusters=6
self.cluster_array_multisession(sessionList, site=site, experiment=experiment)
allSessionObj = [self.get_session_obj(session, experiment, site) for session in sessionList]
allTetrodes=[so.tetrodes for so in allSessionObj]
# allEventOnsetTimes = [self.loader.get_event_onset_times(ed) for ed in allEventData]
siteObj = self.get_site_obj(site=site, experiment=experiment)
allSessionType = [siteObj.session_types()[ind] for ind in sessionList]
self.fig = plt.gcf()
self.fig.clf()
self.fig.set_facecolor('w')
from matplotlib import gridspec
gs = gridspec.GridSpec(2*len(allTetrodes[0]), 6+6*len(sessionList))
gs.update(wspace=0.5, hspace=0.5)
nClusters=6 #FIXME hardcoded number of clusters to plot
from jaratoolbox import colorpalette
cp = colorpalette.TangoPalette
colors = [cp['SkyBlue1'], cp['Chameleon1'], cp['Orange1'],
cp['Plum1'], cp['ScarletRed1'], cp['Aluminium4']]
for indSession, sessionObj in enumerate(allSessionObj):
# sessionObj = allSessionObj[indSession]
# sessionDir = allSessionDir[indSession]
sessionDir = sessionObj.ephys_dir()
# eventData = allEventData[indSession]
# eventOnsetTimes = allEventOnsetTimes[indSession]
tetrodes = allTetrodes[indSession]
if plotType[indSession] == 'tuning':
if sessionObj.behavsuffix is None:
raise AttributeError('There is no behavior suffix recorded for this session') #TODO: add session info
behavClass = loadbehavior.BehaviorData
dateStr = ''.join(sessionObj.date.split('-'))
fullSessionStr = '{}{}'.format(dateStr, sessionObj.behavsuffix)
behavDataFilePath = loadbehavior.path_to_behavior_data(sessionObj.subject,
sessionObj.paradigm,
fullSessionStr)
bdata = behavClass(behavDataFilePath,readmode='full')
#FIXME: Hardcoded variable name to sort by for tuning
freqEachTrial = bdata['currentFreq']
freqLabels = ["%.1f"%freq for freq in np.unique(freqEachTrial)/1000]
for indt, tetrode in enumerate(tetrodes):
colStart = 6+(6*indSession)
colEnd = colStart+6
psth_ax = plt.subplot(gs[indt*2:(indt*2)+2, colStart:colEnd])
for indc, cluster in enumerate(range(1, nClusters+1)):
ephysData = ephyscore.load_ephys(sessionObj.subject, sessionObj.paradigm, sessionDir, tetrode, cluster)
spikeTimestamps = ephysData['spikeTimes']
eventOnsetTimes = ephysData['events']['stimOn']
clusterColor = colors[indc]
# spikeData= self.loader.get_session_spikes(sessionDir, tetrode, cluster)
# spikeTimestamps = spikeData.timestamps
timeRange = [-0.2, 1]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimestamps, eventOnsetTimes, timeRange)
if plotType[indSession] == 'psth':
binEdges = np.linspace(-0.2, 1, 100)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
binEdges)
# import ipdb; ipdb.set_trace()
smoothWinSize = 3
winShape = np.concatenate((np.zeros(smoothWinSize),np.ones(smoothWinSize))) # Square (causal)
winShape = winShape/np.sum(winShape)
binsStartTime=binEdges[:-1]
binSize = binEdges[1]-binEdges[0]
thisPSTH = np.mean(spikeCountMat/binSize,axis=0)
smoothPSTH = np.convolve(thisPSTH,winShape,mode='same')
downsamplefactor=1
sSlice = slice(0,len(smoothPSTH),downsamplefactor)
psth_ax.plot(binsStartTime[sSlice],smoothPSTH[sSlice], color = clusterColor, lw=2)
psth_ax.set_xlim(timeRange)
elif plotType[indSession] == 'tuning':
trialsEachCond = behavioranalysis.find_trials_each_type(freqEachTrial, np.unique(freqEachTrial))
# spikeArray = dataplotter.avg_spikes_in_event_locked_timerange_each_cond(spikeTimestamps, trialsEachCond, eventOnsetTimes, timeRange=tuningTimeRange)
spikeArray = self.avg_spikes_in_event_locked_timerange_each_cond(spikeTimestamps, trialsEachCond, eventOnsetTimes, timeRange=tuningTimeRange)
psth_ax.plot(spikeArray, ls='-', lw=2, color = clusterColor)
psth_ax.set_xticks(range(len(np.unique(freqEachTrial))))
psth_ax.set_xticklabels(freqLabels,fontsize=8)
psth_ax.hold(1)
psth_ax.axvline(x=0, color='k')
if indt==0:
psth_ax.set_title(allSessionType[indSession])
crow = indc/3 + (indt*2)
ccolStart = (indc%3)*2
ccolEnd = ccolStart+2
if indSession==0:
cluster_ax = plt.subplot(gs[crow, ccolStart:ccolEnd])
# print 'r{}c{} : Cluster {}, {} spikes'.format(crow, ccolStart, cluster, len(spikeData.timestamps))
plot_colored_waveforms(ephysData['samples'], clusterColor, ax=cluster_ax)
plt.show()
def calculate_monotonicity_index(eventOnsetTimes, currentFreq,
currentIntensity, uniqueIntensity, spikeTimes,
cf):
"""
Args:
eventOnsetTimes (np.array): Same size as the number of trials with each value being the time sound detector turned on
currentFreq (np.array): Same size as number of trials presented with each value being a specific frequency for that trial
currentIntensity (np.array): Same size as number of trials presented with each value being a specific intensity for that trial
uniqueIntensity (np.array): Uses currentIntensity to find how many unique intensity values were presented and store each unique value in ascending order
spikeTimes (np.array): Each value is a time when a spike occurred; obtained from ephys data
cf (float): Characteristic frequency of the cell, calculated by analyzing lowest threshold value for a cell
Returns:
monoIndex (float): Index value for monotonicity of a cell, between 0 and 1
overallMaxSpikes (float): Mean number of spikes at the intensity that had the most spikes for a stimulus
"""
# if len(eventOnsetTimes) != len(freqEachTrial):
# eventOnsetTimes = eventOnsetTimes[:-1]
# if len(eventOnsetTimes) != len(freqEachTrial):
# continue
# cfTrials = currentFreq == dbRow['cf'] # cf is characteristic frequency
cfTrials = currentFreq == cf
eventsThisFreq = eventOnsetTimes[cfTrials]
intenThisFreq = currentIntensity[cfTrials]
baseRange = [-0.1, 0]
responseRange = [0, 0.1]
alignmentRange = [baseRange[0], responseRange[1]]
meanSpikesAllInten = np.empty(len(uniqueIntensity))
maxSpikesAllInten = np.empty(len(uniqueIntensity))
baseSpikesAllInten = np.empty(len(uniqueIntensity))
for indInten, inten in enumerate(uniqueIntensity):
# print inten
trialsThisIntensity = intenThisFreq == inten
eventsThisCombo = eventsThisFreq[trialsThisIntensity]
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
spikeTimes, eventsThisCombo, alignmentRange)
nspkBase = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, responseRange)
spikesThisInten = nspkResp[:, 0]
baselineThisInten = nspkBase[:, 0]
# print spikesThisInten
try:
meanSpikesThisInten = np.mean(spikesThisInten)
meanBaselineSpikesThisInten = np.mean(baselineThisInten)
maxSpikesThisInten = np.max(spikesThisInten)
except ValueError:
meanSpikesThisInten = 0
maxSpikesThisInten = 0
meanBaselineSpikesThisInten = 0
meanSpikesAllInten[indInten] = meanSpikesThisInten
maxSpikesAllInten[indInten] = maxSpikesThisInten
baseSpikesAllInten[indInten] = meanBaselineSpikesThisInten
baseline = np.mean(baseSpikesAllInten)
monoIndex = (meanSpikesAllInten[-1] -
baseline) / (np.max(meanSpikesAllInten) - baseline)
overallMaxSpikes = np.max(maxSpikesAllInten)
return monoIndex, overallMaxSpikes
timeRange: (list or np.array) two-element array specifying time-range to extract around event.
spikeTimesFromEventOnset: 1D array with time of spikes locked to event.
o trialIndexForEachSpike: 1D array with the trial corresponding to each spike.
The first spike index is 0.
indexLimitsEachTrial: [2,nTrials] range of spikes for each trial. Note that
the range is from firstSpike to lastSpike+1 (like in python slices)
spikeIndices
'''
sortedIndexForEachSpike = sortingInds[trialIndexForEachSpike] #Takes values of trialIndexForEachSpike and finds value of sortingInds at that index and makes array. This array gives an array with the sorted index of each trial for each spike
# -- Calculate tuning --
responseRange = [0.010,0.10] #range of time to count spikes in after event onset
nSpikes = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,responseRange) #array of the number of spikes in range for each trial
'''Count number of spikes on each trial in a given time range.
spikeTimesFromEventOnset: vector of spikes timestamps with respect
to the onset of the event.
indexLimitsEachTrial: each column contains [firstInd,lastInd+1] of the spikes on a trial.
timeRange: time range to evaluate. Spike times exactly at the limits are not counted.
returns nSpikes
'''
meanSpikesEachFrequency = np.empty(len(possibleFreq)) #make empty array of same size as possibleFreq
# -- This part will be replace by something like behavioranalysis.find_trials_each_type --
trialsEachFreq = []
for indf,oneFreq in enumerate(possibleFreq):
trialsEachFreq.append(np.flatnonzero(freqEachTrial==oneFreq)) #finds indices of each frequency. Appends them to get an array of indices of trials sorted by freq
bandTimeRange = [-0.3, 1.5]
bandEventOnsetTimes = bandEventData.get_event_onset_times()
bandSpikeTimestamps = bandSpikeData.timestamps
bandTrialsEachCond = behavioranalysis.find_trials_each_combination(
bandEachTrial, numBands, secondSort, numSec)
bandSpikeTimesFromEventOnset, trialIndexForEachSpike, bandIndexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
bandSpikeTimestamps, bandEventOnsetTimes, bandTimeRange)
# --- produce input for bandwidth tuning curve ---
#soundDuration = 1.0
#print('WARNING! The sound duration is HARDCODED ({0} sec)'.format(soundDuration))
soundDuration = bdata['stimDur'][-1]
print('Sound duration from behavior data: {0} sec'.format(soundDuration))
timeRange = [0.0, soundDuration]
bandSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
bandSpikeTimesFromEventOnset, bandIndexLimitsEachTrial, timeRange)
spikeArray = np.zeros((len(numBands), len(numSec))) # Average firing rate
errorArray = np.zeros_like(spikeArray)
for thisSecVal in range(len(numSec)):
trialsThisSecVal = bandTrialsEachCond[:, :, thisSecVal]
for band in range(len(numBands)):
trialsThisBand = trialsThisSecVal[:, band]
if bandSpikeCountMat.shape[0] != len(trialsThisBand):
bandSpikeCountMat = bandSpikeCountMat[:-1, :]
if any(trialsThisBand):
thisBandCounts = bandSpikeCountMat[trialsThisBand].flatten()
spikeArray[
band, thisSecVal] = np.mean(thisBandCounts) / soundDuration
errorArray[band, thisSecVal] = stats.sem(
thisBandCounts
) / soundDuration # Error is standard error of the mean
def calculate_onset_to_sustained_ratio(eventOnsetTimes, spikeTimes,
currentFreq, currentIntensity, cf,
respLatency):
"""
Args:
eventOnsetTimes (np.array): Same size as the number of trials with each value being the time sound detector turned on
currentFreq (np.array): Same size as number of trials presented with each value being a specific frequency for that trial
currentIntensity (np.array): Same size as number of trials presented with each value being a specific intensity for that trial
uniqueIntensity (np.array): Uses currentIntensity to find how many unique intensity values were presented and store each unique value in ascending order
spikeTimes (np.array): Each value is a time when a spike occurred; obtained from ephys data
respLatency (float): Time in seconds that the cell takes to respond to the stimulus being presented
Returns:
onsetRate (float): The number of spikes that happen within the response time range
sustainedRate (float): The number of spikes that happen within the sustained time range
baseRate (float): The number of spikes that happen within the baseline time range
"""
cfTrials = currentFreq == cf
eventsThisFreq = eventOnsetTimes[cfTrials]
intenThisFreq = currentIntensity[cfTrials]
# Get only the trials with the CF and the top 5 intensities
uniqIntensity = np.unique(intenThisFreq)
if len(uniqIntensity) > 4:
intenToUse = uniqIntensity[-5:]
else:
intenToUse = uniqIntensity
# Boolean of which trials from this frequency were high intensity
highIntenTrials = np.in1d(intenThisFreq, intenToUse)
# Filter the events this frequency to just take the ones from high intensity
eventsThisFreqHighIntensity = eventsThisFreq[highIntenTrials]
if not respLatency > 0:
print("Negative latency!! Skipping")
onsetRate = np.nan
sustainedRate = np.nan
baseRate = np.nan
return onsetRate, sustainedRate, baseRate
baseRange = [-0.1, -0.05]
# responseRange = [0, 0.05, 0.1]
responseRange = [respLatency, respLatency + 0.05, 0.1 + respLatency]
# if dbRow['brainArea']=='rightAC':
# # responseRange = [0.02, 0.07, 0.12]
# responseRange = [0.02, 0.07, 0.1]
# elif dbRow['brainArea']=='rightThal':
# # responseRange = [0.005, 0.015, 0.105]
# responseRange = [0.005, 0.015, 0.1]
alignmentRange = [baseRange[0], responseRange[-1]]
# Align spikes just to the selected event onset times
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
spikeTimes, eventsThisFreqHighIntensity, alignmentRange)
nspkBase = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, responseRange)
avgResponse = nspkResp.mean(axis=0)
onsetSpikes = avgResponse[0]
sustainedSpikes = avgResponse[1]
onsetRate = onsetSpikes / (responseRange[1] - responseRange[0])
sustainedRate = sustainedSpikes / (responseRange[2] - responseRange[1])
baseSpikes = nspkBase.mean()
baseRate = baseSpikes / (baseRange[1] - baseRange[0])
return onsetRate, sustainedRate, baseRate
def raster_sound_psycurve(animalName):
oneCell = allcells.cellDB[cellID]
if (behavSession != oneCell.behavSession):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir,subject)
# -- Load Behavior Data --
behaviorFilename = loadbehavior.path_to_behavior_data(subject,experimenter,paradigm,behavSession)
bdata = loadbehavior.BehaviorData(behaviorFilename)
numberOfTrials = len(bdata['choice'])
# -- Load event data and convert event timestamps to ms --
ephysDir = os.path.join(ephysRoot, ephysSession)
eventFilename=os.path.join(ephysDir, 'all_channels.events')
events = loadopenephys.Events(eventFilename) # Load events data
eventTimes=np.array(events.timestamps)/SAMPLING_RATE #get array of timestamps for each event and convert to seconds by dividing by sampling rate (Hz). matches with eventID and
soundOnsetEvents = (events.eventID==1) & (events.eventChannel==soundTriggerChannel)
eventOnsetTimes = eventTimes[soundOnsetEvents]
rightward = bdata['choice']==bdata.labels['choice']['right']
leftward = bdata['choice']==bdata.labels['choice']['left']
invalid = bdata['outcome']==bdata.labels['outcome']['invalid']
possibleFreq = np.unique(bdata['targetFrequency'])
numberOfFrequencies = len(possibleFreq)
# -- Load Spike Data From Certain Cluster --
spkData = ephyscore.CellData(oneCell)
spkTimeStamps = spkData.spikes.timestamps
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
for Frequency in range(numberOfFrequencies):
Freq = possibleFreq[Frequency]
oneFreq = bdata['targetFrequency'] == Freq
trialsToUseRight = rightward & oneFreq
trialsToUseLeft = leftward & oneFreq
trialsEachCond = np.c_[trialsToUseLeft,trialsToUseRight]; colorEachCond = ['r','g']
plt.clf()
ax1 = plt.subplot2grid((3,1), (0, 0), rowspan=2)
extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange,trialsEachCond=trialsEachCond,colorEachCond=colorEachCond,fillWidth=None,labels=None)
plt.ylabel('Trials')
timeVec = np.arange(timeRange[0],timeRange[-1],binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,timeVec)
smoothWinSize = 3
ax2 = plt.subplot2grid((3,1), (2, 0), sharex=ax1)
extraplots.plot_psth(spikeCountMat/binWidth,smoothWinSize,timeVec,trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,linestyle=None,linewidth=3,downsamplefactor=1)
plt.xlabel('Time from sound onset (s)')
plt.ylabel('Firing rate (spk/sec)')
if ((Frequency == numberOfFrequencies/2) or (Frequency == (numberOfFrequencies/2 - 1))):
freqFile = 'Center_Frequencies'
else:
freqFile = 'Outside_Frequencies'
tetrodeClusterName = 'T'+str(oneCell.tetrode)+'c'+str(oneCell.cluster)
plt.gcf().set_size_inches((8.5,11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = 'rast_%s_%s_%s_%s.%s'%(subject,behavSession,Freq,tetrodeClusterName,figformat)
fulloutputDir = outputDir+subject+'/'+ freqFile +'/'
fullFileName = os.path.join(fulloutputDir,filename)
directory = os.path.dirname(fulloutputDir)
if not os.path.exists(directory):
os.makedirs(directory)
print 'saving figure to %s'%fullFileName
plt.gcf().savefig(fullFileName,format=figformat)
labelsForYaxis = ['%.1f' % f for f in arrayOfFrequenciesOddkHz]
trialsEachCondOdd = behavioranalysis.find_trials_each_type(
frequenciesEachTrialOdd, arrayOfFrequenciesOdd)
'''
PSTH
'''
# Parameters
binWidth = 0.010 # seconds
timeVec = np.arange(timeRange[0], timeRange[-1], binWidth)
smoothWinSizePsth = 5
lwPsth = 2
downsampleFactorPsth = 1
iletLowFreqOddInStdPara = indexLimitsEachTrialStd[:, trialsEachCondStd[:,
0]]
spikeCountMatLowFreqOddInStdPara = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetStd, iletLowFreqOddInStdPara, timeVec)
iletHighFreqStdInStdPara = indexLimitsEachTrialStd[:, trialsEachCondStd[:,
1]]
spikeCountMatHighFreqStdInStdPara = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetStd, iletHighFreqStdInStdPara, timeVec)
iletLowFreqStdInOddPara = indexLimitsEachTrialOdd[:, trialsEachCondOdd[:,
0]]
spikeCountMatLowFreqStdInOddPara = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetOdd, iletLowFreqStdInOddPara, timeVec)
iletHighFreqOddInOddPara = indexLimitsEachTrialOdd[:, trialsEachCondOdd[:,
1]]
spikeCountMatHighFreqOddInOddPara = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnsetOdd, iletHighFreqOddInOddPara, timeVec)
def am_raster(bdata, ephysData, gs):
freqEachTrial = bdata['currentFreq']
laserEachTrial = bdata['laserOn']
#intEachTrial = bdata['currentIntensity']
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimeStamps = ephysData['spikeTimes']
timeRange = [-0.3, 0.8]
baseTimeRange = [-0.15, -0.05]
possiblefreqs = np.unique(freqEachTrial)
#freqLabels = [round(x/1000, 1) for x in possiblefreqs]
freqLabels = [round(x, 1) for x in possiblefreqs]
possiblelaser = np.unique(laserEachTrial)
#possibleInts = np.unique(intEachTrial)
laserOnsetTimes = ephysData['events']['laserOn']
laserOffsetTimes = ephysData['events']['laserOff']
laserDuration = laserOffsetTimes - laserOnsetTimes
meanLaser = round(laserDuration.mean(), 2)
#print(meanLaser)
laserEventOnsetTimes = eventOnsetTimes[laserEachTrial == True]
if len(laserOnsetTimes) > len(laserEventOnsetTimes):
laserStartTimes = laserOnsetTimes[:-1] - laserEventOnsetTimes
elif len(laserEventOnsetTimes) > len(laserOnsetTimes):
laserStartTimes = laserOnsetTimes - laserEventOnsetTimes[:-1]
else:
laserStartTimes = laserOnsetTimes - laserEventOnsetTimes
laserStart = round(laserStartTimes.mean(), 2)
#print(laserStart)
#trialsEachCond = behavioranalysis.find_trials_each_type(freqEachTrial, possiblefreqs)
laserTrialsEachCond = behavioranalysis.find_trials_each_combination(
freqEachTrial, possiblefreqs, laserEachTrial, possiblelaser)
#intTrialsEachCond = behavioranalysis.find_trials_each_combination(freqEachTrial, possiblefreqs, intEachTrial, possibleInts)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, eventOnsetTimes, timeRange)
#plt.figure()
baseSpikeMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange)
#for intInd, inten in enumerate(possibleInts):
for indLaser in possiblelaser:
#plt.subplot(2, 1, indLaser)
ax = plt.subplot(gs[indLaser * 5:5 + indLaser * 5, 3:5])
if indLaser == 0:
title = "No Laser AM"
else:
title = "Laser AM"
trialsEachCond = laserTrialsEachCond[:, :, indLaser]
'''
try:
base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, baseIndexLimitsEachTrial)
except:
behavBaseIndexLimitsEachTrial = baseIndexLimitsEachTrial[0:2,:-1]
base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, behavBaseIndexLimitsEachTrial)
base_avg = np.mean(base_avgs)
base_frs = np.divide(base_avg, baseTimeRange[1] - baseTimeRange[0])
'''
trialsThisLaser = np.all([bdata['laserOn'] == indLaser], axis=0)
baseSpikeMatThisCond = baseSpikeMat[trialsThisLaser == True]
base_avg = np.mean(baseSpikeMatThisCond) / (baseTimeRange[1] -
baseTimeRange[0])
base_sem = stats.sem(baseSpikeMat) / (baseTimeRange[1] -
baseTimeRange[0])
title += " (Base FR: {} +/- {} spikes/s)".format(
round(base_avg, 2), round(base_sem, 2))
#title += " (Base FR: {} spikes/s)".format(round(base_avg, 2))
pRaster, hcond, zline = extraplots.raster_plot(
spikeTimesFromEventOnset,
indexLimitsEachTrial,
timeRange,
trialsEachCond=trialsEachCond,
labels=freqLabels)
if indLaser == 1:
laserbar = patches.Rectangle(
(laserStart, sum(sum(trialsEachCond)) + 2),
meanLaser,
5,
color="b",
clip_on=False)
#laserbar = patches.Rectangle((-0.05, 10), 2.0, 5, color="b")
ax.add_patch(laserbar)
xlabel = 'Time from sound onset (s)'
ylabel = 'AM Rate (Hz)'
plt.title(title, fontsize='medium')
plt.xlabel(xlabel)
plt.ylabel(ylabel)
'''
def plot_gaussian(cell, gs):
laserTuningSessionInds = cell.get_session_inds('laserTuningCurve')
if len(laserTuningSessionInds) != 0:
for sessionInd in laserTuningSessionInds:
bdata = cell.load_behavior_by_index(sessionInd)
ephysData = cell.load_ephys_by_index(sessionInd)
else:
return
freqEachTrial = bdata['currentFreq']
laserEachTrial = bdata['laserOn']
intEachTrial = bdata['currentIntensity']
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimeStamps = ephysData['spikeTimes']
timeRange = [-0.3, 0.6]
baseTimeRange = [0.0, 0.1]
alignmentRange = [baseTimeRange[0], timeRange[1]]
possiblefreqs = np.unique(freqEachTrial)
freqLabels = [round(x / 1000, 1) for x in possiblefreqs]
possiblelaser = np.unique(laserEachTrial)
possibleInts = np.unique(intEachTrial)
#Init list to hold the optimized parameters for the gaussian for each intensity and laser
popts = []
Rsquareds = []
#Init arrays to hold the baseline and response spike counts per condition
allLaserIntenBase = np.array([])
allLaserIntenResp = np.empty(
(len(possiblelaser), len(possibleInts), len(possiblefreqs)))
allLaserIntenRespMedian = np.empty(
(len(possiblelaser), len(possibleInts), len(possiblefreqs)))
for indlaser, laser in enumerate(possiblelaser):
for indinten, inten in enumerate(possibleInts):
spks = np.array([])
freqs = np.array([])
base = np.array([])
for indfreq, freq in enumerate(possiblefreqs):
selectinds = np.flatnonzero((freqEachTrial == freq)
& (intEachTrial == inten)
& (laserEachTrial == laser))
selectedOnsetTimes = eventOnsetTimes[selectinds]
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, selectedOnsetTimes, alignmentRange)
nspkBase = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial,
baseTimeRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
base = np.concatenate([base, nspkBase.ravel()])
spks = np.concatenate([spks, nspkResp.ravel()])
# inds = np.concatenate([inds, np.ones(len(nspkResp.ravel()))*indfreq])
freqs = np.concatenate(
[freqs, np.ones(len(nspkResp.ravel())) * freq])
allLaserIntenBase = np.concatenate(
[allLaserIntenBase, nspkBase.ravel()])
allLaserIntenResp[indlaser, indinten,
indfreq] = np.mean(nspkResp)
allLaserIntenRespMedian[indlaser, indinten,
indfreq] = np.median(nspkResp)
try:
popt, pcov = optimize.curve_fit(
gaussian, #Fit the curve for this intensity
np.log2(freqs),
spks,
p0=[
1,
np.log2(possiblefreqs[7]), 1,
allLaserIntenBase.mean()
],
#bounds=([0, np.log2(possiblefreqs[0]), 0, 0],
# [inf, np.log2(possiblefreqs[-1]), inf, inf])
)
popts.append(popt) #Save the curve paramaters
## Calculate the R**2 value for the fit
fittedSpks = gaussian(np.log2(freqs), *popt)
residuals = spks - fittedSpks
SSresidual = np.sum(residuals**2)
SStotal = np.sum((spks - np.mean(spks))**2)
Rsquared = 1 - (SSresidual / SStotal)
Rsquareds.append(Rsquared)
except RuntimeError:
'''
failed=True
print "RUNTIME ERROR, Cell {}".format(indIter)
runtimeErrorInds.append(indIter)
thresholds[indIter] = None
cfs[indIter] = None
lowerFreqs[indIter] = None
upperFreqs[indIter] = None
'''
print "RUNTIME ERROR, Cell {}".format(indIter)
popts.append([np.nan, np.nan, np.nan, np.nan])
Rsquareds.append(np.nan)
continue
#plt.figure()
#print(gaussian(popt[1], *popt))
#plt.plot(np.log2(freqs), gaussian(np.log2(freqs), *popt))
#plt.show()
print(popts)
print(Rsquareds)
def laser_tuning_curve(cell, gs):
#plt.subplot(gs[3, 1])
laserSessionInds = cell.get_session_inds('laserTuningCurve')
for count, sessionInd in enumerate(laserSessionInds):
bdata = cell.load_behavior_by_index(sessionInd)
ephysData = cell.load_ephys_by_index(sessionInd)
freqEachTrial = bdata['currentFreq']
laserEachTrial = bdata['laserOn']
intEachTrial = bdata['currentIntensity']
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimeStamps = ephysData['spikeTimes']
timeRange = [-0.3, 0.6]
soundTimeRange = [0.0, 0.1]
possiblefreqs = np.unique(freqEachTrial)
freqLabels = [round(x / 1000, 1) for x in possiblefreqs]
possiblelaser = np.unique(laserEachTrial)
possibleInts = np.unique(intEachTrial)
laserTrialsEachCond = behavioranalysis.find_trials_each_combination(
freqEachTrial, possiblefreqs, laserEachTrial, possiblelaser)
intTrialsEachCond = behavioranalysis.find_trials_each_combination(
freqEachTrial, possiblefreqs, intEachTrial, possibleInts)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, eventOnsetTimes, timeRange)
for intInd, inten in enumerate(possibleInts):
plt.subplot(gs[10:15, intInd + (count * 2) + 1])
line = '-'
#if intInd == 0:
# line = '--'
for indLaser in possiblelaser:
color = 'black'
if indLaser == 1:
color = 'blue'
laser = 'No Laser'
if indLaser == 1:
laser = 'Laser'
curveName = laser + str(inten) + ' dB'
trialsEachCond = laserTrialsEachCond[:, :,
indLaser] & intTrialsEachCond[:, :,
intInd]
spikeMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial,
soundTimeRange)
freq_avgs = np.empty(len(possiblefreqs))
freq_sems = np.empty(len(possiblefreqs))
for freqInd, freq in enumerate(possiblefreqs):
freq_spikecounts = spikeMat[trialsEachCond[:, freqInd] ==
True]
freq_avg = np.mean(freq_spikecounts) / (soundTimeRange[1] -
soundTimeRange[0])
freq_avgs[freqInd] = freq_avg
freq_sem = stats.sem(freq_spikecounts) / (
soundTimeRange[1] - soundTimeRange[0])
freq_sems[freqInd] = freq_sem
'''
try:
freq_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, indexLimitsEachTrial)
base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, baseIndexLimitsEachTrial)
except:
behavIndexLimitsEachTrial = indexLimitsEachTrial[0:2,:-1]
freq_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, behavIndexLimitsEachTrial)
freq_frs = np.divide(freq_avgs, timeRange[1]-timeRange[0])
#print(freq_avgs, freq_frs)
'''
xpoints = [x for x in range(0, len(possiblefreqs))]
xpointticks = [x for x in range(1, len(possiblefreqs), 2)]
freqticks = [
freqLabels[x] for x in range(1, len(freqLabels), 2)
]
#plt.semilogx(possiblefreqs, freq_avgs, linestyle = line, color = color, label = curveName)
#plt.plot(xvalues, freq_avgs, linestyle = line, color = 'black', label = curveName, xlabels = possiblefreqs)
#plt.plot(xpoints, freq_avgs, linestyle = line, color = color, marker = 'o', label = laser)
#plt.errorbar(xpoints, freq_avgs, yerr = freq_stds, linestyle = line, color = color, marker = 'o', label = laser)
plt.plot(xpoints,
freq_avgs,
linestyle=line,
color=color,
marker='o',
label=laser)
#plt.fill_between(xpoints, freq_avgs - freq_sems, freq_avgs + freq_sems, alpha = 0.1, color = color)
plt.xticks(xpointticks, freqticks)
plt.hold(True)
xlabel = 'Frequency (kHz)'
ylabel = 'Firing rate (spikes/s)'
title = str(inten) + ' dB Tuning curve (time range: {})'.format(
soundTimeRange)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
plt.title(title, fontsize='medium')
plt.legend(fontsize='x-small',
loc='upper right',
frameon=False,
framealpha=100,
markerscale=0.5)
plt.hold(False)
def tuning_curve(bdata, ephysData, gs):
plt.subplot(gs[10:15, 1])
freqEachTrial = bdata['currentFreq']
intEachTrial = bdata['currentIntensity']
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimeStamps = ephysData['spikeTimes']
timeRange = [-0.3, 0.6]
soundTimeRange = [0.0, 0.1]
possiblefreqs = np.unique(freqEachTrial)
freqLabels = [round(x / 1000, 1) for x in possiblefreqs]
possibleInts = np.unique(intEachTrial)
intTrialsEachCond = behavioranalysis.find_trials_each_combination(
freqEachTrial, possiblefreqs, intEachTrial, possibleInts)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, eventOnsetTimes, timeRange)
for intInd, inten in enumerate(possibleInts):
line = '-'
if intInd == 0 and len(possibleInts) > 1:
line = '--'
curveName = str(inten) + ' dB'
trialsEachCond = intTrialsEachCond[:, :, intInd]
spikeMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, soundTimeRange)
freq_avgs = np.empty(len(possiblefreqs))
freq_sems = np.empty(len(possiblefreqs))
for freqInd, freq in enumerate(possiblefreqs):
freq_spikecounts = spikeMat[trialsEachCond[:, freqInd] == True]
freq_avg = np.mean(freq_spikecounts) / (soundTimeRange[1] -
soundTimeRange[0])
freq_avgs[freqInd] = freq_avg
freq_sem = stats.sem(freq_spikecounts) / (soundTimeRange[1] -
soundTimeRange[0])
freq_sems[freqInd] = freq_sem
#print(spikeMat)
#print(freq_avgs)
'''
try:
freq_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, indexLimitsEachTrial)
except:
behavIndexLimitsEachTrial = indexLimitsEachTrial[0:2,:-1]
freq_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, behavIndexLimitsEachTrial)
freq_frs = np.divide(freq_avgs, timeRange[1]-timeRange[0])
'''
xpoints = [x for x in range(0, len(possiblefreqs))]
xpointticks = [x for x in range(1, len(possiblefreqs), 2)]
freqticks = [freqLabels[x] for x in range(1, len(freqLabels), 2)]
#plt.semilogx(possiblefreqs, freq_avgs, linestyle = line, color = 'black', label = curveName)
#plt.plot(log(possiblefreqs), freq_avgs, linestyle = line, color = 'black', label = curveName, xlabels = possiblefreqs)
#plt.plot(xpoints, freq_avgs, linestyle = line, color = 'black', marker = 'o', label = curveName)
#plt.errorbar(xpoints, freq_avgs, yerr = freq_stds, linestyle = line, color = 'black', marker = 'o', label = curveName)
plt.plot(xpoints,
freq_avgs,
linestyle=line,
color='black',
marker='o',
label=curveName)
plt.fill_between(xpoints,
freq_avgs - (freq_sems * 2),
freq_avgs + (freq_sems * 2),
alpha=0.1,
color='black')
plt.xticks(xpointticks, freqticks)
plt.hold(True)
xlabel = 'Frequency (kHz)'
ylabel = 'Firing rate (spikes/s)'
title = 'Tuning curve (time range: {})'.format(soundTimeRange)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
plt.title(title, fontsize='medium')
plt.legend(fontsize='x-small',
loc='upper right',
frameon=False,
framealpha=100,
markerscale=0.5)
plt.hold(False)
def tuning_raster(bdata, ephysData, gs):
#plt.subplot(gs[1, 1])
freqEachTrial = bdata['currentFreq']
intEachTrial = bdata['currentIntensity']
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimeStamps = ephysData['spikeTimes']
timeRange = [-0.3, 0.6]
baseTimeRange = [-0.15, -0.05]
possiblefreqs = np.unique(freqEachTrial)
freqLabels = [round(x / 1000, 1) for x in possiblefreqs]
possibleInts = np.unique(intEachTrial)
intTrialsEachCond = behavioranalysis.find_trials_each_combination(
freqEachTrial, possiblefreqs, intEachTrial, possibleInts)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, eventOnsetTimes, timeRange)
#print len(freqEachTrial), len(eventOnsetTimes)
baseSpikeMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange)
for intInd, inten in enumerate(possibleInts):
ax = plt.subplot(gs[intInd * 5:5 + (intInd * 5), 1])
trialsEachCond = intTrialsEachCond[:, :, intInd]
trialsThisInt = np.all([bdata['currentIntensity'] == inten], axis=0)
baseSpikeMatThisCond = baseSpikeMat[trialsThisIntLaser == True]
base_avg = np.mean(baseSpikeMatThisCond) / (baseTimeRange[1] -
baseTimeRange[0])
base_sem = stats.sem(baseSpikeMatThisCond) / (baseTimeRange[1] -
baseTimeRange[0])
# for freqInd, freq in enumerate(possiblefreqs):
# freq_spikecounts = spikeMat[trialsEachCond[:,freqInd]==True]
# freq_avg = np.mean(freq_spikecounts) / (soundTimeRange[1] - soundTimeRange[0])
# freq_avgs.append(freq_avg)
'''
try:
base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, baseIndexLimitsEachTrial)
except:
behavBaseIndexLimitsEachTrial = baseIndexLimitsEachTrial[0:2,:-1]
base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, behavBaseIndexLimitsEachTrial)
base_avg = np.mean(base_avgs)
base_frs = np.divide(base_avg, baseTimeRange[1] - baseTimeRange[0])
#print(base_avg)
'''
title = "Tuning Curve {} dB (Base FR: {} +/- {} spikes/s)".format(
str(inten), round(base_avg, 2), round(base_sem, 2))
#title = "Tuning Curve (Base FR: {} spikes/s)".format(round(base_avg, 2))
pRaster, hcond, zline = extraplots.raster_plot(
spikeTimesFromEventOnset,
indexLimitsEachTrial,
timeRange,
trialsEachCond=trialsEachCond,
labels=freqLabels)
xlabel = 'Time from sound onset (s)'
ylabel = 'Frequency (kHz)'
plt.title(title, fontsize='medium')
plt.xlabel(xlabel)
plt.ylabel(ylabel)
'''
def bandwidth_suppression_from_peak(spikeTimeStamps,
eventOnsetTimes,
firstSort,
secondSort,
timeRange=[0.2, 1.0],
baseRange=[-1.0, -0.2],
subtractBaseline=False,
zeroBWBaseline=True):
'''Calculates suppression stats from raw data (no model).
Inputs:
spikeTimeStamps: array of timestamps indicating when spikes occurred
eventOnsetTimes: array of timestamps indicating sound onsets
firstSort: array of length N trials indicating value of first parameter for each trial (ex. bandwidths)
secondSort: array of length N trials indicating value of second parameter for each trial. Second parameter should be manipulation being done (ex. laser), as it is used to calculate separate indices and baselines.
timeRange: time period over which to calculate cell responses
subtractBaseline: boolean, whether baseline firing rate should be subtracted from responses when calculating stats
Output:
suppressionIndex: suppression index for cell for each condition (e.g. for each amplitude, for each laser trial type)
suppressionpVal: p value for each value in suppressionIndex
facilitationIndex: facilitation index for cell for each condition
facilitationpVal: p value for each value in facilitationIndex
peakInd: index of responseArray containing largest firing rate (to calculate preferred bandwidth)
spikeArray: array of size N condition 1 x N condition 2, average spike rates for each condition used to calculate suppression stats
'''
fullTimeRange = [baseRange[0], timeRange[1]]
trialsEachCond = behavioranalysis.find_trials_each_combination(
firstSort, np.unique(firstSort), secondSort, np.unique(secondSort))
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimeStamps, eventOnsetTimes, fullTimeRange)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
trialsEachSecondSort = behavioranalysis.find_trials_each_type(
secondSort, np.unique(secondSort))
spikeArray, errorArray = calculate_tuning_curve_inputs(
spikeCountMat, firstSort, secondSort)
spikeArray = spikeArray / (timeRange[1] - timeRange[0]
) #convert spike counts to firing rate
suppressionIndex = np.zeros(spikeArray.shape[1])
facilitationIndex = np.zeros_like(suppressionIndex)
peakInds = np.zeros_like(suppressionIndex)
suppressionpVal = np.zeros_like(suppressionIndex)
facilitationpVal = np.zeros_like(suppressionIndex)
for ind in range(len(suppressionIndex)):
trialsThisSecondVal = trialsEachSecondSort[:, ind]
if spikeCountMat.shape[0] != len(trialsThisSecondVal):
spikeCountMat = spikeCountMat[:-1, :]
baseSpikeCountMat = baseSpikeCountMat[:-1, :]
thisCondResponse = spikeArray[:, ind]
thisCondBaseline = np.mean(
baseSpikeCountMat[trialsThisSecondVal].flatten()) / (baseRange[1] -
baseRange[0])
if zeroBWBaseline:
thisCondResponse[0] = thisCondBaseline
if not subtractBaseline:
thisCondBaseline = 0
spikeArray[:, ind] = thisCondResponse
suppressionIndex[ind] = (max(thisCondResponse) - thisCondResponse[-1]
) / (max(thisCondResponse) - thisCondBaseline)
facilitationIndex[ind] = (max(thisCondResponse) -
thisCondResponse[0]) / (
max(thisCondResponse) - thisCondBaseline)
peakInd = np.argmax(thisCondResponse)
peakInds[ind] = peakInd
fullTrialsThisSecondVal = trialsEachCond[:, :, ind]
if zeroBWBaseline:
if peakInd == 0:
peakSpikeCounts = baseSpikeCountMat[
trialsThisSecondVal].flatten()
else:
peakSpikeCounts = spikeCountMat[
fullTrialsThisSecondVal[:, peakInd]].flatten()
zeroBWSpikeCounts = baseSpikeCountMat[trialsThisSecondVal].flatten(
)
else:
peakSpikeCounts = spikeCountMat[
fullTrialsThisSecondVal[:, peakInd]].flatten()
zeroBWSpikeCounts = spikeCountMat[
fullTrialsThisSecondVal[:, 0]].flatten()
whiteNoiseSpikeCounts = spikeCountMat[
fullTrialsThisSecondVal[:, -1]].flatten()
suppressionpVal[ind] = stats.ranksums(peakSpikeCounts,
whiteNoiseSpikeCounts)[1]
facilitationpVal[ind] = stats.ranksums(peakSpikeCounts,
zeroBWSpikeCounts)[1]
return suppressionIndex, suppressionpVal, facilitationIndex, facilitationpVal, peakInds, spikeArray
newTime=time.time(); print 'Elapsed time: {0:0.2f} LOADED EVLOCKED DATA'.format(newTime-zeroTime); zeroTime=newTime; sys.stdout.flush() ### PROFILER
else:
newTime=time.time(); print 'Elapsed time: {0:0.2f} LOADED EPHYS/BEHAV one cell'.format(newTime-zeroTime); zeroTime=newTime; sys.stdout.flush() ### PROFILER
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,EventOnsetTimes,timeRange)
#---- Save intermediate results somewhere, next time can just load it ----
np.savez(outputFullPath, spikeTimesFromEventOnset=spikeTimesFromEventOnset,
trialIndexForEachSpike=trialIndexForEachSpike,
indexLimitsEachTrial=indexLimitsEachTrial, timeRange=timeRange, alignment=alignment)
print 'Saved event-locked data to {0}'.format(outputFullPath)
newTime=time.time(); print 'Elapsed time: {0:0.2f} Calculated EVLOCKED DATA'.format(newTime-zeroTime); zeroTime=newTime; sys.stdout.flush() ### PROFILER
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,countTimeRange) #spike counts in the window of interest for modulation
spikeCountEachTrial = spikeCountMat.flatten() #spikeCountMat contains num of spikes in countTimeRange, each column is each trial, only one row because only given one time bin(countTimeRange)
freqLabels = ['Low','High']
for indf,freq in enumerate([lowFreq, highFreq]):
!!!### HERE GET SPIKE COUNT AVE BY BLOCK IN THIS WINDOW
trialsMoreLeft = trialsEachType[:,1] & freq & correct
trialsMoreRight = trialsEachType[:,2] & freq & correct
trialsEachCond = [trialsMoreRight,trialsMoreLeft]
# -- Calculate modulation index and significance p value -- #
spikeAvgRight = np.average(spikeCountEachTrial[trialsMoreRight])
spikeAvgLeft = np.average(spikeCountEachTrial[trialsMoreLeft])
if ((spikeAvgRight + spikeAvgLeft) == 0):
modIndex = 0.0
def evaluate_2afc_sound_response_celldb(cellDb):
'''
Analyse 2afc sound response: calculate sound response Z score for each freq, store frequencies presented and corresponding Z scores.
'''
if not ('behavZscore' in cellDb.columns):
print 'Calculating sound response Z scores for 2afc session'
behavDict = {
'behavFreqs': [],
'behavZscore': [],
'behavPval': [],
'behavRespIndex': [],
'behavAveResp': []
}
#movementModI = np.zeros(len(cellDb)) #default value 0
#movementModS = np.ones(len(cellDb)) #default value 1
for indCell, cell in cellDb.iterrows():
cellObj = ephyscore.Cell(cell)
sessiontype = 'behavior' #2afc behavior
#ephysData, bata = cellObj.load(sessiontype)
sessionInd = cellObj.get_session_inds(sessiontype)[0]
bdata = cellObj.load_behavior_by_index(sessionInd)
possibleFreq = np.unique(bdata['targetFrequency'])
numFreqs = len(possibleFreq)
try:
ephysData = cellObj.load_ephys_by_index(sessionInd)
except (ValueError, IOError) as error:
print(error)
spikeData = (0, 0)
behavDict['behavFreqs'].append(possibleFreq)
behavDict['behavZscore'].append(np.zeros(numFreqs))
behavDict['behavPval'].append(np.ones(numFreqs))
behavDict['behavRespIndex'].append(np.zeros(numFreqs))
behavDict['behavAveResp'].append(np.zeros(numFreqs))
continue
eventsDict = ephysData['events']
spikeTimestamps = ephysData['spikeTimes']
if spikeTimestamps.ndim == 0: #There is only one spike, ! spikesanalysis.eventlocked_spiketimes cannot handle only one spike !
behavDict['behavFreqs'].append(possibleFreq)
behavDict['behavZscore'].append(np.zeros(numFreqs))
behavDict['behavPval'].append(np.ones(numFreqs))
behavDict['behavRespIndex'].append(np.zeros(numFreqs))
behavDict['behavAveResp'].append(np.zeros(numFreqs))
continue
soundOnsetTimes = eventsDict['{}On'.format(soundChannelType)]
soundOnsetTimeBehav = bdata['timeTarget']
# -- Check to see if ephys and behav recordings have same number of trials, remove missing trials from behav file -- #
# Find missing trials
missingTrials = behavioranalysis.find_missing_trials(
soundOnsetTimes, soundOnsetTimeBehav)
# Remove missing trials
bdata.remove_trials(missingTrials)
if len(soundOnsetTimes) != len(
bdata['timeTarget']
): #some error not handled by remove missing trials
behavDict['behavFreqs'].append(possibleFreq)
behavDict['behavZscore'].append(np.zeros(numFreqs))
behavDict['behavPval'].append(np.ones(numFreqs))
behavDict['behavRespIndex'].append(np.zeros(numFreqs))
behavDict['behavAveResp'].append(np.zeros(numFreqs))
continue
# -- Calculate Z score of sound response for each frequency -- #
zScores = []
pVals = []
responseEachFreq = []
responseInds = []
for freq in possibleFreq:
# -- Only use valid trials of one frequency to estimate response index -- #
oneFreqTrials = (bdata['targetFrequency']
== freq) & bdata['valid'].astype('bool')
oneFreqSoundOnsetTimes = soundOnsetTimes[oneFreqTrials]
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spikeTimestamps,oneFreqSoundOnsetTimes,timeRange)
# Generate the spkCountMatrix where each row is one trial, each column is a time bin to count spikes in, in this case one time bin for baseline and one time bin for sound period
#pdb.set_trace()
nspkBase = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, respRange)
print nspkBase.shape, nspkResp.shape
# Calculate response index (S-B)/(S+B) where S and B are ave response during the sound window and baseline window, respectively
responseIndex = (np.mean(nspkResp) - np.mean(nspkBase)) / (
np.mean(nspkResp) + np.mean(nspkBase))
responseInds.append(responseIndex)
responseEachFreq.append(np.mean(
nspkResp)) #Store mean response to each stim frequency
print 'ave firing rate for baseline and sound periods are', np.mean(
nspkBase), np.mean(
nspkResp), 'response index is', responseIndex
# Calculate statistic using ranksums test
zStat, pValue = stats.ranksums(nspkResp, nspkBase)
print zStat, pValue
zScores.append(zStat)
pVals.append(pValue)
behavDict['behavFreqs'].append(possibleFreq)
behavDict['behavZscore'].append(zScores)
behavDict['behavPval'].append(pVals)
behavDict['behavRespIndex'].append(responseInds)
behavDict['behavAveResp'].append(responseEachFreq)
return behavDict
freqEachTrial, possibleFreq)
baseRange = [-0.1, 0]
responseRange = [0, 0.1]
alignmentRange = [-0.2, 0.2]
#Align all spikes to events
(spikeTimesFromEventOnset,
trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(spikeTimes,
eventOnsetTimes,
alignmentRange)
#Count spikes in baseline and response ranges
nspkBase = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
baseRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
responseRange)
#Filter and average the response spikes by the condition matrix
conditionMatShape = np.shape(trialsEachCondition)
numRepeats = np.product(conditionMatShape[1:])
nSpikesMat = np.reshape(nspkResp.squeeze().repeat(numRepeats), conditionMatShape)
spikesFilteredByTrialType = nSpikesMat * trialsEachCondition
avgRespArray = np.sum(spikesFilteredByTrialType, 0) / np.sum(
trialsEachCondition, 0).astype('float')
thresholdFRA=0.2
thresholdResponse = nspkBase.mean() + thresholdFRA*(avgRespArray.max()-nspkBase.mean())
def plot_gaussian(cell, gs):
laserTuningSessionInds = cell.get_session_inds('laserTuningCurve')
if len(laserTuningSessionInds) != 0:
for sessionInd in laserTuningSessionInds:
bdata = cell.load_behavior_by_index(sessionInd)
ephysData = cell.load_ephys_by_index(sessionInd)
else:
return
freqEachTrial = bdata['currentFreq']
laserEachTrial = bdata['laserOn']
intEachTrial = bdata['currentIntensity']
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimeStamps = ephysData['spikeTimes']
timeRange = [-0.3, 0.6]
baseTimeRange = [0.0, 0.1]
alignmentRange = [baseTimeRange[0], timeRange[1]]
possiblefreqs = np.unique(freqEachTrial)
freqLabels = [round(x/1000, 1) for x in possiblefreqs]
possiblelaser = np.unique(laserEachTrial)
possibleInts = np.unique(intEachTrial)
#Init list to hold the optimized parameters for the gaussian for each intensity and laser
popts = []
Rsquareds = []
#Init arrays to hold the baseline and response spike counts per condition
allLaserIntenBase = np.array([])
allLaserIntenResp = np.empty((len(possiblelaser), len(possibleInts), len(possiblefreqs)))
allLaserIntenRespMedian = np.empty((len(possiblelaser), len(possibleInts), len(possiblefreqs)))
for indlaser, laser in enumerate(possiblelaser):
for indinten, inten in enumerate(possibleInts):
spks = np.array([])
freqs = np.array([])
base = np.array([])
for indfreq, freq in enumerate(possiblefreqs):
selectinds = np.flatnonzero((freqEachTrial==freq)&(intEachTrial==inten)&(laserEachTrial==laser))
selectedOnsetTimes = eventOnsetTimes[selectinds]
(spikeTimesFromEventOnset,
trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(spikeTimeStamps,
selectedOnsetTimes,
alignmentRange)
nspkBase = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
baseTimeRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
timeRange)
base = np.concatenate([base, nspkBase.ravel()])
spks = np.concatenate([spks, nspkResp.ravel()])
# inds = np.concatenate([inds, np.ones(len(nspkResp.ravel()))*indfreq])
freqs = np.concatenate([freqs, np.ones(len(nspkResp.ravel()))*freq])
allLaserIntenBase = np.concatenate([allLaserIntenBase, nspkBase.ravel()])
allLaserIntenResp[indlaser, indinten, indfreq] = np.mean(nspkResp)
allLaserIntenRespMedian[indlaser, indinten, indfreq] = np.median(nspkResp)
try:
popt, pcov = optimize.curve_fit(gaussian, #Fit the curve for this intensity
np.log2(freqs),
spks,
p0=[1, np.log2(possiblefreqs[7]), 1, allLaserIntenBase.mean()],
#bounds=([0, np.log2(possiblefreqs[0]), 0, 0],
# [inf, np.log2(possiblefreqs[-1]), inf, inf])
)
popts.append(popt) #Save the curve paramaters
## Calculate the R**2 value for the fit
fittedSpks = gaussian(np.log2(freqs), *popt)
residuals = spks - fittedSpks
SSresidual = np.sum(residuals**2)
SStotal = np.sum((spks-np.mean(spks))**2)
Rsquared = 1-(SSresidual/SStotal)
Rsquareds.append(Rsquared)
except RuntimeError:
'''
failed=True
print "RUNTIME ERROR, Cell {}".format(indIter)
runtimeErrorInds.append(indIter)
thresholds[indIter] = None
cfs[indIter] = None
lowerFreqs[indIter] = None
upperFreqs[indIter] = None
'''
print "RUNTIME ERROR, Cell {}".format(indIter)
popts.append([np.nan, np.nan, np.nan, np.nan])
Rsquareds.append(np.nan)
continue
#plt.figure()
#print(gaussian(popt[1], *popt))
#plt.plot(np.log2(freqs), gaussian(np.log2(freqs), *popt))
#plt.show()
print(popts)
print(Rsquareds)
(binsize / 1000.0)
])
binEdges = np.around(np.arange(
noiseTimeRange[0] - (binsize / 1000.0),
noiseTimeRange[1] + 2 * (binsize / 1000.0),
(binsize / 1000.0)),
decimals=2)
if thisCellTypePSTHs is None:
thisCellTypePSTHs = []
thisCellTypeLaserPSTHs = []
thisCellTypePSTHs2 = []
thisCellTypeLaserPSTHs2 = []
noiseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
noiseSpikeTimesFromEventOnset, noiseIndexLimitsEachTrial,
binEdges)
laserSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
laserSpikeTimesFromEventOnset, laserIndexLimitsEachTrial,
binEdges)
thisNoisePSTH = np.mean(noiseSpikeCountMat, axis=0)
thisLaserPSTH = np.mean(laserSpikeCountMat, axis=0)
if (thisNoisePSTH[0] != 0) and (thisLaserPSTH[0] != 0):
thisNoisePSTH1 = thisNoisePSTH / thisNoisePSTH[
0] #normalise so baseline is 1
thisLaserPSTH1 = thisLaserPSTH / thisLaserPSTH[0]
thisCellTypePSTHs.append(thisNoisePSTH1)
thisCellTypeLaserPSTHs.append(thisLaserPSTH1)
tuningSpikeTimestamps = tuningEphysData['spikeTimes']
freqEachTrial = tuningBehavData['currentFreq']
intensityEachTrial = tuningBehavData['currentIntensity']
numFreqs = np.unique(freqEachTrial)
numIntensities = np.unique(intensityEachTrial)
timeRange = [-0.2, 0.2]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
tuningSpikeTimestamps,
tuningEventOnsetTimes,
timeRange)
trialsEachType = behavioranalysis.find_trials_each_type(intensityEachTrial, numIntensities)
trialsHighInt = trialsEachType[:,-1]
trialsEachComb = behavioranalysis.find_trials_each_combination(freqEachTrial, numFreqs, intensityEachTrial, numIntensities)
trialsEachFreqHighInt = trialsEachComb[:,:,-1]
tuningWindow = best_window_freq_tuning(spikeTimesFromEventOnset, indexLimitsEachTrial, trialsEachFreqHighInt)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, tuningWindow)
tuningSpikeRates = (spikeCountMat[trialsHighInt].flatten())/(tuningWindow[1]-tuningWindow[0])
freqsThisIntensity = freqEachTrial[trialsHighInt]
freqFit, thisRsquared = gaussian_tuning_fit(np.log2(freqsThisIntensity), tuningSpikeRates)
if freqFit is not None:
bestFreq = 2**freqFit[0]
bandIndex, octavesFromBest = best_index(cellObj, bestFreq, sessionType)
else:
freqFit = np.zeros(4)
bestFreq = np.nan
bandIndex = np.nan
octavesFromBest = np.nan
gaussFit.append(freqFit)
tuningTimeRange.append(tuningWindow)
Rsquared[indRow] = thisRsquared
prefFreq[indRow] = bestFreq
def plot_rew_change_byblock_per_cell(oneCell,
trialLimit=[],
alignment='sound',
choiceSide='both'):
'''
Plots ephys data during behavior (reward_change_freq_discrim paradigm), data split according to the block in behavior and the choice (left or right). only plotting correct trials.
oneCell is an CellInfo object as in celldatabase.
'trialLimit' (e.g. [0, 600]) is the indecies of trials wish to be plotted.
'choiceSide' is a string, either 'left' or 'right', to plot leftward and rightward trials, respectively. If not provided, will plot both sides.
'alignment' selects which event to align spike data to, should be 'sound', 'center-out', or 'side-in'.
'''
SAMPLING_RATE = 30000.0
soundTriggerChannel = 0 # channel 0 is the sound presentation, 1 is the trial
binWidth = 0.010 # Size of each bin in histogram in seconds
#timeRange = [-0.2,0.8] # In seconds. Time range for rastor plot to plot spikes (around some event onset as 0)
#timeRange = [-0.25,1.0]
timeRange = [-0.4, 1.2]
bdata = load_behav_per_cell(oneCell)
currentBlock = bdata['currentBlock']
if currentBlock[0] == bdata.labels['currentBlock']['more_left']:
startMoreLeft = True
else:
startMoreLeft = False
blockTypes = [
bdata.labels['currentBlock']['more_left'],
bdata.labels['currentBlock']['more_right']
]
if (not len(trialLimit)):
validTrials = np.ones(len(currentBlock), dtype=bool)
else:
validTrials = np.zeros(len(currentBlock), dtype=bool)
validTrials[trialLimit[0]:trialLimit[1]] = 1
bdata.find_trials_each_block()
trialsEachBlock = bdata.blocks['trialsEachBlock']
#print trialsEachBlock
nBlocks = bdata.blocks['nBlocks']
#blockLabels = ['more_left', 'more_right']
rightward = bdata['choice'] == bdata.labels['choice']['right']
leftward = bdata['choice'] == bdata.labels['choice']['left']
invalid = bdata['outcome'] == bdata.labels['outcome']['invalid']
correct = bdata['outcome'] == bdata.labels['outcome']['correct']
incorrect = bdata['outcome'] == bdata.labels['outcome']['error']
######Split left and right trials into correct and incorrect categories to look at error trials#########
rightcorrect = rightward & correct & validTrials
leftcorrect = leftward & correct & validTrials
#righterror = rightward&incorrect&validTrials
#lefterror = leftward&incorrect&validTrials
####construct trialsEachCond and colorEachCond for ploting####
for block in range(nBlocks):
rightcorrectThisBlock = rightcorrect & trialsEachBlock[:, block]
leftcorrectThisBlock = leftcorrect & trialsEachBlock[:, block]
#trialTypeVec = leftcorrect*1+rightcorrect*2
#trialTypePossibleValues = [1,2] #1 stands for left correct, 2 stands for right correct
#trialsEachTypeEachBlock = behavioranalysis.find_trials_each_type_each_block(trialTypeVec, trialTypePossibleValues,currentBlock,blockTypes)
if block == 0:
#trialsEachCond=np.c_[leftcorrectThisBlock,rightcorrectThisBlock]
if choiceSide == 'right':
trialsEachCond = np.c_[rightcorrectThisBlock]
elif choiceSide == 'left':
trialsEachCond = np.c_[leftcorrectThisBlock]
elif choiceSide == 'both':
trialsEachCond = np.c_[leftcorrectThisBlock,
rightcorrectThisBlock]
else:
if choiceSide == 'right':
trialsEachCond = np.c_[trialsEachCond, rightcorrectThisBlock]
elif choiceSide == 'left':
trialsEachCond = np.c_[trialsEachCond, leftcorrectThisBlock]
elif choiceSide == 'both':
trialsEachCond = np.c_[trialsEachCond, leftcorrectThisBlock,
rightcorrectThisBlock]
if choiceSide == 'right':
if startMoreLeft:
colorEachCond = ['r', 'b', 'r', 'b', 'r', 'b', 'r', 'b']
else:
colorEachCond = ['b', 'r', 'b', 'r', 'b', 'r', 'b', 'r']
elif choiceSide == 'left':
if startMoreLeft:
colorEachCond = ['g', 'm', 'g', 'm', 'g', 'm', 'g', 'm']
else:
colorEachCond = ['m', 'g', 'm', 'g', 'm', 'g', 'm', 'g']
elif choiceSide == 'both':
if startMoreLeft:
colorEachCond = [
'g', 'r', 'm', 'b', 'g', 'r', 'm', 'b', 'g', 'r', 'm', 'b',
'g', 'r', 'm', 'b', 'g', 'r', 'm', 'b', 'g', 'r', 'm', 'b',
'g', 'r', 'm', 'b'
]
else:
colorEachCond = [
'm', 'b', 'g', 'r', 'm', 'b', 'g', 'r', 'm', 'b', 'g', 'r',
'm', 'b', 'g', 'r', 'm', 'b', 'g', 'r', 'm', 'b', 'g', 'r',
'm', 'b', 'g', 'r'
]
(spikeTimestamps, waveforms, eventOnsetTimes,
eventData) = load_ephys_per_cell(oneCell)
if alignment == 'sound':
soundOnsetEvents = (eventData.eventID == 1) & (eventData.eventChannel
== soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
elif alignment == 'center-out':
soundOnsetEvents = (eventData.eventID == 1) & (eventData.eventChannel
== soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
diffTimes = bdata['timeCenterOut'] - bdata['timeTarget']
EventOnsetTimes += diffTimes
elif alignment == 'side-in':
soundOnsetEvents = (eventData.eventID == 1) & (eventData.eventChannel
== soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
diffTimes = bdata['timeSideIn'] - bdata['timeTarget']
EventOnsetTimes += diffTimes
freqEachTrial = bdata['targetFrequency']
possibleFreq = np.unique(freqEachTrial)
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spikeTimestamps,EventOnsetTimes,timeRange)
plt.figure()
###########Plot raster and PSTH#################
ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2)
pRaster, hcond, zline = extraplots.raster_plot(
spikeTimesFromEventOnset,
indexLimitsEachTrial,
timeRange,
trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,
fillWidth=None,
labels=None)
#plt.setp(pRaster, ms=0.8)
plt.ylabel('Trials')
plt.xlim(timeRange)
fig_title = '{0}_{1}_TT{2}_c{3}_{4}_{5}'.format(oneCell.animalName,
oneCell.behavSession,
oneCell.tetrode,
oneCell.cluster, alignment,
choiceSide)
plt.title(fig_title)
timeVec = np.arange(timeRange[0], timeRange[-1], binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeVec)
smoothWinSize = 3
ax2 = plt.subplot2grid((3, 1), (2, 0), sharex=ax1)
extraplots.plot_psth(spikeCountMat / binWidth,
smoothWinSize,
timeVec,
trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,
linestyle=None,
linewidth=1.5,
downsamplefactor=1)
plt.xlabel('Time from sound onset (s)')
plt.ylabel('Firing rate (spk/sec)')
#plt.show()
#fig_path=
#full_fig_path = os.path.join(fig_path, fig_title)
#print full_fig_path
#plt.tight_layout()
plt.gcf().set_size_inches((8.5, 11))
def calculate_latency(eventOnsetTimes, currentFreq, uniqFreq, currentIntensity,
uniqueIntensity, spikeTimes, indRow):
"""
Args:
eventOnsetTimes (np.array): Same size as the number of trials with each value being the time sound detector turned on
currentFreq (np.array): Same size as number of trials presented with each value being a specific frequency for that trial
currentIntensity (np.array): Same size as number of trials presented with each value being a specific intensity for that trial
uniqueIntensity (np.array): Uses currentIntensity to find how many unique intensity values were presented and store each unique value
uniqFreq (np.array): Uses currentFreq to find how many unique frequency values were presented and store each unique value
spikeTimes (np.array): Each value is a time when a spike occurred; obtained from ephys data
indRow (int): Row number of cell in database(DataFrame)
Returns:
respLatency (float): Time, in seconds, from when the stimulus is presented and the cell responds
"""
trialsEachCondition = behavioranalysis.find_trials_each_combination(
currentIntensity, uniqueIntensity, currentFreq, uniqFreq)
baseRange = [-0.1, 0]
responseRange = [0, 0.1]
alignmentRange = [-0.2, 0.2]
thresholdFRA = 0.2
# Align all spikes to events
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
spikeTimes, eventOnsetTimes, alignmentRange)
# Count spikes in baseline and response ranges
nspkBase = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, responseRange)
# Filter and average the response spikes by the condition matrix
conditionMatShape = np.shape(trialsEachCondition)
numRepeats = np.product(conditionMatShape[1:])
nSpikesMat = np.reshape(nspkResp.squeeze().repeat(numRepeats),
conditionMatShape)
spikesFilteredByTrialType = nSpikesMat * trialsEachCondition
avgRespArray = np.sum(spikesFilteredByTrialType, 0) / np.sum(
trialsEachCondition, 0).astype('float')
thresholdResponse = nspkBase.mean() + thresholdFRA * (avgRespArray.max() -
nspkBase.mean())
if not np.any(avgRespArray > thresholdResponse):
print("Nothing above the threshold")
respLatency = np.nan
return respLatency
# Determine trials that come from a I/F pair with a response above the threshold
fra = avgRespArray > thresholdResponse
selectedTrials = np.any(trialsEachCondition[:, fra], axis=1)
# -- Calculate response latency --
indexLimitsSelectedTrials = indexLimitsEachTrial[:, selectedTrials]
timeRangeForLatency = [-0.1, 0.1]
try:
(respLatency,
interim) = spikesanalysis.response_latency(spikeTimesFromEventOnset,
indexLimitsSelectedTrials,
timeRangeForLatency,
threshold=0.5,
win=signal.hanning(11))
# TODO capture the exception outside in the database file itself
except IndexError:
print("Index error for cell {}".format(
indRow)) # If there are no spikes in the timeRangeForLatency
respLatency = np.nan
print('Response latency: {:0.1f} ms'.format(1e3 * respLatency))
return respLatency
def plot_rew_change_per_cell(oneCell, trialLimit=[], alignment='sound'):
'''
Plots raster and PSTH for one cell during reward_change_freq_dis task, split by block; alignment parameter should be set to either 'sound', 'center-out', or 'side-in'.
'''
bdata = load_behav_per_cell(oneCell)
currentBlock = bdata['currentBlock']
blockTypes = [
bdata.labels['currentBlock']['more_left'],
bdata.labels['currentBlock']['more_right']
]
#blockLabels = ['more_left', 'more_right']
if (not len(trialLimit)):
validTrials = np.ones(len(currentBlock), dtype=bool)
else:
validTrials = np.zeros(len(currentBlock), dtype=bool)
validTrials[trialLimit[0]:trialLimit[1]] = 1
trialsEachType = behavioranalysis.find_trials_each_type(
currentBlock, blockTypes)
(spikeTimestamps, waveforms, eventOnsetTimes,
eventData) = load_ephys_per_cell(oneCell)
if alignment == 'sound':
soundOnsetEvents = (eventData.eventID == 1) & (eventData.eventChannel
== soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
elif alignment == 'center-out':
soundOnsetEvents = (eventData.eventID == 1) & (eventData.eventChannel
== soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
diffTimes = bdata['timeCenterOut'] - bdata['timeTarget']
EventOnsetTimes += diffTimes
elif alignment == 'side-in':
soundOnsetEvents = (eventData.eventID == 1) & (eventData.eventChannel
== soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
diffTimes = bdata['timeSideIn'] - bdata['timeTarget']
EventOnsetTimes += diffTimes
freqEachTrial = bdata['targetFrequency']
possibleFreq = np.unique(freqEachTrial)
rightward = bdata['choice'] == bdata.labels['choice']['right']
leftward = bdata['choice'] == bdata.labels['choice']['left']
invalid = bdata['outcome'] == bdata.labels['outcome']['invalid']
correct = bdata['outcome'] == bdata.labels['outcome']['correct']
incorrect = bdata['outcome'] == bdata.labels['outcome']['error']
######Split left and right trials into correct and incorrect categories to look at error trials#########
rightcorrect = rightward & correct & validTrials
leftcorrect = leftward & correct & validTrials
#righterror = rightward&incorrect&validTrials
#lefterror = leftward&incorrect&validTrials
rightcorrectBlockMoreLeft = rightcorrect & trialsEachType[:, 0]
rightcorrectBlockMoreRight = rightcorrect & trialsEachType[:, 1]
leftcorrectBlockMoreLeft = leftcorrect & trialsEachType[:, 0]
leftcorrectBlockMoreRight = leftcorrect & trialsEachType[:, 1]
trialsEachCond = np.c_[leftcorrectBlockMoreLeft, rightcorrectBlockMoreLeft,
leftcorrectBlockMoreRight,
rightcorrectBlockMoreRight]
colorEachCond = ['g', 'r', 'm', 'b']
#trialsEachCond = np.c_[invalid,leftcorrect,rightcorrect,lefterror,righterror]
#colorEachCond = ['0.75','g','r','b','m']
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spikeTimestamps,EventOnsetTimes,timeRange)
###########Plot raster and PSTH#################
plt.figure()
ax1 = plt.subplot2grid((8, 5), (0, 0), rowspan=4, colspan=5)
extraplots.raster_plot(spikeTimesFromEventOnset,
indexLimitsEachTrial,
timeRange,
trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,
fillWidth=None,
labels=None)
plt.ylabel('Trials')
plt.xlim(timeRange)
plt.title('{0}_{1}_TT{2}_c{3}_{4}'.format(oneCell.animalName,
oneCell.behavSession,
oneCell.tetrode, oneCell.cluster,
alignment))
timeVec = np.arange(timeRange[0], timeRange[-1], binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeVec)
smoothWinSize = 3
ax2 = plt.subplot2grid((8, 5), (4, 0), colspan=5, rowspan=2, sharex=ax1)
extraplots.plot_psth(spikeCountMat / binWidth,
smoothWinSize,
timeVec,
trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,
linestyle=None,
linewidth=3,
downsamplefactor=1)
plt.xlabel('Time from {0} onset (s)'.format(alignment))
plt.ylabel('Firing rate (spk/sec)')
# -- Plot ISI histogram --
plt.subplot2grid((8, 5), (6, 0), rowspan=1, colspan=2)
spikesorting.plot_isi_loghist(spikeTimestamps)
plt.ylabel('c%d' % oneCell.cluster, rotation=0, va='center', ha='center')
plt.xlabel('')
# -- Plot waveforms --
plt.subplot2grid((8, 5), (7, 0), rowspan=1, colspan=3)
spikesorting.plot_waveforms(waveforms)
# -- Plot projections --
plt.subplot2grid((8, 5), (6, 2), rowspan=1, colspan=3)
spikesorting.plot_projections(waveforms)
# -- Plot events in time --
plt.subplot2grid((8, 5), (7, 3), rowspan=1, colspan=2)
spikesorting.plot_events_in_time(spikeTimestamps)
plt.subplots_adjust(wspace=0.7)
#plt.show()
#fig_path =
#fig_name = 'TT{0}Cluster{1}{2}.png'.format(tetrode, cluster, '_2afc plot_each_type')
#full_fig_path = os.path.join(fig_path, fig_name)
#print full_fig_path
plt.gcf().set_size_inches((8.5, 11))
def rasterBlock(oneCell):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir, subject)
# -- Load Behavior Data --
behaviorFilename = loadbehavior.path_to_behavior_data(
subject, experimenter, paradigm, behavSession)
bdata = loadbehavior.FlexCategBehaviorData(behaviorFilename)
bdata.find_trials_each_block()
# -- Load event data and convert event timestamps to ms --
ephysDir = os.path.join(ephysRoot, ephysSession)
eventFilename = os.path.join(ephysDir, 'all_channels.events')
events = loadopenephys.Events(eventFilename) # Load events data
eventTimes = np.array(events.timestamps) / SAMPLING_RATE
soundOnsetEvents = (events.eventID == 1) & (events.eventChannel
== soundTriggerChannel)
# -- Load Spike Data From Certain Cluster --
spkData = ephyscore.CellData(oneCell)
spkTimeStamps = spkData.spikes.timestamps
eventOnsetTimes = eventTimes[soundOnsetEvents]
correct = bdata['outcome'] == bdata.labels['outcome']['correct']
possibleFreq = np.unique(bdata['targetFrequency'])
oneFreq = bdata['targetFrequency'] == possibleFreq[middleFreq]
correctOneFreq = oneFreq & correct
correctTrialsEachBlock = bdata.blocks[
'trialsEachBlock'] & correctOneFreq[:, np.newaxis]
#trialsEachCond = np.c_[invalid,leftward,rightward]; colorEachCond = ['0.75','g','r']
#trialsEachCond = np.c_[leftward,rightward]; colorEachCond = ['0.5','0.7','0']
trialsEachCond = correctTrialsEachBlock
if bdata['currentBlock'][0] == bdata.labels['currentBlock'][
'low_boundary']:
colorEachBlock = 3 * ['g', 'r']
else:
colorEachBlock = 3 * ['r', 'g']
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
#plot(spikeTimesFromEventOnset,trialIndexForEachSpike,'.')
plt.clf()
ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2)
extraplots.raster_plot(spikeTimesFromEventOnset,
indexLimitsEachTrial,
timeRange,
trialsEachCond=correctTrialsEachBlock,
colorEachCond=colorEachBlock,
fillWidth=None,
labels=None)
#plt.yticks([0,trialsEachCond.sum()])
#ax1.set_xticklabels([])
plt.ylabel('Trials')
timeVec = np.arange(timeRange[0], timeRange[-1], binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeVec)
smoothWinSize = 3
ax2 = plt.subplot2grid((3, 1), (2, 0), sharex=ax1)
extraplots.plot_psth(spikeCountMat / binWidth,
smoothWinSize,
timeVec,
trialsEachCond=correctTrialsEachBlock,
colorEachCond=colorEachBlock,
linestyle=None,
linewidth=3,
downsamplefactor=1)
plt.xlabel('Time from sound onset (s)')
plt.ylabel('Firing rate (spk/sec)')
#plt.show()
nameFreq = str(possibleFreq[middleFreq])
tetrodeClusterName = 'T' + str(oneCell.tetrode) + 'c' + str(
oneCell.cluster)
plt.gcf().set_size_inches((8.5, 11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = 'block_%s_%s_%s_%s.%s' % (
subject, behavSession, tetrodeClusterName, nameFreq, figformat)
fulloutputDir = outputDir + subject + '/'
fullFileName = os.path.join(fulloutputDir, filename)
directory = os.path.dirname(fulloutputDir)
if not os.path.exists(directory):
os.makedirs(directory)
print 'saving figure to %s' % fullFileName
plt.gcf().savefig(fullFileName, format=figformat)
fontsize=fontSizeLabels,
labelpad=labelDis)
plt.title('Tuning curve', fontsize=fontSizeLabels)
# -- Plot tuning PSTH -- #
ax2 = plt.subplot(gs00[2, :])
freqScaleFactor = 3 #factor to reduce number of frequencies plotted by
possibleFreq = possibleFreq[
1::freqScaleFactor] #select just a subset of frequencies to plot
labels = ['%.1f' % f for f in np.unique(possibleFreq) / 1000.0]
numFreqs = len(possibleFreq)
trialsEachFreq = behavioranalysis.find_trials_each_type(
freqEachTrial, possibleFreq)
timeVec = np.arange(timeRange[0], timeRange[-1], binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeVec)
cm_subsection = np.linspace(0.0, 1.0, numFreqs)
colorEachCond = [colormapTuning(x) for x in cm_subsection]
pPSTH = extraplots.plot_psth(spikeCountMat / binWidth,
smoothWinSizePsth,
timeVec,
trialsEachCond=trialsEachFreq,
colorEachCond=colorEachCond,
linestyle=None,
linewidth=lwPsth,
downsamplefactor=downsampleFactorPsth)
for ind, line in enumerate(pPSTH):
plt.setp(line, label=labels[ind])
plt.legend(loc='upper right',
fontsize=fontSizeTicks,
def plot_tuning_PSTH_one_intensity(oneCell,
intensity=50.0,
timeRange=[-0.5, 1],
binWidth=0.010,
halfFreqs=True):
#calls load_remote_tuning_data(oneCell) to get the data, then plot raster
eventOnsetTimes, spikeTimestamps, bdata = load_remote_tuning_data(
oneCell, BEHAVDIR_MOUNTED, EPHYSDIR_MOUNTED)
freqEachTrial = bdata['currentFreq']
intensityEachTrial = bdata['currentIntensity']
possibleIntensity = np.unique(intensityEachTrial)
if len(possibleIntensity) != 1:
intensity = intensity #50dB is the stimulus intensity used in 2afc task
###Just select the trials with a given intensity###
trialsThisIntensity = [intensityEachTrial == intensity]
freqEachTrial = freqEachTrial[trialsThisIntensity]
intensityEachTrial = intensityEachTrial[trialsThisIntensity]
eventOnsetTimes = eventOnsetTimes[trialsThisIntensity]
possibleFreq = np.unique(freqEachTrial)
if halfFreqs:
possibleFreq = possibleFreq[
1::3] #slice to get every other frequence presented
numFreqs = len(possibleFreq)
#print len(intensityEachTrial),len(eventOnsetTimes),len(spikeTimestamps)
trialsEachFreq = behavioranalysis.find_trials_each_type(
freqEachTrial, possibleFreq)
#pdb.set_trace() #for debug
#colormap = plt.cm.gist_ncar
#colorEachFreq = [colormap(i) for i in np.linspace(0, 0.9, numFreqs)]
#from jaratoolbox.colorpalette import TangoPalette as Tango
#colorEachFreq = [Tango['Aluminium3'], Tango['Orange2'],Tango['Chameleon1'],Tango['Plum1'],Tango['Chocolate1'],Tango['SkyBlue2'],Tango['ScarletRed1'],'k']
#Creat colorEachCond from color map
from matplotlib import cm
cm_subsection = np.linspace(0.0, 1.0, numFreqs)
colorEachFreq = [cm.winter(x) for x in cm_subsection]
#Create legend
import matplotlib.patches as mpatches
handles = []
for (freq, color) in zip(possibleFreq, colorEachFreq):
patch = mpatches.Patch(color=color, label=str(freq) + ' Hz')
handles.append(patch)
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spikeTimestamps,eventOnsetTimes,timeRange)
timeVec = np.arange(timeRange[0], timeRange[-1], binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeVec)
smoothWinSize = 3
#plt.figure()
extraplots.plot_psth(spikeCountMat / binWidth,
smoothWinSize,
timeVec,
trialsEachCond=trialsEachFreq,
colorEachCond=colorEachFreq,
linestyle=None,
linewidth=2,
downsamplefactor=1)
extraplots.set_ticks_fontsize(ax=plt.gca(), fontSize=14)
plt.xlim(timeRange[0] + 0.1, timeRange[1])
plt.legend(handles=handles, loc=2)
plt.xlabel('Time from sound onset (s)', fontsize=18)
plt.ylabel('Firing rate (spk/sec)', fontsize=18)
def plot_blind_cell_quality(cell):
plt.clf()
gs = gridspec.GridSpec(5, 6)
#create cell object for loading data
cellObj = ephyscore.Cell(cell)
# -- plot laser pulse raster --
laserEphysData, noBehav = cellObj.load('laserPulse')
laserEventOnsetTimes = laserEphysData['events']['laserOn']
laserSpikeTimestamps = laserEphysData['spikeTimes']
timeRange = [-0.1, 0.4]
plt.subplot(gs[0:2, 0:3])
laserSpikeTimesFromEventOnset, trialIndexForEachSpike, laserIndexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
laserSpikeTimestamps, laserEventOnsetTimes, timeRange)
pRaster, hcond, zline = extraplots.raster_plot(
laserSpikeTimesFromEventOnset, laserIndexLimitsEachTrial, timeRange)
plt.xlabel('Time from laser onset (sec)')
plt.title('Laser Pulse Raster')
# -- plot laser pulse psth --
plt.subplot(gs[2:4, 0:3])
binsize = 10 / 1000.0
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
laserSpikeTimestamps, laserEventOnsetTimes,
[timeRange[0] - binsize, timeRange[1]])
binEdges = np.around(np.arange(timeRange[0] - binsize,
timeRange[1] + 2 * binsize, binsize),
decimals=2)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges)
pPSTH = extraplots.plot_psth(spikeCountMat / binsize, 1, binEdges[:-1])
plt.xlim(timeRange)
plt.xlabel('Time from laser onset (sec)')
plt.ylabel('Firing Rate (Hz)')
plt.title('Laser Pulse PSTH')
# -- didn't record laser trains for some earlier sessions --
if len(cellObj.get_session_inds('laserTrain')) > 0:
# -- plot laser train raster --
laserTrainEphysData, noBehav = cellObj.load('laserTrain')
laserTrainEventOnsetTimes = laserTrainEphysData['events']['laserOn']
laserTrainSpikeTimestamps = laserTrainEphysData['spikeTimes']
laserTrainEventOnsetTimes = spikesanalysis.minimum_event_onset_diff(
laserTrainEventOnsetTimes, 0.5)
timeRange = [-0.2, 1.0]
plt.subplot(gs[0:2, 3:])
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
laserTrainSpikeTimestamps, laserTrainEventOnsetTimes, timeRange)
pRaster, hcond, zline = extraplots.raster_plot(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
plt.xlabel('Time from laser onset (sec)')
plt.title('Laser Train Raster')
# -- plot laser train psth --
plt.subplot(gs[2:4, 3:])
binsize = 10 / 1000.0
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
laserTrainSpikeTimestamps, laserTrainEventOnsetTimes,
[timeRange[0] - binsize, timeRange[1]])
binEdges = np.around(np.arange(timeRange[0] - binsize,
timeRange[1] + 2 * binsize, binsize),
decimals=2)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges)
pPSTH = extraplots.plot_psth(spikeCountMat / binsize, 1, binEdges[:-1])
plt.xlim(timeRange)
plt.xlabel('Time from laser onset (sec)')
plt.ylabel('Firing Rate (Hz)')
plt.title('Laser Train PSTH')
# -- show cluster analysis --
#tsThisCluster, wavesThisCluster, recordingNumber = celldatabase.load_all_spikedata(cell)
# -- Plot ISI histogram --
plt.subplot(gs[4, 0:2])
spikesorting.plot_isi_loghist(tsThisCluster)
# -- Plot waveforms --
plt.subplot(gs[4, 2:4])
spikesorting.plot_waveforms(wavesThisCluster)
# -- Plot events in time --
plt.subplot(gs[4, 4:6])
spikesorting.plot_events_in_time(tsThisCluster)
def plot_rew_change_byblock_per_cell(oneCell,trialLimit=[],alignment='sound',choiceSide='both'):
'''
Plots ephys data during behavior (reward_change_freq_discrim paradigm), data split according to the block in behavior and the choice (left or right). only plotting correct trials.
oneCell is an CellInfo object as in celldatabase.
'trialLimit' (e.g. [0, 600]) is the indecies of trials wish to be plotted.
'choiceSide' is a string, either 'left' or 'right', to plot leftward and rightward trials, respectively. If not provided, will plot both sides.
'alignment' selects which event to align spike data to, should be 'sound', 'center-out', or 'side-in'.
'''
SAMPLING_RATE=30000.0
soundTriggerChannel = 0 # channel 0 is the sound presentation, 1 is the trial
binWidth = 0.010 # Size of each bin in histogram in seconds
#timeRange = [-0.2,0.8] # In seconds. Time range for rastor plot to plot spikes (around some event onset as 0)
#timeRange = [-0.25,1.0]
timeRange = [-0.4,1.2]
bdata = load_behav_per_cell(oneCell)
(spikeTimestamps,waveforms,eventOnsetTimes,eventData)=load_ephys_per_cell(oneCell)
# -- Check to see if ephys has skipped trials, if so remove trials from behav data
soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel)
soundOnsetTimeEphys = eventOnsetTimes[soundOnsetEvents]
soundOnsetTimeBehav = bdata['timeTarget']
# Find missing trials
missingTrials = behavioranalysis.find_missing_trials(soundOnsetTimeEphys,soundOnsetTimeBehav)
# Remove missing trials
bdata.remove_trials(missingTrials)
currentBlock = bdata['currentBlock']
if(not len(trialLimit)):
validTrials = np.ones(len(currentBlock),dtype=bool)
else:
validTrials = np.zeros(len(currentBlock),dtype=bool)
validTrials[trialLimit[0]:trialLimit[1]] = 1
bdata.find_trials_each_block()
trialsEachBlock = bdata.blocks['trialsEachBlock']
#print trialsEachBlock
nBlocks = bdata.blocks['nBlocks']
#blockLabels = ['more_left', 'more_right']
rightward = bdata['choice']==bdata.labels['choice']['right']
leftward = bdata['choice']==bdata.labels['choice']['left']
invalid = bdata['outcome']==bdata.labels['outcome']['invalid']
correct = bdata['outcome']==bdata.labels['outcome']['correct']
incorrect = bdata['outcome']==bdata.labels['outcome']['error']
######Split left and right trials into correct and incorrect categories to look at error trials#########
rightcorrect = rightward&correct&validTrials
leftcorrect = leftward&correct&validTrials
#righterror = rightward&incorrect&validTrials
#lefterror = leftward&incorrect&validTrials
colorEachCond=[]
####construct trialsEachCond and colorEachCond for ploting####
for block in range(nBlocks):
rightcorrectThisBlock = rightcorrect&trialsEachBlock[:,block]
leftcorrectThisBlock = leftcorrect&trialsEachBlock[:,block]
#trialTypeVec = leftcorrect*1+rightcorrect*2
#trialTypePossibleValues = [1,2] #1 stands for left correct, 2 stands for right correct
firstIndexThisBlock=np.nonzero(trialsEachBlock[:,block])[0][0]
if currentBlock[firstIndexThisBlock]==bdata.labels['currentBlock']['more_left']:
if choiceSide=='right':
colorThisCond='r'
elif choiceSide=='left':
colorThisCond='g'
elif choiceSide=='both':
colorThisCond=['g','r']
if currentBlock[firstIndexThisBlock]==bdata.labels['currentBlock']['more_right']:
if choiceSide=='right':
colorThisCond='b'
elif choiceSide=='left':
colorThisCond='m'
elif choiceSide=='both':
colorThisCond=['m','b']
if currentBlock[firstIndexThisBlock]==bdata.labels['currentBlock']['same_reward']:
if choiceSide=='right':
colorThisCond='darkgray'
elif choiceSide=='left':
colorThisCond='y'
elif choiceSide=='both':
colorThisCond=['y','darkgray']
#trialsEachTypeEachBlock = behavioranalysis.find_trials_each_type_each_block(trialTypeVec, trialTypePossibleValues,currentBlock,blockTypes)
if block==0:
#trialsEachCond=np.c_[leftcorrectThisBlock,rightcorrectThisBlock]
if choiceSide=='right':
trialsEachCond=np.c_[rightcorrectThisBlock]
elif choiceSide=='left':
trialsEachCond=np.c_[leftcorrectThisBlock]
elif choiceSide=='both':
trialsEachCond=np.c_[leftcorrectThisBlock,rightcorrectThisBlock]
else:
if choiceSide=='right':
trialsEachCond=np.c_[trialsEachCond,rightcorrectThisBlock]
elif choiceSide=='left':
trialsEachCond=np.c_[trialsEachCond,leftcorrectThisBlock]
elif choiceSide=='both':
trialsEachCond=np.c_[trialsEachCond,leftcorrectThisBlock,rightcorrectThisBlock]
colorEachCond.append(colorThisCond)
if alignment == 'sound':
soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
elif alignment == 'center-out':
soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
diffTimes=bdata['timeCenterOut']-bdata['timeTarget']
EventOnsetTimes+=diffTimes
elif alignment == 'side-in':
soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel)
EventOnsetTimes = eventOnsetTimes[soundOnsetEvents]
diffTimes=bdata['timeSideIn']-bdata['timeTarget']
EventOnsetTimes+=diffTimes
freqEachTrial = bdata['targetFrequency']
possibleFreq = np.unique(freqEachTrial)
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spikeTimestamps,EventOnsetTimes,timeRange)
plt.figure()
###########Plot raster and PSTH#################
ax1 = plt.subplot2grid((3,1), (0, 0), rowspan=2)
pRaster,hcond,zline =extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange,trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,fillWidth=None,labels=None)
#plt.setp(pRaster, ms=0.8)
plt.ylabel('Trials')
plt.xlim(timeRange)
fig_title='{0}_{1}_TT{2}_c{3}_{4}_{5}'.format(oneCell.animalName,oneCell.behavSession,oneCell.tetrode,oneCell.cluster,alignment,choiceSide)
plt.title(fig_title)
timeVec = np.arange(timeRange[0],timeRange[-1],binWidth)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,timeVec)
smoothWinSize = 3
ax2 = plt.subplot2grid((3,1), (2, 0), sharex=ax1)
extraplots.plot_psth(spikeCountMat/binWidth,smoothWinSize,timeVec,trialsEachCond=trialsEachCond,
colorEachCond=colorEachCond,linestyle=None,linewidth=1.5,downsamplefactor=1)
plt.xlabel('Time from sound onset (s)')
plt.ylabel('Firing rate (spk/sec)')
#plt.show()
#fig_path=
#full_fig_path = os.path.join(fig_path, fig_title)
#print full_fig_path
#plt.tight_layout()
plt.gcf().set_size_inches((8.5,11))
def plot_bandwidth_report(cell, bandIndex, type='normal'):
plt.clf()
if bandIndex is None:
print 'No bandwidth session given'
return
#create cell object for loading data
cellObj = ephyscore.Cell(cell)
#change dimensions of report to add laser trials if they exist
if len(cellObj.get_session_inds('laserPulse')) > 0:
laser = True
gs = gridspec.GridSpec(13, 6)
else:
laser = False
gs = gridspec.GridSpec(9, 6)
offset = 4 * laser
gs.update(left=0.15, right=0.85, top=0.96, wspace=0.7, hspace=1.0)
tetrode = int(cell['tetrode'])
cluster = int(cell['cluster'])
#load bandwidth ephys and behaviour data
bandEphysData, bandBData = cellObj.load_by_index(bandIndex)
bandEventOnsetTimes = ephysanalysis.get_sound_onset_times(
bandEphysData, 'bandwidth')
bandSpikeTimestamps = bandEphysData['spikeTimes']
timeRange = [-0.2, 1.5]
bandEachTrial = bandBData['currentBand']
numBands = np.unique(bandEachTrial)
#change the trial type that the bandwidth session is split by so we can use this report for Arch-inactivation experiments
#also changes the colours to be more thematically appropriate! (in Anna's opinion)
if type == 'laser':
secondSort = bandBData['laserTrial']
secondSortLabels = ['no laser', 'laser']
colours = ['k', '#c4a000']
errorColours = ['0.5', '#fce94f']
gaussFitCol = 'gaussFit'
tuningR2Col = 'tuningFitR2'
elif type == 'normal':
secondSort = bandBData['currentAmp']
secondSortLabels = [
'{} dB'.format(amp) for amp in np.unique(secondSort)
]
colours = ['#4e9a06', '#5c3566']
errorColours = ['#8ae234', '#ad7fa8']
gaussFitCol = 'gaussFit'
tuningR2Col = 'tuningFitR2'
charfreq = str(np.unique(bandBData['charFreq'])[0] / 1000)
modrate = str(np.unique(bandBData['modRate'])[0])
numBands = np.unique(bandEachTrial)
# -- plot rasters of the bandwidth trials --
rasterColours = [
np.tile([colours[0], errorColours[0]],
len(numBands) / 2 + 1),
np.tile([colours[1], errorColours[1]],
len(numBands) / 2 + 1)
]
plot_separated_rasters(gs, [0, 3],
5 + offset,
bandEachTrial,
secondSort,
bandSpikeTimestamps,
bandEventOnsetTimes,
colours=rasterColours,
titles=secondSortLabels,
plotHeight=2)
# -- plot bandwidth tuning curves --
plt.subplot(gs[5 + offset:, 3:])
timeRange = [0.2, 1.0] # if type=='normal' else [0.1, 1.1]
baseRange = [-1.1, -0.3]
tuningDict = ephysanalysis.calculate_tuning_curve_inputs(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange,
info='plotting')
plot_tuning_curve(tuningDict['responseArray'],
tuningDict['errorArray'],
numBands,
tuningDict['baselineSpikeRate'],
linecolours=colours,
errorcolours=errorColours)
# load tuning ephys and behaviour data
tuningEphysData, tuningBData = cellObj.load('tuningCurve')
tuningEventOnsetTimes = ephysanalysis.get_sound_onset_times(
tuningEphysData, 'tuningCurve')
tuningSpikeTimestamps = tuningEphysData['spikeTimes']
# -- plot frequency tuning at intensity used in bandwidth trial with gaussian fit --
# high amp bandwidth trials used to select appropriate frequency
maxAmp = max(np.unique(bandBData['currentAmp']))
if maxAmp < 1:
maxAmp = 66.0 #HARDCODED dB VALUE FOR SESSIONS DONE BEFORE NOISE CALIBRATION
# find tone intensity that corresponds to tone sessions in bandwidth trial
toneInt = maxAmp - 15.0 #HARDCODED DIFFERENCE IN TONE AND NOISE AMP BASED ON OSCILLOSCOPE READINGS FROM RIG 2
freqEachTrial = tuningBData['currentFreq']
plt.subplot(gs[2 + offset:4 + offset, 0:3])
plot_tuning_fitted_gaussian(tuningSpikeTimestamps,
tuningEventOnsetTimes,
tuningBData,
toneInt,
cell[gaussFitCol],
cell[tuningR2Col],
timeRange=cell['tuningTimeRange'])
# -- plot frequency tuning raster --
plt.subplot(gs[0 + offset:2 + offset, 0:3])
freqLabels = ["%.1f" % freq for freq in np.unique(freqEachTrial) / 1000.0]
plot_sorted_raster(tuningSpikeTimestamps,
tuningEventOnsetTimes,
freqEachTrial,
timeRange=[-0.2, 0.6],
labels=freqLabels)
plt.title('Frequency Tuning Raster')
# -- plot AM PSTH --
amEphysData, amBData = cellObj.load('AM')
amEventOnsetTimes = ephysanalysis.get_sound_onset_times(amEphysData, 'AM')
amSpikeTimestamps = amEphysData['spikeTimes']
rateEachTrial = amBData['currentFreq']
timeRange = [-0.2, 1.5]
colourList = ['b', 'g', 'y', 'orange', 'r']
plt.subplot(gs[2 + offset:4 + offset, 3:])
plot_sorted_psth(amSpikeTimestamps,
amEventOnsetTimes,
rateEachTrial,
timeRange=[-0.2, 0.8],
binsize=25,
colorEachCond=colourList)
plt.xlabel('Time from sound onset (sec)')
plt.ylabel('Firing rate (Hz)')
plt.title('AM PSTH')
# -- plot AM raster --
plt.subplot(gs[0 + offset:2 + offset, 3:])
rateLabels = ["%.0f" % rate for rate in np.unique(rateEachTrial)]
plot_sorted_raster(amSpikeTimestamps,
amEventOnsetTimes,
rateEachTrial,
timeRange=[-0.2, 0.8],
labels=rateLabels,
colorEachCond=colourList)
plt.xlabel('Time from sound onset (sec)')
plt.ylabel('Modulation Rate (Hz)')
plt.title('AM Raster')
# -- plot laser pulse and laser train data (if available) --
if laser:
# -- plot laser pulse raster --
laserEphysData, noBehav = cellObj.load('laserPulse')
laserEventOnsetTimes = laserEphysData['events']['laserOn']
laserSpikeTimestamps = laserEphysData['spikeTimes']
timeRange = [-0.1, 0.4]
plt.subplot(gs[0:2, 0:3])
laserSpikeTimesFromEventOnset, trialIndexForEachSpike, laserIndexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
laserSpikeTimestamps, laserEventOnsetTimes, timeRange)
pRaster, hcond, zline = extraplots.raster_plot(
laserSpikeTimesFromEventOnset, laserIndexLimitsEachTrial,
timeRange)
plt.xlabel('Time from laser onset (sec)')
plt.title('Laser Pulse Raster')
# -- plot laser pulse psth --
plt.subplot(gs[2:4, 0:3])
binsize = 10 / 1000.0
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
laserSpikeTimestamps, laserEventOnsetTimes,
[timeRange[0] - binsize, timeRange[1]])
binEdges = np.around(np.arange(timeRange[0] - binsize,
timeRange[1] + 2 * binsize, binsize),
decimals=2)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges)
pPSTH = extraplots.plot_psth(spikeCountMat / binsize, 1, binEdges[:-1])
plt.xlim(timeRange)
plt.xlabel('Time from laser onset (sec)')
plt.ylabel('Firing Rate (Hz)')
plt.title('Laser Pulse PSTH')
# -- didn't record laser trains for some earlier sessions --
if len(cellObj.get_session_inds('laserTrain')) > 0:
# -- plot laser train raster --
laserTrainEphysData, noBehav = cellObj.load('laserTrain')
laserTrainEventOnsetTimes = laserTrainEphysData['events'][
'laserOn']
laserTrainSpikeTimestamps = laserTrainEphysData['spikeTimes']
laserTrainEventOnsetTimes = spikesanalysis.minimum_event_onset_diff(
laserTrainEventOnsetTimes, 0.5)
timeRange = [-0.2, 1.0]
plt.subplot(gs[0:2, 3:])
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
laserTrainSpikeTimestamps, laserTrainEventOnsetTimes,
timeRange)
pRaster, hcond, zline = extraplots.raster_plot(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
plt.xlabel('Time from laser onset (sec)')
plt.title('Laser Train Raster')
# -- plot laser train psth --
plt.subplot(gs[2:4, 3:])
binsize = 10 / 1000.0
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
laserTrainSpikeTimestamps, laserTrainEventOnsetTimes,
[timeRange[0] - binsize, timeRange[1]])
binEdges = np.around(np.arange(timeRange[0] - binsize,
timeRange[1] + 2 * binsize,
binsize),
decimals=2)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges)
pPSTH = extraplots.plot_psth(spikeCountMat / binsize, 1,
binEdges[:-1])
plt.xlim(timeRange)
plt.xlabel('Time from laser onset (sec)')
plt.ylabel('Firing Rate (Hz)')
plt.title('Laser Train PSTH')
# -- show cluster analysis --
#tsThisCluster, wavesThisCluster, recordingNumber = celldatabase.load_all_spikedata(cell)
# -- Plot ISI histogram --
plt.subplot(gs[4 + offset, 0:2])
spikesorting.plot_isi_loghist(bandSpikeTimestamps)
# -- Plot waveforms --
plt.subplot(gs[4 + offset, 2:4])
spikesorting.plot_waveforms(bandEphysData['samples'])
# -- Plot events in time --
plt.subplot(gs[4 + offset, 4:6])
spikesorting.plot_events_in_time(bandSpikeTimestamps)
title = '{0}, {1}, {2}um, Tetrode {3}, Cluster {4}, {5}kHz, {6}Hz modulation'.format(
cell['subject'], cell['date'], cell['depth'], tetrode, cluster,
charfreq, modrate)
plt.suptitle(title)
fig_path = '/home/jarauser/Pictures/cell reports'
fig_name = '{0}_{1}_{2}um_TT{3}Cluster{4}.png'.format(
cell['subject'], cell['date'], cell['depth'], tetrode, cluster)
full_fig_path = os.path.join(fig_path, fig_name)
fig = plt.gcf()
fig.set_size_inches(20, 25)
fig.savefig(full_fig_path, format='png', bbox_inches='tight')
def inactivation_base_stats(db):
'''
This function takes as argument a pandas DataFrame and adds new columns.
The filename should be the full path to where the database will be saved. If a filename is not specified, the database will not be saved.
This function computed basic statistics for all clusters (e.g. laser responsiveness, sound responsiveness, preferred frequency).
'''
laserTestStatistic = np.empty(len(db))
laserPVal = np.empty(len(db))
soundResponseTestStatistic = np.empty(len(db))
soundResponsePVal = np.empty(len(db))
onsetSoundResponseTestStatistic = np.empty(len(db))
onsetSoundResponsePVal = np.empty(len(db))
sustainedSoundResponseTestStatistic = np.empty(len(db))
sustainedSoundResponsePVal = np.empty(len(db))
gaussFit = []
tuningTimeRange = []
Rsquared = np.empty(len(db))
prefFreq = np.empty(len(db))
octavesFromPrefFreq = np.empty(len(db))
bestBandSession = np.empty(len(db))
for indRow, (dbIndex, dbRow) in enumerate(db.iterrows()):
cellObj = ephyscore.Cell(dbRow)
print "Now processing", dbRow['subject'], dbRow['date'], dbRow[
'depth'], dbRow['tetrode'], dbRow['cluster']
# --- Determine laser responsiveness of each cell (using first 100 ms of noise-in-laser trials) ---
try:
laserEphysData, noBehav = cellObj.load('lasernoisebursts')
except IndexError:
print "No laser pulse session for this cell"
testStatistic = np.nan
pVal = np.nan
changeFR = np.nan
else:
testStatistic, pVal, changeFR = funcs.laser_response(
laserEphysData,
baseRange=[-0.3, -0.2],
responseRange=[0.0, 0.1])
laserTestStatistic[indRow] = testStatistic
laserPVal[indRow] = pVal
# --- Determine sound responsiveness during bandwidth sessions and calculate baseline firing rates with and without laser---
# done in a kind of stupid way because regular and control sessions are handled the same way
if any(session in dbRow['sessionType']
for session in ['laserBandwidth', 'laserBandwidthControl']):
if 'laserBandwidth' in dbRow['sessionType']:
bandEphysData, bandBehavData = cellObj.load('laserBandwidth')
behavSession = 'laserBandwidth'
db.at[dbIndex, 'controlSession'] = 0
elif 'laserBandwidthControl' in dbRow['sessionType']:
bandEphysData, bandBehavData = cellObj.load(
'laserBandwidthControl')
behavSession = 'laserBandwidthControl'
db.at[dbIndex, 'controlSession'] = 1
bandEventOnsetTimes = funcs.get_sound_onset_times(
bandEphysData, 'bandwidth')
bandSpikeTimestamps = bandEphysData['spikeTimes']
bandEachTrial = bandBehavData['currentBand']
secondSort = bandBehavData['laserTrial']
numBands = np.unique(bandEachTrial)
numSec = np.unique(secondSort)
trialsEachComb = behavioranalysis.find_trials_each_combination(
bandEachTrial, numBands, secondSort, numSec)
trialsEachBaseCond = trialsEachComb[:, :,
0] # using no laser trials to determine sound responsiveness
testStatistic, pVal = funcs.sound_response_any_stimulus(
bandEventOnsetTimes, bandSpikeTimestamps, trialsEachBaseCond,
[0.0, 1.0], [-1.2, -0.2])
onsetTestStatistic, onsetpVal = funcs.sound_response_any_stimulus(
bandEventOnsetTimes, bandSpikeTimestamps, trialsEachBaseCond,
[0.0, 0.05], [-0.25, -0.2])
sustainedTestStatistic, sustainedpVal = funcs.sound_response_any_stimulus(
bandEventOnsetTimes, bandSpikeTimestamps, trialsEachBaseCond,
[0.2, 1.0], [-1.0, -0.2])
pVal *= len(numBands) # correction for multiple comparisons
onsetpVal *= len(numBands)
sustainedpVal *= len(numBands)
#pdb.set_trace()
# find baselines with and without laser
baselineRange = [-0.05, 0.0]
baselineRates, baselineSEMs = funcs.inactivated_cells_baselines(
bandSpikeTimestamps, bandEventOnsetTimes, secondSort,
baselineRange)
db.at[dbIndex, 'baselineFRnoLaser'] = baselineRates[0]
db.at[dbIndex, 'baselineFRLaser'] = baselineRates[1]
db.at[dbIndex, 'baselineFRnoLaserSEM'] = baselineSEMs[0]
db.at[dbIndex, 'baselineFRLaserSEM'] = baselineSEMs[1]
db.at[dbIndex,
'baselineChangeFR'] = baselineRates[1] - baselineRates[0]
else:
print "No bandwidth session for this cell"
testStatistic = np.nan
pVal = np.nan
onsetTestStatistic = np.nan
onsetpVal = np.nan
sustainedTestStatistic = np.nan
sustainedpVal = np.nan
#pdb.set_trace()
soundResponseTestStatistic[indRow] = testStatistic
soundResponsePVal[indRow] = pVal
onsetSoundResponseTestStatistic[indRow] = onsetTestStatistic
onsetSoundResponsePVal[indRow] = onsetpVal
sustainedSoundResponseTestStatistic[indRow] = sustainedTestStatistic
sustainedSoundResponsePVal[indRow] = sustainedpVal
# --- Determine frequency tuning of cells ---
try:
tuningEphysData, tuningBehavData = cellObj.load('tuningCurve')
except IndexError:
print "No tuning session for this cell"
freqFit = np.full(4, np.nan)
thisRsquared = np.nan
bestFreq = np.nan
tuningWindow = np.full(2, np.nan)
octavesFromBest = np.nan
bandIndex = np.nan
else:
tuningEventOnsetTimes = funcs.get_sound_onset_times(
tuningEphysData, 'tuningCurve')
tuningSpikeTimestamps = tuningEphysData['spikeTimes']
freqEachTrial = tuningBehavData['currentFreq']
intensityEachTrial = tuningBehavData['currentIntensity']
numFreqs = np.unique(freqEachTrial)
numIntensities = np.unique(intensityEachTrial)
timeRange = [-0.2, 0.2]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
tuningSpikeTimestamps, tuningEventOnsetTimes, timeRange)
trialsEachType = behavioranalysis.find_trials_each_type(
intensityEachTrial, numIntensities)
trialsHighInt = trialsEachType[:, -1]
trialsEachComb = behavioranalysis.find_trials_each_combination(
freqEachTrial, numFreqs, intensityEachTrial, numIntensities)
trialsEachFreqHighInt = trialsEachComb[:, :, -1]
tuningWindow = funcs.best_window_freq_tuning(
spikeTimesFromEventOnset, indexLimitsEachTrial,
trialsEachFreqHighInt)
tuningWindow = np.array(tuningWindow)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, tuningWindow)
if spikeCountMat.shape[0] == len(trialsHighInt) + 1:
spikeCountMat = spikeCountMat[:-1, :]
tuningSpikeRates = (spikeCountMat[trialsHighInt].flatten()) / (
tuningWindow[1] - tuningWindow[0])
freqsThisIntensity = freqEachTrial[trialsHighInt]
freqFit, thisRsquared = funcs.gaussian_tuning_fit(
np.log2(freqsThisIntensity), tuningSpikeRates)
if freqFit is not None:
bestFreq = 2**freqFit[0]
bandIndex, octavesFromBest = funcs.best_index(
cellObj, bestFreq, behavSession)
else:
freqFit = np.full(4, np.nan)
bestFreq = np.nan
bandIndex = np.nan
octavesFromBest = np.nan
gaussFit.append(freqFit)
tuningTimeRange.append(tuningWindow)
Rsquared[indRow] = thisRsquared
prefFreq[indRow] = bestFreq
octavesFromPrefFreq[indRow] = octavesFromBest
bestBandSession[indRow] = bandIndex
db['laserPVal'] = laserPVal
db['laserUStat'] = laserTestStatistic
db['soundResponseUStat'] = soundResponseTestStatistic
db['soundResponsePVal'] = soundResponsePVal
db['onsetSoundResponseUStat'] = onsetSoundResponseTestStatistic
db['onsetSoundResponsePVal'] = onsetSoundResponsePVal
db['sustainedSoundResponseUStat'] = sustainedSoundResponseTestStatistic
db['sustainedSoundResponsePVal'] = sustainedSoundResponsePVal
db['gaussFit'] = gaussFit
db['tuningTimeRange'] = tuningTimeRange
db['tuningFitR2'] = Rsquared
db['prefFreq'] = prefFreq
db['octavesFromPrefFreq'] = octavesFromPrefFreq
db['bestBandSession'] = bestBandSession
return db
def photoID_base_stats(db, filename=''):
'''
This function takes as argument a pandas DataFrame and adds new columns.
The filename should be the full path to where the database will be saved. If a filename is not specified, the database will not be saved.
This function computed basic statistics for all clusters (e.g. laser responsiveness, sound responsiveness, preferred frequency).
'''
soundLoc = []
NaKpeakLatency = np.empty(len(db))
laserTestStatistic = np.empty(len(db))
laserPVal = np.empty(len(db))
laserTrainTestStatistic = np.empty(len(db))
laserTrainPVal = np.empty(len(db))
laserChangeFR = np.empty(len(db))
soundResponseTestStatistic = np.empty(len(db))
soundResponsePVal = np.empty(len(db))
onsetSoundResponseTestStatistic = np.empty(len(db))
onsetSoundResponsePVal = np.empty(len(db))
sustainedSoundResponseTestStatistic = np.empty(len(db))
sustainedSoundResponsePVal = np.empty(len(db))
AMRate = np.empty(len(db))
gaussFit = []
tuningTimeRange = []
Rsquared = np.empty(len(db))
prefFreq = np.empty(len(db))
octavesFromPrefFreq = np.empty(len(db))
bestBandSession = np.empty(len(db))
for indRow, (dbIndex, dbRow) in enumerate(db.iterrows()):
cellObj = ephyscore.Cell(dbRow, useModifiedClusters=True)
print "Now processing", dbRow['subject'], dbRow['date'], dbRow[
'depth'], dbRow['tetrode'], dbRow['cluster']
# --- Determine if sound presentation was ipsi or contra to recording location ---
soundSide = dbRow['info'][2]
recordingSide = dbRow['brainArea']
if (soundSide == 'sound_left' and recordingSide == 'left_AC') or (
soundSide == 'sound_right' and recordingSide == 'right_AC'):
soundLoc.append('ipsi')
else:
soundLoc.append('contra')
# --- Determine time difference between Na and K peak (spike width) ---
peakTimes = dbRow['spikePeakTimes']
latency = peakTimes[2] - peakTimes[1]
NaKpeakLatency[indRow] = latency
# --- Determine laser responsiveness of each cell (using laser pulse) ---
try:
laserEphysData, noBehav = cellObj.load('laserPulse')
except IndexError:
print "No laser pulse session for this cell"
testStatistic = np.nan
pVal = np.nan
changeFR = np.nan
else:
testStatistic, pVal, changeFR = funcs.laser_response(
laserEphysData)
laserTestStatistic[indRow] = testStatistic
laserPVal[indRow] = pVal
laserChangeFR[indRow] = changeFR
# --- Determine laser responsiveness of each cell (using laser train) ---
try:
laserTrainEphysData, noBehav = cellObj.load('laserTrain')
except IndexError:
print "No laser train session for this cell"
testStatistic = np.nan
pVal = np.nan
else:
testStatistic, pVal, changeFR = funcs.laser_response(
laserTrainEphysData)
laserTrainTestStatistic[indRow] = testStatistic
laserTrainPVal[indRow] = pVal
# --- Determine sound responsiveness during bandwidth sessions and other statistics about bandwidth session---
try:
bandEphysData, bandBehavData = cellObj.load('bandwidth')
except IndexError:
print "No bandwidth session for this cell"
testStatistic = np.nan
pVal = np.nan
onsetTestStatistic = np.nan
onsetpVal = np.nan
sustainedTestStatistic = np.nan
sustainedpVal = np.nan
AM = np.nan
else:
bandEventOnsetTimes = funcs.get_sound_onset_times(
bandEphysData, 'bandwidth')
bandSpikeTimestamps = bandEphysData['spikeTimes']
bandEachTrial = bandBehavData['currentBand']
secondSort = bandBehavData['currentAmp']
numBands = np.unique(bandEachTrial)
numSec = np.unique(secondSort)
AM = np.unique(bandBehavData['modRate'])
trialsEachComb = behavioranalysis.find_trials_each_combination(
bandEachTrial, numBands, secondSort, numSec)
trialsEachBaseCond = trialsEachComb[:, :,
-1] #using high amp trials for photoidentified, no laser for inactivation
testStatistic, pVal = funcs.sound_response_any_stimulus(
bandEventOnsetTimes, bandSpikeTimestamps, trialsEachBaseCond,
[0.0, 1.0], [-1.2, -0.2])
onsetTestStatistic, onsetpVal = funcs.sound_response_any_stimulus(
bandEventOnsetTimes, bandSpikeTimestamps, trialsEachBaseCond,
[0.0, 0.05], [-0.25, 0.2])
sustainedTestStatistic, sustainedpVal = funcs.sound_response_any_stimulus(
bandEventOnsetTimes, bandSpikeTimestamps, trialsEachBaseCond,
[0.2, 1.0], [-1.0, 0.2])
pVal *= len(numSec) #correction for multiple comparisons
onsetpVal *= len(numSec)
sustainedpVal *= len(numSec)
soundResponseTestStatistic[indRow] = testStatistic
soundResponsePVal[indRow] = pVal
onsetSoundResponseTestStatistic[indRow] = onsetTestStatistic
onsetSoundResponsePVal[indRow] = onsetpVal
sustainedSoundResponseTestStatistic[indRow] = sustainedTestStatistic
sustainedSoundResponsePVal[indRow] = sustainedpVal
AMRate[indRow] = AM
# --- Determine frequency tuning of cells ---
try:
tuningEphysData, tuningBehavData = cellObj.load('tuningCurve')
except IndexError:
print "No tuning session for this cell"
freqFit = np.full(4, np.nan)
thisRsquared = np.nan
bestFreq = np.nan
tuningWindow = [np.nan, np.nan]
octavesFromBest = np.nan
bandIndex = np.nan
else:
tuningEventOnsetTimes = funcs.get_sound_onset_times(
tuningEphysData, 'tuningCurve')
tuningSpikeTimestamps = tuningEphysData['spikeTimes']
freqEachTrial = tuningBehavData['currentFreq']
intensityEachTrial = tuningBehavData['currentIntensity']
numFreqs = np.unique(freqEachTrial)
numIntensities = np.unique(intensityEachTrial)
timeRange = [-0.2, 0.2]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
tuningSpikeTimestamps, tuningEventOnsetTimes, timeRange)
trialsEachType = behavioranalysis.find_trials_each_type(
intensityEachTrial, numIntensities)
trialsHighInt = trialsEachType[:, -1]
trialsEachComb = behavioranalysis.find_trials_each_combination(
freqEachTrial, numFreqs, intensityEachTrial, numIntensities)
trialsEachFreqHighInt = trialsEachComb[:, :, -1]
tuningWindow = funcs.best_window_freq_tuning(
spikeTimesFromEventOnset, indexLimitsEachTrial,
trialsEachFreqHighInt)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, tuningWindow)
tuningSpikeRates = (spikeCountMat[trialsHighInt].flatten()) / (
tuningWindow[1] - tuningWindow[0])
freqsThisIntensity = freqEachTrial[trialsHighInt]
freqFit, thisRsquared = funcs.gaussian_tuning_fit(
np.log2(freqsThisIntensity), tuningSpikeRates)
if freqFit is not None:
bestFreq = 2**freqFit[0]
bandIndex, octavesFromBest = funcs.best_index(
cellObj, bestFreq, 'bandwidth')
else:
freqFit = np.full(4, np.nan)
bestFreq = np.nan
bandIndex = np.nan
octavesFromBest = np.nan
gaussFit.append(freqFit)
tuningTimeRange.append(tuningWindow)
Rsquared[indRow] = thisRsquared
prefFreq[indRow] = bestFreq
octavesFromPrefFreq[indRow] = octavesFromBest
bestBandSession[indRow] = bandIndex
db['soundLocation'] = soundLoc
db['spikeWidth'] = NaKpeakLatency
db['AMRate'] = AMRate
db['laserPVal'] = laserPVal
db['laserUStat'] = laserTestStatistic
db['laserTrainPVal'] = laserTrainPVal
db['laserTrainUStat'] = laserTrainTestStatistic
db['laserChangeFR'] = laserChangeFR
db['soundResponseUStat'] = soundResponseTestStatistic
db['soundResponsePVal'] = soundResponsePVal
db['onsetSoundResponseUStat'] = onsetSoundResponseTestStatistic
db['onsetSoundResponsePVal'] = onsetSoundResponsePVal
db['sustainedSoundResponseUStat'] = sustainedSoundResponseTestStatistic
db['sustainedSoundResponsePVal'] = sustainedSoundResponsePVal
db['gaussFit'] = gaussFit
db['tuningTimeRange'] = tuningTimeRange
db['tuningFitR2'] = Rsquared
db['prefFreq'] = prefFreq
db['octavesFromPrefFreq'] = octavesFromPrefFreq
db['bestBandSession'] = bestBandSession
if len(filename) != 0:
celldatabase.save_hdf(db, filename)
print filename + " saved"
return db
def evaluate_tuning_sound_response_celldb(cellDb):
'''
Analyse tuning curve data: calculate sound response Z score for each freq, store frequencies presented and corresponding Z scores.
'''
if not ('tuningZscore' in cellDb.columns):
print 'Calculating sound response Z scores for tuning curve'
# -- Aalyse tuning curve and 2afc data -- #
tuningDict = {
'tuningFreqs': [],
'tuningZscore': [],
'tuningPval': [],
'tuningRespIndex': [],
'tuningAveResp': []
}
for indCell, cell in cellDb.iterrows():
cellObj = ephyscore.Cell(cell)
sessiontype = 'tc' #tuningcurve
#ephysData, bata = cellObj.load(sessiontype)
sessionInd = cellObj.get_session_inds(sessiontype)[0]
bdata = cellObj.load_behavior_by_index(sessionInd)
possibleFreq = np.unique(bdata['currentFreq'])
numFreqs = len(possibleFreq)
try:
ephysData = cellObj.load_ephys_by_index(sessionInd)
except (ValueError, IOError) as error:
print(error)
spikeData = (0, 0)
tuningDict['tuningFreqs'].append(possibleFreq)
tuningDict['tuningZscore'].append(np.zeros(numFreqs))
tuningDict['tuningPval'].append(np.ones(numFreqs))
tuningDict['tuningRespIndex'].append(np.zeros(numFreqs))
tuningDict['tuningAveResp'].append(np.zeros(numFreqs))
continue
eventsDict = ephysData['events']
spikeTimestamps = ephysData['spikeTimes']
if spikeTimestamps.ndim == 0: #There is only one spike, ! spikesanalysis.eventlocked_spiketimes cannot handle only one spike !
tuningDict['tuningFreqs'].append(possibleFreq)
tuningDict['tuningZscore'].append(np.zeros(numFreqs))
tuningDict['tuningPval'].append(np.ones(numFreqs))
tuningDict['tuningRespIndex'].append(np.zeros(numFreqs))
tuningDict['tuningAveResp'].append(np.zeros(numFreqs))
continue
soundOnsetTimes = eventsDict['{}On'.format(soundChannelType)]
if len(soundOnsetTimes) != len(bdata['currentFreq']):
# This is a hack for when ephys is one trial longer than behavior
if len(soundOnsetTimes) == len(bdata['currentFreq']) + 1:
soundOnsetTimes = soundOnsetTimes[:-1]
else:
tuningDict['tuningFreqs'].append(possibleFreq)
tuningDict['tuningZscore'].append(np.zeros(numFreqs))
tuningDict['tuningPval'].append(np.ones(numFreqs))
tuningDict['tuningRespIndex'].append(np.zeros(numFreqs))
tuningDict['tuningAveResp'].append(np.zeros(numFreqs))
continue #skip all subsequent analysis if the two files did not recorded same number of trials
# -- Calculate Z score of sound response for each frequency -- #
zScores = []
pVals = []
responseEachFreq = []
responseInds = []
for freq in possibleFreq:
oneFreqTrials = bdata['currentFreq'] == freq
oneFreqSoundOnsetTimes = soundOnsetTimes[oneFreqTrials]
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spikeTimestamps,oneFreqSoundOnsetTimes,timeRange)
# Generate the spkCountMatrix where each row is one trial, each column is a time bin to count spikes in, in this case only one time bin
nspkBase = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, respRange)
print nspkBase.shape, nspkResp.shape
# Calculate response index (S-B)/(S+B) where S and B are ave response during the sound window and baseline window, respectively
responseIndex = (np.mean(nspkResp) - np.mean(nspkBase)) / (
np.mean(nspkResp) + np.mean(nspkBase))
responseInds.append(responseIndex)
responseEachFreq.append(np.mean(
nspkResp)) #Store mean response to each stim frequency
print 'ave firing rate for baseline and sound periods are', np.mean(
nspkBase), np.mean(
nspkResp), 'response index is', responseIndex
# Calculate statistic using ranksums test
[zStat, pValue] = stats.ranksums(nspkResp, nspkBase)
zScores.append(zStat)
pVals.append(pValue)
tuningDict['tuningFreqs'].append(possibleFreq)
tuningDict['tuningZscore'].append(zScores)
tuningDict['tuningPval'].append(pVals)
tuningDict['tuningRespIndex'].append(responseInds)
tuningDict['tuningAveResp'].append(responseEachFreq)
return tuningDict
def calculate_phase_discrim_accuracy(spikeTimes,
eventOnsetTimes,
currentFreq,
uniqFreq,
shuffle=False):
SHUFFLE = shuffle
# Timerange for alignment?
timeRange = [
0.05, 0.5
] # Ignoring onset responses TODO: Is this the best way to do this??
phaseDiscrimAccuracy = {}
for thisFreq in uniqFreq:
# Only use events for this frequency
eventsThisFreq = eventOnsetTimes[currentFreq == thisFreq]
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
spikeTimes, eventsThisFreq, timeRange)
# This is really all we need to do to bin things by phase.
radsPerSec = thisFreq * 2 * np.pi
spikeRads = (spikeTimesFromEventOnset * radsPerSec) % (2 * np.pi)
strength, phase = signal.vectorstrength(spikeTimesFromEventOnset,
1.0 / thisFreq)
phase = (phase + 2 * np.pi) % (2 * np.pi)
shiftedRads = ((spikeRads - phase) + 2.25 * np.pi)
if any(shiftedRads < 0):
raise ValueError("Some shifted rads below 0")
# shiftedRads = ((spikeRads - phase) + 2.25*np.pi)%(2*np.pi)
spikeRads = shiftedRads % (2 * np.pi)
nBins = 4
binEdges = np.arange(0, 2.01 * np.pi, 2 * np.pi /
nBins) # The 2.01 makes it actually include 2pi
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeRads, indexLimitsEachTrial, binEdges)
spikeCountMatCopy = copy.deepcopy(spikeCountMat)
spikeCountMatShuffle = np.empty(np.shape(spikeCountMatCopy))
for indMatRow in range(np.shape(spikeCountMatCopy)[0]):
numRolls = np.random.choice(range(np.shape(spikeCountMatCopy)[1]))
# numRolls = 0
spikeCountMatShuffle[indMatRow, :] = np.roll(
spikeCountMatCopy[indMatRow, :], numRolls)
if SHUFFLE:
spikeCountMat = spikeCountMatShuffle
binMeans = np.mean(spikeCountMat, axis=0)
prefInd = np.argmax(binMeans)
nonPrefInd = np.argmin(binMeans)
spikesPref = spikeCountMat[:, prefInd]
spikesNonPref = spikeCountMat[:, nonPrefInd]
maxAccuracy, threshold = linear_discriminator(spikesPref,
spikesNonPref)
# dataframe.set_value(indRow, 'phaseAccuracy_{}Hz'.format(int(thisFreq)), maxAccuracy)
phaseDiscrimAccuracy[int(thisFreq)] = maxAccuracy
return phaseDiscrimAccuracy
def plot_pinp_report(dbRow, saveDir=None, useModifiedClusters=True):
#Init cell object
cell = ephyscore.Cell(dbRow, useModifiedClusters=useModifiedClusters)
plt.clf()
gs = gridspec.GridSpec(11, 6)
gs.update(left=0.15, right=0.95, bottom=0.15, wspace=1, hspace=1)
if 'noiseburst' in dbRow['sessionType']: #DONE
ax0 = plt.subplot(gs[0:2, 0:3])
ephysData, bdata = cell.load('noiseburst')
eventOnsetTimes = ephysData['events']['stimOn']
timeRange = [-0.3, 0.5]
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
ephysData['spikeTimes'], eventOnsetTimes, timeRange)
pRaster, hCond, zLine = extraplots.raster_plot(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
plt.setp(pRaster, ms=1)
ax0.set_xlim(timeRange)
ax0.set_xticks([])
#Laser pulse psth
ax1 = plt.subplot(gs[4:6, 0:3])
win = np.array([0, 0.25, 0.75, 1, 0.75, 0.25,
0]) # scipy.signal.hanning(7)
win = win / np.sum(win)
binEdges = np.arange(timeRange[0], timeRange[-1], 0.001)
timeVec = binEdges[
1:] # FIXME: is this the best way to define the time axis?
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges)
avResp = np.mean(spikeCountMat, axis=0)
smoothPSTH = np.convolve(avResp, win, mode='same')
plt.plot(timeVec, smoothPSTH, 'k-', mec='none', lw=2)
ax1.set_xlim(timeRange)
ax1.set_xlabel('Time from noise onset (s)')
if 'laserpulse' in dbRow['sessionType']: #DONE
#Laser pulse raster
ax0 = plt.subplot(gs[2:4, 0:3])
ephysData, bdata = cell.load('laserpulse')
eventOnsetTimes = ephysData['events']['stimOn']
timeRange = [-0.3, 0.5]
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
ephysData['spikeTimes'], eventOnsetTimes, timeRange)
pRaster, hCond, zLine = extraplots.raster_plot(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
plt.setp(pRaster, ms=1)
ax0.set_xlim(timeRange)
ax0.set_xticks([])
#Laser pulse psth
ax1 = plt.subplot(gs[4:6, 0:3])
win = np.array([0, 0.25, 0.75, 1, 0.75, 0.25,
0]) # scipy.signal.hanning(7)
win = win / np.sum(win)
binEdges = np.arange(timeRange[0], timeRange[-1], 0.001)
timeVec = binEdges[
1:] # FIXME: is this the best way to define the time axis?
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges)
avResp = np.mean(spikeCountMat, axis=0)
smoothPSTH = np.convolve(avResp, win, mode='same')
plt.plot(timeVec, smoothPSTH, 'k-', mec='none', lw=2)
ax1.set_xlim(timeRange)
ax1.set_xlabel('Time from laser pulse onset (s)')
if 'lasertrain' in dbRow['sessionType']: #DONE
#Laser train raster
ax2 = plt.subplot(gs[2:4, 3:6])
ephysData, bdata = cell.load('lasertrain')
eventOnsetTimes = ephysData['events']['stimOn']
eventOnsetTimes = spikesanalysis.minimum_event_onset_diff(
eventOnsetTimes, 0.5)
timeRange = [-0.5, 1]
pulseTimes = [0, 0.2, 0.4, 0.6, 0.8]
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
ephysData['spikeTimes'], eventOnsetTimes, timeRange)
pRaster, hCond, zLine = extraplots.raster_plot(
spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange)
plt.setp(pRaster, ms=1)
ax2.set_xlim(timeRange)
ax2.set_xticks(pulseTimes)
#Laser train psth
ax3 = plt.subplot(gs[4:6, 3:6])
win = np.array([0, 0.25, 0.75, 1, 0.75, 0.25,
0]) # scipy.signal.hanning(7)
win = win / np.sum(win)
binEdges = np.arange(timeRange[0], timeRange[-1], 0.001)
timeVec = binEdges[
1:] # FIXME: is this the best way to define the time axis?
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges)
avResp = np.mean(spikeCountMat, axis=0)
smoothPSTH = np.convolve(avResp, win, mode='same')
plt.plot(timeVec, smoothPSTH, 'k-', mec='none', lw=2)
ax3.set_xlim(timeRange)
ax3.set_xticks(pulseTimes)
ax3.set_xlabel('Time from first pulse onset (s)')
#Sorted tuning raster
if 'tc' in dbRow['sessionType']: #DONE
ax4 = plt.subplot(gs[6:8, 0:3])
ephysData, bdata = cell.load('tc')
eventOnsetTimes = ephysData['events']['stimOn']
timeRange = [-0.5, 1]
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
ephysData['spikeTimes'], eventOnsetTimes, timeRange)
freqEachTrial = bdata['currentFreq']
possibleFreq = np.unique(freqEachTrial)
freqLabels = ['{0:.1f}'.format(freq / 1000.0) for freq in possibleFreq]
trialsEachCondition = behavioranalysis.find_trials_each_type(
freqEachTrial, possibleFreq)
pRaster, hCond, zLine = extraplots.raster_plot(
spikeTimesFromEventOnset,
indexLimitsEachTrial,
timeRange,
trialsEachCond=trialsEachCondition,
labels=freqLabels)
plt.setp(pRaster, ms=1)
ax4.set_ylabel('Frequency (kHz)')
#TC heatmap
ax5 = plt.subplot(gs[8:10, 0:3])
baseRange = [-0.1, 0]
responseRange = [0, 0.1]
alignmentRange = [baseRange[0], responseRange[1]]
freqEachTrial = bdata['currentFreq']
possibleFreq = np.unique(freqEachTrial)
intensityEachTrial = bdata['currentIntensity']
possibleIntensity = np.unique(intensityEachTrial)
#Init arrays to hold the baseline and response spike counts per condition
allIntenBase = np.array([])
allIntenResp = np.empty((len(possibleIntensity), len(possibleFreq)))
spikeTimes = ephysData['spikeTimes']
for indinten, inten in enumerate(possibleIntensity):
spks = np.array([])
freqs = np.array([])
base = np.array([])
for indfreq, freq in enumerate(possibleFreq):
selectinds = np.flatnonzero((freqEachTrial == freq)
& (intensityEachTrial == inten))
selectedOnsetTimes = eventOnsetTimes[selectinds]
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
spikeTimes, selectedOnsetTimes, alignmentRange)
nspkBase = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial,
responseRange)
base = np.concatenate([base, nspkBase.ravel()])
spks = np.concatenate([spks, nspkResp.ravel()])
# inds = np.concatenate([inds, np.ones(len(nspkResp.ravel()))*indfreq])
freqs = np.concatenate(
[freqs, np.ones(len(nspkResp.ravel())) * freq])
allIntenBase = np.concatenate([allIntenBase, nspkBase.ravel()])
allIntenResp[indinten, indfreq] = np.mean(nspkResp)
lowFreq = possibleFreq.min()
highFreq = possibleFreq.max()
nFreqLabels = 3
freqTickLocations = np.linspace(0, len(possibleFreq), nFreqLabels)
freqs = np.logspace(np.log10(lowFreq), np.log10(highFreq), nFreqLabels)
freqs = np.round(freqs, decimals=1)
nIntenLabels = 3
intensities = np.linspace(possibleIntensity.min(),
possibleIntensity.max(), nIntenLabels)
intenTickLocations = np.linspace(0,
len(possibleIntensity) - 1,
nIntenLabels)
plt.imshow(np.flipud(allIntenResp),
interpolation='nearest',
cmap='Blues')
ax5.set_yticks(intenTickLocations)
ax5.set_yticklabels(intensities[::-1])
ax5.set_xticks(freqTickLocations)
freqLabels = ['{0:.1f}'.format(freq) for freq in freqs]
# ax.set_xticklabels(freqLabels, rotation='vertical')
ax5.set_xticklabels(freqLabels)
ax5.set_xlabel('Frequency (kHz)')
plt.ylabel('Intensity (db SPL)')
if not pd.isnull(dbRow['threshold']):
plt.hold(1)
indThresh = (len(possibleIntensity) - 1) - np.where(
dbRow['threshold'] == possibleIntensity)[0]
indCF = np.where(dbRow['cf'] == possibleFreq)[0]
# import ipdb; ipdb.set_trace()
ax5.plot(indCF, indThresh, 'r*')
plt.suptitle('Threshold: {}'.format(dbRow['threshold']))
if not pd.isnull(dbRow['upperFreq']):
plt.hold(1)
threshPlus10 = indThresh - (10 / np.diff(possibleIntensity)[0])
upperFraction = (np.log2(dbRow['upperFreq']) - np.log2(
possibleFreq[0])) / (np.log2(possibleFreq[-1]) -
np.log2(possibleFreq[0]))
indUpper = upperFraction * (len(possibleFreq) - 1)
lowerFraction = (np.log2(dbRow['lowerFreq']) - np.log2(
possibleFreq[0])) / (np.log2(possibleFreq[-1]) -
np.log2(possibleFreq[0]))
indLower = lowerFraction * (len(possibleFreq) - 1)
# import ipdb; ipdb.set_trace()
ax5.plot(indUpper, threshPlus10, 'b*')
ax5.plot(indLower, threshPlus10, 'b*')
if 'am' in dbRow['sessionType']: #DONE
#Sorted am raster
# ax6 = plt.subplot(gs[4:6, 3:6])
ax6spec = gs[6:8, 3:6]
ephysData, bdata = cell.load('am')
eventOnsetTimes = ephysData['events']['stimOn']
colors = get_colors(len(np.unique(bdata['currentFreq'])))
timeRange = [-0.5, 1]
(spikeTimesFromEventOnset, trialIndexForEachSpike,
indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(
ephysData['spikeTimes'], eventOnsetTimes, timeRange)
# extraplots.raster_plot(spikeTimesFromEventOnset,
# indexLimitsEachTrial,
# timeRange,
# trialsEachCond=bdata['currentFreq'],
# colorsEachCond=colors)
plot_example_with_rate(ax6spec,
spikeTimesFromEventOnset,
indexLimitsEachTrial,
bdata['currentFreq'],
colorEachCond=colors,
maxSyncRate=cell.dbRow['highestSyncCorrected'])
#AM cycle average hist
psthLineWidth = 2
ax7 = plt.subplot(gs[8:10, 3:6])
colorEachCond = colors
plt.hold(True)
sortArray = bdata['currentFreq']
for indFreq, (freq, spikeTimesThisFreq,
trialIndicesThisFreq) in enumerate(
spiketimes_each_frequency(spikeTimesFromEventOnset,
trialIndexForEachSpike,
sortArray)):
radsPerSec = freq * 2 * np.pi
spikeRads = (spikeTimesThisFreq * radsPerSec) % (2 * np.pi)
ax7.hist(spikeRads,
bins=20,
color=colors[indFreq],
histtype='step')
#AM psth
# psthLineWidth = 2
# ax7 = plt.subplot(gs[6:8, 3:6])
# colorEachCond = colors
# binsize = 50
# sortArray = bdata['currentFreq']
# binsize = binsize/1000.0
# # If a sort array is supplied, find the trials that correspond to each value of the array
# trialsEachCond = behavioranalysis.find_trials_each_type(sortArray, np.unique(sortArray))
# (spikeTimesFromEventOnset,
# trialIndexForEachSpike,
# indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes(ephysData['spikeTimes'],
# eventOnsetTimes,
# [timeRange[0]-binsize,
# timeRange[1]])
# binEdges = np.around(np.arange(timeRange[0]-binsize, timeRange[1]+2*binsize, binsize), decimals=2)
# spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges)
# pPSTH = extraplots.plot_psth(spikeCountMat/binsize, 1, binEdges[:-1], trialsEachCond, colorEachCond=colors)
# plt.setp(pPSTH, lw=psthLineWidth)
# plt.hold(True)
# zline = plt.axvline(0,color='0.75',zorder=-10)
# plt.xlim(timeRange)
(timestamps, samples, recordingNumber) = cell.load_all_spikedata()
#ISI loghist
ax8 = plt.subplot(gs[10, 0:2])
if timestamps is not None:
try:
spikesorting.plot_isi_loghist(timestamps)
except:
# raise AttributeError
print "problem with isi vals"
#Waveforms
ax9 = plt.subplot(gs[10, 2:4])
if len(samples) > 0:
spikesorting.plot_waveforms(samples)
#Events in time
ax10 = plt.subplot(gs[10, 4:6])
if timestamps is not None:
try:
spikesorting.plot_events_in_time(timestamps)
except:
print "problem with isi vals"
fig = plt.gcf()
fig.set_size_inches(8.5 * 2, 11 * 2)
figName = '{}_{}_{}um_TT{}c{}.png'.format(dbRow['subject'], dbRow['date'],
int(dbRow['depth']),
int(dbRow['tetrode']),
int(dbRow['cluster']))
plt.suptitle(figName[:-4])
if saveDir is not None:
figPath = os.path.join(saveDir, figName)
plt.savefig(figPath)
def plot_example_with_rate(subplotSpec, exampleName, color='k'):
fig = plt.gcf()
sub_gs = gridspec.GridSpecFromSubplotSpec(1, 4, subplot_spec=subplotSpec, wspace=-0.45, hspace=0.0)
specRaster = sub_gs[0:2]
axRaster = plt.Subplot(fig, specRaster)
fig.add_subplot(axRaster)
spikeTimes = exampleSpikeTimes[exampleName]
indexLimitsEachTrial = exampleIndexLimitsEachTrial[exampleName]
timeRange = [-0.2, 0.7]
freqEachTrial = exampleFreqEachTrial[exampleName]
possibleFreq = np.unique(freqEachTrial)
freqLabels = ['{0:.0f}'.format(freq) for freq in possibleFreq]
trialsEachCondition = behavioranalysis.find_trials_each_type(freqEachTrial, possibleFreq)
pRaster, hCond, zline = extraplots.raster_plot(spikeTimes, indexLimitsEachTrial,
timeRange, trialsEachCondition, labels=freqLabels)
plt.setp(pRaster, ms=figparams.rasterMS)
blankLabels = ['']*11
for labelPos in [0, 5, 10]:
blankLabels[labelPos] = freqLabels[labelPos]
axRaster.set_yticklabels(blankLabels)
ax = plt.gca()
ax.set_xticks([0, 0.5])
ax.set_xlabel('Time from\nsound onset (s)', fontsize=fontSizeLabels, labelpad=-1)
ax.set_ylabel('AM rate (Hz)', fontsize=fontSizeLabels, labelpad=-5)
# ax.annotate('A', xy=(labelPosX[0],labelPosY[0]), xycoords='figure fraction',
# fontsize=fontSizePanel, fontweight='bold')
countRange = [0.1, 0.5]
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimes, indexLimitsEachTrial, countRange)
numSpikesInTimeRangeEachTrial = np.squeeze(spikeCountMat)
numSpikesInTimeRangeEachTrial = np.squeeze(np.diff(indexLimitsEachTrial,
axis=0))
if len(numSpikesInTimeRangeEachTrial) == len(freqEachTrial)+1:
numSpikesInTimeRangeEachTrial = numSpikesInTimeRangeEachTrial[:-1]
conditionMatShape = np.shape(trialsEachCondition)
numRepeats = np.product(conditionMatShape[1:])
nSpikesMat = np.reshape(numSpikesInTimeRangeEachTrial.repeat(numRepeats),
conditionMatShape)
spikesFilteredByTrialType = nSpikesMat * trialsEachCondition
avgSpikesArray = np.sum(spikesFilteredByTrialType, 0) / np.sum(
trialsEachCondition, 0).astype('float')/np.diff(np.array(countRange))
stdSpikesArray = np.std(spikesFilteredByTrialType, 0)/np.diff(np.array(countRange))
specRate = sub_gs[3]
axRate = plt.Subplot(fig, specRate)
fig.add_subplot(axRate)
nRates = len(possibleFreq)
# plt.hold(True)
plt.plot(avgSpikesArray, range(nRates), 'ro-', mec='none', ms=6, lw=3, color=color)
plt.plot(avgSpikesArray-stdSpikesArray, range(len(possibleFreq)), 'k:')
plt.plot(avgSpikesArray+stdSpikesArray, range(len(possibleFreq)), 'k:')
axRate.set_ylim([-0.5, nRates-0.5])
axRate.set_yticks(range(nRates))
axRate.set_yticklabels([])
# ax = plt.gca()
axRate.set_xlabel('Firing rate\n(spk/s)', fontsize = fontSizeLabels, labelpad=-1)
extraplots.boxoff(axRate)
# extraplots.boxoff(ax, keep='right')
return axRaster, axRate
spkTimeStamps = spkData.spikes.timestamps
clusterNumber = (oneCell.tetrode-1)*clusNum+(oneCell.cluster-1)
for Freq in possibleFreq:
oneFreq = targetFreqs == Freq
trialsToUseRight = rightward & oneFreq
trialsToUseLeft = leftward & oneFreq
#print 'behavior ',behavSession,' tetrode ',oneCell.tetrode,' cluster ',oneCell.cluster,'freq',Freq
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,countTimeRange)
spikeCountEachTrial = spikeCountMat.flatten()
spikeAvgRight = sum(spikeCountEachTrial[trialsToUseRight])/float(sum(trialsToUseRight))
spikeAvgLeft = sum(spikeCountEachTrial[trialsToUseLeft])/float(sum(trialsToUseLeft))
if ((spikeAvgRight + spikeAvgLeft) == 0):
modIDict[behavSession][Freq][clusterNumber]=0.0
else:
modIDict[behavSession][Freq][clusterNumber]=((spikeAvgRight - spikeAvgLeft)/(spikeAvgRight + spikeAvgLeft))
#print spikeAvgRight,' ', spikeAvgLeft, ' ',modIDict[behavSession][Freq][clusterNumber]
except:
if (oneCell.behavSession not in badSessionList):
badSessionList.append(oneCell.behavSession)
def plot_example_with_rate(subplotSpec,
spikeTimes,
indexLimitsEachTrial,
freqEachTrial,
color='k',
colorEachCond=None,
maxSyncRate=None):
fig = plt.gcf()
gs = gridspec.GridSpecFromSubplotSpec(1,
4,
subplot_spec=subplotSpec,
wspace=-0.45,
hspace=0.0)
specRaster = gs[0:2]
axRaster = plt.Subplot(fig, specRaster)
fig.add_subplot(axRaster)
# spikeTimes = exampleSpikeTimes[exampleName]
# indexLimitsEachTrial = exampleIndexLimitsEachTrial[exampleName]
timeRange = [-0.2, 0.7]
# freqEachTrial = exampleFreqEachTrial[exampleName]
possibleFreq = np.unique(freqEachTrial)
freqLabels = ['{0:.1f}'.format(freq) for freq in possibleFreq]
trialsEachCondition = behavioranalysis.find_trials_each_type(
freqEachTrial, possibleFreq)
pRaster, hCond, zline = extraplots.raster_plot(spikeTimes,
indexLimitsEachTrial,
timeRange,
trialsEachCondition,
labels=freqLabels,
colorEachCond=colorEachCond)
axYTicks = plt.gca().get_yticklabels()
if (maxSyncRate is not None) and (maxSyncRate !=
0.0) and not np.isnan(maxSyncRate):
indMaxSync = np.where(possibleFreq == maxSyncRate)
axYTicks[int(indMaxSync[0])].set_color('red')
plt.setp(pRaster, ms=2)
ax = plt.gca()
ax.set_xticks([0, 0.5])
ax.set_xlabel('Time from\nsound onset (s)')
ax.set_ylabel('AM Rate (Hz)')
# ax.annotate('A', xy=(labelPosX[0],labelPosY[0]), xycoords='figure fraction',
# fontsize=fontSizePanel, fontweight='bold')
countRange = [0.1, 0.5]
spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(
spikeTimes, indexLimitsEachTrial, countRange)
numSpikesInTimeRangeEachTrial = np.squeeze(spikeCountMat)
numSpikesInTimeRangeEachTrial = np.squeeze(
np.diff(indexLimitsEachTrial, axis=0))
if len(numSpikesInTimeRangeEachTrial) == len(freqEachTrial) + 1:
numSpikesInTimeRangeEachTrial = numSpikesInTimeRangeEachTrial[:-1]
conditionMatShape = np.shape(trialsEachCondition)
numRepeats = np.product(conditionMatShape[1:])
nSpikesMat = np.reshape(numSpikesInTimeRangeEachTrial.repeat(numRepeats),
conditionMatShape)
spikesFilteredByTrialType = nSpikesMat * trialsEachCondition
avgSpikesArray = np.sum(spikesFilteredByTrialType, 0) / np.sum(
trialsEachCondition, 0).astype('float') / np.diff(np.array(countRange))
stdSpikesArray = np.std(spikesFilteredByTrialType, 0) / np.diff(
np.array(countRange))
specRate = gs[3]
axRate = plt.Subplot(fig, specRate)
fig.add_subplot(axRate)
nRates = len(possibleFreq)
plt.hold(True)
plt.plot(avgSpikesArray,
range(nRates),
'ro-',
mec='none',
ms=7,
lw=3,
color=color)
plt.plot(avgSpikesArray - stdSpikesArray, range(len(possibleFreq)), 'k:')
plt.plot(avgSpikesArray + stdSpikesArray, range(len(possibleFreq)), 'k:')
axRate.set_ylim([-0.5, nRates - 0.5])
axRate.set_yticks(range(nRates))
axRate.set_yticklabels([])
#ax = plt.gca()
axRate.set_xlabel('Firing rate\n(spk/s)')
extraplots.boxoff(axRate)
# extraplots.boxoff(ax, keep='right')
return (axRaster, axRate)
