interfaceiterator.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_MMESHINTERFACEITERATOR_HH
#define DUNE_GRID_MMESHINTERFACEITERATOR_HH
 
// Dune includes
#include <dune/grid/common/gridenums.hh>
 
namespace Dune {
template <int codim, class GridImp, int dim>
class MMeshInterfaceIteratorImp;
 
template <int codim, class Grid>
using MMeshInterfaceIterator =
    EntityIterator<codim, Grid,
                   MMeshInterfaceIteratorImp<codim, Grid, Grid::dimension>>;
 
template <class GridImp>
class MMeshInterfaceIteratorImp<1, GridImp, 2> {
 private:
  using EdgeIterator = typename GridImp::HostGridType::Finite_edges_iterator;
 
 public:
  typedef typename GridImp::template Codim<1>::Entity Entity;
 
  explicit MMeshInterfaceIteratorImp(const GridImp* mMesh, bool includeBoundary)
      : mMesh_(mMesh),
        edgeIterator_(mMesh_->getHostGrid().finite_edges_begin()),
        includeBoundary_(includeBoundary) {
    while (edgeIterator_ != mMesh_->getHostGrid().finite_edges_end()) {
      if (isInterface_())
        break;
      else
        edgeIterator_++;
    }
  }
 
  explicit MMeshInterfaceIteratorImp(const GridImp* mMesh, bool endDummy,
                                     bool includeBoundary)
      : mMesh_(mMesh),
        edgeIterator_(mMesh_->getHostGrid().finite_edges_end()),
        includeBoundary_(includeBoundary) {}
 
  void increment() {
    edgeIterator_++;
    while (edgeIterator_ != mMesh_->getHostGrid().finite_edges_end()) {
      if (isInterface_())
        break;
      else
        edgeIterator_++;
    }
  }
 
  Entity dereference() const { return Entity{{mMesh_, *edgeIterator_}}; }
 
  bool equals(const MMeshInterfaceIteratorImp& iter) const {
    return edgeIterator_ == iter.edgeIterator_;
  }
 
 private:
  bool isInterface_() const {
    if (includeBoundary_)
      return mMesh_->isInterface(dereference());
    else {
      return mMesh_->isInterface(dereference()) &&
             !mMesh_->getHostGrid().is_infinite(
                 edgeIterator_->first)  // exclude boundary segments
             && !mMesh_->getHostGrid().is_infinite(
                    edgeIterator_->first->neighbor(edgeIterator_->second));
    }
  }
 
  const GridImp* mMesh_;
  EdgeIterator edgeIterator_;
  bool includeBoundary_;
};
 
template <class GridImp>
class MMeshInterfaceIteratorImp<1, GridImp, 3> {
 private:
  using FacetIterator = typename GridImp::HostGridType::Finite_facets_iterator;
 
 public:
  typedef typename GridImp::template Codim<1>::Entity Entity;
 
  explicit MMeshInterfaceIteratorImp(const GridImp* mMesh, bool includeBoundary)
      : mMesh_(mMesh),
        facetIterator_(mMesh_->getHostGrid().finite_facets_begin()),
        includeBoundary_(includeBoundary) {
    while (facetIterator_ != mMesh_->getHostGrid().finite_facets_end()) {
      if (isInterface_())
        break;
      else
        facetIterator_++;
    }
  }
 
  explicit MMeshInterfaceIteratorImp(const GridImp* mMesh, bool endDummy,
                                     bool includeBoundary)
      : mMesh_(mMesh),
        facetIterator_(mMesh_->getHostGrid().finite_facets_end()),
        includeBoundary_(includeBoundary) {}
 
  void increment() {
    facetIterator_++;
    while (facetIterator_ != mMesh_->getHostGrid().finite_facets_end()) {
      if (isInterface_())
        break;
      else
        facetIterator_++;
    }
  }
 
  Entity dereference() const { return Entity{{mMesh_, *facetIterator_}}; }
 
  bool equals(const MMeshInterfaceIteratorImp& iter) const {
    return facetIterator_ == iter.facetIterator_;
  }
 
 private:
  bool isInterface_() const {
    if (includeBoundary_)
      return mMesh_->isInterface(dereference());
    else {
      return mMesh_->isInterface(dereference()) &&
             !mMesh_->getHostGrid().is_infinite(
                 facetIterator_->first)  // exclude boundary segments
             && !mMesh_->getHostGrid().is_infinite(
                    facetIterator_->first->neighbor(facetIterator_->second));
    }
  }
 
  const GridImp* mMesh_;
  FacetIterator facetIterator_;
  bool includeBoundary_;
};
 
template <class GridImp, int dim>
class MMeshInterfaceVertexIteratorImp;
 
template <class Grid>
using MMeshInterfaceVertexIterator =
    EntityIterator<Grid::dimension, Grid,
                   MMeshInterfaceVertexIteratorImp<Grid, Grid::dimension>>;
 
template <class GridImp, int dim>
class MMeshInterfaceVertexIteratorImp {
 private:
  using InterfaceIterator = MMeshInterfaceIterator<1, GridImp>;
  using InterfaceIteratorImpl = typename InterfaceIterator::Implementation;
 
 public:
  typedef typename GridImp::template Codim<dim>::Entity Vertex;
 
  explicit MMeshInterfaceVertexIteratorImp(const GridImp* mMesh,
                                           bool includeBoundary)
      : mMesh_(mMesh),
        interfaceIterator_(InterfaceIteratorImpl(mMesh_, includeBoundary)),
        interfaceEnd_(InterfaceIteratorImpl(mMesh_, true, includeBoundary)),
        i_(0) {
    if (interfaceIterator_ != interfaceEnd_) {
      // add first vertex to visited
      std::size_t id = dereference().impl().hostEntity()->info().id;
      visited.insert(id);
    }
  }
 
  explicit MMeshInterfaceVertexIteratorImp(const GridImp* mMesh, bool endDummy,
                                           bool includeBoundary)
      : mMesh_(mMesh),
        interfaceIterator_(
            InterfaceIteratorImpl(mMesh_, true, includeBoundary)),
        interfaceEnd_(InterfaceIteratorImpl(mMesh_, true, includeBoundary)),
        i_(0) {}
 
  void increment() {
    i_++;
 
    if (i_ == dim) {
      i_ = 0;
      interfaceIterator_++;
    }
 
    if (interfaceIterator_ != interfaceEnd_) {
      // check if already visited
      std::size_t id = dereference().impl().hostEntity()->info().id;
      int count = visited.count(id);
      assert(count <= 1);
      if (count > 0)
        increment();
      else
        visited.insert(id);
    }
  }
 
  Vertex dereference() const {
    const auto host = interfaceIterator_->impl().hostEntity();
    return Vertex{
        {mMesh_, host.first->vertex((host.second + i_ + 1) % (dim + 1))}};
  }
 
  bool equals(const MMeshInterfaceVertexIteratorImp& iter) const {
    return interfaceIterator_ == iter.interfaceIterator_ && i_ == iter.i_;
  }
 
 private:
  const GridImp* mMesh_;
  InterfaceIterator interfaceIterator_, interfaceEnd_;
  std::unordered_set<std::size_t> visited;
  int i_;
};
 
}  // namespace Dune
 
#endif