Exemplo n.º 1
0
 def test_getSpikes(self):
     p = sim.Population(3, IF_cond_exp())
     p.record('spikes')
     sim.run(10.0)
     p.get_data = Mock()
     p.getSpikes()
     p.get_data.assert_called_with('spikes', True)
Exemplo n.º 2
0
 def test_print_v(self):
     p = sim.Population(3, IF_cond_exp())
     p.record_v()
     sim.run(10.0)
     p.write_data = Mock()
     p.print_v("foo.txt")
     p.write_data.assert_called_with('foo.txt', 'v', True)
Exemplo n.º 3
0
 def test_SpikeSourceArray(self):
     spike_times = [50.]
     p = sim.Population(3, sim.SpikeSourceArray(spike_times=spike_times))
     p2 = sim.Population(3, sim.Hardware_IF_cond_exp())
     syn = sim.StaticSynapse(weight=0.012)
     con = sim.Projection(p,
                          p2,
                          connector=sim.OneToOneConnector(),
                          synapse_type=syn,
                          receptor_type='excitatory')
     spike_times_g = p.get('spike_times')
     p2.record('v')
     sim.run(100.0)
     weights = nan_to_num(con.get('weight', format="array"))
     print weights
     data = p2.get_data().segments[0]
     vm = data.filter(name="v")[0]
     print vm
     Figure(
         Panel(weights,
               data_labels=["ext->cell"],
               line_properties=[{
                   'xticks': True,
                   'yticks': True,
                   'cmap': 'Greys'
               }]),
         Panel(vm,
               ylabel="Membrane potential (mV)",
               data_labels=["excitatory", "excitatory"],
               line_properties=[{
                   'xticks': True,
                   'yticks': True
               }]),
     ).save("result")
Exemplo n.º 4
0
 def test_get_v(self):
     p = sim.Population(3, IF_cond_exp())
     p.record_v()
     sim.run(10.0)
     p.get_data = Mock()
     p.get_v()
     p.get_data.assert_called_with('v', True)
Exemplo n.º 5
0
 def test_SpikeSourceArray(self):
     spike_times = [50.0]
     p = sim.Population(3, sim.SpikeSourceArray(spike_times=spike_times))
     p2 = sim.Population(3, sim.Hardware_IF_cond_exp())
     syn = sim.StaticSynapse(weight=0.012)
     con = sim.Projection(p, p2, connector=sim.OneToOneConnector(), synapse_type=syn, receptor_type="excitatory")
     spike_times_g = p.get("spike_times")
     p2.record("v")
     sim.run(100.0)
     weights = nan_to_num(con.get("weight", format="array"))
     print weights
     data = p2.get_data().segments[0]
     vm = data.filter(name="v")[0]
     print vm
     Figure(
         Panel(
             weights, data_labels=["ext->cell"], line_properties=[{"xticks": True, "yticks": True, "cmap": "Greys"}]
         ),
         Panel(
             vm,
             ylabel="Membrane potential (mV)",
             data_labels=["excitatory", "excitatory"],
             line_properties=[{"xticks": True, "yticks": True}],
         ),
     ).save("result")
Exemplo n.º 6
0
 def test_meanSpikeCount(self):
     p = sim.Population(14, EIF_cond_exp_isfa_ista())
     p.record('spikes')
     sim.run(100.0)
     p.mean_spike_count = Mock()
     p.meanSpikeCount()
     self.assertTrue(p.mean_spike_count.called)
Exemplo n.º 7
0
 def test_printSpikes(self):
     # TODO: implement assert_deprecated
     p = sim.Population(3, IF_cond_exp())
     p.record('spikes')
     sim.run(10.0)
     p.write_data = Mock()
     p.printSpikes("foo.txt")
     p.write_data.assert_called_with('foo.txt', 'spikes', True)
Exemplo n.º 8
0
 def test_get_spike_counts(self):
     p = sim.Population(3, EIF_cond_exp_isfa_ista())
     p.record('spikes')
     sim.run(100.0)
     self.assertEqual(p.get_spike_counts(),
                      {p.all_cells[0]: 2,
                       p.all_cells[1]: 2,
                       p.all_cells[2]: 2})
