def calculate_highest_significant_sync_rate(self, dataframe=None): #Use the whole database by default if dataframe is None: dataframe = self.db #Highest significant sync rate #TODO: I need to unit test this part highestSync = np.empty(len(dataframe)) for indCell, cell in dataframe.iterrows(): spikeData, eventData = dataloader.get_session_ephys(cell, 'am') bdata = dataloader.get_session_bdata(cell, 'am') eventOnsetTimes = eventData.get_event_onset_times(eventChannel=5) eventOnsetTimes = spikesanalysis.minimum_event_onset_diff( eventOnsetTimes, 0.5) if spikeData.samples is not None: #NOTE: This is where I am ignoring the onset response. is 50msec sufficient?? timeRange = [0.05, 0.5] freqEachTrial = bdata['currentFreq'] possibleFreq = np.unique(freqEachTrial) (spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes( spikeData.timestamps, eventOnsetTimes, timeRange) allRayleighPvals = np.zeros(len(possibleFreq)) for indFreq, oneFreq in enumerate(possibleFreq): trialsThisFreq = np.flatnonzero(freqEachTrial == oneFreq) spikeTimesThisFreq = spikeTimesFromEventOnset[np.in1d( trialIndexForEachSpike, trialsThisFreq)] #Number of radians in one second for this stimulus frequency radsPerSec = oneFreq * 2 * np.pi period = 1.0 / oneFreq spikeRads = (spikeTimesThisFreq * radsPerSec) % (2 * np.pi) #Compute average vector length and angle strength, phase = signal.vectorstrength( spikeTimesThisFreq, period) #Compute prob for the rayleigh statistic p = self.rayleigh_test(strength, len(spikeTimesThisFreq)) allRayleighPvals[indFreq] = p if np.any(allRayleighPvals < 0.05): hs = np.max(possibleFreq[allRayleighPvals < 0.05]) else: hs = 0 highestSync[indCell] = hs else: highestSync[indCell] = 0 dataframe['highestSync'] = highestSync
def test_opposite_2dperiod(self): events = np.array([0, .25, .5, .75]) period = [1.] * 10 targ_strength = [0.] * 10 strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 1) assert_equal(phase.ndim, 1) assert_almost_equal(strength, targ_strength)
def get_vector_strength(self, times): """ Calculates the vector strength of this run returns: (strength, phase) """ period = self.opt_pulse_isi + self.opt_pulse_width events = [times[x] for x in self.peaks] return vectorstrength(events, period)
def test_opposite_2dperiod(self): events = np.array([0, .25, .5, .75]) period = [1.]*10 targ_strength = [0.]*10 strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 1) assert_equal(phase.ndim, 1) assert_almost_equal(strength, targ_strength)
def test_single_1dperiod(self): events = np.array([.5]) period = 5. targ_strength = 1. targ_phase = .1 strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 0) assert_equal(phase.ndim, 0) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2*np.pi*targ_phase)
def test_partial_2dperiod(self): events = np.array([.25, .5, .75]) period = [1., 1., 1., 1.] targ_strength = [1. / 3.] * 4 targ_phase = np.array([.5, .5, .5, .5]) strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 1) assert_equal(phase.ndim, 1) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2 * np.pi * targ_phase)
def test_spaced_2dperiod(self): events = np.array([.1, 1.1, 2.1, 4.1, 10.1]) period = [1, .5] targ_strength = [1.] * 2 targ_phase = np.array([.1, .2]) strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 1) assert_equal(phase.ndim, 1) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2 * np.pi * targ_phase)
def test_partial_1dperiod(self): events = np.array([.25, .5, .75]) period = 1 targ_strength = 1. / 3. targ_phase = .5 strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 0) assert_equal(phase.ndim, 0) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2 * np.pi * targ_phase)
def test_single_2dperiod(self): events = np.array([.5]) period = [1, 2, 5.] targ_strength = [1.] * 3 targ_phase = np.array([.5, .25, .1]) strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 1) assert_equal(phase.ndim, 1) assert_array_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2 * np.pi * targ_phase)
def test_spaced_1dperiod(self): events = np.array([.1, 1.1, 2.1, 4.1, 10.1]) period = 1 targ_strength = 1. targ_phase = .1 strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 0) assert_equal(phase.ndim, 0) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2 * np.pi * targ_phase)
def test_single_2dperiod(self): events = np.array([.5]) period = [1, 2, 5.] targ_strength = [1.]*3 targ_phase = np.array([.5, .25, .1]) strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 1) assert_equal(phase.ndim, 1) assert_array_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2*np.pi*targ_phase)
def test_single_1dperiod(self): events = np.array([.5]) period = 5. targ_strength = 1. targ_phase = .1 strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 0) assert_equal(phase.ndim, 0) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2 * np.pi * targ_phase)
def test_partial_2dperiod(self): events = np.array([.25, .5, .75]) period = [1., 1., 1., 1.] targ_strength = [1./3.]*4 targ_phase = np.array([.5, .5, .5, .5]) strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 1) assert_equal(phase.ndim, 1) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2*np.pi*targ_phase)
def test_partial_1dperiod(self): events = np.array([.25, .5, .75]) period = 1 targ_strength = 1./3. targ_phase = .5 strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 0) assert_equal(phase.ndim, 0) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2*np.pi*targ_phase)
def test_spaced_2dperiod(self): events = np.array([.1, 1.1, 2.1, 4.1, 10.1]) period = [1, .5] targ_strength = [1.]*2 targ_phase = np.array([.1, .2]) strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 1) assert_equal(phase.ndim, 1) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2*np.pi*targ_phase)
def test_spaced_1dperiod(self): events = np.array([.1, 1.1, 2.1, 4.1, 10.1]) period = 1 targ_strength = 1. targ_phase = .1 strength, phase = vectorstrength(events, period) assert_equal(strength.ndim, 0) assert_equal(phase.ndim, 0) assert_almost_equal(strength, targ_strength) assert_almost_equal(phase, 2*np.pi*targ_phase)
def calculate_am_significance_synchronization(amSyncSpikeTimesFromEventOnset, amSyncTrialIndexForEachSpike, amCurrentFreq, amUniqFreq): """ Args: amSpikeTimes (np.array): Each value is a time when a spike occurred. Obatained from Ephys Data amOnsetTimes (np.array): Contains as many values as there were trials with each value being the tme a trial started. amBaseTime (list): Contains two values that represent the time range for the base firing rate amOnsetTime (list): Contains two values that represent the time range for the onset firing rate amCurrentFreq (np.array): Contains as many values as there were trials with each value being the am rate for a specific trial. Obtained from Behavior Data amUniqFreq (np.array): Contains as many values as there were unique am rates presented over the entire session. Returns: allFreqSyncPVal (np.array): Contains one p-value for each unique am rate presented over the entire session allFreqSyncZScore (np.array): Contains one z-value for each unique am rate presented over the entire session allFreqVectorStrength (np.array): allFreqRal (np.array): """ numFreq = len(amUniqFreq) allFreqSyncPVal = np.empty(numFreq) allFreqVectorStrength = np.empty(numFreq) allFreqRal = np.empty(numFreq) allFreqSyncZScore = np.empty(numFreq) for indFreq, (freq, spiketimes, trialInds) in enumerate( spiketimes_each_frequency(amSyncSpikeTimesFromEventOnset, amSyncTrialIndexForEachSpike, amCurrentFreq)): strength, phase = signal.vectorstrength(spiketimes, 1.0 / freq) radsPerSec = freq * 2 * np.pi spikeRads = (spiketimes * radsPerSec) % (2 * np.pi) ral = np.array([2 * len(spiketimes) * (strength**2)]) # NOTE: I checked the math in this function using the text referenced (Mike W. has a copy if needed) - Nick zVal, pVal = rayleigh_test(spikeRads) allFreqVectorStrength[indFreq] = strength # Frequency vector strength allFreqRal[indFreq] = ral # Unsure what this is allFreqSyncPVal[indFreq] = pVal # p-value allFreqSyncZScore[indFreq] = zVal return allFreqSyncPVal, allFreqSyncZScore, allFreqVectorStrength, allFreqRal
def calculate_phase_discrim_accuracy(spikeTimes, eventOnsetTimes, currentFreq, uniqFreq, shuffle=False): SHUFFLE = shuffle # Timerange for alignment? timeRange = [ 0.05, 0.5 ] # Ignoring onset responses TODO: Is this the best way to do this?? phaseDiscrimAccuracy = {} for thisFreq in uniqFreq: # Only use events for this frequency eventsThisFreq = eventOnsetTimes[currentFreq == thisFreq] (spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes( spikeTimes, eventsThisFreq, timeRange) # This is really all we need to do to bin things by phase. radsPerSec = thisFreq * 2 * np.pi spikeRads = (spikeTimesFromEventOnset * radsPerSec) % (2 * np.pi) strength, phase = signal.vectorstrength(spikeTimesFromEventOnset, 1.0 / thisFreq) phase = (phase + 2 * np.pi) % (2 * np.pi) shiftedRads = ((spikeRads - phase) + 2.25 * np.pi) if any(shiftedRads < 0): raise ValueError("Some shifted rads below 0") # shiftedRads = ((spikeRads - phase) + 2.25*np.pi)%(2*np.pi) spikeRads = shiftedRads % (2 * np.pi) nBins = 4 binEdges = np.arange(0, 2.01 * np.pi, 2 * np.pi / nBins) # The 2.01 makes it actually include 2pi spikeCountMat = spikesanalysis.spiketimes_to_spikecounts( spikeRads, indexLimitsEachTrial, binEdges) spikeCountMatCopy = copy.deepcopy(spikeCountMat) spikeCountMatShuffle = np.empty(np.shape(spikeCountMatCopy)) for indMatRow in range(np.shape(spikeCountMatCopy)[0]): numRolls = np.random.choice(range(np.shape(spikeCountMatCopy)[1])) # numRolls = 0 spikeCountMatShuffle[indMatRow, :] = np.roll( spikeCountMatCopy[indMatRow, :], numRolls) if SHUFFLE: spikeCountMat = spikeCountMatShuffle binMeans = np.mean(spikeCountMat, axis=0) prefInd = np.argmax(binMeans) nonPrefInd = np.argmin(binMeans) spikesPref = spikeCountMat[:, prefInd] spikesNonPref = spikeCountMat[:, nonPrefInd] maxAccuracy, threshold = linear_discriminator(spikesPref, spikesNonPref) # dataframe.set_value(indRow, 'phaseAccuracy_{}Hz'.format(int(thisFreq)), maxAccuracy) phaseDiscrimAccuracy[int(thisFreq)] = maxAccuracy return phaseDiscrimAccuracy
dataframe.loc[indRow, 'highestSync'] = np.nan print "Breaking, no significant response" continue ### ------------------------------------------------------------ ### ### --- Calculate vector strength and significance --- ### timeRange = [0.1, 0.5] #DONE: Use this to cut out onset responses (spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial) = spikesanalysis.eventlocked_spiketimes( spikeTimes, eventOnsetTimes, timeRange) freqEachTrial = bdata['currentFreq'] for indFreq, (freq, spiketimes, trialInds) in enumerate( spiketimes_each_frequency(spikeTimesFromEventOnset, trialIndexForEachSpike, freqEachTrial)): strength, phase = signal.vectorstrength(spiketimes, 1.0 / freq) # vsArr = np.concatenate((vsArr, np.array([strength]))) #TODO: Check the math here radsPerSec = freq * 2 * np.pi spikeRads = (spiketimes * radsPerSec) % (2 * np.pi) ral = np.array([2 * len(spiketimes) * (strength**2)]) #NOTE: I checked the math in this function using the text referenced (Mike W. has a copy if needed) zVal, pVal = rayleigh_test(spikeRads) allFreqVS[indFreq] = strength allFreqRal[indFreq] = ral allFreqPval[indFreq] = pVal # # pValArr = np.concatenate((pValArr, np.array([pVal])))
def cpu_version(self, events, period): return signal.vectorstrength(events, period)