siegert_neuron.h

Go to the documentation of this file.

/*
 *  siegert_neuron.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 SIEGERT_NEURON_H
#define SIEGERT_NEURON_H
 
#include "config.h"
 
#ifdef HAVE_GSL
 
// C includes:
#include <gsl/gsl_integration.h>
#include <gsl/gsl_sf_dawson.h>
#include <gsl/gsl_sf_erf.h>
 
// Includes from nestkernel:
#include "archiving_node.h"
#include "connection.h"
#include "event.h"
#include "nest_types.h"
#include "node.h"
#include "recordables_map.h"
#include "ring_buffer.h"
#include "universal_data_logger.h"
 
namespace nest
{
 
/* BeginUserDocs: neuron, rate
 
Short description
+++++++++++++++++
 
model for mean-field analysis of spiking networks
 
Description
+++++++++++
 
``siegert_neuron`` is an implementation of a rate model with the
non-linearity given by the gain function of the
leaky-integrate-and-fire neuron with delta or exponentially decaying
synapses :footcite:p:`Fourcaud2002` and :footcite:p:`Schuecker2015` (their eq. 25). The model can be used for a
mean-field analysis of spiking networks. A constant mean input can be
provided to create neurons with a target rate, e.g. to model a constant
external input.
 
The model supports connections to other rate models with zero
delay, and uses the secondary_event concept introduced with the
gap-junction framework.
 
For details on the numerical solution of the Siegert integral, you can
check out the `Siegert_neuron_integration
<../model_details/siegert_neuron_integration.ipynb>`_
notebook in the NEST source code.
 
See also :footcite:p:`Hahne2017`, :footcite:p:`Hahne2015`.
 
Parameters
++++++++++
 
The following parameters can be set in the status Dictionary.
 
=====  ====== ==============================
 rate  1/s    Rate (1/s)
 tau   ms     Time constant
 mean  1/s    Additional constant input
=====  ====== ==============================
 
The following parameters can be set in the status directory and are
used in the evaluation of the gain function. Parameters as in
iaf_psc_exp/delta.
 
=========  ======  ================================================
 tau_m     ms      Membrane time constant
 tau_syn   ms      Time constant of postsynaptic currents
 t_ref     ms      Duration of refractory period
 theta     mV      Threshold relative to resting potential
 V_reset   mV      Reset relative to resting potential
=========  ======  ================================================
 
References
++++++++++
 
.. footbibliography::
 
Sends
+++++
 
DiffusionConnectionEvent
 
Receives
++++++++
 
DiffusionConnectionEvent, DataLoggingRequest
 
See also
++++++++
 
diffusion_connection
 
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: siegert_neuron
 
EndUserDocs */
 
void register_siegert_neuron( const std::string& name );
 
class siegert_neuron : public ArchivingNode
{
 
public:
  typedef Node base;
 
  siegert_neuron();
  siegert_neuron( const siegert_neuron& );
 
  ~siegert_neuron() override;
 
  using Node::handle;
  using Node::handles_test_event;
  using Node::sends_secondary_event;
 
  void handle( DiffusionConnectionEvent& ) override;
  void handle( DataLoggingRequest& ) override;
 
  size_t handles_test_event( DiffusionConnectionEvent&, size_t ) override;
  size_t handles_test_event( DataLoggingRequest&, size_t ) override;
 
  void
  sends_secondary_event( DiffusionConnectionEvent& ) override
  {
  }
 
  void get_status( Dictionary& ) const override;
  void set_status( const Dictionary& ) override;
 
private:
  void init_buffers_() override;
  void pre_run_hook() override;
 
  bool update_( Time const&, const long, const long, const bool );
 
  void update( Time const&, const long, const long ) override;
  bool wfr_update( Time const&, const long, const long ) override;
 
  // siegert function
  double siegert( double, double );
 
  // The next two classes need to be friends to access the State_ class/member
  friend class RecordablesMap< siegert_neuron >;
  friend class UniversalDataLogger< siegert_neuron >;
 
  // ----------------------------------------------------------------
 
  struct Parameters_
  {
    double tau_;
 
    double tau_m_;
 
    double tau_syn_;
 
    double t_ref_;
 
    double mean_;
 
    double theta_;
 
    double V_reset_;
 
    Parameters_();  
 
    void get( Dictionary& ) const;  
 
    void set( const Dictionary&, Node* node );
  };
 
  // ----------------------------------------------------------------
 
  struct State_
  {
    double r_;  
 
    State_();  
 
    void get( Dictionary& ) const;
    void set( const Dictionary&, Node* node );
  };
 
  // ----------------------------------------------------------------
 
  struct Buffers_
  {
    Buffers_( siegert_neuron& );
    Buffers_( const Buffers_&, siegert_neuron& );
 
    std::vector< double > drift_input_;      
    std::vector< double > diffusion_input_;  
    // received by DiffusionConnection
    std::vector< double > last_y_values;            
    UniversalDataLogger< siegert_neuron > logger_;  
  };
 
  // ----------------------------------------------------------------
 
  struct Variables_
  {
 
    // propagators
    double P1_;
    double P2_;
  };
 
  double
  get_rate_() const
  {
    return S_.r_;
  }
 
  // ----------------------------------------------------------------
 
  Parameters_ P_;
  State_ S_;
  Variables_ V_;
  Buffers_ B_;
 
  gsl_integration_workspace* gsl_w_;
 
  static RecordablesMap< siegert_neuron > recordablesMap_;
};
 
inline void
siegert_neuron::update( Time const& origin, const long from, const long to )
{
  update_( origin, from, to, false );
}
 
inline bool
siegert_neuron::wfr_update( Time const& origin, const long from, const long to )
{
  State_ old_state = S_;  // save state before wfr update
  const bool wfr_tol_exceeded = update_( origin, from, to, true );
  S_ = old_state;  // restore old state
 
  return not wfr_tol_exceeded;
}
 
inline size_t
siegert_neuron::handles_test_event( DiffusionConnectionEvent&, size_t receptor_type )
{
  if ( receptor_type == 0 )
  {
    return 0;
  }
  else if ( receptor_type == 1 )
  {
    return 1;
  }
  else
  {
    throw UnknownReceptorType( receptor_type, get_name() );
  }
}
 
inline size_t
siegert_neuron::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
siegert_neuron::get_status( Dictionary& d ) const
{
  P_.get( d );
  S_.get( d );
  ArchivingNode::get_status( d );
  d[ names::recordables ] = recordablesMap_.get_list();
}
 
inline void
siegert_neuron::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, 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  // SIEGERT_NEURON_H