def _target_positions(self): """Return positions of all connected target nodes.""" return [ tuple(pos) for pos in nest.GetTargetPositions(self._driver, self._lt)[0] ]
def test_GetTargetPositions(self): """Test that GetTargetPosition works as expected""" cdict = {'rule': 'pairwise_bernoulli', 'p': 1.} sdict = {'synapse_model': 'stdp_synapse'} nest.SetKernelStatus({'sort_connections_by_source': False}) l = nest.Create('iaf_psc_alpha', positions=nest.spatial.grid(shape=[1, 1], extent=(1., 1.), edge_wrap=False)) nest.Connect(l, l, cdict, sdict) # Simple test with one node ID in the layer, should be placed in the origin p = nest.GetTargetPositions(l, l) self.assertTrue(p, [[(0.0, 0.0)]]) # Test positions on a grid, we can calculate what they should be nest.ResetKernel() nest.SetKernelStatus({'sort_connections_by_source': False}) x_extent = 1. y_extent = 1. shape = [3, 3] l = nest.Create('iaf_psc_alpha', positions=nest.spatial.grid( shape=shape, extent=[x_extent, y_extent], edge_wrap=False)) nest.Connect(l, l, cdict, sdict) p = nest.GetTargetPositions(l[:1], l) self.assertEqual(len(p), 1) self.assertTrue(all([len(pp) == 2 for pp in p[0]])) p = nest.GetTargetPositions(l, l) self.assertEqual(len(p), len(l)) dx = x_extent / shape[0] dy = y_extent / shape[1] x = [-dx, -dx, -dx, 0.0, 0.0, 0.0, dx, dx, dx] y = [dy, 0.0, -dy, dy, 0.0, -dy, dy, 0.0, -dy] pos = [(x[i], y[i]) for i in range(len(x))] for indx in range(len(pos)): # 4 chosen randomly, they should all be the same, as all node IDs in # the layer are connected self.assertAlmostEqual(p[4][indx][0], pos[indx][0]) self.assertAlmostEqual(p[4][indx][1], pos[indx][1]) # Test that we get correct positions when we send in a positions array # when creating the layer nest.ResetKernel() nest.SetKernelStatus({'sort_connections_by_source': False}) positions = [(np.random.uniform(-0.5, 0.5), np.random.uniform(-0.5, 0.5)) for _ in range(50)] l = nest.Create('iaf_psc_alpha', positions=nest.spatial.free(positions, edge_wrap=False)) nest.Connect(l, l, cdict, sdict) p = nest.GetTargetPositions(l[:1], l) for indx in range(len(p[0])): self.assertAlmostEqual(positions[indx][0], p[0][indx][0]) self.assertAlmostEqual(positions[indx][1], p[0][indx][1])
# extract position information, transpose to list of x, y and z positions xpos, ypos, zpos = zip(*nest.GetPosition(l1)) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(xpos, ypos, zpos, s=15, facecolor='b') # Gaussian connections in full box volume [-0.75,0.75]**3 nest.Connect(l1, l1, {'rule': 'pairwise_bernoulli', 'p': nest.spatial_distributions.gaussian(nest.spatial.distance, std=0.25), 'allow_autapses': False, 'mask': {'box': {'lower_left': [-0.75, -0.75, -0.75], 'upper_right': [0.75, 0.75, 0.75]}}}) # show connections from center element # sender shown in red, targets in green ctr = nest.FindCenterElement(l1) xtgt, ytgt, ztgt = zip(*nest.GetTargetPositions(ctr, l1)[0]) xctr, yctr, zctr = nest.GetPosition(ctr) ax.scatter([xctr], [yctr], [zctr], s=40, facecolor='r') ax.scatter(xtgt, ytgt, ztgt, s=40, facecolor='g', edgecolor='g') tgts = nest.GetTargetNodes(ctr, l1)[0] distances = nest.Distance(ctr, l1) tgt_distances = [d for i, d in enumerate(distances) if i + 1 in tgts] plt.figure() plt.hist(tgt_distances, 25) plt.show()
}) plt.clf() ###################################################### # plot targets of neurons in different grid locations # obtain node id for center: pick first node of composite ctr_index = 30 * 15 + 15 ctr_id = a_pyr[ctr_index:ctr_index + 1] # get all projection targets of center neuron conn = nest.GetConnections(ctr_id) tgts = conn.get('target') tpyr = nest.GetTargetPositions(ctr_id, b_pyr)[0] tin = nest.GetTargetPositions(ctr_id, b_in)[0] tpyr_x = np.array([x for x, y in tpyr]) tpyr_y = np.array([y for x, y in tpyr]) tin_x = np.array([x for x, y in tin]) tin_y = np.array([y for x, y in tin]) # scatter-plot plt.scatter(tpyr_x - 0.02, tpyr_y - 0.02, 20, 'b', zorder=10) plt.scatter(tin_x + 0.02, tin_y + 0.02, 20, 'r', zorder=10) # mark locations with background grey circle plt.plot(tpyr_x, tpyr_y, 'o',
'lower_left': [-0.2, -0.5], 'upper_right': [0.2, 0.5] } } }, syn_spec={'weight': nest.random.uniform(0.5, 2.)}) plt.clf() ############################################################################ # plot sources of neurons in different grid locations for tgt_index in [30 * 15 + 15, 0]: # obtain node id for center tgt = a[tgt_index:tgt_index + 1] # obtain list of outgoing connections for ctr spos = nest.GetTargetPositions(tgt, b)[0] spos_x = np.array([x for x, y in spos]) spos_y = np.array([y for x, y in spos]) print(spos_x) print(spos_y) # scatter-plot plt.scatter(spos_x, spos_y, 20, zorder=10) # mark sender position with transparent red circle ctrpos = np.array(nest.GetPosition(tgt)) plt.gca().add_patch( plt.Circle(ctrpos, radius=0.1, zorder=99, fc='r', alpha=0.4, ec='none'))