gridfunctionwrapperexpression.hh

#ifndef __DUNE_ACFEM_GRIDFUNCTIONWRAPPEREXPRESSION_HH__
#define __DUNE_ACFEM_GRIDFUNCTIONWRAPPEREXPRESSION_HH__
 
#include "../functions/gridfunctionwrapper.hh"
#include "../functions/functionexpression.hh"
#include "../functions/gridfunctionexpressionbase.hh"
#include "../expressions/parameterexpression.hh"
 
namespace Dune
{
 
  namespace ACFem
  {
 
    // forward
    template<class UnOp, class Function>
    class UnaryGridFunctionExpression;
 
    // forward
    template<class BinOp, class LeftFunction, class RightFunction>
    class BinaryGridFunctionExpression;
 
    namespace {
 
      template<class GridFunction, class GridPart>
      struct EssGridFunction
      {
        typedef GridFunctionWrapper<GridFunction, GridPart> WrappedFunctionType;
        enum {
          hasLocalFunction = std::is_base_of<Fem::HasLocalFunction, GridFunction>::value
        };
 
        template<bool hasLF, class dummy = void>
        struct Helper;
 
        template<class dummy>
        struct Helper<true, dummy>
        {
          typedef GridFunction FunctionType;
          static const FunctionType& construct(const WrappedFunctionType& arg)
          {
            return arg.function();
          }
        };
 
        template<class dummy>
        struct Helper<false, dummy>
        {
          typedef WrappedFunctionType FunctionType;
          static const FunctionType& construct(const WrappedFunctionType& arg)
          {
            return arg;
          }
        };
 
        typedef Helper<hasLocalFunction> HelperType;
        typedef typename HelperType::FunctionType FunctionType;
        static const FunctionType& construct(const WrappedFunctionType& arg)
        {
          return HelperType::construct(arg);
        }
      };
 
      template<class GridFunction, class GridPart>
      const typename EssGridFunction<GridFunction, GridPart>::FunctionType&
      asEssGridFct(const GridFunctionWrapper<GridFunction, GridPart>& arg)
      {
        return EssGridFunction<GridFunction, GridPart>::construct(arg);
      }
 
      template<class GridFunction, class GridPart>
      auto
      asExprArg(const GridFunctionWrapper<GridFunction, GridPart>& arg)
        -> decltype(asExprFunction(asEssGridFct(arg)))
      {
        return asExprFunction(asEssGridFct(arg));
      }
 
    }
 
