incidentiterator.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_MMESHINCIDENTITERATOR_HH
#define DUNE_GRID_MMESHINCIDENTITERATOR_HH
 
// Dune includes
#include <dune/grid/common/gridenums.hh>
 
namespace Dune
{
  template<class GridImp, int dim>
  class MMeshIncidentIteratorImp;
 
  template<class Grid>
  using MMeshIncidentIterator = EntityIterator<0, Grid, MMeshIncidentIteratorImp<Grid, Grid::dimension>>;
 
  template<class GridImp, int dim>
  class MMeshEdgeIncidentIteratorImp;
 
  template<class Grid>
  using MMeshEdgeIncidentIterator = EntityIterator<0, Grid, MMeshEdgeIncidentIteratorImp<Grid, Grid::dimension>>;
 
  template<class GridImp, int dim>
  class MMeshIncidentFacetsIteratorImp;
 
  template<class Grid>
  using MMeshIncidentFacetsIterator = EntityIterator<1, Grid, MMeshIncidentFacetsIteratorImp<Grid, Grid::dimension>>;
 
  template<class GridImp, int dim>
  class MMeshIncidentVerticesIteratorImp;
 
  template<class Grid>
  using MMeshIncidentVerticesIterator = EntityIterator<Grid::dimension, Grid, MMeshIncidentVerticesIteratorImp<Grid, Grid::dimensionworld>>;
 
  template<class GridImp>
  class MMeshIncidentIteratorImp<GridImp, 2>
  {
  private:
    typedef typename GridImp::template HostGridEntity<GridImp::dimension> HostGridVertex;
    typedef typename GridImp::template HostGridEntity<0> HostGridEntity;
 
   using ElementContainer = std::vector<HostGridEntity>;
 
  public:
    enum {codimension = 0};
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
 
