network.hpp

Go to the documentation of this file.

/*
 *  Cypress -- C++ Spiking Neural Network Simulation Framework
 *  Copyright (C) 2016  Andreas Stöckel
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef CYPRESS_CORE_NETWORK_HPP
#define CYPRESS_CORE_NETWORK_HPP

#include <cypress/core/exceptions.hpp>
#include <cypress/core/network_base.hpp>
#include <cypress/core/network_base_objects.hpp>

namespace cypress {

/*
 * Forward declarations
 */
class Network;
template <typename T>
class Population;
template <typename T>
class PopulationView;
template <typename T>
class Neuron;

template <typename T>
class Population
    : public IterableMixin<Population<T>, Neuron<T>, Accessor>,
      public ViewableMixin<Population<T>, PopulationView<T>, Accessor>,
      public DataMixin<Population<T>, Accessor, typename T::Parameters,
                       typename T::Signals>,
      public PopulationMixin<Population<T>, Accessor>,
      public ConnectableMixin<Population<T>, Accessor> {
private:
    using PopulationMixin_ = PopulationMixin<Population<T>, Accessor>;
    using DataMixin_ = DataMixin<Population<T>, Accessor,
                                 typename T::Parameters, typename T::Signals>;
    using IterableMixin_ = IterableMixin<Population<T>, Neuron<T>, Accessor>;
    using ViewableMixin_ =
        ViewableMixin<Population<T>, PopulationView<T>, Accessor>;

    PopulationBase m_population;

public:
    using PopulationMixin_::size;
    using IterableMixin_::operator();
    using ViewableMixin_::operator();

    explicit Population(const PopulationBase &population)
        : m_population(population)
    {
    }

    Population(Network &network, size_t size,
               const typename T::Parameters &params = typename T::Parameters(),
               const typename T::Signals &signals = typename T::Signals(),
               const char *name = "");

    Population(Network &network, size_t size,
               const typename T::Parameters &params, const char *name)
        : Population(network, size, params, typename T::Signals(), name)
    {
    }

    operator PopulationBase() const { return m_population; }
    operator const PopulationBase &() const { return m_population; }
    operator PopulationBase &() { return m_population; }

    const NeuronType &type() const { return T::inst(); }

    Network network() const;

    PopulationIndex pid() const { return m_population.pid(); }
};

template <typename T>
class PopulationView
    : public IterableMixin<PopulationView<T>, Neuron<T>, Accessor>,
      public ViewableMixin<PopulationView<T>, PopulationView<T>, Accessor>,
      public DataMixin<PopulationView<T>, Accessor, typename T::Parameters,
                       typename T::Signals>,
      public ConnectableMixin<PopulationView<T>, Accessor> {
private:
    using IterableMixin_ =
        IterableMixin<PopulationView<T>, Neuron<T>, Accessor>;
    using ViewableMixin_ =
        ViewableMixin<PopulationView<T>, PopulationView<T>, Accessor>;

    PopulationViewBase m_view;

public:
    using IterableMixin_::operator();
    using ViewableMixin_::operator();

    PopulationView(const NetworkBase &network, PopulationIndex pid,
                   NeuronIndex nid0, NeuronIndex nid1)
        : m_view(network, pid, nid0, nid1)
    {
        if ((network.populations()[pid].size() < size_t(nid1)) ||
            (nid1 < nid0)) {
            throw CypressException(
                "2nd Neuron index " + std::to_string(nid1) +
                "is either bigger than Population size or start neuron id");
        }
    }

    operator PopulationViewBase() const { return m_view; }
    operator const PopulationViewBase &() const { return m_view; }
    operator PopulationViewBase &() { return m_view; }

    const NeuronType &type() const { return T::inst(); }

    Network network() const;

    PopulationIndex pid() const { return m_view.pid(); }

    NeuronIndex nid_begin() const { return m_view.nid_begin(); }

    NeuronIndex nid_end() const { return m_view.nid_end(); }
};

template <typename T>
class Neuron : public NeuronMixin<Neuron<T>>,
               public IterableMixin<Neuron<T>, Neuron<T>, Accessor>,
               public ViewableMixin<Neuron<T>, PopulationViewBase, Accessor>,
               public DataMixin<Neuron<T>, Accessor, typename T::Parameters,
                                typename T::Signals>,
               public ConnectableMixin<Neuron<T>, Accessor> {
private:
    using DataMixin_ = DataMixin<Neuron<T>, Accessor, typename T::Parameters,
                                 typename T::Signals>;
    using IterableMixin_ = IterableMixin<Neuron<T>, Neuron<T>, Accessor>;
    using ViewableMixin_ =
        ViewableMixin<Neuron<T>, PopulationViewBase, Accessor>;

    NeuronBase m_neuron;

public:
    using IterableMixin_::operator();
    using ViewableMixin_::operator();

    explicit Neuron(const NeuronBase &neuron) : m_neuron(neuron) {}

    template <typename Parent>
    Neuron(const Parent &parent, NeuronIndex nid)
        : m_neuron(parent, nid)
    {
    }

    operator NeuronBase() const { return m_neuron; }
    operator const NeuronBase &() const { return m_neuron; }
    operator NeuronBase &() { return m_neuron; }

    const NeuronType &type() const { return T::inst(); }

    Network network() const;

    Population<T> population() const
    {
        return Population<T>(m_neuron.network(), pid());
    }

    PopulationIndex pid() const { return m_neuron.pid(); }

    NeuronIndex nid() const { return m_neuron.nid(); }
};

