API Reference: calix

template<typename TL>
struct AddPickle

Add pickle support to list of classes.

Template Parameters

TL – Type list of classes to add pickle support for

template<typename ...Ts>
struct ccalix::AddPickle<hate::type_list<Ts...>>

#include <pickle.h>

Public Static Functions

static inline void apply(pybind11::module &parent, std::vector<std::string> const &container_names)

Add pickle support to list of classes.

Note

Specified name list has to match type list of wrapped types.

Template Parameters

T – Type of wrapped object

Parameters

• parent – Pybind11 module

• name – Name of object in python module

Private Static Functions

template<size_t I, size_t... Is>
static inline void apply_impl(pybind11::module &parent, std::vector<std::string> const &container_names, std::index_sequence<I, Is...>)

template<typename T>
static inline void apply_single(pybind11::module &parent, std::string const &name)

Add pickle support to single class.

Note

Specified name has to match object of correct wrapped type.

Template Parameters

T – Type of wrapped object

Parameters

• parent – Pybind11 module

• name – Name of object in python module

struct ccalix::CADCCalibOptions : public ccalix::CalibOptions

#include <cadc_calib_options.h>

Further configuration parameters for the CADC calibration, that are not directly calibration targets.

Public Functions

CADCCalibOptions() = default

Public Members

bool calibrate_offsets = {true}

Private Functions

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

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CADCCalibOptions const &options) SYMBOL_VISIBLE

struct ccalix::CadcCalibParam : public ccalix::CalibratedParameter

#include <cadc_calib_param.h>

Public Functions

CadcCalibParam() = default

CadcCalibParam(trafo::Linear const &transformation)

virtual std::unique_ptr<CalibratedParameter> copy() const override

virtual std::unique_ptr<CalibratedParameter> move() override

virtual std::ostream &print(std::ostream &os) const override

Public Members

trafo::Linear translation

Protected Functions

virtual bool is_equal_to(CalibratedParameter const &other) const override

Private Functions

template<typename Archiver>
inline void serialize(Archiver &ar)

Friends

friend class cereal::access

struct ccalix::CADCCalibTarget : public ccalix::CalibTarget

#include <cadc_calib_target.h>

Target parameters for the CADC calibration.

Public Types

typedef Range<haldls::vx::v3::CapMemCell::Value> DynamicRange

typedef Range<haldls::vx::v3::CADCSampleQuad::Value> ReadRange

Public Functions

CADCCalibTarget () SYMBOL_VISIBLE

Public Members

DynamicRange dynamic_range

CapMem settings (LSB) at the minimum and maximum of the desired dynamic range.

By default, the full dynamic range of the CADC is used, which corresponds to some 0.15 to 1.05 V. The voltages are configured as stp_v_charge_0, which gets connected to the CADCs via the CapMem debug readout.

ReadRange read_range

Target CADC reads at the lower and upper end of the dynamic range.

Private Functions

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

Friends

friend class cereal::access

struct ccalix::CadcOnDLS : public ccalix::ModelEntityOnDLS

#include <cadc_on_dls.h>

Public Types

using ChannelType = halco::hicann_dls::vx::CADCChannelConfigOnDLS

Public Functions

CadcOnDLS() = default

CadcOnDLS(ChannelType const &channel)

virtual std::unique_ptr<ModelEntityOnDLS> copy() const override

virtual std::unique_ptr<ModelEntityOnDLS> move() override

virtual std::ostream &print(std::ostream &os) const override

Public Members

ChannelType channel

Protected Functions

virtual size_t hash() const override

virtual bool is_equal_to(ModelEntityOnDLS const &other) const override

Private Functions

template<typename Archiver>
inline void serialize(Archiver &ar)

Friends

friend class cereal::access

struct ccalix::CadcTranslation : public ccalix::ParameterTranslation

#include <cadc_translation.h>

Public Types

typedef dapr::UnorderedMap<ModelEntityOnDLS, CalibratedParameter> CalibratedParameters

Calibrated set of hardware parameters.

In general they can’t be combined to form a more complete calibration, since the interface for querying doesn’t expose dependencies.

typedef dapr::UnorderedMap<ModelEntityOnDLS, ModelParameter> ModelParameters

Public Functions

CadcTranslation() = default

CadcTranslation(CadcOnDLS cadc, trafo::Linear const &transformation)

virtual std::unique_ptr<ParameterTranslation> copy() const override

virtual std::unique_ptr<ParameterTranslation> move() override

virtual std::ostream &print(std::ostream &os) const override

virtual void translate(ModelParameters const &targets, CalibratedParameters &calibrated_parameters) const override

Public Members

CadcOnDLS cadc

trafo::Linear translation

Protected Functions

virtual bool is_equal_to(ParameterTranslation const &other) const override

Private Functions

template<typename Archiver>
inline void serialize(Archiver &ar)

Friends

friend class cereal::access

struct CalibOptions

#include <calib_options.h>

Subclassed by ccalix::CADCCalibOptions, ccalix::CorrelationCalibOptions, ccalix::HagenCalibOptions, ccalix::HagenSyninCalibOptions, ccalix::NeuronCalibOptions, ccalix::STPCalibOptions, ccalix::SpikingCalibOptions, ccalix::SynapseDriverCalibOptions

struct ccalix::CalibratedParameter : public dapr::Property<CalibratedParameter>

#include <calibrated_parameter.h>

Subclassed by ccalix::CadcCalibParam, ccalix::MadcCalibParam

Private Functions

template<typename Archiver>
inline void serialize(Archiver&)

Friends

friend class cereal::access

class ccalix::CalibTarget

#include <calib_target.h>

Subclassed by ccalix::CADCCalibTarget, ccalix::CorrelationCalibTarget, ccalix::HagenCalibTarget, ccalix::HagenNeuronCalibTarget, ccalix::HagenSyninCalibTarget, ccalix::NeuronCalibTarget, ccalix::STPCalibTarget, ccalix::SpikingCalibTarget

Private Functions

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

Friends

friend class cereal::access

struct ccalix::CapacitanceInFarad : public halco::common::detail::BaseType<CapacitanceInFarad, double>

#include <types.h>

Public Functions

inline explicit constexpr CapacitanceInFarad(value_type const value = 0.)

struct ccalix::CompleteParameterTranslation : public ccalix::ParameterTranslation

#include <complete_parameter_translation.h>

