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))
