neuron.h

Go to the documentation of this file.

#pragma once
#include "haldls/vx/v3/capmem.h"
#include "haldls/vx/v3/neuron.h"
#include "hate/visibility.h"
#include "lola/vx/genpybind.h"
#include "lola/vx/v3/synapse.h"
 
namespace lola::vx::v3 GENPYBIND_TAG_LOLA_VX_V3 {
 
class GENPYBIND(visible) AtomicNeuron
{
public:
    typedef haldls::vx::v3::CapMemCell::Value AnalogValue GENPYBIND(visible);
    typedef haldls::vx::v3::CapMemCell::DisableRefresh AnalogDisableRefresh GENPYBIND(visible);
    typedef haldls::vx::v3::CapMemCell::value_type AnalogValueVariant;
 
    struct GENPYBIND(visible) SynapticInput
    {
        SynapticInput() SYMBOL_VISIBLE;
 
        bool enable;
 
        AnalogValueVariant i_bias_tau;
 
        AnalogValueVariant i_bias_coba;
 
        AnalogValueVariant i_shift_reference;
 
        AnalogValueVariant i_bias_gm;
 
        AnalogValueVariant v_rev_coba;
 
        bool enable_small_capacitance;
 
        bool enable_high_resistance;
 
        bool enable_coba_mode;
 