Public Types

typedef dapr::UnorderedMap<ModelEntityOnDLS, CalibratedParameter> CalibratedParameters

Calibrated set of hardware parameters.

In general they can’t be combined to form a more complete calibration, since the interface for querying doesn’t expose dependencies.

typedef dapr::UnorderedMap<ModelEntityOnDLS, ModelParameter> ModelParameters

Public Functions

CompleteParameterTranslation() = default

CompleteParameterTranslation(std::vector<CadcTranslation> const &cadc_translations, std::vector<MadcTranslation> const &madc_translations)

virtual std::unique_ptr<ParameterTranslation> copy() const override

virtual std::unique_ptr<ParameterTranslation> move() override

virtual std::ostream &print(std::ostream &os) const override

template<typename Archiver>
inline void serialize(Archiver &ar)

virtual void translate(ModelParameters const &targets, CalibratedParameters &parameters) const override

Public Members

std::vector<CadcTranslation> cadc

std::vector<MadcTranslation> madc

Protected Functions

virtual bool is_equal_to(ParameterTranslation const &other) const override

Friends

friend class cereal::access

struct ccalix::CorrelationCalibOptions : public ccalix::CalibOptions

#include <correlation_calib_options.h>

Public Types

enum class Branches

Values:

enumerator CAUSAL

enumerator ACAUSAL

enumerator BOTH

Public Functions

CorrelationCalibOptions() = default

void check () const SYMBOL_VISIBLE

Check if given parameters are in a valid range.

Public Members

Branches branches = {Branches::BOTH}

bool calibrate_synapses = {false}

haldls::vx::v3::SynapseCorrelationCalibQuad::AmpCalib default_amp_calib = {0}

haldls::vx::v3::SynapseCorrelationCalibQuad::TimeCalib default_time_calib = {0}

double time_constant_priority = {0.3}

PotentialInVolt v_res_meas = {PotentialInVolt(0.9)}

PotentialInVolt v_reset = {PotentialInVolt(1.85)}

Private Functions

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

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CorrelationCalibOptions const &options) SYMBOL_VISIBLE

struct ccalix::CorrelationCalibTarget : public ccalix::CalibTarget

#include <correlation_calib_target.h>

Target parameters for correlation calibration.

Public Functions

CorrelationCalibTarget () SYMBOL_VISIBLE

Public Members

double amplitude

Target correlation amplitude (at delay 0) for all synapses, per correlated event.

Feasible targets range from some 0.2 to 2.0, higher amplitudes will likely require adjusting v_res_meas.

TimeInS time_constant

Target correlation time constant for all synapses.

Feasible targets range from some 2 to 30 us.

Private Functions

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

Friends

friend class cereal::access

struct ccalix::HagenCalibOptions : public ccalix::CalibOptions

#include <hagen_calib_options.h>

Public Functions

HagenCalibOptions() = default

Public Members

CADCCalibOptions cadc_options

Further options for CADC calibration.

bool neuron_disable_leakage = {true}

Decide whether the neuron leak bias currents are set to zero after calibration.

This is done by default, which disables leakage entirely. Note that even if the leak bias is set to zero, some pseudo-leakage may occur through the synaptic input OTAs.

NeuronCalibOptions neuron_options

Further options for neuron calibration.

SynapseDriverCalibOptions synapse_driver_options

Further options for synapse driver calibration.

Private Functions

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

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, HagenCalibOptions const &options) SYMBOL_VISIBLE

struct ccalix::HagenCalibTarget : public ccalix::CalibTarget

#include <hagen_calib_target.h>

Public Functions

HagenCalibTarget () SYMBOL_VISIBLE

Public Members

CADCCalibTarget cadc_target

Target parameters for CADC calibration.

HagenNeuronCalibTarget neuron_target

Target parameters for neuron calibration.

Private Functions

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

Friends

friend class cereal::access

struct ccalix::HagenNeuronCalibTarget : public ccalix::CalibTarget

#include <hagen_neuron_calib_target.h>

Target parameters for the neuron calibration.

Public Types

typedef halco::common::typed_array<TimeInS, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> PerNeuronTimeConstant

typedef halco::common::typed_array<haldls::vx::v3::CADCSampleQuad::Value, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> Potential

typedef halco::common::typed_array<TauSynOnNeuron, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> TauSyn

typedef halco::common::typed_array<TimeInS, halco::hicann_dls::vx::v3::SynapticInputOnNeuron> TauSynOnNeuron

Public Functions

HagenNeuronCalibTarget()

Construct calib target parameters.

Public Members

haldls::vx::v3::CapMemCell::Value i_synin_gm

Target synaptic input OTA bias current.

The amplitudes of excitatory inputs using this target current are measured, and the median of all neurons’ amplitudes is taken as target for calibration of the synaptic input strengths. The inhibitory synaptic input gets calibrated to match the excitatory. Some 300 LSB are proposed here. Choosing high values yields higher noise and lower time constants on the neurons, choosing low values yields less gain in a multiplication.

Potential leak

Target CADC read at resting potential of the membrane.

Due to the low leak bias currents, the spread of resting potentials may be high even after calibration.

haldls::vx::v3::CapMemCell::Value synapse_dac_bias

Synapse DAC bias current that is desired.

Can be lowered in order to reduce the amplitude of a spike at the input of the synaptic input OTA. This can be useful to avoid saturation when using larger synaptic time constants.

std::optional<double> target_noise

Noise amplitude in an integration process to aim for when searching the optimum leak OTA bias current, given as the standard deviation of successive reads in CADC LSB.

Higher noise settings mean longer membrane time constants but impact reproducibility. Set target_noise to None to skip optimization of noise amplitudes entirely. In this case, the original membrane time constant calibration is used for leak bias currents.

PerNeuronTimeConstant tau_mem

Targeted membrane time constant while calibrating the synaptic inputs.

Too short values can not be achieved with this calibration routine. The default value of 60 us should work. If a target_noise is given (default), this setting does not affect the final leak bias currents, as those are determined by reaching the target noise.

TauSyn tau_syn

Controls the synaptic input time constant.

If set to 0 us, the minimum synaptic input time constant will be used, which means different synaptic input time constants per neuron.

Private Functions

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

Friends

friend class cereal::access

struct ccalix::HagenSyninCalibOptions : public ccalix::CalibOptions

#include <hagen_synin_calib_options.h>

