def test_iadd_list_of_spiketrains(self):
"""Adding a list of SpikeTrains to a SpikeTrainList in place
should return the original SpikeTrainList"""
extended_stl = deepcopy(self.stl_from_array)
extended_stl += [
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([22.2, 33.3], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms), ]
self.assertIsInstance(extended_stl, SpikeTrainList)
self.assertEqual(len(extended_stl), 7)
def test_time_slice_none_both(self):
st = SpikeTrain([0.1,0.5,1.2,3.3,6.4,7] * pq.ms, t_stop=10.0,
t_start=0.1)
# time_slice spike train, keep sliced spike times
st2 = st.time_slice(None,None)
assert_arrays_equal(st, st2)
# but keep everything else pristine
self.assertEqual(st.name, st2.name)
self.assertEqual(st.description, st2.description)
self.assertEqual(st.annotations, st2.annotations)
self.assertEqual(st.file_origin, st2.file_origin)
self.assertEqual(st.dtype, st2.dtype)
self.assertEqual(st.t_start, st2.t_start)
self.assertEqual(st.t_stop, st2.t_stop)
def test_time_slice_empty(self):
st = SpikeTrain([] * pq.ms, t_stop=10.0)
# time_slice spike train, keep sliced spike times
t_start = 0.01* pq.ms
t_stop = 70.0 * pq.ms
st2 = st.time_slice(t_start,t_stop)
assert_arrays_equal(st, st2)
# but keep everything else pristine
self.assertEqual(st.name, st2.name)
self.assertEqual(st.description, st2.description)
self.assertEqual(st.annotations, st2.annotations)
self.assertEqual(st.file_origin, st2.file_origin)
self.assertEqual(st.dtype, st2.dtype)
self.assertEqual(t_start, st2.t_start)
self.assertEqual(st.t_stop, st2.t_stop)
def test_time_slice_differnt_units(self):
st = SpikeTrain([0.1,0.5,1.2,3.3,6.4,7] * pq.ms, t_stop=10.0)
# time_slice spike train, keep sliced spike times
t_start = 0.00012* pq.s
t_stop = 0.0035 * pq.s
st2 = st.time_slice(t_start,t_stop)
assert_arrays_equal(st2, SpikeTrain([0.5,1.2,3.3] * pq.ms, t_stop=3.3))
# but keep everything else pristine
self.assertEqual(st.name, st2.name)
self.assertEqual(st.description, st2.description)
self.assertEqual(st.annotations, st2.annotations)
self.assertEqual(st.file_origin, st2.file_origin)
self.assertEqual(st.dtype, st2.dtype)
self.assertEqual(t_start, st2.t_start)
self.assertEqual(t_stop, st2.t_stop)
def setUp(self):
spike_time_array = np.array([0.5, 0.6, 0.7, 1.1, 11.2, 23.6, 88.5, 99.2])
channel_id_array = np.array([0, 0, 1, 2, 1, 0, 2, 0])
all_channel_ids = (0, 1, 2, 3)
self.stl_from_array = SpikeTrainList.from_spike_time_array(
spike_time_array,
channel_id_array,
all_channel_ids=all_channel_ids,
units='ms',
t_start=0 * pq.ms,
t_stop=100.0 * pq.ms,
identifier=["A", "B", "C", "D"] # annotation
)
self.stl_from_obj_list = SpikeTrainList(items=(
SpikeTrain([0.5, 0.6, 23.6, 99.2], units="ms",
t_start=0 * pq.ms, t_stop=100.0 * pq.ms, channel_id=101),
SpikeTrain([0.0007, 0.0112], units="s", t_start=0 * pq.ms, t_stop=100.0 * pq.ms,
channel_id=102),
SpikeTrain([1100, 88500], units="us", t_start=0 * pq.ms, t_stop=100.0 * pq.ms,
channel_id=103),
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms,
channel_id=104),
))
self.stl_from_obj_list_incl_proxy = SpikeTrainList(items=(
SpikeTrain([0.5, 0.6, 23.6, 99.2], units="ms",
t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([0.0007, 0.0112], units="s", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrainProxy(rawio=MockRawIO(), spike_channel_index=0),
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
))
def test_time_slice_typical(self):
st = SpikeTrain([0.1,0.5,1.2,3.3,6.4,7] * pq.ms, t_stop=10.0)
# time_slice spike train, keep sliced spike times
# this is the typical time slice falling somewhere in the middle of spikes
t_start = 0.12* pq.ms
t_stop = 3.5 * pq.ms
st2 = st.time_slice(t_start,t_stop)
assert_arrays_equal(st2, SpikeTrain([0.5,1.2,3.3] * pq.ms, t_stop=3.3))
# but keep everything else pristine
self.assertEqual(st.name, st2.name)
self.assertEqual(st.description, st2.description)
self.assertEqual(st.annotations, st2.annotations)
self.assertEqual(st.file_origin, st2.file_origin)
self.assertEqual(st.dtype, st2.dtype)
self.assertEqual(t_start, st2.t_start)
self.assertEqual(t_stop, st2.t_stop)
def setUp(self):
test_data = np.random.rand(100, 8) * pq.mV
channel_names = np.array(["a", "b", "c", "d", "e", "f", "g", "h"])
self.test_signal = AnalogSignal(test_data,
sampling_period=0.1 * pq.ms,
name="test signal",
description="this is a test signal",
array_annotations={"channel_names": channel_names},
attUQoLtUaE=42)
self.test_view = ChannelView(self.test_signal, [1, 2, 5, 7],
name="view of test signal",
description="this is a view of a test signal",
array_annotations={"something": np.array(["A", "B", "C", "D"])},
sLaTfat="fish")
self.test_spiketrains = [SpikeTrain(np.arange(100.0), units="ms", t_stop=200),
SpikeTrain(np.arange(0.5, 100.5), units="ms", t_stop=200)]
self.test_segment = Segment()
self.test_segment.analogsignals.append(self.test_signal)
self.test_segment.spiketrains.extend(self.test_spiketrains)
def setup_spiketrains(self):
trainname11 = 'spiketrain 1 1'
trainname12 = 'spiketrain 1 2'
trainname21 = 'spiketrain 2 1'
trainname22 = 'spiketrain 2 2'
traindata11 = np.arange(0, 10) * pq.ms
traindata12 = np.arange(10, 20) * pq.ms
traindata21 = np.arange(20, 30) * pq.s
traindata22 = np.arange(30, 40) * pq.s
self.trainnames1 = [trainname11, trainname12]
self.trainnames2 = [trainname21, trainname22]
self.trainnames = [trainname11, trainname12, trainname21, trainname22]
train11 = SpikeTrain(traindata11, t_stop=100 * pq.s, name=trainname11)
train12 = SpikeTrain(traindata12, t_stop=100 * pq.s, name=trainname12)
train21 = SpikeTrain(traindata21, t_stop=100 * pq.s, name=trainname21)
train22 = SpikeTrain(traindata22, t_stop=100 * pq.s, name=trainname22)
self.train1 = [train11, train12]
self.train2 = [train21, train22]
self.train = [train11, train12, train21, train22]
def test_sort(self):
wf = numpy.array([[0., 1.], [2., 3.], [4., 5.]])
st = SpikeTrain([3,4,5]*pq.s, waveforms=wf, name='n', t_stop=10.0)
st.sort()
assert_arrays_equal(st, [3,4,5]*pq.s)
assert_arrays_equal(st.waveforms, wf)
self.assertEqual(st.name, 'n')
self.assertEqual(st.t_stop, 10.0 * pq.s)
st = SpikeTrain([3,5,4]*pq.s, waveforms=wf, name='n', t_stop=10.0)
st.sort()
assert_arrays_equal(st, [3,4,5]*pq.s)
assert_arrays_equal(st.waveforms, wf[[0,2,1]])
self.assertEqual(st.name, 'n')
self.assertEqual(st.t_start, 0.0 * pq.s)
self.assertEqual(st.t_stop, 10.0 * pq.s)
def test_add_list_of_spiketrains(self):
"""Adding a list of SpikeTrains to a SpikeTrainList should return a new SpikeTrainList"""
extended_stl = self.stl_from_array + [
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([22.2, 33.3], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms), ]
self.assertIsInstance(extended_stl, SpikeTrainList)
self.assertEqual(len(extended_stl), 7)
self.assertNotEqual(id(extended_stl), id(self.stl_from_array))
extended_stl = self.stl_from_obj_list_incl_proxy + [
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([22.2, 33.3], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms)]
self.assertIsInstance(extended_stl, SpikeTrainList)
self.assertEqual(len(extended_stl), 7)
def test_radd_list_of_spiketrains(self):
""" """
extended_stl = [
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([22.2, 33.3], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms)
] + self.stl_from_array
self.assertIsInstance(extended_stl, SpikeTrainList)
self.assertEqual(len(extended_stl), 7)
extended_stl = [
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([22.2, 33.3], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms),
SpikeTrain([], units="ms", t_start=0 * pq.ms, t_stop=100.0 * pq.ms)
] + self.stl_from_obj_list_incl_proxy
self.assertIsInstance(extended_stl, SpikeTrainList)
self.assertEqual(len(extended_stl), 7)
def test_append(self):
"""Appending a SpikeTrain to a SpikeTrainList should make the STL longer"""
for stl in (self.stl_from_obj_list, self.stl_from_array):
stl.append(SpikeTrain([22.2, 33.3], units="ms",
t_start=0 * pq.ms, t_stop=100.0 * pq.ms))
self.assertEqual(len(stl), 5)
def test__rescale_same_units(self):
data = [3,4,5] * pq.ms
st = SpikeTrain(data, t_start=0.5, t_stop=10.0)
newst = st.rescale(pq.ms)
assert_arrays_equal(st, newst)
self.assertEqual(newst.units, 1 * pq.ms)