    template<class Function, class GridPart>
    static inline
    auto operator-(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(-asExprArg(f_)), GridPart>
    {
      typedef decltype(-asExprArg(f_)) InnerExpressionType;
      typedef GridPart GridPartType;
      typedef GridFunctionWrapper<InnerExpressionType, GridPartType> ExpressionType;
 
      auto inner(-asExprArg(f_));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto operator+(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<Function, GridPart>
    {
      return f_;
    }
 
    template<class Left, class Right, class GridPart>
    static inline
    auto operator+(const GridFunctionWrapper<Left, GridPart>& f_,
                   const GridFunctionWrapper<Right, GridPart>& g_)
      -> GridFunctionWrapper<decltype(asExprArg(f_) + asExprArg(g_)), GridPart>
    {
      typedef decltype(asExprArg(f_) + asExprArg(g_)) InnerExpressionType;
      typedef GridPart GridPartType;
      typedef GridFunctionWrapper<InnerExpressionType, GridPartType> ExpressionType;
 
      auto inner(asExprArg(f_) + asExprArg(g_));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Left, class Right, class GridPart>
    static inline
    auto operator-(const GridFunctionWrapper<Left, GridPart>& f_,
                   const GridFunctionWrapper<Right, GridPart>& g_)
      -> GridFunctionWrapper<decltype(asExprArg(f_) - asExprArg(g_)), GridPart>
    {
      typedef decltype(asExprArg(f_) - asExprArg(g_)) InnerExpressionType;
      typedef GridPart GridPartType;
      typedef GridFunctionWrapper<InnerExpressionType, GridPartType> ExpressionType;
 
      auto inner(asExprArg(f_) - asExprArg(g_));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto operator*(const typename Function::RangeFieldType& s_,
                   const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(s_ * asExprArg(f_)), GridPart>
    {
      typedef decltype(s_ * asExprArg(f_)) InnerExpressionType;
      typedef GridPart GridPartType;
      typedef GridFunctionWrapper<InnerExpressionType, GridPartType> ExpressionType;
 
      auto inner(s_ * asExprArg(f_));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto operator*(const GridFunctionWrapper<Function, GridPart>& f_,
                   const typename Function::RangeFieldType& s_)
      -> decltype(s_ * f_)
    {
      return s_ * f_;
    }
 
    template<class Parameter, class Function, class GridPart>
    static inline
    auto operator*(const ParameterInterface<Parameter>& p_,
                   const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(asImp(p_) * asExprArg(f_)), GridPart>
    {
      typedef decltype(asImp(p_) * asExprArg(f_)) InnerExpressionType;
      typedef GridPart GridPartType;
      typedef GridFunctionWrapper<InnerExpressionType, GridPartType> ExpressionType;
 
      auto inner(asImp(p_) * asExprArg(f_));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Parameter, class Function, class GridPart>
    static inline
    auto operator*(const GridFunctionWrapper<Function, GridPart>& f_,
                   const ParameterInterface<Parameter>& p_)
      -> decltype(asImp(p_) * f_)
    {
      return asImp(p_) * f_;
    }
 
    template<class Field, class Parameter, class Function, class GridPart>
    static inline
    auto operator*(const BinaryParameterExpression<SMultiplyOperation, Field, Parameter>& p_,
                   const GridFunctionWrapper<Function, GridPart>& f_)
      -> decltype(p_.left() * (p_.right() * f_))
    {
      return p_.left() * (p_.right() * f_);
    }
 
    template<class Left, class Right, class GridPart>
    static inline
    auto operator*(const GridFunctionWrapper<Left, GridPart>& f_,
                   const GridFunctionWrapper<Right, GridPart>& g_)
      -> GridFunctionWrapper<decltype(asExprArg(f_) * asExprArg(g_)), GridPart>
    {
      typedef decltype(asExprArg(f_) * asExprArg(g_)) InnerExpressionType;
      typedef GridPart GridPartType;
      typedef GridFunctionWrapper<InnerExpressionType, GridPartType> ExpressionType;
 
      auto inner(asExprArg(f_) * asExprArg(g_));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Left, class Right, class GridPart>
    static inline
    auto operator/(const GridFunctionWrapper<Left, GridPart>& f_,
                   const GridFunctionWrapper<Right, GridPart>& g_)
      -> GridFunctionWrapper<decltype(asExprArg(f_) / asExprArg(g_)), GridPart>
    {
      typedef decltype(asExprArg(f_) / asExprArg(g_)) InnerExpressionType;
      typedef GridPart GridPartType;
      typedef GridFunctionWrapper<InnerExpressionType, GridPartType> ExpressionType;
 
      auto inner(asExprArg(f_) / asExprArg(g_));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto operator/(const typename Function::RangeFieldType& s_,
                   const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(s_ / asExprArg(f_)), GridPart>
    {
      typedef decltype(s_ / asExprArg(f_)) InnerExpressionType;
      typedef GridPart GridPartType;
      typedef GridFunctionWrapper<InnerExpressionType, GridPartType> ExpressionType;
 
      auto inner(s_ / asExprArg(f_));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Parameter, class Function, class GridPart>
    static inline
    auto operator/(const ParameterInterface<Parameter>& p_,
                   const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(asImp(p_) / asExprArg(f_)), GridPart>
    {
      typedef decltype(asImp(p_) / asExprArg(f_)) InnerExpressionType;
      typedef GridPart GridPartType;
      typedef GridFunctionWrapper<InnerExpressionType, GridPartType> ExpressionType;
 
      auto inner(asImp(p_) / asExprArg(f_));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto exp(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(exp(asExprArg(f_))), GridPart>
    {
      typedef decltype(exp(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(exp(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(exp(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto log(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(log(asExprArg(f_))), GridPart>
    {
      typedef decltype(log(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(log(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(log(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto sqrt(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(sqrt(asExprArg(f_))), GridPart>
    {
      typedef decltype(sqrt(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(sqrt(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(sqrt(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto sqr(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(sqr(asExprArg(f_))), GridPart>
    {
      typedef decltype(sqr(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(sqr(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(sqr(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto sin(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(sin(asExprArg(f_))), GridPart>
    {
      typedef decltype(sin(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(sin(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(sin(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto cos(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(cos(asExprArg(f_))), GridPart>
    {
      typedef decltype(cos(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(cos(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(cos(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto tan(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(tan(asExprArg(f_))), GridPart>
    {
      typedef decltype(tan(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(tan(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(tan(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto atan(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(atan(asExprArg(f_))), GridPart>
    {
      typedef decltype(atan(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(atan(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(atan(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto asin(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(asin(asExprArg(f_))), GridPart>
    {
      typedef decltype(asin(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(asin(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(asin(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
    template<class Function, class GridPart>
    static inline
    auto acos(const GridFunctionWrapper<Function, GridPart>& f_)
      -> GridFunctionWrapper<decltype(acos(asExprArg(f_))), GridPart>
    {
      typedef decltype(acos(asExprArg(f_))) InnerExpressionType;
      typedef GridFunctionWrapper<decltype(acos(asExprArg(f_))), GridPart> ExpressionType;
 
      auto inner(acos(asExprArg(f_)));
 
      return ExpressionType(inner.name(), inner, f_.gridPart(), inner.space().order());
    }
 
 
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_GRIDFUNCTIONWRAPPEREXPRESSION_HH__