Public Functions

HagenSyninCalibOptions() = default

Public Members

CADCCalibOptions cadc_options

Further options for CADC calibration.

SynapseDriverCalibOptions synapse_driver_options

Further options for synapse driver calibration.

Private Functions

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

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, HagenSyninCalibOptions const &options) SYMBOL_VISIBLE

struct ccalix::HagenSyninCalibTarget : public ccalix::CalibTarget

#include <hagen_synin_calib_target.h>

Public Functions

HagenSyninCalibTarget () SYMBOL_VISIBLE

Public Members

CADCCalibTarget cadc_target

haldls::vx::v3::CapMemCell::Value synapse_dac_bias

Private Functions

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

Friends

friend class cereal::access

struct ccalix::MadcCalibParam : public ccalix::CalibratedParameter

#include <madc_calib_param.h>

Public Functions

MadcCalibParam() = default

MadcCalibParam(trafo::Linear const &transformation)

virtual std::unique_ptr<CalibratedParameter> copy() const override

virtual std::unique_ptr<CalibratedParameter> move() override

virtual std::ostream &print(std::ostream &os) const override

Public Members

trafo::Linear translation

Protected Functions

virtual bool is_equal_to(CalibratedParameter const &other) const override

Private Functions

template<typename Archiver>
inline void serialize(Archiver &ar)

Friends

friend class cereal::access

struct ccalix::MadcOnDLS : public ccalix::ModelEntityOnDLS

#include <madc_on_dls.h>

Public Types

using ChannelType = halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection

Public Functions

MadcOnDLS() = default

MadcOnDLS(ChannelType const &channel)

virtual std::unique_ptr<ModelEntityOnDLS> copy() const override

virtual std::unique_ptr<ModelEntityOnDLS> move() override

virtual std::ostream &print(std::ostream &os) const override

Public Members

ChannelType channel

Protected Functions

virtual size_t hash() const override

virtual bool is_equal_to(ModelEntityOnDLS const &other) const override

Private Functions

template<typename Archiver>
inline void serialize(Archiver &ar)

Friends

friend class cereal::access

struct ccalix::MadcTranslation : public ccalix::ParameterTranslation

#include <madc_translation.h>

Public Types

typedef dapr::UnorderedMap<ModelEntityOnDLS, CalibratedParameter> CalibratedParameters

Calibrated set of hardware parameters.

In general they can’t be combined to form a more complete calibration, since the interface for querying doesn’t expose dependencies.

typedef dapr::UnorderedMap<ModelEntityOnDLS, ModelParameter> ModelParameters

Public Functions

MadcTranslation() = default

MadcTranslation(MadcOnDLS madc, trafo::Linear const &transformation)

virtual std::unique_ptr<ParameterTranslation> copy() const override

virtual std::unique_ptr<ParameterTranslation> move() override

virtual std::ostream &print(std::ostream &os) const override

virtual void translate(ModelParameters const &targets, CalibratedParameters &calibrated_parameters) const override

Public Members

MadcOnDLS madc

trafo::Linear translation

Protected Functions

virtual bool is_equal_to(ParameterTranslation const &other) const override

Private Functions

template<typename Archiver>
inline void serialize(Archiver &ar)

Friends

friend class cereal::access

struct ModelCadc : public dapr::EmptyProperty<ModelCadc, ModelParameter>

#include <model_cadc.h>

struct ccalix::ModelEntityOnDLS : public dapr::Property<ModelEntityOnDLS>, public dapr::Hashable

#include <model_entity_on_dls.h>

Subclassed by ccalix::CadcOnDLS, ccalix::MadcOnDLS

Private Functions

template<typename Archiver>
inline void serialize(Archiver&)

Friends

friend class cereal::access

struct ModelMadc : public dapr::EmptyProperty<ModelMadc, ModelParameter>

#include <model_madc.h>

struct ModelParameter : public dapr::Property<ModelParameter>

#include <model_parameter.h>

struct ccalix::NeuronCalibOptions : public ccalix::CalibOptions

#include <neuron_calib_options.h>

Public Functions

NeuronCalibOptions() = default

Public Members

std::optional<halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> readout_neuron = {std::nullopt}

Private Functions

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

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, NeuronCalibOptions const &options) SYMBOL_VISIBLE

struct ccalix::NeuronCalibTarget : public ccalix::CalibTarget

#include <neuron_calib_target.h>

Target parameters for the neuron calibration.

Public Types

typedef halco::common::typed_array<lola::vx::v3::AtomicNeuron::MembraneCapacitance::CapacitorSize, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> MembraneCapacitance

typedef halco::common::typed_array<TimeInS, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> PerNeuronTimeConstant

typedef halco::common::typed_array<haldls::vx::v3::CADCSampleQuad::Value, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> Potential

typedef halco::common::typed_array<TauSynPerNeuron, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> TauSyn

typedef halco::common::typed_array<TimeInS, halco::hicann_dls::vx::v3::SynapticInputOnNeuron> TauSynPerNeuron

Public Functions

NeuronCalibTarget()

Construct calib target parameters.

Public Members

CalibratedCobaSynapticInput coba_synin

std::variant<UncalibratedCubaSynapticInput, CalibratedCubaSynapticInput, CalibratedMatchingCubaSynapticInput> cuba_synin

PerNeuronTimeConstant holdoff_time

Target length of the holdoff period.

The holdoff period is the time at the end of the refractory period in which the clamping to the reset voltage is already released but new spikes can still not be generated.

Potential leak

Target CADC read at leak (resting) potential.

MembraneCapacitance membrane_capacitance

Selected membrane capacitance.

The available range is 0 to approximately 2.2 pF, represented as 0 to 63 LSB.

PerNeuronTimeConstant refractory_time

Refractory time in us.

Potential reset

Target CADC read at reset potential.

haldls::vx::v3::CapMemCell::Value synapse_dac_bias

Synapse DAC bias current that is desired.

Can be lowered in order to reduce the amplitude of a spike at the input of the synaptic input OTA. This can be useful to avoid saturation when using larger synaptic time constants.

std::optional<PerNeuronTimeConstant> tau_icc

Time constant of the inter-compartment conductance.

If the value is None, the inter-compartment conductance is not calibrated.

PerNeuronTimeConstant tau_mem

Membrane time constant.

TauSyn tau_syn

Synaptic input time constant.

Potential threshold

