def make_vogels(N): NE = N // 5 * 4 NI = N // 5 * 1 N = NE + NI Wex = 0.4 * 16000000 / N / N Win = 5.1 * 16000000 / N / N neuron = ngpu.Create("iaf_psc_exp_g", N, 2) E = neuron[0:NE] # inhibitory neurons I = neuron[NE:N] ngpu.SetStatus(neuron, {"V_m_rel": -60, "V_reset_rel": -60, "Theta_rel": -50, "t_ref": 5, "G_ex": 0, "G_in": 0}) ngpu.Connect(E, E, {"rule": "fixed_total_number", "total_num": NE * NE // 50}, {"weight": Wex, "delay": 0.8, "receptor":0}) ngpu.Connect(E, I, {"rule": "fixed_total_number", "total_num": NE * NI // 50}, {"weight": Wex, "delay": 0.8, "receptor":0}) ngpu.Connect(I, E, {"rule": "fixed_total_number", "total_num": NI * NE // 50}, {"weight": Win, "delay": 0.8, "receptor":1}) ngpu.Connect(I, I, {"rule": "fixed_total_number", "total_num": NI * NI // 50}, {"weight": Win, "delay": 0.8, "receptor":1})
def make_synth(N, pconnect, pfire, delay): pg = ngpu.Create("poisson_generator") ngpu.SetStatus(pg, "rate", 10000 * pfire) neuron = ngpu.Create("iaf_psc_exp", N, 2) ngpu.SetStatus(neuron, {"V_m_rel": 0, "V_reset_rel": 0, "Theta_rel": 20, "t_ref": 0}) ngpu.Connect(pg, neuron, {"rule": "all_to_all"}, {"weight": 20, "delay": 0.1, "receptor":0}) ngpu.Connect(neuron, neuron, {"rule": "fixed_total_number", "total_num": int(N * N * pconnect)}, {"weight": 0, "delay": 0.1 * delay, "receptor":0})
def __connect_thalamic_stim_input(self): """ Connects the thalamic input to the neuronal populations.""" if self.Rank == 0: print('Connecting thalamic input.') # connect Poisson input to thalamic population ngpu.Connect(self.poisson_th, self.thalamic_population) # connect thalamic population to neuronal populations for i, target_pop in enumerate(self.pops): conn_dict_th = { 'rule': 'fixed_total_number', 'N': self.num_th_synapses[i] } w_mean = self.weight_th, w_std = self.weight_th * self.net_dict['weight_rel_std'] w_min = 0.0, w_max = w_mean + 3.0 * w_std d_mean = self.stim_dict['delay_th_mean'] d_std = (self.stim_dict['delay_th_mean'] * self.stim_dict['delay_th_rel_std']) d_min = self.sim_resolution d_max = d_mean + 3.0 * d_std syn_dict_th = { 'weight': { "distribution": "normal_clipped", "mu": w_mean, "low": w_min, "high": w_max, "sigma": w_std }, 'delay': { "distribution": "normal_clipped", "mu": d_mean, "low": d_min, "high": d_max, "sigma": d_std } } ngpu.Connect(self.thalamic_population, target_pop, conn_spec=conn_dict_th, syn_spec=syn_dict_th)
def __connect_neuronal_populations(self): """ Creates the recurrent connections between neuronal populations. """ if self.Rank == 0: print('Connecting neuronal populations recurrently.') for i, target_pop in enumerate(self.pops): for j, source_pop in enumerate(self.pops): if self.num_synapses[i][j] >= 0.: conn_dict_rec = { 'rule': 'fixed_total_number', 'total_num': self.num_synapses[i][j] } w_mean = self.weight_matrix_mean[i][j] w_std = abs(self.weight_matrix_mean[i][j] * self.net_dict['weight_rel_std']) if w_mean < 0: w_min = w_mean - 3.0 * w_std w_max = 0.0 # i_receptor = 1 else: w_min = 0.0 w_max = w_mean + 3.0 * w_std # i_receptor = 0 d_mean = self.net_dict['delay_matrix_mean'][i][j] d_std = (self.net_dict['delay_matrix_mean'][i][j] * self.net_dict['delay_rel_std']) d_min = self.sim_resolution d_max = d_mean + 3.0 * d_std syn_dict = { 'weight': { 'distribution': 'normal_clipped', 'mu': w_mean, 'low': w_min, 'high': w_max, 'sigma': w_std }, 'delay': { 'distribution': 'normal_clipped', 'mu': d_mean, 'low': d_min, 'high': d_max, 'sigma': d_std } } #'receptor':i_receptor} ngpu.Connect(source_pop, target_pop, conn_dict_rec, syn_dict)
def __connect_poisson_bg_input(self): """ Connects the Poisson generators to the microcircuit.""" if self.Rank == 0: print('Connecting Poisson generators for background input.') for i, target_pop in enumerate(self.pops): conn_dict_poisson = {'rule': 'all_to_all'} syn_dict_poisson = { 'weight': self.weight_ext, 'delay': self.net_dict['delay_poisson'] } ngpu.Connect([self.poisson_bg_input[i]], target_pop, conn_dict_poisson, syn_dict_poisson)
def make_brunel(N): NP = N // 10 * 5 NE = N // 10 * 4 NI = N // 10 * 1 N = NP + NE + NI Wex = 0.1 * 20000 / N Win = -0.5 * 20000 / N pg = ngpu.Create("poisson_generator") ngpu.SetStatus(pg, "rate", 20) neuron = ngpu.Create("iaf_psc_exp", N, 2) P = neuron[0:NP] # excitatory neurons E = neuron[NP:NP+NE] # inhibitory neurons I = neuron[NP+NE:N] ngpu.SetStatus(P, {"V_m_rel": 0, "V_reset_rel": 0, "Theta_rel": 20, "t_ref": 0}) ngpu.SetStatus(E, {"V_m_rel": 0, "V_reset_rel": 0, "Theta_rel": 20, "t_ref": 2}) ngpu.SetStatus(I, {"V_m_rel": 0, "V_reset_rel": 0, "Theta_rel": 20, "t_ref": 2}) ngpu.Connect(pg, P, {"rule": "all_to_all"}, {"weight": 20, "delay": 0.1, "receptor":0}) ngpu.Connect(P, E, {"rule": "fixed_total_number", "total_num": NP * NE // 10}, {"weight": Wex, "delay": 1.5, "receptor":0}) ngpu.Connect(P, I, {"rule": "fixed_total_number", "total_num": NP * NI // 10}, {"weight": Wex, "delay": 1.5, "receptor":0}) ngpu.Connect(E, E, {"rule": "fixed_total_number", "total_num": NE * NE // 10}, {"weight": Wex, "delay": 1.5, "receptor":0}) ngpu.Connect(E, I, {"rule": "fixed_total_number", "total_num": NE * NI // 10}, {"weight": Wex, "delay": 1.5, "receptor":0}) ngpu.Connect(I, E, {"rule": "fixed_total_number", "total_num": NI * NE // 10}, {"weight": Win, "delay": 1.5, "receptor":1}) ngpu.Connect(I, I, {"rule": "fixed_total_number", "total_num": NI * NI // 10}, {"weight": Win, "delay": 1.5, "receptor":1})
even_to_odd_weight.append(100.0 * (2.0 * N * ise + ito)) odd_to_even_delay.append(2.0 * N * iso + ite) odd_to_even_weight.append(100.0 * (2.0 * N * iso + ite)) conn_dict = {"rule": "all_to_all"} even_to_odd_syn_dict = { "weight_array": even_to_odd_weight, "delay_array": even_to_odd_delay } odd_to_even_syn_dict = { "weight_array": odd_to_even_weight, "delay_array": odd_to_even_delay } ngpu.Connect(neuron_even, neuron_odd, conn_dict, even_to_odd_syn_dict) ngpu.Connect(neuron_odd, neuron_even, conn_dict, odd_to_even_syn_dict) # Even to all conn_id = ngpu.GetConnections(neuron_even, neuron) conn_status_dict = ngpu.GetStatus(conn_id) print("########################################") print("Even to all") for i in range(len(conn_status_dict)): print(conn_status_dict[i]) print() print() # Even to all weight, delay conn_status_dict = ngpu.GetStatus(conn_id, ["weight", "delay"]) print("########################################")
import neurongpu as ngpu neuron = ngpu.Create("aeif_cond_beta") poiss_gen = ngpu.Create("poisson_generator"); ngpu.SetStatus(poiss_gen, "rate", 12000.0) conn_dict={"rule": "one_to_one"} syn_dict={"weight": 0.05, "delay": 2.0, "receptor":0} ngpu.Connect(poiss_gen, neuron, conn_dict, syn_dict) record = ngpu.CreateRecord("", ["V_m"], [neuron[0]], [0]) ngpu.Simulate() data_list = ngpu.GetRecordData(record) t=[row[0] for row in data_list] V_m=[row[1] for row in data_list] import matplotlib.pyplot as plt plt.figure(1) plt.plot(t, V_m) plt.draw() plt.pause(1) ngpu.waitenter("<Hit Enter To Close>") plt.close()
neuron_post = ngpu.Create("parrot_neuron", N) #spike generator sg = ngpu.Create("spike_generator") # spike generator produces n_spikes spikes with time interval Dt_spike spike_times = [] for i in range(n_spikes): spike_times.append(Dt_spike * (i + 1)) ngpu.SetStatus(sg, {"spike_times": spike_times}) #connect spike generator to parrot neurons sg_conn_dict = {"rule": "all_to_all"} syn_dict_sg_pre = {"weight": 1.0, "delay": sg_delay_m - Dt_offset / 2.0} ngpu.Connect(sg, neuron_pre, sg_conn_dict, syn_dict_sg_pre) syn_dict_sg_post = {"weight": 1.0, "delay": sg_delay_m + Dt_offset / 2.0} ngpu.Connect(sg, neuron_post, sg_conn_dict, syn_dict_sg_post) syn_group = ngpu.CreateSynGroup \ ("stdp", {"tau_plus":tau_plus, "tau_minus":tau_minus, \ "lambda":lambd, "alpha":alpha, "mu_plus":mu_plus, \ "mu_minus":mu_minus, "Wmax":Wmax}) conn_dict = {"rule": "one_to_one"} for j in range(N): delay_post = 0.1 + round(Dt_max * j / N, 1) ngpu.SetStatus([neuron_post[j]], {"den_delay": delay_post}) for i in range(N): delay_pre = 0.1 + round(Dt_max * i / N, 1) syn_dict_stdp={"weight":weight_stdp, "delay":delay_pre, \ "synapse_group":syn_group, "receptor":1}
"E_rev": E_rev, "tau_decay": tau_decay, "tau_rise": tau_rise }) neuron_image = ngpu_nest.CreateNeuronImage(nest_neuron, 2) poiss_gen = ngpu.Create("poisson_generator") ngpu.SetStatus(poiss_gen, "rate", 12000.0) parrot = ngpu.Create("parrot_neuron") ngpu.SetStatus(parrot, {'hold_spike_height': 1}) conn_dict = {"rule": "one_to_one"} syn_dict_pg = {"weight": 1.0, "delay": 1.0} ngpu.Connect(poiss_gen, parrot, conn_dict, syn_dict_pg) syn_dict = {"weight": 0.05, "delay": 2.0, "receptor": 0} syn_dict1 = {"weight": 0.05, "delay": 2.0, "receptor": 1} ngpu.Connect(parrot, ngpu_neuron, conn_dict, syn_dict) ngpu.Connect(parrot, neuron_image, conn_dict, syn_dict1) record = ngpu.CreateRecord("", ["V_m"], [ngpu_neuron[0]], [0]) voltmeter = nest.Create('voltmeter') nest.Connect(voltmeter, nest_neuron) nest.Simulate(1000) data_list = ngpu.GetRecordData(record) t = [row[0] for row in data_list] Vm = [row[1] for row in data_list]
import neurongpu as ngpu neuron = ngpu.Create("aeif_cond_beta", 2) neuron0 = neuron[0:0] neuron1 = neuron[1:1] ngpu.SetStatus(neuron0, {"I_e": 1000.0}) parrot = ngpu.Create("parrot_neuron", 2) parrot0 = parrot[0:0] parrot1 = parrot[1:1] conn_dict = {"rule": "one_to_one"} syn_dict0 = {"weight": 0.5, "delay": 1.0, "receptor": 0} ngpu.Connect(neuron0, parrot0, conn_dict, syn_dict0) syn_dict1 = {"weight": 0.1, "delay": 1.0, "receptor": 0} ngpu.Connect(parrot0, neuron1, conn_dict, syn_dict1) ngpu.Connect(parrot0, parrot1, conn_dict, syn_dict1) neuron0_record = ngpu.CreateRecord("", ["V_m"], [neuron0[0]], [0]) parrot0_record = ngpu.CreateRecord("", ["V", "spike"], [parrot0[0], parrot0[0]], [0, 0]) neuron1_record = ngpu.CreateRecord("", ["g1"], [neuron1[0]], [0]) parrot1_record = ngpu.CreateRecord("", ["V", "spike"], [parrot1[0], parrot1[0]], [0, 0]) ngpu.Simulate() neuron0_data_list = ngpu.GetRecordData(neuron0_record) t_neuron0 = [row[0] for row in neuron0_data_list] V_m = [row[1] for row in neuron0_data_list]
import neurongpu as ngpu import nest import ngpu_nest nest_neuron = nest.Create("aeif_cond_alpha", 5) node_image = ngpu_nest.CreateNeuronImage(nest_neuron, 1) nest.SetStatus(nest_neuron, {"I_e": 800.0}) spike_det = ngpu.Create("spike_detector", 5) conn_dict = {"rule": "one_to_one"} syn_dict = {"weight": 1.0, "delay": 1.0} ngpu.Connect(node_image, spike_det, conn_dict, syn_dict) record_n = ngpu.CreateRecord("", ["spike"], [node_image[0]], [0]) record_sd = ngpu.CreateRecord("", ["spike_height"], [spike_det[0]], [0]) multimeter = nest.Create("multimeter") multimeter.set(record_from=["V_m"]) nest.Connect(multimeter, nest_neuron) nest_neuron2 = nest.Create("aeif_cond_alpha", 1) node_image2 = ngpu_nest.CreateNeuronImage(nest_neuron2, 1) spike = ngpu.Create("spike_generator") spike_times = [50.0, 100.0, 400.0, 600.0] n_spikes = 4 # set spike times and heights ngpu.SetStatus(spike, {"spike_times": spike_times})
ngpu.ActivateRecSpikeTimes(neuron_pre, 20) #spike generators sg_post = ngpu.Create("spike_generator") sg_pre = ngpu.Create("spike_generator") # spike times spike_times_post = [1.0] spike_times_pre = [1.0] ngpu.SetStatus(sg_post, {"spike_times": spike_times_post}) ngpu.SetStatus(sg_pre, {"spike_times": spike_times_pre}) # connect spike generators to neurons syn_dict = {"weight": 1.0, "delay": 1.0} conn_dict = {"rule": "one_to_one"} ngpu.Connect(sg_post, neuron_post, conn_dict, syn_dict) ngpu.Connect(sg_pre, neuron_pre, conn_dict, syn_dict) # STDP connection parameters tau_plus = 20.0 tau_minus = 20.0 lambd = 0.01 alpha = 1.0 mu_plus = 1.0 mu_minus = 1.0 Wmax = 10.0 den_delay = 1.0 weight_stdp = 1.0 delay = 3.0
}) ngpu.SetStatus(neuron, {"h_min_rel": 0.1, "h0_rel": 0.1}) delay = 2.0 # Excitatory connections # connect excitatory neurons to port 0 of all neurons # normally distributed delays, weight Wex and CE connections per neuron exc_conn_dict = {"rule": "fixed_indegree", "indegree": CE} exc_syn_dict = { "weight": Wex, "delay": delay, "receptor": 0, "synapse_group": syn_group_ex } ngpu.Connect(exc_neuron, neuron, exc_conn_dict, exc_syn_dict) # Inhibitory connections # connect inhibitory neurons to port 1 of all neurons # normally distributed delays, weight Win and CI connections per neuron inh_conn_dict = {"rule": "fixed_indegree", "indegree": CI} inh_syn_dict = { "weight": Win, "delay": delay, "receptor": 1, "synapse_group": syn_group_in } ngpu.Connect(inh_neuron, neuron, inh_conn_dict, inh_syn_dict) #connect poisson generator to port 0 of all neurons
# Excitatory connections # connect excitatory neurons to port 0 of all neurons # normally distributed delays, weight Wex and CE connections per neuron exc_conn_dict = {"rule": "fixed_indegree", "indegree": CE} exc_syn_dict = { "weight": Wex, "delay": { "distribution": "normal_clipped", "mu": mean_delay, "low": min_delay, "high": mean_delay + 3 * std_delay, "sigma": std_delay }, "receptor": 0 } ngpu.Connect(exc_neuron, neuron, exc_conn_dict, exc_syn_dict) exc_syn_dict1 = { "weight": Wex, "delay": { "distribution": "normal_clipped", "mu": mean_delay, "low": min_delay, "high": mean_delay + 3 * std_delay, "sigma": std_delay }, "receptor": 1 } ngpu.Connect(exc_neuron, neuron_image, exc_conn_dict, exc_syn_dict1)
pg = ngpu.Create("poisson_generator") ngpu.SetStatus(pg, "rate", poiss_rate) # Create n_neurons neurons neuron = ngpu.Create("aeif_cond_beta", n_neurons) ngpu.ActivateSpikeCount(neuron) ngpu.ActivateRecSpikeTimes(neuron, 500) # Create n_neurons spike detectors sd = ngpu.Create("spike_detector", n_neurons) #connect poisson generator to all neurons pg_conn_dict = {"rule": "all_to_all"} pg_syn_dict = {"weight": poiss_weight, "delay": poiss_delay} ngpu.Connect(pg, neuron, pg_conn_dict, pg_syn_dict) #connect neurons to spike detectors sd_conn_dict = {"rule": "one_to_one"} sd_syn_dict = {"weight": 1.0, "delay": 0.1} ngpu.Connect(neuron, sd, sd_conn_dict, sd_syn_dict) # create multimeter record of spikes i_node_list = sd.ToList() i_receptor_list = [0] * n_neurons var_name_list = ["spike_height"] * n_neurons record = ngpu.CreateRecord("", var_name_list, i_node_list, \ i_receptor_list)
spike_times = [50.0] n_spikes = 1 # set spike times and height ngpu.SetStatus(sg, {"spike_times": spike_times}) delay0 = 1.0 delay1 = delay0 + time_diff weight_sg = 17.9 # to make it spike immediately and only once weight_stdp = Wmax / 2 conn_dict = {"rule": "one_to_one"} conn_dict_full = {"rule": "all_to_all"} syn_dict0 = {"weight": weight_sg, "delay": delay0} syn_dict1 = {"weight": weight_sg, "delay": delay1} ngpu.Connect(sg, neuron0, conn_dict, syn_dict0) ngpu.Connect(sg, neuron1, conn_dict_full, syn_dict1) syn_dict_stdp={"weight":weight_stdp, "delay_array":delay_stdp_list, \ "synapse_group":syn_group} ngpu.Connect(neuron0, neuron1, conn_dict_full, syn_dict_stdp) ngpu.Simulate(1000.0) #conn_id = ngpu.GetConnections(neuron0, neuron1) dt = dt_list #w = ngpu.GetStatus(conn_id, "weight") expect_w = []
nest.SetStatus(nest_neuron, { "E_rev": E_rev, "tau_decay": tau_decay, "tau_rise": tau_rise }) neuron_image = ngpu_nest.CreateNeuronImage(nest_neuron, 2) poiss_gen = ngpu.Create("poisson_generator") ngpu.SetStatus(poiss_gen, "rate", 10000.0) conn_dict = {"rule": "all_to_all"} syn_dict = {"weight": 0.05, "delay": 1.0, "receptor": 0} syn_dict1 = {"weight": 0.05, "delay": 1.0, "receptor": 1} ngpu.Connect(poiss_gen, ngpu_neuron, conn_dict, syn_dict) ngpu.Connect(poiss_gen, neuron_image, conn_dict, syn_dict1) neur_conn_dict = {"rule": "fixed_indegree", "indegree": indegree} neur_syn_dict = {"weight": 0.005, "delay": 1.0, "receptor": 0} neur_syn_dict1 = {"weight": 0.005, "delay": 1.0, "receptor": 1} ngpu.Connect(ngpu_neuron, ngpu_neuron, neur_conn_dict, neur_syn_dict) ngpu.Connect(ngpu_neuron, neuron_image, neur_conn_dict, neur_syn_dict1) record = ngpu.CreateRecord("", ["V_m"], [ngpu_neuron[0]], [0]) voltmeter = nest.Create('voltmeter') nest.Connect(voltmeter, nest_neuron[0]) nest.Simulate(1000)
spike_height = [1.0] n_spikes = 1 time_diff = 400.0 # set spike times and height ngpu.SetStatus(sg, {"spike_times": spike_time, "spike_heights": spike_height}) delay0 = 1.0 delay1 = delay0 + time_diff weight_sg = 17.9 # to make it spike immediately and only once weight_stdp = Wmax / 2 conn_dict = {"rule": "one_to_one"} syn_dict0 = {"weight": weight_sg, "delay": delay0} syn_dict1 = {"weight": weight_sg, "delay": delay1} ngpu.Connect(sg, neuron0, conn_dict, syn_dict0) ngpu.Connect(sg, neuron1, conn_dict, syn_dict1) for i in range(N): delay_stdp = time_diff - dt_list[i] syn_dict_stdp={"weight":weight_stdp, "delay":delay_stdp, \ "synapse_group":syn_group} ngpu.Connect([neuron0[i]], [neuron1[i]], conn_dict, syn_dict_stdp) ngpu.Simulate(1000.0) conn_id = ngpu.GetConnections(neuron0, neuron1) dt = dt_list w = ngpu.GetStatus(conn_id, "weight") expect_w = []
neuron = ngpu.Create('iaf_psc_exp_hc', 1) spike = ngpu.Create("spike_generator") spike_times = [10.0, 400.0] n_spikes = 2 # set spike times and height ngpu.SetStatus(spike, {"spike_times": spike_times}) delay = [1.0, 100.0] weight = [1.0, -2.0] conn_spec = {"rule": "all_to_all"} syn_spec_ex = {'weight': weight[0], 'delay': delay[0]} syn_spec_in = {'weight': weight[1], 'delay': delay[1]} ngpu.Connect(spike, neuron, conn_spec, syn_spec_ex) ngpu.Connect(spike, neuron, conn_spec, syn_spec_in) record = ngpu.CreateRecord("", ["V_m_rel"], [neuron[0]], [0]) #voltmeter = nest.Create('voltmeter') #nest.Connect(voltmeter, neuron) ngpu.Simulate(800.0) data_list = ngpu.GetRecordData(record) t = [row[0] for row in data_list] V_m = [row[1] + E_L for row in data_list] #dmm = nest.GetStatus(voltmeter)[0] #V_m = dmm["events"]["V_m"] #t = dmm["events"]["times"] #with open('test_iaf_psc_exp_nest.txt', 'w') as f:
import neurongpu as ngpu tolerance = 1.0e-6 neuron = ngpu.Create("aeif_cond_beta", 3) ngpu.SetStatus(neuron, {"I_e": 1000.0}) spike_det = ngpu.Create("spike_detector") conn_dict = {"rule": "one_to_one"} syn_dict1 = {"weight": 1.0, "delay": 10.0, "receptor": 0} syn_dict2 = {"weight": 2.0, "delay": 20.0, "receptor": 0} syn_dict3 = {"weight": 3.0, "delay": 30.0, "receptor": 0} ngpu.Connect(neuron[0:0], spike_det, conn_dict, syn_dict1) ngpu.Connect(neuron[1:1], spike_det, conn_dict, syn_dict2) ngpu.Connect(neuron[2:2], spike_det, conn_dict, syn_dict3) record_n = ngpu.CreateRecord("", ["spike"], [neuron[0]], [0]) record_sd = ngpu.CreateRecord("", ["spike_height"], [spike_det[0]], [0]) ngpu.Simulate() data_n = ngpu.GetRecordData(record_n) t_n = [row[0] for row in data_n] spike_n = [row[1] for row in data_n]
'E_rev': [0.0, 0.0, 0.0, -85.0], 'tau_decay': [50.0, 20.0, 20.0, 20.0], 'tau_rise': [10.0, 10.0, 1.0, 1.0] }) spike = nest.Create('spike_generator', params={'spike_times': np.array([10.0])}) spike_image = ngpu_nest.CreateNeuronImage(spike, 1) delay = [1.0, 300.0, 500.0, 700.0] w = [1.0, 1.0, 1.0, 1.0] conn_spec = {"rule": "all_to_all"} for syn in range(4): syn_spec = {'receptor': syn, 'weight': w[syn], 'delay': delay[syn]} ngpu.Connect(spike_image, neuron, conn_spec, syn_spec) record = ngpu.CreateRecord("", ["V_m"], [neuron[0]], [0]) nest.Simulate(1000.0) data_list = ngpu.GetRecordData(record) t = [row[0] for row in data_list] V_m = [row[1] for row in data_list] import matplotlib.pyplot as plt plt.figure(1) plt.plot(t, V_m) plt.draw()
tolerance = 1.0e-6 neuron = ngpu.Create("aeif_cond_beta", 3) ngpu.SetStatus(neuron, {"I_e":1000.0}) spike_det = ngpu.Create("spike_detector") conn_dict={"rule": "one_to_one"} syn_dict1={"weight": 1.0, "delay": 10.0, "receptor":0} syn_dict2={"weight": 2.0, "delay": 20.0, "receptor":0} syn_dict3={"weight": 3.0, "delay": 30.0, "receptor":0} ngpu.Connect([neuron[0]], spike_det, conn_dict, syn_dict1) ngpu.Connect([neuron[1]], spike_det, conn_dict, syn_dict2) ngpu.Connect([neuron[2]], spike_det, conn_dict, syn_dict3) record_n = ngpu.CreateRecord("", ["spike"], [neuron[0]], [0]) record_sd = ngpu.CreateRecord("", ["spike_height"], [spike_det[0]], [0]) ngpu.Simulate() data_n = ngpu.GetRecordData(record_n) t_n=[row[0] for row in data_n] spike_n=[row[1] for row in data_n]