def test_only_one_spike(self):
'''The output should be the same as the input'''
x = np.arange(0, 20, 0.1)
y = x**2
sr = 10 / ms
z = AnalogSignalArray(np.array([y]).T, units='mV', sampling_rate=sr)
spiketime = 8 * ms
spiketime_in_ms = int((spiketime / ms).simplified)
st = SpikeTrain([spiketime_in_ms], units='ms', t_stop=20)
window_starttime = -3 * ms
window_endtime = 5 * ms
STA = sta.spike_triggered_average(z, st,
(window_starttime, window_endtime))
cutout = z[int(((spiketime + window_starttime) *
sr).simplified):int(((spiketime + window_endtime) *
sr).simplified)]
cutout.t_start = window_starttime
assert_array_equal(STA, cutout)
def setUp(self):
# standard testsignals
tlen0 = 100 * pq.s
f0 = 20. * pq.Hz
fs0 = 1 * pq.ms
t0 = np.arange(0,
tlen0.rescale(pq.s).magnitude,
fs0.rescale(pq.s).magnitude) * pq.s
self.anasig0 = AnalogSignalArray(np.sin(
2 * np.pi * (f0 * t0).simplified.magnitude),
units=pq.mV,
t_start=0 * pq.ms,
sampling_period=fs0)
self.st0 = SpikeTrain(np.arange(0,
tlen0.rescale(pq.ms).magnitude, 50) *
pq.ms,
t_start=0 * pq.ms,
t_stop=tlen0)
self.bst0 = BinnedSpikeTrain(self.st0, binsize=fs0)
def test_old_scipy_version(self):
self.assertRaises(AttributeError, sta.spike_field_coherence,
self.anasig0, self.bst0)
def test_empty_analogsignal(self):
asiga = AnalogSignalArray([], units='mV', sampling_rate=10 / ms)
st = SpikeTrain([5], units='ms', t_stop=10)
self.assertRaises(ValueError, sta.spike_triggered_average,
asiga, st, (-1 * ms, 1 * ms))
def setUp(self):
# standard testsignals
tlen0 = 100 * pq.s
f0 = 20. * pq.Hz
fs0 = 1 * pq.ms
t0 = np.arange(0,
tlen0.rescale(pq.s).magnitude,
fs0.rescale(pq.s).magnitude) * pq.s
self.anasig0 = AnalogSignalArray(np.sin(
2 * np.pi * (f0 * t0).simplified.magnitude),
units=pq.mV,
t_start=0 * pq.ms,
sampling_period=fs0)
self.st0 = SpikeTrain(np.arange(0,
tlen0.rescale(pq.ms).magnitude, 50) *
pq.ms,
t_start=0 * pq.ms,
t_stop=tlen0)
self.bst0 = BinnedSpikeTrain(self.st0, binsize=fs0)
# shortened analogsignals
self.anasig1 = self.anasig0.time_slice(1 * pq.s, None)
self.anasig2 = self.anasig0.time_slice(None, 99 * pq.s)
# increased sampling frequency
fs1 = 0.1 * pq.ms
self.anasig3 = AnalogSignalArray(np.sin(
2 * np.pi * (f0 * t0).simplified.magnitude),
units=pq.mV,
t_start=0 * pq.ms,
sampling_period=fs1)
self.bst1 = BinnedSpikeTrain(self.st0.time_slice(
self.anasig3.t_start, self.anasig3.t_stop),
binsize=fs1)
# analogsignal containing multiple traces
self.anasig4 = AnalogSignalArray(np.array([
np.sin(2 * np.pi * (f0 * t0).simplified.magnitude),
np.sin(4 * np.pi * (f0 * t0).simplified.magnitude)
]).transpose(),
units=pq.mV,
t_start=0 * pq.ms,
sampling_period=fs0)
# shortened spike train
self.st3 = SpikeTrain(np.arange(
(tlen0.rescale(pq.ms).magnitude * .25),
(tlen0.rescale(pq.ms).magnitude * .75), 50) * pq.ms,
t_start=0 * pq.ms,
t_stop=tlen0)
self.bst3 = BinnedSpikeTrain(self.st3, binsize=fs0)
self.st4 = SpikeTrain(np.arange(
(tlen0.rescale(pq.ms).magnitude * .25),
(tlen0.rescale(pq.ms).magnitude * .75), 50) * pq.ms,
t_start=5 * fs0,
t_stop=tlen0 - 5 * fs0)
self.bst4 = BinnedSpikeTrain(self.st4, binsize=fs0)
# spike train with incompatible binsize
self.bst5 = BinnedSpikeTrain(self.st3, binsize=fs0 * 2.)
# spike train with same binsize as the analog signal, but with
# bin edges not aligned to the time axis of the analog signal
self.bst6 = BinnedSpikeTrain(self.st3,
binsize=fs0,
t_start=4.5 * fs0,
t_stop=tlen0 - 4.5 * fs0)
