Merge 52a0b0a into da6cf4b

p8_integration_tests/scripts/pynnBrunnelBrianNestSpinnaker.py

@@ -159,11 +159,11 @@ def do_run(Neurons, sim_time, record, seed=None):
             label="Poisson_pop_I")
     else:
         poisson_ext_e = pynn.Population(
-            n_e, pynn.SpikeSourcePoisson(rate=10.0, seed=seed),
-            label="Poisson_pop_E")
+            n_e, pynn.SpikeSourcePoisson(rate=10.0),
+            label="Poisson_pop_E", additional_parameters={"seed": seed})
         poisson_ext_i = pynn.Population(
-            n_i, pynn.SpikeSourcePoisson(rate=10.0, seed=seed+1),
-            label="Poisson_pop_I")
+            n_i, pynn.SpikeSourcePoisson(rate=10.0),
+            label="Poisson_pop_I", additional_parameters={"seed": seed+1})
 
     # Connectors
     e_conn = pynn.FixedProbabilityConnector(epsilon)

p8_integration_tests/scripts/synfire_run.py

@@ -400,9 +400,8 @@ def __create_synfire_chain(
         else:
             populations.append(p.Population(
                 1, input_class(
-                    rate=rate, start=start_time, duration=duration,
-                    seed=seed),
-                label='inputSSP_1'))
+                    rate=rate, start=start_time, duration=duration),
+                label='inputSSP_1', additional_parameters={"seed": seed}))
 
         # handle projections
         if use_spike_connections:

p8_integration_tests/test_external_devices/test_recordable_spike_injector.py

@@ -3,56 +3,59 @@
 from random import randint
 from collections import defaultdict
 from six import iteritems
-
-n_spikes = defaultdict(lambda: 0)
-n_neurons = 100
-
-
-def _inject(label, connection):
-    time.sleep(0.1)
-    for _ in range(5000):
-        neuron_id = randint(0, n_neurons - 1)
-        n_spikes[neuron_id] += 1
-        connection.send_spike(label, neuron_id)
-        time.sleep(0.001)
-    print("Finished")
-
-
-def test_recordable_spike_injector():
-    p.setup(1.0)
-    pop = p.Population(
-        n_neurons, p.external_devices.SpikeInjector(), label="input")
-    pop.record("spikes")
-
-    connection = p.external_devices.SpynnakerLiveSpikesConnection(
-        send_labels=["input"])
-    connection.add_start_callback("input", _inject)
-
-    p.run(10000)
-    spikes = pop.get_data("spikes").segments[0].spiketrains
-
-    p.end()
-
-    spike_trains = dict()
-    for spiketrain in spikes:
-        i = spiketrain.annotations['source_index']
-        if __name__ == "__main__":
-            if n_spikes[i] != len(spiketrain):
-                print("Incorrect number of spikes, expected {} but got {}:"
-                      .format(n_spikes[i], len(spiketrain)))
-                print(spiketrain)
-        else:
-            assert n_spikes[i] == len(spiketrain)
-        spike_trains[i] = spiketrain
-
-    for (index, count) in iteritems(n_spikes):
-        if __name__ == "__main__":
-            if index not in spike_trains:
-                print("Neuron {} should have spiked {} times but didn't"
-                      .format(index, count))
-        else:
-            assert index in spike_trains
+from p8_integration_tests.base_test_case import BaseTestCase
+import unittest
+
+
+class TestRecordableSpikeInjector(BaseTestCase):
+
+    _n_spikes = defaultdict(lambda: 0)
+    _n_neurons = 100
+
+    def _inject(self, label, connection):
+        time.sleep(0.1)
+        for _ in range(5000):
+            neuron_id = randint(0, self._n_neurons - 1)
+            self._n_spikes[neuron_id] += 1
+            connection.send_spike(label, neuron_id)
+            time.sleep(0.001)
+        print("Finished")
+
+    def test_recordable_spike_injector(self):
+        p.setup(1.0)
+        pop = p.Population(
+            self._n_neurons, p.external_devices.SpikeInjector(), label="input")
+        pop.record("spikes")
+
+        connection = p.external_devices.SpynnakerLiveSpikesConnection(
+            send_labels=["input"])
+        connection.add_start_callback("input", self._inject)
+
+        p.run(10000)
+        spikes = pop.get_data("spikes").segments[0].spiketrains
+
+        p.end()
+
+        spike_trains = dict()
+        for spiketrain in spikes:
+            i = spiketrain.annotations['source_index']
+            if __name__ == "__main__":
+                if self._n_spikes[i] != len(spiketrain):
+                    print("Incorrect number of spikes, expected {} but got {}:"
+                          .format(self._n_spikes[i], len(spiketrain)))
+                    print(spiketrain)
+            else:
+                assert self._n_spikes[i] == len(spiketrain)
+            spike_trains[i] = spiketrain
+
+        for (index, count) in iteritems(self._n_spikes):
+            if __name__ == "__main__":
+                if index not in spike_trains:
+                    print("Neuron {} should have spiked {} times but didn't"
+                          .format(index, count))
+            else:
+                assert index in spike_trains
 
 
 if __name__ == "__main__":
