def ppr_peak():
# Get function values
decay_func = stf.leastsq(0)
# Create time from fit start to next peak
x = np.arange(stf.get_fit_start(), stf.peak_index())
# Create fitted curve up until peak
trace = [(decay_func['Offset'] + decay_func['Amp_0'] * np.exp(-(ind/10.0)/decay_func['Tau_0'])) for ind, val in enumerate(x)]
# Find peak value
peak_val = stf.get_peak()-stf.get_base()
print('The measured peak is {0} pA'.format(peak_val))
# Find value of fit at peak
fit_peak = trace[-1] - stf.get_base()
print('Tau is {0} pA'.format(decay_func['Tau_0']))
print('The fitted peak is {0} pA'.format(fit_peak))
print('The baseline is {0} pA'.format(stf.get_base()))
# stf.new_window(trace)
final_peak = peak_val - fit_peak
print('The final peak is {0} pA'.format(final_peak))
return True
def preliminary():
"""Creates a preliminary template"""
stf.set_peak_start(209900)
stf.set_peak_end(210500)
stf.set_fit_start(209900)
stf.set_fit_end(210400)
stf.set_peak_mean(3)
stf.set_base_start(209600)
stf.set_base_end(209900)
stf.measure()
return stf.leastsq(5)
def final():
"""Creates a final template"""
stf.set_peak_start(100)
stf.set_peak_end(599)
stf.set_fit_start(100)
stf.set_fit_end(599)
stf.set_peak_mean(3)
stf.set_base_start(0)
stf.set_base_end(100)
stf.measure()
return stf.leastsq(5)
def preliminary():
"""Creates a preliminary template"""
stf.set_peak_start(209900)
stf.set_peak_end(210500)
stf.set_fit_start(209900)
stf.set_fit_end(210400)
stf.set_peak_mean(3)
stf.set_base_start(209600)
stf.set_base_end(209900)
stf.measure()
return stf.leastsq(5)
def final():
"""Creates a final template"""
stf.set_peak_start(100)
stf.set_peak_end(599)
stf.set_fit_start(100)
stf.set_fit_end(599)
stf.set_peak_mean(3)
stf.set_base_start(0)
stf.set_base_end(100)
stf.measure()
return stf.leastsq(5)
def final():
"""
Sets peak, base and fit cursors around a synaptic event
and performs a biexponetial fit to create the final template
for event detection.
"""
stf.base.cursor_index = (000, 100)
stf.peak.cursor_index = (100, 599)
stf.fit.cursor_index = (100, 599)
stf.set_peak_mean(3)
stf.measure() # update cursors
return stf.leastsq(5)
def preliminary():
"""
Sets peak, base and fit cursors around a synaptic event
and performs a biexponential fit to create the preliminary template
for event detection.
"""
stf.base.cursor_index = (209600, 209900)
stf.peak.cursor_index = (209900, 210500)
stf.fit.cursor_index = (209900, 210400)
stf.set_peak_mean(3)
stf.measure() # update cursors
return stf.leastsq(5)
def fit_experiment(params, pulse_length, function_to_fit):
num_sweeps = stf.get_size_channel()
stf.set_channel(0)
stf.set_trace(0)
#jjm_analysis.set_params(params);
#stf.measure();
#this is in samples
#peak_index = stf.peak_index();
#stf.set_fit_start(peak_index, is_time=False);
#fit_start_time = peak_index*stf.get_sampling_interval();
#stf.set_fit_end(fit_start_time+pulse_length-(10*stf.get_sampling_interval()), is_time=True);
#fit_func = stf.leastsq(function_to_fit);
#fit_func['Baseline(pA)']=stf.get_base();
#fit_df = pd.DataFrame(fit_func, index=[0]);
fits = []
traces = []
for x in range(0, num_sweeps):
stf.set_trace(x)
jjm_analysis.set_params(params)
stf.measure()
#this is in samples
peak_index = stf.peak_index()
stf.set_fit_start(peak_index, is_time=False)
fit_start_time = peak_index * stf.get_sampling_interval()
stf.set_fit_end(fit_start_time + pulse_length -
(10 * stf.get_sampling_interval()),
is_time=True)
sweep_fit = stf.leastsq(function_to_fit)
sweep_fit['Baseline(pA)'] = stf.get_base()
fits.append(sweep_fit)
traces.append(x)
fit_df = pd.DataFrame(fits)
return (fit_df)
def glu_iv(pulses=13, subtract_base=True):
"""Calculates an iv from a repeated series of fast application and
voltage pulses.
Keyword arguments:
pulses -- Number of pulses for the iv.
subtract_base -- If True (default), baseline will be subtracted.
Returns:
True if successful.
"""
# Some ugly definitions for the time being
# Cursors are in ms here.
gFitEnd = 330.6 # fit end cursor is variable
gFSelect = 0 # Monoexp
gDictSize = stf.leastsq_param_size(
gFSelect) + 2 # Parameters, chisqr, peak value
gBaseStart = 220.5 # Start and end of the baseline before the control pulse, in ms
gBaseEnd = 223.55
gPeakStart = 223.55 # Start and end of the peak cursors for the control pulse, in ms
gPeakEnd = 253.55
if (gDictSize < 0):
print('Couldn\'t retrieve function id=%d, aborting now.' % gFSelect)
return False
if (not (stf.check_doc())):
print('Couldn\'t find an open file; aborting now.')
return False
# analyse iv, subtract baseline if requested:
ivtools.analyze_iv(pulses)
if (subtract_base == True):
if (not (stf.set_base_start(gBaseStart, True))): return False
if (not (stf.set_base_end(gBaseEnd, True))): return False
stf.measure()
stf.select_all()
stf.subtract_base()
# set cursors:
if (not (stf.set_peak_start(gPeakStart, True))): return False
if (not (stf.set_peak_end(gPeakEnd, True))): return False
if (not (stf.set_base_start(gBaseStart, True))): return False
if (not (stf.set_base_end(gBaseEnd, True))): return False
if (not (stf.set_fit_end(gFitEnd, True))): return False
if (not (stf.set_peak_mean(3))): return False
if (not (stf.set_peak_direction("both"))): return False
# A list for dictionary keys and values:
dict_keys = []
dict_values = np.empty((gDictSize, stf.get_size_channel()))
firstpass = True
for n in range(0, stf.get_size_channel()):
if (stf.set_trace(n) == False):
print('Couldn\'t set a new trace; aborting now.')
return False
print('Analyzing trace %d of %d' % (n + 1, stf.get_size_channel()))
# set the fit window cursors:
if (not (stf.set_fit_start(stf.peak_index()))): return False
# Least-squares fitting:
p_dict = stf.leastsq(gFSelect)
if (p_dict == 0):
print('Couldn\'t perform a fit; aborting now.')
return False
# Create an empty list:
tempdict_entry = []
row = 0
for k, v in p_dict.iteritems():
if (firstpass == True):
dict_keys.append(k)
dict_values[row][n] = v
row = row + 1
if (firstpass):
dict_keys.append("Peak amplitude")
dict_values[row][n] = stf.get_peak() - stf.get_base()
firstpass = False
retDict = dict()
# Create the dictionary for the table:
entry = 0
for elem in dict_keys:
retDict[elem] = dict_values[entry].tolist()
entry = entry + 1
return stf.show_table_dictlist(retDict)
def timeconstants(fitwindow, pulsewindow, ichannel=0, vchannel=1):
"""
Compute and plot decay time constants
Parameters
----------
fitwindow : (float, float), optional
Window for fitting time constant (time in ms from beginning of sweep)
None for current cursor settings. Default: None
pulsewindow : (float, float), optional
Window for voltage pulse measurement (time in ms from beginning of sweep)
None for current cursor settings. Default: None
ichannel : int, optional
current channel number. Default: 0
vchannel : int, optional
voltage channel number. Default: 1
Returns
-------
v_commands : numpy.ndarray
Command voltages
taus : numpy.ndarray
Time constants
"""
import stf
if not stf.check_doc():
return None
nchannels = stf.get_size_recording()
if nchannels < 2:
sys.stderr.write(
"Function requires 2 channels (0: current; 1: voltage)\n")
return
dt = stf.get_sampling_interval()
v_commands = []
taus = []
fig = stf.mpl_panel(figsize=(12, 8)).fig
fig.clear()
gs = gridspec.GridSpec(4, 8)
ax_currents = stfio_plot.StandardAxis(fig,
gs[:3, :4],
hasx=False,
hasy=False)
ax_voltages = stfio_plot.StandardAxis(fig,
gs[3:, :4],
hasx=False,
hasy=False,
sharex=ax_currents)
for ntrace in range(stf.get_size_channel()):
stf.set_trace(ntrace)
stf.set_channel(ichannel)
trace = stf.get_trace()
ax_currents.plot(np.arange(len(trace)) * dt, trace)
if fitwindow is not None:
stf.fit.cursor_time = fitwindow
res = stf.leastsq(0, False)
taus.append(res['Tau_0'])
# Measure pulse amplitude
stf.set_channel(vchannel)
trace = stf.get_trace()
ax_voltages.plot(np.arange(len(trace)) * dt, trace)
stf.set_peak_direction("up")
stf.set_peak_mean(-1)
if pulsewindow is not None:
stf.peak.cursor_time = pulsewindow
stf.measure()
v_commands.append(stf.peak.value)
stfio_plot.plot_scalebars(ax_currents,
xunits=stf.get_xunits(),
yunits=stf.get_yunits(channel=ichannel))
stfio_plot.plot_scalebars(ax_voltages,
xunits=stf.get_xunits(),
yunits=stf.get_yunits(channel=vchannel))
v_commands = np.array(v_commands)
taus = np.array(taus)
ax_taus = plot_iv(taus, v_commands, "ms", stf.get_yunits(channel=vchannel),
fig, 122)
# Reset peak computation to single sampling point
stf.set_peak_mean(1)
# Reset active channel
stf.set_channel(ichannel)
# Compute conductances:
stf.show_table_dictlist({
"Voltage ({0})".format(stf.get_yunits(channel=vchannel)):
v_commands.tolist(),
"Taus (ms)":
taus.tolist(),
})
return v_commands, taus
def psc_analysis(self):
self.psc_data = self.metadata[self.metadata.recording_type == 'psc']
self.psc_data['ch1_self_psc'] = [False for _ in self.psc_data]
self.psc_data['ch1_other_psc'] = [False for _ in self.psc_data]
self.psc_data['ch2_self_psc'] = [False for _ in self.psc_data]
self.psc_data['ch2_other_psc'] = [False for _ in self.psc_data]
self.psc_data['ch1_self_tau'] = [False for _ in self.psc_data]
self.psc_data['ch1_other_tau'] = [False for _ in self.psc_data]
self.psc_data['ch2_self_tau'] = [False for _ in self.psc_data]
self.psc_data['ch2_other_tau'] = [False for _ in self.psc_data]
for idx, abffiles in enumerate(self.psc_data):
# Initialize Channel 1
data = AbfFile(abffiles, self.path)
stf.new_window_matrix(data.channel1.signal)
# Cell 1 to Self
advance_var = input("Cell 1: Select the traces to use, set the Peak, Baseline, and fit cursors for self.\n"
"If no connection exists, type 'no connection'\n"
"Type 'y' to advance to the next trace:\t")
while advance_var is not 'y' or advance_var is not 'no connection':
advance_var = input("You must type 'y' or 'no connection' to advance:\t")
if advance_var == 'no connection':
self.psc_data['ch1_self_psc'][idx] = None
self.psc_data['ch1_self_tau'][idx] = None
else:
peaks = np.array(
[np.min(trace[stf.get_peak_start():stf.get_peak_end()]) for trace in data.channel1.signal]
)
bases = np.array(
[np.mean(trace[stf.get_base_start():stf.get_base_end()]) for trace in data.channel1.signal]
)
peak = np.mean(peaks - bases)
fit = stf.leastsq(0)
self.psc_data['ch1_self_psc'][idx] = peak
self.psc_data['ch1_self_tau'][idx] = fit['Tau_0']
# Cell 2 to Cell 1
advance_var = input("Great, now do the same for Cell 2 onto Cell 1.\n"
"Type 'y' to advance to the next trace:\t")
while advance_var is not 'y' or advance_var is not 'no connection':
advance_var = input("You must type 'y' or 'no connection' to advance:\t")
if advance_var == 'no connection':
self.psc_data['ch2_other_psc'][idx] = None
self.psc_data['ch2_other_tau'][idx] = None
else:
peaks = np.array(
[np.min(trace[stf.get_peak_start():stf.get_peak_end()]) for trace in data.channel1.signal]
)
bases = np.array(
[np.mean(trace[stf.get_base_start():stf.get_base_end()]) for trace in data.channel1.signal]
)
peak = np.mean(peaks - bases)
fit = stf.leastsq(0)
self.psc_data['ch2_other_psc'][idx] = peak
self.psc_data['ch2_other_tau'][idx] = fit['Tau_0']
# Initialize Channel 2
data = AbfFile(abffiles, self.path)
stf.new_window_matrix(data.channel1.signal)
# Cell 2 to Self
advance_var = input("Cell 2: Select the traces to use, set the Peak, Baseline, and fit cursors for self.\n"
"If no connection exists, type 'no connection'\n"
"Type 'y' to advance to the next trace:\t")
while advance_var is not 'y' or advance_var is not 'no connection':
advance_var = input("You must type 'y' or 'no connection' to advance:\t")
if advance_var == 'no connection':
self.psc_data['ch2_self_psc'][idx] = None
self.psc_data['ch2_self_tau'][idx] = None
else:
peaks = np.array([np.min(trace[stf.get_peak_start():stf.get_peak_end()]) for trace in data.channel1.signal])
bases = np.array(
[np.mean(trace[stf.get_base_start():stf.get_base_end()]) for trace in data.channel1.signal])
peak = np.mean(peaks - bases)
fit = stf.leastsq(0)
self.psc_data['ch2_self_psc'][idx] = peak
self.psc_data['ch2_self_tau'][idx] = fit['Tau_0']
# Cell 2 to Cell 1
advance_var = input("Great, now do the same for Cell 2 onto Cell 1.\n"
"Type 'y' to advance to the next trace:\t")
while advance_var is not 'y' or advance_var is not 'no connection':
advance_var = input("You must type 'y' or 'no connection' to advance:\t")
if advance_var == 'no connection':
self.psc_data['ch1_other_psc'][idx] = None
self.psc_data['ch1_other_tau'][idx] = None
else:
peaks = np.array([np.min(trace[stf.get_peak_start():stf.get_peak_end()]) for trace in data.channel1.signal])
bases = np.array(
[np.mean(trace[stf.get_base_start():stf.get_base_end()]) for trace in data.channel1.signal])
peak = np.mean(peaks - bases)
fit = stf.leastsq(0)
self.psc_data['ch1_other_psc'][idx] = peak
self.psc_data['ch1_other_tau'][idx] = fit['Tau_0']
self.psc_data.to_csv(os.path.join(self.path, '.stimpy', 'psc_data.csv'))
def glu_iv( pulses = 13, subtract_base=True ):
"""Calculates an iv from a repeated series of fast application and
voltage pulses.
Keyword arguments:
pulses -- Number of pulses for the iv.
subtract_base -- If True (default), baseline will be subtracted.
Returns:
True if successful.
"""
# Some ugly definitions for the time being
# Cursors are in ms here.
gFitEnd = 330.6 # fit end cursor is variable
gFSelect = 0 # Monoexp
gDictSize = stf.leastsq_param_size( gFSelect ) + 2 # Parameters, chisqr, peak value
gBaseStart = 220.5 # Start and end of the baseline before the control pulse, in ms
gBaseEnd = 223.55
gPeakStart = 223.55 # Start and end of the peak cursors for the control pulse, in ms
gPeakEnd = 253.55
if ( gDictSize < 0 ):
print('Couldn\'t retrieve function id=%d, aborting now.'%gFSelect)
return False
if ( not(stf.check_doc()) ):
print('Couldn\'t find an open file; aborting now.')
return False
# analyse iv, subtract baseline if requested:
ivtools.analyze_iv( pulses )
if ( subtract_base == True ):
if ( not(stf.set_base_start( gBaseStart, True )) ): return False
if ( not(stf.set_base_end( gBaseEnd, True )) ): return False
stf.measure()
stf.select_all()
stf.subtract_base()
# set cursors:
if ( not(stf.set_peak_start( gPeakStart, True )) ): return False
if ( not(stf.set_peak_end( gPeakEnd, True )) ): return False
if ( not(stf.set_base_start( gBaseStart, True )) ): return False
if ( not(stf.set_base_end( gBaseEnd, True )) ): return False
if ( not(stf.set_fit_end( gFitEnd, True )) ): return False
if ( not(stf.set_peak_mean( 3 )) ): return False
if ( not(stf.set_peak_direction( "both" )) ): return False
# A list for dictionary keys and values:
dict_keys = []
dict_values = np.empty( (gDictSize, stf.get_size_channel()) )
firstpass = True
for n in range( 0, stf.get_size_channel() ):
if ( stf.set_trace( n ) == False ):
print('Couldn\'t set a new trace; aborting now.')
return False
print('Analyzing trace %d of %d'%( n+1, stf.get_size_channel() ) )
# set the fit window cursors:
if ( not(stf.set_fit_start( stf.peak_index() )) ): return False
# Least-squares fitting:
p_dict = stf.leastsq( gFSelect )
if ( p_dict == 0 ):
print('Couldn\'t perform a fit; aborting now.')
return False
# Create an empty list:
tempdict_entry = []
row = 0
for k, v in p_dict.iteritems():
if ( firstpass == True ):
dict_keys.append( k )
dict_values[row][n] = v
row = row+1
if ( firstpass ):
dict_keys.append( "Peak amplitude" )
dict_values[row][n] = stf.get_peak()-stf.get_base()
firstpass = False
retDict = dict()
# Create the dictionary for the table:
entry = 0
for elem in dict_keys:
retDict[ elem ] = dict_values[entry].tolist()
entry = entry+1
return stf.show_table_dictlist( retDict )
def timeconstants(fitwindow, pulsewindow, ichannel=0, vchannel=1):
"""
Compute and plot decay time constants
Parameters
----------
fitwindow : (float, float), optional
Window for fitting time constant (time in ms from beginning of sweep)
None for current cursor settings. Default: None
pulsewindow : (float, float), optional
Window for voltage pulse measurement (time in ms from beginning of sweep)
None for current cursor settings. Default: None
ichannel : int, optional
current channel number. Default: 0
vchannel : int, optional
voltage channel number. Default: 1
Returns
-------
v_commands : numpy.ndarray
Command voltages
taus : numpy.ndarray
Time constants
"""
import stf
if not stf.check_doc():
return None
nchannels = stf.get_size_recording()
if nchannels < 2:
sys.stderr.write(
"Function requires 2 channels (0: current; 1: voltage)\n")
return
dt = stf.get_sampling_interval()
v_commands = []
taus = []
fig = stf.mpl_panel(figsize=(12, 8)).fig
fig.clear()
gs = gridspec.GridSpec(4, 8)
ax_currents = stfio_plot.StandardAxis(
fig, gs[:3, :4], hasx=False, hasy=False)
ax_voltages = stfio_plot.StandardAxis(
fig, gs[3:, :4], hasx=False, hasy=False, sharex=ax_currents)
for ntrace in range(stf.get_size_channel()):
stf.set_trace(ntrace)
stf.set_channel(ichannel)
trace = stf.get_trace()
ax_currents.plot(np.arange(len(trace))*dt, trace)
if fitwindow is not None:
stf.fit.cursor_time = fitwindow
res = stf.leastsq(0, False)
taus.append(res['Tau_0'])
# Measure pulse amplitude
stf.set_channel(vchannel)
trace = stf.get_trace()
ax_voltages.plot(np.arange(len(trace))*dt, trace)
stf.set_peak_direction("up")
stf.set_peak_mean(-1)
if pulsewindow is not None:
stf.peak.cursor_time = pulsewindow
stf.measure()
v_commands.append(stf.peak.value)
stfio_plot.plot_scalebars(
ax_currents, xunits=stf.get_xunits(),
yunits=stf.get_yunits(channel=ichannel))
stfio_plot.plot_scalebars(
ax_voltages, xunits=stf.get_xunits(),
yunits=stf.get_yunits(channel=vchannel))
v_commands = np.array(v_commands)
taus = np.array(taus)
ax_taus = plot_iv(
taus, v_commands, "ms",
stf.get_yunits(channel=vchannel), fig, 122)
# Reset peak computation to single sampling point
stf.set_peak_mean(1)
# Reset active channel
stf.set_channel(ichannel)
# Compute conductances:
stf.show_table_dictlist({
"Voltage ({0})".format(
stf.get_yunits(channel=vchannel)): v_commands.tolist(),
"Taus (ms)": taus.tolist(),
})
return v_commands, taus
