API Reference: lola

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

bool operator!=(CADCReadoutChain const &other) const

bool operator==(CADCReadoutChain const &other) const

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 struct haldls::vx::detail::VisitPreorderImpl< CADCReadoutChain >

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

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

bool operator==(Channel const &other) const

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)

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

bool operator==(Correlation const &other) const

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)

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

bool operator==(Ramp const &other) const

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)

class GENPYBIND_TAG_LOLA_VX_VY::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()

Default constructor.

bool operator!=(CADCSampleRow const &other) const

bool operator==(CADCSampleRow const &other) const

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)

class GENPYBIND_TAG_LOLA_VX_VY::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()

Default constructor.

bool operator!=(CADCSamples const &other) const

bool operator==(CADCSamples const &other) const

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)

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

bool operator==(CapMem const &other) const

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)

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()

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

Returns neuron within specified compartment at given index.

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

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

Convert MCSafeAtomicNeuron to AtomicNeuron inside the morphology.

MCSafeAtomicNeuron const &get_neuron(std::pair<CompartmentOnLogicalNeuron, size_t> const &index) const

Get neuron within specified compartment at given index.

Parameters

coord – Compartment coordinate.

Returns

Config of neurons in compartment.

bool operator!=(LogicalNeuron const &other) const

bool operator==(LogicalNeuron const &other) const

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

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)

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

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

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)

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()

Constructors.

explicit MCSafeAtomicNeuron(AtomicNeuron atomic_neuron)

explicit MCSafeAtomicNeuron(AtomicNeuron::Multicompartment an_multicompartment)

MCSafeAtomicNeuron(MCSafeAtomicNeuron &&other)

Move constructor.

MCSafeAtomicNeuron(MCSafeAtomicNeuron const &mc_safe_atomic_neuron)

Copy constructor.

~MCSafeAtomicNeuron() = default

Destructor.

explicit operator AtomicNeuron() const

bool operator!=(MCSafeAtomicNeuron const &other) const

MCSafeAtomicNeuron &operator=(MCSafeAtomicNeuron &&other)

Move assignment operator.

MCSafeAtomicNeuron &operator=(MCSafeAtomicNeuron const &other)

Copy assignment operator.

bool operator==(MCSafeAtomicNeuron const &other) const

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)

struct GENPYBIND_TAG_LOLA_VX_VY::MCSafeAtomicNeuron::Multicompartment

#include <morphology.h>

Public Functions

Multicompartment()

explicit Multicompartment(AtomicNeuron::Multicompartment an_multicomp)

Multicompartment(Multicompartment &&other)

Move constructor.

Multicompartment(Multicompartment const &multicompartment)

Copy constructor.

~Multicompartment() = default

Destructor.

bool operator!=(Multicompartment const &other) const

Multicompartment &operator=(Multicompartment &&other)

Move assignment operator.

Multicompartment &operator=(Multicompartment const &other)

bool operator==(Multicompartment const &other) const

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

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)

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)

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

void connect_to_soma(AtomicNeuronOnLogicalNeuron const &coord)

CompartmentOnLogicalNeuron create_compartment(Compartment const &compartment)

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

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)

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

bool operator==(ReadoutChain const &other) const

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)

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()

bool operator!=(BufferToPadT const &other) const

bool operator==(BufferToPadT const &other) const

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)

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()

bool operator!=(CurrentDAC const &other) const

bool operator==(CurrentDAC const &other) const

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)

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

bool operator==(DynamicMux const &other) const

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)

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

bool operator==(MADC const &other) const

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)

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()

bool operator!=(MADCDebugCrossbar const &other) const

bool operator==(MADCDebugCrossbar const &other) const

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)

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()

bool operator!=(MADCInputCrossbar const &other) const

bool operator==(MADCInputCrossbar const &other) const

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)

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

bool operator==(MADCPreamp const &other) const

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)

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

bool operator==(PseudoDifferentialConverter const &other) const

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)

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

bool operator==(SourceMeasureUnit const &other) const

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)

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

bool operator==(SynapseBlock const &other) const

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)

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

