target_identifier.h

Go to the documentation of this file.

/*
 *  target_identifier.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 TARGET_IDENTIFIER_H
#define TARGET_IDENTIFIER_H
 
#include "compose.hpp"
#include "kernel_manager.h"
 
namespace nest
{
 
class TargetIdentifierPtrRport
{
 
public:
  TargetIdentifierPtrRport()
    : target_( nullptr )
    , rport_( 0 )
  {
  }
 
 
  TargetIdentifierPtrRport( const TargetIdentifierPtrRport& t ) = default;
  TargetIdentifierPtrRport& operator=( const TargetIdentifierPtrRport& t ) = default;
 
 
  void
  get_status( Dictionary& d ) const
  {
    // Do nothing if called on synapse prototype
    if ( target_ )
    {
      d[ names::rport ] = static_cast< long >( rport_ );
      d[ names::target ] = static_cast< long >( target_->get_node_id() );
    }
  }
 
  Node*
  get_target_ptr( const size_t ) const
  {
    return target_;
  }
 
  size_t
  get_rport() const
  {
    return rport_;
  }
 
  void
  set_target( Node* target )
  {
    target_ = target;
  }
 
  void
  set_rport( size_t rprt )
  {
    rport_ = rprt;
  }
 
private:
  Node* target_;  
  size_t rport_;  
};
 
 
class TargetIdentifierIndex
{
 
public:
  TargetIdentifierIndex()
    : target_( invalid_targetindex )
  {
  }
 
  TargetIdentifierIndex( const TargetIdentifierIndex& t ) = default;
  TargetIdentifierIndex& operator=( const TargetIdentifierIndex& t ) = default;
 
  void
  get_status( Dictionary& d ) const
  {
    // Do nothing if called on synapse prototype
    if ( target_ != invalid_targetindex )
    {
      d[ names::rport ] = 0;
      d[ names::target ] = target_;
    }
  }
 
  Node*
  get_target_ptr( const size_t tid ) const
  {
    assert( target_ != invalid_targetindex );
    return kernel().node_manager.thread_lid_to_node( tid, target_ );
  }
 
  size_t
  get_rport() const
  {
    return 0;
  }
 
  void set_target( Node* target );
 
  void
  set_rport( size_t rprt )
  {
    if ( rprt != 0 )
    {
      throw IllegalConnection(
        "Only rport==0 allowed for HPC synapses. Use normal synapse models "
        "instead. See Kunkel et al, Front Neuroinform 8:78 (2014), Sec "
        "3.3.2." );
    }
  }
 
private:
  targetindex target_;  
};
 
inline void
TargetIdentifierIndex::set_target( Node* target )
{
  assert( kernel().node_manager.thread_local_data_is_up_to_date() );
 
  size_t target_lid = target->get_thread_lid();
  if ( target_lid > max_targetindex )
  {
    throw IllegalConnection(
      String::compose( "HPC synapses support at most %1 nodes per thread. "
                       "See Kunkel et al, Front Neuroinform 8:78 (2014), Sec 3.3.2.",
        max_targetindex ) );
  }
  target_ = target_lid;
}
 
 
}  // namespace nest
 
 
#endif