Exemplo n.º 9
0
    def runTest(self):
        import numpy

        import pyNN.hardware.brainscales as pynn

        # set-up the simulator
        pynn.setup(
            timestep=0.1,
            useSystemSim=True,
            speedupFactor=8000,
            ignoreDatabase=True,
            ignoreHWParameterRanges=True,
            hardware=pynn.hardwareSetup['one-hicann'],
        )

        # Set the neuron model class
        neuron_model = pynn.IF_cond_exp  # I&F

        neuron_parameters = {
            'cm': 0.281,  # membrane capacitance nF
            'e_rev_E': 0.0,  # excitatory reversal potential in mV
            'e_rev_I':
            -50.0,  # inhibitory reversal potential in mV (HIGHER THAN v_thresh)
            'i_offset': 0.0,  # offset current
            'tau_m': 9.3667,  # membrane time constant
            'tau_refrac': 1.0,  # absolute refractory period
            'tau_syn_E': 5.0,  # excitatory synaptic time constant
            'tau_syn_I': 5.0,  # inhibitory synaptic time constant
            'v_reset': -70.6,  # reset potential in mV
            'v_rest': -70.6,  # resting potential in mV
            'v_thresh': -55.,  # spike initiaton threshold voltage in mV
        }

        # We create a Population with 1 neuron of our
        N1 = pynn.Population(size=1,
                             cellclass=neuron_model,
                             cellparams=neuron_parameters)

        spiketimes = numpy.arange(10., 60., 5.)
        S1 = pynn.Population(1,
                             pynn.SpikeSourceArray,
                             cellparams={'spike_times': spiketimes})

        pynn.Projection(S1,
                        N1,
                        pynn.AllToAllConnector(weights=0.010425507084882381),
                        target='excitatory')  # max weight in hardware

        # record the voltage of all neurons of the population
        N1.record()

        # run the simulation for 200 ms
        pynn.run(80.)
        spikes = N1.getSpikes()
        pynn.end()
        self.assertEqual(
            spikes.shape, (3, 2),
            "Number of spikes is not as expected")  # should have 3 spikes!!
Exemplo n.º 10
0
 def test_getSpikes(self):
     p1 = sim.Population(11, sim.IF_cond_exp())
     p2 = sim.Population(11, sim.IF_cond_exp())
     a = sim.Assembly(p1, p2, label="test")
     a.record('spikes')
     sim.run(10.0)
     a.get_data = Mock()
     a.getSpikes()
     a.get_data.assert_called_with('spikes', True)
Exemplo n.º 11
0
 def test_print_v(self):
     p1 = sim.Population(11, sim.IF_cond_exp())
     p2 = sim.Population(11, sim.IF_cond_exp())
     a = sim.Assembly(p1, p2, label="test")
     a.record_v()
     sim.run(10.0)
     a.write_data = Mock()
     a.print_v("foo.txt")
     a.write_data.assert_called_with('foo.txt', 'v', True)
Exemplo n.º 12
0
 def test_get_gsyn(self):
     p1 = sim.Population(11, sim.IF_cond_exp())
     p2 = sim.Population(11, sim.IF_cond_exp())
     a = sim.Assembly(p1, p2, label="test")
     a.record_gsyn()
     sim.run(10.0)
     a.get_data = Mock()
     a.get_gsyn()
     a.get_data.assert_called_with(['gsyn_exc', 'gsyn_inh'], True)
Exemplo n.º 13
0
 def test_get_gsyn(self):
     p1 = sim.Population(11, sim.IF_cond_exp())
     p2 = sim.Population(11, sim.IF_cond_exp())
     a = sim.Assembly(p1, p2, label="test")
     a.record_gsyn()
     sim.run(10.0)
     a.get_data = Mock()
     a.get_gsyn()
     a.get_data.assert_called_with(['gsyn_exc', 'gsyn_inh'], True)
Exemplo n.º 14
0
 def test_print_v(self):
     p1 = sim.Population(11, sim.IF_cond_exp())
     p2 = sim.Population(11, sim.IF_cond_exp())
     a = sim.Assembly(p1, p2, label="test")
     a.record_v()
     sim.run(10.0)
     a.write_data = Mock()
     a.print_v("foo.txt")
     a.write_data.assert_called_with('foo.txt', 'v', True)
