IZNeuronBase.H

Go to the documentation of this file.

/*!@file ModelNeuron/IZNeuronBase.H Class declarations for an izhikevich neuron */

// //////////////////////////////////////////////////////////////////// //
// The iLab Neuromorphic Vision C++ Toolkit - Copyright (C) 2001 by the //
// University of Southern California (USC) and the iLab at USC.         //
// See http://iLab.usc.edu for information about this project.          //
// //////////////////////////////////////////////////////////////////// //
// Major portions of the iLab Neuromorphic Vision Toolkit are protected //
// under the U.S. patent ``Computation of Intrinsic Perceptual Saliency //
// in Visual Environments, and Applications'' by Christof Koch and      //
// Laurent Itti, California Institute of Technology, 2001 (patent       //
// pending; application number 09/912,225 filed July 23, 2001; see      //
// http://pair.uspto.gov/cgi-bin/final/home.pl for current status).     //
// //////////////////////////////////////////////////////////////////// //
// This file is part of the iLab Neuromorphic Vision C++ Toolkit.       //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit 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 2 of the License, or (at your option) any later version.     //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit 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 the iLab Neuromorphic Vision C++ Toolkit; if not, write   //
// to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,   //
// Boston, MA 02111-1307 USA.                                           //
// //////////////////////////////////////////////////////////////////// //
//
// Primary maintainer for this file: David Berg <dberg@usc.edu>
// $HeadURL: svn://ilab.usc.edu/trunk/saliency/src/ModelNeuron/IZNeuronBase.H $

#ifndef IZNEURONBASE_H_DEFINED
#define IZNEURONBASE_H_DEFINED

#include "Util/SimTime.H"

// ######################################################################
//! An izhikevich Neural model as presented in his 2003 paper
// ######################################################################

class IZNeuronBase
{
public:
  //! constructor
  /*! Constructor with default params
    @param timeStep is the integration time step, in milliseconds.
    See the general description for the other params. */
  inline IZNeuronBase(const SimTime timeStep = SimTime::MSECS(.1),
                      const double a = 0.15,          // dimensionless
                      const double b = 8,           // dimensionless 
                      const double c = -55.0,         // dimensionless
                      const double d = 200.0,         // dimensionless
                      const double k = 1,           // dimensionless
                      const double Cm = 20.0,        // farads
                      const double V_rest = -55.0,    // in millivolts
                      const double V_thresh = -40.0, // in millivolts
                      const double V_peak = 25.0);     // in millivolts
                      
  //! set input current (A)
  inline void input(const double current);

  //! set membrane potential to given value relative to Ei (in Volts)
  inline void setV(const double val);

  //! integrate for up to given time (in msecs)
  /*! Returns true if a spike was generated. */
  virtual inline uint evolve(const SimTime& t);
    
  //! integrate 1 time step (in msecs)
  /*! Returns true if a spike was generated. */
  inline bool integrate(const SimTime& t);
  
  //! get current membrane potential (in V)
  inline double getV() const;

  inline double getU() const;

  inline double getI() const;

  //! return our internal time step:
  inline SimTime getTimeStep() const;
 
  //! set the current internal time:
  inline void setTime(const SimTime& t);

  //! get our internal time:
  inline SimTime getTime() const;

private:
  inline void reset();// reset when a spike occurs

  SimTime itsTimeStep;// time step to use for difference equations (in msecs)

  double itsV;         // membrane potential in millivolts
  double itsI;         // input current in picoamperes
  double itsU;         //recovery variable

  double itsa;
  double itsb;
  double itsc;
  double itsd;
  double itsk;
  double itsCm;
  double itsVr;
  double itsVth;
  double itsVp;

  SimTime itsT;       // time of last integration
};



// ######################################################################
// ##### Inline functions for IZNeuronBase:
// ######################################################################

inline IZNeuronBase::IZNeuronBase(const SimTime timeStep,
                                  const double a,
                                  const double b,
                                  const double c,
                                  const double d,
                                  const double k,
                                  const double cm, 
                                  const double vr,
                                  const double vth,
                                  const double vp) :
  itsTimeStep(timeStep), itsV(vr), itsI(0.0), itsU(0.0), itsa(a), itsb(b), 
  itsc(c), itsd(d), itsk(k), itsCm(cm), itsVr(vr), itsVth(vth), itsVp(vp), 
  itsT(SimTime::ZERO())
{  }

// ######################################################################
inline void IZNeuronBase::input(const double current)
{ itsI = current;}


inline uint IZNeuronBase::evolve(const SimTime& t)
{
  // we run our difference equations with a time step of itsTimeStep;
  // let's here figure out how many iterations we will need to go from
  // itsT to t. We will iterate for a number of equal steps, with each
  // step as close to itsTimeStep as possible to that we end up at
  // time t after iterating for an integer number of time steps:
  
  uint spike = 0;
  const SimTime dt = SimTime::computeDeltaT((t - itsT), itsTimeStep);
  for (SimTime tt = itsT; tt < t; tt += dt)
    spike += (uint)integrate(dt);
  itsT = t;
  return spike;
}

// ######################################################################
inline bool IZNeuronBase::integrate(const SimTime& dt)
{
  // we run our difference equations with a time step of itsTimeStep;
  // let's here figure out how many iterations we will need to go from
  // itsT to t. We will iterate for a number of equal steps, with each
  // step as close to itsTimeStep as possible to that we end up at
  // time t after iterating for an integer number of time steps:
  
  bool spike = false;
  
  // Integrate U      
  itsU += dt.msecs() * (itsa * (itsb * (itsV-itsVr) - itsU) ); 
  
  // Integrate V
  double temp = itsk * (itsV - itsVr) * (itsV - itsVth) - itsU - itsI;
  //multiply timestip converted to ms, and devide capacitance      
  itsV += dt.msecs() * (temp / itsCm);
  
  
  // Check if voltage has exceeded threshold -> if so, then fire:
  if (itsV > itsVth) {spike = true; reset();}
  
  // we are done, just keep track of new current time:
  itsT += dt;
  return spike;
}

// ######################################################################
inline void IZNeuronBase::setV(const double val)
{ itsV = val; }

// ######################################################################
inline double IZNeuronBase::getV() const
{ return itsV; }

// ######################################################################
inline double IZNeuronBase::getU() const
{ return itsU; }

// ######################################################################
inline double IZNeuronBase::getI() const
{ return itsI; }

// ######################################################################
inline void IZNeuronBase::reset()
{
  itsV =  itsc;
  itsU += itsd;
}

// ######################################################################
inline SimTime IZNeuronBase::getTimeStep() const
{ return itsTimeStep; }

// ######################################################################
inline void IZNeuronBase::setTime(const SimTime& t)
{itsT = t;}

// ######################################################################
inline SimTime IZNeuronBase::getTime() const
{return itsT;}


#endif

// ######################################################################
/* So things look consistent in everyone's emacs... */
/* Local Variables: */
/* indent-tabs-mode: nil */
/* End: */

---