grid/leafiterator.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_MMESHLEAFITERATOR_HH
#define DUNE_MMESH_GRID_MMESHLEAFITERATOR_HH
 
// Dune includes
#include <dune/grid/common/gridenums.hh>
 
namespace Dune {
 
template <int codim, PartitionIteratorType pitype, class GridImp,
          typename Enable = void>
class MMeshLeafIteratorImp {};
 
template <int codim, PartitionIteratorType pitype, class GridImp>
using MMeshLeafIterator = MMeshLeafIteratorImp<codim, pitype, GridImp>;
 
template <PartitionIteratorType pitype, class GridImp>
class MMeshLeafIteratorImp<0, pitype, GridImp,
                           std::enable_if_t<GridImp::dimension == 2>> {
 public:
  using HostGridLeafIterator =
      typename GridImp::HostGridType::Finite_faces_iterator;
  enum { codimension = 0 };
 
  typedef typename GridImp::template Codim<0>::Entity Entity;
 
  explicit MMeshLeafIteratorImp() : mMesh_(nullptr) {}
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh)
      : mMesh_(mMesh),
        hostLeafIterator_(pitype == Interior_Partition
                              ? mMesh->partitionHelper().leafInteriorBegin()
                              : mMesh->getHostGrid().finite_faces_begin()) {
    while (proceed()) increment();
  }
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh, bool endDummy)
      : mMesh_(mMesh),
        hostLeafIterator_(pitype == Interior_Partition
                              ? mMesh->partitionHelper().leafInteriorEnd()
                              : mMesh->getHostGrid().finite_faces_end()) {}
 
  void increment() {
    do {
      ++hostLeafIterator_;
    } while (proceed());
  }
 
  Entity dereference() const { return Entity{{mMesh_, hostLeafIterator_}}; }
 
  bool equals(const MMeshLeafIteratorImp& i) const {
    return hostLeafIterator_ == i.hostLeafIterator_;
  }
 
 private:
  bool proceed() {
    const auto endIterator = (pitype == Interior_Partition
                                  ? mMesh_->partitionHelper().leafInteriorEnd()
                                  : mMesh_->getHostGrid().finite_faces_end());
    if (hostLeafIterator_ == endIterator) return false;
    return !mMesh_->partitionHelper().contains(
        pitype, hostLeafIterator_->info().partition);
  }
 
  const GridImp* mMesh_;
  HostGridLeafIterator hostLeafIterator_;
};
 
template <PartitionIteratorType pitype, class GridImp>
class MMeshLeafIteratorImp<1, pitype, GridImp,
                           std::enable_if_t<GridImp::dimension == 2>> {
 private:
  using HostGridLeafIterator =
      typename GridImp::HostGridType::Finite_edges_iterator;
 
 public:
  enum { codimension = 1 };
 
  typedef typename GridImp::template Codim<1>::Entity Entity;
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_edges_begin()) {
    while (proceed()) increment();
  }
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh, bool endDummy)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_edges_end()) {}
 
  void increment() {
    do {
      ++hostLeafIterator_;
    } while (proceed());
  }
 
  Entity dereference() const { return Entity{{mMesh_, *hostLeafIterator_}}; }
 
  bool equals(const MMeshLeafIteratorImp& i) const {
    return hostLeafIterator_ == i.hostLeafIterator_;
  }
 
 private:
  bool proceed() {
    if (hostLeafIterator_ == mMesh_->getHostGrid().finite_edges_end())
      return false;
    return !mMesh_->partitionHelper().contains(pitype, dereference());
  }
  const GridImp* mMesh_;
 
  HostGridLeafIterator hostLeafIterator_;
};
 
template <PartitionIteratorType pitype, class GridImp>
class MMeshLeafIteratorImp<2, pitype, GridImp,
                           std::enable_if_t<GridImp::dimension == 2>> {
 private:
  using HostGridLeafIterator =
      typename GridImp::HostGridType::Finite_vertices_iterator;
 
 public:
  enum { codimension = GridImp::dimension };
 
  typedef typename GridImp::template Codim<codimension>::Entity Entity;
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_vertices_begin()) {
    while (proceed()) increment();
  }
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh, bool endDummy)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_vertices_end()) {}
 
  void increment() {
    do {
      ++hostLeafIterator_;
    } while (proceed());
  }
 
  Entity dereference() const { return Entity{{mMesh_, hostLeafIterator_}}; }
 
  bool equals(const MMeshLeafIteratorImp& i) const {
    return hostLeafIterator_ == i.hostLeafIterator_;
  }
 
 private:
  bool proceed() {
    if (hostLeafIterator_ == mMesh_->getHostGrid().finite_vertices_end())
      return false;
    return !mMesh_->partitionHelper().contains(
        pitype, hostLeafIterator_->info().partition);
  }
 
  const GridImp* mMesh_;
  HostGridLeafIterator hostLeafIterator_;
};
 
