def get_session_bdata(cell, sessiontype): sessionInds = get_session_inds(cell, sessiontype) sessionInd = sessionInds[0] #FIXME: Just takes the first one for now behavFile = cell['behavior'][sessionInd] behavDataFilePath=os.path.join(settings.BEHAVIOR_PATH, cell['subject'], behavFile) bdata = loadbehavior.BehaviorData(behavDataFilePath,readmode='full') return bdata
def __init__(self, ephys_root, numTetrodes, behavior_directory=None, behav_filename=None): ''' Accepts the root directory containing all of the ephys files relevant to a particular experiment, and the directory containing the behavior files if these are relevant to the experiment. Arguments ephys_root (string) - The parent directory of all individual recording session directories numTetrodes (int) - Number of tetrodes behavior_directory (string) - Directory containing behavior files ''' self.ephys_root = ephys_root self.numTetrodes = numTetrodes if behavior_directory != None: self.behavior_directory = behavior_directory self.behav_filename = behav_filename behavDataFileName = os.path.join(behavior_directory, behav_filename) self.bdata = loadbehavior.BehaviorData(behavDataFileName, readmode='full')
def get_session_behav_data(self, session, behavFileIdentifier): behaviorDir=os.path.join(self.localBehavPath, self.animalName) fullBehavFilename = ''.join([self.behavFileBaseName, behavFileIdentifier, '.h5']) behavDataFileName=os.path.join(behaviorDir, fullBehavFilename) #Extract the frequency presented each trial from the behavior data bdata = loadbehavior.BehaviorData(behavDataFileName,readmode='full') return bdata
def load_behavior_basic(animal, behavSession): '''Load behavior using the basic BehaviorData class of loadbehavior module. :param arg1: String containing animal name. :param arg2: A string of the name of the behavior session, this is the full filename in '{animal}_{paradigm}_{date}{behavsuffix}.h5' format. :return: bData object (as defined in loadbehavior). ''' behavFullPath = os.path.join(BEHAVIOR_PATH, animal, behavSession) bData = loadbehavior.BehaviorData(behavFullPath) return bData
def get_session_behavior(self, behavFileName): if self.mode=='online': behaviorDir=os.path.join(self.onlineBehavPath, self.animalName) fullBehavFilename = ''.join([self.behavFileBaseName, behavFileName, '.h5']) behavDataFilePath=os.path.join(behaviorDir, fullBehavFilename) elif self.mode=='offline': #The path should already be relative to the mouse print "Fixme: Stop dividing the behavior by experimenter and change this method" behavDataFilePath = os.path.join(settings.BEHAVIOR_PATH, self.experimenter, behavFileName) bdata = loadbehavior.BehaviorData(behavDataFilePath,readmode='full') return bdata
def load_remote_tuning_data(oneCell, behavDir=BEHAVDIR_MOUNTED, ephysDir=EPHYSDIR_MOUNTED): ''' Given a CellInfo object and remote behavior and ephys directories, this function loads the associated tuning ephys and tuning behav data from the mounted jarastore drive. Returns eventOnsetTimes, spikeTimestamps, and bData objects. ''' ### Get behavior data associated with tuning curve ### behavFileName = '{0}_{1}_{2}.h5'.format(oneCell.animalName, 'tuning_curve', oneCell.tuningBehavior) behavFile = os.path.join(behavDir, oneCell.animalName, behavFileName) bData = loadbehavior.BehaviorData(behavFile, readmode='full') ### Get events data ### fullEventFilename = os.path.join(ephysDir, oneCell.animalName, oneCell.tuningSession, 'all_channels.events') eventData = loadopenephys.Events(fullEventFilename) ### Get event onset times ### eventTimestamps = np.array( eventData.timestamps ) / EPHYS_SAMPLING_RATE #hard-coded ephys sampling rate!! evID = np.array(eventData.eventID) eventOnsetTimes = eventTimestamps[(evID == 1)] ### GEt spike data for just this cluster ### spikeFilename = os.path.join(ephysDir, oneCell.animalName, oneCell.tuningSession, 'Tetrode{}.spikes'.format(oneCell.tetrode)) spikeData = loadopenephys.DataSpikes(spikeFilename) spikeData.timestamps = spikeData.timestamps / EPHYS_SAMPLING_RATE clustersDir = os.path.join(ephysDir, oneCell.animalName, oneCell.tuningSession) + '_kk' clusterFilename = os.path.join(clustersDir, 'Tetrode{}.clu.1'.format(oneCell.tetrode)) clusters = np.fromfile(clusterFilename, dtype='int32', sep=' ')[1:] spikeData.timestamps = spikeData.timestamps[clusters == oneCell.cluster] spikeData.samples = spikeData.samples[clusters == oneCell.cluster, :, :] spikeData.samples = spikeData.samples.astype( float) - 2**15 # FIXME: this is specific to OpenEphys # FIXME: This assumes the gain is the same for all channels and records spikeData.samples = (1000.0 / spikeData.gain[0, 0]) * spikeData.samples #spikeData = ephyscore.CellData(oneCell) #spikeTimestamps=spikeData.spikes.timestamps return (eventOnsetTimes, spikeData.timestamps, bData)
def loadData(self): """ Walks through all files in settings.BEHAVIOR_PATH and lazily loads in the relevent files to the "behavData" list where each index is a tuple formatted as, (<full path of file>, <loaded behavior data>). Args: None Returns: None """ for info in os.walk(settings.BEHAVIOR_PATH): path = info[0] # Get the files, if there are any for element in info[2]: split = element.split(".") # If there's only one '.' in the filename, then we know it's not a .old.h5 file, or a file without an extension. if(len(split) == 2): name, extension = element.split(".") if(self.log): logging.debug("Name: " + name + " Extension: " + extension) for animal in self.subjects: # Get the date from the name and format it in ISO format to compare to the current date. experimentDate = name.split("_")[-1] isoDate = experimentDate[:4] + "-" + experimentDate[4:6] + "-" + experimentDate[6:8] if(self.log): logging.debug("Comparing date: " + str(isoDate) + " to " + str(self.date) + " (today)") # We only want data from today from an animal that we care about if(self.date == extrafuncs.parse_isodate(isoDate) and extension == "h5" and animal in name): try: full_path = os.path.join(path, element) self.behavData.append((full_path, loadbehavior.BehaviorData(full_path, readmode='full'))) if(self.log): logging.info("Successfully loaded data from: " + full_path) except: self.sendToAllSubscribers("Error when attempting to load " + full_path + ".", "Alert: Alarm error") if(self.log): logging.error("Could not load " + full_path + ".")
def get_session_behav_data(self, session, behavFileIdentifier=None): if not isinstance( session, str): #FIXME: This is a hack but I think it will work for nto behavFileIdentifier = self.get_session_name(session, dataType='behavior') else: if not behavFileIdentifier: print "Either supply a Session object as the session, or supply a valid behav file identifier" behaviorDir = os.path.join(self.localBehavPath, self.animalName) fullBehavFilename = ''.join( [self.behavFileBaseName, behavFileIdentifier, '.h5']) behavDataFileName = os.path.join(behaviorDir, fullBehavFilename) #Extract the frequency presented each trial from the behavior data bdata = loadbehavior.BehaviorData(behavDataFileName, readmode='full') return bdata
def get_session_bdata(cell, sessiontype): ''' Load the behavior data from a cell for a single session. Args: cell (pandas.Series): One row from a pandas cell database created using generate_cell_database or by manually constructing a pandas.Series object that contains the required fields. This function requires the 'sessiontype' field, which must contain a list of strings. sessiontype (str): The type of session Returns: bdata (jaratoolbox.loadbehavior.BehaviorData): The behavior data for the session ''' sessionInds = get_session_inds(cell, sessiontype) sessionInd = sessionInds[0] #FIXME: Just takes the first one for now behavFile = cell['behavior'][sessionInd] behavDataFilePath = os.path.join(settings.BEHAVIOR_PATH, cell['subject'], behavFile) bdata = loadbehavior.BehaviorData(behavDataFilePath, readmode='full') return bdata
def mod_switching_summary(animalName, sessions): fn = '/home/nick/data/behavior/nick/{0}/{1}_2afc_{2}.h5'.format(animalName, animalName, date) #fn = '/var/tmp/data/santiago/nick/nick_2afc_20160330a.h5' #Not psycurve bdata = loadbehavior.BehaviorData(fn) numSoundType = len(np.unique(bdata['soundType'])) soundTypes = [bdata.labels['soundType'][np.unique(bdata['soundType'])[x]] for x in range(numSoundType)] plt.clf() if any(bdata['psycurveMode']): for indType, soundType in enumerate(soundTypes): plt.subplot2grid((numSoundType, 2), (indType, 0)) plot_frequency_psycurve_soundtype(bdata, soundType) plt.title('{}, {}'.format(animalName, soundType)) else: for indType, soundType in enumerate(soundTypes): plt.subplot2grid((numSoundType, 2), (indType, 0)) plot_summary_sound_type(bdata, soundType) plt.title('{}, {}'.format(animalName, soundType)) for indType, soundType in enumerate(soundTypes): plt.subplot2grid((numSoundType, 2), (indType, 1)) plot_dynamics_sound_type(bdata, soundType) plt.title('{}, {}'.format(animalName, soundType)) behavFolder = '/home/nick/data/behavior_reports' figname = '{}_{}.png'.format(animalName, date) filename = os.path.join(behavFolder, figname) plt.suptitle(date) plt.tight_layout() plt.savefig(filename)
def raster_tuning(ax): fullbehaviorDir = behaviorDir + subject + '/' behavName = subject + '_tuning_curve_' + tuningBehavior + '.h5' tuningBehavFileName = os.path.join(fullbehaviorDir, behavName) tuning_bdata = loadbehavior.BehaviorData(tuningBehavFileName, readmode='full') freqEachTrial = tuning_bdata['currentFreq'] possibleFreq = np.unique(freqEachTrial) numberOfTrials = len(freqEachTrial) # -- The old way of sorting (useful for plotting sorted raster) -- sortedTrials = [] numTrialsEachFreq = [ ] #Used to plot lines after each group of sorted trials for indf, oneFreq in enumerate( possibleFreq ): #indf is index of this freq and oneFreq is the frequency indsThisFreq = np.flatnonzero( freqEachTrial == oneFreq) #this gives indices of this frequency sortedTrials = np.concatenate( (sortedTrials, indsThisFreq)) #adds all indices to a list called sortedTrials numTrialsEachFreq.append( len(indsThisFreq)) #finds number of trials each frequency has sortingInds = argsort( sortedTrials) #gives array of indices that would sort the sortedTrials # -- Load event data and convert event timestamps to ms -- tuning_ephysDir = os.path.join(settings.EPHYS_PATH, subject, tuningEphys) tuning_eventFilename = os.path.join(tuning_ephysDir, 'all_channels.events') tuning_ev = loadopenephys.Events( tuning_eventFilename) #load ephys data (like bdata structure) tuning_eventTimes = np.array( tuning_ev.timestamps ) / SAMPLING_RATE #get array of timestamps for each event and convert to seconds by dividing by sampling rate (Hz). matches with eventID and tuning_evID = np.array( tuning_ev.eventID ) #loads the onset times of events (matches up with eventID to say if event 1 went on (1) or off (0) tuning_eventOnsetTimes = tuning_eventTimes[ tuning_evID == 1] #array that is a time stamp for when the chosen event happens. #ev.eventChannel woul load array of events like trial start and sound start and finish times (sound event is 0 and trial start is 1 for example). There is only one event though and its sound start while (numberOfTrials < len(tuning_eventOnsetTimes)): tuning_eventOnsetTimes = tuning_eventOnsetTimes[:-1] ####################################################################################################### ###################THIS IS SUCH A HACK TO GET SPKDATA FROM EPHYSCORE################################### ####################################################################################################### thisCell = celldatabase.CellInfo( animalName=subject, ############################################ ephysSession=tuningEphys, tuningSession='DO NOT NEED THIS', tetrode=tetrode, cluster=cluster, quality=1, depth=0, tuningBehavior='DO NOT NEED THIS', behavSession=tuningBehavior) tuning_spkData = ephyscore.CellData(thisCell) tuning_spkTimeStamps = tuning_spkData.spikes.timestamps (tuning_spikeTimesFromEventOnset, tuning_trialIndexForEachSpike, tuning_indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes( tuning_spkTimeStamps, tuning_eventOnsetTimes, tuning_timeRange) #print 'numTrials ',max(tuning_trialIndexForEachSpike)##################################### ''' Create a vector with the spike timestamps w.r.t. events onset. (spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = eventlocked_spiketimes(timeStamps,eventOnsetTimes,timeRange) timeStamps: (np.array) the time of each spike. eventOnsetTimes: (np.array) the time of each instance of the event to lock to. timeRange: (list or np.array) two-element array specifying time-range to extract around event. spikeTimesFromEventOnset: 1D array with time of spikes locked to event. o trialIndexForEachSpike: 1D array with the trial corresponding to each spike. The first spike index is 0. indexLimitsEachTrial: [2,nTrials] range of spikes for each trial. Note that the range is from firstSpike to lastSpike+1 (like in python slices) spikeIndices ''' tuning_sortedIndexForEachSpike = sortingInds[ tuning_trialIndexForEachSpike] #Takes values of trialIndexForEachSpike and finds value of sortingInds at that index and makes array. This array gives an array with the sorted index of each trial for each spike # -- Calculate tuning -- plot(tuning_spikeTimesFromEventOnset, tuning_sortedIndexForEachSpike, '.', ms=3) #axvline(x=0, ymin=0, ymax=1, color='r') #The cumulative sum of the list of specific frequency presentations, #used below for plotting the lines across the figure. numTrials = cumsum(numTrialsEachFreq) #Plot the lines across the figure in between each group of sorted trials for indf, num in enumerate(numTrials): ax.axhline(y=num, xmin=0, xmax=1, color='0.90', zorder=0) tickPositions = numTrials - mean(numTrialsEachFreq) / 2 tickLabels = [ "%0.2f" % (possibleFreq[indf] / 1000) for indf in range(len(possibleFreq)) ] ax.set_yticks(tickPositions) ax.set_yticklabels(tickLabels) ax.set_ylim([-1, numberOfTrials]) ylabel('Frequency Presented (kHz), {} total trials'.format(numTrials[-1])) #title(ephysSession+' T{}c{}'.format(tetrodeID,clusterID)) xlabel('Time (sec)')
def get_session_behavior(self, behavFileName): behavDataFilePath = os.path.join(self.behavPath, behavFileName) bdata = loadbehavior.BehaviorData(behavDataFilePath, readmode='full') return bdata
#behavSession = '20150322c'; ephysSession = '2015-03-22_17-40-55' behavSession = '20150323a'; ephysSession = '2015-03-23_21-51-50' #behavSession = '20150323b'; ephysSession = '2015-03-23_22-46-13' tetrodes = [3,6]#[3,6] nTetrodes = len(tetrodes) #ephysSession=sort(os.listdir(fullephysRoot))[-1] fullephysDir = os.path.join(settings.EPHYS_PATH,subject, ephysSession) event_filename = os.path.join(fullephysDir, 'all_channels.events') experimenter = settings.DEFAULT_EXPERIMENTER paradigm = 'laser_tuning_curve' behavDataFileName = loadbehavior.path_to_behavior_data(subject,experimenter,paradigm,behavSession) bdata = loadbehavior.BehaviorData(behavDataFileName,readmode='full') freqEachTrial = bdata['currentFreq'] intensityEachTrial = bdata['currentIntensity'] nTrials = len(freqEachTrial) # -- Load event data and convert event timestamps to ms -- ev = loadopenephys.Events(event_filename) # load ephys data (like bdata structure) eventTimes = np.array(ev.timestamps)/SAMPLING_RATE # convert to seconds by dividing by sampling rate (Hz) evID = np.array(ev.eventID) # loads the onset times of events (matches up with eventID to say if event 1 went on (1) or off (0) eventOnsetTimes = eventTimes[evID==1] # array that is a time stamp for when the chosen event happens. if nTrials != len(eventOnsetTimes): print 'Number of behavior trials and ephys trials do not match. The longest will be cut.' minNtrials = min(nTrials,len(eventOnsetTimes)) nTrials = minNtrials freqEachTrial = freqEachTrial[:nTrials]
def plot_tc_psth(self, session, tetrode, behavFileIdentifier, cluster=None): #FIXME: This method needs a lot of work SAMPLING_RATE = 30000.0 PLOTTING_WINDOW = 0.1 #Window to plot, in seconds ephysSession = self.get_session_name(session) ephysDir=os.path.join(self.localEphysDir, ephysSession) event_filename=os.path.join(ephysDir, 'all_channels.events') behaviorDir=os.path.join(self.localBehavPath, self.animalName) fullBehavFilename = ''.join([self.behavFileBaseName, behavFileIdentifier, '.h5']) behavDataFileName=os.path.join(behaviorDir, fullBehavFilename) #Extract the frequency presented each trial from the behavior data bdata = loadbehavior.BehaviorData(behavDataFileName,readmode='full') freqEachTrial = bdata['currentFreq'] intensityEachTrial = bdata['currentIntensity'] possibleFreq = np.unique(freqEachTrial) possibleIntensity = np.unique(intensityEachTrial) #Get the event timestamps from openEphys ev=loadopenephys.Events(event_filename) evID=np.array(ev.eventID) eventOnsetTimes=ev.timestamps[evID==1] #The timestamps of all of the stimulus onsets tetrode = 6 #The tetrode to plot spikeFilename = os.path.join(ephysDir, 'Tetrode{}.spikes'.format(tetrode)) spikeData = loadopenephys.DataSpikes(spikeFilename) if cluster: clustersDir = os.path.join(settings.EPHYS_PATH,'%s/%s_kk/'%(self.animalName,ephysSession)) clustersFile = os.path.join(clustersDir,'Tetrode%d.clu.1'%tetrode) spikeData.set_clusters(clustersFile) spikeTimestamps = spikeData.timestamps[spikeData.clusters==cluster] else: spikeTimestamps = spikeData.timestamps allSettingsSpikes = defaultdict(dict) #2D dictionary to hold the spiketimes arrays organized by frequency and intensity for indFreq, currentFreq in enumerate(possibleFreq): for indIntensity, currentIntensity in enumerate(possibleIntensity): #Determine which trials this setting was presented on. trialsThisSetting = np.flatnonzero((freqEachTrial == currentFreq) & (intensityEachTrial == currentIntensity)) #Get the onset timestamp for each of the trials of this setting. timestampsThisSetting = eventOnsetTimes[trialsThisSetting] spikesAfterThisSetting = np.array([]) #Loop through all of the trials for this setting, extracting the trace after each presentation for indts, eventTimestamp in enumerate(timestampsThisSetting): spikes = spikeTimestamps[(spikeTimestamps >= eventTimestamp) & (spikeTimestamps <= eventTimestamp + SAMPLING_RATE * PLOTTING_WINDOW)] spikes = spikes - eventTimestamp spikes = spikes / 30 #Spikes in ms after the stimulus spikesAfterThisSetting = np.concatenate((spikesAfterThisSetting, spikes)) allSettingsSpikes[indFreq][indIntensity] = spikesAfterThisSetting #Put the spikes into the 2d dict figure() maxBinCount = [] for indI, intensity in enumerate(possibleIntensity): for indF, frequency in enumerate(possibleFreq): h, bin_edges = histogram(allSettingsSpikes[indF][indI]) #Dict is ordered by freq and then by Int. maxBinCount.append(max(h)) maxNumSpikesperBin = max(maxBinCount) for intensity in range(len(possibleIntensity)): #Subplot2grid plots from top to bottom, but we need to plot from bottom to top #on the intensity scale. So we make an array of reversed intensity indices. intensPlottingInds = range(len(possibleIntensity))[::-1] for frequency in range(len(possibleFreq)): if (intensity == len(possibleIntensity) - 1) & (frequency == len(possibleFreq) -1): ax2 = subplot2grid((len(possibleIntensity), len(possibleFreq)), (intensPlottingInds[intensity], frequency)) if len(allSettingsSpikes[frequency][intensity]) is not 0: ax2.hist(allSettingsSpikes[frequency][intensity]) else: pass ax2.set_ylim([0, maxNumSpikesperBin]) ax2.get_xaxis().set_ticks([]) else: ax = subplot2grid((len(possibleIntensity), len(possibleFreq)), (intensPlottingInds[intensity], frequency)) if len(allSettingsSpikes[frequency][intensity]) is not 0: ax.hist(allSettingsSpikes[frequency][intensity]) else: pass ax.set_ylim([0, maxNumSpikesperBin]) ax.set_axis_off() def getXlabelpoints(n): rawArray = array(range(1, n+1))/float(n+1) #The positions in a perfect (0,1) world diffFromCenter = rawArray - 0.6 partialDiffFromCenter = diffFromCenter * 0.175 #Percent change has to be determined empirically finalArray = rawArray - partialDiffFromCenter return finalArray #Not sure yet if similar modification to the locations will be necessary. def getYlabelpoints(n): rawArray = array(range(1, n+1))/float(n+1) #The positions in a perfect (0,1) world return rawArray freqLabelPositions = getXlabelpoints(len(possibleFreq)) for indp, position in enumerate(freqLabelPositions): figtext(position, 0.065, "%.1f"% (possibleFreq[indp]/1000), ha = 'center') intensLabelPositions = getYlabelpoints(len(possibleIntensity)) for indp, position in enumerate(intensLabelPositions): figtext(0.075, position, "%d"% possibleIntensity[indp]) figtext(0.525, 0.025, "Frequency (kHz)", ha = 'center') figtext(0.025, 0.5, "Intensity (dB SPL)", va = 'center', rotation = 'vertical') show()
stepArrays = [] trialNumArrays = [] performanceArrays = [] for subject in subjects: dataDir = os.path.join(settings.BEHAVIOR_PATH, subject) sessions = sorted(os.listdir(dataDir)) trainingSteps = np.empty(len(sessions)) trialStartEachSession = np.empty(len(sessions)) percentCorrect = np.empty(len(sessions)) trials = 0 highestStep = 0 for indSession, sessionFn in enumerate(sessions): sessionFullPath = os.path.join(dataDir, sessionFn) try: bdata = loadbehavior.BehaviorData(sessionFullPath) except KeyError: print "Key Error with session: {}".format(sessionFullPath) try: step, percentCorrectThisSession = behavior_step(bdata) except NoSoundTypeMode as e: #Using the animal for other paradigms throws key errors if highestStep == 8: #If we are at the end of the animal's career step, percentCorrectThisSession = -1, 0 #Animal was being used for different things else: print e raise KeyError('Problem before end of animal career') #Keep track of the highest step the animal has acheived. if step > highestStep: highestStep = step
def main(oneCell): 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'] correct = bdata['outcome']==bdata.labels['outcome']['correct'] correctRightward = rightward & correct correctLeftward = leftward & correct possibleFreq = np.unique(bdata['targetFrequency']) Freq = possibleFreq[Frequency] oneFreq = bdata['targetFrequency'] == possibleFreq[Frequency] trialsToUseRight = correctRightward & oneFreq trialsToUseLeft = correctLeftward & oneFreq trialsEachCond = np.c_[trialsToUseLeft,trialsToUseRight]; colorEachCond = ['g','r'] # -- Load Spike Data From Certain Cluster -- spkData = ephyscore.CellData(oneCell) spkTimeStamps = spkData.spikes.timestamps (spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \ spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange) 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)') nameFreq = str(Freq) 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,nameFreq,tetrodeClusterName,figformat) fulloutputDir = outputDir+subject+'/'+ nameFreq +'/' 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)
clf() # 2 sound types, muscimol/saline for indRow in range(len(salineSessions)): #Plot chords saline subplot(plotRows, plotCols, indRow * 4 + 1) soundType = 'chords' date = salineSessions[indRow] fn = '/home/nick/data/behavior/nick/{0}/{1}_2afc_{2}.h5'.format( animal, animal, date) #fn = '/var/tmp/data/santiago/nick/nick_2afc_20160330a.h5' #Not psycurve bdata = loadbehavior.BehaviorData(fn) behavioranalysis.plot_frequency_psycurve_soundtype(bdata, soundType) title('{} {}'.format(date, soundType)) xlabel('') subplot(plotRows, plotCols, indRow * 4 + 2) soundType = 'amp_mod' date = salineSessions[indRow] fn = '/home/nick/data/behavior/nick/{0}/{1}_2afc_{2}.h5'.format( animal, animal, date) #fn = '/var/tmp/data/santiago/nick/nick_2afc_20160330a.h5' #Not psycurve bdata = loadbehavior.BehaviorData(fn) behavioranalysis.plot_frequency_psycurve_soundtype(bdata, soundType) title('{} {}'.format(date, soundType))
for cellParams in cellParamsList: mouseName = cellParams['firstParam'] allcellsFileName = 'allcells_' + mouseName + '_quality' #This is specific to Billy's final allcells files after adding cluster quality info sys.path.append(settings.ALLCELLS_PATH) allcells = importlib.import_module(allcellsFileName) ### Using cellDB methode to find the index of this cell in the cellDB ### cellIndex = allcells.cellDB.findcell(**cellParams) oneCell = allcells.cellDB[cellIndex] ## Get behavior data associated with 2afc session ### behavFileName = '{0}_{1}_{2}.h5'.format(oneCell.animalName, paradigm, oneCell.behavSession) behavFile = os.path.join(BEHAVIOR_PATH, oneCell.animalName, behavFileName) bdata = loadbehavior.BehaviorData(behavFile, readmode='full') ### Get events data ### fullEventFilename = os.path.join(EPHYS_PATH, oneCell.animalName, oneCell.ephysSession, 'all_channels.events') eventData = loadopenephys.Events(fullEventFilename) ##### Get event onset times ##### eventData.timestamps = np.array( eventData.timestamps ) / EPHYS_SAMPLING_RATE #hard-coded ephys sampling rate!! ### GEt spike data of just this cluster ### spikeFilename = os.path.join(EPHYS_PATH, oneCell.animalName, oneCell.ephysSession, 'Tetrode{}.spikes'.format(oneCell.tetrode))
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
#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.astype(int)) == 2) + 1 #Should catch the leading edges #How many samples before and after onset to average samplesBefore = 0 samplesAfter = 20 traceLen = samplesBefore + samplesAfter #Load the behavior data behavFn = loadbehavior.path_to_behavior_data('imag002', 'am_tuning_curve', '20181201b') 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) maxEachFreq = np.empty(len(possibleFreq)) minEachFreq = np.empty(len(possibleFreq)) axEachFreq = [] for indFreq, thisFreq in enumerate(possibleFreq): ax = plt.subplot(4, 3, indFreq + 1) axEachFreq.append(ax) onsetsThisFreq = onsets[np.flatnonzero(currentFreq == thisFreq)]
''' from jaratoolbox import loadopenephys from jaratoolbox import loadbehavior import numpy as np import matplotlib.pyplot as plt EPHYS_SAMPLING_RATE = 30000.0 #ephysfn = '/home/languo/data/ephys/d1pi002/2015-08-14_15-42-36/all_channels.events' #bData has 999 trials while len(eventOnsetTimes)=996 ephysfn = '/home/languo/data/ephys/d1pi002/2015-08-14_14-55-22/all_channels.events' eventData = loadopenephys.Events(ephysfn) #behavfn ='/home/languo/data/behavior/lan/d1pi002/d1pi002_laser_tuning_curve_20150814b.h5' #bData has 999 trials while len(eventOnsetTimes)=996 behavfn = '/home/languo/data/behavior/lan/d1pi002/d1pi002_laser_tuning_curve_20150814a.h5' bData = loadbehavior.BehaviorData(behavfn) eventID = 1 eventChannel = 0 evID = np.array(eventData.eventID) evChannel = np.array(eventData.eventChannel) eventTimes = np.array(eventData.timestamps) / EPHYS_SAMPLING_RATE eventOnsetTimes = eventTimes[(evID == eventID) & (evChannel == eventChannel)] eventOnsetTimes = eventOnsetTimes - eventOnsetTimes[0] indexLEET = bData.events['indexLastEventEachTrial'] indexFEET = np.hstack( (4, (indexLEET[:-1] + 1))) #hard-coded index for start of first trial as 4 time_FEET = bData.events['eventTime'][indexFEET]
def load_behaviour_data(subject, fileName): behavFile = os.path.join(settings.BEHAVIOR_PATH,subject,fileName) bdata = loadbehavior.BehaviorData(behavFile,readmode='full') return bdata
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
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)
def raster_tuning(ax): fullbehaviorDir = behaviorDir + subject + '/' behavName = subject + '_tuning_curve_' + tuningBehavior + '.h5' tuningBehavFileName = os.path.join(fullbehaviorDir, behavName) tuning_bdata = loadbehavior.BehaviorData(tuningBehavFileName, readmode='full') freqEachTrial = tuning_bdata['currentFreq'] possibleFreq = np.unique(freqEachTrial) numberOfTrials = len(freqEachTrial) # -- The old way of sorting (useful for plotting sorted raster) -- sortedTrials = [] numTrialsEachFreq = [ ] #Used to plot lines after each group of sorted trials for indf, oneFreq in enumerate( possibleFreq ): #indf is index of this freq and oneFreq is the frequency indsThisFreq = np.flatnonzero( freqEachTrial == oneFreq) #this gives indices of this frequency sortedTrials = np.concatenate( (sortedTrials, indsThisFreq)) #adds all indices to a list called sortedTrials numTrialsEachFreq.append( len(indsThisFreq)) #finds number of trials each frequency has sortingInds = argsort( sortedTrials) #gives array of indices that would sort the sortedTrials # -- Load event data and convert event timestamps to ms -- tuning_ephysDir = os.path.join(settings.EPHYS_PATH, subject, tuningEphys) tuning_eventFilename = os.path.join(tuning_ephysDir, 'all_channels.events') tuning_ev = loadopenephys.Events( tuning_eventFilename) #load ephys data (like bdata structure) tuning_eventTimes = np.array( tuning_ev.timestamps ) / SAMPLING_RATE #get array of timestamps for each event and convert to seconds by dividing by sampling rate (Hz). matches with eventID and tuning_evID = np.array( tuning_ev.eventID ) #loads the onset times of events (matches up with eventID to say if event 1 went on (1) or off (0) tuning_eventOnsetTimes = tuning_eventTimes[ tuning_evID == 1] #array that is a time stamp for when the chosen event happens. #ev.eventChannel woul load array of events like trial start and sound start and finish times (sound event is 0 and trial start is 1 for example). There is only one event though and its sound start while (numberOfTrials < len(tuning_eventOnsetTimes)): tuning_eventOnsetTimes = tuning_eventOnsetTimes[:-1] ####################################################################################################### ###################THIS IS SUCH A HACK TO GET SPKDATA FROM EPHYSCORE################################### ####################################################################################################### thisCell = celldatabase.CellInfo( animalName=subject, ############################################ ephysSession=tuningEphys, tuningSession='DO NOT NEED THIS', tetrode=tetrode, cluster=cluster, quality=1, depth=0, tuningBehavior='DO NOT NEED THIS', behavSession=tuningBehavior) tuning_spkData = ephyscore.CellData(thisCell) tuning_spkTimeStamps = tuning_spkData.spikes.timestamps (tuning_spikeTimesFromEventOnset, tuning_trialIndexForEachSpike, tuning_indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes( tuning_spkTimeStamps, tuning_eventOnsetTimes, tuning_timeRange) #print 'numTrials ',max(tuning_trialIndexForEachSpike)##################################### ''' Create a vector with the spike timestamps w.r.t. events onset. (spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = eventlocked_spiketimes(timeStamps,eventOnsetTimes,timeRange) timeStamps: (np.array) the time of each spike. eventOnsetTimes: (np.array) the time of each instance of the event to lock to. timeRange: (list or np.array) two-element array specifying time-range to extract around event. spikeTimesFromEventOnset: 1D array with time of spikes locked to event. o trialIndexForEachSpike: 1D array with the trial corresponding to each spike. The first spike index is 0. indexLimitsEachTrial: [2,nTrials] range of spikes for each trial. Note that the range is from firstSpike to lastSpike+1 (like in python slices) spikeIndices ''' tuning_sortedIndexForEachSpike = sortingInds[ tuning_trialIndexForEachSpike] #Takes values of trialIndexForEachSpike and finds value of sortingInds at that index and makes array. This array gives an array with the sorted index of each trial for each spike # -- Calculate tuning -- #nSpikes = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,responseRange) #array of the number of spikes in range for each trial '''Count number of spikes on each trial in a given time range. spikeTimesFromEventOnset: vector of spikes timestamps with respect to the onset of the event. indexLimitsEachTrial: each column contains [firstInd,lastInd+1] of the spikes on a trial. timeRange: time range to evaluate. Spike times exactly at the limits are not counted. returns nSpikes ''' ''' meanSpikesEachFrequency = np.empty(len(possibleFreq)) #make empty array of same size as possibleFreq # -- This part will be replace by something like behavioranalysis.find_trials_each_type -- trialsEachFreq = [] for indf,oneFreq in enumerate(possibleFreq): trialsEachFreq.append(np.flatnonzero(freqEachTrial==oneFreq)) #finds indices of each frequency. Appends them to get an array of indices of trials sorted by freq # -- Calculate average firing for each freq -- for indf,oneFreq in enumerate(possibleFreq): meanSpikesEachFrequency[indf] = np.mean(nSpikes[trialsEachFreq[indf]]) ''' #clf() #if (len(tuning_spkTimeStamps)>0): #ax1 = plt.subplot2grid((4,4), (3, 0), colspan=1) #spikesorting.plot_isi_loghist(spkData.spikes.timestamps) #ax3 = plt.subplot2grid((4,4), (3, 3), colspan=1) #spikesorting.plot_events_in_time(tuning_spkTimeStamps) #samples = tuning_spkData.spikes.samples.astype(float)-2**15 #samples = (1000.0/tuning_spkData.spikes.gain[0,0]) *samples #ax2 = plt.subplot2grid((4,4), (3, 1), colspan=2) #spikesorting.plot_waveforms(samples) #ax4 = plt.subplot2grid((4,4), (0, 0), colspan=3,rowspan = 3) plot(tuning_spikeTimesFromEventOnset, tuning_sortedIndexForEachSpike, '.', ms=3) #axvline(x=0, ymin=0, ymax=1, color='r') #The cumulative sum of the list of specific frequency presentations, #used below for plotting the lines across the figure. numTrials = cumsum(numTrialsEachFreq) #Plot the lines across the figure in between each group of sorted trials for indf, num in enumerate(numTrials): ax.axhline(y=num, xmin=0, xmax=1, color='0.90', zorder=0) tickPositions = numTrials - mean(numTrialsEachFreq) / 2 tickLabels = [ "%0.2f" % (possibleFreq[indf] / 1000) for indf in range(len(possibleFreq)) ] ax.set_yticks(tickPositions) ax.set_yticklabels(tickLabels) ax.set_ylim([-1, numberOfTrials]) ylabel('Frequency Presented (kHz), {} total trials'.format(numTrials[-1])) #title(ephysSession+' T{}c{}'.format(tetrodeID,clusterID)) xlabel('Time (sec)') ''' ax5 = plt.subplot2grid((4,4), (0, 3), colspan=1,rowspan=3) ax5.set_xscale('log') plot(possibleFreq,meanSpikesEachFrequency,'o-') ylabel('Avg spikes in window {0}-{1} sec'.format(*responseRange)) xlabel('Frequency') ''' #show() '''
subjects = ['adap021', 'adap023', 'adap028', 'adap029', 'adap035'] #Init array to hold percent correct for 4 saline sessions for each animal percCorrect = np.empty((len(subjects), 4)) for indSubject, subject in enumerate(subjects): datesDict = muscimol_sessions.animals[subject] alldates = [] salinedates = datesDict['saline'] muscimoldates = datesDict['muscimol'] sessions = salinedates for indSession, session in enumerate(sessions): #Load behavior data for the sessioln bfile = loadbehavior.path_to_behavior_data(subject, '2afc', session) bdata = loadbehavior.BehaviorData(bfile) #Compute percent correct for valid trials valid = bdata['valid'] correct = bdata['outcome'] == bdata.labels['outcome']['correct'] validCorrect = (valid & correct) numValid = sum(valid) numCorrect = sum(validCorrect) percCorrect[indSubject, indSession] = (numCorrect / float(numValid)) * 100 #Related-samples t-test between first and last saline day firstSaline = percCorrect[:, 0] lastSaline = percCorrect[:, -1] zVal, pVal = stats.ttest_rel(firstSaline, lastSaline) print "Related sample t-test between percent correct on first and last day, p = {}".format(
def light_discrim_behavior_report(subjects, sessions, outputDir=None): #allPerf(subjects, sessions) allPerf = np.zeros((len(subjects), len(sessions))) upper = np.zeros((len(subjects), len(sessions))) lower = np.zeros((len(subjects), len(sessions))) allPerfRightSide = np.zeros((len(subjects), len(sessions))) allPerfLeftSide = np.zeros((len(subjects), len(sessions))) for indSubject, subject in enumerate(subjects): for indSession, session in enumerate(sessions): bfile = loadbehavior.path_to_behavior_data(subject, 'lightDiscrim', session) bdata = loadbehavior.BehaviorData(bfile) valid = bdata['valid'] correct = bdata['outcome'] == bdata.labels['outcome']['correct'] validCorrect = (valid & correct) numValid = sum(valid) numCorrect = sum(validCorrect) allPerf[indSubject, indSession] = numCorrect / float(numValid) # import ipdb; ipdb.set_trace() ci = proportion_confint(numCorrect, numValid) lower[indSubject, indSession] = ci[0] upper[indSubject, indSession] = ci[1] rightTrials = bdata['rewardSide'] == bdata.labels['rewardSide'][ 'right'] leftTrials = bdata['rewardSide'] == bdata.labels['rewardSide'][ 'left'] correctRight = (validCorrect & rightTrials) correctLeft = (validCorrect & leftTrials) allPerfRightSide[indSubject, indSession] = sum(correctRight) / float( sum(rightTrials)) allPerfLeftSide[indSubject, indSession] = sum(correctLeft) / float( sum(leftTrials)) # plt.figure() plt.clf() for indSubject, subject in enumerate(subjects): plt.subplot(len(subjects), 1, indSubject + 1) thisPerf = allPerf[indSubject, :] plt.plot(100 * thisPerf, 'b-o') upperWhisker = np.array(upper[indSubject, :] - thisPerf) lowerWhisker = np.array(thisPerf - lower[indSubject, :]) plt.errorbar(range(len(thisPerf)), 100 * thisPerf, yerr=[100 * lowerWhisker, 100 * upperWhisker], label='Overall') plt.plot(100 * allPerfLeftSide[indSubject, :], 'r-o', label='Left') plt.plot(100 * allPerfRightSide[indSubject, :], 'g-o', label='Right') plt.ylim([-5, 105]) plt.xlim([-0.1, len(sessions) - 0.9]) plt.title('{}'.format(subject)) plt.ylabel('% correct') plt.axhline(100, color='0.7') plt.axhline(50, color='0.7') plt.axhline(0, color='0.7') plt.legend(loc=8) plt.xlabel('session') plt.show() if outputDir: subjectString = '-'.join(subjects) dateString = '_to_'.join([sessions[0], sessions[-1]]) figName = '{}.png'.format('_'.join([subjectString, dateString])) fullFigPath = os.path.join(outputDir, figName) plt.savefig(fullFigPath)
elif CASE==2: if 1: subjects = ['test011','test012','test013','test014','test015', 'test016','test017','test018','test019','test020'] else: subjects = ['test050','test051','test052','test053','test054', 'test055','test056','test057','test058','test059'] #subjects = ['test019','test020'] #sessions = '20140321a' # No currentBlock sessions = '20140616a' behavior_summary(subjects,sessions,trialslim=[0,1200],outputDir='/tmp/') elif CASE==3: fname=loadbehavior.path_to_behavior_data('test052','santiago','2afc','20140911a') bdata=loadbehavior.BehaviorData(fname) (possibleFreq,pRightEach,ci,nTrialsEach,nRightwardEach) = OLD_calculate_psychometric(bdata, parameterName='targetFrequency') print pRightEach elif CASE==4: allBehavData = load_many_sessions(['test020'],sessions=['20140421a','20140422a','20140423a']) elif CASE==5: param = np.array([7,4,7,5,7,4,7,5,7,4,7,8,8,8]) possibleParam = np.unique(param) tet = find_trials_each_type(param,possibleParam) mask = param>4 tet = tet & mask[:,np.newaxis] print possibleParam print tet elif CASE==6: #parameter1 = np.array([1,2,3,4,5,1,2,3,4,5])
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']) correct = bdata['outcome']==bdata.labels['outcome']['correct']
''' Test corrupted behavior file. ''' from jaratoolbox import loadbehavior filev1 = '/data/behavior/test055/test055_2afc_20150313a.h5' filev2 = '/data/old_behavior_santiago/test055/test055_2afc_20150313a.h5' filev3 = '/mnt/jarahubdata/behavior/test055/test055_2afc_20150313a.h5' bdata = loadbehavior.BehaviorData(filev3)