neurons_base.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_NEURONS_BASE_HPP
#define CYPRESS_CORE_NEURONS_BASE_HPP

#include <cstdint>
#include <memory>
#include <string>
#include <vector>

#include <cypress/core/data.hpp>
#include <cypress/core/exceptions.hpp>
#include <cypress/core/types.hpp>
#include <cypress/util/matrix.hpp>
#include <cypress/util/optional.hpp>

namespace cypress {

class NullNeuron;
class NullNeuronParameters;
class NullNeuronSignals;

class NeuronType {
protected:
    NeuronType(const std::string &name,
               const std::vector<std::string> &parameter_names,
               const std::vector<std::string> &parameter_units,
               const std::vector<Real> &parameter_defaults,
               const std::vector<std::string> &signal_names,
               const std::vector<std::string> &signal_units,
               bool conductance_based, bool spike_source)
        : name(name),
          parameter_names(parameter_names),
          parameter_units(parameter_units),
          parameter_defaults(parameter_defaults),
          signal_names(signal_names),
          signal_units(signal_units),
          conductance_based(conductance_based),
          spike_source(spike_source)
    {
    }

public:
    NeuronType(const NeuronType &) = delete;
    NeuronType(NeuronType &&) = delete;
    NeuronType &operator=(const NeuronType &) = delete;
    NeuronType &operator=(NeuronType &&) = delete;

    const std::string name;

    const std::vector<std::string> parameter_names;

    const std::vector<std::string> parameter_units;

    const std::vector<Real> parameter_defaults;

    const std::vector<std::string> signal_names;

    const std::vector<std::string> signal_units;

    const bool conductance_based;

    const bool spike_source;

    Optional<size_t> parameter_index(const std::string &name) const;

    Optional<size_t> signal_index(const std::string &name) const;
};

template <typename Parameters_, typename Signals_>
class NeuronTypeBase : public NeuronType {
public:
    using Parameters = Parameters_;
    using Signals = Signals_;

    using NeuronType::NeuronType;
};

class NeuronParameters : public PopulationDataView {
protected:
    NeuronParameters(std::initializer_list<Real> parameters)
    {
        for (auto &p : write_parameters()) {
            p = std::vector<Real>(parameters);
        }
    }

    NeuronParameters(const std::vector<Real> &parameters)
    {
        for (auto &p : write_parameters()) {
            p = parameters;
        }
    }

public:
    NeuronParameters(std::shared_ptr<PopulationData> data, NeuronIndex nid0,
                     NeuronIndex nid1)
        : PopulationDataView(std::move(data), nid0, nid1, true, false, false)
    {
    }

    const std::vector<Real> &parameters() const { return read_parameters(); }

    void parameters(std::vector<Real> parameters)
    {
        for (auto &p : write_parameters()) {
            p = parameters;
        }
    }

    void set(size_t idx, Real value)
    {
        for (auto &p : write_parameters()) {
            p[idx] = value;
        }
    }

    Real operator[](size_t i) const { return read_parameters()[i]; }

    const Real *begin() const { return &read_parameters().front(); }

    const Real *end() const { return &read_parameters().back() + 1; }

    size_t size() const { return get_parameters_size(); }
};

template <typename Impl, typename Type_>
class NeuronParametersBase : public NeuronParameters {
public:
    using Type = Type_;

    using NeuronParameters::NeuronParameters;

    NeuronParametersBase() : NeuronParameters(Type::inst().parameter_defaults)
    {
    }

    NeuronParametersBase(std::initializer_list<Impl> list)
        : NeuronParameters(PopulationDataView::from_sequence(list))
    {
    }
    
    NeuronParametersBase(std::vector<Impl> list)
        : NeuronParameters(PopulationDataView::from_sequence(list))
    {
    }
};

template <typename Impl, typename Type, size_t Size>
class ConstantSizeNeuronParametersBase
    : public NeuronParametersBase<Impl, Type> {
public:
    using NeuronParametersBase<Impl, Type>::NeuronParametersBase;

    ConstantSizeNeuronParametersBase() = default;

    ConstantSizeNeuronParametersBase(const std::vector<Real> &parameters)
        : NeuronParametersBase<Impl, Type>(parameters)
    {
        if (parameters.size() != Size) {
            throw InvalidParameterArraySize(
                "Number of parameters in the parameter vector does not match "
                "the number of parameters.");
        }
    }

    static constexpr size_t size() { return Size; }
};

class NeuronSignals : public PopulationDataView {
protected:
    NeuronSignals(size_t signal_count)
    {
        for (auto &p : write_record()) {
            p.resize(signal_count);
        }
        for (auto &p : write_data()) {
            p.resize(signal_count);
        }
    }

public:
    NeuronSignals(std::shared_ptr<PopulationData> data, NeuronIndex nid0,
                  NeuronIndex nid1)
        : PopulationDataView(std::move(data), nid0, nid1, false, true, true)
    {
    }

    void record(size_t i, bool record = true)
    {
        for (auto &p : write_record()) {
            p[i] = record;
        }
    }

    bool is_recording(size_t i) const { return read_record()[i]; }

    void data(size_t i, std::shared_ptr<Matrix<Real>> matrix)
    {
        for (auto &p : write_data()) {
            p[i] = matrix;
        }
    }

    std::shared_ptr<Matrix<Real>> data_ptr(size_t i) const
    {
        static std::shared_ptr<Matrix<Real>> empty =
            std::make_shared<Matrix<Real>>();
        auto res = const_cast<NeuronSignals *>(this)->read_data()[i];
        if (!res) {
            if (!is_recording(i)) {
                throw SignalNotRecordedException();
            }
            return empty;
        }
        return res;
    }

    const Matrix<Real> &data(size_t i) const { return *data_ptr(i); }

    size_t size() const { return get_record_size(); }
};

template <class Impl, class Type_, size_t Size>
class NeuronSignalsBase : public NeuronSignals {
public:
    using Type = Type_;

    using NeuronSignals::NeuronSignals;

    NeuronSignalsBase() : NeuronSignals(Size) {}

    NeuronSignalsBase(std::initializer_list<std::string> record_signal_names)
        : NeuronSignalsBase()
    {
        for (auto &signal : record_signal_names) {
            auto idx = Type::inst().signal_index(signal);
            if (!idx.valid()) {
                throw InvalidSignal(std::string("Signal with name \"") +
                                    signal + "\" does not exist.");
            }
            record(idx.value());
        }
    }

    static constexpr size_t size() { return Size; }
};

/*
 * NullNeuron
 */
class NullNeuronParameters;
class NullNeuronSignals;

class NullNeuron final
    : public NeuronTypeBase<NullNeuronParameters, NullNeuronSignals> {
private:
    NullNeuron();

public:
    static const NullNeuron &inst();
};

class NullNeuronParameters final
    : public ConstantSizeNeuronParametersBase<NullNeuronParameters, NullNeuron,
                                              0> {
public:
    using ConstantSizeNeuronParametersBase<NullNeuronParameters, NullNeuron,
                                           0>::ConstantSizeNeuronParametersBase;
};

class NullNeuronSignals final
    : public NeuronSignalsBase<NullNeuronSignals, NullNeuron, 0> {
public:
    using NeuronSignalsBase<NullNeuronSignals, NullNeuron,
                            0>::NeuronSignalsBase;
};
}  // namespace cypress

#endif /* CYPRESS_CORE_NEURONS_BASE_HPP */