aeif_psc_delta_clopath.h

Go to the documentation of this file.

/*
 *  aeif_psc_delta_clopath.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 AEIF_PSC_DELTA_CLOPATH_H
#define AEIF_PSC_DELTA_CLOPATH_H
 
// Generated includes:
#include "config.h"
 
#ifdef HAVE_GSL
 
// External includes:
#include <gsl/gsl_errno.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_odeiv.h>
 
// Includes from nestkernel:
#include "clopath_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 aeif_psc_delta_clopath_dynamics( double, const double*, double*, void* );
 
/* BeginUserDocs: neuron, adaptation, integrate-and-fire, Clopath plasticity, current-based, soft threshold
 
Short description
+++++++++++++++++
 
Adaptive exponential integrate-and-fire neuron
 
Description
+++++++++++
 
``aeif_psc_delta_clopath`` is an implementation of the neuron model as it is used
in :footcite:p:`Clopath2010a`. It is an extension of the ``aeif_psc_delta`` model and capable of
connecting to a Clopath synapse.
 
Note that there are two points that are not mentioned in the paper but
present in a MATLAB implementation by Claudia Clopath :footcite:p:`Torben-Nielsen2010`. The first one is the
clamping of the membrane potential to a fixed value after a spike occurred to
mimic a real spike and not just the upswing. This is important since the finite
duration of the spike influences the evolution of the convolved versions
(``u_bar_[plus/minus]``) of the membrane potential and thus the change of the
synaptic weight. Secondly, there is a delay with which ``u_bar_[plus/minus]`` are
used to compute the change of the synaptic weight.
 
Note:
Neither the clamping nor the delayed processing of u_bar_[plus/minus] are
mentioned in :footcite:p:`Clopath2010a`. However, they are part of an reference implementation
by Claudia Clopath et al. that can be found on ModelDB :footcite:p:`Torben-Nielsen2010`. The clamping is
important to mimic a spike which is otherwise not described by the aeif neuron
model.
 
For implementation details see the
`aeif_models_implementation <../model_details/aeif_models_implementation.ipynb>`_ notebook.
 
See also :footcite:p:`Clopath2010b`.
 
.. note::
 
    The default refractory period for ``aeif`` models is zero, consistent with the model definition in
    Brette & Gerstner :footcite:p:`Brette2005`.  Thus, an ``aeif`` neuron with default parameters can fire multiple
    spikes in a single time step, which can lead to exploding spike numbers and extreme slow-down of simulations.
 
    To avoid such unphysiological behavior, you should set a refractory time ``t_ref > 0``.
 
Parameters
++++++++++
 
The following parameters can be set in the status Dictionary.
 
=========== ======  ===================================================
**Dynamic state variables**
-----------------------------------------------------------------------
V_m         mV      Membrane potential
w           pA      Spike-adaptation current
z           pA      Spike-adaptation current
V_th        mV      Adaptive spike initiation threshold
u_bar_plus  mV      Low-pass filtered Membrane potential
u_bar_minus mV      Low-pass filtered Membrane potential
u_bar_bar   mV      Low-pass filtered u_bar_minus
=========== ======  ===================================================
 
================== ======= =================================================
**Membrane Parameters**
----------------------------------------------------------------------------
 C_m               pF      Capacity of the membrane
 t_ref             ms      Duration of refractory period
 V_reset           mV      Reset value for V_m after a spike
 E_L               mV      Leak reversal potential
 g_L               nS      Leak conductance
 I_e               pA      Constant external input current
 tau_u_bar_plus    ms      Time constant of u_bar_plus
 tau_u_bar_minus   ms      Time constant of u_bar_minus
 tau_u_bar_bar     ms      Time constant of u_bar_bar
================== ======= =================================================
 
========== ======  ===================================================
**Spike adaptation parameters**
----------------------------------------------------------------------
a          nS      Subthreshold adaptation
b          pA      Spike-triggered adaptation
Delta_T    mV      Slope factor
tau_w      ms      Adaptation time constant
tau_z      ms      Spike afterpotential current time constant
I_sp       pA      Depolarizing spike afterpotential current magnitude
V_peak     mV      Spike detection threshold
V_th_max   mV      Value of V_th after a spike
V_th_rest  mV      Resting value of V_th
========== ======  ===================================================
 
============= ======= =======================================================
**Clopath rule parameters**
-----------------------------------------------------------------------------
A_LTD         1/mV    Amplitude of depression
A_LTP         1/mV^2  Amplitude of facilitation
theta_plus    mV      Threshold for u
theta_minus   mV      Threshold for u_bar_[plus/minus]
A_LTD_const   boolean Flag that indicates whether `A_LTD_` should
                      be constant (true, default) or multiplied by
                      u_bar_bar^2 / u_ref_squared (false).
delay_u_bars  real    Delay with which u_bar_[plus/minus] are processed
                      to compute the synaptic weights.
U_ref_squared real    Reference value for u_bar_bar_^2.
============= ======= =======================================================
 
=======  ====== =============================================================
**Other parameters**
-----------------------------------------------------------------------------
t_clamp  ms     Duration of clamping of Membrane potential after a spike
V_clamp  mV     Value to which the Membrane potential is clamped
=======  ====== =============================================================
 
============= ======= =========================================================
**Integration parameters**
-------------------------------------------------------------------------------
gsl_error_tol real    This parameter controls the admissible error of the
                      GSL integrator. Reduce it if NEST complains about
                      numerical instabilities.
============= ======= =========================================================
 
Sends
+++++
 
SpikeEvent
 
Receives
++++++++
 
SpikeEvent, CurrentEvent, DataLoggingRequest
 
References
++++++++++
 
.. footbibliography::
 
See also
++++++++
 
aeif_psc_delta, clopath_synapse, hh_psc_alpha_clopath
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: aeif_psc_delta_clopath
 
EndUserDocs */
 
