ht_synapse.h

Go to the documentation of this file.

/*
 *  ht_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 HT_SYNAPSE_H
#define HT_SYNAPSE_H
 
// Includes from nestkernel:
#include "connection.h"
 
namespace nest
{
 
/* BeginUserDocs: synapse, chemical, functional, stp, Hill-Tononi
 
Short description
+++++++++++++++++
 
Synapse with depression after Hill & Tononi (2005)
 
Description
+++++++++++
 
This synapse implements the depression model described in :footcite:p:`Hill2005`, p 1678.
 
Synaptic dynamics are given by
 
.. math::
 
    \frac{dP(t)}{dt} &= \frac{1}{\tau_\mathrm{P}} \left( 1 - P \right)  \\
    P(t=0) &= 1 \\
 
Upon the arrival of a presynaptic spike at time :math:`t_\mathrm{sp}`, the value of :math:`P` is updated as follows:
 
.. math::
 
    P \leftarrow (1 - \delta_\mathrm{P}) P
 
:math:`w(t) = w_\mathrm{max} \cdot P(t)` is the resulting synaptic weight.
 
For implementation details see:
`HillTononi_model <../model_details/HillTononiModels.ipynb>`_
 
.. 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:
 
========  ======  =========================================================
 tau_P    ms      Synaptic vesicle pool recovery time constant
 delta_P  real    Fractional change in vesicle pool on incoming spikes
                  (unitless)
 P        real    Current size of the vesicle pool (unitless, 0 <= P <= 1)
========  ======  =========================================================
 
References
++++++++++
 
.. footbibliography::
 
Transmits
+++++++++
 
SpikeEvent
 
See also
++++++++
 
ht_neuron, tsodyks_synapse, stdp_synapse, static_synapse
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: ht_synapse
 
EndUserDocs */
 
void register_ht_synapse( const std::string& name );
 
template < typename targetidentifierT >
class ht_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;
 
  ht_synapse();
 
  ht_synapse( const ht_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;
 
  virtual ~ht_synapse()
  {
  }
 
  virtual void get_status( Dictionary& d ) const;
 
  virtual 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 tau_P_;    
  double delta_P_;  
 
  double p_;  
 
  double t_lastspike_;  
};
 
template < typename targetidentifierT >
constexpr ConnectionModelProperties ht_synapse< targetidentifierT >::properties;
 
template < typename targetidentifierT >
inline bool
ht_synapse< targetidentifierT >::send( Event& e, size_t t, const CommonSynapseProperties& )
{
  // propagation t_lastspike -> t_spike, t_lastspike_ = 0 initially, p_ = 1
  const double t_spike = e.get_stamp().get_ms();
  const double h = t_spike - t_lastspike_;
  p_ = 1 - ( 1 - p_ ) * std::exp( -h / tau_P_ );
 
  // send the spike to the target
  e.set_receiver( *get_target( t ) );
  e.set_weight( weight_ * p_ );
  e.set_delay_steps( get_delay_steps() );
  e.set_rport( get_rport() );
  e();
 
  // reduce pool after spike is sent
  p_ *= ( 1 - delta_P_ );
 
  t_lastspike_ = t_spike;
 
  return true;
}
 
template < typename targetidentifierT >
ht_synapse< targetidentifierT >::ht_synapse()
  : ConnectionBase()
  , weight_( 1.0 )
  , tau_P_( 500.0 )
  , delta_P_( 0.125 )
  , p_( 1.0 )
  , t_lastspike_( 0.0 )
{
}
 
template < typename targetidentifierT >
void
ht_synapse< targetidentifierT >::get_status( Dictionary& d ) const
{
  ConnectionBase::get_status( d );
  d[ names::weight ] = weight_;
  d[ names::tau_P ] = tau_P_;
  d[ names::delta_P ] = delta_P_;
  d[ names::P ] = p_;
  d[ names::size_of ] = static_cast< long >( sizeof( *this ) );
}
 
template < typename targetidentifierT >
void
ht_synapse< targetidentifierT >::set_status( const Dictionary& d, ConnectorModel& cm )
{
  ConnectionBase::set_status( d, cm );
 
  d.update_value( names::weight, weight_ );
  d.update_value( names::tau_P, tau_P_ );
  d.update_value( names::delta_P, delta_P_ );
  d.update_value( names::P, p_ );
 
  if ( tau_P_ <= 0.0 )
  {
    throw BadProperty( "tau_P > 0 required." );
  }
 
  if ( delta_P_ < 0.0 or delta_P_ > 1.0 )
  {
    throw BadProperty( "0 <= delta_P <= 1 required." );
  }
 
  if ( p_ < 0.0 or p_ > 1.0 )
  {
    throw BadProperty( "0 <= P <= 1 required." );
  }
}
 
}  // namespace
 
#endif  // HT_SYNAPSE_H