Exemplo n.º 15
0
 def test_record_with_single_variable(self):
     p = sim.Population(14, EIF_cond_exp_isfa_ista())
     p.record('v')
     sim.run(12.3)
     data = p.get_data(gather=True).segments[0]
     self.assertEqual(len(data.analogsignalarrays), 1)
     n_values = int(round(12.3 / sim.get_time_step())) + 1
     self.assertEqual(data.analogsignalarrays[0].name, 'v')
     self.assertEqual(data.analogsignalarrays[0].shape, (n_values, p.size))
Exemplo n.º 16
0
 def test_getSpikes(self):
     p1 = sim.Population(11, sim.IF_cond_exp())
     p2 = sim.Population(11, sim.IF_cond_exp())
     a = sim.Assembly(p1, p2, label="test")
     a.record('spikes')
     sim.run(10.0)
     a.get_data = Mock()
     a.getSpikes()
     a.get_data.assert_called_with('spikes', True)
Exemplo n.º 17
0
 def test_printSpikes(self):
     # TODO: implement assert_deprecated
     p1 = sim.Population(11, sim.IF_cond_exp())
     p2 = sim.Population(11, sim.IF_cond_exp())
     a = sim.Assembly(p1, p2, label="test")
     a.record('spikes')
     sim.run(10.0)
     a.write_data = Mock()
     a.printSpikes("foo.txt")
     a.write_data.assert_called_with('foo.txt', 'spikes', True)
Exemplo n.º 18
0
 def test_printSpikes(self):
     # TODO: implement assert_deprecated
     p1 = sim.Population(11, sim.IF_cond_exp())
     p2 = sim.Population(11, sim.IF_cond_exp())
     a = sim.Assembly(p1, p2, label="test")
     a.record('spikes')
     sim.run(10.0)
     a.write_data = Mock()
     a.printSpikes("foo.txt")
     a.write_data.assert_called_with('foo.txt', 'spikes', True)
Exemplo n.º 19
0
 def test_record_with_multiple_variables(self):
     p = sim.Population(2, EIF_cond_exp_isfa_ista())
     p.record(('v', 'spikes'))
     sim.run(10.0)
     data = p.get_data(gather=True).segments[0]
     self.assertEqual(len(data.analogsignalarrays), 1)
     n_values = int(round(10.0 / sim.get_time_step())) + 1
     names = set(arr.name for arr in data.analogsignalarrays)
     self.assertEqual(names, set(('v')))
     for arr in data.analogsignalarrays:
         self.assertEqual(arr.shape, (n_values, p.size))
Exemplo n.º 20
0
def test_restart_loop():
    extra = {"loglevel": 0, "useSystemSim": True, "hardware": sim.hardwareSetup["one-hicann"]}
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
Exemplo n.º 21
0
def test_restart_loop():
    extra = {
        'loglevel': 0,
        'useSystemSim': True,
        'hardware': sim.hardwareSetup['one-hicann']
    }
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
Exemplo n.º 22
0
def test_restart_loop():
    if not have_hardware_brainscales:
        raise SkipTest
    extra = {'loglevel': 0, 'useSystemSim': True, 'hardware': sim.hardwareSetup['one-hicann']}
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()

# def test_several_runs():
    if not have_hardware_brainscales:
        raise SkipTest
Exemplo n.º 23
0
def test_restart_loop():
    if not have_hardware_brainscales:
        raise SkipTest
    extra = {'loglevel':0, 'useSystemSim': True, 'hardware': sim.hardwareSetup['one-hicann']}
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    
#def test_several_runs():
    if not have_hardware_brainscales:
        raise SkipTest