void register_aeif_psc_delta_clopath( const std::string& name );
 
class aeif_psc_delta_clopath : public ClopathArchivingNode
{
 
public:
  aeif_psc_delta_clopath();
  aeif_psc_delta_clopath( const aeif_psc_delta_clopath& );
  ~aeif_psc_delta_clopath() override;
 
  using Node::handle;
  using Node::handles_test_event;
 
  size_t send_test_event( Node&, size_t, synindex, bool ) override;
 
  void handle( SpikeEvent& ) override;
  void handle( CurrentEvent& ) override;
  void handle( DataLoggingRequest& ) 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 get_status( Dictionary& ) const override;
  void set_status( const Dictionary& ) override;
 
private:
  void init_buffers_() override;
  void pre_run_hook() override;
  void update( const Time&, const long, const long ) override;
 
  // END Boilerplate function declarations ----------------------------
 
  // Friends --------------------------------------------------------
 
  // make dynamics function quasi-member
  friend int aeif_psc_delta_clopath_dynamics( double, const double*, double*, void* );
 
  // The next two classes need to be friends to access the State_ class/member
  friend class RecordablesMap< aeif_psc_delta_clopath >;
  friend class UniversalDataLogger< aeif_psc_delta_clopath >;
 
private:
  // ----------------------------------------------------------------
 
  struct Parameters_
  {
    double V_peak_;   
    double V_reset_;  
    double t_ref_;    
 
    double g_L;              
    double C_m;              
    double E_L;              
    double Delta_T;          
    double tau_w;            
    double tau_z;            
    double tau_V_th;         
    double V_th_max;         
    double V_th_rest;        
    double tau_u_bar_plus;   
    double tau_u_bar_minus;  
    double tau_u_bar_bar;    
    double a;                
    double b;                
    double I_sp;             
    double I_e;              
 
    double gsl_error_tol;  
 
    double t_clamp_;  
    double V_clamp_;  
 
 
    Parameters_();  
 
    void get( Dictionary& ) const;              
    void set( const Dictionary&, Node* node );  
  };
 
public:
  // ----------------------------------------------------------------
 
  struct State_
  {
    enum StateVecElems
    {
      V_M = 0,
      W,            // 1
      Z,            // 2
      V_TH,         // 3
      U_BAR_PLUS,   // 4
      U_BAR_MINUS,  // 5
      U_BAR_BAR,    // 6
      STATE_VEC_SIZE
    };
 
    double y_[ STATE_VEC_SIZE ];
    unsigned int r_;        
    unsigned int clamp_r_;  
 
    State_( const Parameters_& );  
    State_( const State_& );
 
    State_& operator=( const State_& );
 
    void get( Dictionary& ) const;
    void set( const Dictionary&, const Parameters_&, Node* );
  };
 
  // ----------------------------------------------------------------
 
  struct Buffers_
  {
    Buffers_( aeif_psc_delta_clopath& );                   
    Buffers_( const Buffers_&, aeif_psc_delta_clopath& );  
 
    UniversalDataLogger< aeif_psc_delta_clopath > logger_;
 
    RingBuffer spikes_;
    RingBuffer currents_;
 
    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_;
  };
 
  // ----------------------------------------------------------------
 
  struct Variables_
  {
    double V_peak_;
 
    unsigned int refractory_counts_;
    unsigned int clamp_counts_;
  };
 
  // Access functions for UniversalDataLogger -------------------------------
 
  template < State_::StateVecElems elem >
  double
  get_y_elem_() const
  {
    return S_.y_[ elem ];
  }
 
  // ----------------------------------------------------------------
 
  Parameters_ P_;
  State_ S_;
  Variables_ V_;
  Buffers_ B_;
 
  static RecordablesMap< aeif_psc_delta_clopath > recordablesMap_;
};
 
inline size_t
aeif_psc_delta_clopath::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
aeif_psc_delta_clopath::handles_test_event( SpikeEvent&, size_t receptor_type )
{
  if ( receptor_type != 0 )
  {
    throw UnknownReceptorType( receptor_type, get_name() );
  }
  return 0;
}
 
inline size_t
aeif_psc_delta_clopath::handles_test_event( CurrentEvent&, size_t receptor_type )
{
  if ( receptor_type != 0 )
  {
    throw UnknownReceptorType( receptor_type, get_name() );
  }
  return 0;
}
 
inline size_t
aeif_psc_delta_clopath::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
aeif_psc_delta_clopath::get_status( Dictionary& d ) const
{
  P_.get( d );
  S_.get( d );
  ClopathArchivingNode::get_status( d );
 
  d[ names::recordables ] = recordablesMap_.get_list();
}
 
inline void
aeif_psc_delta_clopath::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.
  ClopathArchivingNode::set_status( d );
 
  // if we get here, temporaries contain consistent set of properties
  P_ = ptmp;
  S_ = stmp;
}
 
}  // namespace
 
#endif  // HAVE_GSL
 
#endif  // AEIF_PSC_DELTA_CLOPATH_H