layer.h

Go to the documentation of this file.

/*
 *  layer.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 LAYER_H
#define LAYER_H
 
// C++ includes:
#include <bitset>
#include <iostream>
#include <utility>
 
// Includes from nestkernel:
#include "kernel_manager.h"
#include "nest_names.h"
#include "nest_types.h"
 
 
// Includes from spatial:
#include "connection_creator.h"
#include "ntree.h"
#include "position.h"
 
namespace nest
{
 
class AbstractLayer;
typedef std::shared_ptr< AbstractLayer > AbstractLayerPTR;
 
class AbstractLayer
{
public:
  AbstractLayer()
    : node_collection_( NodeCollectionPTR( nullptr ) )
  {
  }
 
  virtual ~AbstractLayer();
 
  virtual void set_status( const Dictionary& ) = 0;
 
  virtual void get_status( Dictionary&, NodeCollection const* const ) const = 0;
 
  virtual unsigned int get_num_dimensions() const = 0;
 
  virtual std::vector< double > get_position_vector( const size_t lid ) const = 0;
 
  virtual std::vector< double > compute_displacement( const std::vector< double >& from_pos,
    const size_t to ) const = 0;
  virtual double compute_displacement( const std::vector< double >& from_pos,
    const std::vector< double >& to_pos,
    const unsigned int dimension ) const = 0;
 
  virtual double compute_distance( const std::vector< double >& from_pos, const size_t lid ) const = 0;
  virtual double compute_distance( const std::vector< double >& from_pos,
    const std::vector< double >& to_pos ) const = 0;
 
  virtual void connect( NodeCollectionPTR source_nc,
    AbstractLayerPTR target,
    NodeCollectionPTR target_nc,
    ConnectionCreator& connector ) = 0;
 
  static NodeCollectionPTR create_layer( const Dictionary& );
 
  virtual std::vector< size_t > get_global_nodes( const MaskPTR mask,
    const std::vector< double >& anchor,
    bool allow_oversized,
    NodeCollectionPTR node_collection ) = 0;
 
  virtual void dump_nodes( std::ostream& os ) const = 0;
 
  virtual void dump_connections( std::ostream& out,
    NodeCollectionPTR node_collection,
    AbstractLayerPTR target_layer,
    const std::string& syn_model ) = 0;
 
  void set_node_collection( NodeCollectionPTR );
  NodeCollectionPTR get_node_collection();
 
protected:
  NodeCollectionPTR node_collection_;
 
  static NodeCollectionMetadataPTR cached_ntree_md_;
 
  static NodeCollectionMetadataPTR cached_vector_md_;
 
  virtual void clear_ntree_cache_() const = 0;
 
  virtual void clear_vector_cache_() const = 0;
 
  NodeCollectionMetadataPTR get_metadata() const;
};
 
template < int D >
class MaskedLayer;
 
template < int D >
class Layer : public AbstractLayer
{
public:
  Layer();
 
  Layer( const Layer& other_layer );
 
  ~Layer() override;
 
  void set_status( const Dictionary& ) override;
 
  void get_status( Dictionary&, NodeCollection const* const ) const override;
 
  unsigned int
  get_num_dimensions() const override
  {
    return D;
  }
 
  const Position< D >&
  get_lower_left() const
  {
    return lower_left_;
  }
 
  const Position< D >&
  get_extent() const
  {
    return extent_;
  }
 
  Position< D >
  get_center() const
  {
    return lower_left_ + extent_ / 2;
  }
 
  std::bitset< D >
  get_periodic_mask() const
  {
    return periodic_;
  }
 
  virtual Position< D > get_position( size_t sind ) const = 0;
 
  std::vector< double > get_position_vector( const size_t sind ) const override;
 
  Position< D > compute_displacement( const Position< D >& from_pos, const Position< D >& to_pos ) const;
  double compute_displacement( const std::vector< double >& from_pos,
    const std::vector< double >& to_pos,
    const unsigned int dimension ) const override;
 
  Position< D > compute_displacement( const Position< D >& from_pos, const size_t to ) const;
 
  std::vector< double > compute_displacement( const std::vector< double >& from_pos, const size_t to ) const override;
 
  double compute_distance( const Position< D >& from_pos, const size_t lid ) const;
 
  double compute_distance( const std::vector< double >& from_pos, const size_t lid ) const override;
 
  double compute_distance( const std::vector< double >& from_pos, const std::vector< double >& to_pos ) const override;
 
 
  std::shared_ptr< Ntree< D, size_t > > get_global_positions_ntree( NodeCollectionPTR node_collection );
 
  std::shared_ptr< Ntree< D, size_t > > get_global_positions_ntree( std::bitset< D > periodic,
    Position< D > lower_left,
    Position< D > extent,
    NodeCollectionPTR node_collection );
 
  std::vector< std::pair< Position< D >, size_t > >* get_global_positions_vector( NodeCollectionPTR node_collection );
 
  virtual std::vector< std::pair< Position< D >, size_t > > get_global_positions_vector( const MaskPTR mask,
    const Position< D >& anchor,
    bool allow_oversized,
    NodeCollectionPTR node_collection );
 
  std::vector< size_t > get_global_nodes( const MaskPTR mask,
    const std::vector< double >& anchor,
    bool allow_oversized,
    NodeCollectionPTR node_collection ) override;
 
  void connect( NodeCollectionPTR source_nc,
    AbstractLayerPTR target,
    NodeCollectionPTR target_nc,
    ConnectionCreator& connector ) override;
 
  void dump_nodes( std::ostream& os ) const override;
 
  void dump_connections( std::ostream& out,
    NodeCollectionPTR node_collection,
    AbstractLayerPTR target_layer,
    const std::string& syn_model ) override;
 
protected:
  void clear_ntree_cache_() const override;
 
  void clear_vector_cache_() const override;
 
  std::shared_ptr< Ntree< D, size_t > > do_get_global_positions_ntree_( NodeCollectionPTR node_collection );
 
  virtual void insert_global_positions_ntree_( Ntree< D, size_t >& tree, NodeCollectionPTR node_collection ) = 0;
 
  virtual void insert_global_positions_vector_( std::vector< std::pair< Position< D >, size_t > >&,
    NodeCollectionPTR ) = 0;
 
  Position< D > lower_left_;
  Position< D > extent_;       
  std::bitset< D > periodic_;  
 
  static std::shared_ptr< Ntree< D, size_t > > cached_ntree_;
  static std::vector< std::pair< Position< D >, size_t > >* cached_vector_;
 
  friend class MaskedLayer< D >;
};
 
template < int D >
class MaskedLayer
{
public:
  MaskedLayer( Layer< D >& layer, const MaskPTR mask, bool allow_oversized, NodeCollectionPTR node_collection );
 
  MaskedLayer( Layer< D >& layer,
    const MaskPTR mask,
    bool allow_oversized,
    Layer< D >& target,
    NodeCollectionPTR node_collection );
 
  ~MaskedLayer();
 
  typename Ntree< D, size_t >::masked_iterator begin( const Position< D >& anchor );
 
  typename Ntree< D, size_t >::masked_iterator end();
 
protected:
  void check_mask_( Layer< D >& layer, bool allow_oversized );
 
  std::shared_ptr< Ntree< D, size_t > > ntree_;
  MaskPTR mask_;
};
 
inline void
AbstractLayer::set_node_collection( NodeCollectionPTR node_collection )
{
  node_collection_ = node_collection;
}
 
 
inline NodeCollectionPTR
AbstractLayer::get_node_collection()
{
  return node_collection_;
}
 
template < int D >
inline MaskedLayer< D >::MaskedLayer( Layer< D >& layer,
  const MaskPTR maskd,
  bool allow_oversized,
  NodeCollectionPTR node_collection )
  : mask_( maskd )
{
  ntree_ = layer.get_global_positions_ntree( node_collection );
 
  check_mask_( layer, allow_oversized );
}
 
template < int D >
inline MaskedLayer< D >::MaskedLayer( Layer< D >& layer,
  const MaskPTR maskd,
  bool allow_oversized,
  Layer< D >& target,
  NodeCollectionPTR node_collection )
  : mask_( maskd )
{
  ntree_ = layer.get_global_positions_ntree(
    target.get_periodic_mask(), target.get_lower_left(), target.get_extent(), node_collection );
 
  check_mask_( target, allow_oversized );
  mask_ = MaskPTR( new ConverseMask< D >( dynamic_cast< const Mask< D >& >( *mask_ ) ) );
}
 
template < int D >
inline MaskedLayer< D >::~MaskedLayer()
{
}
 
template < int D >
inline typename Ntree< D, size_t >::masked_iterator
MaskedLayer< D >::begin( const Position< D >& anchor )
{
  try
  {
    return ntree_->masked_begin( dynamic_cast< const Mask< D >& >( *mask_ ), anchor );
  }
  catch ( std::bad_cast& e )
  {
    throw BadProperty( "Mask is incompatible with layer." );
  }
}
 
template < int D >
inline typename Ntree< D, size_t >::masked_iterator
MaskedLayer< D >::end()
{
  return ntree_->masked_end();
}
 
template < int D >
inline Layer< D >::Layer()
{
  // Default center (0,0) and extent (1,1)
  for ( int i = 0; i < D; ++i )
  {
    lower_left_[ i ] = -0.5;
    extent_[ i ] = 1.0;
  }
}
 
template < int D >
inline Layer< D >::Layer( const Layer& other_layer )
  : AbstractLayer( other_layer )
  , lower_left_( other_layer.lower_left_ )
  , extent_( other_layer.extent_ )
  , periodic_( other_layer.periodic_ )
{
}
 
template < int D >
inline Layer< D >::~Layer()
{
  if ( cached_ntree_md_ == get_metadata() )
  {
    clear_ntree_cache_();
  }
 
  if ( cached_vector_md_ == get_metadata() )
  {
    clear_vector_cache_();
  }
}
 
template < int D >
inline Position< D >
Layer< D >::compute_displacement( const Position< D >& from_pos, const size_t to_lid ) const
{
  return compute_displacement( from_pos, get_position( to_lid ) );
}
 
template < int D >
inline std::vector< double >
Layer< D >::compute_displacement( const std::vector< double >& from_pos, const size_t to_lid ) const
{
  return std::vector< double >( compute_displacement( Position< D >( from_pos ), to_lid ).get_vector() );
}
 
template < int D >
inline double
Layer< D >::compute_distance( const Position< D >& from_pos, const size_t lid ) const
{
  return compute_displacement( from_pos, lid ).length();
}
 
template < int D >
inline double
Layer< D >::compute_distance( const std::vector< double >& from_pos, const size_t lid ) const
{
  return compute_displacement( Position< D >( from_pos ), lid ).length();
}
 
template < int D >
inline double
Layer< D >::compute_distance( const std::vector< double >& from_pos, const std::vector< double >& to_pos ) const
{
  double squared_displacement = 0;
  for ( unsigned int i = 0; i < D; ++i )
  {
    const double displacement = compute_displacement( from_pos, to_pos, i );
    squared_displacement += displacement * displacement;
  }
  return std::sqrt( squared_displacement );
}
 
template < int D >
inline std::vector< double >
Layer< D >::get_position_vector( const size_t sind ) const
{
  return get_position( sind ).get_vector();
}
 
template < int D >
inline void
Layer< D >::clear_ntree_cache_() const
{
  cached_ntree_ = std::shared_ptr< Ntree< D, size_t > >();
  cached_ntree_md_ = NodeCollectionMetadataPTR( nullptr );
}
 
template < int D >
inline void
Layer< D >::clear_vector_cache_() const
{
  if ( cached_vector_ != 0 )
  {
    delete cached_vector_;
  }
  cached_vector_ = 0;
  cached_vector_md_ = NodeCollectionMetadataPTR( nullptr );
}
 
}  // namespace nest
 
#endif