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 = []