Target CADC read near spike threshold.

Private Functions

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

Friends

friend class cereal::access

struct ccalix::NeuronCalibTarget::CalibratedCobaSynapticInput

#include <neuron_calib_target.h>

Targets for the conductance-based synaptic input.

Values provided superseed the current-based targets.

Public Types

typedef halco::common::typed_array<PotentialOnNeuron, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> Potential

typedef halco::common::typed_array<std::optional<double>, halco::hicann_dls::vx::v3::SynapticInputOnNeuron> PotentialOnNeuron

Public Functions

CalibratedCobaSynapticInput () SYMBOL_VISIBLE

Public Members

Potential e_coba_reference

COBA synaptic input reference potential.

At this potential, the original CUBA synaptic input strength, given via i_synin_gm, is not modified by COBA modulation. Optional: If None, the midpoint between leak and threshold will be used. Given in CADC units. The values must be reachable by the leak term, and the dynamic range of the CADC must allow for measurement of synaptic input amplitudes on top of this potential. We recommend choosing a value between the leak and threshold.

Potential e_coba_reversal

COBA synaptic input reversal potential.

At this potential, the synaptic input strength will be zero. The distance between COBA reversal and reference potential determines the strength of the amplitude modulation. Note that in biological context, the difference between reference and reversal potentials is a scaling factor for the conductance achieved by an input event. Optional: If None, the synaptic input will use CUBA mode for the respective neuron. Given in CADC units. The values may exceed the dynamic range of leak and CADC. In this case, the calibration is performed at a lower, linearly interpolated value.

Private Functions

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

Friends

friend class cereal::access

struct ccalix::NeuronCalibTarget::CalibratedCubaSynapticInput

#include <neuron_calib_target.h>

Both excitatory and inhibitory synaptic inputs are calibrated to a target measured as the median of all neurons at this setting.

Public Types

typedef halco::common::typed_array<haldls::vx::v3::CapMemCell::Value, halco::hicann_dls::vx::v3::SynapticInputOnNeuron> ISyninGM

Public Functions

CalibratedCubaSynapticInput () SYMBOL_VISIBLE

Public Members

ISyninGM i_synin_gm

Synaptic input strength as CapMem bias current.

Private Functions

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

Friends

friend class cereal::access

struct ccalix::NeuronCalibTarget::CalibratedMatchingCubaSynapticInput

#include <neuron_calib_target.h>

Both excitatory and inhibitory synaptic inputs are calibrated to a target measured as the median of all neurons at this setting.

Public Functions

CalibratedMatchingCubaSynapticInput () SYMBOL_VISIBLE

Public Members

haldls::vx::v3::CapMemCell::Value i_synin_gm

Synaptic input strength as CapMem bias current.

Private Functions

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

Friends

friend class cereal::access

struct ccalix::NeuronCalibTarget::UncalibratedCubaSynapticInput

#include <neuron_calib_target.h>

The synaptic input strength is NOT calibrated, as this array would already be the result of calibration.

Instead, the values are set up per neuron and used during the later parts, i.e.synaptic input reference calibration.

Public Types

typedef halco::common::typed_array<ISyninGMOnNeuron, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> ISyninGM

typedef halco::common::typed_array<haldls::vx::v3::CapMemCell::Value, halco::hicann_dls::vx::v3::SynapticInputOnNeuron> ISyninGMOnNeuron

Public Functions

UncalibratedCubaSynapticInput () SYMBOL_VISIBLE

Public Members

ISyninGM i_synin_gm

Synaptic input strength as CapMem bias current.

Private Functions

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

Friends

friend class cereal::access

class ccalix::OutsideDomainException : public std::runtime_error

#include <outside_domain_exception.h>

Public Functions

inline OutsideDomainException(std::string const &msg = "Value outside of domain.")

template<class T>
struct ccalix::ParameterInterval

#include <parameter_interval.h>

Public Functions

ParameterInterval() = default

ParameterInterval(T lower_limit, T upper_limit)

bool contains(T const &parameter) const

T const &get_lower() const

T const &get_upper() const

bool operator!=(ParameterInterval const &other) const = default

bool operator==(ParameterInterval const &other) const = default

Private Members

T m_lower_limit = {}

T m_upper_limit = {}

struct ccalix::ParameterTranslation : public dapr::Property<ParameterTranslation>

#include <parameter_translation.h>

Subclassed by ccalix::CadcTranslation, ccalix::CompleteParameterTranslation, ccalix::MadcTranslation

Public Types

typedef dapr::UnorderedMap<ModelEntityOnDLS, CalibratedParameter> CalibratedParameters

Calibrated set of hardware parameters.

In general they can’t be combined to form a more complete calibration, since the interface for querying doesn’t expose dependencies.

typedef dapr::UnorderedMap<ModelEntityOnDLS, ModelParameter> ModelParameters

Public Functions

virtual void translate(ModelParameters const &targets, CalibratedParameters &calibrated_parameters) const = 0

Private Functions

template<typename Archiver>
inline void serialize(Archiver&)

Friends

friend class cereal::access

struct ccalix::PotentialInVolt : public halco::common::detail::BaseType<PotentialInVolt, double>

#include <types.h>

Public Functions

inline explicit constexpr PotentialInVolt(value_type const value = 0.)

template<typename T>
struct ccalix::Range

#include <range.h>

Public Types

typedef T Value

Public Functions

inline Range(T const &lower, T const &upper)

inline std::tuple<Value, Value> to_tuple() const

Public Members

Value lower

Value upper

Private Functions

inline T check_lower(T const &lower, T const &upper)

template<typename Archive>
inline void serialize(Archive &ar, std::uint32_t)

Friends

friend class cereal::access

inline friend std::ostream &operator<<(std::ostream &os, Range const &value)

struct ccalix::SpikingCalibOptions : public ccalix::CalibOptions

#include <spiking_calib_options.h>

Public Functions

SpikingCalibOptions(CADCCalibOptions cadc_options = CADCCalibOptions(), NeuronCalibOptions neuron_options = NeuronCalibOptions(), CorrelationCalibOptions correlation_options = CorrelationCalibOptions(), STPCalibOptions stp_options = STPCalibOptions(), std::optional<bool> refine_potentials = std::nullopt)

Public Members

CADCCalibOptions cadc_options

CorrelationCalibOptions correlation_options

NeuronCalibOptions neuron_options