Exemplo n.º 24
0
 def test_SpikeSourceArray(self):
     from pyNN.utility.plotting import Figure, Panel
     spike_times = [50.]
     p = sim.Population(3, sim.SpikeSourceArray(spike_times=spike_times))
     p2 = sim.Population(3, sim.Hardware_IF_cond_exp())
     syn = sim.StaticSynapse(weight=0.012)
     con = sim.Projection(p, p2, connector = sim.OneToOneConnector(), synapse_type=syn,receptor_type='excitatory')
     spike_times_g = p.get('spike_times')
     p2.record('v')
     sim.run(100.0)
     weights = nan_to_num(con.get('weight', format="array"))
     print weights
     data = p2.get_data().segments[0]
     vm = data.filter(name="v")[0]
     print vm
     Figure(
         Panel(weights,data_labels=["ext->cell"], line_properties=[{'xticks':True, 'yticks':True, 'cmap':'Greys'}]),
         Panel(vm, ylabel="Membrane potential (mV)", data_labels=["excitatory", "excitatory"], line_properties=[{'xticks': True, 'yticks':True}]),
     ).save("result")
    def run_experiment(self, weight_distortion=None):
        import pyNN.hardware.brainscales as pynn
        setup_params = dict(
            useSystemSim=True,
            ignoreDatabase=True,
            ignoreHWParameterRanges=True,
            hardware=pynn.hardwareSetup["one-hicann"],
            rng_seeds=[123567],
        )

        if weight_distortion is not None:
            setup_params['ess_params'] = {
                'weightDistortion': weight_distortion
            }

        pynn.setup(**setup_params)
        num_neurons = 2
        pop = pynn.Population(num_neurons, pynn.IF_cond_exp)
        # two different input spike trains, with identical rate but shifted to avoid loss in merger tree
        spike_times1 = np.arange(100., 500, 10.)
        spike_times2 = np.arange(105., 505, 10.)
        pop_source = pynn.Population(2, pynn.SpikeSourceArray)
        pop_source.tset('spike_times', [spike_times1, spike_times2])

        weight = 0.1  # weight = pop[0].cell.getConductanceRange("weight")[1]
        conn = pynn.OneToOneConnector(weights=weight)
        proj_0 = pynn.Projection(pop_source, pop, conn)

        pop.record()
        pynn.run(600.)

        spikes = pop.getSpikes()
        spikes_nrn_0 = spikes[spikes[:, 0] == 0, 1]
        spikes_nrn_1 = spikes[spikes[:, 0] == 1, 1]

        pynn.end()
        return len(spikes_nrn_0), len(spikes_nrn_1)
 def test_reset(self):
     sim.setup(**extra)
     sim.run(100.0)
     sim.reset()
     self.assertEqual(sim.get_current_time(), 0.0)
Exemplo n.º 27
0
    def runTest(self):
        import numpy

        import pyNN.hardware.brainscales as pynn

        # set-up the simulator
        pynn.setup(
            timestep=0.1,
            useSystemSim=True,
            speedupFactor=10000,
            ignoreDatabase=True,
            ignoreHWParameterRanges=True,
            hardware=pynn.hardwareSetup['one-hicann'],
        )

        # Set the neuron model class
        neuron_model = pynn.IF_cond_exp  # I&F

        neuron_parameters = {
            'cm': 0.281,  # membrane capacitance nF
            'e_rev_E': 0.0,  # excitatory reversal potential in mV
            'e_rev_I': -100.0,  # inhibitory reversal potential in mV
            'i_offset': 0.0,  # offset current
            'tau_m': 9.3667,  # membrane time constant
            'tau_refrac': 1.0,  # absolute refractory period
            'tau_syn_E': 5.0,  # excitatory synaptic time constant
            'tau_syn_I': 5.0,  # inhibitory synaptic time constant
            'v_reset': -70.6,  # reset potential in mV
            'v_rest': -70.6,  # resting potential in mV
            'v_thresh': -55.,  # spike initiaton threshold voltage in mV
        }

        # We create a Population with 1 neuron of our
        N1 = pynn.Population(size=2,
                             cellclass=neuron_model,
                             cellparams=neuron_parameters)
        N1a = N1[0:1]
        N1b = N1[1:2]
        v_shift = 5.
        # shift all voltages of 2nd neuron  by 5 mV
        N1b.set('v_rest', neuron_parameters['v_rest'] - v_shift)
        N1b.set('v_reset', neuron_parameters['v_reset'] - v_shift)
        N1b.set('v_thresh', neuron_parameters['v_thresh'] - v_shift)
        N1b.set('e_rev_E', neuron_parameters['e_rev_E'] - v_shift)
        N1b.set('e_rev_I', neuron_parameters['e_rev_I'] - v_shift)

        spiketimes = [10., 50., 110., 122.5]
        S1 = pynn.Population(1,
                             pynn.SpikeSourceArray,
                             cellparams={'spike_times': spiketimes})

        pynn.Projection(S1,
                        N1,
                        pynn.AllToAllConnector(weights=0.0123938304114),
                        target='inhibitory')  # max weight in hardware

        # record the voltage of all neurons of the population
        N1.record_v()

        # run the simulation for 200 ms
        pynn.run(150.)

        # format of get_v: [id, t, v]
        mean_v_a = N1a.get_v().transpose()[2].mean()
        mean_v_b = N1b.get_v().transpose()[2].mean()
        self.assertAlmostEqual(
            mean_v_a,
            mean_v_b + v_shift,
            places=3,
            msg=
            'The mean voltage of neuron a and b should have a difference of 5 mV'
        )
        pynn.end()
