synapseModels.h

Go to the documentation of this file.

#ifndef SYNAPSEMODELS_H
#define SYNAPSEMODELS_H

#include "dpclass.h"

#include <string>
#include <vector>

using namespace std;


class weightUpdateModel
{
public:
    string simCode; 
    string simCodeEvnt; 
    string simLearnPost; 
    string evntThreshold; 
    string synapseDynamics; 
    string simCode_supportCode; 
    string simLearnPost_supportCode; 
    string synapseDynamics_supportCode; 
    vector<string> varNames; 
    vector<string> varTypes; 
    vector<string> pNames; 
    vector<string> dpNames; 
    vector<string> extraGlobalSynapseKernelParameters; 
    vector<string> extraGlobalSynapseKernelParameterTypes; 
    dpclass *dps;
    bool needPreSt; 
    bool needPostSt; 

    weightUpdateModel(); 
    ~weightUpdateModel(); 
};


// Synapse Types
extern vector<weightUpdateModel> weightUpdateModels; 
extern unsigned int NSYNAPSE; 
extern unsigned int NGRADSYNAPSE; 
extern unsigned int LEARN1SYNAPSE; 
const unsigned int SYNTYPENO = 4; // maximum number of synapse types: SpineML needs to know this


//--------------------------------------------------------------------------
//--------------------------------------------------------------------------

class pwSTDP : public dpclass 
{
public:
    double calculateDerivedParameter(int index, vector<double> pars, double = 1.0) {
        switch (index) {
        case 0:
            return lim0(pars);
        case 1:
            return lim1(pars);
        case 2:
            return slope0(pars);
        case 3:
            return slope1(pars);
        case 4:
            return off0(pars);
        case 5:
            return off1(pars);
        case 6:
            return off2(pars);
        }
        return -1;
    }

private:
    double lim0(const vector<double> &pars) {
        return (1/pars[4] + 1/pars[1]) * pars[0] / (2/pars[1]);
    }

    double lim1(const vector<double> &pars) {
        return -((1/pars[3] + 1/pars[1]) * pars[0] / (2/pars[1]));
    }

    double slope0(const vector<double> &pars) {
        return -2*pars[5]/(pars[1]*pars[0]);
    }

    double slope1(const vector<double> &pars) {
        return -1*slope0(pars);
    }

    double off0(const vector<double> &pars) {
        return pars[5]/pars[4];
    }

    double off1(const vector<double> &pars) {
        return pars[5]/pars[1];
    }

    double off2(const vector<double> &pars) {
        return pars[5]/pars[3];
    }
};


//--------------------------------------------------------------------------
//--------------------------------------------------------------------------

void prepareWeightUpdateModels();

#endif // SYNAPSEMODELS_H