iaf_cond_beta.h

Go to the documentation of this file.

/*
 *  iaf_cond_beta.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_COND_BETA_H
#define IAF_COND_BETA_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
{
extern "C" int iaf_cond_beta_dynamics( double, const double*, double*, void* );
 
/* BeginUserDocs: neuron, integrate-and-fire, conductance-based, hard threshold
 
Short description
+++++++++++++++++
 
Simple conductance based leaky integrate-and-fire neuron model
 
Description
+++++++++++
 
``iaf_cond_beta`` is an implementation of a spiking neuron using IAF dynamics with
conductance-based synapses. Incoming spike events induce a postsynaptic change
of conductance modelled by a beta function. The beta function
is normalized such that an event of weight 1.0 results in a peak conductance of
1 nS at :math:`t = \tau_{rise\_[ex|in]}`.
 
.. note::
   Per 2009-04-17, this class has been revised to our newest
   insights into class design. Please use THIS CLASS as a reference
   when designing your own models with nonlinear dynamics.
   One weakness of this class is that it distinguishes between
   inputs to the two synapses by the sign of the synaptic weight.
   It would be better to use ``receptor_types``, cf ``iaf_cond_alpha_mc``.
 
See also :footcite:p:`Meffin2004`, :footcite:p:`Bernander1991`, :footcite:p:`Kuhn2004`, :footcite:p:`Rotter1999`,
:footcite:p:`Roth2010`.
 
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
 t_ref        ms      Duration of refractory period
 V_th         mV      Spike threshold
 V_reset      mV      Reset potential of the membrane
 E_ex         mV      Excitatory reversal potential
 E_in         mV      Inhibitory reversal potential
 g_L          nS      Leak conductance
 tau_rise_ex  ms      Rise time of the excitatory synaptic beta function
 tau_decay_ex ms      Decay time of the excitatory synaptic beta function
 tau_rise_in  ms      Rise time of the inhibitory synaptic beta function
 tau_decay_in ms      Decay time of the inhibitory synaptic beta function
 I_e          pA      Constant input current
============= ====== =========================================================
 
 
Sends
+++++
 
SpikeEvent
 
Receives
++++++++
 
SpikeEvent, CurrentEvent, DataLoggingRequest
 
References
++++++++++
 
.. footbibliography::
 
See also
++++++++
 
iaf_cond_exp, iaf_cond_alpha, iaf_cond_alpha_mc
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: iaf_cond_beta
 
EndUserDocs */
 
void register_iaf_cond_beta( const std::string& name );
 
class iaf_cond_beta : public ArchivingNode
{
 
  // Boilerplate function declarations --------------------------------
 
public:
  iaf_cond_beta();
  iaf_cond_beta( const iaf_cond_beta& );
  ~iaf_cond_beta() override;
 
  /*
   * Import all overloaded virtual functions that we
   * override in this class.  For background information,
   * see http://www.gotw.ca/gotw/005.htm.
   */
 
  using Node::handle;
  using Node::handles_test_event;
 
  size_t send_test_event( Node& tagret, size_t receptor_type, synindex, bool ) override;
 
  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;
  double get_normalisation_factor( double, double );
  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_cond_beta_dynamics( double, const double*, double*, void* );
 
  // The next two classes need to be friends to access the State_ class/member
  friend class RecordablesMap< iaf_cond_beta >;
  friend class UniversalDataLogger< iaf_cond_beta >;
 
private:
  // Parameters class -------------------------------------------------
 
  struct Parameters_
  {
    double V_th;          
    double V_reset;       
    double t_ref;         
    double g_L;           
    double C_m;           
    double E_ex;          
    double E_in;          
    double E_L;           
    double tau_rise_ex;   
    double tau_decay_ex;  
    double tau_rise_in;   
    double tau_decay_in;  
    double I_e;           
 
    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,
      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_cond_beta& );                   
    Buffers_( const Buffers_&, iaf_cond_beta& );  
 
    UniversalDataLogger< iaf_cond_beta > 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;
 
    int RefractoryCounts;
  };
 
  // 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;
  }
 
  // Data members -----------------------------------------------------------
 
  // keep the order of these lines, seems to give best performance
  Parameters_ P_;
  State_ S_;
  Variables_ V_;
  Buffers_ B_;
 
  static RecordablesMap< iaf_cond_beta > recordablesMap_;
};
 
 
// Boilerplate inline function definitions ----------------------------------
 
inline size_t
iaf_cond_beta::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_cond_beta::handles_test_event( SpikeEvent&, size_t receptor_type )
{
  if ( receptor_type != 0 )
  {
    throw UnknownReceptorType( receptor_type, get_name() );
  }
  return 0;
}
 
inline size_t
iaf_cond_beta::handles_test_event( CurrentEvent&, size_t receptor_type )
{
  if ( receptor_type != 0 )
  {
    throw UnknownReceptorType( receptor_type, get_name() );
  }
  return 0;
}
 
inline size_t
iaf_cond_beta::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_cond_beta::get_status( Dictionary& d ) const
{
  P_.get( d );
  S_.get( d );
  ArchivingNode::get_status( d );
 
  d[ names::recordables ] = recordablesMap_.get_list();
}
 
inline void
iaf_cond_beta::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_COND_BETA_H