gridfunctionexpressionbase.hh

#ifndef __DUNE_ACFEM_GRIDFUNCTIONEXPRESSIONBASE_HH__
#define __DUNE_ACFEM_GRIDFUNCTIONEXPRESSIONBASE_HH__
 
#include <dune/fem/version.hh>
#include <dune/fem/function/common/discretefunction.hh>
 
#include "../expressions/expressionoperations.hh"
 
namespace Dune
{
 
  namespace ACFem
  {
 
    template<class UnOp, class Function>
    class UnaryGridFunctionExpression;
 
    template<class BinOp, class LeftFunction, class RightFunction>
    class BinaryGridFunctionExpression;
 
    template<class FunctionSpaceImp, class ExpressionImp,
             template<class> class ExpressionTag = ExpressionTemplate>
    class GridFunctionExpression
      : public Fem::Function<FunctionSpaceImp, ExpressionImp>,
        public ExpressionTag<ExpressionImp>,
        public Fem::HasLocalFunction
    {
     public:
      typedef FunctionSpaceImp FunctionSpaceType;
      typedef typename FunctionSpaceType::ScalarFunctionSpaceType ScalarFunctionSpaceType;
      typedef typename FunctionSpaceType::RangeType RangeType;
      typedef typename FunctionSpaceType::JacobianRangeType JacobianRangeType;
 
      void setName(const std::string& newName)
      {
        name_ = newName;
      }
 
      const std::string& name() const
      {
        if (name_ == "") {
          return this->expression().expressionName();
        } else {
          return name_;
        }
      }
 
      const std::string& expressionName() const
      {
        return expressionName_;
      }
 
     protected:
      // Stolen from the Fem::GridFunctionAdapter
      template<class LocalFunction, class QuadratureType, class VectorType>
      static void evaluateQuadratureImp(const LocalFunction& lf,
                                        const QuadratureType& quadrature,
                                        VectorType& values,
                                        const RangeType&)
      {
        const unsigned int nop = quadrature.nop();
        for (unsigned int qp = 0; qp < nop; ++qp) {
          lf.evaluate(quadrature[qp], values[qp]);
        }
      }
 
      // Stolen from the Fem::GridFunctionAdapter
      template<class LocalFunction, class QuadratureType, class VectorType>
      static void evaluateQuadratureImp(const LocalFunction& lf,
                                        const QuadratureType& quadrature,
                                        VectorType& values,
                                        const JacobianRangeType&)
      {
        const unsigned int nop = quadrature.nop();
        for (unsigned int qp = 0; qp < nop; ++qp) {
          lf.jacobian(quadrature[qp], values[qp]);
        }
      }
 
      mutable std::string expressionName_;
      std::string name_;
    };
 
    template<class FunctionSpaceImp, class ExpressionImp>
    class ZeroGridFunctionExpression
      : public GridFunctionExpression<FunctionSpaceImp, ExpressionImp, ZeroExpression>
    {};
 
    struct IsPieceWiseConstant
    {};
 
    struct IsNotPieceWiseConstant
    {};
 
 
 
  } // namespace ACFem
 
} // namespace Dune
 
#endif //  __DUNE_ACFEM_GRIDFUNCTIONEXPRESSIONBASE_HH__