iaf_chxk_2008.h

Go to the documentation of this file.

/*
 *  iaf_chxk_2008.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST 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.
 *
 *  NEST 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 NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef IAF_CHXK_2008_H
#define IAF_CHXK_2008_H
 
// Generated includes:
#include "config.h"
 
#ifdef HAVE_GSL
 
// C includes:
#include <gsl/gsl_errno.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_odeiv.h>
 
// Includes from nestkernel:
#include "archiving_node.h"
#include "connection.h"
#include "event.h"
#include "nest_types.h"
#include "recordables_map.h"
#include "ring_buffer.h"
#include "universal_data_logger.h"
 
namespace nest
{
 
/* BeginUserDocs: neuron, integrate-and-fire, conductance-based, precise, hard threshold
 
Short description
+++++++++++++++++
 
Conductance-based leaky integrate-and-fire neuron model supporting
precise spike times used in Casti et al. 2008
 
Description
+++++++++++
 
``iaf_chxk_2008`` is an implementation of a spiking neuron using IAF dynamics with
conductance-based synapses :footcite:p:`Casti2008`. A spike is emitted when the membrane potential
is crossed from below. After a spike, an afterhyperpolarizing (AHP) conductance
is activated which repolarizes the neuron over time. Membrane potential is not
reset explicitly and the model also has no explicit refractory time.
 
The AHP conductance and excitatory and inhibitory synaptic input conductances
follow alpha-function time courses as in the ``iaf_cond_alpha`` model.
 
.. note::
   In accordance with the original Fortran implementation of the model used
   in :footcite:p:`Casti2008`, the activation time point for the AHP following a spike is
   determined by linear interpolation within the time step during which the
   threshold was crossed.
 
   ``iaf_chxk_2008`` neurons therefore emit spikes with precise spike time
   information, but they ignore precise spike times when handling synaptic
   input.
 
.. note::
   In the original Fortran implementation underlying :footcite:p:`Casti2008`, all previous AHP
   activation was discarded when a new spike occurred, leading to reduced AHP
   currents in particular during periods of high spiking activity. Set
   ``ahp_bug`` to ``true`` to obtain this behavior in the model.
 
Parameters
++++++++++
 
The following parameters can be set in the status Dictionary.
 
========  ======= ===========================================================
 V_m      mV      Membrane potential
 E_L      mV      Leak reversal potential
 C_m      pF      Capacity of the membrane
 V_th     mV      Spike threshold
 E_ex     mV      Excitatory reversal potential
 E_in     mV      Inhibitory reversal potential
 g_L      nS      Leak conductance
 tau_ex   ms      Rise time of the excitatory synaptic alpha function
 tau_in   ms      Rise time of the inhibitory synaptic alpha function
 I_e      pA      Constant input current
 tau_ahp  ms      Afterhyperpolarization (AHP) time constant
 E_ahp    mV      AHP potential
 g_ahp    nS      AHP conductance
 ahp_bug  boolean Defaults to false. If true, behaves like original
                  model implementation
========  ======= ===========================================================
 
References
++++++++++
 
.. footbibliography::
 
Sends
+++++
 
SpikeEvent
 
Receives
++++++++
 
SpikeEvent, CurrentEvent
 
See also
++++++++
 
iaf_cond_alpha
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: iaf_chxk_2008
 
EndUserDocs */
 
extern "C" int iaf_chxk_2008_dynamics( double, const double*, double*, void* );
 
void register_iaf_chxk_2008( const std::string& name );
 
class iaf_chxk_2008 : public ArchivingNode
{
 
  // Boilerplate function declarations --------------------------------
 
public:
  iaf_chxk_2008();
  iaf_chxk_2008( const iaf_chxk_2008& );
  ~iaf_chxk_2008() override;
 
  using Node::handle;
  using Node::handles_test_event;
 
  size_t send_test_event( Node&, size_t, synindex, bool ) override;
 
  bool
  is_off_grid() const override
  {
    return true;
  }
 
  size_t handles_test_event( SpikeEvent&, size_t ) override;
  size_t handles_test_event( CurrentEvent&, size_t ) override;
  size_t handles_test_event( DataLoggingRequest&, size_t ) override;
 
  void handle( SpikeEvent& ) override;
  void handle( CurrentEvent& ) override;
  void handle( DataLoggingRequest& ) override;
 
  void get_status( Dictionary& ) const override;
  void set_status( const Dictionary& ) override;
 
private:
  void init_buffers_() override;
  void pre_run_hook() override;
  void update( Time const&, const long, const long ) override;
 
  // END Boilerplate function declarations ----------------------------
 
  // Friends --------------------------------------------------------
 
  // make dynamics function quasi-member
  friend int iaf_chxk_2008_dynamics( double, const double*, double*, void* );
 
  // The next two classes need to be friends to access the State_ class/member
  friend class RecordablesMap< iaf_chxk_2008 >;
  friend class UniversalDataLogger< iaf_chxk_2008 >;
 
private:
  // Parameters class -------------------------------------------------
 
  struct Parameters_
  {
    double V_th;      
    double g_L;       
    double C_m;       
    double E_ex;      
    double E_in;      
    double E_L;       
    double tau_synE;  
    double tau_synI;  
    double I_e;       
    double tau_ahp;   
    double g_ahp;     
    double E_ahp;     
    bool ahp_bug;     
 
