class sfc_TestCase_new_scipy(unittest.TestCase): 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 = AnalogSignal(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, bin_size=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 = AnalogSignal(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), bin_size=fs1) # analogsignal containing multiple traces self.anasig4 = AnalogSignal(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, bin_size=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, bin_size=fs0) # spike train with incompatible bin_size self.bst5 = BinnedSpikeTrain(self.st3, bin_size=fs0 * 2.) # spike train with same bin_size as the analog signal, but with # bin edges not aligned to the time axis of the analog signal self.bst6 = BinnedSpikeTrain(self.st3, bin_size=fs0, t_start=4.5 * fs0, t_stop=tlen0 - 4.5 * fs0) # ========================================================================= # Tests for correct input handling # ========================================================================= def test_wrong_input_type(self): self.assertRaises(TypeError, sta.spike_field_coherence, np.array([1, 2, 3]), self.bst0) self.assertRaises(TypeError, sta.spike_field_coherence, self.anasig0, [1, 2, 3]) self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig0.duplicate_with_new_data([]), self.bst0) def test_start_stop_times_out_of_range(self): self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig1, self.bst0) self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig2, self.bst0) def test_non_matching_input_binning(self): self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig0, self.bst1) def test_incompatible_spiketrain_analogsignal(self): # These spike trains have incompatible binning (bin_size or alignment # to time axis of analog signal) self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig0, self.bst5) self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig0, self.bst6) def test_signal_dimensions(self): # single analogsignal trace and single spike train s_single, f_single = sta.spike_field_coherence(self.anasig0, self.bst0) self.assertEqual(len(f_single.shape), 1) self.assertEqual(len(s_single.shape), 2) # multiple analogsignal traces and single spike train s_multi, f_multi = sta.spike_field_coherence(self.anasig4, self.bst0) self.assertEqual(len(f_multi.shape), 1) self.assertEqual(len(s_multi.shape), 2) # frequencies are identical since same sampling frequency was used # in both cases and data length is the same assert_array_equal(f_single, f_multi) # coherences of s_single and first signal in s_multi are identical, # since first analogsignal trace in anasig4 is same as in anasig0 assert_array_equal(s_single[:, 0], s_multi[:, 0]) def test_non_binned_spiketrain_input(self): s, f = sta.spike_field_coherence(self.anasig0, self.st0) f_ind = np.where(f >= 19.)[0][0] max_ind = np.argmax(s[1:]) + 1 self.assertEqual(f_ind, max_ind) self.assertAlmostEqual(s[f_ind], 1., delta=0.01) # ========================================================================= # Tests for correct return values # ========================================================================= def test_spike_field_coherence_perfect_coherence(self): # check for detection of 20Hz peak in anasig0/bst0 with warnings.catch_warnings(): warnings.simplefilter("ignore") """ When the spiketrain is a vector with zero values, ignore the warning RuntimeWarning: invalid value encountered in true_divide Cxy = np.abs(Pxy)**2 / Pxx / Pyy. """ s, f = sta.spike_field_coherence(self.anasig0, self.bst0, window='boxcar') f_ind = np.where(f >= 19.)[0][0] max_ind = np.argmax(s[1:]) + 1 self.assertEqual(f_ind, max_ind) self.assertAlmostEqual(s[f_ind], 1., delta=0.01) def test_output_frequencies(self): nfft = 256 _, f = sta.spike_field_coherence(self.anasig3, self.bst1, nfft=nfft) # check number of frequency samples self.assertEqual(len(f), nfft / 2 + 1) f_max = self.anasig3.sampling_rate.rescale('Hz').magnitude / 2 f_ground_truth = np.linspace(start=0, stop=f_max, num=nfft // 2 + 1) * pq.Hz # check values of frequency samples assert_array_almost_equal(f, f_ground_truth) def test_short_spiketrain(self): # this spike train has the same length as anasig0 with warnings.catch_warnings(): warnings.simplefilter("ignore") """ When the spiketrain is a vector with zero values, ignore the warning RuntimeWarning: invalid value encountered in true_divide Cxy = np.abs(Pxy)**2 / Pxx / Pyy. """ s1, f1 = sta.spike_field_coherence(self.anasig0, self.bst3, window='boxcar') # this spike train has the same spikes as above, # but it's shorter than anasig0 s2, f2 = sta.spike_field_coherence(self.anasig0, self.bst4, window='boxcar') # the results above should be the same, nevertheless assert_array_equal(s1.magnitude, s2.magnitude) assert_array_equal(f1.magnitude, f2.magnitude)
class sfc_TestCase_new_scipy(unittest.TestCase): 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 = AnalogSignal( 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 = AnalogSignal( 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 = AnalogSignal( 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) # ========================================================================= # Tests for correct input handling # ========================================================================= def test_wrong_input_type(self): self.assertRaises(TypeError, sta.spike_field_coherence, np.array([1, 2, 3]), self.bst0) self.assertRaises(TypeError, sta.spike_field_coherence, self.anasig0, [1, 2, 3]) self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig0.duplicate_with_new_array([]), self.bst0) def test_start_stop_times_out_of_range(self): self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig1, self.bst0) self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig2, self.bst0) def test_non_matching_input_binning(self): self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig0, self.bst1) def test_incompatible_spiketrain_analogsignal(self): # These spike trains have incompatible binning (binsize or alignment to # time axis of analog signal) self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig0, self.bst5) self.assertRaises(ValueError, sta.spike_field_coherence, self.anasig0, self.bst6) def test_signal_dimensions(self): # single analogsignal trace and single spike train s_single, f_single = sta.spike_field_coherence(self.anasig0, self.bst0) self.assertEqual(len(f_single.shape), 1) self.assertEqual(len(s_single.shape), 2) # multiple analogsignal traces and single spike train s_multi, f_multi = sta.spike_field_coherence(self.anasig4, self.bst0) self.assertEqual(len(f_multi.shape), 1) self.assertEqual(len(s_multi.shape), 2) # frequencies are identical since same sampling frequency was used # in both cases and data length is the same assert_array_equal(f_single, f_multi) # coherences of s_single and first signal in s_multi are identical, # since first analogsignal trace in anasig4 is same as in anasig0 assert_array_equal(s_single[:, 0], s_multi[:, 0]) def test_non_binned_spiketrain_input(self): s, f = sta.spike_field_coherence(self.anasig0, self.st0) f_ind = np.where(f >= 19.)[0][0] max_ind = np.argmax(s[1:]) + 1 self.assertEqual(f_ind, max_ind) self.assertAlmostEqual(s[f_ind], 1., delta=0.01) # ========================================================================= # Tests for correct return values # ========================================================================= def test_spike_field_coherence_perfect_coherence(self): # check for detection of 20Hz peak in anasig0/bst0 s, f = sta.spike_field_coherence( self.anasig0, self.bst0, window='boxcar') f_ind = np.where(f >= 19.)[0][0] max_ind = np.argmax(s[1:]) + 1 self.assertEqual(f_ind, max_ind) self.assertAlmostEqual(s[f_ind], 1., delta=0.01) def test_output_frequencies(self): nfft = 256 _, f = sta.spike_field_coherence(self.anasig3, self.bst1, nfft=nfft) # check number of frequency samples self.assertEqual(len(f), nfft / 2 + 1) # check values of frequency samples assert_array_almost_equal( f, np.linspace( 0, self.anasig3.sampling_rate.rescale('Hz').magnitude / 2, nfft / 2 + 1) * pq.Hz) def test_short_spiketrain(self): # this spike train has the same length as anasig0 s1, f1 = sta.spike_field_coherence( self.anasig0, self.bst3, window='boxcar') # this spike train has the same spikes as above, but is shorter than # anasig0 s2, f2 = sta.spike_field_coherence( self.anasig0, self.bst4, window='boxcar') # the results above should be the same, nevertheless assert_array_equal(s1.magnitude, s2.magnitude) assert_array_equal(f1.magnitude, f2.magnitude)