background.h

Go to the documentation of this file.

#pragma once
#include <array>
#include <iosfwd>
 
#include "halco/common/geometry.h"
#include "halco/hicann-dls/vx/background.h"
#include "halco/hicann-dls/vx/event.h"
 
#include "haldls/cerealization.h"
#include "haldls/vx/genpybind.h"
#include "haldls/vx/traits.h"
#include "hate/math.h"
#include "hate/visibility.h"
 
#ifndef __ppu__
#include "hxcomm/vx/target.h"
#endif
 
namespace fisch::vx {
class OmnibusChipOverJTAG;
class Omnibus;
} // namespace fisch::vx
 
namespace haldls {
namespace vx GENPYBIND_TAG_HALDLS_VX {
 
class GENPYBIND(visible) BackgroundSpikeSource
{
public:
    typedef halco::hicann_dls::vx::BackgroundSpikeSourceOnDLS coordinate_type;
    typedef std::true_type is_leaf_node;
#ifndef __ppu__
    constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
        hxcomm::vx::Target::hardware, hxcomm::vx::Target::simulation};
#endif
 
    struct GENPYBIND(inline_base("*")) Period
        : public halco::common::detail::
              RantWrapper<Period, uint_fast32_t, hate::math::pow(2, 16) - 1, 0>
    {
        constexpr explicit Period(uintmax_t const val = 0)
            GENPYBIND(implicit_conversion) : rant_t(val)
        {}
    };
 
    struct GENPYBIND(inline_base("*")) Rate
        : public halco::common::detail::
              RantWrapper<Rate, uint_fast16_t, hate::math::pow(2, 8) - 1, 0>
    {
        constexpr explicit Rate(uintmax_t const val = 0)
            GENPYBIND(implicit_conversion) : rant_t(val)
        {}
    };
 
    struct GENPYBIND(inline_base("*")) Seed
        : public halco::common::detail::
              RantWrapper<Seed, uint_fast64_t, hate::math::pow(2, 32) - 1, 0>
    {
        constexpr explicit Seed(uintmax_t const val = 0)
            GENPYBIND(implicit_conversion) : rant_t(val)
        {}
    };
 
    struct GENPYBIND(inline_base("*")) Mask
        : public halco::common::detail::
              RantWrapper<Mask, uint_fast16_t, hate::math::pow(2, 8) - 1, 0>
    {
        constexpr explicit Mask(uintmax_t const val = 0)
            GENPYBIND(implicit_conversion) : rant_t(val)
        {}
    };
 
    BackgroundSpikeSource() SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(enable))
    bool get_enable() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(enable))
    void set_enable(bool value) SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(enable_random))
    bool get_enable_random() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(enable_random))
    void set_enable_random(bool value) SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(period))
    Period get_period() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(period))
    void set_period(Period const& value) SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(rate))
    Rate get_rate() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(rate))
    void set_rate(Rate const& value) SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(seed))
    Seed get_seed() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(seed))
    void set_seed(Seed const& value) SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(mask))
    Mask get_mask() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(mask))
    void set_mask(Mask const& value) SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(neuron_label))
    halco::hicann_dls::vx::NeuronLabel get_neuron_label() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(neuron_label))
    void set_neuron_label(halco::hicann_dls::vx::NeuronLabel const& value) SYMBOL_VISIBLE;
 
    bool operator==(BackgroundSpikeSource const& other) const SYMBOL_VISIBLE;
    bool operator!=(BackgroundSpikeSource const& other) const SYMBOL_VISIBLE;
 
    static size_t constexpr config_size_in_words GENPYBIND(hidden) = 3;
    template <typename AddressT>
    static std::array<AddressT, config_size_in_words> addresses(coordinate_type const& neuron)
        SYMBOL_VISIBLE GENPYBIND(hidden);
    template <typename WordT>
    std::array<WordT, config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
    template <typename WordT>
    void decode(std::array<WordT, config_size_in_words> const& data) SYMBOL_VISIBLE
        GENPYBIND(hidden);
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, BackgroundSpikeSource const& config)
        SYMBOL_VISIBLE;
 
private:
    friend class cereal::access;
    template <class Archive>
    void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
 
    bool m_enable;
    bool m_enable_random;
    Period m_period;
    Rate m_rate;
    Seed m_seed;
    Mask m_mask;
    halco::hicann_dls::vx::NeuronLabel m_neuron_label;
};
 
EXTERN_INSTANTIATE_CEREAL_SERIALIZE(BackgroundSpikeSource)
 
namespace detail {
 
template <>
struct BackendContainerTrait<BackgroundSpikeSource>
    : public BackendContainerBase<
          BackgroundSpikeSource,
          fisch::vx::word_access_type::Omnibus,
          fisch::vx::word_access_type::OmnibusChipOverJTAG>
{};
 
} // namespace detail
 
} // namespace vx
} // namespace haldls