예제 #1
0
    def test_trial_shuffling_output_format_concatenated(self):
        spiketrain = neo.SpikeTrain([90, 93, 97, 100, 105, 150, 180, 350] *
                                    pq.ms,
                                    t_stop=.5 * pq.s)
        trial_length = 200 * pq.ms
        trial_separation = 50 * pq.ms
        n_surrogates = 2
        dither = 10 * pq.ms
        surrogate_trains = surr._trial_shifting_of_concatenated_spiketrain(
            spiketrain,
            dither=dither,
            n_surrogates=n_surrogates,
            trial_length=trial_length,
            trial_separation=trial_separation)

        self.assertIsInstance(surrogate_trains, list)
        self.assertEqual(len(surrogate_trains), n_surrogates)

        self.assertIsInstance(surrogate_trains[0], neo.SpikeTrain)
        for surrogate_train in surrogate_trains:
            self.assertEqual(surrogate_train.units, spiketrain.units)
            self.assertEqual(surrogate_train.t_start, spiketrain.t_start)
            self.assertEqual(surrogate_train.t_stop, spiketrain.t_stop)
            self.assertEqual(len(surrogate_train), len(spiketrain))
            assert_array_less(0., np.diff(surrogate_train))  # check ordering
예제 #2
0
    def test_trial_shuffling_empty_train_concatenated(self):

        empty_spiketrain = neo.SpikeTrain([] * pq.ms, t_stop=500 * pq.ms)
        trial_length = 200 * pq.ms
        trial_separation = 50 * pq.ms

        dither = 10 * pq.ms
        surrogate_train = surr._trial_shifting_of_concatenated_spiketrain(
            empty_spiketrain, dither=dither, n_surrogates=1,
            trial_length=trial_length, trial_separation=trial_separation)[0]
        self.assertEqual(len(surrogate_train), 0)