def test_SetStatusVth_E_L(self):
"""SetStatus of reversal and threshold potential """
m = "sample_neuron"
cynest.ResetKernel()
neuron1 = cynest.Create(m)
neuron2 = cynest.Create(m)
# must not depend on the order.
new_EL = -90.
new_Vth = -10.
cynest.SetStatus(neuron1, {'E_L': new_EL})
cynest.SetStatus(neuron2, {'V_th': new_Vth})
cynest.SetStatus(neuron1, {'V_th': new_Vth})
cynest.SetStatus(neuron2, {'E_L': new_EL})
# next three lines for debugging
vth1, vth2 = cynest.GetStatus(neuron1, 'V_th'), cynest.GetStatus(
neuron2, 'V_th')
if vth1 != vth2:
print(m, vth1, vth2, cynest.GetStatus(neuron1, 'E_L'),
cynest.GetStatus(neuron2, 'E_L'))
assert (cynest.GetStatus(neuron1,
'V_th') == cynest.GetStatus(neuron2, 'V_th'))
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 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 build(self, neuronName, custom):
"""
Create all nodes, used in the model.
"""
if self.built == True: return
self.calibrate()
self.nodes = cynest.Create(neuronName, self.N_neurons)
self.noise = cynest.Create("poisson_generator", 1,
{"rate": self.p_rate})
self.spikes = cynest.Create("spike_detector", 2,
[{
"label": "brunel-py-ex"
}, {
"label": "brunel-py-in"
}])
if custom == True:
cynest.SetStatus(self.nodes, [{"optimized": True}])
self.nodes_E = self.nodes[:self.N_E]
self.nodes_I = self.nodes[self.N_E:]
self.spikes_E = self.spikes[:1]
self.spikes_I = self.spikes[1:]
self.built = True
def build_network(dt):
nest.ResetKernel()
nest.SetKernelStatus({"local_num_threads": 1, "resolution": dt})
neuron = nest.Create('iaf_neuron')
nest.SetStatus(neuron, "I_e", 376.0)
vm = nest.Create('voltmeter')
nest.SetStatus(vm, "withtime", True)
sd = nest.Create('spike_detector')
nest.Connect(vm, neuron)
nest.Connect(neuron, sd)
return vm, sd
def build(self):
nest.ResetKernel()
nest.SetKernelStatus({'local_num_threads': self.n_threads})
if self.params:
nest.SetDefaults(self.model,self.params)
self.neuron=nest.Create(self.model,self.n_neurons)
self.noise=nest.Create('noise_generator')
self.spike=nest.Create('spike_detector')
nest.SetStatus(self.spike,[{'to_memory':True, 'to_file':False}])
def test_SetStatusParam(self):
"""SetStatus with parameter"""
m = "sample_neuron"
cynest.ResetKernel()
n = cynest.Create(m)
cynest.SetStatus(n, 'V_m', 3.)
self.assertEqual(cynest.GetStatus(n, 'V_m')[0], 3.)
def test_SetStatusList(self):
"""SetStatus with list"""
m = "sample_neuron"
cynest.ResetKernel()
n = cynest.Create(m)
cynest.SetStatus(n, [{'V_m': 2.}])
self.assertEqual(cynest.GetStatus(n, 'V_m')[0], 2.)
def test_SetStatus(self):
"""SetStatus with dict"""
m = "sample_neuron"
cynest.ResetKernel()
n = cynest.Create(m)
cynest.SetStatus(n, {'V_m': 1.})
self.assertEqual(cynest.GetStatus(n, 'V_m')[0], 1.)
def test_Function(self):
"""Test of function object"""
cynest.ResetKernel()
node = cynest.Create("sample_neuron")
try:
cynest.SetStatus(node, {"param2": testFct})
except:
info = sys.exc_info()[1]
def test_Instance(self):
"""Test of instance object"""
cynest.ResetKernel()
t = testClass()
node = cynest.Create("sample_neuron")
try:
cynest.SetStatus(node, {"param2": t})
except:
info = sys.exc_info()[1]
def test_FindConnections(self):
"""FindConnections"""
nest.ResetKernel()
a = nest.Create("iaf_neuron", 3)
nest.DivergentConnect(a, a)
c1 = nest.FindConnections(a)
c2 = nest.FindConnections(a, synapse_type="static_synapse")
self.assertEqual(c1, c2)
d1 = [{"weight": w} for w in [2.0, 3.0, 4.0]]
c3 = nest.FindConnections(a, a)
nest.SetStatus(c3, d1)
s1 = nest.GetStatus(c3, "weight")
self.assertEqual(s1, [w["weight"] for w in d1])
# To be consistent with the other parameters in the equations, b must be
# converted to pA (pico Ampere).
import cynest as nest
import cynest.voltage_trace
import pylab
nest.ResetKernel()
res = 0.1
nest.SetKernelStatus({"resolution": res})
neuron = nest.Create("aeif_cond_exp")
nest.SetStatus(neuron, {
"V_peak": 20.,
"E_L": -60.0,
"a": 80.0,
"b": 80.5,
"tau_w": 720.0
})
dc = nest.Create("dc_generator")
nest.SetStatus(dc, [{"amplitude": -800.0, "start": 0.0, "stop": 400.0}])
nest.ConvergentConnect(dc, neuron)
voltmeter = nest.Create("voltmeter")
nest.SetStatus(voltmeter, {"withgid": True, "withtime": True, 'interval': 0.1})
nest.Connect(voltmeter, neuron)
nest.Simulate(1000.0)
# Third, the nodes are created using Create(). We store the returned
# handles in variables for later reference.
neuron = nest.Create("iaf_neuron")
noise = nest.Create("poisson_generator", 2)
voltmeter = nest.Create("voltmeter")
spikedetector = nest.Create("spike_detector")
# Fourth, the excitatory Poisson generator (noise[0]) and the
# voltmeter are configured using SetStatus, which expects a list of
# node handles and a list of parameter dictionaries. The rate of the
# inhibitory Poisson generator is set later. Note that we need not set
# parameters for the neuron and the spike detector, since they have
# satisfactory defaults.
nest.SetStatus(noise, [{"rate": n_ex * r_ex}, {"rate": n_in * r_in}])
nest.SetStatus(voltmeter, {
"interval": 10.0,
"withgid": True,
"withtime": True
})
# Fifth, the neuron is connected to the spike detector and the
# voltmeter, as are the two Poisson generators to the neuron. The
# command Connect() has different variants. Plain Connect() just takes
# the handles of pre- and post-synaptic nodes and uses the default
# values for weight and delay. ConvergentConnect() takes four
# arguments: A list of pre-synaptic nodes, a list of post-synaptic
# nodes, and lists of weights and delays. Note that the connection
# direction for the voltmeter is reversed compared to the spike
# detector, because it observes the neuron instead of receiving events
nest.SetDefaults("dc_generator", {
"amplitude": I0,
"start": TIstart,
"stop": TIend
})
# create dc_generator:
dc_gen = nest.Create("dc_generator")
# set properties of voltmeter:
volts = nest.Create("voltmeter")
# create voltmeter:
nest.SetStatus([volts], [{
"label": "voltmeter",
"withtime": True,
"withgid": True,
"interval": 1.
}])
# 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,
# Brette and Gerstner (2005) J. Neurophysiology.
# This script reproduces figure 2.C of the paper.
# Note that Brette&Gerstner give the value for b in nA.
# To be consistent with the other parameters in the equations, b must be
# converted to pA (pico Ampere).
import cynest as nest
import cynest.voltage_trace
import pylab
nest.ResetKernel()
res = 0.1
nest.SetKernelStatus({"resolution": res})
neuron = nest.Create("aeif_cond_alpha")
nest.SetStatus(neuron, {"a": 4.0, "b": 80.5})
dc = nest.Create("dc_generator", 2)
nest.SetStatus(dc, [{
"amplitude": 500.0,
"start": 0.0,
"stop": 200.0
}, {
"amplitude": 800.0,
"start": 500.0,
"stop": 1000.0
}])
nest.ConvergentConnect(dc, neuron)
voltmeter = nest.Create("voltmeter")
#! /usr/bin/env python
import cynest as nest
import cynest.voltage_trace
nest.ResetKernel()
neuron = nest.Create("iaf_neuron")
noise = nest.Create("poisson_generator", 2)
nest.SetStatus(noise, [{"rate": 80000.0}, {"rate": 20000.0}])
sine = nest.Create("ac_generator")
nest.SetStatus(sine, [{"amplitude": 100.0, "frequency": 2.0}])
voltmeter = nest.Create("voltmeter")
nest.SetStatus(voltmeter, {"withgid": True, "withtime": True})
nest.ConvergentConnect(noise, neuron, [1.0, -1.0], 1.0)
nest.Connect(voltmeter, neuron)
nest.Connect(sine, neuron)
nest.Simulate(1000.0)
nest.voltage_trace.from_device(voltmeter)
nest.voltage_trace.show()
#! /usr/bin/env python
import cynest as nest
import cynest.voltage_trace
nest.ResetKernel()
neuron = nest.Create("iaf_neuron")
noise = nest.Create("poisson_generator", 2)
nest.SetStatus(noise, [{"rate": 80000.0}, {"rate": 15000.0}])
voltmeter = nest.Create("voltmeter")
nest.SetStatus(voltmeter, {"withgid": True, "withtime": True})
nest.ConvergentConnect(noise, neuron, [1.2, -1.0], 1.0)
nest.Connect(voltmeter, neuron)
nest.Simulate(1000.0)
nest.voltage_trace.from_device(voltmeter)
nest.voltage_trace.show()
#! layer, since they will differ from layer to layer. We will add them
#! below by updating the ``'elements'`` dictionary entry for each
#! population.
#! Retina
#! ------
layerProps.update({'elements': 'RetinaNode'})
retina = topo.CreateLayer(layerProps)
#! Now set phases of retinal oscillators; we use a list comprehension instead
#! of a loop.
[
nest.SetStatus(
[n], {
"phi":
phiInit(
topo.GetPosition([n])[0], Params["lambda_dg"],
Params["phi_dg"])
}) for n in nest.GetLeaves(retina)[0]
]
#! Thalamus
#! --------
#! We first introduce specific neuron models for the thalamic relay
#! cells and interneurons. These have identical properties, but by
#! treating them as different models, we can address them specifically
#! when building connections.
#!
#! We use a list comprehension to do the model copies.
[
Plot several runs of the iaf_cond_exp_sfa_rr neuron with no input and
various initial values for the membrane potential.
"""
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)")
fac_params = {"U": 0.1, "tau_fac": 1000., "tau_rec": 100., "weight": 250.}
# 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()
#! /usr/bin/env python
import matplotlib
# matplotlib.use("macosx")
import pylab
import cynest as nest
import cynest.voltage_trace
weight = 20.0
delay = 1.0
stim = 1000.0
neuron1 = nest.Create("iaf_neuron")
neuron2 = nest.Create("iaf_neuron")
voltmeter = nest.Create("voltmeter")
nest.SetStatus(neuron1, {"I_e": stim})
nest.Connect(neuron1, neuron2, weight, delay)
nest.Connect(voltmeter, neuron2)
nest.Simulate(100.0)
nest.voltage_trace.from_device(voltmeter)
nest.voltage_trace.show()
}
nest.SetDefaults("iaf_psc_delta", neuron_params)
nodes_ex = nest.Create("iaf_psc_delta", NE)
nodes_in = nest.Create("iaf_psc_delta", NI)
nest.SetDefaults("poisson_generator", {"rate": p_rate})
noise = nest.Create("poisson_generator")
espikes = nest.Create("spike_detector")
ispikes = nest.Create("spike_detector")
nest.SetStatus([espikes], [{
"label": "brunel-py-ex",
"withtime": True,
"withgid": True
}])
nest.SetStatus([ispikes], [{
"label": "brunel-py-in",
"withtime": True,
"withgid": True
}])
print("Connecting devices.")
nest.CopyModel("static_synapse", "excitatory", {
"weight": J_ex,
"delay": delay
})
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()
#!/usr/bin/env python
import cynest as nest
import cynest.voltage_trace
nest.ResetKernel()
neuron = nest.Create("iaf_neuron")
nest.SetStatus(neuron, "I_e", 376.0)
voltmeter = nest.Create("voltmeter")
nest.SetStatus(voltmeter, {"withgid": True, "withtime": True})
nest.Connect(voltmeter, neuron)
nest.Simulate(1000.0)
nest.voltage_trace.from_device(voltmeter)
nest.voltage_trace.show()
tmp[len(psp) - 1:-1] += psp
psp = tmp
del tmp
P = a * weight * pylab.convolve(gauss, psp)
l = len(P)
t_P = convolution_resolution * numpy.linspace(
-l / 2., l / 2., l) + pulsetime + 1. # one ms delay
#########################################################################
# simulation section
nest.ResetKernel()
nest.SetStatus([0], [{'resolution': simulation_resolution}])
J = Cm * weight / tau_s * fudge
nest.SetDefaults('static_synapse', {'weight': J})
n = nest.Create(
'iaf_psc_alpha', n_neurons, {
'V_th': Vth,
'tau_m': tau_m,
'tau_syn_ex': tau_s,
'C_m': Cm,
'E_L': V0,
'V_reset': V0,
'V_m': V0
})
pp = nest.Create('pulsepacket_generator', n_neurons, {
'pulse_times': [pulsetime],
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()
