interpolation.hh

#ifndef DUNE_FEM_SPACE_LAGRANGE_INTERPOLATION_HH
#define DUNE_FEM_SPACE_LAGRANGE_INTERPOLATION_HH
 
#include <cstddef>
 
#include <utility>
 
#include "lagrangepoints.hh"
 
namespace Dune
{
 
  namespace Fem
  {
 
    // LagrangeLocalInterpolation
    // --------------------------
 
    template< class GridPart, int maxOrder, class BasisFunctionSet >
    class LagrangeLocalInterpolation
    {
      typedef LagrangeLocalInterpolation< GridPart, maxOrder, BasisFunctionSet > ThisType;
 
    public:
      typedef BasisFunctionSet BasisFunctionSetType;
      typedef LagrangePointSet< GridPart, maxOrder > LagrangePointSetType;
 
    private:
      typedef typename BasisFunctionSetType::FunctionSpaceType FunctionSpaceType;
 
    public:
      LagrangeLocalInterpolation ()
        : pointSet_( nullptr )
        , basisFunctionSet_()
      {
      }
 
      LagrangeLocalInterpolation ( const LagrangePointSetType &pointSet,
                                   const BasisFunctionSetType &basisFunctionSet )
        : pointSet_( &pointSet ),
          basisFunctionSet_( basisFunctionSet )
      {}
 
      LagrangeLocalInterpolation ( const LagrangePointSetType &pointSet,
                                   BasisFunctionSetType &&basisFunctionSet )
        : pointSet_( &pointSet ),
          basisFunctionSet_( std::forward< BasisFunctionSetType >( basisFunctionSet ) )
      {}
 
      LagrangeLocalInterpolation ( const ThisType & ) = default;
 
      LagrangeLocalInterpolation ( ThisType &&other )
        : pointSet_( std::move( other.pointSet_ ) ),
          basisFunctionSet_( std::move( other.basisFunctionSet_ ) )
      {}
 
      LagrangeLocalInterpolation &operator= ( const ThisType & ) = default;
 
      LagrangeLocalInterpolation &operator= ( ThisType &&other )
      {
        pointSet_ = other.pointSet_ ;
        basisFunctionSet_ = std::move( other.basisFunctionSet_ );
        return *this;
      }
 
      BasisFunctionSetType basisFunctionSet () const
      {
        return basisFunctionSet_;
      }
 
      template< class LocalFunction, class LocalDofVector >
      void operator() ( const LocalFunction &localFunction, LocalDofVector &localDofVector ) const
      {
        apply( localFunction, localDofVector );
      }
 
      template< class LocalFunction, class LocalDofVector >
      void apply ( const LocalFunction &localFunction, LocalDofVector &localDofVector ) const
      {
        const LagrangePointSetType &pointSet = this->pointSet();
 
        int k = 0;
        const std::size_t nop = pointSet.nop();
        for( std::size_t pt = 0; pt < nop; ++pt )
        {
          typename FunctionSpaceType::RangeType phi;
          localFunction.evaluate( pointSet[ pt ], phi );
          for( int i = 0; i < FunctionSpaceType::dimRange; ++i )
            localDofVector[ k++ ] = phi[ i ];
        }
      }
 
      void unbind()
      {
        pointSet_ = nullptr;
        // basisFunctionSet_ = BasisFunctionSetType();
      }
 
    protected:
      const LagrangePointSetType &pointSet () const
      {
        assert( pointSet_ );
        return *pointSet_;
      }
 
      const LagrangePointSetType* pointSet_ = nullptr;
      BasisFunctionSetType basisFunctionSet_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_SPACE_LAGRANGE_INTERPOLATION_HH