inh_syn_dict = {"weight": Win, "delay": delay, "receptor": 1}
ngpu.Connect(inh_neuron, neuron, inh_conn_dict, inh_syn_dict)
#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)
filename = "test_brunel_mpi" + str(mpi_id) + ".dat"
i_neuron_arr = [neuron[0], 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)
######################################################################
## WRITE HERE REMOTE CONNECTIONS
######################################################################
# Excitatory remote connections
# connect excitatory neurons to port 0 of all neurons
# weight Wex and fixed indegree CE//4
# host 0 to host 1
re_conn_dict = {"rule": "fixed_indegree", "indegree": CE // 4}
re_syn_dict = {"weight": Wex, "delay": delay, "receptor": 0}
# host 0 to host 1
ngpu.RemoteConnect(0, exc_neuron, 1, neuron, re_conn_dict, re_syn_dict)
# host 1 to host 0
ngpu.RemoteConnect(1, exc_neuron, 0, neuron, re_conn_dict, re_syn_dict)
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:
# for i in range(len(t)):
# f.write("%s\t%s\n" % (t[i], V_m[i]))
pg_conn_dict = {"rule": "all_to_all"}
pg_syn_dict = {"weight": poiss_weight, "delay": poiss_delay, "receptor": 0}
ngpu.Connect(pg_list, neuron_list, pg_conn_dict, pg_syn_dict)
i_neuron_list = [neuron[0], neuron[n_neurons - 1]]
i_receptor_list = [0, 0]
var_name_list = ["spike", "spike"]
for i in range(n_test - 2):
i_neuron_list.append(neuron[randrange(n_neurons)])
i_receptor_list.append(0)
var_name_list.append("spike")
# create multimeter record of spikes
record = ngpu.CreateRecord("", var_name_list, i_neuron_list, i_receptor_list)
ngpu.Simulate()
data_list = ngpu.GetRecordData(record)
n_conn_tot = 0
for i in range(1000):
conn_id = ngpu.GetConnections(i + 1)
n_out_conn = len(conn_id)
n_conn_tot = n_conn_tot + n_out_conn
if (n_conn_tot != (NE + NI) * CPN):
print("Expected total number of connections: ", (NE + NI) * CPN)
print("Total number of connections ", n_conn_tot)
sys.exit(1)
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})
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)
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([])
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]
data_sd = ngpu.GetRecordData(record_sd)
t_sd=[row[0] for row in data_sd]
spike_sd=[row[1] for row in data_sd]
for i in range(len(t_n)-400):
if spike_n[i]>0.5:
