gridfunctionwrapper.hh

#ifndef DUNE_ACFEM_GRIDFUNCTIONWRAPPER_HH
#define DUNE_ACFEM_GRIDFUNCTIONWRAPPER_HH
 
//#include <dune/fem/function/common/gridfunctionadapter.hh>
#include "../functions/gridfunctionadapter.hh" // use our own version in order to get rid of a static_assert
 
#include "../functions/gridfunctionexpressionbase.hh"
#include "../common/stringhelper.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class FunctionImp, class GridPart>
    class GridFunctionWrapper;
 
    template<class FunctionImp, class GridPart>
    class GridFunctionWrapperTraits
      : public GridFunctionAdapterTraits<FunctionImp, GridPart>
    {
      typedef GridFunctionWrapper<FunctionImp, GridPart> DiscreteFunctionType;
    };
 
    template<class FunctionImp, class GridPart>
    class GridFunctionWrapper
      : public GridFunctionExpression<typename FunctionImp::FunctionSpaceType,
                                      GridFunctionWrapper<FunctionImp, GridPart> >
    {
      typedef GridFunctionWrapper<FunctionImp, GridPart> ThisType;
      typedef GridFunctionAdapter<FunctionImp, GridPart> BaseType;
      typedef GridFunctionAdapter<FunctionImp, GridPart> AdapterType;
      typedef GridFunctionExpression<typename FunctionImp::FunctionSpaceType, ThisType> ExpressionBaseType;
 
     public:
      typedef GridFunctionWrapperTraits<FunctionImp, GridPart> Traits;
 
      typedef GridPart GridPartType;
      typedef ThisType FunctionType;
      typedef FunctionImp FunctionImpType;
 
      typedef ThisType DiscreteFunctionType;
 
      typedef typename AdapterType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
 
      // type of discrete function space
      typedef typename AdapterType::FunctionSpaceType FunctionSpaceType;
 
      typedef typename DiscreteFunctionSpaceType::GridType GridType;
 
      typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType ;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType ;
      typedef typename DiscreteFunctionSpaceType::DomainType DomainType ;
      typedef typename DiscreteFunctionSpaceType::RangeType RangeType ;
      typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
      typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
 
      typedef typename AdapterType::EntityType EntityType;
 
      static const int dimRange = DiscreteFunctionSpaceType::dimRange;
      static const int dimDomain = GridPart::GridType::dimensionworld;
      static const int dimLocal = GridPart::GridType::dimension;
 
     private:
      class LocalFunction;
      class LocalFunctionStorage;
      using ExpressionBaseType::expressionName_;
 
     public:
      typedef LocalFunction LocalFunctionType;
      typedef LocalFunctionStorage LocalFunctionStorageType;
 
      GridFunctionWrapper(const std::string& name,
                          const FunctionImpType& function,
                          const GridPartType& gridPart,
                          unsigned int order = DiscreteFunctionSpaceType::polynomialOrder)
        : function_(function),
          localFunctionStorage_(*this),
          adapter_(name, function_, gridPart, order)
      {
        expressionName_ = makeName(adapter_.name());
      }
 
      GridFunctionWrapper(const ThisType& other)
        : ExpressionBaseType(other),
          function_(other.function_),
          localFunctionStorage_(*this),
          adapter_(other.adapter_.name(), function_, other.space().gridPart(), other.space().order())
      {}
 
      void evaluate(const DomainType &global, RangeType &result) const
      {
        adapter_.evaluate(global, result);
      }
 
      void jacobian(const DomainType &global, JacobianRangeType &result) const
      {
        adapter_.jacobian(global, result);
      }
 
      void hessian(const DomainType &global, HessianRangeType &result) const
      {
        adapter_.hessian(global, result);
      }
 
      const LocalFunctionType localFunction(const EntityType &entity) const
      {
        return localFunctionStorage().localFunction(entity);
      }
 
      LocalFunctionType localFunction(const EntityType &entity)
      {
        return localFunctionStorage().localFunction(entity);
      }
 
      LocalFunctionStorageType &localFunctionStorage () const
      {
        return localFunctionStorage_;
      }
 
      const DiscreteFunctionSpaceType &space() const
      {
        return adapter_.space();
      }
 
      const GridPartType &gridPart() const
      {
        return adapter_.gridPart();
      }
 
      const AdapterType& adapter() const {
        return adapter_;
      }
 
      const FunctionImpType& function() const {
        return function_;
      }
 
     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 = "W(" + result + ")";
        return result;
      }
 
      FunctionImpType function_;
      mutable LocalFunctionStorageType localFunctionStorage_;
      GridFunctionAdapter<FunctionImp, GridPart> adapter_;
    };
 
    template<class FunctionImp, class GridPart>
    class GridFunctionWrapper<FunctionImp, GridPart>::LocalFunction
      : public GridFunctionAdapter<FunctionImp, GridPart>::LocalFunctionType
    {
      typedef LocalFunction ThisType;
      typedef GridFunctionAdapter<FunctionImp, GridPart> AdapterType;
      typedef typename AdapterType::LocalFunctionType BaseType;
    public:
      typedef GridFunctionWrapper<FunctionImp, GridPart> DiscreteFunctionType;
 
      typedef typename BaseType::EntityType EntityType;
 
      LocalFunction(const EntityType &entity, const DiscreteFunctionType &df)
        : BaseType(entity, df.adapter_)
      {}
 
      LocalFunction (const DiscreteFunctionType &df)
        : BaseType(df.adapter_)
      {}
 
      LocalFunction(LocalFunctionStorageType &storage)
        : BaseType(storage)
      {}
    };
 
    // 1-to-1 copy from Fem::GridFunctionAdapter
    template<class FunctionImp, class GridPart>
    class GridFunctionWrapper<FunctionImp, GridPart>::LocalFunctionStorage
      : public GridFunctionAdapter<FunctionImp, GridPart>::LocalFunctionStorageType
    {
      typedef LocalFunctionStorage ThisType;
      typedef GridFunctionWrapper<FunctionImp, GridPart> DiscreteFunctionType;
      typedef GridFunctionAdapter<FunctionImp, GridPart> AdapterType;
      typedef typename AdapterType::LocalFunctionStorageType BaseType;
     public:
      typedef typename DiscreteFunctionType::LocalFunctionType LocalFunctionType;
 
      explicit LocalFunctionStorage(DiscreteFunctionType &discreteFunction)
        : BaseType(discreteFunction.adapter_),
          discreteFunction_(discreteFunction)
      {}
 
      LocalFunctionType localFunction()
      {
        return LocalFunctionType(function());
      }
 
      template<class Entity>
      const LocalFunctionType localFunction(const Entity &entity) const
      {
        return LocalFunctionType(entity, function());
      }
 
      template<class Entity>
      LocalFunctionType localFunction ( const Entity &entity )
      {
        return LocalFunctionType(entity, function());
      }
 
      DiscreteFunctionType &function()
      {
        return discreteFunction_;
      }
 
     private:
      LocalFunctionStorage(const ThisType &);
      ThisType operator= (const ThisType &);
 
      DiscreteFunctionType &discreteFunction_;
    };
 
    template<class FunctionImp, class GridPart>
    struct GridFunctionConverter
    {
     protected:
      template<class Dummy, bool hasLocalFunction = true>
      struct ConverterHelper
      {
        typedef FunctionImp WrappedGridFunctionType;
        typedef FunctionImp AdaptedGridFunctionType;
 
        static const WrappedGridFunctionType& wrap(const std::string& name, const FunctionImp& f, const GridPart& g, unsigned order)
        {
          return f;
        }
 
        static const AdaptedGridFunctionType& adapt(const std::string& name, const FunctionImp& f, const GridPart& g, unsigned order)
        {
          return f;
        }
      };
 
      template<class Dummy>
      struct ConverterHelper<Dummy, false>
      {
        typedef GridFunctionWrapper<FunctionImp, GridPart> WrappedGridFunctionType;
        typedef GridFunctionAdapter<FunctionImp, GridPart> AdaptedGridFunctionType;
 
        static WrappedGridFunctionType wrap(const std::string& name, const FunctionImp& f, const GridPart& g, unsigned order)
        {
          return WrappedGridFunctionType(name, f, g, order);
        }
 
        static AdaptedGridFunctionType adapt(const std::string& name, const FunctionImp& f, const GridPart& g, unsigned order)
        {
          return AdaptedGridFunctionType(name, f, g, order);
        }
      };
      enum { hasLocalFunction = std::is_base_of<Fem::HasLocalFunction, FunctionImp>::value };
      typedef ConverterHelper<void, hasLocalFunction> HelperType;
     public:
      typedef typename HelperType::WrappedGridFunctionType WrappedGridFunctionType;
      typedef typename HelperType::AdaptedGridFunctionType AdaptedGridFunctionType;
 
      static auto wrap(const std::string& name, const FunctionImp& f, const GridPart& g, unsigned order)
        -> decltype(HelperType::wrap(name, f, g, order))
      {
        return HelperType::wrap(name, f, g, order);
      }
 
      static auto adapt(const std::string& name, const FunctionImp& f, const GridPart& g, unsigned order)
        -> decltype(HelperType::adapt(name, f, g, order))
      {
        return HelperType::adapt(name, f, g, order);
      }
    };
 
    template<class FunctionImp, class GridPart>
    static inline
    auto wrapToGridFunction(const std::string& name, const FunctionImp& f, const GridPart& g, unsigned order = 111)
      -> decltype(GridFunctionConverter<FunctionImp, GridPart>::wrap(name, f, g, order))
    {
      return GridFunctionConverter<FunctionImp, GridPart>::wrap(name, f, g, order);
    }
 
    template<class FunctionImp, class GridPart>
    static inline
    auto adaptToGridFunction(const std::string& name, const FunctionImp& f, const GridPart& g, unsigned order = 111)
      -> decltype(GridFunctionConverter<FunctionImp, GridPart>::adapt(name, f, g, order))
    {
      return GridFunctionConverter<FunctionImp, GridPart>::adapt(name, f, g, order);
    }
 
 
 
  } // ACFem::
 
} // Dune::
 
 
#endif // DUN_ACFEM_GRIDFUNCITONWRAPPER_HH