connection.h

Go to the documentation of this file.

/*
 *  connection.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 CONNECTION_H
#define CONNECTION_H
 
// Includes from nestkernel:
#include "common_synapse_properties.h"
#include "connection_label.h"
#include "connector_base_impl.h"
#include "delay_checker.h"
#include "event.h"
#include "kernel_manager.h"
#include "nest.h"
#include "nest_names.h"
#include "nest_time.h"
#include "nest_timeconverter.h"
#include "nest_types.h"
#include "node.h"
#include "spikecounter.h"
#include "syn_id_delay.h"
 
namespace nest
{
 
class ConnectorModel;
 
class ConnTestDummyNodeBase : public Node
{
  void
  pre_run_hook() override
  {
  }
  void
  update( const Time&, long, long ) override
  {
  }
  void
  set_status( const Dictionary& ) override
  {
  }
  void
  get_status( Dictionary& ) const override
  {
  }
  void
  init_state_() override
  {
  }
  void
  init_buffers_() override
  {
  }
};
 
template < typename targetidentifierT >
class Connection
{
 
public:
  // properties used when registering a connection with the ModelManager
  static constexpr ConnectionModelProperties properties = ConnectionModelProperties::NONE;
 
  // Whether this connection type supports flush events.
  static constexpr bool supports_flush_event = false;
 
  Connection()
    : target_()
    , syn_id_delay_( 1.0 )
  {
  }
 
  Connection( const Connection< targetidentifierT >& rhs ) = default;
  Connection& operator=( const Connection< targetidentifierT >& rhs ) = default;
 
  std::unique_ptr< SecondaryEvent > get_secondary_event();
 
  void get_status( Dictionary& d ) const;
 
  void set_status( const Dictionary& d, ConnectorModel& cm );
 
  void check_synapse_params( const Dictionary& d ) const;
 
  void calibrate( const TimeConverter& );
 
  double
  get_delay() const
  {
    return syn_id_delay_.get_delay_ms();
  }
 
  long
  get_delay_steps() const
  {
    return syn_id_delay_.delay;
  }
 
  void
  set_delay( const double delay )
  {
    syn_id_delay_.set_delay_ms( delay );
  }
 
  void
  set_delay_steps( const long delay )
  {
    syn_id_delay_.delay = delay;
  }
 
  void
  set_syn_id( synindex syn_id )
  {
    syn_id_delay_.syn_id = syn_id;
  }
 
  synindex
  get_syn_id() const
  {
    return syn_id_delay_.syn_id;
  }
 
  long
  get_label() const
  {
    return UNLABELED_CONNECTION;
  }
 
  void trigger_update_weight( const size_t,
    const std::vector< spikecounter >&,
    const double,
    const CommonSynapseProperties& );
 
  Node*
  get_target( const size_t tid ) const
  {
    return target_.get_target_ptr( tid );
  }
  size_t
  get_rport() const
  {
    return target_.get_rport();
  }
 
  void
  set_source_has_more_targets( const bool more_targets )
  {
    syn_id_delay_.set_source_has_more_targets( more_targets );
  }
 
  bool
  source_has_more_targets() const
  {
    return syn_id_delay_.source_has_more_targets();
  }
 
  void
  disable()
  {
    syn_id_delay_.disable();
  }
 
  bool
  is_disabled() const
  {
    return syn_id_delay_.is_disabled();
  }
 
protected:
  void check_connection_( Node& dummy_target, Node& source, Node& target, const size_t receptor_type );
 
  // The order of the members below is critical as it influcences the size of the object.
  // Please leave unchanged!
  targetidentifierT target_;
  // syn_id (9 bit), delay (21 bit) in timesteps of this connection and more_targets and disabled flags (each 1 bit)
  SynIdDelay syn_id_delay_;
};
 
template < typename targetidentifierT >
constexpr ConnectionModelProperties Connection< targetidentifierT >::properties;
 
template < typename targetidentifierT >
inline void
Connection< targetidentifierT >::check_connection_( Node& dummy_target,
  Node& source,
  Node& target,
  const size_t receptor_type )
{
  // 1. does this connection support the event type sent by source
  // try to send event from source to dummy_target
  // this line might throw an exception
  source.send_test_event( dummy_target, receptor_type, get_syn_id(), true );
 
  // 2. does the target accept the event type sent by source
  // try to send event from source to target
  // this returns the port of the incoming connection
  // p must be stored in the base class connection
  // this line might throw an exception
  target_.set_rport( source.send_test_event( target, receptor_type, get_syn_id(), false ) );
 
  // 3. do the events sent by source mean the same thing as they are
  // interpreted in target?
  // note that we here use a bitwise and operation (&), because we interpret
  // each bit in the signal type as a collection of individual flags
  if ( not( source.sends_signal() & target.receives_signal() ) )
  {
    throw IllegalConnection( "Source and target neuron are not compatible (e.g., spiking vs binary neuron)." );
  }
 
  target_.set_target( &target );
}
 
template < typename targetidentifierT >
inline void
Connection< targetidentifierT >::get_status( Dictionary& d ) const
{
  d[ names::delay ] = syn_id_delay_.get_delay_ms();
  target_.get_status( d );
}
 
template < typename targetidentifierT >
inline void
Connection< targetidentifierT >::set_status( const Dictionary& d, ConnectorModel& )
{
  double delay;
  if ( d.update_value( names::delay, delay ) )
  {
    kernel().connection_manager.get_delay_checker().assert_valid_delay_ms( delay );
    syn_id_delay_.set_delay_ms( delay );
  }
  // no call to target_.set_status() because target and rport cannot be changed
}
 
template < typename targetidentifierT >
inline void
Connection< targetidentifierT >::check_synapse_params( const Dictionary& ) const
{
}
 
template < typename targetidentifierT >
inline void
Connection< targetidentifierT >::calibrate( const TimeConverter& tc )
{
  Time t = tc.from_old_steps( syn_id_delay_.delay );
  syn_id_delay_.delay = t.get_steps();
 
  if ( syn_id_delay_.delay == 0 )
  {
    syn_id_delay_.delay = 1;
  }
}
 
template < typename targetidentifierT >
inline void
Connection< targetidentifierT >::trigger_update_weight( const size_t,
  const std::vector< spikecounter >&,
  const double,
  const CommonSynapseProperties& )
{
  throw IllegalConnection( "Connection does not support updates that are triggered by a volume transmitter." );
}
 
template < typename targetidentifierT >
std::unique_ptr< SecondaryEvent >
Connection< targetidentifierT >::get_secondary_event()
{
  assert( false and "Non-primary connections have to provide get_secondary_event()" );
  return nullptr;
}
 
}  // namespace nest
 
#endif /* CONNECTION_H */