    Parameters_();  
 
    void get( Dictionary& ) const;              
    void set( const Dictionary&, Node* node );  
  };
 
  // State variables class --------------------------------------------
 
public:
  struct State_
  {
    enum StateVecElems
    {
      V_M = 0,
      DG_EXC,
      G_EXC,
      DG_INH,
      G_INH,
      DG_AHP,
      G_AHP,
      STATE_VEC_SIZE
    };
 
    double y[ STATE_VEC_SIZE ];
 
    int r;
 
    State_( const Parameters_& );  
    State_( const State_& );
 
    State_& operator=( const State_& );
 
    void get( Dictionary& ) const;  
 
    void set( const Dictionary&, const Parameters_&, Node* );
  };
 
private:
  // Buffers class --------------------------------------------------------
 
  struct Buffers_
  {
    Buffers_( iaf_chxk_2008& );                   
    Buffers_( const Buffers_&, iaf_chxk_2008& );  
 
    UniversalDataLogger< iaf_chxk_2008 > logger_;
 
    RingBuffer spike_exc_;
    RingBuffer spike_inh_;
    RingBuffer currents_;
 
    /* GSL ODE stuff */
    gsl_odeiv_step* s_;     
    gsl_odeiv_control* c_;  
    gsl_odeiv_evolve* e_;   
    gsl_odeiv_system sys_;  
 
    // Since IntegrationStep_ is initialized with step_, and the resolution
    // cannot change after nodes have been created, it is safe to place both
    // here.
    double step_;             
    double IntegrationStep_;  
 
    double I_stim_;
  };
 
  // Variables class -------------------------------------------------------
 
  struct Variables_
  {
    double PSConInit_E;
 
    double PSConInit_I;
 
    double PSConInit_AHP;
  };
 
  // Access functions for UniversalDataLogger -------------------------------
 
  template < State_::StateVecElems elem >
  double
  get_y_elem_() const
  {
    return S_.y[ elem ];
  }
 
  double
  get_r_() const
  {
    return Time::get_resolution().get_ms() * S_.r;
  }
 
  double
  get_I_syn_exc_() const
  {
    return S_.y[ State_::G_EXC ] * ( S_.y[ State_::V_M ] - P_.E_ex );
  }
  double
  get_I_syn_inh_() const
  {
    return S_.y[ State_::G_INH ] * ( S_.y[ State_::V_M ] - P_.E_in );
  }
  double
  get_I_ahp_() const
  {
    return S_.y[ State_::G_AHP ] * ( S_.y[ State_::V_M ] - P_.E_ahp );
  }
 
 
  // Data members -----------------------------------------------------------
 
  // keep the order of these lines, seems to give best performance
  Parameters_ P_;
  State_ S_;
  Variables_ V_;
  Buffers_ B_;
 
  static RecordablesMap< iaf_chxk_2008 > recordablesMap_;
};
 
 
// Boilerplate inline function definitions ----------------------------------
 
inline size_t
iaf_chxk_2008::send_test_event( Node& target, size_t receptor_type, synindex, bool )
{
  SpikeEvent e;
  e.set_sender( *this );
 
  return target.handles_test_event( e, receptor_type );
}
 
inline size_t
iaf_chxk_2008::handles_test_event( SpikeEvent&, size_t receptor_type )
{
  if ( receptor_type != 0 )
  {
    throw UnknownReceptorType( receptor_type, get_name() );
  }
  return 0;
}
 
inline size_t
iaf_chxk_2008::handles_test_event( CurrentEvent&, size_t receptor_type )
{
  if ( receptor_type != 0 )
  {
    throw UnknownReceptorType( receptor_type, get_name() );
  }
  return 0;
}
 
inline size_t
iaf_chxk_2008::handles_test_event( DataLoggingRequest& dlr, size_t receptor_type )
{
  if ( receptor_type != 0 )
  {
    throw UnknownReceptorType( receptor_type, get_name() );
  }
  return B_.logger_.connect_logging_device( dlr, recordablesMap_ );
}
 
inline void
iaf_chxk_2008::get_status( Dictionary& d ) const
{
  P_.get( d );
  S_.get( d );
  ArchivingNode::get_status( d );
 
  d[ names::recordables ] = recordablesMap_.get_list();
}
 
inline void
iaf_chxk_2008::set_status( const Dictionary& d )
{
  Parameters_ ptmp = P_;      // temporary copy in case of errors
  ptmp.set( d, this );        // throws if BadProperty
  State_ stmp = S_;           // temporary copy in case of errors
  stmp.set( d, ptmp, this );  // throws if BadProperty
 
  // We now know that (ptmp, stmp) are consistent. We do not
  // write them back to (P_, S_) before we are also sure that
  // the properties to be set in the parent class are internally
  // consistent.
  ArchivingNode::set_status( d );
 
  // if we get here, temporaries contain consistent set of properties
  P_ = ptmp;
  S_ = stmp;
}
 
}  // namespace
 
 
#endif  // HAVE_GSL
#endif  // IAF_CHXK_2008_H