def process_data(self):
data = self.data
run_param = self.run_param
process_param = self.process_param
LFP_amp = LFPy_util.data_extraction.maxabs(data['LFP'],axis=1)
LFP_amp = LFP_amp.reshape([data['n_elec_x'],data['n_elec_y']])
grid_x, grid_y = np.meshgrid(data['lin_x'],data['lin_y'])
signal = data['soma_v']
spike, spikes_t_vec, I = de.extract_spikes(
data['t_vec'],
signal,
pre_dur=process_param['pre_dur'],
post_dur=process_param['post_dur'],
threshold=process_param['threshold'],
amp_option=process_param['amp_option'],
)
# Gather all spikes from the same indices as where the spike appears
# in the first electrode.
spike_index = process_param['spike_to_measure']
if spike.shape[0] < spike_index:
raise ValueError("Found fewer spikes than process_param['spike_to_measure']")
spikes = data['LFP'][:, I[spike_index, 0]:I[spike_index, 1]]
amps_I = de.find_amplitude_type_I(spikes, amp_option=process_param['amp_option'])
amps_II = de.find_amplitude_type_II(spikes)
widths_I, widths_I_trace = de.find_wave_width_type_I(spikes,
dt=data['dt'])
widths_II, widths_II_trace = de.find_wave_width_type_II(
spikes,
dt=data['dt'],
amp_option=process_param['amp_option'])
widths_I = widths_I.reshape([data['n_elec_x'],data['n_elec_y']])
widths_II = widths_II.reshape([data['n_elec_x'],data['n_elec_y']])
data['LFP_amp'] = LFP_amp*1000
data['grid_x'] = grid_x
data['grid_y'] = grid_y
data['amps_I'] = amps_I * 1000
data['amps_II'] = amps_II * 1000
data['widths_I'] = widths_I
data['widths_I_trace'] = widths_I_trace * 1000
data['widths_II'] = widths_II
data['widths_II_trace'] = widths_II_trace * 1000
data['spikes'] = spikes * 1000
data['spikes_t_vec'] = spikes_t_vec
def process_data(self):
data = self.data
run_param = self.run_param
process_param = self.process_param
# Get the signal from the soma potential.
signal = data['soma_v']
spike, spikes_t_vec, I = de.extract_spikes(
data['t_vec'],
signal,
pre_dur=process_param['pre_dur'],
post_dur=process_param['post_dur'],
threshold=process_param['threshold'],
amp_option=process_param['amp_option'],
)
# Gather all spikes from the same indices as where the spike appears
# in the first electrode.
spike_index = process_param['spike_to_measure']
if spike.shape[0] < spike_index:
raise ValueError("Found fewer spikes than process_param['spike_to_measure']")
spikes = data['LFP'][:, I[spike_index, 0]:I[spike_index, 1]]
amps_I = de.find_amplitude_type_I(spikes, amp_option=process_param['amp_option'])
amps_II = de.find_amplitude_type_II(spikes)
widths_I, widths_I_trace = de.find_wave_width_type_I(spikes,
dt=data['dt'])
widths_II, widths_II_trace = de.find_wave_width_type_II(
spikes,
threshold=process_param['width_II_thresh'],
dt=data['dt'],
amp_option=process_param['amp_option'])
widths_III, widths_III_trace = de.find_wave_width_type_III(
spikes,
threshold=process_param['width_III_thresh'],
dt=data['dt'],
amp_option=process_param['amp_option'])
p = run_param['n_phi']
n = run_param['n']
amps_I = np.reshape(amps_I, (p, n))
amps_II = np.reshape(amps_II, (p, n))
widths_I = np.reshape(widths_I, (p, n))
widths_II = np.reshape(widths_II, (p, n))
widths_III = np.reshape(widths_III, (p, n))
# Becomes vector with length n.
amps_I_mean = np.mean(amps_I, 0)
amps_I_std = np.std(amps_I, 0)
amps_II_mean = np.mean(amps_II, 0)
amps_II_std = np.std(amps_II, 0)
widths_I_mean = np.mean(widths_I, 0)
widths_I_std = np.std(widths_I, 0)
widths_II_mean = np.mean(widths_II, 0)
widths_II_std = np.std(widths_II, 0)
widths_III_mean = np.mean(widths_III, 0)
widths_III_std = np.std(widths_III, 0)
data['amps_I_mean'] = amps_I_mean * 1000
data['amps_I_std'] = amps_I_std * 1000
data['amps_I'] = amps_I * 1000
data['amps_II_mean'] = amps_II_mean * 1000
data['amps_II_std'] = amps_II_std * 1000
data['amps_II'] = amps_II * 1000
data['widths_I_mean'] = widths_I_mean
data['widths_I_std'] = widths_I_std
data['widths_I'] = widths_I
data['widths_I_trace'] = widths_I_trace * 1000
data['widths_II_mean'] = widths_II_mean
data['widths_II_std'] = widths_II_std
data['widths_II'] = widths_II
data['widths_II_trace'] = widths_II_trace * 1000
data['widths_III_mean'] = widths_III_mean
data['widths_III_std'] = widths_III_std
data['widths_III'] = widths_III
data['widths_III_trace'] = widths_III_trace * 1000
data['spikes'] = spikes * 1000
data['spikes_t_vec'] = spikes_t_vec
data['r_vec'] = np.linspace(run_param['R_0'], run_param['R'],
run_param['n'])
def process_data(self):
data = self.data
run_param = self.run_param
process_param = self.process_param
t_vec = np.array(data['t_vec'])
v_vec = np.array(data['LFP'])*1000
x = np.array(data['elec_x']).flatten()
y = np.array(data['elec_y']).flatten()
z = np.array(data['elec_z']).flatten()
# Calculate the radial distance to the electrodes.
r = np.sqrt(x * x + y * y + z * z).flatten()
# Get the signal from the soma potential.
# signal = data['LFP'][0]
signal = data['soma_v']
spikes, spikes_t_vec, I = de.extract_spikes(
data['t_vec'],
signal,
pre_dur=process_param['pre_dur'],
post_dur=process_param['post_dur'],
threshold=process_param['threshold'],
amp_option=process_param['amp_option'],
)
# Gather all spikes from the same indices as where the spike appears
# in the membrane potential.
spike_index = process_param['spike_to_measure']
if spikes.shape[0] < spike_index:
raise ValueError("Found fewer spikes than process_param['spike_to_measure']")
spikes = v_vec[:, I[spike_index, 0]:I[spike_index, 1]]
# Find widths of the spikes, trace can be used for plotting.
widths_I, widths_I_trace = de.find_wave_width_type_I(spikes,
dt=data['dt'])
widths_II, widths_II_trace = de.find_wave_width_type_II(
spikes,
threshold=process_param['width_half_thresh'],
dt=data['dt'],
amp_option=self.process_param['amp_option'])
amps_I = de.find_amplitude_type_I(spikes, amp_option=self.process_param['amp_option'])
amps_II = de.find_amplitude_type_II(spikes)
# Remove spikes which does not look nice.
data['widths_I_original'] = widths_I
data['widths_II_original'] = widths_II
if process_param['assert_width']:
low = np.where(widths_I < process_param['assert_width_I_low'])[0]
high = np.where(widths_I > process_param['assert_width_I_high'])[0]
ignored_spikes_I = np.union1d(low, high)
low = np.where(widths_II < process_param['assert_width_II_low'])[0]
high = np.where(widths_II > process_param['assert_width_II_high'])[0]
ignored_spikes_II = np.union1d(low, high)
ignored_spikes = np.union1d(ignored_spikes_I, ignored_spikes_II)
spikes = np.delete(spikes, ignored_spikes, axis=0)
widths_I = np.delete(widths_I, ignored_spikes, axis=0)
widths_II = np.delete(widths_II, ignored_spikes, axis=0)
amps_I = np.delete(amps_I, ignored_spikes, axis=0)
amps_II = np.delete(amps_II, ignored_spikes, axis=0)
x = np.delete(x, ignored_spikes, axis=0)
y = np.delete(y, ignored_spikes, axis=0)
z = np.delete(z, ignored_spikes, axis=0)
r = np.delete(r, ignored_spikes, axis=0)
self.info['ignored_spikes_cnt'] = len(ignored_spikes)
# Put widths_I in bins decided by the radial distance.
# Then calculate std and mean.
bins = np.linspace(0, run_param['R'], self.process_param['bins'], endpoint=True)
# Find the indices of the bins to which each value in r array belongs.
inds = np.digitize(r, bins)
# Widths and amps binned by distance.
widths_I_at_r = [widths_I[inds == i] for i in range(len(bins))]
widths_II_at_r = [widths_II[inds == i] for i in range(len(bins))]
amps_I_at_r = [amps_I[inds == i] for i in range(len(bins))]
amps_II_at_r = [amps_II[inds == i] for i in range(len(bins))]
with warnings.catch_warnings():
# Ignore warnings where mean or var has zero sized array as input.
warnings.simplefilter("ignore", category=RuntimeWarning)
widths_I_mean = [widths_I[inds == i].mean() for i in range(len(bins))]
widths_I_std = [np.sqrt(widths_I[inds == i].var()) for i in range(len(bins))]
widths_II_mean = [widths_II[inds == i].mean() for i in range(len(bins))]
widths_II_std = [np.sqrt(widths_II[inds == i].var()) for i in range(len(bins))]
amps_I_mean = [amps_I[inds == i].mean() for i in range(len(bins))]
amps_I_std = [np.sqrt(amps_I[inds == i].var()) for i in range(len(bins))]
amps_II_mean = [amps_II[inds == i].mean() for i in range(len(bins))]
amps_II_std = [np.sqrt(amps_II[inds == i].var()) for i in range(len(bins))]
widths_I_mean = np.array(widths_I_mean)
widths_II_mean = np.array(widths_II_mean)
amps_I_mean = np.array(amps_I_mean)
amps_II_mean = np.array(amps_II_mean)
widths_I_std = np.array(widths_I_std)
widths_II_std = np.array(widths_II_std)
amps_I_std = np.array(amps_I_std)
amps_II_std = np.array(amps_II_std)
data['elec_r_all'] = r
data['amps_I_mean'] = amps_I_mean
data['amps_I_std'] = amps_I_std
data['amps_I'] = amps_I
data['amps_I_at_r'] = amps_I_at_r
data['amps_II_mean'] = amps_II_mean
data['amps_II_std'] = amps_II_std
data['amps_II'] = amps_II
data['amps_II_at_r'] = amps_II_at_r
data['widths_I_mean'] = widths_I_mean
data['widths_I_std'] = widths_I_std
data['widths_I'] = widths_I
data['widths_I_trace'] = widths_I_trace
data['widths_I_at_r'] = widths_I_at_r
data['widths_II_mean'] = widths_II_mean
data['widths_II_std'] = widths_II_std
data['widths_II'] = widths_II
data['widths_II_trace'] = widths_II_trace
data['widths_II_at_r'] = widths_II_at_r
data['bins'] = bins
data['elec_r'] = r
data['spikes'] = spikes
data['spikes_t_vec'] = spikes_t_vec
self.info['spike_to_measure'] = process_param['spike_to_measure']
self.info['dt'] = data['dt']
def process_data(self):
data = self.data
run_param = self.run_param
process_param = self.process_param
signal = data['soma_v']
spikes_soma, spikes_t_vec, I = de.extract_spikes(
data['t_vec'],
signal,
pre_dur=process_param['pre_dur'],
post_dur=process_param['post_dur'],
threshold=process_param['threshold'],
amp_option=process_param['amp_option'],
)
spike_index = process_param['spike_to_measure']
if spikes_soma.shape[0] < spike_index:
raise ValueError("Found fewer spikes than process_param['spike_to_measure']")
# Gather all spikes from the same indices as where the spike appears
# in the membrane potential.
spikes = data['LFP'][:, I[spike_index, 0]:I[spike_index, 1]]
widths_I, widths_I_trace = de.find_wave_width_type_I(
spikes,
dt=data['dt'],
)
widths_II, widths_II_trace = de.find_wave_width_type_II(
spikes,
dt=data['dt'],
amp_option=process_param['amp_option'],
)
widths_I_soma, widths_I_trace_soma = de.find_wave_width_type_I(
spikes_soma[spike_index],
dt=data['dt'],
)
widths_II_soma, widths_II_trace_soma = de.find_wave_width_type_II(
spikes_soma[spike_index],
dt=data['dt'],
amp_option=process_param['amp_option'],
)
freq, amp, phase = \
LFPy_util.data_extraction.find_freq_and_fft(data['dt'], spikes)
# Remove the first coefficient as we don't care about the baseline.
freq = np.delete(freq, 0)
amp = np.delete(amp, 0, axis=1)
data['freq'] = freq * pq.kHz
data['amp'] = amp
data['phase'] = phase
data['spikes'] = spikes
data['spikes_t_vec'] = spikes_t_vec
data['spike_soma'] = spikes_soma[spike_index]
data['width_I'] = widths_I
data['width_I_trace'] = widths_I_trace
data['width_II'] = widths_II
data['width_II_trace'] = widths_II_trace
data['width_I_soma'] = widths_I_soma
data['width_I_trace_soma'] = widths_I_trace_soma[0]
data['width_II_soma'] = widths_II_soma
data['width_II_trace_soma'] = widths_II_trace_soma[0]
self.info['elec_x'] = data['elec_x']
self.info['elec_y'] = data['elec_y']
self.info['elec_z'] = data['elec_z']
def process_data(self):
data = self.data
run_param = self.run_param
process_param = self.process_param
if not data:
raise ValueError('No data to process.')
freqs = np.zeros(run_param['sweeps'])
isi = np.zeros(run_param['sweeps'])
freqs_elec = np.zeros(run_param['sweeps'])
isi_elec = np.zeros(run_param['sweeps'])
# Find firing frequency and inter spike interval from soma.
for i in xrange(run_param['sweeps']):
spike_indices = de.find_spikes(
data['t_vec'],
data['v_vec_soma'][i],
process_param['threshold'],
pre_dur=process_param['pre_dur'],
post_dur=process_param['post_dur'],
threshold_abs=process_param['threshold_abs_soma']
)
isi_tmp = np.diff(spike_indices) * data['dt']
if isi_tmp.size != 0:
isi[i] = np.mean(isi_tmp)
freqs[i] = 1000/isi[i] # Hz
else:
isi[i] = 0
freqs[i] = 0
spikes_soma = [None]*run_param['sweeps']
widths_I_soma = [None]*run_param['sweeps']
widths_I_soma_mean = np.zeros(run_param['sweeps'])
widths_I_soma_std = np.zeros(run_param['sweeps'])
widths_II_soma = [None]*run_param['sweeps']
widths_II_soma_mean = np.zeros(run_param['sweeps'])
widths_II_soma_std = np.zeros(run_param['sweeps'])
amps_I_soma = [None]*run_param['sweeps']
amps_I_soma_mean = np.zeros(run_param['sweeps'])
amps_I_soma_std = np.zeros(run_param['sweeps'])
# Soma spikes and widths.
for i in xrange(run_param['sweeps']):
with warnings.catch_warnings():
# Ignore warnings when not finding spikes.
warnings.simplefilter("ignore", category=RuntimeWarning)
spikes_soma[i], spikes_t_vec, I = de.extract_spikes(
data['t_vec'],
data['v_vec_soma'][i],
pre_dur=process_param['pre_dur'],
post_dur=process_param['post_dur'],
threshold=process_param['threshold'],
amp_option=process_param['amp_option'],
threshold_abs=process_param['threshold_abs_soma']
)
if spikes_soma[i].shape[0] == 0:
widths_I_soma[i] = []
widths_I_soma_mean[i] = np.nan
widths_II_soma[i] = []
widths_II_soma_mean[i] = np.nan
amps_I_soma_mean[i] = np.nan
amps_I_soma_std[i] = np.nan
continue
widths_I_soma[i], trace = de.find_wave_width_type_I(
spikes_soma[i],
dt=data['dt'],
)
widths_II_soma[i], trace = de.find_wave_width_type_II(
spikes_soma[i],
dt=data['dt'],
amp_option=process_param['amp_option'],
)
widths_I_soma_mean[i] = np.mean(widths_I_soma[i])
widths_II_soma_mean[i] = np.mean(widths_II_soma[i])
widths_I_soma_std[i] = np.sqrt(np.var(widths_I_soma[i]))
widths_II_soma_std[i] = np.sqrt(np.var(widths_II_soma[i]))
amps_I_soma[i] = de.find_amplitude_type_I(
spikes_soma[i],
process_param['amp_option'])
amps_I_soma_mean[i] = np.mean(amps_I_soma[i])
amps_I_soma_std[i] = np.sqrt(np.var(amps_I_soma[i]))
# There are a variable amount of spikes, so these varibles have
# one dimension with unknown lenght.
spikes_elec = [None]*run_param['sweeps']
widths_I_elec = [None]*run_param['sweeps']
widths_II_elec = [None]*run_param['sweeps']
amps_I_elec = [None]*run_param['sweeps']
for i in xrange(run_param['sweeps']):
spikes_elec[i] = [None]*run_param['n_elec']
widths_I_elec[i] = [None]*run_param['n_elec']
widths_II_elec[i] = [None]*run_param['n_elec']
amps_I_elec[i] = [None]*run_param['n_elec']
widths_I_elec_mean = np.zeros([run_param['sweeps'], run_param['n_elec']])
widths_I_elec_std = np.zeros([run_param['sweeps'], run_param['n_elec']])
widths_II_elec_mean = np.zeros([run_param['sweeps'], run_param['n_elec']])
widths_II_elec_std = np.zeros([run_param['sweeps'], run_param['n_elec']])
amps_I_elec_mean = np.zeros([run_param['sweeps'], run_param['n_elec']])
amps_I_elec_std = np.zeros([run_param['sweeps'], run_param['n_elec']])
# Electrode spikes and widths.
for i in xrange(run_param['sweeps']):
for j in xrange(run_param['n_elec']):
with warnings.catch_warnings():
# Ignore warnings when not finding spikes.
warnings.simplefilter("ignore", category=RuntimeWarning)
spikes_elec[i][j], spikes_t_vec, I = de.extract_spikes(
data['t_vec'],
data['v_vec_elec'][i, j],
pre_dur=process_param['pre_dur'],
post_dur=process_param['post_dur'],
threshold=process_param['threshold'],
amp_option=process_param['amp_option'],
threshold_abs=process_param['threshold_abs_elec']
)
if spikes_elec[i][j].shape[0] == 0:
widths_I_elec[i][j] = []
widths_I_elec_mean[i, j] = np.nan
widths_II_elec[i][j] = []
widths_II_elec_mean[i, j] = np.nan
amps_I_elec_mean[i, j] = np.nan
amps_I_elec_std[i, j] = np.nan
continue
widths_I_elec[i][j], trace = de.find_wave_width_type_I(
spikes_elec[i][j],
dt=data['dt'],
)
widths_II_elec[i][j], trace = de.find_wave_width_type_II(
spikes_elec[i][j],
dt=data['dt'],
amp_option=process_param['amp_option'],
)
widths_I_elec_mean[i, j] = np.mean(widths_I_elec[i][j])
widths_II_elec_mean[i, j] = np.mean(widths_II_elec[i][j])
widths_I_elec_std[i, j] = np.sqrt(np.var(widths_I_elec[i][j]))
widths_II_elec_std[i, j] = np.sqrt(np.var(widths_II_elec[i][j]))
amps_I_elec[i] = de.find_amplitude_type_I(
spikes_elec[i][j],
process_param['amp_option'])
amps_I_elec_mean[i, j] = np.mean(amps_I_elec[i][j])
amps_I_elec_std[i, j] = np.sqrt(np.var(amps_I_elec[i][j]))
data['spikes_t_vec'] = spikes_t_vec
data['spikes_soma'] = spikes_soma
data['spikes_elec'] = spikes_elec
data['freqs'] = freqs
data['isi'] = isi
data['widths_I_soma'] = widths_I_soma
data['widths_I_soma_mean'] = widths_I_soma_mean
data['widths_I_soma_std'] = widths_I_soma_std
data['widths_II_soma'] = widths_II_soma
data['widths_II_soma_mean'] = widths_II_soma_mean
data['widths_II_soma_std'] = widths_II_soma_std
data['amps_I_soma'] = amps_I_soma
data['amps_I_soma_mean'] = amps_I_soma_mean
data['amps_I_soma_std'] = amps_I_soma_std
data['widths_I_elec'] = widths_I_elec
data['widths_I_elec_mean'] = widths_I_elec_mean
data['widths_I_elec_std'] = widths_I_elec_std
data['widths_II_elec'] = widths_II_elec
data['widths_II_elec_mean'] = widths_II_elec_mean
data['widths_II_elec_std'] = widths_II_elec_std
data['amps_I_elec'] = amps_I_elec
data['amps_I_elec_mean'] = amps_I_elec_mean
data['amps_I_elec_std'] = amps_I_elec_std
self.info['elec_positions'] = zip(data['elec_x'],
data['elec_y'],
data['elec_z'])
