def get_plot(mice,date,plo_typ):
EXPERIMENTER = settings.DEFAULT_EXPERIMENTER
paradigm = '2afc'
subject_list = mice
session_list = date
all_file_name = []
for subject in subject_list:
for session in session_list:
behavFile = loadbehavior.path_to_behavior_data(subject,EXPERIMENTER,paradigm,session)
behavData = loadbehavior.FlexCategBehaviorData(behavFile,readmode='full')
for plot_type in plo_typ:
out_dict = form_out_put(sub=subject,typ=plot_type,data=behavData,sess=session)
all_file_name.append(out_dict['filename'])
if not check_exsit(fil_nam=out_dict['filename']):
#non_exsi_file.append(out_dict['filename'])
test_list=[]
test_list.append(out_dict)
pg.Generate(plotList=test_list)
#test_plot(out_dic=out_dict)
#print
return all_file_name
def get_plot(mice,date,plo_typ):
'''
Args:
mice: A list to store the mice
date: A list to store the dates
plo_typ: A list to store the plot types
Returns:
all_file_name: A list to store all the file names that referenced in this excuction
'''
subject_list = mice
session_list = date
all_file_name = []
for subject in subject_list:
for session in session_list:
behavData = None
try:
behavFile = loadbehavior.path_to_behavior_data(subject,EXPERIMENTER,paradigm,session)
behavData = loadbehavior.FlexCategBehaviorData(behavFile,readmode='full')
except:
for plot_type in plo_typ:
out_dict = form_out_put(sub=subject,typ='summary',data=None,sess=session)
all_file_name.append(out_dict['filename'])
continue
for plot_type in plo_typ:
out_dict = form_out_put(sub=subject,typ=plot_type,data=behavData,sess=session)
all_file_name.append(out_dict['filename'])
if not check_exist(fil_nam=out_dict['filename']):
#non_exsi_file.append(out_dict['filename'])
#test_list=[]
#test_list.append(out_dict)
pg.generate(plotInfo=out_dict)
return all_file_name
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 load_session_data(self, session, experiment, site, tetrode, cluster=None, behavClass=None):
'''
Return ephys and behavior data for a particular session.
Args
session (int or str): Can be an integer index, to be used
on the list of sessions for this site/experiment,
or a string with the timestamp of the session.
experiment (int): The index of the experiment to use
site (int): The index of the site to use
tetrode (int): Tetrode number to load
cluster (int): Cluster number to load (set to None to load all clusters)
behavClass (str): name of jaratoolbox.loadbehavior class to use for loading behavior
Returns
ephysData (dict): dictionary of ephys data returned by jaratoolbox.ephyscore.load_ephys()
bdata (dict): jaratoolbox.loadbehavior.BehaviorData (or subclass, depending on behavClass arg)
'''
sessionObj = self.get_session_obj(session, experiment, site)
sessionDir = sessionObj.ephys_dir()
#Some info to return about the session. TODO: Is this necessary??
info = {'sessionDir':sessionDir}
if behavClass == None:
behavClass = loadbehavior.BehaviorData
if sessionObj.behavsuffix is not None:
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')
else:
bdata = None
ephysData = ephyscore.load_ephys(sessionObj.subject, sessionObj.paradigm, sessionDir, tetrode, cluster)
return ephysData, bdata, info
def load_many_sessions(animalNames,sessions,paradigm='2afc',datesRange=None):
'''
Based on behavioranalysis.save_many_sessions_reversal()
TO DO:
- Add params='all', (it depends on loadbehavior.FlexCateg being able to load a subset of vars)
- What to do if a parameter only exists for some sessions?
'''
if isinstance(animalNames,str):
animalNames = [animalNames]
if datesRange:
datesLims = [parse_isodate(dateStr) for dateStr in datesRange]
allDates = [datesLims[0]+datetime.timedelta(n) \
for n in range((datesLims[-1]-datesLims[0]).days+1)]
allSessions = [oneDate.strftime('%Y%m%da') for oneDate in allDates]
else:
allSessions = sessions
nAnimals = len(animalNames)
if paradigm=='2afc':
loadingClass = loadbehavior.FlexCategBehaviorData
else:
raise TypeError('Loading many sessions for that paradigm has not been implemented')
#if params=='all':
# readmode = 'full'
#else:
# readmode = params
readmode = 'full'
#allBehavData = {}
#allBehavData['sessionID'] = np.empty(0,dtype='i2')
#allBehavData['animalID'] = np.empty(0,dtype='i1')
inds=0
for inda,animalName in enumerate(animalNames):
for indsa,thisSession in enumerate(allSessions):
try:
behavFile = loadbehavior.path_to_behavior_data(animalName,EXPERIMENTER,paradigm,thisSession)
behavData = loadingClass(behavFile,readmode=readmode)
except IOError:
print thisSession+' does not exist'
continue
if inds==0:
allBehavData = behavData # FIXME: Should it be .copy()?
nTrials = len(behavData['outcome']) # FIXME: what if this key does not exist?
allBehavData['sessionID'] = np.zeros(nTrials,dtype='i2')
allBehavData['animalID'] = np.zeros(nTrials,dtype='i1')
else:
for key,val in behavData.iteritems():
if not allBehavData.has_key(key):
allBehavData[key]=val
else:
allBehavData[key] = np.concatenate((allBehavData[key],val))
nTrials = len(behavData['outcome']) # FIXME: what if this key does not exist?
allBehavData['sessionID'] = np.concatenate((allBehavData['sessionID'],
np.tile(inds,nTrials)))
allBehavData['animalID'] = np.concatenate((allBehavData['animalID'],
np.tile(inda,nTrials)))
inds += 1
return allBehavData
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 __init__(self, experimenter, paradigm, subject, session, threshold):
# Setup the file and the data
# FIXME: We really shouldn't be hardcoding any of this. We should be scanning through the directories, checking each one.
self.experimenter = experimenter
self.paradigm = paradigm
self.subject = subject
self.session = session
self.behavFile = loadbehavior.path_to_behavior_data(subject,experimenter,paradigm,session)
self.behavData = loadbehavior.FlexCategBehaviorData(self.behavFile, readmode='full')
# A basic threshold, to detect if average performance falls below it.
self.threshold = threshold
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 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 loadBehavior(subject, sessionstr):
############################################################################################################################
#PARAMETERS
############################################################################################################################
experimenter = 'santiago'
paradigm = '2afc'
############################################################################################################################
behaviorFilename = loadbehavior.path_to_behavior_data(subject,experimenter,
paradigm,sessionstr)
bdata = loadbehavior.BehaviorData(behaviorFilename)
numberOfTrials = len(bdata['choice'])
targetFrequencies = bdata['targetFrequency']
#This gives an array of all frequencies presented
possibleFreq = np.unique(bdata['targetFrequency'])
#This gives an array with true and indices where the mouse made a correct decision
correct = bdata['outcome']==bdata.labels['outcome']['correct']
#This gives an array with true and indices where the mouse made a incorrect decision
incorrect = bdata['outcome']==bdata.labels['outcome']['error']
#This gives an array with true at indices of trials that are correct and went right
rightward = bdata['choice']==bdata.labels['choice']['right']
correctRightward = correct*rightward
#This gives an array with true at indices of trials that are correct and went left
leftward = bdata['choice']==bdata.labels['choice']['left']
correctLeftward = correct*leftward
#This gives an array with true at indices of trials that are incorrect and went right
incorrectRightward = incorrect*rightward
#This gives an array with true at indices of trials that are incorrect and went left
incorrectLeftward = incorrect*leftward
#This gives an array with true at indices of correct and incorrect (valid trials where a choice was made) trials only
#trialsWithChoices = correct or incorrect
return;
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 create_plots(subjectsList, datesList, plotsList, loaderStr=DEFAULT_LOADER):
'''
Return a list of plots filenames.
Args:
subjectsList (list): list of strings with subject names.
datesList (list): list of strings with sessions.
plotsList (list): list of strings with plot names.
Returns:
allFilenames (list): all the filenames of plots.
'''
allFilenames = []
for subject in subjectsList:
for session in datesList:
behavData = None
# FIXME: specify an exception type
loader = getattr(loadbehavior,loaderStr)
try:
behavFile = loadbehavior.path_to_behavior_data(subject, PARADIGM, session)
#behavData = loadbehavior.FlexCategBehaviorData(behavFile,readmode='full')
#behavData = loadbehavior.BehaviorData(behavFile,readmode='full')
behavData = loader(behavFile)
except:
for plot_type in plotsList:
filename = make_filename(subject, session, 'summary')
allFilenames.append(filename)
continue
for plot_type in plotsList:
filename = make_filename(subject, session, plot_type)
allFilenames.append(filename)
if settings.REGENERATE_PLOTS:
plotter.generate(behavData, plot_type, settings.IMAGE_PATH_OUTPUT, filename)
else:
if not os.path.isfile(filename):
plotter.generate(behavData, plot_type, settings.IMAGE_PATH_OUTPUT, filename)
return allFilenames
for cellID in range(0,numOfCells):
oneCell = allcells.cellDB[cellID]
if (behavSession != oneCell.behavSession):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir,subject)
if (behavSession in minPerfList): #if it is already in the list, dont add it again
continue
# -- Load Behavior Data --
behaviorFilename = loadbehavior.path_to_behavior_data(subject=subject,paradigm=paradigm,sessionstr=behavSession)
bdata = loadbehavior.BehaviorData(behaviorFilename)
numberOfTrials = len(bdata['choice'])
correct = bdata['outcome']==bdata.labels['outcome']['correct']
incorrect = bdata['outcome']==bdata.labels['outcome']['error']
possibleFreq = np.unique(bdata['targetFrequency'])
firstFreq = bdata['targetFrequency'] == possibleFreq[0]
lastFreq = bdata['targetFrequency'] == possibleFreq[2]
correctFirst = sum(correct & firstFreq)
correctLast = sum(correct & lastFreq)
incorrectFirst = sum(incorrect & firstFreq)
incorrectLast = sum(incorrect & lastFreq)
valid = behavData['valid']
movAvChoiceMatrix = np.ndarray([len(possibleFreq), sum(valid)])
rightChoice = behavData['choice'] == behavData.labels['choice'][
'right']
for indf, thisFreq in enumerate(possibleFreq):
trialsThisFreq = (behavData['targetFrequency'] == thisFreq)
choiceVecThisFreq = np.ma.masked_array(rightChoice[valid])
choiceVecThisFreq.mask = ~trialsThisFreq[valid]
movAvChoice = extrafuncs.moving_average_masked(
choiceVecThisFreq, winsize)
movAvChoiceMatrix[indf, :] = movAvChoice
return movAvChoiceMatrix
for animalName, session in sessionsDict.items():
behavFileName = loadbehavior.path_to_behavior_data(animalName, paradigm,
session)
behavData = loadbehavior.FlexCategBehaviorData(behavFileName)
#allBehavDataThisAnimal = behavioranalysis.load_many_sessions(animalName,sessions)
#targetFrequency = allBehavDataThisAnimal['targetFrequency']
#currentBlock = allBehavDataThisAnimal['currentBlock']
#blockTypes = [allBehavDataThisAnimal.labels['currentBlock'][blockLabel] for blockLabel in blockLabels]
#trialsEachType = behavioranalysis.find_trials_each_type(currentBlock,blockTypes)
#choice = allBehavDataThisAnimal['choice']
#valid = allBehavDataThisAnimal['valid']& (choice!=allBehavDataThisAnimal.labels['choice']['none'])
#choiceRight = choice==allBehavDataThisAnimal.labels['choice']['right']
#nBlocks = len(blockTypes)
#nFreqs = len(np.unique(targetFrequency))
movAvChoiceMatrix = calculate_dynamics(behavData,
winsize=40,
soundfreq=None,
byBlock=True)
#Get onset frame numbers
ttl = rtData['ttl_log']
ttl = ttl.ravel().astype(int) #uint8 making things strange for diff
onsets = np.flatnonzero(
np.diff((ttl == 2).astype(int)) == 1) + 1 #leading edges
onsets = onsets[:-1] #NOTE: Drop the last event because too close to the end
nEvents = len(onsets)
#How many samples before and after onset to average
samplesBefore = 10
samplesAfter = 30
nSamples = samplesBefore + samplesAfter
#Load the behavior data
behavFn = loadbehavior.path_to_behavior_data('imag003', 'am_tuning_curve',
'20181217d')
bdata = loadbehavior.BehaviorData(behavFn)
currentFreq = bdata['currentFreq']
if len(onsets) != len(currentFreq):
currentFreq = currentFreq[:len(
onsets)] #Events will stop sooner than behavior.
possibleFreq = np.unique(currentFreq)
#Initialize array to hold stim-locked traces
alignedTraces = np.empty([nROIs, nEvents, nSamples])
for indEvent, onsetFrame in enumerate(onsets):
frameStart = onsetFrame - samplesBefore
frameEnd = onsetFrame + samplesAfter
for indROI in range(nROIs):
from pylab import * import matplotlib.pyplot as plt from statsmodels.stats.proportion import proportion_confint #Used to compute confidence interval for the error bars. from jaratoolbox import settings import sys animalName = 'test012' session = '20150106a' experimenter = 'santiago' paradigm = '2afc' behavioranalysis.behavior_summary(animalName,session) sys.exit() behavFile = loadbehavior.path_to_behavior_data(animalName,experimenter,paradigm,session) bdata = loadbehavior.FlexCategBehaviorData(behavFile) targetFrequency = bdata['targetFrequency'] choice=bdata['choice'] valid=bdata['valid']& (choice!=bdata.labels['choice']['none']) choiceRight = choice==bdata.labels['choice']['right'] possibleFreq = np.unique(targetFrequency) nFreq = len(possibleFreq) trialsEachFreq = behavioranalysis.find_trials_each_type(targetFrequency,possibleFreq) (possibleValues,fractionHitsEachValue,ciHitsEachValue,nTrialsEachValue,nHitsEachValue)=\ behavioranalysis.calculate_psychometric(choiceRight,targetFrequency,valid) (pline, pcaps, pbars, pdots) = extraplots.plot_psychometric(possibleValues,fractionHitsEachValue,ciHitsEachValue)
def main():
global behavSession
global subject
global tetrode
global cluster
global bdata
global eventOnsetTimes
global spikeTimesFromEventOnset
global indexLimitsEachTrial
global spikeTimesFromMovementOnset
global indexLimitsEachMovementTrial
global titleText
print "SwitchingReport"
for cellID in range(0, numOfCells):
oneCell = allcells.cellDB[cellID]
try:
if (behavSession != oneCell.behavSession):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir, subject)
print behavSession
# -- Load Behavior Data --
behaviorFilename = loadbehavior.path_to_behavior_data(
subject, experimenter, paradigm, behavSession)
bdata = loadbehavior.FlexCategBehaviorData(behaviorFilename)
#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]
soundOnsetTimeBehav = bdata['timeTarget']
# Find missing trials
missingTrials = behavioranalysis.find_missing_trials(
eventOnsetTimes, soundOnsetTimeBehav)
# Remove missing trials
bdata.remove_trials(missingTrials)
bdata.find_trials_each_block()
###############################################################################################
centerOutTimes = bdata[
'timeCenterOut'] #This is the times that the mouse goes out of the center port
soundStartTimes = bdata[
'timeTarget'] #This gives an array with the times in seconds from the start of the behavior paradigm of when the sound was presented for each trial
timeDiff = centerOutTimes - soundStartTimes
if (len(eventOnsetTimes) < len(timeDiff)):
timeDiff = timeDiff[:-1]
eventOnsetTimesCenter = eventOnsetTimes + timeDiff
elif (len(eventOnsetTimes) > len(timeDiff)):
eventOnsetTimesCenter = eventOnsetTimes[:-1] + timeDiff
else:
eventOnsetTimesCenter = eventOnsetTimes + timeDiff
###############################################################################################
tetrode = oneCell.tetrode
cluster = oneCell.cluster
# -- Load Spike Data From Certain Cluster --
spkData = ephyscore.CellData(oneCell)
spkTimeStamps = spkData.spikes.timestamps
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
(spikeTimesFromMovementOnset,movementTrialIndexForEachSpike,indexLimitsEachMovementTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimesCenter,timeRange)
plt.clf()
if (len(spkTimeStamps) > 0):
ax1 = plt.subplot2grid((numRows, numCols),
((numRows - sizeClusterPlot), 0),
colspan=(numCols / 3))
spikesorting.plot_isi_loghist(spkData.spikes.timestamps)
ax3 = plt.subplot2grid(
(numRows, numCols),
((numRows - sizeClusterPlot), (numCols / 3) * 2),
colspan=(numCols / 3))
spikesorting.plot_events_in_time(spkTimeStamps)
samples = spkData.spikes.samples.astype(float) - 2**15
samples = (1000.0 / spkData.spikes.gain[0, 0]) * samples
ax2 = plt.subplot2grid(
(numRows, numCols),
((numRows - sizeClusterPlot), (numCols / 3)),
colspan=(numCols / 3))
spikesorting.plot_waveforms(samples)
###############################################################################
ax4 = plt.subplot2grid((numRows, numCols), (0, 0),
colspan=(numCols / 2),
rowspan=sizeRasters)
plt.setp(ax4.get_xticklabels(), visible=False)
raster_sound_block_switching()
ax5 = plt.subplot2grid((numRows, numCols), (sizeRasters, 0),
colspan=(numCols / 2),
rowspan=sizeHists,
sharex=ax4)
hist_sound_block_switching()
ax6 = plt.subplot2grid((numRows, numCols), (0, (numCols / 2)),
colspan=(numCols / 2),
rowspan=sizeRasters)
plt.setp(ax6.get_xticklabels(), visible=False)
raster_movement_block_switching()
ax7 = plt.subplot2grid((numRows, numCols),
(sizeRasters, (numCols / 2)),
colspan=(numCols / 2),
rowspan=sizeHists,
sharex=ax6)
hist_movement_block_switching()
ax8 = plt.subplot2grid((numRows, numCols),
((sizeRasters + sizeHists), 0),
colspan=(numCols / 2),
rowspan=sizeRasters)
plt.setp(ax8.get_xticklabels(), visible=False)
raster_sound_allFreq_switching()
ax9 = plt.subplot2grid((numRows, numCols),
((2 * sizeRasters + sizeHists), 0),
colspan=(numCols / 2),
rowspan=sizeHists,
sharex=ax8)
hist_sound_allFreq_switching()
ax10 = plt.subplot2grid((numRows, numCols),
((sizeRasters + sizeHists), (numCols / 2)),
colspan=(numCols / 2),
rowspan=sizeRasters)
plt.setp(ax10.get_xticklabels(), visible=False)
raster_sound_switching()
ax11 = plt.subplot2grid(
(numRows, numCols),
((2 * sizeRasters + sizeHists), (numCols / 2)),
colspan=(numCols / 2),
rowspan=sizeHists,
sharex=ax10)
hist_sound_switching()
###############################################################################
#plt.tight_layout()
modulation_index_switching()
plt.suptitle(titleText)
tetrodeClusterName = 'T' + str(oneCell.tetrode) + 'c' + str(
oneCell.cluster)
plt.gcf().set_size_inches((8.5, 11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = 'report_%s_%s_%s.%s' % (subject, behavSession,
tetrodeClusterName, figformat)
fulloutputDir = outputDir + subject + '/'
fullFileName = os.path.join(fulloutputDir, filename)
directory = os.path.dirname(fulloutputDir)
if not os.path.exists(directory): #makes sure output folder exists
os.makedirs(directory)
#print 'saving figure to %s'%fullFileName
plt.gcf().savefig(fullFileName, format=figformat)
#plt.show()
except:
print "error with session " + oneCell.behavSession
if (oneCell.behavSession not in badSessionList):
badSessionList.append(oneCell.behavSession)
print 'error with sessions: '
for badSes in badSessionList:
print badSes
sessions = sys.argv[1:]
nSessions = len(sessions)
nAnimals = len(subjects)
loadingClass = loadbehavior.FlexCategBehaviorData #using this bdata class so we get 'blocks'
paradigm = '2afc'
gs = gridspec.GridSpec(nSessions * nAnimals, 1)
gs.update(hspace=0.5, wspace=0.4)
plt.clf()
for inds, thisSession in enumerate(sessions):
for inda, animalName in enumerate(subjects):
try:
behavFile = loadbehavior.path_to_behavior_data(
animalName, EXPERIMENTER, paradigm, thisSession)
behavData = loadingClass(behavFile, readmode='full')
except IOError:
print thisSession + ' does not exist'
continue
print 'Loaded %s %s' % (animalName, thisSession)
targetFrequency = behavData['targetFrequency']
choice = behavData['choice']
valid = behavData['valid'] & (choice !=
behavData.labels['choice']['none'])
choiceRight = choice == behavData.labels['choice']['right']
currentBlock = behavData['currentBlock']
behavData.find_trials_each_block()
trialsEachBlock = behavData.blocks['trialsEachBlock']
from jaratoolbox import behavioranalysis
from jaratoolbox import loadbehavior
import numpy as np
from pylab import *
import matplotlib.pyplot as plt
from jaratoolbox import settings
subjects = ['hm4d004', 'hm4d005', 'hm4d006']
sessions = ['20140824a']
for subject_ind, subject in enumerate(subjects):
for session_ind, session in enumerate(sessions):
fname=loadbehavior.path_to_behavior_data(subject,'nick','2afc',session)
try:
bdata=loadbehavior.BehaviorData(fname)
except IOError:
pass
targetFrequency=bdata['targetFrequency']
valid=bdata['valid']
choice=bdata['choice']
intensities=bdata['targetIntensity']
choiceRight = choice==bdata.labels['choice']['right']
possibleFreq = np.unique(targetFrequency)
nFreq = len(possibleFreq)
fractionRightEachFreq=np.zeros(nFreq)
def behavior_summary(subjects,sessions,trialslim=[],outputDir='',paradigm='2afc',soundfreq=None):
'''
subjects: an array of animals to analyze (it can also be a string for a single animal)
sessions: an array of sessions to analyze (it can also be a string for a single session)
trialslim: array to set xlim() of dynamics' plot
outputDir: where to save the figure (if not specified, nothing will be saved)
paradigm: load data from a different paradigm. Warning: data should be loaded with
loadbehavior.ReversalBehaviorData().
'''
if isinstance(subjects,str):
subjects = [subjects]
if isinstance(sessions,str):
sessions = [sessions]
nSessions = len(sessions)
nAnimals = len(subjects)
loadingClass = loadbehavior.FlexCategBehaviorData
gs = gridspec.GridSpec(nSessions*nAnimals, 3)
gs.update(hspace=0.5,wspace=0.4)
plt.clf()
for inds,thisSession in enumerate(sessions):
for inda,animalName in enumerate(subjects):
try:
behavFile = loadbehavior.path_to_behavior_data(animalName,paradigm,thisSession)
behavData = loadingClass(behavFile,readmode='full')
except IOError:
print thisSession+' does not exist'
continue
print 'Loaded %s %s'%(animalName,thisSession)
# -- Plot either psychometric or average performance
thisAnimalPos = 3*inda*nSessions
thisPlotPos = thisAnimalPos+3*inds
ax1=plt.subplot(gs[thisPlotPos])
if any(behavData['psycurveMode']):
(pline, pcaps, pbars, pdots) = plot_frequency_psycurve(behavData,fontsize=8)
plt.setp(pdots,ms=6)
plt.ylabel('% rightward')
nValid = behavData['nValid'][-1]
nTrials = len(behavData['nValid'])
if soundfreq is None:
freqsToUse = [behavData['lowFreq'][-1],behavData['highFreq'][-1]]
titleStr = '{0} [{1}] {2}\n'.format(behavData.session['subject'],behavData.session['date'],
behavData.session['hostname'])
titleStr += '{0} valid, {1:.0%} early'.format(nValid,(nTrials-nValid)/float(nTrials))
plt.title(titleStr,fontweight='bold',fontsize=8,y=0.95)
else:
behavData.find_trials_each_block()
if soundfreq is None:
freqsToUse = [behavData['lowFreq'][-1],behavData['midFreq'][-1],behavData['highFreq'][-1]]
plot_summary(behavData,fontsize=8,soundfreq=freqsToUse)
# -- Plot dynamics --
ax2=plt.subplot(gs[thisPlotPos+1:thisPlotPos+3])
plot_dynamics(behavData,winsize=40,fontsize=8,soundfreq=freqsToUse)
#plt.setp(ax1.get_xticklabels(),visible=False)
ax1xlabel = ax1.get_xlabel()
ax2xlabel = ax2.get_xlabel()
ax1.set_xlabel('')
ax2.set_xlabel('')
if trialslim:
plt.xlim(trialslim)
plt.draw()
plt.show()
plt.setp(ax1.get_xticklabels(),visible=True)
plt.setp(ax2.get_xticklabels(),visible=True)
ax1.set_xlabel(ax1xlabel)
ax2.set_xlabel(ax2xlabel)
#plt.draw()
#plt.show()
if len(outputDir):
animalStr = '-'.join(subjects)
sessionStr = '-'.join(sessions)
plt.gcf().set_size_inches((8.5,11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = 'behavior_%s_%s.%s'%(animalStr,sessionStr,figformat)
fullFileName = os.path.join(outputDir,filename)
print 'saving figure to %s'%fullFileName
plt.gcf().savefig(fullFileName,format=figformat)
confintervRightEachValue = [] # TO BE IMPLEMENTED LATER
return (possibleValues,fractionRightEachValue,confintervRightEachValue,nTrialsEachValue,nRightwardEachValue)
if __name__ == "__main__":
CASE=6
if CASE==1:
from jaratoolbox import loadbehavior
import numpy as np
experimenter = 'santiago'
paradigm = '2afc'
subject = 'test020'
session = '20140421a'
behavFile = loadbehavior.path_to_behavior_data(subject,experimenter,paradigm,session)
behavData = loadbehavior.FlexCategBehaviorData(behavFile,readmode='full')
behavData.find_trials_each_block()
#trialsEachBlock = behavData.blocks['trialsEachBlock']
#nValidEachBlock = np.sum(trialsEachBlock & (~behavData['valid'][:,np.newaxis]),axis=0)
#validEachBlock = trialsEachBlock & behavData['valid'][:,np.newaxis].astype(bool)
#plot_dynamics(behavData,winsize=100)
plot_summary(behavData)
#tet = find_trials_each_type(behavData['targetFrequency'],np.unique(behavData['targetFrequency']),
# behavData['currentBlock'],np.unique(behavData['currentBlock']))
elif CASE==2:
if 1:
subjects = ['test011','test012','test013','test014','test015',
if len(sys.argv)>1:
session = sys.argv[1]+'a'
else:
session = '20150308a'
for CASE in [1]:
if CASE==1:
subjects = ['cued001','cued002','cued003','cued004','cued005','cued006']
elif CASE==2:
pass
figure(CASE)
#behavioranalysis.behavior_summary(subjects,sessions,trialslim=[0,1000],outputDir='/var/tmp/behavior_reports/')
for inda,animalName in enumerate(subjects):
fname=loadbehavior.path_to_behavior_data(animalName,'santiago','2afc',session)
try:
bdata=loadbehavior.BehaviorData(fname)
nReward = bdata['nRewarded'][-1]
nValid = bdata['nValid'][-1]
correct = nReward/float(nValid)
print '{0} (rew/valid): {1} / {2} = {3:0.0%}'.format(animalName,nReward,nValid,correct)
except:
print 'Something is wrong with this session'
pass
'''
subjects = ['test011','test015','test016']
sessions = ['20150222a','20150223a']
behavioranalysis.behavior_summary(subjects,sessions,trialslim=[0,1000],outputDir='/tmp/')
def main():
global behavSession
global subject
global ephysSession
global tetrode
global cluster
global bdata
global eventOnsetTimes
global spikeTimesFromEventOnset
global indexLimitsEachTrial
global spikeTimesFromMovementOnset
global indexLimitsEachMovementTrial
global tuningBehavior #behavior file name of tuning curve
global tuningEphys #ephys session name of tuning curve
for cellID in range(0, numOfCells):
oneCell = allcells.cellDB[cellID]
try:
if (behavSession != oneCell.behavSession):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir, subject)
tuningBehavior = oneCell.tuningBehavior
tuningEphys = oneCell.tuningSession
print behavSession
# -- Load Behavior Data --
behaviorFilename = loadbehavior.path_to_behavior_data(
subject=subject,
paradigm=paradigm,
sessionstr=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]
soundOnsetTimeBehav = bdata['timeTarget']
# Find missing trials
missingTrials = behavioranalysis.find_missing_trials(
eventOnsetTimes, soundOnsetTimeBehav)
# Remove missing trials
bdata.remove_trials(missingTrials)
possibleFreq = np.unique(bdata['targetFrequency'])
numberOfFrequencies = len(possibleFreq)
centerFrequencies = [(numberOfFrequencies / 2 - 1),
numberOfFrequencies / 2]
#################################################################################################
centerOutTimes = bdata[
'timeCenterOut'] #This is the times that the mouse goes out of the center port
soundStartTimes = bdata[
'timeTarget'] #This gives an array with the times in seconds from the start of the behavior paradigm of when the sound was presented for each trial
timeDiff = centerOutTimes - soundStartTimes
if (len(eventOnsetTimes) < len(timeDiff)):
eventOnsetTimesCenter = eventOnsetTimes + timeDiff[:-1]
elif (len(eventOnsetTimes) > len(timeDiff)):
eventOnsetTimesCenter = eventOnsetTimes[:-1] + timeDiff
else:
eventOnsetTimesCenter = eventOnsetTimes + timeDiff
#################################################################################################
tetrode = oneCell.tetrode
cluster = oneCell.cluster
# -- Load Spike Data From Certain Cluster --
spkData = ephyscore.CellData(oneCell)
spkTimeStamps = spkData.spikes.timestamps
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
(spikeTimesFromMovementOnset,movementTrialIndexForEachSpike,indexLimitsEachMovementTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimesCenter,timeRange)
plt.clf()
if (len(spkTimeStamps) > 0):
ax1 = plt.subplot2grid((numRows, numCols),
((numRows - sizeClusterPlot), 0),
colspan=(numCols / 3))
spikesorting.plot_isi_loghist(spkData.spikes.timestamps)
ax3 = plt.subplot2grid(
(numRows, numCols),
((numRows - sizeClusterPlot), (numCols / 3) * 2),
colspan=(numCols / 3))
spikesorting.plot_events_in_time(spkData.spikes.timestamps)
samples = spkData.spikes.samples.astype(float) - 2**15
samples = (1000.0 / spkData.spikes.gain[0, 0]) * samples
ax2 = plt.subplot2grid(
(numRows, numCols),
((numRows - sizeClusterPlot), (numCols / 3)),
colspan=(numCols / 3))
spikesorting.plot_waveforms(samples)
###############################################################################
ax4 = plt.subplot2grid((numRows, numCols), (0, 0),
colspan=(numCols / 3),
rowspan=3 * sizeRasters)
#plt.setp(ax4.get_xticklabels(), visible=False)
#raster_sound_psycurve(centerFrequencies[0])
raster_tuning(ax4)
axvline(x=0, ymin=0, ymax=1, color='r')
plt.gca().set_xlim(tuning_timeRange)
#ax5 = plt.subplot2grid((7,6), (2,0), colspan = 3, sharex=ax4)
#hist_sound_psycurve(centerFrequencies[0])
ax6 = plt.subplot2grid((numRows, numCols), (0, (numCols / 3)),
colspan=(2 * numCols / 3),
rowspan=sizeHalfRaster)
raster_allfreq_sound_psycurve()
ax6.set_ylabel('frequencies')
ax6.yaxis.set_label_position("right")
plt.setp(ax6.get_xticklabels(), visible=False)
ax6.yaxis.tick_right()
ax6.yaxis.set_ticks_position('both')
plt.gca().set_xlim(timeRange)
plt.title('Top: sound aligned, Bottom: movement aligned')
ax7 = plt.subplot2grid((numRows, numCols),
(sizeHalfRaster, (numCols / 3)),
colspan=(2 * numCols / 3),
rowspan=sizeHalfRaster)
hist_allfreq_sound_psycurve(ax7)
ax7.yaxis.tick_right()
ax7.yaxis.set_ticks_position('both')
plt.setp(ax7.get_xticklabels(), visible=False)
plt.gca().set_xlim(timeRange)
ax8 = plt.subplot2grid((numRows, numCols),
(2 * sizeHalfRaster, (numCols / 3)),
colspan=(2 * numCols / 3),
rowspan=sizeHalfRaster)
ax8.yaxis.tick_right()
plt.setp(ax8.get_xticklabels(), visible=False)
raster_allfreq_movement_psycurve()
ax8.set_ylabel('frequencies')
ax8.yaxis.set_label_position("right")
ax10 = plt.subplot2grid((numRows, numCols),
(3 * sizeHalfRaster, (numCols / 3)),
colspan=(2 * numCols / 3),
rowspan=sizeHalfRaster)
#plt.setp(ax10.get_xticklabels(), visible=False)
hist_allfreq_movement_psycurve(ax10)
ax10.yaxis.tick_right()
ax10.yaxis.set_ticks_position('both')
plt.gca().set_xlim(timeRange)
ax10.set_xlabel('Time (sec)')
#ax11 = plt.subplot2grid((numRows,numCols), ((2*sizeRasters+sizeHists),(numCols/2)), colspan = (numCols/2), rowspan = sizeHists, sharex=ax10)
#hist_sound_psycurve(centerFrequencies[1])
#ax11.yaxis.tick_right()
#ax11.yaxis.set_ticks_position('both')
#plt.setp(ax11.get_yticklabels(), visible=False)
#plt.gca().set_xlim(timeRange)
###############################################################################
#plt.tight_layout()
modulation_index_psycurve(centerFrequencies)
plt.suptitle(titleText)
tetrodeClusterName = 'T' + str(oneCell.tetrode) + 'c' + str(
oneCell.cluster)
plt.gcf().set_size_inches((8.5, 11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = reportname + '_%s_%s_%s.%s' % (
subject, behavSession, tetrodeClusterName, 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)
#plt.show()
except:
if (oneCell.behavSession not in badSessionList):
badSessionList.append(oneCell.behavSession)
print 'error with sessions: '
for badSes in badSessionList:
print badSes
#subject = 'hm4d003' #session = '20140820a' ''' subject = 'test053' session = '20140907a' experimenter = 'santiago' ''' subject = 'test000' session = '20141110a' experimenter = 'santiago' minIntensityToPlot = 30 fname=loadbehavior.path_to_behavior_data(subject,experimenter,'2afc',session) bdata=loadbehavior.BehaviorData(fname) from jaratoolbox import settings targetFrequency=bdata['targetFrequency'] valid=bdata['valid'] choice=bdata['choice'] intensity=bdata['targetIntensity'] choiceRight = choice==bdata.labels['choice']['right'] possibleFreq = np.unique(targetFrequency) nFreq = len(possibleFreq) trialsEachFreq = behavioranalysis.find_trials_each_type(targetFrequency,possibleFreq)
from jaratoolbox import loadopenephys
subject = 'd1pi039'
paradigm = 'am_tuning_curve'
session = '20190731h'
ephysSession = '2019-07-31_16-09-08'
# subject = 'd1pi039'
# paradigm = 'am_tuning_curve'
# session = '20190731b'
# ephysSession = '2019-07-31_11-17-46'
eventsFilename = os.path.join(settings.EPHYS_PATH, subject, ephysSession,
'all_channels.events')
behavFile = loadbehavior.path_to_behavior_data(subject, paradigm, session)
behavData = loadbehavior.BehaviorData(behavFile, readmode='full')
eventData = loadopenephys.Events(eventsFilename)
channelID = 0
thisChannelOn = eventData.get_event_onset_times(eventID=1,
eventChannel=channelID)
behavDataSize = len(behavData['currentAmpL'])
ephysDataSize = len(thisChannelOn)
print('Behavior: {}'.format(behavDataSize))
print('Ephys: {}'.format(ephysDataSize))
trialsToRemove = behavDataSize - ephysDataSize + 1
if trialsToRemove > 0:
def passes_test(self, subject, paradigm, sessionstr):
self.behavFile = loadbehavior.path_to_behavior_data(subject, paradigm, sessionstr)
if not os.path.exists(self.behavFile):
get_behavior(subject)
self.bdata = loadbehavior.BehaviorData(self.behavFile)
return self.test()
def switch_report(mouseName, behavSession, tetrode, cluster):
#global behavSession
#global subject
global bdata
global eventOnsetTimes
global spikeTimesFromEventOnset
global indexLimitsEachTrial
global spikeTimesFromMovementOnset
global indexLimitsEachMovementTrial
allcellsFileName = 'allcells_' + mouseName
sys.path.append(settings.ALLCELLS_PATH)
allcells = importlib.import_module(allcellsFileName)
cellID = allcells.cellDB.findcell(mouseName, behavSession, tetrode,
cluster)
oneCell = allcells.cellDB[cellID]
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 = loadbehavior.BehaviorData(behaviorFilename)
bdata.find_trials_each_block()
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]
#################################################################################################
centerOutTimes = bdata[
'timeCenterOut'] #This is the times that the mouse goes out of the center port
soundStartTimes = bdata[
'timeTarget'] #This gives an array with the times in seconds from the start of the behavior paradigm of when the sound was presented for each trial
timeDiff = centerOutTimes - soundStartTimes
if (len(eventOnsetTimes) < len(timeDiff)):
timeDiff = timeDiff[:-1]
eventOnsetTimesCenter = eventOnsetTimes + timeDiff
#################################################################################################
# -- Load Spike Data From Certain Cluster --
spkData = ephyscore.CellData(oneCell)
spkTimeStamps = spkData.spikes.timestamps
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
(spikeTimesFromMovementOnset,movementTrialIndexForEachSpike,indexLimitsEachMovementTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimesCenter,timeRange)
plt.clf()
if (len(spkTimeStamps) > 0):
ax1 = plt.subplot2grid((numRows, numCols),
((numRows - sizeClusterPlot), 0),
colspan=(numCols / 3))
spikesorting.plot_isi_loghist(spkData.spikes.timestamps)
ax3 = plt.subplot2grid(
(numRows, numCols),
((numRows - sizeClusterPlot), (numCols / 3) * 2),
colspan=(numCols / 3))
spikesorting.plot_events_in_time(spkTimeStamps)
samples = spkData.spikes.samples.astype(float) - 2**15
samples = (1000.0 / spkData.spikes.gain[0, 0]) * samples
ax2 = plt.subplot2grid((numRows, numCols),
((numRows - sizeClusterPlot), (numCols / 3)),
colspan=(numCols / 3))
spikesorting.plot_waveforms(samples)
###############################################################################
ax4 = plt.subplot2grid((numRows, numCols), (0, 0),
colspan=(numCols / 2),
rowspan=sizeRasters)
raster_sound_block_switching()
ax5 = plt.subplot2grid((numRows, numCols), (sizeRasters, 0),
colspan=(numCols / 2),
rowspan=sizeHists)
hist_sound_block_switching()
ax6 = plt.subplot2grid((numRows, numCols), (0, (numCols / 2)),
colspan=(numCols / 2),
rowspan=sizeRasters)
raster_movement_block_switching()
ax7 = plt.subplot2grid((numRows, numCols), (sizeRasters, (numCols / 2)),
colspan=(numCols / 2),
rowspan=sizeHists)
hist_movement_block_switching()
ax8 = plt.subplot2grid((numRows, numCols), ((sizeRasters + sizeHists), 0),
colspan=(numCols / 2),
rowspan=sizeRasters)
raster_sound_allFreq_switching()
ax9 = plt.subplot2grid((numRows, numCols),
((2 * sizeRasters + sizeHists), 0),
colspan=(numCols / 2),
rowspan=sizeHists)
hist_sound_allFreq_switching()
ax10 = plt.subplot2grid((numRows, numCols),
((sizeRasters + sizeHists), (numCols / 2)),
colspan=(numCols / 2),
rowspan=sizeRasters)
raster_sound_switching()
ax11 = plt.subplot2grid((numRows, numCols),
((2 * sizeRasters + sizeHists), (numCols / 2)),
colspan=(numCols / 2),
rowspan=sizeHists)
hist_sound_switching()
###############################################################################
#plt.tight_layout()
tetrodeClusterName = 'T' + str(oneCell.tetrode) + 'c' + str(
oneCell.cluster)
plt.suptitle(mouseName + ' ' + behavSession + ' ' + tetrodeClusterName)
plt.gcf().set_size_inches((8.5, 11))
#figformat = 'png' #'png' #'pdf' #'svg'
#filename = 'report_%s_%s_%s.%s'%(subject,behavSession,tetrodeClusterName,figformat)
#fulloutputDir = outputDir+subject +'/'
#fullFileName = os.path.join(fulloutputDir,filename)
#directory = os.path.dirname(fulloutputDir)
#if not os.path.exists(directory): #makes sure output folder exists
#os.makedirs(directory)
#print 'saving figure to %s'%fullFileName
#plt.gcf().savefig(fullFileName,format=figformat)
plt.show()
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)
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)
def behavior_summary(subjects,sessions,trialslim=[],outputDir='',paradigm=None,soundfreq=None):
'''
subjects: an array of animals to analyze (it can also be a string for a single animal)
sessions: an array of sessions to analyze (it can also be a string for a single session)
trialslim: array to set xlim() of dynamics' plot
outputDir: where to save the figure (if not specified, nothing will be saved)
paradigm: load data from a different paradigm. Warning: data should be loaded with
loadbehavior.ReversalBehaviorData().
'''
if isinstance(subjects,str):
subjects = [subjects]
if isinstance(sessions,str):
sessions = [sessions]
nSessions = len(sessions)
nAnimals = len(subjects)
loadingClass = loadbehavior.FlexCategBehaviorData
paradigm = '2afc'
gs = gridspec.GridSpec(nSessions*nAnimals, 3)
gs.update(hspace=0.5,wspace=0.4)
plt.clf()
for inds,thisSession in enumerate(sessions):
for inda,animalName in enumerate(subjects):
try:
behavFile = loadbehavior.path_to_behavior_data(animalName,EXPERIMENTER,paradigm,thisSession)
behavData = loadingClass(behavFile,readmode='full')
except IOError:
print thisSession+' does not exist'
continue
print 'Loaded %s %s'%(animalName,thisSession)
# -- Plot either psychometric or average performance
thisAnimalPos = 3*inda*nSessions
thisPlotPos = thisAnimalPos+3*inds
ax1=plt.subplot(gs[thisPlotPos])
if any(behavData['psycurveMode']):
(pline, pcaps, pbars, pdots) = plot_frequency_psycurve(behavData,fontsize=8)
plt.setp(pdots,ms=6)
plt.ylabel('% rightward')
nValid = behavData['nValid'][-1]
nTrials = len(behavData['nValid'])
if soundfreq is None:
# freqsToUse = [behavData['lowFreq'][-1],behavData['highFreq'][-1]]
freqsToUse = [min(np.unique(behavData['targetFrequency'])),max(np.unique(behavData['targetFrequency']))]
titleStr = '{0} [{1}] {2}\n'.format(behavData.session['subject'],behavData.session['date'],
behavData.session['hostname'])
titleStr += '{0} valid, {1:.0%} early'.format(nValid,(nTrials-nValid)/float(nTrials))
plt.title(titleStr,fontweight='bold',fontsize=8,y=0.95)
else:
behavData.find_trials_each_block()
if soundfreq is None:
# freqsToUse = [behavData['lowFreq'][-1],behavData['highFreq'][-1]]
freqsToUse = [min(np.unique(behavData['targetFrequency'])),max(np.unique(behavData['targetFrequency']))]
plot_summary(behavData,fontsize=8,soundfreq=freqsToUse)
# -- Plot dynamics --
ax2=plt.subplot(gs[thisPlotPos+1:thisPlotPos+3])
plot_dynamics(behavData,winsize=40,fontsize=8,soundfreq=freqsToUse)
#plt.setp(ax1.get_xticklabels(),visible=False)
ax1xlabel = ax1.get_xlabel()
ax2xlabel = ax2.get_xlabel()
ax1.set_xlabel('')
ax2.set_xlabel('')
if trialslim:
plt.xlim(trialslim)
plt.draw()
plt.show()
plt.setp(ax1.get_xticklabels(),visible=True)
plt.setp(ax2.get_xticklabels(),visible=True)
ax1.set_xlabel(ax1xlabel)
ax2.set_xlabel(ax2xlabel)
#plt.draw()
#plt.show()
if len(outputDir):
animalStr = '-'.join(subjects)
sessionStr = '-'.join(sessions)
# plt.gcf().set_size_inches((8.5,11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = 'behavior_%s_%s.%s'%(animalStr,sessionStr,figformat)
fullFileName = os.path.join(outputDir,filename)
print 'saving figure to %s'%fullFileName
plt.gcf().savefig(fullFileName,format=figformat)
subjects = ['adap005', 'adap008']
EXPERIMENTER = 'santiago'
paradigm = '2afc'
loadingClass = loadbehavior.FlexCategBehaviorData
outputDir = '/home/languo/data/behavior_reports'
settings.BEHAVIOR_PATH = '/home/languo/data/mnt/jarahubdata'
nAnimals = len(subjects)
nSessions = len(sessions)
gs = gridspec.GridSpec(nAnimals*nSessions, 6)
gs.update(hspace=0.2,wspace=0.7)
plt.figure()
for inda, subject in enumerate(subjects):
for inds, thisSession in enumerate(sessions):
try:
behavFile = loadbehavior.path_to_behavior_data(subject,EXPERIMENTER,paradigm,thisSession)
bData = loadingClass(behavFile,readmode='full')
except IOError:
print thisSession+' does not exist'
continue
print 'Loaded %s %s'%(subject,thisSession)
thisPlotPos = inda*nSessions+inds
# -- Plot performance speed as intertrial intervals (left or right)--
ax1=plt.subplot(gs[thisPlotPos,:-4])
plot_ITI_dynamics(bData, winsize=20, fontsize=12)
# -- Plot choice time based on trial outcome and actual choice--
ax2=plt.subplot(gs[thisPlotPos,2:4])
plot_choicetime_dynamics(bData, winsize=20, fontsize=12)
# -- Plot reactopm time based on trial outcome and actual choice--
ax3=plt.subplot(gs[thisPlotPos,-2:])
'''
animalList = ['gosi001','gosi002','gosi003','gosi004','gosi005',
'gosi006','gosi007','gosi008','gosi009','gosi010',
'gosi011','gosi012','gosi013','gosi014','gosi015']
'''
nValidAll = []
fractionValidAll = []
fractionCorrectAll = []
plt.clf()
nSubjects = len(animalList)
for inds,subject in enumerate(animalList):
behavFile = loadbehavior.path_to_behavior_data(subject,'2afc',session)
bdata = loadbehavior.BehaviorData(behavFile)
delayToTargetMean = bdata['delayToTargetMean'][-1]
delayToTargetHalfRange = bdata['delayToTargetHalfRange'][-1]
targetDuration = bdata['targetDuration'][-1]
delayToGoSignal = bdata['delayToGoSignal'][-1]
targetFrequency = bdata['targetFrequency']
choice = bdata['choice']
valid = bdata['valid'] & (choice!=bdata.labels['choice']['none'])
choiceRight = (choice==bdata.labels['choice']['right'])
outcome = bdata['outcome']
validCorrect = outcome[valid.astype(bool)]==bdata.labels['outcome']['correct']
nValid = np.sum(valid)
def main():
global behavSession
global subject
global ephysSession
global tetrodeID
global bdata
global eventOnsetTimes
global spikeTimesFromEventOnset
global indexLimitsEachTrial
global spikeTimesFromMovementOnset
global indexLimitsEachMovementTrial
for cellID in range(0,numOfCells):
oneCell = allcells.cellDB[cellID]
try:
if (behavSession != oneCell.behavSession):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir,subject)
print behavSession
# -- 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]
possibleFreq = np.unique(bdata['targetFrequency'])
numberOfFrequencies = len(possibleFreq)
centerFrequencies = [(numberOfFrequencies/2-1),numberOfFrequencies/2]
#################################################################################################
centerOutTimes = bdata['timeCenterOut'] #This is the times that the mouse goes out of the center port
soundStartTimes = bdata['timeTarget'] #This gives an array with the times in seconds from the start of the behavior paradigm of when the sound was presented for each trial
timeDiff = centerOutTimes - soundStartTimes
if (len(eventOnsetTimes) < len(timeDiff)):
timeDiff = timeDiff[:-1]
eventOnsetTimesCenter = eventOnsetTimes + timeDiff
#################################################################################################
# -- Load Spike Data From Certain Cluster --
spkData = ephyscore.CellData(oneCell)
spkTimeStamps = spkData.spikes.timestamps
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
(spikeTimesFromMovementOnset,movementTrialIndexForEachSpike,indexLimitsEachMovementTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimesCenter,timeRange)
plt.clf()
if (len(spkTimeStamps)>0):
ax1 = plt.subplot2grid((7,6), (6,0), colspan = 2)
spikesorting.plot_isi_loghist(spkData.spikes.timestamps)
ax3 = plt.subplot2grid((7,6), (6,4), colspan = 2)
spikesorting.plot_events_in_time(spkData.spikes.timestamps)
samples = spkData.spikes.samples.astype(float)-2**15
samples = (1000.0/spkData.spikes.gain[0,0]) *samples
ax2 = plt.subplot2grid((7,6), (6,2), colspan = 2)
spikesorting.plot_waveforms(samples)
###############################################################################
ax4 = plt.subplot2grid((7,6), (0,0), colspan = 3, rowspan = 2)
raster_sound_psycurve(centerFrequencies[0])
ax5 = plt.subplot2grid((7,6), (2,0), colspan = 3)
hist_sound_psycurve(centerFrequencies[0])
ax6 = plt.subplot2grid((7,6), (0,3), colspan = 3, rowspan = 2)
raster_sound_psycurve(centerFrequencies[1])
ax7 = plt.subplot2grid((7,6), (2,3), colspan = 3)
hist_sound_psycurve(centerFrequencies[1])
ax8 = plt.subplot2grid((7,6), (3,0), colspan = 3, rowspan = 2)
raster_movement_psycurve(centerFrequencies[0])
ax9 = plt.subplot2grid((7,6), (5,0), colspan = 3)
hist_movement_psycurve(centerFrequencies[0])
ax10 = plt.subplot2grid((7,6), (3,3), colspan = 3, rowspan = 2)
raster_movement_psycurve(centerFrequencies[1])
ax11 = plt.subplot2grid((7,6), (5,3), colspan = 3)
hist_movement_psycurve(centerFrequencies[1])
###############################################################################
#plt.tight_layout()
tetrodeClusterName = 'T'+str(oneCell.tetrode)+'c'+str(oneCell.cluster)
plt.gcf().set_size_inches((8.5,11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = 'report_centerFreq_%s_%s_%s.%s'%(subject,behavSession,tetrodeClusterName,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)
#plt.show()
except:
#print "error with session "+oneCell.behavSession
if (oneCell.behavSession not in badSessionList):
badSessionList.append(oneCell.behavSession)
print 'error with sessions: '
for badSes in badSessionList:
print badSes
text_file = open("%s/%s.txt" % (finalOutputDir, nameOfFile),
"w") #open a text file to write in
text_file.write("minimum performance percentage: %s\n" % minPerf)
for cellID in range(0, numOfCells):
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'])
correct = bdata['outcome'] == bdata.labels['outcome']['correct']
incorrect = bdata['outcome'] == bdata.labels['outcome']['error']
possibleFreq = np.unique(bdata['targetFrequency'])
firstFreq = bdata['targetFrequency'] == possibleFreq[0]
lastFreq = bdata['targetFrequency'] == possibleFreq[2]
correctFirst = sum(correct & firstFreq)
correctLast = sum(correct & lastFreq)
incorrectFirst = sum(incorrect & firstFreq)
incorrectLast = sum(incorrect & lastFreq)
if len(sys.argv) > 1:
session = sys.argv[1] + 'a'
else:
session = '20150329a'
subjects = ['cued001', 'cued002', 'cued003', 'cued004', 'cued005', 'cued006']
#subjects = ['cued004']
nAnimals = len(subjects)
smallFontSize = 8
fontSize = 10
clf()
for inda, animalName in enumerate(subjects):
fname = loadbehavior.path_to_behavior_data(animalName, 'santiago', '2afc',
session)
try:
bdata = loadbehavior.BehaviorData(fname)
except IOError:
#print fname+' does not exist'
continue
nReward = bdata['nRewarded'][-1]
nValid = bdata['nValid'][-1]
fractionCorrect = nReward / float(nValid)
targetFrequency = bdata['targetFrequency']
possibleTarget = unique(targetFrequency)
cueFrequency = bdata['cueFrequency']
possibleCue = unique(cueFrequency)
extraplots.set_ticks_fontsize(ax,fontsize)
plt.draw()
plt.show()
if __name__ == "__main__":
CASE=6
if CASE==1:
from jaratoolbox import loadbehavior
import numpy as np
experimenter = 'santiago'
paradigm = '2afc'
subject = 'test020'
session = '20140421a'
behavFile = loadbehavior.path_to_behavior_data(subject,experimenter,paradigm,session)
behavData = loadbehavior.FlexCategBehaviorData(behavFile,readmode='full')
behavData.find_trials_each_block()
#trialsEachBlock = behavData.blocks['trialsEachBlock']
#nValidEachBlock = np.sum(trialsEachBlock & (~behavData['valid'][:,np.newaxis]),axis=0)
#validEachBlock = trialsEachBlock & behavData['valid'][:,np.newaxis].astype(bool)
#plot_dynamics(behavData,winsize=100)
plot_summary(behavData)
#tet = find_trials_each_type(behavData['targetFrequency'],np.unique(behavData['targetFrequency']),
# behavData['currentBlock'],np.unique(behavData['currentBlock']))
elif CASE==2:
if 1:
subjects = ['test011','test012','test013','test014','test015',
gcf().subplots_adjust(bottom=0.15)
for inda, animalName in enumerate(animalsNames):
subplot(1, nAnimals, inda + 1)
for inds, oneSession in enumerate(allSessions):
typeThisSession = typeEachSessionLabels[typeEachSession[inds]]
if (typeThisSession == 'pre') | (typeThisSession == 'post') | (
typeThisSession == 'morepost'):
paradigm = '2afc'
elif typeThisSession == 'visual':
paradigm = 'lightDiscrim'
else:
raise TypeError('This session type is not defined')
try:
fname = loadbehavior.path_to_behavior_data(animalName,
experimenter, paradigm,
oneSession)
bdata = loadbehavior.BehaviorData(fname)
except IOError:
print 'It could not load {0}'.format(fname)
continue
'''
print '-----------------------------'
print bdata['nRewarded'][-1]
print bdata['nValid'][-1]
'''
nCorrectEachSession[inds] = bdata['nRewarded'][-1]
nValidEachSession[inds] = bdata['nValid'][-1]
avPerfEachSession = nCorrectEachSession / nValidEachSession
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:
validPerSNR, rightPerSNR, possibleSNRs = band_SNR_psychometric(animal, session)
# -- Panel A: schematic of switching task -- #
#ax1 = plt.subplot(gs[0:2, 0:2])
ax1 = plt.subplot(gs[0:2, 0])
plt.axis('off')
ax1.annotate('A', xy=(labelPosX[0],labelPosY[0]), xycoords='figure fraction', fontsize=fontSizePanel, fontweight='bold')
# -- Panel B: example dynamics plot -- #
ax2 = plt.subplot(gs[2:4, 0])
ax1.annotate('B', xy=(labelPosX[0],labelPosY[1]), xycoords='figure fraction', fontsize=fontSizePanel, fontweight='bold')
animal = 'test089'
paradigm = '2afc'
session = '20160113a'
winsize = 40
behavFileName = loadbehavior.path_to_behavior_data(animal,paradigm,session)
behavData = loadbehavior.FlexCategBehaviorData(behavFileName)
hPlots = behavioranalysis.plot_dynamics_2afc_by_freq(behavData, winsize=winsize, fontsize=fontSizeLabels, soundfreq=None)
extraplots.boxoff(plt.gca())
plt.setp(hPlots[1], color=colorLeft) #Block1, midFreq
plt.setp(hPlots[2], color='grey') #Block1, highFreq
plt.setp(hPlots[3], color='grey') #Block2, lowFreq
plt.setp(hPlots[4], color=colorRight) #Block2, midFreq
plt.setp(hPlots[8], color='grey') #Block3, highFreq
plt.setp(hPlots[7], color=colorLeft) #Block3, midFreq
plt.setp(hPlots[9], color='grey') #Block4, lowFreq
plt.setp(hPlots[10], color=colorRight) #Block4, midFreq
plt.xlim([0,740])
plt.xticks([0,200,400,600])
plt.yticks([0,50,100])
plt.ylabel('Rightward\ntrials (%)', labelpad=0.5, fontsize=fontSizeLabels)
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 main():
global behavSession
global subject
global ephysSession
global tetrode
global cluster
global bdata
global eventOnsetTimes
global spikeTimesFromEventOnset
global indexLimitsEachTrial
global spikeTimesFromMovementOnset
global indexLimitsEachMovementTrial
global tuningBehavior#behavior file name of tuning curve
global tuningEphys#ephys session name of tuning curve
print 'psycurve_tuning_report'
for cellID in range(0,numOfCells):
oneCell = allcells.cellDB[cellID]##########!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#try:#######################!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if (behavSession != oneCell.behavSession):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir,subject)
tuningBehavior = oneCell.tuningBehavior
tuningEphys = oneCell.tuningSession
print behavSession
# -- Load Behavior Data --
behaviorFilename = loadbehavior.path_to_behavior_data(subject=subject,paradigm=paradigm,sessionstr=behavSession)
bdata = loadbehavior.BehaviorData(behaviorFilename)
numberOfTrials = len(bdata['choice'])
#print 'numberTrials ',numberOfTrials############################!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# -- 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]
soundOnsetTimeBehav = bdata['timeTarget']
# Find missing trials
missingTrials = behavioranalysis.find_missing_trials(eventOnsetTimes,soundOnsetTimeBehav)
#print 'missing ',len(missingTrials)############################!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Remove missing trials
bdata.remove_trials(missingTrials)
possibleFreq = np.unique(bdata['targetFrequency'])
numberOfFrequencies = len(possibleFreq)
centerFrequencies = [(numberOfFrequencies/2-1),numberOfFrequencies/2]
#################################################################################################
centerOutTimes = bdata['timeCenterOut'] #This is the times that the mouse goes out of the center port
soundStartTimes = bdata['timeTarget'] #This gives an array with the times in seconds from the start of the behavior paradigm of when the sound was presented for each trial
timeDiff = centerOutTimes - soundStartTimes
#print 'timeDiff ',len(timeDiff)############################!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#print 'eventOnsetTimes ',len(eventOnsetTimes)############################!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if (len(eventOnsetTimes) < len(timeDiff)):
eventOnsetTimesCenter = eventOnsetTimes + timeDiff[:-1]
elif (len(eventOnsetTimes) > len(timeDiff)):
eventOnsetTimesCenter = eventOnsetTimes[:-1] + timeDiff
else:
eventOnsetTimesCenter = eventOnsetTimes + timeDiff
#################################################################################################
tetrode = oneCell.tetrode
cluster = oneCell.cluster
# -- Load Spike Data From Certain Cluster --
spkData = ephyscore.CellData(oneCell)
spkTimeStamps = spkData.spikes.timestamps
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
(spikeTimesFromMovementOnset,movementTrialIndexForEachSpike,indexLimitsEachMovementTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimesCenter,timeRange)
plt.clf()
if (len(spkTimeStamps)>0):
ax1 = plt.subplot2grid((numRows,numCols), ((numRows-sizeClusterPlot),0), colspan = (numCols/3))
spikesorting.plot_isi_loghist(spkData.spikes.timestamps)
ax3 = plt.subplot2grid((numRows,numCols), ((numRows-sizeClusterPlot),(numCols/3)*2), colspan = (numCols/3))
spikesorting.plot_events_in_time(spkData.spikes.timestamps)
samples = spkData.spikes.samples.astype(float)-2**15
samples = (1000.0/spkData.spikes.gain[0,0]) *samples
ax2 = plt.subplot2grid((numRows,numCols), ((numRows-sizeClusterPlot),(numCols/3)), colspan = (numCols/3))
spikesorting.plot_waveforms(samples)
###############################################################################
ax4 = plt.subplot2grid((numRows,numCols), (0,0), colspan = (numCols/2), rowspan = 3*sizeRasters)
#plt.setp(ax4.get_xticklabels(), visible=False)
#raster_sound_psycurve(centerFrequencies[0])
raster_tuning(ax4)
axvline(x=0, ymin=0, ymax=1, color='r')
plt.gca().set_xlim(tuning_timeRange)
#ax5 = plt.subplot2grid((7,6), (2,0), colspan = 3, sharex=ax4)
#hist_sound_psycurve(centerFrequencies[0])
ax6 = plt.subplot2grid((numRows,numCols), (0,(numCols/2)), colspan = (numCols/2), rowspan = sizeRasters)
plt.setp(ax6.get_xticklabels(), visible=False)
plt.setp(ax6.get_yticklabels(), visible=False)
raster_sound_psycurve(centerFrequencies[0])
plt.title('Frequency Top: '+str(possibleFreq[centerFrequencies[0]])+' Bottom: '+str(possibleFreq[centerFrequencies[1]]))
ax7 = plt.subplot2grid((numRows,numCols), (sizeRasters,(numCols/2)), colspan = (numCols/2), rowspan = sizeHists, sharex=ax6)
hist_sound_psycurve(centerFrequencies[0])
ax7.yaxis.tick_right()
ax7.yaxis.set_ticks_position('both')
plt.setp(ax7.get_xticklabels(), visible=False)
plt.gca().set_xlim(timeRange)
#ax8 = plt.subplot2grid((7,6), (3,0), colspan = 3, rowspan = 2)
#plt.setp(ax8.get_xticklabels(), visible=False)
#raster_movement_psycurve(centerFrequencies[0])
#ax9 = plt.subplot2grid((7,6), (5,0), colspan = 3, sharex=ax8)
#hist_movement_psycurve(centerFrequencies[0])
ax10 = plt.subplot2grid((numRows,numCols), ((sizeRasters+sizeHists),(numCols/2)), colspan = (numCols/2), rowspan = sizeRasters)
plt.setp(ax10.get_xticklabels(), visible=False)
plt.setp(ax10.get_yticklabels(), visible=False)
raster_sound_psycurve(centerFrequencies[1])
ax11 = plt.subplot2grid((numRows,numCols), ((2*sizeRasters+sizeHists),(numCols/2)), colspan = (numCols/2), rowspan = sizeHists, sharex=ax10)
hist_sound_psycurve(centerFrequencies[1])
ax11.yaxis.tick_right()
ax11.yaxis.set_ticks_position('both')
#plt.setp(ax11.get_yticklabels(), visible=False)
plt.gca().set_xlim(timeRange)
###############################################################################
#plt.tight_layout()
modulation_index_psycurve(centerFrequencies)
plt.suptitle(titleText)
tetrodeClusterName = 'T'+str(oneCell.tetrode)+'c'+str(oneCell.cluster)
plt.gcf().set_size_inches((8.5,11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = 'report_centerFreq_%s_%s_%s.%s'%(subject,behavSession,tetrodeClusterName,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)
#plt.show()
#except:##############################!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#print "error with session "+oneCell.behavSession
#if (oneCell.behavSession not in badSessionList):####################!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#badSessionList.append(oneCell.behavSession)#######################!!!!!!!!!!!!!!!!!!!!!!
print 'error with sessions: '
for badSes in badSessionList:
print badSes
def main():
global behavSession
global subject
global tetrode
global cluster
global bdata
global eventOnsetTimes
global spikeTimesFromEventOnset
global indexLimitsEachTrial
global spikeTimesFromMovementOnset
global indexLimitsEachMovementTrial
global titleText
print "SwitchingReport"
for cellID in range(0,numOfCells):
oneCell = allcells.cellDB[cellID]
if (behavSession != oneCell.behavSession):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir,subject)
print behavSession
# -- Load Behavior Data --
behaviorFilename = loadbehavior.path_to_behavior_data(subject,experimenter,paradigm,behavSession)
bdata = loadbehavior.FlexCategBehaviorData(behaviorFilename)
#bdata = loadbehavior.BehaviorData(behaviorFilename)
bdata.find_trials_each_block()
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]
###############################################################################################
centerOutTimes = bdata['timeCenterOut'] #This is the times that the mouse goes out of the center port
soundStartTimes = bdata['timeTarget'] #This gives an array with the times in seconds from the start of the behavior paradigm of when the sound was presented for each trial
timeDiff = centerOutTimes - soundStartTimes
if (len(eventOnsetTimes) < len(timeDiff)):
timeDiff = timeDiff[:-1]
eventOnsetTimesCenter = eventOnsetTimes + timeDiff
###############################################################################################
tetrode = oneCell.tetrode
cluster = oneCell.cluster
# -- Load Spike Data From Certain Cluster --
spkData = ephyscore.CellData(oneCell)
spkTimeStamps = spkData.spikes.timestamps
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
(spikeTimesFromMovementOnset,movementTrialIndexForEachSpike,indexLimitsEachMovementTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimesCenter,timeRange)
plt.clf()
if (len(spkTimeStamps)>0):
ax1 = plt.subplot2grid((numRows,numCols), ((numRows-sizeClusterPlot),0), colspan = (numCols/3))
spikesorting.plot_isi_loghist(spkData.spikes.timestamps)
ax3 = plt.subplot2grid((numRows,numCols), ((numRows-sizeClusterPlot),(numCols/3)*2), colspan = (numCols/3))
spikesorting.plot_events_in_time(spkTimeStamps)
samples = spkData.spikes.samples.astype(float)-2**15
samples = (1000.0/spkData.spikes.gain[0,0]) *samples
ax2 = plt.subplot2grid((numRows,numCols), ((numRows-sizeClusterPlot),(numCols/3)), colspan = (numCols/3))
spikesorting.plot_waveforms(samples)
###############################################################################
ax4 = plt.subplot2grid((numRows,numCols), (0,0), colspan = (numCols/2), rowspan = sizeRasters)
raster_sound_block_switching()
ax5 = plt.subplot2grid((numRows,numCols), (sizeRasters,0), colspan = (numCols/2), rowspan = sizeHists)
hist_sound_block_switching()
ax6 = plt.subplot2grid((numRows,numCols), (0,(numCols/2)), colspan = (numCols/2), rowspan = sizeRasters)
raster_movement_block_switching()
ax7 = plt.subplot2grid((numRows,numCols), (sizeRasters,(numCols/2)), colspan = (numCols/2), rowspan = sizeHists)
hist_movement_block_switching()
ax8 = plt.subplot2grid((numRows,numCols), ((sizeRasters+sizeHists),0), colspan = (numCols/2), rowspan = sizeRasters)
raster_sound_allFreq_switching()
ax9 = plt.subplot2grid((numRows,numCols), ((2*sizeRasters+sizeHists),0), colspan = (numCols/2), rowspan = sizeHists)
hist_sound_allFreq_switching()
ax10 = plt.subplot2grid((numRows,numCols), ((sizeRasters+sizeHists),(numCols/2)), colspan = (numCols/2), rowspan = sizeRasters)
raster_sound_switching()
ax11 = plt.subplot2grid((numRows,numCols), ((2*sizeRasters+sizeHists),(numCols/2)), colspan = (numCols/2), rowspan = sizeHists)
hist_sound_switching()
###############################################################################
#plt.tight_layout()
modulation_index_switching()
plt.suptitle(titleText)
tetrodeClusterName = 'T'+str(oneCell.tetrode)+'c'+str(oneCell.cluster)
plt.gcf().set_size_inches((8.5,11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = 'report_%s_%s_%s.%s'%(subject,behavSession,tetrodeClusterName,figformat)
fulloutputDir = outputDir+subject +'/'
fullFileName = os.path.join(fulloutputDir,filename)
directory = os.path.dirname(fulloutputDir)
if not os.path.exists(directory): #makes sure output folder exists
os.makedirs(directory)
#print 'saving figure to %s'%fullFileName
plt.gcf().savefig(fullFileName,format=figformat)
def overall_muscimol_performance(animal, muscimolSessions, salineSessions):
'''
DEPRECATED
Plot psychometric and average performance reports for muscimol experiments
INCOMPLETE: hard coded for chords and modulations right now.
'''
#Plot the psycurves
subplot(221)
muscimol_plot_sound_type(animal, muscimolSessions, salineSessions, 'chords')
subplot(223)
muscimol_plot_sound_type(animal, muscimolSessions, salineSessions, 'amp_mod')
#Overall muscimol and saline performance
muscimolData = behavioranalysis.load_many_sessions(animal, muscimolSessions)
muscimolChords = percent_correct_sound_type(muscimolData, 'chords')
muscimolMod = percent_correct_sound_type(muscimolData, 'amp_mod')
salineData = behavioranalysis.load_many_sessions(animal, salineSessions)
salineChords = percent_correct_sound_type(salineData, 'chords')
salineMod = percent_correct_sound_type(salineData, 'amp_mod')
#Individual session muscimol and saline performance
for indp, pair in enumerate(zip(salineSessions, muscimolSessions)):
salineFile = loadbehavior.path_to_behavior_data(animal,settings.DEFAULT_EXPERIMENTER,'2afc',pair[0])
salineData = loadbehavior.BehaviorData(salineFile,readmode='full')
salineChords = percent_correct_sound_type(salineData, 'chords')
salineMod = percent_correct_sound_type(salineData, 'amp_mod')
muscimolFile = loadbehavior.path_to_behavior_data(animal,settings.DEFAULT_EXPERIMENTER,'2afc',pair[1])
muscimolData = loadbehavior.BehaviorData(muscimolFile,readmode='full')
muscimolChords = percent_correct_sound_type(muscimolData, 'chords')
muscimolMod = percent_correct_sound_type(muscimolData, 'amp_mod')
if indp==0:
allPerfChords = array([salineChords, muscimolChords])
else:
allPerfChords = vstack([allPerfChords, array([salineChords, muscimolChords])])
if indp==0:
allPerfMod = array([salineMod, muscimolMod])
else:
allPerfMod = vstack([allPerfMod, array([salineMod, muscimolMod])])
## -- Chords performance
subplot(222)
bar([0, 1], [salineChords, muscimolChords], width=0.5, facecolor='w', edgecolor='k', linewidth = 2)
#plot lines
# for expt in allPerfChords:
# plot([0.25, 1.25], expt, '0.3', lw=2)
#Plot points
for point in allPerfChords[:,0]:
plot(0.25, point, 'ko', ms=7)
for point in allPerfChords[:,1]:
plot(1.25, point, 'ro', ms=7)
xlim([-0.5, 2])
xticks([0.25, 1.25])
ax = gca()
ax.set_xticklabels(['Saline', 'Muscimol'])
ylim([0, 100])
ylabel('Percent Correct')
## -- Amp mod performance
subplot(224)
bar([0, 1], [salineMod, muscimolMod], width=0.5, facecolor='w', edgecolor='k', linewidth = 2)
# for expt in allPerfMod:
# plot([0.25, 1.25], expt, '0.3', lw=2)
#Plot points
for point in allPerfMod[:,0]:
plot(0.25, point, 'ko', ms=7)
for point in allPerfMod[:,1]:
plot(1.25, point, 'ro', ms=7)
xlim([-0.5, 2])
xticks([0.25, 1.25])
ax = gca()
ax.set_xticklabels(['Saline', 'Muscimol'])
ylim([0, 100])
ylabel('Percent Correct')
return (allPerfChords, allPerfMod)
qualityList = [1]
minZVal = 3.0
maxISIviolation = 0.02
'''
cellID = allcells.cellDB.findcell(mouseName, behavSession, tetrode, cluster)
oneCell = allcells.cellDB[cellID]
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=subject,
paradigm=paradigm,
sessionstr=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)
eventOnsetTimes = eventTimes[soundOnsetEvents]
from jaratoolbox import behavioranalysis
from jaratoolbox import loadbehavior
import numpy as np
from pylab import *
import matplotlib.pyplot as plt
from statsmodels.stats.proportion import proportion_confint #Used to compute confidence interval for the error bars.
from jaratoolbox import settings
subjects = ['hm4d004', 'hm4d005', 'hm4d006']
session = '20140826a'
positions = [(0, 0), (0, 1), (1, 0),
(1, 1)] #FIXME: can only place 4 mice for now
for ind, subject in enumerate(subjects): #Iterate through each subject
fname = loadbehavior.path_to_behavior_data(subject, 'nick', '2afc',
session)
try: #Attempt to load the data for this subject
bdata = loadbehavior.BehaviorData(fname)
except IOError: #If the data from this subject is not available:
ax1 = plt.subplot2grid((2, 2), positions[ind]) #Alert the user
xlim([0, 2])
ylim([0, 2])
ax1.text(1,
1,
"No Data Available",
va='center',
ha='center',
Santiago Jaramillo - 2016-04-15
'''
from jaratoolbox import settings
from jaratoolbox import loadbehavior
from jaratoolbox import behavioranalysis
import matplotlib.pyplot as plt
EXPERIMENTER = settings.DEFAULT_EXPERIMENTER
paradigm = '2afc'
subject = 'adap021'
session = '20160310a' # This is the date formatted as YYYYMMDD and one more character (usually 'a')
# -- Find the data filename and load the data into a data object (similar to a Python dict) --
behavFile = loadbehavior.path_to_behavior_data(subject,EXPERIMENTER,paradigm,session)
behavData = loadbehavior.FlexCategBehaviorData(behavFile,readmode='full')
# -- Calculate average performance --
nValidTrials = behavData['nValid'][-1]
nRewardedTrials = behavData['nRewarded'][-1]
print 'Average performance: {:0.1%}'.format(float(nRewardedTrials)/nValidTrials)
# -- Plot psychometric curve --
plt.clf()
(pline, pcaps, pbars, pdots) = behavioranalysis.plot_frequency_psycurve(behavData,fontsize=14)
plt.show()
'''
plt.clf()
freqsToUse = [behavData['lowFreq'][-1],behavData['highFreq'][-1]]
def plot_array_raster(self, session, experiment=-1, site=-1, tetrodes=None, replace=0, sortArray='currentFreq', timeRange = [-0.5, 1], ms=4, electrodeName='Tetrode'):
'''
Plot rasters for each tetrode, for a single recording session.
Args:
session (index): The index of the session to cluster.
experiment (index): The index of the experiment to get the site from.
site (index): The index of the site to pull sessions from.
tetrodes (list of int): The tetrodes to plot. Defaults to all siteObj.tetrodes
replace (bool): True clears and uses the current figure. False makes a new figure.
sortArray (string): Label of the bdata array used to sort the trials.
timeRange (list): Time range around each event to align spikes.
ms (float): matplotlib marker size for raster plots
electrodeName (string): Name of spikes file should be {electrodeName}{electrodeNumber}.spikes
Returns nothing - draws a figure.
'''
sessionObj = self.get_session_obj(session, experiment, site)
sessionDir = sessionObj.ephys_dir()
# behavFile = sessionObj.behav_filename()
# if not behavFile:
# sortArray = []
# else:
# bdata = self.loader.get_session_behavior(behavFile)
# sortArray = bdata[sortArray]
behavClass = None #TODO: This should be an option somewhere.
if behavClass == None:
behavClass = loadbehavior.BehaviorData
if sessionObj.behavsuffix is not None:
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')
sortArray = bdata[sortArray]
else:
sortArray = []
if not tetrodes:
tetrodes=sessionObj.tetrodes
numTetrodes = len(tetrodes)
# eventData = self.loader.get_session_events(sessionDir)
# eventOnsetTimes = self.loader.get_event_onset_times(eventData)
plotTitle = sessionDir
if replace:
fig = plt.gcf()
plt.clf()
else:
fig = plt.figure()
for ind , tetrode in enumerate(tetrodes):
# spikeData = self.loader.get_session_spikes(sessionDir, tetrode)
ephysData = ephyscore.load_ephys(sessionObj.subject, sessionObj.paradigm, sessionDir, tetrode)
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimestamps = ephysData['spikeTimes']
if ind == 0:
ax = fig.add_subplot(numTetrodes,1,ind+1)
else:
ax = fig.add_subplot(numTetrodes,1,ind+1, sharex = fig.axes[0], sharey = fig.axes[0])
# spikeTimestamps = spikeData.timestamps
plot_raster(spikeTimestamps, eventOnsetTimes, sortArray=sortArray, ms=ms, timeRange = timeRange)
if ind == 0:
plt.title(plotTitle)
plt.ylabel('TT {}'.format(tetrode))
plt.xlabel('time (sec)')
plt.show()
stimOnsetFrame = stimOnsetFrame[:
-1] # Remove last to avoid problems of not having full data
nEvents = len(stimOnsetFrame)
# -- Calculate response each trial --
ftraceEachTrial = np.empty([nCells, nEvents])
responseWindow = [0, 30] # in frames
for indEvent, stimOnset in enumerate(stimOnsetFrame):
# FIXME: I'm rounding the stimOnset. Not sure if this is the best option
rangeLims = int(np.round(stimOnset)) + np.array(responseWindow)
frameRange = np.arange(rangeLims[0], rangeLims[1])
ftraceEachTrial[:, indEvent] = np.mean(ftraces[:, frameRange], axis=1)
# -- Load behavior --
behavFilename = loadbehavior.path_to_behavior_data(subject, paradigm,
behavSession)
bdata = loadbehavior.BehaviorData(behavFilename)
currentFreq = bdata['currentFreq']
if nEvents != len(currentFreq):
currentFreq = currentFreq[:
nEvents] #Events will stop sooner than behavior.
possibleFreq = np.unique(currentFreq)
nFreq = len(possibleFreq)
trialsEachType = behavioranalysis.find_trials_each_type(
currentFreq, possibleFreq)
# -- Calculate response each freq --
respEachFreqMean = np.empty([nCells, nFreq])
respEachFreqStDev = np.empty([nCells, nFreq])
nTrialsEachFreq = np.sum(trialsEachType, axis=0)
for indf, oneFreq in enumerate(possibleFreq):
sessions = sys.argv[1:]
nSessions = len(sessions)
nAnimals = len(subjects)
loadingClass = loadbehavior.FlexCategBehaviorData #using this bdata class so we get 'blocks'
paradigm = '2afc'
gs = gridspec.GridSpec(nSessions*nAnimals, 1)
gs.update(hspace=0.5,wspace=0.4)
plt.clf()
for inds,thisSession in enumerate(sessions):
for inda,animalName in enumerate(subjects):
try:
behavFile = loadbehavior.path_to_behavior_data(animalName,EXPERIMENTER,paradigm,thisSession)
behavData = loadingClass(behavFile,readmode='full')
except IOError:
print thisSession+' does not exist'
continue
print 'Loaded %s %s'%(animalName,thisSession)
targetFrequency = behavData['targetFrequency']
choice=behavData['choice']
valid=behavData['valid']& (choice!=behavData.labels['choice']['none'])
choiceRight = choice==behavData.labels['choice']['right']
currentBlock = behavData['currentBlock']
behavData.find_trials_each_block()
trialsEachBlock = behavData.blocks['trialsEachBlock']
#print trialsEachBlock
maxZ_file.write("\n%s " % freq)
for ZVal in maxZDict[behavSession][freq]:
maxZ_file.write("%s," % ZVal)
maxZ_file.write("\n")
# -- Start processing new session --
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir, subject)
print oneCell.behavSession
# -- Load Behavior Data --
behaviorFilename = loadbehavior.path_to_behavior_data(
subject, paradigm, behavSession
) #Omitted experimenter since data no longer stored in experimenter folder
bdata = loadbehavior.BehaviorData(behaviorFilename)
numberOfTrials = len(bdata['choice'])
print "number of behavior trials ", numberOfTrials
# -- 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
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)
def main():
global behavSession
global subject
global ephysSession
global tetrodeID
global bdata
global eventOnsetTimes
global spikeTimesFromEventOnset
global indexLimitsEachTrial
global spikeTimesFromMovementOnset
global indexLimitsEachMovementTrial
for cellID in range(0, numOfCells):
oneCell = allcells.cellDB[cellID]
try:
if (behavSession != oneCell.behavSession):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir, subject)
print behavSession
# -- 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]
possibleFreq = np.unique(bdata['targetFrequency'])
numberOfFrequencies = len(possibleFreq)
centerFrequencies = [(numberOfFrequencies / 2 - 1),
numberOfFrequencies / 2]
#################################################################################################
centerOutTimes = bdata[
'timeCenterOut'] #This is the times that the mouse goes out of the center port
soundStartTimes = bdata[
'timeTarget'] #This gives an array with the times in seconds from the start of the behavior paradigm of when the sound was presented for each trial
timeDiff = centerOutTimes - soundStartTimes
if (len(eventOnsetTimes) < len(timeDiff)):
timeDiff = timeDiff[:-1]
eventOnsetTimesCenter = eventOnsetTimes + timeDiff
#################################################################################################
# -- Load Spike Data From Certain Cluster --
spkData = ephyscore.CellData(oneCell)
spkTimeStamps = spkData.spikes.timestamps
(spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
(spikeTimesFromMovementOnset,movementTrialIndexForEachSpike,indexLimitsEachMovementTrial) = \
spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimesCenter,timeRange)
plt.clf()
if (len(spkTimeStamps) > 0):
ax1 = plt.subplot2grid((7, 6), (6, 0), colspan=2)
spikesorting.plot_isi_loghist(spkData.spikes.timestamps)
ax3 = plt.subplot2grid((7, 6), (6, 4), colspan=2)
spikesorting.plot_events_in_time(spkData.spikes.timestamps)
samples = spkData.spikes.samples.astype(float) - 2**15
samples = (1000.0 / spkData.spikes.gain[0, 0]) * samples
ax2 = plt.subplot2grid((7, 6), (6, 2), colspan=2)
spikesorting.plot_waveforms(samples)
###############################################################################
ax4 = plt.subplot2grid((7, 6), (0, 0), colspan=3, rowspan=2)
raster_sound_psycurve(centerFrequencies[0])
ax5 = plt.subplot2grid((7, 6), (2, 0), colspan=3)
hist_sound_psycurve(centerFrequencies[0])
ax6 = plt.subplot2grid((7, 6), (0, 3), colspan=3, rowspan=2)
raster_sound_psycurve(centerFrequencies[1])
ax7 = plt.subplot2grid((7, 6), (2, 3), colspan=3)
hist_sound_psycurve(centerFrequencies[1])
ax8 = plt.subplot2grid((7, 6), (3, 0), colspan=3, rowspan=2)
raster_movement_psycurve(centerFrequencies[0])
ax9 = plt.subplot2grid((7, 6), (5, 0), colspan=3)
hist_movement_psycurve(centerFrequencies[0])
ax10 = plt.subplot2grid((7, 6), (3, 3), colspan=3, rowspan=2)
raster_movement_psycurve(centerFrequencies[1])
ax11 = plt.subplot2grid((7, 6), (5, 3), colspan=3)
hist_movement_psycurve(centerFrequencies[1])
###############################################################################
#plt.tight_layout()
tetrodeClusterName = 'T' + str(oneCell.tetrode) + 'c' + str(
oneCell.cluster)
plt.gcf().set_size_inches((8.5, 11))
figformat = 'png' #'png' #'pdf' #'svg'
filename = 'report_centerFreq_%s_%s_%s.%s' % (
subject, behavSession, tetrodeClusterName, 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)
#plt.show()
except:
#print "error with session "+oneCell.behavSession
if (oneCell.behavSession not in badSessionList):
badSessionList.append(oneCell.behavSession)
print 'error with sessions: '
for badSes in badSessionList:
print badSes
oneCell = allcells.cellDB[cellID]
if (oneCell.behavSession in modIList): #checks to make sure the modI value is not recalculated
continue
try:
if (behavSession != oneCell.behavSession):
subject = oneCell.animalName
behavSession = oneCell.behavSession
ephysSession = oneCell.ephysSession
ephysRoot = os.path.join(ephysRootDir,subject)
print behavSession
# -- Load Behavior Data --
behaviorFilename = loadbehavior.path_to_behavior_data(subject,experimenter,paradigm,behavSession)
bdata = loadbehavior.BehaviorData(behaviorFilename)
# -- 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']
valid = (bdata['outcome']==bdata.labels['outcome']['correct'])|(bdata['outcome']==bdata.labels['outcome']['error'])
def load_many_sessions(animalNames,
sessions,
paradigm='2afc',
datesRange=None):
'''
Based on behavioranalysis.save_many_sessions_reversal()
TO DO:
- Add params='all', (it depends on loadbehavior.FlexCateg being able to load a subset of vars)
- What to do if a parameter only exists for some sessions?
'''
if isinstance(animalNames, str):
animalNames = [animalNames]
if datesRange:
datesLims = [parse_isodate(dateStr) for dateStr in datesRange]
allDates = [datesLims[0]+datetime.timedelta(n) \
for n in range((datesLims[-1]-datesLims[0]).days+1)]
allSessions = [oneDate.strftime('%Y%m%da') for oneDate in allDates]
else:
allSessions = sessions
nAnimals = len(animalNames)
if paradigm == '2afc':
loadingClass = loadbehavior.FlexCategBehaviorData
else:
raise TypeError(
'Loading many sessions for that paradigm has not been implemented')
#if params=='all':
# readmode = 'full'
#else:
# readmode = params
readmode = 'full'
#allBehavData = {}
#allBehavData['sessionID'] = np.empty(0,dtype='i2')
#allBehavData['animalID'] = np.empty(0,dtype='i1')
inds = 0
for inda, animalName in enumerate(animalNames):
for indsa, thisSession in enumerate(allSessions):
try:
behavFile = loadbehavior.path_to_behavior_data(
animalName, EXPERIMENTER, paradigm, thisSession)
behavData = loadingClass(behavFile, readmode=readmode)
except IOError:
print thisSession + ' does not exist'
continue
if inds == 0:
allBehavData = behavData # FIXME: Should it be .copy()?
nTrials = len(behavData['outcome']
) # FIXME: what if this key does not exist?
allBehavData['sessionID'] = np.zeros(nTrials, dtype='i2')
allBehavData['animalID'] = np.zeros(nTrials, dtype='i1')
else:
for key, val in behavData.iteritems():
if not allBehavData.has_key(key):
allBehavData[key] = val
else:
allBehavData[key] = np.concatenate(
(allBehavData[key], val))
nTrials = len(behavData['outcome']
) # FIXME: what if this key does not exist?
allBehavData['sessionID'] = np.concatenate(
(allBehavData['sessionID'], np.tile(inds, nTrials)))
allBehavData['animalID'] = np.concatenate(
(allBehavData['animalID'], np.tile(inda, nTrials)))
inds += 1
return allBehavData