-    test_recordable_spike_injector()
+    unittest.main()

p8_integration_tests/test_live_packet_gather/test_synfire_chain_BB_2pop_ABS.py

@@ -25,7 +25,7 @@ def do_run(plot):
 
     cell_params_lif_in = {
                           'tau_m':      32,
-                          'v_init': -80,
+                          'v': -80,
                           'v_rest': -75,
                           'v_reset': -95,
                           'v_thresh': -55,
@@ -36,7 +36,7 @@ def do_run(plot):
                           }
 
     cell_params_lif = {'tau_m':       32,
-                       'v_init': -80,
+                       'v': -80,
                        'v_rest': -75,
                        'v_reset': -95,
                        'v_thresh': -55,

p8_integration_tests/test_selective_recording/test_sampling.py

@@ -29,7 +29,7 @@ def run_script(
     sim.Projection(input1, pop_1, sim.AllToAllConnector(),
                    synapse_type=sim.StaticSynapse(weight=5, delay=1))
     input2 = sim.Population(n_neurons, sim.SpikeSourcePoisson(
-        rate=100.0, seed=1),  label="Stim_Exc")
+        rate=100.0),  label="Stim_Exc", additional_parameters={"seed": 1})
     sim.Projection(input2, pop_1, sim.OneToOneConnector(),
                    synapse_type=sim.StaticSynapse(weight=5, delay=1))
     if record_spikes:

p8_integration_tests/test_various/test_multiboard_spike_output.py

@@ -12,6 +12,7 @@ def spike_receiver(label, time, neuron_ids):
         TestMultiBoardSpikeOutput.counts[label] += len(neuron_ids)
 
     def test_multi_board_spike_output(self):
+        self.assert_not_spin_three()
         TestMultiBoardSpikeOutput.counts = dict()
         p.setup(1.0, n_chips_required=((48 * 2) + 1))
         machine = p.get_machine()

p8_integration_tests/test_various/test_mwh_population_synfire.py

@@ -82,6 +82,7 @@ def do_run(nNeurons, neurons_per_core):
 class MwhPopulationSynfire(BaseTestCase):
 
     def test_run_heavy(self):
+        self.assert_not_spin_three()
         try:
             nNeurons = 200  # number of neurons in each population
             neurons_per_core = 256

p8_integration_tests/test_various/test_one_pop_lif_example.py

@@ -10,7 +10,7 @@ def do_run(nNeurons):
 
     p.setup(timestep=1.0, min_delay=1.0, max_delay=8.0)
 
