modelSpec.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------
   Author: Thomas Nowotny
  
   Institute: Center for Computational Neuroscience and Robotics
              University of Sussex
              Falmer, Brighton BN1 9QJ, UK 
  
   email to:  T.Nowotny@sussex.ac.uk
  
   initial version: 2010-02-07
   
   This file contains neuron model declarations.
  
--------------------------------------------------------------------------*/

#ifndef _MODELSPEC_H_
#define _MODELSPEC_H_ 

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

#include <vector>
#include "global.h"


//neuronType
#define MAPNEURON 0 
#define POISSONNEURON 1 
#define TRAUBMILES 2 
#define IZHIKEVICH 3 
#define IZHIKEVICH_V 4 
#define MAXNRN 5 // maximum number of neuron types: SpineML needs to know this

#define SYNTYPENO 4

//synapseType
#define NSYNAPSE 0 
#define NGRADSYNAPSE 1 
#define LEARN1SYNAPSE 2 
#define USERDEFSYNAPSE 3 

//input type
#define NOINP 0 
#define CONSTINP 1 
#define MATINP 2 
#define INPRULE 3 
#define RANDNINP 4 

unsigned int SYNPNO[SYNTYPENO]= {
  3,        // NSYNAPSE_PNO 
  4,        // NGRADSYNAPSE_PNO 
  13,       // LEARN1SYNAPSE_PNO 
  1                     // USERDEFSYNAPSE_PNO 
}; 

//connectivity of the network (synapseConnType)
#define ALLTOALL 0  
#define DENSE 1 
#define SPARSE 2

//conductance type (synapseGType)
#define INDIVIDUALG 0  
#define GLOBALG 1 
#define INDIVIDUALID 2 

#define NO_DELAY 1 

#define NOLEARNING 0 
#define LEARNING 1 

#define EXITSYN 0 
#define INHIBSYN 1 

#define TRUE 1 
#define FALSE 0 

#define CPU 0 
#define GPU 1 

#define FLOAT 0  
#define DOUBLE 1  

#define AUTODEVICE -1  

// for purposes of STDP
#define SPK_THRESH_STDP 0.0f 
//#define MAXSPKCNT 50000

//postsynaptic parameters
#define EXPDECAY 0 //default - how it is in the original version
#define IZHIKEVICH_PS 1 //empty postsynaptic rule for the Izhikevich model.
// currently values >1 will be defined by code generation.
#define MAXPOSTSYN 2 // maximum number of postsynaptic integration: SpineML needs to know this

class dpclass {
public:
  dpclass() {}  
  virtual float calculateDerivedParameter(int index, vector < float > pars, float dt = 1.0) {return -1;}
};


struct neuronModel
{
  string simCode; 
  string thresholdConditionCode; 
  string resetCode; 
  vector<string> varNames; 
  vector<string> tmpVarNames; 
  vector<string> varTypes; 
  vector<string> tmpVarTypes; 
  vector<string> pNames; 
  vector<string> dpNames; 
  vector<string> extraGlobalNeuronKernelParameters; 

  vector<string> extraGlobalNeuronKernelParameterTypes; 
  dpclass * dps;
};


struct postSynModel
{
  string postSyntoCurrent;
  string postSynDecay;
  vector<string> varNames; 
  vector<string> varTypes; 
  vector<string> pNames; 
  vector<string> dpNames; 
  dpclass * dps;
};


/*===============================================================
//
================================================================*/

class NNmodel
{

public:

  // PUBLIC MODEL VARIABLES
  //========================

  string name; 
  string ftype; 
  int valid; 
  unsigned int needSt; 
  unsigned int needSynapseDelay; 
  int chooseGPUDevice;

  // PUBLIC NEURON VARIABLES
  //========================

  vector<string> neuronName; 
  unsigned int neuronGrpN; 
  vector<unsigned int> neuronN; 
  vector<unsigned int> sumNeuronN; 
  vector<unsigned int> padSumNeuronN; 
  vector<unsigned int> neuronPostSyn; 
  vector<unsigned int> neuronType; 
  vector<vector<float> > neuronPara; 
  vector<vector<float> > dnp; 
  vector<vector<float> > neuronIni; 
  vector<vector<unsigned int> > inSyn; 
  vector<int> receivesInputCurrent; 
  vector<unsigned int> neuronNeedSt; 
  vector<unsigned int> neuronDelaySlots; 
  vector<int> neuronHostID; 
  vector<int> neuronDeviceID; 

  //NB: This is not directly user controlled, but is decided by, for example,
  //the pre-spike threshold set for outgoing synapses
  vector<float> nSpkEvntThreshold;