template <PartitionIteratorType pitype, class GridImp>
class MMeshLeafIteratorImp<0, pitype, GridImp,
                           std::enable_if_t<GridImp::dimension == 3>> {
 public:
  using HostGridLeafIterator =
      typename GridImp::HostGridType::Finite_cells_iterator;
 
  enum { codimension = 0 };
 
  typedef typename GridImp::template Codim<0>::Entity Entity;
 
  explicit MMeshLeafIteratorImp() : mMesh_(nullptr) {}
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh)
      : mMesh_(mMesh),
        hostLeafIterator_(pitype == Interior_Partition
                              ? mMesh->partitionHelper().leafInteriorBegin()
                              : mMesh->getHostGrid().finite_cells_begin()) {
    while (proceed()) increment();
  }
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh, bool endDummy)
      : mMesh_(mMesh),
        hostLeafIterator_(pitype == Interior_Partition
                              ? mMesh->partitionHelper().leafInteriorEnd()
                              : mMesh->getHostGrid().finite_cells_end()) {}
 
  void increment() {
    do {
      ++hostLeafIterator_;
    } while (proceed());
  }
 
  Entity dereference() const { return Entity{{mMesh_, hostLeafIterator_}}; }
 
  bool equals(const MMeshLeafIteratorImp& i) const {
    return hostLeafIterator_ == i.hostLeafIterator_;
  }
 
 private:
  bool proceed() {
    const auto endIterator = (pitype == Interior_Partition
                                  ? mMesh_->partitionHelper().leafInteriorEnd()
                                  : mMesh_->getHostGrid().finite_cells_end());
    if (hostLeafIterator_ == endIterator) return false;
    return !mMesh_->partitionHelper().contains(
        pitype, hostLeafIterator_->info().partition);
  }
 
  const GridImp* mMesh_;
  HostGridLeafIterator hostLeafIterator_;
};
 
template <PartitionIteratorType pitype, class GridImp>
class MMeshLeafIteratorImp<1, pitype, GridImp,
                           std::enable_if_t<GridImp::dimension == 3>> {
 private:
  using HostGridLeafIterator =
      typename GridImp::HostGridType::Finite_facets_iterator;
 
 public:
  enum { codimension = 1 };
 
  typedef typename GridImp::template Codim<1>::Entity Entity;
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_facets_begin()) {
    while (proceed()) increment();
  }
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh, bool endDummy)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_facets_end()) {}
 
  void increment() {
    do {
      ++hostLeafIterator_;
    } while (proceed());
  }
 
  Entity dereference() const { return Entity{{mMesh_, *hostLeafIterator_}}; }
 
  bool equals(const MMeshLeafIteratorImp& i) const {
    return hostLeafIterator_ == i.hostLeafIterator_;
  }
 
 private:
  bool proceed() {
    if (hostLeafIterator_ == mMesh_->getHostGrid().finite_facets_end())
      return false;
    return !mMesh_->partitionHelper().contains(pitype, dereference());
  }
 
  const GridImp* mMesh_;
  HostGridLeafIterator hostLeafIterator_;
};
 
template <PartitionIteratorType pitype, class GridImp>
class MMeshLeafIteratorImp<2, pitype, GridImp,
                           std::enable_if_t<GridImp::dimension == 3>> {
 private:
  using HostGridLeafIterator =
      typename GridImp::HostGridType::Finite_edges_iterator;
 
 public:
  enum { codimension = 2 };
 
  typedef typename GridImp::template Codim<2>::Entity Entity;
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_edges_begin()) {
    while (proceed()) increment();
  }
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh, bool endDummy)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_edges_end()) {}
 
  void increment() {
    do {
      ++hostLeafIterator_;
    } while (proceed());
  }
 
  Entity dereference() const { return Entity{{mMesh_, *hostLeafIterator_}}; }
 
  bool equals(const MMeshLeafIteratorImp& i) const {
    return hostLeafIterator_ == i.hostLeafIterator_;
  }
 
 private:
  bool proceed() {
    if (hostLeafIterator_ == mMesh_->getHostGrid().finite_edges_end())
      return false;
    return !mMesh_->partitionHelper().contains(pitype, dereference());
  }
 
  const GridImp* mMesh_;
  HostGridLeafIterator hostLeafIterator_;
};
 
template <PartitionIteratorType pitype, class GridImp>
class MMeshLeafIteratorImp<3, pitype, GridImp,
                           std::enable_if_t<GridImp::dimension == 3>> {
 private:
  typedef typename GridImp::HostGridType::Vertex_iterator HostGridLeafIterator;
 
 public:
  enum { codimension = GridImp::dimension };
 
  typedef typename GridImp::template Codim<codimension>::Entity Entity;
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_vertices_begin()) {
    while (proceed()) increment();
  }
 
  explicit MMeshLeafIteratorImp(const GridImp* mMesh, bool endDummy)
      : mMesh_(mMesh),
        hostLeafIterator_(mMesh->getHostGrid().finite_vertices_end()) {}
 
  void increment() {
    do {
      ++hostLeafIterator_;
    } while (proceed());
  }
 
  Entity dereference() const { return Entity{{mMesh_, hostLeafIterator_}}; }
 
  bool equals(const MMeshLeafIteratorImp& i) const {
    return hostLeafIterator_ == i.hostLeafIterator_;
  }
 
 private:
  bool proceed() {
    if (hostLeafIterator_ ==
        HostGridLeafIterator(mMesh_->getHostGrid().finite_vertices_end()))
      return false;
    if (hostLeafIterator_ == mMesh_->getHostGrid().infinite_vertex())
      return true;
    return !mMesh_->partitionHelper().contains(
        pitype, hostLeafIterator_->info().partition);
  }
 
  const GridImp* mMesh_;
  HostGridLeafIterator hostLeafIterator_;
};
 
}  // namespace Dune
 
#endif