intersectioniteratorwrapper.hh

Go to the documentation of this file.

#ifndef DUNE_INTERSECTIONITERATORWRAPPER_HH
#define DUNE_INTERSECTIONITERATORWRAPPER_HH
 
#include <dune/common/version.hh>
 
#include <dune/grid/common/intersectioniterator.hh>
#include <dune/alugrid/common/macrogridview.hh>
 
#include <dune/alugrid/common/memory.hh>
#include <dune/alugrid/3d/alu3dinclude.hh>
 
namespace Dune {
 
template <class GridImp, class IntersectionIteratorImpl>
class IntersectionIteratorWrapper
{
  enum { dim = GridImp :: dimension };
  enum { dimworld = GridImp :: dimensionworld };
 
  typedef IntersectionIteratorWrapper<GridImp,IntersectionIteratorImpl> ThisType;
 
  typedef IntersectionIteratorImpl IntersectionIteratorImp;
 
public:
  enum { dimension      = dim };
  enum { dimensionworld = dimworld };
 
  typedef typename GridImp :: ctype ctype;
 
  typedef typename GridImp::template Codim<0>::Entity Entity;
 
  typedef typename GridImp::template Codim<1>::Geometry Geometry;
  typedef typename GridImp::template Codim<1>::LocalGeometry LocalGeometry;
 
  typedef FieldVector<ctype , dimworld> NormalType;
 
  typedef typename IntersectionIteratorImpl::Twists Twists;
  typedef typename Twists::Twist Twist;
 
  IntersectionIteratorWrapper() : itPtr_() {}
 
  template <class EntityImp>
  IntersectionIteratorWrapper(const GridImp& grid, const EntityImp & en, int wLevel , bool end)
    : itPtr_()
  {
    if(end)
      it().done( en );
    else
      it().first( en, wLevel, grid );
  }
 
  operator bool () const { return bool( itPtr_ ); }
 
  bool equals ( const ThisType &other ) const
  {
    return (itPtr_ && other.itPtr_ ) ? it().equals( other.it() ) : itPtr_ == other.itPtr_;
  }
 
  void increment ()
  {
    // if the shared pointer is unique we can increment
    if( itPtr_.unique() )
    {
      it().increment();
    }
    else
    {
      // otherwise make a copy and assign the same intersection
      // and then increment
      ALU3DSPACE SharedPointer< IntersectionIteratorImp > copy( itPtr_ );
      itPtr_.invalidate();
      it().assign( *copy );
      it().increment();
    }
  }
 
  Entity outside() const { return it().outside(); }
 
  Entity inside() const { return it().inside(); }
 
  bool boundary () const { return it().boundary(); }
 
  bool neighbor () const { return it().neighbor(); }
 
  int boundaryId () const { return it().boundaryId(); }
 
  size_t boundarySegmentIndex() const { return it().boundarySegmentIndex(); }
 
  int segmentId() const { return it().segmentId(); }
 
  LocalGeometry geometryInInside () const
  {
    return it().geometryInInside();
  }
 
  Geometry geometry () const
  {
    return it().geometry();
  }
 
  GeometryType type () const
  {
    return it().type();
  }
 
  int indexInInside () const
  {
    return it().indexInInside();
  }
 
  LocalGeometry geometryInOutside () const
  {
    return it().geometryInOutside();
  }
 
  int indexInOutside () const
  {
    return it().indexInOutside();
  }
 
  Twist twistInInside() const { return it().twistInInside(); }
 
  Twist twistInOutside() const { return it().twistInOutside(); }
 
  const NormalType unitOuterNormal ( const FieldVector< ctype, dim-1 > &local ) const
  {
    return it().unitOuterNormal( local );
  }
 
  const NormalType centerUnitOuterNormal ( ) const
  {
    const auto& refElement = GridImp::faceReferenceElement();
    assert( refElement.type() == type() );
    return unitOuterNormal(refElement.position(0,0));
  }
 
  const NormalType outerNormal ( const FieldVector< ctype, dim-1 > &local ) const
  {
    return it().outerNormal( local );
  }
 
  const NormalType integrationOuterNormal ( const FieldVector< ctype, dim-1 > &local ) const
  {
    return it().integrationOuterNormal( local );
  }
 
  int level () const { return it().level(); }
 
  bool conforming () const { return it().conforming(); }
 
  IntersectionIteratorImp & it() { return *itPtr_; }
  const IntersectionIteratorImp & it() const { return *itPtr_; }
 
  int weight() const
  {
    return it().weight();
  }
 
private:
  mutable ALU3DSPACE SharedPointer< IntersectionIteratorImp > itPtr_;
}; // end class IntersectionIteratorWrapper
 
template <class GridImp>
class LeafIntersectionWrapper
: public IntersectionIteratorWrapper<GridImp,typename GridImp::LeafIntersectionIteratorImp>
{
  typedef LeafIntersectionWrapper<GridImp> ThisType;
  typedef IntersectionIteratorWrapper<GridImp,typename GridImp::LeafIntersectionIteratorImp> BaseType;
public:
  LeafIntersectionWrapper () {}
 
  template <class EntityImp>
  LeafIntersectionWrapper(const GridImp& grid, const EntityImp & en, int wLevel , bool end )
    : BaseType( grid, en, wLevel, end )
  {
  }
 
  LeafIntersectionWrapper(const ThisType & org)
    : BaseType(org)
  {
  }
 
};
 
template <class GridImp>
class LeafIntersectionIteratorWrapper
{
  typedef LeafIntersectionIteratorWrapper<GridImp> ThisType;
  typedef LeafIntersectionWrapper<GridImp> IntersectionImp;
 
public:
  typedef Dune::Intersection< GridImp, IntersectionImp > Intersection;
 
