boundaryfunctionexpression.hh

#ifndef __DUNE_ACFEM_BOUNDARYFUNCTIONEXPRESSION_HH__
#define __DUNE_ACFEM_BOUNDARYFUNCTIONEXPRESSION_HH__
 
#include "../functions/boundarysupportedfunction.hh"
#include "../functions/gridfunctionexpression.hh"
#include "../expressions/parameterinterface.hh"
#include "../expressions/parameterexpression.hh"
 
namespace Dune
{
 
  namespace ACFem
  {
 
    namespace {
 
      template<class F>
      static inline
      BoundarySupportedFunction<F>
      asBndryFct(const Fem::Function<typename F::FunctionSpaceType, F>& f_)
      {
        return BoundarySupportedFunction<F>(f_, EntireBoundaryIndicatorType());
      }
 
      template<class F, class FInd>
      BoundarySupportedFunction<F>
      asBndryFct(const BoundarySupportedFunction<F, EntireBoundaryIndicatorType>& f_)
      {
        return f_;
      }
 
      template<class F>
      auto asBndryFct(const BoundarySupportedFunction<F, EmptyBoundaryIndicatorType>& f_)
        -> BoundarySupportedFunction<decltype(zeroFunction(f_)), EmptyBoundaryIndicatorType>
      {
        typedef
          BoundarySupportedFunction<decltype(zeroFunction(f_)), EmptyBoundaryIndicatorType>
          ResultType;
 
        return ResultType(zeroFunction(f_), EmptyBoundaryIndicatorType());
      }
 
      template<class GridFunction>
      struct EssBndryFct
      {
        typedef GridFunction Type;
        static const Type& construct(const Type& arg)
        {
          return arg;
        }
      };
 
      template<class GridFunction, class Indicator>
      struct EssBndryFct<BoundarySupportedFunction<GridFunction, Indicator> >
      {
        typedef BoundarySupportedFunction<GridFunction, Indicator> Type;
        static const Type& construct(const Type& arg)
        {
          return arg;
        }
      };
 
      template<class GridFunction>
      struct EssBndryFct<BoundarySupportedFunction<GridFunction, EntireBoundaryIndicatorType> >
      {
        typedef BoundarySupportedFunction<GridFunction, EntireBoundaryIndicatorType> BndryFctType;
        typedef GridFunction Type;
        static const Type& construct(const BndryFctType& arg)
        {
          return arg.function();
        }
      };
 
      template<class GridFunction>
      struct EssBndryFct<BoundarySupportedFunction<GridFunction, EmptyBoundaryIndicatorType> >
      {
        typedef BoundarySupportedFunction<GridFunction, EmptyBoundaryIndicatorType> BndryFctType;
        typedef ZeroGridFunction<typename GridFunction::FunctionSpaceType,
                                 typename GridFunction::GridPartType> Type;
        static Type construct(const BndryFctType& arg)
        {
          return Type(arg.gridPart());
        }
      };
 
      template<class GridFunction>
      auto asEssBndryFct(const GridFunction& arg)
        -> decltype(EssBndryFct<GridFunction>::construct(arg))
      {
        return EssBndryFct<GridFunction>::construct(arg);
      }
 
      template<class GridFunction, class Indicator>
      auto
      asExprArg(const BoundarySupportedFunction<GridFunction, Indicator>& arg)
        -> decltype(asExprFunction(asEssBndryFct(arg)))
      {
        return asExprFunction(asEssBndryFct(arg));
      }
 
      template<class GridFunction>
      auto
      asExprArg(const BoundarySupportedFunction<GridFunction, EmptyBoundaryIndicatorType>& arg)
        -> decltype(asEssBndryFct(arg))
      {
        return asEssBndryFct(arg);
      }
 
    } // anonymous namespace
 
