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]
