connection_creator.h

Go to the documentation of this file.

/*
 *  connection_creator.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_CREATOR_H
#define CONNECTION_CREATOR_H
 
// C++ includes:
#include <vector>
 
// Includes from nestkernel:
#include "kernel_manager.h"
#include "mask.h"
#include "nest_names.h"
#include "ntree.h"
#include "position.h"
 
namespace nest
{
template < int D >
class Layer;
 
template < int D >
class MaskedLayer;
 
class ConnectionCreator
{
public:
  enum ConnectionType
  {
    Pairwise_bernoulli_on_source,
    Pairwise_bernoulli_on_target,
    Pairwise_poisson,
    Fixed_indegree,
    Fixed_outdegree
  };
 
  ConnectionCreator( const Dictionary& dict );
 
  template < int D >
  void connect( Layer< D >& source, NodeCollectionPTR source_nc, Layer< D >& target, NodeCollectionPTR target_nc );
 
private:
  template < int D >
  class PoolWrapper_
  {
  public:
    PoolWrapper_();
    ~PoolWrapper_();
    void define( MaskedLayer< D >* );
    void define( std::vector< std::pair< Position< D >, size_t > >* );
 
    typename Ntree< D, size_t >::masked_iterator masked_begin( const Position< D >& pos ) const;
    typename Ntree< D, size_t >::masked_iterator masked_end() const;
 
    typename std::vector< std::pair< Position< D >, size_t > >::iterator begin() const;
    typename std::vector< std::pair< Position< D >, size_t > >::iterator end() const;
 
  private:
    MaskedLayer< D >* masked_layer_;
    std::vector< std::pair< Position< D >, size_t > >* positions_;
  };
 
  void extract_params_( const Dictionary&, std::vector< Dictionary >& );
 
  template < typename Iterator, int D >
  void connect_to_target_( Iterator from,
    Iterator to,
    Node* tgt_ptr,
    const Position< D >& tgt_pos,
    size_t tgt_thread,
    const Layer< D >& source );
 
  template < typename Iterator, int D >
  void connect_to_target_poisson_( Iterator from,
    Iterator to,
    Node* tgt_ptr,
    const Position< D >& tgt_pos,
    size_t tgt_thread,
    const Layer< D >& source );
 
  template < int D >
  void pairwise_bernoulli_on_source_( Layer< D >& source,
    NodeCollectionPTR source_nc,
    Layer< D >& target,
    NodeCollectionPTR target_nc );
 
  template < int D >
  void pairwise_bernoulli_on_target_( Layer< D >& source,
    NodeCollectionPTR source_nc,
    Layer< D >& target,
    NodeCollectionPTR target_nc );
 
  template < int D >
  void
  pairwise_poisson_( Layer< D >& source, NodeCollectionPTR source_nc, Layer< D >& target, NodeCollectionPTR target_nc );
 
  template < int D >
  void
  fixed_indegree_( Layer< D >& source, NodeCollectionPTR source_nc, Layer< D >& target, NodeCollectionPTR target_nc );
 
  template < int D >
  void
  fixed_outdegree_( Layer< D >& source, NodeCollectionPTR source_nc, Layer< D >& target, NodeCollectionPTR target_nc );
 
  ConnectionType type_;
  bool allow_autapses_;
  bool allow_multapses_;
  bool allow_oversized_;
  ParameterPTR number_of_connections_;
  MaskPTR mask_;
  ParameterPTR kernel_;
  std::vector< size_t > synapse_model_;
  std::vector< std::vector< Dictionary > > param_dicts_;
  std::vector< ParameterPTR > weight_;
  std::vector< ParameterPTR > delay_;
};
 
}  // namespace nest
 
#endif