localfunctionwrapper.hh

#ifndef __DUNE_ACFEM_LOCALFUNCTIONWRAPPER_HH__
#define __DUNE_ACFEM_LOCALFUNCTIONWRAPPER_HH__
 
#include <dune/fem/function/common/discretefunction.hh>
#include "../expressions/expressionoperations.hh"
#include "../common/stringhelper.hh"
#include "gridfunctionexpression.hh"
 
namespace Dune
{
 
  namespace ACFem
  {
 
    template<class LocalFunctionImpl, class GridPart>
    class LocalFunctionWrapper;
 
    template<class LocalFunctionImpl, class GridPart>
    struct LocalFunctionWrapperTraits
    {
      typedef typename LocalFunctionImpl::FunctionSpaceType FunctionSpaceType;
      typedef GridPart GridPartType;
 
      typedef typename FunctionSpaceType::RangeFieldType RangeFieldType;
      typedef typename FunctionSpaceType::DomainFieldType DomainFieldType;
      typedef typename FunctionSpaceType::RangeType RangeType;
      typedef typename FunctionSpaceType::DomainType DomainType;
      typedef typename FunctionSpaceType::JacobianRangeType JacobianRangeType;
      typedef typename FunctionSpaceType::HessianRangeType HessianRangeType;
 
      typedef typename GridPartType::GridType GridType;
      typedef typename GridPartType::template Codim<0>::EntityType EntityType;
      typedef typename GridPartType::template Codim<0>::IteratorType IteratorType;
      typedef typename GridPartType::IndexSetType IndexSetType;
 
      typedef Fem::DiscreteFunctionSpaceAdapter<FunctionSpaceType, GridPartType> DiscreteFunctionSpaceType;
 
      typedef LocalFunctionWrapper<LocalFunctionImpl, GridPart> DiscreteFunctionType;
    };
 
    template<class LocalFunctionImpl, class GridPart>
    class LocalFunctionWrapper
      : public GridFunctionExpression<typename LocalFunctionImpl::FunctionSpaceType,
                                      LocalFunctionWrapper<LocalFunctionImpl, GridPart>,
                                      ExpressionTemplate>
    {
      typedef LocalFunctionWrapper<LocalFunctionImpl, GridPart> ThisType;
      typedef GridFunctionExpression<typename LocalFunctionImpl::FunctionSpaceType, ThisType, ExpressionTemplate> ExpressionBaseType;
 
     public:
 
      typedef ThisType  DiscreteFunctionType;
 
      typedef LocalFunctionImpl LocalFunctionImplType;
 
      typedef GridPart GridPartType;
 
      typedef LocalFunctionWrapperTraits<LocalFunctionImplType, GridPartType> TraitsType;
 
      typedef typename TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
 
      typedef typename TraitsType::GridType GridType;
      typedef typename TraitsType::DomainFieldType DomainFieldType ;
      typedef typename TraitsType::RangeFieldType RangeFieldType ;
      typedef typename TraitsType::DomainType DomainType;
      typedef typename TraitsType::RangeType RangeType;
      typedef typename TraitsType::JacobianRangeType JacobianRangeType;
      typedef typename TraitsType::HessianRangeType HessianRangeType;
      typedef typename TraitsType::EntityType EntityType;
 
     private:
      class LocalFunction;
      using ExpressionBaseType::expressionName_;
 
     public:
      typedef LocalFunction LocalFunctionType;
 
      LocalFunctionWrapper (const std::string &name,
                            const LocalFunctionImplType &eval,
                            const GridPartType &gridPart,
                            unsigned int order = DiscreteFunctionSpaceType::polynomialOrder)
        : space_(gridPart, order),
          localFunctionImpl_(eval)
      {
        expressionName_ = makeName(name);
      }
 
      void evaluate(const DomainType &global, RangeType &result) const
      {
        DUNE_THROW(NotImplemented, "LocalFunctionWrapper::evaluate is not implemented.");
        result = 0;
      }
 
      void jacobian(const DomainType &global, JacobianRangeType &result) const
      {
        DUNE_THROW(NotImplemented, "LocalFunctionWrapper::jacobian is not implemented.");
        result = 0;
      }
 
      void hessian(const DomainType &global, HessianRangeType &result) const
      {
        DUNE_THROW(NotImplemented, "LocalFunctionWrapper::hessian is not implemented.");
        result = 0;
      }
 
      LocalFunctionType localFunction(const EntityType &entity)
      {
        return LocalFunctionType(entity, *this);
      }
 
      const LocalFunctionType localFunction(const EntityType &entity) const
      {
        return LocalFunctionType(entity, *this);
      }
 
      const DiscreteFunctionSpaceType &space () const
      {
        return space_;
      }
 
    protected:
      // Remove any outer redundant parenthesis and wrap into "W(.)"
      static std::string makeName(const std::string& name)
      {
        std::string result(name);
        trimParenthesis(result);
        result = "L(" + result + ")";
        return result;
      }
 
      DiscreteFunctionSpaceType space_;
      LocalFunctionImplType localFunctionImpl_;
    };
 
 
    template<class LocalFunctionImpl, class GridPart>
    class LocalFunctionWrapper<LocalFunctionImpl, GridPart>::LocalFunction
    {
      typedef LocalFunction ThisType;
 
