intersectioniterator.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_MMESH_GRID_INTERSECTIONITERATOR_HH
#define DUNE_MMESH_GRID_INTERSECTIONITERATOR_HH
 
// Dune includes
#include <dune/grid/common/intersection.hh>
 
// Dune MMesh includes
#include <dune/mmesh/grid/entity.hh>
#include <dune/mmesh/grid/intersections.hh>
 
namespace Dune {
 
template <class GridImp>
class MMeshLeafIntersectionIterator {
  enum { dim = GridImp::dimension };
 
  enum { dimworld = GridImp::dimensionworld };
 
  // The type used to store coordinates
  typedef typename GridImp::ctype ctype;
 
  typedef typename GridImp::template HostGridEntity<0> HostGridEntity;
 
 public:
  typedef Dune::Intersection<const GridImp,
                             Dune::MMeshLeafIntersection<GridImp> >
      Intersection;
 
  MMeshLeafIntersectionIterator() : i_(0) {}
 
  MMeshLeafIntersectionIterator(const GridImp* mMesh,
                                const HostGridEntity& hostEntity)
      : mMesh_(mMesh), hostEntity_(hostEntity), i_(0) {
    while (proceed()) increment();
  }
 
  MMeshLeafIntersectionIterator(const GridImp* mMesh,
                                const HostGridEntity& hostEntity, bool endDummy)
      : mMesh_(mMesh), hostEntity_(hostEntity), i_(dim + 1) {}
 
  bool equals(const MMeshLeafIntersectionIterator& other) const {
    return i_ == other.i_ && hostEntity_ == other.hostEntity_;
  }
 
  void increment() {
    do {
      ++i_;
    } while (proceed());
  }
 
  Intersection dereference() const {
    // remark: the i-th intersection in CGAL corresponds to the (dim-i)-th edge
    // in DUNE
    return MMeshLeafIntersection<GridImp>(mMesh_, hostEntity_, dim - i_);
  }
 
 private:
  bool proceed() {
    if (i_ == dim + 1) return false;
 
    // on ghosts return intersection only if adjacent entity is interior
    if (hostEntity_->info().partition == 2) {
      const auto& neighborHostEntity = hostEntity_->neighbor(dim - i_);
 
      if (mMesh_->getHostGrid().is_infinite(neighborHostEntity)) return true;
 
      // skip ghost neighbors
      if (neighborHostEntity->info().partition != 0) return true;
    }
    return false;
  }
 
  const GridImp* mMesh_;
  HostGridEntity hostEntity_;
  int i_;
};
 
}  // namespace Dune
 
#endif