def test_sample(self, sim=sim):
p = sim.Population(13, sim.IF_cond_exp())
pv1 = p[0, 3, 7, 10, 12]
rng = Mock()
rng.permutation = Mock(return_value=numpy.array([3, 1, 0, 2, 4]))
pv2 = pv1.sample(3, rng=rng)
assert_array_equal(pv2.all_cells, p.all_cells[[10, 3, 0]])
def setUp(self):
sim.setup(num_processes=2, rank=1, min_delay=0.123)
self.p1 = sim.Population(4, sim.IF_cond_exp(), structure=space.Line())
self.p2 = sim.Population(5, sim.HH_cond_exp(), structure=space.Line())
assert_array_equal(self.p1._mask_local,
numpy.array([0, 1, 0, 1], dtype=bool))
assert_array_equal(self.p2._mask_local,
numpy.array([0, 1, 0, 1, 0], dtype=bool))
def test___add__three(self, sim=sim):
# adding three population views should give an Assembly
pv1 = sim.Population(6, sim.IF_curr_exp())[0:3]
pv2 = sim.Population(17, sim.IF_cond_exp())[1, 5, 14]
pv3 = sim.Population(9, sim.HH_cond_exp())[3:8]
assembly = pv1 + pv2 + pv3
self.assertIsInstance(assembly, sim.Assembly)
self.assertEqual(assembly.populations, [pv1, pv2, pv3])
def test___add__three(self, sim=sim):
# adding three populations should give an Assembly
p1 = sim.Population(6, sim.IF_curr_exp())
p2 = sim.Population(17, sim.IF_cond_exp())
p3 = sim.Population(9, sim.HH_cond_exp())
assembly = p1 + p2 + p3
self.assertIsInstance(assembly, sim.Assembly)
self.assertEqual(assembly.populations, [p1, p2, p3])
def test_position_generator(self, sim=sim):
p = sim.Population(11, sim.IF_cond_exp())
assert_array_equal(p.position_generator(0), p.positions[:, 0])
assert_array_equal(p.position_generator(10), p.positions[:, 10])
assert_array_equal(p.position_generator(-1), p.positions[:, 10])
assert_array_equal(p.position_generator(-11), p.positions[:, 0])
self.assertRaises(IndexError, p.position_generator, 11)
self.assertRaises(IndexError, p.position_generator, -12)
def test_getitem_int(self, sim=sim):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_alpha())
p3 = sim.Population(3, sim.IF_curr_exp())
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 setUp(self, sim=sim, **extra):
sim.setup(num_processes=2, rank=1, min_delay=0.123, **extra)
self.p1 = sim.Population(9, sim.IF_cond_exp(),
structure=space.Grid2D(aspect_ratio=1.0, dx=1.0, dy=1.0))
self.p2 = sim.Population(9, sim.HH_cond_exp(),
structure=space.Grid2D(aspect_ratio=1.0, dx=1.0, dy=1.0))
assert_array_equal(self.p2._mask_local, np.array(
[1, 0, 1, 0, 1, 0, 1, 0, 1], dtype=bool))
def test_set_structure(self, sim=sim):
p = sim.Population(11, sim.IF_cond_exp(), structure=space.Grid2D())
pv = p[2, 5, 7, 8]
new_struct = space.Line()
def set_struct(struct):
pv.structure = struct
self.assertRaises(AttributeError, set_struct, new_struct)
def test_set_positions(self, sim=sim):
p = sim.Population(11, sim.IF_cond_exp())
assert p._structure is not None
new_positions = numpy.random.uniform(size=(3, 11))
p.positions = new_positions
self.assertEqual(p.structure, None)
assert_array_equal(p.positions, new_positions)
new_positions[0, 0] = 99.9
self.assertNotEqual(p.positions[0, 0], 99.9)
def test_id_to_index(self, sim=sim):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_alpha())
p3 = sim.Population(3, sim.IF_curr_exp())
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__getitem__int(self, sim=sim):
# Should return the correct ID object
p = sim.Population(12, sim.IF_cond_exp())
pv = p[1, 5, 6, 8, 11]
self.assertEqual(pv[0], p[1], 42)
self.assertEqual(pv[4], p[11], 53)
self.assertRaises(IndexError, pv.__getitem__, 6)
self.assertEqual(pv[-1], p[11], 53)
def test_nearest(self, sim=sim):
p = sim.Population(13, sim.IF_cond_exp())
p.positions = numpy.arange(39).reshape((13, 3)).T
pv = p[0, 2, 5, 11]
self.assertEqual(pv.nearest((0.0, 1.0, 2.0)), pv[0])
self.assertEqual(pv.nearest((3.0, 4.0, 5.0)), pv[0])
self.assertEqual(pv.nearest((36.0, 37.0, 38.0)), pv[3])
self.assertEqual(pv.nearest((1.49, 2.49, 3.49)), pv[0])
self.assertEqual(pv.nearest((1.51, 2.51, 3.51)), pv[0])
def test_all_iterator(self, sim=sim):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_alpha())
p3 = sim.Population(3, sim.IF_curr_exp())
a = sim.Assembly(p1, p2, p3)
assert hasattr(a.all(), "next") or hasattr(a.all(), "__next__") # 2nd form is for Py3
ids = list(a.all())
self.assertEqual(ids, p1.all_cells.tolist() +
p2.all_cells.tolist() + p3.all_cells.tolist())
def test_create_with_standard_cell_simple(self, sim=sim):
p = sim.Population(11, sim.IF_cond_exp())
self.assertEqual(p.size, 11)
self.assertIsInstance(p.label, basestring)
self.assertIsInstance(p.celltype, sim.IF_cond_exp)
self.assertIsInstance(p._structure, space.Line)
self.assertEqual(p._positions, None)
self.assertEqual(p.initial_values.keys(),
p.celltype.default_initial_values.keys())
def test_position_generator(self, sim=sim):
p = sim.Population(11, sim.IF_cond_exp())
pv = p[2, 5, 7, 8]
assert_array_equal(pv.position_generator(0), p.positions[:, 2])
assert_array_equal(pv.position_generator(3), p.positions[:, 8])
assert_array_equal(pv.position_generator(-1), p.positions[:, 8])
assert_array_equal(pv.position_generator(-4), p.positions[:, 2])
self.assertRaises(IndexError, pv.position_generator, 4)
self.assertRaises(IndexError, pv.position_generator, -5)
def test_get_multiple_inhomogeneous_params_with_gather(self):
p = sim.Population(4, sim.IF_cond_exp(tau_m=12.3,
cm=[0.987, 0.988, 0.989, 0.990],
i_offset=lambda i: -0.2*i))
cm, tau_m, i_offset = p.get(('cm', 'tau_m', 'i_offset'), gather=True)
self.assertIsInstance(tau_m, float)
self.assertIsInstance(cm, numpy.ndarray)
assert_array_equal(cm, numpy.array([0.987, 0.988, 0.989, 0.990]))
self.assertEqual(tau_m, 12.3)
assert_array_almost_equal(i_offset, numpy.array([-0.0, -0.2, -0.4, -0.6]), decimal=12)
def test_get_multiple_homogeneous_params_with_gather(self, sim=sim):
p1 = sim.Population(4, sim.IF_cond_exp(
**{'tau_m': 12.3, 'tau_syn_E': 0.987, 'tau_syn_I': 0.7}))
p2 = sim.Population(4, sim.IF_curr_exp(
**{'tau_m': 12.3, 'tau_syn_E': 0.987, 'tau_syn_I': 0.7}))
a = p1 + p2
tau_syn_E, tau_m = a.get(('tau_syn_E', 'tau_m'), gather=True)
self.assertIsInstance(tau_syn_E, float)
self.assertEqual(tau_syn_E, 0.987)
self.assertAlmostEqual(tau_m, 12.3)
def test_sample(self, sim=sim):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_alpha())
p3 = sim.Population(3, sim.IF_curr_exp())
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_get_positions(self, sim=sim):
p = sim.Population(11, sim.IF_cond_exp())
pos1 = numpy.arange(33).reshape(3, 11)
p._structure = Mock()
p._structure.generate_positions = Mock(return_value=pos1)
self.assertEqual(p._positions, None)
assert_array_equal(p.positions, pos1)
pos2 = 1 + numpy.arange(33).reshape(3, 11)
p.positions = pos2
assert_array_equal(p.positions, pos2)
def setUp(self, sim=sim, **extra):
sim.setup(min_delay=0.123, **extra)
self.p1 = sim.Population(4, sim.IF_cond_exp(), structure=space.Line())
self.p2 = sim.Population(5, sim.HH_cond_exp(), structure=space.Line())
self.connection_list = [
(0, 0, 0.1, 0.1),
(3, 0, 0.2, 0.11),
(2, 3, 0.3, 0.12), # local
(2, 2, 0.4, 0.13),
(0, 1, 0.5, 0.14), # local
]
def test_get_multiple_inhomogeneous_params_with_gather(self, sim=sim):
p = sim.Population(4, sim.IF_cond_exp(tau_m=12.3,
tau_syn_E=[0.987, 0.988, 0.989, 0.990],
tau_syn_I=lambda i: 0.5 + 0.1 * i))
pv = p[0, 1, 3]
tau_syn_E, tau_m, tau_syn_I = pv.get(('tau_syn_E', 'tau_m', 'tau_syn_I'), gather=True)
self.assertIsInstance(tau_m, float)
self.assertIsInstance(tau_syn_E, numpy.ndarray)
assert_array_equal(tau_syn_E, numpy.array([0.987, 0.988, 0.990]))
self.assertAlmostEqual(tau_m, 12.3)
assert_array_almost_equal(tau_syn_I, numpy.array([0.5, 0.6, 0.8]), decimal=12)
def test_save_positions(self, sim=sim):
import os
p = sim.Population(7, sim.IF_cond_exp())
p.positions = numpy.arange(15, 36).reshape((7, 3)).T
pv = p[2, 4, 5]
output_file = Mock()
pv.save_positions(output_file)
assert_array_equal(output_file.write.call_args[0][0],
numpy.array([[0, 21, 22, 23],
[1, 27, 28, 29],
[2, 30, 31, 32]]))
self.assertEqual(output_file.write.call_args[0][1], {'population': pv.label})
def setUp(self):
sim.setup(num_processes=2, rank=1, min_delay=0.123)
self.p1 = sim.Population(4, sim.IF_cond_exp(), structure=space.Line())
self.p2 = sim.Population(5, sim.HH_cond_exp(), structure=space.Line())
assert_array_equal(self.p2._mask_local, numpy.array([0,1,0,1,0], dtype=bool))
self.connection_list = [
(0, 0, 0.1, 0.1),
(3, 0, 0.2, 0.11),
(2, 3, 0.3, 0.12), # local
(2, 2, 0.4, 0.13),
(0, 1, 0.5, 0.14), # local
]
def test_get_multiple_homogeneous_params_with_gather(self):
p = sim.Population(
4,
sim.IF_cond_exp(**{
'tau_m': 12.3,
'cm': 0.987,
'i_offset': -0.21
}))
cm, tau_m = p.get(('cm', 'tau_m'), gather=True)
self.assertIsInstance(cm, float)
self.assertEqual(cm, 0.987)
self.assertEqual(tau_m, 12.3)
def test_inject(self, sim=sim):
p1 = sim.Population(3, sim.IF_curr_alpha())
p2 = sim.Population(5, sim.IF_cond_exp())
a = p1 + p2
cs = Mock()
a.inject(cs)
meth, args, kwargs = cs.method_calls[0]
self.assertEqual(meth, "inject_into")
self.assertEqual(args, (p1,))
meth, args, kwargs = cs.method_calls[1]
self.assertEqual(meth, "inject_into")
self.assertEqual(args, (p2,))
def test_create_with_slice_selector(self, sim=sim):
p = sim.Population(11, sim.IF_cond_exp())
mask = slice(3, 9, 2)
pv = sim.PopulationView(parent=p, selector=mask)
self.assertEqual(pv.parent, p)
self.assertEqual(pv.size, 3)
self.assertEqual(pv.mask, 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.local_cells, numpy.array([p.all_cells[3]]))
#assert_array_equal(pv._mask_local, numpy.array([1,0,0], dtype=bool))
self.assertEqual(pv.celltype, p.celltype)
self.assertEqual(pv.first_id, p.all_cells[3])
self.assertEqual(pv.last_id, p.all_cells[7])
def test_getitem_slice(self, sim=sim):
p1 = sim.Population(11, sim.IF_cond_exp())
p2 = sim.Population(6, sim.IF_cond_alpha())
p3 = sim.Population(3, sim.IF_curr_exp())
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_create_with_parameters(self):
p = sim.Population(
4,
sim.IF_cond_exp(
**{
'tau_m': 12.3,
'cm': lambda i: 0.987 + 0.01 * i,
'i_offset': numpy.array([-0.21, -0.20, -0.19, -0.18])
}))
cm, tau_m, i_offset = p.get(('cm', 'tau_m', 'i_offset'), gather=True)
assert_array_equal(cm, numpy.array([0.987, 0.997, 1.007, 1.017]))
self.assertEqual(tau_m, 12.3)
assert_array_equal(i_offset, numpy.array([-0.21, -0.20, -0.19, -0.18]))
def test_set_random_distribution_parallel_safe(self):
orig_rcfg = random.get_mpi_config
random.get_mpi_config = lambda: (1, 2)
sim.simulator.state.num_processes = 2
sim.simulator.state.mpi_rank = 1
p = sim.Population(4, sim.IF_cond_exp(cm=0.987))
rng = MockRNG(start=1.21, delta=0.01, parallel_safe=True)
p.set(cm=random.RandomDistribution('uniform', rng=rng))
cm = p.get('cm', gather=False)
assert_array_equal(cm, numpy.array([1.22, 1.24]))
random.get_mpi_config = orig_rcfg
sim.simulator.state.num_processes = 1
sim.simulator.state.mpi_rank = 0
def test_get_multiple_inhomogeneous_params_with_gather(self, sim=sim):
p1 = sim.Population(4, sim.IF_cond_exp(tau_m=12.3,
tau_syn_E=[0.987, 0.988, 0.989, 0.990],
tau_syn_I=lambda i: 0.5 + 0.1 * i))
p2 = sim.Population(3, sim.EIF_cond_exp_isfa_ista(tau_m=12.3,
tau_syn_E=[0.991, 0.992, 0.993],
tau_syn_I=lambda i: 0.5 + 0.1 * (i + 4)))
a = p1 + p2
tau_syn_E, tau_m, tau_syn_I = a.get(('tau_syn_E', 'tau_m', 'tau_syn_I'), gather=True)
self.assertIsInstance(tau_m, float)
self.assertIsInstance(tau_syn_E, numpy.ndarray)
assert_array_equal(tau_syn_E, numpy.array([0.987, 0.988, 0.989, 0.990, 0.991, 0.992, 0.993]))
self.assertAlmostEqual(tau_m, 12.3)
assert_array_almost_equal(tau_syn_I, numpy.array([0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]), decimal=12)
