cachingquadrature.hh

#ifndef DUNE_FEM_CACHINGQUADRATURE_HH
#define DUNE_FEM_CACHINGQUADRATURE_HH
 
//- Local includes
#include "elementquadrature.hh"
#include "caching/twistutility.hh"
#include "caching/pointmapper.hh"
#include "caching/cacheprovider.hh"
 
#include "cachingpointlist.hh"
 
namespace Dune
{
  namespace Fem
  {
 
    template< typename GridPartImp, int codim, template <class, int> class QuadratureTraits = DefaultQuadratureTraits >
    class CachingQuadrature;
 
 
 
    template< typename GridPart, template <class, int> class QuadratureTraits >
    class CachingQuadrature< GridPart, 0, QuadratureTraits >
    : public CachingPointList< GridPart, 0, ElementQuadratureTraits< GridPart, 0, QuadratureTraits > >
    {
    public:
      typedef GridPart GridPartType;
 
      static constexpr auto codimension = 0;
 
    private:
      typedef ElementQuadratureTraits< GridPartType, codimension, QuadratureTraits > IntegrationTraits;
 
      typedef CachingQuadrature< GridPartType, codimension, QuadratureTraits > ThisType;
      typedef CachingPointList< GridPartType, codimension, IntegrationTraits > BaseType;
 
    public:
      static constexpr auto dimension = BaseType::dimension;
 
      typedef typename BaseType :: RealType RealType;
      typedef typename BaseType :: CoordinateType CoordinateType;
 
      typedef typename BaseType::QuadratureKeyType QuadratureKeyType;
 
      typedef QuadraturePointWrapper< ThisType > QuadraturePointWrapperType;
      typedef QuadraturePointIterator< ThisType > IteratorType;
 
      // for compatibility
      typedef typename GridPartType::template Codim< 0 >::EntityType EntityType;
 
    protected:
      using BaseType :: quadImp;
 
    public:
      using BaseType::nop;
 
      CachingQuadrature( const EntityType &entity, const QuadratureKeyType& quadKey )
      : BaseType( entity.type(), quadKey )
      {}
 
      CachingQuadrature( const GeometryType &type, const QuadratureKeyType& quadKey )
      : BaseType( type, quadKey )
      {}
 
      CachingQuadrature( const ThisType &org )
      : BaseType( org )
      {}
 
      QuadraturePointWrapperType operator[] ( std::size_t i ) const
      {
        return QuadraturePointWrapperType( *this, i );
      }
 
      IteratorType begin () const noexcept { return IteratorType( *this, 0 ); }
      IteratorType end () const noexcept { return IteratorType( *this, nop() ); }
 
      const RealType &weight ( std::size_t i ) const
      {
        return quadImp().weight( i );
      }
    };
 
 
 
    template< typename GridPartImp, template <class, int> class QuadratureTraits  >
    class CachingQuadrature< GridPartImp, 1, QuadratureTraits >
    : public CachingPointList
      < GridPartImp, 1, ElementQuadratureTraits< GridPartImp, 1, QuadratureTraits > >
    {
    public:
      typedef GridPartImp GridPartType;
 
      static constexpr auto codimension = 1;
 
    private:
      typedef ElementQuadratureTraits< GridPartType, codimension, QuadratureTraits > IntegrationTraits;
 
      typedef CachingQuadrature< GridPartType, codimension, QuadratureTraits > ThisType;
      typedef CachingPointList< GridPartType, codimension, IntegrationTraits > BaseType;
 
    protected:
      using BaseType :: quadImp;
 
    public:
      static constexpr auto dimension = BaseType::dimension;
 
      typedef typename BaseType::RealType RealType;
 
      typedef typename BaseType::CoordinateType CoordinateType;
 
      typedef typename BaseType::QuadratureKeyType QuadratureKeyType;
 
      typedef QuadraturePointWrapper< ThisType > QuadraturePointWrapperType;
      typedef QuadraturePointIterator< ThisType > IteratorType;
 
      typedef typename BaseType :: IntersectionIteratorType IntersectionIteratorType;
      typedef typename IntersectionIteratorType :: Intersection IntersectionType;
 
      typedef ElementQuadrature< GridPartImp, codimension > NonConformingQuadratureType;
 
      using BaseType::nop;
 
      CachingQuadrature( const GridPartType &gridPart, const IntersectionType &intersection,
                         const QuadratureKeyType& quadKey, typename BaseType::Side side )
      : BaseType( gridPart, intersection, quadKey, side )
      {}
 
      CachingQuadrature( const ThisType& org )
      : BaseType( org )
      {}
 
      QuadraturePointWrapperType operator[] ( std::size_t i ) const
      {
        return QuadraturePointWrapperType( *this, i );
      }
 
      IteratorType begin () const noexcept { return IteratorType( *this, 0 ); }
      IteratorType end () const noexcept { return IteratorType( *this, nop() ); }
 
      const RealType &weight( std::size_t i ) const
      {
        return quadImp().weight(i);
      }
    };
 
    template<class GridPart, class Entity>
    static inline auto cachingQuadrature(const GridPart& gridPart, const Entity& entity, unsigned quadOrder)
    {
      using Quadrature = Dune::Fem::CachingQuadrature<GridPart, 0>;
      return Quadrature(entity, quadOrder);
    }
  } //namespace Fem
 
} //namespace Dune
 
#endif // #ifndef DUNE_FEM_CACHINGQUADRATURE_HH