bool operator==(SynapseDriverBlock const &other) const

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)

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>

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)

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()

bool operator!=(ColumnCorrelationRow const &other) const

bool operator==(ColumnCorrelationRow const &other) const

Public Members

Values values

Friends

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

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

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()

bool operator!=(ColumnCurrentRow const &other) const

bool operator==(ColumnCurrentRow const &other) const

Public Members

Values values

Friends

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

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

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()

Default constructor.

bool operator!=(CorrelationResetRow const &other) const

bool operator==(CorrelationResetRow const &other) const

Friends

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

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

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()

Default constructor.

bool operator!=(Crossbar const &other) const

bool operator==(Crossbar const &other) const

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)

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()

Default constructor.

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

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

bool operator==(DACChannelBlock const &other) const

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

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 DACChannelBlock default_ldo_1

Default value for LDO version 1.

static const 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)

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()

Default constructor.

bool operator!=(DACControlBlock const &other) const

bool operator==(DACControlBlock const &other) const

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)

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

#include <ppu.h>

Contiguous block of bytes in the external DRAM PPU memory.

Public Types

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

typedef halco::hicann_dls::vx::ExternalPPUDRAMMemoryBlockOnFPGA coordinate_type

typedef std::false_type has_local_data

typedef halco::hicann_dls::vx::ExternalPPUDRAMMemoryBlockSize size_type

Public Functions

explicit ExternalPPUDRAMMemoryBlock(size_type size = size_type())

haldls::vx::ExternalPPUDRAMMemoryByte &at(size_t index)

haldls::vx::ExternalPPUDRAMMemoryByte const &at(size_t index) const

bytes_type const &get_bytes() const

ExternalPPUDRAMMemoryBlock get_subblock(size_t begin, size_type length) const

bool operator!=(ExternalPPUDRAMMemoryBlock const &other) const

bool operator==(ExternalPPUDRAMMemoryBlock const &other) const

haldls::vx::ExternalPPUDRAMMemoryByte &operator[](size_t index)

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

void set_bytes(bytes_type const &bytes)

void set_subblock(size_t begin, ExternalPPUDRAMMemoryBlock const &subblock)

size_type size() const

std::string to_string() const

Private Functions

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

Private Members

bytes_type m_bytes

Friends

friend class cereal::access

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

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()

ExternalPPUMemoryBlock get_subblock(size_t begin, size_type length) const

bool operator!=(ExternalPPUMemory const &other) const

bool operator==(ExternalPPUMemory const &other) const

void set_subblock(size_t begin, ExternalPPUMemoryBlock const &subblock)

std::string to_string() const

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)

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))

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

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

bytes_type const &get_bytes() const

ExternalPPUMemoryBlock get_subblock(size_t begin, size_type length) const

bool operator!=(ExternalPPUMemoryBlock const &other) const

bool operator==(ExternalPPUMemoryBlock const &other) const

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

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

void set_bytes(bytes_type const &bytes)

void set_subblock(size_t begin, ExternalPPUMemoryBlock const &subblock)

size_type size() const

std::string to_string() const

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)

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

bool operator==(MemoryTiming const &other) const

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)

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)

Open file.

Parameters

filename – File to open

~PPUElfFile()

Close file.

Memory read_program()

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()

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.

static constexpr uint32_t external_dram_base_address   = 0x9000'0000

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

static constexpr uint32_t external_dram_data_base_address   = 0x5000'0000

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

struct lola::vx::PPUElfFile::Memory

#include <ppu.h>

Public Members

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

std::optional<lola::vx::ExternalPPUDRAMMemoryBlock> external_dram

haldls::vx::PPUMemoryBlock internal

class PPUProgram

#include <ppu.h>

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, halco::hicann_dls::vx::ExternalPPUDRAMMemoryBlockOnFPGA> Coordinate

enum class Type

Symbol type.

Values:

enumerator object

enumerator function

enumerator other

Public Functions

Symbol()

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

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

Construct a symbol from a type and a coordinate.

bool operator!=(Symbol const &other) const