        bool operator==(SynapticInput const& other) const SYMBOL_VISIBLE;
        bool operator!=(SynapticInput const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, SynapticInput const& config)
            SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) Leak
    {
        Leak() SYMBOL_VISIBLE;
 
        AnalogValueVariant v_leak;
 
        /*
         * Bias current of OTA during leak.
         * High values result in a shorter membrane time constant.
         */
        AnalogValueVariant i_bias;
 
        bool enable_degeneration;
 
        bool enable_division;
 
        bool enable_multiplication;
 
        bool operator==(Leak const& other) const SYMBOL_VISIBLE;
        bool operator!=(Leak const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, Leak const& config) SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) Reset
    {
        Reset() SYMBOL_VISIBLE;
 
        AnalogValueVariant v_reset;
 
        /*
         * Bias current of OTA during reset.
         * High values result in higher reset conductance.
         */
        AnalogValueVariant i_bias;
 
        bool enable_degeneration;
 
        bool enable_division;
 
        bool enable_multiplication;
 
        bool operator==(Reset const& other) const SYMBOL_VISIBLE;
        bool operator!=(Reset const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, Reset const& config) SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) Threshold
    {
        Threshold() SYMBOL_VISIBLE;
 
        bool enable;
 
        AnalogValueVariant v_threshold;
 
        bool operator==(Threshold const& other) const SYMBOL_VISIBLE;
        bool operator!=(Threshold const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, Threshold const& config) SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) Multicompartment
    {
        Multicompartment() SYMBOL_VISIBLE;
 
        bool connect_soma;
 
        bool connect_soma_right;
 
        bool connect_right;
 
        bool connect_vertical;
 
        bool enable_conductance;
 
        bool enable_conductance_division;
 
        bool enable_conductance_multiplication;
 
        AnalogValueVariant i_bias_nmda;
 
        bool operator==(Multicompartment const& other) const SYMBOL_VISIBLE;
        bool operator!=(Multicompartment const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, Multicompartment const& config)
            SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) ConstantCurrent
    {
        ConstantCurrent() SYMBOL_VISIBLE;
 
        bool enable;
 
        AnalogValueVariant i_offset;
 
        enum class Type
        {
            source,
            sink
        } type;
 
        bool operator==(ConstantCurrent const& other) const SYMBOL_VISIBLE;
        bool operator!=(ConstantCurrent const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, ConstantCurrent const& config)
            SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) MembraneCapacitance
    {
        typedef haldls::vx::v3::NeuronConfig::MembraneCapacitorSize CapacitorSize
            GENPYBIND(visible);
 
        MembraneCapacitance() SYMBOL_VISIBLE;
 
        CapacitorSize capacitance;
 
        bool operator==(MembraneCapacitance const& other) const SYMBOL_VISIBLE;
        bool operator!=(MembraneCapacitance const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, MembraneCapacitance const& config)
            SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) Adaptation
    {
        Adaptation() SYMBOL_VISIBLE;
 
        bool enable;
 
        bool enable_pulse;
 
        bool invert_a;
 
        bool invert_b;
 
        AnalogValueVariant v_ref;
 
        AnalogValueVariant i_bias_tau;
 
        AnalogValueVariant i_bias_a;
 
        AnalogValueVariant i_bias_b;
 
        AnalogValueVariant v_leak;
 
        bool operator==(Adaptation const& other) const SYMBOL_VISIBLE;
        bool operator!=(Adaptation const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, Adaptation const& config) SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) Exponential
    {
        bool enable;
 
        AnalogValueVariant v_exp;
 
        AnalogValueVariant i_bias;
 
        Exponential() SYMBOL_VISIBLE;
 
        bool operator==(Exponential const& other) const SYMBOL_VISIBLE;
        bool operator!=(Exponential const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, Exponential const& config) SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) EventRouting
    {
        EventRouting() SYMBOL_VISIBLE;
 
        typedef haldls::vx::v3::NeuronBackendConfig::AddressOut Address GENPYBIND(visible);
 
        enum class AnalogOutputMode
        {
            off,
            normal,
            strong
        } analog_output;
 
        bool enable_digital;
 
        bool enable_bypass_excitatory;
 
        bool enable_bypass_inhibitory;
 
        Address address;
 
        bool enable_post_overwrite;
 
        EventRouting(
            AnalogOutputMode analog_output,
            bool enable_digital,
            bool enable_bypass_excitatory,
            bool enable_bypass_inhibitory,
            Address address,
            bool enable_post_overwrite) SYMBOL_VISIBLE;
 
        static const EventRouting disabled SYMBOL_VISIBLE;
        static const EventRouting enabled SYMBOL_VISIBLE;
        static const EventRouting bypass_exc SYMBOL_VISIBLE;
        static const EventRouting bypass_inh SYMBOL_VISIBLE;
 
        bool operator==(EventRouting const& other) const SYMBOL_VISIBLE;
        bool operator!=(EventRouting const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, EventRouting const& config)
            SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) Readout
    {
        typedef haldls::vx::v3::NeuronConfig::ReadoutSource Source GENPYBIND(visible);
 
        bool enable_buffered_access;
 
        bool enable_amplifier;
 
        bool enable_unbuffered_access;
 
        Source source;
 
        Readout() SYMBOL_VISIBLE;
 
        bool operator==(Readout const& other) const SYMBOL_VISIBLE;
        bool operator!=(Readout const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, Readout const& config) SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) RefractoryPeriod
    {
        typedef haldls::vx::v3::NeuronBackendConfig::InputClock InputClock GENPYBIND(visible);
        typedef haldls::vx::v3::NeuronBackendConfig::ResetHoldoff ResetHoldoff GENPYBIND(visible);
        typedef haldls::vx::v3::NeuronBackendConfig::RefractoryTime RefractoryTime
            GENPYBIND(visible);
 
        InputClock input_clock;
 
        ResetHoldoff reset_holdoff;
 
        RefractoryTime refractory_time;
 
        bool enable_pause;
 
        RefractoryPeriod() SYMBOL_VISIBLE;
 
        bool operator==(RefractoryPeriod const& other) const SYMBOL_VISIBLE;
        bool operator!=(RefractoryPeriod const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, RefractoryPeriod const& config)
            SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) Bayesian
    {
        Bayesian() SYMBOL_VISIBLE;
 
        bool enable;
        bool connect_fire_vertical;
        bool connect_fire_to_right;
        bool connect_fire_from_right;
 
        bool enable_master;
        bool enable_slave;
        bool enable_0;
        bool enable_1;
 
        bool operator==(Bayesian const& other) const SYMBOL_VISIBLE;
        bool operator!=(Bayesian const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, Bayesian const& config) SYMBOL_VISIBLE;
    };
 
 
    typedef halco::hicann_dls::vx::v3::AtomicNeuronOnDLS coordinate_type;
    typedef std::false_type has_local_data;
 
    AtomicNeuron() SYMBOL_VISIBLE;
 
    SynapticInput excitatory_input;
    SynapticInput inhibitory_input;
    Leak leak;
    Reset reset;
    Threshold threshold;
    Multicompartment multicompartment;
    ConstantCurrent constant_current;
    MembraneCapacitance membrane_capacitance;
    Adaptation adaptation;
    Exponential exponential;
    EventRouting event_routing;
    Readout readout;
    RefractoryPeriod refractory_period;
    Bayesian bayesian;
 