    public:
      typedef LocalFunctionImpl LocalFunctionImplType;
 
      typedef LocalFunctionWrapperTraits<LocalFunctionImplType, GridPart> TraitsType;
 
      typedef typename TraitsType::FunctionSpaceType FunctionSpaceType;
      typedef GridPart GridPartType;
 
      typedef typename TraitsType::DomainFieldType DomainFieldType;
      typedef typename TraitsType::RangeFieldType RangeFieldType;
      typedef typename TraitsType::DomainType DomainType;
      typedef typename TraitsType::RangeType RangeType;
      typedef typename TraitsType::JacobianRangeType JacobianRangeType;
      typedef typename TraitsType::HessianRangeType HessianRangeType;
 
 
      typedef typename TraitsType::DiscreteFunctionType DiscreteFunctionType;
      typedef typename TraitsType::EntityType EntityType;
 
      LocalFunction(const EntityType &entity, const DiscreteFunctionType &wrapper)
      : entity_(&entity),
        wrapper_(wrapper),
        localFunctionImpl_(wrapper_.localFunctionImpl_)
      {
        // add local function to list
        localFunctionImpl_.init(entity);
      }
 
      explicit LocalFunction(const DiscreteFunctionType &wrapper)
      : entity_(0),
        wrapper_(wrapper),
        localFunctionImpl_(wrapper.localFunctionImpl_)
      {}
 
      template<class PointType>
      void evaluate (const PointType &x, RangeType &ret) const
      {
        localFunctionImpl_.evaluate(x, ret);
      }
 
      template<class PointType>
      void jacobian (const PointType &x, JacobianRangeType &ret) const
      {
        localFunctionImpl_.jacobian(x, ret);
      }
 
      // hessian of local function
      template<class PointType>
      void hessian (const PointType &x, HessianRangeType &ret) const
      {
        localFunctionImpl_.hessian(x, ret);
      }
 
      template<class QuadratureType, class VectorType>
      void evaluateQuadrature(const QuadratureType& quadrature, VectorType& values) const
      {
        assert(values.size() == quadrature.nop());
        DiscreteFunctionType::evaluateQuadratureImp(*this, quadrature, values, values[0]);
      }
 
      void init(const EntityType& entity)
      {
        entity_ = &entity;
        localFunctionImpl_.init(entity);
      }
 
      inline const EntityType& entity() const
      {
        assert( entity_ );
        return *entity_;
      }
 
      int order () const
      {
        return localFunctionImpl_.order();
      }
 
    protected:
      EntityType const* entity_;
      const DiscreteFunctionType &wrapper_;
      LocalFunctionImplType localFunctionImpl_;
    };
 
  } // namespace ACFem
 
} // namespace Dune
 
 
#endif // #ifndef DUNE_FEM_LOCALFUNCTIONWRAPPER_HH