quantal_stp_synapse.h

Go to the documentation of this file.

/*
 *  quantal_stp_synapse.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 QUANTAL_STP_SYNAPSE_H
#define QUANTAL_STP_SYNAPSE_H
 
// Includes from nestkernel:
#include "connection.h"
 
namespace nest
{
 
/* BeginUserDocs: synapse, chemical, functional, stp
 
Short description
+++++++++++++++++
 
Probabilistic synapse model with short term plasticity
 
Description
+++++++++++
 
This synapse model implements synaptic short-term depression and
short-term facilitation according to the quantal release model
described by Fuhrmann et al. :footcite:p:`Fuhrmann2002` and Loebel et al. :footcite:p:`Loebel2009`.
 
Each presynaptic spike will stochastically activate a fraction of
the available release sites.  This fraction is binomialy
distributed and the release probability per site is governed by the
Fuhrmann et al. (2002) model. The solution of the differential
equations is taken from Maass and Markram 2002 :footcite:p:`Maass2002`.
 
The connection weight is interpreted as the maximal weight that can
be obtained if all n release sites are activated.
 
.. warning::
 
   This synaptic plasticity rule does not take
   :ref:`precise spike timing <sim_precise_spike_times>` into
   account. When calculating the weight update, the precise spike time part
   of the timestamp is ignored.
 
Parameters
++++++++++
 
The following parameters can be set in the status dictionary:
 
==========  ======= =========================================================
 U          real    Maximal fraction of available resources [0,1],
                    default = 0.5
 u          real    Available fraction of resources [0,1], default = U
 n          integer Total number of release sites, default = 1
 a          integer Number of available release sites, default = n
 tau_fac    ms      Time constant for facilitation, default = 0 (off)
 tau_rec    ms      Time constant for depression, default = 800
==========  ======= =========================================================
 
References
++++++++++
 
.. footbibliography::
 
Transmits
+++++++++
 
SpikeEvent
 
See also
++++++++
 
tsodyks2_synapse, stdp_synapse, static_synapse
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: quantal_stp_synapse
 
EndUserDocs */
 
void register_quantal_stp_synapse( const std::string& name );
 
template < typename targetidentifierT >
class quantal_stp_synapse : public Connection< targetidentifierT >
{
public:
  typedef CommonSynapseProperties CommonPropertiesType;
  typedef Connection< targetidentifierT > ConnectionBase;
 
  static constexpr ConnectionModelProperties properties = ConnectionModelProperties::HAS_DELAY
    | ConnectionModelProperties::IS_PRIMARY | ConnectionModelProperties::SUPPORTS_HPC
    | ConnectionModelProperties::SUPPORTS_LBL;
 
  quantal_stp_synapse();
 
  quantal_stp_synapse( const quantal_stp_synapse& ) = default;
  quantal_stp_synapse& operator=( const quantal_stp_synapse& ) = default;
 
  // Explicitly declare all methods inherited from the dependent base
  // ConnectionBase. This avoids explicit name prefixes in all places these
  // functions are used. Since ConnectionBase depends on the template parameter,
  // they are not automatically found in the base class.
  using ConnectionBase::get_delay;
  using ConnectionBase::get_delay_steps;
  using ConnectionBase::get_rport;
  using ConnectionBase::get_target;
 
  void get_status( Dictionary& d ) const;
 
  void set_status( const Dictionary& d, ConnectorModel& cm );
 
  bool send( Event& e, size_t t, const CommonSynapseProperties& cp );
 
  class ConnTestDummyNode : public ConnTestDummyNodeBase
  {
  public:
    // Ensure proper overriding of overloaded virtual functions.
    // Return values from functions are ignored.
    using ConnTestDummyNodeBase::handles_test_event;
    size_t
    handles_test_event( SpikeEvent&, size_t ) override
    {
      return invalid_port;
    }
  };
 
  void
  check_connection( Node& s, Node& t, size_t receptor_type, const CommonPropertiesType& )
  {
    ConnTestDummyNode dummy_target;
    ConnectionBase::check_connection_( dummy_target, s, t, receptor_type );
  }
 
  void
  set_weight( double w )
  {
    weight_ = w;
  }
 
private:
  double weight_;       
  double U_;            
  double u_;            
  double tau_rec_;      
  double tau_fac_;      
  int n_;               
  int a_;               
  double t_lastspike_;  
};
 
template < typename targetidentifierT >
constexpr ConnectionModelProperties quantal_stp_synapse< targetidentifierT >::properties;
 
template < typename targetidentifierT >
inline bool
quantal_stp_synapse< targetidentifierT >::send( Event& e, size_t t, const CommonSynapseProperties& )
{
  const double t_spike = e.get_stamp().get_ms();
 
  if ( t_lastspike_ >= 0.0 )
  {
    // only update a and u if this is not the first spike to pass through the synapse
 
    // Compute the decay factors, based on the time since the last spike.
    const double h = t_spike - t_lastspike_;
    const double p_decay = std::exp( -h / tau_rec_ );
    const double u_decay = ( tau_fac_ < 1.0e-10 ) ? 0.0 : std::exp( -h / tau_fac_ );
 
    // Compute release probability
    u_ = U_ + u_ * ( 1. - U_ ) * u_decay;  // Eq. 4 from Loebel et al. (2009)
 
    // Compute number of sites that recovered during the interval.
    for ( int depleted = n_ - a_; depleted > 0; --depleted )
    {
      if ( get_vp_specific_rng( t )->drand() < ( 1.0 - p_decay ) )
      {
        ++a_;
      }
    }
  }
 
  // Compute number of released sites
  int n_release = 0;
  for ( int i = a_; i > 0; --i )
  {
    if ( get_vp_specific_rng( t )->drand() < u_ )
    {
      ++n_release;
    }
  }
 
  const bool send_spike = n_release > 0;
 
  if ( send_spike )
  {
    e.set_receiver( *get_target( t ) );
    e.set_weight( n_release * weight_ );
    e.set_delay_steps( get_delay_steps() );
    e.set_rport( get_rport() );
    e();
    a_ -= n_release;
  }
 
  t_lastspike_ = t_spike;
 
  return send_spike;
}
 
}  // namespace
 
#endif  // QUANTAL_STP_SYNAPSE_H