localfunctionsetadapter.hh

#ifndef DUNE_FEM_FUNCTION_LOCALFUNCTION_LOCALFUNCTIONSETADAPTER_HH
#define DUNE_FEM_FUNCTION_LOCALFUNCTION_LOCALFUNCTIONSETADAPTER_HH
 
#include <cassert>
#include <cstddef>
 
#include <dune/fem/common/coordinate.hh>
#include <dune/fem/storage/entitygeometry.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // LocalFunctionSetAdapter
    // -----------------------
 
    template< class Entity, class FunctionSet >
    struct LocalFunctionSetAdapter
      : public EntityGeometryStorage< Entity >
    {
    protected:
      typedef EntityGeometryStorage< Entity > BaseType;
 
    public:
      typedef typename BaseType::EntityType EntityType;
 
      typedef typename BaseType::Geometry  Geometry;
 
      typedef FunctionSet FunctionSetType;
 
      typedef typename FunctionSet::FunctionSpaceType FunctionSpaceType;
 
      typedef typename FunctionSpaceType::DomainType DomainType;
      typedef typename FunctionSpaceType::RangeType RangeType;
      typedef typename FunctionSpaceType::JacobianRangeType JacobianRangeType;
      typedef typename FunctionSpaceType::HessianRangeType HessianRangeType;
 
      explicit LocalFunctionSetAdapter ( const FunctionSet &functionSet = FunctionSet() )
        : BaseType(),
          functionSet_( functionSet )
      {}
 
      explicit LocalFunctionSetAdapter ( const Entity &entity, const FunctionSet &functionSet = FunctionSet() )
        : BaseType( entity ), functionSet_( functionSet )
      {}
 
      int order () const { return functionSet_.order(); }
 
      using BaseType :: entity;
      using BaseType :: geometry;
      using BaseType :: bind;
      using BaseType :: unbind;
 
      std::size_t size () const { return functionSet().size(); }
 
      template< class Point, class Functor >
      void evaluateEach ( const Point &x, Functor functor ) const
      {
        DomainType y = geometry().global( coordinate( x ) );
        functionSet().evaluateEach( y, functor );
      }
 
      template< class Point, class Functor >
      void jacobianEach ( const Point &x, Functor functor ) const
      {
        DomainType y = geometry().global( coordinate( x ) );
        functionSet().jacobianEach( y, functor );
      }
 
      template< class Point, class Functor >
      void hessianEach ( const Point &x, Functor functor ) const
      {
        DomainType y = geometry().global( coordinate( x ) );
        functionSet().hessianEach( y, functor );
      }
 
      // Non-interface methods
      // ---------------------
 
      const FunctionSetType functionSet () const { return functionSet_; }
 
    private:
      FunctionSetType functionSet_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_FUNCTION_LOCALFUNCTION_LOCALFUNCTIONSETADAPTER_HH