    template<class Function, class Indicator>
    static inline
    auto operator-(const BoundarySupportedFunction<Function, Indicator>& f_)
      -> BoundarySupportedFunction<decltype(-f_.function()), Indicator>
    {
      typedef decltype(-f_.function()) InnerExpressionType;
      typedef BoundarySupportedFunction<InnerExpressionType, Indicator> ExpressionType;
 
      return ExpressionType(-f_.function(), f_.outerIndicator());
    }
 
    template<class Function, class Indicator>
    static inline
    auto operator+(const BoundarySupportedFunction<Function, Indicator>& f_)
      -> BoundarySupportedFunction<Function, Indicator>
    {
      return f_;
    }
 
    template<class Left, class Right, class LeftInd, class RightInd>
    static inline
    auto operator+(const BoundarySupportedFunction<Left, LeftInd>& f_,
                   const BoundarySupportedFunction<Right, RightInd>& g_)
      -> decltype(asBndryFct(asExprArg(f_) + asExprArg(g_)))
    {
      return asBndryFct(asExprArg(f_) + asExprArg(g_));
    }
 
    template<class Left, class Right, class LeftInd>
    static inline
    auto operator+(const BoundarySupportedFunction<Left, LeftInd>& f_,
                   const Fem::Function<typename Right::FunctionSpaceType, Right>& g_)
      -> decltype(asBndryFct(asExprArg(f_) + g_))
    {
      return asBndryFct(asExprArg(f_) + g_);
    }
 
    template<class Left, class Right, class RightInd>
    static inline
    auto operator+(const Fem::Function<typename Left::FunctionSpaceType, Left>& f_,
                   const BoundarySupportedFunction<Right, RightInd>& g_)
      -> decltype(asBndryFct(f_ + asExprArg(g_)))
    {
      return asBndryFct(f_ + asExprArg(g_));
    }
 
    template<class ZeroExpression, class Left, class LeftInd>
    static inline
    auto operator+(const BoundarySupportedFunction<Left, LeftInd>& f_,
                   const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& g_)
      -> decltype(asBndryFct(asExprArg(f_) + g_))
    {
      return asBndryFct(asExprArg(f_) + g_);
    }
 
    template<class ZeroExpression, class Right, class RightInd>
    static inline
    auto operator+(const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& f_,
                   const BoundarySupportedFunction<Right, RightInd>& g_)
      -> decltype(asBndryFct(f_ + asExprArg(g_)))
    {
      return asBndryFct(f_ + asExprArg(g_));
    }
 
    template<class F, class FC, class Z>
    static inline
    auto operator+(const BoundarySupportedFunction<F, FC>& f_,
                   const BoundarySupportedFunction<Z, EmptyBoundaryIndicatorType>& z_)
      -> BoundarySupportedFunction<F, FC>
    {
      return f_;
    }
 
    template<class F, class FC, class Z>
    static inline
    auto operator+(const BoundarySupportedFunction<Z, EmptyBoundaryIndicatorType>& z_,
                   const BoundarySupportedFunction<F, FC>& f_)
      -> BoundarySupportedFunction<F, FC>
    {
      return f_;
    }
 
    template<class Z1, class Z2>
    static inline
    BoundarySupportedFunction<ZeroGridFunction<typename Z1::FunctionSpaceType,
                                               typename Z1::GridPartType>,
                              EmptyBoundaryIndicatorType>
    operator+(const BoundarySupportedFunction<Z1, EmptyBoundaryIndicatorType>& z1_,
              const BoundarySupportedFunction<Z2, EmptyBoundaryIndicatorType>& z2_)
    {
      // don't use decltype & friends here in order to have one well-defined end-point.
      typedef
        ZeroGridFunction<typename Z1::FunctionSpaceType, typename Z1::GridPartType>
        ZeroFunction;
      typedef
        BoundarySupportedFunction<ZeroFunction, EmptyBoundaryIndicatorType>
        ResultType;
 
      return ResultType(ZeroFunction(z1_.gridPart()), EmptyBoundaryIndicatorType());
    }
 
