newNeuronModels.h

Go to the documentation of this file.

#pragma once

// Standard includes
#include <array>
#include <functional>
#include <string>
#include <tuple>
#include <vector>

// GeNN includes
#include "codeGenUtils.h"
#include "neuronModels.h"
#include "newModels.h"

//----------------------------------------------------------------------------
// Macros
//----------------------------------------------------------------------------
#define SET_SIM_CODE(SIM_CODE) virtual std::string getSimCode() const override{ return SIM_CODE; }
#define SET_THRESHOLD_CONDITION_CODE(THRESHOLD_CONDITION_CODE) virtual std::string getThresholdConditionCode() const override{ return THRESHOLD_CONDITION_CODE; }
#define SET_RESET_CODE(RESET_CODE) virtual std::string getResetCode() const override{ return RESET_CODE; }
#define SET_SUPPORT_CODE(SUPPORT_CODE) virtual std::string getSupportCode() const override{ return SUPPORT_CODE; }
#define SET_EXTRA_GLOBAL_PARAMS(...) virtual StringPairVec getExtraGlobalParams() const override{ return __VA_ARGS__; }
#define SET_ADDITIONAL_INPUT_VARS(...) virtual NameTypeValVec getAdditionalInputVars() const override{ return __VA_ARGS__; }

//----------------------------------------------------------------------------
// NeuronModels::Base
//----------------------------------------------------------------------------
namespace NeuronModels
{
class Base : public NewModels::Base
{
public:
    //----------------------------------------------------------------------------
    // Declared virtuals
    //----------------------------------------------------------------------------

    virtual std::string getSimCode() const{ return ""; }


    virtual std::string getThresholdConditionCode() const{ return ""; }

    virtual std::string getResetCode() const{ return ""; }


    virtual std::string getSupportCode() const{ return ""; }

    virtual NewModels::Base::StringPairVec getExtraGlobalParams() const{ return {}; }

    virtual NewModels::Base::NameTypeValVec getAdditionalInputVars() const{ return {}; }

    virtual bool isPoisson() const{ return false; }
};

//----------------------------------------------------------------------------
// NeuronModels::LegacyWrapper
//----------------------------------------------------------------------------
class LegacyWrapper : public NewModels::LegacyWrapper<Base, neuronModel, nModels>
{
public:
    LegacyWrapper(unsigned int legacyTypeIndex) : NewModels::LegacyWrapper<Base, neuronModel, nModels>(legacyTypeIndex)
    {
    }

    //----------------------------------------------------------------------------
    // Base virtuals
    //----------------------------------------------------------------------------
    virtual std::string getSimCode() const;

    virtual std::string getThresholdConditionCode() const;

    virtual std::string getResetCode() const;

    virtual std::string getSupportCode() const;

    virtual NewModels::Base::StringPairVec getExtraGlobalParams() const;

    virtual bool isPoisson() const;
};

//----------------------------------------------------------------------------
// NeuronModels::RulkovMap
//----------------------------------------------------------------------------

class RulkovMap : public Base
{
public:
    DECLARE_MODEL(NeuronModels::RulkovMap, 4, 2);

    SET_SIM_CODE(
        "if ($(V) <= 0) {\n"
        "   $(preV)= $(V);\n"
        "   $(V)= $(ip0)/(($(Vspike)) - $(V) - ($(beta))*$(Isyn)) +($(ip1));\n"
        "}\n"
        "else {"
        "   if (($(V) < $(ip2)) && ($(preV) <= 0)) {\n"
        "       $(preV)= $(V);\n"
        "       $(V)= $(ip2);\n"
        "   }\n"
        "   else {\n"
        "       $(preV)= $(V);\n"
        "       $(V)= -($(Vspike));\n"
        "   }\n"
        "}\n");

    SET_THRESHOLD_CONDITION_CODE("$(V) >= $(ip2)");

    SET_PARAM_NAMES({"Vspike", "alpha", "y", "beta"});
    SET_VARS({{"V","scalar"}, {"preV", "scalar"}});

    SET_DERIVED_PARAMS({
        {"ip0", [](const vector<double> &pars, double){ return pars[0] * pars[0] * pars[1]; }},
        {"ip1", [](const vector<double> &pars, double){ return pars[0] * pars[2]; }},
        {"ip2", [](const vector<double> &pars, double){ return (pars[0] * pars[1]) + (pars[0] * pars[2]); }}});
};

//----------------------------------------------------------------------------
// NeuronModels::Izhikevich
//----------------------------------------------------------------------------

class Izhikevich : public Base
{
public:
    DECLARE_MODEL(NeuronModels::Izhikevich, 4, 2);

