def suppression_stats(cell, bandIndex=0):
cellInfo = get_cell_info(cell)
loader = dataloader.DataLoader(cell['subject'])
try:
eventData = loader.get_session_events(cellInfo['ephysDirs'][bandIndex])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][bandIndex],
cellInfo['tetrode'],
cluster=cellInfo['cluster'])
bandBData = loader.get_session_behavior(
cellInfo['behavDirs'][bandIndex])
except IOError:
print "File does not exist"
return None, None
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimeStamps = spikeData.timestamps
timeRange = [0.0, 1.0]
bandEachTrial = bandBData['currentBand']
ampEachTrial = bandBData['currentAmp']
charFreq = np.unique(bandBData['charFreq'])[0]
numBands = np.unique(bandEachTrial)
numAmps = np.unique(ampEachTrial)
spikeArray, errorArray, baselineSpikeRate = band_select(
spikeTimeStamps, eventOnsetTimes, ampEachTrial, bandEachTrial,
timeRange)
print spikeArray
suppressionStats = compute_suppression_stats(spikeArray, numBands)
return suppressionStats
def band_SNR_laser_psychometric(animal, sessions, trialTypes='laserSide', paradigm='2afc', xlabel=True, ylabel=True):
loader = dataloader.DataLoader(animal)
validPerSNR = None
rightPerSNR = None
for ind, session in enumerate(sessions):
behavFile = loadbehavior.path_to_behavior_data(animal,paradigm,session)
behavData = loader.get_session_behavior(behavFile)
ax = plt.gca()
ax.cla()
possibleSNRs = np.unique(behavData['currentSNR'])
laserTrialTypes = np.unique(behavData[trialTypes])
trialsEachCond = behavioranalysis.find_trials_each_combination(behavData['currentSNR'], possibleSNRs,
behavData[trialTypes], laserTrialTypes)
valid = behavData['valid'].astype(bool)
rightChoice = behavData['choice']==behavData.labels['choice']['right']
if validPerSNR is None:
validPerSNR = np.zeros((len(laserTrialTypes),len(possibleSNRs)))
rightPerSNR = np.zeros((len(laserTrialTypes),len(possibleSNRs)))
for las in range(len(laserTrialTypes)):
trialsThisLaser = trialsEachCond[:,:,las]
for inds in range(len(possibleSNRs)):
trialsThisSNR = trialsThisLaser[:,inds]
validThisSNR = np.sum(trialsThisSNR.astype(int)[valid])
rightThisSNR = np.sum(trialsThisSNR.astype(int)[rightChoice])
validPerSNR[las,inds] += validThisSNR
rightPerSNR[las,inds] += rightThisSNR
return validPerSNR, rightPerSNR, possibleSNRs, laserTrialTypes
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 highest_significant_sync(cell):
try:
sessiontypeIndex = cell['sessiontype'].index(defaultAMtype)
except ValueError: #The cell does not have this session type
return None
#Initialize a data loader for this animal
loader = dataloader.DataLoader(cell['subject'])
#Get the behavior data
behavData = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
freqEachTrial = behavData['currentFreq']
possibleFreq = np.unique(freqEachTrial)
ephysDir = cell['ephys'][sessiontypeIndex]
clusterSpikeData = loader.get_session_spikes(ephysDir,
int(cell['tetrode']),
cluster=int(cell['cluster']))
clusterSpikeTimes = clusterSpikeData.timestamps
#Get the events for this session and calculate onset times
eventData = loader.get_session_events(ephysDir)
eventOnsetTimes = loader.get_event_onset_times(eventData,
minEventOnsetDiff=None)
timeRange = [0, 0.5]
trialsEachCond = behavioranalysis.find_trials_each_type(
freqEachTrial, possibleFreq)
vs_array, pval_array, ral_array = AM_vector_strength(
clusterSpikeTimes, eventOnsetTimes, behavData, timeRange)
if np.any(pval_array < 0.05):
highestSync = np.max(possibleFreq[pval_array < 0.05])
else:
highestSync = 0
return highestSync
def best_band_index(cell):
cellInfo = get_cell_info(cell)
loader = dataloader.DataLoader(cell['subject'])
bandIndex = cellInfo['bandIndex']
if len(bandIndex)==0:
bandIndex = cellInfo['laserBandIndex']
charFreqs = []
if len(bandIndex)==0:
print "No bandwidth session"
return None, None, None
for ind in bandIndex:
bandBData = loader.get_session_behavior(cellInfo['behavDirs'][ind])
charFreq = np.unique(bandBData['charFreq'])[0]
charFreqs.append(charFreq)
tuningIndex = cellInfo['tuningIndex'][0]
tuningBData = loader.get_session_behavior(cellInfo['behavDirs'][tuningIndex])
eventData = loader.get_session_events(cellInfo['ephysDirs'][tuningIndex])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][tuningIndex], cellInfo['tetrode'], cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimeStamps = spikeData.timestamps
freqEachTrial = tuningBData['currentFreq']
bandAtBest = []
for charFreq in charFreqs:
atBestFreq, bestFreq = at_best_freq(spikeTimeStamps, eventOnsetTimes, charFreq, freqEachTrial)
bandAtBest.append(atBestFreq)
if True in bandAtBest:
bestIndex = bandAtBest.index(True)
bandIndex = bandIndex[bestIndex]
atBestFreq = True
else:
bandIndex = None
return bandIndex, atBestFreq, bestFreq
def compare_laser_spikeshapes(cell):
try:
sessiontypeIndex = cell['sessiontype'].index('LaserPulse')
except ValueError: #The cell does not have this session type
return numpy.nan, numpy.nan
loader = dataloader.DataLoader(cell['subject'])
clusterSpikeData = loader.get_session_spikes(
cell['ephys'][sessiontypeIndex],
cluster=int(cell['cluster']),
tetrode=int(cell['tetrode']))
eventData = loader.get_session_events(cell['ephys'][sessiontypeIndex])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spontRange = [-0.1, -0]
evokedRange = [0, 0.1]
samples = clusterSpikeData.samples
timestamps = clusterSpikeData.timestamps
spontWaveform, spontStd = average_waveform_in_timerange(
samples, timestamps, eventOnsetTimes, spontRange)
evokedWaveform, evokedStd = average_waveform_in_timerange(
samples, timestamps, eventOnsetTimes, evokedRange)
return spontWaveform, evokedWaveform, spontStd, evokedStd
def plot_bandwidth_report_if_best(cell):
cellInfo = get_cell_info(cell)
loader = dataloader.DataLoader(cell['subject'])
bandIndex = cellInfo['bandIndex']
charFreqs = []
for ind in bandIndex:
bandBData = loader.get_session_behavior(cellInfo['behavDirs'][ind])
charFreq = np.unique(bandBData['charFreq'])[0]
charFreqs.append(charFreq)
tuningIndex = cellInfo['tuningIndex'][0]
tuningBData = loader.get_session_behavior(cellInfo['behavDirs'][tuningIndex])
eventData = loader.get_session_events(cellInfo['ephysDirs'][tuningIndex])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][tuningIndex], cellInfo['tetrode'], cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimeStamps = spikeData.timestamps
freqEachTrial = tuningBData['currentFreq']
bandAtBest = []
for charFreq in charFreqs:
atBestFreq = at_best_freq(spikeTimeStamps, eventOnsetTimes, charFreq, freqEachTrial)
bandAtBest.append(atBestFreq)
#plot reports for cells at best frequency
if True in bandAtBest:
bestIndex = bandAtBest.index(True)
bandIndex = bandIndex[bestIndex]
plot_bandwidth_report(cell, bandIndex)
def tuning_curve_response(cell):
'''
Calculate max Z-score during the response period for each freq-inten combo in a TC
'''
try:
sessiontypeIndex = cell['sessiontype'].index(defaultTCtype)
except ValueError: #The cell does not have this session type
return None
#Initialize a data loader for this animal
loader = dataloader.DataLoader(cell['subject'])
#Get the behavior data
behavData = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
intensityEachTrial = behavData['currentIntensity']
freqEachTrial = behavData['currentFreq']
possibleFreq = np.unique(freqEachTrial)
possibleIntensity = np.unique(intensityEachTrial)
#Return the cluster spike data for this ephys session
ephysDir = cell['ephys'][sessiontypeIndex]
clusterSpikeData = loader.get_session_spikes(ephysDir, int(cell['tetrode']), cluster=int(cell['cluster']))
clusterSpikeTimes = clusterSpikeData.timestamps
#Get the events for this session and calculate onset times
eventData = loader.get_session_events(ephysDir)
eventOnsetTimes = loader.get_event_onset_times(eventData, minEventOnsetDiff=None)
baseRange = [-0.1, 0]
responseRange = [0, 0.1]
alignmentRange = [baseRange[0], responseRange[1]]
zvalArray = np.zeros((len(possibleIntensity), len(possibleFreq)))
for indfreq, freq in enumerate(possibleFreq):
for indinten, inten in enumerate(possibleIntensity):
selectinds = np.flatnonzero((freqEachTrial==freq)&(intensityEachTrial==inten))
selectedOnsetTimes = eventOnsetTimes[selectinds]
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(clusterSpikeTimes,selectedOnsetTimes,alignmentRange)
nspkBase = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
baseRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,
responseRange)
zStat, pValue = stats.ranksums(nspkResp[:,0], nspkBase[:,0])
zvalArray[indinten, indfreq] = zStat
return zvalArray
def event_response_score(cell,
sessiontype,
maxZonly=False,
responseTimeRange=[-0.5, 1],
skip=False):
'''
Used to calculate simple response to noise bursts and laser pulses
'''
#Find the index of the ephys for this session if it exists
try:
sessiontypeIndex = cell['sessiontype'].index(sessiontype)
except ValueError: #The cell does not have this session type
return None
#Initialize a data loader for this animal
loader = dataloader.DataLoader(cell['subject'])
#Return the cluster spike data for this ephys session
ephysDir = cell['ephys'][sessiontypeIndex]
clusterSpikeData = loader.get_session_spikes(ephysDir,
int(cell['tetrode']),
cluster=int(cell['cluster']))
clusterSpikeTimes = clusterSpikeData.timestamps
#Get the events for this session and calculate onset times
eventData = loader.get_session_events(ephysDir)
eventOnsetTimes = loader.get_event_onset_times(eventData,
minEventOnsetDiff=None)
if skip:
onsetTimesToUse = np.arange(skip, len(eventOnsetTimes), skip)
eventOnsetTimes = eventOnsetTimes[onsetTimesToUse]
#Zscore settings from billy
baseRange = [-0.050, -0.025] # Baseline range (in seconds)
binTime = baseRange[1] - baseRange[0] # Time-bin size
responseTimeRange = responseTimeRange #Time range to calculate z value for (should be divisible by binTime
responseTime = responseTimeRange[1] - responseTimeRange[0]
numBins = responseTime / binTime
binEdges = np.arange(responseTimeRange[0], responseTimeRange[1], binTime)
timeRange = [-0.5, 1]
#TODO: Get the spikes and events
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(clusterSpikeTimes,eventOnsetTimes,timeRange)
[zStat, pValue, maxZ] = spikesanalysis.response_score(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange, binEdges
) #computes z score for each bin. zStat is array of z scores. maxZ is maximum value of z in timeRange
if maxZonly:
return maxZ
else:
return zStat, pValue, maxZ
def behav_stats(animal, sessions, paradigm='2afc'):
loader = dataloader.DataLoader(animal)
nValid = 0
nCorrect = 0
for session in sessions:
behavFile = loadbehavior.path_to_behavior_data(animal,paradigm,session)
behavData = loader.get_session_behavior(behavFile)
correct = behavData['outcome']==behavData.labels['outcome']['correct']
valid = behavData['valid'].astype(bool)
nValid += len(valid)
nCorrect += len(correct[correct==True])
return nValid, nCorrect
def plot_laser_bandwidth_summary(cell, bandIndex):
cellInfo = get_cell_info(cell)
loader = dataloader.DataLoader(cell['subject'])
plt.clf()
gs = gridspec.GridSpec(2, 4)
eventData = loader.get_session_events(cellInfo['ephysDirs'][bandIndex])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][bandIndex], cellInfo['tetrode'], cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimestamps = spikeData.timestamps
timeRange = [-0.2, 1.5]
bandBData = loader.get_session_behavior(cellInfo['behavDirs'][bandIndex])
bandEachTrial = bandBData['currentBand']
laserTrial = bandBData['laserTrial']
numBands = np.unique(bandEachTrial)
numLas = np.unique(laserTrial)
firstSortLabels = ['{}'.format(band) for band in np.unique(bandEachTrial)]
secondSortLabels = ['no laser','laser']
trialsEachCond = behavioranalysis.find_trials_each_combination(bandEachTrial,
numBands,
laserTrial,
numLas)
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimestamps,
eventOnsetTimes,
timeRange)
colours = [np.tile(['0.25','0.6'],len(numBands)/2+1), np.tile(['#4e9a06','#8ae234'],len(numBands)/2+1)]
for ind, secondArrayVal in enumerate(numLas):
plt.subplot(gs[ind, 0:2])
trialsThisSecondVal = trialsEachCond[:, :, ind]
pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset,
indexLimitsEachTrial,
timeRange,
trialsEachCond=trialsThisSecondVal,
labels=firstSortLabels,
colorEachCond = colours[ind])
plt.setp(pRaster, ms=4)
#plt.title(secondSortLabels[ind])
plt.ylabel('bandwidth (octaves)')
if ind == len(numLas) - 1:
plt.xlabel("Time from sound onset (sec)")
# -- plot Yashar plots for bandwidth data --
plt.subplot(gs[0:, 2:])
spikeArray, errorArray, baseSpikeRate = band_select(spikeTimestamps, eventOnsetTimes, laserTrial, bandEachTrial, timeRange = [0.0, 1.0])
band_select_plot(spikeArray, errorArray, baseSpikeRate, numBands, legend=True, labels=secondSortLabels, linecolours=['0.25','#4e9a06'], errorcolours=['0.6','#8ae234'])
fig_path = '/home/jarauser/Pictures/cell reports'
fig_name = '{0}_{1}_{2}um_TT{3}Cluster{4}.svg'.format(cellInfo['subject'], cellInfo['date'], cellInfo['depth'], cellInfo['tetrode'], cellInfo['cluster'])
full_fig_path = os.path.join(fig_path, fig_name)
fig = plt.gcf()
fig.set_size_inches(16, 8)
fig.savefig(full_fig_path, format = 'svg', bbox_inches='tight')
def plot_am_psth(cell):
try:
sessiontypeIndex = cell['sessiontype'].index(defaultAMtype)
except ValueError: #The cell does not have this session type
return None
#Initialize a data loader for this animal
loader = dataloader.DataLoader(cell['subject'])
#Get the behavior data
behavData = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
freqEachTrial = behavData['currentFreq']
possibleFreq = np.unique(freqEachTrial)
ephysDir = cell['ephys'][sessiontypeIndex]
clusterSpikeData = loader.get_session_spikes(ephysDir,
int(cell['tetrode']),
cluster=int(cell['cluster']))
clusterSpikeTimes = clusterSpikeData.timestamps
#Get the events for this session and calculate onset times
eventData = loader.get_session_events(ephysDir)
eventOnsetTimes = loader.get_event_onset_times(eventData,
minEventOnsetDiff=None)
# timeRange = [-0.1, 0.6]
# spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(clusterSpikeTimes, eventOnsetTimes, timeRange)
# colourList = ['b', 'g', 'y', 'orange', 'r']
nColors = len(possibleFreq)
# colors = plt.cm.viridis(np.linspace(0, 1, nColors))
colors = plt.cm.jet(np.linspace(0, 1, nColors))
# numRates = np.unique(rateEachTrial)
# trialsEachCond = behavioranalysis.find_trials_each_type(rateEachTrial, numRates)
dataplotter.plot_psth(clusterSpikeTimes,
eventOnsetTimes,
freqEachTrial,
timeRange=[-0.2, 0.8],
binsize=50,
colorEachCond=colors)
plt.xlabel('Time from sound onset (sec)')
plt.ylabel('Firing rate (Hz)')
plt.title('AM PSTH')
def behav_laser_stats(animal, sessions, paradigm='2afc'):
loader = dataloader.DataLoader(animal)
nValid = [0,0]
nCorrect = [0,0]
for session in sessions:
behavFile = loadbehavior.path_to_behavior_data(animal,paradigm,session)
behavData = loader.get_session_behavior(behavFile)
laserTrials = np.where(behavData['laserSide']!=0)
conTrials = np.where(behavData['laserSide']==0)
correct = behavData['outcome']==behavData.labels['outcome']['correct']
valid = behavData['valid'].astype(bool)
nValid[0] += len(valid[conTrials])
nValid[1] += len(valid[laserTrials])
nCorrect[0] += np.sum(correct[conTrials])
nCorrect[1] += np.sum(correct[laserTrials])
return nValid, nCorrect
def am_dependence(spikesEachTrial, rateEachTrial):
'''
Calculate the average firing rate of a cell during the 0.5sec AM sound.
Perform a linear regression on average firing rate and AM rate, and
return the correlation coefficient for the regression.
'''
try:
sessiontypeIndex = cell['sessiontype'].index(defaultAMtype)
except ValueError: #The cell does not have this session type
return None
#Initialize a data loader for this animal
loader = dataloader.DataLoader(cell['subject'])
#Get the behavior data
behavData = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
freqEachTrial = behavData['currentFreq']
possibleFreq = np.unique(freqEachTrial)
ephysDir = cell['ephys'][sessiontypeIndex]
clusterSpikeData = loader.get_session_spikes(ephysDir,
int(cell['tetrode']),
cluster=int(cell['cluster']))
clusterSpikeTimes = clusterSpikeData.timestamps
#Get the events for this session and calculate onset times
eventData = loader.get_session_events(ephysDir)
eventOnsetTimes = loader.get_event_onset_times(eventData,
minEventOnsetDiff=None)
timeRange = [0, 0.5]
trialsEachCond = behavioranalysis.find_trials_each_type(
freqEachTrial, possibleFreq)
spikeArray = dataplotter.avg_spikes_in_event_locked_timerange_each_cond(
clusterSpikeTimes, trialsEachCond, eventOnsetTimes, timeRange)
slope, intercept, r_value, p_value, std_err = stats.linregress(
spikeArray, possibleFreq)
if not frArray:
return r_value
else:
return r_value, spikeArray, possibleFreq
def plot_am_raster(cell):
try:
sessiontypeIndex = cell['sessiontype'].index(defaultAMtype)
except ValueError: #The cell does not have this session type
return None
#Initialize a data loader for this animal
loader = dataloader.DataLoader(cell['subject'])
#Get the behavior data
behavData = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
freqEachTrial = behavData['currentFreq']
possibleFreq = np.unique(freqEachTrial)
ephysDir = cell['ephys'][sessiontypeIndex]
clusterSpikeData = loader.get_session_spikes(ephysDir,
int(cell['tetrode']),
cluster=int(cell['cluster']))
clusterSpikeTimes = clusterSpikeData.timestamps
#Get the events for this session and calculate onset times
eventData = loader.get_session_events(ephysDir)
eventOnsetTimes = loader.get_event_onset_times(eventData,
minEventOnsetDiff=None)
timeRange = [-0.2, 0.8]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
clusterSpikeTimes, eventOnsetTimes, timeRange)
nColors = len(possibleFreq)
# colors = plt.cm.viridis(np.linspace(0, 1, nColors))
colors = plt.cm.jet(np.linspace(0, 1, nColors))
freqLabels = ["%.0f" % rate for rate in np.unique(freqEachTrial)]
dataplotter.plot_raster(clusterSpikeTimes,
eventOnsetTimes,
sortArray=freqEachTrial,
timeRange=[-0.2, 0.8],
labels=freqLabels,
colorEachCond=colors)
plt.xlabel('Time from sound onset (sec)')
plt.ylabel('Modulation Rate (Hz)')
plt.title('AM Raster')
def time_differences_by_trial(animal, sessions, sortBy, paradigm = '2afc', triggers = ['Cin', 'Cout']):
loader = dataloader.DataLoader(animal)
timeDiff = []
import pdb
for ind,session in enumerate(sessions):
behavFile = loadbehavior.path_to_behavior_data(animal,paradigm,session)
behavData = loader.get_session_behavior(behavFile)
possibleSort = np.unique(behavData[sortBy])
if ind == 0:
for sort in range(len(possibleSort)):
timeDiff.append([])
trialsEachCond = behavioranalysis.find_trials_each_type(behavData[sortBy], possibleSort)
eventCode = np.array(behavData.events['eventCode'])
eventTime = behavData.events['eventTime']
nextState = behavData.events['nextState']
trialEnd = np.where(nextState==behavData.stateMatrix['statesNames']['startTrial'])[0][1:]
try:
start = np.where(eventCode==behavData.stateMatrix['eventsNames'][triggers[0]])[0]
except KeyError:
start = np.where(nextState==behavData.stateMatrix['statesNames'][triggers[0]])[0]+1
try:
stop = np.where(eventCode==behavData.stateMatrix['eventsNames'][triggers[1]])[0]
except KeyError:
stop = np.where(nextState==behavData.stateMatrix['statesNames'][triggers[1]])[0]+1
for ind in range(len(possibleSort)):
trialsThisCond = trialsEachCond[:,ind]
if len(trialsThisCond) > len(trialEnd):
trialsThisCond = trialsThisCond[:-1]
trialEndThisCond = trialEnd[trialsThisCond]
startThisCond = np.zeros(sum(trialsThisCond))
stopThisCond = np.zeros(sum(trialsThisCond))
#pdb.set_trace()
for i in range(len(trialEndThisCond)):
startThisCond[i] = max(j for j in start if j < trialEndThisCond[i])
stopThisCond[i] = min(k for k in stop if k > startThisCond[i])
startThisCond = startThisCond.astype(int)
stopThisCond = stopThisCond.astype(int)
startTime = eventTime[startThisCond]
stopTime = eventTime[stopThisCond]
diffThisCond = stopTime - startTime
#pdb.set_trace()
timeDiff[ind].extend(diffThisCond)
return timeDiff, possibleSort
def plot_cell_am(cell, amtype):
fontsize = 20
loader = dataloader.DataLoader(cell['subject'])
try:
sessiontypeIndex = cell['sessiontype'].index(amtype)
plt.cla()
bdata = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
eventData = loader.get_session_events(cell['ephys'][sessiontypeIndex])
spikeData = loader.get_session_spikes(cell['ephys'][sessiontypeIndex],
int(cell['tetrode']),
cluster=int(cell['cluster']))
spikeTimestamps = spikeData.timestamps
eventOnsetTimes = loader.get_event_onset_times(eventData)
currentFreq = bdata['currentFreq']
dataplotter.plot_raster(spikeTimestamps,
eventOnsetTimes,
sortArray=currentFreq,
fillWidth=0,
timeRange=[-0.2, 0.8],
ms=2.5)
ax = plt.gca()
# extraplots.set_ticks_fontsize(ax, fontsize)
# ax.set_yticks(np.linspace(0, 10, 3))
# ax.set_yticklabels(np.round(np.logspace(np.log10(4), np.log10(128), 3), decimals=1))
fig = plt.gcf()
# fig.set_size_inches(4.3, 3.9)
plt.ylabel('AM Rate (Hz)', fontsize=fontsize)
plt.xlabel('Time from sound onset (s)', fontsize=fontsize)
# ax.set_xticks([0, 0.5])
except ValueError: #The cell does not have this session type
print 'no am'
def band_SNR_psychometric(animal, sessions, paradigm = '2afc'):
loader = dataloader.DataLoader(animal)
validPerSNR = None
rightPerSNR = None
for ind,session in enumerate(sessions):
behavFile = loadbehavior.path_to_behavior_data(animal,paradigm,session)
behavData = loader.get_session_behavior(behavFile)
possibleSNRs = np.unique(behavData['currentSNR'])
trialsEachCond = behavioranalysis.find_trials_each_type(behavData['currentSNR'], possibleSNRs)
valid = behavData['valid'].astype(bool)
rightChoice = behavData['choice']==behavData.labels['choice']['right']
if validPerSNR is None:
validPerSNR = np.zeros(len(possibleSNRs))
rightPerSNR = np.zeros(len(possibleSNRs))
for inds in range(len(possibleSNRs)):
trialsThisSNR = trialsEachCond[:,inds]
validThisSNR = np.sum(trialsThisSNR.astype(int)[valid])
rightThisSNR = np.sum(trialsThisSNR.astype(int)[rightChoice])
validPerSNR[inds] += validThisSNR
rightPerSNR[inds] += rightThisSNR
return validPerSNR, rightPerSNR, possibleSNRs
def time_differences(animal, sessions, paradigm = '2afc', triggers = ['Cin', 'Cout']):
import pdb
loader = dataloader.DataLoader(animal)
timeDiff = None
for ind,session in enumerate(sessions):
behavFile = loadbehavior.path_to_behavior_data(animal,paradigm,session)
behavData = loader.get_session_behavior(behavFile)
eventCode = np.array(behavData.events['eventCode'])
eventTime = behavData.events['eventTime']
nextState = behavData.events['nextState']
try:
start = np.where(eventCode==behavData.stateMatrix['eventsNames'][triggers[0]])[0]
except KeyError:
start = np.where(nextState==behavData.stateMatrix['statesNames'][triggers[0]])[0]+1
try:
stop = np.where(eventCode==behavData.stateMatrix['eventsNames'][triggers[1]])[0]
except KeyError:
stop = np.where(nextState==behavData.stateMatrix['statesNames'][triggers[1]])[0]+1
if len(start)>len(stop):
startAll = start.copy()
start = np.zeros(len(stop))
for i in range(len(stop)):
start[i] = max(j for j in startAll if j < stop[i])
start = start.astype(int)
if len(stop)>len(start):
stopAll = stop.copy()
stop = np.zeros(len(start))
for i in range(len(start)):
stop[i] = min(j for j in stopAll if j > start[i])
stop = stop.astype(int)
startTime = eventTime[start]
stopTime = eventTime[stop]
pdb.set_trace()
diffThisSess = stopTime-startTime
if timeDiff is None:
timeDiff = diffThisSess
else:
timeDiff = np.concatenate((timeDiff, diffThisSess))
return timeDiff
def suppression_stats(cell, bandSession=0):
cellInfo = get_cell_info(cell)
loader = dataloader.DataLoader(cell['subject'])
try:
bandIndex = cellInfo['bandIndex'][bandSession] #defaults to first band session if none speficied
except IndexError:
print "No bandwidth session"
return None, None
try:
eventData = loader.get_session_events(cellInfo['ephysDirs'][bandIndex])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][bandIndex], cellInfo['tetrode'], cluster=cellInfo['cluster'])
bandBData = loader.get_session_behavior(cellInfo['behavDirs'][bandIndex])
except IOError:
print "File does not exist"
return None, None
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimeStamps = spikeData.timestamps
timeRange = [0.0, 1.0]
bandEachTrial = bandBData['currentBand']
ampEachTrial = bandBData['currentAmp']
charFreq = np.unique(bandBData['charFreq'])[0]
numBands = np.unique(bandEachTrial)
numAmps = np.unique(ampEachTrial)
spikeArray, errorArray, baselineSpikeRate = band_select(spikeTimeStamps, eventOnsetTimes, ampEachTrial, bandEachTrial, timeRange)
suppressionStats = compute_suppression_stats(spikeArray, numBands)
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
laserResponse = laser_response(spikeTimestamps, eventOnsetTimes)
else:
laserResponse = False
return suppressionStats, laserResponse
def plot_bandwidth_report(cell, bandIndex):
cellInfo = get_cell_info(cell)
#pdb.set_trace()
loader = dataloader.DataLoader(cell['subject'])
if len(cellInfo['laserIndex'])>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)
# -- plot bandwidth rasters --
plt.clf()
eventData = loader.get_session_events(cellInfo['ephysDirs'][bandIndex])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][bandIndex], cellInfo['tetrode'], cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimestamps = spikeData.timestamps
timeRange = [-0.2, 1.5]
bandBData = loader.get_session_behavior(cellInfo['behavDirs'][bandIndex])
bandEachTrial = bandBData['currentBand']
ampEachTrial = bandBData['currentAmp']
charfreq = str(np.unique(bandBData['charFreq'])[0]/1000)
modrate = str(np.unique(bandBData['modRate'])[0])
numBands = np.unique(bandEachTrial)
numAmps = np.unique(ampEachTrial)
firstSortLabels = ['{}'.format(band) for band in np.unique(bandEachTrial)]
secondSortLabels = ['Amplitude: {}'.format(amp) for amp in np.unique(ampEachTrial)]
spikeTimesFromEventOnset, indexLimitsEachTrial, trialsEachCond, firstSortLabels = bandwidth_raster_inputs(eventOnsetTimes, spikeTimestamps, bandEachTrial, ampEachTrial)
colours = [np.tile(['#4e9a06','#8ae234'],len(numBands)/2+1), np.tile(['#5c3566','#ad7fa8'],len(numBands)/2+1)]
for ind, secondArrayVal in enumerate(numAmps):
plt.subplot(gs[5+2*ind+offset:7+2*ind+offset, 0:3])
trialsThisSecondVal = trialsEachCond[:, :, ind]
pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset,
indexLimitsEachTrial,
timeRange,
trialsEachCond=trialsThisSecondVal,
labels=firstSortLabels,
colorEachCond = colours[ind])
plt.setp(pRaster, ms=4)
plt.title(secondSortLabels[ind])
plt.ylabel('bandwidth (octaves)')
if ind == len(np.unique(ampEachTrial)) - 1:
plt.xlabel("Time from sound onset (sec)")
# -- plot Yashar plots for bandwidth data --
plt.subplot(gs[5+offset:, 3:])
spikeArray, errorArray, baseSpikeRate = band_select(spikeTimestamps, eventOnsetTimes, ampEachTrial, bandEachTrial, timeRange = [0.0, 1.0])
band_select_plot(spikeArray, errorArray, baseSpikeRate, numBands, legend=True)
# -- plot frequency tuning heat map --
tuningBData = loader.get_session_behavior(cellInfo['behavDirs'][cellInfo['tuningIndex'][-1]])
freqEachTrial = tuningBData['currentFreq']
intEachTrial = tuningBData['currentIntensity']
eventData = loader.get_session_events(cellInfo['ephysDirs'][cellInfo['tuningIndex'][-1]])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][cellInfo['tuningIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimestamps = spikeData.timestamps
plt.subplot(gs[2+offset:4+offset, 0:3])
dataplotter.two_axis_heatmap(spikeTimestamps=spikeTimestamps,
eventOnsetTimes=eventOnsetTimes,
firstSortArray=intEachTrial,
secondSortArray=freqEachTrial,
firstSortLabels=["%.0f" % inten for inten in np.unique(intEachTrial)],
secondSortLabels=["%.1f" % freq for freq in np.unique(freqEachTrial)/1000.0],
xlabel='Frequency (kHz)',
ylabel='Intensity (dB SPL)',
plotTitle='Frequency Tuning Curve',
flipFirstAxis=False,
flipSecondAxis=False,
timeRange=[0, 0.1])
plt.ylabel('Intensity (dB SPL)')
plt.xlabel('Frequency (kHz)')
plt.title('Frequency Tuning Curve')
# -- plot frequency tuning raster --
plt.subplot(gs[0+offset:2+offset, 0:3])
freqLabels = ["%.1f" % freq for freq in np.unique(freqEachTrial)/1000.0]
dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, sortArray=freqEachTrial, timeRange=[-0.1, 0.5], labels=freqLabels)
plt.xlabel('Time from sound onset (sec)')
plt.ylabel('Frequency (kHz)')
plt.title('Frequency Tuning Raster')
# -- plot AM PSTH --
amBData = loader.get_session_behavior(cellInfo['behavDirs'][cellInfo['amIndex'][-1]])
rateEachTrial = amBData['currentFreq']
eventData = loader.get_session_events(cellInfo['ephysDirs'][cellInfo['amIndex'][-1]])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][cellInfo['amIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimestamps = spikeData.timestamps
timeRange = [-0.2, 1.5]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimestamps, eventOnsetTimes, timeRange)
colourList = ['b', 'g', 'y', 'orange', 'r']
numRates = np.unique(rateEachTrial)
trialsEachCond = behavioranalysis.find_trials_each_type(rateEachTrial, numRates)
plt.subplot(gs[2+offset:4+offset, 3:])
dataplotter.plot_psth(spikeTimestamps, eventOnsetTimes, 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)]
dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, sortArray=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 --
plt.subplot(gs[0:2, 0:3])
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
timeRange = [-0.1, 0.4]
dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, timeRange=timeRange)
plt.xlabel('Time from sound onset (sec)')
plt.title('Laser Pulse Raster')
# -- plot laser pulse psth --
plt.subplot(gs[2:4, 0:3])
dataplotter.plot_psth(spikeTimestamps, eventOnsetTimes, timeRange = timeRange, binsize = 10)
plt.xlabel('Time from sound onset (sec)')
plt.ylabel('Firing Rate (Hz)')
plt.title('Laser Pulse PSTH')
# -- didn't record laser trains for some earlier sessions --
if len(cellInfo['laserTrainIndex']) > 0:
# -- plot laser train raster --
plt.subplot(gs[0:2, 3:])
eventData = loader.get_session_events(cellInfo['ephysDirs'][cellInfo['laserTrainIndex'][-1]])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][cellInfo['laserTrainIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimestamps = spikeData.timestamps
timeRange = [-0.2, 1.0]
dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, timeRange=timeRange)
plt.xlabel('Time from sound onset (sec)')
plt.title('Laser Train Raster')
# -- plot laser train psth --
plt.subplot(gs[2:4, 3:])
dataplotter.plot_psth(spikeTimestamps, eventOnsetTimes, timeRange = timeRange, binsize = 10)
plt.xlabel('Time from sound onset (sec)')
plt.ylabel('Firing Rate (Hz)')
plt.title('Laser Train PSTH')
# -- show cluster analysis --
tsThisCluster, wavesThisCluster = load_cluster_waveforms(cellInfo)
# -- Plot ISI histogram --
plt.subplot(gs[4+offset, 0:2])
spikesorting.plot_isi_loghist(tsThisCluster)
plt.ylabel('c%d'%cellInfo['cluster'],rotation=0,va='center',ha='center')
plt.xlabel('')
# -- Plot waveforms --
plt.subplot(gs[4+offset, 2:4])
spikesorting.plot_waveforms(wavesThisCluster)
# -- Plot events in time --
plt.subplot(gs[4+offset, 4:6])
spikesorting.plot_events_in_time(tsThisCluster)
plt.suptitle('{0}, {1}, {2}um, Tetrode {3}, Cluster {4}, {5}kHz, {6}Hz modulation'.format(cellInfo['subject'],
cellInfo['date'],
cellInfo['depth'],
cellInfo['tetrode'],
cellInfo['cluster'],
charfreq,
modrate))
fig_path = '/home/jarauser/Pictures/cell reports'
fig_name = '{0}_{1}_{2}um_TT{3}Cluster{4}.png'.format(cellInfo['subject'], cellInfo['date'], cellInfo['depth'], cellInfo['tetrode'], cellInfo['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 plot_cell_phys(cell, rastertypes, tctype):
loader = dataloader.DataLoader(cell['subject'])
fig = plt.clf()
#Plot raster sessions
for indRaster, rastertype in enumerate(rastertypes):
plt.subplot2grid((6, 6), (indRaster, 0), rowspan=1, colspan=3)
try:
sessiontypeIndex = cell['sessiontype'].index(rastertype)
except ValueError: #The cell does not have this session type
continue
sessionEphys = cell['ephys'][sessiontypeIndex]
rasterSpikes = loader.get_session_spikes(sessionEphys,
int(cell['tetrode']),
cluster=int(cell['cluster']))
spikeTimestamps = rasterSpikes.timestamps
rasterEvents = loader.get_session_events(sessionEphys)
eventOnsetTimes = loader.get_event_onset_times(rasterEvents)
dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, ms=1)
plt.ylabel('{}\n{}'.format(rastertype,
sessionEphys.split('_')[1]),
fontsize=10)
ax = plt.gca()
extraplots.set_ticks_fontsize(ax, 6)
#Plot tuning curve
try:
sessiontypeIndex = cell['sessiontype'].index(tctype)
plt.subplot2grid((6, 6), (0, 3), rowspan=3, colspan=3)
bdata = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
eventData = loader.get_session_events(cell['ephys'][sessiontypeIndex])
spikeData = loader.get_session_spikes(cell['ephys'][sessiontypeIndex],
int(cell['tetrode']),
cluster=int(cell['cluster']))
spikeTimestamps = spikeData.timestamps
eventOnsetTimes = loader.get_event_onset_times(eventData)
freqEachTrial = bdata['currentFreq']
intensityEachTrial = bdata['currentIntensity']
possibleFreq = np.unique(freqEachTrial)
possibleIntensity = np.unique(intensityEachTrial)
xlabel = 'Frequency (kHz)'
ylabel = 'Intensity (dB SPL)'
freqLabels = ["%.1f" % freq for freq in possibleFreq / 1000.0]
intenLabels = ["%.1f" % inten for inten in possibleIntensity]
dataplotter.two_axis_heatmap(spikeTimestamps=spikeTimestamps,
eventOnsetTimes=eventOnsetTimes,
firstSortArray=intensityEachTrial,
secondSortArray=freqEachTrial,
firstSortLabels=intenLabels,
secondSortLabels=freqLabels,
xlabel=xlabel,
ylabel=ylabel,
plotTitle='',
flipFirstAxis=True,
flipSecondAxis=False,
timeRange=[0, 0.1],
cmap='magma')
# plt.title("{0}\n{1}".format(mainTCsession, mainTCbehavFilename), fontsize = 10)
except ValueError: #The cell does not have this session type
print 'no tc'
plt.show()
def tuning_curve_response(cell):
'''
Calculate max Z-score during the response period for each freq-inten combo in a TC
'''
try:
sessiontypeIndex = cell['sessiontype'].index('TuningCurve')
except ValueError: #The cell does not have this session type
return None
#Initialize a data loader for this animal
loader = dataloader.DataLoader(cell['subject'])
#Get the behavior data
behavData = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
intensityEachTrial = behavData['currentIntensity']
freqEachTrial = behavData['currentFreq']
possibleFreq = np.unique(freqEachTrial)
possibleIntensity = np.unique(intensityEachTrial)
#Return the cluster spike data for this ephys session
ephysDir = cell['ephys'][sessiontypeIndex]
clusterSpikeData = loader.get_session_spikes(ephysDir,
int(cell['tetrode']),
cluster=int(cell['cluster']))
clusterSpikeTimes = clusterSpikeData.timestamps
#Get the events for this session and calculate onset times
eventData = loader.get_session_events(ephysDir)
eventOnsetTimes = loader.get_event_onset_times(eventData,
minEventOnsetDiff=None)
timeRange = [0, 0.1]
baseRange = [-0.050, -0.025] # Baseline range (in seconds)
binTime = baseRange[1] - baseRange[0] # Time-bin size
responseTimeRange = timeRange #Time range to calculate z value for (should be divisible by binTime
responseTime = responseTimeRange[1] - responseTimeRange[0]
numBins = responseTime / binTime
binEdges = np.arange(responseTimeRange[0], responseTimeRange[1], binTime)
zvalArray = np.zeros((len(possibleIntensity), len(possibleFreq)))
for indfreq, freq in enumerate(possibleFreq):
for indinten, inten in enumerate(possibleIntensity):
selectinds = np.flatnonzero((freqEachTrial == freq)
& (intensityEachTrial == inten))
selectedOnsetTimes = eventOnsetTimes[selectinds]
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(clusterSpikeTimes,selectedOnsetTimes,timeRange)
[zStat, pValue, maxZ] = spikesanalysis.response_score(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange,
binEdges
) #computes z score for each bin. zStat is array of z scores. maxZ is maximum value of z in timeRange
zvalArray[indinten, indfreq] = maxZ
# zvalArray = np.flipud(zvalArray)
return zvalArray
def plot_bandwidth_noise_amps_comparison(cell, bandIndex=None):
cellInfo = get_cell_info(cell)
loader = dataloader.DataLoader(cell['subject'])
if bandIndex is None:
try:
bandIndex = cellInfo['bandIndex'][0]
except IndexError:
print 'no bandwidth session'
pass
plt.clf()
gs = gridspec.GridSpec(1, 2)
eventData = loader.get_session_events(cellInfo['ephysDirs'][bandIndex])
spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][bandIndex],
cellInfo['tetrode'],
cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimestamps = spikeData.timestamps
timeRange = [-0.2, 1.5]
bandBData = loader.get_session_behavior(cellInfo['behavDirs'][bandIndex])
bandEachTrial = bandBData['currentBand']
secondSort = bandBData['currentAmp']
secondSortLabels = ['{} dB'.format(amp) for amp in np.unique(secondSort)]
plt.subplot(gs[0, 0])
spikeArray, errorArray, baseSpikeRate = band_select(spikeTimestamps,
eventOnsetTimes,
secondSort,
bandEachTrial,
timeRange=[0.0, 1.0])
spikeArray = spikeArray[:, -1].reshape((7, 1))
errorArray = errorArray[:, -1].reshape((7, 1))
band_select_plot(spikeArray,
errorArray,
np.unique(bandEachTrial),
linecolours=['0.25'],
errorcolours=['0.6'])
plt.title('Bandwidth tuning')
ampsBData = loader.get_session_behavior(
cellInfo['behavDirs'][cellInfo['ampsIndex'][-1]])
ampEachTrial = ampsBData['currentIntensity']
eventData = loader.get_session_events(
cellInfo['ephysDirs'][cellInfo['ampsIndex'][-1]])
spikeData = loader.get_session_spikes(
cellInfo['ephysDirs'][cellInfo['ampsIndex'][-1]],
cellInfo['tetrode'],
cluster=cellInfo['cluster'])
eventOnsetTimes = loader.get_event_onset_times(eventData)
spikeTimestamps = spikeData.timestamps
timeRange = [-0.2, 1.0]
spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(
spikeTimestamps, eventOnsetTimes, timeRange)
numRates = np.unique(ampEachTrial)
trialsEachCond = behavioranalysis.find_trials_each_type(
ampEachTrial, numRates)
plt.subplot(gs[0, 1])
spikeArray, errorArray, baseSpikeRate = band_select(
spikeTimestamps,
eventOnsetTimes,
ampsBData['currentFreq'],
ampEachTrial,
timeRange=[0.0, 0.5])
band_select_plot(spikeArray,
errorArray,
np.unique(ampEachTrial),
linecolours=['0.25'],
errorcolours=['0.6'])
plt.xlabel('white noise intensity (dB)')
plt.ylabel('Average num spikes')
plt.title('Intensity tuning')
fig_path = '/home/jarauser/Pictures/cell reports'
fig_name = '{0}_{1}_{2}um_TT{3}Cluster{4}_noiseAmps.png'.format(
cellInfo['subject'], cellInfo['date'], cellInfo['depth'],
cellInfo['tetrode'], cellInfo['cluster'])
full_fig_path = os.path.join(fig_path, fig_name)
fig = plt.gcf()
fig.set_size_inches(9, 4)
fig.savefig(full_fig_path, format='png', bbox_inches='tight')
from jaratest.nick.utils import transferutils as tf
from jaratest.nick.database import dataplotter
reload(dataplotter)
from jaratest.nick.utils import clusterutils
reload(clusterutils)
reload(tf)
from matplotlib import pyplot as plt
import numpy as np
import os
subject = inforec.subject
sessions = inforec.experiments[0].sites[0].session_ephys_dirs()
sessionTypes = inforec.experiments[0].sites[0].session_types()
sessionBehav = inforec.experiments[0].sites[0].session_behav_filenames()
loader = dataloader.DataLoader(subject)
for session in sessions:
tf.rsync_session_data(subject, session)
for bfile in sessionBehav:
tf.rsync_behavior(subject, bfile)
for tetrode in range(1, 9):
# tetrode=1 #This was the best tetrode
#Cluster the sessions together
idString = '2016-08-24_light_sound'
oneTT = clusterutils.cluster_many_sessions(subject,
sessions,
tetrode,
idString,
def plot_cell_tc(cell, tctype):
loader = dataloader.DataLoader(cell['subject'])
# try:
sessiontypeIndex = cell['sessiontype'].index(tctype)
plt.cla()
bdata = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
eventData = loader.get_session_events(cell['ephys'][sessiontypeIndex])
spikeData = loader.get_session_spikes(cell['ephys'][sessiontypeIndex],
int(cell['tetrode']),
cluster=int(cell['cluster']))
spikeTimestamps = spikeData.timestamps
eventOnsetTimes = loader.get_event_onset_times(eventData)
freqEachTrial = bdata['currentFreq']
intensityEachTrial = bdata['currentIntensity']
possibleFreq = np.unique(freqEachTrial)
possibleIntensity = np.unique(intensityEachTrial)
xlabel = 'Frequency (kHz)'
ylabel = 'Intensity (dB SPL)'
freqLabels = ["%.1f" % freq for freq in possibleFreq / 1000.0]
intenLabels = ["%d" % inten for inten in possibleIntensity]
ax, cax, cbar, spikeArray = dataplotter.two_axis_heatmap(
spikeTimestamps=spikeTimestamps,
eventOnsetTimes=eventOnsetTimes,
firstSortArray=intensityEachTrial,
secondSortArray=freqEachTrial,
firstSortLabels=intenLabels,
secondSortLabels=freqLabels,
xlabel=xlabel,
ylabel=ylabel,
plotTitle='',
flipFirstAxis=False,
flipSecondAxis=False,
timeRange=[0, 0.1],
cmap='YlOrRd')
fontsize = 20
ax.set_xticks(np.linspace(0, 15, 3))
ax.set_xticklabels(
np.round(np.logspace(np.log10(2), np.log10(40), 3), decimals=1))
ax.set_xlabel('Frequency (kHz)', fontsize=fontsize)
ax.set_ylabel('Intensity (dB SPL)', fontsize=fontsize)
cbar.ax.yaxis.labelpad = -10
maxFr = np.max(spikeArray.ravel())
print maxFr
cbar.set_clim(0, maxFr)
cbar.set_ticks([0, maxFr])
cbar.set_ticklabels([0, np.int(maxFr * 10)])
cbar.set_label('Firing rate (Hz)', fontsize=fontsize)
plt.show()
extraplots.set_ticks_fontsize(ax, fontsize)
extraplots.set_ticks_fontsize(cbar.ax, fontsize)
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
import scipy
db = pandas.read_hdf('/home/nick/data/database/pinp017/pinp017_database.h5',
'database')
soundResponsive = db.query(
'isiViolations<0.02 and shapeQuality>2 and noisePval<0.05')
cell = soundResponsive.iloc[0]
sessiontypeIndex = cell['sessiontype'].index('tc')
#Initialize a data loader for this animal
loader = dataloader.DataLoader(cell['subject'])
#Get the behavior data
behavData = loader.get_session_behavior(cell['behavior'][sessiontypeIndex])
intensityEachTrial = behavData['currentIntensity']
freqEachTrial = behavData['currentFreq']
possibleFreq = np.unique(freqEachTrial)
possibleIntensity = np.unique(intensityEachTrial)
#Return the cluster spike data for this ephys session
ephysDir = cell['ephys'][sessiontypeIndex]
clusterSpikeData = loader.get_session_spikes(ephysDir,
int(cell['tetrode']),
cluster=int(cell['cluster']))
clusterSpikeTimes = clusterSpikeData.timestamps
timeDiff[ind].extend(diffThisCond)
return timeDiff, possibleSort
if __name__ == '__main__':
import pdb
SAVE = 0
CASE = 2
paradigm = '2afc'
if CASE < 3:
#animalNames = ['band011']#, 'band012']
#animalNames = ['band011', 'band012', 'band017','band020']
animalNames = ['band020']
session = ['20170414a','20170415a','20170416a']
for ind,animal in enumerate(animalNames):
#plt.subplot(2,2,ind+1)
loader = dataloader.DataLoader(animal)
behavFile = loadbehavior.path_to_behavior_data(animal,paradigm,session[0])
behavData = loader.get_session_behavior(behavFile)
if ind<2:
xlabel = False
else:
xlabel = True
if ind%2==0:
ylabel = True
else:
ylabel = False
if CASE==0:
plot_dynamics(behavData)
elif CASE==1:
band_discrim_byside(behavData)
elif CASE==2:
