spiking_utils.hpp

Go to the documentation of this file.

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

#ifndef CYPRESS_UTIL_SPIKING_UTILS_HPP
#define CYPRESS_UTIL_SPIKING_UTILS_HPP

#include <cypress/core/network.hpp>
#include <cypress/util/neuron_parameters.hpp>

namespace cypress {
class SpikingUtils {
public:
    template <typename T>
    static PopulationBase add_typed_population(
        Network &network, const NeuronParameter &neuronParams,
        const size_t size,
        const typename T::Signals &rec_signal =
            typename T::Signals().record_spikes())
    {
        using Parameters = typename T::Parameters;
        return network.create_population<T>(
            size, Parameters(neuronParams.parameter()), rec_signal);
    }

    template <typename T>
    static cypress::PopulationBase add_typed_population_no_record(
        Network &network, const NeuronParameter &neuronParams,
        const size_t size);

    static const NeuronType &detect_type(std::string neuron_type_str);

    static cypress::PopulationBase add_population(
        const std::string neuron_type_str, Network &network,
        const NeuronParameter &neuronParams, const size_t size,
        const std::string record_signal = "");

    static bool rerun_fixed_number_trials(Network &network, Backend &backend,
                                          Real time, size_t n_trials = 3);

    static int calc_num_spikes(const std::vector<cypress::Real> &spiketrain,
                               const cypress::Real start = 0.0,
                               const cypress::Real end = 0.0);

    template <typename T>
    static std::vector<int> calc_num_spikes_vec(
        const cypress::Matrix<T> &spiketrains, const cypress::Real start = 0.0,
        const cypress::Real end = std::numeric_limits<cypress::Real>::max())
    {
        std::vector<int> res;
        size_t rows = spiketrains.rows();
        size_t colls = spiketrains.cols();
        for (size_t i = 0; i < rows; i++) {
            int counter = 0;
            for (size_t j = 0; j < colls; j++) {
                if ((spiketrains[i * colls + j] >= start - 0.001) &&
                    (spiketrains[i * colls + j] <= end + 0.001)) {
                    counter++;
                }
            }
            res.push_back(counter);
        }
        return res;
    }

    template <typename T>
    static std::vector<T> spike_time_binning(
        const Real &start, const Real &stop, const size_t &n_bins,
        const std::vector<cypress::Real> &spike_times)
    {
        Real bin_size = (stop - start) / n_bins;
        std::vector<T> bin_counts(n_bins, 0);
        for (Real spike : spike_times) {
            if (spike >= stop || spike < start) {
                continue;
            }
            size_t bin_idx = size_t((spike - start) / bin_size);
            bin_counts[bin_idx]++;
        }
        return bin_counts;
    }

    static std::vector<Real> spike_time_binning_TTFS(
        const Real &start, const Real &stop, const size_t &n_bins,
        const std::vector<cypress::Real> &spike_times);
};
}  // namespace cypress

#endif /* CYPRESS_UTIL_SPIKING_UTILS_HPP */