bool operator==(Symbol const &other) const

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)

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()

Default constructor.

bool operator!=(SynapseCorrelationCalibMatrix const &other) const

bool operator==(SynapseCorrelationCalibMatrix const &other) const

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)

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()

Default constructor.

bool operator!=(SynapseCorrelationCalibRow const &other) const

bool operator==(SynapseCorrelationCalibRow const &other) const

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)

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()

Default constructor.

bool operator!=(SynapseLabelMatrix const &other) const

bool operator==(SynapseLabelMatrix const &other) const

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)

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()

Default constructor.

bool operator!=(SynapseLabelRow const &other) const

bool operator==(SynapseLabelRow const &other) const

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)

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()

Default constructor.

bool operator!=(SynapseMatrix const &other) const

bool operator==(SynapseMatrix const &other) const

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)

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()

Default constructor.

bool operator!=(SynapseRow const &other) const

bool operator==(SynapseRow const &other) const

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)

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()

Default constructor.

bool operator!=(SynapseWeightMatrix const &other) const

bool operator==(SynapseWeightMatrix const &other) const

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)

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()

Default constructor.

bool operator!=(SynapseWeightRow const &other) const

bool operator==(SynapseWeightRow const &other) const

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)

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()

explicit operator haldls::vx::v3::NeuronBackendConfig() const

Allow converting to/from a haldls neuron backend config.

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

Allow converting to/from a haldls neuron config.

bool operator!=(AtomicNeuron const &other) const

bool operator==(AtomicNeuron const &other) const

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

void set_from(haldls::vx::v3::NeuronConfig const &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

Threshold threshold

Friends

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

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

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

#include <neuron.h>

Public Functions

Adaptation()

bool operator!=(Adaptation const &other) const

bool operator==(Adaptation const &other) const

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)

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

#include <neuron.h>

Public Types

enum class 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()

bool operator!=(Bayesian const &other) const

bool operator==(Bayesian const &other) const

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)

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

#include <neuron.h>

Public Types

enum class Type

Sink/source offset current on membrane.

Values:

enumerator source

enumerator sink

Public Functions

ConstantCurrent()

bool operator!=(ConstantCurrent const &other) const

bool operator==(ConstantCurrent const &other) const

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)

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

#include <neuron.h>

Public Types

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

enum class 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()

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

bool operator!=(EventRouting const &other) const

bool operator==(EventRouting const &other) const

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 bypass_exc

static const EventRouting bypass_inh

static const EventRouting disabled

static const EventRouting enabled

Friends

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

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

#include <neuron.h>

Public Functions

Exponential()

bool operator!=(Exponential const &other) const

bool operator==(Exponential const &other) const

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)

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

#include <neuron.h>

Public Functions

Leak()

bool operator!=(Leak const &other) const

bool operator==(Leak const &other) const

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)

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

#include <neuron.h>

Public Types

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

Public Functions

MembraneCapacitance()

bool operator!=(MembraneCapacitance const &other) const

bool operator==(MembraneCapacitance const &other) const

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)

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()

bool operator!=(Multicompartment const &other) const

bool operator==(Multicompartment const &other) const

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)

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

#include <neuron.h>

Public Types

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

Public Functions

Readout()

bool operator!=(Readout const &other) const

bool operator==(Readout const &other) const

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)

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()

bool operator!=(RefractoryPeriod const &other) const

bool operator==(RefractoryPeriod const &other) const

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)

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

#include <neuron.h>

Public Functions

Reset()

bool operator!=(Reset const &other) const

bool operator==(Reset const &other) const

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)

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

#include <neuron.h>

Public Functions

SynapticInput()

bool operator!=(SynapticInput const &other) const

bool operator==(SynapticInput const &other) const

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)

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

#include <neuron.h>

Public Functions

Threshold()

bool operator!=(Threshold const &other) const

bool operator==(Threshold const &other) const

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)

class lola::vx::v3::Chip : public haldls::vx::ContainerBase<Chip>, private haldls::vx::DifferentialWriteTrait

#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

