def _get_deconvolved_trains(self):
train_responses = self.train_responses
deconv = OrderedDict()
for k,v in train_responses.items():
ind = v[0].bsub_mean()
rec = v[1].bsub_mean()
idec = bessel_filter(exp_deconvolve(ind, self.exp_tau), self.cutoff)
rdec = bessel_filter(exp_deconvolve(rec, self.exp_tau), self.cutoff)
deconv[k] = (idec, rdec)
self._deconvolved_trains = deconv
def _get_deconvolved_trains(self):
train_responses = self.train_responses
deconv = OrderedDict()
for k, v in train_responses.items():
ind = v[0].bsub_mean()
rec = v[1].bsub_mean()
idec = bessel_filter(exp_deconvolve(ind, self.exp_tau),
self.cutoff)
rdec = bessel_filter(exp_deconvolve(rec, self.exp_tau),
self.cutoff)
deconv[k] = (idec, rdec)
self._deconvolved_trains = deconv
def deconv_filter(trace,
pulse_times,
tau=15e-3,
lowpass=24000.,
lpf=True,
remove_artifacts=False,
bsub=True):
if tau is not None:
dec = exp_deconvolve(trace, tau)
else:
dec = trace
if remove_artifacts:
# after deconvolution, the pulse causes two sharp artifacts; these
# must be removed before LPF
cleaned = remove_crosstalk_artifacts(dec, pulse_times)
else:
cleaned = dec
if bsub:
baseline = np.median(
cleaned.time_slice(cleaned.t0 + 5e-3, cleaned.t0 + 10e-3).data)
b_subbed = cleaned - baseline
else:
b_subbed = cleaned
if lpf:
return filter.bessel_filter(b_subbed, lowpass)
else:
return b_subbed
def deconv_train(trace):
deconv = [[], []]
for i, k in enumerate(trace):
for n in k:
n_dec = bessel_filter(exp_deconvolve(n, 15e-3), 500)
deconv[i].append(n_dec)
return deconv
def deconv_train(trace):
deconv = [[], []]
for i, k in enumerate(trace):
for n in k:
n_dec = bessel_filter(exp_deconvolve(n, 15e-3), 500)
deconv[i].append(n_dec)
return deconv
def train_response_plot(expt_list, name=None, summary_plots=[None, None], color=None):
ind_base_subtract = []
rec_base_subtract = []
train_plots = pg.plot()
train_plots.setLabels(left=('Vm', 'V'))
tau =15e-3
lp = 1000
for expt in expt_list:
for pre, post in expt.connections:
if expt.cells[pre].cre_type == cre_type[0] and expt.cells[post].cre_type == cre_type[1]:
print ('Processing experiment: %s' % (expt.nwb_file))
ind = []
rec = []
analyzer = DynamicsAnalyzer(expt, pre, post)
train_responses = analyzer.train_responses
artifact = analyzer.cross_talk()
if artifact > 0.03e-3:
continue
for i, stim_params in enumerate(train_responses.keys()):
rec_t = int(np.round(stim_params[1] * 1e3, -1))
if stim_params[0] == 50 and rec_t == 250:
pulse_offsets = analyzer.pulse_offsets
if len(train_responses[stim_params][0]) != 0:
ind_group = train_responses[stim_params][0]
rec_group = train_responses[stim_params][1]
for j in range(len(ind_group)):
ind.append(ind_group.responses[j])
rec.append(rec_group.responses[j])
if len(ind) > 5:
ind_avg = TraceList(ind).mean()
rec_avg = TraceList(rec).mean()
rec_avg.t0 = 0.3
base = float_mode(ind_avg.data[:int(10e-3 / ind_avg.dt)])
ind_base_subtract.append(ind_avg.copy(data=ind_avg.data - base))
rec_base_subtract.append(rec_avg.copy(data=rec_avg.data - base))
train_plots.plot(ind_avg.time_values, ind_avg.data - base)
train_plots.plot(rec_avg.time_values, rec_avg.data - base)
app.processEvents()
if len(ind_base_subtract) != 0:
print (name + ' n = %d' % len(ind_base_subtract))
ind_grand_mean = TraceList(ind_base_subtract).mean()
rec_grand_mean = TraceList(rec_base_subtract).mean()
ind_grand_mean_dec = bessel_filter(exp_deconvolve(ind_grand_mean, tau), lp)
train_plots.addLegend()
train_plots.plot(ind_grand_mean.time_values, ind_grand_mean.data, pen={'color': 'g', 'width': 3}, name=name)
train_plots.plot(rec_grand_mean.time_values, rec_grand_mean.data, pen={'color': 'g', 'width': 3}, name=name)
#train_plots.plot(ind_grand_mean_dec.time_values, ind_grand_mean_dec.data, pen={'color': 'g', 'dash': [1,5,3,2]})
train_amps = train_amp([ind_base_subtract, rec_base_subtract], pulse_offsets, '+')
if ind_grand_mean is not None:
train_plots = summary_plot_train(ind_grand_mean, plot=summary_plots[0], color=color,
name=(legend + ' 50 Hz induction'))
train_plots = summary_plot_train(rec_grand_mean, plot=summary_plots[0], color=color)
train_plots2 = summary_plot_train(ind_grand_mean_dec, plot=summary_plots[1], color=color,
name=(legend + ' 50 Hz induction'))
return train_plots, train_plots2, train_amps
else:
print ("No Traces")
return None
def train_response_plot(expt_list, name=None, summary_plots=[None, None], color=None):
grand_train = [[], []]
train_plots = pg.plot()
train_plots.setLabels(left=('Vm', 'V'))
tau =15e-3
lp = 1000
for expt in expt_list:
for pre, post in expt.connections:
if expt.cells[pre].cre_type == cre_type[0] and expt.cells[post].cre_type == cre_type[1]:
print ('Processing experiment: %s' % (expt.nwb_file))
train_responses, artifact = get_response(expt, pre, post, analysis_type='train')
if artifact > 0.03e-3:
continue
train_filter = response_filter(train_responses['responses'], freq_range=[50, 50], train=0, delta_t=250)
pulse_offsets = response_filter(train_responses['pulse_offsets'], freq_range=[50, 50], train=0, delta_t=250)
if len(train_filter[0]) > 5:
ind_avg = TraceList(train_filter[0]).mean()
rec_avg = TraceList(train_filter[1]).mean()
rec_avg.t0 = 0.3
grand_train[0].append(ind_avg)
grand_train[1].append(rec_avg)
train_plots.plot(ind_avg.time_values, ind_avg.data)
train_plots.plot(rec_avg.time_values, rec_avg.data)
app.processEvents()
if len(grand_train[0]) != 0:
print (name + ' n = %d' % len(grand_train[0]))
ind_grand_mean = TraceList(grand_train[0]).mean()
rec_grand_mean = TraceList(grand_train[1]).mean()
ind_grand_mean_dec = bessel_filter(exp_deconvolve(ind_grand_mean, tau), lp)
train_plots.addLegend()
train_plots.plot(ind_grand_mean.time_values, ind_grand_mean.data, pen={'color': 'g', 'width': 3}, name=name)
train_plots.plot(rec_grand_mean.time_values, rec_grand_mean.data, pen={'color': 'g', 'width': 3}, name=name)
train_amps = train_amp([grand_train[0], grand_train[1]], pulse_offsets, '+')
if ind_grand_mean is not None:
train_plots = summary_plot_train(ind_grand_mean, plot=summary_plots[0], color=color,
name=(legend + ' 50 Hz induction'))
train_plots = summary_plot_train(rec_grand_mean, plot=summary_plots[0], color=color)
train_plots2 = summary_plot_train(ind_grand_mean_dec, plot=summary_plots[1], color=color,
name=(legend + ' 50 Hz induction'))
return train_plots, train_plots2, train_amps
else:
print ("No Traces")
return None
def deconv_filter(trace, pulse_times, tau=15e-3, lowpass=1000., lpf=True, remove_artifacts=False, bsub=True):
dec = exp_deconvolve(trace, tau)
if remove_artifacts:
# after deconvolution, the pulse causes two sharp artifacts; these
# must be removed before LPF
dt = dec.dt
r = [-50e-6, 250e-6]
edges = [(int((t+r[0])/dt), int((t+r[1])/dt)) for t in pulse_times]
cleaned = filter.remove_artifacts(dec, edges, window=400e-6)
else:
cleaned = dec
if bsub:
baseline = np.median(cleaned.time_slice(cleaned.t0, cleaned.t0+10e-3).data)
b_subbed = cleaned-baseline
else:
b_subbed = cleaned
if lpf:
return filter.bessel_filter(b_subbed, lowpass)
else:
return b_subbed
def deconv_filter(trace, pulse_times, tau=15e-3, lowpass=24000., lpf=True, remove_artifacts=False, bsub=True):
if tau is not None:
dec = exp_deconvolve(trace, tau)
else:
dec = trace
if remove_artifacts:
# after deconvolution, the pulse causes two sharp artifacts; these
# must be removed before LPF
cleaned = remove_crosstalk_artifacts(dec, pulse_times)
else:
cleaned = dec
if bsub:
baseline = np.median(cleaned.time_slice(cleaned.t0+5e-3, cleaned.t0+10e-3).data)
b_subbed = cleaned - baseline
else:
b_subbed = cleaned
if lpf:
return filter.bessel_filter(b_subbed, lowpass)
else:
return b_subbed
def test_exp_deconv_psp_params():
from neuroanalysis.event_detection import exp_deconvolve, exp_deconv_psp_params
from neuroanalysis.data import TSeries
from neuroanalysis.fitting import Psp
x = np.linspace(0, 0.02, 10000)
amp = 1
rise_time = 4e-3
decay_tau = 10e-3
rise_power = 2
# Make a PSP waveform
psp = Psp()
y = psp.eval(x=x,
xoffset=0,
yoffset=0,
amp=amp,
rise_time=rise_time,
decay_tau=decay_tau,
rise_power=rise_power)
# exponential deconvolution
y_ts = TSeries(y, time_values=x)
y_deconv = exp_deconvolve(y_ts, decay_tau).data
# show that we can get approximately the same result using exp_deconv_psp_params
d_amp, d_rise_time, d_rise_power, d_decay_tau = exp_deconv_psp_params(
amp, rise_time, rise_power, decay_tau)
y2 = psp.eval(x=x,
xoffset=0,
yoffset=0,
amp=d_amp,
rise_time=d_rise_time,
decay_tau=d_decay_tau,
rise_power=d_rise_power)
assert np.allclose(y_deconv, y2[1:], atol=0.02)
def train_response_plot(expt_list,
name=None,
summary_plots=[None, None],
color=None):
grand_train = [[], []]
train_plots = pg.plot()
train_plots.setLabels(left=('Vm', 'V'))
tau = 15e-3
lp = 1000
for expt in expt_list:
for pre, post in expt.connections:
if expt.cells[pre].cre_type == cre_type[0] and expt.cells[
post].cre_type == cre_type[1]:
print('Processing experiment: %s' % (expt.nwb_file))
train_responses, artifact = get_response(expt,
pre,
post,
analysis_type='train')
if artifact > 0.03e-3:
continue
train_filter = response_filter(train_responses['responses'],
freq_range=[50, 50],
train=0,
delta_t=250)
pulse_offsets = response_filter(
train_responses['pulse_offsets'],
freq_range=[50, 50],
train=0,
delta_t=250)
if len(train_filter[0]) > 5:
ind_avg = TraceList(train_filter[0]).mean()
rec_avg = TraceList(train_filter[1]).mean()
rec_avg.t0 = 0.3
grand_train[0].append(ind_avg)
grand_train[1].append(rec_avg)
train_plots.plot(ind_avg.time_values, ind_avg.data)
train_plots.plot(rec_avg.time_values, rec_avg.data)
app.processEvents()
if len(grand_train[0]) != 0:
print(name + ' n = %d' % len(grand_train[0]))
ind_grand_mean = TraceList(grand_train[0]).mean()
rec_grand_mean = TraceList(grand_train[1]).mean()
ind_grand_mean_dec = bessel_filter(exp_deconvolve(ind_grand_mean, tau),
lp)
train_plots.addLegend()
train_plots.plot(ind_grand_mean.time_values,
ind_grand_mean.data,
pen={
'color': 'g',
'width': 3
},
name=name)
train_plots.plot(rec_grand_mean.time_values,
rec_grand_mean.data,
pen={
'color': 'g',
'width': 3
},
name=name)
train_amps = train_amp([grand_train[0], grand_train[1]], pulse_offsets,
'+')
if ind_grand_mean is not None:
train_plots = summary_plot_train(ind_grand_mean,
plot=summary_plots[0],
color=color,
name=(legend +
' 50 Hz induction'))
train_plots = summary_plot_train(rec_grand_mean,
plot=summary_plots[0],
color=color)
train_plots2 = summary_plot_train(ind_grand_mean_dec,
plot=summary_plots[1],
color=color,
name=(legend +
' 50 Hz induction'))
return train_plots, train_plots2, train_amps
else:
print("No Traces")
return None
x_scale = pg.ScaleBar(size=10e-3, suffix='s')
x_scale.setParentItem(grid[row, 0].vb)
x_scale.anchor(scale_anchor, scale_anchor, offset=scale_offset)
if plot_trains is True:
train_responses = get_response(expt, pre_cell, post_cell, type='train')
train_sweep_list = response_filter(train_responses['responses'],
freq_range=[50, 50],
holding_range=holding,
train=0)
n_train_sweeps = len(train_sweep_list)
if n_train_sweeps > sweep_threshold:
dec_sweep_list = []
for sweep in range(n_train_sweeps):
train_sweep = train_sweep_list[sweep]
train_base = bsub(train_sweep)
dec_sweep = bessel_filter(exp_deconvolve(train_sweep, tau), lp)
dec_base = bsub(dec_sweep)
dec_sweep_list.append(dec_base)
if plot_sweeps is True:
trace_plot(train_base, sweep_color, plot=grid[row, 1])
trace_plot(dec_base, sweep_color, plot=grid[row, 2])
ind_avg = trace_avg(train_sweep_list)
ind_avg.t0 = 0
ind_dec = trace_avg(dec_sweep_list)
ind_dec.t0 = 0
trace_plot(ind_avg, avg_color, plot=grid[row, 1])
trace_plot(ind_dec, avg_color, plot=grid[row, 2])
label = pg.LabelItem('n = %d' % n_train_sweeps)
label.setParentItem(grid[row, 1].vb)
label.setPos(50, 0)
grid[row, 1].label = label
#responses = analyzer.all_events
n_responses = len(responses)
# do exponential deconvolution on all responses
deconv = TraceList()
grid1 = PlotGrid()
grid1.set_shape(2, 1)
for i in range(n_responses):
r = responses.responses[i]
grid1[0, 0].plot(r.time_values, r.data)
filt = bessel_filter(r - np.median(r.time_slice(0, 10e-3).data), 300.)
responses.responses[i] = filt
dec = exp_deconvolve(r, 15e-3)
baseline = np.median(dec.data[:100])
r2 = bessel_filter(dec-baseline, 300.)
grid1[1, 0].plot(r2.time_values, r2.data)
deconv.append(r2)
grid1.show()
def measure_amp(trace, baseline=(6e-3, 8e-3), response=(13e-3, 17e-3)):
baseline = trace.time_slice(*baseline).data.mean()
peak = trace.time_slice(*response).data.max()
return peak - baseline
#responses = analyzer.all_events
n_responses = len(responses)
# do exponential deconvolution on all responses
deconv = TraceList()
grid1 = PlotGrid()
grid1.set_shape(2, 1)
for i in range(n_responses):
r = responses.responses[i]
grid1[0, 0].plot(r.time_values, r.data)
filt = bessel_filter(r - np.median(r.time_slice(0, 10e-3).data), 300.)
responses.responses[i] = filt
dec = exp_deconvolve(r, 15e-3)
baseline = np.median(dec.data[:100])
r2 = bessel_filter(dec-baseline, 300.)
grid1[1, 0].plot(r2.time_values, r2.data)
deconv.append(r2)
grid1.show()
def measure_amp(trace, baseline=(6e-3, 8e-3), response=(13e-3, 17e-3)):
baseline = trace.time_slice(*baseline).data.mean()
peak = trace.time_slice(*response).data.max()
return peak - baseline
else:
print("%s not enough sweeps for first pulse" % connection_type)
if plot_trains is True:
train_responses = analyzer.train_responses
for i, stim_params in enumerate(train_responses.keys()):
if stim_params[0] == 50:
if len(train_responses[stim_params][0]) != 0:
ind_group = train_responses[stim_params][0]
for j in range(len(ind_group)):
train_trace = ind_group.responses[j]
ind_base = float_mode(
train_trace.data[:int(10e-3 / train_trace.dt)])
ind['response'].append(
train_trace.copy(data=train_trace.data - ind_base))
dec_trace = bessel_filter(
exp_deconvolve(train_trace, tau), lp)
dec_base = float_mode(
dec_trace.data[:int(10e-3 / dec_trace.dt)])
ind['dec'].append(
dec_trace.copy(data=dec_trace.data - dec_base))
ind['spike'].append(ind_group.spikes[j])
if len(ind['response']) > 5:
n = len(ind['response'])
if plot_sweeps is True:
for sweep in range(n):
train_sweep = ind['response'][sweep]
dec_sweep = ind['dec'][sweep]
grid[row[1], 1].plot(train_sweep.time_values,
train_sweep.data,
pen=sweep_color)
grid[row[1], 2].plot(dec_sweep.time_values,
else:
print ("%s -> %s not enough sweeps for first pulse" % (connection_type[0], connection_type[1]))
if row == len(connection_types) - 1:
x_scale = pg.ScaleBar(size=10e-3, suffix='s')
x_scale.setParentItem(grid[row, 0].vb)
x_scale.anchor(scale_anchor, scale_anchor, offset=scale_offset)
if plot_trains is True:
train_responses, _ = get_response(expt, pre_cell, post_cell, analysis_type='train')
train_sweep_list = response_filter(train_responses['responses'], freq_range=[50, 50], holding_range=holding, train=0)
n_train_sweeps = len(train_sweep_list)
if n_train_sweeps > sweep_threshold:
dec_sweep_list = []
for sweep in range(n_train_sweeps):
train_sweep = train_sweep_list[sweep]
train_base = bsub(train_sweep)
dec_sweep = bessel_filter(exp_deconvolve(train_sweep, tau), lp)
dec_base = bsub(dec_sweep)
dec_sweep_list.append(dec_base)
if plot_sweeps is True:
trace_plot(train_base, sweep_color, plot=grid[row, 1])
trace_plot(dec_base, sweep_color, plot=grid[row, 2])
ind_avg = trace_avg(train_sweep_list)
ind_avg.t0 = 0
ind_dec = trace_avg(dec_sweep_list)
ind_dec.t0 = 0
trace_plot(ind_avg, avg_color, plot=grid[row, 1])
trace_plot(ind_dec, avg_color, plot=grid[row, 2])
label = pg.LabelItem('n = %d' % n_train_sweeps)
label.setParentItem(grid[row, 1].vb)
label.setPos(50, 0)
grid[row, 1].label = label
