def test_rset(self):
p = sim.Population(17, sim.EIF_cond_exp_isfa_ista())
pv = p[::4]
pv.set = Mock()
v_rest = random.RandomDistribution('uniform', low=-70.0, high=-60.0)
pv.rset("v_rest", v_rest)
pv.set.assert_called_with(v_rest=v_rest)
def test_tset(self):
p = sim.Population(17, sim.EIF_cond_exp_isfa_ista())
pv = p[::4]
pv.set = Mock()
tau_m = numpy.linspace(10.0, 20.0, num=pv.size)
pv.tset("tau_m", tau_m)
pv.set.assert_called_with(tau_m=tau_m)
def test_first_and_last_id(self):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_exp())
p3 = sim.Population(3, sim.EIF_cond_exp_isfa_ista())
a = sim.Assembly(p3, p1, p2)
self.assertEqual(a.first_id, p1[0])
self.assertEqual(a.last_id, p3[-1])
def test_can_record(self):
pv = sim.Population(17, sim.EIF_cond_exp_isfa_ista())[::2]
assert pv.can_record('v')
assert not pv.can_record('w')
assert not pv.can_record('gsyn_inh')
assert pv.can_record('spikes')
assert not pv.can_record('foo')
def test_inject(self):
pv = sim.Population(3, sim.EIF_cond_exp_isfa_ista())[1, 2]
cs = Mock()
pv.inject(cs)
meth, args, kwargs = cs.method_calls[0]
self.assertEqual(meth, "inject_into")
self.assertEqual(args, (pv, ))
def test_can_record_population(self, sim=sim):
p = sim.Population(17, sim.EIF_cond_exp_isfa_ista())
assert p.can_record('v')
assert not p.can_record('w')
assert not p.can_record('gsyn_inh')
assert p.can_record('spikes')
assert not p.can_record('foo')
def test_id_to_index(self):
p = sim.Population(11, sim.EIF_cond_exp_isfa_ista())
pv = p[2, 5, 7, 8]
self.assertEqual(pv.id_to_index(pv[0]), 0)
self.assertEqual(pv.id_to_index(pv[3]), 3)
self.assertEqual(pv.id_to_index(p[2]), 0)
self.assertEqual(pv.id_to_index(p[8]), 3)
def test__getitem__tuple(self):
p = sim.Population(23, sim.EIF_cond_exp_isfa_ista())
pv1 = p[1, 5, 6, 8, 11, 12, 15, 16, 19, 20]
pv2 = pv1[(3, 5, 7)]
self.assertEqual(pv2.parent, pv1)
assert_array_almost_equal(pv2.all_cells, p.all_cells[[8, 12, 16]])
def test_getitem_int(self):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_exp())
p3 = sim.Population(3, sim.EIF_cond_exp_isfa_ista())
a = sim.Assembly(p3, p1, p2)
self.assertEqual(a[0], p3[0])
self.assertEqual(a[3], p1[0])
self.assertEqual(a[14], p2[0])
def test_conductance_based(self):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_exp())
p3 = sim.Population(3, sim.EIF_cond_exp_isfa_ista())
a1 = sim.Assembly(p1, p2)
a2 = sim.Assembly(p1, p3)
self.assertTrue(a1.conductance_based)
self.assertFalse(a2.conductance_based)
def test__homogeneous_synapses(self):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_exp())
p3 = sim.Population(3, sim.EIF_cond_exp_isfa_ista())
a1 = sim.Assembly(p1, p2)
a2 = sim.Assembly(p1, p3)
self.assertTrue(a1._homogeneous_synapses)
self.assertFalse(a2._homogeneous_synapses)
def test_create_with_index_array_selector(self):
p = sim.Population(11, sim.EIF_cond_exp_isfa_ista())
mask = numpy.array([3, 5, 7])
pv = sim.PopulationView(parent=p, selector=mask)
assert_array_equal(
pv.all_cells,
numpy.array([p.all_cells[3], p.all_cells[5], p.all_cells[7]]))
assert_array_equal(pv.mask, mask)
def test___add__three(self):
# adding three population views should give an Assembly
pv1 = sim.Population(6, sim.IF_cond_exp())[0:3]
pv2 = sim.Population(17, sim.IF_cond_exp())[1, 5, 14]
pv3 = sim.Population(9, sim.EIF_cond_exp_isfa_ista())[3:8]
assembly = pv1 + pv2 + pv3
self.assertIsInstance(assembly, sim.Assembly)
self.assertEqual(assembly.populations, [pv1, pv2, pv3])
def test_all_iterator(self):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_exp())
p3 = sim.Population(3, sim.EIF_cond_exp_isfa_ista())
a = sim.Assembly(p1, p2, p3)
assert hasattr(a.all(), "next")
ids = list(a.all())
self.assertEqual(ids, p1.all_cells.tolist() + p2.all_cells.tolist() + p3.all_cells.tolist())
def test_create_with_slice_selector(self):
p = sim.Population(11, sim.EIF_cond_exp_isfa_ista())
mask1 = slice(0,9,1)
pv1 = sim.PopulationView(parent=p, selector=mask1)
assert_array_equal(pv1.all_cells, p.all_cells[0:9])
mask2 = slice(3,9,2)
pv2 = sim.PopulationView(parent=pv1, selector=mask2)
self.assertEqual(pv2.parent, pv1) # or would it be better to resolve the parent chain up to an actual Population?
assert_array_equal(pv2.all_cells, numpy.array([p.all_cells[3], p.all_cells[5], p.all_cells[7]]))
def test_id_to_index(self):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_exp())
p3 = sim.Population(3, sim.EIF_cond_exp_isfa_ista())
a = sim.Assembly(p3, p1, p2)
self.assertEqual(a.id_to_index(p3[0]), 0)
self.assertEqual(a.id_to_index(p1[0]), 3)
self.assertEqual(a.id_to_index(p2[0]), 14)
assert_array_equal(a.id_to_index([p1[0], p2[0], p3[0]]), [3, 14, 0])
def test_get_spike_counts(self):
p = sim.Population(5, sim.EIF_cond_exp_isfa_ista())
pv = p[0, 1, 4]
pv.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[4]: 2})
def test_record_with_single_variable(self):
p = sim.Population(14, sim.EIF_cond_exp_isfa_ista())
pv = p[0, 4, 6, 13]
pv.record('v')
sim.run(12.3)
data = p.get_data(gather=True).segments[0]
self.assertEqual(len(data.analogsignals), 1)
n_values = int(round(12.3 / sim.get_time_step())) + 1
self.assertEqual(data.analogsignals[0].name, 'v')
self.assertEqual(data.analogsignals[0].shape, (n_values, pv.size))
def test_sample(self):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_exp())
p3 = sim.Population(3, sim.EIF_cond_exp_isfa_ista())
a = sim.Assembly(p3, p1, p2)
a1 = a.sample(10, rng=MockRNG())
# MockRNG.permutation reverses the order
self.assertEqual(len(a1.populations), 2)
assert_array_equal(a1.populations[0].all_cells, p1[11:6:-1])
assert_array_equal(a1.populations[1].all_cells, p2[6::-1])
def test__getitem__slice(self):
# Should return a PopulationView with the correct parent and value
# of all_cells
p = sim.Population(17, sim.EIF_cond_exp_isfa_ista())
pv1 = p[1, 5, 6, 8, 11, 12, 15, 16]
pv2 = pv1[2:6]
self.assertEqual(pv2.parent, pv1)
self.assertEqual(pv2.grandparent, p)
assert_array_equal(pv2.all_cells, pv1.all_cells[[2, 3, 4, 5]])
assert_array_equal(pv2.all_cells, p.all_cells[[6, 8, 11, 12]])
def test_record_with_multiple_variables(self):
p = sim.Population(4, sim.EIF_cond_exp_isfa_ista())
pv = p[0, 3]
pv.record(('v', 'spikes'))
sim.run(10.0)
data = p.get_data(gather=True).segments[0]
self.assertEqual(len(data.analogsignals), 1)
n_values = int(round(10.0 / sim.get_time_step())) + 1
names = set(arr.name for arr in data.analogsignals)
self.assertEqual(names, set(('v')))
for arr in data.analogsignals:
self.assertEqual(arr.shape, (n_values, pv.size))
def test_getitem_slice(self):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_exp())
p3 = sim.Population(3, sim.EIF_cond_exp_isfa_ista())
a = sim.Assembly(p3, p1, p2)
a1 = a[0:3]
self.assertIsInstance(a1, sim.Assembly)
self.assertEqual(len(a1.populations), 1)
assert_array_equal(a1.populations[0].all_cells, p3[:].all_cells)
a2 = a[2:8]
self.assertEqual(len(a2.populations), 2)
assert_array_equal(a2.populations[0].all_cells, p3[2:].all_cells)
assert_array_equal(a2.populations[1].all_cells, p1[:5].all_cells)
def test_getitem_array(self):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_exp())
p3 = sim.Population(3, sim.EIF_cond_exp_isfa_ista())
a = sim.Assembly(p3, p1, p2)
a1 = a[3, 5, 6, 10]
self.assertIsInstance(a1, sim.Assembly)
self.assertEqual(len(a1.populations), 1)
assert_array_equal(a1.populations[0].all_cells, [p1[0], p1[2], p1[3], p1[7]])
a2 = a[17, 2, 10, 11, 19]
self.assertEqual(len(a2.populations), 3)
assert_array_equal(a2.populations[0].all_cells, p3[2:].all_cells)
assert_array_equal(a2.populations[1].all_cells, p1[7:9].all_cells)
assert_array_equal(a2.populations[2].all_cells, p2[3, 5].all_cells)
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_record_invalid_variable(self):
pv = sim.Population(14, sim.EIF_cond_exp_isfa_ista())[::3]
self.assertRaises(
errors.RecordingError, pv.record,
('v', 'gsyn_exc')) # can't record gsyn_exc from this celltype
def test_record_gsyn(self):
pv = sim.Population(2, sim.EIF_cond_exp_isfa_ista())[1:]
pv.record = Mock()
pv.record_gsyn("arg1")
pv.record.assert_called_with(['gsyn_exc', 'gsyn_inh'], "arg1")
def test_record_v(self):
pv = sim.Population(2, sim.EIF_cond_exp_isfa_ista())[0:1]
pv.record = Mock()
pv.record_v("arg1")
pv.record.assert_called_with('v', "arg1")
def test_id_to_index_with_invalid_id(self):
p = sim.Population(11, sim.EIF_cond_exp_isfa_ista())
pv = p[2, 5, 7, 8]
self.assertRaises(IndexError, pv.id_to_index, p[0])
self.assertRaises(IndexError, pv.id_to_index, p[9])
def test_set_invalid_name(self):
p = sim.Population(9, sim.EIF_cond_exp_isfa_ista())
pv = p[3:5]
self.assertRaises(errors.NonExistentParameterError, pv.set, foo=13.2)
def test__getitem__invalid(self):
p = sim.Population(23, sim.EIF_cond_exp_isfa_ista())
pv = p[1, 5, 6, 8, 11, 12, 15, 16, 19, 20]
self.assertRaises(TypeError, pv.__getitem__, "foo")