  enum { dimension      = GridImp :: dimension  };
  enum { dimensionworld = GridImp :: dimensionworld };
 
  typedef typename GridImp :: ctype ctype;
 
  typedef typename GridImp::template Codim<0>::Entity Entity;
 
  typedef typename GridImp::template Codim<1>::Geometry Geometry;
  typedef typename GridImp::template Codim<1>::LocalGeometry LocalGeometry;
 
  typedef FieldVector<ctype , dimensionworld> NormalType;
 
  LeafIntersectionIteratorWrapper () {}
 
  template <class EntityImp>
  LeafIntersectionIteratorWrapper(const GridImp& grid, const EntityImp & en, int wLevel , bool end )
  : intersection_( IntersectionImp( grid, en, wLevel, end) )
  {}
 
  LeafIntersectionIteratorWrapper(const ThisType & org)
  : intersection_( IntersectionImp( org.impl() ) )
  {}
 
  ThisType & operator = (const ThisType & org)
  {
    impl() = org.impl();
    return *this;
  }
 
  const Intersection &dereference () const
  {
    return intersection_;
  }
 
  bool equals (const ThisType & i) const { return impl().equals( i.impl() ); }
 
  void increment()
  {
    impl().increment();
  }
protected:
  // intersection object
  Intersection intersection_;
 
  // return reference to real implementation
  IntersectionImp& impl() { return intersection_.impl(); }
  // return reference to real implementation
  const IntersectionImp& impl() const { return intersection_.impl(); }
}; // end class IntersectionIteratorWrapper
 
template <class GridImp>
class LevelIntersectionWrapper
: public IntersectionIteratorWrapper<GridImp,typename GridImp::LevelIntersectionIteratorImp>
{
  typedef LevelIntersectionWrapper<GridImp> ThisType;
  typedef IntersectionIteratorWrapper<GridImp,typename GridImp::LevelIntersectionIteratorImp> BaseType;
public:
  LevelIntersectionWrapper () {}
 
  template <class EntityImp>
  LevelIntersectionWrapper(const GridImp& grid, const EntityImp & en, int wLevel , bool end )
    : BaseType( grid, en, wLevel, end )
  {
  }
 
  LevelIntersectionWrapper(const ThisType & org)
    : BaseType(org)
  {
  }
};
 
template <class GridImp>
class LevelIntersectionIteratorWrapper
{
  typedef LevelIntersectionIteratorWrapper<GridImp> ThisType;
  typedef LevelIntersectionWrapper<GridImp> IntersectionImp;
public:
  typedef Dune::Intersection< GridImp, IntersectionImp > Intersection;
 
  enum { dimension      = GridImp :: dimension  };
  enum { dimensionworld = GridImp :: dimensionworld };
 
  typedef typename GridImp :: ctype ctype;
 
  typedef typename GridImp::template Codim<0>::Entity Entity;
 
  typedef typename GridImp::template Codim<1>::Geometry Geometry;
  typedef typename GridImp::template Codim<1>::LocalGeometry LocalGeometry;
 
  typedef FieldVector<ctype , dimensionworld> NormalType;
 
  LevelIntersectionIteratorWrapper () {}
 
  template <class EntityImp>
  LevelIntersectionIteratorWrapper(const GridImp& grid, const EntityImp & en, int wLevel , bool end )
  : intersection_( IntersectionImp( grid, en, wLevel, end ) )
  {
    if( wLevel > 0 && grid.conformingRefinement() )
    {
      // conceptually the level intersection iterator does not work for
      // bisection type grids, only on the macro level. Therefore,
      // an exception is thrown here
      DUNE_THROW( NotImplemented, "LevelIntersectionIterator does not work for bisection refinement type grids on higher levels!");
    }
  }
 
  LevelIntersectionIteratorWrapper(const ThisType & org)
  : intersection_( IntersectionImp( org.impl() ) )
  {}
 
  ThisType & operator = (const ThisType & org)
  {
    impl() = org.impl();
    return *this;
  }
 
  const Intersection &dereference () const
  {
    return intersection_;
  }
 
  bool equals (const ThisType & i) const { return impl().equals( i.impl() ); }
 
  void increment()
  {
    impl().increment();
  }
 
  // template <class,PartitionIteratorType> friend class MacroGridView; // specialize
protected:
  // intersection object
  Intersection intersection_;
 
  // return reference to real implementation
  IntersectionImp& impl() { return intersection_.impl(); }
  // return reference to real implementation
  const IntersectionImp& impl() const { return intersection_.impl(); }
}; // end class IntersectionIteratorWrapper
 
} // end namespace Dune
#endif