    template<class Left, class Right, class LeftInd, class RightInd>
    static inline
    auto operator-(const BoundarySupportedFunction<Left, LeftInd>& f_,
                   const BoundarySupportedFunction<Right, RightInd>& g_)
      -> decltype(asBndryFct(asExprArg(f_) - asExprArg(g_)))
    {
      return asBndryFct(asExprArg(f_) - asExprArg(g_));
    }
 
    template<class Left, class Right, class LeftInd>
    static inline
    auto operator-(const BoundarySupportedFunction<Left, LeftInd>& f_,
                   const Fem::Function<typename Right::FunctionSpaceType, Right>& g_)
      -> decltype(asBndryFct(asExprArg(f_) - g_))
    {
      return asBndryFct(asExprArg(f_) - g_);
    }
 
    template<class Left, class Right, class RightInd>
    static inline
    auto operator-(const Fem::Function<typename Left::FunctionSpaceType, Left>& f_,
                   const BoundarySupportedFunction<Right, RightInd>& g_)
      -> decltype(asBndryFct(f_ - asExprArg(g_)))
    {
      return asBndryFct(f_ - asExprArg(g_));
    }
 
    template<class F, class FC, class Z>
    static inline
    auto operator-(const BoundarySupportedFunction<F, FC>& f_,
                   const BoundarySupportedFunction<Z, EmptyBoundaryIndicatorType>& z_)
      -> BoundarySupportedFunction<F, FC>
    {
      return f_;
    }
 
    template<class F, class FC, class Z>
    static inline
    auto operator-(const BoundarySupportedFunction<Z, EmptyBoundaryIndicatorType>& z_,
                   const BoundarySupportedFunction<F, FC>& f_)
      -> decltype(-f_)
    {
      return -f_;
    }
 
    template<class Z1, class Z2>
    static inline
    BoundarySupportedFunction<ZeroGridFunction<typename Z1::FunctionSpaceType,
                                               typename Z1::GridPartType>,
                              EmptyBoundaryIndicatorType>
    operator-(const BoundarySupportedFunction<Z1, EmptyBoundaryIndicatorType>& z1_,
              const BoundarySupportedFunction<Z2, EmptyBoundaryIndicatorType>& z2_)
    {
      // don't use decltype & friends here in order to have one well-defined end-point.
      typedef
        ZeroGridFunction<typename Z1::FunctionSpaceType, typename Z1::GridPartType>
        ZeroFunction;
      typedef
        BoundarySupportedFunction<ZeroFunction, EmptyBoundaryIndicatorType>
        ResultType;
 
      return ResultType(ZeroFunction(z1_.gridPart()), EmptyBoundaryIndicatorType());
    }
 
    template<class Function, class Indicator>
    static inline
    auto operator*(const typename Function::RangeFieldType& s_,
                   const BoundarySupportedFunction<Function, Indicator>& f_)
      -> decltype(asBndryFct(asEssBndryFct(s_ * asExprArg(f_))))
    {
      return asBndryFct(asEssBndryFct(s_ * asExprArg(f_)));
    }
 
    template<class Function>
    static inline
    BoundarySupportedFunction<ZeroGridFunction<typename Function::FunctionSpaceType,
                                               typename Function::GridPartType>,
                              EmptyBoundaryIndicatorType>
    operator*(const typename Function::RangeFieldType& s_,
              const BoundarySupportedFunction<Function, EmptyBoundaryIndicatorType>& f_)
    {
      typedef
        ZeroGridFunction<typename Function::FunctionSpaceType,
                         typename Function::GridPartType>
        ZeroType;
      typedef EmptyBoundaryIndicatorType IndicatorType;
      typedef BoundarySupportedFunction<ZeroType, IndicatorType> ExpressionType;
 
      return ExpressionType(ZeroType(f_.gridPart()), IndicatorType());
    }
 