bool operator==(Chip const &other) const

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 Chip default_neuron_bypass

Default instance for neuron bypass.

Friends

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

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

#include <neuron.h>

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

bool operator!=(NeuronBlock const &other) const

bool operator==(NeuronBlock const &other) const

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 struct haldls::vx::detail::VisitPreorderImpl< NeuronBlock >

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

class lola::vx::v4::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::v4::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::v4::CapMemCell::Value AnalogValue

typedef haldls::vx::v4::CapMemCell::value_type AnalogValueVariant

typedef halco::hicann_dls::vx::v4::AtomicNeuronOnDLS coordinate_type

typedef std::false_type has_local_data

Public Functions

AtomicNeuron()

explicit operator haldls::vx::v4::NeuronBackendConfig() const

Allow converting to/from a haldls neuron backend config.

explicit operator haldls::vx::v4::NeuronConfig() const

Allow converting to/from a haldls neuron config.

bool operator!=(AtomicNeuron const &other) const

bool operator==(AtomicNeuron const &other) const

void set_from(haldls::vx::v4::NeuronBackendConfig const &neuron_backend_config)

void set_from(haldls::vx::v4::NeuronConfig const &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

Threshold threshold

Friends

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

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

struct lola::vx::v4::AtomicNeuron::Adaptation

#include <neuron.h>

Public Functions

Adaptation()

bool operator!=(Adaptation const &other) const

bool operator==(Adaptation const &other) const

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)

struct lola::vx::v4::AtomicNeuron::Bayesian

#include <neuron.h>

Public Types

enum class 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()

bool operator!=(Bayesian const &other) const

bool operator==(Bayesian const &other) const

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::v4::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)

struct lola::vx::v4::AtomicNeuron::ConstantCurrent

#include <neuron.h>

Public Types

enum class Type

Sink/source offset current on membrane.

Values:

enumerator source

enumerator sink

Public Functions

ConstantCurrent()

bool operator!=(ConstantCurrent const &other) const

bool operator==(ConstantCurrent const &other) const

Public Members

bool enable

Enable application of offset current on membrane.

AnalogValueVariant i_offset

Offset current source/sink from the membrane.

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

Friends

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

struct lola::vx::v4::AtomicNeuron::EventRouting

#include <neuron.h>

Public Types

typedef haldls::vx::v4::NeuronBackendConfig::AddressOut Address

enum class 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()

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

bool operator!=(EventRouting const &other) const

bool operator==(EventRouting const &other) const

Public Members

Address address

Lower 8 bit of address sent on event output.

enum lola::vx::v4::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 bypass_exc

static const EventRouting bypass_inh

static const EventRouting disabled

static const EventRouting enabled

Friends

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

struct lola::vx::v4::AtomicNeuron::Exponential

#include <neuron.h>

Public Functions

Exponential()

bool operator!=(Exponential const &other) const

bool operator==(Exponential const &other) const

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)

struct lola::vx::v4::AtomicNeuron::Leak

#include <neuron.h>

Public Functions

Leak()

bool operator!=(Leak const &other) const

bool operator==(Leak const &other) const

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)

struct lola::vx::v4::AtomicNeuron::MembraneCapacitance

#include <neuron.h>

Public Types

typedef haldls::vx::v4::NeuronConfig::MembraneCapacitorSize CapacitorSize

Public Functions

MembraneCapacitance()

bool operator!=(MembraneCapacitance const &other) const

bool operator==(MembraneCapacitance const &other) const

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)

struct lola::vx::v4::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()

bool operator!=(Multicompartment const &other) const

bool operator==(Multicompartment const &other) const

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)

struct lola::vx::v4::AtomicNeuron::Readout

#include <neuron.h>

Public Types

typedef haldls::vx::v4::NeuronConfig::ReadoutSource Source

Public Functions

Readout()

bool operator!=(Readout const &other) const

bool operator==(Readout const &other) const

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)

struct lola::vx::v4::AtomicNeuron::RefractoryPeriod

#include <neuron.h>

Public Types

typedef haldls::vx::v4::NeuronBackendConfig::InputClock InputClock