    explicit operator haldls::vx::v3::NeuronConfig() const SYMBOL_VISIBLE;
    GENPYBIND_MANUAL({
        parent.def("asNeuronConfig", [](GENPYBIND_PARENT_TYPE const& self) {
            return static_cast<haldls::vx::v3::NeuronConfig>(self);
        });
    })
 
    void set_from(haldls::vx::v3::NeuronConfig const& neuron_config) SYMBOL_VISIBLE;
 
    explicit operator haldls::vx::v3::NeuronBackendConfig() const SYMBOL_VISIBLE;
    GENPYBIND_MANUAL({
        parent.def("asNeuronBackendConfig", [](GENPYBIND_PARENT_TYPE const& self) {
            return static_cast<haldls::vx::v3::NeuronBackendConfig>(self);
        });
    })
 
    void set_from(haldls::vx::v3::NeuronBackendConfig const& neuron_backend_config) SYMBOL_VISIBLE;
 
    bool operator==(AtomicNeuron const& other) const SYMBOL_VISIBLE;
    bool operator!=(AtomicNeuron const& other) const SYMBOL_VISIBLE;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, AtomicNeuron const& config) SYMBOL_VISIBLE;
 
private:
    friend class haldls::vx::detail::VisitPreorderImpl<AtomicNeuron>;
};
 
 
class GENPYBIND(visible) NeuronBlock
{
public:
    typedef haldls::vx::v3::CapMemCell::Value AnalogValue GENPYBIND(visible);
    typedef haldls::vx::v3::CapMemCell::DisableRefresh AnalogDisableRefresh GENPYBIND(visible);
    typedef haldls::vx::v3::CapMemCell::value_type AnalogValueVariant;
 
    typedef halco::hicann_dls::vx::v3::NeuronBlockOnDLS coordinate_type;
    typedef std::false_type has_local_data;
 
    NeuronBlock() = default;
 
    typedef halco::common::
        typed_heap_array<AtomicNeuron, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS>
            AtomicNeurons GENPYBIND(opaque(false));
    AtomicNeurons atomic_neurons{};
 
    typedef halco::common::typed_array<
        haldls::vx::v3::CommonNeuronBackendConfig,
        halco::hicann_dls::vx::v3::CommonNeuronBackendConfigOnDLS>
        Backends GENPYBIND(opaque(false));
 
    Backends backends{};
 
    typedef halco::common::typed_array<
        lola::vx::v3::ColumnCurrentRow,
        halco::hicann_dls::vx::v3::ColumnCurrentRowOnDLS>
        CurrentRows GENPYBIND(opaque(false));
 
    CurrentRows current_rows{};
 
    typedef halco::common::
        typed_array<AnalogValueVariant, halco::hicann_dls::vx::v3::CapMemBlockOnDLS>
            AnalogValues;
    AnalogValues v_bias_casc_n{
        AnalogValue{250}, AnalogValue{250}, AnalogValue{250}, AnalogValue{250}};
 
    AnalogValues i_bias_readout_amp{
        AnalogValue{110}, AnalogValue{110}, AnalogValue{110}, AnalogValue{110}};
 
    AnalogValues i_bias_leak_source_follower{
        AnalogValue{100}, AnalogValue{100}, AnalogValue{100}, AnalogValue{100}};
 
    AnalogValues i_bias_threshold_comparator{
        AnalogValue{200}, AnalogValue{200}, AnalogValue{200}, AnalogValue{200}};
 
    AnalogValues i_bias_synin_drop{
        AnalogValue{300}, AnalogValue{300}, AnalogValue{300}, AnalogValue{300}};
 