    SET_SIM_CODE(
        "if ($(V) >= 30.0){\n"
        "   $(V)=$(c);\n"
        "   $(U)+=$(d);\n"
        "} \n"
        "$(V)+=0.5*(0.04*$(V)*$(V)+5.0*$(V)+140.0-$(U)+$(Isyn))*DT; //at two times for numerical stability\n"
        "$(V)+=0.5*(0.04*$(V)*$(V)+5.0*$(V)+140.0-$(U)+$(Isyn))*DT;\n"
        "$(U)+=$(a)*($(b)*$(V)-$(U))*DT;\n"
        "if ($(V) > 30.0){   //keep this to not confuse users with unrealistiv voltage values \n"
        "  $(V)=30.0; \n"
        "}\n");

    SET_THRESHOLD_CONDITION_CODE("$(V) >= 29.99");

    SET_PARAM_NAMES({"a", "b", "c", "d"});
    SET_VARS({{"V","scalar"}, {"U", "scalar"}});
};

//----------------------------------------------------------------------------
// NeuronModels::IzhikevichVariable
//----------------------------------------------------------------------------

class IzhikevichVariable : public Izhikevich
{
public:
    DECLARE_MODEL(NeuronModels::IzhikevichVariable, 0, 6);

    SET_PARAM_NAMES({});
    SET_VARS({{"V","scalar"}, {"U", "scalar"}, {"a", "scalar"},
             {"b", "scalar"}, {"c", "scalar"}, {"d", "scalar"}});
};

//----------------------------------------------------------------------------
// NeuronModels::SpikeSource
//----------------------------------------------------------------------------

class SpikeSource : public Base
{
public:
    DECLARE_MODEL(NeuronModels::SpikeSource, 0, 0);

    SET_THRESHOLD_CONDITION_CODE("0");
};

//----------------------------------------------------------------------------
// NeuronModels::SpikeSourceArray
//----------------------------------------------------------------------------

class SpikeSourceArray : public Base
{
public:
    DECLARE_MODEL(NeuronModels::SpikeSourceArray, 0, 2);
    SET_SIM_CODE("oldSpike = false;\n")
    SET_THRESHOLD_CONDITION_CODE(
        "$(startSpike) != $(endSpike) && "
        "$(t) >= $(spikeTimes)[$(startSpike)]" );
    SET_RESET_CODE( "$(startSpike)++;\n" );
    SET_VARS( {{"startSpike", "unsigned int"}, {"endSpike", "unsigned int"}} );
    SET_EXTRA_GLOBAL_PARAMS( {{"spikeTimes", "scalar*"}} );
};

//----------------------------------------------------------------------------
// NeuronModels::Poisson
//----------------------------------------------------------------------------

class Poisson : public Base
{
public:
    DECLARE_MODEL(NeuronModels::Poisson, 4, 3);

    SET_SIM_CODE(
        "uint64_t theRnd;\n"
        "if ($(V) > $(Vrest)) {\n"
        "   $(V)= $(Vrest);\n"
        "}"
        "else if ($(t) - $(spikeTime) > ($(trefract))) {\n"
        "   MYRAND($(seed),theRnd);\n"
        "   if (theRnd < *($(rates)+$(offset)+$(id))) {\n"
        "       $(V)= $(Vspike);\n"
        "       $(spikeTime)= $(t);\n"
        "   }\n"
        "}\n");
    SET_THRESHOLD_CONDITION_CODE("$(V) >= $(Vspike)");

    SET_PARAM_NAMES({"therate", "trefract", "Vspike", "Vrest"});
    SET_VARS({{"V", "scalar"}, {"seed", "uint64_t"}, {"spikeTime", "scalar"}});
    SET_EXTRA_GLOBAL_PARAMS({{"rates", "uint64_t *"}, {"offset", "unsigned int"}});

    virtual bool isPoisson() const override{ return true; }
};

//----------------------------------------------------------------------------
// NeuronModels::PoissonNew
//----------------------------------------------------------------------------

class PoissonNew : public Base
{
public:
    DECLARE_MODEL(NeuronModels::PoissonNew, 1, 1);

    SET_SIM_CODE(
        "if($(timeStepToSpike) <= 0.0f) {\n"
        "    $(timeStepToSpike) += $(isi) * $(gennrand_exponential);\n"
        "}\n"
        "$(timeStepToSpike) -= 1.0;\n"
    );

    SET_THRESHOLD_CONDITION_CODE("$(timeStepToSpike) <= 0.0");

