def csa_example():
cs = csa.cset(csa.random(0.1), 10000.0, 1.0)
pop1 = nest.LayoutNetwork("iaf_neuron", [16])
pop2 = nest.LayoutNetwork("iaf_neuron", [16])
nest.PrintNetwork(10)
nest.CGConnect(pop1, pop2, cs, {"weight": 0, "delay": 1})
pg = nest.Create("poisson_generator", params={"rate": 80000.0})
nest.DivergentConnect(pg, nest.GetLeaves(pop1)[0], 1.2, 1.0)
vm_params = {
"record_to": ["memory"],
"withgid": True,
"withtime": True,
"interval": 0.1
}
vm = nest.Create("voltmeter", params=vm_params)
nest.DivergentConnect(vm, nest.GetLeaves(pop2)[0])
nest.Simulate(50.0)
from nest import visualization
allnodes = pg + nest.GetLeaves(pop1)[0] + nest.GetLeaves(pop2)[0] + vm
visualization.plot_network(allnodes, "test_csa.png")
if havePIL:
im = Image.open("test_csa.png")
im.show()
from nest import voltage_trace
voltage_trace.from_device(vm)
def create_network(network_obj, weight, JENoise, noise_rate, resolution=0.1,
verbose=True, print_time=False):
ncells = network_obj['ncells']
ncons = network_obj['ncons']
if verbose:
print "Constructing NEST network of %i nodes and %i connections." % (
ncells, ncons)
nest.ResetKernel()
nthreads = cpu_count()
if verbose:
nest.set_verbosity('M_INFO')
else:
nest.set_verbosity('M_ERROR')
nest.SetKernelStatus(dict(local_num_threads=nthreads, resolution=0.1,
print_time=print_time, overwrite_files=True))
neuron_params = dict(C_m=1.0, tau_m=20.0, t_ref=2.0, E_L=0.0, V_th=20.0)
nest.SetDefaults("iaf_neuron", neuron_params)
neuronsE = nest.Create("iaf_neuron", n=ncells)
# save GID offset of first neuron - this has the advantage that the output
# later will be independent of the point at which the neurons were created
GIDoffset = neuronsE[0]
espikes = nest.Create("spike_detector")
nest.ConvergentConnect(neuronsE, espikes)
noise = nest.Create("poisson_generator", n=1, params=dict(rate=noise_rate))
# Warning: delay is overwritten later if weights are given!
nest.SetDefaults("tsodyks_synapse",
dict(delay=1.5, tau_rec=500., tau_fac=0., U=0.3))
nest.CopyModel("tsodyks_synapse", "exc", dict(weight=weight))
nest.CopyModel("static_synapse", "poisson", dict(weight=JENoise))
# every neuron gets the same noisy input???
nest.DivergentConnect(noise, neuronsE, model="poisson")
for node in network_obj['nodes']:
presyn_index = node['id']
postsyn_indices = node['connectedTo']
nest.DivergentConnect(
[neuronsE[presyn_index]], # from, list of len 1
[neuronsE[ii] for ii in postsyn_indices], # to, list
model='exc', # synapse model
)
return ncells, ncons, neuronsE, espikes, noise, GIDoffset
def connect(self):
"""
Connect all nodes in the model.
"""
if self.connected: return
if not self.built:
self.build()
nest.CopyModel("static_synapse_hom_wd", "excitatory", {
"weight": self.J_E,
"delay": self.delay
})
nest.CopyModel("static_synapse_hom_wd", "inhibitory", {
"weight": self.J_I,
"delay": self.delay
})
nest.RandomConvergentConnect(self.nodes_E,
self.nodes,
self.C_E,
model="excitatory")
nest.RandomConvergentConnect(self.nodes_I,
self.nodes,
self.C_I,
model="inhibitory")
nest.DivergentConnect(self.noise, self.nodes, model="excitatory")
nest.ConvergentConnect(self.nodes_E[:self.N_rec], self.spikes_E)
nest.ConvergentConnect(self.nodes_I[:self.N_rec], self.spikes_I)
self.connected = True
def _divergentConnectEE(self, pre, post, weights):
post_global = list(self.E_pop[0] + np.asanyarray(post))
nest.DivergentConnect([self.E_pop[0] + pre],
post_global,
model='I_AMPA_NMDA',
weight=list(weights),
delay=[self.no.delay] * len(weights))
def _divergentConnectIE(self, pre, post, weights):
post_global = list(self.E_pop[0] + np.array(post))
nest.DivergentConnect([self.I_pop[0] + pre],
post_global,
model='E_GABA_A',
weight=list(weights),
delay=[self.no.delay] * len(weights))
def inject_into(self, cell_list):
"""Inject this current source into some cells."""
for id in cell_list:
if id.local and 'v' not in id.cellclass.recordable:
raise TypeError("Can't inject current into a spike source.")
if isinstance(cell_list, Population):
cell_list = [cell for cell in cell_list]
nest.DivergentConnect(self._device, cell_list)
def test_DivergentConnect(self):
"""DivergentConnect pre to post"""
nest.ResetKernel()
pre = nest.Create("iaf_neuron", 1)
post = nest.Create("iaf_neuron", 3)
nest.DivergentConnect(pre, post)
connections = nest.FindConnections(pre)
targets = nest.GetStatus(connections, "target")
self.assertEqual(targets, post)
def inject_into(self, cell_list):
"""Inject this current source into some cells."""
for id in cell_list:
if id.local and not id.celltype.injectable:
raise TypeError("Can't inject current into a spike source.")
if isinstance(cell_list, (Population, PopulationView, Assembly)):
self.cell_list = [cell for cell in cell_list]
else:
self.cell_list = cell_list
nest.DivergentConnect(self._device, self.cell_list)
def inject_into(self, cells):
__doc__ = StandardCurrentSource.inject_into.__doc__
for id in cells:
if id.local and not id.celltype.injectable:
raise TypeError("Can't inject current into a spike source.")
if isinstance(cells, (Population, PopulationView, Assembly)):
self.cell_list = [cell for cell in cells]
else:
self.cell_list = cells
nest.DivergentConnect(self._device, self.cell_list)
def connect_to_cells(self):
if not self._connected:
ids = list(self._all_ids)
if self.type is "spike_detector":
nest.ConvergentConnect(ids,
self.device,
model='static_synapse')
else:
nest.DivergentConnect(self.device, ids, model='static_synapse')
self._connected = True
def csa_example():
cs = csa.cset(csa.random(0.1), 10000.0, 1.0)
# This does not work yet, as the implementation does not yet
# support nested subnets.
#
#pop1 = nest.LayoutNetwork("iaf_neuron", [4,4])
#pop2 = nest.LayoutNetwork("iaf_neuron", [4,4])
pop1 = nest.LayoutNetwork("iaf_neuron", [16])
pop2 = nest.LayoutNetwork("iaf_neuron", [16])
nest.PrintNetwork(10)
nest.CGConnect(pop1, pop2, cs, {"weight": 0, "delay": 1})
pg = nest.Create("poisson_generator", params={"rate": 80000.0})
nest.DivergentConnect(pg, nest.GetLeaves(pop1)[0], 1.2, 1.0)
vm = nest.Create("voltmeter",
params={
"record_to": ["memory"],
"withgid": True,
"withtime": True,
"interval": 0.1
})
nest.DivergentConnect(vm, nest.GetLeaves(pop2)[0])
nest.Simulate(50.0)
# Not yet supported in NEST
#from nest import visualization
#allnodes = [pg, nest.GetLeaves(pop1)[0], nest.GetLeaves(pop2)[0], vm]
#visualization.plot_network(allnodes, "test_csa.png", "png", plot_modelnames=True
#if havePIL:
# im = Image.open("test_csa.png")
# im.show()
from nest import voltage_trace
voltage_trace.from_device(vm)
def _divergent_connect(self, source, targets, weights, delays):
"""
Connect a neuron to one or more other neurons.
`source` -- the ID of the pre-synaptic cell.
`targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
`weight` -- a list/1D array of connection weights, or a single weight.
Must have the same length as `targets`.
`delays` -- a list/1D array of connection delays, or a single delay.
Must have the same length as `targets`.
"""
# are we sure the targets are all on the current node?
if core.is_listlike(source):
assert len(source) == 1
source = source[0]
if not core.is_listlike(targets):
targets = [targets]
assert len(targets) > 0
if self.synapse_type not in targets[0].celltype.synapse_types:
raise errors.ConnectionError(
"User gave synapse_type=%s, synapse_type must be one of: %s" %
(self.synapse_type,
"'" + "', '".join(st
for st in targets[0].celltype.synapse_types
or ['*No connections supported*'])) + "'")
weights = numpy.array(
weights
) * 1000.0 # weights should be in nA or uS, but iaf_neuron uses pA and iaf_cond_neuron uses nS.
# Using convention in this way is not ideal. We should
# be able to look up the units used by each model somewhere.
if self.synapse_type == 'inhibitory' and common.is_conductance(
targets[0]):
weights *= -1 # NEST wants negative values for inhibitory weights, even if these are conductances
if isinstance(weights, numpy.ndarray):
weights = weights.tolist()
elif isinstance(weights, float):
weights = [weights]
if isinstance(delays, numpy.ndarray):
delays = delays.tolist()
elif isinstance(delays, float):
delays = [delays]
if targets[0].celltype.standard_receptor_type:
try:
nest.DivergentConnect([source], targets, weights, delays,
self.synapse_model)
except nest.NESTError, e:
raise errors.ConnectionError(
"%s. source=%s, targets=%s, weights=%s, delays=%s, synapse model='%s'"
%
(e, source, targets, weights, delays, self.synapse_model))
def test_DivergentConnectWD(self):
"""DivergentConnect pre to post with weight and delay"""
nest.ResetKernel()
pre = nest.Create("iaf_neuron", 1)
post = nest.Create("iaf_neuron", 3)
nest.DivergentConnect(pre,
post,
weight=(2.0, 2.0, 2.0),
delay=(1.0, 2.0, 3.0))
connections = nest.FindConnections(pre)
weights = nest.GetStatus(connections, "weight")
delays = nest.GetStatus(connections, "delay")
self.assertEqual(weights, (2.0, 2.0, 2.0))
self.assertEqual(delays, (1.0, 2.0, 3.0))
def _record(self, new_ids):
"""Called by record()."""
if self._device is None:
self._create_device()
device_name = nest.GetStatus(self._device, "model")[0]
if device_name == "spike_detector":
nest.ConvergentConnect(new_ids,
self._device,
model='static_synapse')
elif device_name in ('voltmeter', 'conductancemeter'):
nest.DivergentConnect(self._device,
new_ids,
model='static_synapse')
else:
raise Exception("%s is not a valid recording device" % device_name)
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_model="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])
def test_ThreadsFindConnections(self):
"""FindConnections with threads"""
if not self.nest_multithreaded(): return
nest.ResetKernel()
nest.SetKernelStatus({'local_num_threads': 8})
pre = nest.Create("iaf_neuron")
post = nest.Create("iaf_neuron", 6)
nest.DivergentConnect(pre, post)
conn = nest.FindConnections(pre)
# Because of threading, targets may be in a different order than
# in post, so we sort the vector.
targets = nest.GetStatus(conn, "target")
targets.sort()
self.assertEqual(targets, post)
def test_GetConnections(self):
"""GetConnections"""
nest.ResetKernel()
a = nest.Create("iaf_neuron", 3)
nest.DivergentConnect(a, a)
c1 = nest.GetConnections(a)
c2 = nest.GetConnections(a, synapse_model="static_synapse")
self.assertEqual(c1, c2)
weights = (2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
d1 = tuple({"weight": w} for w in weights)
c3 = nest.GetConnections(a, a)
nest.SetStatus(c3, d1)
s1 = nest.GetStatus(c3, "weight")
self.assertEqual(s1, weights)
c4 = nest.GetConnections()
self.assertEqual(c1, c4)
def test_ThreadsGetEvents(self):
""" Gathering events across threads """
if not self.nest_multithreaded():
self.skipTest("NEST was compiled without multi-threading")
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 __init__(self,
models='iaf_neuron',
n=1,
params={},
mm_dt=1.0,
sname='',
spath='',
sd=True,
mm=True):
'''
Constructor
Arguments:
models nest model type, can be a list
n number of models to create, can be a list
params common parameters for models to be set
mm_dt multimeter recording precision
sname file basename
spath Path to save file at
sd boolean, True if spikes should me recorded
mm boolean, True if mulitmeter should record
'''
self.connections = {
} # Set after network has been built with FindConnections
self.ids = []
self.local_ids = []
self.mm = [] # Id of multimeter
self.mm_dt = 0 # Recording interval multimeter
self.models = []
self.params = []
self.receptor_types = {}
self.recordables = {}
self.sd = [] # Id of spike detector
self.sname = '' # Specific file basename
self.spath = '' # Path to save file at
self.signals = {
} # dictionary with signals for current, conductance, voltage or spikes
# If model is a string put it in a list
if isinstance(models, str):
models = [models]
# If n is a integer put it in a list
if isinstance(n, int):
n = [n]
self.models = models
# If no sname is provided take first model neuron as save name.
if sname is '': self.sname = self.models[0]
else: self.sname = sname
# If no spath is provided current path plus data_tmp is set to
# spath.
if spath is '': self.spath = os.getcwd() + '/output_tmp'
else: self.spath = spath
# Create save dir if it do not exist
try:
os.system('mkdir ' + self.spath)
except:
print self.spath + ' already exists'
print 'Group save path: ' + self.spath
# For each model create it with i neurons.
for model, i in zip(models, n):
self.ids.extend(nest.Create(model, i, params))
# Get local ids on this processor. Necessary to have for mpi run.
for id in self.ids:
nodetype = nest.GetStatus([id])[0]['model']
if nodetype != 'proxynode':
self.local_ids.append(id)
self.params = nest.GetStatus(self.ids)
# Pick out recordables and receptor types using first model.
try:
self.recordables = nest.GetDefaults(models[0])['recordables']
except:
print 'No recordables'
try:
self.receptor_types = nest.GetDefaults(models[0])['receptor_types']
except:
print 'No receptor types'
# Add spike detector
if sd: self.sd = nest.Create("spike_detector")
nest.SetStatus(self.sd, {"withgid": True})
nest.ConvergentConnect(self.ids, self.sd)
# Record with multimeter from first neuron
if mm:
self.mm = nest.Create("multimeter")
self.mm_dt = mm_dt # Recording interval
nest.SetStatus(self.mm, {
'interval': self.mm_dt,
'record_from': self.recordables
})
nest.DivergentConnect(self.mm, self.ids)
nest.SetStatus(zmn_nodes_L23i, {"stop": 5000.0})
syn_dict_e = {
'model': 'zmn_synapse',
'weight': +ST['zmn_weight'],
'delay': ST['zmn_delay']
}
syn_dict_i = {
'model': 'zmn_synapse',
'weight': -ST['zmn_weight'],
'delay': ST['zmn_delay']
}
val = 0.12
nest.DivergentConnect(zmn_nodes_L23e,
PYR_MC0,
model=syn_dict_e['model'],
weight=syn_dict_e['weight'],
delay=syn_dict_e['delay']) #adjusted for nest 2.2.2
nest.DivergentConnect(zmn_nodes_L23i,
PYR_MC0,
model=syn_dict_i['model'],
weight=syn_dict_i['weight'],
delay=syn_dict_i['delay']) #adjusted for nest 2.2.2
nest.DivergentConnect(zmn_nodes_L23e,
DBC_MC0,
model=syn_dict_e['model'],
weight=val,
delay=syn_dict_e['delay']) #adjusted for nest 2.2.2
nest.DivergentConnect(zmn_nodes_L23i,
DBC_MC0,
'radius': 0.5
}
},
"synapse_model": "static_synapse",
'kernel': {
'gaussian': {
'p_center': 1.0,
'sigma': 0.15
}
}
}
tp.ConnectLayers(lexc, lexc, conndict)
tp.ConnectLayers(linh, lexc, conndict)
nest.DivergentConnect(mm, nest.GetLeaves(lexc)[0])
nest.DivergentConnect(exc, nest.GetLeaves(lexc)[0])
nest.DivergentConnect(inh, nest.GetLeaves(linh)[0])
d = nest.GetStatus(mm)[0]['events']['V_m']
nest.Simulate(100)
events = nest.GetStatus(mm)[0]['events']
t = events['times']
print d, t, events
pl.clf()
pl.subplot(211)
pl.plot(t, events['V_m'])
#pl.axis([0, 100, -75, -53])
pl.ylabel('Membrane potential [mV]')
rate = 10.0
nu_ext = 5.0
g = -5.0
w_exc = 70.0
w_inh = g*w_exc
alpha = ???
nest.ResetKernel()
neuron = nest.Create('iaf_psc_alpha',1,{'tau_minus': 20.0})
pg_exc = nest.Create('poisson_generator',1,{'rate': rate})
inputs = nest.Create('parrot_neuron',CE)
pg_inh = nest.Create('poisson_generator',1,{'rate': CI*rate})
pg_ext = nest.Create('poisson_generator',1,{'rate': CE*nu_ext})
nest.SetDefaults('stdp_synapse',{'tau_plus': 20.0,
'mu_plus': mu,
'mu_minus': mu,
'alpha': alpha,
'lambda': 0.1,
'Wmax': 2.0*w_exc})
nest.DivergentConnect(pg_exc,inputs,1.0,1.0,'static_synapse')
nest.ConvergentConnect(inputs,neuron,w_exc,1.0,'stdp_synapse')
nest.Connect(pg_inh,neuron,w_inh,1.0,'static_synapse')
nest.Connect(pg_ext,neuron,w_exc,1.0,'static_synapse')
'start': 0.,
'stop': 2000.
})
sd = nest.Create('spike_detector',
params={
'to_file': True,
'label': file_name_sd
})
vm = nest.Create('voltmeter', params={'interval': 0.01})
nest.SetStatus(vm, [{
"withtime": True,
'to_file': True,
'label': file_name_mem
}])
nest.DivergentConnect(dc_gen, neuron, weight=1.0, delay=1.0)
nest.Connect(vm, neuron)
nest.Connect(neuron, sd)
nest.Simulate(T)
spikes = nest.GetStatus(sd, 'events')[0]
potential = nest.GetStatus(vm, 'events')[0]
ax1 = fig.add_axes([0.1, 0.8 - (i * 0.125), 0.33, 0.1])
#ax1 = fig.add_axes([0.6,0.66 - (i*0.22),0.37,0.2])
ax1.plot(potential['times'], potential['V_m'], col_lis[i], linewidth=2)
ax1.plot(spikes['times'], spikes['senders'] - 50., "ko", markersize=3)
yr = np.arange(-80., -40., 10.)
ax1.set_yticks(yr[::3])
for tl in ax1.get_yticklabels():
tl.set_fontsize(ticksize)
#if i == 0:
#ax1.title('Regular Spiking', fontsize = 50)
def DivergentConnect(pre, post, *args, **kwargs):
if hasattr(nest, 'DivergentConnect'):
nest.DivergentConnect(pre, post, *args, **kwargs)
else:
nest.Connect(pre, post, *args, **kwargs)
nest.ResetKernel()
nest.SetKernelStatus({'local_num_threads':
4}) # show this work for multiple threads
g = nest.Create('sinusoidal_poisson_generator',
params={
'dc': 100.0,
'ac': 50.0,
'freq': 10.0,
'phi': 0.0,
'individual_spike_trains': True
})
p = nest.Create('parrot_neuron', 20)
s = nest.Create('spike_detector')
nest.DivergentConnect(g, p)
nest.ConvergentConnect(p, s)
nest.Simulate(200)
ev = nest.GetStatus(s)[0]['events']
plt.subplot(222)
plt.plot(ev['times'], ev['senders'] - min(ev['senders']), 'o')
plt.ylim([-0.5, 19.5])
plt.yticks([])
plt.title('Individual spike trains for each target')
# now one spike train for all targets
nest.ResetKernel()
nest.SetKernelStatus({'local_num_threads':
4}) # show this work for multiple threads
"withtime": True,
"withgid": True
}])
print "Connecting devices."
nest.CopyModel("static_synapse", "excitatory", {
"weight": J_ex,
"delay": delay
})
nest.CopyModel("static_synapse", "inhibitory", {
"weight": J_in,
"delay": delay
})
nest.DivergentConnect(noise, nodes_ex, model="excitatory")
nest.DivergentConnect(noise, nodes_in, model="excitatory")
nest.ConvergentConnect(range(1, N_rec + 1), espikes, model="excitatory")
nest.ConvergentConnect(range(NE + 1, NE + 1 + N_rec),
ispikes,
model="excitatory")
print "Connecting network."
# We now iterate over all neuron IDs, and connect the neuron to
# the sources from our array. The first loop connects the excitatory neurons
# and the second loop the inhibitory neurons.
print "Excitatory connections"
def createGenericPlaceCells(self,
N,
maxRate,
weight,
start=None,
end=None,
posIn=None):
'''
Generate place cells and connect them to grid cells. The wiring is
fixed, and there is no plasticity. This method can be used more than
once, to set up different populations of place cells.
'''
if start is None:
start = self.no.theta_start_t
if end is None:
end = self.no.time
if posIn is None:
self._loadRatVelocities()
posIn = PosInputs(self.rat_pos_x, self.rat_pos_y, self.rat_dt)
if N != 0:
gcnLogger.info('Setting up generic place cells')
NTotal = N * N
boxSize = [self.no.arenaSize, self.no.arenaSize]
PCHelper = UniformBoxPlaceCells(boxSize, (N, N),
maxRate,
self.no.pc_field_std,
random=False)
PC = nest.Create('place_cell_generator',
NTotal,
params={
'rate': maxRate,
'field_size': self.no.pc_field_std,
'start': start,
'stop': end
})
nest.SetStatus(PC, 'ctr_x', PCHelper.centers[:, 0])
nest.SetStatus(PC, 'ctr_y', PCHelper.centers[:, 1])
npos = int(self.no.time / posIn.pos_dt)
nest.SetStatus(
[PC[0]],
params={
'rat_pos_x': list(posIn.pos_x[0:npos]),
'rat_pos_y': list(posIn.pos_y[0:npos]),
'rat_pos_dt': posIn.pos_dt
})
# test_x = nest.GetStatus([PC[0]], 'rat_pos_x')
# test_y = nest.GetStatus([PC[0]], 'rat_pos_y')
# print test_x, test_y
# Connections
# Here we extract connections from the PlaceCellInput class that
# was originaly used as a current input generator for place cell
# resetting mechanism. The output of this class perfectly matches
# how divergent connections from a single place cell should be
# mapped onto the twisted torus grid cell sheet
# how divergent the connections are, 3sigma rule --> division by 6.
connStdDev = self.no.gridSep / 2. / 6.
pc_weight_threshold = 0.1
pc_input = PlaceCellInput(self.Ne_x,
self.Ne_y,
self.no.arenaSize,
self.no.gridSep, [.0, .0],
fieldSigma=connStdDev)
ctr_x = nest.GetStatus(PC, 'ctr_x')
ctr_y = nest.GetStatus(PC, 'ctr_y')
for pc_id in xrange(NTotal):
w = pc_input.getSheetInput(ctr_x[pc_id],
ctr_y[pc_id]).flatten()
gt_th = w > pc_weight_threshold
post = np.array(self.E_pop)[gt_th]
w = w[gt_th]
# print post, w
nest.DivergentConnect([PC[pc_id]],
list(post),
weight=list(w * weight),
delay=[self.no.delay] * len(w),
model='PC_AMPA')
return PC, PCHelper, NTotal
else:
gcnLogger.warn("trying to set up place cells with N_place_cells "
"== 0")
self._placeCellsLoaded = True
np.array([204., 187., 20.]) / 255.
]
amp_arr = np.arange(65000., 80000., 2000.)
sup_fr_lis = []
fig = pl.figure(1, (8, 5))
ax1 = fig.add_axes([0.55, 0.135, 0.37, 0.79])
for kk, jj in enumerate(np.arange(5.)):
fr_lis = []
for ii in amp_arr:
nest.ResetKernel()
dc_gen = nest.Create("poisson_generator", params={'rate': ii})
aa = nest.Create("psdb", params={'spb': jj + 1})
#aa = nest.Create('iaf_neuron')
sd = nest.Create('spike_detector')
nest.Connect(aa, sd)
nest.DivergentConnect(dc_gen, aa, weight=1., delay=1.)
nest.Simulate(tsim)
spikes = nest.GetStatus(sd, 'events')[0]
num_spikes = len(spikes['senders'])
f_rate = (num_spikes * 1000) / tsim
fr_lis.append(f_rate)
ax1.plot(amp_arr,
fr_lis,
lw=5.,
alpha=0.7,
color=col_lis[kk],
label=str(jj + 1))
pl.legend(loc='best', prop={'size': 10.})
#pl.xlim(300,500)
ax1.set_ylim(0, 40)
#! This recording device setup is a bit makeshift. For each population
#! we want to record from, we create one ``multimeter``, then select
#! all nodes of the right model from the target population and
#! connect. ``loc`` is the subplot location for the layer.
print "Connecting: Recording devices"
recorders = {}
for name, loc, population, model in [('TpRelay', 1, Tp, 'TpRelay'),
('Rp', 2, Rp, 'RpNeuron'),
('Vp_v L4pyr', 3, Vp_v, 'L4pyr'),
('Vp_h L4pyr', 4, Vp_h, 'L4pyr')]:
recorders[name] = (nest.Create('RecordingNode'), loc)
tgts = [
nd for nd in nest.GetLeaves(population)[0]
if nest.GetStatus([nd], 'model')[0] == model
]
nest.DivergentConnect(recorders[name][0], tgts)
#! Example simulation
#! ====================
#! 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.
'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(sd, [sdparams])
nest.SetStatus(neurons, [neuronparams])
nest.SetStatus(neurons, map(bias, neurons))
nest.DivergentConnect(drive, neurons)
nest.DivergentConnect(noise, neurons)
nest.ConvergentConnect(neurons, sd)
nest.Simulate(T)
print "nest model processing complete with %s neurons" % N
nest.raster_plot.from_device(sd)
nest.raster_plot.show()