-    cell_params_lif_in = {'tau_m': 333.33, 'cm': 208.33, 'v_init': 0.0,
+    cell_params_lif_in = {'tau_m': 333.33, 'cm': 208.33, 'v': 0.0,
                           'v_rest': 0.1, 'v_reset': 0.0, 'v_thresh': 1.0,
                           'tau_syn_E': 1, 'tau_syn_I': 2, 'tau_refrac': 2.5,
                           'i_offset': 3.0}

p8_integration_tests/test_various/test_poisson.py

@@ -17,10 +17,11 @@ def do_run(seed=None):
             rate=10.0, start=0, duration=simtime), label="pg_pop2")
     else:
         pg_pop1 = sim.Population(2, sim.SpikeSourcePoisson(
-            rate=10.0, start=0, duration=simtime, seed=seed), label="pg_pop1")
+            rate=10.0, start=0, duration=simtime),
+            additional_parameters={"seed": seed}, label="pg_pop1")
         pg_pop2 = sim.Population(2, sim.SpikeSourcePoisson(
-            rate=10.0, start=0, duration=simtime, seed=seed+1),
-                                 label="pg_pop2")
+            rate=10.0, start=0, duration=simtime),
+            additional_parameters={"seed": seed+1}, label="pg_pop2")
 
     pg_pop1.record("spikes")
     pg_pop2.record("spikes")

p8_integration_tests/test_various/test_stdp_example.py

@@ -89,36 +89,45 @@ def do_run(seed=None):
     # Test of the effect of activity of the pre_pop population on the post_pop
     # population prior to the "pairing" protocol : only pre_pop is stimulated
     for i in range(n_stim_test):
-        IAddPre.append(sim.Population(pop_size, sim.SpikeSourcePoisson(
-            rate=in_rate, start=start_test_pre_pairing + ISI*(i),
-            duration=dur_stim, seed=random.randint(0, 100000000))))
+        IAddPre.append(sim.Population(
+            pop_size, sim.SpikeSourcePoisson(
+                rate=in_rate, start=start_test_pre_pairing + ISI*(i),
+                duration=dur_stim),
+            additional_parameters={"seed": random.randint(0, 100000000)}))
 
     # Pairing protocol : pre_pop and post_pop are stimulated with a 10 ms
     # difference
     for i in range(n_stim_pairing):
-        IAddPre.append(sim.Population(pop_size, sim.SpikeSourcePoisson(
-            rate=in_rate, start=start_pairing + ISI*(i), duration=dur_stim,
-            seed=random.randint(0, 100000000))))
-        IAddPost.append(sim.Population(pop_size, sim.SpikeSourcePoisson(
-            rate=in_rate, start=start_pairing + ISI*(i) + 10.,
-            duration=dur_stim, seed=random.randint(0, 100000000))))
+        IAddPre.append(sim.Population(
+            pop_size, sim.SpikeSourcePoisson(
+                rate=in_rate, start=start_pairing + ISI*(i),
+                duration=dur_stim),
+            additional_parameters={"seed": random.randint(0, 100000000)}))
+        IAddPost.append(sim.Population(
+            pop_size, sim.SpikeSourcePoisson(
+                rate=in_rate, start=start_pairing + ISI*(i) + 10.,
+                duration=dur_stim),
+            additional_parameters={"seed": random.randint(0, 100000000)}))
 
     # Test post pairing : only pre_pop is stimulated
     # (and should trigger activity in Post)
     for i in range(n_stim_test):
         start = start_pairing + ISI * n_stim_pairing + \
                 start_test_post_pairing + ISI * i
-        IAddPre.append(sim.Population(pop_size, sim.SpikeSourcePoisson(
-            rate=in_rate, start=start, duration=dur_stim,
-            seed=random.randint(0, 100000000))))
+        IAddPre.append(sim.Population(
+            pop_size, sim.SpikeSourcePoisson(
+                rate=in_rate, start=start, duration=dur_stim),
+            additional_parameters={"seed": random.randint(0, 100000000)}))
 
     # Noise inputs
     INoisePre = sim.Population(pop_size, sim.SpikeSourcePoisson(
-        rate=e_rate, start=0, duration=simtime,
-        seed=random.randint(0, 100000000)), label="expoisson")
+        rate=e_rate, start=0, duration=simtime),
+        additional_parameters={"seed": random.randint(0, 100000000)},
+        label="expoissonpre")
     INoisePost = sim.Population(pop_size, sim.SpikeSourcePoisson(
-        rate=e_rate, start=0, duration=simtime,
-        seed=random.randint(0, 100000000)), label="expoisson")
+        rate=e_rate, start=0, duration=simtime),
+        additional_parameters={"seed": random.randint(0, 100000000)},
+        label="expoissonpost")
 
     # +-------------------------------------------------------------------+
     # | Creation of connections                                           |