std::optional<bool> refine_potentials = std::nullopt

STPCalibOptions stp_options

Private Functions

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

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SpikingCalibOptions const &options) SYMBOL_VISIBLE

struct ccalix::SpikingCalibTarget : public ccalix::CalibTarget

#include <spiking_calib_target.h>

Public Functions

SpikingCalibTarget() = default

Public Members

CADCCalibTarget cadc_target

Target parameters for CADC calibration.

std::optional<CorrelationCalibTarget> correlation_target = {std::nullopt}

Target parameters for correlation calibration.

NeuronCalibTarget neuron_target

Target parameters for neuron calibration.

STPCalibTarget stp_target

Target parameters for STP calibration.

Private Functions

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

Friends

friend class cereal::access

struct ccalix::STPCalibOptions : public ccalix::CalibOptions

#include <stp_calib_options.h>

Public Types

typedef halco::common::typed_array<haldls::vx::v3::CapMemCell::Value, halco::hicann_dls::vx::v3::CapMemBlockOnDLS> ValuePerQuadrant

Public Functions

STPCalibOptions () SYMBOL_VISIBLE

Public Members

ValuePerQuadrant i_ramp

ValuePerQuadrant v_stp

Private Functions

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

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, STPCalibOptions const &options) SYMBOL_VISIBLE

struct ccalix::STPCalibTarget : public ccalix::CalibTarget

#include <stp_calib_target.h>

Public Types

typedef halco::common::typed_array<haldls::vx::v3::CapMemCell::Value, halco::hicann_dls::vx::v3::CapMemBlockOnDLS> ValuePerQuadrant

Public Functions

STPCalibTarget () SYMBOL_VISIBLE

Public Members

ValuePerQuadrant v_charge_0

ValuePerQuadrant v_charge_1

ValuePerQuadrant v_recover_0

ValuePerQuadrant v_recover_1

Private Functions

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

Friends

friend class cereal::access

struct ccalix::SynapseDriverCalibOptions : public ccalix::CalibOptions

#include <synapse_driver_calib_options.h>

Public Functions

SynapseDriverCalibOptions() = default

Public Members

haldls::vx::v3::SynapseQuad::Label offset_test_activation{haldls::vx::v3::SynapseQuad::Label(haldls::vx::v3::PADIEvent::HagenActivation(3))}

Private Functions

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

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SynapseDriverCalibOptions const &options) SYMBOL_VISIBLE

struct ccalix::TimeInS : public halco::common::detail::BaseType<TimeInS, double>

#include <types.h>

Time in seconds.

Public Functions

inline explicit constexpr TimeInS(value_type const value = 0)

class ccalix::trafo::Linear : public ccalix::trafo::Transformation

#include <linear.h>

Public Types

enum class OutsideDomainBehavior

Behavior when the transformation of a value outside of the domain is requested.

Values:

enumerator THROW

throw an OutsideDomainException

enumerator CLIP

clip: use the domain boundary that is closer to the value

enumerator IGNORE

ignore the domain boundaries

Public Functions

Linear() = default

Linear(std::vector<FloatType> const &coefficients, FloatType constant_term)

Set default outer domain and coefficients.

virtual ~Linear()

virtual std::vector<FloatType> apply(std::vector<FloatType> const &in, OutsideDomainBehavior outside_domain_behavior = OutsideDomainBehavior::CLIP) const override

Applies the transformation to.

Parameters

• in. –

• outside_domain_behavior – determines the behavior if

• in – is outside of the stored domain.

virtual std::unique_ptr<Transformation> copy() const override

std::vector<FloatType> const &get_coefficients() const

FloatType get_constant_term() const

virtual size_t get_dimensionality() const override

Returns number of dimensions.

BoxType get_domain() const

Returns domain.

virtual bool in_domain(std::vector<FloatType> const &val) const

Checks if.

Parameters

• val – is within

• domain. – Can be overridden in the child classes to support non box type domains.

virtual bool in_reverse_domain(std::vector<FloatType> const &val) const

Like this domain and reverse domain of different types are supported.

virtual bool is_invertible() const override

Checks if the transformation is invertible.

virtual std::unique_ptr<Transformation> move() override

virtual std::ostream &print(std::ostream &os) const override

virtual std::vector<FloatType> reverse_apply(std::vector<FloatType> const &in, OutsideDomainBehavior outside_domain_behavior = OutsideDomainBehavior::CLIP) const override

Applies the transformation in reverse.

Need to call is_invertible() first. Heavily depends on specific transformation. Implementation is required -> throw error if not invertible.

void set_domain(BoxType const &domain)

Sets the domain and also calculates and sets the reverse domain.

Protected Functions

virtual BoxType get_reverse_domain() const override

Used by set_domain function to calculate the reverse domain.

Depends on specific transformation.

virtual bool is_equal_to(Transformation const &other) const override

virtual std::vector<FloatType> respect_domain(std::vector<FloatType> const &val, OutsideDomainBehavior outside_domain_behavior) const

Returns a value within the domain.

Default implementation supports only BoxType, can be overridden.

virtual std::vector<FloatType> respect_reverse_domain(std::vector<FloatType> const &val, OutsideDomainBehavior outside_domain_behavior) const

Returns a value within the reverse domain.

Protected Attributes

BoxType m_domain

BoxType m_reverse_domain

Private Functions

template<typename Archiver>
inline void serialize(Archiver &ar)

Private Members

std::vector<FloatType> m_coefficients

FloatType m_constant_term = {}

Friends

friend class cereal::access

class ccalix::trafo::Transformation : public dapr::Property<Transformation>

#include <transformation.h>

Base class of all n-dimensional Transformations, similar to calibtic/trafoTransformation.

Subclassed by ccalix::trafo::Linear

Public Types

enum class OutsideDomainBehavior

Behavior when the transformation of a value outside of the domain is requested.

Values:

enumerator THROW

throw an OutsideDomainException

enumerator CLIP

clip: use the domain boundary that is closer to the value

enumerator IGNORE

ignore the domain boundaries

Public Functions

Transformation()

Sets the domain to calix’s min/max.

virtual ~Transformation()

virtual std::vector<FloatType> apply(std::vector<FloatType> const &in, OutsideDomainBehavior outside_domain_behavior = OutsideDomainBehavior::THROW) const = 0

Applies the transformation to.

Parameters

• in. –