    SET_PARAM_NAMES({"rate"});
    SET_VARS({{"timeStepToSpike", "scalar"}});
    SET_DERIVED_PARAMS({{"isi", [](const vector<double> &pars, double dt){ return 1000.0 / (pars[0] * dt); }}});
};

//----------------------------------------------------------------------------
// NeuronModels::TraubMiles
//----------------------------------------------------------------------------

class TraubMiles : public Base
{
public:
    DECLARE_MODEL(NeuronModels::TraubMiles, 7, 4);

    SET_SIM_CODE(
        "scalar Imem;\n"
        "unsigned int mt;\n"
        "scalar mdt= DT/25.0;\n"
        "for (mt=0; mt < 25; mt++) {\n"
        "   Imem= -($(m)*$(m)*$(m)*$(h)*$(gNa)*($(V)-($(ENa)))+\n"
        "       $(n)*$(n)*$(n)*$(n)*$(gK)*($(V)-($(EK)))+\n"
        "       $(gl)*($(V)-($(El)))-$(Isyn));\n"
        "   scalar _a;\n"
        "   if (lV == -52.0) {\n"
        "       _a= 1.28;\n"
        "   }\n"
        "   else {\n"
        "       _a= 0.32*(-52.0-$(V))/(exp((-52.0-$(V))/4.0)-1.0);\n"
        "   }\n"
        "   scalar _b;\n"
        "   if (lV == -25.0) {\n"
        "       _b= 1.4;\n"
        "   }\n"
        "   else {\n"
        "       _b= 0.28*($(V)+25.0)/(exp(($(V)+25.0)/5.0)-1.0);\n"
        "   }\n"
        "   $(m)+= (_a*(1.0-$(m))-_b*$(m))*mdt;\n"
        "   _a= 0.128*exp((-48.0-$(V))/18.0);\n"
        "   _b= 4.0 / (exp((-25.0-$(V))/5.0)+1.0);\n"
        "   $(h)+= (_a*(1.0-$(h))-_b*$(h))*mdt;\n"
        "   if (lV == -50.0) {\n"
        "       _a= 0.16;\n"
        "   }\n"
        "   else {\n"
        "       _a= 0.032*(-50.0-$(V))/(exp((-50.0-$(V))/5.0)-1.0);\n"
        "   }\n"
        "   _b= 0.5*exp((-55.0-$(V))/40.0);\n"
        "   $(n)+= (_a*(1.0-$(n))-_b*$(n))*mdt;\n"
        "   $(V)+= Imem/$(C)*mdt;\n"
        "}\n");

    SET_THRESHOLD_CONDITION_CODE("$(V) >= 0.0");

    SET_PARAM_NAMES({"gNa", "ENa", "gK", "EK", "gl", "El", "C"});
    SET_VARS({{"V", "scalar"}, {"m", "scalar"}, {"h", "scalar"}, {"n", "scalar"}});
};

//----------------------------------------------------------------------------
// NeuronModels::TraubMilesFast
//----------------------------------------------------------------------------

class TraubMilesFast : public TraubMiles
{
public:
    DECLARE_MODEL(NeuronModels::TraubMilesFast, 7, 4);

    SET_SIM_CODE(
        "scalar Imem;\n"
        "unsigned int mt;\n"
        "scalar mdt= DT/25.0;\n"
        "for (mt=0; mt < 25; mt++) {\n"
        "   Imem= -($(m)*$(m)*$(m)*$(h)*$(gNa)*($(V)-($(ENa)))+\n"
        "       $(n)*$(n)*$(n)*$(n)*$(gK)*($(V)-($(EK)))+\n"
        "       $(gl)*($(V)-($(El)))-$(Isyn));\n"
        "   scalar _a= 0.32*(-52.0-$(V))/(exp((-52.0-$(V))/4.0)-1.0);\n"
        "   scalar _b= 0.28*($(V)+25.0)/(exp(($(V)+25.0)/5.0)-1.0);\n"
        "   $(m)+= (_a*(1.0-$(m))-_b*$(m))*mdt;\n"
        "   _a= 0.128*exp((-48.0-$(V))/18.0);\n"
        "   _b= 4.0 / (exp((-25.0-$(V))/5.0)+1.0);\n"
        "   $(h)+= (_a*(1.0-$(h))-_b*$(h))*mdt;\n"
        "   _a= 0.032*(-50.0-$(V))/(exp((-50.0-$(V))/5.0)-1.0);\n"
        "   _b= 0.5*exp((-55.0-$(V))/40.0);\n"
        "   $(n)+= (_a*(1.0-$(n))-_b*$(n))*mdt;\n"
        "   $(V)+= Imem/$(C)*mdt;\n"
        "}\n");
};

//----------------------------------------------------------------------------
// NeuronModels::TraubMilesAlt
//----------------------------------------------------------------------------

class TraubMilesAlt : public TraubMiles
{
public:
    DECLARE_MODEL(NeuronModels::TraubMilesAlt, 7, 4);

