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

#include <vector>
#include "network.h"
#include "position.h"
#include "topologymodule.h"
#include "topology_names.h"
#include "vose.h"
#include "mask.h"
#include "parameter.h"
#include "selector.h"

namespace nest
{
  template<int D>
  class Layer;

  template <int D>
  class MaskedLayer;

  class ConnectionCreator {
  public:

    enum ConnectionType {Target_driven, Source_driven, Convergent, Divergent};

    ConnectionCreator(DictionaryDatum dict);

    template<int D>
    void connect(Layer<D>& source, Layer<D>& target);

  private:

    template <int D>
    class PoolWrapper_
    {
    public:
      PoolWrapper_();
      ~PoolWrapper_();
      void define(MaskedLayer<D>*);
      void define(std::vector<std::pair<Position<D>,index> >*); 
      
      typename Ntree<D,index>::masked_iterator masked_begin(const Position<D>& pos) const;
      typename Ntree<D,index>::masked_iterator masked_end() const;

      typename std::vector<std::pair<Position<D>,index> >::iterator begin() const;
      typename std::vector<std::pair<Position<D>,index> >::iterator end() const;

    private:
      MaskedLayer<D>* masked_layer_;
      std::vector<std::pair<Position<D>,index> >* positions_;
    };

    template<typename Iterator, int D>
    void connect_to_target_(Iterator from, Iterator to, Node* tgt_ptr,  
                const Position<D>& tgt_pos, thread tgt_thread, const Layer<D>& source);

    template<int D>
    void target_driven_connect_(Layer<D>& source, Layer<D>& target);

    template<int D>
    void source_driven_connect_(Layer<D>& source, Layer<D>& target);

    template<int D>
    void convergent_connect_(Layer<D>& source, Layer<D>& target);

    template<int D>
    void divergent_connect_(Layer<D>& source, Layer<D>& target);

    void connect_(index s, Node* target, thread target_thread,
         double_t w, double_t d, index syn);

    template<int D>
    void get_parameters_(const Position<D> & pos, librandom::RngPtr rng, 
             double& weight, double& delay);

    ConnectionType type_;
    bool allow_autapses_;
    bool allow_multapses_;
    bool allow_oversized_;
    Selector source_filter_;
    Selector target_filter_;
    index number_of_connections_;
    lockPTR<AbstractMask> mask_;
    lockPTR<Parameter> kernel_;
    index synapse_model_;
    lockPTR<Parameter> weight_;
    lockPTR<Parameter> delay_;

    Network& net_;
  };

  inline 
  void ConnectionCreator::connect_(index s, Node* target, thread target_thread,
        double_t w, double_t d, index syn)
  {
    // check whether the target is on this process
    if (net_.is_local_gid(target->get_gid()))
    {
      // check whether the target is on our thread
      thread tid = net_.get_thread_id();      
      if( tid == target_thread)
    net_.connect(s, target, target_thread, syn, d, w);
    }
  }

} // namespace nest

#endif