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_MMESH_INTERFACE_INCIDENTITERATOR_HH
#define DUNE_MMESH_INTERFACE_INCIDENTITERATOR_HH
 
// Dune includes
#include <dune/grid/common/gridenums.hh>
 
namespace Dune
{
 
  template<class GridImp, int dim>
  class MMeshIncidentInterfaceVerticesIteratorImp;
 
  template<class Grid>
  using MMeshIncidentInterfaceVerticesIterator = EntityIterator<Grid::dimension, Grid, MMeshIncidentInterfaceVerticesIteratorImp<Grid, Grid::dimension>>;
 
  template<class GridImp>
  class MMeshIncidentInterfaceVerticesIteratorImp<GridImp, 1>
  {
  private:
    typedef typename GridImp::VertexHandle HostGridVertex;
 
   using Circulator = typename GridImp::HostGridType::Vertex_circulator;
   using ElementContainer = std::vector<HostGridVertex>;
 
  public:
    enum {codimension = 1};
 
    typedef typename GridImp::template Codim<1>::Entity Entity;
 
    explicit MMeshIncidentInterfaceVerticesIteratorImp(const GridImp* igrid, const HostGridVertex& hostEntity)
    : mMesh_(&igrid->getMMesh()),
      i_(0)
    {
      Circulator circulator = mMesh_->getHostGrid().incident_vertices(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if (circulator->info().isInterface)
          elementContainer_.push_back( circulator );
    }
 
    explicit MMeshIncidentInterfaceVerticesIteratorImp(const GridImp* igrid, const HostGridVertex& hostEntity, bool endDummy)
    : mMesh_(&igrid->getMMesh()),
      i_(0)
    {
      Circulator circulator = mMesh_->getHostGrid().incident_vertices(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if (circulator->info().isInterface)
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ &mMesh_->interfaceGrid(), elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentInterfaceVerticesIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const typename GridImp::MMeshType* mMesh_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
 
  template<class GridImp>
  class MMeshIncidentInterfaceVerticesIteratorImp<GridImp, 2>
  {
  private:
    typedef typename GridImp::VertexHandle HostGridVertex;
 
    using ElementOutput = std::list<HostGridVertex>;
 
    using ElementContainer = std::vector<HostGridVertex>;
 
  public:
    enum {codimension = 2};
 
    typedef typename GridImp::template Codim<2>::Entity Entity;
 
    explicit MMeshIncidentInterfaceVerticesIteratorImp(const GridImp* igrid, const HostGridVertex& hostEntity)
    : mMesh_(&igrid->getMMesh()),
      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 ((*fit)->info().isInterface)
          elementContainer_.push_back( *fit );
    }
 
    explicit MMeshIncidentInterfaceVerticesIteratorImp(const GridImp* igrid, const HostGridVertex& hostEntity, bool endDummy)
    : mMesh_(&igrid->getMMesh()),
      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 ((*fit)->info().isInterface)
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ &mMesh_->interfaceGrid(), elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentInterfaceVerticesIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const typename GridImp::MMeshType* mMesh_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
 
  template<class GridImp, int dim>
  class MMeshIncidentInterfaceElementsIteratorImp;
 
  template<class Grid>
  using MMeshIncidentInterfaceElementsIterator = EntityIterator<0, Grid, MMeshIncidentInterfaceElementsIteratorImp<Grid, Grid::dimension>>;
 
  template<class GridImp>
  class MMeshIncidentInterfaceElementsIteratorImp<GridImp, 1>
  {
  private:
    typedef typename GridImp::template MMeshInterfaceEntity<0> HostGridElement;
 
    typedef typename GridImp::VertexHandle HostGridVertex;
 
   using Circulator = typename GridImp::HostGridType::Edge_circulator;
   using ElementContainer = std::vector<HostGridElement>;
 
  public:
    enum {codimension = 0};
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
 
    explicit MMeshIncidentInterfaceElementsIteratorImp(const GridImp* igrid, const HostGridVertex& hostEntity)
    : igrid_(igrid),
      i_(0)
    {
      Circulator circulator = mMesh().getHostGrid().incident_edges(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if ( mMesh().isInterface( mMesh().entity( *circulator ) ) )
          elementContainer_.push_back( *circulator );
    }
 
    explicit MMeshIncidentInterfaceElementsIteratorImp(const GridImp* igrid, const HostGridVertex& hostEntity, bool endDummy)
    : igrid_(igrid),
      i_(0)
    {
      Circulator circulator = mMesh().getHostGrid().incident_edges(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if ( mMesh().isInterface( mMesh().entity( *circulator ) ) )
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ igrid_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentInterfaceElementsIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const typename GridImp::MMeshType& mMesh() const { return igrid_->getMMesh(); }
 
    const GridImp* igrid_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
 
  template<class GridImp>
  class MMeshIncidentInterfaceElementsIteratorImp<GridImp, 2>
  {
  private:
    typedef typename GridImp::template MMeshInterfaceEntity<0> HostGridElement;
 
    typedef typename GridImp::VertexHandle HostGridVertex;
 
    using ElementOutput = std::list<HostGridElement>;
 
    using ElementContainer = std::vector<HostGridElement>;
 
  public:
    enum {codimension = 0};
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
 
    explicit MMeshIncidentInterfaceElementsIteratorImp(const GridImp* igrid, const HostGridVertex& hostEntity)
    : igrid_(igrid),
      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++)
        if ( mMesh().isInterface( mMesh().entity( *fit ) ) )
          elementContainer_.push_back( *fit );
    }
 
    explicit MMeshIncidentInterfaceElementsIteratorImp(const GridImp* igrid, const HostGridVertex& hostEntity, bool endDummy)
    : igrid_(igrid),
      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++)
        if ( mMesh().isInterface( mMesh().entity( *fit ) ) )
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ igrid_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshIncidentInterfaceElementsIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const typename GridImp::MMeshType& mMesh() const { return igrid_->getMMesh(); }
 
    const GridImp* igrid_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
 
  template<class GridImp, int dim>
  class MMeshEdgeIncidentInterfaceElementsIteratorImp;
 
  template<class Grid>
  using MMeshEdgeIncidentInterfaceElementsIterator = EntityIterator<0, Grid,
    MMeshEdgeIncidentInterfaceElementsIteratorImp<Grid, Grid::dimension>>;
 
  template<class GridImp>
  class MMeshEdgeIncidentInterfaceElementsIteratorImp<GridImp, 2>
  {
  private:
    typedef typename GridImp::template MMeshInterfaceEntity<0> HostGridElement;
 
    typedef typename GridImp::EdgeHandle HostGridEdge;
 
    using Circulator = typename GridImp::HostGridType::Facet_circulator;
 
    using ElementContainer = std::vector<HostGridElement>;
 
  public:
    enum {codimension = 0};
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
 
    explicit MMeshEdgeIncidentInterfaceElementsIteratorImp(const GridImp* igrid, const HostGridEdge& hostEntity)
    : igrid_(igrid),
    i_(0)
    {
      Circulator circulator = mMesh().getHostGrid().incident_facets(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if ( mMesh().isInterface( mMesh().entity( *circulator ) ) )
          elementContainer_.push_back( *circulator );
    }
 
    explicit MMeshEdgeIncidentInterfaceElementsIteratorImp(const GridImp* igrid, const HostGridEdge& hostEntity, bool endDummy)
    : igrid_(igrid),
    i_(0)
    {
      Circulator circulator = mMesh().getHostGrid().incident_facets(hostEntity);
      for ( std::size_t i = 0; i < CGAL::circulator_size(circulator); ++i, ++circulator )
        if ( mMesh().isInterface( mMesh().entity( *circulator ) ) )
          ++i_;
    }
 
    void increment() {
      ++i_;
    }
 
    Entity dereference() const {
      return Entity {{ igrid_, elementContainer_[i_] }};
    }
 
    bool equals(const MMeshEdgeIncidentInterfaceElementsIteratorImp& iter) const {
      return i_ == iter.i_;
    }
 
  private:
    const typename GridImp::MMeshType& mMesh() const { return igrid_->getMMesh(); }
 
    const GridImp* igrid_;
    ElementContainer elementContainer_;
    std::size_t i_;
  };
 
}  // namespace Dune
 
#endif