def detect_epochs(self):
"""
Detect epochs if they are not provided in the constructor
"""
if "test" not in self.epochs:
self.epochs["test"] = ep.get_test_epoch(self.stimulus,
self.sampling_rate)
if self.epochs["test"]:
test_pulse = True
else:
test_pulse = False
epoch_detectors = {
"sweep":
ep.get_sweep_epoch(self.response),
"recording":
ep.get_recording_epoch(self.response),
"experiment":
ep.get_experiment_epoch(self._i, self.sampling_rate, test_pulse),
"stim":
ep.get_stim_epoch(self.stimulus, test_pulse),
}
for epoch_name, epoch_detector in epoch_detectors.items():
if epoch_name not in self.epochs:
self.epochs[epoch_name] = epoch_detector
def experiment_plot_data(
sweep: Sweep,
backup_start_index: int = 5000,
baseline_start_index: int = 5000,
baseline_end_index: int = 9000
) -> Tuple[np.ndarray, np.ndarray, float]:
""" Extract the data required for plotting a single sweep's experiment
epoch.
Parameters
----------
sweep : contains data to be extracted
backup_start_index : if the start index of this sweep's experiment epoch
cannot be programatically assessed, fall back to this.
baseline_start_index : Start accumulating baseline samples from this index
baseline_end_index : Stop accumulating baseline samples at this index
Returns
-------
time : timestamps (s) of voltage samples for this sweep
voltage : in (mV). The voltage trace for this sweep's experiment epoch.
baseline_mean : the average voltage (mV) during the baseline epoch for this
sweep
"""
experiment_start_index, experiment_end_index = \
get_experiment_epoch(sweep.i, sweep.sampling_rate) \
or (backup_start_index, len(sweep.i))
if experiment_start_index <= 0:
experiment_start_index = backup_start_index
time = sweep.t[experiment_start_index:experiment_end_index]
voltage = sweep.v[experiment_start_index:experiment_end_index]
voltage[np.isnan(voltage)] = 0.0
baseline_mean = np.nanmean(
voltage[baseline_start_index:baseline_end_index])
return time, voltage, baseline_mean
def detect_epochs(self):
"""
Detect epochs if they are not provided in the constructor
"""
if "test" not in self.epochs:
self.epochs["test"] = ep.get_test_epoch(self._stimulus, self.sampling_rate)
if self.epochs["test"]:
test_pulse = True
else:
test_pulse = False
if "sweep" not in self.epochs:
self.epochs["sweep"] = ep.get_sweep_epoch(self._i)
if "recording" not in self.epochs:
self.epochs["recording"] = ep.get_recording_epoch(self._response)
# get valid recording by selecting epoch and using i/v prop before detecting stim
self.select_epoch("recording")
stim = self.i if self.clamp_mode == "CurrentClamp" else self.v
if "stim" not in self.epochs:
self.epochs["stim"] = ep.get_stim_epoch(stim, test_pulse)
if "experiment" not in self.epochs:
self.epochs["experiment"] = ep.get_experiment_epoch(stim, self.sampling_rate, test_pulse)
def test_get_experiment_epoch(i, sampling_rate, expt_epoch):
assert expt_epoch == ep.get_experiment_epoch(i, sampling_rate)
def plot_single_ap_values(data_set, sweep_numbers, lims_features,
sweep_features, cell_features, type_name):
figs = [plt.figure() for f in range(3 + len(sweep_numbers))]
v, i, t, r, dt = load_sweep(data_set, sweep_numbers[0])
if type_name == "short_square" or type_name == "long_square":
stim_start, stim_dur, stim_amp, start_idx, end_idx = st.get_stim_characteristics(
i, t)
elif type_name == "ramp":
stim_start, _, _, start_idx, _ = st.get_stim_characteristics(i, t)
gen_features = [
"threshold", "peak", "trough", "fast_trough", "slow_trough"
]
voltage_features = [
"threshold_v", "peak_v", "trough_v", "fast_trough_v", "slow_trough_v"
]
time_features = [
"threshold_t", "peak_t", "trough_t", "fast_trough_t", "slow_trough_t"
]
for sn in sweep_numbers:
spikes = get_spikes(sweep_features, sn)
if (len(spikes) < 1):
logging.warning("no spikes in sweep %d" % sn)
continue
if type_name != "long_square":
voltages = [spikes[0][f] for f in voltage_features]
times = [spikes[0][f] for f in time_features]
else:
rheo_sn = cell_features["long_squares"]["rheobase_sweep"][
"sweep_number"]
rheo_spike = get_spikes(sweep_features, rheo_sn)[0]
voltages = [rheo_spike[f] for f in voltage_features]
times = [rheo_spike[f] for f in time_features]
plt.figure(figs[0].number)
plt.scatter(range(len(voltages)), voltages, color='gray')
plt.tight_layout()
plt.figure(figs[1].number)
plt.scatter(range(len(times)), times, color='gray')
plt.tight_layout()
plt.figure(figs[2].number)
plt.scatter([0], [spikes[0]['upstroke'] / (-spikes[0]['downstroke'])],
color='gray')
plt.tight_layout()
plt.figure(figs[0].number)
yvals = [
float(lims_features[k + "_v_" + type_name]) for k in gen_features
if lims_features[k + "_v_" + type_name] is not None
]
xvals = range(len(yvals))
plt.scatter(xvals, yvals, color='blue', marker='_', s=40, zorder=100)
plt.xticks(xvals, ['thr', 'pk', 'tr', 'ftr', 'str'])
plt.title(type_name + ": voltages")
plt.figure(figs[1].number)
yvals = [
float(lims_features[k + "_t_" + type_name]) for k in gen_features
if lims_features[k + "_t_" + type_name] is not None
]
xvals = range(len(yvals))
plt.scatter(xvals, yvals, color='blue', marker='_', s=40, zorder=100)
plt.xticks(xvals, ['thr', 'pk', 'tr', 'ftr', 'str'])
plt.title(type_name + ": times")
plt.figure(figs[2].number)
if lims_features["upstroke_downstroke_ratio_" + type_name] is not None:
plt.scatter(
[0],
[float(lims_features["upstroke_downstroke_ratio_" + type_name])],
color='blue',
marker='_',
s=40,
zorder=100)
plt.xticks([])
plt.title(type_name + ": up/down")
for index, sn in enumerate(sweep_numbers):
plt.figure(figs[3 + index].number)
v, i, t, r, dt = load_sweep(data_set, sn)
hz = 1. / dt
expt_start_idx, _ = ep.get_experiment_epoch(i, hz)
t = t - expt_start_idx * dt
stim_start_shifted = stim_start - expt_start_idx * dt
plt.plot(t, v, color='black')
plt.title(str(sn))
spikes = get_spikes(sweep_features, sn)
nspikes = len(spikes)
delta_v = 5.0
if nspikes:
if type_name != "long_square" and nspikes:
voltages = [spikes[0][f] for f in voltage_features]
times = [spikes[0][f] for f in time_features]
else:
rheo_sn = cell_features["long_squares"]["rheobase_sweep"][
"sweep_number"]
rheo_spike = get_spikes(sweep_features, rheo_sn)[0]
voltages = [rheo_spike[f] for f in voltage_features]
times = [rheo_spike[f] for f in time_features]
plt.scatter(times, voltages, color='red', zorder=20)
plt.plot([
spikes[0]['upstroke_t'] - 1e-3 *
(delta_v / spikes[0]['upstroke']), spikes[0]['upstroke_t'] +
1e-3 * (delta_v / spikes[0]['upstroke'])
], [
spikes[0]['upstroke_v'] - delta_v,
spikes[0]['upstroke_v'] + delta_v
],
color='red')
if 'downstroke_t' in spikes[0]:
plt.plot([
spikes[0]['downstroke_t'] - 1e-3 *
(delta_v / spikes[0]['downstroke']),
spikes[0]['downstroke_t'] + 1e-3 *
(delta_v / spikes[0]['downstroke'])
], [
spikes[0]['downstroke_v'] - delta_v,
spikes[0]['downstroke_v'] + delta_v
],
color='red')
if type_name == "ramp":
if nspikes:
plt.xlim(spikes[0]["threshold_t"] - 0.002,
spikes[0]["fast_trough_t"] + 0.01)
elif type_name == "short_square":
plt.xlim(stim_start_shifted - 0.002,
stim_start_shifted + stim_dur + 0.01)
elif type_name == "long_square":
plt.xlim(times[0] - 0.002, times[-2] + 0.002)
plt.tight_layout()
return figs
def load_sweep(data_set, sweep_number):
sweep = data_set.sweep(sweep_number)
dt = sweep.t[1] - sweep.t[0]
r = ep.get_experiment_epoch(sweep.i, sweep.sampling_rate)
return (sweep.v, sweep.i, sweep.t, r, dt)