    template<class Function, class Indicator>
    static inline
    auto operator*(const BoundarySupportedFunction<Function, Indicator>& f_,
                   const typename Function::RangeFieldType& s_)
      -> decltype(s_ * f_)
    {
      return s_ * f_;
    }
 
    template<class Parameter, class Function, class Indicator>
    static inline
    auto operator*(const ParameterInterface<Parameter>& p_,
                   const BoundarySupportedFunction<Function, Indicator>& f_)
      -> decltype(asBndryFct(asEssBndryFct(asImp(p_) * asExprArg(f_))))
    {
      return asBndryFct(asEssBndryFct(asImp(p_) * asExprArg(f_)));
    }
 
    template<class Parameter, class Function>
    static inline
    BoundarySupportedFunction<ZeroGridFunction<typename Function::FunctionSpaceType,
                                               typename Function::GridPartType>,
                              EmptyBoundaryIndicatorType>
    operator*(const ParameterInterface<Parameter>& p_,
              const BoundarySupportedFunction<Function, EmptyBoundaryIndicatorType>& f_)
    {
      typedef
        ZeroGridFunction<typename Function::FunctionSpaceType,
                         typename Function::GridPartType>
        ZeroType;
      typedef EmptyBoundaryIndicatorType IndicatorType;
      typedef BoundarySupportedFunction<ZeroType, IndicatorType> ExpressionType;
 
      return ExpressionType(ZeroType(f_.gridPart()), IndicatorType());
    }
 
    template<class Parameter, class Function, class Indicator>
    static inline
    auto operator*(const BoundarySupportedFunction<Function, Indicator>& f_,
                   const ParameterInterface<Parameter>& p_)
      -> decltype(asImp(p_) * f_)
    {
      return asImp(p_) * f_;
    }
 
    template<class Field, class Parameter, class Function, class Indicator>
    static inline
    auto operator*(const BinaryParameterExpression<SMultiplyOperation, Field, Parameter>& p_,
                   const BoundarySupportedFunction<Function, Indicator>& f_)
      -> decltype(p_.left() * (p_.right() * f_))
    {
      return p_.left() * (p_.right() * f_);
    }
 
    template<class Left, class Right, class LeftInd, class RightInd>
    static inline
    auto operator*(const BoundarySupportedFunction<Left, LeftInd>& f_,
                   const BoundarySupportedFunction<Right, RightInd>& g_)
      -> decltype(asBndryFct(asEssBndryFct(asExprArg(f_) * asExprArg(g_))))
    {
      return asBndryFct(asEssBndryFct(asExprArg(f_) * asExprArg(g_)));
    }
 
    template<class Zero, class F, class FInd>
    static inline
    auto operator*(const BoundarySupportedFunction<Zero, EmptyBoundaryIndicatorType>& z_,
                   const BoundarySupportedFunction<F, FInd>& f_)
      -> BoundarySupportedFunction<decltype(zeroProduct(z_, f_)), EmptyBoundaryIndicatorType>
    {
      typedef decltype(zeroProduct(z_, f_)) InnerExpressionType;
      typedef EmptyBoundaryIndicatorType IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(zeroProduct(z_, f_), IndicatorType());
    }
 
    template<class F, class Zero, class FInd>
    static inline
    auto operator*(const BoundarySupportedFunction<F, FInd>& f_,
                   const BoundarySupportedFunction<Zero, EmptyBoundaryIndicatorType>& z_)
      -> BoundarySupportedFunction<decltype(zeroProduct(z_, f_)), EmptyBoundaryIndicatorType>
    {
      typedef decltype(zeroProduct(z_, f_)) InnerExpressionType;
      typedef EmptyBoundaryIndicatorType IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(zeroProduct(f_, z_), IndicatorType());
    }
 
