API Reference: lola

struct Adaptation

#include <neuron.h>

Public Functions

Adaptation () SYMBOL_VISIBLE

bool operator!= (Adaptation const &other) const SYMBOL_VISIBLE

bool operator== (Adaptation const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Enable adaptation term.

bool enable_pulse

Enable neuron refractory pulse reaching the adaptation circuitry.

The length of the adaptation pulse is set in the common neuron backend.

AnalogValueVariant i_bias_a

Bias current controlling the sub-threshold adaptation strength.

AnalogValueVariant i_bias_b

Bias current controlling the spike-triggered adaptation strength.

AnalogValueVariant i_bias_tau

Bias current controlling the adaptation time constant.

bool invert_a

Flip the sign of a (sub-threshold adaptation).

bool invert_b

Flip the sign of b (spike-triggered adaptation).

AnalogValueVariant v_leak

Reference potential for adaptation OTA.

AnalogValueVariant v_ref

Adaptation reference potential the adaptation state variable is pulled towards.

Friends

friend std::ostream & operator<< (std::ostream &os, Adaptation const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::Adaptation

#include <neuron.h>

Public Functions

Adaptation () SYMBOL_VISIBLE

bool operator!= (Adaptation const &other) const SYMBOL_VISIBLE

bool operator== (Adaptation const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Enable adaptation term.

bool enable_pulse

Enable neuron refractory pulse reaching the adaptation circuitry.

The length of the adaptation pulse is set in the common neuron backend.

AnalogValueVariant i_bias_a

Bias current controlling the sub-threshold adaptation strength.

AnalogValueVariant i_bias_b

Bias current controlling the spike-triggered adaptation strength.

AnalogValueVariant i_bias_tau

Bias current controlling the adaptation time constant.

bool invert_a

Flip the sign of a (sub-threshold adaptation).

bool invert_b

Flip the sign of b (spike-triggered adaptation).

AnalogValueVariant v_leak

Reference potential for adaptation OTA.

AnalogValueVariant v_ref

Adaptation reference potential the adaptation state variable is pulled towards.

Friends

friend std::ostream & operator<< (std::ostream &os, Adaptation const &config) SYMBOL_VISIBLE

class lola::vx::v3::AtomicNeuron : public haldls::vx::ContainerBase<AtomicNeuron>

#include <neuron.h>

Configuration of digital and analog parameters for a single-denmem neuron.

Public Types

typedef haldls::vx::v3::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::v3::CapMemCell::Value AnalogValue

typedef haldls::vx::v3::CapMemCell::value_type AnalogValueVariant

typedef halco::hicann_dls::vx::v3::AtomicNeuronOnDLS coordinate_type

typedef std::false_type has_local_data

Public Functions

AtomicNeuron () SYMBOL_VISIBLE

explicit  operator haldls::vx::v3::NeuronConfig () const SYMBOL_VISIBLE

Allow converting to/from a haldls neuron config.

Public Members

Adaptation adaptation

Bayesian bayesian

ConstantCurrent constant_current

EventRouting event_routing

SynapticInput excitatory_input

Exponential exponential

SynapticInput inhibitory_input

Leak leak

MembraneCapacitance membrane_capacitance

Multicompartment multicompartment

Readout readout

RefractoryPeriod refractory_period

Reset reset

struct lola::vx::v3::AtomicNeuron::SynapticInput set_from

Threshold threshold

template<>
struct BackendContainerTrait<lola::vx::CHIP_REVISION_STR::CADCReadoutChain> : public BackendContainerBase<lola::vx::CHIP_REVISION_STR::CADCReadoutChain, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <cadc.h>

template<>
struct BackendContainerTrait<lola::vx::CHIP_REVISION_STR::CADCSampleRow> : public BackendContainerBase<lola::vx::CHIP_REVISION_STR::CADCSampleRow, fisch::vx::word_access_type::Omnibus>

#include <cadc.h>

template<>
struct BackendContainerTrait<lola::vx::CHIP_REVISION_STR::CADCSamples> : public BackendContainerBase<lola::vx::CHIP_REVISION_STR::CADCSamples, fisch::vx::word_access_type::Omnibus>

#include <cadc.h>

template<>
struct BackendContainerTrait<lola::vx::CHIP_REVISION_STR::SynapseBlock> : public BackendContainerBase<lola::vx::CHIP_REVISION_STR::SynapseBlock, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse_block.h>

template<>
struct BackendContainerTrait<lola::vx::CHIP_REVISION_STR::SynapseDriverBlock> : public BackendContainerBase<lola::vx::CHIP_REVISION_STR::SynapseDriverBlock, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse_driver.h>

template<>
struct BackendContainerTrait<lola::vx::ColumnCorrelationRow> : public BackendContainerBase<lola::vx::ColumnCorrelationRow, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::ColumnCurrentRow> : public BackendContainerBase<lola::vx::ColumnCurrentRow, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::CorrelationResetRow> : public BackendContainerBase<lola::vx::CorrelationResetRow, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::DACChannelBlock> : public BackendContainerBase<lola::vx::DACChannelBlock, fisch::vx::word_access_type::SPIDACDataRegister>

#include <dac.h>

template<>
struct BackendContainerTrait<lola::vx::DACControlBlock> : public BackendContainerBase<lola::vx::DACControlBlock, fisch::vx::word_access_type::SPIDACControlRegister>

#include <dac.h>

template<>
struct BackendContainerTrait<lola::vx::SynapseCorrelationCalibMatrix> : public BackendContainerBase<lola::vx::SynapseCorrelationCalibMatrix, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::SynapseCorrelationCalibRow> : public BackendContainerBase<lola::vx::SynapseCorrelationCalibRow, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::SynapseLabelMatrix> : public BackendContainerBase<lola::vx::SynapseLabelMatrix, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::SynapseLabelRow> : public BackendContainerBase<lola::vx::SynapseLabelRow, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::SynapseMatrix> : public BackendContainerBase<lola::vx::SynapseMatrix, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::SynapseRow> : public BackendContainerBase<lola::vx::SynapseRow, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::SynapseWeightMatrix> : public BackendContainerBase<lola::vx::SynapseWeightMatrix, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

template<>
struct BackendContainerTrait<lola::vx::SynapseWeightRow> : public BackendContainerBase<lola::vx::SynapseWeightRow, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

struct Bayesian

#include <neuron.h>

Public Types

enum Operation

Switch the logic operation executed by the bayesian module.

The operation affects the spike output and, if enabled, the correlation post-pulse.

local uses only the neuron’s own refractory state. This is the default for non-connected neurons and does not require further configuration to work.

AND creates an output only if local and remote refractory states are present.

XNOR creates an output at the falling edge of an XOR gate between the local and remote refractory states.

MULLER_C executes a Muller C-element operation between the local and refractory state: The output is activated if both the local and remote neuron are refractory, but both have to be non-refractory once before the next output can be generated.

Values:

enumerator local

enumerator AND

enumerator XNOR

enumerator MULLER_C

Public Functions

Bayesian () SYMBOL_VISIBLE

bool operator!= (Bayesian const &other) const SYMBOL_VISIBLE

bool operator== (Bayesian const &other) const SYMBOL_VISIBLE

Public Members

bool connect_fire_from_right

bool connect_fire_to_right

bool connect_fire_vertical

bool enable_master

bool enable_slave

enum Bayesian::Operation operation

bool to_post_pulse

Decide whether the bayesian output will be routed to the synapses as correlation post-pulse.

If disabled, spikes in the selected master neuron will trigger post-pulses.

Friends

friend std::ostream & operator<< (std::ostream &os, Bayesian const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::Bayesian

#include <neuron.h>

Public Types

enum Operation

Switch the logic operation executed by the bayesian module.

The operation affects the spike output and, if enabled, the correlation post-pulse.

local uses only the neuron’s own refractory state. This is the default for non-connected neurons and does not require further configuration to work.

AND creates an output only if local and remote refractory states are present.

XNOR creates an output at the falling edge of an XOR gate between the local and remote refractory states.

MULLER_C executes a Muller C-element operation between the local and refractory state: The output is activated if both the local and remote neuron are refractory, but both have to be non-refractory once before the next output can be generated.

Values:

enumerator local

enumerator AND

enumerator XNOR

enumerator MULLER_C

Public Functions

Bayesian () SYMBOL_VISIBLE

bool operator!= (Bayesian const &other) const SYMBOL_VISIBLE

bool operator== (Bayesian const &other) const SYMBOL_VISIBLE

Public Members

bool connect_fire_from_right

bool connect_fire_to_right

bool connect_fire_vertical

bool enable_master

bool enable_slave

enum lola::vx::v3::AtomicNeuron::Bayesian::Operation operation

bool to_post_pulse

Decide whether the bayesian output will be routed to the synapses as correlation post-pulse.

If disabled, spikes in the selected master neuron will trigger post-pulses.

Friends

friend std::ostream & operator<< (std::ostream &os, Bayesian const &config) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain::BufferToPadT

#include <readout_chain.h>

Configuration of the buffer connection the pads.

The source multiplexers can drive buffered signals to the two pad multiplexers. Note that you still have to select the corresponding connection at the pad multiplexers in order to make the connection.

Public Functions

BufferToPadT () SYMBOL_VISIBLE

bool operator!= (BufferToPadT const &other) const SYMBOL_VISIBLE

bool operator== (BufferToPadT const &other) const SYMBOL_VISIBLE

Public Members

AnalogValueVariant amp_i_bias

Bias current for buffer connecting to PAD.

bool enable

Connect input multiplexer to PAD multiplexer.

Friends

friend std::ostream & operator<< (std::ostream &os, BufferToPadT const &config) SYMBOL_VISIBLE

class GENPYBIND_TAG_LOLA_VX_VY::CADCReadoutChain : public haldls::vx::ContainerBase<CADCReadoutChain>

#include <cadc.h>

Configuration container for CADC and correlation/neuron-readout related settings.

Public Types

typedef halco::common::typed_array<haldls::vx::CHIP_REVISION_STR::CapMemCell::value_type, halco::hicann_dls::vx::CHIP_REVISION_STR::CapMemBlockOnHemisphere> AnalogValues

typedef halco::common::typed_array<Channel, halco::hicann_dls::vx::CADCChannelColumnOnSynram> ChannelArray

Configuration of each CADC channel.

Contains individual calibration and connection settings.

typedef halco::hicann_dls::vx::CADCOnDLS coordinate_type

typedef std::false_type has_local_data

Public Functions

CADCReadoutChain() = default

av def ("__getitem__", &::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::get, "", parent->py::arg("key"), parent->py::return_value_policy::reference)

av def ("__iter__", [av](::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues &self) { return pybind11::make_iterator(self);}, parent->py::template keep_alive< 0, 1 >())

av def ("__setitem__", &::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::set, "", parent->py::arg("key"), parent->py::arg("value"))

av def ("at",(genpybind_at_type) &::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::at, "", parent->py::arg("key"))

av def ("at",(genpybind_at_type) &::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::at, "", parent->py::arg("key"))

av def ("back",(genpybind_back_type) &::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::back, "")

av def ("back",(genpybind_back_type) &::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::back, "")

av def ("fill", &::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::fill, "", parent->py::arg("val"))

av def ("from_numpy", [](::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues &self, pybind11::array const &array) { ::halco::common::detail::from_numpy(self, array);})

av def ("front",(genpybind_front_type) &::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::front, "")

av def ("front",(genpybind_front_type) &::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::front, "")

av def ("to_numpy", [](::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues const &self) { return ::halco::common::detail::to_numpy(self);})

av def (parent->py::template init< const ::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues & >(), "")

av def (parent->py::template init<>(), "")

av def_property_readonly ("empty", parent->py::cpp_function(&::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::empty))

av def_property_readonly ("max_size", parent->py::cpp_function(&::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::max_size))

av def_property_readonly ("size", parent->py::cpp_function(&::lola::vx::CHIP_REVISION_STR::CADCReadoutChain::AnalogValues::size))

bool operator!= (CADCReadoutChain const &other) const SYMBOL_VISIBLE

bool operator== (CADCReadoutChain const &other) const SYMBOL_VISIBLE

Public Members

ChannelArray channels_acausal = {}

Individual channel settings, like their connections.

ChannelArray channels_causal = {}

Individual channel settings, like their connections.

Correlation correlation = {}

Synapses’ correlation settings, affecting correlation reset, measurement and readout, but also CADC behaviour and neuron resets and readout.

Ramp ramp = {}

CADC ramp generation settings.

Friends

friend std::ostream & operator<< (std::ostream &os, CADCReadoutChain const &config) SYMBOL_VISIBLE

class CADCSampleRow : public haldls::vx::ContainerBase<CADCSampleRow>

#include <cadc.h>

Public Types

typedef halco::common::typed_heap_array<Value, halco::hicann_dls::vx::SynapseOnSynapseRow> _samples_type

typedef halco::hicann_dls::vx::CADCSampleRowOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::CADCSampleQuad::Value Value

Public Functions

CADCSampleRow () SYMBOL_VISIBLE

Default constructor.

bool operator!= (CADCSampleRow const &other) const SYMBOL_VISIBLE

bool operator== (CADCSampleRow const &other) const SYMBOL_VISIBLE

Public Members

_samples_type acausal

Acausal sample value array.

_samples_type causal

Causal sample value array.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< CADCSampleRow >

friend std::ostream & operator<< (std::ostream &os, CADCSampleRow const &row) SYMBOL_VISIBLE

class CADCSamples : public haldls::vx::ContainerBase<CADCSamples>

#include <cadc.h>

Public Types

typedef halco::common::typed_heap_array<halco::common::typed_array<Value, halco::hicann_dls::vx::SynapseOnSynapseRow>, halco::hicann_dls::vx::SynramOnDLS> _samples_type

typedef halco::hicann_dls::vx::CADCSamplesOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::CADCSampleQuad::Value Value

Public Functions

CADCSamples () SYMBOL_VISIBLE

Default constructor.

bool operator!= (CADCSamples const &other) const SYMBOL_VISIBLE

bool operator== (CADCSamples const &other) const SYMBOL_VISIBLE

Public Members

_samples_type acausal

_samples_type causal

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< CADCSamples >

friend std::ostream & operator<< (std::ostream &os, CADCSamples const &row) SYMBOL_VISIBLE

class GENPYBIND_TAG_LOLA_VX_VY::CapMem : public haldls::vx::ContainerBase<CapMem>

#include <capmem.h>

Configuration of the CapMem and associated selections as well as the reference generator.

Public Types

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::Value AnalogValue

typedef halco::common::typed_array<haldls::vx::CHIP_REVISION_STR::CapMemBlockConfig, halco::hicann_dls::vx::CHIP_REVISION_STR::CapMemBlockConfigOnDLS> Blocks

typedef halco::hicann_dls::vx::CapMemOnDLS coordinate_type

typedef std::false_type has_local_data

typedef halco::common::typed_array<haldls::vx::CHIP_REVISION_STR::CapMemCell::value_type, halco::hicann_dls::vx::CHIP_REVISION_STR::UnusedCapMemCellOnDLS> UnusedCells

Public Functions

CapMem() = default

bool operator!= (CapMem const &other) const SYMBOL_VISIBLE

bool operator== (CapMem const &other) const SYMBOL_VISIBLE

Public Members

Blocks blocks

CapMem configuration per quadrant.

haldls::vx::CHIP_REVISION_STR::ReferenceGeneratorConfig reference_generator

Reference generator.

haldls::vx::CHIP_REVISION_STR::SynapseBiasSelection synapse_bias_selection

Synapse bias selection.

UnusedCells unused_cells

Unused CapMem cells.

Friends

friend std::ostream & operator<< (std::ostream &os, CapMem const &config) SYMBOL_VISIBLE

class GENPYBIND_TAG_LOLA_VX_VY::CADCReadoutChain::Channel

#include <cadc.h>

Configuration of each CADC channel.

Contains individual calibration and connection settings.

Public Types

typedef haldls::vx::CADCChannelConfig::Offset Offset

Public Functions

Channel() = default

bool operator!= (Channel const &other) const SYMBOL_VISIBLE

bool operator== (Channel const &other) const SYMBOL_VISIBLE

Public Members

bool enable_connect_correlation = {false}

Decide whether the CADC channel is connected to the synapse array.

This is required when reading either from the synapses’ correlation sensors or from the neurons.

bool enable_connect_debug = {false}

Decide whether the CADC channel is connected to a common debug line.

This must not be enabled if all channels are to be used independently.

bool enable_connect_neuron = {false}

Decide whether the line through the synapse array is connected to the neuron readout buffer.

This must not be enabled if correlations are to be read.

Offset offset = {}

Digital offset for the result obtained by the CADC channel.

Typically obtained from calibration.

Friends

friend std::ostream & operator<< (std::ostream &os, Channel const &config) SYMBOL_VISIBLE

class lola::vx::v3::Chip : public haldls::vx::ContainerBase<Chip>

#include <chip.h>

Complete static configuration of one chip.

Public Types

typedef halco::common::typed_array<haldls::vx::v3::BackgroundSpikeSource, halco::hicann_dls::vx::v3::BackgroundSpikeSourceOnDLS> BackgroundSpikeSources

typedef halco::common::typed_array<CADCReadoutChain, halco::hicann_dls::vx::v3::CADCOnDLS> CADCReadoutChains

typedef halco::hicann_dls::vx::ChipOnDLS coordinate_type

typedef std::false_type has_local_data

typedef halco::common::typed_array<haldls::vx::v3::PPUMemory, halco::hicann_dls::vx::v3::PPUMemoryOnDLS> PPUMemory

typedef halco::common::typed_array<SynapseBlock, halco::hicann_dls::vx::v3::SynapseBlockOnDLS> SynapseBlocks

typedef halco::common::typed_array<SynapseDriverBlock, halco::hicann_dls::vx::v3::SynapseDriverBlockOnDLS> SynapseDriverBlocks

Public Functions

Chip() = default

bool operator!= (Chip const &other) const SYMBOL_VISIBLE

bool operator== (Chip const &other) const SYMBOL_VISIBLE

Public Members

BackgroundSpikeSources background_spike_sources

Background spike sources.

CADCReadoutChains cadc_readout_chains

CADC readout chains, one per hemisphere containing CADC and correlation sensor configuration as well as the switches to the synapses or neurons.

CapMem capmem

CapMem configuration and unused cells, all cells associated with other entities, e.g.

neurons are placed at their respective containers.

Crossbar crossbar

Event routing crossbar configuration.

ExternalPPUMemory external_ppu_memory

Chip-external global PPU memory.

MemoryTiming memory_timing

Timing of memory cells, SynRAM, CADC offsets, analog and digital neuron and synapse driver configuration.

NeuronBlock neuron_block

Block on neurons containing all atomic neuron circuit configurations, chip-global neuron backend parameters and synaptic input switches to the synapse blocks.

PPUMemory ppu_memory

PPU SRAM memory, one per PPU.

ReadoutChain readout_chain

Readout chain containing MADC configuration and analog signal routing.

SynapseBlocks synapse_blocks

Blocks of synapses, one per hemisphere containing hemisphere-global configuration and all individual synapse parameters.

SynapseDriverBlocks synapse_driver_blocks

Blocks of synapse drivers, one per hemisphere containing hemisphere-global configuration and all individual synapse driver configurations.

Public Static Attributes

static const SYMBOL_VISIBLE Chip default_neuron_bypass

Default instance for neuron bypass.

Friends

friend std::ostream & operator<< (std::ostream &os, Chip const &config) SYMBOL_VISIBLE

class lola::vx::ColumnCorrelationRow : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<ColumnCorrelationRow>

#include <synapse.h>

Public Types

typedef halco::hicann_dls::vx::ColumnCorrelationRowOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::ColumnCorrelationQuad::ColumnCorrelationSwitch Value

typedef halco::common::typed_heap_array<Value, halco::hicann_dls::vx::SynapseOnSynapseRow> Values

Public Functions

ColumnCorrelationRow () SYMBOL_VISIBLE

bool operator!= (ColumnCorrelationRow const &other) const SYMBOL_VISIBLE

bool operator== (ColumnCorrelationRow const &other) const SYMBOL_VISIBLE

Public Members

Values values

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< ColumnCorrelationRow >

friend std::ostream & operator<< (std::ostream &os, ColumnCorrelationRow const &row) SYMBOL_VISIBLE

class lola::vx::ColumnCurrentRow : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<ColumnCurrentRow>

#include <synapse.h>

Public Types

typedef halco::hicann_dls::vx::ColumnCurrentRowOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::ColumnCurrentQuad::ColumnCurrentSwitch Value

typedef halco::common::typed_heap_array<Value, halco::hicann_dls::vx::SynapseOnSynapseRow> Values

Public Functions

ColumnCurrentRow () SYMBOL_VISIBLE

bool operator!= (ColumnCurrentRow const &other) const SYMBOL_VISIBLE

bool operator== (ColumnCurrentRow const &other) const SYMBOL_VISIBLE

Public Members

Values values

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< ColumnCurrentRow >

friend std::ostream & operator<< (std::ostream &os, ColumnCurrentRow const &row) SYMBOL_VISIBLE

struct ConstantCurrent

#include <neuron.h>

Public Types

enum Type

Sink/source offset current on membrane.

Values:

enumerator source

enumerator sink

Public Functions

ConstantCurrent () SYMBOL_VISIBLE

bool operator!= (ConstantCurrent const &other) const SYMBOL_VISIBLE

bool operator== (ConstantCurrent const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Enable application of offset current on membrane.

AnalogValueVariant i_offset

Offset current source/sink from the membrane.

enum ConstantCurrent::Type type

Friends

friend std::ostream & operator<< (std::ostream &os, ConstantCurrent const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::ConstantCurrent

#include <neuron.h>

Public Types

enum Type

Sink/source offset current on membrane.

Values:

enumerator source

enumerator sink

Public Functions

ConstantCurrent () SYMBOL_VISIBLE

bool operator!= (ConstantCurrent const &other) const SYMBOL_VISIBLE

bool operator== (ConstantCurrent const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Enable application of offset current on membrane.

AnalogValueVariant i_offset

Offset current source/sink from the membrane.

enum lola::vx::v3::AtomicNeuron::ConstantCurrent::Type type

Friends

friend std::ostream & operator<< (std::ostream &os, ConstantCurrent const &config) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::CADCReadoutChain::Correlation

#include <cadc.h>

Synapses’ correlation settings, affecting correlation reset, measurement and readout, but also CADC behaviour and neuron resets and readout.

Public Types

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::Value AnalogValue

typedef haldls::vx::CHIP_REVISION_STR::CommonCorrelationConfig::ResetDuration ResetDuration

typedef haldls::vx::CHIP_REVISION_STR::CommonCorrelationConfig::ResetFallTime ResetFallTime

typedef haldls::vx::CHIP_REVISION_STR::CommonCorrelationConfig::ResetMode ResetMode

typedef haldls::vx::CHIP_REVISION_STR::CommonCorrelationConfig::SenseDelay SenseDelay

Public Functions

Correlation() = default

bool operator!= (Correlation const &other) const SYMBOL_VISIBLE

bool operator== (Correlation const &other) const SYMBOL_VISIBLE

Public Members

CADCReadoutChain::AnalogValues i_bias_corout = {}

Correlation readout bias current, applied to the source follower in the readout of the accumulation capacitor.

When using auto-calibrating reset, this current also controls the discharge rate of the correlation capacitor after the initial reset.

CADCReadoutChain::AnalogValues i_bias_ramp = {}

Correlation ramp bias, controlling the time constant of the correlation measurements.

A lower ramp current corresponds to a longer time constant.

CADCReadoutChain::AnalogValues i_bias_store = {}

Correlation storage bias, controlling the amplitude of each correlated spike pair that is stored on the accumulation capacitor.

Lower bias currents result in a higher amplitude per spike pair.

ResetDuration reset_duration = {}

Duration of a correlation reset.

Has to be sufficient to charge the correlation accumulation capacitor. Given in PPU clock cycles. This setting also affects the parallel neuron reset.

ResetFallTime reset_fall_time = {}

When using auto-calibrating correlation reset, this setting controls the maximum discharge time per synapse, after the initial reset to a higher voltage.

The comparator needs to trigger within this time. Given in PPU clock cycles.

ResetMode reset_mode = {ResetMode::normal}

Select between normal and auto-calibrating correlation reset.

Normal reset: The correlation accumulation capacitors are connected to an external voltage (v_reset) for a given period of time (reset_duration).

Auto-calibrating reset: The correlation readout is enabled for the synapses to be reset. The correlation accumulation capacitor is connected to an external voltage (v_reset) for reset_duration. V_reset must be higher than the target reset potential. After this initial reset, the capacitor is discharged by a constant current (controlled by i_bias_corout) until the column’s CADC comparator triggers. The resulting potential on the correlation accumulation capacitor should therefore be close to v_offset of the CADC (given i_slope is zero). Note that while using auto-calibrating reset, the CADC cannot be used normally, a read will never return.

SenseDelay sense_delay = {}

Delay between issuing a read command, i.e.

connecting correlation output of a given synapse row to the CADC channels, and triggering the CADC read. Given in PPU clock cycles. This setting also adds a delay to reading potentials from the neurons and the start of the auto-calibrating reset.

Friends

friend std::ostream & operator<< (std::ostream &os, Correlation const &config) SYMBOL_VISIBLE

class lola::vx::CorrelationResetRow : public haldls::vx::ContainerBase<CorrelationResetRow>

#include <synapse.h>

Reset correlation capacitors in all quads of a given row on synram.

Using this container is equivalent to writing haldls CorrelationReset containers to all quads of the row.

Public Types

typedef halco::hicann_dls::vx::CorrelationResetRowOnDLS coordinate_type

typedef std::false_type has_local_data

Public Functions

CorrelationResetRow () SYMBOL_VISIBLE

Default constructor.

bool operator!= (CorrelationResetRow const &other) const SYMBOL_VISIBLE

bool operator== (CorrelationResetRow const &other) const SYMBOL_VISIBLE

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< CorrelationResetRow >

friend std::ostream & operator<< (std::ostream &os, CorrelationResetRow const &row) SYMBOL_VISIBLE

class lola::vx::Crossbar : public haldls::vx::ContainerBase<Crossbar>

#include <routing_crossbar.h>

Container for configuration of the routing crossbar.

Public Types

typedef halco::hicann_dls::vx::CrossbarOnDLS coordinate_type

typedef std::false_type has_local_data

typedef halco::common::typed_array<haldls::vx::CrossbarNode, halco::hicann_dls::vx::CrossbarNodeOnDLS> Nodes

Public Functions

Crossbar () SYMBOL_VISIBLE

Default constructor.

bool operator!= (Crossbar const &other) const SYMBOL_VISIBLE

bool operator== (Crossbar const &other) const SYMBOL_VISIBLE

Public Members

Nodes nodes

Crossbar node configuration.

haldls::vx::CrossbarOutputConfig outputs

Public Static Attributes

static constexpr auto unsupported_read_targets = {hxcomm::vx::Target::hardware}

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::Crossbar >

friend std::ostream & operator<< (std::ostream &os, Crossbar const &block) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain::CurrentDAC

#include <readout_chain.h>

Configuration of the current DAC of the readout chain.

The DAC’s output can be connected to neuron membranes or synapse lines. The potential there can be sampled using the MADC concurrently.

Public Types

typedef haldls::vx::CurrentDAC::Current Current

typedef haldls::vx::CurrentDAC::Sign Sign

Public Functions

CurrentDAC () SYMBOL_VISIBLE

bool operator!= (CurrentDAC const &other) const SYMBOL_VISIBLE

bool operator== (CurrentDAC const &other) const SYMBOL_VISIBLE

Public Members

HemisphereType connect_neuron_stimulus

Connect neuron stimulus per hemisphere.

SynapseTargetType connect_synapse_debug

Connect synapse debug wires.

Current current

Current value of DAC.

bool enable_current

Enable current DAC.

AnalogValueVariant i_bias

Bias current.

AnalogValueVariant i_bias_casc

Cascode bias current.

Sign sign

Sing of current, either source or sink.

Friends

friend std::ostream & operator<< (std::ostream &os, CurrentDAC const &config) SYMBOL_VISIBLE

class lola::vx::DACChannelBlock : public haldls::vx::ContainerBase<DACChannelBlock>

#include <dac.h>

Container for configuration of all DAC channels on the xBoard.

Public Types

typedef halco::common::typed_array<Value, halco::hicann_dls::vx::DACChannelOnBoard> _value_type

typedef halco::hicann_dls::vx::DACChannelBlockOnBoard coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::DACChannel::Value Value

Public Functions

DACChannelBlock () SYMBOL_VISIBLE

Default constructor.

double get_voltage (halco::hicann_dls::vx::DACChannelOnBoard coord) const SYMBOL_VISIBLE

Getter for DAC values in volts.

Parameters

coord – Coordinate of the DAC channel to read.

Returns

Voltage in Volt (V) applied at that channel.

bool operator!= (DACChannelBlock const &other) const SYMBOL_VISIBLE

bool operator== (DACChannelBlock const &other) const SYMBOL_VISIBLE

void set_voltage (halco::hicann_dls::vx::DACChannelOnBoard coord, double voltage) SYMBOL_VISIBLE

Setter for DAC values in volts.

Parameters

• coord – Coordinate of the DAC channel to configure.

• voltage – Voltage in Volt (V) to apply at that channel.

Public Members

_value_type value

Array of channel values.

Public Static Attributes

static const SYMBOL_VISIBLE DACChannelBlock default_ldo_1

Default value for LDO version 1.

static const SYMBOL_VISIBLE DACChannelBlock default_ldo_2

Default value for LDO version 2.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::DACChannelBlock >

friend std::ostream & operator<< (std::ostream &os, DACChannelBlock const &block) SYMBOL_VISIBLE

class lola::vx::DACControlBlock : public haldls::vx::ContainerBase<DACControlBlock>

#include <dac.h>

Container for configuration of all DAC channel enable values on the xBoard.

Public Types

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::DACChannelOnBoard> _enable_type

typedef halco::hicann_dls::vx::DACControlBlockOnBoard coordinate_type

typedef std::false_type has_local_data

Public Functions

DACControlBlock () SYMBOL_VISIBLE

Default constructor.

bool operator!= (DACControlBlock const &other) const SYMBOL_VISIBLE

bool operator== (DACControlBlock const &other) const SYMBOL_VISIBLE

Public Members

_enable_type enable

Array of channel enable values.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::DACControlBlock >

friend std::ostream & operator<< (std::ostream &os, DACControlBlock const &block) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain::DynamicMux

#include <readout_chain.h>

Configuration of the Dynamic multiplexer.

This multiplexer switches between the two available input channels (source multiplexers) on a per-sample basis.

Public Types

typedef haldls::vx::MADCConfig::input_selection_type InputSelect

typedef haldls::vx::MADCConfig::ActiveMuxInputSelectLength InputSelectLength

Public Functions

DynamicMux() = default

bool operator!= (DynamicMux const &other) const SYMBOL_VISIBLE

bool operator== (DynamicMux const &other) const SYMBOL_VISIBLE

Public Members

bool enable_amplifiers = {true}

Enable Mux amplifiers.

AnalogValueVariant i_bias = {AnalogValue{500}}

Bias current for amplifier in dynamic mux.

InputSelect initially_selected_input = {}

Input channel (one of two multiplexers) to acquire the first batch of samples from.

InputSelectLength input_select_length = {}

Number of samples after which the other input channel is selected.

Use 1 to sample both channels alternately.

Friends

friend std::ostream & operator<< (std::ostream &os, DynamicMux const &config) SYMBOL_VISIBLE

struct EventRouting

#include <neuron.h>

Public Types

typedef haldls::vx::v3::NeuronBackendConfig::AddressOut Address

enum AnalogOutputMode

Analog output (off/normal/strong) settings.

Non-off states enable event output from the analog part. This setting also affects the bypass circuits. “Strong” increases the strength of the analog part’s pulse.

Values:

enumerator off

enumerator normal

enumerator strong

Public Functions

EventRouting () SYMBOL_VISIBLE

EventRouting (AnalogOutputMode analog_output, bool enable_digital, bool enable_bypass_excitatory, bool enable_bypass_inhibitory, Address address, bool enable_post_overwrite) SYMBOL_VISIBLE

bool operator!= (EventRouting const &other) const SYMBOL_VISIBLE

bool operator== (EventRouting const &other) const SYMBOL_VISIBLE

Public Members

Address address

Lower 8 bit of address sent on event output.

enum EventRouting::AnalogOutputMode analog_output

bool enable_bypass_excitatory

Enable excitatory bypass circuit.

bool enable_bypass_inhibitory

Enable inhibitory bypass circuit.

bool enable_digital

Enable sending a spike packet out of the digital backend.

bool enable_post_overwrite

Enable usage of external post pulses reaching the synapses exclusively.

If disabled, the internal neuron spikes reach the synapses.

Public Static Attributes

static const EventRouting disabled SYMBOL_VISIBLE

static const EventRouting enabled SYMBOL_VISIBLE

static const EventRouting bypass_exc SYMBOL_VISIBLE

static const EventRouting bypass_inh SYMBOL_VISIBLE

Friends

friend std::ostream & operator<< (std::ostream &os, EventRouting const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::EventRouting

#include <neuron.h>

Public Types

typedef haldls::vx::v3::NeuronBackendConfig::AddressOut Address

enum AnalogOutputMode

Analog output (off/normal/strong) settings.

Non-off states enable event output from the analog part. This setting also affects the bypass circuits. “Strong” increases the strength of the analog part’s pulse.

Values:

enumerator off

enumerator normal

enumerator strong

Public Functions

EventRouting () SYMBOL_VISIBLE

EventRouting (AnalogOutputMode analog_output, bool enable_digital, bool enable_bypass_excitatory, bool enable_bypass_inhibitory, Address address, bool enable_post_overwrite) SYMBOL_VISIBLE

bool operator!= (EventRouting const &other) const SYMBOL_VISIBLE

bool operator== (EventRouting const &other) const SYMBOL_VISIBLE

Public Members

Address address

Lower 8 bit of address sent on event output.

enum lola::vx::v3::AtomicNeuron::EventRouting::AnalogOutputMode analog_output

bool enable_bypass_excitatory

Enable excitatory bypass circuit.

bool enable_bypass_inhibitory

Enable inhibitory bypass circuit.

bool enable_digital

Enable sending a spike packet out of the digital backend.

bool enable_post_overwrite

Enable usage of external post pulses reaching the synapses exclusively.

If disabled, the internal neuron spikes reach the synapses.

Public Static Attributes

static const EventRouting disabled SYMBOL_VISIBLE

static const EventRouting enabled SYMBOL_VISIBLE

static const EventRouting bypass_exc SYMBOL_VISIBLE

static const EventRouting bypass_inh SYMBOL_VISIBLE

Friends

friend std::ostream & operator<< (std::ostream &os, EventRouting const &config) SYMBOL_VISIBLE

struct Exponential

#include <neuron.h>

Public Functions

Exponential () SYMBOL_VISIBLE

bool operator!= (Exponential const &other) const SYMBOL_VISIBLE

bool operator== (Exponential const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Enable exponential term.

AnalogValueVariant i_bias

Bias current controlling the strength of the exponential term.

AnalogValueVariant v_exp

Threshold voltage for the exponential term.

Friends

friend std::ostream & operator<< (std::ostream &os, Exponential const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::Exponential

#include <neuron.h>

Public Functions

Exponential () SYMBOL_VISIBLE

bool operator!= (Exponential const &other) const SYMBOL_VISIBLE

bool operator== (Exponential const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Enable exponential term.

AnalogValueVariant i_bias

Bias current controlling the strength of the exponential term.

AnalogValueVariant v_exp

Threshold voltage for the exponential term.

Friends

friend std::ostream & operator<< (std::ostream &os, Exponential const &config) SYMBOL_VISIBLE

class lola::vx::ExternalPPUMemory : public haldls::vx::ContainerBase<ExternalPPUMemory>

#include <ppu.h>

Complete external PPU memory.

Public Types

typedef halco::common::typed_heap_array<haldls::vx::ExternalPPUMemoryByte, halco::hicann_dls::vx::ExternalPPUMemoryByteOnFPGA> Bytes

typedef halco::hicann_dls::vx::ExternalPPUMemoryOnFPGA coordinate_type

typedef std::false_type has_local_data

typedef halco::hicann_dls::vx::ExternalPPUMemoryBlockSize size_type

Public Functions

ExternalPPUMemory () SYMBOL_VISIBLE

ExternalPPUMemoryBlock get_subblock (size_t begin, size_type length) const SYMBOL_VISIBLE

bool operator!= (ExternalPPUMemory const &other) const SYMBOL_VISIBLE

bool operator== (ExternalPPUMemory const &other) const SYMBOL_VISIBLE

void set_subblock (size_t begin, ExternalPPUMemoryBlock const &subblock) SYMBOL_VISIBLE

std::string to_string () const SYMBOL_VISIBLE

Print words as string discarding non-printable characters.

Returns

Printable characters as string

Public Members

Bytes bytes

Friends

friend std::ostream & operator<< (std::ostream &os, ExternalPPUMemory const &config) SYMBOL_VISIBLE

class lola::vx::ExternalPPUMemoryBlock : public haldls::vx::ContainerBase<ExternalPPUMemoryBlock>

#include <ppu.h>

Contiguous block of bytes in the external PPU memory.

Public Types

typedef std::vector<haldls::vx::ExternalPPUMemoryByte> bytes_type

typedef halco::hicann_dls::vx::ExternalPPUMemoryBlockOnFPGA coordinate_type

typedef std::false_type has_local_data

typedef halco::hicann_dls::vx::ExternalPPUMemoryBlockSize size_type

Public Functions

explicit  ExternalPPUMemoryBlock (size_type size=size_type(halco::hicann_dls::vx::ExternalPPUMemoryByteOnFPGA::size)) SYMBOL_VISIBLE

haldls::vx::ExternalPPUMemoryByte const & at (size_t index) const SYMBOL_VISIBLE

haldls::vx::ExternalPPUMemoryByte & at (size_t index) SYMBOL_VISIBLE

bytes_type const & get_bytes () const SYMBOL_VISIBLE

ExternalPPUMemoryBlock get_subblock (size_t begin, size_type length) const SYMBOL_VISIBLE

bool operator!= (ExternalPPUMemoryBlock const &other) const SYMBOL_VISIBLE

bool operator== (ExternalPPUMemoryBlock const &other) const SYMBOL_VISIBLE

haldls::vx::ExternalPPUMemoryByte const & operator[] (size_t index) const SYMBOL_VISIBLE

haldls::vx::ExternalPPUMemoryByte & operator[] (size_t index) SYMBOL_VISIBLE

void set_bytes (bytes_type const &bytes) SYMBOL_VISIBLE

void set_subblock (size_t begin, ExternalPPUMemoryBlock const &subblock) SYMBOL_VISIBLE

size_type size () const SYMBOL_VISIBLE

std::string to_string () const SYMBOL_VISIBLE

Private Functions

template<typename Archive>
friend void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, ExternalPPUMemoryBlock &value, std::uint32_t const version)

Private Members

bytes_type m_bytes

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ExternalPPUMemoryBlock const &config) SYMBOL_VISIBLE

struct Leak

#include <neuron.h>

Public Functions

Leak () SYMBOL_VISIBLE

bool operator!= (Leak const &other) const SYMBOL_VISIBLE

bool operator== (Leak const &other) const SYMBOL_VISIBLE

Public Members

bool enable_degeneration

Enable source degeneration of leak OTA.

bool enable_division

Enable division (/8) of leak conductance.

bool enable_multiplication

Enable multiplication (*8) of leak conductance.

AnalogValueVariant i_bias

AnalogValueVariant v_leak

Leak potential.

Friends

friend std::ostream & operator<< (std::ostream &os, Leak const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::Leak

#include <neuron.h>

Public Functions

Leak () SYMBOL_VISIBLE

bool operator!= (Leak const &other) const SYMBOL_VISIBLE

bool operator== (Leak const &other) const SYMBOL_VISIBLE

Public Members

bool enable_degeneration

Enable source degeneration of leak OTA.

bool enable_division

Enable division (/8) of leak conductance.

bool enable_multiplication

Enable multiplication (*8) of leak conductance.

AnalogValueVariant i_bias

AnalogValueVariant v_leak

Leak potential.

Friends

friend std::ostream & operator<< (std::ostream &os, Leak const &config) SYMBOL_VISIBLE

class GENPYBIND_TAG_LOLA_VX_VY::LogicalNeuron : public haldls::vx::ContainerBase<LogicalNeuron>

#include <morphology.h>

Configuration of a multicompartment/logical neuron.

Public Types

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::AtomicNeuronOnDLS AtomicNeuronOnDLS

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::CompartmentOnLogicalNeuron CompartmentOnLogicalNeuron

typedef std::pair<NeuronOnLogicalNeuronCompartment, NeuronOnLogicalNeuronCompartment> Connection

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::LogicalNeuronOnDLS coordinate_type

typedef std::false_type has_local_data

typedef std::map<CompartmentOnLogicalNeuron, std::vector<MCSafeAtomicNeuron>> MorphologyMap

Holds the morphology and configuration of the logical/multicompartment neuron.

typedef std::pair<CompartmentOnLogicalNeuron, size_t> NeuronOnLogicalNeuronCompartment

typedef std::map<CompartmentOnLogicalNeuron, std::vector<AtomicNeuronOnDLS>> PlacedCompartments

Public Functions

LogicalNeuron () SYMBOL_VISIBLE

MCSafeAtomicNeuron const & at (CompartmentOnLogicalNeuron const &compartment_coord, size_t const &neuron_index) const SYMBOL_VISIBLE

MCSafeAtomicNeuron & at (CompartmentOnLogicalNeuron const &compartment_coord, size_t const &neuron_index) SYMBOL_VISIBLE

Returns neuron within specified compartment at given index.

std::map< CompartmentOnLogicalNeuron, std::vector< AtomicNeuron > > collapse_neuron () const SYMBOL_VISIBLE

Convert MCSafeAtomicNeuron to AtomicNeuron inside the morphology.

bool operator!= (LogicalNeuron const &other) const SYMBOL_VISIBLE

bool operator== (LogicalNeuron const &other) const SYMBOL_VISIBLE

return_value_policy(reference)) MCSafeAtomicNeuron const &get_neuron(std void set_neuron (std::pair< CompartmentOnLogicalNeuron, size_t > const &index, MCSafeAtomicNeuron const &neuron) SYMBOL_VISIBLE

Set neuron within specified compartment at given index.

Parameters

• coord – Compartment coordinate.

• neuron – Set config for neurons in compartment.

Public Members

MorphologyMap morphology

Private Types

typedef std::vector<Connection> Connections

Private Functions

LogicalNeuron (Morphology morph, Connections connected_neighbors, Connections involved_connect_soma_right_neurons) SYMBOL_VISIBLE

std::pair< AtomicNeuronOnDLS const &, AtomicNeuronOnDLS const & > get_coordinates (Connection const &connection, PlacedCompartments placed_compartments) const SYMBOL_VISIBLE

Get pair of AtomicNeuronOnDLS from connection provided the placed compartments.

Parameters

• connection – Connection for which pair of AtomicNeuronOnDLS will be created.

• placed_compartments – Placed compartments of the LogicalNeuron.

Returns

Pair of coordinates involved in connection (pair of AtomicNeuronOnDLS).

std::pair< MCSafeAtomicNeuron &, MCSafeAtomicNeuron & > get_neurons (Connection const &connection, MorphologyMap &morphology) const SYMBOL_VISIBLE

Get pair of MCSafeAtomicNeuron from the LogicalNeuron’s morphology for given connection.

Parameters

• connection – Connection between to neurons.

• morphology – Morphology of the LogicalNeuron containing the connection.

Returns

Reference to the in the connection involved neurons (pair of MCSafeAtomicNeuron).

Private Members

Connections m_involved_connect_right_neurons

Remember connected neighbors.

Only store horizontal connections since vertical connections are symmetric wrt to flips.

Connections m_involved_connect_soma_right_neurons

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< LogicalNeuron >

friend class Morphology

friend std::ostream & operator<< (std::ostream &os, LogicalNeuron const &logical_neuron) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain::MADC

#include <readout_chain.h>

Configuration of the MADC.

Public Types

typedef haldls::vx::MADCConfig::CalibrationWaitValue CalibrationWaitValue

typedef haldls::vx::MADCConfig::MADCClockScaleValue ClockScaleValue

typedef haldls::vx::MADCConfig::ConversionCyclesOffset ConversionCyclesOffset

typedef haldls::vx::MADCConfig::NumberOfSamples NumberOfSamples

typedef haldls::vx::MADCConfig::PowerupWaitValue PowerupWaitValue

typedef haldls::vx::MADCConfig::SampleDurationAdjust SampleDurationAdjust

typedef haldls::vx::MADCConfig::SARResetLength SARResetLength

typedef haldls::vx::MADCConfig::SARResetWait SARResetWait

Public Functions

MADC() = default

bool operator!= (MADC const &other) const SYMBOL_VISIBLE

bool operator== (MADC const &other) const SYMBOL_VISIBLE

Public Members

CalibrationWaitValue calibration_wait_value = {}

Built-in calibration’s timing.

ClockScaleValue clock_scale_value = {}

Clock scale value.

The clock is derived from a PLL madc_clk output.

ConversionCyclesOffset conversion_cycles_offset = {}

Conversion cycles offset.

This seems to be redundant to sample_duration_adjust. Both settings are summed up in hardware.

bool enable_calibration = {false}

Enable built-in calibration of the MADC.

bool enable_dummy_data = {false}

bool enable_madc_clock_scaling = {false}

Enable clock scaling.

The clock is derived from a PLL madc_clk output.

bool enable_sar_reset_on_fall = {false}

Configuration of the MADC’s SAR reset timing.

AnalogValueVariant in_500na = {AnalogValue{500}}

500nA reference current.

NumberOfSamples number_of_samples = {}

Number of samples recorded by the MADC.

The MADC records a fixed number of samples as long as it is not configured to sample continuously (c.f. enable_sample_continously in MADCControl).

PowerupWaitValue powerup_wait_value = {}

Powerup wait value.

The MADC remains in the wake up state for a number of MADC clock cycles determined by this property before transitioning to the READY state (via ENABLE).

SampleDurationAdjust sample_duration_adjust = {SampleDurationAdjust()}

Sample duration adjustment.

This seems to be redundant to conversion_cycles_offset. Both settings are summed up in hardware.

bool sample_on_positive_edge = {true}

SARResetLength sar_reset_length = {}

SARResetWait sar_reset_wait = {}

Friends

friend std::ostream & operator<< (std::ostream &os, MADC const &config) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain::MADCDebugCrossbar

#include <readout_chain.h>

Configuration of the crossbar connecting the MADC to debug pads.

Public Types

typedef haldls::vx::MADCConfig::PreampGainCapacitorSize GainCapacitorSize

Public Functions

MADCDebugCrossbar () SYMBOL_VISIBLE

bool operator!= (MADCDebugCrossbar const &other) const SYMBOL_VISIBLE

bool operator== (MADCDebugCrossbar const &other) const SYMBOL_VISIBLE

Public Members

bool connect_pads_to_madc

Connect MADCDebugPads to MADC.

bool connect_preamp_to_madc

Connect MADCPreamp to MADC.

bool connect_preamp_to_pads

Connect MADCPreamp to MADCDebugPads.

Friends

friend std::ostream & operator<< (std::ostream &os, MADCDebugCrossbar const &config) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain::MADCInputCrossbar

#include <readout_chain.h>

Configuration of the crossbar connecting the MADC to the different measure/readout circuits.

Public Functions

MADCInputCrossbar () SYMBOL_VISIBLE

bool operator!= (MADCInputCrossbar const &other) const SYMBOL_VISIBLE

bool operator== (MADCInputCrossbar const &other) const SYMBOL_VISIBLE

Public Members

bool connect_dynamic_mux

Connect the DynamicMux to the input crossbar.

bool connect_madc_preamp

Connect the MADCPreamp to the input crossbar.

bool connect_pad_mux

Connect the PADMux to the input crossbar, using the debug_plus and debug_minus lines.

bool connect_source_measure_unit

Connect the SourceMeasureUnit to the input crossbar.

Friends

friend std::ostream & operator<< (std::ostream &os, MADCInputCrossbar const &config) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain::MADCPreamp

#include <readout_chain.h>

Configuration of the MADC preamplifier.

Public Types

typedef haldls::vx::MADCConfig::PreampGainCapacitorSize GainCapacitorSize

Public Functions

MADCPreamp() = default

bool operator!= (MADCPreamp const &other) const SYMBOL_VISIBLE

bool operator== (MADCPreamp const &other) const SYMBOL_VISIBLE

Public Members

GainCapacitorSize gain_cap_size = {}

Gain capacitor size.

AnalogValueVariant i_bias = {AnalogValue{500}}

Bias current.

SamplingWindowTiming sampling_window_end = {8}

End of sampling window.

SamplingWindowTiming sampling_window_start = {3}

Start of sampling window.

AnalogValueVariant v_ref = {AnalogValue{400}}

Reference voltage.

Friends

friend std::ostream & operator<< (std::ostream &os, MADCPreamp const &config) SYMBOL_VISIBLE

class GENPYBIND_TAG_LOLA_VX_VY::MCSafeAtomicNeuron

#include <morphology.h>

Helper class for the LogicalNeuron (Multi-Compartment Safe AtomicNeuron).

This helper class is completly equivalent to the AtomicNeuron with the exception that it sets members of the Multicompartment struct private, which influence the morphology/structure of a neuron ultimately preserving the morphology/structure of a LogicalNeuron.

Public Types

using Adaptation = AtomicNeuron::Adaptation

using AnalogValueVariant = AtomicNeuron::AnalogValueVariant

using Bayesian = AtomicNeuron::Bayesian

using ConstantCurrent = AtomicNeuron::ConstantCurrent

using EventRouting = AtomicNeuron::EventRouting

using Exponential = AtomicNeuron::Exponential

using Leak = AtomicNeuron::Leak

using MembraneCapacitance = AtomicNeuron::MembraneCapacitance

using Readout = AtomicNeuron::Readout

using RefractoryPeriod = AtomicNeuron::RefractoryPeriod

using Reset = AtomicNeuron::Reset

using SynapticInput = AtomicNeuron::SynapticInput

using Threshold = AtomicNeuron::Threshold

Public Functions

MCSafeAtomicNeuron () SYMBOL_VISIBLE

Constructors.

explicit  MCSafeAtomicNeuron (AtomicNeuron atomic_neuron) SYMBOL_VISIBLE

explicit  MCSafeAtomicNeuron (AtomicNeuron::Multicompartment an_multicompartment) SYMBOL_VISIBLE

MCSafeAtomicNeuron (MCSafeAtomicNeuron &&other) SYMBOL_VISIBLE

Move constructor.

MCSafeAtomicNeuron (MCSafeAtomicNeuron const &mc_safe_atomic_neuron) SYMBOL_VISIBLE

Copy constructor.

~MCSafeAtomicNeuron() = default

Destructor.

explicit  operator AtomicNeuron () const SYMBOL_VISIBLE

bool operator!= (MCSafeAtomicNeuron const &other) const SYMBOL_VISIBLE

MCSafeAtomicNeuron & operator= (MCSafeAtomicNeuron &&other) SYMBOL_VISIBLE

Move assignment operator.

MCSafeAtomicNeuron & operator= (MCSafeAtomicNeuron const &other) SYMBOL_VISIBLE

Copy assignment operator.

bool operator== (MCSafeAtomicNeuron const &other) const SYMBOL_VISIBLE

Public Members

Adaptation adaptation

Bayesian bayesian

ConstantCurrent constant_current

EventRouting event_routing

SynapticInput excitatory_input

Exponential exponential

SynapticInput inhibitory_input

Leak leak

MembraneCapacitance membrane_capacitance

Multicompartment multicompartment

Readout readout

RefractoryPeriod refractory_period

Reset reset

Threshold threshold

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< LogicalNeuron >

friend class LogicalNeuron

friend std::ostream & operator<< (std::ostream &os, MCSafeAtomicNeuron const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::MembraneCapacitance

#include <neuron.h>

Public Types

typedef haldls::vx::v3::NeuronConfig::MembraneCapacitorSize CapacitorSize

Public Functions

MembraneCapacitance () SYMBOL_VISIBLE

bool operator!= (MembraneCapacitance const &other) const SYMBOL_VISIBLE

bool operator== (MembraneCapacitance const &other) const SYMBOL_VISIBLE

Public Members

CapacitorSize capacitance

Select membrane capacitance.

The maximum value at 63 is ~2.3pF.

Friends

friend std::ostream & operator<< (std::ostream &os, MembraneCapacitance const &config) SYMBOL_VISIBLE

struct MembraneCapacitance

#include <neuron.h>

Public Types

typedef haldls::vx::v3::NeuronConfig::MembraneCapacitorSize CapacitorSize

Public Functions

MembraneCapacitance () SYMBOL_VISIBLE

bool operator!= (MembraneCapacitance const &other) const SYMBOL_VISIBLE

bool operator== (MembraneCapacitance const &other) const SYMBOL_VISIBLE

Public Members

CapacitorSize capacitance

Select membrane capacitance.

The maximum value at 63 is ~2.3pF.

Friends

friend std::ostream & operator<< (std::ostream &os, MembraneCapacitance const &config) SYMBOL_VISIBLE

struct lola::vx::PPUElfFile::Memory

#include <ppu.h>

Public Members

std::optional<lola::vx::ExternalPPUMemoryBlock> external

haldls::vx::PPUMemoryBlock internal

class lola::vx::MemoryTiming : public haldls::vx::ContainerBase<MemoryTiming>

#include <memory_timing.h>

Timing configuration of memories.

Public Types

typedef halco::common::typed_array<haldls::vx::CADCOffsetSRAMTimingConfig, haldls::vx::CADCOffsetSRAMTimingConfig::coordinate_type> CADCOffset

typedef halco::hicann_dls::vx::MemoryTimingOnDLS coordinate_type

typedef std::false_type has_local_data

typedef halco::common::typed_array<haldls::vx::NeuronSRAMTimingConfig, haldls::vx::NeuronSRAMTimingConfig::coordinate_type> Neuron

typedef halco::common::typed_array<haldls::vx::NeuronBackendSRAMTimingConfig, haldls::vx::NeuronBackendSRAMTimingConfig::coordinate_type> NeuronBackend

typedef halco::common::typed_array<haldls::vx::SynapseDriverSRAMTimingConfig, haldls::vx::SynapseDriverSRAMTimingConfig::coordinate_type> SynapseDriver

typedef halco::common::typed_array<haldls::vx::CommonSynramConfig, haldls::vx::CommonSynramConfig::coordinate_type> Synram

Public Functions

MemoryTiming() = default

bool operator!= (MemoryTiming const &other) const SYMBOL_VISIBLE

bool operator== (MemoryTiming const &other) const SYMBOL_VISIBLE

Public Members

CADCOffset cadc_offset

Memory timing of SRAM of CADC offsets.

Neuron neuron

Memory timing of SRAM of neurons.

NeuronBackend neuron_backend

Memory timing of SRAM of neuron backends.

SynapseDriver synapse_driver

Memory timing of SRAM of synapse drivers.

Synram synram

Memory timing of SRAM of synram.

Friends

friend std::ostream & operator<< (std::ostream &os, MemoryTiming const &config) SYMBOL_VISIBLE

class GENPYBIND_TAG_LOLA_VX_VY::Morphology

#include <morphology.h>

Builder for the LogicalNeuron.

The Morphology represents the structure of a MC-neuron, more precise it saves which switches are set but also the whole neuron config. Through the set switches the structure is fully described. It is composed of single AtomicNeurons (denmem neurons).

Public Types

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::AtomicNeuronOnLogicalNeuron AtomicNeuronOnLogicalNeuron

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::LogicalNeuronCompartments::Compartment Compartment

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::CompartmentOnLogicalNeuron CompartmentOnLogicalNeuron

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::LogicalNeuronCompartments::Compartments Compartments

typedef std::map<AtomicNeuronOnLogicalNeuron, AtomicNeuron::Multicompartment> MorphologyMap

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::NeuronColumnOnLogicalNeuron NeuronColumnOnLogicalNeuron

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::NeuronRowOnLogicalNeuron NeuronRowOnLogicalNeuron

Public Functions

inline AtomicNeuron::Multicompartment at(AtomicNeuronOnLogicalNeuron const &coord) const

Get neuron.

Returns

AtomicNeurons’s Multicompartment configuration.

void connect_resistor_to_soma (AtomicNeuronOnLogicalNeuron const &coord) SYMBOL_VISIBLE

void connect_soma_line (NeuronColumnOnLogicalNeuron const &start, NeuronColumnOnLogicalNeuron const &end, NeuronRowOnLogicalNeuron const &row) SYMBOL_VISIBLE

void connect_to_soma (AtomicNeuronOnLogicalNeuron const &coord) SYMBOL_VISIBLE

CompartmentOnLogicalNeuron create_compartment (Compartment const &compartment) SYMBOL_VISIBLE

std::pair< halco::hicann_dls::vx::CHIP_REVISION_STR::LogicalNeuronCompartments, LogicalNeuron > done () SYMBOL_VISIBLE

Public Members

MorphologyMap morphology

Private Functions

bool check_compartment_connectivity(Compartments const &comp_sets)

void connect_right(AtomicNeuronOnLogicalNeuron const &neuron_left, AtomicNeuronOnLogicalNeuron const &neuron_right)

void connect_vertical(NeuronColumnOnLogicalNeuron const &column)

std::stringstream create_current_config() const

Create string stream which sketches the current structure of the morphology.

void define_compartments()

Compartment extract_compartment(AtomicNeuronOnLogicalNeuron const &start_neuron, std::set<AtomicNeuronOnLogicalNeuron> &unvisited_neurons)

Compartment get_neighbors(AtomicNeuronOnLogicalNeuron const &start_neuron)

std::set<CompartmentOnLogicalNeuron> get_neighbors(CompartmentOnLogicalNeuron const &curr_comp_idx)

std::set<CompartmentOnLogicalNeuron> walk_neighbors(CompartmentOnLogicalNeuron const &start_comp)

Private Members

Compartments m_compartments

std::vector<std::pair<AtomicNeuronOnLogicalNeuron, AtomicNeuronOnLogicalNeuron>> m_involved_connect_right

Remember “connect_right” connections since they change by x-flipping.

std::vector<std::pair<AtomicNeuronOnLogicalNeuron, AtomicNeuronOnLogicalNeuron>> m_involved_connect_soma_right

Remember “connect_soma_right” connections since they change by x-flipping.

Friends

friend class LogicalNeuron

friend std::ostream & operator<< (std::ostream &os, Morphology const &morph) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::MCSafeAtomicNeuron::Multicompartment

#include <morphology.h>

Public Functions

Multicompartment () SYMBOL_VISIBLE

explicit  Multicompartment (AtomicNeuron::Multicompartment an_multicomp) SYMBOL_VISIBLE

Multicompartment (Multicompartment &&other) SYMBOL_VISIBLE

Move constructor.

Multicompartment (Multicompartment const &multicompartment) SYMBOL_VISIBLE

Copy constructor.

~Multicompartment() = default

Destructor.

bool operator!= (Multicompartment const &other) const SYMBOL_VISIBLE

Multicompartment & operator= (Multicompartment &&other) SYMBOL_VISIBLE

Move assignment operator.

Multicompartment & operator= (Multicompartment const &other) SYMBOL_VISIBLE

bool operator== (Multicompartment const &other) const SYMBOL_VISIBLE

Public Members

bool enable_conductance_division

Enable division (/4) of inter-compartment conductance.

bool enable_conductance_multiplication

Enable multiplication (*4) of inter-compartment conductance.

AnalogValueVariant i_bias_nmda

Bias current of inter-compartmental conductance.

Private Functions

explicit  operator AtomicNeuron::Multicompartment () const SYMBOL_VISIBLE

Multicompartment &operator=(AtomicNeuron::Multicompartment const &other)

template<class Archive>
void serialize(Archive &ar, std::uint32_t const)

Private Members

bool connect_right

Connect local membrane to membrane on the right.

bool connect_soma

Members that can change the morphology of a neuron are immutable.

Connect local membrane to soma.

bool connect_soma_right

Connect soma to soma on the right.

bool connect_vertical

Connect local membrane vertically to membrane on the opposite hemisphere.

bool enable_conductance

Enable inter-compartment conductance.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< LogicalNeuron >

friend struct haldls::vx::detail::VisitPreorderImpl< MCSafeAtomicNeuron >

friend class MCSafeAtomicNeuron

friend std::ostream & operator<< (std::ostream &os, Multicompartment const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::Multicompartment

#include <neuron.h>

Multicompartment configuration of connectivity to adjacent neurons.

See https://arxiv.org/abs/1804.01840 III.A for more information about the circuit.

Public Functions

Multicompartment () SYMBOL_VISIBLE

bool operator!= (Multicompartment const &other) const SYMBOL_VISIBLE

bool operator== (Multicompartment const &other) const SYMBOL_VISIBLE

Public Members

bool connect_right

Connect local membrane to membrane on the right.

bool connect_soma

Connect local membrane to soma.

bool connect_soma_right

Connect soma to soma on the right.

bool connect_vertical

Connect local membrane vertically to membrane on the opposite hemisphere.

bool enable_conductance

Enable inter-compartment conductance.

bool enable_conductance_division

Enable division (/4) of inter-compartment conductance.

bool enable_conductance_multiplication

Enable multiplication (*4) of inter-compartment conductance.

AnalogValueVariant i_bias_nmda

Bias current of inter-compartmental conductance.

Friends

friend std::ostream & operator<< (std::ostream &os, Multicompartment const &config) SYMBOL_VISIBLE

struct Multicompartment

#include <neuron.h>

Multicompartment configuration of connectivity to adjacent neurons.

See https://arxiv.org/abs/1804.01840 III.A for more information about the circuit.

Public Functions

Multicompartment () SYMBOL_VISIBLE

bool operator!= (Multicompartment const &other) const SYMBOL_VISIBLE

bool operator== (Multicompartment const &other) const SYMBOL_VISIBLE

Public Members

bool connect_right

Connect local membrane to membrane on the right.

bool connect_soma

Connect local membrane to soma.

bool connect_soma_right

Connect soma to soma on the right.

bool connect_vertical

Connect local membrane vertically to membrane on the opposite hemisphere.

bool enable_conductance

Enable inter-compartment conductance.

bool enable_conductance_division

Enable division (/4) of inter-compartment conductance.

bool enable_conductance_multiplication

Enable multiplication (*4) of inter-compartment conductance.

AnalogValueVariant i_bias_nmda

Bias current of inter-compartmental conductance.

Friends

friend std::ostream & operator<< (std::ostream &os, Multicompartment const &config) SYMBOL_VISIBLE

class NeuronBlock : public haldls::vx::ContainerBase<NeuronBlock>

Neuron block of all neurons on one chip including switches to synapses and global parameters.

Public Types

typedef haldls::vx::v3::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::v3::CapMemCell::Value AnalogValue

typedef halco::common::typed_array<AnalogValueVariant, halco::hicann_dls::vx::v3::CapMemBlockOnDLS> AnalogValues

typedef haldls::vx::v3::CapMemCell::value_type AnalogValueVariant

typedef halco::common::typed_heap_array<AtomicNeuron, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> AtomicNeurons

typedef halco::common::typed_array<haldls::vx::v3::CommonNeuronBackendConfig, halco::hicann_dls::vx::v3::CommonNeuronBackendConfigOnDLS> Backends

typedef halco::hicann_dls::vx::v3::NeuronBlockOnDLS coordinate_type

typedef halco::common::typed_array<lola::vx::v3::ColumnCurrentRow, halco::hicann_dls::vx::v3::ColumnCurrentRowOnDLS> CurrentRows

typedef std::false_type has_local_data

Public Functions

NeuronBlock() = default

av def ("__getitem__", &::lola::vx::v3::NeuronBlock::AnalogValues::get, "", parent->py::arg("key"), parent->py::return_value_policy::reference)

av def ("__iter__", [av](::lola::vx::v3::NeuronBlock::AnalogValues &self) { return pybind11::make_iterator(self);}, parent->py::template keep_alive< 0, 1 >())

av def ("__setitem__", &::lola::vx::v3::NeuronBlock::AnalogValues::set, "", parent->py::arg("key"), parent->py::arg("value"))

av def ("at",(genpybind_at_type) &::lola::vx::v3::NeuronBlock::AnalogValues::at, "", parent->py::arg("key"))

av def ("at",(genpybind_at_type) &::lola::vx::v3::NeuronBlock::AnalogValues::at, "", parent->py::arg("key"))

av def ("back",(genpybind_back_type) &::lola::vx::v3::NeuronBlock::AnalogValues::back, "")

av def ("back",(genpybind_back_type) &::lola::vx::v3::NeuronBlock::AnalogValues::back, "")

av def ("fill", &::lola::vx::v3::NeuronBlock::AnalogValues::fill, "", parent->py::arg("val"))

av def ("from_numpy", [](::lola::vx::v3::NeuronBlock::AnalogValues &self, pybind11::array const &array) { ::halco::common::detail::from_numpy(self, array);})

av def ("front",(genpybind_front_type) &::lola::vx::v3::NeuronBlock::AnalogValues::front, "")

av def ("front",(genpybind_front_type) &::lola::vx::v3::NeuronBlock::AnalogValues::front, "")

av def ("to_numpy", [](::lola::vx::v3::NeuronBlock::AnalogValues const &self) { return ::halco::common::detail::to_numpy(self);})

av def (parent->py::template init< const ::lola::vx::v3::NeuronBlock::AnalogValues & >(), "")

av def (parent->py::template init<>(), "")

av def_property_readonly ("empty", parent->py::cpp_function(&::lola::vx::v3::NeuronBlock::AnalogValues::empty))

av def_property_readonly ("max_size", parent->py::cpp_function(&::lola::vx::v3::NeuronBlock::AnalogValues::max_size))

av def_property_readonly ("size", parent->py::cpp_function(&::lola::vx::v3::NeuronBlock::AnalogValues::size))

bool operator!= (NeuronBlock const &other) const SYMBOL_VISIBLE

bool operator== (NeuronBlock const &other) const SYMBOL_VISIBLE

Public Members

AtomicNeurons atomic_neurons = {}

Array of all neuron circuits.

Backends backends = {}

Block-wise digital backend configuration.

CurrentRows current_rows = {}

Switch-rows to synapse arrays.

AnalogValues i_bias_leak_source_follower = {AnalogValue{100}, AnalogValue{100}, AnalogValue{100}, AnalogValue{100}}

Bias current for the leak/reset input voltage drop source follower.

AnalogValues i_bias_readout_amp = {AnalogValue{110}, AnalogValue{110}, AnalogValue{110}, AnalogValue{110}}

Bias current for the neuron’s readout amplifier.

AnalogValues i_bias_synin_drop = {AnalogValue{300}, AnalogValue{300}, AnalogValue{300}, AnalogValue{300}}

Bias current for the source follower controlling the drop of the voltage on the synaptic line before the OTA’s input.

AnalogValues i_bias_threshold_comparator = {AnalogValue{200}, AnalogValue{200}, AnalogValue{200}, AnalogValue{200}}

Bias current for the threshold comparator.

AnalogValues v_bias_casc_n = {AnalogValue{250}, AnalogValue{250}, AnalogValue{250}, AnalogValue{250}}

Cascode bias potential for various OTAs within the neuron.

Friends

friend std::ostream & operator<< (std::ostream &os, NeuronBlock const &config) SYMBOL_VISIBLE

class lola::vx::PPUElfFile

#include <ppu.h>

Read-access to memory and symbol data of PPU program file in the ELF file format.

Public Types

typedef std::map<std::string, PPUProgram::Symbol> symbols_type

Map of named symbols.

Public Functions

PPUElfFile (std::string const &filename) SYMBOL_VISIBLE

Open file.

Parameters

filename – File to open

~PPUElfFile () SYMBOL_VISIBLE

Close file.

Memory read_program () SYMBOL_VISIBLE

Read program memory data, i.e.

the data associated to all sections necessary for execution placed at their specified location in memory.

Returns

Continuous block of PPU memory data for external and internal memory.

symbols_type read_symbols () SYMBOL_VISIBLE

Read symbol data.

Returns

Map of named symbols.

Private Members

Elf *m_elf_ptr

int m_fd

Private Static Attributes

static constexpr uint32_t external_base_address   = 0x8000'0000

Base address of external memory for instructions from the view of the PPU.

static constexpr uint32_t external_data_base_address   = 0x4000'0000

Base address of external memory for data from the view of the PPU.

class PPUProgram

#include <ppu.h>

struct GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain::PseudoDifferentialConverter

#include <readout_chain.h>

Configuration of the pseudo differential converter.

This circuit adds a reference to the signal measured by one of the two source multiplexers. It is forwarded to the MADC as a differential signal.

Public Functions

PseudoDifferentialConverter() = default

bool operator!= (PseudoDifferentialConverter const &other) const SYMBOL_VISIBLE

bool operator== (PseudoDifferentialConverter const &other) const SYMBOL_VISIBLE

Public Members

AnalogValueVariant buffer_bias = {AnalogValue{0}}

Bias current for the buffer providing the reference voltage.

HemisphereType enable_reference = {{false, false}}

Connect reference to a wire on north or south hemisphere.

AnalogValueVariant v_ref = {AnalogValue{400}}

Reference voltage.

Friends

friend std::ostream & operator<< (std::ostream &os, PseudoDifferentialConverter const &config) SYMBOL_VISIBLE

class GENPYBIND_TAG_LOLA_VX_VY::CADCReadoutChain::Ramp

#include <cadc.h>

CADC ramp generation settings.

Public Types

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::Value AnalogValue

typedef haldls::vx::CADCConfig::DeadTime DeadTime

typedef haldls::vx::CHIP_REVISION_STR::CommonCorrelationConfig::RampOffsets OffsetAssignment

typedef haldls::vx::CADCConfig::ResetWait ResetWait

Public Functions

Ramp() = default

bool operator!= (Ramp const &other) const SYMBOL_VISIBLE

bool operator== (Ramp const &other) const SYMBOL_VISIBLE

Public Members

DeadTime dead_time = {}

Dead time before a read returns, after the CADC ramp has increased to 1.2 V.

Given in PPU clock cycles.

bool enable = {false}

Enable CADC for the current hemisphere.

CADCReadoutChain::AnalogValues i_bias_comparator = {}

Bias current for the comparator in each CADC channel.

CADCReadoutChain::AnalogValues i_bias_vreset_buffer = {}

Bias current for the buffer for v_offset, relevant during reset of the ramp.

CADCReadoutChain::AnalogValues i_slope = {}

Ramp current, determines slope of the linear voltage range.

ResetWait reset_wait = {}

Reset duration of the CADC ramp.

At the beginning of a read (after the sense_delay has passed), the ramp is pulled down from 1.2 V to v_offset for this time. Given in PPU clock cycles.

CADCReadoutChain::AnalogValues v_bias_buffer = {}

Bias voltage for the buffer distributing the ramp to each channel.

CADCReadoutChain::AnalogValues v_offset = {}

Ramp start voltage.

OffsetAssignment v_offset_assignment{halco::hicann_dls::vx::CHIP_REVISION_STR::CapMemBlockOnHemisphere(0), halco::hicann_dls::vx::CHIP_REVISION_STR::CapMemBlockOnHemisphere(1)}

Select the assignment of v_offset between left and right CapMem instances.

Each of the ramp generators (left and right CADC branch) can independently select a source for their v_offset voltage (left and right CapMem).

Friends

friend std::ostream & operator<< (std::ostream &os, Ramp const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::Readout

#include <neuron.h>

Public Types

typedef haldls::vx::v3::NeuronConfig::ReadoutSource Source

Public Functions

Readout () SYMBOL_VISIBLE

bool operator!= (Readout const &other) const SYMBOL_VISIBLE

bool operator== (Readout const &other) const SYMBOL_VISIBLE

Public Members

bool enable_amplifier

Enable readout amplifier.

bool enable_buffered_access

Connect the readout amplifier’s output to the shared readout lines.

Do not enable this setting for more than one neuron per line. This setting does not need to be enabled to reach the CADCs.

bool enable_unbuffered_access

Enable direct, unbuffered access.

Connects output of readout mux to shared line different from the buffered readout lines.

Source source

Source of readout output.

This multiplexer affects both buffered and unbuffered access.

When choosing one of the synaptic inputs, the voltage is dropped by a source follower before reaching the multiplexer. The source follower bias current is derived from the readout amplifier, thus the enable_amplifier flag and the current i_bias have to be set, even when using unbuffered access only.

The mux is not capable of disconnecting signals above 1.2 V properly, which can occur on the membrane as a result of synaptic input. In order to record low voltages from e.g. the synaptic input, the synaptic inputs should be disabled. During normal operation, the source follower in the synaptic input prevents feedback.

Friends

friend std::ostream & operator<< (std::ostream &os, Readout const &config) SYMBOL_VISIBLE

struct Readout

#include <neuron.h>

Public Types

typedef haldls::vx::v3::NeuronConfig::ReadoutSource Source

Public Functions

Readout () SYMBOL_VISIBLE

bool operator!= (Readout const &other) const SYMBOL_VISIBLE

bool operator== (Readout const &other) const SYMBOL_VISIBLE

Public Members

bool enable_amplifier

Enable readout amplifier.

bool enable_buffered_access

Connect the readout amplifier’s output to the shared readout lines.

Do not enable this setting for more than one neuron per line. This setting does not need to be enabled to reach the CADCs.

bool enable_unbuffered_access

Enable direct, unbuffered access.

Connects output of readout mux to shared line different from the buffered readout lines.

Source source

Source of readout output.

This multiplexer affects both buffered and unbuffered access.

When choosing one of the synaptic inputs, the voltage is dropped by a source follower before reaching the multiplexer. The source follower bias current is derived from the readout amplifier, thus the enable_amplifier flag and the current i_bias have to be set, even when using unbuffered access only.

The mux is not capable of disconnecting signals above 1.2 V properly, which can occur on the membrane as a result of synaptic input. In order to record low voltages from e.g. the synaptic input, the synaptic inputs should be disabled. During normal operation, the source follower in the synaptic input prevents feedback.

Friends

friend std::ostream & operator<< (std::ostream &os, Readout const &config) SYMBOL_VISIBLE

class GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain : public haldls::vx::ContainerBase<ReadoutChain>

#include <readout_chain.h>

Configuration of all circuits composing the analog readout chain.

Public Types

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::Value AnalogValue

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::value_type AnalogValueVariant

typedef halco::common::typed_array<BufferToPadT, halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection> BufferToPad

typedef halco::hicann_dls::vx::ReadoutChainOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::MADCConfig::hemisphere_type HemisphereType

typedef halco::common::typed_array<haldls::vx::ReadoutSourceSelection::SourceMultiplexer, halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection> InputMux

Configuration of the multiplexer for the different input signals from chip.

These source multiplexers connect to the Dynamic multiplexer and are the standard way of selecting the readout source of the MADC. They can also be connected to the pads.

typedef halco::common::typed_array<haldls::vx::PadMultiplexerConfig, halco::hicann_dls::vx::PadMultiplexerConfigOnDLS> PadMux

Configuration of the Pad multiplexers.

These provide are a multitude of possibilities for reading out voltages from chip or making direct (unbuffered) connections to outside the chip.

typedef haldls::vx::MADCConfig::SamplingWindowTiming SamplingWindowTiming

typedef haldls::vx::MADCConfig::synapse_target_type SynapseTargetType

Public Functions

ReadoutChain() = default

bool operator!= (ReadoutChain const &other) const SYMBOL_VISIBLE

bool operator== (ReadoutChain const &other) const SYMBOL_VISIBLE

Public Members

BufferToPad buffer_to_pad

CurrentDAC current_dac

DynamicMux dynamic_mux

InputMux input_mux

MADC madc

MADCDebugCrossbar madc_debug_crossbar

MADCInputCrossbar madc_input_crossbar

MADCPreamp madc_preamp

PadMux pad_mux

PseudoDifferentialConverter pseudo_diff_converter

SourceMeasureUnit source_measure_unit

Friends

friend std::ostream & operator<< (std::ostream &os, ReadoutChain const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::RefractoryPeriod

#include <neuron.h>

Public Types

typedef haldls::vx::v3::NeuronBackendConfig::InputClock InputClock

typedef haldls::vx::v3::NeuronBackendConfig::RefractoryTime RefractoryTime

typedef haldls::vx::v3::NeuronBackendConfig::ResetHoldoff ResetHoldoff

Public Functions

RefractoryPeriod () SYMBOL_VISIBLE

bool operator!= (RefractoryPeriod const &other) const SYMBOL_VISIBLE

bool operator== (RefractoryPeriod const &other) const SYMBOL_VISIBLE

Public Members

bool enable_pause

Enable gating of synaptic inputs and exponential term during reset periods.

InputClock input_clock

Select between the two input clocks specified in the common neuron backend.

A value of 0 refers to the setting called “slow”, a value of 1 selects the “fast” clock.

RefractoryTime refractory_time

Counter value to control refractory time.

Beginning with a spike, the counter is increased with the selected input clock. Once the given value is reached, the refractory period ends.

ResetHoldoff reset_holdoff

Release the reset potential before the refractory time ends.

This allows a dead time after the reset where no new spike can be recorded and the membrane is connected to the leak potential already. A higher value results in a later release of the reset.

Note: A more detailed description is given with the ResetHoldoff type.

Friends

friend std::ostream & operator<< (std::ostream &os, RefractoryPeriod const &config) SYMBOL_VISIBLE

struct RefractoryPeriod

#include <neuron.h>

Public Types

typedef haldls::vx::v3::NeuronBackendConfig::InputClock InputClock

typedef haldls::vx::v3::NeuronBackendConfig::RefractoryTime RefractoryTime

typedef haldls::vx::v3::NeuronBackendConfig::ResetHoldoff ResetHoldoff

Public Functions

RefractoryPeriod () SYMBOL_VISIBLE

bool operator!= (RefractoryPeriod const &other) const SYMBOL_VISIBLE

bool operator== (RefractoryPeriod const &other) const SYMBOL_VISIBLE

Public Members

bool enable_pause

Enable gating of synaptic inputs and exponential term during reset periods.

InputClock input_clock

Select between the two input clocks specified in the common neuron backend.

A value of 0 refers to the setting called “slow”, a value of 1 selects the “fast” clock.

RefractoryTime refractory_time

Counter value to control refractory time.

Beginning with a spike, the counter is increased with the selected input clock. Once the given value is reached, the refractory period ends.

ResetHoldoff reset_holdoff

Release the reset potential before the refractory time ends.

This allows a dead time after the reset where no new spike can be recorded and the membrane is connected to the leak potential already. A higher value results in a later release of the reset.

Note: A more detailed description is given with the ResetHoldoff type.

Friends

friend std::ostream & operator<< (std::ostream &os, RefractoryPeriod const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::Reset

#include <neuron.h>

Public Functions

Reset () SYMBOL_VISIBLE

bool operator!= (Reset const &other) const SYMBOL_VISIBLE

bool operator== (Reset const &other) const SYMBOL_VISIBLE

Public Members

bool enable_degeneration

Enable source degeneration of reset OTA.

bool enable_division

Enable division (/8) of reset conductance.

bool enable_multiplication

Enable multiplication (*8) of reset conductance.

AnalogValueVariant i_bias

AnalogValueVariant v_reset

Reset potential.

Friends

friend std::ostream & operator<< (std::ostream &os, Reset const &config) SYMBOL_VISIBLE

struct Reset

#include <neuron.h>

Public Functions

Reset () SYMBOL_VISIBLE

bool operator!= (Reset const &other) const SYMBOL_VISIBLE

bool operator== (Reset const &other) const SYMBOL_VISIBLE

Public Members

bool enable_degeneration

Enable source degeneration of reset OTA.

bool enable_division

Enable division (/8) of reset conductance.

bool enable_multiplication

Enable multiplication (*8) of reset conductance.

AnalogValueVariant i_bias

AnalogValueVariant v_reset

Reset potential.

Friends

friend std::ostream & operator<< (std::ostream &os, Reset const &config) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::ReadoutChain::SourceMeasureUnit

#include <readout_chain.h>

Configuration of the source measure unit.

An input current from neuron membranes or synapse lines can be measured: the current is converted to a voltage that is sampled by the MADC.

Public Functions

SourceMeasureUnit() = default

bool operator!= (SourceMeasureUnit const &other) const SYMBOL_VISIBLE

bool operator== (SourceMeasureUnit const &other) const SYMBOL_VISIBLE

Public Members

AnalogValueVariant amp_i_bias = {}

Amplifier bias current.

AnalogValueVariant amp_v_ref = {AnalogValue{400}}

Amplifier reference voltage.

AnalogValueVariant buffer_i_bias = {}

Buffer bias current.

HemisphereType connect_neuron_stimulus = {{false, false}}

Connect neuron stimulus per hemisphere.

SynapseTargetType connect_synapse_debug = {{false, false}}

Connect synapse debug wires.

SamplingWindowTiming sampling_window_end = {14}

End of sampling window.

SamplingWindowTiming sampling_window_start = {9}

Start of sampling window.

AnalogValueVariant test_voltage = {AnalogValue{400}}

Test reference voltage.

Friends

friend std::ostream & operator<< (std::ostream &os, SourceMeasureUnit const &config) SYMBOL_VISIBLE

class lola::vx::PPUProgram::Symbol

#include <ppu.h>

Symbol of PPU program describing the location and type of a continuous block of memory.

Symbols can either describe an object, i.e. global data or executable code of a function.

Public Types

typedef std::variant<halco::hicann_dls::vx::PPUMemoryBlockOnPPU, halco::hicann_dls::vx::ExternalPPUMemoryBlockOnFPGA> Coordinate

enum Type

Symbol type.

Values:

enumerator object

enumerator function

enumerator other

Public Functions

Symbol () SYMBOL_VISIBLE

Default construct a symbol of type ‘other’ and default coordinate.

Symbol (Type const &type, Coordinate const &coord) SYMBOL_VISIBLE

Construct a symbol from a type and a coordinate.

bool operator!= (Symbol const &other) const SYMBOL_VISIBLE

bool operator== (Symbol const &other) const SYMBOL_VISIBLE

Public Members

Coordinate coordinate

Location of memory block corresponding to symbol.

Type type

Type of symbol.

Friends

friend std::ostream & operator<< (std::ostream &os, Symbol const &symbol) SYMBOL_VISIBLE

struct GENPYBIND_TAG_LOLA_VX_VY::SynapseBlock : public haldls::vx::ContainerBase<SynapseBlock>

#include <synapse_block.h>

Synapses of one hemisphere in conjunction with hemisphere-global configuration.

Public Types

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::Value AnalogValue

typedef halco::common::typed_array<haldls::vx::CHIP_REVISION_STR::CapMemCell::value_type, halco::hicann_dls::vx::CHIP_REVISION_STR::CapMemBlockOnHemisphere> AnalogValues

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::value_type AnalogValueVariant

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::SynapseBlockOnDLS coordinate_type

typedef std::false_type has_local_data

typedef SynapseMatrix Matrix

Public Functions

SynapseBlock() = default

Default constructor.

bool operator!= (SynapseBlock const &other) const SYMBOL_VISIBLE

bool operator== (SynapseBlock const &other) const SYMBOL_VISIBLE

Public Members

AnalogValues i_bias_dac = {AnalogValue{1022}, AnalogValue{1022}}

DAC bias altering the synaptic strength.

Matrix matrix

Synapses.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseBlock >

friend std::ostream & operator<< (std::ostream &os, SynapseBlock const &config) SYMBOL_VISIBLE

class lola::vx::SynapseCorrelationCalibMatrix : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseCorrelationCalibMatrix>

#include <synapse.h>

Public Types

typedef row_type<AmpCalib> _amp_calibs_row_type

typedef matrix_type<AmpCalib> _amp_calibs_type

typedef row_type<TimeCalib> _time_calibs_row_type

typedef matrix_type<TimeCalib> _time_calibs_type

typedef haldls::vx::SynapseCorrelationCalibQuad::AmpCalib AmpCalib

typedef halco::hicann_dls::vx::SynapseCorrelationCalibMatrixOnDLS coordinate_type

typedef std::false_type has_local_data

template<typename T>
using matrix_type = halco::common::typed_heap_array<row_type<T>, halco::hicann_dls::vx::SynapseRowOnSynram>

template<typename T>
using row_type = halco::common::typed_array<T, halco::hicann_dls::vx::SynapseOnSynapseRow>

typedef haldls::vx::SynapseCorrelationCalibQuad::TimeCalib TimeCalib

Public Functions

SynapseCorrelationCalibMatrix () SYMBOL_VISIBLE

Default constructor.

bool operator!= (SynapseCorrelationCalibMatrix const &other) const SYMBOL_VISIBLE

bool operator== (SynapseCorrelationCalibMatrix const &other) const SYMBOL_VISIBLE

Public Members

_amp_calibs_type amp_calibs

Synapse correlation amplitude calibration array.

_time_calibs_type time_calibs

Synapse correlation time calibration array.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseCorrelationCalibMatrix >

friend std::ostream & operator<< (std::ostream &os, SynapseCorrelationCalibMatrix const &row) SYMBOL_VISIBLE

class lola::vx::SynapseCorrelationCalibRow : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseCorrelationCalibRow>

#include <synapse.h>

Public Types

typedef halco::common::typed_heap_array<AmpCalib, halco::hicann_dls::vx::SynapseOnSynapseRow> _amp_calibs_type

typedef halco::common::typed_heap_array<TimeCalib, halco::hicann_dls::vx::SynapseOnSynapseRow> _time_calibs_type

typedef haldls::vx::SynapseCorrelationCalibQuad::AmpCalib AmpCalib

typedef halco::hicann_dls::vx::SynapseCorrelationCalibRowOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::SynapseCorrelationCalibQuad::TimeCalib TimeCalib

Public Functions

SynapseCorrelationCalibRow () SYMBOL_VISIBLE

Default constructor.

bool operator!= (SynapseCorrelationCalibRow const &other) const SYMBOL_VISIBLE

bool operator== (SynapseCorrelationCalibRow const &other) const SYMBOL_VISIBLE

Public Members

_amp_calibs_type amp_calibs

Synapse correlation amplitude calibration array.

_time_calibs_type time_calibs

Synapse correlation time calibration array.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseCorrelationCalibRow >

friend std::ostream & operator<< (std::ostream &os, SynapseCorrelationCalibRow const &row) SYMBOL_VISIBLE

class GENPYBIND_TAG_LOLA_VX_VY::SynapseDriverBlock : public haldls::vx::ContainerBase<SynapseDriverBlock>

#include <synapse_driver.h>

Block on synapse drivers and global configuration of one hemisphere.

Public Types

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::Value AnalogValue

typedef halco::common::typed_array<haldls::vx::CHIP_REVISION_STR::CapMemCell::value_type, halco::hicann_dls::vx::CHIP_REVISION_STR::CapMemBlockOnHemisphere> AnalogValues

typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::value_type AnalogValueVariant

typedef halco::hicann_dls::vx::CHIP_REVISION_STR::SynapseDriverBlockOnDLS coordinate_type

typedef std::false_type has_local_data

typedef halco::common::typed_array<haldls::vx::CHIP_REVISION_STR::SynapseDriverConfig, halco::hicann_dls::vx::CHIP_REVISION_STR::SynapseDriverOnSynapseDriverBlock> SynapseDrivers

Public Functions

SynapseDriverBlock() = default

Default constructor.

bool operator!= (SynapseDriverBlock const &other) const SYMBOL_VISIBLE

bool operator== (SynapseDriverBlock const &other) const SYMBOL_VISIBLE

Public Members

AnalogValueVariant hagen_i_bias_dac

haldls::vx::CHIP_REVISION_STR::CommonPADIBusConfig padi_bus

Configuration of PADI-busses.

haldls::vx::CHIP_REVISION_STR::CommonSTPConfig stp

Digital STP configuration.

AnalogValues stp_i_bias_comparator

AnalogValueVariant stp_i_bias_readout

AnalogValues stp_i_calib

AnalogValues stp_i_ramp

AnalogValues stp_v_charge_0

AnalogValues stp_v_charge_1

AnalogValues stp_v_recover_0

AnalogValues stp_v_recover_1

SynapseDrivers synapse_drivers

Block of synapse drivers.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseDriverBlock >

friend std::ostream & operator<< (std::ostream &os, SynapseDriverBlock const &config) SYMBOL_VISIBLE

class lola::vx::SynapseLabelMatrix : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseLabelMatrix>

#include <synapse.h>

Public Types

typedef row_type<Value> _row_type

typedef matrix_type<Value> _values_type

typedef halco::hicann_dls::vx::SynapseLabelMatrixOnDLS coordinate_type

typedef std::false_type has_local_data

template<typename T>
using matrix_type = halco::common::typed_heap_array<row_type<T>, halco::hicann_dls::vx::SynapseRowOnSynram>

template<typename T>
using row_type = halco::common::typed_array<T, halco::hicann_dls::vx::SynapseOnSynapseRow>

typedef haldls::vx::SynapseLabelQuad::Value Value

Public Functions

SynapseLabelMatrix () SYMBOL_VISIBLE

Default constructor.

bool operator!= (SynapseLabelMatrix const &other) const SYMBOL_VISIBLE

bool operator== (SynapseLabelMatrix const &other) const SYMBOL_VISIBLE

Public Members

_values_type values

Synapse label array.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseLabelMatrix >

friend std::ostream & operator<< (std::ostream &os, SynapseLabelMatrix const &row) SYMBOL_VISIBLE

class lola::vx::SynapseLabelRow : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseLabelRow>

#include <synapse.h>

Public Types

typedef halco::common::typed_heap_array<Value, halco::hicann_dls::vx::SynapseOnSynapseRow> _values_type

typedef halco::hicann_dls::vx::SynapseLabelRowOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::SynapseLabelQuad::Value Value

Public Functions

SynapseLabelRow () SYMBOL_VISIBLE

Default constructor.

bool operator!= (SynapseLabelRow const &other) const SYMBOL_VISIBLE

bool operator== (SynapseLabelRow const &other) const SYMBOL_VISIBLE

Public Members

_values_type values

Synapse label array.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseLabelRow >

friend std::ostream & operator<< (std::ostream &os, SynapseLabelRow const &row) SYMBOL_VISIBLE

class lola::vx::SynapseMatrix : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseMatrix>

#include <synapse.h>

Public Types

typedef row_type<AmpCalib> _amp_calibs_row_type

typedef matrix_type<AmpCalib> _amp_calibs_type

typedef row_type<Label> _labels_row_type

typedef matrix_type<Label> _labels_type

typedef row_type<TimeCalib> _time_calibs_row_type

typedef matrix_type<TimeCalib> _time_calibs_type

typedef row_type<Weight> _weights_row_type

typedef matrix_type<Weight> _weights_type

typedef haldls::vx::SynapseQuad::AmpCalib AmpCalib

typedef halco::hicann_dls::vx::SynramOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::SynapseQuad::Label Label

template<typename T>
using matrix_type = halco::common::typed_heap_array<row_type<T>, halco::hicann_dls::vx::SynapseRowOnSynram>

template<typename T>
using row_type = halco::common::typed_array<T, halco::hicann_dls::vx::SynapseOnSynapseRow>

typedef haldls::vx::SynapseQuad::TimeCalib TimeCalib

typedef haldls::vx::SynapseQuad::Weight Weight

Public Functions

SynapseMatrix () SYMBOL_VISIBLE

Default constructor.

bool operator!= (SynapseMatrix const &other) const SYMBOL_VISIBLE

bool operator== (SynapseMatrix const &other) const SYMBOL_VISIBLE

Public Members

_amp_calibs_type amp_calibs

Synapse correlation amplitude calibration array.

_labels_type labels

Synapse label array.

_time_calibs_type time_calibs

Synapse correlation time calibration array.

_weights_type weights

Synapse weight array.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseMatrix >

friend std::ostream & operator<< (std::ostream &os, SynapseMatrix const &row) SYMBOL_VISIBLE

class lola::vx::SynapseRow : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseRow>

#include <synapse.h>

Public Types

typedef halco::common::typed_heap_array<AmpCalib, halco::hicann_dls::vx::SynapseOnSynapseRow> _amp_calibs_type

typedef halco::common::typed_heap_array<Label, halco::hicann_dls::vx::SynapseOnSynapseRow> _labels_type

typedef halco::common::typed_heap_array<TimeCalib, halco::hicann_dls::vx::SynapseOnSynapseRow> _time_calibs_type

typedef halco::common::typed_heap_array<Weight, halco::hicann_dls::vx::SynapseOnSynapseRow> _weights_type

typedef haldls::vx::SynapseQuad::AmpCalib AmpCalib

typedef halco::hicann_dls::vx::SynapseRowOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::SynapseQuad::Label Label

typedef haldls::vx::SynapseQuad::TimeCalib TimeCalib

typedef haldls::vx::SynapseQuad::Weight Weight

Public Functions

SynapseRow () SYMBOL_VISIBLE

Default constructor.

bool operator!= (SynapseRow const &other) const SYMBOL_VISIBLE

bool operator== (SynapseRow const &other) const SYMBOL_VISIBLE

Public Members

_amp_calibs_type amp_calibs

Synapse correlation amplitude calibration array.

_labels_type labels

Synapse label array.

_time_calibs_type time_calibs

Synapse correlation time calibration array.

_weights_type weights

Synapse weight array.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseRow >

friend std::ostream & operator<< (std::ostream &os, SynapseRow const &row) SYMBOL_VISIBLE

class lola::vx::SynapseWeightMatrix : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseWeightMatrix>

#include <synapse.h>

Public Types

typedef row_type<Value> _row_type

typedef matrix_type<Value> _values_type

typedef halco::hicann_dls::vx::SynapseWeightMatrixOnDLS coordinate_type

typedef std::false_type has_local_data

template<typename T>
using matrix_type = halco::common::typed_heap_array<row_type<T>, halco::hicann_dls::vx::SynapseRowOnSynram>

template<typename T>
using row_type = halco::common::typed_array<T, halco::hicann_dls::vx::SynapseOnSynapseRow>

typedef haldls::vx::SynapseWeightQuad::Value Value

Public Functions

SynapseWeightMatrix () SYMBOL_VISIBLE

Default constructor.

bool operator!= (SynapseWeightMatrix const &other) const SYMBOL_VISIBLE

bool operator== (SynapseWeightMatrix const &other) const SYMBOL_VISIBLE

Public Members

_values_type values

Synapse weight array.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseWeightMatrix >

friend std::ostream & operator<< (std::ostream &os, SynapseWeightMatrix const &row) SYMBOL_VISIBLE

class lola::vx::SynapseWeightRow : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseWeightRow>

#include <synapse.h>

Public Types

typedef halco::common::typed_heap_array<Value, halco::hicann_dls::vx::SynapseOnSynapseRow> _values_type

typedef halco::hicann_dls::vx::SynapseWeightRowOnDLS coordinate_type

typedef std::false_type has_local_data

typedef haldls::vx::SynapseWeightQuad::Value Value

Public Functions

SynapseWeightRow () SYMBOL_VISIBLE

Default constructor.

bool operator!= (SynapseWeightRow const &other) const SYMBOL_VISIBLE

bool operator== (SynapseWeightRow const &other) const SYMBOL_VISIBLE

Public Members

_values_type values

Synapse weight array.

Friends

friend struct haldls::vx::detail::VisitPreorderImpl< SynapseWeightRow >

friend std::ostream & operator<< (std::ostream &os, SynapseWeightRow const &row) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::SynapticInput

#include <neuron.h>

Public Functions

SynapticInput () SYMBOL_VISIBLE

bool operator!= (SynapticInput const &other) const SYMBOL_VISIBLE

bool operator== (SynapticInput const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Digital enable of synaptic input.

bool enable_coba_mode

Switch synaptic input from CUBA to COBA mode.

bool enable_high_resistance

Enable high resistance mode controlling the time constant.

bool enable_small_capacitance

Enable small capacitance mode of the synaptic input.

This disconnects the capacitor connected to the line in the synapse array, using only parasitic capacitance of the line.

AnalogValueVariant i_bias_coba

Bias current for the conductance based mode of the synaptic input.

Scales the conductivity at a given difference between membrane and reversal potential.

AnalogValueVariant i_bias_gm

Bias current of synaptic input OTA for current-based input.

AnalogValueVariant i_bias_tau

Bias current for the RC circuit controlling the synaptic input time constant.

AnalogValueVariant i_shift_reference

Bias current for the source follower controlling the reference voltage for the synaptic input’s OTA.

AnalogValueVariant v_rev_coba

Reversal potential of the COBA based synaptic input.

Friends

friend std::ostream & operator<< (std::ostream &os, SynapticInput const &config) SYMBOL_VISIBLE

struct SynapticInput

#include <neuron.h>

Public Functions

SynapticInput () SYMBOL_VISIBLE

bool operator!= (SynapticInput const &other) const SYMBOL_VISIBLE

bool operator== (SynapticInput const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Digital enable of synaptic input.

bool enable_coba_mode

Switch synaptic input from CUBA to COBA mode.

bool enable_high_resistance

Enable high resistance mode controlling the time constant.

bool enable_small_capacitance

Enable small capacitance mode of the synaptic input.

This disconnects the capacitor connected to the line in the synapse array, using only parasitic capacitance of the line.

AnalogValueVariant i_bias_coba

Bias current for the conductance based mode of the synaptic input.

Scales the conductivity at a given difference between membrane and reversal potential.

AnalogValueVariant i_bias_gm

Bias current of synaptic input OTA for current-based input.

AnalogValueVariant i_bias_tau

Bias current for the RC circuit controlling the synaptic input time constant.

AnalogValueVariant i_shift_reference

Bias current for the source follower controlling the reference voltage for the synaptic input’s OTA.

AnalogValueVariant v_rev_coba

Reversal potential of the COBA based synaptic input.

Friends

friend std::ostream & operator<< (std::ostream &os, SynapticInput const &config) SYMBOL_VISIBLE

struct lola::vx::v3::AtomicNeuron::Threshold

#include <neuron.h>

Public Functions

Threshold () SYMBOL_VISIBLE

bool operator!= (Threshold const &other) const SYMBOL_VISIBLE

bool operator== (Threshold const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Enable spike threshold comparator.

AnalogValueVariant v_threshold

Spike Threshold potential.

Friends

friend std::ostream & operator<< (std::ostream &os, Threshold const &config) SYMBOL_VISIBLE

struct Threshold

#include <neuron.h>

Public Functions

Threshold () SYMBOL_VISIBLE

bool operator!= (Threshold const &other) const SYMBOL_VISIBLE

bool operator== (Threshold const &other) const SYMBOL_VISIBLE

Public Members

bool enable

Enable spike threshold comparator.

AnalogValueVariant v_threshold

Spike Threshold potential.

Friends

friend std::ostream & operator<< (std::ostream &os, Threshold const &config) SYMBOL_VISIBLE

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::CHIP_REVISION_STR::CADCReadoutChain>

#include <cadc.h>

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<lola::vx::CHIP_REVISION_STR::CADCReadoutChain::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, lola::vx::CHIP_REVISION_STR::CADCReadoutChain::coordinate_type const &coord, VisitorT &&visitor)

template<typename VisitorT>
static inline void call(hate::Empty<lola::vx::CHIP_REVISION_STR::CADCReadoutChain> const &config, lola::vx::CHIP_REVISION_STR::CADCReadoutChain::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::CHIP_REVISION_STR::CADCSampleRow>

#include <cadc.h>

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<lola::vx::CHIP_REVISION_STR::CADCSampleRow::coordinate_type> coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, lola::vx::CHIP_REVISION_STR::CADCSampleRow::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> config, lola::vx::CHIP_REVISION_STR::CADCSampleRow::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::CHIP_REVISION_STR::CADCSamples>

#include <cadc.h>

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<lola::vx::CHIP_REVISION_STR::CADCSamples::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, lola::vx::CHIP_REVISION_STR::CADCSamples::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> const &config, lola::vx::CHIP_REVISION_STR::CADCSamples::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::CHIP_REVISION_STR::SynapseBlock>

#include <synapse_block.h>

Public Types

typedef lola::vx::CHIP_REVISION_STR::SynapseBlock container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> const &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::CHIP_REVISION_STR::SynapseDriverBlock>

#include <synapse_driver.h>

Public Types

typedef lola::vx::CHIP_REVISION_STR::SynapseDriverBlock container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<lola::vx::CHIP_REVISION_STR::SynapseDriverBlock::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, lola::vx::CHIP_REVISION_STR::SynapseDriverBlock::coordinate_type const &coord, VisitorT &&visitor)

template<typename VisitorT>
static inline void call(hate::Empty<container_type> const &config, lola::vx::CHIP_REVISION_STR::SynapseDriverBlock::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::ColumnCorrelationRow>

#include <synapse.h>

Public Types

typedef lola::vx::ColumnCorrelationRow container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::ColumnCurrentRow>

#include <synapse.h>

Public Types

typedef lola::vx::ColumnCurrentRow container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::CorrelationResetRow>

#include <synapse.h>

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<lola::vx::CorrelationResetRow::coordinate_type> coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, lola::vx::CorrelationResetRow::coordinate_type const &coord, VisitorT &&visitor)

template<typename VisitorT>
static inline void call(hate::Empty<lola::vx::CorrelationResetRow> config, lola::vx::CorrelationResetRow::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::DACChannelBlock>

#include <dac.h>

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<lola::vx::DACChannelBlock::coordinate_type> coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, lola::vx::DACChannelBlock::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> const &config, lola::vx::DACChannelBlock::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::DACControlBlock>

#include <dac.h>

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<lola::vx::DACControlBlock::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, lola::vx::DACControlBlock::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> const &config, lola::vx::DACControlBlock::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::SynapseCorrelationCalibMatrix>

#include <synapse.h>

Public Types

typedef lola::vx::SynapseCorrelationCalibMatrix container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::SynapseCorrelationCalibRow>

#include <synapse.h>

Public Types

typedef lola::vx::SynapseCorrelationCalibRow container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::SynapseLabelMatrix>

#include <synapse.h>

Public Types

typedef lola::vx::SynapseLabelMatrix container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::SynapseLabelRow>

#include <synapse.h>

Public Types

typedef lola::vx::SynapseLabelRow container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::SynapseMatrix>

#include <synapse.h>

Public Types

typedef lola::vx::SynapseMatrix container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> const &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::SynapseRow>

#include <synapse.h>

Public Types

typedef lola::vx::SynapseRow container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<lola::vx::SynapseRow::coordinate_type> coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename VisitorT>
static inline void call(hate::Empty<lola::vx::SynapseRow> config, lola::vx::SynapseRow::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::SynapseWeightMatrix>

#include <synapse.h>

Public Types

typedef lola::vx::SynapseWeightMatrix container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<lola::vx::SynapseWeightRow>

#include <synapse.h>

Public Types

typedef lola::vx::SynapseWeightRow container_type

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, hate::Empty<typename container_type::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> config, typename container_type::coordinate_type const &coord, VisitorT &&visitor)

namespace cereal

Functions

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, lola::vx::ExternalPPUMemoryBlock &value, std::uint32_t const version)

namespace GENPYBIND_TAG_LOLA_VX_VY

Functions

std::ostream & operator<< (std::ostream &os, ReadoutChain::BufferToPad const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, ReadoutChain::InputMux const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, ReadoutChain::PadMux const &config) SYMBOL_VISIBLE

Variables

GENPYBIND_TAG_LOLA_VX_VY::CADCReadoutChain CADCReadoutChain

namespace haldls

namespace vx

namespace detail

namespace lola

namespace vx

namespace lola::vx::detail

Functions

std::string gray_scale (double value) SYMBOL_VISIBLE

Map bars of monotonously increasing height to visualize scalar positive values between zero and one.

The dot maps to zero.

Parameters

value – Value to visualize.

namespace lola::vx::v3

Typedefs

using ColumnCorrelationRow = lola::vx::ColumnCorrelationRow

using ColumnCurrentRow = lola::vx::ColumnCurrentRow

using CorrelationResetRow = lola::vx::CorrelationResetRow

using Crossbar = lola::vx::Crossbar

using DACChannelBlock = lola::vx::DACChannelBlock

using DACControlBlock = lola::vx::DACControlBlock

using ExternalPPUMemory = lola::vx::ExternalPPUMemory

using ExternalPPUMemoryBlock = lola::vx::ExternalPPUMemoryBlock

using MemoryTiming = lola::vx::MemoryTiming

using PPUElfFile = lola::vx::PPUElfFile

using PPUProgram = lola::vx::PPUProgram

using SynapseCorrelationCalibMatrix = lola::vx::SynapseCorrelationCalibMatrix

using SynapseCorrelationCalibRow = lola::vx::SynapseCorrelationCalibRow

using SynapseLabelMatrix = lola::vx::SynapseLabelMatrix

using SynapseLabelRow = lola::vx::SynapseLabelRow

using SynapseMatrix = lola::vx::SynapseMatrix

using SynapseRow = lola::vx::SynapseRow

using SynapseWeightMatrix = lola::vx::SynapseWeightMatrix

using SynapseWeightRow = lola::vx::SynapseWeightRow

Functions

attr attr ("__str__")

attr ("PadMux")

lola::vx::v3::AtomicNeuron haldls::vx::ContainerBase set_from (haldls::vx::v3::NeuronConfig const &neuron_config) SYMBOL_VISIBLE

Variables

auto ism = parent->py::is_method(attr)

auto const to_str = [](ReadoutChain::PadMux const& self) { std::stringstream ss; ss << self; return ss.str(); }

namespace lola::vx::v3::detail

Typedefs

hate::type_list<# 33 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/lola/vx/v3/pylola.h" 2 > pickle_types

Functions

py::list get_containers_list(py::module &m)

Variables

static std::vector<std::string> const pickle_type_names = {}

namespace std

STL namespace.

file capmem.h

#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/capmem.h”#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/synapse.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/capmem.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include “lola/vx/capmem.tcc”

Defines

CONCAT(w, x, y, z)

ID(x)

STR(x)

XSTR(x)

file capmem.h

#include “lola/vx/capmem.h”

Defines

CHIP_REVISION

file genpybind.h

#include <genpybind.h>

Defines

GENPYBIND_TAG_LOLA_VX

GENPYBIND_TAG_LOLA_VX_V3

file gray_scale.h

#include <string>#include “hate/visibility.h”

file hana.h

#include <boost/hana.hpp>

Functions

template<typename T>
std::enable_if_t<boost::hana::Struct<T>::value, bool> equal(T const &a, T const &b)

template<typename T>
std::enable_if_t<boost::hana::Struct<T>::value, bool> unequal(T const &a, T const &b)

file memory_timing.h

#include “halco/hicann-dls/vx/memory_timing.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include “haldls/vx/cadc.h”#include “haldls/vx/container.h”#include “haldls/vx/neuron.h”#include “haldls/vx/synapse.h”#include “haldls/vx/synapse_driver.h”#include “lola/vx/memory_timing.tcc”

file memory_timing.h

#include “lola/vx/genpybind.h”#include “lola/vx/memory_timing.h”

file morphology.h

#include “haldls/vx/container.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include <map>#include <set>#include <utility>#include <vector>#include “lolaID(/)vxID(/)vID(CHIP_REVISION)/neuron.h”#include “lola/vx/morphology.tcc”

Defines

CONCAT(w, x, y, z)

ID(x)

STR(x)

XSTR(x)

file morphology.h

#include “lola/vx/morphology.h”

Defines

CHIP_REVISION

file cadc.h

#include “halco/common/iter_all.h”#include “halco/common/typed_array.h”#include “halco/common/typed_heap_array.h”#include “haldls/vx/cadc.h”#include “haldls/vx/common.h”#include “haldls/vx/container.h”#include “haldls/vx/synapse.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include “lola/vx/synapse.h”#include <boost/hana/adapt_struct.hpp>#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/capmem.h”#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/correlation.h”

Defines

CONCAT(w, x, y, z)

ID(x)

STR(x)

XSTR(x)

Functions

BOOST_HANA_ADAPT_STRUCT(lola::vx::CHIP_REVISION_STR::CADCReadoutChain, ramp, channels_causal, channels_acausal, correlation)

BOOST_HANA_ADAPT_STRUCT(lola::vx::CHIP_REVISION_STR::CADCReadoutChain::Channel, offset, enable_connect_correlation, enable_connect_debug, enable_connect_neuron)

BOOST_HANA_ADAPT_STRUCT(lola::vx::CHIP_REVISION_STR::CADCReadoutChain::Correlation, sense_delay, reset_duration, reset_fall_time, reset_mode, i_bias_ramp, i_bias_store, i_bias_corout)

BOOST_HANA_ADAPT_STRUCT(lola::vx::CHIP_REVISION_STR::CADCReadoutChain::Ramp, enable, reset_wait, dead_time, v_offset_assignment, v_offset, i_slope, i_bias_comparator, i_bias_vreset_buffer, v_bias_buffer)

BOOST_HANA_ADAPT_STRUCT(lola::vx::CHIP_REVISION_STR::CADCSampleRow, causal, acausal)

BOOST_HANA_ADAPT_STRUCT(lola::vx::CHIP_REVISION_STR::CADCSamples, causal, acausal)

file cadc.h

#include “lola/vx/cadc.h”

Defines

CHIP_REVISION

file chip.h

#include “halco/hicann-dls/vx/v3/chip.h”#include “haldls/vx/container.h”#include “haldls/vx/v3/background.h”#include “haldls/vx/v3/ppu.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include “lola/vx/v3/cadc.h”#include “lola/vx/v3/capmem.h”#include “lola/vx/v3/memory_timing.h”#include “lola/vx/v3/neuron.h”#include “lola/vx/v3/ppu.h”#include “lola/vx/v3/readout_chain.h”#include “lola/vx/v3/routing_crossbar.h”#include “lola/vx/v3/synapse_block.h”#include “lola/vx/v3/synapse_driver.h”#include <boost/hana/adapt_struct.hpp>#include “lola/vx/v3/chip.tcc”

file container.h

#include “lola/vx/v3/cadc.h”#include “lola/vx/v3/capmem.h”#include “lola/vx/v3/chip.h”#include “lola/vx/v3/dac.h”#include “lola/vx/v3/memory_timing.h”#include “lola/vx/v3/morphology.h”#include “lola/vx/v3/neuron.h”#include “lola/vx/v3/ppu.h”#include “lola/vx/v3/readout_chain.h”#include “lola/vx/v3/routing_crossbar.h”#include “lola/vx/v3/synapse.h”#include “lola/vx/v3/synapse_block.h”#include “lola/vx/v3/synapse_driver.h”

file dac.h

#include “halco/common/iter_all.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/dac.h”#include “haldls/vx/common.h”#include “haldls/vx/container.h”#include “haldls/vx/spi.h”#include “haldls/vx/traits.h”#include “hate/empty.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include <boost/hana/adapt_struct.hpp>

Functions

BOOST_HANA_ADAPT_STRUCT(lola::vx::DACChannelBlock, value)

BOOST_HANA_ADAPT_STRUCT(lola::vx::DACControlBlock, enable)

file dac.h

#include “lola/vx/dac.h”#include “lola/vx/genpybind.h”

file lola.h

#include “lola/vx/v3/container.h”

file neuron.h

#include “haldls/vx/container.h”#include “haldls/vx/v3/capmem.h”#include “haldls/vx/v3/neuron.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include “lola/vx/v3/synapse.h”#include “lola/vx/v3/neuron.tcc”

Typedefs

typedef haldls::vx::v3::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::v3::CapMemCell::Value AnalogValue

typedef haldls::vx::v3::CapMemCell::value_type AnalogValueVariant

typedef halco::hicann_dls::vx::v3::AtomicNeuronOnDLS coordinate_type

typedef std::false_type has_local_data

Functions

AtomicNeuron () SYMBOL_VISIBLE

bool operator!= (AtomicNeuron const &other) const SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, AtomicNeuron const &config) SYMBOL_VISIBLE

bool operator== (AtomicNeuron const &other) const SYMBOL_VISIBLE

void set_from (haldls::vx::v3::NeuronBackendConfig const &neuron_backend_config) SYMBOL_VISIBLE

Variables

Adaptation adaptation

Bayesian bayesian

ConstantCurrent constant_current

EventRouting event_routing

SynapticInput excitatory_input

Exponential exponential

SynapticInput inhibitory_input

Leak leak

MembraneCapacitance membrane_capacitance

Multicompartment multicompartment

NeuronBlock NeuronBlock

Readout readout

RefractoryPeriod refractory_period

Reset reset

Threshold threshold

file ppu.h

#include “halco/common/typed_heap_array.h”#include “halco/hicann-dls/vx/coordinates.h”#include “haldls/vx/container.h”#include “haldls/vx/fpga.h”#include “haldls/vx/ppu.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include <map>#include <optional>#include <variant>#include <boost/hana/adapt_struct.hpp>#include <cereal/macros.hpp>#include “lola/vx/ppu.tcc”

file ppu.h

#include “lola/vx/genpybind.h”#include “lola/vx/ppu.h”

file pylola.h

#include <vector>#include <pybind11/pybind11.h>#include “lola/vx/genpybind.h”#include “cereal/types/haldls/cereal.tcc”#include “cereal/types/lola/vx/v3/lola.h”#include “haldls/vx/pickle.h”#include “lola/vx/v3/lola.h”#include <cereal/macros.hpp>#include “lola/vx/v3/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)

LAST_PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

Functions

parent attr ("containers")

file readout_chain.h

#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/capmem.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/readout.h”#include “halco/hicann-dls/vx/current_dac.h”#include “haldls/vx/madc.h”#include “haldls/vx/current_dac.h”#include “haldls/vx/readout.h”#include “haldls/vx/container.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include “lola/vx/readout_chain.tcc”

Defines

CONCAT(w, x, y, z)

ID(x)

STR(x)

XSTR(x)

file readout_chain.h

#include “lola/vx/readout_chain.h”

Defines

CHIP_REVISION

Functions

attr attr ("__str__")

Variables

auto ism = parent->py::is_method(attr)

auto const to_str = [](ReadoutChain::InputMux const& self) { std::stringstream ss; ss << self; return ss.str(); }

file routing_crossbar.h

#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/routing_crossbar.h”#include “haldls/vx/common.h”#include “haldls/vx/container.h”#include “haldls/vx/routing_crossbar.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”#include “lola/vx/genpybind.h”#include “lola/vx/routing_crossbar.tcc”

file routing_crossbar.h

#include “lola/vx/genpybind.h”#include “lola/vx/routing_crossbar.h”

file synapse.h

#include “halco/common/iter_all.h”#include “halco/common/typed_array.h”#include “halco/common/typed_heap_array.h”#include “haldls/vx/common.h”#include “haldls/vx/container.h”#include “haldls/vx/synapse.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include <boost/hana/adapt_struct.hpp>

Functions

BOOST_HANA_ADAPT_STRUCT(lola::vx::ColumnCorrelationRow, values)

BOOST_HANA_ADAPT_STRUCT(lola::vx::ColumnCurrentRow, values)

BOOST_HANA_ADAPT_STRUCT(lola::vx::CorrelationResetRow)

BOOST_HANA_ADAPT_STRUCT(lola::vx::SynapseCorrelationCalibMatrix, time_calibs, amp_calibs)

BOOST_HANA_ADAPT_STRUCT(lola::vx::SynapseCorrelationCalibRow, time_calibs, amp_calibs)

BOOST_HANA_ADAPT_STRUCT(lola::vx::SynapseLabelMatrix, values)

BOOST_HANA_ADAPT_STRUCT(lola::vx::SynapseLabelRow, values)

BOOST_HANA_ADAPT_STRUCT(lola::vx::SynapseMatrix, weights, labels, time_calibs, amp_calibs)

BOOST_HANA_ADAPT_STRUCT(lola::vx::SynapseRow, weights, labels, time_calibs, amp_calibs)

BOOST_HANA_ADAPT_STRUCT(lola::vx::SynapseWeightMatrix, values)

BOOST_HANA_ADAPT_STRUCT(lola::vx::SynapseWeightRow, values)

file synapse.h

#include “lola/vx/genpybind.h”#include “lola/vx/synapse.h”

file synapse_block.h

#include “halco/common/iter_all.h”#include “halco/common/typed_array.h”#include “halco/common/typed_heap_array.h”#include “haldls/vx/common.h”#include “haldls/vx/container.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include <boost/hana/adapt_struct.hpp>#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/capmem.h”#include “lolaID(/)vxID(/)vID(CHIP_REVISION)/synapse.h”

Defines

CONCAT(w, x, y, z)

ID(x)

STR(x)

XSTR(x)

Functions

BOOST_HANA_ADAPT_STRUCT(lola::vx::CHIP_REVISION_STR::SynapseBlock, matrix, i_bias_dac)

file synapse_block.h

#include “lola/vx/synapse_block.h”

Defines

CHIP_REVISION

file synapse_driver.h

#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/capmem.h”#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/padi.h”#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/synapse_driver.h”#include “halco/common/iter_all.h”#include “halco/common/typed_array.h”#include “haldls/vx/common.h”#include “haldls/vx/traits.h”#include “haldls/vx/container.h”#include “hate/visibility.h”#include “lola/vx/genpybind.h”#include <boost/hana/adapt_struct.hpp>

Defines

CONCAT(w, x, y, z)

ID(x)

STR(x)

XSTR(x)

Functions

BOOST_HANA_ADAPT_STRUCT(lola::vx::CHIP_REVISION_STR::SynapseDriverBlock, synapse_drivers, padi_bus, stp, stp_v_charge_0, stp_v_charge_1, stp_v_recover_0, stp_v_recover_1, stp_i_bias_comparator, stp_i_ramp, stp_i_calib, stp_i_bias_readout, hagen_i_bias_dac)

file synapse_driver.h

#include “lola/vx/synapse_driver.h”

Defines

CHIP_REVISION

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/lola

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/lola/vx/v3

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/lola/vx