Exemplo n.º 28
0
 def test_reset(self):
     sim.setup(**extra)
     sim.run(100.0)
     sim.reset()
     self.assertEqual(sim.get_current_time(), 0.0)
Exemplo n.º 29
0
 def test_run(self):
     sim.setup(**extra)
     self.assertEqual(sim.run(100.0), 100.0)
Exemplo n.º 30
0
 def test_mean_spike_count(self):
     p = sim.Population(14, sim.EIF_cond_exp_isfa_ista())
     pv = p[2::3]
     pv.record('spikes')
     sim.run(100.0)
     self.assertEqual(p.mean_spike_count(), 2.0)
 def test_run(self):
     sim.setup(**extra)
     self.assertEqual(sim.run(100.0), 100.0)
Exemplo n.º 32
0
    def runTest(self):
        import pyNN.hardware.brainscales as pynn
        from pyNN.hardware.brainscales import mapper
        import os

        place = mapper.place()

        current_directory = os.path.dirname(os.path.realpath(__file__))
        pynn.setup(timestep=0.1,
                useSystemSim = True,
                algoinitFilename= current_directory + "/algoinit_l1_delay.pl",
                mappingStrategy="user",
                loglevel=2,
                hardware=[dict(setup="wafer", wafer_id=0,hicannIndices=[279,280])],
                hardwareNeuronSize=1,
                logfile='logfile.txt',
                speedupFactor=10000,
                rng_seeds=[123567],
                ignoreHWParameterRanges=True,
                ignoreDatabase=True,
                tempFolder="debug_l1_delay",
                )
        LIF_nrn_params = {
         'cm': 1.0,
         'e_rev_E': 0.0,
         'e_rev_I': -70.0,
         'i_offset': 0.0,
         'tau_m': 20.0,
         'tau_refrac': 5., # high value to avoid 2nd spike
         'tau_syn_E': 5.0,
         'tau_syn_I': 5.0,
         'v_reset': -65.0,
         'v_rest': -65.0,
         'v_thresh': -60.0} # low value for 1 spike

        num_pe = 8 # number of priority encoders
        pop_1 = pynn.Population(num_pe, pynn.IF_cond_exp, LIF_nrn_params)
        pop_2 = pynn.Population(num_pe, pynn.IF_cond_exp, LIF_nrn_params)
        pop_source = pynn.Population(num_pe, pynn.SpikeSourceArray)

        spike_times = [[i*10. + 10.] for i in range(num_pe)]
        pop_source.tset('spike_times',spike_times)
        weight = 0.05
        conn = pynn.OneToOneConnector(weight,0.1)
        proj_0=pynn.Projection(pop_source,pop_1, conn)
        proj_1=pynn.Projection(pop_1,pop_2, conn)
        for i in range(num_pe):
            place.to(pop_1[i], hicann=279, neuron=32*i)
            place.to(pop_2[i], hicann=279, neuron=32*i +1)
        place.commit()

        pop_1.record()
        pop_2.record()

        pynn.run(100.)

        spikes_1 = pop_1.getSpikes()
        spikes_2 = pop_2.getSpikes()
        self.assertEqual(8,len(spikes_1))
        self.assertEqual(8,len(spikes_2))

        # sort spikes by ID:
        spikes_1.sort()
        spikes_2.sort()
        # spiketimes only
        spikes_1 = spikes_1[:,(1,)]
        spikes_2 = spikes_2[:,(1,)]
        delays = spikes_2 - spikes_1

        # delay pe 1 > 0, 2, 4, 7
        self.assertTrue(delays[1] > delays[0])
        self.assertTrue(delays[1] > delays[2])
        self.assertTrue(delays[1] > delays[4])
        self.assertTrue(delays[1] > delays[7])

        # delay pe 6 > 0, 2, 4, 7
        self.assertTrue(delays[6] > delays[0])
        self.assertTrue(delays[6] > delays[2])
        self.assertTrue(delays[6] > delays[4])
        self.assertTrue(delays[6] > delays[7])

        # delay pe 5 > than everything expect 3
        self.assertTrue(delays[5] > delays[0])
        self.assertTrue(delays[5] > delays[1])
        self.assertTrue(delays[5] > delays[2])
        self.assertTrue(delays[5] > delays[4])
        self.assertTrue(delays[5] > delays[6])
        self.assertTrue(delays[5] > delays[7])

        # delay pe 3 > than everything
        self.assertTrue(delays[3] > delays[0])
        self.assertTrue(delays[3] > delays[1])
        self.assertTrue(delays[3] > delays[2])
        self.assertTrue(delays[3] > delays[4])
        self.assertTrue(delays[3] > delays[5])
        self.assertTrue(delays[3] > delays[6])
        self.assertTrue(delays[3] > delays[7])
