def connect(self):
"""
Connect all nodes in the model.
"""
if self.connected: return
if not self.built:
self.build()
nest.CopyModel("static_synapse_hom_wd", "excitatory", {
"weight": self.J_E,
"delay": self.delay
})
nest.CopyModel("static_synapse_hom_wd", "inhibitory", {
"weight": self.J_I,
"delay": self.delay
})
nest.RandomConvergentConnect(self.nodes_E,
self.nodes,
self.C_E,
model="excitatory")
nest.RandomConvergentConnect(self.nodes_I,
self.nodes,
self.C_I,
model="inhibitory")
nest.DivergentConnect(self.noise, self.nodes, model="excitatory")
nest.ConvergentConnect(self.nodes_E[:self.N_rec], self.spikes_E)
nest.ConvergentConnect(self.nodes_I[:self.N_rec], self.spikes_I)
self.connected = True
def test_ConvergentDivergentConnectOptions(self):
"""Convergent/DivergentConnect with non-standard options and
ensure that the option settings are properly restored before
returning."""
nest.ResetKernel()
copts = nest.sli_func('GetOptions',
'/RandomConvergentConnect',
litconv=True)
dopts = nest.sli_func('GetOptions',
'/RandomDivergentConnect',
litconv=True)
ncopts = dict(
(k, not v) for k, v in copts.items() if k != 'DefaultOptions')
ndopts = dict(
(k, not v) for k, v in dopts.items() if k != 'DefaultOptions')
n = nest.Create('iaf_neuron', 3)
nest.RandomConvergentConnect(n, n, 1, options=ncopts)
nest.RandomDivergentConnect(n, n, 1, options=ndopts)
opts = nest.sli_func('GetOptions',
'/RandomConvergentConnect',
litconv=True)
self.assertEqual(copts, opts)
opts = nest.sli_func('GetOptions',
'/RandomDivergentConnect',
litconv=True)
self.assertEqual(dopts, opts)
def connect(d, chunks, type_conn):
# chunks = 1
n = 500
if type_conn == 'Connect':
args = get_pre_post(n, d[0], d[0])
print 'Connecting'
print len(args[0])
m = len(args[0])
step = m / chunks
for i in range(chunks):
if i < chunks - 1:
pre = args[0][i * step:(i + 1) * step]
post = args[0][i * step:(i + 1) * step]
else:
pre = args[0][i * step:]
post = args[0][i * step:]
# nest.Connect(pre, post, model='static')
my_nest.Connect_speed(pre, post, model='static')
# nest_speed.Connect(pre, post, model='static')
del pre
del post
if type_conn == 'RandomConvergentConnect':
nest.RandomConvergentConnect(d[0], d[0], n)
n
def test_ConnectOptions(self):
"""ConnectOptions"""
nest.ResetKernel()
copts = nest.sli_func('GetOptions',
'/RandomConvergentConnect',
litconv=True)
dopts = nest.sli_func('GetOptions',
'/RandomDivergentConnect',
litconv=True)
ncopts = dict([(k, not v) for k, v in copts.iteritems()
if k != 'DefaultOptions'])
ndopts = dict([(k, not v) for k, v in dopts.iteritems()
if k != 'DefaultOptions'])
n = nest.Create('iaf_neuron', 3)
nest.RandomConvergentConnect(n, n, 1, options=ncopts)
nest.RandomDivergentConnect(n, n, 1, options=ndopts)
self.assertEqual(
copts,
nest.sli_func('GetOptions',
'/RandomConvergentConnect',
litconv=True))
self.assertEqual(
dopts,
nest.sli_func('GetOptions',
'/RandomDivergentConnect',
litconv=True))
def _connect(self):
'''Connect populations.'''
if self._fan == 'in':
nest.RandomConvergentConnect(self._source_pop,
self._target_pop,
self._C,
options={'allow_multapses': True})
elif self._fan == 'out':
nest.RandomDivergentConnect(self._source_pop,
self._target_pop,
self._C,
options={'allow_multapses': True})
def connect(d, chunks, type_conn):
n = 500
if type_conn == 'Connect':
args = get_pre_post(n, d[0], d[0])
m = len(args[0])
step = m / chunks
for i in range(chunks):
if i < chunks - 1:
pre = args[0][i * step:(i + 1) * step]
post = args[0][i * step:(i + 1) * step]
else:
pre = args[0][i * step:]
post = args[0][i * step:]
nest.Connect(pre, post, model='static')
del pre
del post
if type_conn == 'RandomConvergentConnect':
nest.RandomConvergentConnect(d[0], d[0], n)
if type_conn == 'Connect_DC':
my_nest.RandomConvergentConnect(d[0], d[0], n)
nest.ConvergentConnect(range(1, N_rec + 1), espikes, model="excitatory")
nest.ConvergentConnect(range(NE + 1, NE + 1 + N_rec),
ispikes,
model="excitatory")
print "Connecting network."
# We now iterate over all neuron IDs, and connect the neuron to
# the sources from our array. The first loop connects the excitatory neurons
# and the second loop the inhibitory neurons.
print "Excitatory connections"
nest.RandomConvergentConnect(nodes_ex,
nodes_ex + nodes_in,
CE,
model="excitatory")
print "Inhibitory connections"
nest.RandomConvergentConnect(nodes_in,
nodes_ex + nodes_in,
CI,
model="inhibitory")
endbuild = time.time()
print "Simulating."
nest.Simulate(simtime)
{"C_m": 1.0,
"tau_m": tau_m,
"t_ref": 2.0,
"E_L": 0.0,
"V_th": V_th,
"V_reset": 10.0})
nodes = nest.Create("iaf_psc_delta",N_neurons)
nodes_E= nodes[:N_E]
nodes_I= nodes[N_E:]
nest.CopyModel("static_synapse_hom_wd",
"excitatory",
{"weight":J_E,
"delay":delay})
nest.RandomConvergentConnect(nodes_E, nodes, C_E,model="excitatory")
nest.CopyModel("static_synapse_hom_wd",
"inhibitory",
{"weight":J_I,
"delay":delay})
nest.RandomConvergentConnect(nodes_I, nodes, C_I,model="inhibitory")
noise=nest.Create("poisson_generator",1,{"rate": p_rate})
nest.DivergentConnect(noise,nodes,model="excitatory")
spikes=nest.Create("spike_detector",2,
[{"label": "brunel-py-ex"},
{"label": "brunel-py-in"}])
spikes_E=spikes[:1]
spikes_I=spikes[1:]
'C_m': 1.,
'tau_m': tau_m,
't_ref': 2.,
'E_L': 0.,
'V_th': V_th,
'V_reset': 10.
})
nodes = nest.Create('iaf_psc_delta', N_neurons)
nodes_E = nodes[:N_E]
nodes_I = nodes[N_E:]
nest.CopyModel('static_synapse_hom_w', 'excitory', {
'weight': J_E,
'delay': delay
})
nest.RandomConvergentConnect(nodes_E, nodes, C_E, model='excitory')
nest.CopyModel('static_synapse_hom_w', 'inhibitory', {
'weight': J_I,
'delay': delay
})
nest.RandomConvergentConnect(nodes_I, nodes, C_I, model='inhibitory')
noise = nest.Create('poisson_generator', 1, {'rate': p_rate})
nest.DivergentConnect(noise, nodes, model='excitory')
spikes = nest.Create('spike_detector', 2, [{
'label': 'brunel-py-ex'
}, {
'label': 'brunel-py-in'
}])
spikes_E = spikes[:1]
spikes_I = spikes[1:]
nodes = nest.Create("iaf_psc_delta", N_neurons)
nodes_E = nodes[:N_E]
nodes_I = nodes[N_E:]
# randomize membrane potential
node_info = nest.GetStatus(nodes, ['global_id', 'vp', 'local'])
local_nodes = [(gid, vp) for gid, vp, islocal in node_info if islocal]
for gid, vp in local_nodes:
nest.SetStatus([gid], {'V_m': pyrngs[vp].uniform(-V_th, V_th)})
nest.CopyModel("static_synapse", "excitatory")
for tgt_gid, tgt_vp in local_nodes:
weights = pyrngs[tgt_vp].uniform(0.5 * J_E, 1.5 * J_E, C_E)
nest.RandomConvergentConnect(nodes_E, [tgt_gid],
C_E,
weight=list(weights),
delay=delay,
model="excitatory")
nest.CopyModel("static_synapse_hom_wd", "inhibitory", {
"weight": J_I,
"delay": delay
})
nest.RandomConvergentConnect(nodes_I, nodes, C_I, model="inhibitory")
noise = nest.Create("poisson_generator", 1, {"rate": p_rate})
nest.CopyModel("static_synapse_hom_wd", "excitatory-input", {
"weight": J_E,
"delay": delay
})
'stop': POISSON_START
})
IN_on = nest.Create('poisson_generator', 1, {
'rate': input_on_rate,
'start': POISSON_START,
'stop': POISSON_START + POISSON_DURATION
})
IN_on_post = nest.Create('poisson_generator', 1, {
'rate': input_off_rate,
'start': POISSON_START + POISSON_DURATION,
'stop': DURATION + 0.
})
## Wire It Up!
nest.RandomConvergentConnect(nodes_E, nodes_I, C_E, model='exc_E_to_I')
nest.RandomConvergentConnect(nodes_I, nodes_E, C_I, model='inh')
nest.DivergentConnect(IN_off, nodes_E_OFF, model='exc_IN_to_E')
nest.DivergentConnect(IN_on_pre, nodes_I, model='exc_IN_to_I')
nest.DivergentConnect(IN_on, nodes_I, model='exc_IN_to_I')
nest.DivergentConnect(IN_on_post, nodes_I, model='exc_IN_to_I')
nest.DivergentConnect(IN_on_pre, nodes_E_ON, model='exc_IN_to_E')
nest.DivergentConnect(IN_on, nodes_E_ON, model='exc_IN_to_E')
nest.DivergentConnect(IN_on_post, nodes_E_ON, model='exc_IN_to_E')
# Connect Cliques
cliques = []