    template<class Left, class Right>
    static inline
    auto operator*(const BoundarySupportedFunction<Left, EmptyBoundaryIndicatorType>& z1_,
                   const BoundarySupportedFunction<Right, EmptyBoundaryIndicatorType>& z2_)
      -> BoundarySupportedFunction<decltype(zeroProduct(z1_, z2_)), EmptyBoundaryIndicatorType>
    {
      typedef decltype(zeroProduct(z1_, z2_)) InnerExpressionType;
      typedef EmptyBoundaryIndicatorType IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(zeroProduct(z1_, z2_), IndicatorType());
    }
 
    /***********************************************
     *
     * f * Wrapped(g)
     *
     */
 
    template<class Left, class Right, class RightInd>
    static inline
    auto operator*(const Fem::Function<typename Left::FunctionSpaceType, Left>& f_,
                   const BoundarySupportedFunction<Right, RightInd>& g_)
      -> BoundarySupportedFunction<typename EssBndryFct<decltype(asImp(f_) * g_.function())>::Type,
                                   typename BoundarySupportedFunction<Right, RightInd>::IndicatorType>
    {
      typedef EssBndryFct<decltype(asImp(f_) * g_.function())> EssBndryTraits;
      typedef typename EssBndryTraits::Type InnerExpressionType;
      typedef
        typename BoundarySupportedFunction<Right, RightInd>::IndicatorType
        IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(asEssBndryFct(asImp(f_) * g_.function()), g_.indicator());
    }
 
    template<class Left, class Right>
    static inline
    auto operator*(const Fem::Function<typename Left::FunctionSpaceType, Left>& f_,
                   const BoundarySupportedFunction<Right, EmptyBoundaryIndicatorType>& g_)
      -> BoundarySupportedFunction<decltype(zeroProduct(asImp(f_), g_)), EmptyBoundaryIndicatorType>
    {
      typedef decltype(zeroProduct(asImp(f_), g_)) InnerExpressionType;
      typedef EmptyBoundaryIndicatorType IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(InnerExpressionType(g_.gridPart()), IndicatorType());
    }
 
    template<class ZeroExpression, class Function, class Indicator>
    static inline
    auto operator*(const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_,
                   const BoundarySupportedFunction<Function, Indicator>& b_)
      -> BoundarySupportedFunction<decltype(zeroProduct(*z_, b_)),
                                   typename BoundarySupportedFunction<Function, Indicator>::IndicatorType>
    {
      typedef decltype(zeroProduct(*z_, b_)) InnerExpressionType;
      typedef typename BoundarySupportedFunction<Function, Indicator>::IndicatorType IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(*z_, b_.indicator());
    }
 
    template<class ZeroExpression, class Right>
    static inline
    auto operator*(const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& f_,
                   const BoundarySupportedFunction<Right, EmptyBoundaryIndicatorType>& g_)
      -> BoundarySupportedFunction<decltype(zeroProduct(*f_, g_)), EmptyBoundaryIndicatorType>
    {
      typedef decltype(zeroProduct(*f_, g_)) InnerExpressionType;
      typedef EmptyBoundaryIndicatorType IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(InnerExpressionType((*f_).gridPart()), IndicatorType());
    }
 
    /***********************************************
     *
     * Wrapped(g) * f
     *
     */
 
