def test_empty(self):
bst = (nel.SpikeTrainArray([[3, 4, 5, 6, 7], [2, 4, 5]],
support=nel.EpochArray([0, 8]),
fs=1).bin(ds=1))
desc = 'test case for bst'
bst._desc = desc
n_series = bst.n_series
bst1 = bst.empty(inplace=False)
bst.empty(inplace=True)
assert bst.binned_support == None
assert bst.bin_centers == None
assert bst.bins == None
assert bst.eventarray.isempty
assert bst.n_series == n_series
assert bst._desc == desc
assert bst.support.isempty
# Emptying should be consistent whether we do it
# in place or not
assert bst1.binned_support == bst.binned_support
assert bst1.bin_centers == bst.bin_centers
assert bst1.bins == bst.bins
assert bst1.eventarray.isempty
assert bst1._desc == bst._desc
assert bst1.support.isempty
def test_indexing_1(self):
bst = (nel.SpikeTrainArray(
[[1, 2, 3, 4, 5, 6, 7, 8, 9.5, 10, 10.5, 11.4, 15, 18, 19, 20, 21],
[4, 8, 17]],
support=nel.EpochArray([[0, 8], [12, 22]]),
fs=1).bin(ds=1))
data = bst.data
bst._desc = 'test case for bst'
expected_bins = np.array([2, 3, 4, 5, 6, 7, 8, 12, 13, 14, 20, 21, 22])
expected_bin_centers = np.array(
[2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 12.5, 13.5, 20.5, 21.5])
expected_binned_support = np.array([[0, 5], [6, 7], [8, 9]])
bst_indexed = bst[nel.EpochArray([[2, 8], [9, 14], [19.5, 25]]), 1]
assert bst_indexed.n_series == 1
# binned support is an int array and should be exact. The others
# are floats so we use np.allclose
assert bst_indexed.binned_support.dtype.kind in ('i', 'u')
assert np.all(bst_indexed.binned_support == expected_binned_support)
assert np.allclose(bst_indexed.bins, expected_bins)
assert np.allclose(bst_indexed.bin_centers, expected_bin_centers)
# make sure original object's data didn't get mutated when indexing
assert np.all(bst.data == data)
# make sure metadata didn't get lost!
assert bst_indexed._desc == bst._desc
def test_construct(self):
fs = 1
series_ids = [21]
series_labels = ['pyr']
series_tags = ['CA1']
label = 'hippocampal units'
series_label = 'Neuron$'
sta = nel.SpikeTrainArray(
[0, 1.5, 3],
fs=fs,
label=label,
series_ids=series_ids,
series_labels=series_labels,
series_label=series_label,
series_tags=series_tags,
)
# Verify STA's attributes are same as arguments
# passed to the constructor
assert sta.fs == fs
assert sta.series_ids == series_ids
assert sta.series_tags == series_tags
assert sta.series_labels == series_labels
assert sta.label == label
assert sta._series_label == series_label
# Verify other attributes
assert sta.n_series == 1
def get_base_data(data_path, spike_path, session):
"""
Load and format data for replay analysis
"""
# get data session path from mat file
path = functions.get_session_path(
os.path.join(data_path, session) + '.mat')
# load position data from .mat file
df = functions.load_position(os.path.join(data_path, session) + '.mat')
# get the size of each maze
maze_size_cm = functions.get_maze_size_cm(
os.path.join(data_path, session) + '.mat')
# get session epochs
session_epochs = nel.EpochArray(
functions.get_epochs(os.path.join(data_path, session) + '.mat'))
# rescale epoch coordinates into cm
df = rescale_coords(df, session_epochs, maze_size_cm)
# put position into object
pos = nel.AnalogSignalArray(timestamps=df.ts,
data=[df.x],
fs=1 / statistics.mode(np.diff(df.ts)),
support=(session_epochs))
# load spikes & add to object
spikes = np.load(os.path.join(spike_path, session) + '.npy',
allow_pickle=True)
spikes_ = list(itertools.chain(*spikes))
session_bounds = nel.EpochArray([min(spikes_), max(spikes_)])
st = nel.SpikeTrainArray(timestamps=spikes,
support=session_bounds,
fs=32000)
return maze_size_cm, pos, st
def load_add_spikes(spike_path, session, fs=32000):
spikes = np.load(os.path.join(spike_path, session) + '.npy',
allow_pickle=True)
spikes_ = list(itertools.chain(*spikes))
session_bounds = nel.EpochArray([min(spikes_), max(spikes_)])
return nel.SpikeTrainArray(timestamps=spikes,
support=session_bounds,
fs=fs)
def test_16(self):
sta = nel.SpikeTrainArray(
[[1, 2, 3, 5, 10, 11, 12, 15], [1, 2, 3, 5, 10, 11, 12, 15]], fs=5)
sta = sta.partition(n_epochs=5)
for aa, bb in zip(ragged_array([np.array([5, 15]),
np.array([5, 15])]),
sta.iloc[[1, 4], :].data):
assert np.allclose(aa, bb)
def test_copy_without_data(self):
sta = nel.SpikeTrainArray([[3, 4, 5, 6, 7], [2, 4, 5]],
support=nel.EpochArray([0, 8]),
fs=1)
desc = 'test case for sta'
sta._desc = desc
sta_copied = sta._copy_without_data()
assert sta_copied.n_series == sta.n_series
assert sta_copied._desc == sta._desc
assert sta_copied.isempty
def copy_without_data(self):
bst = (nel.SpikeTrainArray([[3, 4, 5, 6, 7], [2, 4, 5]],
support=nel.EpochArray([0, 8]),
fs=1).bin(ds=1))
desc = 'test case for bst'
bst._desc = desc
bst_copied = bst._copy_without_data()
assert bst_copied.n_series == bst.n_series
assert bst._desc == desc
assert bst.isempty
assert bst.eventarray.isempty
def test_indexing_2(self):
# support indexing by list
bst = (nel.SpikeTrainArray(
[1, 2, 3, 4, 5, 6, 7, 8, 9.5, 10, 10.5, 11.4, 15, 18, 19, 20, 21],
support=nel.EpochArray([[0, 8], [10, 12], [15, 22]]),
fs=1).bin(ds=1))
bst_indexed = bst[[0, 1, 2]]
assert bst_indexed.n_intervals == 3
# Now test if we don't take all epochs, the original object
# should not have been mutated
bst_indexed = bst[[1, 2]]
assert bst_indexed.n_intervals == 2
assert bst.n_intervals == 3
def test_indexing(self):
sta = (nel.SpikeTrainArray(
[[1, 2, 3, 4, 5, 6, 7, 8, 9.5, 10, 10.5, 11.4, 15, 18, 19, 20, 21],
[4, 8, 17]],
support=nel.EpochArray([[0, 8], [12, 22]]),
fs=1).bin(ds=1))
sta._desc = 'test case for sta'
data = sta.data
sta_indexed = sta[nel.EpochArray([[2, 8], [9, 14], [19.5, 25]]), 1]
assert sta_indexed.n_series == 1
# make sure original object's data didn't get mutated when indexing
assert np.all(sta.data == data)
# make sure metadata didn't get lost!
assert sta_indexed._desc == sta._desc
def test_construct_with_sta(self):
fs = 1
series_ids = [21]
series_labels = ['pyr']
series_tags = ['CA1']
label = 'hippocampal units'
sta = nel.SpikeTrainArray([0, 1.5, 3],
fs=fs,
label=label,
series_ids=series_ids,
series_labels=series_labels,
series_tags=series_tags)
ds = 0.2
bst = nel.BinnedSpikeTrainArray(sta, ds=ds)
# Verify BST's attributes are same as those
# passed to the constructor
assert bst.ds == ds
# Verify BST's attributes are inherited from STA
assert bst.fs == sta.fs
assert bst.series_ids == sta.series_ids
assert bst.series_labels == sta.series_labels
assert bst.series_tags == sta.series_tags
assert bst.label == sta.label
# Verify BST's eventarray's attributes are also
# inherited from STA
assert bst.eventarray.fs == sta.fs
assert bst.eventarray.series_ids == sta.series_ids
assert bst.eventarray.series_labels == sta.series_labels
assert bst.eventarray.series_tags == sta.series_tags
assert bst.eventarray.label == sta.label
# Verify other attributes
assert bst.n_series == 1
def test_empty(self):
sta = nel.SpikeTrainArray([[3, 4, 5, 6, 7], [2, 4, 5]],
support=nel.EpochArray([0, 8]),
fs=1)
desc = 'test case for sta'
sta._desc = desc
n_series = sta.n_series
sta1 = sta.empty(inplace=False)
sta.empty(inplace=True)
assert sta.n_series == n_series
assert sta._desc == desc # ensure metadata preserved
assert sta.isempty
assert sta.support.isempty
# Emptying should be consistent whether we do it
# in place or not
assert sta1.n_series == sta.n_series
assert sta1._desc == sta._desc
assert sta1.isempty
assert sta1.support.isempty
def test_14(self):
sta = nel.SpikeTrainArray([[3, 4], [4], [2]])
assert sta.n_units == 3
def test_13(self):
sta = nel.SpikeTrainArray([[[3, 4], [4],
[2]]]) # failed before updates
assert sta.n_units == 3
def test_12(self):
sta = nel.SpikeTrainArray(empty=True)
assert sta.n_units == 0
def test_11(self):
sta = nel.SpikeTrainArray([[1, 2, 3], []])
assert sta.n_units == 2
def test_8(self):
sta = nel.SpikeTrainArray([[1, 2], [3, 4]])
assert sta.n_units == 2
def test_7(self):
sta = nel.SpikeTrainArray(1)
assert sta.n_units == 1
def test_4(self):
sta = nel.SpikeTrainArray([1])
assert sta.n_units == 1
def test_3(self):
sta = nel.SpikeTrainArray([[1], [2], [3]])
assert sta.n_units == 3 # failed before updates
def test_2(self):
sta = nel.SpikeTrainArray([[], [], [3]])
assert sta.n_units == 3
def test_6(self):
sta = nel.SpikeTrainArray([[]])
assert sta.n_units == 1 # failed before updates
def test_10(self):
sta = nel.SpikeTrainArray([1, 2, 3])
assert sta.n_units == 1