  // PUBLIC SYNAPSE VARIABLES
  //=========================

  vector<string> synapseName; 
  unsigned int synapseGrpN; 
  //vector<unsigned int>synapseNo; // !<numnber of synapses in a synapse group
  vector<unsigned int> sumSynapseTrgN; 
  vector<unsigned int> padSumSynapseTrgN; 
  vector<unsigned int> maxConn; 
  vector<unsigned int> padSumSynapseKrnl; //Combination of padSumSynapseTrgN and padSumMaxConn to support both sparse and all-to-all connectivity in a model
  vector<unsigned int> synapseType; 
  vector<unsigned int> synapseConnType; 
  vector<unsigned int> synapseGType; 
  vector<unsigned int> synapseSource; 
  vector<unsigned int> synapseTarget; 
  vector<unsigned int> synapseInSynNo; 
  vector<vector<float> > synapsePara; 
  vector<vector<float> > dsp;  
  vector<unsigned int> postSynapseType; 
  vector<vector<float> > postSynapsePara; 
  vector<vector<float> > postSynIni; 
  vector<vector<float> > dpsp;  
  vector<float> g0; 
  vector<float> globalInp; 
  unsigned int lrnGroups; 
  vector<unsigned int> padSumLearnN; 
  vector<unsigned int> lrnSynGrp; 
  vector<unsigned int> synapseDelay; 
  vector<int> synapseHostID; 
  vector<int> synapseDeviceID; 

    
private:

  // PRIVATE NEURON FUNCTIONS
  //=========================

  void setNeuronName(unsigned int, const string); 
  void setNeuronN(unsigned int, unsigned int); 
  void setNeuronType(unsigned int, unsigned int); 
  void setNeuronPara(unsigned int, float*); 
  void setNeuronIni(unsigned int, float*); 
  unsigned int findNeuronGrp(const string); 
  void initDerivedNeuronPara(unsigned int); 
  void initNeuronSpecs(unsigned int); 


  // PRIVATE SYNAPSE FUNCTIONS
  //==========================

  void setSynapseName(unsigned int, const string); 
  void setSynapseType(unsigned int, unsigned int); 
  void setSynapseSource(unsigned int, unsigned int); 
  void setSynapseTarget(unsigned int, unsigned int); 
  void setSynapsePara(unsigned int, float*); 
  void setSynapseConnType(unsigned int, unsigned int); 
  void setSynapseGType(unsigned int, unsigned int); 
  unsigned int findSynapseGrp(const string); //< Find the the ID number of a synapse group by its name
  void initDerivedSynapsePara(unsigned int); 
  void initDerivedPostSynapsePara(unsigned int); 


public:

  // PUBLIC MODEL FUNCTIONS
  //=======================

  NNmodel();
  ~NNmodel();
  void setName(const string); 

  void setPrecision(unsigned int);//< Set numerical precision for floating point

  void checkSizes(unsigned int *, unsigned int *, unsigned int *); //< Check if the sizes of the initialized neuron and synapse groups are correct.

  void resetPaddedSums(); 

  void setGPUDevice(int); 

  // PUBLIC NEURON FUNCTIONS
  //========================

  void addNeuronPopulation(const char *, unsigned int, unsigned int, float *, float *); 

  void addNeuronPopulation(const string, unsigned int, unsigned int, float *, float *); 
  //void activateDirectInput(const char *, unsigned int);  
  //void addPostSyntoNeuron(const string,unsigned int); //!< Method for defining postsynaptic dynamics

  void activateDirectInput(const string, unsigned int);  

  void setConstInp(const string, float); 

  void setNeuronClusterIndex(const string neuronGroup, int hostID, int deviceID); 


  // PUBLIC SYNAPSE FUNCTIONS
  //=========================

  void addSynapsePopulation(const string name, unsigned int syntype, unsigned int conntype, unsigned int gtype, const string src, const string trg, float *p)  __attribute__ ((deprecated)); 

  void addSynapsePopulation(const char *, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, const char *, const char *, float *, float *, float *); 

  void addSynapsePopulation(const string, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, const string, const string, float *, float *, float *); 

  void setSynapseG(const string, float); 
  //void setSynapseNo(unsigned int,unsigned int); // !< Sets the number of connections for sparse matrices  

  void setMaxConn(const string, unsigned int); //< Set maximum connections per neuron for the given group (needed for optimization by sparse connectivity)

  void setSynapseClusterIndex(const string synapseGroup, int hostID, int deviceID); 

};

#endif