typedef haldls::vx::v4::NeuronBackendConfig::RefractoryTime RefractoryTime

typedef haldls::vx::v4::NeuronBackendConfig::ResetHoldoff ResetHoldoff

Public Functions

RefractoryPeriod()

bool operator!=(RefractoryPeriod const &other) const

bool operator==(RefractoryPeriod const &other) const

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)

struct lola::vx::v4::AtomicNeuron::Reset

#include <neuron.h>

Public Functions

Reset()

bool operator!=(Reset const &other) const

bool operator==(Reset const &other) const

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)

struct lola::vx::v4::AtomicNeuron::SynapticInput

#include <neuron.h>

Public Functions

SynapticInput()

bool operator!=(SynapticInput const &other) const

bool operator==(SynapticInput const &other) const

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)

struct lola::vx::v4::AtomicNeuron::Threshold

#include <neuron.h>

Public Functions

Threshold()

bool operator!=(Threshold const &other) const

bool operator==(Threshold const &other) const

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)

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

#include <chip.h>

Complete static configuration of one chip.

Public Types

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

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

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

typedef std::false_type has_local_data

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

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

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

Public Functions

Chip() = default

bool operator!=(Chip const &other) const

bool operator==(Chip const &other) const

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 Chip default_neuron_bypass

Default instance for neuron bypass.

Friends

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

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

#include <neuron.h>

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

Public Types

typedef haldls::vx::v4::CapMemCell::DisableRefresh AnalogDisableRefresh

typedef haldls::vx::v4::CapMemCell::Value AnalogValue

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

typedef haldls::vx::v4::CapMemCell::value_type AnalogValueVariant

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

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

typedef halco::hicann_dls::vx::v4::NeuronBlockOnDLS coordinate_type

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

typedef std::false_type has_local_data

Public Functions

NeuronBlock() = default

bool operator!=(NeuronBlock const &other) const

bool operator==(NeuronBlock const &other) const

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 struct haldls::vx::detail::VisitPreorderImpl< NeuronBlock >

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

namespace cereal

Functions

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

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

namespace haldls

namespace vx

namespace detail

namespace lola

namespace vx

namespace lola::vx::detail

Functions

std::string gray_scale(double value)

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 ExternalPPUDRAMMemoryBlock = lola::vx::ExternalPPUDRAMMemoryBlock

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

std::ostream &operator<<(std::ostream&, AtomicNeuron::Bayesian::Operation const&)

std::ostream &operator<<(std::ostream&, AtomicNeuron::ConstantCurrent::Type const&)

std::ostream &operator<<(std::ostream&, AtomicNeuron::EventRouting::AnalogOutputMode const&)

namespace lola::vx::v3::detail

Typedefs

hate::type_list<# 33 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI5NjI.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 lola::vx::v4

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 ExternalPPUDRAMMemoryBlock = lola::vx::ExternalPPUDRAMMemoryBlock

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

std::ostream &operator<<(std::ostream&, AtomicNeuron::Bayesian::Operation const&)

std::ostream &operator<<(std::ostream&, AtomicNeuron::ConstantCurrent::Type const&)

std::ostream &operator<<(std::ostream&, AtomicNeuron::EventRouting::AnalogOutputMode const&)

namespace lola::vx::v4::detail

Typedefs

hate::type_list<# 33 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI5NjI.x/haldls/include/lola/vx/v4/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 genpybind.h

#include <genpybind.h>

Defines

GENPYBIND_TAG_LOLA_VX

GENPYBIND_TAG_LOLA_VX_V3

GENPYBIND_TAG_LOLA_VX_V4

file gray_scale.h

#include <>

#include “”

file hana.h

#include “”

#include “”

#include <>

#include <>

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, std::ostream&> print(std::ostream &os, T const &value)

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

file cadc.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include “lola/vx/synapse.h”

#include <>

#include “”

#include “”

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 cadc.h

#include “lola/vx/cadc.h”

Defines

CHIP_REVISION

file capmem.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include “”

Defines

CONCAT(w, x, y, z)

