def test_sip(self):

        # Generate an example SIP mode
        sip, coinc = stgen.single_interaction_process(
            n_spiketrains=self.n,
            t_stop=self.t_stop,
            rate=self.rate,
            coincidence_rate=self.rate_c,
            return_coincidences=True)

        # Check the output types
        self.assertEqual(type(sip), list)
        self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(type(coinc[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(sip[0].simplified.units, 1000 * pq.ms)
        self.assertEqual(coinc[0].simplified.units, 1000 * pq.ms)

        # Check the output length
        self.assertEqual(len(sip), self.n)
        self.assertEqual(len(coinc[0]),
                         (self.rate_c * self.t_stop).simplified.magnitude)

        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            # Generate an example SIP mode giving a list of rates as imput
            sip, coinc = stgen.single_interaction_process(
                t_stop=self.t_stop,
                rate=self.rates,
                coincidence_rate=self.rate_c,
                return_coincidences=True)

        # Check the output types
        self.assertEqual(type(sip), list)
        self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(type(coinc[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(sip[0].simplified.units, 1000 * pq.ms)
        self.assertEqual(coinc[0].simplified.units, 1000 * pq.ms)

        # Check the output length
        self.assertEqual(len(sip), self.n)
        self.assertEqual(len(coinc[0]),
                         (self.rate_c * self.t_stop).rescale(pq.dimensionless))

        # Generate an example SIP mode stochastic number of coincidences
        sip = stgen.single_interaction_process(n_spiketrains=self.n,
                                               t_stop=self.t_stop,
                                               rate=self.rate,
                                               coincidence_rate=self.rate_c,
                                               coincidences='stochastic',
                                               return_coincidences=False)

        # Check the output types
        self.assertEqual(type(sip), list)
        self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(sip[0].simplified.units, 1000 * pq.ms)
示例#2
0
    def test_sip(self):

        # Generate an example SIP mode
        sip, coinc = stgen.single_interaction_process(n=self.n,
                                                      t_stop=self.t_stop,
                                                      rate=self.rate,
                                                      rate_c=self.rate_c,
                                                      return_coinc=True)

        # Check the output types
        self.assertEqual(type(sip), list)
        self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(type(coinc[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(sip[0].simplified.units, 1000 * ms)
        self.assertEqual(coinc[0].simplified.units, 1000 * ms)

        # Check the output length
        self.assertEqual(len(sip), self.n)
        self.assertEqual(len(coinc[0]),
                         (self.rate_c * self.t_stop).rescale(dimensionless))

        # Generate an example SIP mode giving a list of rates as imput
        sip, coinc = stgen.single_interaction_process(t_stop=self.t_stop,
                                                      rate=self.rates,
                                                      rate_c=self.rate_c,
                                                      return_coinc=True)

        # Check the output types
        self.assertEqual(type(sip), list)
        self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(type(coinc[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(sip[0].simplified.units, 1000 * ms)
        self.assertEqual(coinc[0].simplified.units, 1000 * ms)

        # Check the output length
        self.assertEqual(len(sip), self.n)
        self.assertEqual(len(coinc[0]),
                         (self.rate_c * self.t_stop).rescale(dimensionless))

        # Generate an example SIP mode stochastic number of coincidences
        sip = stgen.single_interaction_process(n=self.n,
                                               t_stop=self.t_stop,
                                               rate=self.rate,
                                               rate_c=self.rate_c,
                                               coincidences='stochastic',
                                               return_coinc=False)

        # Check the output types
        self.assertEqual(type(sip), list)
        self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(sip[0].simplified.units, 1000 * ms)
    def test_sip(self):

        # Generate an example SIP mode
        sip, coinc = stgen.single_interaction_process(
            n=self.n, t_stop=self.t_stop, rate=self.rate,
            rate_c=self.rate_c, return_coinc=True)

        # Check the output types
        self.assertEqual(type(sip), list)
        self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(type(coinc[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(sip[0].simplified.units,  1000*ms)
        self.assertEqual(coinc[0].simplified.units,  1000*ms)

        # Check the output length
        self.assertEqual(len(sip), self.n)
        self.assertEqual(
            len(coinc[0]), (self.rate_c*self.t_stop).rescale(dimensionless))

        # Generate an example SIP mode giving a list of rates as imput
        sip, coinc = stgen.single_interaction_process(
            t_stop=self.t_stop, rate=self.rates,
            rate_c=self.rate_c, return_coinc=True)

        # Check the output types
        self.assertEqual(type(sip), list)
        self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(type(coinc[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(sip[0].simplified.units,  1000*ms)
        self.assertEqual(coinc[0].simplified.units,  1000*ms)

        # Check the output length
        self.assertEqual(len(sip), self.n)
        self.assertEqual(
            len(coinc[0]), (self.rate_c*self.t_stop).rescale(dimensionless))

        # Generate an example SIP mode stochastic number of coincidences
        sip = stgen.single_interaction_process(
            n=self.n, t_stop=self.t_stop, rate=self.rate,
            rate_c=self.rate_c, coincidences='stochastic', return_coinc=False)

        # Check the output types
        self.assertEqual(type(sip), list)
        self.assertEqual(type(sip[0]), neo.core.spiketrain.SpikeTrain)
        self.assertEqual(sip[0].simplified.units,  1000*ms)