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

#include <iostream>
#include <utility>
#include <bitset>
#include "nest.h"
#include "subnet.h"
#include "position.h"
#include "dictutils.h"
#include "topology_names.h"
#include "ntree.h"
#include "connection_creator.h"
#include "selector.h"

namespace nest
{

  class AbstractLayer: public Subnet
  {
  public:
    AbstractLayer() : depth_(1)
      {}

    virtual ~AbstractLayer();

    virtual std::vector<double_t> get_position_vector(const index sind) const = 0;

    virtual std::vector<double_t> compute_displacement(const std::vector<double_t>& from_pos,
                                                       const index to) const = 0;

    virtual double_t compute_distance(const std::vector<double_t>& from_pos,
                                      const index to) const = 0;

    virtual void connect(AbstractLayer& target, ConnectionCreator &connector) = 0;

    static index create_layer(const DictionaryDatum&);

    virtual std::vector<index> get_global_nodes(const MaskDatum &mask, const std::vector<double_t> &anchor, bool allow_oversized) = 0;

    virtual void dump_nodes(std::ostream & os) const = 0;

    virtual void dump_connections(std::ostream & out, const Token & syn_model) = 0;

    using Subnet::local_begin;
    using Subnet::local_end;

    std::vector<Node*>::iterator local_begin(int_t depth);

    std::vector<Node*>::iterator local_end(int_t depth);

    std::vector<Node*>::const_iterator local_begin(int_t depth) const;

    std::vector<Node*>::const_iterator local_end(int_t depth) const;

  protected:
    static index cached_ntree_layer_;

    int_t depth_;

    static index cached_vector_layer_;

    virtual void clear_ntree_cache_() const = 0;

    virtual void clear_vector_cache_() const = 0;

  };

  template<int D>
  class MaskedLayer;

  template <int D>
  class Layer: public AbstractLayer
  {
  public:
    Layer();

    Layer(const Layer &l);

    ~Layer();

    void set_status(const DictionaryDatum&);

    void get_status(DictionaryDatum&) const;

    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(index sind) const = 0;

    std::vector<double_t> get_position_vector(const index sind) const;

    virtual Position<D> compute_displacement(const Position<D>& from_pos,
                                             const Position<D>& to_pos) const;

    Position<D> compute_displacement(const Position<D>& from_pos,
                                             const index to) const;

    std::vector<double_t> compute_displacement(const std::vector<double_t>& from_pos,
                                               const index to) const;

    double_t compute_distance(const Position<D>& from_pos,
                                      const index to) const;

    double_t compute_distance(const std::vector<double_t>& from_pos,
                              const index to) const;


    lockPTR<Ntree<D,index> > get_local_positions_ntree(Selector filter=Selector());

    lockPTR<Ntree<D,index> > get_global_positions_ntree(Selector filter=Selector());

    lockPTR<Ntree<D,index> > get_global_positions_ntree(Selector filter, std::bitset<D> periodic, Position<D> lower_left, Position<D> extent);

    std::vector<std::pair<Position<D>,index> >* get_global_positions_vector(Selector filter=Selector());

    virtual std::vector<std::pair<Position<D>,index> > get_global_positions_vector(Selector filter, const MaskDatum& mask, const Position<D>& anchor, bool allow_oversized);

    std::vector<index> get_global_nodes(const MaskDatum &mask, const std::vector<double_t> &anchor, bool allow_oversized);

    void connect(AbstractLayer& target, ConnectionCreator &connector);

    void dump_nodes(std::ostream & os) const;

    void dump_connections(std::ostream & out, const Token & syn_model);

    bool is_subnet() const
      { return false; }

  protected:
    void clear_ntree_cache_() const;

    void clear_vector_cache_() const;

    lockPTR<Ntree<D,index> > do_get_global_positions_ntree_(const Selector& filter);

    virtual void insert_global_positions_ntree_(Ntree<D,index> & tree, const Selector& filter) = 0;

    virtual void insert_global_positions_vector_(std::vector<std::pair<Position<D>,index> > &, const Selector& filter) = 0;

    virtual void insert_local_positions_ntree_(Ntree<D,index> & tree, const Selector& filter) = 0;

