quadratureimp.hh

#ifndef DUNE_FEM_QUADRATUREIMP_HH
#define DUNE_FEM_QUADRATUREIMP_HH
 
#include <cassert>
#include <vector>
 
#include <dune/common/fvector.hh>
 
#include <dune/geometry/type.hh>
 
#include <dune/fem/version.hh>
#include <dune/fem/quadrature/idprovider.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< typename FieldImp, int dim >
    class IntegrationPointListImp
    {
    public:
      typedef FieldImp FieldType;
 
    protected:
      typedef IntegrationPointListImp< FieldType, dim > ThisType;
 
      // this is used for interpolation quadratures to obtain element
      // interpolation points for face quadratures
      typedef FieldVector< FieldType, dim+1 > ElementCoordinateType;
    public:
      typedef FieldVector< FieldType, dim > CoordinateType;
 
      enum { codimension = 0 };
 
      static const int dimension = dim ;
 
    protected:
      // vector holding the coordinates for each point
      mutable std::vector< CoordinateType > points_;
 
      // identifier of the integration point list
      const size_t id_;
 
      explicit IntegrationPointListImp( size_t id )
      : points_(), id_( id )
      {}
 
    public:
      IntegrationPointListImp( const IntegrationPointListImp& ) = delete;
 
      virtual ~IntegrationPointListImp () = default;
 
      const CoordinateType &point ( size_t i ) const
      {
        assert( i < nop() );
        return points_[ i ];
      }
 
      size_t nop () const
      {
        return points_.size();
      }
 
      size_t id () const
      {
        return id_;
      }
 
      virtual int order() const = 0;
 
      virtual GeometryType geometryType () const = 0;
 
      virtual std::vector< ElementCoordinateType > interpolationPoints(const int reqDim) const
      {
        return std::vector< ElementCoordinateType >();
      }
 
      virtual bool isFaceInterpolationQuadrature(const size_t numShapeFunctions ) const { return false; }
 
    protected:
      void addIntegrationPoint( const CoordinateType &point )
      {
        points_.push_back( point );
      }
 
      void setIntegrationPoints( std::vector< CoordinateType >&& points )
      {
        points_.swap( points );
      }
    };
 
 
 
    template< typename FieldImp, int dim >
    class QuadratureImp
    : public IntegrationPointListImp< FieldImp, dim >
    {
    public:
      typedef FieldImp FieldType;
 
    private:
      typedef QuadratureImp< FieldType, dim > ThisType;
      typedef IntegrationPointListImp< FieldType, dim > BaseType;
 
    public:
      typedef typename BaseType :: CoordinateType CoordinateType;
 
    protected:
      // vector holding weights of each integration point
      mutable std::vector< FieldType > weights_;
 
      explicit QuadratureImp( size_t id )
      : BaseType( id ), weights_()
      {}
 
    public:
      QuadratureImp ( const QuadratureImp& ) = delete;
 
      virtual ~QuadratureImp () = default;
 
      const FieldType &weight ( size_t i ) const
      {
        return weights_[ i ];
      }
 
    private:
      // Disallow use of addIntegrationPoint for quadratures
      void addIntegrationPoint ( const CoordinateType &point )
      {
        BaseType :: addIntegrationPoint( point );
      }
 
    protected:
      void addQuadraturePoint ( const CoordinateType &point, const FieldType weight )
      {
        addIntegrationPoint( point );
        weights_.push_back( weight );
      }
    };
 
 
 
    // \brief Allows injection of arbitrary points as quadrature points.
    // Useful to test some features of the quadrature framework in isolation
    // and with known input data. Each TestQuadrature object gets its own
    // unique id.
    template <class ct, int dim>
    class TestQuadrature : public QuadratureImp<ct, dim>
    {
    public:
      typedef FieldVector<ct, dim> CoordinateType;
 
      // dummy value
      enum { maxOrder_ = 10 };
 
      TestQuadrature(const GeometryType& geo, int order);
 
      void newQuadraturePoint(const CoordinateType& c, ct weight);
 
      virtual GeometryType geometryType() const { return geo_; }
 
      virtual int order() const { return order_; }
 
      static size_t maxOrder() { return maxOrder_; }
 
    private:
      GeometryType geo_;
      int order_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#include "quadratureimp_inline.hh"
 
#endif // #ifndef DUNE_FEM_QUADRATUREIMP_HH