    SET_SIM_CODE(
        "scalar Imem;\n"
        "unsigned int mt;\n"
        "scalar mdt= DT/25.0;\n"
        "for (mt=0; mt < 25; mt++) {\n"
        "   Imem= -($(m)*$(m)*$(m)*$(h)*$(gNa)*($(V)-($(ENa)))+\n"
        "       $(n)*$(n)*$(n)*$(n)*$(gK)*($(V)-($(EK)))+\n"
        "       $(gl)*($(V)-($(El)))-$(Isyn));\n"
        "   scalar volatile _tmp= abs(exp((-52.0-$(V))/4.0)-1.0);\n"
        "   scalar _a= 0.32*abs(-52.0-$(V))/(_tmp+SCALAR_MIN);\n"
        "   _tmp= abs(exp(($(V)+25.0)/5.0)-1.0);\n"
        "   scalar _b= 0.28*abs($(V)+25.0)/(_tmp+SCALAR_MIN);\n"
        "   $(m)+= (_a*(1.0-$(m))-_b*$(m))*mdt;\n"
        "   _a= 0.128*exp((-48.0-$(V))/18.0);\n"
        "   _b= 4.0 / (exp((-25.0-$(V))/5.0)+1.0);\n"
        "   $(h)+= (_a*(1.0-$(h))-_b*$(h))*mdt;\n"
        "   _tmp= abs(exp((-50.0-$(V))/5.0)-1.0);\n"
        "   _a= 0.032*abs(-50.0-$(V))/(_tmp+SCALAR_MIN);\n"
        "   _b= 0.5*exp((-55.0-$(V))/40.0);\n"
        "   $(n)+= (_a*(1.0-$(n))-_b*$(n))*mdt;\n"
        "   $(V)+= Imem/$(C)*mdt;\n"
        "}\n");
};

//----------------------------------------------------------------------------
// NeuronModels::TraubMilesNStep
//----------------------------------------------------------------------------

class TraubMilesNStep : public TraubMiles
{
public:
    DECLARE_MODEL(NeuronModels::TraubMilesNStep, 8, 4);

    SET_SIM_CODE(
        "scalar Imem;\n"
        "unsigned int mt;\n"
        "scalar mdt= DT/scalar($(ntimes));\n"
        "for (mt=0; mt < $(ntimes); mt++) {\n"
        "   Imem= -($(m)*$(m)*$(m)*$(h)*$(gNa)*($(V)-($(ENa)))+\n"
        "       $(n)*$(n)*$(n)*$(n)*$(gK)*($(V)-($(EK)))+\n"
        "       $(gl)*($(V)-($(El)))-$(Isyn));\n"
        "   scalar _a;\n"
        "   if (lV == -52.0) {\n"
        "       _a= 1.28;\n"
        "   }\n"
        "   else {\n"
        "       _a= 0.32*(-52.0-$(V))/(exp((-52.0-$(V))/4.0)-1.0);\n"
        "   }\n"
        "   scalar _b;\n"
        "   if (lV == -25.0) {\n"
        "       _b= 1.4;\n"
        "   }\n"
        "   else {\n"
        "       _b= 0.28*($(V)+25.0)/(exp(($(V)+25.0)/5.0)-1.0);\n"
        "   }\n"
        "   $(m)+= (_a*(1.0-$(m))-_b*$(m))*mdt;\n"
        "   _a= 0.128*exp((-48.0-$(V))/18.0);\n"
        "   _b= 4.0 / (exp((-25.0-$(V))/5.0)+1.0);\n"
        "   $(h)+= (_a*(1.0-$(h))-_b*$(h))*mdt;\n"
        "   if (lV == -50.0) {\n"
        "       _a= 0.16;\n"
        "   }\n"
        "   else {\n"
        "       _a= 0.032*(-50.0-$(V))/(exp((-50.0-$(V))/5.0)-1.0);\n"
        "   }\n"
        "   _b= 0.5*exp((-55.0-$(V))/40.0);\n"
        "   $(n)+= (_a*(1.0-$(n))-_b*$(n))*mdt;\n"
        "   $(V)+= Imem/$(C)*mdt;\n"
        "}\n");

    SET_PARAM_NAMES({"gNa", "ENa", "gK", "EK", "gl", "El", "C", "ntimes"});
};
} // NeuronModels