    Position<D> lower_left_;  
    Position<D> extent_;      
    std::bitset<D> periodic_; 

    static lockPTR<Ntree<D,index> > cached_ntree_;
    static std::vector<std::pair<Position<D>,index> > * cached_vector_;
    static Selector cached_selector_;

    friend class MaskedLayer<D>;
  };

  template<int D>
  class MaskedLayer {
  public:

    MaskedLayer(Layer<D>& layer, Selector filter, const MaskDatum& mask, bool include_global, bool allow_oversized);

    MaskedLayer(Layer<D>& layer, Selector filter, const MaskDatum& mask, bool include_global, bool allow_oversized, Layer<D>& target);

    ~MaskedLayer();

    typename Ntree<D,index>::masked_iterator begin(const Position<D>& anchor);

    typename Ntree<D,index>::masked_iterator end();

  protected:

    void check_mask_(Layer<D>& layer, bool allow_oversized);

    lockPTR<Ntree<D,index> > ntree_;
    MaskDatum mask_;
  };

  template<int D>
  inline
  MaskedLayer<D>::MaskedLayer(Layer<D>& layer, Selector filter, const MaskDatum& maskd, bool include_global, bool allow_oversized):
    mask_(maskd)
  {
    if (include_global)
      ntree_ = layer.get_global_positions_ntree(filter);
    else
      ntree_ = layer.get_local_positions_ntree(filter);

    check_mask_(layer, allow_oversized);
  }

  template<int D>
  inline
  MaskedLayer<D>::MaskedLayer(Layer<D>& layer, Selector filter, const MaskDatum& maskd, bool include_global, bool allow_oversized, Layer<D>& target):
    mask_(maskd)
  {
    if (include_global)
      ntree_ = layer.get_global_positions_ntree(filter, target.get_periodic_mask(), target.get_lower_left(), target.get_extent());
    //else
    //  ntree_ = layer.get_local_positions_ntree(filter, target.get_periodic_mask(), target.get_lower_left(), target.get_extent());

    check_mask_(target, allow_oversized);
    mask_ = new ConverseMask<D>(dynamic_cast<const Mask<D>&>(*mask_));
  }

  template<int D>
  inline
  MaskedLayer<D>::~MaskedLayer()
  {
  }

  template<int D>
  inline
  typename Ntree<D,index>::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,index>::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 &l) :
      AbstractLayer(l),
      lower_left_(l.lower_left_),
      extent_(l.extent_),
      periodic_(l.periodic_)
  {
  }

  template<int D>
  inline
  Layer<D>::~Layer()
  {
    if (cached_ntree_layer_ == get_gid()) {
      clear_ntree_cache_();
    }

    if (cached_vector_layer_ == get_gid()) {
      clear_vector_cache_();
    }
  }

  template<int D>
  inline
  Position<D> Layer<D>::compute_displacement(const Position<D>& from_pos,
                                             const index to) const
  {
    return compute_displacement(from_pos,get_position(to));
  }

  template<int D>
  inline
  std::vector<double_t> Layer<D>::compute_displacement(const std::vector<double_t>& from_pos,
                                                       const index to) const
  {
    return std::vector<double_t>(compute_displacement(Position<D>(from_pos), to));
  }

  template<int D>
  inline
  double_t Layer<D>::compute_distance(const Position<D>& from_pos,
                                      const index to) const
  {
    return compute_displacement(from_pos, to).length();
  }

  template<int D>
  inline
  double_t Layer<D>::compute_distance(const std::vector<double_t>& from_pos,
                                      const index to) const
  {
    return compute_displacement(Position<D>(from_pos), to).length();
  }

  template<int D>
  inline
  std::vector<double_t> Layer<D>::get_position_vector(const index sind) const
  {
    return std::vector<double_t>(get_position(sind));
  }

  template <int D>
  inline
  void Layer<D>::clear_ntree_cache_() const
  {
    cached_ntree_ = lockPTR<Ntree<D,index> >();
    cached_ntree_layer_ = -1;
  }

  template <int D>
  inline
  void Layer<D>::clear_vector_cache_() const
  {
    if (cached_vector_ != 0)
      delete cached_vector_;
    cached_vector_ = 0;
    cached_vector_layer_ = -1;
  }

} // namespace nest

#endif