    template<class Function, class Wrapped, class Indicator>
    static inline
    auto operator*(const BoundarySupportedFunction<Wrapped, Indicator>& b_,
                   const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
      -> BoundarySupportedFunction<typename EssBndryFct<decltype(b_.function() * asImp(f_))>::Type,
                                   typename BoundarySupportedFunction<Wrapped, Indicator>::IndicatorType>
    {
      typedef EssBndryFct<decltype(b_.function() * asImp(f_))> EssBndryTraits;
      typedef typename EssBndryTraits::Type InnerExpressionType;
      typedef
        typename BoundarySupportedFunction<Wrapped, Indicator>::IndicatorType
        IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(asEssBndryFct(b_.function() * asImp(f_)), b_.indicator());
    }
 
    template<class Function, class Wrapped>
    static inline
    auto operator*(const BoundarySupportedFunction<Wrapped, EmptyBoundaryIndicatorType>& b_,
                   const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
      -> BoundarySupportedFunction<decltype(zeroProduct(b_, asImp(f_))), EmptyBoundaryIndicatorType>
    {
      typedef decltype(zeroProduct(b_, asImp(f_))) InnerExpressionType;
      typedef EmptyBoundaryIndicatorType IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(InnerExpressionType(b_.gridPart()), IndicatorType());
    }
 
    template<class ZeroExpression, class Wrapped, class Indicator>
    static inline
    auto operator*(const BoundarySupportedFunction<Wrapped, Indicator>& b_,
                   const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_)
      -> BoundarySupportedFunction<decltype(zeroProduct(b_, *z_)),
                                   typename BoundarySupportedFunction<Wrapped, Indicator>::IndicatorType>
    {
      typedef decltype(zeroProduct(b_, *z_)) InnerExpressionType;
      typedef typename BoundarySupportedFunction<Wrapped, Indicator>::IndicatorType IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(InnerExpressionType(b_.gridPart()), b_.indicator());
    }
 
    template<class ZeroExpression, class Wrapped>
    static inline
    auto operator*(const BoundarySupportedFunction<Wrapped, EmptyBoundaryIndicatorType>& b_,
                   const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_)
      -> BoundarySupportedFunction<decltype(zeroProduct(b_, *z_)), EmptyBoundaryIndicatorType>
    {
      typedef decltype(zeroProduct(b_, *z_)) InnerExpressionType;
      typedef EmptyBoundaryIndicatorType IndicatorType;
      typedef BoundarySupportedFunction<InnerExpressionType, IndicatorType> ExpressionType;
 
      return ExpressionType(InnerExpressionType(b_.gridPart()), IndicatorType());
    }
 
    /*
     *
     *
     **********************************************/
 
    template<class Function, class Indicator>
    static inline
    BoundarySupportedFunction<Function, Indicator>
    operator*(const decltype(oneFunction(std::declval<Function>()))& one,
              const BoundarySupportedFunction<Function, Indicator>& f_)
    {
      return f_;
    }
 
    template<class Function, class Indicator>
    static inline
    BoundarySupportedFunction<Function, Indicator>
    operator*(const BoundarySupportedFunction<Function, Indicator>& f_,
              const decltype(oneFunction(std::declval<Function>()))& one)
    {
      return f_;
    }
 
    template<class Left, class Right, class RightInd>
    static inline
    auto operator/(const Fem::Function<typename Left::FunctionSpaceType, Left>& f_,
                   const BoundarySupportedFunction<Right, RightInd>& g_)
      -> decltype(asBndryFct(asEssBndryFct(f_ / asExprArg(g_))))
    {
      return asBndryFct(asEssBndryFct(f_ / asExprArg(g_)));
    }
 
    template<class Function, class Indicator>
    static inline
    auto operator/(const typename Function::RangeFieldType& s_,
                   const BoundarySupportedFunction<Function, Indicator>& f_)
      -> decltype(asBndryFct(asEssBndryFct(s_ / asExprArg(f_))))
    {
      return asBndryFct(asEssBndryFct(s_ / asExprArg(f_)));
    }
 
    template<class Parameter, class Function, class Indicator>
    static inline
    auto operator/(const ParameterInterface<Parameter>& p_,
                   const BoundarySupportedFunction<Function, Indicator>& f_)
      -> decltype(asBndryFct(asEssBndryFct(asImp(p_) / asExprArg(f_))))
    {
      return asBndryFct(asEssBndryFct(asImp(p_) / asExprArg(f_)));
    }
 
#if 0
    // UNIMPLEMENTED, usually we want those BoundarySupportedFunction
    // expression in order to form Model-expressions.
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<ExpOperation, Function>, GridPart>
    exp(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<ExpOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<LogOperation, Function>, GridPart>
    log(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<LogOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<SqrtOperation, Function>, GridPart>
    sqrt(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<SqrtOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<SquareOperation, Function>, GridPart>
    sqr(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<SquareOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<SinOperation, Function>, GridPart>
    sin(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<SinOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<CosOperation, Function>, GridPart>
    cos(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<CosOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<TanOperation, Function>, GridPart>
    tan(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<TanOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<AtanOperation, Function>, GridPart>
    atan(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<AtanOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<AsinOperation, Function>, GridPart>
    asin(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<AsinOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
 
    template<class Function, class GridPart>
    static inline
    GridFunctionWrapper<UnaryFunctionExpression<AcosOperation, Function>, GridPart>
    acos(const GridFunctionWrapper<Function, GridPart>& f)
    {
      typedef
        UnaryBoundaryFunctionExpressionTraits<AcosOperation, Function, GridPart>
        TraitsType;
 
      return TraitsType::wrap(f);
    }
#endif
 
 
    template<class Indicator, class Function>
    static inline
    auto operator*(const BoundaryIndicatorInterface<Indicator>& chi,
                   const Fem::Function<typename Function::FunctionSpaceType, Function>& f)
      -> decltype(boundarySupportedFunction(f, chi))
    {
      return boundarySupportedFunction(f, chi);
    }
 
    template<class Indicator, class Function>
    static inline
    auto operator*(const Fem::Function<typename Function::FunctionSpaceType, Function>& f,
                   const BoundaryIndicatorInterface<Indicator>& chi)
      -> decltype(asImp(chi) * asImp(f))
    {
      return asImp(chi) * asImp(f);
    }
 
    template<class Function>
    static inline
    BoundarySupportedFunction<ZeroGridFunction<typename Function::FunctionSpaceType,
                                               typename Function::GridParType>,
                              EmptyBoundaryIndicatorType>
    operator*(const EmptyBoundaryIndicatorType& chi,
              const Fem::Function<typename Function::FunctionSpaceType, Function>& f)
    {
      typedef
        ZeroGridFunction<typename Function::FunctionSpaceType,
                         typename Function::GridParType>
        ZeroFunction;
      typedef
        BoundarySupportedFunction<ZeroFunction, EmptyBoundaryIndicatorType>
        BoundaryFunction;
 
      return BoundaryFunction(ZeroFunction(f.gridPart), EmptyBoundaryIndicatorType());
    }
 
    template<class Function, class Indicator>
    static inline
    BoundarySupportedFunction<ZeroGridFunction<typename Function::FunctionSpaceType,
                                               typename Function::GridParType>,
                              EmptyBoundaryIndicatorType>
    operator*(const EmptyBoundaryIndicatorType& chi,
              const BoundarySupportedFunction<Function, Indicator>& f)
    {
      typedef
        ZeroGridFunction<typename Function::FunctionSpaceType,
                         typename Function::GridParType>
        ZeroFunction;
      typedef
        BoundarySupportedFunction<ZeroFunction, EmptyBoundaryIndicatorType>
        BoundaryFunction;
 
      return BoundaryFunction(ZeroFunction(f.gridPart), EmptyBoundaryIndicatorType());
    }
 
    template<class Function, class Indicator>
    static inline
    BoundarySupportedFunction<Function, Indicator>
    operator*(const EntireBoundaryIndicatorType& chi,
              const BoundarySupportedFunction<Function, Indicator>& f)
    {
      return f;
    }
 
 
 
 
  } // ACFem::
 
  namespace Fem {
    using ACFem::operator+;
    using ACFem::operator-;
    using ACFem::operator*;
    using ACFem::operator/;
  }
 
} // Dune::
 
#endif // __DUNE_ACFEM_GRIDFUNCTIONWRAPPEREXPRESSION_HH__