• outside_domain_behavior – determines the behavior if

• in – is outside of the stored domain.

virtual size_t get_dimensionality() const = 0

Returns number of dimensions.

BoxType get_domain() const

Returns domain.

virtual BoxType get_reverse_domain() const = 0

Used by set_domain function to calculate the reverse domain.

Depends on specific transformation.

virtual bool in_domain(std::vector<FloatType> const &val) const

Checks if.

Parameters

• val – is within

• domain. – Can be overridden in the child classes to support non box type domains.

virtual bool in_reverse_domain(std::vector<FloatType> const &val) const

Like this domain and reverse domain of different types are supported.

virtual bool is_invertible() const = 0

Checks if the transformation is invertible.

virtual std::vector<FloatType> reverse_apply(std::vector<FloatType> const &in, OutsideDomainBehavior outside_domain_behavior = OutsideDomainBehavior::THROW) const = 0

Applies the transformation in reverse.

Need to call is_invertible() first. Heavily depends on specific transformation. Implementation is required -> throw error if not invertible.

void set_domain(BoxType const &domain)

Sets the domain and also calculates and sets the reverse domain.

Protected Functions

virtual std::vector<FloatType> respect_domain(std::vector<FloatType> const &val, OutsideDomainBehavior outside_domain_behavior) const

Returns a value within the domain.

Default implementation supports only BoxType, can be overridden.

virtual std::vector<FloatType> respect_reverse_domain(std::vector<FloatType> const &val, OutsideDomainBehavior outside_domain_behavior) const

Returns a value within the reverse domain.

Protected Attributes

BoxType m_domain

BoxType m_reverse_domain

Private Functions

virtual std::vector<FloatType> respect_domain_impl(std::vector<FloatType> const &val, OutsideDomainBehavior outside_domain_behavior, BoxType const &domain) const

Currently only supports BoxType domains, may be changed in the future.

template<typename Archiver>
inline void serialize(Archiver &ar)

Friends

friend class cereal::access

namespace ccalix

Typedefs

typedef ParameterInterval<double> ParameterIntervalDouble

Functions

CompleteParameterTranslation from_portable_binary(std::string const&)

std::ostream & operator<< (std::ostream &os, CorrelationCalibOptions::Branches const &value) SYMBOL_VISIBLE

template<typename T>
std::ostream &operator<<(std::ostream &os, ParameterInterval<T> const &interval)

std::string to_portable_binary(CompleteParameterTranslation const&)

namespace ccalix::detail

Typedefs

typedef hate::type_list<ccalix::CalibTarget, ccalix::CADCCalibOptions, ccalix::CorrelationCalibOptions, ccalix::HagenCalibOptions, ccalix::HagenSyninCalibOptions, ccalix::NeuronCalibOptions, ccalix::SpikingCalibOptions, ccalix::SynapseDriverCalibOptions, ccalix::STPCalibOptions, ccalix::CADCCalibTarget, ccalix::CorrelationCalibTarget, ccalix::HagenCalibTarget, ccalix::HagenSyninCalibTarget, ccalix::HagenNeuronCalibTarget, ccalix::NeuronCalibTarget, ccalix::SpikingCalibTarget, ccalix::STPCalibTarget> pickle_types

Variables

static std::vector<std::string> const pickle_type_names = {"CalibTarget", "CADCCalibOptions", "CorrelationCalibOptions", "HagenCalibOptions", "HagenSyninCalibOptions", "NeuronCalibOptions", "SpikingCalibOptions", "SynapseDriverCalibOptions", "STPCalibOptions", "CADCCalibTarget", "CorrelationCalibTarget", "HagenCalibTarget", "HagenSyninCalibTarget", "HagenNeuronCalibTarget", "NeuronCalibTarget", "SpikingCalibTarget", "STPCalibTarget"}

namespace hagen

namespace ccalix::hagen::multiplication

Functions

SYMBOL_VISIBLE void send_vectors (stadls::vx::v3::PlaybackProgramBuilder &builder, const pybind11::array_t< uint_fast16_t > &vector, const size_t num_sends, const size_t wait_period, const halco::hicann_dls::vx::v3::SynramOnDLS synram_coord, const size_t synram_selection_bit)

Generate events for the given vector in hagen mode.

Parameters

• builder – Builder to append writes to

• vector – Array containing the input vector

• num_sends – Number of repeats of the whole vector

• wait_period – Wait time between two successive events

• synram_coord – Coordinate of synapse array to target with the events

• synram_selection_bit – Determines which bit in the event label selects the synram

namespace ccalix::hagen::multiplication::detail

Functions

haldls::vx::v3::SpikePack1ToChip prepare_event(const haldls::vx::v3::SynapseQuad::Label address, const halco::hicann_dls::vx::v3::SynapseDriverOnSynapseDriverBlock target_driver, const halco::hicann_dls::vx::v3::SynramOnDLS synram_coord, const size_t synram_selection_bit)

Return a spike pack to chip, containing an event reaching the desired synapse driver on the desired synram.

Parameters

• address – Address that is sent to the driver. The MSB reaches the synapses, the lower 5 bit encode the desired activation.

• target_driver – Coordinate of target synapse driver.

• synram_coord – Coordinate of target synapse array.

• synram_selection_bit – Bit position that selects synapse array.

Returns

Spike packet to chip.

namespace ccalix::helpers

Functions

std::string get_repo_state()

template<typename builder_t>
void write_capmem_row(builder_t &builder, const halco::hicann_dls::vx::v3::CapMemRowOnCapMemBlock row, const pybind11::array_t<uint_fast16_t> &values)

Attach write commands for a single, full row of non-global capmem cells to a given builder.

Template Parameters

builder_t – Type of the builder in use

Parameters

• builder – Builder writes are appended to

• row – Capmem row to be written

• values – Array of payload data to be written to the given capmem row

template SYMBOL_VISIBLE void write_capmem_row (stadls::vx::v3::PlaybackProgramBuilder &, const halco::hicann_dls::vx::v3::CapMemRowOnCapMemBlock, const pybind11::array_t< uint_fast16_t > &)

template SYMBOL_VISIBLE void write_capmem_row (stadls::vx::v3::PlaybackProgramBuilderDumper &, const halco::hicann_dls::vx::v3::CapMemRowOnCapMemBlock, const pybind11::array_t< uint_fast16_t > &)

namespace spiking

