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_INTERFACE_INTERSECTIONITERATOR_HH
#define DUNE_MMESH_INTERFACE_INTERSECTIONITERATOR_HH
 
// Dune includes
#include <dune/grid/common/intersection.hh>
 
// Dune MMesh includes
#include <dune/mmesh/interface/entity.hh>
#include <dune/mmesh/interface/intersections.hh>
 
namespace Dune {
 
template <class GridImp>
class MMeshInterfaceGridLeafIntersectionIterator {
  enum { dimension = GridImp::dimension };
 
  enum { dimensionworld = GridImp::dimensionworld };
 
  // The type used to store coordinates
  typedef typename GridImp::ctype ctype;
 
  typedef typename GridImp::template MMeshInterfaceEntity<0>
      MMeshInterfaceEntity;
 
 public:
  typedef Dune::Intersection<const GridImp,
                             Dune::MMeshInterfaceGridLeafIntersection<GridImp> >
      Intersection;
 
  MMeshInterfaceGridLeafIntersectionIterator() {}
 
  MMeshInterfaceGridLeafIntersectionIterator(
      const GridImp* grid, const MMeshInterfaceEntity& hostEntity)
      : grid_(grid), hostEntity_(hostEntity), i_(0), nbIdx_(0) {
    const auto& indexSet = grid_->leafIndexSet();
    const auto& cgalIndex =
        MMeshInterfaceImpl::computeCGALIndices<MMeshInterfaceEntity, dimension>(
            hostEntity);
 
    for (int d = 0; d < dimension + 1; ++d) {
      std::array<std::size_t, dimension> ids;
      if constexpr (dimension == 1) {
        ids[0] = indexSet.vertexIndexMap().at(
            hostEntity.first->vertex(cgalIndex[d])->info().id);
      } else  // dim == 2
      {
        ids[0] = indexSet.vertexIndexMap().at(
            hostEntity.first->vertex(cgalIndex[d == 2 ? 1 : 0])->info().id);
        ids[1] = indexSet.vertexIndexMap().at(
            hostEntity.first->vertex(cgalIndex[d == 0 ? 1 : 2])->info().id);
      }
 
      try {
        std::sort(ids.begin(), ids.end());
        maxNbIdx_[d] = (int)indexSet.indexMap().at(ids).size() - 2;
      } catch (std::exception& e) {
        DUNE_THROW(InvalidStateException, e.what());
      }
    }
 
    while (skip()) increment();
  }
 
  MMeshInterfaceGridLeafIntersectionIterator(
      const GridImp* grid, const MMeshInterfaceEntity& hostEntity,
      bool endDummy)
      : grid_(grid), hostEntity_(hostEntity), i_(dimension + 1), nbIdx_(0) {}
 
  bool equals(const MMeshInterfaceGridLeafIntersectionIterator& other) const {
    return hostEntity_ == other.hostEntity_ && i_ == other.i_ &&
           nbIdx_ == other.nbIdx_;
  }
 
  void increment() {
    if (maxNbIdx_[i_] != -1 and nbIdx_ < maxNbIdx_[i_])
      nbIdx_++;
    else {
      ++i_;
      nbIdx_ = 0;
    }
 
    if (skip()) increment();
  }
 
  Intersection dereference() const {
    return MMeshInterfaceGridLeafIntersection<GridImp>(grid_, hostEntity_, i_,
                                                       nbIdx_);
  }
 
 private:
  bool skip() {
    if (i_ == dimension + 1) return false;
    if (grid_->entity(hostEntity_).partitionType() == GhostEntity)
      return maxNbIdx_[i_] == -1 ||
             dereference().outside().partitionType() == GhostEntity;
    return false;
  }
 
  const GridImp* grid_;
  MMeshInterfaceEntity hostEntity_;
  std::size_t i_;
  std::size_t nbIdx_;
  std::array<int, dimension + 1> maxNbIdx_;
};
 
}  // namespace Dune
 
#endif