Exemplo n.º 33
0
 def test_mean_spike_count(self):
     p = sim.Population(14, sim.EIF_cond_exp_isfa_ista())
     pv = p[2::3]
     pv.record('spikes')
     sim.run(100.0)
     self.assertEqual(p.mean_spike_count(), 2.0)
Exemplo n.º 34
0
    def runTest(self):
        import numpy
        backend = "hardware.brainscales"

        import pyNN.hardware.brainscales as pynn


        # set-up the simulator
        pynn.setup(
                timestep=0.1,
                useSystemSim=True,
                speedupFactor=8000,
                ignoreDatabase=True,
                ignoreHWParameterRanges=True,
                hardware=pynn.hardwareSetup['one-hicann'],
                )

        neuron_count = 1 # size of the Population we will create

        # Set the neuron model class
        neuron_model = pynn.EIF_cond_exp_isfa_ista # an Adaptive Exponential I&F Neuron

        neuron_parameters = {
         'a'          : 10.0,    # adaptation variable a in nS
         'b'          : 0.0805, # adaptation variable b in pA
         'cm'         : 0.281,  # membrane capacitance nF
         'delta_T'    : 2.0,    # delta_T fom Adex mod in mV, determines the sharpness of spike initiation
         'e_rev_E'    : 0.0,    # excitatory reversal potential in mV
         'e_rev_I'    : -100.0,  # inhibitory reversal potential in mV
         'i_offset'   : 0.0,    # offset current
         'tau_m'      : 9.3667, # membrane time constant
         'tau_refrac' : 8.0,    # absolute refractory period
         'tau_syn_E'  : 5.0,    # excitatory synaptic time constant
         'tau_syn_I'  : 5.0,    # inhibitory synaptic time constant
         'tau_w'      : 144.0,  # adaptation time constant
         'v_reset'    : -70.6,  # reset potential in mV
         'v_rest'     : -70.6,  # resting potential in mV
         'v_spike'    : -40.0,  # spike detection voltage in mV
         'v_thresh'   : -66.9,  # spike initiaton threshold voltage in mV
         }

        # We create a Population with 1 neuron of our 
        N1 = pynn.Population( size = 1, cellclass = neuron_model, cellparams = neuron_parameters)
        N1.initialize('v',neuron_parameters['v_rest'])

        spiketimes = numpy.arange(100.,800.,0.5)
        S1 = pynn.Population(1,pynn.SpikeSourceArray, cellparams = {'spike_times':spiketimes})

        pynn.Projection(S1,N1,pynn.OneToOneConnector(weights=0.0123938304114), target='inhibitory') # max weight in hardware


        # record the spikes of all neurons of the population
        N1.record()

        # run the simulation for 500 ms
        pynn.run(1000.)


        num_spikes = 0
        # After the simulation, we get Spikes and save the voltage trace to a file
        spike_times = N1.getSpikes()
        for pair in spike_times:
            print "Neuron ", int(pair[0]), " spiked at ", pair[1]
            num_spikes += 1

        pynn.end()

        self.assertEqual(int(num_spikes),1,'The Neuron spiked more than once, i.e. there was a rebound burst, and not a single rebound spike as it should be')