pynn.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_BACKEND_PYNN2_HPP
#define CYPRESS_BACKEND_PYNN2_HPP

// Include first to avoid "_POSIX_C_SOURCE redefined" warning
#include <pybind11/pybind11.h>

#include <pybind11/embed.h>

#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

#include <cypress/backend/pynn/pynn.hpp>
#include <cypress/core/backend.hpp>
#include <cypress/core/network_base_objects.hpp>
#include <cypress/util/json.hpp>

namespace cypress {
namespace py = pybind11;

class PythonInstance {
private:
    PythonInstance();

public:
    PythonInstance(PythonInstance const &) = delete;
    void operator=(PythonInstance const &) = delete;
    static PythonInstance &instance()
    {
        static PythonInstance instance;
        return instance;
    }

private:
    ~PythonInstance();
};

class PyNN : public Backend {
protected:
    std::string m_simulator;
    std::string m_normalised_simulator;
    std::vector<std::string> m_imports;
    bool m_keep_log;
    Json m_setup;
    void do_run(NetworkBase &network, Real duration) const override;

public:
    class PyNNSimulatorNotFound : public std::runtime_error {
    public:
        using std::runtime_error::runtime_error;
    };
    PyNN(const std::string &simulator, const Json &setup = Json());

    ~PyNN() override;
    
    Real timestep();
    
    std::unordered_set<const NeuronType *> supported_neuron_types()
        const override;
        
    std::string name() const override { return m_normalised_simulator; }

    const std::string &simulator() const { return m_simulator; }

    const std::string &normalised_simulator() const
    {
        return m_normalised_simulator;
    }
    
    const std::vector<std::string> &imports() const { return m_imports; }

    std::string nmpi_platform() const;
    
    static std::vector<std::string> simulators();

    static std::string get_import(const std::vector<std::string> &imports,
                                  const std::string &simulator);
    Json setup() const { return m_setup; }

    static int get_pynn_version();

    static int get_neo_version();

    static py::dict json_to_dict(Json json);

    static std::string get_neuron_class(const NeuronType &neuron_type);

    static void init_logger();

    static py::object create_source_population(const PopulationBase &pop,
                                               py::module &pynn);
    static py::object create_homogeneous_pop(const PopulationBase &pop,
                                             py::module &pynn,
                                             bool &init_available);

    static void set_inhomogeneous_parameters(const PopulationBase &pop,
                                             py::object &pypop,
                                             bool init_available = false);

    static void set_homogeneous_rec(const PopulationBase &pop,
                                    py::object &pypop);

    static void set_inhomogenous_rec(const PopulationBase &pop,
                                     py::object &pypop, py::module &pynn);

    static py::object get_pop_view(const py::module &pynn,
                                   const py::object &py_pop,
                                   const PopulationBase &c_pop,
                                   const size_t &start, const size_t &end);

    static py::object get_connector7(const ConnectionDescriptor &conn,
                                     const py::module &pynn);

    static py::object get_connector(const std::string &connector_name,
                                    const py::module &pynn,
                                    const Real &additional_parameter,
                                    const bool allow_self_connections);

    static py::object group_connect(
        const std::vector<PopulationBase> &populations,
        const std::vector<py::object> &pypopulations,
        const ConnectionDescriptor &conn, const py::module &pynn,
        const bool nest_flag, const Real timestep = 0.0);

    static py::object group_connect(
        const std::vector<PopulationBase> &populations,
        const std::vector<py::object> &pypopulations,
        const ConnectionDescriptor &conn, const py::module &pynn,
        const Real nest_flag) = delete;
    static py::object group_connect7(
        const std::vector<PopulationBase> &populations,
        const std::vector<py::object> &pypopulations,
        const ConnectionDescriptor &conn, const py::module &pynn);

    static std::tuple<py::object, py::object> list_connect(
        const std::vector<py::object> &pypopulations,
        const ConnectionDescriptor conn, const py::module &pynn,
        const bool current_based, const Real timestep = 0.0);

    static std::tuple<py::object, py::object> list_connect(
        const std::vector<py::object> &pypopulations,
        const ConnectionDescriptor conn, const py::module &pynn,
        const Real current_based) = delete;

    static std::tuple<py::object, py::object> list_connect7(
        const std::vector<py::object> &pypopulations,
        const ConnectionDescriptor conn, const py::module &pynn);

    template <typename T>
    static Matrix<T> matrix_from_numpy(const py::object &object,
                                       bool transposed = false);

    static void fetch_data_nest(const std::vector<PopulationBase> &populations,
                                const std::vector<py::object> &pypopulations);

    static void fetch_data_spinnaker(
        const std::vector<PopulationBase> &populations,
        const std::vector<py::object> &pypopulations);

    static void fetch_data_neo(const std::vector<PopulationBase> &populations,
                               const std::vector<py::object> &pypopulations);

    // ______________ Spikey related part _______________________

    static void spikey_run(NetworkBase &source, Real duration, py::module &pynn,
                           py::dict dict);

    static py::object spikey_create_source_population(const PopulationBase &pop,
                                                      py::module &pynn);

    static py::object spikey_create_homogeneous_pop(const PopulationBase &pop,
                                                    py::module &pynn);

    static void spikey_set_homogeneous_rec(const PopulationBase &pop,
                                           py::object &pypop, py::module &pynn);

    static void spikey_set_inhomogeneous_rec(const PopulationBase &pop,
                                             py::object &pypop,
                                             py::module pynn);

    static void spikey_set_inhomogeneous_parameters(const PopulationBase &pop,
                                                    py::object &pypop);

    static void spikey_get_spikes(PopulationBase pop, py::object &pypop);
    static void spikey_get_voltage(NeuronBase neuron, py::module &pynn);
};
}  // namespace cypress

#endif /* CYPRESS_BACKEND_PYNN_HPP */