def do_v_no_constraint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=False, record_v=True, record_gsyn_exc_7=False, record_gsyn_inh=False) v = synfire_run.get_output_pop_voltage_numpy() self.assertEqual(n_neurons * runtime, len(v)) read_v = numpy.loadtxt(v_file, delimiter=',') self.assertTrue(numpy.allclose(read_v, v, rtol=1e-03), "v neo method mismatch")
def do_gsyn_no_constraint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=False, record_v=False, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() self.assertEqual(n_neurons * runtime, len(gsyn_exc)) read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch")
def do_spikes_no_constraint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=True, record_v=False, record_gsyn_exc_7=False, record_gsyn_inh=False) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEqual(expected_spikes, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) read_spikes = numpy.loadtxt(spike_file, delimiter=',') self.assertTrue(numpy.allclose(read_spikes, spikes), "spikes neo method mismatch")
def test_all_no_constarint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=True, record_7=True, record_v=True, record_v_7=True, record_gsyn_exc=True, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc_7 = synfire_run.get_output_pop_gsyn_exc_7() v_7 = synfire_run.get_output_pop_voltage_7() spikes_7 = synfire_run.get_output_pop_spikes_7() gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEquals(n_neurons * runtime, len(gsyn_exc)) read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') if not numpy.allclose(read_gsyn, gsyn_exc_7): for g1, g2 in zip(read_gsyn, gsyn_exc_7): if not numpy.allclose(g1, g2, rtol=1e-04): print(g1, g2, g1[2] - g2[2], (g1[2] - g2[2]) / g1[2]) self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc_7, rtol=1e-04), "gsyn synakker method mismatch") self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch") self.assertEquals(n_neurons * runtime, len(v)) read_v = numpy.loadtxt(v_file, delimiter=',') self.assertTrue(numpy.allclose(read_v, v_7, rtol=1e-03), "v synakker method mismatch") self.assertTrue(numpy.allclose(read_v, v, rtol=1e-03), "v neo method mismatch") self.assertEquals(expected_spikes, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) read_spikes = numpy.loadtxt(spike_file, delimiter=',') self.assertTrue(numpy.allclose(read_spikes, spikes_7), "spikes synakker method mismatch") self.assertTrue(numpy.allclose(read_spikes, spikes), "spikes neo method mismatch")
def do_all_constraint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], placement_constraint=placement_constraint, record=True, record_7=True, record_v=True, record_v_7=True, record_gsyn_exc=True, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEqual(n_neurons * runtime, len(gsyn_exc)) read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch") self.assertEqual(n_neurons * runtime, len(v)) read_v = numpy.loadtxt(v_file, delimiter=',') self.assertTrue(numpy.allclose(read_v, v, rtol=1e-03), "v neo method mismatch") self.assertEqual(expected_spikes, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) read_spikes = numpy.loadtxt(spike_file, delimiter=',') self.assertTrue(numpy.allclose(read_spikes, spikes), "spikes neo method mismatch")
def do_sampling_rate(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=True, record_7=True, record_v=True, record_v_7=True, v_sampling_rate=2, gsyn_exc_sampling_rate=3, record_gsyn_exc=True, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc_7 = synfire_run.get_output_pop_gsyn_exc_7() v_7 = synfire_run.get_output_pop_voltage_7() spikes_7 = synfire_run.get_output_pop_spikes_7() gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') small_gsyn = read_gsyn[read_gsyn[:, 1] % 3 == 0] self.assertEqual(len(small_gsyn), len(gsyn_exc_7)) self.assertTrue(numpy.allclose(small_gsyn, gsyn_exc_7, rtol=1e-04), "gsyn synakker method mismatch") self.assertTrue(numpy.allclose(small_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch") self.assertEqual(n_neurons*(runtime/2), len(v)) read_v = numpy.loadtxt(v_file, delimiter=',') small_v = read_v[read_v[:, 1] % 2 == 0] self.assertTrue(numpy.allclose(small_v, v_7, rtol=1e-03), "v synakker method mismatch") self.assertTrue(numpy.allclose(small_v, v, rtol=1e-03), "v neo method mismatch") self.assertEqual(expected_spikes, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) read_spikes = numpy.loadtxt(spike_file, delimiter=',') self.assertTrue(numpy.allclose(read_spikes, spikes_7), "spikes synakker method mismatch") self.assertTrue(numpy.allclose(read_spikes, spikes), "spikes neo method mismatch")
def do_run(seed=None): # Simulate using both simulators synfire_run = SynfireRunner() synfire_run.do_run( n_neurons=1, input_class=SpikeSourcePoisson, rate=noise_rate, start_time=0, duration=simtime, seed=seed, use_spike_connections=False, cell_params=cell_params, run_times=[simtime], record=True, record_v=True, randomise_v_init=True, record_input_spikes=True, weight_to_spike=0.4) s_pop_voltages = synfire_run.get_output_pop_voltage_numpy() s_pop_spikes = synfire_run.get_output_pop_spikes_numpy() noise_spike_times = synfire_run.get_spike_source_spikes_numpy() return noise_spike_times, s_pop_spikes, s_pop_voltages
def get_before_and_after(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, weight_to_spike=weight_to_spike, delay=delay, placement_constraint=placement_constraint, run_times=runtimes, get_weights=get_weights, get_delays=get_delays) weights = synfire_run.get_weights() self.assertEqual(n_neurons, len(weights[0])) self.assertEqual(n_neurons, len(weights[1])) self.assertTrue(numpy.allclose(weights[0][0][2], weights[1][0][2])) delays = synfire_run.get_delay() self.assertEqual(n_neurons, len(delays[0])) self.assertEqual(n_neurons, len(delays[1])) self.assertTrue(numpy.allclose(delays[0][0][2], delays[1][0][2]))
weights = synfire_run.get_weights() self.assertEqual(n_neurons, len(weights[0])) self.assertEqual(n_neurons, len(weights[1])) self.assertTrue(numpy.allclose(weights[0][0][2], weights[1][0][2])) delays = synfire_run.get_delay() self.assertEqual(n_neurons, len(delays[0])) self.assertEqual(n_neurons, len(delays[1])) self.assertTrue(numpy.allclose(delays[0][0][2], delays[1][0][2])) def test_get_before_and_after(self): self.runsafe(self.get_before_and_after) if __name__ == '__main__': synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, weight_to_spike=weight_to_spike, delay=delay, placement_constraint=placement_constraint, run_times=runtimes, get_weights=get_weights, get_delays=get_delays) weights = synfire_run.get_weights() delays = synfire_run.get_delay() print("weights[0]") print(weights[0]) print(weights[0].shape) print("weights[1]") print(weights[1])
""" Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner nNeurons = 200 # number of neurons in each population spike_times = [[0, 1050]] run_times = [1000, 1000] reset = False new_pop = True synfire_run = SynfireRunner() class Synfire2RunNewPopIfCurrExpLower(BaseTestCase): def test_run(self): try: synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=reset, new_pop=new_pop) except NotImplementedError: # This is the current behaviour but would not be wrong if changed. print("Adding populations without reset not yet supported") if __name__ == '__main__': synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times,
""" Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner import spynnaker.plot_utils as plot_utils import spynnaker.spike_checker as spike_checker n_neurons = 200 # number of neurons in each population neurons_per_core = n_neurons / 2 spike_times = [[0, 1050]] runtimes = [1000, 500] reset = False synfire_run = SynfireRunner() class Synfire2RunExtractionIfCurrExpLowerSecondRun(BaseTestCase): def test_run(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, spike_times=spike_times, run_times=runtimes, reset=reset) spikes = synfire_run.get_output_pop_spikes_list_numpy() self.assertEquals(53, len(spikes[0])) self.assertEquals(103, len(spikes[1])) spike_checker.synfire_spike_checker(spikes[0], n_neurons) spike_checker.synfire_multiple_lines_spike_checker(spikes[1], n_neurons, 2)
""" Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner import spynnaker.plot_utils as plot_utils import spynnaker.spike_checker as spike_checker from spynnaker8.utilities import neo_convertor, neo_compare from spynnaker8.utilities.version_util import pynn8_syntax nNeurons = 200 # number of neurons in each population run_times = [1000, 500] reset = True synfire_run = SynfireRunner() class Synfire1RunReset1RunSmallerRuntimeNoExtraction(BaseTestCase): def test_run(self): synfire_run.do_run(nNeurons, run_times=run_times, reset=reset, get_all=True) neos = synfire_run.get_output_pop_all_list() spikes_0_0 = neo_convertor.convert_spikes(neos[0], 0) spikes_1_1 = neo_convertor.convert_spikes(neos[1], 1) self.assertEquals(53, len(spikes_0_0)) self.assertEquals(27, len(spikes_1_1)) spike_checker.synfire_spike_checker(spikes_0_0, nNeurons) spike_checker.synfire_spike_checker(spikes_1_1, nNeurons) # v + gsyn_exc + gsyn_ihn = 3 (spikes not in analogsignalarrays if pynn8_syntax:
delay=delay, run_times=[runtime], record=False, record_v=False, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() self.assertEqual(n_neurons * runtime, len(gsyn_exc)) read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch") def test_gsyn_no_constraint(self): self.runsafe(self.do_gsyn_no_constraint) if __name__ == '__main__': synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], placement_constraint=placement_constraint, record=True, record_7=True, record_v=True, record_v_7=True, record_gsyn_exc=True, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() gsyn_exc_neo = synfire_run.get_output_pop_gsyn_exc_neo() v = synfire_run.get_output_pop_voltage_numpy() v_neo = synfire_run.get_output_pop_voltage_neo() spikes = synfire_run.get_output_pop_spikes_numpy() spikes_neo = synfire_run.get_output_pop_spikes_neo() numpy.savetxt(spike_file, spikes, delimiter=',')
n_neurons = 200 # number of neurons in each population neurons_per_core = n_neurons / 2 run_times = [5000, 5000] wrap_around = False # parameters for population 1 first run input_class = p.SpikeSourcePoisson start_time = 0 duration = 5000.0 rate = 2.0 # parameters for population 2 first run set_between_runs = [(1, 'duration', 0)] extract_between_runs = False record_input_spikes = True synfire_run = SynfireRunner() class TestSynfirePoissonIfCurrExpParameterTestSecondNone(BaseTestCase): def second_none(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=run_times, use_wrap_around_connections=wrap_around, input_class=input_class, start_time=start_time, duration=duration, rate=rate, extract_between_runs=extract_between_runs, set_between_runs=set_between_runs, record_input_spikes=record_input_spikes)
""" Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner import spynnaker.plot_utils as plot_utils import spynnaker.spike_checker as spike_checker n_neurons = 200 # number of neurons in each population runtime = 5000 neurons_per_core = n_neurons / 2 synfire_run = SynfireRunner() class SynfireIfCurrExp(BaseTestCase): def test_run(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=[runtime], seed=self._test_seed) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEquals(263, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) synfire_run.get_output_pop_gsyn_exc_numpy() synfire_run.get_output_pop_voltage_numpy() if __name__ == '__main__': synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core,
""" Synfirechain-like example """ # general imports from p8_integration_tests.scripts.synfire_run import SynfireRunner from p8_integration_tests.base_test_case import BaseTestCase import spynnaker.spike_checker as spike_checker from spinnman.exceptions import SpinnmanTimeoutException from unittest import SkipTest n_neurons = 10 # number of neurons in each population runtime = 50 synfire_run = SynfireRunner() class TestGsyn(BaseTestCase): """ tests the printing of get gsyn given a simulation """ def test_get_gsyn(self): try: synfire_run.do_run(n_neurons, max_delay=14.4, time_step=0.1, neurons_per_core=5, delay=1.7, run_times=[runtime]) spikes = synfire_run.get_output_pop_spikes_numpy() # no check of spikes length as the system overloads spike_checker.synfire_spike_checker(spikes, n_neurons)
from __future__ import print_function from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner import spynnaker.plot_utils as plot_utils import numpy n_neurons = 200 # number of neurons in each population neurons_per_core = n_neurons / 2 runtimes = [5000, 5000] set_between_runs = [(0, 'i_offset', 30)] synfire_run = SynfireRunner() extract_between_runs = False class TestGetGsyn(BaseTestCase): """ tests the printing of get gsyn given a simulation """ def test_get_gsyn(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=runtimes, extract_between_runs=extract_between_runs, set_between_runs=set_between_runs) spikes = synfire_run.get_output_pop_spikes_numpy() # Check spikes increase in second half by at least a factor of ten hist = numpy.histogram(spikes[:, 1], bins=[0, 5000, 10000]) self.assertEquals(263, hist[0][0]) self.assertEquals(333400, hist[0][1])
""" Synfirechain-like example """ import spynnaker.plot_utils as plot_utils import spynnaker.spike_checker as spike_checker from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner nNeurons = 200 # number of neurons in each population neurons_per_core = 10 delay = 17 run_times = [5000] get_weights = True synfire_run = SynfireRunner() class SynfireIfCurr_exp(BaseTestCase): def test_run(self): synfire_run.do_run(nNeurons, neurons_per_core=neurons_per_core, delay=delay, run_times=run_times, get_weights=get_weights) spikes = synfire_run.get_output_pop_spikes_numpy() weights = synfire_run.get_weights() self.assertEqual(263, len(spikes)) self.assertEqual(200, len(weights)) spike_checker.synfire_spike_checker(spikes, nNeurons) if __name__ == '__main__':
# GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """ Synfirechain-like example """ # general imports from spinn_front_end_common.utilities.exceptions import ConfigurationException from p8_integration_tests.scripts.synfire_run import SynfireRunner from p8_integration_tests.base_test_case import BaseTestCase n_neurons = 10 # number of neurons in each population runtime = 50 synfire_run = SynfireRunner() class TestGsyn(BaseTestCase): """ tests the printing of get gsyn given a simulation """ def test_get_gsyn(self): with self.assertRaises(ConfigurationException): synfire_run.do_run(n_neurons, max_delay=14.4, time_step=0.1, neurons_per_core=5, delay=1.7, run_times=[runtime]) if __name__ == '__main__':
n_neurons = 200 # number of neurons in each population neurons_per_core = n_neurons / 2 run_times = [5000, 5000] # parameters for population 1 first run input_class = p.SpikeSourcePoisson start_time = 0 duration = 5000.0 rate = 2.0 # parameters for population 2 first run set_between_runs = [(1, 'start', 5000), (1, 'rate', 200.0), (1, 'duration', 2000.0)] extract_between_runs = False synfire_run = SynfireRunner() class TestSynfirePoissonIfCurrExpParameter(BaseTestCase): def synfire_poisson_if_curr_exp_parameter(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=run_times, input_class=input_class, start_time=start_time, duration=duration, rate=rate, extract_between_runs=extract_between_runs, set_between_runs=set_between_runs, seed=12345) spikes = synfire_run.get_output_pop_spikes_numpy() # Check spikes increase in second half by at least a factor of ten hist = numpy.histogram(spikes[:, 1], bins=[0, 5000, 10000]) self.assertLess(hist[0][0] * 10, hist[0][1])
""" Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner import spynnaker.plot_utils as plot_utils import spynnaker.spike_checker as spike_checker nNeurons = 200 # number of neurons in each population spike_times = [[0, 1050, 2200]] run_times = [1000, 1000, 1000] reset = False extract_between_runs = False synfire_run = SynfireRunner() class Synfire3Rrun1ExitNoExtractionIfCurrExp(BaseTestCase): def test_run(self): synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=reset, extract_between_runs=extract_between_runs) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEquals(303, len(spikes)) spike_checker.synfire_multiple_lines_spike_checker(spikes, nNeurons, 3) if __name__ == '__main__':
from __future__ import print_function """ Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner import spynnaker.plot_utils as plot_utils from spynnaker8.utilities import neo_convertor import spynnaker.spike_checker as spike_checker from six.moves import reduce n_neurons = 200 # number of neurons in each population runtimes = [1000, 1000, 1000, 1000, 1000] neurons_per_core = n_neurons / 2 synfire_run = SynfireRunner() class SynfireIfCurrExp(BaseTestCase): def test_run(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=runtimes, record=True, record_v=True, record_gsyn_exc=True, record_gsyn_inh=False) spikes_neos = synfire_run.get_output_pop_spikes_list() len0 = reduce(lambda x, y: x + y, map(len, spikes_neos[0].segments[0].spiketrains)) len1 = reduce(lambda x, y: x + y,
""" Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner import spynnaker.plot_utils as plot_utils import spynnaker.spike_checker as spike_checker import spynnaker.gsyn_tools as gsyn_tools n_neurons = 10 # number of neurons in each population max_delay = 14.4 timestep = 1 neurons_per_core = n_neurons / 2 delay = 1.7 runtime = 50 synfire_run = SynfireRunner() class TestGetGsyn(BaseTestCase): """ tests the printing of get gsyn given a simulation """ def test_get_gsyn(self): synfire_run.do_run(n_neurons, max_delay=max_delay, time_step=timestep, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime]) spikes = synfire_run.get_output_pop_spikes_numpy() gsyn = synfire_run.get_output_pop_gsyn_exc_numpy()
""" Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner from testfixtures import LogCapture nNeurons = 200 # number of neurons in each population spike_times = [[0, 1050]] run_times = [1000, 1000] reset = False synfire_run = SynfireRunner() class Synfire2RunExtractionIfCurrExp(BaseTestCase): def test_run(self): with LogCapture() as lc: synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=False) self.assert_logs_messages( lc.records, "Working out if machine is booted", 'INFO', 2) if __name__ == '__main__': synfire_run.do_run( nNeurons, spike_times=spike_times, run_times=run_times, reset=False)
import os from neo.io import PickleIO import unittest from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner from spynnaker8.utilities import neo_compare n_neurons = 200 # number of neurons in each population runtime = 500 current_file_path = os.path.dirname(os.path.abspath(__file__)) current_v_file_path = os.path.join(current_file_path, "v.pickle") max_delay = 14 timestep = 1 neurons_per_core = n_neurons / 2 delay = 1.7 synfire_run = SynfireRunner() class TestPrintVoltage(BaseTestCase): """ tests the printing of print v given a simulation """ def test_print_voltage(self): """ test that tests the printing of v from a pre determined recording :return: """ synfire_run.do_run(n_neurons, max_delay=max_delay, time_step=timestep, neurons_per_core=neurons_per_core,
Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner import spynnaker.plot_utils as plot_utils import spynnaker.spike_checker as spike_checker from spynnaker8.utilities import neo_convertor, neo_compare from spynnaker8.utilities.version_util import pynn8_syntax nNeurons = 200 # number of neurons in each population spike_times = [[0, 1050]] neurons_per_core = nNeurons / 2 runtimes = [1000, 2000] reset = True synfire_run = SynfireRunner() class Synfire1RunReset1RunLargertRuntimeNoExtraction(BaseTestCase): def test_run(self): synfire_run.do_run(nNeurons, spike_times=spike_times, reset=reset, run_times=runtimes, neurons_per_core=neurons_per_core, get_all=True) neos = synfire_run.get_output_pop_all_list() spikes_0_0 = neo_convertor.convert_spikes(neos[0], 0) spikes_1_1 = neo_convertor.convert_spikes(neos[1], 1) self.assertEquals(53, len(spikes_0_0)) self.assertEquals(156, len(spikes_1_1))
""" Synfirechain-like example """ # general imports from p8_integration_tests.scripts.synfire_run import SynfireRunner from p8_integration_tests.base_test_case import BaseTestCase from spinn_front_end_common.utilities.exceptions import ConfigurationException n_neurons = 20 # number of neurons in each population runtime = 200 delay = 30 neurons_per_core = None synfire_run = SynfireRunner() record = False get_spikes = True record_v = False get_gsyn_exc = False get_gsyn_inh = False class ExtractingSpikesWhenVOnlySetToRecord(BaseTestCase): """ tests the printing of get gsyn given a simulation """ def test_cause_error(self): with self.assertRaises(ConfigurationException): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime],
""" Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner import spynnaker.plot_utils as plot_utils import spynnaker.spike_checker as spike_checker nNeurons = 200 # number of neurons in each population spike_times = [[0, 1050]] run_times = [1000, 500] reset = False synfire_run = SynfireRunner() class Synfire2RunExtractionIfCurrExpLower(BaseTestCase): def test_run(self): synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=reset) spikes = synfire_run.get_output_pop_spikes_list_numpy() self.assertEquals(53, len(spikes[0])) self.assertEquals(103, len(spikes[1])) spike_checker.synfire_spike_checker(spikes[0], nNeurons) spike_checker.synfire_multiple_lines_spike_checker( spikes[1], nNeurons, 2)
#!/usr/bin/python """ Synfirechain-like example """ import spynnaker.plot_utils as plot_utils import spynnaker.spike_checker as spike_checker from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner nNeurons = 6300 # number of neurons in each population delay = 1 record_v = False record_gsyn = False synfire_run = SynfireRunner() class Synfire200n10pc2chipsWithNoDelaysSpikeRecording(BaseTestCase): def test_run(self): self.assert_not_spin_three() synfire_run.do_run(nNeurons, delay=delay, record_v=record_v, record_gsyn_exc=record_gsyn, record_gsyn_inh=record_gsyn) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEqual(333, len(spikes)) spike_checker.synfire_spike_checker(spikes, nNeurons) if __name__ == '__main__':
# along with this program. If not, see <http://www.gnu.org/licenses/>. """ Synfirechain-like example """ import spynnaker.plot_utils as plot_utils from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner n_neurons = 200 # number of neurons in each population runtime = 5000 neurons_per_core = n_neurons / 2 record = False record_v = True record_gsyn = False synfire_run = SynfireRunner() class SynfireIfCurrExp(BaseTestCase): def test_run(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=[runtime], record=record, record_v=record_v, record_gsyn_exc=record_gsyn) gsyn = synfire_run.get_output_pop_gsyn_exc_list() v = synfire_run.get_output_pop_voltage_list() spikes = synfire_run.get_output_pop_spikes_list() self.assertEqual(1, len(v)) self.assertEqual(0, len(gsyn)) self.assertEqual(0, len(spikes))