quadrature.hh

#ifndef DUNE_FEM_QUADRATURE_GEOMETRIC_QUADRATURE_HH
#define DUNE_FEM_QUADRATURE_GEOMETRIC_QUADRATURE_HH
 
#include <cstddef>
 
#include <dune/common/bartonnackmanifcheck.hh>
#include <dune/common/fvector.hh>
 
#include <dune/geometry/type.hh>
 
#include <dune/fem/quadrature/quadrature.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // GeometricQuadrature
    // -------------------
 
    template< class Field, int mydim, int dim, class Implementation >
    class GeometricQuadrature
    {
      using ThisType = GeometricQuadrature< Field, mydim, dim, Implementation >;
 
    public:
      using FieldType = Field;
 
      static const int mydimension = mydim;
      static const int dimension = dim;
 
      using CoordinateType = Dune::FieldVector< FieldType, dimension >;
      using LocalCoordinateType = Dune::FieldVector< FieldType, mydimension >;
 
      using QuadraturePointWrapperType = Dune::Fem::QuadraturePointWrapper< Implementation >;
 
    protected:
#ifndef DOXYGEN
      GeometricQuadrature () = default;
#endif // #ifndef DOXYGEN
 
    public:
      GeometricQuadrature ( const ThisType & ) = default;
 
      GeometricQuadrature ( ThisType && ) = default;
 
      GeometricQuadrature &operator= ( const ThisType & ) = default;
 
      GeometricQuadrature &operator= ( ThisType && ) = default;
 
      Dune::GeometryType type () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( impl().type() );
        return impl().type();
      }
 
      int order () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( impl().order() );
        return impl().order();
      }
 
      std::size_t nop () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( impl().nop() );
        return impl().nop();
      }
 
      const CoordinateType &point ( std::size_t i ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( impl().point( i ) );
        return impl().point( i );
      }
 
      const LocalCoordinateType &localPoint ( std::size_t i ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( impl().localPoint( i ) );
        return impl().localPoint( i );
      }
 
      FieldType weight ( std::size_t i ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( impl().weight( i ) );
        return impl().weight( i );
      }
 
      const QuadraturePointWrapperType operator[] ( std::size_t i ) const
      {
        return QuadraturePointWrapperType( impl(), i );
      }
 
    protected:
      const Implementation &impl () const
      {
        return static_cast< const Implementation & >( *this );
      }
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_QUADRATURE_GEOMETRIC_QUADRATURE_HH