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 "neuronModels.h"
#include "synapseModels.h"
#include "postSynapseModels.h"

#include <set>
#include <string>
#include <vector>

using namespace std;


void initGeNN();
extern unsigned int GeNNReady;

// connectivity of the network (synapseConnType)
enum SynapseConnType
{
    ALLTOALL,
    DENSE,
    SPARSE,
};

// conductance type (synapseGType)
enum SynapseGType
{
    INDIVIDUALG,
    GLOBALG,
    INDIVIDUALID,
};

#define NO_DELAY 0 

#define NOLEARNING 0 
#define LEARNING 1 

#define EXITSYN 0 
#define INHIBSYN 1 

#define CPU 0 
#define GPU 1 

// Floating point precision to use for models
enum FloatType
{
    GENN_FLOAT,
    GENN_DOUBLE,
    GENN_LONG_DOUBLE,
};

#define AUTODEVICE -1  


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

class NNmodel
{
public:

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

  string name; 
  string ftype; 
  string RNtype; 
  double dt; 
  int final; 
  unsigned int needSt; 
  unsigned int needSynapseDelay; 
  bool timing;
  unsigned int seed;
  unsigned int resetKernel;  


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

  unsigned int neuronGrpN; 
  vector<string> neuronName; 
  vector<unsigned int> neuronN; 
  vector<unsigned int> sumNeuronN; 
  vector<unsigned int> padSumNeuronN; 
  vector<unsigned int> neuronPostSyn; 
  vector<unsigned int> neuronType; 
  vector<vector<double> > neuronPara; 
  vector<vector<double> > dnp; 
  vector<vector<double> > neuronIni; 
  vector<vector<unsigned int> > inSyn; 
  vector<vector<unsigned int> > outSyn; 
  vector<bool> neuronNeedSt; 
  vector<bool> neuronNeedTrueSpk; 
  vector<bool> neuronNeedSpkEvnt; 
  vector<vector<bool> > neuronVarNeedQueue; 
  vector<set<pair<string, string>>> neuronSpkEvntCondition; 
  vector<unsigned int> neuronDelaySlots; 
  vector<int> neuronHostID; 
  vector<int> neuronDeviceID; 


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

  unsigned int synapseGrpN; 
  vector<string> synapseName; 
  //vector<unsigned int>synapseNo; // !<numnber of synapses in a synapse group
  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<SynapseConnType> synapseConnType; 
  vector<SynapseGType> synapseGType; 
  vector<unsigned int> synapseSpanType; 
  vector<unsigned int> synapseSource; 
  vector<unsigned int> synapseTarget; 
  vector<unsigned int> synapseInSynNo; 
  vector<unsigned int> synapseOutSynNo; 
  vector<bool> synapseUsesTrueSpikes; 
  vector<bool> synapseUsesSpikeEvents; 
  vector<bool> synapseUsesPostLearning; 
  vector<bool> synapseUsesSynapseDynamics; 
  vector<bool> needEvntThresholdReTest; 
  vector<vector<double> > synapsePara; 
  vector<vector<double> > synapseIni; 
  vector<vector<double> > dsp_w;  
  vector<unsigned int> postSynapseType; 
  vector<vector<double> > postSynapsePara; 
  vector<vector<double> > postSynIni; 
  vector<vector<double> > dpsp;  
  unsigned int lrnGroups; 
  vector<unsigned int> padSumLearnN; 
  vector<unsigned int> lrnSynGrp; 
  vector<unsigned int> synapseDelay; 
  unsigned int synDynGroups; 
  vector<unsigned int> synDynGrp; 
  vector<unsigned int> padSumSynDynN; 
  vector<int> synapseHostID; 
  vector<int> synapseDeviceID; 


  // PUBLIC KERNEL PARAMETER VARIABLES
  //==================================

  vector<string> neuronKernelParameters;
  vector<string> neuronKernelParameterTypes;
  vector<string> synapseKernelParameters;
  vector<string> synapseKernelParameterTypes;
  vector<string> simLearnPostKernelParameters;
  vector<string> simLearnPostKernelParameterTypes;
  vector<string> synapseDynamicsKernelParameters;
  vector<string> synapseDynamicsKernelParameterTypes;
    
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, double*); 
  void setNeuronIni(unsigned int, double*); 
  void initDerivedNeuronPara(); 


  // 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, double*); 
  void setSynapseConnType(unsigned int, unsigned int); 
  void setSynapseGType(unsigned int, unsigned int); 
  void initDerivedSynapsePara(); 
  void initDerivedPostSynapsePara(); 
  void registerSynapsePopulation(unsigned int); 

public:


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

  NNmodel();
  ~NNmodel();
  void setName(const string); 
  void setPrecision(FloatType); 
  void setDT(double); 
  void setTiming(bool); 
  void setSeed(unsigned int); 
  void checkSizes(unsigned int *, unsigned int *, unsigned int *); //< Check if the sizes of the initialized neuron and synapse groups are correct.
#ifndef CPU_ONLY
  void setGPUDevice(int); 
#endif
  string scalarExpr(const double) const;
  void setPopulationSums(); 
  void finalize(); 


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

  void addNeuronPopulation(const string&, unsigned int, unsigned int, const double *, const double *); 
  void addNeuronPopulation(const string&, unsigned int, unsigned int, const vector<double>&, const vector<double>&); 
  void setNeuronClusterIndex(const string &neuronGroup, int hostID, int deviceID); 
  void activateDirectInput(const string&, unsigned int type); 
  void setConstInp(const string&, double);
  unsigned int findNeuronGrp(const string&) const; 
  

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

  void addSynapsePopulation(const string &name, unsigned int syntype, SynapseConnType conntype, SynapseGType gtype, const string& src, const string& trg, const double *p); 
  void addSynapsePopulation(const string&, unsigned int, SynapseConnType, SynapseGType, unsigned int, unsigned int, const string&, const string&, const double *, const double *, const double *); 
  void addSynapsePopulation(const string&, unsigned int, SynapseConnType, SynapseGType, unsigned int, unsigned int, const string&, const string&, const double *, const double *, const double *, const double *); 
  void addSynapsePopulation(const string&, unsigned int, SynapseConnType, SynapseGType, unsigned int, unsigned int, const string&, const string&,
                            const vector<double>&, const vector<double>&, const vector<double>&, const vector<double>&); 
  void setSynapseG(const string&, double); 
  void setMaxConn(const string&, unsigned int); //< Set maximum connections per neuron for the given group (needed for optimization by sparse connectivity)
  void setSpanTypeToPre(const string&); 
  void setSynapseClusterIndex(const string &synapseGroup, int hostID, int deviceID); 
  void initLearnGrps();
  unsigned int findSynapseGrp(const string&) const; //< Find the the ID number of a synapse group by its name
 
};

#endif