to_json.hpp

Go to the documentation of this file.

/*
 *  Cypress -- C++ Spiking Neural Network Simulation Framework
 *  Copyright (C) 2019 Christoph Ostrau
 *
 *  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

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

#include <thread>

namespace cypress {

class ToJson : public Backend {
protected:
    std::string m_simulator;
    Json m_setup;
    bool m_save_json = false;
    bool m_no_output = false;
    void do_run(NetworkBase &network, Real duration) const override;
    std::string m_path, m_json_path;

    Json output_json(NetworkBase &network, Real duration) const;
    void read_json(Json &result, NetworkBase &network) const;

public:
    ToJson(const std::string &simulator, const Json &setup = Json());

    ~ToJson() override;

    std::unordered_set<const NeuronType *> supported_neuron_types()
        const override;

    std::string name() const override;

    static std::vector<bool> inhom_rec_single(const PopulationBase &pop,
                                              size_t index);

    static Json inhom_rec_to_json(const PopulationBase &pop);

    static Json connector_to_json(const ConnectionDescriptor &conn);

    static Json pop_to_json(const PopulationBase &pop);

    static void hom_rec_to_json(const PopulationBase &pop, Json &json);

    static Json pop_vec_to_json(const std::vector<PopulationBase> &pops);

    static Json recs_to_json(const PopulationBase &pop);

    static void read_recordings_from_json(const Json &pop_data,
                                          NetworkBase &netw);

    static void create_pop_from_json(const Json &pop_json, Network &netw);

    static std::shared_ptr<SynapseBase> get_synapse(
        const std::string &name, const std::vector<Real> &parameters);

    static void create_conn_from_json(const Json &con_json, Network &netw);

    static NetworkBase network_from_json(std::string path);

    static void learned_weights_from_json(const Json &json, NetworkBase netw);
};

void to_json(Json &j, const Network &netw);

void from_json(const Json &j, Network &netw);

void from_json(const Json &json, NetworkRuntime &runtime);

void to_json(Json &json, const NetworkRuntime &runtime);

template <typename T>
void to_json(Json &j, const Matrix<T> &mat)
{
    /*if (mat.cols() == 1) {
        std::vector<Real> rows(mat.rows());
        for (size_t k = 0; k < mat.rows(); k++) {
            rows[k] = mat(k, 0);
        }
        j.push_back(rows);
    }
    else {*/
    for (size_t i = 0; i < mat.rows(); i++) {
        std::vector<Real> rows(mat.cols());
        for (size_t k = 0; k < mat.cols(); k++) {
            rows[k] = mat(i, k);
        }
        j.push_back(rows);
    }
    //}

    // Maybe transpose // TODO
    // std::cout << j<<std::endl;
}

template <typename T>
void from_json(const Json &j, Matrix<T> &mat)
{
    size_t rows = j.size();
    if (rows == 0) {
        return;
    }
    size_t cols = j[0].size();
    mat = Matrix<T>(rows, cols);
    for (size_t i = 0; i < rows; i++) {
        for (size_t k = 0; k < cols; k++) {
            mat(i, k) = T(j[i][k]);
        }
    }
}

}  // namespace cypress