cont_delay_synapse.h

Go to the documentation of this file.

/*
 *  cont_delay_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 CONT_DELAY_SYNAPSE_H
#define CONT_DELAY_SYNAPSE_H
 
 
// C++ includes:
#include <cmath>
 
// Includes from nestkernel:
#include "connection.h"
 
namespace nest
{
 
/* BeginUserDocs: synapse, chemical, static
 
Short description
+++++++++++++++++
 
Synapse type for continuous delays
 
Description
+++++++++++
 
``cont_delay_synapse`` relaxes the condition that NEST only implements delays
which are an integer multiple of the time step `h`. A continuous delay is
decomposed into an integer part (``delay_``) and a double (``delay_offset_``) so
that the actual delay is given by  ``delay_*h - delay_offset_``. This can be
combined with off-grid spike times.
 
All delays set by the normal NEST Connect function will be rounded, even
when using cont_delay_synapse. To set non-grid delays, you must either
 
1. set the delay as model default using :py:func:`.SetDefaults`, which
   is very efficient, but results in a situation where all synapses then
   will have the same delay.
 
2. set the delay for each synapse after the connections have been
   created, which is slower, but allows individual delay values.
 
Continuous delays cannot be shorter than the simulation resolution.
 
Transmits
+++++++++
 
SpikeEvent, RateEvent, CurrentEvent, ConductanceEvent, DoubleDataEvent
 
See also
++++++++
 
static_synapse, iaf_psc_alpha_ps
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: cont_delay_synapse
 
EndUserDocs */
 
void register_cont_delay_synapse( const std::string& name );
 
template < typename targetidentifierT >
class cont_delay_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 | ConnectionModelProperties::SUPPORTS_WFR;
 
  cont_delay_synapse();
 
  cont_delay_synapse( const cont_delay_synapse& ) = default;
 
  ~cont_delay_synapse()
  {
  }
 
  // 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_steps;
  using ConnectionBase::get_rport;
  using ConnectionBase::get_target;
  using ConnectionBase::set_delay_steps;
 
  void
  set_weight( double w )
  {
    weight_ = w;
  }
 
  void get_status( Dictionary& d ) const;
 
  void set_status( const Dictionary& d, ConnectorModel& cm );
 
  void check_synapse_params( const Dictionary& d ) const;
 
  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;
    }
    size_t
    handles_test_event( RateEvent&, size_t ) override
    {
      return invalid_port;
    }
    size_t
    handles_test_event( DataLoggingRequest&, size_t ) override
    {
      return invalid_port;
    }
    size_t
    handles_test_event( CurrentEvent&, size_t ) override
    {
      return invalid_port;
    }
    size_t
    handles_test_event( ConductanceEvent&, size_t ) override
    {
      return invalid_port;
    }
    size_t
    handles_test_event( DoubleDataEvent&, size_t ) override
    {
      return invalid_port;
    }
    size_t
    handles_test_event( DSSpikeEvent&, size_t ) override
    {
      return invalid_port;
    }
    size_t
    handles_test_event( DSCurrentEvent&, 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 );
  }
 
private:
  double weight_;        
  double delay_offset_;  
};
 
template < typename targetidentifierT >
inline bool
cont_delay_synapse< targetidentifierT >::send( Event& e, size_t t, const CommonSynapseProperties& )
{
  e.set_receiver( *get_target( t ) );
  e.set_weight( weight_ );
  e.set_rport( get_rport() );
  double orig_event_offset = e.get_offset();
  double total_offset = orig_event_offset + delay_offset_;
  // As far as i have seen, offsets are outside of tics regime provided
  // by the Time-class to allow more precise spike-times, hence comparing
  // on the tics level here is not reasonable. Still, the double comparison
  // seems save.
  if ( total_offset < Time::get_resolution().get_ms() )
  {
    e.set_delay_steps( get_delay_steps() );
    e.set_offset( total_offset );
  }
  else
  {
    e.set_delay_steps( get_delay_steps() - 1 );
    e.set_offset( total_offset - Time::get_resolution().get_ms() );
  }
  e();
  // reset offset to original value
  e.set_offset( orig_event_offset );
 
  return true;
}
 
template < typename targetidentifierT >
constexpr ConnectionModelProperties cont_delay_synapse< targetidentifierT >::properties;
 
}  // of namespace nest
 
#endif  // of #ifndef CONT_DELAY_SYNAPSE_H