namespace internal {
template <typename PopulationType>
auto resolve_population(Network &, PopulationType p);
}

class Network : public NetworkBase {
private:
    template <typename T>
    friend class Population;

    template <typename T>
    size_t create_population_index(size_t size,
                                   const typename T::Parameters &params,
                                   const typename T::Signals &signals,
                                   const std::string &name = std::string())
    {
        return NetworkBase::create_population_index(size, T::inst(), params,
                                                    signals, name);
    }

public:
    using NetworkBase::populations;
    using NetworkBase::population;

    Network() = default;
    Network(const Network &) = default;
    Network(Network &&) noexcept = default;
    Network &operator=(const Network &) = default;
    Network &operator=(Network &&) = default;
    ~Network() = default;

    Network(const NetworkBase &network) : NetworkBase(network) {}

    Network &operator=(const NetworkBase &o)
    {
        *this = Network(o);
        return *this;
    }

    template <typename T>
    std::vector<Population<T>> populations(
        const std::string &name = std::string())
    {
        std::vector<Population<T>> res;
        for (const PopulationBase &p : populations(name, T::inst())) {
            res.emplace_back(PopulationBase(*this, p.pid()));
        }
        return res;
    }

    PopulationBase population(const std::string &name = std::string())
    {
        auto pops = populations(name);
        if (pops.empty()) {
            throw NoSuchPopulationException(
                std::string("Population with name \"") + name +
                "\" does not exist");
        }
        return pops.back();
    }

    template <typename T>
    Population<T> population(const std::string &name = std::string())
    {
        auto pops = populations<T>(name);
        if (pops.empty()) {
            throw NoSuchPopulationException(
                std::string("Population of type \"") + T::inst().name +
                "\" with name \"" + name + "\" does not exist");
        }
        return pops.back();
    }

    template <typename T>
    Population<T> create_population(size_t size,
                                    const typename T::Parameters &params,
                                    const typename T::Signals &signals,
                                    const char *name = "")
    {
        return Population<T>(*this, size, params, signals, name);
    }

    template <typename T>
    Population<T> create_population(
        size_t size,
        const typename T::Parameters &params = typename T::Parameters(),
        const char *name = "")
    {
        return Population<T>(*this, size, params, name);
    }

    /*
     * One-line builder-like interface
     */

    template <typename T>
    Network &add_population(
        const char *name, size_t size, const typename T::Parameters &params,
        const typename T::Signals &signals = typename T::Signals())
    {
        create_population<T>(size, params, signals, name);
        return *this;
    }

    template <typename Source, typename Target>
    Network &add_connection(const Source &source, const Target &target,
                            std::unique_ptr<Connector> connector, const char *name = "")
    {
        internal::resolve_population(*this, source)
            .connect_to(internal::resolve_population(*this, target),
                        std::move(connector), name);
        return *this;
    }

    Network &run(const Backend &backend, Real duration = 0.0)
    {
        NetworkBase::run(backend, duration);
        return *this;
    }

    Network &run(const std::string &backend_id, Real duration = 0.0,
                 int argc = 0, const char *argv[] = nullptr)
    {
        NetworkBase::run(backend_id, duration, argc, argv);
        return *this;
    }
};

/*
 * Out-of-class function definitions.
 */

template <typename T>
inline Population<T>::Population(Network &network, size_t size,
                                 const typename T::Parameters &params,
                                 const typename T::Signals &signals,
                                 const char *name)
    : Population(PopulationBase(network, network.create_population_index<T>(
                                             size, params, signals, name)))
{
}

template <typename T>
inline Network Population<T>::network() const
{
    return Network(m_population.network());
}

template <typename T>
inline Network PopulationView<T>::network() const
{
    return Network(m_view.network());
}

template <typename T>
inline Network Neuron<T>::network() const
{
    return Network(m_neuron.network());
}

namespace internal {
template <typename PopulationType>
inline auto resolve_population(Network &, PopulationType p)
{
    return p;
}

template <>
inline auto resolve_population(Network &net, const char *str)
{
    return net.population(str);
}

template <>
inline auto resolve_population(Network &net, const std::string &str)
{
    return net.population(str);
}
}
}

#endif /* CYPRESS_CORE_NETWORK_HPP */