def simulate(self, t_sim):
""" Simulates the microcircuit.
Parameters
----------
t_sim
Simulation time (in ms).
"""
if self.Rank == 0:
print('Simulating {} ms.'.format(t_sim))
ngpu.Simulate(t_sim)
pg_syn_dict = {"weight": poiss_weight, "delay": poiss_delay, "receptor": 0}
ngpu.Connect(pg, neuron, pg_conn_dict, pg_syn_dict)
filename = "test_brunel_net.dat"
i_neuron_arr = [
neuron[37], neuron[randrange(n_neurons)], neuron[n_neurons - 1]
]
i_receptor_arr = [0, 0, 0]
# any set of neuron indexes
# create multimeter record of V_m
var_name_arr = ["V_m", "V_m", "V_m"]
record = ngpu.CreateRecord(filename, var_name_arr, i_neuron_arr,
i_receptor_arr)
ngpu.Simulate()
nrows = ngpu.GetRecordDataRows(record)
ncol = ngpu.GetRecordDataColumns(record)
#print nrows, ncol
data_list = ngpu.GetRecordData(record)
t = [row[0] for row in data_list]
V1 = [row[1] for row in data_list]
V2 = [row[2] for row in data_list]
V3 = [row[3] for row in data_list]
import matplotlib.pyplot as plt
plt.figure(1)
plt.plot(t, V1)
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:
# for i in range(len(t)):
# f.write("%s\t%s\n" % (t[i], V_m[i]))
data = np.loadtxt('../test/test_fast_iaf_psc_exp_nest.txt', delimiter="\t")
t1 = [x[0] for x in data]
V_m1 = [x[1] for x in data]
#print (len(t))
delay = 3.0
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})
syn_dict_stdp={"weight":weight_stdp, "delay":delay, \
"synapse_group":syn_group, "receptor":1}
ngpu.SetStatus(neuron_post, {"den_delay": den_delay})
ngpu.Connect(neuron_pre, neuron_post, conn_dict, syn_dict_stdp)
ngpu.Simulate(sim_time)
conn_id = ngpu.GetConnections(neuron_pre, neuron_post)
w = ngpu.GetStatus(conn_id, "weight")
print("Initial weight: ", weight_stdp)
print("Simulated weight: ", w[0])
Wplus = Wmax * lambd
Dt = -2.0
w1 = STDPUpdate(weight_stdp, Dt, tau_plus, tau_minus, Wplus, \
alpha, mu_plus, mu_minus, Wmax)
print("Expected theoretical weight: ", w1)
print("dw/w: ", (w1 - w[0]) / w1)
pg_conn_dict={"rule": "all_to_all"}
pg_syn_dict={"weight": poiss_weight, "delay": poiss_delay, "receptor":0}
ngpu.Connect(pg, neuron, pg_conn_dict, pg_syn_dict)
filename = "test_brunel_net.dat"
i_neuron_arr = [neuron[37], neuron[randrange(n_neurons)], neuron[n_neurons-1]]
i_receptor_arr = [0, 0, 0]
# any set of neuron indexes
# create multimeter record of V_m
var_name_arr = ["V_m", "V_m", "V_m"]
record = ngpu.CreateRecord(filename, var_name_arr, i_neuron_arr,
i_receptor_arr)
ngpu.Simulate(sim_time*1000.0)
spike_count = ngpu.GetStatus(neuron, "spike_count")
spike_count = [s[0] for s in spike_count]
print("Average firing rate: ", sum(spike_count)/len(spike_count)/sim_time)
data_list = ngpu.GetRecordData(record)
t=[row[0] for row in data_list]
V1=[row[1] for row in data_list]
V2=[row[2] for row in data_list]
V3=[row[3] for row in data_list]
import matplotlib.pyplot as plt
plt.figure(1)
plt.plot(t, V1)
#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)
ngpu.Simulate(490)
ngpu.SetStatus(pg, "rate", 0.0)
ngpu.Simulate(10)
data_list = ngpu.GetRecordData(record)
row_sum = list(data_list[0])
for row in data_list[1:len(data_list)]:
for i in range(len(row_sum)):
row_sum[i] = row_sum[i] + row[i]
spike_times = []
for i in range(len(neuron)):
spike_times.append([])
for row in data_list[0:len(data_list)]:
for i in range(1, len(row)):
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 = []
dw = []
sim_w = []
for i in range(N):
conn_id = ngpu.GetConnections(neuron0, neuron1[i])
w = ngpu.GetStatus(conn_id, "weight")
w1 = STDPUpdate(weight_stdp, dt[i], tau_plus, tau_minus, lambd*Wmax, \
alpha, mu_plus, mu_minus, Wmax)
expect_w.append(w1)
sim_w.append(w[0])
"receptor": 2
}
ngpu.Connect(inh_neuron, neuron_image, inh_conn_dict, inh_syn_dict1)
#connect poisson generator to port 0 of all neurons
pg_conn_dict = {"rule": "all_to_all"}
pg_syn_dict = {"weight": poiss_weight, "delay": poiss_delay, "receptor": 0}
ngpu.Connect(pg, neuron, pg_conn_dict, pg_syn_dict)
pg_syn_dict1 = {"weight": poiss_weight, "delay": poiss_delay, "receptor": 1}
ngpu.Connect(pg, neuron_image, pg_conn_dict, pg_syn_dict1)
sd = ngpu.Create("spike_detector", n_test)
sd_conn_dict = {"rule": "one_to_one"}
sd_syn_dict = {"weight": 1.0, "delay": 1.0}
i_neuron_list = []
i_receptor_list = []
var_name_list = []
for i in range(n_test):
ngpu.Connect([neuron[randrange(n_neurons)]], [sd[i]], sd_conn_dict,
sd_syn_dict)
i_neuron_list.append(sd[i])
i_receptor_list.append(0)
var_name_list.append("spike_height")
nest.Simulate(1000)
ngpu.SetVerbosityLevel(3)
ngpu.Simulate(0.1)
syn_dict1 = {
"weight": weight_sg,
"delay": delay1,
"receptor": 0,
"synapse_group": 0
}
ngpu.Connect(sg, neuron0, conn_dict, syn_dict0)
ngpu.Connect(sg, neuron1, conn_dict, syn_dict1)
for i in range(N):
delay_test = time_diff - dt_list[i]
syn_dict_test={"weight":weight_test, "delay":delay_test, "receptor":0, \
"synapse_group":syn_group}
ngpu.Connect([neuron0[i]], [neuron1[i]], conn_dict, syn_dict_test)
ngpu.Simulate(200.0)
conn_id = ngpu.GetConnections(neuron0, neuron1)
conn_status_dict = ngpu.GetStatus(conn_id, ["weight", "delay"])
#print (conn_status_dict)
for i in range(N):
#print dt_list[i], conn_status_dict[i][0]
expect_w = dt_list[i] * fact + offset
if abs(expect_w - conn_status_dict[i][0]) > tolerance:
print("Expected weight: ", expect_w, " simulated: ", \
conn_status_dict[i][0])
sys.exit(1)
sys.exit(0)