    bool operator==(NeuronBlock const& other) const SYMBOL_VISIBLE;
    bool operator!=(NeuronBlock const& other) const SYMBOL_VISIBLE;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, NeuronBlock const& config) SYMBOL_VISIBLE;
 
    // TODO (Issue 3622): Manual wrapping is necessary due to genpybind forgetting full
    // qualification
    GENPYBIND_MANUAL({
        auto av = parent->py::template class_<::lola::vx::v3::NeuronBlock::AnalogValues>(
            parent, "AnalogValues");
        av.def(
            "fill", &::lola::vx::v3::NeuronBlock::AnalogValues::fill, "", parent->py::arg("val"));
        {
            typedef ::lola::vx::v3::NeuronBlock::AnalogValues::reference (
                ::lola::vx::v3::NeuronBlock::AnalogValues::*genpybind_at_type)(
                const ::lola::vx::v3::NeuronBlock::AnalogValues::key_type&);
            av.def(
                "at", (genpybind_at_type) & ::lola::vx::v3::NeuronBlock::AnalogValues::at, "",
                parent->py::arg("key"));
        }
        {
            typedef ::lola::vx::v3::NeuronBlock::AnalogValues::const_reference (
                ::lola::vx::v3::NeuronBlock::AnalogValues::*genpybind_at_type)(
                const ::lola::vx::v3::NeuronBlock::AnalogValues::key_type&) const;
            av.def(
                "at", (genpybind_at_type) & ::lola::vx::v3::NeuronBlock::AnalogValues::at, "",
                parent->py::arg("key"));
        }
        {
            typedef ::lola::vx::v3::NeuronBlock::AnalogValues::reference (
                ::lola::vx::v3::NeuronBlock::AnalogValues::*genpybind_front_type)();
            av.def(
                "front", (genpybind_front_type) & ::lola::vx::v3::NeuronBlock::AnalogValues::front,
                "");
        }
        {
            typedef ::lola::vx::v3::NeuronBlock::AnalogValues::const_reference (
                ::lola::vx::v3::NeuronBlock::AnalogValues::*genpybind_front_type)() const;
            av.def(
                "front", (genpybind_front_type) & ::lola::vx::v3::NeuronBlock::AnalogValues::front,
                "");
        }
        {
            typedef ::lola::vx::v3::NeuronBlock::AnalogValues::reference (
                ::lola::vx::v3::NeuronBlock::AnalogValues::*genpybind_back_type)();
            av.def(
                "back", (genpybind_back_type) & ::lola::vx::v3::NeuronBlock::AnalogValues::back,
                "");
        }
        {
            typedef ::lola::vx::v3::NeuronBlock::AnalogValues::const_reference (
                ::lola::vx::v3::NeuronBlock::AnalogValues::*genpybind_back_type)() const;
            av.def(
                "back", (genpybind_back_type) & ::lola::vx::v3::NeuronBlock::AnalogValues::back,
                "");
        }
        av.def(
            "__getitem__", &::lola::vx::v3::NeuronBlock::AnalogValues::get, "",
            parent->py::arg("key"), parent->py::return_value_policy::reference);
        av.def(
            "__setitem__", &::lola::vx::v3::NeuronBlock::AnalogValues::set, "",
            parent->py::arg("key"), parent->py::arg("value"));
        av.def(
            "__iter__",
            [av](::lola::vx::v3::NeuronBlock::AnalogValues& self) {
                return pybind11::make_iterator(self);
            },
            parent->py::template keep_alive<0, 1>());
 
        av.def("to_numpy", [](::lola::vx::v3::NeuronBlock::AnalogValues const& self) {
            return ::halco::common::detail::to_numpy(self);
        });
        av.def(
            "from_numpy",
            [](::lola::vx::v3::NeuronBlock::AnalogValues& self, pybind11::array const& array) {
                ::halco::common::detail::from_numpy(self, array);
            });
        av.def(parent->py::template init<const ::lola::vx::v3::NeuronBlock::AnalogValues&>(), "");
        av.def(parent->py::template init<>(), "");
        av.def_property_readonly(
            "size", parent->py::cpp_function(&::lola::vx::v3::NeuronBlock::AnalogValues::size));
        av.def_property_readonly(
            "max_size",
            parent->py::cpp_function(&::lola::vx::v3::NeuronBlock::AnalogValues::max_size));
        av.def_property_readonly(
            "empty", parent->py::cpp_function(&::lola::vx::v3::NeuronBlock::AnalogValues::empty));
    })
private:
    friend class haldls::vx::detail::VisitPreorderImpl<NeuronBlock>;
};
 
} // namespace lola::vx::v3
 
#include "lola/vx/v3/neuron.tcc"