def output_rate(self,mean, std): t=nest.GetKernelStatus('time') if t>100000: # prevent overflow of clock self.build() self.connect() t=0.0 nest.Simulate(self.t_inter_trial) nest.SetStatus(self.spike, "n_events", 0) nest.SetStatus(self.noise,[{'mean':mean, 'std':std, 'start': 0.0, 'stop': 1000., 'origin':t}]) nest.Simulate(self.t_sim) rate=nest.GetStatus(self.spike, "n_events")[0]*1000.0/(self.n_neurons*self.t_sim) return rate
def test_ParamTypes(self): """Test of all parameter types""" cynest.ResetKernel() node = cynest.Create("sample_neuron") cynest.SetStatus(node, {"param1":2, "param2":6.5, "param3": True, "param4":"sd", "param5":'r', \ "param6":[1,2,3,4], "param7":{"c1":1, "c2":2}, "param8":{"e1":{"s1":1}}}) cynest.Simulate(1) s = cynest.GetStatus(node)[0] self.assertEqual(s["param1"], 2) self.assertEqual(s["param2"], 6.5) self.assertEqual(s["param3"], True) self.assertEqual(s["param4"], "sd") self.assertEqual(s["param5"], 'r') self.assertEqual(s["param6"][0], 1) self.assertEqual(s["param6"][1], 2) self.assertEqual(s["param6"][2], 3) self.assertEqual(s["param6"][3], 4) self.assertEqual(s["param7"]["c1"], 1) self.assertEqual(s["param7"]["c2"], 2) self.assertEqual(s["param8"]["e1"]["s1"], 1)
def output_rate(guess): print "Inhibitory rate estimate: %5.2f Hz ->" % guess, rate = float(abs(n_in * guess)) nest.SetStatus([noise[1]], "rate", rate) nest.SetStatus(spikedetector, "n_events", 0) nest.Simulate(t_sim) out = nest.GetStatus(spikedetector, "n_events")[0] * 1000.0 / t_sim print "Neuron rate: %6.2f Hz (goal: %4.2f Hz)" % (out, r_ex) return out
def test_ModelCreateSimulate(self): """Model Creation and Simulation""" cynest.ResetKernel() cynest.SetDefaults("sample_neuron", {"param": 20}) node = cynest.Create("sample_neuron") cynest.Simulate(1) self.assertEqual(cynest.GetStatus(node)[0]["param"], 30)
def run(self, neuronName, simtime=40.): """ Simulate the model for simtime milliseconds and print the firing rates of the network during htis period. """ if not self.connected: self.connect(neuronName) cynest.Simulate(simtime) events = cynest.GetStatus(self.spikes, "n_events") self.rate_ex = events[0] / simtime * 1000.0 / self.N_rec print "Excitatory rate : %.2f Hz" % self.rate_ex self.rate_in = events[1] / simtime * 1000.0 / self.N_rec print "Inhibitory rate : %.2f Hz" % self.rate_in
def test_EventsVoltage(self): """Voltage Events""" nest.ResetKernel() nest.sr('20 setverbosity') n = nest.Create('iaf_neuron') vm = nest.Create('voltmeter', 1, {'withtime': True, 'interval': 1.}) nest.Connect(vm, n) nest.SetKernelStatus({'print_time': False}) nest.Simulate(10) d = nest.GetStatus(vm, 'events')[0] self.assertEqual(len(d['V_m']), 9)
def test_EventsSpikes(self): """Spike Events""" nest.ResetKernel() nest.sr('20 setverbosity') n = nest.Create('iaf_neuron', 1, {'I_e': 1000.}) sd = nest.Create('spike_detector', 1, {'withtime': True}) nest.Connect(n, sd) nest.SetKernelStatus({'print_time': False}) nest.Simulate(1000) d = nest.GetStatus(sd, 'events')[0] self.assert_(len(d['times']) > 0)
def test_ThreadsGetEvents(self): """ Gathering events across threads """ # Test if we have a thread-enabled NEST nest.sr("statusdict /have_pthreads get") if not nest.spp(): return threads = [1, 2, 4, 8] n_events_sd = [] n_events_vm = [] N = 128 Simtime = 1000. for t in threads: nest.ResetKernel() nest.SetKernelStatus({'local_num_threads': t}) n = nest.Create('iaf_psc_alpha', N, {'I_e': 2000.}) # force a lot of spike events sd = nest.Create('spike_detector') vm = nest.Create('voltmeter') nest.ConvergentConnect(n, sd) nest.DivergentConnect(vm, n) nest.Simulate(Simtime) n_events_sd.append(nest.GetStatus(sd, 'n_events')[0]) n_events_vm.append(nest.GetStatus(vm, 'n_events')[0]) ref_vm = N * (Simtime - 1) ref_sd = n_events_sd[0] # could be done more elegantly with any(), ravel(), # but we dont want to be dependent on numpy et al [self.assertEqual(x, ref_vm) for x in n_events_vm] [self.assertEqual(x, ref_sd) for x in n_events_sd]
def run(self, neuronName, custom, simtime=40.): """ Simulate the model for simtime milliseconds and print the firing rates of the network during htis period. """ if not self.connected: self.connect(neuronName, custom) cynest.Simulate(simtime) #for i in range(1, 20): # cynest.sps(float(2.0)) # cynest.sr("ms Simulate") events = cynest.GetStatus(self.spikes, "n_events") if sys.version_info >= (3, 0): self.rate_ex = events[0] // simtime * 1000.0 / self.N_rec self.rate_in = events[1] // simtime * 1000.0 / self.N_rec else: self.rate_ex = events[0] / simtime * 1000.0 / self.N_rec self.rate_in = events[1] / simtime * 1000.0 / self.N_rec print("Excitatory rate : %.2f Hz" % self.rate_ex) print("Inhibitory rate : %.2f Hz" % self.rate_in)
# connect dc_generator to neuron 1: nest.Connect(dc_gen, [neurons[0]]) # connect voltmeter to neuron 2: nest.Connect(volts, [neurons[1]]) # set synapse parameters: syn_param = { "tau_psc": Tau_psc, "tau_rec": Tau_rec, "tau_fac": Tau_fac, "U": U, "delay": 0.1, "weight": A, "u": 0.0, "x": 1.0 } # create desired synapse type with chosen parameters: nest.CopyModel("tsodyks_synapse", "syn", syn_param) # connect neuron 1 with neuron 2 via synapse model 'syn': nest.Connect([neurons[0]], [neurons[1]], model="syn") # simulate: nest.Simulate(Tend) # print membrane potential of neuron 2: nest.voltage_trace.from_device(volts) nest.voltage_trace.show()
""" import cynest as nest import numpy import pylab for vinit in numpy.arange(-100, -50, 10, float): nest.ResetKernel() cbn = nest.Create('iaf_cond_exp_sfa_rr') # set the initial membrane potential nest.SetStatus(cbn, 'V_m', vinit) voltmeter = nest.Create('voltmeter') nest.SetStatus(voltmeter, {'withtime': True}) nest.Connect(voltmeter, cbn) nest.Simulate(75.0) t = nest.GetStatus(voltmeter, "events")[0]["times"] v = nest.GetStatus(voltmeter, "events")[0]["V_m"] pylab.plot(t, v, label="initial V_m=%.2f mV" % vinit) pylab.legend(loc=4) pylab.xlabel("time (ms)") pylab.ylabel("V_m (mV)") pylab.show()
#! This simulation is set up to create a step-wise visualization of #! the membrane potential. To do so, we simulate ``sim_interval`` #! milliseconds at a time, then read out data from the multimeters, #! clear data from the multimeters and plot the data as pseudocolor #! plots. #! show time during simulation nest.SetStatus([0], {'print_time': True}) #! lower and upper limits for color scale, for each of the four #! populations recorded. vmn = [-80, -80, -80, -80] vmx = [-50, -50, -50, -50] nest.Simulate(Params['sim_interval']) #! loop over simulation intervals for t in pylab.arange(Params['sim_interval'], Params['simtime'], Params['sim_interval']): # do the simulation nest.Simulate(Params['sim_interval']) # clear figure and choose colormap pylab.clf() pylab.jet() # now plot data from each recorder in turn, assume four recorders for name, r in recorders.iteritems(): rec = r[0]
# Here we assign the parameter set to the synapse models t1_params = fac_params # for tsodyks_synapse t2_params = t1_params.copy() # for tsodyks2_synapse nest.SetDefaults("tsodyks_synapse", t1_params) nest.SetDefaults("tsodyks2_synapse", t2_params) nest.SetDefaults("iaf_psc_exp", {"tau_syn_ex": 3.}) neuron = nest.Create("iaf_psc_exp", 3) nest.Connect([neuron[0]], [neuron[1]], model="tsodyks_synapse") nest.Connect([neuron[0]], [neuron[2]], model="tsodyks2_synapse") voltmeter = nest.Create("voltmeter", 2) nest.SetStatus(voltmeter, {"withgid": True, "withtime": True}) nest.Connect([voltmeter[0]], [neuron[1]]) nest.Connect([voltmeter[1]], [neuron[2]]) nest.SetStatus([neuron[0]], "I_e", 376.0) nest.Simulate(500.0) nest.SetStatus([neuron[0]], "I_e", 0.0) nest.Simulate(800.0) nest.SetStatus([neuron[0]], "I_e", 376.0) nest.Simulate(500.0) nest.SetStatus([neuron[0]], "I_e", 0.0) nest.Simulate(100.0) nest.voltage_trace.from_device([voltmeter[0]]) nest.voltage_trace.from_device([voltmeter[1]]) nest.voltage_trace.show()
def bias(n): # constructs the dictionary with current ramp return { 'I_e': (n * (bias_end-bias_begin)/N + bias_begin) } driveparams = {'amplitude':50., 'frequency':35.} noiseparams = {'mean':0.0, 'std':200.} neuronparams = { 'tau_m':20., 'V_th':20., 'E_L':10., 't_ref':2., 'V_reset':0., 'C_m':200., 'V_m':0.} neurons = nest.Create('iaf_psc_alpha',N) sd = nest.Create('spike_detector') noise = nest.Create('noise_generator') drive = nest.Create('ac_generator') nest.SetStatus(drive, driveparams ) nest.SetStatus(noise, noiseparams ) nest.SetStatus(neurons, neuronparams) nest.SetStatus(neurons, map(bias, neurons)) nest.SetStatus(sd, {"withgid": True, "withtime": True}) nest.DivergentConnect(drive, neurons) nest.DivergentConnect(noise, neurons) nest.ConvergentConnect(neurons, sd) nest.Simulate(T) nest.raster_plot.from_device(sd, hist=True) nest.raster_plot.show()
'interval': 0.1, 'record_from': ['V_m', 'g_ex', 'g_in'] }) # Create spike generators and connect gex = nest.Create('spike_generator', params={'spike_times': np.array([10.0, 20.0, 50.0])}) gin = nest.Create('spike_generator', params={'spike_times': np.array([15.0, 25.0, 55.0])}) nest.Connect(gex, n, params={'weight': 40.0}) # excitatory nest.Connect(gin, n, params={'weight': -20.0}) # inhibitory nest.Connect(m, n) # simulate nest.Simulate(100) # obtain and display data events = nest.GetStatus(m)[0]['events'] t = events['times'] pl.clf() pl.subplot(211) pl.plot(t, events['V_m']) pl.axis([0, 100, -75, -53]) pl.ylabel('Membrane potential [mV]') pl.subplot(212) pl.plot(t, events['g_ex'], t, events['g_in']) pl.axis([0, 100, 0, 45])
trial_duration = 1000.0 # trial duration, in ms num_trials = 5 # number of trials to perform # set up network nest.ResetKernel() pg = nest.Create('poisson_generator', params={ 'rate': rate, 'start': start, 'stop': stop }) sd = nest.Create('spike_detector') nest.Connect(pg, sd) # before each trial, we set the 'origin' of the poisson_generator to the current # simulation time for n in xrange(num_trials): nest.SetStatus(pg, {'origin': nest.GetKernelStatus()['time']}) nest.Simulate(trial_duration) # now plot the result, including a histogram # note: The histogram will show spikes seemingly located before 100ms into # each trial. This is due to sub-optimal automatic placement of histogram bin borders. import cynest.raster_plot nest.raster_plot.from_device(sd, hist=True, hist_binwidth=100., title='Repeated stimulation by Poisson generator') nest.raster_plot.show()