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
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