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 process_response(self, sr, plt=None):
stim = sr.stim_tseries
pre = sr.pre_tseries
post = sr.post_tseries.copy()
if self.params['correction', 'stimulus']:
pulse_start = sr.stim_pulse.onset_time
pulse_stop = pulse_start + sr.stim_pulse.duration
stim_correction = post.copy(data=np.zeros(len(post)))
stim_correction.t0 = stim_correction.t0 + stim_correction.dt * self.params['correction', 'stimulus', 'shift']
stim_correction.time_slice(pulse_start, pulse_stop).data[:] = self.params['correction', 'stimulus', 'scale'] * sr.stim_pulse.amplitude
stim_correction = filter.bessel_filter(stim_correction, self.params['correction', 'stimulus', 'lowpass'], bidir=False)
post = post - stim_correction.data
if self.params['correction', 'charging']:
tau = self.params['correction', 'charging', 'capacitance'] * self.params['correction', 'charging', 'resistance']
scale = self.params['correction', 'charging', 'scale']
pulse_start = sr.stim_pulse.onset_time
pulse_stop = pulse_start + sr.stim_pulse.duration
charging_correction = post.copy(data=np.zeros(len(post)))
during_pulse = charging_correction.time_slice(pulse_start, pulse_stop)
t = during_pulse.time_values - during_pulse.t0
during_pulse.data[:] = scale * sr.stim_pulse.amplitude * (1.0 - np.exp(-t / tau))
after_pulse = charging_correction.time_slice(pulse_stop, None)
t = after_pulse.time_values - after_pulse.t0
after_pulse.data[:] = during_pulse.data[-1] * np.exp(-t / tau)
charging_correction = filter.bessel_filter(charging_correction, self.params['correction', 'charging', 'lowpass'], bidir=False)
post = post - charging_correction.data
if self.params['correction', 'spike']:
spike = pre.copy(data=pre.data * self.params['correction', 'spike', 'scale'])
spike_correction = filter.bessel_filter(spike, self.params['correction', 'spike', 'lowpass'], bidir=False)
start = max(spike.t0, post.t0)
stop = min(spike.t_end, post.t_end)
post = post.time_slice(start, stop) - spike_correction.time_slice(start, stop).data
if self.params['correction', 'spike dv/dt']:
spike_diff = np.diff(pre.data) * self.params['correction', 'spike dv/dt', 'scale']
spike = pre.copy(data=spike_diff)
spike_correction = filter.bessel_filter(spike, self.params['correction', 'spike dv/dt', 'lowpass'], bidir=False)
start = max(spike.t0, post.t0)
stop = min(spike.t_end, post.t_end)
post = post.time_slice(start, stop) - spike_correction.time_slice(start, stop).data
return data.PulseResponse(stim_pulse=sr.stim_pulse, post_tseries=post)
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 display_filter(self, ts, dvdt, lowpass):
if dvdt is True:
ts = ts.copy(data=np.diff(ts.data))
if lowpass is not None:
try:
ts = filter.bessel_filter(ts, lowpass, bidir=True)
except ValueError:
pass
return ts
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=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 plot_response_averages(expt, show_baseline=False, **kwds):
analyzer = MultiPatchExperimentAnalyzer.get(expt)
devs = analyzer.list_devs()
# First get average evoked responses for all pre/post pairs
responses, rows, cols = analyzer.get_evoked_response_matrix(**kwds)
# resize plot grid accordingly
plots = PlotGrid()
plots.set_shape(len(rows), len(cols))
plots.show()
ranges = [([], []), ([], [])]
points = []
# Plot each matrix element with PSP fit
for i, dev1 in enumerate(rows):
for j, dev2 in enumerate(cols):
# select plot and hide axes
plt = plots[i, j]
if i < len(devs) - 1:
plt.getAxis('bottom').setVisible(False)
if j > 0:
plt.getAxis('left').setVisible(False)
if dev1 == dev2:
plt.getAxis('bottom').setVisible(False)
plt.getAxis('left').setVisible(False)
continue
# adjust axes / labels
plt.setXLink(plots[0, 0])
plt.setYLink(plots[0, 0])
plt.addLine(x=10e-3, pen=0.3)
plt.addLine(y=0, pen=0.3)
plt.setLabels(bottom=(str(dev2), 's'))
if kwds.get('clamp_mode', 'ic') == 'ic':
plt.setLabels(left=('%s' % dev1, 'V'))
else:
plt.setLabels(left=('%s' % dev1, 'A'))
# print "==========", dev1, dev2
avg_response = responses[(dev1, dev2)].bsub_mean()
if avg_response is not None:
avg_response.t0 = 0
t = avg_response.time_values
y = bessel_filter(Trace(avg_response.data, dt=avg_response.dt),
2e3).data
plt.plot(t, y, antialias=True)
# fit!
#fit = responses[(dev1, dev2)].fit_psp(yoffset=0, mask_stim_artifact=(abs(dev1-dev2) < 3))
#lsnr = np.log(fit.snr)
#lerr = np.log(fit.nrmse())
#color = (
#np.clip(255 * (-lerr/3.), 0, 255),
#np.clip(50 * lsnr, 0, 255),
#np.clip(255 * (1+lerr/3.), 0, 255)
#)
#plt.plot(t, fit.best_fit, pen=color)
## plt.plot(t, fit.init_fit, pen='y')
#points.append({'x': lerr, 'y': lsnr, 'brush': color})
#if show_baseline:
## plot baseline for reference
#bl = avg_response.meta['baseline'] - avg_response.meta['baseline_med']
#plt.plot(np.arange(len(bl)) * avg_response.dt, bl, pen=(0, 100, 0), antialias=True)
# keep track of data range across all plots
ranges[0][0].append(y.min())
ranges[0][1].append(y.max())
ranges[1][0].append(t[0])
ranges[1][1].append(t[-1])
plots[0, 0].setYRange(min(ranges[0][0]), max(ranges[0][1]))
plots[0, 0].setXRange(min(ranges[1][0]), max(ranges[1][1]))
# scatter plot of SNR vs NRMSE
plt = pg.plot()
plt.setLabels(left='ln(SNR)', bottom='ln(NRMSE)')
plt.plot([p['x'] for p in points], [p['y'] for p in points],
pen=None,
symbol='o',
symbolBrush=[pg.mkBrush(p['brush']) for p in points])
# show threshold line
line = pg.InfiniteLine(pos=[0, 6], angle=180 / np.pi * np.arctan(1))
plt.addItem(line, ignoreBounds=True)
return plots
def process_response(self, sr, plt=None):
stim = sr.stim_tseries
pre = sr.pre_tseries
post = sr.post_tseries.copy()
if self.params['correction', 'stimulus']:
pulse_start = sr.stim_pulse.onset_time
pulse_stop = pulse_start + sr.stim_pulse.duration
stim_correction = post.copy(data=np.zeros(len(post)))
stim_correction.t0 = stim_correction.t0 + stim_correction.dt * self.params[
'correction', 'stimulus', 'shift']
stim_correction.time_slice(
pulse_start, pulse_stop
).data[:] = self.params['correction', 'stimulus',
'scale'] * sr.stim_pulse.amplitude
stim_correction = filter.bessel_filter(stim_correction,
self.params['correction',
'stimulus',
'lowpass'],
bidir=False)
post = post - stim_correction.data
if self.params['correction', 'charging']:
tau = self.params['correction', 'charging',
'capacitance'] * self.params['correction',
'charging',
'resistance']
scale = self.params['correction', 'charging', 'scale']
pulse_start = sr.stim_pulse.onset_time
pulse_stop = pulse_start + sr.stim_pulse.duration
charging_correction = post.copy(data=np.zeros(len(post)))
during_pulse = charging_correction.time_slice(
pulse_start, pulse_stop)
t = during_pulse.time_values - during_pulse.t0
during_pulse.data[:] = scale * sr.stim_pulse.amplitude * (
1.0 - np.exp(-t / tau))
after_pulse = charging_correction.time_slice(pulse_stop, None)
t = after_pulse.time_values - after_pulse.t0
after_pulse.data[:] = during_pulse.data[-1] * np.exp(-t / tau)
charging_correction = filter.bessel_filter(
charging_correction,
self.params['correction', 'charging', 'lowpass'],
bidir=False)
post = post - charging_correction.data
if self.params['correction', 'spike']:
spike = pre.copy(data=pre.data *
self.params['correction', 'spike', 'scale'])
spike_correction = filter.bessel_filter(spike,
self.params['correction',
'spike',
'lowpass'],
bidir=False)
start = max(spike.t0, post.t0)
stop = min(spike.t_end, post.t_end)
post = post.time_slice(start, stop) - spike_correction.time_slice(
start, stop).data
if self.params['correction', 'spike dv/dt']:
spike_diff = np.diff(
pre.data) * self.params['correction', 'spike dv/dt', 'scale']
spike = pre.copy(data=spike_diff)
spike_correction = filter.bessel_filter(spike,
self.params['correction',
'spike dv/dt',
'lowpass'],
bidir=False)
start = max(spike.t0, post.t0)
stop = min(spike.t_end, post.t_end)
post = post.time_slice(start, stop) - spike_correction.time_slice(
start, stop).data
return data.PulseResponse(stim_pulse=sr.stim_pulse, post_tseries=post)
def plot_response_averages(expt, show_baseline=False, **kwds):
analyzer = MultiPatchExperimentAnalyzer.get(expt)
devs = analyzer.list_devs()
# First get average evoked responses for all pre/post pairs
responses, rows, cols = analyzer.get_evoked_response_matrix(**kwds)
# resize plot grid accordingly
plots = PlotGrid()
plots.set_shape(len(rows), len(cols))
plots.show()
ranges = [([], []), ([], [])]
points = []
# Plot each matrix element with PSP fit
for i, dev1 in enumerate(rows):
for j, dev2 in enumerate(cols):
# select plot and hide axes
plt = plots[i, j]
if i < len(devs) - 1:
plt.getAxis('bottom').setVisible(False)
if j > 0:
plt.getAxis('left').setVisible(False)
if dev1 == dev2:
plt.getAxis('bottom').setVisible(False)
plt.getAxis('left').setVisible(False)
continue
# adjust axes / labels
plt.setXLink(plots[0, 0])
plt.setYLink(plots[0, 0])
plt.addLine(x=10e-3, pen=0.3)
plt.addLine(y=0, pen=0.3)
plt.setLabels(bottom=(str(dev2), 's'))
if kwds.get('clamp_mode', 'ic') == 'ic':
plt.setLabels(left=('%s' % dev1, 'V'))
else:
plt.setLabels(left=('%s' % dev1, 'A'))
# print "==========", dev1, dev2
avg_response = responses[(dev1, dev2)].bsub_mean()
if avg_response is not None:
avg_response.t0 = 0
t = avg_response.time_values
y = bessel_filter(Trace(avg_response.data, dt=avg_response.dt), 2e3).data
plt.plot(t, y, antialias=True)
# fit!
#fit = responses[(dev1, dev2)].fit_psp(yoffset=0, mask_stim_artifact=(abs(dev1-dev2) < 3))
#lsnr = np.log(fit.snr)
#lerr = np.log(fit.nrmse())
#color = (
#np.clip(255 * (-lerr/3.), 0, 255),
#np.clip(50 * lsnr, 0, 255),
#np.clip(255 * (1+lerr/3.), 0, 255)
#)
#plt.plot(t, fit.best_fit, pen=color)
## plt.plot(t, fit.init_fit, pen='y')
#points.append({'x': lerr, 'y': lsnr, 'brush': color})
#if show_baseline:
## plot baseline for reference
#bl = avg_response.meta['baseline'] - avg_response.meta['baseline_med']
#plt.plot(np.arange(len(bl)) * avg_response.dt, bl, pen=(0, 100, 0), antialias=True)
# keep track of data range across all plots
ranges[0][0].append(y.min())
ranges[0][1].append(y.max())
ranges[1][0].append(t[0])
ranges[1][1].append(t[-1])
plots[0,0].setYRange(min(ranges[0][0]), max(ranges[0][1]))
plots[0,0].setXRange(min(ranges[1][0]), max(ranges[1][1]))
# scatter plot of SNR vs NRMSE
plt = pg.plot()
plt.setLabels(left='ln(SNR)', bottom='ln(NRMSE)')
plt.plot([p['x'] for p in points], [p['y'] for p in points], pen=None, symbol='o', symbolBrush=[pg.mkBrush(p['brush']) for p in points])
# show threshold line
line = pg.InfiniteLine(pos=[0, 6], angle=180/np.pi * np.arctan(1))
plt.addItem(line, ignoreBounds=True)
return plots
responses = analyzer.amp_group
# collect all events
#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()
def plot_prd_ids(self, ids, source, pen=None, trace_list=None, avg=False):
"""Plot raw or decolvolved PulseResponse data, given IDs of records in
a PulseResponseStrength table.
"""
with pg.BusyCursor():
if source == 'fg':
q = response_query(self.session)
q = q.join(PulseResponseStrength)
q = q.filter(PulseResponseStrength.id.in_(ids))
traces = self.selected_fg_traces
plot = self.fg_trace_plot
else:
q = baseline_query(self.session)
q = q.join(BaselineResponseStrength)
q = q.filter(BaselineResponseStrength.id.in_(ids))
traces = self.selected_bg_traces
plot = self.bg_trace_plot
recs = q.all()
if len(recs) == 0:
return
for i in trace_list[:]:
plot.removeItem(i)
trace_list.remove(i)
if pen is None:
alpha = np.clip(1000 / len(recs), 30, 255)
pen = (255, 255, 255, alpha)
traces = []
spike_times = []
spike_values = []
for rec in recs:
s = {'fg': 'pulse_response', 'bg': 'baseline'}[source]
result = analyze_response_strength(rec, source=s, lpf=self.lpf_check.isChecked(),
remove_artifacts=self.ar_check.isChecked(), bsub=self.bsub_check.isChecked())
if self.deconv_check.isChecked():
trace = result['dec_trace']
else:
trace = result['raw_trace']
if self.bsub_check.isChecked():
trace = trace - np.median(trace.time_slice(0, 9e-3).data)
if self.lpf_check.isChecked():
trace = filter.bessel_filter(trace, 500)
spike_values.append(trace.value_at([result['spike_time']])[0])
if self.align_check.isChecked():
trace.t0 = -result['spike_time']
spike_times.append(0)
else:
spike_times.append(result['spike_time'])
traces.append(trace)
trace_list.append(plot.plot(trace.time_values, trace.data, pen=pen))
if avg:
mean = TraceList(traces).mean()
trace_list.append(plot.plot(mean.time_values, mean.data, pen='g'))
trace_list[-1].setZValue(10)
spike_scatter = pg.ScatterPlotItem(spike_times, spike_values, size=4, pen=None, brush=(200, 200, 0))
spike_scatter.setZValue(-100)
plot.addItem(spike_scatter)
trace_list.append(spike_scatter)
def train_response_plot(expt_list,
name=None,
summary_plots=[None, None],
color=None):
ind_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 = []
analyzer = DynamicsAnalyzer(expt, pre, post)
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)):
ind.append(ind_group.responses[j])
if len(ind) > 5:
ind_avg = TraceList(ind).mean()
base = float_mode(ind_avg.data[:int(10e-3 / ind_avg.dt)])
ind_base_subtract.append(
ind_avg.copy(data=ind_avg.data - base))
train_plots.plot(ind_avg.time_values, ind_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()
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(ind_grand_mean_dec.time_values,
ind_grand_mean_dec.data,
pen={
'color': 'g',
'dash': [1, 5, 3, 2]
})
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_plots2 = summary_plot_train(ind_grand_mean_dec,
plot=summary_plots[1],
color=color,
name=(legend +
' 50 Hz induction'))
return train_plots, train_plots2
else:
print("No Traces")
return None
def plot_element_data(self, pre_class, post_class, element, field_name, color='g', trace_plt=None):
summary = element.agg(self.summary_stat)
val = summary[field_name]['metric_summary']
line = pg.InfiniteLine(val, pen={'color': color, 'width': 2}, movable=False)
scatter = None
tracesA = []
tracesB = []
connections = element[element['Connected'] == True].index.tolist()
for pair in connections:
# rsf = pair.resting_state_fit
synapse = pair.synapse
if synapse is None:
continue
arfs = pair.avg_response_fits
latency = pair.synapse.latency
syn_typ = pair.synapse.synapse_type
self.pair_items[pair.id] = []
trace_itemA = None
trace_itemB = None
# if rsf is not None:
# traceA = TSeries(data=rsf.ic_avg_data, sample_rate=db.default_sample_rate)
# start_time = rsf.ic_avg_data_start_time
# if latency is not None and start_time is not None:
# xoffset = start_time - latency
# baseline_window = [abs(xoffset)-1e-3, abs(xoffset)]
# traceA = format_trace(traceA, baseline_window, x_offset=xoffset, align='psp')
# trace_itemA = trace_plt[0].plot(traceA.time_values, traceA.data)
# trace_itemA.pair = pair
# trace_itemA.curve.setClickable(True)
# trace_itemA.sigClicked.connect(self.trace_plot_clicked)
# self.pair_items[pair.id].append(trace_itemA)
# tracesA.append(traceA)
if arfs is not None:
for arf in arfs:
if arf.holding in syn_typ_holding[syn_typ] and arf.manual_qc_pass is True and latency is not None:
if arf.clamp_mode == 'vc' and trace_itemA is None:
traceA = TSeries(data=arf.avg_data, sample_rate=db.default_sample_rate)
traceA = bessel_filter(traceA, 5000, btype='low', bidir=True)
start_time = arf.avg_data_start_time
if start_time is not None:
xoffset = start_time - latency
baseline_window = [abs(xoffset)-1e-3, abs(xoffset)]
traceA = format_trace(traceA, baseline_window, x_offset=xoffset, align='psp')
trace_itemA = trace_plt[0].plot(traceA.time_values, traceA.data)
trace_itemA.pair = pair
trace_itemA.curve.setClickable(True)
trace_itemA.sigClicked.connect(self.trace_plot_clicked)
self.pair_items[pair.id].append(trace_itemA)
tracesA.append(traceA)
if arf.clamp_mode == 'ic' and trace_itemB is None:
traceB = TSeries(data=arf.avg_data, sample_rate=db.default_sample_rate)
start_time = arf.avg_data_start_time
if latency is not None and start_time is not None:
xoffset = start_time - latency
baseline_window = [abs(xoffset)-1e-3, abs(xoffset)]
traceB = format_trace(traceB, baseline_window, x_offset=xoffset, align='psp')
trace_itemB = trace_plt[1].plot(traceB.time_values, traceB.data)
trace_itemB.pair = pair
trace_itemB.curve.setClickable(True)
trace_itemB.sigClicked.connect(self.trace_plot_clicked)
tracesB.append(traceB)
self.pair_items[pair.id] = [trace_itemA, trace_itemB]
if len(tracesA) > 0:
grand_trace = TSeriesList(tracesA).mean()
name = ('%s->%s' % (pre_class, post_class))
# trace_plt[0].addLegend()
trace_plt[0].plot(grand_trace.time_values, grand_trace.data, pen={'color': color, 'width': 3}, name=name)
trace_plt[0].setXRange(-5e-3, 20e-3)
trace_plt[0].setLabels(left=('', 'A'), bottom=('Response Onset', 's'))
trace_plt[0].setTitle('Voltage Clamp')
if len(tracesB) > 0:
grand_trace = TSeriesList(tracesB).mean()
trace_plt[1].plot(grand_trace.time_values, grand_trace.data, pen={'color': color, 'width': 3})
trace_plt[1].setLabels(right=('', 'V'), bottom=('Response Onset', 's'))
trace_plt[1].setTitle('Current Clamp')
return line, scatter
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
def plot_element_data(self, pre_class, post_class, element, field_name, color='g', trace_plt=None):
val = element[field_name].mean()
line = pg.InfiniteLine(val, pen={'color': color, 'width': 2}, movable=False)
scatter = None
baseline_window = int(db.default_sample_rate * 5e-3)
values = []
tracesA = []
tracesB = []
point_data = []
for pair, value in element[field_name].iteritems():
latency = self.results.loc[pair]['Latency']
trace_itemA = None
trace_itemB = None
if pair.has_synapse is not True:
continue
if np.isnan(value):
continue
syn_typ = pair.synapse.synapse_type
rsf = pair.resting_state_fit
if rsf is not None:
nrmse = rsf.vc_nrmse if field_name.startswith('PSC') else rsf.ic_nrmse
# if nrmse is None or nrmse > 0.8:
# continue
data = rsf.vc_avg_data if field_name.startswith('PSC') else rsf.ic_avg_data
traceA = TSeries(data=data, sample_rate=db.default_sample_rate)
if field_name.startswith('PSC'):
traceA = bessel_filter(traceA, 5000, btype='low', bidir=True)
bessel_filter(traceA, 5000, btype='low', bidir=True)
start_time = rsf.vc_avg_data_start_time if field_name.startswith('PSC') else rsf.ic_avg_data_start_time
if latency is not None and start_time is not None:
if field_name == 'Latency':
xoffset = start_time + latency
else:
xoffset = start_time - latency
baseline_window = [abs(xoffset)-1e-3, abs(xoffset)]
traceA = format_trace(traceA, baseline_window, x_offset=xoffset, align='psp')
trace_itemA = trace_plt[1].plot(traceA.time_values, traceA.data)
trace_itemA.pair = pair
trace_itemA.curve.setClickable(True)
trace_itemA.sigClicked.connect(self.trace_plot_clicked)
tracesA.append(traceA)
if field_name == 'Latency' and rsf.vc_nrmse is not None: #and rsf.vc_nrmse < 0.8:
traceB = TSeries(data=rsf.vc_avg_data, sample_rate=db.default_sample_rate)
traceB = bessel_filter(traceB, 5000, btype='low', bidir=True)
start_time = rsf.vc_avg_data_start_time
if latency is not None and start_time is not None:
xoffset = start_time + latency
baseline_window = [abs(xoffset)-1e-3, abs(xoffset)]
traceB = format_trace(traceB, baseline_window, x_offset=xoffset, align='psp')
trace_itemB = trace_plt[0].plot(traceB.time_values, traceB.data)
trace_itemB.pair = pair
trace_itemB.curve.setClickable(True)
trace_itemB.sigClicked.connect(self.trace_plot_clicked)
tracesB.append(traceB)
self.pair_items[pair.id] = [trace_itemA, trace_itemB]
if trace_itemA is not None:
values.append(value)
point_data.append(pair)
y_values = pg.pseudoScatter(np.asarray(values, dtype=float), spacing=1)
scatter = pg.ScatterPlotItem(symbol='o', brush=(color + (150,)), pen='w', size=12)
scatter.setData(values, y_values + 10., data=point_data)
for point in scatter.points():
pair_id = point.data().id
self.pair_items[pair_id].extend([point, color])
scatter.sigClicked.connect(self.scatter_plot_clicked)
if len(tracesA) > 0:
if field_name == 'Latency':
spike_line = pg.InfiniteLine(0, pen={'color': 'w', 'width': 1, 'style': pg.QtCore.Qt.DotLine}, movable=False)
trace_plt[0].addItem(spike_line)
x_label = 'Time from presynaptic spike'
else:
x_label = 'Response Onset'
grand_trace = TSeriesList(tracesA).mean()
name = ('%s->%s, n=%d' % (pre_class, post_class, len(tracesA)))
trace_plt[1].plot(grand_trace.time_values, grand_trace.data, pen={'color': color, 'width': 3}, name=name)
units = 'A' if field_name.startswith('PSC') else 'V'
title = 'Voltage Clamp' if field_name.startswith('PSC') else 'Current Clamp'
trace_plt[1].setXRange(-5e-3, 20e-3)
trace_plt[1].setLabels(left=('', units), bottom=(x_label, 's'))
trace_plt[1].setTitle(title)
if len(tracesB) > 0:
trace_plt[1].setLabels(right=('', units))
trace_plt[1].hideAxis('left')
spike_line = pg.InfiniteLine(0, pen={'color': 'w', 'width': 1, 'style': pg.QtCore.Qt.DotLine}, movable=False)
trace_plt[0].addItem(spike_line)
grand_trace = TSeriesList(tracesB).mean()
trace_plt[0].plot(grand_trace.time_values, grand_trace.data, pen={'color': color, 'width': 3})
trace_plt[0].setXRange(-5e-3, 20e-3)
trace_plt[0].setLabels(left=('', 'A'), bottom=('Time from presynaptic spike', 's'))
trace_plt[0].setTitle('Voltage Clamp')
return line, scatter
responses = analyzer.amp_group
# collect all events
#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()
maxYpulse.append((row[1], grid[row[1], 0].getAxis('left').range[1]))
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,
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
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