ID(x)

STR(x)

XSTR(x)

file capmem.h

#include “lola/vx/capmem.h”

Defines

CHIP_REVISION

file capmem.h

#include “lola/vx/capmem.h”

Defines

CHIP_REVISION

file chip.h

#include “”

#include “”

#include “”

#include “”

#include “”

#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 <>

#include “”

file chip.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include “lola/vx/v4/cadc.h”

#include “lola/vx/v4/capmem.h”

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

#include “lola/vx/v4/neuron.h”

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

#include “lola/vx/v4/readout_chain.h”

#include “lola/vx/v4/routing_crossbar.h”

#include “lola/vx/v4/synapse_block.h”

#include “lola/vx/v4/synapse_driver.h”

#include <>

#include “”

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 container.h

#include “lola/vx/v4/cadc.h”

#include “lola/vx/v4/capmem.h”

#include “lola/vx/v4/chip.h”

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

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

#include “lola/vx/v4/morphology.h”

#include “lola/vx/v4/neuron.h”

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

#include “lola/vx/v4/readout_chain.h”

#include “lola/vx/v4/routing_crossbar.h”

#include “lola/vx/v4/synapse.h”

#include “lola/vx/v4/synapse_block.h”

#include “lola/vx/v4/synapse_driver.h”

file dac.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include <>

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 dac.h

#include “lola/vx/dac.h”

#include “lola/vx/genpybind.h”

file lola.h

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

file lola.h

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

file memory_timing.h

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

file memory_timing.h

#include “lola/vx/genpybind.h”

#include “lola/vx/memory_timing.h”

file memory_timing.h

#include “lola/vx/genpybind.h”

#include “lola/vx/memory_timing.h”

file morphology.h

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include <>

#include <>

#include <>

#include <>

#include “”

#include “”

Defines

CONCAT(w, x, y, z)

ID(x)

STR(x)

XSTR(x)

file morphology.h

#include “lola/vx/morphology.h”

Defines

CHIP_REVISION

file morphology.h

#include “lola/vx/morphology.h”

Defines

CHIP_REVISION

file neuron.h

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

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

#include “”

file neuron.h

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include “lola/vx/v4/synapse.h”

#include “”

file ppu.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include <>

#include <>

#include <>

#include <>

#include <>

#include “”

file ppu.h

#include “lola/vx/genpybind.h”

#include “lola/vx/ppu.h”

file ppu.h

#include “lola/vx/genpybind.h”

#include “lola/vx/ppu.h”

file pylola.h

#include <>

#include <>

#include “lola/vx/genpybind.h”

#include “”

#include “”

#include “”

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

#include <>

#include “”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)

LAST_PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

file pylola.h

#include “lola/vx/genpybind.h”

#include <>

#include <>

#include “”

#include “”

#include “”

#include “lola/vx/v4/lola.h”

#include <>

#include “”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)

LAST_PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

file readout_chain.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include “”

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

file readout_chain.h

#include “lola/vx/readout_chain.h”

Defines

CHIP_REVISION

file routing_crossbar.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include “”

file routing_crossbar.h

#include “lola/vx/genpybind.h”

#include “lola/vx/routing_crossbar.h”

file routing_crossbar.h

#include “lola/vx/genpybind.h”

#include “lola/vx/routing_crossbar.h”

file synapse.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include <>

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.h

#include “lola/vx/genpybind.h”

#include “lola/vx/synapse.h”

file synapse_block.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include <>

#include “”

#include “”

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_block.h

#include “lola/vx/synapse_block.h”

Defines

CHIP_REVISION

file synapse_driver.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “lola/vx/genpybind.h”

#include <>

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

file synapse_driver.h

#include “lola/vx/synapse_driver.h”

Defines

CHIP_REVISION

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI5NjI.x/haldls

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI5NjI.x/haldls/include

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI5NjI.x/haldls/include/lola

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI5NjI.x/haldls/include/lola/vx/v3

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI5NjI.x/haldls/include/lola/vx/v4

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI5NjI.x/haldls/include/lola/vx