elementpointlistbase.hh

#ifndef DUNE_FEM_ELEMENTPOINTLISTBASE_HH
#define DUNE_FEM_ELEMENTPOINTLISTBASE_HH
 
#include <dune/geometry/referenceelements.hh>
 
#include <dune/fem/quadrature/quadrature.hh>
 
#include <dune/fem/gridpart/common/capabilities.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class GridPartImp, int codim, class IntegrationTraits >
    class ElementPointListBase;
 
 
    template< class GridPartImp, class IntegrationTraits >
    class ElementPointListBase< GridPartImp, 0, IntegrationTraits >
    {
      typedef ElementPointListBase< GridPartImp, 0, IntegrationTraits > This;
 
    public:
      typedef GridPartImp GridPartType;
 
      enum Side { INSIDE, OUTSIDE };
 
      static const int codimension = 0;
 
      typedef typename GridPartType::ctype RealType;
 
      static const int dimension = GridPartType::dimension;
 
      typedef typename GridPartType::template Codim< 0 >::EntityType EntityType;
 
      typedef typename IntegrationTraits::IntegrationPointListType IntegrationPointListType;
 
      typedef typename IntegrationTraits::CoordinateType CoordinateType;
      typedef typename IntegrationPointListType::CoordinateType LocalCoordinateType;
 
      //typedef typename IntegrationPointListType :: QuadratureKeyType  QuadratureKeyType;
 
      template <class QuadratureKey>
      ElementPointListBase ( const GeometryType &geometry, const QuadratureKey& quadKey )
      : quad_( geometry, quadKey )
      {}
 
      ElementPointListBase ( const IntegrationPointListType& ipList )
      : quad_( ipList )
      {}
 
      size_t nop () const
      {
        return quadImp().nop();
      }
 
      const LocalCoordinateType &localPoint( size_t i ) const
      {
        return quadImp().point( i );
      }
 
      size_t id () const
      {
        return quadImp().id();
      }
 
      int order () const
      {
        return quadImp().order();
      }
 
      GeometryType geometry () const
      {
        return quadImp().geometryType();
      }
 
      GeometryType type () const
      {
        return quadImp().geometryType();
      }
 
      GeometryType geometryType () const
      {
        return quadImp().geometryType();
      }
 
      GeometryType elementGeometry () const
      {
        return quadImp().geometry();
      }
 
      size_t cachingPoint( const size_t quadraturePoint ) const
      {
        return quadraturePoint;
      }
 
      size_t localCachingPoint( const size_t quadraturePoint ) const
      {
        return quadraturePoint;
      }
 
      static constexpr bool twisted () { return false; }
 
      inline int twistId () const { return 0; }
 
      int localFaceIndex () const
      {
        return 0;
      }
 
      inline int nCachingPoints () const { return nop(); }
      inline int cachingPointStart () const { return 0; }
 
    protected:
      const IntegrationPointListType &quadImp () const
      {
        return quad_;
      }
 
    protected:
      IntegrationPointListType quad_;
    };
 
 
 
    template< class GridPartImp, int codim, class IntegrationTraits >
    class ElementPointListBase
    {
      typedef ElementPointListBase< GridPartImp, codim, IntegrationTraits > This;
 
    public:
      typedef GridPartImp GridPartType;
 
      enum Side { INSIDE, OUTSIDE };
 
      static const int codimension = codim;
 
      typedef typename GridPartType::ctype RealType;
 
      static const int dimension = GridPartType::dimension;
 
      typedef typename IntegrationTraits::IntegrationPointListType IntegrationPointListType;
 
      typedef typename IntegrationTraits::CoordinateType CoordinateType;
      typedef typename IntegrationPointListType::CoordinateType LocalCoordinateType;
 
      template <class QuadratureKeyType>
      ElementPointListBase ( const GeometryType &elementGeo,
                             const GeometryType &faceGeo,
                             const int localFaceIndex,
                             const QuadratureKeyType& quadKey )
      : quad_( faceGeo, quadKey ),
        elementGeometry_( elementGeo ),
        localFaceIndex_( localFaceIndex )
      {}
 
      template <class QuadratureKeyType>
      ElementPointListBase ( const GeometryType &elementGeo,
                             const int localFaceIndex,
                             const QuadratureKeyType& quadKey )
      : quad_( getFaceGeometry( elementGeo, localFaceIndex ), quadKey ),
        elementGeometry_( elementGeo ),
        localFaceIndex_( localFaceIndex )
      {}
 
      size_t nop () const
      {
        return quadImp().nop();
      }
 
      const LocalCoordinateType &localPoint ( size_t i ) const
      {
        return quad_.point( i );
      }
 
      size_t id () const
      {
        return quadImp().id();
      }
 
      int order () const
      {
        return quadImp().order();
      }
 
      GeometryType geometry () const
      {
        return quadImp().geo();
      }
 
      GeometryType elementGeometry () const
      {
        return elementGeometry_;
      }
 
      size_t cachingPoint( const size_t quadraturePoint ) const
      {
        return quadraturePoint;
      }
 
      size_t localCachingPoint( const size_t quadraturePoint ) const
      {
        return quadraturePoint;
      }
 
      static constexpr bool twisted () { return false; }
 
      inline int twistId () const { return 0; }
 
      inline int nCachingPoints () const { return nop(); }
      inline int cachingPointStart () const { return 0; }
 
      int localFaceIndex () const
      {
        return localFaceIndex_;
      }
 
    protected:
      const IntegrationPointListType &quadImp() const
      {
        return quad_;
      }
 
      static GeometryType
      getFaceGeometry ( const GeometryType &elementGeo, const int face )
      {
        // for cube and simplex geom types the dim-1 geom type
        // is also cube or simplex
 
        static const bool isCube =
              GridPartCapabilities::hasSingleGeometryType< GridPartType >::v &&
              GridPartCapabilities::hasSingleGeometryType< GridPartType >::topologyId == Dune::GeometryTypes::cube(dimension).id();
 
        static const bool isSimplex =
              GridPartCapabilities::hasSingleGeometryType< GridPartType >::v &&
              GridPartCapabilities::hasSingleGeometryType< GridPartType >::topologyId == Dune::GeometryTypes::simplex(dimension).id();
 
        if( isCube || isSimplex )
        {
          assert( elementGeo.dim() == dimension );
          if( isCube )
          {
            return Dune::GeometryTypes::cube( dimension-1 );
          }
          else
          {
            assert( isSimplex );
            return Dune::GeometryTypes::simplex( dimension-1 );
          }
        }
        else if( elementGeo.isNone() )
        {
          // if cell geometry is none and dim is 2 then the
          // face is a normal edge which is of type cube
          if( elementGeo.dim() == 2 )
          {
            return Dune::GeometryTypes::cube( 1 );
          }
          else
          {
            return Dune::GeometryTypes::none( elementGeo.dim()-1 );
          }
        }
        else // use reference element to determine type
        {
          assert( ! elementGeo.isNone() );
          typedef Dune::ReferenceElements< RealType, dimension > RefElements;
          return RefElements::general( elementGeo ).type( face, codimension );
        }
      }
 
    private:
      IntegrationPointListType quad_;
      GeometryType elementGeometry_;
      int localFaceIndex_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_ELEMENTPOINTLISTBASE_HH