namespace ccalix::spiking::correlation_measurement

Functions

SYMBOL_VISIBLE pybind11::array_t< uint_fast16_t > evaluate_correlation (std::vector< stadls::vx::v3::ContainerTicket > tickets)

Evaluate correlation reads in given list of tickets.

Parameters

List – of read tickets, as returned by the read_correlation() function.

Returns

Numpy array containing all reads. It will be shaped (4, 256, 2) for the entries in a quad, the rows, and the causal/acausal correlation.

SYMBOL_VISIBLE std::vector< stadls::vx::v3::ContainerTicket > read_correlation (stadls::vx::v3::PlaybackProgramBuilder &builder, const halco::hicann_dls::vx::v3::SynapseQuadColumnOnDLS quad, const halco::hicann_dls::vx::v3::SynramOnDLS synram)

Read CADCs in given quad column.

Returns a list of tickets for each row.

Parameters

• builder – Builder to append reads to.

• quad – Quad coordinate to be read.

• synram – Synram to be used.

Returns

List of read tickets, ordered [causal row 0, acausal row 0, causal row 1, …]

SYMBOL_VISIBLE void reset_correlation (stadls::vx::v3::PlaybackProgramBuilder &builder, const halco::hicann_dls::vx::v3::SynapseQuadColumnOnDLS quad, const halco::hicann_dls::vx::v3::SynramOnDLS synram)

Reset all synapse correlations in given quad.

Parameters

• builder – Builder to append instructions to.

• quad – Quad column to be reset.

• synram – Target synram coordinate.

SYMBOL_VISIBLE void send_postpulse (stadls::vx::v3::PlaybackProgramBuilder &builder, const halco::hicann_dls::vx::v3::SynapseQuadColumnOnDLS quad, const halco::hicann_dls::vx::v3::SynramOnDLS synram)

Reset the given quad of neurons, sending an STDP postpulse to synapses.

Parameters

• builder – Builder to append instructions to.

• quad – Quad column to reset neurons in.

• synram – Target synram coordinate.

SYMBOL_VISIBLE void send_prepulse (stadls::vx::v3::PlaybackProgramBuilder &builder, const halco::hicann_dls::vx::v3::SynramOnDLS synram, const haldls::vx::v3::SynapseQuad::Label address)

Send a PADI event to all drivers, i.e.

an STDP prepulse to all synapses.

Parameters

• builder – Builder to append instructions to.

• synram – Synram coordinate of synapses to stimulate.

• address – Address to be sent to synapses.

namespace ccalix::trafo

Typedefs

typedef std::vector<IntervalType> BoxType

typedef double FloatType

typedef ParameterInterval<FloatType> IntervalType

Variables

const FloatType calix_domain_max = std::numeric_limits<FloatType>::max()

const FloatType calix_domain_min = -std::numeric_limits<FloatType>::min()

namespace cereal

Functions

template<class Archive, class T>
inline void serialize(Archive &ar, ccalix::ParameterInterval<T> &interval)

Serialization support for ParameterInterval.

namespace dapr

namespace halco

namespace common

namespace detail

namespace std

STL namespace.

file cadc_calib_options.h

#include “ccalix/calib_options.h”

#include “ccalix/cerealization.h”

#include “”

#include <>

#include <>

file cadc_calib_target.h

#include “ccalix/calib_target.h”

#include “ccalix/cerealization.h”

#include “ccalix/range.h”

#include “”

#include “”

#include “”

#include <>

file calib_options.h

#include “ccalix/genpybind.h”

file calib_target.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

file ccalix.h

#include “ccalix/cadc_calib_options.h”

#include “ccalix/calib_options.h”

#include “ccalix/correlation_calib_options.h”

#include “ccalix/correlation_calib_target.h”

#include “ccalix/genpybind.h”

#include “ccalix/hagen/multiplication.h”

#include “ccalix/hagen_calib_options.h”

#include “ccalix/hagen_calib_target.h”

#include “ccalix/hagen_neuron_calib_target.h”

#include “ccalix/hagen_synin_calib_options.h”

#include “ccalix/hagen_synin_calib_target.h”

#include “ccalix/helpers.h”

#include “ccalix/neuron_calib_options.h”

#include “ccalix/neuron_calib_target.h”

#include “ccalix/spiking/correlation_measurement.h”

#include “ccalix/spiking_calib_options.h”

#include “ccalix/spiking_calib_target.h”

#include “ccalix/stp_calib_options.h”

#include “ccalix/stp_calib_target.h”

#include “ccalix/synapse_driver_calib_options.h”

#include “ccalix/trafo/linear.h”

#include “ccalix/trafo/outside_domain_exception.h”

#include “ccalix/trafo/transformation.h”

#include “ccalix/translation/cadc_calib_param.h”

#include “ccalix/translation/cadc_on_dls.h”

#include “ccalix/translation/cadc_translation.h”

#include “ccalix/translation/calibrated_parameter.h”

#include “ccalix/translation/complete_parameter_translation.h”

#include “ccalix/translation/madc_calib_param.h”

#include “ccalix/translation/madc_on_dls.h”

#include “ccalix/translation/madc_translation.h”

#include “ccalix/translation/model_cadc.h”

#include “ccalix/translation/model_madc.h”

#include “ccalix/translation/model_parameter.h”

#include “ccalix/translation/parameter_translation.h”

#include “ccalix/types.h”

#include “”

#include “”

file cerealization.h

#include “”

#include <>

Defines

CCALIX_EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CLASS_NAME)

file correlation_calib_options.h

#include “ccalix/cadc_calib_options.h”

#include “ccalix/calib_options.h”

#include “ccalix/cerealization.h”

#include “ccalix/correlation_calib_options.h”

#include “ccalix/neuron_calib_options.h”

#include “ccalix/stp_calib_options.h”

#include “ccalix/types.h”

#include “”

#include “”

#include <>

#include <>

file correlation_calib_target.h

#include “ccalix/calib_target.h”

#include “ccalix/cerealization.h”

#include “ccalix/types.h”

#include “”

#include <>

file genpybind.h

Defines

GENPYBIND(...)

GENPYBIND_MANUAL(...)

GENPYBIND_MODULE

GENPYBIND_TAG_CCALIX

file multiplication.h

#include “ccalix/genpybind.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

file hagen_calib_options.h

#include “ccalix/cadc_calib_options.h”

