def test_on_neurons(self, pop_size):
pynn.setup(marocco=self.marocco)
pop = pynn.Population(pop_size, pynn.IF_cond_exp, {})
neuron_block = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(3))
logical_neurons = [
(LogicalNeuron.on(neuron_block)
.add(C.NeuronOnNeuronBlock(X(3), Y(0)), 2)
.add(C.NeuronOnNeuronBlock(X(3), Y(1)), 2)
.done()),
(LogicalNeuron.on(neuron_block)
.add(C.NeuronOnNeuronBlock(X(11), Y(0)), 2)
.add(C.NeuronOnNeuronBlock(X(11), Y(1)), 2)
.done()),
]
self.marocco.manual_placement.on_neuron(pop, logical_neurons)
if pop_size != len(logical_neurons):
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
return
pynn.run(0)
pynn.end()
results = self.load_results()
for nrn, logical_neuron in zip(pop, logical_neurons):
placement_item, = results.placement.find(nrn)
self.assertEqual(logical_neuron, placement_item.logical_neuron())
def test_popview_on_neuron(self):
pynn.setup(marocco=self.marocco)
pop = pynn.Population(4, pynn.IF_cond_exp, {})
neuron_block = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(3))
neuron_block_1 = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(2))
logical_neuron = (LogicalNeuron.on(neuron_block)
.add(C.NeuronOnNeuronBlock(X(3), Y(0)), 2)
.add(C.NeuronOnNeuronBlock(X(3), Y(1)), 2)
.done())
logical_neuron_1 = (LogicalNeuron.on(neuron_block_1)
.add(C.NeuronOnNeuronBlock(X(4), Y(0)), 2)
.add(C.NeuronOnNeuronBlock(X(4), Y(1)), 2)
.done())
popview = pynn.PopulationView(pop,[0])
popview_1 = pynn.PopulationView(pop,[2])
popview_auto_placement= pynn.PopulationView(pop,[1,3])
self.marocco.manual_placement.on_neuron(popview, logical_neuron)
self.marocco.manual_placement.on_neuron(popview_1, logical_neuron_1)
pynn.run(0)
pynn.end()
results = self.load_results()
placement_item, = results.placement.find(popview[0])
self.assertEqual(logical_neuron, placement_item.logical_neuron())
placement_item, = results.placement.find(popview_1[0])
self.assertEqual(logical_neuron_1, placement_item.logical_neuron())
for nrn in popview_auto_placement:
placement_item, = results.placement.find(nrn)
self.assertIsNotNone(placement_item.logical_neuron())
def test_on_neuron_wrong_shape(self):
pynn.setup(marocco=self.marocco)
pop = pynn.Population(1, pynn.IF_cond_exp, {})
neuron_block = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(3))
logical_neuron = (LogicalNeuron.on(neuron_block)
.add(C.NeuronOnNeuronBlock(X(2), Y(0)), 4)
.add(C.NeuronOnNeuronBlock(X(3), Y(1)), 2)
.done())
self.marocco.manual_placement.on_neuron(pop, logical_neuron)
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
def test(self):
wafer = 99999 # a wafer for which no redman data is availale
hicann = 82
neuron_number = 12
marocco = PyMarocco()
marocco.neuron_placement.default_neuron_size(4)
marocco.backend = PyMarocco.Without
marocco.default_wafer = C.Wafer(wafer)
used_hicann = C.HICANNGlobal(C.HICANNOnWafer(Enum(hicann)),
C.Wafer(wafer))
used_hicann # prevent pep8 warning of unused variable
pynn.setup(marocco=marocco)
pop = pynn.Population(1, pynn.IF_cond_exp)
topleft = C.NeuronOnWafer(C.NeuronOnHICANN(X(neuron_number), Y(0)),
C.HICANNOnWafer(Enum(hicann)))
logical_neuron = LogicalNeuron.rectangular(topleft, size=4)
marocco.manual_placement.on_neuron(pop, logical_neuron)
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
def test_on_neuron(self):
pynn.setup(marocco=self.marocco)
pop = pynn.Population(1, pynn.IF_cond_exp, {})
neuron_block = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(3))
logical_neuron = (LogicalNeuron.on(neuron_block)
.add(C.NeuronOnNeuronBlock(X(3), Y(0)), 2)
.add(C.NeuronOnNeuronBlock(X(3), Y(1)), 2)
.done())
self.marocco.manual_placement.on_neuron(pop, logical_neuron)
pynn.run(0)
pynn.end()
results = self.load_results()
placement_item, = results.placement.find(pop[0])
self.assertEqual(logical_neuron, placement_item.logical_neuron())
def parse_dnc(arg):
"""Helper to parse dnc coordinate, given as <x,y> or as <enum>"""
tmp = arg.split(",")
if len(tmp) == 1:
return DNCOnWafer(Enum(int(tmp[0])))
elif len(tmp) == 2:
xcoord, ycoord = tmp
return DNCOnWafer(X(int(xcoord)), Y(int(ycoord)))
else:
raise argparse.ArgumentTypeError(
"Please provide --dnc <x,y> or --dnc <enum>")
def test_TwoNeuron(self):
if True:
pynn.setup(marocco=self.marocco)
# create neuron with v_rest below v_thresh
source = pynn.Population(1, pynn.EIF_cond_exp_isfa_ista, {
'v_rest': -50.,
'v_thresh': -60.,
'v_reset': -70.6,
})
N = 8 # number of target populations
p = [
pynn.Population(1, pynn.EIF_cond_exp_isfa_ista)
for i in range(N)
]
# place source on HICANN 0
source_hicann = self.chip(0)
self.marocco.manual_placement.on_hicann(source, source_hicann)
# place targets on all HICANNs on same reticle but random neurons
nrns = self.shuffle(255)
for ii, pop in enumerate(p):
hicann = HICANNGlobal(X(int(source_hicann.x()) + ii % 4),
Y(int(source_hicann.y()) + ii // 4))
self.marocco.manual_placement.on_hicann(pop, hicann)
print(pop, hicann)
connector = pynn.AllToAllConnector(allow_self_connections=True,
weights=1.)
store = []
# connect source to targets
for trg in p:
proj = pynn.Projection(source,
trg,
connector,
target='excitatory')
weights = copy.deepcopy(proj.getWeights())
store.append((proj, weights))
# start simulation
pynn.run(10) # in ms
pynn.end()
# make sure we have no synapse loss
self.assertEqual(0, self.marocco.stats.getSynapseLoss())
# assert weights are the same (at least as long as we don't send be
# the transformed digital weights)
for proj, weights in store:
self.assertEqual(self.marocco.stats.getWeights(proj), weights)
def parse_arg(arg):
tmp = arg.split(",")
if len(tmp) == 1:
coord = CoordinateType(Enum(int(tmp[0])))
elif len(tmp) == 2:
x, y = tmp
coord = CoordinateType(X(int(x)), Y(int(y)))
else:
raise argparse.ArgumentTypeError(
"Please provide {0} <x,y> or {0} <enum>".format(
arg_name))
return formatter(coord)
def test_on_rectangular_neuron(self):
pynn.setup(marocco=self.marocco)
pop = pynn.Population(1, pynn.IF_cond_exp, {})
topleft = C.NeuronOnWafer(C.NeuronOnHICANN(X(2), Y(0)))
logical_neuron = LogicalNeuron.rectangular(topleft, size=4)
self.marocco.manual_placement.on_neuron(pop, logical_neuron)
pynn.run(0)
pynn.end()
results = self.load_results()
placement_item, = results.placement.find(pop[0])
self.assertEqual(logical_neuron, placement_item.logical_neuron())
def test_basic(self):
"""
tests the routing and parameter trafo of a IF_multicond_exp neuron
with 4 different synaptic input settings.
For 4 synaptic targets and hardware neuron size 4, the mapping of
synapse types is as follows:
Denmem: | 0 | 1 |
Synapse Type: |0 1|2 3| (left and right input)
Build a minimal network with 1 neuron and 4 spike sources each
connecting to different synaptic target on the neuron. Then check that
the configuration of the synapse driver and synapses is as expected.
Furthermore, check that the different parameters for e_rev and tau_syn
are correctly transformed by getting the FG values (qualitatively).
"""
marocco = pymarocco.PyMarocco()
marocco.backend = pymarocco.PyMarocco.Without
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.defects.backend = pymarocco.Defects.Backend.Without
marocco.neuron_placement.default_neuron_size(4)
marocco.wafer_cfg = os.path.join(self.temporary_directory, "wafer.bin")
marocco.persist = os.path.join(self.temporary_directory, "results.bin")
used_hicann = HICANNGlobal(Enum(0))
pynn.setup(marocco=marocco)
p1 = pynn.Population(1, pynn.IF_multicond_exp)
# we use 4 different time constants and reversal potentials
p1.set('e_rev', [0., -10, -80, -100])
p1.set('tau_syn', [2, 3, 4, 5])
# place to a certain HICANN to be able to extract config data afterwards
topleft = NeuronOnWafer(NeuronOnHICANN(X(0), Y(0)), used_hicann)
logical_neuron = LogicalNeuron.rectangular(topleft, size=4)
marocco.manual_placement.on_neuron(p1, logical_neuron)
s1 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
s2 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
s3 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
s4 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
prj1 = pynn.Projection(s1,
p1,
pynn.OneToOneConnector(weights=0.01),
target="0")
prj2 = pynn.Projection(s2,
p1,
pynn.OneToOneConnector(weights=0.01),
target="1")
prj3 = pynn.Projection(s3,
p1,
pynn.OneToOneConnector(weights=0.01),
target="2")
prj4 = pynn.Projection(s4,
p1,
pynn.OneToOneConnector(weights=0.01),
target="3")
p1.record()
pynn.run(1.)
h = debug_config.load_hicann_cfg(marocco.wafer_cfg, used_hicann)
# routing config
active_drivers = []
driver_c = None
for driver in iter_all(SynapseDriverOnHICANN):
drv_cfg = h.synapses[driver]
if drv_cfg.is_enabled():
active_drivers.append(drv_cfg)
driver_c = driver
assert len(active_drivers) == 1
act_drv = active_drivers[0]
# two different synaptic input sides are used on the synapse driver
syn_input_top = debug_config.get_syn_in_side(
act_drv[RowOnSynapseDriver(top)])
syn_input_bot = debug_config.get_syn_in_side(
act_drv[RowOnSynapseDriver(bottom)])
self.assertNotEqual(syn_input_top, syn_input_bot)
# assumed column and input side:
exptected_mapping = [(s1, SynapseColumnOnHICANN(0), left),
(s2, SynapseColumnOnHICANN(0), right),
(s3, SynapseColumnOnHICANN(1), left),
(s4, SynapseColumnOnHICANN(1), right)]
results = Marocco.from_file(marocco.persist)
for (src, col, side) in exptected_mapping:
items = list(results.placement.find(src[0]))
self.assertEqual(1, len(items))
item = items[0]
addr = item.address().toL1Address()
syns = debug_config.find_synapses(h.synapses, driver_c, addr)
self.assertEqual(1, len(syns))
syn = syns[0]
# check synapse column
self.assertEqual(syn.toSynapseColumnOnHICANN(), col)
# check synaptic input side
row_addr = syn.toSynapseRowOnHICANN()
self.assertEqual(
debug_config.get_syn_in_side(
act_drv[row_addr.toRowOnSynapseDriver()]), side)
# FG values
nrn_left = NeuronOnHICANN(X(0), Y(0))
nrn_right = NeuronOnHICANN(X(1), Y(0))
fgs = h.floating_gates
# e_rev params are montonic decreasing
E1 = fgs.getNeuron(nrn_left, nrn_param.E_synx)
E2 = fgs.getNeuron(nrn_left, nrn_param.E_syni)
E3 = fgs.getNeuron(nrn_right, nrn_param.E_synx)
E4 = fgs.getNeuron(nrn_right, nrn_param.E_syni)
E = [E1, E2, E3, E4]
for k, l in zip(E, E[1:]):
self.assertGreater(k, l)
# tau_syn params are montonic increasing
T1 = fgs.getNeuron(nrn_left, nrn_param.V_syntcx)
T2 = fgs.getNeuron(nrn_left, nrn_param.V_syntci)
T3 = fgs.getNeuron(nrn_right, nrn_param.V_syntcx)
T4 = fgs.getNeuron(nrn_right, nrn_param.V_syntci)
T = [T1, T2, T3, T4]
# HICANN V4: The lower the DAC-Value, the higher the time constant
for k, l in zip(T, T[1:]):
self.assertGreater(k, l)
for neuron in pop:
for item in results.placement.find(neuron):
for denmem in item.logical_neuron():
yield denmem
marocco = PyMarocco()
marocco.calib_backend = PyMarocco.CalibBackend.Default
marocco.defects.backend = Defects.Backend.None
marocco.neuron_placement.skip_hicanns_without_neuron_blacklisting(False)
marocco.persist = "results.xml.gz"
pynn.setup(marocco=marocco)
# place the full population to a specific HICANN
pop = pynn.Population(1, pynn.IF_cond_exp)
marocco.manual_placement.on_hicann(pop, HICANNOnWafer(X(5), Y(5)), 4)
# place only parts of a population
pop2 = pynn.Population(3, pynn.IF_cond_exp)
marocco.manual_placement.on_hicann(pynn.PopulationView(pop2, [0]),
HICANNOnWafer(Enum(5)))
marocco.manual_placement.on_hicann(pynn.PopulationView(pop2, [1]),
HICANNOnWafer(Enum(1)))
# the third neuron will be automatically placed
pynn.run(10)
pynn.end()
results = Marocco.from_file(marocco.persist)
for denmem in get_denmems(pop, results):
def test_NeuronCurrentStimHWTest(self):
fgc = HICANN.FGControl()
fg_config = HICANN.FGConfig()
for block in [Enum(0), Enum(1)]:
block = Coordinate.FGBlockOnHICANN(block)
HICANN.set_fg_config(self.h, block, fg_config)
HICANN.set_fg_values(self.h, block, fgc.getBlock(block))
# 2nd: configure the neuron
nrn = HICANN.Neuron()
#HICANN.Neuron other_nrn = HICANN.Neuron()
nrn.address(HICANN.L1Address(42))
nrn.activate_firing(True)
nrn.enable_spl1_output(True)
nrn.enable_fire_input(False)
nrn.enable_aout(True)
nrn.enable_current_input(True)
nquad = HICANN.NeuronQuad()
nquad[Coordinate.NeuronOnQuad(X(0), Y(0))] = nrn
HICANN.set_denmem_quad(self.h, Coordinate.QuadOnHICANN(0), nquad)
# NEURON CONFIG
nrn_cfg = HICANN.NeuronConfig()
nrn_cfg.bigcap.set(Coordinate.top)
HICANN.set_neuron_config(self.h, nrn_cfg)
# set ANALOG
ac = HICANN.Analog()
ac.set_membrane_top_even(Coordinate.AnalogOnHICANN(0))
HICANN.set_analog(self.h, ac)
# CURRENT STIMULUS
fg_config = HICANN.FGConfig()
fg_config.pulselength = 15
for block in [Enum(0), Enum(1)]:
block = Coordinate.FGBlockOnHICANN(block)
HICANN.set_fg_config(self.h, block, fg_config)
stimulus = HICANN.FGStimulus()
stimulus.setContinuous(True)
stimulus[:40] = [800] * 40
stimulus[40:] = [0] * (len(stimulus) - 40)
HICANN.set_current_stimulus(self.h,
Coordinate.FGBlockOnHICANN(Enum(0)),
stimulus)
# READOUT PULSES!
#configure merger tree, phase
tree = HICANN.MergerTree()
#default settings are OK
HICANN.set_merger_tree(self.h, tree)
HICANN.set_phase(self.h)
dnc_mergers = HICANN.DNCMergerLine()
for i in range(8):
# rcv from HICANN
mer = Coordinate.DNCMergerOnHICANN(i)
dnc_mergers[mer].config = HICANN.Merger.RIGHT_ONLY
dnc_mergers[mer].slow = False
dnc_mergers[mer].loopback = False
HICANN.set_dnc_merger(self.h, dnc_mergers)
# DNC and dnc_if:
gbit = Coordinate.GbitLinkOnHICANN(0)
gl = HICANN.GbitLink()
gl.dirs[gbit.value()] = HICANN.GbitLink.Direction.TO_DNC
gr = DNC.GbitReticle()
gr[self.h.to_HICANNOnDNC()] = gl
HICANN.set_gbit_link(self.h, gl)
DNC.set_hicann_directions(self.fpga, self.dnc, gr)
HICANN.flush(self.h)
rec_pulses = FPGA.receive(self.fpga, self.dnc, 10000)
# 10 ms
print(str(rec_pulses.size()) + " packets received")
self.assertGreater(rec_pulses.size(), 0)
# Check for correct addrss of spikes
for np in range(rec_pulses.size()):
pulse = rec_pulses.get(np)
self.assertEqual(HICANN.L1Address(42), pulse.getNeuronAddress())
self.assertEqual(gbit, pulse.getChannel())
self.assertEqual(self.hicann, pulse.getChipAddress())
self.assertEqual(self.dnc, pulse.getDncAddress())
#turn off links
gl.dirs[0] = HICANN.GbitLink.Direction.OFF
gr[Coordinate.HICANNOnDNC(Enum(0))] = gl
HICANN.set_gbit_link(self.h, gl)
DNC.set_hicann_directions(self.fpga, self.dnc, gr)
HICANN.flush(self.h)
def read_fg_cell(self,cell_x,cell_y):
ph.HICANN.set_fg_cell(self.h, self.fg_coord, pyhalco_hicann_v2.FGCellOnFGBlock(X(cell_x),Y(cell_y)))
ph.HICANN.flush(self.h)
ph.ADC.trigger_now(self.adc)
raw_trace = ph.ADC.get_trace(self.adc)
trace = pylab.array(raw_trace, dtype=pylab.ushort)
calibrated_trace = self.adc_calib.apply(self.adc_channel, trace)
return calibrated_trace
def test_find_neuron_in_analog_output(self):
"""
Check if find_neuron_in_analog_output works.
"""
import pysthal
from pyhalco_common import iter_all, X, Y
from pyhalco_hicann_v2 import NeuronOnHICANN, AnalogOnHICANN
hicann = pysthal.HICANN()
NeuronOnHICANN.__repr__ = NeuronOnHICANN.__str__
# Nothing active, this should throw
for analog in iter_all(AnalogOnHICANN):
with self.assertRaises(RuntimeError):
hicann.find_neuron_in_analog_output(analog)
# Enable 4 neurons, connected to different analog mux entries, but not
# the mux yet, this should throw
hicann.neurons[NeuronOnHICANN(X(0), Y(0))].enable_aout(True)
hicann.neurons[NeuronOnHICANN(X(1), Y(0))].enable_aout(True)
hicann.neurons[NeuronOnHICANN(X(0), Y(1))].enable_aout(True)
hicann.neurons[NeuronOnHICANN(X(1), Y(1))].enable_aout(True)
for analog in iter_all(AnalogOnHICANN):
with self.assertRaises(RuntimeError):
hicann.find_neuron_in_analog_output(analog)
# Now enable the mux for each of the neurons and check if the correct
# neuron was found
for analog in iter_all(AnalogOnHICANN):
hicann.analog.set_membrane_top_even(analog)
self.assertEqual(NeuronOnHICANN(X(0), Y(0)),
hicann.find_neuron_in_analog_output(analog))
hicann.analog.set_membrane_top_odd(analog)
self.assertEqual(NeuronOnHICANN(X(1), Y(0)),
hicann.find_neuron_in_analog_output(analog))
hicann.analog.set_membrane_bot_even(analog)
self.assertEqual(NeuronOnHICANN(X(0), Y(1)),
hicann.find_neuron_in_analog_output(analog))
hicann.analog.set_membrane_bot_odd(analog)
self.assertEqual(NeuronOnHICANN(X(1), Y(1)),
hicann.find_neuron_in_analog_output(analog))
hicann.analog.disable(analog)
# Now enable 4 more, each connected to different analog mux entries,
# now it should fail, because two neurons are connected
hicann.neurons[NeuronOnHICANN(X(30), Y(0))].enable_aout(True)
hicann.neurons[NeuronOnHICANN(X(41), Y(0))].enable_aout(True)
hicann.neurons[NeuronOnHICANN(X(10), Y(1))].enable_aout(True)
hicann.neurons[NeuronOnHICANN(X(255), Y(1))].enable_aout(True)
for analog in iter_all(AnalogOnHICANN):
hicann.analog.set_membrane_top_even(analog)
with self.assertRaises(RuntimeError):
hicann.find_neuron_in_analog_output(analog)
hicann.analog.set_membrane_top_odd(analog)
with self.assertRaises(RuntimeError):
hicann.find_neuron_in_analog_output(analog)
hicann.analog.set_membrane_bot_even(analog)
with self.assertRaises(RuntimeError):
hicann.find_neuron_in_analog_output(analog)
hicann.analog.set_membrane_bot_odd(analog)
with self.assertRaises(RuntimeError):
hicann.find_neuron_in_analog_output(analog)
hicann.analog.disable(analog)
# Now disable the first 4 neurons, and everything should be fine again
hicann.neurons[NeuronOnHICANN(X(0), Y(0))].enable_aout(False)
hicann.neurons[NeuronOnHICANN(X(1), Y(0))].enable_aout(False)
hicann.neurons[NeuronOnHICANN(X(0), Y(1))].enable_aout(False)
hicann.neurons[NeuronOnHICANN(X(1), Y(1))].enable_aout(False)
for analog in iter_all(AnalogOnHICANN):
hicann.analog.set_membrane_top_even(analog)
self.assertEqual(NeuronOnHICANN(X(30), Y(0)),
hicann.find_neuron_in_analog_output(analog))
hicann.analog.set_membrane_top_odd(analog)
self.assertEqual(NeuronOnHICANN(X(41), Y(0)),
hicann.find_neuron_in_analog_output(analog))
hicann.analog.set_membrane_bot_even(analog)
self.assertEqual(NeuronOnHICANN(X(10), Y(1)),
hicann.find_neuron_in_analog_output(analog))
hicann.analog.set_membrane_bot_odd(analog)
self.assertEqual(NeuronOnHICANN(X(255), Y(1)),
hicann.find_neuron_in_analog_output(analog))
hicann.analog.disable(analog)
def test_BGToNeuronMembrane(self):
"""Try to send periodic events from a background generator to a neuron.
Please note that this test relies on the default config values in most objects
and only changes those necessary to run the test."""
weight = 15
period = 700 * 2
event = HICANN.L1Address(0)
offevent = HICANN.L1Address(55)
trace_length = 19500
exc = True
inh = False
E_syn = (570, 570)
firing = False
firingevent = HICANN.L1Address(42)
# FIXME: Differs from HICANN to HICANN, this needs connection database
analog = Coordinate.AnalogOnHICANN(1)
adc_channel = 7
neuron = Coordinate.NeuronOnHICANN(Enum(15))
vline = Coordinate.VLineOnHICANN(28) # or 60, 92, 124
driver = Coordinate.SynapseDriverOnHICANN(Y(111), left)
synapse_row = Coordinate.SynapseRowOnHICANN(driver, top)
##############################
# set floating gate values #
##############################
fgcfg = HICANN.FGConfig()
fgctrl = HICANN.FGControl()
# Set same reverse potential for both synaptic inputs (for all neurons)
for ii in range(512):
nrn = Coordinate.NeuronOnHICANN(Enum(ii))
fgctrl.setNeuron(nrn, HICANN.neuron_parameter.E_synx, E_syn[0])
fgctrl.setNeuron(nrn, HICANN.neuron_parameter.E_syni, E_syn[1])
fgctrl.setNeuron(nrn, HICANN.neuron_parameter.I_bexp, 0)
for block in Coordinate.iter_all(Coordinate.FGBlockOnHICANN):
HICANN.set_fg_config(self.h, block, fgcfg)
HICANN.set_fg_values(self.h, fgctrl)
##############################
# set global neuron config #
##############################
nconf = HICANN.NeuronConfig()
nconf.bigcap[int(top)] = True
nconf.bigcap[int(bottom)] = True
HICANN.set_neuron_config(self.h, nconf)
#################
# set mergers #
#################
dnc = HICANN.DNCMergerLine()
for i in range(8):
mer = Coordinate.DNCMergerOnHICANN(i)
dnc[mer].slow = True
dnc[mer].config = HICANN.Merger.RIGHT_ONLY
# Tree defaults to one on one passthrough (forward downwards)
tree = HICANN.MergerTree()
HICANN.set_dnc_merger(self.h, dnc)
HICANN.set_merger_tree(self.h, tree)
##########################
# background generator #
##########################
# We use one background generator to provide events
gens = HICANN.BackgroundGeneratorArray()
g = gens[7]
g.enable(True)
g.random(False)
g.period(period)
g.address(event)
HICANN.set_background_generator(self.h, gens)
# Forward its output to this HICANN
srepeater = Coordinate.OutputBufferOnHICANN(7).repeater()
sr = HICANN.HorizontalRepeater()
sr.setOutput(right)
HICANN.set_repeater(self.h, srepeater.horizontal(), sr)
###############################################
# connect via Crossbars and SynapseSwitches #
###############################################
hline = srepeater.toHLineOnHICANN()
cb = HICANN.Crossbar()
cb.set(vline, hline, True)
HICANN.set_crossbar_switch_row(self.h, hline, vline.toSideHorizontal(),
cb.get_row(hline, vline.toSideHorizontal()))
# Connect VLine to synapse driver
sw = HICANN.SynapseSwitch()
sw.set(vline, driver.toHLineOnHICANN(), True)
HICANN.set_syndriver_switch_row(self.h, driver.toSynapseSwitchRowOnHICANN(),
sw.get_row(driver.toSynapseSwitchRowOnHICANN()))
########################
# set synapse driver #
########################
drv = HICANN.SynapseDriver()
drv.set_l1()
drv[top].set_syn_in(left, exc)
drv[top].set_syn_in(right, inh)
drv[bottom].set_syn_in(left, exc)
drv[bottom].set_syn_in(right, inh)
HICANN.set_synapse_driver(self.h, HICANN.SynapseController(), driver, drv)
decoders = HICANN.DecoderDoubleRow()
weights = HICANN.WeightRow()
# Reset decoders and weights to 'off' state
for ii in range(2):
for jj in range(256):
decoders[ii][jj] = offevent.getSynapseDecoderMask()
for ii in range(256):
weights[ii] = 0
# Only enable decoders/weights for background generator and neuron
decoders[0][int(neuron.x())] = event.getSynapseDecoderMask()
weights[int(neuron.x())] = weight
HICANN.set_decoder_double_row(self.h, HICANN.SynapseController() ,driver, decoders)
HICANN.set_weights_row(self.h, HICANN.SynapseController(), synapse_row, weights)
###################
# get ADC trace #
###################
self.set_denmem_quads(
neuron, address=firingevent,
activate_firing=firing,
enable_aout=True)
self.set_analog(analog, neuron)
trace, v, t = self.get_trace(adc_channel, trace_length)
if False:
import pylab
fig, ax = pylab.subplots()
ax.plot(t, v)
pylab.show()
## Case 1: Sometimes the membrane seems 'stuck' at 1.2V
self.assertNotAlmostEqual(v.mean(), 1.2, places=1)
self.assertGreater(v.std(), 0.01)