def tuning_raster(bdata, ephysdata, gs): plt.subplot(gs[0, 1]) freqEachTrial = bdata['currentFreq'] eventOnsetTimes = ephysData['events']['stimOn'] spikeTimeStamps = ephysData['spikeTimes'] timeRange = [-0.3, 0.6] possiblefreqs = np.unique(freqEachTrial) freqLabels = [round(x / 1000, 1) for x in possiblefreqs] trialsEachCond = behavioranalysis.find_trials_each_type( freqEachTrial, possiblefreqs) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, timeRange) #print len(freqEachTrial), len(eventOnsetTimes) pRaster, hcond, zline = extraplots.raster_plot( spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsEachCond, labels=freqLabels) xlabel = 'time (s)' ylabel = 'Frequency (kHz)' plt.title('Tuning Curve') plt.xlabel(xlabel) plt.ylabel(ylabel) '''
def plot_ave_psycurve_reward_change(animal, sessions): FREQCOLORS = [colorpalette.TangoPalette['Chameleon3'], colorpalette.TangoPalette['ScarletRed1'], colorpalette.TangoPalette['SkyBlue2']] allBehavDataThisAnimal = behavioranalysis.load_many_sessions(animal,sessions) targetFrequency = allBehavDataThisAnimal['targetFrequency'] choice=allBehavDataThisAnimal['choice'] valid=allBehavDataThisAnimal['valid']& (choice!=allBehavDataThisAnimal.labels['choice']['none']) choiceRight = choice==allBehavDataThisAnimal.labels['choice']['right'] currentBlock = allBehavDataThisAnimal['currentBlock'] blockTypes = [allBehavDataThisAnimal.labels['currentBlock']['same_reward'],allBehavDataThisAnimal.labels['currentBlock']['more_left'],allBehavDataThisAnimal.labels['currentBlock']['more_right']] #blockTypes = [allBehavDataThisAnimal.labels['currentBlock']['more_left'],allBehavDataThisAnimal.labels['currentBlock']['more_right']] blockLabels = ['same_reward','more_left','more_right'] #blockLabels = ['more_left','more_right'] trialsEachType = behavioranalysis.find_trials_each_type(currentBlock,blockTypes) nFreqs = len(np.unique(targetFrequency)) print '{}, freqs: {}'.format(animal, str(np.unique(targetFrequency))) #print trialsEachType nBlocks = len(blockTypes) #thisAnimalPos = inda #ax1=plt.subplot(gs[thisAnimalPos]) #plt.clf() fontsize = 12 allPline = [] blockLegends = [] fractionHitsEachValueAllBlocks = np.empty((nBlocks,nFreqs)) for blockType in range(nBlocks): if np.any(trialsEachType[:,blockType]): targetFrequencyThisBlock = targetFrequency[trialsEachType[:,blockType]] validThisBlock = valid[trialsEachType[:,blockType]] choiceRightThisBlock = choiceRight[trialsEachType[:,blockType]] #currentBlockValue = currentBlock[trialsEachBlock[0,block]] (possibleValues,fractionHitsEachValue,ciHitsEachValue,nTrialsEachValue,nHitsEachValue)=\ behavioranalysis.calculate_psychometric(choiceRightThisBlock,targetFrequencyThisBlock,validThisBlock) fractionHitsEachValueAllBlocks[blockType,:] = fractionHitsEachValue (pline, pcaps, pbars, pdots) = extraplots.plot_psychometric(1e-3*possibleValues,fractionHitsEachValue, ciHitsEachValue,xTickPeriod=1) plt.setp((pline, pcaps, pbars), color=FREQCOLORS[blockType]) plt.setp(pdots, mfc=FREQCOLORS[blockType], mec=FREQCOLORS[blockType]) allPline.append(pline) blockLegends.append(blockLabels[blockType]) if blockType == nBlocks-1: plt.xlabel('Frequency (kHz)',fontsize=fontsize) plt.ylabel('Rightward trials (%)',fontsize=fontsize) extraplots.set_ticks_fontsize(plt.gca(),fontsize) legend = plt.legend(allPline,blockLegends,loc=2) # Add the legend manually to the current Axes. ax = plt.gca().add_artist(legend) #plt.hold(True) #plt.legend(bbox_to_anchor=(1, 1), bbox_transform=plt.gcf().transFigure) #plt.show() plt.title('%s_%sto%s'%(animal,sessions[0],sessions[-1])) return fractionHitsEachValueAllBlocks
def plot_sorted_raster(spikeTimeStamps, eventOnsetTimes, sortArray, timeRange=[-0.5, 1], xlabel='Time from sound onset (sec)', ylabel='Frequency (kHz)', ms=4, labels=None, *args, **kwargs): ''' Function to accept spike timestamps, event onset times, and a sorting array and plot a raster plot sorted by the array passed Args: sortarray (array): An array of parameter values for each trial. Output will be sorted by the possible values of the parameter. Must be the same length as the event onset times array ''' trialsEachCond = behavioranalysis.find_trials_each_type( sortArray, np.unique(sortArray)) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, timeRange) pRaster, hcond, zline = extraplots.raster_plot( spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsEachCond, labels=labels, *args, **kwargs) plt.xlabel(xlabel) plt.ylabel(ylabel) plt.setp(pRaster, ms=ms)
def tuning_raster(bdata, ephysdata, gs): plt.subplot(gs[0, 1]) freqEachTrial = bdata['currentFreq'] eventOnsetTimes = ephysData['events']['stimOn'] spikeTimeStamps = ephysData['spikeTimes'] timeRange = [-0.3, 0.6] possiblefreqs = np.unique(freqEachTrial) freqLabels = [round(x/1000, 1) for x in possiblefreqs] trialsEachCond = behavioranalysis.find_trials_each_type(freqEachTrial, possiblefreqs) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, timeRange) #print len(freqEachTrial), len(eventOnsetTimes) pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange, trialsEachCond=trialsEachCond, labels=freqLabels) xlabel = 'time (s)' ylabel = 'Frequency (kHz)' plt.title('Tuning Curve') plt.xlabel(xlabel) plt.ylabel(ylabel) '''
def plot_sorted_psth(spikeTimeStamps, eventOnsetTimes, sortArray, timeRange=[-0.5,1], binsize = 50, lw=2, plotLegend=False, *args, **kwargs): ''' Function to accept spike timestamps, event onset times, and a sorting array and plot a PSTH sorted by the sorting array Args: binsize (float) = size of bins for PSTH in ms ''' binsize = binsize/1000.0 # If a sort array is supplied, find the trials that correspond to each value of the array if len(sortArray) > 0: trialsEachCond = behavioranalysis.find_trials_each_type( sortArray, np.unique(sortArray)) else: trialsEachCond = [] # Align spiketimestamps to the event onset times for plotting spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, [timeRange[0]-binsize, timeRange[1]]) binEdges = np.around(np.arange(timeRange[0]-binsize, timeRange[1]+2*binsize, binsize), decimals=2) spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges) pPSTH = extraplots.plot_psth(spikeCountMat/binsize, 1, binEdges[:-1], trialsEachCond, *args, **kwargs) plt.setp(pPSTH, lw=lw) plt.hold(True) zline = plt.axvline(0,color='0.75',zorder=-10) plt.xlim(timeRange) if plotLegend: if len(sortArray)>0: sortElems = np.unique(sortArray) for ind, pln in enumerate(pPSTH): pln.set_label(sortElems[ind]) # ax = plt.gca() # plt.legend(mode='expand', ncol=3, loc='best') plt.legend(ncol=3, loc='best')
def plot_raster(self, spikeTimestamps, eventOnsetTimes, sortArray = [], replace = 0, timeRange = [-0.5, 1], ms = 4): ''' Plot a raster given spike timestamps and event onset times This method will take the spike timestamps directly, convert them so that they are relative to the event onset times, and then call the appropriate plotting code. This method should ideally be able to handle making both sortArrayed and unsortArrayed rasters. sortArray (array): An array of parameter values for each trial. Output will be sorted by the possible values of the parameter ''' if len(sortArray)>0: trialsEachCond = behavioranalysis.find_trials_each_type(sortArray, np.unique(sortArray)) else: trialsEachCond = [] spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(spikeTimestamps,eventOnsetTimes,timeRange) #pdb.set_trace() if replace: #Now using cla() so that it will work with subplots cla() #else: # figure() pRaster,hcond,zline = extraplots.raster_plot(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond = trialsEachCond) setp(pRaster,ms=ms)
def best_window_freq_tuning(spikeTimesFromEventOnset, indexLimitsEachTrial, freqEachTrial): windowsToTry = [[0.0, 0.1], [0.0, 0.05], [0.1, 0.15]] numFreqs = np.unique(freqEachTrial) zscores = np.zeros((len(windowsToTry), len(numFreqs))) for ind, window in enumerate(windowsToTry): duration = window[1] - window[0] baseTimeRange = [-0.1 - duration, -0.1] spikeCountMat = spikesanalysis.spiketimes_to_spikecounts( spikeTimesFromEventOnset, indexLimitsEachTrial, window) baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts( spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange) trialsEachFreq = behavioranalysis.find_trials_each_type( freqEachTrial, numFreqs) for ind2 in range(len(numFreqs)): trialsThisFreq = trialsEachFreq[:, ind2] spikeCountsThisFreq = spikeCountMat[trialsThisFreq] baseCountsThisFreq = baseSpikeCountMat[trialsThisFreq] zScore, pVal = stats.ranksums(spikeCountsThisFreq, baseCountsThisFreq) zscores[ind, ind2] = zScore maxInd = np.unravel_index(zscores.argmax(), zscores.shape) windowToUse = windowsToTry[maxInd[0]] spikeCountMat = spikesanalysis.spiketimes_to_spikecounts( spikeTimesFromEventOnset, indexLimitsEachTrial, windowToUse) return spikeCountMat, windowToUse
def highest_significant_sync(cell): try: sessiontypeIndex = cell['sessiontype'].index(defaultAMtype) except ValueError: #The cell does not have this session type return None #Initialize a data loader for this animal loader = dataloader.DataLoader(cell['subject']) #Get the behavior data behavData = loader.get_session_behavior(cell['behavior'][sessiontypeIndex]) freqEachTrial = behavData['currentFreq'] possibleFreq = np.unique(freqEachTrial) ephysDir = cell['ephys'][sessiontypeIndex] clusterSpikeData = loader.get_session_spikes(ephysDir, int(cell['tetrode']), cluster=int(cell['cluster'])) clusterSpikeTimes = clusterSpikeData.timestamps #Get the events for this session and calculate onset times eventData = loader.get_session_events(ephysDir) eventOnsetTimes = loader.get_event_onset_times(eventData, minEventOnsetDiff=None) timeRange = [0, 0.5] trialsEachCond = behavioranalysis.find_trials_each_type( freqEachTrial, possibleFreq) vs_array, pval_array, ral_array = AM_vector_strength( clusterSpikeTimes, eventOnsetTimes, behavData, timeRange) if np.any(pval_array < 0.05): highestSync = np.max(possibleFreq[pval_array < 0.05]) else: highestSync = 0 return highestSync
def at_best_freq(spikeTimeStamps, eventOnsetTimes, charFreq, frequencies, timeRange=[0.0,0.1], fullRange = [0.0, 0.7]): atBestFreq = False numFreqs = np.unique(frequencies) spikeArray = np.zeros(len(numFreqs)) trialsEachCond = behavioranalysis.find_trials_each_type(frequencies, numFreqs) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, fullRange) spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange) baseTimeRange = [timeRange[1]+0.2, fullRange[1]] baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange) baselineSpikeRate = np.mean(baseSpikeCountMat)/(baseTimeRange[1]-baseTimeRange[0]) baselineSpikeSDev = np.std(baseSpikeCountMat)/(baseTimeRange[1]-baseTimeRange[0]) for freq in range(len(numFreqs)): trialsThisFreq = trialsEachCond[:,freq] if spikeCountMat.shape[0] != len(trialsThisFreq): spikeCountMat = spikeCountMat[:-1,:] print "FIXME: Using bad hack to make event onset times equal number of trials" thisFreqCounts = spikeCountMat[trialsThisFreq].flatten() spikeArray[freq] = np.mean(thisFreqCounts)/(timeRange[1]-timeRange[0]) bestFreqIndex = np.argmax(spikeArray) bestFreq = numFreqs[bestFreqIndex] minIndex = bestFreqIndex-1 if bestFreqIndex>0 else 0 maxIndex = bestFreqIndex+1 if bestFreqIndex<(len(numFreqs)-1) else len(numFreqs)-1 bestFreqs = [numFreqs[minIndex], numFreqs[maxIndex]] if charFreq >= bestFreqs[0] and charFreq <= bestFreqs[1]: if np.max(spikeArray) > (baselineSpikeRate + baselineSpikeSDev): atBestFreq = True return atBestFreq, bestFreq
def freq_tuning_fit(eventOnsetTimes, spikeTimestamps, bdata, timeRange = [-0.2, 0.2], intensityInds = None): # determine the best frequency of the cell by fitting gaussian curve to tuning data gaussFits = [] bestFreqs = [] Rsquareds = [] freqEachTrial = bdata['currentFreq'] intensityEachTrial = bdata['currentIntensity'] numIntensities = np.unique(intensityEachTrial) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimestamps, eventOnsetTimes, timeRange) trialsEachInt = behavioranalysis.find_trials_each_type(intensityEachTrial, numIntensities) if intensityInds is None: intensityInds = range(len(numIntensities)) spikeCountMat, window = best_window_freq_tuning(spikeTimesFromEventOnset, indexLimitsEachTrial, freqEachTrial) for intensityInd in intensityInds: trialsThisIntensity = trialsEachInt[:,intensityInd] tuningSpikeRates = (spikeCountMat[trialsThisIntensity].flatten())/(window[1]-window[0]) freqsThisIntensity = freqEachTrial[trialsThisIntensity] gaussFit, Rsquared = response_curve_fit(np.log2(freqsThisIntensity), tuningSpikeRates) bestFreq = 2**gaussFit[0] if gaussFit is not None else None gaussFits.append(gaussFit) bestFreqs.append(bestFreq) Rsquareds.append(Rsquared) return gaussFits, bestFreqs, Rsquareds, window
def plot_example(subplotSpec, exampleName): # lowFreq = 4 # highFreq = 128 # nFreqLabels = 3 # freqs = np.logspace(np.log10(lowFreq),np.log10(highFreq),nFreqLabels) # freqs = np.round(freqs, decimals=1) spikeTimes = exampleSpikeTimes[exampleName] indexLimitsEachTrial = exampleIndexLimitsEachTrial[exampleName] timeRange = [-0.2, 0.7] freqEachTrial = exampleFreqEachTrial[exampleName] possibleFreq = np.unique(freqEachTrial) freqLabels = ['{0:.1f}'.format(freq) for freq in possibleFreq] trialsEachCondition = behavioranalysis.find_trials_each_type( freqEachTrial, possibleFreq) pRaster, hCond, zline = extraplots.raster_plot(spikeTimes, indexLimitsEachTrial, timeRange, trialsEachCondition, labels=freqLabels) ax = plt.gca() ax.set_xticks([0, 0.5]) ax.set_xlabel('Time from sound onset (s)') ax.set_ylabel('AM Rate (Hz)') # ax.set_yticks(freqs) # ax.set_yticklabels(freqs) plt.setp(pRaster, ms=2)
def plot_raster(self, spikeTimestamps, eventOnsetTimes, sortArray = [], replace = 0, timeRange = [-0.5, 1], ms = 4): ''' Plot a raster given spike timestamps and event onset times This method will take the spike timestamps directly, convert them so that they are relative to the event onset times, and then call the appropriate plotting code. This method should ideally be able to handle making both sortArrayed and unsortArrayed rasters. sortArray (array): An array of parameter values for each trial. Output will be sorted by the possible values of the parameter ''' if len(sortArray)>0: trialsEachCond = behavioranalysis.find_trials_each_type(sortArray, np.unique(sortArray)) else: trialsEachCond = [] spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(spikeTimestamps,eventOnsetTimes,timeRange) #pdb.set_trace() if replace: #Now using cla() so that it will work with subplots cla() #else: # figure() pRaster,hcond,zline = extraplots.raster_plot(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond = trialsEachCond) setp(pRaster,ms=ms)
def tuning_test_raster(bdata, ephysData, gs): plt.subplot(gs[11:15, 0]) freqEachTrial = bdata['currentFreq'] eventOnsetTimes = ephysData['events']['stimOn'] spikeTimeStamps = ephysData['spikeTimes'] timeRange = [-0.3, 0.6] baseTimeRange = [-0.15, -0.05] possiblefreqs = np.unique(freqEachTrial) freqLabels = [round(x / 1000, 1) for x in possiblefreqs] trialsEachCond = behavioranalysis.find_trials_each_type( freqEachTrial, possiblefreqs) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, timeRange) #print len(freqEachTrial), len(eventOnsetTimes) baseSpikeMat = spikesanalysis.spiketimes_to_spikecounts( spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange) base_avg = np.mean(baseSpikeMat) / (baseTimeRange[1] - baseTimeRange[0]) base_sem = stats.sem(baseSpikeMat) / (baseTimeRange[1] - baseTimeRange[0]) # for freqInd, freq in enumerate(possiblefreqs): # freq_spikecounts = spikeMat[trialsEachCond[:,freqInd]==True] # freq_avg = np.mean(freq_spikecounts) / (soundTimeRange[1] - soundTimeRange[0]) # freq_avgs.append(freq_avg) ''' try: base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, baseIndexLimitsEachTrial) except: behavBaseIndexLimitsEachTrial = baseIndexLimitsEachTrial[0:2,:-1] base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, behavBaseIndexLimitsEachTrial) base_avg = np.mean(base_avgs) base_frs = np.divide(base_avg, baseTimeRange[1] - baseTimeRange[0]) #print(base_avg) ''' title = "Tuning Test (Base FR: {} +/- {} spikes/s)".format( round(base_avg, 2), round(base_sem, 2)) #title = "Tuning Curve (Base FR: {} spikes/s)".format(round(base_avg, 2)) pRaster, hcond, zline = extraplots.raster_plot( spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsEachCond, labels=freqLabels) xlabel = 'Time from sound onset (s)' ylabel = 'Frequency (kHz)' plt.title(title, fontsize='medium') plt.xlabel(xlabel) plt.ylabel(ylabel) '''
def one_axis_tc_or_rlf(spikeTimestamps, eventOnsetTimes, sortArray, timeRange=[0, 0.1]): trialsEachCond = behavioranalysis.find_trials_each_type( sortArray, np.unique(sortArray)) spikeArray = avg_spikes_in_event_locked_timerange_each_cond( spikeTimestamps, trialsEachCond, eventOnsetTimes, timeRange) plt.plot(spikeArray, ls='-', lw=2, c='0.25')
def one_axis_tc_or_rlf(spikeTimestamps, eventOnsetTimes, sortArray, timeRange=[0, 0.1]): trialsEachCond = behavioranalysis.find_trials_each_type( sortArray, np.unique(sortArray)) spikeArray = avg_spikes_in_event_locked_timerange_each_cond( spikeTimestamps, trialsEachCond, eventOnsetTimes, timeRange) plt.plot(spikeArray, ls='-', lw=2, c='0.25')
def plot_tuning_raster(animal, ephysSession, behavSession, tetrode, cluster, intensity=50, timeRange = [-0.5,1]): ''' Function to plot a tuning raster sorted by frequency. :param arg1: A string of the file name of the tuning curve ephys session, this is the full filename, in {date}_XX-XX-XX format. :param arg2: A string of the file name of the tuning curve behavior session, this is the full filename in '{animal}_{paradigm}_{date}{behavsuffix}.h5' format. :param arg3: An int in range(1,9) for tetrode number. :param arg4: An int for cluster number. :param arg5: An int for the intensity in (dB) to plot, default is 50(dB), which is the stimulus intensity used in 2afc task. :param arg6: A list of floats for the start and the end of the time period around sound-onset to plot raster. ''' bdata = load_behavior_basic(animal,behavSession) spikeData = load_spike_data(animal, ephysSession, tetrode, cluster) spikeTimestamps = spikeData.timestamps eventData = load_event_data(animal, ephysSession) eventOnsetTimes = np.array(eventData.timestamps) soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel) eventOnsetTimes = eventOnsetTimes[soundOnsetEvents] freqEachTrial = bdata['currentFreq'] intensityEachTrial = bdata['currentIntensity'] possibleFreq = np.unique(freqEachTrial) possibleIntensity = np.unique(intensityEachTrial) if len(possibleIntensity) != 1: intensity = intensity ###Just select the trials with a given intensity### trialsThisIntensity = [intensityEachTrial==intensity] freqEachTrial = freqEachTrial[trialsThisIntensity] intensityEachTrial = intensityEachTrial[trialsThisIntensity] eventOnsetTimes = eventOnsetTimes[trialsThisIntensity] #print len(intensityEachTrial),len(eventOnsetTimes),len(spikeTimestamps) freqLabels = ['{0:.1f}'.format(freq/1000.0) for freq in possibleFreq] #intensityLabels = ['{:.0f} dB'.format(intensity) for intensity in possibleIntensity] ### FIXME: this is a bad hack for when ephys is one trial more than behavior file ### if len(eventOnsetTimes)==len(intensityEachTrial)+1: eventOnsetTimes=eventOnsetTimes[:-1] #print len(intensityEachTrial),len(eventOnsetTimes),len(spikeTimestamps) trialsEachFreq = behavioranalysis.find_trials_each_type(freqEachTrial,possibleFreq) (spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \ spikesanalysis.eventlocked_spiketimes(spikeTimestamps,eventOnsetTimes,timeRange) pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsEachFreq, labels=freqLabels) plt.xlabel('Time from sound onset') plt.xlim(timeRange[0]+0.1,timeRange[1]) plotTitle = 'Tt'+str(tetrode)+'c'+str(cluster)+' tuning with 50dB chords' plt.title(plotTitle,fontsize=10)
def plot_tuning_raster(cellObj, sessionType='tc', intensity=50, timeRange = [-0.5,1]): ''' Function to plot a tuning raster sorted by frequency. :param arg1: Cell object from ephyscore. :param arg2: A string for the session type, for tuning it should be 'tc'. :param arg3: An int for the intensity in (dB) to plot, default is 50(dB), which is the stimulus intensity used in 2afc task. :param arg4: A list of floats for the start and the end of the time period around sound-onset to plot raster. ''' sessionInd = cellObj.get_session_inds(sessionType)[0] bdata = cellObj.load_behavior_by_index(sessionInd) ephysData = cellObj.load_ephys_by_index(sessionInd) eventsDict = ephysData['events'] spikeTimestamps = ephysData['spikeTimes'] soundOnsetTimes = eventsDict['{}On'.format(soundChannelType)] freqEachTrial = bdata['currentFreq'] intensityEachTrial = bdata['currentIntensity'] possibleFreq = np.unique(freqEachTrial) possibleIntensity = np.unique(intensityEachTrial) if len(possibleIntensity) != 1: intensity = intensity ###Just select the trials with a given intensity### trialsThisIntensity = [intensityEachTrial==intensity] freqEachTrial = freqEachTrial[trialsThisIntensity] intensityEachTrial = intensityEachTrial[trialsThisIntensity] soundOnsetTimes = soundOnsetTimes[trialsThisIntensity] #print len(intensityEachTrial),len(eventOnsetTimes),len(spikeTimestamps) freqLabels = ['{0:.1f}'.format(freq/1000.0) for freq in possibleFreq] #intensityLabels = ['{:.0f} dB'.format(intensity) for intensity in possibleIntensity] ### FIXME: this is a bad hack for when ephys is one trial more than behavior file ### if len(soundOnsetTimes)==len(freqEachTrial)+1: soundOnsetTimes=soundOnsetTimes[:-1] print('Tuning behavior is one trial less than ephys!') ### FIXME: this is a bad hack for when behavior is one trial more than ephys file ### if len(soundOnsetTimes)==len(freqEachTrial)-1: freqEachTrial=freqEachTrial[:-1] print('Tuning behavior is one trial more than ephys!') #print len(freqEachTrial),len(eventOnsetTimes),len(spikeTimestamps) trialsEachFreq = behavioranalysis.find_trials_each_type(freqEachTrial,possibleFreq) (spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \ spikesanalysis.eventlocked_spiketimes(spikeTimestamps,soundOnsetTimes,timeRange) pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsEachFreq, labels=freqLabels) plt.xlabel('Time from sound onset') plt.xlim(timeRange[0]+0.1,timeRange[1]) plotTitle = 'tuning with 50dB chords' plt.title(plotTitle,fontsize=10)
def plot_bandwidth_noise_amps_comparison(cell, bandIndex=None): cellInfo = get_cell_info(cell) loader = dataloader.DataLoader(cell['subject']) if bandIndex is None: try: bandIndex = cellInfo['bandIndex'][0] except IndexError: print 'no bandwidth session' pass plt.clf() gs = gridspec.GridSpec(1, 2) eventData = loader.get_session_events(cellInfo['ephysDirs'][bandIndex]) spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][bandIndex], cellInfo['tetrode'], cluster=cellInfo['cluster']) eventOnsetTimes = loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.2, 1.5] bandBData = loader.get_session_behavior(cellInfo['behavDirs'][bandIndex]) bandEachTrial = bandBData['currentBand'] secondSort = bandBData['currentAmp'] secondSortLabels = ['{} dB'.format(amp) for amp in np.unique(secondSort)] plt.subplot(gs[0,0]) spikeArray, errorArray, baseSpikeRate = band_select(spikeTimestamps, eventOnsetTimes, secondSort, bandEachTrial, timeRange = [0.0, 1.0]) spikeArray = spikeArray[:,-1].reshape((7,1)) errorArray = errorArray[:,-1].reshape((7,1)) band_select_plot(spikeArray, errorArray, np.unique(bandEachTrial), linecolours=['0.25'], errorcolours=['0.6']) plt.title('Bandwidth tuning') ampsBData = loader.get_session_behavior(cellInfo['behavDirs'][cellInfo['ampsIndex'][-1]]) ampEachTrial = ampsBData['currentIntensity'] eventData = loader.get_session_events(cellInfo['ephysDirs'][cellInfo['ampsIndex'][-1]]) spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][cellInfo['ampsIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster']) eventOnsetTimes = loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.2, 1.0] spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimestamps, eventOnsetTimes, timeRange) numRates = np.unique(ampEachTrial) trialsEachCond = behavioranalysis.find_trials_each_type(ampEachTrial, numRates) plt.subplot(gs[0,1]) spikeArray, errorArray, baseSpikeRate = band_select(spikeTimestamps, eventOnsetTimes, ampsBData['currentFreq'], ampEachTrial, timeRange = [0.0, 0.5]) band_select_plot(spikeArray, errorArray, np.unique(ampEachTrial), linecolours=['0.25'], errorcolours=['0.6']) plt.xlabel('white noise intensity (dB)') plt.ylabel('Average num spikes') plt.title('Intensity tuning') fig_path = '/home/jarauser/Pictures/cell reports' fig_name = '{0}_{1}_{2}um_TT{3}Cluster{4}_noiseAmps.png'.format(cellInfo['subject'], cellInfo['date'], cellInfo['depth'], cellInfo['tetrode'], cellInfo['cluster']) full_fig_path = os.path.join(fig_path, fig_name) fig = plt.gcf() fig.set_size_inches(9, 4) fig.savefig(full_fig_path, format = 'png', bbox_inches='tight')
def am_raster(bdata, ephysData, gs): plt.subplot(gs[1, 1]) freqEachTrial = bdata['currentFreq'] eventOnsetTimes = ephysData['events']['stimOn'] spikeTimeStamps = ephysData['spikeTimes'] timeRange = [-0.3, 0.6] baseTimeRange = [-0.15, -0.05] possiblefreqs = np.unique(freqEachTrial) freqLabels = [round(x/1000, 1) for x in possiblefreqs] trialsEachCond = behavioranalysis.find_trials_each_type(freqEachTrial, possiblefreqs) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, timeRange) #print len(freqEachTrial), len(eventOnsetTimes) baseSpikeMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange) base_avg = np.mean(baseSpikeMat) / (baseTimeRange[1] - baseTimeRange[0]) base_sem = stats.sem(baseSpikeMat) / (baseTimeRange[1] - baseTimeRange[0]) # for freqInd, freq in enumerate(possiblefreqs): # freq_spikecounts = spikeMat[trialsEachCond[:,freqInd]==True] # freq_avg = np.mean(freq_spikecounts) / (soundTimeRange[1] - soundTimeRange[0]) # freq_avgs.append(freq_avg) ''' try: base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, baseIndexLimitsEachTrial) except: behavBaseIndexLimitsEachTrial = baseIndexLimitsEachTrial[0:2,:-1] base_avgs = spikesanalysis.avg_num_spikes_each_condition(trialsEachCond, behavBaseIndexLimitsEachTrial) base_avg = np.mean(base_avgs) base_frs = np.divide(base_avg, baseTimeRange[1] - baseTimeRange[0]) #print(base_avg) ''' title = "Tuning Curve (Base FR: {} +/- {} spikes/s)".format(round(base_avg, 2), round(base_sem, 2)) #title = "Tuning Curve (Base FR: {} spikes/s)".format(round(base_avg, 2)) pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange, trialsEachCond=trialsEachCond, labels=freqLabels) xlabel = 'Time from sound onset (s)' ylabel = 'Frequency (kHz)' plt.title(title, fontsize = 'medium') plt.xlabel(xlabel) plt.ylabel(ylabel) '''
def find_trials_each_combination_three_params(parameter1,parameterPossibleValues1,parameter2,parameterPossibleValues2,parameter3,parameterPossibleValues3): ''' Returns a boolean 4D array of size [nTrials,nValues1,nValues2,nValues3]. True for each combination. ''' if len(parameter1)!=len(parameter2): raise ValueError('parameters must be vectors of same size.') nTrials = len(parameter1) nValues1 = len(parameterPossibleValues1) nValues2 = len(parameterPossibleValues2) nValues3 = len(parameterPossibleValues3) trialsEachComb = np.zeros((nTrials,nValues1,nValues2,nValues3),dtype=bool) trialsEachComb12 = behavioranalysis.find_trials_each_combination(parameter1, parameterPossibleValues1, parameter2, parameterPossibleValues2) trialsEachType3 = behavioranalysis.find_trials_each_type(parameter3,parameterPossibleValues3) for ind3 in range(nValues3): trialsEachComb[:,:,:,ind3] = trialsEachComb12 & trialsEachType3[:,ind3][:,np.newaxis,np.newaxis] return trialsEachComb
def plot_sorted_psth(spikeTimeStamps, eventOnsetTimes, sortArray, timeRange=[-0.5, 1], binsize=50, lw=2, plotLegend=False, *args, **kwargs): ''' Function to accept spike timestamps, event onset times, and a sorting array and plot a PSTH sorted by the sorting array Args: binsize (float) = size of bins for PSTH in ms ''' binsize = binsize / 1000.0 # If a sort array is supplied, find the trials that correspond to each value of the array if len(sortArray) > 0: trialsEachCond = behavioranalysis.find_trials_each_type( sortArray, np.unique(sortArray)) else: trialsEachCond = [] # Align spiketimestamps to the event onset times for plotting spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, [timeRange[0] - binsize, timeRange[1]]) binEdges = np.around(np.arange(timeRange[0] - binsize, timeRange[1] + 2 * binsize, binsize), decimals=2) spikeCountMat = spikesanalysis.spiketimes_to_spikecounts( spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges) pPSTH = extraplots.plot_psth(spikeCountMat / binsize, 1, binEdges[:-1], trialsEachCond, *args, **kwargs) plt.setp(pPSTH, lw=lw) plt.hold(True) zline = plt.axvline(0, color='0.75', zorder=-10) plt.xlim(timeRange) if plotLegend: if len(sortArray) > 0: sortElems = np.unique(sortArray) for ind, pln in enumerate(pPSTH): pln.set_label(sortElems[ind]) # ax = plt.gca() # plt.legend(mode='expand', ncol=3, loc='best') plt.legend(ncol=3, loc='best')
def am_dependence(spikesEachTrial, rateEachTrial): ''' Calculate the average firing rate of a cell during the 0.5sec AM sound. Perform a linear regression on average firing rate and AM rate, and return the correlation coefficient for the regression. ''' try: sessiontypeIndex = cell['sessiontype'].index(defaultAMtype) except ValueError: #The cell does not have this session type return None #Initialize a data loader for this animal loader = dataloader.DataLoader(cell['subject']) #Get the behavior data behavData = loader.get_session_behavior(cell['behavior'][sessiontypeIndex]) freqEachTrial = behavData['currentFreq'] possibleFreq = np.unique(freqEachTrial) ephysDir = cell['ephys'][sessiontypeIndex] clusterSpikeData = loader.get_session_spikes(ephysDir, int(cell['tetrode']), cluster=int(cell['cluster'])) clusterSpikeTimes = clusterSpikeData.timestamps #Get the events for this session and calculate onset times eventData = loader.get_session_events(ephysDir) eventOnsetTimes = loader.get_event_onset_times(eventData, minEventOnsetDiff=None) timeRange = [0, 0.5] trialsEachCond = behavioranalysis.find_trials_each_type( freqEachTrial, possibleFreq) spikeArray = dataplotter.avg_spikes_in_event_locked_timerange_each_cond( clusterSpikeTimes, trialsEachCond, eventOnsetTimes, timeRange) slope, intercept, r_value, p_value, std_err = stats.linregress( spikeArray, possibleFreq) if not frArray: return r_value else: return r_value, spikeArray, possibleFreq
def band_psychometric(animal, sessions, trialTypes=['currentSNR']): ''' Produces the number of valid trials and number of trials where animal went to the right for each condition. Can sort by up to three parameters. Input: animal = name of animal whose behaviour is to be used (string) sessions = file names of sessions to be used (list of strings) trialTypes = names of parameters in behavData to be used for sorting trials (list of strings, up to 3 parameters) Output: validPerCond = 1D to 3D array (depending on number of parameters given) giving number of valid trials for each condition rightPerCond = like validPerCond, only trials where animal went to the right possibleParams = possible values each parameter takes ''' behavData = behavioranalysis.load_many_sessions(animal, sessions) firstSort = behavData[trialTypes[0]] possibleFirstSort = np.unique(firstSort) possibleSecondSort = None possibleThirdSort = None if len(trialTypes) > 1: secondSort = behavData[trialTypes[1]] possibleSecondSort = np.unique(secondSort) if len(trialTypes) > 2: thirdSort = behavData[trialTypes[2]] possibleThirdSort = np.unique(thirdSort) valid = behavData['valid'].astype(bool) rightChoice = behavData['choice']==behavData.labels['choice']['right'] if len(trialTypes) == 3: trialsEachComb = find_trials_each_combination_three_params(firstSort, possibleFirstSort, secondSort, possibleSecondSort, thirdSort, possibleThirdSort) elif len(trialTypes) == 2: trialsEachComb = behavioranalysis.find_trials_each_combination(firstSort, possibleFirstSort, secondSort, possibleSecondSort) elif len(trialTypes) == 1: trialsEachComb = behavioranalysis.find_trials_each_type(firstSort, possibleFirstSort) validPerCond, rightPerCond = compute_psychometric_inputs(valid, rightChoice, trialsEachComb) possibleParams = [possibleFirstSort, possibleSecondSort, possibleThirdSort] possibleParams = [param for param in possibleParams if param is not None] return validPerCond, rightPerCond, possibleParams
def plot_raster(spikeTimestamps, eventOnsetTimes, sortArray = [], timeRange = [-0.5, 1], ms = 4, labels=None): ''' Args: sortarray (array): an array of parameter values for each trial. output will be sorted by the possible values of the parameter. Must be the same length as the event onset times array ''' if len(sortArray)>0: trialsEachCond = behavioranalysis.find_trials_each_type(sortArray, np.unique(sortArray)) if not labels: labels=['%.1f' % f for f in np.unique(sortArray)] else: trialsEachCond = [] spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(spikeTimestamps,eventOnsetTimes,timeRange) pRaster,hcond,zline = extraplots.raster_plot(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond = trialsEachCond, labels=labels) plt.setp(pRaster,ms=ms)
def plot_raster(spikeTimestamps, eventOnsetTimes, sortArray=[], timeRange=[-0.5, 1], ms=4, labels=None, *args, **kwargs): ''' Function to accept spike timestamps, event onset times, and an optional sorting array and plot a raster plot (sorted if the sorting array is passed) This function does not replicate functionality. It allows you to pass spike timestamps and event onset times, which are simple to get, as well as an array of any values that can be used to sort the raster. This function wraps three other good functions and provides a way to use them easily Args: sortarray (array): An array of parameter values for each trial. Output will be sorted by the possible values of the parameter. Must be the same length as the event onset times array ''' # If a sort array is supplied, find the trials that correspond to each value of the array if len(sortArray) > 0: trialsEachCond = behavioranalysis.find_trials_each_type( sortArray, np.unique(sortArray)) if not labels: labels = ['%.1f' % f for f in np.unique(sortArray)] else: trialsEachCond = [] # Align spiketimestamps to the event onset times for plotting spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimestamps, eventOnsetTimes, timeRange) #Plot the raster, which will sort if trialsEachCond is supplied pRaster, hcond, zline = extraplots.raster_plot( spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsEachCond, labels=labels, *args, **kwargs) #Set the marker size for better viewing plt.setp(pRaster, ms=ms)
def am_example(cell, timeRange=[-0.2, 0.7]): #Plot histograms of spikes relative to stimulus period? plotCycleHists = False spikeData, eventData = celldatabase.get_session_ephys(cell, 'am') eventOnsetTimes = eventData.get_event_onset_times(eventID=1, eventChannel=0) eventOnsetTimes = spikesanalysis.minimum_event_onset_diff(eventOnsetTimes, minEventOnsetDiff=0.7) bdata = celldatabase.get_session_bdata(cell, 'am') colors = get_colors(len(np.unique(bdata['currentFreq']))) #Raster plt.clf() if plotCycleHists: plt.subplot2grid((11, 3), (0, 0), rowspan=11, colspan=2) else: plt.subplot(111) ms=6 #4 sortArray = bdata['currentFreq'] trialsEachCond = behavioranalysis.find_trials_each_type( sortArray, np.unique(sortArray)) labels = ['%.1f' % f for f in np.unique(sortArray)] spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeData.timestamps, eventOnsetTimes, timeRange) pRaster, hcond, zline = extraplots.raster_plot( spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsEachCond, labels=labels, colorEachCond=colors) plt.setp(pRaster, ms=ms) fontsize = 20 plt.ylabel('AM rate', fontsize=fontsize) plt.xlabel('Time from stimulus onset (s)', fontsize=fontsize) if plotCycleHists: #Want to plot a hist of spike times from 0 to 2pi # ax3 = plt.subplot(313) plt.hold(True) for indFreq, (freq, spikeTimesThisFreq, trialIndicesThisFreq) in enumerate(spiketimes_each_frequency(spikeTimesFromEventOnset, trialIndexForEachSpike, sortArray)): radsPerSec=freq*2*np.pi spikeRads = (spikeTimesThisFreq*radsPerSec)%(2*np.pi) ax = plt.subplot2grid((11, 3), (10-indFreq, 2)) ax.hist(spikeRads, bins=50, color=colors[indFreq], histtype='step')
def plot_sorted_raster(spikeTimeStamps, eventOnsetTimes, sortArray, timeRange=[-0.5, 1],xlabel='Time from sound onset (sec)',ylabel='Frequency (kHz)',ms=4,labels=None,*args,**kwargs): ''' Function to accept spike timestamps, event onset times, and a sorting array and plot a raster plot sorted by the array passed Args: sortarray (array): An array of parameter values for each trial. Output will be sorted by the possible values of the parameter. Must be the same length as the event onset times array ''' trialsEachCond = behavioranalysis.find_trials_each_type(sortArray, np.unique(sortArray)) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, timeRange) pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange, trialsEachCond=trialsEachCond,labels=labels, *args, **kwargs) plt.xlabel(xlabel) plt.ylabel(ylabel) plt.setp(pRaster, ms=ms)
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 time_differences_by_trial(animal, sessions, sortBy, paradigm = '2afc', triggers = ['Cin', 'Cout']): timeDiff = [] import pdb for ind,session in enumerate(sessions): behavFile = os.path.join(settings.BEHAVIOR_PATH,animal,animal+'_2afc_'+session+'.h5') behavData = loadbehavior.BehaviorData(behavFile,readmode='full') possibleSort = np.unique(behavData[sortBy]) while len(possibleSort)>len(timeDiff): timeDiff.append([]) print len(timeDiff) 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 ind2 in range(len(possibleSort)): trialsThisCond = trialsEachCond[:,ind2] 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[ind2].extend(diffThisCond) return timeDiff, possibleSort
def plot_raster(spikeTimestamps, eventOnsetTimes, sortArray=[], timeRange=[-0.5, 1], ms=4, labels=None, *args, **kwargs): ''' Function to accept spike timestamps, event onset times, and an optional sorting array and plot a raster plot (sorted if the sorting array is passed) This function does not replicate functionality. It allows you to pass spike timestamps and event onset times, which are simple to get, as well as an array of any values that can be used to sort the raster. This function wraps three other good functions and provides a way to use them easily Args: sortarray (array): An array of parameter values for each trial. Output will be sorted by the possible values of the parameter. Must be the same length as the event onset times array ''' # If a sort array is supplied, find the trials that correspond to each value of the array if len(sortArray) > 0: trialsEachCond = behavioranalysis.find_trials_each_type( sortArray, np.unique(sortArray)) if not labels: labels = ['%.1f' % f for f in np.unique(sortArray)] else: trialsEachCond = [] # Align spiketimestamps to the event onset times for plotting spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimestamps, eventOnsetTimes, timeRange) #Plot the raster, which will sort if trialsEachCond is supplied pRaster, hcond, zline = extraplots.raster_plot( spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsEachCond, labels=labels, *args, **kwargs) #Set the marker size for better viewing plt.setp(pRaster, ms=ms)
def compute_psycurve(bdata): targetFrequency=bdata['targetFrequency'] valid=bdata['valid'] choice=bdata['choice'] intensities=bdata['targetIntensity'] choiceRight = choice==bdata.labels['choice']['right'] #Find trials at each frequency possibleFreq = np.unique(targetFrequency) nFreq = len(possibleFreq) trialsEachFreq = behavioranalysis.find_trials_each_type(targetFrequency,possibleFreq) #Preallocate arrays fractionRightEachFreq=np.empty(nFreq) confLimitsEachFreq=np.empty([2, nFreq]) #Upper and lower confidence limits nTrialsEachFreq = np.empty(nFreq) nRightwardEachFreq = np.empty(nFreq) #Compute the number right and c.i for each freq. for indf,thisFreq in enumerate(possibleFreq): nTrialsThisFreq = sum(valid & trialsEachFreq[:,indf]) nRightwardThisFreq = sum(valid & choiceRight & trialsEachFreq[:,indf]) conf = np.array(proportion_confint(nRightwardThisFreq, nTrialsThisFreq, method = 'wilson')) nTrialsEachFreq[indf] = nTrialsThisFreq nRightwardEachFreq[indf] = nRightwardThisFreq confLimitsEachFreq[0, indf] = conf[0] # Lower ci confLimitsEachFreq[1, indf] = conf[1] # Upper ci #Compute %right (c.i. are already in percent) fractionRightEachFreq = nRightwardEachFreq/nTrialsEachFreq.astype(float) #plot(possibleFreq,fractionRightEachFreq,'-o') #gca().set_xscale('log') #Find lengths of whiskers for plotting function upperWhisker = confLimitsEachFreq[1, :] - fractionRightEachFreq lowerWhisker = fractionRightEachFreq - confLimitsEachFreq[0,:] return nRightwardEachFreq, nTrialsEachFreq, fractionRightEachFreq, upperWhisker, lowerWhisker
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 inactivated_cells_baselines(spikeTimeStamps, eventOnsetTimes, laserEachTrial, baselineRange=[-0.05, 0.0]): '''For cells recorded during inhibitory cell inactivation, calculates baseline firing rate with and without laser. Inputs: spikeTimeStamps: array of timestamps indicating when spikes occurred eventOnsetTimes: array of timestamps indicating sound onsets firstSort: array of length N trials indicating whether laser was presented for each trial baselineRange: time range (relative to sound onset) to be used as baseline, list of [start time, end time] Outputs: baselineSpikeRates: array of length (N laser trial types), indicating baseline firing rate for each type of laser trial baselineSEMs: like baselineSpikeRates, gives s.e.m. for each value in baselineSpikeRates ''' bandSpikeTimesFromEventOnset, trialIndexForEachSpike, bandIndexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, baselineRange) numLaser = np.unique(laserEachTrial) baselineDuration = baselineRange[1] - baselineRange[0] baselineSpikeRates = np.zeros(len(numLaser)) baselineSEMs = np.zeros_like(baselineSpikeRates) trialsEachLaser = behavioranalysis.find_trials_each_type( laserEachTrial, numLaser) baselineSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts( bandSpikeTimesFromEventOnset, bandIndexLimitsEachTrial, baselineRange) for las in range(len(numLaser)): trialsThisLaser = trialsEachLaser[:, las] if baselineSpikeCountMat.shape[0] != len(trialsThisLaser): baselineSpikeCountMat = baselineSpikeCountMat[:-1, :] baselineCounts = baselineSpikeCountMat[trialsThisLaser].flatten() baselineMean = np.mean(baselineCounts) / baselineDuration baselineSEM = stats.sem(baselineCounts) / baselineDuration baselineSpikeRates[las] = baselineMean baselineSEMs[las] = baselineSEM return baselineSpikeRates, baselineSEMs
def best_window_freq_tuning(spikeTimesFromEventOnset,indexLimitsEachTrial, freqEachTrial): windowsToTry = [[0.0,0.1],[0.0,0.05],[0.1,0.15]] numFreqs = np.unique(freqEachTrial) zscores = np.zeros((len(windowsToTry),len(numFreqs))) for ind, window in enumerate(windowsToTry): duration = window[1]-window[0] baseTimeRange = [-0.1-duration, -0.1] spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, window) baseSpikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, baseTimeRange) trialsEachFreq = behavioranalysis.find_trials_each_type(freqEachTrial, numFreqs) for ind2 in range(len(numFreqs)): trialsThisFreq = trialsEachFreq[:,ind2] spikeCountsThisFreq = spikeCountMat[trialsThisFreq] baseCountsThisFreq = baseSpikeCountMat[trialsThisFreq] zScore, pVal = stats.ranksums(spikeCountsThisFreq, baseCountsThisFreq) zscores[ind,ind2] = zScore maxInd = np.unravel_index(zscores.argmax(), zscores.shape) windowToUse = windowsToTry[maxInd[0]] spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, windowToUse) return spikeCountMat, windowToUse
def freq_tuning_fit(eventOnsetTimes, spikeTimestamps, bdata, timeRange=[-0.2, 0.2], intensityInds=None): # determine the best frequency of the cell by fitting gaussian curve to tuning data gaussFits = [] bestFreqs = [] Rsquareds = [] freqEachTrial = bdata['currentFreq'] intensityEachTrial = bdata['currentIntensity'] numIntensities = np.unique(intensityEachTrial) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimestamps, eventOnsetTimes, timeRange) trialsEachInt = behavioranalysis.find_trials_each_type( intensityEachTrial, numIntensities) if intensityInds is None: intensityInds = range(len(numIntensities)) spikeCountMat, window = best_window_freq_tuning(spikeTimesFromEventOnset, indexLimitsEachTrial, freqEachTrial) for intensityInd in intensityInds: trialsThisIntensity = trialsEachInt[:, intensityInd] tuningSpikeRates = (spikeCountMat[trialsThisIntensity].flatten()) / ( window[1] - window[0]) freqsThisIntensity = freqEachTrial[trialsThisIntensity] gaussFit, Rsquared = response_curve_fit(np.log2(freqsThisIntensity), tuningSpikeRates) bestFreq = 2**gaussFit[0] if gaussFit is not None else None gaussFits.append(gaussFit) bestFreqs.append(bestFreq) Rsquareds.append(Rsquared) return gaussFits, bestFreqs, Rsquareds, window
# 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): trialsThisFreq = trialsEachType[:, indf] respEachFreqMean[:, indf] = np.mean(ftraceEachTrial[:, trialsThisFreq], axis=1) respEachFreqStDev[:, indf] = np.std(ftraceEachTrial[:, trialsThisFreq], axis=1) respEachFreqSEM = respEachFreqStDev / np.sqrt(nTrialsEachFreq) # -- Plot ophys -- # HighF: 78, 52, 77, 60, 113, 107, 226, 368
def inactivation_base_stats(db, filename=''): laserTestStatistic = np.empty(len(db)) laserPVal = np.empty(len(db)) soundResponseTestStatistic = np.empty(len(db)) soundResponsePVal = np.empty(len(db)) onsetSoundResponseTestStatistic = np.empty(len(db)) onsetSoundResponsePVal = np.empty(len(db)) sustainedSoundResponseTestStatistic = np.empty(len(db)) sustainedSoundResponsePVal = np.empty(len(db)) gaussFit = [] tuningTimeRange = [] Rsquared = np.empty(len(db)) prefFreq = np.empty(len(db)) octavesFromPrefFreq = np.empty(len(db)) bestBandSession = np.empty(len(db)) for indRow, (dbIndex, dbRow) in enumerate(db.iterrows()): cellObj = ephyscore.Cell(dbRow) print "Now processing", dbRow['subject'], dbRow['date'], dbRow[ 'depth'], dbRow['tetrode'], dbRow['cluster'] # --- Determine laser responsiveness of each cell (using first 100 ms of noise-in-laser trials) --- try: laserEphysData, noBehav = cellObj.load('lasernoisebursts') except IndexError: print "No laser pulse session for this cell" testStatistic = np.nan pVal = np.nan changeFR = np.nan else: testStatistic, pVal, changeFR = funcs.laser_response( laserEphysData, baseRange=[-0.3, -0.2], responseRange=[0.0, 0.1]) laserTestStatistic[indRow] = testStatistic laserPVal[indRow] = pVal # --- Determine sound responsiveness during bandwidth sessions and calculate baseline firing rates with and without laser--- #done in a kind of stupid way because regular and control sessions are handled the same way if any(session in dbRow['sessionType'] for session in ['laserBandwidth', 'laserBandwidthControl']): if 'laserBandwidth' in dbRow['sessionType']: bandEphysData, bandBehavData = cellObj.load('laserBandwidth') behavSession = 'laserBandwidth' db.at[dbIndex, 'controlSession'] = 0 elif 'laserBandwidthControl' in dbRow['sessionType']: bandEphysData, bandBehavData = cellObj.load( 'laserBandwidthControl') behavSession = 'laserBandwidthControl' db.at[dbIndex, 'controlSession'] = 1 bandEventOnsetTimes = funcs.get_sound_onset_times( bandEphysData, 'bandwidth') bandSpikeTimestamps = bandEphysData['spikeTimes'] bandEachTrial = bandBehavData['currentBand'] secondSort = bandBehavData['laserTrial'] numBands = np.unique(bandEachTrial) numSec = np.unique(secondSort) trialsEachComb = behavioranalysis.find_trials_each_combination( bandEachTrial, numBands, secondSort, numSec) trialsEachBaseCond = trialsEachComb[:, :, 0] #using no laser trials to determine sound responsiveness testStatistic, pVal = funcs.sound_response_any_stimulus( bandEventOnsetTimes, bandSpikeTimestamps, trialsEachBaseCond, [0.0, 1.0], [-1.2, -0.2]) onsetTestStatistic, onsetpVal = funcs.sound_response_any_stimulus( bandEventOnsetTimes, bandSpikeTimestamps, trialsEachBaseCond, [0.0, 0.05], [-0.25, 0.2]) sustainedTestStatistic, sustainedpVal = funcs.sound_response_any_stimulus( bandEventOnsetTimes, bandSpikeTimestamps, trialsEachBaseCond, [0.2, 1.0], [-1.0, 0.2]) pVal *= len(numBands) #correction for multiple comparisons onsetpVal *= len(numBands) sustainedpVal *= len(numBands) #pdb.set_trace() #find baselines with and without laser baselineRange = [-0.05, 0.0] baselineRates, baselineSEMs = funcs.inactivated_cells_baselines( bandSpikeTimestamps, bandEventOnsetTimes, secondSort, baselineRange) db.at[dbIndex, 'baselineFRnoLaser'] = baselineRates[0] db.at[dbIndex, 'baselineFRLaser'] = baselineRates[1] db.at[dbIndex, 'baselineFRnoLaserSEM'] = baselineSEMs[0] db.at[dbIndex, 'baselineFRLaserSEM'] = baselineSEMs[1] db.at[dbIndex, 'baselineChangeFR'] = baselineRates[1] - baselineRates[0] else: print "No bandwidth session for this cell" testStatistic = np.nan pVal = np.nan onsetTestStatistic = np.nan onsetpVal = np.nan sustainedTestStatistic = np.nan sustainedpVal = np.nan #pdb.set_trace() soundResponseTestStatistic[indRow] = testStatistic soundResponsePVal[indRow] = pVal onsetSoundResponseTestStatistic[indRow] = onsetTestStatistic onsetSoundResponsePVal[indRow] = onsetpVal sustainedSoundResponseTestStatistic[indRow] = sustainedTestStatistic sustainedSoundResponsePVal[indRow] = sustainedpVal # --- Determine frequency tuning of cells --- try: tuningEphysData, tuningBehavData = cellObj.load('tuningCurve') except IndexError: print "No tuning session for this cell" freqFit = np.full(4, np.nan) thisRsquared = np.nan bestFreq = np.nan tuningWindow = np.full(2, np.nan) octavesFromBest = np.nan bandIndex = np.nan else: tuningEventOnsetTimes = funcs.get_sound_onset_times( tuningEphysData, 'tuningCurve') tuningSpikeTimestamps = tuningEphysData['spikeTimes'] freqEachTrial = tuningBehavData['currentFreq'] intensityEachTrial = tuningBehavData['currentIntensity'] numFreqs = np.unique(freqEachTrial) numIntensities = np.unique(intensityEachTrial) timeRange = [-0.2, 0.2] spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( tuningSpikeTimestamps, tuningEventOnsetTimes, timeRange) trialsEachType = behavioranalysis.find_trials_each_type( intensityEachTrial, numIntensities) trialsHighInt = trialsEachType[:, -1] trialsEachComb = behavioranalysis.find_trials_each_combination( freqEachTrial, numFreqs, intensityEachTrial, numIntensities) trialsEachFreqHighInt = trialsEachComb[:, :, -1] tuningWindow = funcs.best_window_freq_tuning( spikeTimesFromEventOnset, indexLimitsEachTrial, trialsEachFreqHighInt) tuningWindow = np.array(tuningWindow) spikeCountMat = spikesanalysis.spiketimes_to_spikecounts( spikeTimesFromEventOnset, indexLimitsEachTrial, tuningWindow) tuningSpikeRates = (spikeCountMat[trialsHighInt].flatten()) / ( tuningWindow[1] - tuningWindow[0]) freqsThisIntensity = freqEachTrial[trialsHighInt] freqFit, thisRsquared = funcs.gaussian_tuning_fit( np.log2(freqsThisIntensity), tuningSpikeRates) if freqFit is not None: bestFreq = 2**freqFit[0] bandIndex, octavesFromBest = funcs.best_index( cellObj, bestFreq, behavSession) else: freqFit = np.full(4, np.nan) bestFreq = np.nan bandIndex = np.nan octavesFromBest = np.nan gaussFit.append(freqFit) tuningTimeRange.append(tuningWindow) Rsquared[indRow] = thisRsquared prefFreq[indRow] = bestFreq octavesFromPrefFreq[indRow] = octavesFromBest bestBandSession[indRow] = bandIndex db['laserPVal'] = laserPVal db['laserUStat'] = laserTestStatistic db['soundResponseUStat'] = soundResponseTestStatistic db['soundResponsePVal'] = soundResponsePVal db['onsetSoundResponseUStat'] = onsetSoundResponseTestStatistic db['onsetSoundResponsePVal'] = onsetSoundResponsePVal db['sustainedSoundResponseUStat'] = sustainedSoundResponseTestStatistic db['sustainedSoundResponsePVal'] = sustainedSoundResponsePVal db['gaussFit'] = gaussFit db['tuningTimeRange'] = tuningTimeRange db['tuningFitR2'] = Rsquared db['prefFreq'] = prefFreq db['octavesFromPrefFreq'] = octavesFromPrefFreq db['bestBandSession'] = bestBandSession if len(filename) != 0: celldatabase.save_hdf(db, filename) print filename + " saved" return db
if oneCell.get_session_inds('standard') != []: try: ephysDataStd, bdataStd = oneCell.load('standard') except ValueError as verror: continue spikeTimesStd = ephysDataStd['spikeTimes'] eventOnsetTimesStd = ephysDataStd['events']['stimOn'] if len(eventOnsetTimesStd) == len(bdataStd['currentFreq']) + 1: eventOnsetTimesStd = eventOnsetTimesStd[:-1] (spikeTimesFromEventOnsetStd,trialIndexForEachSpikeStd,indexLimitsEachTrialStd) = \ spikesanalysis.eventlocked_spiketimes(spikeTimesStd, eventOnsetTimesStd, timeRange) frequenciesEachTrialStd = bdataStd['currentFreq'] arrayOfFrequenciesStd = np.unique(bdataStd['currentFreq']) trialsEachCondStd = behavioranalysis.find_trials_each_type( frequenciesEachTrialStd, arrayOfFrequenciesStd) # -- Oddball session -- if oneCell.get_session_inds('oddball') != []: try: ephysDataOdd, bdataOdd = oneCell.load('oddball') except ValueError as verror: continue spikeTimesOdd = ephysDataOdd['spikeTimes'] eventOnsetTimesOdd = ephysDataOdd['events']['stimOn'] if len(eventOnsetTimesOdd) == len(bdataOdd['currentFreq']) + 1: eventOnsetTimesOdd = eventOnsetTimesOdd[:-1] (spikeTimesFromEventOnsetOdd, trialIndexForEachSpikeOdd, indexLimitsEachTrialOdd) = spikesanalysis.eventlocked_spiketimes( spikeTimesOdd, eventOnsetTimesOdd, timeRange)
def plot_ave_psycurve_reward_change(animal, sessions): FREQCOLORS = [ '0.3', colorpalette.TangoPalette['Orange2'], colorpalette.TangoPalette['SkyBlue2'] ] allBehavDataThisAnimal = behavioranalysis.load_many_sessions( animal, sessions) targetFrequency = allBehavDataThisAnimal['targetFrequency'] choice = allBehavDataThisAnimal['choice'] valid = allBehavDataThisAnimal['valid'] & ( choice != allBehavDataThisAnimal.labels['choice']['none']) choiceRight = choice == allBehavDataThisAnimal.labels['choice']['right'] currentBlock = allBehavDataThisAnimal['currentBlock'] blockTypes = [ allBehavDataThisAnimal.labels['currentBlock']['same_reward'], allBehavDataThisAnimal.labels['currentBlock']['more_left'], allBehavDataThisAnimal.labels['currentBlock']['more_right'] ] #blockTypes = [allBehavDataThisAnimal.labels['currentBlock']['more_left'],allBehavDataThisAnimal.labels['currentBlock']['more_right']] blockLabels = ['same_reward', 'more_left', 'more_right'] #blockLabels = ['more_left','more_right'] trialsEachType = behavioranalysis.find_trials_each_type( currentBlock, blockTypes) nFreqs = len(np.unique(targetFrequency)) #print trialsEachType nBlocks = len(blockTypes) #thisAnimalPos = inda #ax1=plt.subplot(gs[thisAnimalPos]) #plt.clf() fontsize = 12 allPline = [] blockLegends = [] fractionHitsEachValueAllBlocks = np.empty((nBlocks, nFreqs)) for blockType in range(nBlocks): if np.any(trialsEachType[:, blockType]): targetFrequencyThisBlock = targetFrequency[ trialsEachType[:, blockType]] validThisBlock = valid[trialsEachType[:, blockType]] choiceRightThisBlock = choiceRight[trialsEachType[:, blockType]] #currentBlockValue = currentBlock[trialsEachBlock[0,block]] (possibleValues,fractionHitsEachValue,ciHitsEachValue,nTrialsEachValue,nHitsEachValue)=\ behavioranalysis.calculate_psychometric(choiceRightThisBlock,targetFrequencyThisBlock,validThisBlock) logPossibleValues = np.log2(possibleValues) lowerFreqConstraint = logPossibleValues[1] upperFreqConstraint = logPossibleValues[-2] maxFreq = max(logPossibleValues) minFreq = min(logPossibleValues) constraints = ('Uniform({}, {})'.format(lowerFreqConstraint, upperFreqConstraint), 'Uniform(0,5)', 'Uniform(0,1)', 'Uniform(0,1)') estimate = extrastats.psychometric_fit(logPossibleValues, nTrialsEachValue, nHitsEachValue, constraints) fractionHitsEachValueAllBlocks[ blockType, :] = fractionHitsEachValue upperWhisker = ciHitsEachValue[1, :] - fractionHitsEachValue lowerWhisker = fractionHitsEachValue - ciHitsEachValue[0, :] xRange = logPossibleValues[-1] - logPossibleValues[1] fitxvals = np.linspace(logPossibleValues[0] - 0.1 * xRange, logPossibleValues[-1] + 0.1 * xRange, 40) fityvals = extrastats.psychfun(fitxvals, *estimate) # (pline, pcaps, pbars, pdots) = extraplots.plot_psychometric(1e-3*possibleValues,fractionHitsEachValue, ciHitsEachValue,xTickPeriod=1) ax = plt.gca() ax.hold(True) (pline, pcaps, pbars) = ax.errorbar( logPossibleValues, 100 * fractionHitsEachValue, yerr=[100 * lowerWhisker, 100 * upperWhisker], ecolor=FREQCOLORS[blockType], fmt=None, clip_on=False) pdots = ax.plot(logPossibleValues, 100 * fractionHitsEachValue, 'o', ms=6, mec='None', mfc=FREQCOLORS[blockType], clip_on=False) if blockType == 0: pfit = ax.plot(fitxvals, 100 * fityvals, color=FREQCOLORS[blockType], lw=2, clip_on=False, linestyle='--') else: pfit = ax.plot(fitxvals, 100 * fityvals, color=FREQCOLORS[blockType], lw=2, clip_on=False) # plt.setp((pline, pcaps, pbars), color=FREQCOLORS[blockType]) # plt.setp((pline, pbars), color=FREQCOLORS[blockType]) # plt.setp(pdots, mfc=FREQCOLORS[blockType], mec=FREQCOLORS[blockType]) allPline.append(pline) blockLegends.append(blockLabels[blockType]) if blockType == nBlocks - 1: plt.xlabel('Frequency (kHz)', fontsize=fontsize) plt.ylabel('Rightward trials (%)', fontsize=fontsize) extraplots.set_ticks_fontsize(plt.gca(), fontsize) ax.set_xticks(logPossibleValues) tickLabels = [''] * len(possibleValues) tickLabels[0] = 6.2 tickLabels[-1] = 19.2 ax.set_xticklabels(tickLabels) ax.axhline(y=50, linestyle='-', color='0.7') extraplots.boxoff(ax) # legend = plt.legend(allPline,blockLegends,loc=2) #Add the legend manually to the current Axes. # ax = plt.gca().add_artist(legend) #plt.hold(True) #plt.legend(bbox_to_anchor=(1, 1), bbox_transform=plt.gcf().transFigure) #plt.show() # plt.title('%s %s-%s'%(animal,sessions[0],sessions[-1])) return fractionHitsEachValueAllBlocks
tuningWindow = [0,0] octavesFromBest = np.nan bandIndex = np.nan else: tuningEventOnsetTimes = get_sound_onset_times(tuningEphysData, 'tuningCurve') tuningSpikeTimestamps = tuningEphysData['spikeTimes'] freqEachTrial = tuningBehavData['currentFreq'] intensityEachTrial = tuningBehavData['currentIntensity'] numFreqs = np.unique(freqEachTrial) numIntensities = np.unique(intensityEachTrial) timeRange = [-0.2, 0.2] spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( tuningSpikeTimestamps, tuningEventOnsetTimes, timeRange) trialsEachType = behavioranalysis.find_trials_each_type(intensityEachTrial, numIntensities) trialsHighInt = trialsEachType[:,-1] trialsEachComb = behavioranalysis.find_trials_each_combination(freqEachTrial, numFreqs, intensityEachTrial, numIntensities) trialsEachFreqHighInt = trialsEachComb[:,:,-1] tuningWindow = best_window_freq_tuning(spikeTimesFromEventOnset, indexLimitsEachTrial, trialsEachFreqHighInt) spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, tuningWindow) tuningSpikeRates = (spikeCountMat[trialsHighInt].flatten())/(tuningWindow[1]-tuningWindow[0]) freqsThisIntensity = freqEachTrial[trialsHighInt] freqFit, thisRsquared = gaussian_tuning_fit(np.log2(freqsThisIntensity), tuningSpikeRates) if freqFit is not None: bestFreq = 2**freqFit[0] bandIndex, octavesFromBest = best_index(cellObj, bestFreq, sessionType) else: freqFit = np.zeros(4) bestFreq = np.nan bandIndex = np.nan
def plot_bandwidth_report(cell, bandIndex): cellInfo = get_cell_info(cell) #pdb.set_trace() loader = dataloader.DataLoader(cell['subject']) if len(cellInfo['laserIndex'])>0: laser = True gs = gridspec.GridSpec(13, 6) else: laser = False gs = gridspec.GridSpec(9, 6) offset = 4*laser gs.update(left=0.15, right=0.85, top = 0.96, wspace=0.7, hspace=1.0) # -- plot bandwidth rasters -- plt.clf() eventData = loader.get_session_events(cellInfo['ephysDirs'][bandIndex]) spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][bandIndex], cellInfo['tetrode'], cluster=cellInfo['cluster']) eventOnsetTimes = loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.2, 1.5] bandBData = loader.get_session_behavior(cellInfo['behavDirs'][bandIndex]) bandEachTrial = bandBData['currentBand'] ampEachTrial = bandBData['currentAmp'] charfreq = str(np.unique(bandBData['charFreq'])[0]/1000) modrate = str(np.unique(bandBData['modRate'])[0]) numBands = np.unique(bandEachTrial) numAmps = np.unique(ampEachTrial) firstSortLabels = ['{}'.format(band) for band in np.unique(bandEachTrial)] secondSortLabels = ['Amplitude: {}'.format(amp) for amp in np.unique(ampEachTrial)] spikeTimesFromEventOnset, indexLimitsEachTrial, trialsEachCond, firstSortLabels = bandwidth_raster_inputs(eventOnsetTimes, spikeTimestamps, bandEachTrial, ampEachTrial) colours = [np.tile(['#4e9a06','#8ae234'],len(numBands)/2+1), np.tile(['#5c3566','#ad7fa8'],len(numBands)/2+1)] for ind, secondArrayVal in enumerate(numAmps): plt.subplot(gs[5+2*ind+offset:7+2*ind+offset, 0:3]) trialsThisSecondVal = trialsEachCond[:, :, ind] pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsThisSecondVal, labels=firstSortLabels, colorEachCond = colours[ind]) plt.setp(pRaster, ms=4) plt.title(secondSortLabels[ind]) plt.ylabel('bandwidth (octaves)') if ind == len(np.unique(ampEachTrial)) - 1: plt.xlabel("Time from sound onset (sec)") # -- plot Yashar plots for bandwidth data -- plt.subplot(gs[5+offset:, 3:]) spikeArray, errorArray, baseSpikeRate = band_select(spikeTimestamps, eventOnsetTimes, ampEachTrial, bandEachTrial, timeRange = [0.0, 1.0]) band_select_plot(spikeArray, errorArray, baseSpikeRate, numBands, legend=True) # -- plot frequency tuning heat map -- tuningBData = loader.get_session_behavior(cellInfo['behavDirs'][cellInfo['tuningIndex'][-1]]) freqEachTrial = tuningBData['currentFreq'] intEachTrial = tuningBData['currentIntensity'] eventData = loader.get_session_events(cellInfo['ephysDirs'][cellInfo['tuningIndex'][-1]]) spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][cellInfo['tuningIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster']) eventOnsetTimes = loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps plt.subplot(gs[2+offset:4+offset, 0:3]) dataplotter.two_axis_heatmap(spikeTimestamps=spikeTimestamps, eventOnsetTimes=eventOnsetTimes, firstSortArray=intEachTrial, secondSortArray=freqEachTrial, firstSortLabels=["%.0f" % inten for inten in np.unique(intEachTrial)], secondSortLabels=["%.1f" % freq for freq in np.unique(freqEachTrial)/1000.0], xlabel='Frequency (kHz)', ylabel='Intensity (dB SPL)', plotTitle='Frequency Tuning Curve', flipFirstAxis=False, flipSecondAxis=False, timeRange=[0, 0.1]) plt.ylabel('Intensity (dB SPL)') plt.xlabel('Frequency (kHz)') plt.title('Frequency Tuning Curve') # -- plot frequency tuning raster -- plt.subplot(gs[0+offset:2+offset, 0:3]) freqLabels = ["%.1f" % freq for freq in np.unique(freqEachTrial)/1000.0] dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, sortArray=freqEachTrial, timeRange=[-0.1, 0.5], labels=freqLabels) plt.xlabel('Time from sound onset (sec)') plt.ylabel('Frequency (kHz)') plt.title('Frequency Tuning Raster') # -- plot AM PSTH -- amBData = loader.get_session_behavior(cellInfo['behavDirs'][cellInfo['amIndex'][-1]]) rateEachTrial = amBData['currentFreq'] eventData = loader.get_session_events(cellInfo['ephysDirs'][cellInfo['amIndex'][-1]]) spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][cellInfo['amIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster']) eventOnsetTimes = loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.2, 1.5] spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimestamps, eventOnsetTimes, timeRange) colourList = ['b', 'g', 'y', 'orange', 'r'] numRates = np.unique(rateEachTrial) trialsEachCond = behavioranalysis.find_trials_each_type(rateEachTrial, numRates) plt.subplot(gs[2+offset:4+offset, 3:]) dataplotter.plot_psth(spikeTimestamps, eventOnsetTimes, rateEachTrial, timeRange = [-0.2, 0.8], binsize = 25, colorEachCond = colourList) plt.xlabel('Time from sound onset (sec)') plt.ylabel('Firing rate (Hz)') plt.title('AM PSTH') # -- plot AM raster -- plt.subplot(gs[0+offset:2+offset, 3:]) rateLabels = ["%.0f" % rate for rate in np.unique(rateEachTrial)] dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, sortArray=rateEachTrial, timeRange=[-0.2, 0.8], labels=rateLabels, colorEachCond=colourList) plt.xlabel('Time from sound onset (sec)') plt.ylabel('Modulation Rate (Hz)') plt.title('AM Raster') # -- plot laser pulse and laser train data (if available) -- if laser: # -- plot laser pulse raster -- plt.subplot(gs[0:2, 0:3]) eventData = loader.get_session_events(cellInfo['ephysDirs'][cellInfo['laserIndex'][-1]]) spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][cellInfo['laserIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster']) eventOnsetTimes = loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.1, 0.4] dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, timeRange=timeRange) plt.xlabel('Time from sound onset (sec)') plt.title('Laser Pulse Raster') # -- plot laser pulse psth -- plt.subplot(gs[2:4, 0:3]) dataplotter.plot_psth(spikeTimestamps, eventOnsetTimes, timeRange = timeRange, binsize = 10) plt.xlabel('Time from sound onset (sec)') plt.ylabel('Firing Rate (Hz)') plt.title('Laser Pulse PSTH') # -- didn't record laser trains for some earlier sessions -- if len(cellInfo['laserTrainIndex']) > 0: # -- plot laser train raster -- plt.subplot(gs[0:2, 3:]) eventData = loader.get_session_events(cellInfo['ephysDirs'][cellInfo['laserTrainIndex'][-1]]) spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][cellInfo['laserTrainIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster']) eventOnsetTimes = loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.2, 1.0] dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, timeRange=timeRange) plt.xlabel('Time from sound onset (sec)') plt.title('Laser Train Raster') # -- plot laser train psth -- plt.subplot(gs[2:4, 3:]) dataplotter.plot_psth(spikeTimestamps, eventOnsetTimes, timeRange = timeRange, binsize = 10) plt.xlabel('Time from sound onset (sec)') plt.ylabel('Firing Rate (Hz)') plt.title('Laser Train PSTH') # -- show cluster analysis -- tsThisCluster, wavesThisCluster = load_cluster_waveforms(cellInfo) # -- Plot ISI histogram -- plt.subplot(gs[4+offset, 0:2]) spikesorting.plot_isi_loghist(tsThisCluster) plt.ylabel('c%d'%cellInfo['cluster'],rotation=0,va='center',ha='center') plt.xlabel('') # -- Plot waveforms -- plt.subplot(gs[4+offset, 2:4]) spikesorting.plot_waveforms(wavesThisCluster) # -- Plot events in time -- plt.subplot(gs[4+offset, 4:6]) spikesorting.plot_events_in_time(tsThisCluster) plt.suptitle('{0}, {1}, {2}um, Tetrode {3}, Cluster {4}, {5}kHz, {6}Hz modulation'.format(cellInfo['subject'], cellInfo['date'], cellInfo['depth'], cellInfo['tetrode'], cellInfo['cluster'], charfreq, modrate)) fig_path = '/home/jarauser/Pictures/cell reports' fig_name = '{0}_{1}_{2}um_TT{3}Cluster{4}.png'.format(cellInfo['subject'], cellInfo['date'], cellInfo['depth'], cellInfo['tetrode'], cellInfo['cluster']) full_fig_path = os.path.join(fig_path, fig_name) fig = plt.gcf() fig.set_size_inches(20, 25) fig.savefig(full_fig_path, format = 'png', bbox_inches='tight')
ax=subplot(111) ax.plot(fr_array, 'k-', linewidth=3) ax.set_xticks(range(len(possibleFreq))) ax.set_xticklabels(['{:3.0f}'.format(x) for x in possibleFreq]) ax.set_xlabel('Modulation Frequency') ax.set_ylabel('Average Firing Rate (spks/sec)') ############################################################################# timeRange=[0, 0.5] spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(spikeTimestamps,eventOnsetTimes,timeRange) from jaratoolbox import behavioranalysis trialsEachType = behavioranalysis.find_trials_each_type(currentFreq, np.unique(currentFreq)) #I want to get the raster for one frequency. I am certain I am re-inventing #the wheel here but it has been a while. #Trials where the freq was 4 #Indices of spikes that came from that trial # np.flatnonzero(trialIndexForEachSpike==8) # #Spiketimes from event onset for trial 8
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()
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) ''' upperWhisker = ciHitsEachValue[1,:]-fractionHitsEachValue lowerWhisker = fractionHitsEachValue-ciHitsEachValue[0,:] (pline, pcaps, pbars) = errorbar(possibleValues, 100*fractionHitsEachValue, yerr = [100*lowerWhisker, 100*upperWhisker],color='k') plot(possibleValues, 100*fractionHitsEachValue, 'o',mec='none',mfc='k',ms=8) setp(pline,lw=2) axhline(y=50, color = '0.5',ls='--')
soundOnsetTimeBehav = bdata['timeTarget'] diffTimes = bdata['timeCenterOut'] - bdata['timeTarget'] #movementOnsetTimeEphys = soundOnsetTimeEphys + diffTimes # Find missing trials missingTrials = behavioranalysis.find_missing_trials( soundOnsetTimeEphys, soundOnsetTimeBehav) # Remove missing trials bdata.remove_trials(missingTrials) # -- Calculate and store intermediate data for tuning raster -- # freqEachTrial = bdata['targetFrequency'] valid = bdata['valid'].astype('bool') possibleFreq = np.unique(freqEachTrial) trialsEachFreq = behavioranalysis.find_trials_each_type( freqEachTrial, possibleFreq) trialsEachFreq = trialsEachFreq & valid[:, np. newaxis] #Use only valid trials where sound is played in full (spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \ spikesanalysis.eventlocked_spiketimes(spikeTimestamps,soundOnsetTimeEphys,timeRange) ### Save raster data ### #outputDir = os.path.join(settings.FIGURESDATA, figparams.STUDY_NAME) outputFile = 'example_freq_tuning_2afc_raster_{}_{}_T{}_c{}.npz'.format( oneCell.animalName, oneCell.behavSession, oneCell.tetrode, oneCell.cluster) outputFullPath = os.path.join(dataDir, outputFile) np.savez(outputFullPath, spikeTimestamps=spikeTimestamps, eventOnsetTimes=eventOnsetTimes,
plt.figure() for indSubject, subject in enumerate(subjects): for indSession, session in enumerate(sessions): plt.subplot(len(subjects), 1, indSubject+1) bdata = behavioranalysis.load_many_sessions(subject, [session]) targetIntensity = bdata['targetIntensity'] valid = bdata['valid'] choice = bdata['choice'] #Is this the correct thing to get to calculate psychometrics? choiceRight = choice==bdata.labels['choice']['right'] targetFreq = bdata['targetFrequency'] possibleInt = np.unique(targetIntensity) trialsEachInt = behavioranalysis.find_trials_each_type(targetIntensity,possibleInt) trialsInds = {} allPlines = [] for indInt, inten in enumerate(possibleInt): trialsInds[inten] = valid&(bdata['targetIntensity']==inten) (possibleValues,fractionHitsEachValue,ciHitsEachValue,nTrialsEachValue,nHitsEachValue)=\ behavioranalysis.calculate_psychometric(choiceRight, targetFreq, trialsInds[inten]) (pline, pcaps, pbars, pdots) = extraplots.plot_psychometric(1e-3*possibleValues,fractionHitsEachValue,ciHitsEachValue,xTickPeriod=1) allPlines.append(pline) plt.title(subject+' - '+session, fontsize=fontsize) plt.xlabel('Frequency (kHz)',fontsize=fontsize) plt.ylabel('Rightward trials (%)',fontsize=fontsize)
spikeData.samples=spikeData.samples[spikeData.clusters==cluster] spikeData.timestamps=spikeData.timestamps[spikeData.clusters==cluster] # convert to seconds and millivolts spikeData.samples = spikeData.samples.astype(float)-2**15 spikeData.samples = (1000.0/spikeData.gain[0,0]) * spikeData.samples spikeData.timestamps = spikeData.timestamps/spikeData.samplingRate eventData.timestamps = eventData.timestamps/eventData.samplingRate return eventData, spikeData def load_behaviour_data(subject, fileName): behavFile = os.path.join(settings.BEHAVIOR_PATH,subject,fileName) bdata = loadbehavior.BehaviorData(behavFile,readmode='full') return bdata # LOAD YOUR SHIT eventData, spikeData = load_ephys_data(SUBJECT, EPHYSSESSION, tetrode, cluster) eventOnsetTimes = eventData.get_event_onset_times() spikeTimeStamps = spikeData.timestamps tuningBData = load_behaviour_data(SUBJECT, BEHAVIORSESSION) freqEachTrial = tuningBData['currentFreq'] trialsEachCond = behavioranalysis.find_trials_each_type(freqEachTrial, np.unique(freqEachTrial)) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimeStamps, eventOnsetTimes, timeRange) pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange, trialsEachCond=trialsEachCond, *args, **kwargs) plt.xlabel(xlabel) plt.ylabel(ylabel) plt.setp(pRaster, ms=ms)
def plot_rew_change_per_cell(oneCell,trialLimit=[],alignment='sound'): ''' Plots raster and PSTH for one cell during reward_change_freq_dis task, split by block; alignment parameter should be set to either 'sound', 'center-out', or 'side-in'. ''' bdata = load_behav_per_cell(oneCell) (spikeTimestamps,waveforms,eventOnsetTimes,eventData) = load_ephys_per_cell(oneCell) # -- Check to see if ephys has skipped trials, if so remove trials from behav data soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel) soundOnsetTimeEphys = eventOnsetTimes[soundOnsetEvents] soundOnsetTimeBehav = bdata['timeTarget'] # Find missing trials missingTrials = behavioranalysis.find_missing_trials(soundOnsetTimeEphys,soundOnsetTimeBehav) # Remove missing trials bdata.remove_trials(missingTrials) currentBlock = bdata['currentBlock'] blockTypes = [bdata.labels['currentBlock']['same_reward'],bdata.labels['currentBlock']['more_left'],bdata.labels['currentBlock']['more_right']] #blockLabels = ['more_left', 'more_right'] if(not len(trialLimit)): validTrials = np.ones(len(currentBlock),dtype=bool) else: validTrials = np.zeros(len(currentBlock),dtype=bool) validTrials[trialLimit[0]:trialLimit[1]] = 1 trialsEachType = behavioranalysis.find_trials_each_type(currentBlock,blockTypes) if alignment == 'sound': soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel) EventOnsetTimes = eventOnsetTimes[soundOnsetEvents] elif alignment == 'center-out': soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel) EventOnsetTimes = eventOnsetTimes[soundOnsetEvents] diffTimes=bdata['timeCenterOut']-bdata['timeTarget'] EventOnsetTimes+=diffTimes elif alignment == 'side-in': soundOnsetEvents = (eventData.eventID==1) & (eventData.eventChannel==soundTriggerChannel) EventOnsetTimes = eventOnsetTimes[soundOnsetEvents] diffTimes=bdata['timeSideIn']-bdata['timeTarget'] EventOnsetTimes+=diffTimes freqEachTrial = bdata['targetFrequency'] possibleFreq = np.unique(freqEachTrial) rightward = bdata['choice']==bdata.labels['choice']['right'] leftward = bdata['choice']==bdata.labels['choice']['left'] invalid = bdata['outcome']==bdata.labels['outcome']['invalid'] correct = bdata['outcome']==bdata.labels['outcome']['correct'] incorrect = bdata['outcome']==bdata.labels['outcome']['error'] ######Split left and right trials into correct and incorrect categories to look at error trials######### rightcorrect = rightward&correct&validTrials leftcorrect = leftward&correct&validTrials #righterror = rightward&incorrect&validTrials #lefterror = leftward&incorrect&validTrials rightcorrectBlockSameReward = rightcorrect&trialsEachType[:,0] rightcorrectBlockMoreLeft = rightcorrect&trialsEachType[:,1] rightcorrectBlockMoreRight = rightcorrect&trialsEachType[:,2] leftcorrectBlockSameReward = leftcorrect&trialsEachType[:,0] leftcorrectBlockMoreLeft = leftcorrect&trialsEachType[:,1] leftcorrectBlockMoreRight = leftcorrect&trialsEachType[:,2] trialsEachCond = np.c_[leftcorrectBlockMoreLeft,rightcorrectBlockMoreLeft,leftcorrectBlockMoreRight,rightcorrectBlockMoreRight,leftcorrectBlockSameReward,rightcorrectBlockSameReward] colorEachCond = ['g','r','m','b','y','darkgray'] #trialsEachCond = np.c_[invalid,leftcorrect,rightcorrect,lefterror,righterror] #colorEachCond = ['0.75','g','r','b','m'] (spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \ spikesanalysis.eventlocked_spiketimes(spikeTimestamps,EventOnsetTimes,timeRange) ###########Plot raster and PSTH################# plt.figure() ax1 = plt.subplot2grid((8,5), (0, 0), rowspan=4,colspan=5) extraplots.raster_plot(spikeTimesFromEventOnset,indexLimitsEachTrial,timeRange,trialsEachCond=trialsEachCond,colorEachCond=colorEachCond,fillWidth=None,labels=None) plt.ylabel('Trials') plt.xlim(timeRange) plt.title('{0}_{1}_TT{2}_c{3}_{4}'.format(oneCell.animalName,oneCell.behavSession,oneCell.tetrode,oneCell.cluster,alignment)) timeVec = np.arange(timeRange[0],timeRange[-1],binWidth) spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,indexLimitsEachTrial,timeVec) smoothWinSize = 3 ax2 = plt.subplot2grid((8,5), (4, 0),colspan=5,rowspan=2,sharex=ax1) extraplots.plot_psth(spikeCountMat/binWidth,smoothWinSize,timeVec,trialsEachCond=trialsEachCond,colorEachCond=colorEachCond,linestyle=None,linewidth=3,downsamplefactor=1) plt.xlabel('Time from {0} onset (s)'.format(alignment)) plt.ylabel('Firing rate (spk/sec)') # -- Plot ISI histogram -- plt.subplot2grid((8,5), (6,0), rowspan=1, colspan=2) spikesorting.plot_isi_loghist(spikeTimestamps) plt.ylabel('c%d'%oneCell.cluster,rotation=0,va='center',ha='center') plt.xlabel('') # -- Plot waveforms -- plt.subplot2grid((8,5), (7,0), rowspan=1, colspan=3) spikesorting.plot_waveforms(waveforms) # -- Plot projections -- plt.subplot2grid((8,5), (6,2), rowspan=1, colspan=3) spikesorting.plot_projections(waveforms) # -- Plot events in time -- plt.subplot2grid((8,5), (7,3), rowspan=1, colspan=2) spikesorting.plot_events_in_time(spikeTimestamps) plt.subplots_adjust(wspace = 0.7) #plt.show() #fig_path = #fig_name = 'TT{0}Cluster{1}{2}.png'.format(tetrode, cluster, '_2afc plot_each_type') #full_fig_path = os.path.join(fig_path, fig_name) #print full_fig_path plt.gcf().set_size_inches((8.5,11))
def get_trials_each_cond_reward_change(animal, behavSession, ephysSession, tetrode, cluster, freqToPlot, byBlock, colorCondDict): '''Function to generate selection vector showing which trials to plot for each behavior conditions and the color to use in the plot label. :param arg1: A string of the file name of the 2afc behavior session, this is the full filename in '{animal}_{paradigm}_{date}{behavsuffix}.h5' format. :param arg2: A string of the file name of the 2afc ephys session, this is the full filename, in {date}_XX-XX-XX format. :param arg3: An int in range(1,9) for tetrode number. :param arg4: An int for cluster number. :param arg5: A string indicating which frequency to plot, value of 'low' or 'high'. :param arg6: Boolean indicating whether to split the plot by behavior blocks. :param arg7: A dictionary indicating which color label each behavior condition gets in the final plot. :return: bData object, trialsEachCond, colorsEachCond ''' bdata = load_n_remove_missing_trials_2afc_behav(animal, behavSession, ephysSession, tetrode, cluster) # -- Select trials to plot from behavior file -- # correct = bdata['outcome']==bdata.labels['outcome']['correct'] possibleFreq = np.unique(bdata['targetFrequency']) numFreqs = len(possibleFreq) currentBlock = bdata['currentBlock'] # -- Select trials to plot based on desired frequencies to plot and whether to plot by block -- # ### Recordings during reward change usually have 2 frequencies, low freq means go to left, right freq means go to right ### if freqToPlot == 'low': freq = possibleFreq[0] elif freqToPlot == 'high': freq = possibleFreq[1] oneFreq = bdata['targetFrequency'] == freq #vector for selecing trials presenting this frequency correctOneFreq = oneFreq & correct # -- Find trials each block (if plotting mid frequency by block) or find trials each type (e.g. low-boundary, high-boundary; if not plotting by block) -- # if byBlock: bdata.find_trials_each_block() numBlocks = bdata.blocks['nBlocks'] trialsEachBlock = bdata.blocks['trialsEachBlock'] correctTrialsEachBlock = trialsEachBlock & correctOneFreq[:,np.newaxis] correctBlockSizes = sum(correctTrialsEachBlock) if (correctBlockSizes[-1] < minBlockSize): #A check to see if last block is too small to plot correctTrialsEachBlock = correctTrialsEachBlock[:,:-1] numBlocks -= 1 trialsEachCond = correctTrialsEachBlock colorEachCond = np.empty(numBlocks, dtype=object) labelEachCond = np.empty(numBlocks, dtype=object) #pdb.set_trace() for blockNum in range(numBlocks): currentBlockLabel = currentBlock[trialsEachBlock[:,blockNum]][0] if freqToPlot == 'low': if currentBlockLabel == bdata.labels['currentBlock']['same_reward']: colorEachCond[blockNum] = colorCondDict['sameRewardLowFreq'] labelEachCond[blockNum] = 'low freq same reward' elif currentBlockLabel == bdata.labels['currentBlock']['more_left']: colorEachCond[blockNum] = colorCondDict['leftMoreLowFreq'] labelEachCond[blockNum] = 'low freq left more' elif currentBlockLabel == bdata.labels['currentBlock']['more_right']: colorEachCond[blockNum] = colorCondDict['rightMoreLowFreq'] labelEachCond[blockNum] = 'low freq right more' elif freqToPlot == 'high': if currentBlockLabel == bdata.labels['currentBlock']['same_reward']: colorEachCond[blockNum] = colorCondDict['sameRewardHighFreq'] labelEachCond[blockNum] = 'high freq same reward' elif currentBlockLabel == bdata.labels['currentBlock']['more_left']: colorEachCond[blockNum] = colorCondDict['leftMoreHighFreq'] labelEachCond[blockNum] = 'high freq left more' elif currentBlockLabel == bdata.labels['currentBlock']['more_right']: colorEachCond[blockNum] = colorCondDict['rightMoreHighFreq'] labelEachCond[blockNum] = 'high freq right more' else: blockTypes = [bdata.labels['currentBlock']['same_reward'],bdata.labels['currentBlock']['more_left'],bdata.labels['currentBlock']['more_right']] trialsEachType = behavioranalysis.find_trials_each_type(currentBlock,blockTypes) oneFreqCorrectBlockSameReward = correctOneFreq&trialsEachType[:,0] oneFreqCorrectBlockMoreLeft = correctOneFreq&trialsEachType[:,1] oneFreqCorrectBlockMoreRight = correctOneFreq&trialsEachType[:,2] trialsEachCond = np.c_[oneFreqCorrectBlockSameReward,oneFreqCorrectBlockMoreLeft,oneFreqCorrectBlockMoreRight] if freqToPlot == 'low': colorEachCond = [colorCondDict['sameRewardLowFreq'],colorCondDict['leftMoreLowFreq'],colorCondDict['rightMoreLowFreq']] labelEachCond = ['low freq same reward', 'low freq left more', 'low freq right more'] elif freqToPlot == 'high': colorEachCond = [colorCondDict['sameRewardHighFreq'],colorCondDict['leftMoreHighFreq'],colorCondDict['rightMoreHighFreq']] labelEachCond = ['high freq same reward', 'high freq left more', 'high freq right more'] return trialsEachCond, colorEachCond, labelEachCond
def plot_bandwidth_report(mouse, date, site, siteName): sessions = site.get_session_ephys_filenames() behavFilename = site.get_session_behav_filenames() ei = ephysinterface.EphysInterface(mouse, date, '', 'bandwidth_am') bdata = ei.loader.get_session_behavior(behavFilename[3][-4:-3]) charfreq = str(np.unique(bdata['charFreq'])[0]/1000) modrate = str(np.unique(bdata['modRate'])[0]) ei2 = ephysinterface.EphysInterface(mouse, date, '', 'am_tuning_curve') bdata2 = ei2.loader.get_session_behavior(behavFilename[1][-4:-3]) bdata3 = ei2.loader.get_session_behavior(behavFilename[2][-4:-3]) currentFreq = bdata2['currentFreq'] currentBand = bdata['currentBand'] currentAmp = bdata['currentAmp'] currentInt = bdata2['currentIntensity'] currentRate = bdata3['currentFreq'] #for tetrode in site.tetrodes: for tetrode in [2]: oneTT = sitefuncs.cluster_site(site, siteName, tetrode) dataSpikes = ei.loader.get_session_spikes(sessions[3], tetrode) dataSpikes2 = ei2.loader.get_session_spikes(sessions[1], tetrode) #clusters = np.unique(dataSpikes.clusters) clusters = [8] for cluster in clusters: plt.clf() # -- plot bandwidth rasters -- eventData = ei.loader.get_session_events(sessions[3]) spikeData = ei.loader.get_session_spikes(sessions[3], tetrode, cluster=cluster) eventOnsetTimes = ei.loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.2, 1.5] numBands = np.unique(currentBand) numAmps = np.unique(currentAmp) firstSortLabels = ['{}'.format(band) for band in np.unique(currentBand)] secondSortLabels = ['Amplitude: {}'.format(amp) for amp in np.unique(currentAmp)] trialsEachCond = behavioranalysis.find_trials_each_combination(currentBand, numBands, currentAmp, numAmps) spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimestamps, eventOnsetTimes, timeRange) for ind, secondArrayVal in enumerate(numAmps): plt.subplot2grid((12, 15), (5*ind, 0), rowspan = 4, colspan = 7) trialsThisSecondVal = trialsEachCond[:, :, ind] pRaster, hcond, zline = extraplots.raster_plot(spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange, trialsEachCond=trialsThisSecondVal, labels=firstSortLabels) plt.setp(pRaster, ms=4) plt.title(secondSortLabels[ind]) plt.ylabel('bandwidth (octaves)') if ind == len(np.unique(currentAmp)) - 1: plt.xlabel("Time from sound onset (sec)") # -- plot Yashar plots for bandwidth data -- plt.subplot2grid((12,15), (10,0), rowspan = 2, colspan = 3) band_select_plot(spikeTimestamps, eventOnsetTimes, currentAmp, currentBand, [0.0, 1.0], title='bandwidth selectivity') plt.subplot2grid((12,15), (10,3), rowspan = 2, colspan = 3) band_select_plot(spikeTimestamps, eventOnsetTimes, currentAmp, currentBand, [0.2, 1.0], title='first 200ms excluded') # -- plot frequency tuning heat map -- plt.subplot2grid((12, 15), (5, 7), rowspan = 4, colspan = 4) eventData = ei2.loader.get_session_events(sessions[1]) spikeData = ei2.loader.get_session_spikes(sessions[1], tetrode, cluster=cluster) eventOnsetTimes = ei2.loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps dataplotter.two_axis_heatmap(spikeTimestamps=spikeTimestamps, eventOnsetTimes=eventOnsetTimes, firstSortArray=currentInt, secondSortArray=currentFreq, firstSortLabels=["%.1f" % inten for inten in np.unique(currentInt)], secondSortLabels=["%.1f" % freq for freq in np.unique(currentFreq)/1000.0], xlabel='Frequency (kHz)', ylabel='Intensity (dB SPL)', plotTitle='Frequency Tuning Curve', flipFirstAxis=True, flipSecondAxis=False, timeRange=[0, 0.1]) plt.ylabel('Intensity (dB SPL)') plt.xlabel('Frequency (kHz)') plt.title('Frequency Tuning Curve') # -- plot frequency tuning raster -- plt.subplot2grid((12,15), (0, 7), rowspan = 4, colspan = 4) freqLabels = ["%.1f" % freq for freq in np.unique(currentFreq)/1000.0] dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, sortArray=currentFreq, timeRange=[-0.1, 0.5], labels=freqLabels) plt.xlabel('Time from sound onset (sec)') plt.ylabel('Frequency (kHz)') plt.title('Frequency Tuning Raster') # -- plot AM PSTH -- eventData = ei2.loader.get_session_events(sessions[2]) spikeData = ei2.loader.get_session_spikes(sessions[2], tetrode, cluster=cluster) eventOnsetTimes = ei2.loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.2, 1.5] spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimestamps, eventOnsetTimes, timeRange) colourList = ['b', 'g', 'y', 'orange', 'r'] numRates = np.unique(currentRate) trialsEachCond = behavioranalysis.find_trials_each_type(currentRate, numRates) binEdges = np.around(np.arange(-0.2, 0.85, 0.05), decimals=2) spikeCountMat = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset, indexLimitsEachTrial, binEdges) plt.subplot2grid((12,15), (5, 11), rowspan = 4, colspan = 4) pPSTH = extraplots.plot_psth(spikeCountMat/0.05, 1, binEdges[:-1], trialsEachCond, colorEachCond=colourList) plt.setp(pPSTH) plt.xlabel('Time from sound onset (sec)') plt.ylabel('Firing rate (Hz)') plt.title('AM PSTH') # -- plot AM raster -- plt.subplot2grid((12,15), (0, 11), rowspan = 4, colspan = 4) rateLabels = ["%.1f" % rate for rate in np.unique(currentRate)] dataplotter.plot_raster(spikeTimestamps, eventOnsetTimes, sortArray=currentRate, timeRange=[-0.2, 0.8], labels=rateLabels, colorEachCond=colourList) plt.xlabel('Time from sound onset (sec)') plt.ylabel('Modulation Rate (Hz)') plt.title('AM Raster') # -- show cluster analysis -- tsThisCluster = oneTT.timestamps[oneTT.clusters==cluster] wavesThisCluster = oneTT.samples[oneTT.clusters==cluster] # -- Plot ISI histogram -- plt.subplot2grid((12,15), (10,6), rowspan=2, colspan=3) spikesorting.plot_isi_loghist(tsThisCluster) plt.ylabel('c%d'%cluster,rotation=0,va='center',ha='center') plt.xlabel('') # -- Plot waveforms -- plt.subplot2grid((12,15), (10,9), rowspan=2, colspan=3) spikesorting.plot_waveforms(wavesThisCluster) # -- Plot projections -- plt.subplot2grid((12,15), (10,12), rowspan=1, colspan=3) spikesorting.plot_projections(wavesThisCluster) # -- Plot events in time -- plt.subplot2grid((12,15), (11,12), rowspan=1, colspan=3) spikesorting.plot_events_in_time(tsThisCluster) plt.subplots_adjust(wspace = 1.5) plt.suptitle('{0}, {1}, {2}, Tetrode {3}, Cluster {4}, {5}kHz, {6}Hz modulation'.format(mouse, date, siteName, tetrode, cluster, charfreq, modrate)) fig_path = oneTT.clustersDir fig_name = 'TT{0}Cluster{1}.png'.format(tetrode, cluster) full_fig_path = os.path.join(fig_path, fig_name) fig = plt.gcf() fig.set_size_inches(24, 12) fig.savefig(full_fig_path, format = 'png', bbox_inches='tight')
print possibleFreq numberOfFrequencies = len(possibleFreq) numberOfTrials = len(bdata['choice']) targetFreqs = bdata['targetFrequency'] currentBlock = bdata['currentBlock'] #######20160324 Implemented trialLimit constraint to exclude blocks with few trials at the end of a behav session if(not len(trialLimit)): validTrials = np.ones(len(currentBlock),dtype=bool) else: validTrials = np.zeros(len(currentBlock),dtype=bool) validTrials[trialLimit[0]:trialLimit[1]] = 1 blockTypes = [bdata.labels['currentBlock']['same_reward'],bdata.labels['currentBlock']['more_left'],bdata.labels['currentBlock']['more_right']] #blockLabels = ['same_reward','more_left', 'more_right'] trialsEachType = behavioranalysis.find_trials_each_type(currentBlock,blockTypes) #trialsEachType is an array of dimension nTrials*nblockTypes where boolean vector (in a column) indicates which trials are in each type of block for possFreq in possibleFreq: modIDict[behavSession][possFreq] = np.zeros([clusNum*numTetrodes]) #0 being no modIndex modSigDict[behavSession][possFreq] = np.ones([clusNum*numTetrodes]) #1 being no significance test # -- Load Spike Data From Certain Cluster -- spkData = ephyscore.CellData(oneCell) spkTimeStamps = spkData.spikes.timestamps clusterNumber = (oneCell.tetrode-1)*clusNum+(oneCell.cluster-1) for Freq in possibleFreq: oneFreq = targetFreqs == Freq if Freq <= 9500: #Arbitrary boundary based on behavior sessions so far. This is a 'low' freq - going left trial trialsToUseMoreReward = trialsEachType[:,1]&oneFreq&correct&validTrials #trialsEachType[:,1] are all the 'more_left' trials.
freqEachTrial = freqEachTrial[:nTrials] intensityEachTrial = intensityEachTrial[:nTrials] eventOnsetTimes = eventOnsetTimes[:nTrials] possibleFreq = np.unique(freqEachTrial) possibleIntensity = np.unique(intensityEachTrial) # -- Find trials for each frequency and sort them -- if selectedIntensity is None: selectedTrials = np.ones(nTrials,dtype=bool) else: selectedTrials = (intensityEachTrial==selectedIntensity) freqEachTrial = freqEachTrial[selectedTrials] trialsEachFreq = behavioranalysis.find_trials_each_type(freqEachTrial,possibleFreq) ###trialsEachFreq &= selectedTrials[:,np.newaxis] numTrialsEachFreq = trialsEachFreq.sum(axis=0) sortedTrials = np.nonzero(trialsEachFreq.T)[1] # The second array contains the sorted indexes sortingInds = np.argsort(sortedTrials) # gives array of indices that would sort the sortedTrials eventOnsetTimes = eventOnsetTimes[selectedTrials] for indt,tetrodeID in enumerate(tetrodes): spikesFilename = os.path.join(fullephysDir, 'Tetrode{0}.spikes'.format(tetrodeID)) # make a path to ephys spike data of specified tetrode tetrodeID sp = loadopenephys.DataSpikes(spikesFilename) # load spike data from specified tetrode tetrodeID spkTimeStamps = np.array(sp.timestamps)/SAMPLING_RATE # array of timestamps for each spike in seconds (thats why you divide by sampling rate) (spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial) = \ spikesanalysis.eventlocked_spiketimes(spkTimeStamps,eventOnsetTimes,timeRange)
nAnimals = len(subjects) gs = gridspec.GridSpec(nAnimals, 1)#changed from nAnimals to plot one animal with multiple sessions gs.update(hspace=0.5,wspace=0.4) plt.clf() for inda, thisAnimal in enumerate(subjects): allBehavDataThisAnimal = behavioranalysis.load_many_sessions(thisAnimal,sessions) targetFrequency = allBehavDataThisAnimal['targetFrequency'] choice=allBehavDataThisAnimal['choice'] valid=allBehavDataThisAnimal['valid']& (choice!=allBehavDataThisAnimal.labels['choice']['none']) choiceRight = choice==allBehavDataThisAnimal.labels['choice']['right'] currentBlock = allBehavDataThisAnimal['currentBlock'] blockTypes = [allBehavDataThisAnimal.labels['currentBlock']['same_reward'],allBehavDataThisAnimal.labels['currentBlock']['more_left'],allBehavDataThisAnimal.labels['currentBlock']['more_right']] blockLabels = ['same_reward','more_left', 'more_right'] trialsEachType = behavioranalysis.find_trials_each_type(currentBlock,blockTypes) #print trialsEachType nBlocks = len(blockTypes) thisAnimalPos = inda ax1=plt.subplot(gs[thisAnimalPos]) fontsize = 12 allPline = [] legendLabels = [] for blockType in range(nBlocks): targetFrequencyThisBlock = targetFrequency[trialsEachType[:,blockType]] validThisBlock = valid[trialsEachType[:,blockType]] choiceRightThisBlock = choiceRight[trialsEachType[:,blockType]] #currentBlockValue = currentBlock[trialsEachBlock[0,block]] (possibleValues,fractionHitsEachValue,ciHitsEachValue,nTrialsEachValue,nHitsEachValue)=\ behavioranalysis.calculate_psychometric(choiceRightThisBlock,targetFrequencyThisBlock,validThisBlock)
#ex0624.plot_sorted_tuning_raster('15-31-48', 6, 'a', ms=4) import numpy as np from jaratoolbox import extraplots from jaratoolbox import behavioranalysis from jaratoolbox import spikesanalysis import matplotlib import matplotlib.pyplot as plt bdata = ex0624.get_session_behav_data('15-31-48','a') freqEachTrial = bdata['currentFreq'] intensityEachTrial = bdata['currentIntensity'] possibleFreq = np.unique(freqEachTrial) possibleIntensity = np.unique(intensityEachTrial) trialsEachCond = behavioranalysis.find_trials_each_combination(intensityEachTrial, possibleIntensity, freqEachTrial, possibleFreq) trialsEachCondFreq = behavioranalysis.find_trials_each_type(freqEachTrial, possibleFreq) trialsEachCondInt = behavioranalysis.find_trials_each_type(intensityEachTrial, possibleIntensity) spikeData = ex0624.get_session_spike_data_one_tetrode('15-31-48', 6) eventData = ex0624.get_session_event_data('15-31-48') eventOnsetTimes = ex0624.get_event_onset_times(eventData) eventOnsetTimes = eventOnsetTimes[:-1] #FIXME: WHY IS THIS NECESSARY????!! spikeTimestamps=spikeData.timestamps timeRange = [0, 0.1] spikeTimesFromEventOnset,trialIndexForEachSpike,indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes(spikeTimestamps, eventOnsetTimes,