#include “ccalix/calib_options.h”

#include “ccalix/cerealization.h”

#include “ccalix/neuron_calib_options.h”

#include “ccalix/synapse_driver_calib_options.h”

#include “”

#include <>

file hagen_calib_target.h

#include “ccalix/cadc_calib_target.h”

#include “ccalix/calib_target.h”

#include “ccalix/cerealization.h”

#include “ccalix/hagen_neuron_calib_target.h”

#include “”

file hagen_neuron_calib_target.h

#include “ccalix/calib_target.h”

#include “ccalix/cerealization.h”

#include “ccalix/neuron_calib_target.h”

#include “ccalix/types.h”

#include “”

#include “”

#include “”

#include “”

#include “”

file hagen_synin_calib_options.h

#include “ccalix/cadc_calib_options.h”

#include “ccalix/calib_options.h”

#include “ccalix/cerealization.h”

#include “ccalix/synapse_driver_calib_options.h”

#include “”

#include <>

#include <>

file hagen_synin_calib_target.h

#include “ccalix/cadc_calib_target.h”

#include “ccalix/calib_target.h”

#include “ccalix/cerealization.h”

#include “ccalix/hagen_neuron_calib_target.h”

#include “”

file helpers.h

#include “ccalix/genpybind.h”

#include “”

#include “”

#include “”

#include <>

#include <>

file neuron_calib_options.h

#include “ccalix/calib_options.h”

#include “ccalix/cerealization.h”

#include “”

#include “”

#include <>

file neuron_calib_target.h

#include “ccalix/calib_target.h”

#include “ccalix/cerealization.h”

#include “ccalix/types.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

file pickle.h

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

file range.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include <>

#include <>

#include <>

file correlation_measurement.h

#include “ccalix/genpybind.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

file spiking_calib_options.h

#include “ccalix/cadc_calib_options.h”

#include “ccalix/calib_options.h”

#include “ccalix/cerealization.h”

#include “ccalix/correlation_calib_options.h”

#include “ccalix/neuron_calib_options.h”

#include “ccalix/stp_calib_options.h”

#include “”

#include <>

#include <>

file spiking_calib_target.h

#include “ccalix/cadc_calib_target.h”

#include “ccalix/calib_target.h”

#include “ccalix/cerealization.h”

#include “ccalix/correlation_calib_target.h”

#include “ccalix/neuron_calib_target.h”

#include “ccalix/stp_calib_target.h”

#include “”

#include <>

file stp_calib_options.h

#include “ccalix/calib_options.h”

#include “ccalix/cerealization.h”

#include “”

#include “”

#include “”

file stp_calib_target.h

#include “ccalix/calib_target.h”

#include “ccalix/cerealization.h”

#include “”

#include “”

#include “”

#include “”

#include <>

file synapse_driver_calib_options.h

#include “ccalix/calib_options.h”

#include “ccalix/cerealization.h”

#include “”

#include “”

#include “”

#include <>

file linear.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/trafo/transformation.h”

#include <>

#include <>

#include <>

#include <>

file outside_domain_exception.h

#include “ccalix/genpybind.h”

#include <>

file parameter_interval.h

#include “ccalix/genpybind.h”

#include <>

#include <>

#include “”

file transformation.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/trafo/outside_domain_exception.h”

#include “ccalix/trafo/parameter_interval.h”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file cadc_calib_param.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/trafo/linear.h”

#include “ccalix/translation/calibrated_parameter.h”

#include “”

#include <>

#include <>

#include <>

#include <>

Functions

CEREAL_FORCE_DYNAMIC_INIT(CadcCalibParam)

file cadc_on_dls.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/translation/model_entity_on_dls.h”

#include “”

#include “”

#include <>

#include <>

Functions

CEREAL_FORCE_DYNAMIC_INIT(CadcOnDLS)

file cadc_translation.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/trafo/linear.h”

#include “ccalix/translation/cadc_on_dls.h”

#include “ccalix/translation/parameter_translation.h”

#include <>

#include <>

Functions

CEREAL_FORCE_DYNAMIC_INIT(CadcTranslation)

file calibrated_parameter.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “”

#include <>

#include <>

#include <>

#include <>

file complete_parameter_translation.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/translation/cadc_translation.h”

#include “ccalix/translation/madc_translation.h”

#include <>

#include <>

#include <>

#include <>

Functions

CEREAL_FORCE_DYNAMIC_INIT(CompleteParameterTranslation)

file madc_calib_param.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/trafo/linear.h”

#include “ccalix/translation/calibrated_parameter.h”

#include <>

#include <>

Functions

CEREAL_FORCE_DYNAMIC_INIT(MadcCalibParam)

file madc_on_dls.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/translation/model_entity_on_dls.h”

#include “”

#include “”

#include <>

#include <>

Functions

CEREAL_FORCE_DYNAMIC_INIT(MadcOnDLS)

file madc_translation.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/trafo/linear.h”

#include “ccalix/translation/madc_on_dls.h”

#include “ccalix/translation/parameter_translation.h”

#include <>

#include <>

Functions

CEREAL_FORCE_DYNAMIC_INIT(MadcTranslation)

file model_cadc.h

#include “ccalix/genpybind.h”

#include “ccalix/translation/model_parameter.h”

#include “”

#include “”

#include <>

#include <>

#include <>

file model_entity_on_dls.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “”

#include “”

#include <>

#include <>

file model_madc.h

#include “ccalix/genpybind.h”

#include “ccalix/translation/model_parameter.h”

#include “”

#include “”

#include <>

#include <>

#include <>

file model_parameter.h

#include “ccalix/genpybind.h”

#include “”

#include “”

file parameter_translation.h

#include “ccalix/cerealization.h”

#include “ccalix/genpybind.h”

#include “ccalix/translation/calibrated_parameter.h”

#include “ccalix/translation/model_entity_on_dls.h”

#include “ccalix/translation/model_parameter.h”

#include “”

#include <>

#include <>

#include <>

file types.h

#include “ccalix/genpybind.h”

#include “”

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTgzOTA.x/calix

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTgzOTA.x/calix/include/ccalix

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTgzOTA.x/calix/include/ccalix/hagen

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTgzOTA.x/calix/include

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTgzOTA.x/calix/include/ccalix/spiking

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTgzOTA.x/calix/include/ccalix/trafo

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTgzOTA.x/calix/include/ccalix/translation