projection.h

Go to the documentation of this file.

 
#pragma once
 
#include <knp/core/core.h>
#include <knp/core/uid.h>
#include <knp/synapse-traits/all_traits.h>
 
#include <algorithm>
#include <functional>
#include <optional>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index_container.hpp>
 
 
namespace knp::core
{
enum SynapseElementAccess
{
    synapse_data = 0,
    source_neuron_id = 1,
    target_neuron_id = 2
};
 
 
template <class SynapseType>
class Projection final
{
public:
    using ProjectionSynapseType = SynapseType;
    using ProjectionType = Projection<SynapseType>;
    using SynapseParameters = typename synapse_traits::synapse_parameters<SynapseType>;
 
    using Synapse = std::tuple<SynapseParameters, size_t, size_t>;
 
    using SynapseGenerator = std::function<std::optional<Synapse>(size_t)>;
 
public:
    template <typename SynapseT>
    struct SharedSynapseParametersT
    {
        knp::synapse_traits::shared_synapse_parameters<SynapseT> synapses_parameters_;
    };
 
    template <template <typename> typename Rule, typename SynapseT>
    struct SharedSynapseParametersT<knp::synapse_traits::STDP<Rule, SynapseT>>
    {
        enum class ProcessingType
        {
            STDPOnly,
            STDPAndSpike
        };
 
        using ContainerType = std::unordered_map<core::UID, ProcessingType, core::uid_hash>;
        ContainerType stdp_populations_;
 
        knp::synapse_traits::shared_synapse_parameters<knp::synapse_traits::STDP<Rule, SynapseT>> synapses_parameters_;
    };
 
    using SharedSynapseParameters = SharedSynapseParametersT<SynapseType>;
 
public:
    Projection(UID presynaptic_uid, UID postsynaptic_uid);
    Projection(UID uid, UID presynaptic_uid, UID postsynaptic_uid);
 
    Projection(UID presynaptic_uid, UID postsynaptic_uid, SynapseGenerator generator, size_t num_iterations);
 
    Projection(UID uid, UID presynaptic_uid, UID postsynaptic_uid, SynapseGenerator generator, size_t num_iterations);
 
public:
    [[nodiscard]] const UID &get_uid() const { return base_.uid_; }
 
    [[nodiscard]] auto &get_tags() { return base_.tags_; }
 
    [[nodiscard]] const auto &get_tags() const { return base_.tags_; }
 
public:
    [[nodiscard]] Synapse &operator[](size_t index) { return parameters_[index]; }
 
    [[nodiscard]] const Synapse &operator[](size_t index) const { return parameters_[index]; }
 
    [[nodiscard]] auto begin() const { return parameters_.cbegin(); }
 
    [[nodiscard]] auto begin() { return parameters_.begin(); }
 
    [[nodiscard]] auto end() const { return parameters_.cend(); }
 
    [[nodiscard]] auto end() { return parameters_.end(); }
 
public:
    [[nodiscard]] size_t size() const { return parameters_.size(); }
 
    [[nodiscard]] const UID &get_presynaptic() const { return presynaptic_uid_; }
 
    [[nodiscard]] const UID &get_postsynaptic() const { return postsynaptic_uid_; }
 
    enum class Search
    {
        by_presynaptic,
        by_postsynaptic
    };
 
    [[nodiscard]] std::vector<size_t> find_synapses(size_t neuron_index, Search search_method) const;
 
    size_t add_synapses(SynapseGenerator generator, size_t num_iterations);
 
    void clear();
 
    void remove_synapse(size_t index);
 
    size_t remove_synapse_if(std::function<bool(const Synapse &)> predicate);
 
    size_t remove_postsynaptic_neuron_synapses(size_t neuron_index);
 
    size_t remove_presynaptic_neuron_synapses(size_t neuron_index);
 
public:
    void lock_weights() { is_locked_ = true; }
 
    void unlock_weights() { is_locked_ = false; }
 
    bool is_locked() const { return is_locked_; }
 
public:
    SharedSynapseParameters &get_shared_parameters() { return shared_parameters_; }
    const SharedSynapseParameters &get_shared_parameters() const { return shared_parameters_; }
 
private:
    void reindex() const;
 
    BaseData base_;
 
    UID presynaptic_uid_;
 
    UID postsynaptic_uid_;
 
    bool is_locked_ = true;
 
    std::vector<Synapse> parameters_;
    // So far the index is mutable so we can reindex a const object that has a non-updated index.
    struct Connection
    {
        size_t from_;
        size_t to_;
        size_t index_;
        bool operator==(const Connection &connection) const
        {
            return from_ == connection.from_ && to_ == connection.to_ && index_ == connection.index_;
        }
    };
 
    typedef boost::multi_index::multi_index_container<
        Connection,
        boost::multi_index::indexed_by<
            boost::multi_index::hashed_non_unique<
                boost::multi_index::tag<struct mi_presynaptic>, BOOST_MULTI_INDEX_MEMBER(Connection, size_t, from_)>,
            boost::multi_index::hashed_non_unique<
                boost::multi_index::tag<struct mi_postsynaptic>, BOOST_MULTI_INDEX_MEMBER(Connection, size_t, to_)>,
            boost::multi_index::hashed_unique<
                boost::multi_index::tag<struct mi_synapse_index>,
                BOOST_MULTI_INDEX_MEMBER(Connection, size_t, index_)>>>
        Index;
    using ByPresynaptic = mi_presynaptic;
    using ByPostsynaptic = mi_postsynaptic;
 
    mutable Index index_;
    mutable bool is_index_updated_ = false;
 
    SharedSynapseParameters shared_parameters_;
};
 
 
using AllProjections = boost::mp11::mp_transform<knp::core::Projection, knp::synapse_traits::AllSynapses>;
 
using AllProjectionsVariant = boost::mp11::mp_rename<AllProjections, std::variant>;
 
 
}  // namespace knp::core