grid/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