def analyzeABF(abf): abf = swhlab.ABF(abf) EPSCs = [] IPSCs = [] Xs = np.arange(abf.sweeps) * float(abf.sweepLength) / 60.0 for sweep in range(abf.sweeps): print("analyzing sweep %d of %d" % (sweep + 1, abf.sweeps)) plotToo = False if 0 < Xs[sweep] < 120: plotToo = r'C:\Users\swharden\Documents\temp' [hitsPos, hitsNeg] = analyzeSweep(abf, sweep=sweep, m1=.3, plotToo=plotToo) EPSCs.append(hitsPos / (float(abf.sweepLength) - .3)) IPSCs.append(hitsNeg / (float(abf.sweepLength) - .3)) EPSCsmooth = np.convolve(EPSCs, kernel_gaussian(20), mode='same') IPSCsmooth = np.convolve(IPSCs, kernel_gaussian(20), mode='same') plt.figure(figsize=(10, 5)) plt.grid() plt.plot(Xs, EPSCsmooth, '.', color='r', label="EPSCs", ms=10, alpha=.5) plt.plot(Xs, IPSCsmooth, '.', color='b', label="IPSCs", ms=10, alpha=.5) plt.axhline(0, color='k', lw=2) plt.legend() for t in abf.comment_times: plt.axvline(t / 60, color='k', lw=2, ls='--', alpha=.5) plt.margins(0, .1) plt.ylabel("event frequency (Hz)") plt.xlabel("time (minutes)") plt.show() indexPics(r'C:\Users\swharden\Documents\temp')
def test_0021_detectAndPlot2(self): abf = swhlab.ABF(testAbfPath) APs = swhlab.AP(abf) APs.detect() Xs = APs.get_bySweep("times") Ys = APs.get_bySweep("freqs") plt.figure(figsize=(10, 8)) for sweep in range(abf.sweeps): if not len(Ys[sweep]): continue abf.setsweep(sweep) plt.subplot(212) plt.plot(Xs[sweep][1:], Ys[sweep], '.', alpha=.5, label="sweep %d" % sweep, ms=10) plt.subplot(211) plt.plot(abf.sweepX2, abf.sweepY, alpha=.5) plt.ylabel(abf.units2) plt.subplot(212) plt.grid(alpha=.5) plt.legend(loc=3) plt.margins(.1, .1) plt.ylabel("frequency (Hz)") plt.xlabel("time (seconds)") plt.tight_layout() plt.savefig('./output/APsFreqs.jpg') plt.close('all')
def inspectABF(abf=exampleABF,saveToo=False,justPlot=False): """May be given an ABF object or filename.""" pylab.close('all') print(" ~~ inspectABF()") if type(abf) is str: abf=swhlab.ABF(abf) swhlab.plot.new(abf,forceNewFigure=True) if abf.sweepInterval*abf.sweeps<60*5: #shorter than 5 minutes pylab.subplot(211) pylab.title("%s [%s]"%(abf.ID,abf.protoComment)) swhlab.plot.sweep(abf,'all') pylab.subplot(212) swhlab.plot.sweep(abf,'all',continuous=True) swhlab.plot.comments(abf) else: print(" -- plotting as long recording") swhlab.plot.sweep(abf,'all',continuous=True,minutes=True) swhlab.plot.comments(abf,minutes=True) pylab.title("%s [%s]"%(abf.ID,abf.protoComment)) swhlab.plot.annotate(abf) if justPlot: return if saveToo: path=os.path.split(abf.fname)[0] basename=os.path.basename(abf.fname) pylab.savefig(os.path.join(path,"_"+basename.replace(".abf",".png"))) pylab.show() return
def test(): abf = swhlab.ABF(r'C:\Apps\pythonModules\abfs\16711016.abf') swhlab.ap.detect(abf) swhlab.ap.check_AP_phase(abf) Xs = swhlab.common.matrixValues(abf.APs, "expT") Ys = swhlab.common.matrixValues(abf.APs, "downslope") cm.show(True) pylab.plot(Xs, Ys, '.') cm.show(True)
def test_0020_sweepManipulation(self): """try setting sweeps to different use cases.""" abf = swhlab.ABF(testAbfPath) abf.setsweep(0) abf.setsweep(1) abf.setsweep(-1) # negative numbers start from end assert (abf.sweep == abf.sweeps - 1) abf.setsweep('-1') # should convert to 1 abf.setsweep('-lolz') # should fail
def test_0030_average(self): """test abf.average()""" abf = swhlab.ABF(testAbfPath) abf.average() abf.average(.2, .3) abf.average(setsweep=-1) assert abf.sweep == abf.sweeps - 1 abf.average(999, 999) abf.average(888, 999) abf.average(0, 999) abf.average(-999, 999) abf.average(-999, 0)
def autoABF(fname): pylab.close('all') #clean slate for good measure abf=swhlab.ABF(fname) #load the ABF abf.deleteStuff() method=abf.protoComment.replace("-","_") method="proto_"+method print(" ~~",method+"()") try: if method in globals(): globals()[method](abf) else: print(" ~~","proto_unknown()") proto_unknown(abf) except: print(traceback.format_exc()) print("~"*50,"CRASHED","~"*50) return abf.ID
def test_0020_detectAndPlot1(self): abf = swhlab.ABF(testAbfPath) APs = swhlab.AP(abf) APs.detect() plt.figure() #freqs firsts times for feature in "count average median".split(" "): plt.plot(np.arange(abf.sweeps), APs.get_bySweep(feature), '.-', label=feature, alpha=.5) plt.legend(loc=2) plt.margins(.1, .1) plt.xlabel("sweep") plt.savefig('./output/APs1.jpg') plt.close('all')
def analyzeABF(abf): abf = swhlab.ABF(abf) data = [] Xs = np.arange(abf.sweeps) * float(abf.sweepLength) / 60.0 for sweep in range(abf.sweeps): print("analyzing sweep %d of %d" % (sweep + 1, abf.sweeps)) data.append(analyzeSweep(abf, sweep=sweep, m1=.3)) plt.figure(figsize=(10, 5)) plt.grid() plt.plot(Xs[:len(data)], data, '.', alpha=.5, ms=10) plt.axhline(0, color='k', lw=1, ls='--') for t in abf.comment_times: plt.axvline(t / 60, color='k', lw=2, ls='--', alpha=.5) plt.margins(0, .1) plt.xlabel("time (minutes)") plt.ylabel("excitatory balance") plt.show() indexPics(r'C:\Users\swharden\Documents\temp')
def test_0005_plotWithOnlyCore(self): abf = swhlab.ABF(testAbfPath) abf.derivative = True abf.setsweep(-1) # required to do again plt.figure(figsize=(10, 10)) plt.subplot(211) plt.grid(alpha=.5) plt.title("plotting directly from swhlab.ABF") plt.ylabel(abf.units2) plt.plot(abf.sweepX, abf.sweepY, alpha=.5) plt.subplot(212) plt.grid(alpha=.5) plt.ylabel(abf.unitsD2) plt.xlabel("time (sec)") plt.plot(abf.sweepX, abf.sweepD, alpha=.5) plt.tight_layout() plt.savefig('./output/raw.png') plt.close('all')
def test_0040_averageSweep(self): """test abf.averageSweep()""" abf = swhlab.ABF(testAbfPath) abf.averageSweep() abf.averageSweep(0, 1)
plt.subplot(212) plt.plot(Xs, chunks[sweep] + 100 * sweep, alpha=.5, color='b', lw=2) plt.subplot(211) plt.plot(Xs, np.average(chunks, axis=0), alpha=.5, lw=2) plt.title("%s.abf - BLS - average of %d sweeps" % (abf.ID, abf.sweeps)) plt.ylabel(abf.units2) plt.axvspan(T1, T2, alpha=.1, color='y', lw=0) plt.axis([X1, X2, None, None]) plt.subplot(212) plt.xlabel("time (sec)") plt.ylabel("stacked sweeps") plt.axvspan(T1, T2, alpha=.1, color='y', lw=0) plt.axis([X1, X2, None, None]) plt.tight_layout() plt.show() plt.close('all') if __name__ == "__main__": fname = r"X:\Data\2P01\2016\2017-01-09 AT1\17109009.abf" #0501 # fname=r"X:\Data\2P01\2016\2017-01-09 AT1\"17109013.abf"#0502 abf = swhlab.ABF(fname) if abf.protocomment in ['0501', '0502']: BLS_average(abf) print("DONE")
def test2(): """current clamp MT.""" abf = swhlab.ABF(r'C:\Apps\pythonModules\abfs\16701006.abf') swhlab.memtest.memtest(abf) #performs memtest on all sweeps swhlab.memtest.checkSweep(abf) #lets you eyeball check how it did pylab.show()
plt.axhline(0, color='k', lw=2, alpha=.5) plt.tight_layout() plt.show() # TEST GAUSS hist, bin_edges = np.histogram(Yflat, density=True, bins=200) peakPa = bin_edges[np.where(hist == max(hist))[0][0] + 1] if plotToo: plt.figure() plt.grid() plt.plot(bin_edges[1:], hist, alpha=.5) plt.axvline(0, color='k') plt.axvline(peakPa, color='r', ls='--', lw=2, alpha=.5) plt.semilogy() plt.title("sweep data distribution") plt.ylabel("power") plt.xlabel("pA deviation") plt.show() return peakPa if __name__ == "__main__": #analyzeABF(r"X:\Data\2P01\2016\2016-09-01 PIR TGOT\16d07022.abf") abf = swhlab.ABF(r"X:\Data\2P01\2016\2016-09-01 PIR TGOT\16d07022.abf") analyzeSweep(abf, sweep=174, m1=.3, plotToo=True) analyzeSweep(abf, sweep=199, m1=.3, plotToo=True) print("DONE")
def test_0010_loadAndClose(self): """just load an ABF""" abf = swhlab.ABF(testAbfPath) assert (len(abf.sweepY)) # ensure we have data
def atf_empty(lengthSec=5, rate=20000): data = np.empty((rate * lengthSec, 2)) data[:, 0] = np.arange(len(data)) / rate return data def atf_sine(lengthSec=5, rate=20000): data = np.empty((rate * lengthSec, 2)) data[:, 0] = np.arange(len(data)) / rate data[:, 1] = np.sin((data[:, 0]) * np.pi * 2) #1hz sine wave return data def atf_ipsc(): data = atf_sine() pylab.plot(data[:, 0], data[:, 1]) pylab.show() fname = "%d.atf" % time.time() np.savetxt(fname, data, fmt="%.6f", header=atf_header, comments='', delimiter='\t') if __name__ == "__main__": abf = swhlab.ABF('../abfs/group/16701010.abf') print("DONE")
def processAbf(abfFname,saveAs=False,dpi=100,show=True): """ automatically generate a single representative image for an ABF. If saveAs is given (full path of a jpg of png file), the image will be saved. Otherwise, the image will pop up in a matplotlib window. """ if not type(abfFname) is str or not len(abfFname)>3: return abf=swhlab.ABF(abfFname) plot=swhlab.plotting.ABFplot(abf) plot.figure_height=6 plot.figure_width=10 plot.subplot=False plot.figure(True) if abf.get_protocol_sequence(0)==abf.get_protocol_sequence(1) or abf.sweeps<2: # same protocol every time if abf.lengthMinutes<2: # short (probably a memtest or tau) ax1=plt.subplot(211) plot.figure_sweeps() plt.title("{} ({} sweeps)".format(abf.ID,abf.sweeps)) plt.gca().get_xaxis().set_visible(False) plt.subplot(212,sharex=ax1) plot.figure_protocol() plt.title("") else: # long (probably a drug experiment) plot.figure_chronological() else: # protocol changes every sweep plots=[211,212] # assume we want 2 images if abf.units=='mV': # maybe it's something with APs? ap=swhlab.AP(abf) # go ahead and do AP detection ap.detect() # try to detect APs if len(ap.APs): # if we found some plots=[221,223,222,224] # get ready for 4 images ax1=plt.subplot(plots[0]) plot.figure_sweeps() plt.title("{} ({} sweeps)".format(abf.ID,abf.sweeps)) plt.gca().get_xaxis().set_visible(False) plt.subplot(plots[1],sharex=ax1) plot.figure_protocols() plt.title("protocol") if len(plots)>2: # assume we want to look at the first AP ax2=plt.subplot(plots[2]) plot.rainbow=False plot.kwargs["color"]='b' plot.figure_chronological() plt.gca().get_xaxis().set_visible(False) plt.title("first AP magnitude") # velocity plot plt.subplot(plots[3],sharex=ax2) plot.abf.derivative=True plot.rainbow=False plot.traceColor='r' plot.figure_chronological() plt.axis([ap.APs[0]["T"]-.05,ap.APs[0]["T"]+.05,None,None]) plt.title("first AP velocity") if saveAs: print("saving",os.path.abspath(saveAs)) plt.savefig(os.path.abspath(saveAs),dpi=dpi) return if show: plot.show()
import os import swhlab import matplotlib.pyplot as plt import numpy as np import pickle if __name__ == "__main__": abfPath = r"X:\Data\2P01\2016\2016-09-01 PIR TGOT" abfFile = os.path.join(abfPath, "16d14060.abf") abf = swhlab.ABF(abfFile) Xs = np.arange(abf.sweeps) * abf.sweepLength # figure out if we should calculate or load phasic data phasicFname = abf.filename + ".phasic.npy" if not os.path.exists(phasicFname): data = np.empty((abf.sweeps, 3)) for sweep in abf.setsweeps(): print("analyzing sweep %d of %d" % (sweep, abf.sweeps)) data[sweep] = abf.phasic(returnSeparated=True) np.save(phasicFname, data) else: data = np.load(phasicFname) # plot the result with comments plt.figure(figsize=(5, 5)) plt.subplot(211) plt.plot(Xs, data[:, 2], '.', color='k', alpha=.1) plt.plot(Xs, swhlab.common.lowpass(data[:, 2], 40), '-',
def test_0050_derivative(self): abf = swhlab.ABF(testAbfPath) abf.derivative = True abf.setsweep(1) assert len(abf.sweepD) > 100
downslopes=cm.dictVals(cm.dictFlat(abf.APs),"downslope") print("Found %d APs."%len(downslopes)) print("Avg downslope: %.02f V/S"%np.average(downslopes)) pylab.show() """ import os import sys import pylab import time import numpy as np import traceback import swhlab import swhlab.core.common as cm exampleABF = swhlab.ABF() #TODO: this dictionary thing isn't a good idea long term. Can we make it NPY? def detect(abf, sweep=None, threshold_upslope=50, dT=.1, saveToo=True): """ An AP will be detected by a upslope that exceeds 50V/s. Analyzed too. if type(sweep) is int, graph int(sweep) if sweep==None, process all sweeps sweep. """ if type(sweep) is int: sweeps = [sweep] else: sweeps = list(range(abf.sweeps)) timeStart = time.clock()
"""Same as 01.py, but reports speed""" import os import sys if not os.path.abspath('../../../') in sys.path: sys.path.append('../../../') import swhlab import matplotlib.pyplot as plt import numpy as np import time if __name__=="__main__": abfFile=R"X:\Data\DIC1\2013\08-2013\08-16-2013-DP\13816004.abf" abf=swhlab.ABF(abfFile) # defaults to sweep 0 print("analyzing %d sweeps (%.02f sec each)"%(abf.sweeps,abf.sweepLength)) times=[] for sweep in abf.setsweeps(): t1=time.clock() baseFrequency=60 # frequency (Hz) to silence FFT=np.fft.fft(abf.sweepY) # frequency data (i/j vectors starting at 0Hz) for i in range(50): # first 50 odd harmonics I=int(baseFrequency*i+baseFrequency*len(abf.sweepY)/abf.pointsPerSec) FFT[I],FFT[-I]=0,0 # remember to silence from both ends of the FFT Ys2=np.fft.ifft(FFT) # all done times.append(time.clock()-t1) times=np.array(times)*1000 # now in ms print("analysis took %.02f +/- %.02f ms per sweep"%(np.average(times),np.std(times))) # analyzing 60 sweeps (5.00 sec each) # analysis took 6.47 +/- 1.71 ms per sweep
import swhlab import matplotlib.pyplot as plt import numpy as np if __name__ == "__main__": abfFname = r'X:\Data\2P01\2016\2016-09-01 PIR TGOT\16831057.abf' abf = swhlab.ABF(abfFname) # now it's a swhlab ABF object abf.setsweep(267) # set the sweep # calculate membrane resistance baseline = abf.average(.5) / (10**12) # A baselineMT = abf.average(.05, .15) / (10**12) # A dV = 10 / (10**3) # 10 mV dI = abs(baselineMT - baseline) # A Rm = (dV / dI) # R=E/I MOhm # cut off the first half-second (which has memtest) Y = abf.sweepY[int(abf.pointsPerSec * .5):] / (10**12) #A X = abf.sweepX2[int(abf.pointsPerSec * .5):] # create a new figure plt.figure(figsize=(10, 8)) # design the top plot plt.subplot(311) plt.grid() plt.title("voltage clamp (Rm = %.02f MOhm)" % (Rm / (10**6))) plt.ylabel("current (pA)") plt.plot(X, Y * (10**12), color='r', alpha=.8) # plot the data plt.axhline(baseline * (10**12), color='k', lw=3, ls='--', alpha=.5)
plt.xlabel("time (sec)") plt.margins(0, .1) # make the phase plot plt.subplot(133) plt.grid(alpha=.5) plt.plot(Y, dY, alpha=.5, lw=.5, color=cm(abf.sweep / abf.sweeps)) plt.title("phase plot") plt.ylabel("dV (mV/ms)") plt.xlabel("V (mV)") plt.margins(.1, .1) # tighten up the figure plt.tight_layout() if __name__ == "__main__": #abf=swhlab.ABF(R"X:\Data\SCOTT\2017-07-13 OXT-Tom OneOff\17713015.abf") abf = swhlab.ABF(R"X:\Data\SCOTT\2017-07-13 OXT-Tom OneOff\17713013.abf") plt.figure(figsize=(12, 4)) for sweep in abf.setsweeps(): #if sweep<abf.sweeps-1: continue print("plotting sweep", sweep, '...') plt.set_cmap('winter') drawPhasePlot(abf) plt.savefig("phase_%s.png" % abf.ID, dpi=300) plt.show() plt.close('all') print("DONE")
def test_0010_detect(self): abf = swhlab.ABF(testAbfPath) APs = swhlab.AP(abf) APs.detect() assert len(APs.APs)
This module is somewhat experiment specific. The idea is to match protocols (defined by comments) to analysis routines. This is specific to Scott's current set of experiments. Probably this doesn't belong in the module at all... """ import os import sys import glob import pylab import numpy as np import traceback import swhlab from swhlab.core import common as cm #shorthand from swhlab.indexing.indexing import genIndex exampleABF=swhlab.ABF(None) #this helps for IDE recommendations def standard_inspect(abf=exampleABF): cm.inspectABF(abf,justPlot=True) swhlab.plot.save(abf,tag="00-inspect") def standard_overlayWithAverage(abf=exampleABF): swhlab.plot.sweep(abf,'all',alpha=.1) Xs,Av,Es=abf.average_sweep() pylab.plot(Xs,Av,'k') pylab.title("average (n=%d)"%abf.sweeps) swhlab.plot.save(abf,tag='overlay') def standard_groupingForInj(abf,target=200): for i in range(abf.sweeps): abf.setSweep(i)
def test(): abf = swhlab.ABF('../abfs/aps.abf') swhlab.plot.sweep(abf, 8, newFigure=True) #single sweep swhlab.plot.sweep(abf, 'all', newFigure=True) #overlay swhlab.plot.sweep(abf, 'all', newFigure=True, continuous=True) #continuous swhlab.plot.sweep(abf, 'all', newFigure=True, offsetY=100) #stacked
import os import swhlab import matplotlib.pyplot as plt if __name__ == "__main__": abfPath = r"X:\Data\2P01\2016\2016-09-01 PIR TGOT" abf1 = swhlab.ABF(os.path.join(abfPath, "16d14010.abf")) abf2 = swhlab.ABF(os.path.join(abfPath, "16d14011.abf")) I1, I2 = abf1.pointsPerSec * .5, abf1.sweepLength abf1.kernel = abf1.kernel_gaussian(50, True) abf2.kernel = abf2.kernel_gaussian(50, True) plt.figure(figsize=(10, 3)) for i in range(5, 10): abf1.setsweep(abf1.sweeps - i) abf2.setsweep(i) Xoffset = abf1.sweepLength * i Y1 = abf1.sweepYfiltered()[I1:] Y2 = abf2.sweepYfiltered()[I1:] Y1 = Y1 - Y1[0] Y2 = Y2 - Y2[0] plt.plot(abf1.sweepX2[I1:] + .1 * i, Y1 + 30 * i, alpha=.5, color='b') plt.plot(abf2.sweepX2[I1:] + 1.5 + .1 * i, Y2 + 30 * i, alpha=.5, color='g') plt.margins() plt.title("5 sweeps at -70 vs -50") plt.show() print("DONE")
import sys sys.path.insert(0, '../') # force us to import ../swhlab/ module import swhlab import numpy as np import matplotlib.pyplot as plt if __name__ == '__main__': abf = swhlab.ABF(R"X:\Data\2P01\10.7.0.3_modelCell\17217003.abf") plt.plot(abf.sweepX2, abf.sweepY) plt.show() print(steps)