def test_GetTargetNodesPositions(self):
"""Interface check for finding targets."""
ldict = {'elements': ['iaf_neuron', 'iaf_psc_alpha'], 'rows': 3, 'columns':3,
'extent': [2., 2.], 'edge_wrap': True}
cdict = {'connection_type': 'divergent',
'mask': {'grid': {'rows':2, 'columns':2}}}
nest.ResetKernel()
l = topo.CreateLayer(ldict)
ian = [gid for gid in nest.GetLeaves(l)[0]
if nest.GetStatus([gid], 'model')[0] == 'iaf_neuron']
ipa = [gid for gid in nest.GetLeaves(l)[0]
if nest.GetStatus([gid], 'model')[0] == 'iaf_psc_alpha']
# connect ian -> all using static_synapse
cdict.update({'sources': {'model': 'iaf_neuron'},
'synapse_model': 'static_synapse'})
topo.ConnectLayers(l, l, cdict)
for k in ['sources', 'synapse_model']: cdict.pop(k)
# connect ipa -> ipa using stdp_synapse
cdict.update({'sources': {'model': 'iaf_psc_alpha'},
'targets': {'model': 'iaf_psc_alpha'},
'synapse_model': 'stdp_synapse'})
topo.ConnectLayers(l, l, cdict)
for k in ['sources', 'targets', 'synapse_model']: cdict.pop(k)
t = topo.GetTargetNodes(ian[:1], l)
self.assertEqual(len(t), 1)
p = topo.GetTargetPositions(ian[:1], l)
self.assertEqual(len(p), 1)
self.assertTrue(all([len(pp)==2 for pp in p[0]]))
t = topo.GetTargetNodes(ian, l)
self.assertEqual(len(t), len(ian))
self.assertTrue(all([len(g)==8 for g in t])) # 2x2 mask x 2 neurons / element -> eight targets
p = topo.GetTargetPositions(ian, l)
self.assertEqual(len(p), len(ian))
t = topo.GetTargetNodes(ian, l, tgt_model='iaf_neuron')
self.assertEqual(len(t), len(ian))
self.assertTrue(all([len(g)==4 for g in t])) # 2x2 mask -> four targets
t = topo.GetTargetNodes(ian, l, tgt_model='iaf_psc_alpha')
self.assertEqual(len(t), len(ian))
self.assertTrue(all([len(g)==4 for g in t])) # 2x2 mask -> four targets
t = topo.GetTargetNodes(ipa, l)
self.assertEqual(len(t), len(ipa))
self.assertTrue(all([len(g)==4 for g in t])) # 2x2 mask -> four targets
t = topo.GetTargetNodes(ipa, l, syn_model='static_synapse')
self.assertEqual(len(t), len(ipa))
self.assertTrue(all([len(g)==0 for g in t])) # no static syns
t = topo.GetTargetNodes(ipa, l, syn_model='stdp_synapse')
self.assertEqual(len(t), len(ipa))
self.assertTrue(all([len(g)==4 for g in t])) # 2x2 mask -> four targets
def _target_positions(self):
'''Return positions of all connected target nodes.'''
return [
tuple(pos)
for pos in topo.GetTargetPositions(self._driver, self._lt)[0]
]
def check_distance():
layer = tp.CreateLayer(l3d_specs)
tp.ConnectLayers(layer, layer, conn_dict1)
nodes = nest.GetChildren(layer)[0]
positions = tp.GetPosition(nodes)
target_positions = tp.GetTargetPositions(nodes, layer)
deltas = filter(
lambda x: x > 0.35,
[[get_delta(positions[i], pos2) for pos2 in target_positions[i]]
for i in range(len(positions))])
print len(deltas)
def plot_connections(layer_dict, conn_dict, file_name):
conn_dict['synapse_model'] = 'static_synapse'
layer = tp.CreateLayer(layer_dict)
tp.ConnectLayers(layer, layer, conn_dict)
fig = tp.PlotLayer(layer)
tp.PlotTargets(tp.FindCenterElement(layer),
layer,
fig=fig,
tgt_color='red')
pylab.savefig(file_name)
#pylab.show()
tp.DumpLayerConnections(layer, conn_dict['synapse_model'],
file_name + ".dump")
positions = tp.GetTargetPositions(layer, layer)
def plot_connections(ax, src, tgt, pops_list, red_conn_dens):
# z-positions
z0 = pops_list.index(src)
z1 = z0 + (pops_list.index(tgt) - z0)
# x,y-positions
if src == 'STIM':
xyloc = [0., 0.]
elif src == tgt:
xyloc = [0.8, 0.8]
elif src == 'EX':
xyloc = [0.8, -0.8]
elif src == 'IN':
xyloc = [-0.8, -0.8]
srcid = tp.FindNearestElement(pops[src]['layer'], xyloc, False)
srcloc = tp.GetPosition(srcid)[0]
tgtsloc = np.array(tp.GetTargetPositions(srcid, pops[tgt]['layer'])[0])
# targets do not get picked in the same order;
# they are sorted here for reproducibility
tgtsloc = tgtsloc[np.argsort(tgtsloc[:, 0])]
tgtsloc_show = tgtsloc[0:len(tgtsloc):red_conn_dens]
for tgtloc in tgtsloc_show:
ax.plot([srcloc[0], tgtloc[0]], [srcloc[1], tgtloc[1]], [z0, z1],
c=pops[src]['conn_color_light'],
linewidth=1.)
# highlight target
ax.plot(xs=[tgtloc[0]],
ys=[tgtloc[1]],
zs=[z1],
marker='o',
markeredgecolor='none',
markersize=2,
color=pops[src]['conn_color_dark'],
alpha=1.)
# to be printed on top
dots = [tgtsloc_show, z1, pops[src]['conn_color_dark'], 'none', 2]
srcdot = [srcloc, z0, 'white', 'black', 3]
return dots, srcdot
# l1_children is a work-around until NEST 3.0 is released
l1_children = nest.hl_api.GetChildren(l1)[0]
# extract position information, transpose to list of x, y and z positions
xpos, ypos, zpos = zip(*topo.GetPosition(l1_children))
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(xpos, ypos, zpos, s=15, facecolor='b', edgecolor='none')
# Gaussian connections in full volume [-0.75,0.75]**3
topo.ConnectLayers(l1, l1,
{'connection_type': 'divergent', 'allow_autapses': False,
'mask': {'volume': {'lower_left': [-0.75, -0.75, -0.75],
'upper_right': [0.75, 0.75, 0.75]}},
'kernel': {'gaussian': {'p_center': 1., 'sigma': 0.25}}})
# show connections from center element
# sender shown in red, targets in green
ctr = topo.FindCenterElement(l1)
xtgt, ytgt, ztgt = zip(*topo.GetTargetPositions(ctr, l1)[0])
xctr, yctr, zctr = topo.GetPosition(ctr)[0]
ax.scatter([xctr], [yctr], [zctr], s=40, facecolor='r', edgecolor='none')
ax.scatter(xtgt, ytgt, ztgt, s=40, facecolor='g', edgecolor='g')
tgts = topo.GetTargetNodes(ctr, l1)[0]
d = topo.Distance(ctr, tgts)
plt.figure()
plt.hist(d, 25)
# plt.show()
def plot_connections(ax, pop, pops_list, red_conn_dens, dots):
# note that xyloc of connection is set here manually
# connections from pop to tagt
for tgt in pops[pop]['tgts']:
z0 = pops_list.index(pop)
z1 = z0 + (pops_list.index(tgt) - z0)
if pop == tgt or z0 <= z1:
if pop == tgt:
xyloc = [0.8, 0.8]
else:
xyloc = [-0.8, -0.8]
srcid = tp.FindNearestElement(pops[pop]['layer'], xyloc, False)
srcloc = tp.GetPosition(srcid)[0]
tgtsloc = np.array(
tp.GetTargetPositions(srcid, pops[tgt]['layer'])[0])
# targets do not get picked in the same order;
# they are sorted here for reproducibility
tgtsloc = tgtsloc[np.argsort(tgtsloc[:, 0])]
tgtsloc_show = tgtsloc[0:len(tgtsloc):red_conn_dens]
for tgtloc in tgtsloc_show:
plt.plot([srcloc[0], tgtloc[0]], [srcloc[1], tgtloc[1]],
[z0, z1],
c=pops[pop]['conn_color'],
linewidth=1,
alpha=0.1)
# highlight target
plt.plot(tgtloc[0],
tgtloc[1],
zs=[z1],
marker='o',
markeredgecolor='none',
markersize=2,
color=pops[pop]['conn_color'],
alpha=1.)
dots.append([srcloc, z0, 'white', 'black', 3])
if pop == 'IN' and tgt == 'EX': # final
dots.append(
[tgtsloc_show, z1, pops[pop]['conn_color'], 'none', 2])
# draw connections from src to pop
for src in pops_list:
z0 = pops_list.index(src)
z1 = z0 + (pops_list.index(pop) - z0)
if src != pop and (pop in pops[src]['tgts']) and z0 > z1:
if src == 'STIM':
xyloc = [0., 0.]
else:
xyloc = [0.8, -0.8]
srcid = tp.FindNearestElement(pops[src]['layer'], xyloc, False)
srcloc = tp.GetPosition(srcid)[0]
tgtsloc = np.array(
tp.GetTargetPositions(srcid, pops[pop]['layer'])[0])
tgtsloc = tgtsloc[np.argsort(tgtsloc[:, 0])]
tgtsloc_show = tgtsloc[0:len(tgtsloc):red_conn_dens]
for tgtloc in tgtsloc_show:
plt.plot([srcloc[0], tgtloc[0]], [srcloc[1], tgtloc[1]],
[z0, z1],
c=pops[src]['conn_color'],
linewidth=1,
alpha=0.1)
plt.plot(tgtloc[0],
tgtloc[1],
zs=[z1],
marker='o',
markeredgecolor='none',
markersize=2,
color=pops[src]['conn_color'],
alpha=1.)
dots.append([srcloc, z0, 'white', 'black', 3])
if src == 'STIM': # final
dots.append(
[tgtsloc_show, z1, pops[src]['conn_color'], 'none', 2])
return dots
