cellInfo = signRespCells[[
'subject', 'date', 'depth', 'tetrode', 'cluster'
]]
#print(cellInfo)
numSignRespCells = len(signRespCells)
print('Number of cells recorded from: {}'.format(len(celldb)))
print('Number of responsive cells: {}'.format(len(responsivedb)))
print(
'Number of cells that showed a significant difference between expected and unexpected firing rates: {}'
.format(numSignRespCells))
percentSignRespCells = numSignRespCells / len(responsivedb) * 100
print('Percentage of significantly responsive cells: {:.2f}%'.format(
percentSignRespCells))
return signRespCells
signRespCellsdb = comparing_odd_std_significance(responsivedb)
'''
# -- Saving the responsive database --
celldatabase.save_hdf(responsivedb, dbFilename)
print('Saved responsive database to {}'.format(dbFilename))
# -- Saving the database of significantly responsive cells. --
dbPath = os.path.join(settings.FIGURES_DATA_PATH, studyparams.STUDY_NAME)
dbFilename = os.path.join(dbPath,'signRespCellsdb_{}.h5'.format(studyparams.STUDY_NAME))
celldatabase.save_hdf(signRespCellsdb, dbFilename)
print('Saved significantly responsive cell database to {}'.format(dbFilename))
'''
continue
highBaseD = signRespCells['meanBaseHighD'][indRow]
highEvokedD = signRespCells['meanEvokedHighD'][indRow]
midBaseD = signRespCells['meanBaseMidD'][indRow]
midEvokedD = signRespCells['meanEvokedMidD'][indRow]
lowBaseD = signRespCells['meanBaseLowD'][indRow]
lowEvokedD = signRespCells['meanEvokedLowD'][indRow]
if signRespCells['mostRespFreqPValueOddStdD'][indRow] == signRespCells[
'pValHighFRD'][indRow]:
if highBaseD > highEvokedD:
suppressedCells.append(signRespCells.iloc[indRow])
elif signRespCells['mostRespFreqPValueOddStdD'][indRow] == signRespCells[
'pValMidFRD'][indRow]:
if midBaseD > midEvokedD:
suppressedCells.append(signRespCells.iloc[indRow])
else:
if lowBaseD > lowEvokedD:
suppressedCells.append(signRespCells.iloc[indRow])
suppresseddb = pd.DataFrame(suppressedCells)
# -- Saving the database of suppressed significantly responsive cells. --
dbPath = os.path.join(settings.FIGURES_DATA_PATH, studyparams.STUDY_NAME)
dbFilename = os.path.join(
dbPath, 'suppressedRespCellsdb_{}.h5'.format(studyparams.STUDY_NAME))
celldatabase.save_hdf(suppresseddb, dbFilename)
print('Saved suppressed firing significantly responsive cell database to {}'.
format(dbFilename))
maxSpikesThisInten = 0
meanSpikesAllInten[indInten] = meanSpikesThisInten
maxSpikesAllInten[indInten] = maxSpikesThisInten
baseSpikesAllInten[indInten] = meanBaselineSpikesThisInten
baseline = np.mean(baseSpikesAllInten)
monoIndex = (meanSpikesAllInten[-1] - baseline) / (np.max(meanSpikesAllInten)-baseline)
dbToUse.loc[indRow, 'monotonicityIndex'] = monoIndex
overallMaxSpikes = np.max(maxSpikesAllInten)
maxSpikes.append(overallMaxSpikes)
if SAVE:
celldatabase.save_hdf(database, dbPath)
if PLOT:
def jitter(arr, frac):
jitter = (np.random.random(len(arr))-0.5)*2*frac
jitteredArr = arr + jitter
return jitteredArr
plt.clf()
ax = plt.subplot(111)
colorATh = 'b'
colorAC = 'r'
ac = dbToUse.groupby('brainArea').get_group('rightAC')
thal = dbToUse.groupby('brainArea').get_group('rightThal')
# TODO: Need to loop through d1mice as it is a list
inforecFile = os.path.join(settings.INFOREC_PATH, '{}_inforec.py'.format(d1mice))
clusteringObj = spikesorting.ClusterInforec(inforecFile)
clusteringObj.process_all_experiments()
pass
# Generate_cell_database_filters cells with the followings: isi < 0.05, spike quality > 2
basicDB = celldatabase.generate_cell_database_from_subjects(d1mice)
firstDB = basicDB
d1DBFilename = os.path.join(settings.FIGURES_DATA_PATH, '{}_d1mice.h5'.format(studyparams.STUDY_NAME))
# Create and save a database, computing first the base stats and then the indices
if calc_stats:
firstDB = append_base_stats(basicDB, filename=d1DBFilename)
# bestCells = calculate_indices(firstDB, filename = d1DBFilename)
histDB = firstDB
celldatabase.save_hdf(histDB, os.path.join(dbLocation, '{}.h5'.format('temp_rescue_db')))
if calc_locations:
histDB = histologyanalysis.cell_locations(firstDB, brainAreaDict=studyparams.BRAIN_AREA_DICT)
if concat_mice:
first_mouse, *list_of_mice = studyparams.ASTR_D1_CHR2_MICE
histDB = merge_dataframes(list_of_mice, first_mouse)
dbpath = os.path.join(dbLocation, '{}.h5'.format('direct_and_indirect_cells'))
if SAVE:
if os.path.isdir(dbLocation):
celldatabase.save_hdf(histDB, dbpath)
print("SAVED DATAFRAME to {}".format(dbpath))
elif not os.path.isdir(dbLocation):
answer = input_func("Save folder is not present. Would you like to make the desired directory now? (y/n) ")
if answer.upper() in ['Y', 'YES']:
nspkBase = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, baseRange)
nspkResp = spikesanalysis.spiketimes_to_spikecounts(
spikeTimesFromEventOnset, indexLimitsEachTrial, responseRange)
avgResponse = nspkResp.mean(axis=0)
onsetSpikes = avgResponse[0]
sustainedSpikes = avgResponse[1]
onsetRate = onsetSpikes / (responseRange[1] - responseRange[0])
sustainedRate = sustainedSpikes / (responseRange[2] - responseRange[1])
baseSpikes = nspkBase.mean()
baseRate = baseSpikes / (baseRange[1] - baseRange[0])
onsetBaseSubtracted = onsetRate - baseRate
sustainedBaseSubtracted = sustainedRate - baseRate
# baseSub = avgResponse - avgBase
# normResponse = baseSub / baseSub[0]
db.at[indRow, 'onsetRateCF'] = onsetRate
db.at[indRow, 'sustainedRateCF'] = sustainedRate
db.at[indRow, 'baselineRateCF'] = baseRate
db['cfOnsetivityIndex'] = (db['onsetRateCF'] - db['sustainedRateCF']) / (
db['sustainedRateCF'] + db['onsetRateCF'])
if SAVE:
celldatabase.save_hdf(db, pathtoDB)
def inactivation_indices(db, filename=''):
bestCells = db.query("isiViolations<0.02") # or modifiedISI<0.02")
bestCells = bestCells.loc[bestCells['spikeShapeQuality'] > 2]
bestCells = bestCells.query(
'soundResponsePVal<0.05 or onsetSoundResponsePVal<0.05 or sustainedSoundResponsePVal<0.05'
)
bestCells = bestCells.loc[bestCells['tuningFitR2'] > 0.05]
bestCells = bestCells.loc[bestCells['octavesFromPrefFreq'] < 0.5]
for dbIndex, dbRow in bestCells.iterrows():
cell = ephyscore.Cell(dbRow)
bandEphysData, bandBehavData = cell.load_by_index(
int(dbRow['bestBandSession']))
bandEventOnsetTimes = funcs.get_sound_onset_times(
bandEphysData, 'bandwidth')
bandSpikeTimestamps = bandEphysData['spikeTimes']
bandEachTrial = bandBehavData['currentBand']
secondSort = bandBehavData['laserTrial']
propOnset, propSustained = funcs.onset_sustained_spike_proportion(
bandSpikeTimestamps, bandEventOnsetTimes)
db.at[dbIndex, 'proportionSpikesOnset'] = propOnset
db.at[dbIndex, 'proportionSpikesSustained'] = propSustained
#by default: not subtracting baseline, but are replacing pure tone response with baseline for 0 bw condition
onsetSupInds, onsetSupIndpVals, onsetFacInds, onsetFacIndpVals, onsetPeakInds, onsetSpikeArray = funcs.bandwidth_suppression_from_peak(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange=[0.0, 0.05],
baseRange=[-0.05, 0.0])
db.at[dbIndex, 'onsetSuppressionIndexLaser'] = onsetSupInds[-1]
db.at[dbIndex, 'onsetSuppressionpValLaser'] = onsetSupIndpVals[-1]
db.at[dbIndex, 'onsetFacilitationIndexLaser'] = onsetFacInds[-1]
db.at[dbIndex, 'onsetFacilitationpValLaser'] = onsetFacIndpVals[-1]
db.at[dbIndex,
'onsetPrefBandwidthLaser'] = bandEachTrial[onsetPeakInds[-1]]
db.at[dbIndex, 'onsetSuppressionIndexNoLaser'] = onsetSupInds[0]
db.at[dbIndex, 'onsetSuppressionpValNoLaser'] = onsetSupIndpVals[0]
db.at[dbIndex, 'onsetFacilitationIndexNoLaser'] = onsetFacInds[0]
db.at[dbIndex, 'onsetFacilitationpValNoLaser'] = onsetFacIndpVals[0]
db.at[dbIndex,
'onsetPrefBandwidthNoLaser'] = bandEachTrial[onsetPeakInds[0]]
#base range is right before sound onset so we get estimate for laser baseline
sustainedSupInds, sustainedSupIndpVals, sustainedFacInds, sustainedFacIndpVals, sustainedPeakInds, sustainedSpikeArray = funcs.bandwidth_suppression_from_peak(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange=[0.2, 1.0],
baseRange=[-0.05, 0.0])
db.at[dbIndex, 'sustainedSuppressionIndexLaser'] = sustainedSupInds[-1]
db.at[dbIndex,
'sustainedSuppressionpValLaser'] = sustainedSupIndpVals[-1]
db.at[dbIndex,
'sustainedFacilitationIndexLaser'] = sustainedFacInds[-1]
db.at[dbIndex,
'sustainedFacilitationpValLaser'] = sustainedFacIndpVals[-1]
db.at[dbIndex, 'sustainedPrefBandwidthLaser'] = bandEachTrial[
sustainedPeakInds[-1]]
db.at[dbIndex,
'sustainedSuppressionIndexNoLaser'] = sustainedSupInds[0]
db.at[dbIndex,
'sustainedSuppressionpValNoLaser'] = sustainedSupIndpVals[0]
db.at[dbIndex,
'sustainedFacilitationIndexNoLaser'] = sustainedFacInds[0]
db.at[dbIndex,
'sustainedFacilitationpValNoLaser'] = sustainedFacIndpVals[0]
db.at[dbIndex, 'sustainedPrefBandwidthNoLaser'] = bandEachTrial[
sustainedPeakInds[0]]
#no laser fit
sustainedResponseNoLaser = sustainedSpikeArray[:, 0]
bandsForFit = np.unique(bandEachTrial)
bandsForFit[-1] = 6
mFixed = 1
fitParams, R2 = fitfuncs.diff_of_gauss_fit(bandsForFit,
sustainedResponseNoLaser,
mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0noLaser'] = fitParams[0]
db.at[dbIndex, 'RDnoLaser'] = fitParams[3]
db.at[dbIndex, 'RSnoLaser'] = fitParams[4]
db.at[dbIndex, 'mnoLaser'] = mFixed
db.at[dbIndex, 'sigmaDnoLaser'] = fitParams[1]
db.at[dbIndex, 'sigmaSnoLaser'] = fitParams[2]
db.at[dbIndex, 'bandwidthTuningR2noLaser'] = R2
testBands = np.linspace(bandsForFit[0], bandsForFit[-1], 500)
allFitParams = [mFixed]
allFitParams.extend(fitParams)
suppInd, prefBW = fitfuncs.extract_stats_from_fit(
allFitParams, testBands)
db.at[dbIndex, 'fitSustainedSuppressionIndexNoLaser'] = suppInd
db.at[dbIndex, 'fitSustainedPrefBandwidthNoLaser'] = prefBW
#laser fit
sustainedResponseLaser = sustainedSpikeArray[:, 1]
fitParamsLaser, R2Laser = fitfuncs.diff_of_gauss_fit(
bandsForFit, sustainedResponseLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0laser'] = fitParamsLaser[0]
db.at[dbIndex, 'RDlaser'] = fitParamsLaser[3]
db.at[dbIndex, 'RSlaser'] = fitParamsLaser[4]
db.at[dbIndex, 'mlaser'] = mFixed
db.at[dbIndex, 'sigmaDlaser'] = fitParamsLaser[1]
db.at[dbIndex, 'sigmaSlaser'] = fitParamsLaser[2]
db.at[dbIndex, 'bandwidthTuningR2laser'] = R2Laser
allFitParamsLaser = [mFixed]
allFitParamsLaser.extend(fitParamsLaser)
suppIndLaser, prefBWLaser = fitfuncs.extract_stats_from_fit(
allFitParamsLaser, testBands)
db.at[dbIndex, 'fitSustainedSuppressionIndexLaser'] = suppIndLaser
db.at[dbIndex, 'fitSustainedPrefBandwidthLaser'] = prefBWLaser
meanLaserDiff = np.mean(sustainedResponseLaser -
sustainedResponseNoLaser)
db.at[dbIndex, 'laserChangeResponse'] = meanLaserDiff
laserDiff = sustainedResponseLaser - sustainedResponseNoLaser
peakInd = np.argmax(sustainedResponseNoLaser)
db.at[dbIndex, 'peakChangeFR'] = laserDiff[peakInd]
db.at[dbIndex, 'WNChangeFR'] = laserDiff[-1]
testRespsNoLaser = fitfuncs.diff_gauss_form(testBands, *allFitParams)
testRespsLaser = fitfuncs.diff_gauss_form(testBands,
*allFitParamsLaser)
laserDiffModel = testRespsLaser - testRespsNoLaser
peakIndModel = np.argmax(testRespsNoLaser)
db.at[dbIndex, 'fitPeakChangeFR'] = laserDiffModel[peakIndModel]
db.at[dbIndex, 'fitWNChangeFR'] = laserDiffModel[-1]
#also calculating fits and suppression with pure tone being 0 bw condition
toneSustainedSupInds, toneSustainedSupIndpVals, toneSustainedFacInds, toneSustainedFacIndpVals, toneSustainedPeakInds, toneSustainedSpikeArray = funcs.bandwidth_suppression_from_peak(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange=[0.2, 1.0],
baseRange=[-0.05, 0.0],
zeroBWBaseline=False)
db.at[
dbIndex,
'sustainedSuppressionIndexNoLaserPureTone'] = toneSustainedSupInds[
0]
db.at[
dbIndex,
'sustainedSuppressionpValNoLaserPureTone'] = toneSustainedSupIndpVals[
0]
db.at[
dbIndex,
'sustainedFacilitationIndexNoLaserPureTone'] = toneSustainedFacInds[
0]
db.at[
dbIndex,
'sustainedFacilitationpValNoLaserPureTone'] = toneSustainedFacIndpVals[
0]
db.at[dbIndex,
'sustainedPrefBandwidthNoLaserPureTone'] = bandEachTrial[
toneSustainedPeakInds[0]]
db.at[dbIndex,
'sustainedSuppressionIndexLaserPureTone'] = toneSustainedSupInds[
-1]
db.at[
dbIndex,
'sustainedSuppressionpValLaserPureTone'] = toneSustainedSupIndpVals[
-1]
db.at[
dbIndex,
'sustainedFacilitationIndexLaserPureTone'] = toneSustainedFacInds[
-1]
db.at[
dbIndex,
'sustainedFacilitationpValLaserPureTone'] = toneSustainedFacIndpVals[
-1]
db.at[dbIndex, 'sustainedPrefBandwidthLaserPureTone'] = bandEachTrial[
toneSustainedPeakInds[-1]]
toneSustainedResponseNoLaser = toneSustainedSpikeArray[:, 0]
toneFitParamsNoLaser, toneR2 = fitfuncs.diff_of_gauss_fit(
bandsForFit, toneSustainedResponseNoLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0PureToneNoLaser'] = toneFitParamsNoLaser[0]
db.at[dbIndex, 'RDPureToneNoLaser'] = toneFitParamsNoLaser[3]
db.at[dbIndex, 'RSPureToneNoLaser'] = toneFitParamsNoLaser[4]
db.at[dbIndex, 'mPureToneNoLaser'] = mFixed
db.at[dbIndex, 'sigmaDPureToneNoLaser'] = toneFitParamsNoLaser[1]
db.at[dbIndex, 'sigmaSPureToneNoLaser'] = toneFitParamsNoLaser[2]
db.at[dbIndex, 'bandwidthTuningR2PureToneNoLaser'] = toneR2
allFitParamsToneNoLaser = [mFixed]
allFitParamsToneNoLaser.extend(toneFitParamsNoLaser)
suppIndTone, prefBWTone = fitfuncs.extract_stats_from_fit(
allFitParamsToneNoLaser, testBands)
db.at[dbIndex,
'fitSustainedSuppressionIndexPureToneNoLaser'] = suppIndTone
db.at[dbIndex, 'fitSustainedPrefBandwidthPureToneNoLaser'] = prefBWTone
toneSustainedResponseLaser = toneSustainedSpikeArray[:, 1]
toneFitParamsLaser, toneR2Laser = fitfuncs.diff_of_gauss_fit(
bandsForFit, toneSustainedResponseLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0PureToneLaser'] = toneFitParamsLaser[0]
db.at[dbIndex, 'RDPureToneLaser'] = toneFitParamsLaser[3]
db.at[dbIndex, 'RSPureToneLaser'] = toneFitParamsLaser[4]
db.at[dbIndex, 'mPureToneLaser'] = mFixed
db.at[dbIndex, 'sigmaDPureToneLaser'] = toneFitParamsLaser[1]
db.at[dbIndex, 'sigmaSPureToneLaser'] = toneFitParamsLaser[2]
db.at[dbIndex, 'bandwidthTuningR2PureToneLaser'] = toneR2Laser
allFitParamsToneLaser = [mFixed]
allFitParamsToneLaser.extend(toneFitParamsLaser)
suppIndToneLaser, prefBWToneLaser = fitfuncs.extract_stats_from_fit(
allFitParamsToneLaser, testBands)
db.at[dbIndex,
'fitSustainedSuppressionIndexPureToneLaser'] = suppIndToneLaser
db.at[dbIndex,
'fitSustainedPrefBandwidthPureToneLaser'] = prefBWToneLaser
testRespsNoLaser = fitfuncs.diff_gauss_form(testBands,
*allFitParamsToneNoLaser)
testRespsLaser = fitfuncs.diff_gauss_form(testBands,
*allFitParamsToneLaser)
laserDiffModel = testRespsLaser - testRespsNoLaser
peakIndModel = np.argmax(testRespsNoLaser)
db.at[dbIndex,
'fitPeakChangeFRPureTone'] = laserDiffModel[peakIndModel]
db.at[dbIndex, 'fitWNChangeFRPureTone'] = laserDiffModel[-1]
#also calculating fits and suppression with nothing being fit for bw 0
noZeroSustainedResponseNoLaser = sustainedSpikeArray[1:, 0]
bandsForFitNoZero = bandsForFit[1:]
noZeroFitParamsNoLaser, noZeroR2 = fitfuncs.diff_of_gauss_fit(
bandsForFitNoZero, noZeroSustainedResponseNoLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0noZeroNoLaser'] = noZeroFitParamsNoLaser[0]
db.at[dbIndex, 'RDnoZeroNoLaser'] = noZeroFitParamsNoLaser[3]
db.at[dbIndex, 'RSnoZeroNoLaser'] = noZeroFitParamsNoLaser[4]
db.at[dbIndex, 'mnoZeroNoLaser'] = mFixed
db.at[dbIndex, 'sigmaDnoZeroNoLaser'] = noZeroFitParamsNoLaser[1]
db.at[dbIndex, 'sigmaSnoZeroNoLaser'] = noZeroFitParamsNoLaser[2]
db.at[dbIndex, 'bandwidthTuningR2noZeroNoLaser'] = noZeroR2
allFitParamsNoZero = [mFixed]
allFitParamsNoZero.extend(noZeroFitParamsNoLaser)
testBandsNoZero = np.linspace(bandsForFitNoZero[0],
bandsForFitNoZero[-1], 500)
suppIndNoZero, prefBWNoZero = fitfuncs.extract_stats_from_fit(
allFitParamsNoZero, testBandsNoZero)
db.at[dbIndex,
'fitSustainedSuppressionIndexNoZeroNoLaser'] = suppIndNoZero
db.at[dbIndex, 'fitSustainedPrefBandwidthNoZeroNoLaser'] = prefBWNoZero
noZeroSustainedResponseLaser = sustainedSpikeArray[1:, 1]
bandsForFitNoZero = bandsForFit[1:]
noZeroFitParamsLaser, noZeroR2Laser = fitfuncs.diff_of_gauss_fit(
bandsForFitNoZero, noZeroSustainedResponseLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0noZeroLaser'] = noZeroFitParamsLaser[0]
db.at[dbIndex, 'RDnoZeroLaser'] = noZeroFitParamsLaser[3]
db.at[dbIndex, 'RSnoZeroLaser'] = noZeroFitParamsLaser[4]
db.at[dbIndex, 'mnoZeroLaser'] = mFixed
db.at[dbIndex, 'sigmaDnoZeroLaser'] = noZeroFitParamsLaser[1]
db.at[dbIndex, 'sigmaSnoZeroLaser'] = noZeroFitParamsLaser[2]
db.at[dbIndex, 'bandwidthTuningR2noZeroLaser'] = noZeroR2Laser
allFitParamsNoZeroLaser = [mFixed]
allFitParamsNoZeroLaser.extend(noZeroFitParamsLaser)
suppIndNoZeroLaser, prefBWNoZeroLaser = fitfuncs.extract_stats_from_fit(
allFitParamsNoZeroLaser, testBandsNoZero)
db.at[dbIndex,
'fitSustainedSuppressionIndexNoZeroLaser'] = suppIndNoZeroLaser
db.at[dbIndex,
'fitSustainedPrefBandwidthNoZeroLaser'] = prefBWNoZeroLaser
testRespsNoLaser = fitfuncs.diff_gauss_form(testBandsNoZero,
*allFitParamsNoZero)
testRespsLaser = fitfuncs.diff_gauss_form(testBandsNoZero,
*allFitParamsNoZeroLaser)
laserDiffModel = testRespsLaser - testRespsNoLaser
peakIndModel = np.argmax(testRespsNoLaser)
db.at[dbIndex, 'fitPeakChangeFRNoZero'] = laserDiffModel[peakIndModel]
db.at[dbIndex, 'fitWNChangeFRNoZero'] = laserDiffModel[-1]
if len(filename) != 0:
celldatabase.save_hdf(db, filename)
print filename + " saved"
return db
def calculate_cell_locations(db):
pass
if __name__ == "__main__":
# -- Spike sort the data (code is left here for reference) --
'''
subject = 'testXXX'
inforecFile = os.path.join(settings.INFOREC_PATH,'{}_inforec.py'.format(subject))
clusteringObj = spikesorting.ClusterInforec(inforecFile)
clusteringObj.process_all_experiments()
'''
# -- Generate cell database (this function excludes clusters with isi>0.05, spikeQuality<2 --
celldb = celldatabase.generate_cell_database_from_subjects(studyparams.MICE_LIST)
# -- Compute the base stats and indices for each cell --
celldb = calculate_base_stats(celldb) # Calculated for all cells
celldb = calculate_indices(celldb) # Calculated for a selected subset of cells
dbPath = os.path.join(settings.FIGURES_DATA_PATH, studyparams.STUDY_NAME)
dbFilename = os.path.join(dbPath,'celldb_{}.h5'.format(studyparams.STUDY_NAME))
if os.path.isdir(dbPath):
celldatabase.save_hdf(celldb, dbFilename)
print('Saved database to {}'.format(dbFilename))
else:
print('{} does not exist. Please create this folder.'.format(dbPath))
basicDB = celldatabase.generate_cell_database_from_subjects(d1mice)
d1DBFilename = os.path.join(settings.FIGURES_DATA_PATH,
'{}_d1mice.h5'.format(studyparams.STUDY_NAME))
# Create and save a database, computing first the base stats and then the indices
firstDB = calculate_base_stats(basicDB, filename=d1DBFilename)
# bestCells = calculate_indices(firstDB, filename = d1DBFilename)
if SAVE:
dbpath = os.path.join(settings.FIGURES_DATA_PATH,
studyparams.STUDY_NAME,
'{}.h5'.format('_'.join(d1mice)))
# dbpath = os.path.join(settings.FIGURES_DATA_PATH, studyparams.STUDY_NAME, '{}.h5'.format('temp'))
if os.path.isdir(
os.path.join(settings.FIGURES_DATA_PATH,
studyparams.STUDY_NAME)):
celldatabase.save_hdf(firstDB, dbpath)
print("SAVED DATAFRAME to {}".format(dbpath))
elif not os.path.isdir(
os.path.join(settings.FIGURES_DATA_PATH,
studyparams.STUDY_NAME)):
answer = input_func(
"Save folder is not present. Would you like to make the desired directory now? (y/n) "
)
if answer in ['y', 'Y', 'Yes', 'YES']:
os.mkdir(
os.path.join(settings.FIGURES_DATA_PATH,
studyparams.STUDY_NAME))
celldatabase.save_hdf(firstDB, dbpath)
print("SAVED DATAFRAME to {}".format(dbpath))
pcovs = []
ind10AboveButNone = []
# ------------ start of frequency specific calculations -------------
for indFreq, freq in enumerate(uniqFreq):
selectinds = np.flatnonzero((currentFreq == freq) & (
currentIntensity == intensity)).tolist()
nspkBase, nspkResp = funcs.calculate_firing_rate(
ttEventOnsetTimes,
ttSpikeTimes,
baseRange,
selectinds=selectinds)
spks = np.concatenate([spks, nspkResp.ravel()])
freqs = np.concatenate(
[freqs, np.ones(len(nspkResp.ravel())) * freq])
respSpikeMean[indInten, indFreq] = np.mean(nspkResp)
allIntenBase = np.concatenate(
[allIntenBase, nspkBase.ravel()])
Rsquared, popt = funcs.calculate_fit(
uniqFreq, allIntenBase, freqs, spks)
Rsquareds[indInten, indFreq] = Rsquared
db.at[indRow, 'tuningTest_pVal'] = ttPVal
db.at[indRow, 'tuningTest_zStat'] = ttZStat
db.at[indRow, 'ttR2Fit'] = Rsquareds[-1].mean(
) # Using the highest (only) intensity
celldatabase.save_hdf(db, '/var/tmp/figuresdata/2019astrpi/ttDBR2.h5')
onsetStats = bandwidth_suppression_from_peak(onsetTuningDict)
db.at[dbIndex, 'onsetSuppressionIndexLaser'] = onsetStats['suppressionIndex'][-1]
db.at[dbIndex, 'onsetSuppressionpValLaser'] = onsetStats['suppressionpVal'][-1]
db.at[dbIndex, 'onsetFacilitationIndexLaser'] = onsetStats['facilitationIndex'][-1]
db.at[dbIndex, 'onsetFacilitationpValLaser'] = onsetStats['facilitationpVal'][-1]
db.at[dbIndex, 'onsetSuppressionIndexNoLaser'] = onsetStats['suppressionIndex'][0]
db.at[dbIndex, 'onsetSuppressionpValNoLaser'] = onsetStats['suppressionpVal'][0]
db.at[dbIndex, 'onsetFacilitationIndexNoLaser'] = onsetStats['facilitationIndex'][0]
db.at[dbIndex, 'onsetFacilitationpValNoLaser'] = onsetStats['facilitationpVal'][0]
sustainedStats = bandwidth_suppression_from_peak(sustainedTuningDict)
db.at[dbIndex, 'sustainedSuppressionIndexLaser'] = sustainedStats['suppressionIndex'][-1]
db.at[dbIndex, 'sustainedSuppressionpValLaser'] = sustainedStats['suppressionpVal'][-1]
db.at[dbIndex, 'sustainedFacilitationIndexLaser'] = sustainedStats['facilitationIndex'][-1]
db.at[dbIndex, 'sustainedFacilitationpValLaser'] = sustainedStats['facilitationpVal'][-1]
db.at[dbIndex, 'sustainedSuppressionIndexNoLaser'] = sustainedStats['suppressionIndex'][0]
db.at[dbIndex, 'sustainedSuppressionpValNoLaser'] = sustainedStats['suppressionpVal'][0]
db.at[dbIndex, 'sustainedFacilitationIndexNoLaser'] = sustainedStats['facilitationIndex'][0]
db.at[dbIndex, 'sustainedFacilitationpValNoLaser'] = sustainedStats['facilitationpVal'][0]
if subType == 'chr2':
outputName = 'photoidentification_cells2.h5'
elif subType == 'archt':
outputName = 'inactivation_cells2.h5'
dbFilename = os.path.join(settings.DATABASE_PATH,outputName)
celldatabase.save_hdf(db, dbFilename)
print('Saved database to: {}'.format(dbFilename))
maxPossibleClusters=12,
recluster=False)
if FIND_TETRODES_WITH_NO_SPIKES:
ci = spikesorting.ClusterInforec(inforecFn)
ci.find_tetrodes_with_no_spikes()
continue
fullDb = celldatabase.generate_cell_database(inforecFn)
fullDbFullPath = os.path.join(
dbFolder, '{}_database_all_clusters.h5'.format(animal))
if SAVE_FULL_DB:
print 'Saving database to {}'.format(fullDbFullPath)
#fullDb.to_hdf(fullDbFullPath, key=dbKey)
celldatabase.save_hdf(fullDb, fullDbFullPath)
if CASE == 2:
# -- check behavior criteria, cell depth is inside target region, consistent firing during behavior(2afc) session, generate a good quality cell db, save only subset of good qual cells on disk -- #
for animal in animals:
fullDbFullPath = os.path.join(
dbFolder, '{}_database_all_clusters.h5'.format(animal))
#fullDb = pd.read_hdf(fullDbFullPath, key=dbKey)
fullDb = celldatabase.load_hdf(fullDbFullPath)
# -- check if cell meets behavior criteria -- #
print 'Checking behavior criteria'
metBehavCriteria = behavCriteria.ensure_behav_criteria_celldb(
fullDb,
strict=useStrictBehavCriterionWhenSaving,
sessiontype='behavior',
def inactivation_database(db,
baseStats=False,
computeIndices=True,
filename='inactivation_cells.h5'):
if type(db) == str:
dbPath = os.path.join(settings.DATABASE_PATH, db)
db = celldatabase.load_hdf(dbPath)
if baseStats:
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 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['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 computeIndices:
bestCells = db.query("isiViolations<0.02") # or modifiedISI<0.02")
bestCells = bestCells.loc[bestCells['spikeShapeQuality'] > 2]
bestCells = bestCells.query(
'soundResponsePVal<0.05 or onsetSoundResponsePVal<0.05 or sustainedSoundResponsePVal<0.05'
)
bestCells = bestCells.loc[bestCells['tuningFitR2'] > R2CUTOFF]
bestCells = bestCells.loc[
bestCells['octavesFromPrefFreq'] < OCTAVESCUTOFF]
for dbIndex, dbRow in bestCells.iterrows():
cell = ephyscore.Cell(dbRow)
bandEphysData, bandBehavData = cell.load_by_index(
int(dbRow['bestBandSession']))
bandEventOnsetTimes = funcs.get_sound_onset_times(
bandEphysData, 'bandwidth')
bandSpikeTimestamps = bandEphysData['spikeTimes']
bandEachTrial = bandBehavData['currentBand']
secondSort = bandBehavData['laserTrial']
propOnset, propSustained = funcs.onset_sustained_spike_proportion(
bandSpikeTimestamps, bandEventOnsetTimes)
db.at[dbIndex, 'proportionSpikesOnset'] = propOnset
db.at[dbIndex, 'proportionSpikesSustained'] = propSustained
#by default: not subtracting baseline, but are replacing pure tone response with baseline for 0 bw condition
onsetSupInds, onsetSupIndpVals, onsetFacInds, onsetFacIndpVals, onsetPeakInds, onsetSpikeArray = funcs.bandwidth_suppression_from_peak(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange=[0.0, 0.05],
baseRange=[-0.05, 0.0])
db.at[dbIndex, 'onsetSuppressionIndexLaser'] = onsetSupInds[-1]
db.at[dbIndex, 'onsetSuppressionpValLaser'] = onsetSupIndpVals[-1]
db.at[dbIndex, 'onsetFacilitationIndexLaser'] = onsetFacInds[-1]
db.at[dbIndex, 'onsetFacilitationpValLaser'] = onsetFacIndpVals[-1]
db.at[dbIndex,
'onsetPrefBandwidthLaser'] = bandEachTrial[onsetPeakInds[-1]]
db.at[dbIndex, 'onsetSuppressionIndexNoLaser'] = onsetSupInds[0]
db.at[dbIndex, 'onsetSuppressionpValNoLaser'] = onsetSupIndpVals[0]
db.at[dbIndex, 'onsetFacilitationIndexNoLaser'] = onsetFacInds[0]
db.at[dbIndex,
'onsetFacilitationpValNoLaser'] = onsetFacIndpVals[0]
db.at[dbIndex, 'onsetPrefBandwidthNoLaser'] = bandEachTrial[
onsetPeakInds[0]]
#base range is right before sound onset so we get estimate for laser baseline
sustainedSupInds, sustainedSupIndpVals, sustainedFacInds, sustainedFacIndpVals, sustainedPeakInds, sustainedSpikeArray = funcs.bandwidth_suppression_from_peak(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange=[0.2, 1.0],
baseRange=[-0.05, 0.0])
db.at[dbIndex,
'sustainedSuppressionIndexLaser'] = sustainedSupInds[-1]
db.at[dbIndex,
'sustainedSuppressionpValLaser'] = sustainedSupIndpVals[-1]
db.at[dbIndex,
'sustainedFacilitationIndexLaser'] = sustainedFacInds[-1]
db.at[dbIndex,
'sustainedFacilitationpValLaser'] = sustainedFacIndpVals[-1]
db.at[dbIndex, 'sustainedPrefBandwidthLaser'] = bandEachTrial[
sustainedPeakInds[-1]]
db.at[dbIndex,
'sustainedSuppressionIndexNoLaser'] = sustainedSupInds[0]
db.at[dbIndex,
'sustainedSuppressionpValNoLaser'] = sustainedSupIndpVals[0]
db.at[dbIndex,
'sustainedFacilitationIndexNoLaser'] = sustainedFacInds[0]
db.at[dbIndex,
'sustainedFacilitationpValNoLaser'] = sustainedFacIndpVals[0]
db.at[dbIndex, 'sustainedPrefBandwidthNoLaser'] = bandEachTrial[
sustainedPeakInds[0]]
#no laser fit
sustainedResponseNoLaser = sustainedSpikeArray[:, 0]
bandsForFit = np.unique(bandEachTrial)
bandsForFit[-1] = 6
mFixed = 1
fitParams, R2 = fitfuncs.diff_of_gauss_fit(
bandsForFit, sustainedResponseNoLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0noLaser'] = fitParams[0]
db.at[dbIndex, 'RDnoLaser'] = fitParams[3]
db.at[dbIndex, 'RSnoLaser'] = fitParams[4]
db.at[dbIndex, 'mnoLaser'] = mFixed
db.at[dbIndex, 'sigmaDnoLaser'] = fitParams[1]
db.at[dbIndex, 'sigmaSnoLaser'] = fitParams[2]
db.at[dbIndex, 'bandwidthTuningR2noLaser'] = R2
testBands = np.linspace(bandsForFit[0], bandsForFit[-1], 500)
allFitParams = [mFixed]
allFitParams.extend(fitParams)
suppInd, prefBW = fitfuncs.extract_stats_from_fit(
allFitParams, testBands)
db.at[dbIndex, 'fitSustainedSuppressionIndexNoLaser'] = suppInd
db.at[dbIndex, 'fitSustainedPrefBandwidthNoLaser'] = prefBW
#laser fit
sustainedResponseLaser = sustainedSpikeArray[:, 1]
fitParamsLaser, R2Laser = fitfuncs.diff_of_gauss_fit(
bandsForFit, sustainedResponseLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0laser'] = fitParamsLaser[0]
db.at[dbIndex, 'RDlaser'] = fitParamsLaser[3]
db.at[dbIndex, 'RSlaser'] = fitParamsLaser[4]
db.at[dbIndex, 'mlaser'] = mFixed
db.at[dbIndex, 'sigmaDlaser'] = fitParamsLaser[1]
db.at[dbIndex, 'sigmaSlaser'] = fitParamsLaser[2]
db.at[dbIndex, 'bandwidthTuningR2laser'] = R2Laser
allFitParamsLaser = [mFixed]
allFitParamsLaser.extend(fitParamsLaser)
suppIndLaser, prefBWLaser = fitfuncs.extract_stats_from_fit(
allFitParamsLaser, testBands)
db.at[dbIndex, 'fitSustainedSuppressionIndexLaser'] = suppIndLaser
db.at[dbIndex, 'fitSustainedPrefBandwidthLaser'] = prefBWLaser
meanLaserDiff = np.mean(sustainedResponseLaser -
sustainedResponseNoLaser)
db.at[dbIndex, 'laserChangeResponse'] = meanLaserDiff
laserDiff = sustainedResponseLaser - sustainedResponseNoLaser
peakInd = np.argmax(sustainedResponseNoLaser)
db.at[dbIndex, 'peakChangeFR'] = laserDiff[peakInd]
db.at[dbIndex, 'WNChangeFR'] = laserDiff[-1]
testRespsNoLaser = fitfuncs.diff_gauss_form(
testBands, *allFitParams)
testRespsLaser = fitfuncs.diff_gauss_form(testBands,
*allFitParamsLaser)
laserDiffModel = testRespsLaser - testRespsNoLaser
peakIndModel = np.argmax(testRespsNoLaser)
db.at[dbIndex, 'fitPeakChangeFR'] = laserDiffModel[peakIndModel]
db.at[dbIndex, 'fitWNChangeFR'] = laserDiffModel[-1]
#also calculating fits and suppression with pure tone being 0 bw condition
toneSustainedSupInds, toneSustainedSupIndpVals, toneSustainedFacInds, toneSustainedFacIndpVals, toneSustainedPeakInds, toneSustainedSpikeArray = funcs.bandwidth_suppression_from_peak(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange=[0.2, 1.0],
baseRange=[-0.05, 0.0],
zeroBWBaseline=False)
db.at[
dbIndex,
'sustainedSuppressionIndexNoLaserPureTone'] = toneSustainedSupInds[
0]
db.at[
dbIndex,
'sustainedSuppressionpValNoLaserPureTone'] = toneSustainedSupIndpVals[
0]
db.at[
dbIndex,
'sustainedFacilitationIndexNoLaserPureTone'] = toneSustainedFacInds[
0]
db.at[
dbIndex,
'sustainedFacilitationpValNoLaserPureTone'] = toneSustainedFacIndpVals[
0]
db.at[dbIndex,
'sustainedPrefBandwidthNoLaserPureTone'] = bandEachTrial[
toneSustainedPeakInds[0]]
db.at[
dbIndex,
'sustainedSuppressionIndexLaserPureTone'] = toneSustainedSupInds[
-1]
db.at[
dbIndex,
'sustainedSuppressionpValLaserPureTone'] = toneSustainedSupIndpVals[
-1]
db.at[
dbIndex,
'sustainedFacilitationIndexLaserPureTone'] = toneSustainedFacInds[
-1]
db.at[
dbIndex,
'sustainedFacilitationpValLaserPureTone'] = toneSustainedFacIndpVals[
-1]
db.at[dbIndex,
'sustainedPrefBandwidthLaserPureTone'] = bandEachTrial[
toneSustainedPeakInds[-1]]
toneSustainedResponseNoLaser = toneSustainedSpikeArray[:, 0]
toneFitParamsNoLaser, toneR2 = fitfuncs.diff_of_gauss_fit(
bandsForFit, toneSustainedResponseNoLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0PureToneNoLaser'] = toneFitParamsNoLaser[0]
db.at[dbIndex, 'RDPureToneNoLaser'] = toneFitParamsNoLaser[3]
db.at[dbIndex, 'RSPureToneNoLaser'] = toneFitParamsNoLaser[4]
db.at[dbIndex, 'mPureToneNoLaser'] = mFixed
db.at[dbIndex, 'sigmaDPureToneNoLaser'] = toneFitParamsNoLaser[1]
db.at[dbIndex, 'sigmaSPureToneNoLaser'] = toneFitParamsNoLaser[2]
db.at[dbIndex, 'bandwidthTuningR2PureToneNoLaser'] = toneR2
allFitParamsToneNoLaser = [mFixed]
allFitParamsToneNoLaser.extend(toneFitParamsNoLaser)
suppIndTone, prefBWTone = fitfuncs.extract_stats_from_fit(
allFitParamsToneNoLaser, testBands)
db.at[dbIndex,
'fitSustainedSuppressionIndexPureToneNoLaser'] = suppIndTone
db.at[dbIndex,
'fitSustainedPrefBandwidthPureToneNoLaser'] = prefBWTone
toneSustainedResponseLaser = toneSustainedSpikeArray[:, 1]
toneFitParamsLaser, toneR2Laser = fitfuncs.diff_of_gauss_fit(
bandsForFit, toneSustainedResponseLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0PureToneLaser'] = toneFitParamsLaser[0]
db.at[dbIndex, 'RDPureToneLaser'] = toneFitParamsLaser[3]
db.at[dbIndex, 'RSPureToneLaser'] = toneFitParamsLaser[4]
db.at[dbIndex, 'mPureToneLaser'] = mFixed
db.at[dbIndex, 'sigmaDPureToneLaser'] = toneFitParamsLaser[1]
db.at[dbIndex, 'sigmaSPureToneLaser'] = toneFitParamsLaser[2]
db.at[dbIndex, 'bandwidthTuningR2PureToneLaser'] = toneR2Laser
allFitParamsToneLaser = [mFixed]
allFitParamsToneLaser.extend(toneFitParamsLaser)
suppIndToneLaser, prefBWToneLaser = fitfuncs.extract_stats_from_fit(
allFitParamsToneLaser, testBands)
db.at[
dbIndex,
'fitSustainedSuppressionIndexPureToneLaser'] = suppIndToneLaser
db.at[dbIndex,
'fitSustainedPrefBandwidthPureToneLaser'] = prefBWToneLaser
testRespsNoLaser = fitfuncs.diff_gauss_form(
testBands, *allFitParamsToneNoLaser)
testRespsLaser = fitfuncs.diff_gauss_form(testBands,
*allFitParamsToneLaser)
laserDiffModel = testRespsLaser - testRespsNoLaser
peakIndModel = np.argmax(testRespsNoLaser)
db.at[dbIndex,
'fitPeakChangeFRPureTone'] = laserDiffModel[peakIndModel]
db.at[dbIndex, 'fitWNChangeFRPureTone'] = laserDiffModel[-1]
#also calculating fits and suppression with nothing being fit for bw 0
noZeroSustainedResponseNoLaser = sustainedSpikeArray[1:, 0]
bandsForFitNoZero = bandsForFit[1:]
noZeroFitParamsNoLaser, noZeroR2 = fitfuncs.diff_of_gauss_fit(
bandsForFitNoZero,
noZeroSustainedResponseNoLaser,
mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0noZeroNoLaser'] = noZeroFitParamsNoLaser[0]
db.at[dbIndex, 'RDnoZeroNoLaser'] = noZeroFitParamsNoLaser[3]
db.at[dbIndex, 'RSnoZeroNoLaser'] = noZeroFitParamsNoLaser[4]
db.at[dbIndex, 'mnoZeroNoLaser'] = mFixed
db.at[dbIndex, 'sigmaDnoZeroNoLaser'] = noZeroFitParamsNoLaser[1]
db.at[dbIndex, 'sigmaSnoZeroNoLaser'] = noZeroFitParamsNoLaser[2]
db.at[dbIndex, 'bandwidthTuningR2noZeroNoLaser'] = noZeroR2
allFitParamsNoZero = [mFixed]
allFitParamsNoZero.extend(noZeroFitParamsNoLaser)
testBandsNoZero = np.linspace(bandsForFitNoZero[0],
bandsForFitNoZero[-1], 500)
suppIndNoZero, prefBWNoZero = fitfuncs.extract_stats_from_fit(
allFitParamsNoZero, testBandsNoZero)
db.at[dbIndex,
'fitSustainedSuppressionIndexNoZeroNoLaser'] = suppIndNoZero
db.at[dbIndex,
'fitSustainedPrefBandwidthNoZeroNoLaser'] = prefBWNoZero
noZeroSustainedResponseLaser = sustainedSpikeArray[1:, 1]
bandsForFitNoZero = bandsForFit[1:]
noZeroFitParamsLaser, noZeroR2Laser = fitfuncs.diff_of_gauss_fit(
bandsForFitNoZero, noZeroSustainedResponseLaser, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0noZeroLaser'] = noZeroFitParamsLaser[0]
db.at[dbIndex, 'RDnoZeroLaser'] = noZeroFitParamsLaser[3]
db.at[dbIndex, 'RSnoZeroLaser'] = noZeroFitParamsLaser[4]
db.at[dbIndex, 'mnoZeroLaser'] = mFixed
db.at[dbIndex, 'sigmaDnoZeroLaser'] = noZeroFitParamsLaser[1]
db.at[dbIndex, 'sigmaSnoZeroLaser'] = noZeroFitParamsLaser[2]
db.at[dbIndex, 'bandwidthTuningR2noZeroLaser'] = noZeroR2Laser
allFitParamsNoZeroLaser = [mFixed]
allFitParamsNoZeroLaser.extend(noZeroFitParamsLaser)
suppIndNoZeroLaser, prefBWNoZeroLaser = fitfuncs.extract_stats_from_fit(
allFitParamsNoZeroLaser, testBandsNoZero)
db.at[
dbIndex,
'fitSustainedSuppressionIndexNoZeroLaser'] = suppIndNoZeroLaser
db.at[dbIndex,
'fitSustainedPrefBandwidthNoZeroLaser'] = prefBWNoZeroLaser
testRespsNoLaser = fitfuncs.diff_gauss_form(
testBandsNoZero, *allFitParamsNoZero)
testRespsLaser = fitfuncs.diff_gauss_form(testBandsNoZero,
*allFitParamsNoZeroLaser)
laserDiffModel = testRespsLaser - testRespsNoLaser
peakIndModel = np.argmax(testRespsNoLaser)
db.at[dbIndex,
'fitPeakChangeFRNoZero'] = laserDiffModel[peakIndModel]
db.at[dbIndex, 'fitWNChangeFRNoZero'] = laserDiffModel[-1]
if len(filename) != 0:
celldatabase.save_hdf(db, dbFilename)
zStats = np.empty(len(pulseTimes))
pVals = np.empty(len(pulseTimes))
respSpikeMean = np.empty(len(pulseTimes))
for indPulse, pulse in enumerate(pulseTimes):
responseRange = [pulse, pulse+binTime]
nspkResp = spikesanalysis.spiketimes_to_spikecounts(spikeTimesFromEventOnset,
indexLimitsEachTrial,responseRange)
respSpikeMean[indPulse] = nspkResp.ravel().mean()
try:
zStats[indPulse], pVals[indPulse] = stats.mannwhitneyu(nspkResp, nspkBase)
except ValueError: #All numbers identical will cause mann whitney to fail
zStats[indPulse], pVals[indPulse] = [0, 1]
#Save the number of significant train responses
if (pVals[0] < 0.05) and (sum(pVals[1:]<0.05) >= 3) and (all(respSpikeMean > nspkBase.ravel().mean())):
databaseNBQX.loc[indRow, 'summarySurvivedNBQX'] = 1
# #PLOT THE NBQX REPORTS
# nbqxCells = databaseNBQX.query('isiViolations<0.02 and spikeShapeQuality>2 and summaryPulsePval<0.05')
# for indRow, dbRow in nbqxCells.iterrows():
# plot_NBQX_report(dbRow, saveDir)
if SAVE:
celldatabase.save_hdf(database, '/tmp/database_with_pulse_responses.h5')
celldatabase.save_hdf(databaseNBQX, '/tmp/nbqx_database_with_pulse_responses.h5')
databaseFullPath = os.path.join(settings.DATABASE_PATH, NEW_DATABASE_FOLDER, '{}_database.h5'.format(mouseName))
#outFilename = '/var/tmp/{}_reward_change_modulation_{}.h5'.format(mouseName, processedDate)
outFilePath = '/var/tmp/'
outFilenames = [os.path.join(outFilePath,filename) for filename in os.listdir(outFilePath) if mouseName in filename]
dfThisMouse = celldatabase.load_hdf(databaseFullPath) #pd.read_hdf(databaseFullPath,key='reward_change')
# -- replacing certain columns -- #
#colsToDrop = [col for col in dfThisMouse.columns if '-0.2-0s' in col]
#dfThisMouse = dfThisMouse.drop(columns=colsToDrop)
#################################
dfs = [dfThisMouse]
#allMiceDfs = []
#for mouseName in np.unique(dfAllMeasures['subject']):
#dfThisMouse = dfAllMeasures.loc[dfAllMeasures['subject'] == mouseName].reset_index()
for outFilename in outFilenames:
dfModThisMouse = pd.read_hdf(outFilename, key='reward_change')
dfs.append(dfModThisMouse)
dfAllThisMouse = reduce(lambda left,right: pd.merge(left,right,on=['subject','date','tetrode','cluster'],how='inner'), dfs)
dfAllThisMouse.drop_duplicates(['subject','date','tetrode','cluster','depth'],inplace=True)
if 'level_0' in dfAllThisMouse.columns:
dfAllThisMouse.drop('level_0', 1, inplace=True)
dfAllThisMouse.reset_index(inplace=True)
if 'level_0' in dfAllThisMouse.columns:
dfAllThisMouse.drop('level_0', 1, inplace=True)
#dfAllThisMouse.to_hdf(databaseFullPath, key='reward_change')
celldatabase.save_hdf(dfAllThisMouse, databaseFullPath)
#when saving to hdf, using (format='table',data_columns=True) is slower but enable on disk queries
import pandas as pd
import numpy as np
from jaratoolbox import celldatabase
db = pd.DataFrame()
rand = np.random.random(100)
goodColumn = []
stupidColumn = []
for num in rand:
if num > 0.5:
goodColumn.append(np.array([0.0,1.0]))
stupidColumn.append([0.0,1.0])
else:
goodColumn.append(np.full(2, np.nan))
stupidColumn.append([np.nan, np.nan])
db['goodColumn'] = goodColumn
db['stupidColumn'] = stupidColumn
celldatabase.save_hdf(db, '/tmp/test_db.h5')
loadDB = celldatabase.load_hdf('/tmp/test_db.h5')
# # save db as h5 and csv
# '''
# dbFilename = os.path.join(settings.DATABASE_PATH,'{0}_test.h5'.format(subject))
# db.to_hdf(dbFilename, 'database',mode='w')
# print('Saved database to: {}'.format(dbFilename))
# db.to_csv(dbFilename+'.csv')
# print('Saved database to: {}'.format(dbFilename+'.csv'))
# '''
#dbFilenameNew = os.path.join(settings.DATABASE_PATH,'{0}_new.h5'.format(subject))
dbFilenameNew = '/home/jarauser/data/databases/tmp/{}_new.h5'.format(subject)
celldatabase.save_hdf(db, dbFilenameNew)
print('Saved database to: {}'.format(dbFilenameNew))
# -- To load the HDF5 --
# df = celldatabase.load_hdf('/tmp/band045_new.h5')
#allSubjects = subjects_info.PV_ARCHT_MICE + subjects_info.SOM_ARCHT_MICE
#allSubjects = ['dapa012', 'dapa013', 'dapa014', 'dapa015']
allSubjects = []
fulldb = pd.DataFrame()
for subject in allSubjects:
db = celldatabase.load_hdf('/tmp/{}_new.h5'.format(subject))
fulldb = fulldb.append(db, ignore_index=True)
fulldbFilename = os.path.join(settings.DATABASE_PATH,'dapa_cells.h5')
celldatabase.save_hdf(fulldb, fulldbFilename)
onsetRate = onsetSpikes / (responseRange[1] - responseRange[0])
sustainedRate = sustainedSpikes / (responseRange[2] - responseRange[1])
baseSpikes = nspkBase.mean()
baseRate = baseSpikes / (baseRange[1] - baseRange[0])
onsetBaseSubtracted = onsetRate - baseRate
sustainedBaseSubtracted = sustainedRate - baseRate
# baseSub = avgResponse - avgBase
# normResponse = baseSub / baseSub[0]
db.loc[indRow, 'onsetRateNoise'] = onsetRate
db.loc[indRow, 'sustainedRateNoise'] = sustainedRate
db.loc[indRow, 'baselineRateNoise'] = baseRate
celldatabase.save_hdf(db, '/tmp/database_with_normResponse.h5')
elif CASE == 1:
PLOT = 0
SAVE = 1
#Compute onsetivity using CF trials with top 5 intensities.
for indIter, (indRow, dbRow) in enumerate(db.iterrows()):
cell = ephyscore.Cell(dbRow, useModifiedClusters=True)
try:
ephysData, bdata = cell.load('tc')
except (IndexError, ValueError): #The cell does not have a tc or the tc session has no spikes
print "No TC for cell {}".format(indRow)
eventOnsetTimes = ephysData['events']['stimOn']
spikeTimes = ephysData['spikeTimes']
import os
import pandas as pd
from jaratoolbox import celldatabase
animals = [
'adap005', 'adap012', 'adap013', 'adap015', 'adap017', 'gosi001',
'gosi004', 'gosi008', 'gosi010', 'adap067', 'adap071'
]
celldbFolder = '/home/languo/data/database/new_celldb'
for animal in animals:
celldbPath = os.path.join(celldbFolder,
'{}_database_old_format.h5'.format(animal))
celldb = pd.read_hdf(celldbPath, key='reward_change')
newCelldbPath = os.path.join(celldbFolder, '{}_database.h5'.format(animal))
print('resaving celldb as {}'.format(newCelldbPath))
celldatabase.save_hdf(celldb, newCelldbPath)
def photoID_base_stats(db, filename=''):
'''
This function takes as argument a pandas DataFrame and adds new columns.
The filename should be the full path to where the database will be saved. If a filename is not specified, the database will not be saved.
This function computed basic statistics for all clusters (e.g. laser responsiveness, sound responsiveness, preferred frequency).
'''
soundLoc = []
NaKpeakLatency = np.empty(len(db))
laserTestStatistic = np.empty(len(db))
laserPVal = np.empty(len(db))
laserTrainTestStatistic = np.empty(len(db))
laserTrainPVal = np.empty(len(db))
laserChangeFR = 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))
AMRate = 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, useModifiedClusters=True)
print "Now processing", dbRow['subject'], dbRow['date'], dbRow[
'depth'], dbRow['tetrode'], dbRow['cluster']
# --- Determine if sound presentation was ipsi or contra to recording location ---
soundSide = dbRow['info'][2]
recordingSide = dbRow['brainArea']
if (soundSide == 'sound_left' and recordingSide == 'left_AC') or (
soundSide == 'sound_right' and recordingSide == 'right_AC'):
soundLoc.append('ipsi')
else:
soundLoc.append('contra')
# --- Determine time difference between Na and K peak (spike width) ---
peakTimes = dbRow['spikePeakTimes']
latency = peakTimes[2] - peakTimes[1]
NaKpeakLatency[indRow] = latency
# --- Determine laser responsiveness of each cell (using laser pulse) ---
try:
laserEphysData, noBehav = cellObj.load('laserPulse')
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)
laserTestStatistic[indRow] = testStatistic
laserPVal[indRow] = pVal
laserChangeFR[indRow] = changeFR
# --- Determine laser responsiveness of each cell (using laser train) ---
try:
laserTrainEphysData, noBehav = cellObj.load('laserTrain')
except IndexError:
print "No laser train session for this cell"
testStatistic = np.nan
pVal = np.nan
else:
testStatistic, pVal, changeFR = funcs.laser_response(
laserTrainEphysData)
laserTrainTestStatistic[indRow] = testStatistic
laserTrainPVal[indRow] = pVal
# --- Determine sound responsiveness during bandwidth sessions and other statistics about bandwidth session---
try:
bandEphysData, bandBehavData = cellObj.load('bandwidth')
except IndexError:
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
AM = np.nan
else:
bandEventOnsetTimes = funcs.get_sound_onset_times(
bandEphysData, 'bandwidth')
bandSpikeTimestamps = bandEphysData['spikeTimes']
bandEachTrial = bandBehavData['currentBand']
secondSort = bandBehavData['currentAmp']
numBands = np.unique(bandEachTrial)
numSec = np.unique(secondSort)
AM = np.unique(bandBehavData['modRate'])
trialsEachComb = behavioranalysis.find_trials_each_combination(
bandEachTrial, numBands, secondSort, numSec)
trialsEachBaseCond = trialsEachComb[:, :,
-1] #using high amp trials for photoidentified, no laser for inactivation
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(numSec) #correction for multiple comparisons
onsetpVal *= len(numSec)
sustainedpVal *= len(numSec)
soundResponseTestStatistic[indRow] = testStatistic
soundResponsePVal[indRow] = pVal
onsetSoundResponseTestStatistic[indRow] = onsetTestStatistic
onsetSoundResponsePVal[indRow] = onsetpVal
sustainedSoundResponseTestStatistic[indRow] = sustainedTestStatistic
sustainedSoundResponsePVal[indRow] = sustainedpVal
AMRate[indRow] = AM
# --- 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.nan, 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)
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, 'bandwidth')
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['soundLocation'] = soundLoc
db['spikeWidth'] = NaKpeakLatency
db['AMRate'] = AMRate
db['laserPVal'] = laserPVal
db['laserUStat'] = laserTestStatistic
db['laserTrainPVal'] = laserTrainPVal
db['laserTrainUStat'] = laserTrainTestStatistic
db['laserChangeFR'] = laserChangeFR
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
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
# save db as h5
dbFilenameNew = os.path.join(settings.DATABASE_PATH,
'{0}_clusters.h5'.format(subject))
celldatabase.save_hdf(db, dbFilenameNew)
print('Saved database to: {}'.format(dbFilenameNew))
fulldb = pd.DataFrame()
for subject in allSubjects:
dbFilename = os.path.join(settings.DATABASE_PATH,
'{0}_clusters.h5'.format(subject))
db = celldatabase.load_hdf(dbFilename)
fulldb = fulldb.append(db, ignore_index=True)
if subType == 'chr2':
filename = 'photoidentification_cells.h5'
elif subType == 'archt':
filename = 'inactivation_cells.h5'
fulldbFilename = os.path.join(settings.DATABASE_PATH, filename)
celldatabase.save_hdf(fulldb, fulldbFilename)
def photoID_indices(db, filename=''):
'''
This function takes as argument a pandas DataFrame and adds new columns.
The filename should be the full path to where the database will be saved. If a filename is not specified, the database will not be saved.
This function computes indices like Suppression Index for all cells passing (generous) thresholds for good cells.
The thresholds used here are more generous than the ones in studyparams, in case we want to relax our criteria in the future.
'''
bestCells = db.query("isiViolations<0.02 or modifiedISI<0.02")
bestCells = bestCells.loc[bestCells['spikeShapeQuality'] > 2]
bestCells = bestCells.query(
'soundResponsePVal<0.05 or onsetSoundResponsePVal<0.05 or sustainedSoundResponsePVal<0.05'
)
bestCells = bestCells.loc[bestCells['tuningFitR2'] > 0.05]
bestCells = bestCells.loc[bestCells['octavesFromPrefFreq'] < 0.5]
#prepare arrays of NaNs for when we save arrays of data
bandwidthSpikeArraysHighAmp = np.empty((len(db), 7))
bandwidthSpikeArraysHighAmp[:] = np.nan
bandwidthSpikeArraysLowAmp = np.empty((len(db), 7))
bandwidthSpikeArraysLowAmp[:] = np.nan
bandwidthSpikeArraysOnset = np.empty((len(db), 6))
bandwidthSpikeArraysOnset[:] = np.nan
for dbIndex, dbRow in bestCells.iterrows():
cell = ephyscore.Cell(dbRow, useModifiedClusters=True)
bandEphysData, bandBehavData = cell.load_by_index(
int(dbRow['bestBandSession']))
bandEventOnsetTimes = funcs.get_sound_onset_times(
bandEphysData, 'bandwidth')
bandSpikeTimestamps = bandEphysData['spikeTimes']
bandEachTrial = bandBehavData['currentBand']
secondSort = bandBehavData['currentAmp']
propOnset, propSustained = funcs.onset_sustained_spike_proportion(
bandSpikeTimestamps, bandEventOnsetTimes)
db.at[dbIndex, 'proportionSpikesOnset'] = propOnset
db.at[dbIndex, 'proportionSpikesSustained'] = propSustained
#by default: not subtracting baseline, but are replacing pure tone response with baseline for 0 bw condition
onsetSupInds, onsetSupIndpVals, onsetFacInds, onsetFacIndpVals, onsetPeakInds, onsetSpikeArray = funcs.bandwidth_suppression_from_peak(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange=[0.0, 0.05],
baseRange=[-0.05, 0.0])
db.at[dbIndex, 'onsetSuppressionIndex'] = onsetSupInds[-1]
db.at[dbIndex, 'onsetSuppressionpVal'] = onsetSupIndpVals[-1]
db.at[dbIndex, 'onsetFacilitationIndex'] = onsetFacInds[-1]
db.at[dbIndex, 'onsetFacilitationpVal'] = onsetFacIndpVals[-1]
db.at[dbIndex, 'onsetPrefBandwidth'] = bandEachTrial[onsetPeakInds[-1]]
sustainedSupInds, sustainedSupIndpVals, sustainedFacInds, sustainedFacIndpVals, sustainedPeakInds, sustainedSpikeArray = funcs.bandwidth_suppression_from_peak(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange=[0.2, 1.0],
baseRange=[-1.0, -0.2])
db.at[dbIndex, 'sustainedSuppressionIndex'] = sustainedSupInds[-1]
db.at[dbIndex, 'sustainedSuppressionpVal'] = sustainedSupIndpVals[-1]
db.at[dbIndex, 'sustainedFacilitationIndex'] = sustainedFacInds[-1]
db.at[dbIndex, 'sustainedFacilitationpVal'] = sustainedFacIndpVals[-1]
db.at[dbIndex,
'sustainedPrefBandwidth'] = bandEachTrial[sustainedPeakInds[-1]]
#only interested in high amp responses
sustainedResponse = sustainedSpikeArray[:, -1]
bandsForFit = np.unique(bandEachTrial)
bandsForFit[-1] = 6
mFixed = 1
fitParams, R2 = fitfuncs.diff_of_gauss_fit(bandsForFit,
sustainedResponse,
mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0'] = fitParams[0]
db.at[dbIndex, 'RD'] = fitParams[3]
db.at[dbIndex, 'RS'] = fitParams[4]
db.at[dbIndex, 'm'] = mFixed
db.at[dbIndex, 'sigmaD'] = fitParams[1]
db.at[dbIndex, 'sigmaS'] = fitParams[2]
db.at[dbIndex, 'bandwidthTuningR2'] = R2
testBands = np.linspace(bandsForFit[0], bandsForFit[-1], 500)
allFitParams = [mFixed]
allFitParams.extend(fitParams)
suppInd, prefBW = fitfuncs.extract_stats_from_fit(
allFitParams, testBands)
db.at[dbIndex, 'fitSustainedSuppressionIndex'] = suppInd
db.at[dbIndex, 'fitSustainedPrefBandwidth'] = prefBW
#also calculating fits and suppression with pure tone being 0 bw condition
toneSustainedSupInds, toneSustainedSupIndpVals, toneSustainedFacInds, toneSustainedFacIndpVals, toneSustainedPeakInds, toneSustainedSpikeArray = funcs.bandwidth_suppression_from_peak(
bandSpikeTimestamps,
bandEventOnsetTimes,
bandEachTrial,
secondSort,
timeRange=[0.2, 1.0],
baseRange=[-1.0, -0.2],
zeroBWBaseline=False)
db.at[dbIndex,
'sustainedSuppressionIndexPureTone'] = toneSustainedSupInds[-1]
db.at[
dbIndex,
'sustainedSuppressionpValPureTone'] = toneSustainedSupIndpVals[-1]
db.at[dbIndex,
'sustainedFacilitationIndexPureTone'] = toneSustainedFacInds[-1]
db.at[
dbIndex,
'sustainedFacilitationpValPureTone'] = toneSustainedFacIndpVals[-1]
db.at[dbIndex, 'sustainedPrefBandwidthPureTone'] = bandEachTrial[
toneSustainedPeakInds[-1]]
#only interested in high amp responses
toneSustainedResponse = toneSustainedSpikeArray[:, -1]
toneFitParams, toneR2 = fitfuncs.diff_of_gauss_fit(
bandsForFit, toneSustainedResponse, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0PureTone'] = toneFitParams[0]
db.at[dbIndex, 'RDPureTone'] = toneFitParams[3]
db.at[dbIndex, 'RSPureTone'] = toneFitParams[4]
db.at[dbIndex, 'mPureTone'] = mFixed
db.at[dbIndex, 'sigmaDPureTone'] = toneFitParams[1]
db.at[dbIndex, 'sigmaSPureTone'] = toneFitParams[2]
db.at[dbIndex, 'bandwidthTuningR2PureTone'] = toneR2
allFitParamsTone = [mFixed]
allFitParamsTone.extend(toneFitParams)
suppIndTone, prefBWTone = fitfuncs.extract_stats_from_fit(
allFitParamsTone, testBands)
db.at[dbIndex, 'fitSustainedSuppressionIndexPureTone'] = suppIndTone
db.at[dbIndex, 'fitSustainedPrefBandwidthPureTone'] = prefBWTone
#also calculating fits and suppression with nothing being fit for bw 0, want to do both intensities here
#doing this for onset responses as well
noZeroSustainedResponseHighAmp = sustainedSpikeArray[1:, -1]
noZeroOnsetResponseHighAmp = onsetSpikeArray[1:, -1]
bandsForFitNoZero = bandsForFit[1:]
noZeroFitParamsHigh, noZeroR2High = fitfuncs.diff_of_gauss_fit(
bandsForFitNoZero, noZeroSustainedResponseHighAmp, mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0noZeroHighAmp'] = noZeroFitParamsHigh[0]
db.at[dbIndex, 'RDnoZeroHighAmp'] = noZeroFitParamsHigh[3]
db.at[dbIndex, 'RSnoZeroHighAmp'] = noZeroFitParamsHigh[4]
db.at[dbIndex, 'mnoZeroHighAmp'] = mFixed
db.at[dbIndex, 'sigmaDnoZeroHighAmp'] = noZeroFitParamsHigh[1]
db.at[dbIndex, 'sigmaSnoZeroHighAmp'] = noZeroFitParamsHigh[2]
db.at[dbIndex, 'bandwidthTuningR2noZeroHighAmp'] = noZeroR2High
allFitParamsNoZeroHigh = [mFixed]
allFitParamsNoZeroHigh.extend(noZeroFitParamsHigh)
testBandsNoZero = np.linspace(bandsForFitNoZero[0],
bandsForFitNoZero[-1], 500)
suppIndNoZero, prefBWNoZero = fitfuncs.extract_stats_from_fit(
allFitParamsNoZeroHigh, testBandsNoZero)
db.at[dbIndex,
'fitSustainedSuppressionIndexNoZeroHighAmp'] = suppIndNoZero
db.at[dbIndex, 'fitSustainedPrefBandwidthNoZeroHighAmp'] = prefBWNoZero
noZeroFitParamsOnset, noZeroR2Onset = fitfuncs.diff_of_gauss_fit(
bandsForFitNoZero, noZeroOnsetResponseHighAmp, mFixed=mFixed)
db.at[dbIndex, 'R0noZeroOnset'] = noZeroFitParamsOnset[0]
db.at[dbIndex, 'RDnoZeroOnset'] = noZeroFitParamsOnset[3]
db.at[dbIndex, 'RSnoZeroOnset'] = noZeroFitParamsOnset[4]
db.at[dbIndex, 'mnoZeroOnset'] = mFixed
db.at[dbIndex, 'sigmaDnoZeroOnset'] = noZeroFitParamsOnset[1]
db.at[dbIndex, 'sigmaSnoZeroOnset'] = noZeroFitParamsOnset[2]
db.at[dbIndex, 'bandwidthTuningR2noZeroOnset'] = noZeroR2Onset
allFitParamsNoZeroOnset = [mFixed]
allFitParamsNoZeroOnset.extend(noZeroFitParamsOnset)
suppIndNoZero, prefBWNoZero = fitfuncs.extract_stats_from_fit(
allFitParamsNoZeroOnset, testBandsNoZero)
db.at[dbIndex, 'fitOnsetSuppressionIndexNoZero'] = suppIndNoZero
db.at[dbIndex, 'fitOnsetPrefBandwidthNoZero'] = prefBWNoZero
if sustainedSpikeArray.shape[1] > 1:
noZeroSustainedResponseLowAmp = sustainedSpikeArray[1:, 0]
if all(noZeroSustainedResponseLowAmp):
noZeroFitParamsLow, noZeroR2Low = fitfuncs.diff_of_gauss_fit(
bandsForFitNoZero,
noZeroSustainedResponseLowAmp,
mFixed=mFixed)
#fit params
db.at[dbIndex, 'R0noZeroLowAmp'] = noZeroFitParamsLow[0]
db.at[dbIndex, 'RDnoZeroLowAmp'] = noZeroFitParamsLow[3]
db.at[dbIndex, 'RSnoZeroLowAmp'] = noZeroFitParamsLow[4]
db.at[dbIndex, 'mnoZeroLowAmp'] = mFixed
db.at[dbIndex, 'sigmaDnoZeroLowAmp'] = noZeroFitParamsLow[1]
db.at[dbIndex, 'sigmaSnoZeroLowAmp'] = noZeroFitParamsLow[2]
db.at[dbIndex, 'bandwidthTuningR2noZeroLowAmp'] = noZeroR2Low
allFitParamsNoZeroLow = [mFixed]
allFitParamsNoZeroLow.extend(noZeroFitParamsLow)
suppIndNoZero, prefBWNoZero = fitfuncs.extract_stats_from_fit(
allFitParamsNoZeroLow, testBandsNoZero)
db.at[
dbIndex,
'fitSustainedSuppressionIndexNoZeroLowAmp'] = suppIndNoZero
db.at[dbIndex,
'fitSustainedPrefBandwidthNoZeroLowAmp'] = prefBWNoZero
#save the spike array and baseline rate for each cell in case needed for future calculations
bandwidthSpikeArraysHighAmp[dbIndex, :] = toneSustainedSpikeArray[:,
-1]
bandwidthSpikeArraysLowAmp[dbIndex, :] = toneSustainedSpikeArray[:, 0]
bandwidthSpikeArraysOnset[dbIndex, :] = noZeroOnsetResponseHighAmp
db.at[dbIndex, 'bandwidthBaselineRate'] = sustainedResponse[0]
db['bandwidthOnsetSpikeArrayHighAmp'] = list(bandwidthSpikeArraysOnset)
db['bandwidthSustainedSpikeArrayHighAmp'] = list(
bandwidthSpikeArraysHighAmp)
db['bandwidthSustainedSpikeArrayLowAmp'] = list(bandwidthSpikeArraysLowAmp)
if len(filename) != 0:
celldatabase.save_hdf(db, filename)
print filename + " saved"
return db
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
def photoDB_cell_locations(db, filename=''):
'''
This function takes as argument a pandas DataFrame and adds new columns.
The filename should be the full path to where the database will be saved. If a filename is not specified, the database will not be saved.
This function computes the depths and cortical locations of all cells with suppression indices computed.
This function should be run in a virtual environment because the allensdk has weird dependencies that we don't want tainting our computers.
'''
from allensdk.core.mouse_connectivity_cache import MouseConnectivityCache
# lapPath = os.path.join(settings.ATLAS_PATH, 'AllenCCF_25/coronal_laplacian_25.nrrd')
lapPath = '/mnt/jarahubdata/tmp/coronal_laplacian_25.nrrd'
lapData = nrrd.read(lapPath)
lap = lapData[0]
mcc = MouseConnectivityCache(resolution=25)
rsp = mcc.get_reference_space()
rspAnnotationVolumeRotated = np.rot90(rsp.annotation, 1, axes=(2, 0))
tetrodetoshank = {
1: 1,
2: 1,
3: 2,
4: 2,
5: 3,
6: 3,
7: 4,
8: 4
} #hardcoded dictionary of tetrode to shank mapping for probe geometry used in this study
bestCells = db[db['sustainedSuppressionIndex'].notnull(
)] #calculate depths for all the cells that we calculated SIs for
for dbIndex, dbRow in bestCells.iterrows():
subject = dbRow['subject']
try:
fileNameInfohist = os.path.join(settings.INFOHIST_PATH,
'{}_tracks.py'.format(subject))
tracks = imp.load_source('tracks_module', fileNameInfohist).tracks
except IOError:
print("No such tracks file: {}".format(fileNameInfohist))
else:
brainArea = dbRow['brainArea']
if brainArea == 'left_AC':
brainArea = 'LeftAC'
elif brainArea == 'right_AC':
brainArea = 'RightAC'
tetrode = dbRow['tetrode']
shank = tetrodetoshank[tetrode]
recordingTrack = dbRow['info'][0]
track = next(
(track
for track in tracks if (track['brainArea'] == brainArea) and (
track['shank'] == shank) and (
track['recordingTrack'] == recordingTrack)), None)
if track is not None:
histImage = track['histImage']
filenameSVG = ha.get_filename_registered_svg(
subject, brainArea, histImage, recordingTrack, shank)
if tetrode % 2 == 0:
depth = dbRow['depth']
else:
depth = dbRow['depth'] - 150.0 #odd tetrodes are higher
brainSurfCoords, tipCoords, siteCoords = ha.get_coords_from_svg(
filenameSVG, [depth], dbRow['maxDepth'])
siteCoords = siteCoords[0]
atlasZ = track['atlasZ']
cortexDepthData = np.rot90(lap[:, :, atlasZ], -1)
# We consider the points with depth > 0.95 to be the bottom surface of cortex
bottomData = np.where(cortexDepthData > 0.95)
# Top of cortex is less than 0.02 but greater than 0
topData = np.where((cortexDepthData < 0.02)
& (cortexDepthData > 0))
# Distance between the cell and each point on the surface of the brain
dXTop = topData[1] - siteCoords[0]
dYTop = topData[0] - siteCoords[1]
distanceTop = np.sqrt(dXTop**2 + dYTop**2)
# The index and distance to the closest point on the top surface
indMinTop = np.argmin(distanceTop)
minDistanceTop = distanceTop.min()
# Same for the distance from the cell to the bottom surface of cortex
dXBottom = bottomData[1] - siteCoords[0]
dYBottom = bottomData[0] - siteCoords[1]
distanceBottom = np.sqrt(dXBottom**2 + dYBottom**2)
minDistanceBottom = distanceBottom.min()
# The metric we want is the relative distance from the top surface
cellRatio = minDistanceTop / (minDistanceBottom +
minDistanceTop)
db.at[dbIndex, 'cortexRatioDepth'] = cellRatio
# use allen annotated atlas to figure out where recording site is
thisCoordID = rspAnnotationVolumeRotated[int(siteCoords[0]),
int(siteCoords[1]),
atlasZ]
structDict = rsp.structure_tree.get_structures_by_id(
[thisCoordID])
db.at[dbIndex, 'recordingSiteName'] = structDict[0]['name']
else:
print subject, brainArea, shank, recordingTrack
if len(filename) != 0:
celldatabase.save_hdf(db, filename)
print filename + " saved"
return db
'''
initialDB = '/mnt/jarahubdata/figuresdata/2018thstr/celldatabase_ALLCELLS_MODIFIED_CLU.h5'
amDiscrimDB = '/mnt/jarahubdata/figuresdata/2018thstr/figure_am/celldatabase_with_am_discrimination_accuracy.h5'
phaseDiscrimDB = '/mnt/jarahubdata/figuresdata/2018thstr/figure_am/celldatabase_with_phase_discrimination_accuracy.h5'
dbInitial = pd.read_hdf(initialDB, key='dataframe')
# Change the info column to allow saving with the new function
dbInitial['info'] = dbInitial['info'].apply(lambda x: [x] if not isinstance(x, list) else x)
dbAM = pd.read_hdf(amDiscrimDB, key='dataframe')
dbPhase = pd.read_hdf(phaseDiscrimDB, key='dataframe')
# Columns that need to be moved from aux databases to the main database
# dbAM has a column 'accuracy'. This is the discrimination accuracy of AM rate.
# dbPhase has a set of columns called phaseAccuracy_{}Hz for each AM rate
# Rename this column to be more informative. TODO: See what else we need to do if we change this name.
dbInitial['rateDiscrimAccuracy'] = dbAM['accuracy']
possibleRateKeys = np.array([4, 5, 8, 11, 16, 22, 32, 45, 64, 90, 128])
for rate in possibleRateKeys:
dbInitial['phaseDiscrimAccuracy_{}Hz'.format(rate)] = dbPhase['phaseAccuracy_{}Hz'.format(rate)]
newFn = '/mnt/jarahubdata/figuresdata/2018thstr/celldatabase_calculated_columns.h5'
#Save the database as a new name
celldatabase.save_hdf(dbInitial, newFn)
if 'reward_change_modulation' in filename
]
fullDb = celldatabase.load_hdf(
databaseFullPath) #pd.read_hdf(databaseFullPath,key='reward_change')
# -- replacing certain columns -- #
#colsToDrop = [col for col in dfThisMouse.columns if '-0.2-0s' in col]
#dfThisMouse = dfThisMouse.drop(columns=colsToDrop)
#################################
dfs = [fullDb]
for outFilename in outFilenames:
dfMod = pd.read_hdf(outFilename, key='reward_change')
dfs.append(dfMod)
dfAll = reduce(
lambda left, right: pd.merge(left,
right,
on=
['subject', 'date', 'tetrode', 'cluster'],
how='inner'), dfs)
dfAll.drop_duplicates(['subject', 'date', 'tetrode', 'cluster', 'depth'],
inplace=True)
if 'level_0' in dfAll.columns:
dfAll.drop('level_0', 1, inplace=True)
dfAll.reset_index(inplace=True)
if 'level_0' in dfAll.columns:
dfAll.drop('level_0', 1, inplace=True)
#dfAllThisMouse.to_hdf(databaseFullPath, key='reward_change')
celldatabase.save_hdf(dfAll, databaseFullPath)
#when saving to hdf, using (format='table',data_columns=True) is slower but enable on disk queries
