class TestSynfirePossonIfCurrExpParameter(BaseTestCase):
"""
tests the printing of get gsyn given a simulation
"""
def test_synfire_posson_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)
spikes = synfire_run.get_output_pop_spikes()
# 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])
if __name__ == '__main__':
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)
gsyn = synfire_run.get_output_pop_gsyn()
v = synfire_run.get_output_pop_voltage()
spikes = synfire_run.get_output_pop_spikes()
hist = numpy.histogram(spikes[:, 1], bins=[0, 5000, 10000])
print hist[0][0], hist[0][1]
plot_utils.plot_spikes(spikes)
plot_utils.heat_plot(v)
plot_utils.heat_plot(gsyn)
n_neurons = 200 # number of neurons in each population
neurons_per_core = n_neurons / 2
runtime = 5000
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])
spikes = synfire_run.get_output_pop_spikes_numpy()
spike_checker.synfire_spike_checker(spikes, n_neurons)
self.assertEquals(263, len(spikes))
synfire_run.get_output_pop_gsyn_exc_numpy()
if __name__ == '__main__':
results = synfire_run.do_run(n_neurons,
neurons_per_core=neurons_per_core,
run_times=[runtime])
spikes = synfire_run.get_output_pop_spikes_numpy()
v = synfire_run.get_output_pop_voltage_numpy()
gsyn = synfire_run.get_output_pop_gsyn_exc_numpy()
print(len(spikes))
plot_utils.plot_spikes(spikes)
plot_utils.heat_plot(v, title="v")
plot_utils.heat_plot(gsyn, title="gsyn")
synfire_run = TestRun()
class Synfire2RunExtractionIfCurrExpHigher(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()
self.assertEquals(53, len(spikes[0]))
self.assertEquals(261, len(spikes[1]))
spike_checker.synfire_spike_checker(spikes[0], nNeurons)
spike_checker.synfire_multiple_lines_spike_checker(spikes[1], nNeurons,
2)
if __name__ == '__main__':
synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times,
reset=reset)
gsyn = synfire_run.get_output_pop_gsyn()
v = synfire_run.get_output_pop_voltage()
spikes = synfire_run.get_output_pop_spikes()
print len(spikes[0])
print len(spikes[1])
plot_utils.plot_spikes(spikes[0], spikes[1])
plot_utils.heat_plot(v[0], title="v1")
plot_utils.heat_plot(gsyn[0], title="gysn1")
plot_utils.heat_plot(v[1], title="v2")
plot_utils.heat_plot(gsyn[1], title="gysn2")
synapse_type=synapse_type))
populations[1].record("v")
populations[1].record("spikes")
p.run(100)
neo = populations[1].get_data(["v", "spikes"])
v = neo_convertor.convert_data(neo, name="v")
spikes = neo_convertor.convert_spikes(neo)
p.end()
return (v, spikes)
class MwhSynfireWithDifferentMachineTimeSteps(BaseTestCase):
def test_run(self):
nNeurons = 3 # number of neurons in each population
(v, spikes) = do_run(nNeurons)
self.assertEqual(51, len(spikes))
if __name__ == '__main__':
nNeurons = 3 # number of neurons in each population
(v, spikes) = do_run(nNeurons)
plot_utils.plot_spikes(spikes)
plot_utils.heat_plot(v, title="v")
gsyn_inh_0_0 = neo_convertor.convert_data(neos[0], "gsyn_inh", 0)
gsyn_inh_1_0 = neo_convertor.convert_data(neos[1], "gsyn_inh", 0)
gsyn_inh_1_1 = neo_convertor.convert_data(neos[1], "gsyn_inh", 1)
self.assertEquals(nNeurons * runtimes[0], len(gsyn_inh_0_0))
self.assertEquals(nNeurons * runtimes[0], len(gsyn_inh_1_0))
self.assertEquals(nNeurons * runtimes[1], len(gsyn_inh_1_1))
if __name__ == '__main__':
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 = [1, 1]
spikes[0] = neo_convertor.convert_spikes(neos[1], 0)
spikes[1] = neo_convertor.convert_spikes(neos[1], 1)
v_1_0 = neo_convertor.convert_data(neos[1], "v", 0)
v_1_1 = neo_convertor.convert_data(neos[1], "v", 1)
gsyn_exc_1_0 = neo_convertor.convert_data(neos[1], "gsyn_exc", 0)
gsyn_exc_1_1 = neo_convertor.convert_data(neos[1], "gsyn_exc", 1)
print(len(spikes[0]))
print(len(spikes[1]))
plot_utils.plot_spikes(spikes)
plot_utils.heat_plot(v_1_0, title="v1")
plot_utils.heat_plot(gsyn_exc_1_0, title="gysn1")
plot_utils.heat_plot(v_1_1, title="v2")
plot_utils.heat_plot(gsyn_exc_1_1, title="gysn2")
spikes2 = populations[1].spinnaker_get_data("spikes")
p.end()
return (v1, gsyn1, v2, gsyn2, spikes1, spikes2)
class ATest(BaseTestCase):
def test_run(self):
nNeurons = 200 # number of neurons in each population
(v1, gsyn1, v2, gsyn2, spikes1, spikes2) = do_run(nNeurons)
self.assertEquals(20, len(spikes1))
self.assertEquals(20, len(spikes2))
self.assertTrue(np.array_equal(spikes1, spikes2))
if __name__ == '__main__':
nNeurons = 200 # number of neurons in each population
(v1, gsyn1, v2, gsyn2, spikes1, spikes2) = do_run(nNeurons)
print(len(spikes1))
print(spikes1)
print(len(spikes2))
print(spikes2)
plot_utils.plot_spikes([spikes1, spikes2])
print(np.array_equal(spikes1, spikes2))
plot_utils.heat_plot(v1, title="v1")
plot_utils.heat_plot(v2, title="v2")
plot_utils.heat_plot(gsyn1, title="gysn1")
plot_utils.heat_plot(gsyn2, title="gysn2")
