rate_connection_instantaneous.h

Go to the documentation of this file.

/*
 *  rate_connection_instantaneous.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 RATE_CONNECTION_INSTANTANEOUS_H
#define RATE_CONNECTION_INSTANTANEOUS_H
 
#include "connection.h"
 
namespace nest
{
 
/* BeginUserDocs: synapse, abstract, rate
 
Short description
+++++++++++++++++
 
Synapse type for instantaneous rate connections
 
Description
+++++++++++
 
``rate_connection_instantaneous`` is a connector to create
instantaneous connections between rate model neurons.
 
The value of the parameter delay is ignored for connections of
this type. To create rate connections with delay please use
the synapse type ``rate_connection_delayed``.
 
See also :footcite:p:`Hahne2017`.
 
Transmits
+++++++++
 
InstantaneousRateConnectionEvent
 
References
++++++++++
 
.. footbibliography::
 
See also
++++++++
 
rate_connection_delayed, rate_neuron_ipn, rate_neuron_opn
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: rate_connection_instantaneous
 
EndUserDocs */
 
void register_rate_connection_instantaneous( const std::string& name );
 
template < typename targetidentifierT >
class rate_connection_instantaneous : public Connection< targetidentifierT >
{
 
public:
  // this line determines which common properties to use
  typedef CommonSynapseProperties CommonPropertiesType;
  typedef Connection< targetidentifierT > ConnectionBase;
 
  static constexpr ConnectionModelProperties properties = ConnectionModelProperties::SUPPORTS_WFR;
 
  rate_connection_instantaneous()
    : ConnectionBase()
    , weight_( 1.0 )
  {
  }
 
  std::unique_ptr< SecondaryEvent > get_secondary_event();
 
  // 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;
 
  void
  check_connection( Node& s, Node& t, size_t receptor_type, const CommonPropertiesType& )
  {
    InstantaneousRateConnectionEvent ge;
 
    s.sends_secondary_event( ge );
    ge.set_sender( s );
    Connection< targetidentifierT >::target_.set_rport( t.handles_test_event( ge, receptor_type ) );
    Connection< targetidentifierT >::target_.set_target( &t );
  }
 
  bool
  send( Event& e, size_t t, const CommonSynapseProperties& )
  {
    e.set_weight( weight_ );
    e.set_receiver( *get_target( t ) );
    e.set_rport( get_rport() );
    e();
    return true;
  }
 
  void get_status( Dictionary& d ) const;
 
  void set_status( const Dictionary& d, ConnectorModel& cm );
 
  void
  set_weight( double w )
  {
    weight_ = w;
  }
 
  void
  set_delay( double )
  {
    throw BadProperty( "rate_connection_instantaneous has no delay. Please use rate_connection_delayed." );
  }
 
private:
  double weight_;  
};
 
template < typename targetidentifierT >
constexpr ConnectionModelProperties rate_connection_instantaneous< targetidentifierT >::properties;
 
template < typename targetidentifierT >
void
rate_connection_instantaneous< targetidentifierT >::get_status( Dictionary& d ) const
{
  ConnectionBase::get_status( d );
  d[ names::weight ] = weight_;
  d[ names::size_of ] = static_cast< long >( sizeof( *this ) );
}
 
template < typename targetidentifierT >
void
rate_connection_instantaneous< targetidentifierT >::set_status( const Dictionary& d, ConnectorModel& cm )
{
  // If the delay is set, we throw a BadProperty
  if ( d.known( names::delay ) )
  {
    throw BadProperty( "rate_connection_instantaneous has no delay. Please use rate_connection_delayed." );
  }
 
  ConnectionBase::set_status( d, cm );
  d.update_value( names::weight, weight_ );
}
 
template < typename targetidentifierT >
std::unique_ptr< SecondaryEvent >
rate_connection_instantaneous< targetidentifierT >::get_secondary_event()
{
  return std::make_unique< InstantaneousRateConnectionEvent >();
}
 
}  // namespace
 
#endif /* #ifndef RATE_CONNECTION_INSTANTANEOUS_H */