    explicit MMeshIncidentIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity)
    : mMesh_(mMesh),
      i_(0)
    {
      auto circulator = mMesh->getHostGrid().incident_faces(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if (!mMesh->getHostGrid().is_infinite(circulator))
          elementContainer_.push_back( circulator );
    }
 
    explicit MMeshIncidentIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity, bool endDummy) :
      mMesh_(mMesh),
      i_(0)
    {
      auto circulator = mMesh->getHostGrid().incident_faces(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if (!mMesh->getHostGrid().is_infinite(circulator))
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ mMesh_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const GridImp* mMesh_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
 
  template<class GridImp>
  class MMeshIncidentIteratorImp<GridImp, 3>
  {
  private:
    typedef typename GridImp::template HostGridEntity<GridImp::dimension> HostGridVertex;
    typedef typename GridImp::template HostGridEntity<0> HostGridEntity;
 
    using ElementOutput = typename GridImp::ElementOutput;
 
    using ElementContainer = std::vector<HostGridEntity>;
 
  public:
    enum {codimension = 0};
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
 
    explicit MMeshIncidentIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity)
    : mMesh_(mMesh),
      i_(0)
    {
      ElementOutput elements;
      mMesh_->getHostGrid().finite_incident_cells( hostEntity, std::back_inserter(elements) );
 
      typename ElementOutput::iterator fit;
      for(fit = elements.begin(); fit != elements.end(); fit++)
        elementContainer_.push_back( *fit );
    }
 
    explicit MMeshIncidentIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity, bool endDummy) :
      mMesh_(mMesh),
      i_(0)
    {
      ElementOutput elements;
      mMesh_->getHostGrid().finite_incident_cells( hostEntity, std::back_inserter(elements) );
 
      typename ElementOutput::iterator fit;
      for(fit = elements.begin(); fit != elements.end(); fit++)
        ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ mMesh_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const GridImp* mMesh_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
 
  template<class GridImp>
  class MMeshEdgeIncidentIteratorImp<GridImp, 3>
  {
  private:
    typedef typename GridImp::template HostGridEntity<GridImp::dimension-1> HostGridEdge;
    typedef typename GridImp::template HostGridEntity<0> HostGridEntity;
 
    using Circulator = typename GridImp::HostGridType::Cell_circulator;
    using ElementContainer = std::vector<HostGridEntity>;
 
  public:
    enum {codimension = 0};
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
 
    explicit MMeshEdgeIncidentIteratorImp(const GridImp* mMesh, const HostGridEdge& hostEntity)
    : mMesh_(mMesh),
    i_(0)
    {
      Circulator circulator = mMesh_->getHostGrid().incident_cells( hostEntity );
      for(std::size_t i = 0; i < CGAL::circulator_size(circulator); circulator++, i++)
        if (!mMesh->getHostGrid().is_infinite(circulator))
          elementContainer_.push_back(circulator);
    }
 
    explicit MMeshEdgeIncidentIteratorImp(const GridImp* mMesh, const HostGridEdge& hostEntity, bool endDummy)
    : mMesh_(mMesh),
    i_(0)
    {
      Circulator circulator = mMesh_->getHostGrid().incident_cells( hostEntity );
      for(std::size_t i = 0; i < CGAL::circulator_size(circulator); circulator++, i++)
        if (!mMesh->getHostGrid().is_infinite(circulator))
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ mMesh_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshEdgeIncidentIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const GridImp* mMesh_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
 
  template<class GridImp>
  class MMeshIncidentFacetsIteratorImp<GridImp, 2>
  {
  private:
    typedef typename GridImp::template HostGridEntity<GridImp::dimension> HostGridVertex;
    typedef typename GridImp::template HostGridEntity<1> HostGridEntity;
 
   using Circulator = typename GridImp::HostGridType::Edge_circulator;
   using ElementContainer = std::vector<HostGridEntity>;
 
  public:
    enum {codimension = 1};
 
    typedef typename GridImp::template Codim<1>::Entity Entity;
 
    explicit MMeshIncidentFacetsIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity)
    : mMesh_(mMesh),
      i_(0)
    {
      Circulator circulator = mMesh->getHostGrid().incident_edges(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if (!mMesh->getHostGrid().is_infinite(circulator))
          elementContainer_.push_back( *circulator );
    }
 
    explicit MMeshIncidentFacetsIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity, bool endDummy) :
      mMesh_(mMesh),
      i_(0)
    {
      Circulator circulator = mMesh->getHostGrid().incident_edges(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if (!mMesh->getHostGrid().is_infinite(circulator))
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ mMesh_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentFacetsIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const GridImp* mMesh_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
 
  template<class GridImp>
  class MMeshIncidentFacetsIteratorImp<GridImp, 3>
  {
  private:
    typedef typename GridImp::template HostGridEntity<GridImp::dimension> HostGridVertex;
    typedef typename GridImp::template HostGridEntity<1> HostGridEntity;
 
    using ElementOutput = typename GridImp::BoundaryEdgesOutput;
 
    using ElementContainer = std::vector<HostGridEntity>;
 
  public:
    enum {codimension = 1};
 
    typedef typename GridImp::template Codim<1>::Entity Entity;
 
    explicit MMeshIncidentFacetsIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity)
    : mMesh_(mMesh),
      i_(0)
    {
      ElementOutput elements;
      mMesh_->getHostGrid().finite_incident_facets( hostEntity, std::back_inserter(elements) );
 
      typename ElementOutput::iterator fit;
      for(fit = elements.begin(); fit != elements.end(); fit++)
        elementContainer_.push_back( *fit );
    }
 
    explicit MMeshIncidentFacetsIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity, bool endDummy) :
      mMesh_(mMesh),
      i_(0)
    {
      ElementOutput elements;
      mMesh_->getHostGrid().finite_incident_facets( hostEntity, std::back_inserter(elements) );
 
      typename ElementOutput::iterator fit;
      for(fit = elements.begin(); fit != elements.end(); fit++)
        ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ mMesh_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentFacetsIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const GridImp* mMesh_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
  template<class GridImp>
  class MMeshIncidentVerticesIteratorImp<GridImp, 2>
  {
  private:
    typedef typename GridImp::VertexHandle HostGridVertex;
 
   using Circulator = typename GridImp::HostGridType::Vertex_circulator;
   using ElementContainer = std::vector<HostGridVertex>;
 
  public:
    enum {codimension = GridImp::dimension};
 
    typedef typename GridImp::template Codim<codimension>::Entity Entity;
 
    explicit MMeshIncidentVerticesIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity, bool includeInfinite)
    : mMesh_(mMesh),
      i_(0)
    {
      Circulator circulator = mMesh->getHostGrid().incident_vertices(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if (includeInfinite || !mMesh->getHostGrid().is_infinite(circulator))
          elementContainer_.push_back( circulator );
    }
 
    explicit MMeshIncidentVerticesIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity, bool includeInfinite, bool endDummy) :
      mMesh_(mMesh),
      i_(0)
    {
      Circulator circulator = mMesh->getHostGrid().incident_vertices(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if (includeInfinite || !mMesh->getHostGrid().is_infinite(circulator))
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ mMesh_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentVerticesIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const GridImp* mMesh_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
 
  template<class GridImp>
  class MMeshIncidentVerticesIteratorImp<GridImp, 3>
  {
  private:
    typedef typename GridImp::VertexHandle HostGridVertex;
 
    using ElementOutput = std::list<HostGridVertex>;
 
    using ElementContainer = std::vector<HostGridVertex>;
 
  public:
    enum {codimension = GridImp::dimension};
 
    typedef typename GridImp::template Codim<codimension>::Entity Entity;
 
    explicit MMeshIncidentVerticesIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity, bool includeInfinite)
    : mMesh_(mMesh),
      i_(0)
    {
      ElementOutput elements;
      mMesh_->getHostGrid().incident_vertices( hostEntity, std::back_inserter(elements) );
 
      typename ElementOutput::iterator fit;
      for(fit = elements.begin(); fit != elements.end(); fit++)
        if (includeInfinite || !mMesh->getHostGrid().is_infinite( *fit ))
          elementContainer_.push_back( *fit );
    }
 
    explicit MMeshIncidentVerticesIteratorImp(const GridImp* mMesh, const HostGridVertex& hostEntity, bool includeInfinite, bool endDummy) :
      mMesh_(mMesh),
      i_(0)
    {
      ElementOutput elements;
      mMesh_->getHostGrid().incident_vertices( hostEntity, std::back_inserter(elements) );
 
      typename ElementOutput::iterator fit;
      for(fit = elements.begin(); fit != elements.end(); fit++)
        if (includeInfinite || !mMesh->getHostGrid().is_infinite( *fit ))
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ mMesh_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentVerticesIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const GridImp* mMesh_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
}  // namespace Dune
 
#endif