network.h

Go to the documentation of this file.

 
#pragma once
 
#include <knp/core/backend.h>
#include <knp/core/core.h>
#include <knp/core/impexp.h>
#include <knp/core/population.h>
#include <knp/core/projection.h>
#include <knp/framework/coordinates/generator.h>
#include <knp/framework/projection/connectors.h>
#include <knp/framework/projection/synapse_parameters_generators.h>
#include <knp/neuron-traits/all_traits.h>
#include <knp/synapse-traits/all_traits.h>
 
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
 
namespace knp::framework
{
 
class KNP_DECLSPEC Network
{
public:
    using AllPopulations = boost::mp11::mp_transform<knp::core::Population, knp::neuron_traits::AllNeurons>;
 
    using AllProjections = boost::mp11::mp_transform<knp::core::Projection, knp::synapse_traits::AllSynapses>;
 
    using AllPopulationVariants = boost::mp11::mp_rename<AllPopulations, std::variant>;
    using AllProjectionVariants = boost::mp11::mp_rename<AllProjections, std::variant>;
 
public:
    using PopulationContainer = std::vector<core::AllPopulationsVariant>;
    using ProjectionContainer = std::vector<core::AllProjectionsVariant>;
 
    using PopulationIterator = PopulationContainer::iterator;
    using PopulationConstIterator = PopulationContainer::const_iterator;
 
    using ProjectionIterator = ProjectionContainer::iterator;
    using ProjectionConstIterator = ProjectionContainer::const_iterator;
 
public:
    Network() = default;
 
    explicit Network(const core::UID &uid) : base_({uid, {}}) {}
 
public:
    void add_population(core::AllPopulationsVariant &&population);
    template <typename PopulationType>
    void add_population(typename std::decay<PopulationType>::type &&population);
    template <typename PopulationType>
    void add_population(typename std::decay<PopulationType>::type &population);
 
    [[nodiscard]] bool is_population_exists(const knp::core::UID &population_uid) const;
 
    template <typename NeuronType>
    [[nodiscard]] knp::core::Population<NeuronType> &get_population(const knp::core::UID &population_uid);
 
    template <typename NeuronType>
    [[nodiscard]] const knp::core::Population<NeuronType> &get_population(const knp::core::UID &population_uid) const;
 
    [[nodiscard]] core::AllPopulationsVariant &get_population(const knp::core::UID &population_uid);
 
    void remove_population(const knp::core::UID &population_uid);
 
public:
    void add_projection(core::AllProjectionsVariant &&projection);
    template <typename ProjectionType>
    void add_projection(typename std::decay<ProjectionType>::type &&projection);
    template <typename ProjectionType>
    void add_projection(typename std::decay<ProjectionType>::type &projection);
    template <typename SynapseType>
    void add_projection(
        knp::core::UID projection_uid, knp::core::UID pre_population_uid, knp::core::UID post_population_uid,
        typename knp::core::Projection<SynapseType>::SynapseGenerator generator, size_t synapse_count);
 
    [[nodiscard]] bool is_projection_exists(const knp::core::UID &projection_uid) const;
 
    template <typename SynapseType>
    [[nodiscard]] knp::core::Projection<SynapseType> &get_projection(const knp::core::UID &projection_uid);
    template <typename SynapseType>
    [[nodiscard]] const knp::core::Projection<SynapseType> &get_projection(const knp::core::UID &projection_uid) const;
    [[nodiscard]] core::AllProjectionsVariant &get_projection(const knp::core::UID &projection_uid);
    void remove_projection(const knp::core::UID &projection_uid);
 
public:
    template <typename SynapseType, typename SourceNeuronType, typename DestinationNeuronType>
    knp::core::UID connect_populations(
        const core::Population<SourceNeuronType> &src, const core::Population<DestinationNeuronType> &dst,
        typename projection::parameters_generators::SynGen2ParamsType<SynapseType> syn_gen =
            projection::parameters_generators::default_synapse_gen<SynapseType>)
    {
        const auto &[src_uid, dst_uid] = get_populations_uid(src, dst);
        auto new_proj =
            projection::connect_populations<SynapseType, SourceNeuronType, DestinationNeuronType>(src, dst, syn_gen);
        const auto proj_uid = new_proj.get_uid();
 
        add_projection(std::move(new_proj));
 
        return proj_uid;
    }
 
    template <typename SynapseType, typename SourceNeuronType, typename DestinationNeuronType>
    knp::core::UID connect_populations(
        const core::Population<SourceNeuronType> &src, const core::Population<DestinationNeuronType> &dst,
        typename knp::core::Projection<SynapseType>::SynapseGenerator syn_gen, size_t num_iterations)
    {
        const auto &[src_uid, dst_uid] = get_populations_uid(src, dst);
        auto new_proj = projection::connect_populations<SynapseType, SourceNeuronType, DestinationNeuronType>(
            src, dst, syn_gen, num_iterations);
        const auto proj_uid = new_proj.get_uid();
 
        add_projection(std::move(new_proj));
 
        return proj_uid;
    }
 
public:
    [[nodiscard]] PopulationIterator begin_populations();
    [[nodiscard]] PopulationConstIterator begin_populations() const;
    [[nodiscard]] PopulationIterator end_populations();
    [[nodiscard]] PopulationConstIterator end_populations() const;
    [[nodiscard]] ProjectionIterator begin_projections();
    [[nodiscard]] ProjectionConstIterator begin_projections() const;
    [[nodiscard]] ProjectionIterator end_projections();
    [[nodiscard]] ProjectionConstIterator end_projections() const;
 
public:
    [[nodiscard]] const PopulationContainer &get_populations() const { return populations_; }
    [[nodiscard]] const ProjectionContainer &get_projections() const { return projections_; }
 
public:
    [[nodiscard]] size_t populations_count() const { return populations_.size(); }
    [[nodiscard]] size_t projections_count() const { return projections_.size(); }
 
public:
    [[nodiscard]] const knp::core::UID &get_uid() const { return base_.uid_; }
 
    [[nodiscard]] auto &get_tags() { return base_.tags_; }
 
private:
    template <typename SourceNeuronType, typename DestinationNeuronType>
    [[nodiscard]] std::tuple<core::UID, core::UID> get_populations_uid(
        const core::Population<SourceNeuronType> &src, const core::Population<DestinationNeuronType> &dst) const
    {
        const auto src_uid = src.get_uid();
        if (!is_population_exists(src_uid))
        {
            throw std::logic_error("Source population with UID = " + std::string(src_uid) + " doesn't exist.");
        }
 
        const auto dst_uid = dst.get_uid();
        if (!is_population_exists(dst_uid))
        {
            throw std::logic_error("Source population with UID = " + std::string(dst_uid) + " doesn't exist.");
        }
 
        return std::make_tuple(src_uid, dst_uid);
    }
 
    template <typename PopulationType>
    void check_population_constraints(const PopulationType &population) const;
    template <typename ProjectionType>
    void check_projection_constraints(const ProjectionType &projection) const;
 
private:
    knp::core::BaseData base_;
    PopulationContainer populations_;
    ProjectionContainer projections_;
};
 
 
}  // namespace knp::framework