target_table_devices.h

Go to the documentation of this file.

/*
 *  target_table_devices.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_TABLE_DEVICES_H
#define TARGET_TABLE_DEVICES_H
 
// C++ includes:
#include <cassert>
#include <map>
#include <vector>
 
// Includes from nestkernel:
#include "connection_id.h"
#include "connector_base.h"
#include "event.h"
#include "nest_types.h"
 
 
namespace nest
{
class Node;
class ConnectorModel;
 
class TargetTableDevices
{
private:
  std::vector< std::vector< std::vector< ConnectorBase* > > > target_to_devices_;
 
  std::vector< std::vector< std::vector< ConnectorBase* > > > target_from_devices_;
 
  std::vector< std::vector< size_t > > sending_devices_node_ids_;
 
public:
  TargetTableDevices();
  ~TargetTableDevices();
 
  void initialize();
 
  void finalize();
 
  void add_connection_to_device( Node& source,
    Node& target,
    const size_t s_node_id,
    const size_t tid,
    const synindex syn_id,
    const Dictionary& p,
    const double d,
    const double w );
 
  void add_connection_from_device( Node& source,
    Node& target,
    const size_t tid,
    const synindex syn_id,
    const Dictionary& p,
    const double d,
    const double w );
 
  void send_to_device( const size_t tid, const size_t s_node_id, Event& e, const std::vector< ConnectorModel* >& cm );
  void send_to_device( const size_t tid,
    const size_t s_node_id,
    SecondaryEvent& e,
    const std::vector< ConnectorModel* >& cm );
 
  void send_from_device( const size_t tid, const size_t ldid, Event& e, const std::vector< ConnectorModel* >& cm );
 
  void resize_to_number_of_neurons();
 
  void resize_to_number_of_synapse_types();
 
  void get_connections_to_devices_( const size_t requested_source_node_id,
    const size_t requested_target_node_id,
    const size_t tid,
    const synindex synapse_id,
    const long synapse_label,
    std::deque< ConnectionID >& conns ) const;
 
  void get_connections_to_device_for_lid_( const size_t lid,
    const size_t requested_target_node_id,
    const size_t tid,
    const synindex syn_id,
    const long synapse_label,
    std::deque< ConnectionID >& conns ) const;
 
  void get_connections_from_devices_( const size_t requested_source_node_id,
    const size_t requested_target_node_id,
    const size_t tid,
    const synindex synapse_id,
    const long synapse_label,
    std::deque< ConnectionID >& conns ) const;
 
  void get_connections( const size_t requested_source_node_id,
    const size_t requested_target_node_id,
    const size_t tid,
    const synindex synapse_id,
    const long synapse_label,
    std::deque< ConnectionID >& conns ) const;
 
  void get_synapse_status_to_device( const size_t tid,
    const size_t source_node_id,
    const synindex syn_id,
    Dictionary& dict,
    const size_t lcid ) const;
 
  void get_synapse_status_from_device( const size_t tid,
    const size_t ldid,
    const synindex syn_id,
    Dictionary& dict,
    const size_t lcid ) const;
 
  void set_synapse_status_to_device( const size_t tid,
    const size_t source_node_id,
    const synindex syn_id,
    ConnectorModel& cm,
    const Dictionary& dict,
    const size_t lcid );
 
  void set_synapse_status_from_device( const size_t tid,
    const size_t ldid,
    const synindex syn_id,
    ConnectorModel& cm,
    const Dictionary& dict,
    const size_t lcid );
 
  bool is_device_connected( size_t tid, size_t lcid ) const;
};
 
inline void
TargetTableDevices::get_synapse_status_from_device( const size_t tid,
  const size_t ldid,
  const synindex syn_id,
  Dictionary& dict,
  const size_t lcid ) const
{
  target_from_devices_[ tid ][ ldid ][ syn_id ]->get_synapse_status( tid, lcid, dict );
}
 
inline void
TargetTableDevices::set_synapse_status_from_device( const size_t tid,
  const size_t ldid,
  const synindex syn_id,
  ConnectorModel& cm,
  const Dictionary& dict,
  const size_t lcid )
{
  target_from_devices_[ tid ][ ldid ][ syn_id ]->set_synapse_status( lcid, dict, cm );
}
 
inline void
TargetTableDevices::send_from_device( const size_t tid,
  const size_t ldid,
  Event& e,
  const std::vector< ConnectorModel* >& cm )
{
  for ( std::vector< ConnectorBase* >::iterator it = target_from_devices_[ tid ][ ldid ].begin();
    it != target_from_devices_[ tid ][ ldid ].end();
    ++it )
  {
    if ( *it )
    {
      ( *it )->send_to_all( tid, cm, e );
    }
  }
}
 
inline bool
TargetTableDevices::is_device_connected( const size_t tid, const size_t lcid ) const
{
  for ( auto& synapse : target_from_devices_[ tid ][ lcid ] )
  {
    if ( synapse )
    {
      std::deque< ConnectionID > conns;
      synapse->get_all_connections( lcid, 0, tid, UNLABELED_CONNECTION, conns );
      if ( not conns.empty() )
      {
        return true;
      }
    }
  }
  return false;
}
 
}  // namespace nest
 
#endif