function.hh

#ifndef DUNE_FEM_FUNCTION_HH
#define DUNE_FEM_FUNCTION_HH
 
// dune-common includes
#include <dune/common/fvector.hh>
 
// dune-fem includes
#include <dune/fem/misc/bartonnackmaninterface.hh>
#include <dune/fem/operator/common/mapping.hh>
#include <dune/fem/version.hh>
 
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class FunctionSpaceImp, class FunctionImp >
    class Function
    : public BartonNackmanInterface< Function< FunctionSpaceImp, FunctionImp >,
                                     FunctionImp >,
      public Mapping < typename FunctionSpaceImp :: DomainFieldType,
                       typename FunctionSpaceImp :: RangeFieldType,
                       typename FunctionSpaceImp :: DomainType,
                       typename FunctionSpaceImp :: RangeType >
    {
      typedef Function< FunctionSpaceImp, FunctionImp > ThisType;
      typedef BartonNackmanInterface< ThisType, FunctionImp > BaseType;
 
    public:
      typedef FunctionSpaceImp FunctionSpaceType;
 
      typedef FunctionImp FunctionType;
 
      typedef typename FunctionSpaceType :: DomainFieldType DomainFieldType;
      typedef typename FunctionSpaceType :: RangeFieldType RangeFieldType;
      typedef typename FunctionSpaceType :: DomainType DomainType;
      typedef typename FunctionSpaceType :: RangeType RangeType;
      typedef typename FunctionSpaceType :: JacobianRangeType JacobianRangeType;
      typedef typename FunctionSpaceType :: HessianRangeType HessianRangeType;
 
      typedef Mapping< DomainFieldType, RangeFieldType, DomainType, RangeType >
        MappingType;
 
    protected:
      using BaseType::asImp;
 
      Function () = default;
 
      Function ( const ThisType& ) = default;
 
    public:
      ThisType& operator= ( const ThisType& ) = delete;
 
      virtual ~Function ()
      {}
 
      virtual void operator()(const DomainType & arg, RangeType & dest) const
      {
        evaluate(arg,dest);
      }
 
      void evaluate ( const DomainType &x, RangeType &value ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().evaluate( x, value ) );
      }
 
      void jacobian ( const DomainType &x, JacobianRangeType &jacobian ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().jacobian( x, jacobian ) );
      }
 
      void hessian ( const DomainType &x, HessianRangeType &hessian ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().hessian( x, hessian ) );
      }
 
    private:
      virtual void apply (const DomainType& arg, RangeType& dest) const
      {
        operator()(arg, dest);
      }
    };
 
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_FUNCTION_HH