functionviews.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2002-2021 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef FUNCTIONVIEWS_HH
#define FUNCTIONVIEWS_HH
 
#include <type_traits>
 
namespace Kaskade
{
  namespace FunctionViews
  {
    template <typename Function>
    class AbsSquare
    {
    public:
      typedef typename Function::Space Space;
      typedef typename Function::Scalar Scalar;
      typedef typename Dune::FieldVector<Scalar,1> ValueType;
 
      AbsSquare(Function const& f_) : f(f_) {}
 
      Space const& space() const {return f.space();}
 
      template<class SFS>
      int order(SFS const& sfs) const {return 2*f.order(sfs); }
 
      template<class EPtr, class V>
      ValueType value(EPtr const& ci, V const& v) const
      {
        return f.value(ci,v).two_norm2();
      }
 
      ValueType value(typename Function::Space::Evaluator const& evaluator) const
      {
        return f.value(evaluator).two_norm2();
      }
 
    private:
      Function const& f;
    };
 
    // --------------------------------------------------------------------------------------------
 
    template <typename Function, bool asVector=Function::components==1>
    class Gradient
    {
      static int const m = Function::components;
 
    public:
      typedef typename Function::Space Space;
      static int const dim = Space::dim;
 
      typedef typename Function::Scalar Scalar;
 
 
      using ValueType = std::conditional_t<asVector,       Dune::FieldVector<Scalar,dim*m>,
                                         /*otherwise*/     Dune::FieldMatrix<Scalar,m,dim>>;
 
      Gradient(Function const& f_) : f(f_)
      {}
 
      Space const& space() const 
      {
        return f.space();
      }
 
      template<class SFS>
      int order(SFS const& sfs) const
      {
        return std::max(f.order(sfs)-1,0);
      }
 
      ValueType value(typename Function::Space::Evaluator const& evaluator) const
      {
        return convertToValueType(f.derivative(evaluator));
      }
 
      template<class Cell, class Position>
      ValueType value(Cell const& cell, Position const& xi) const
      {
        return convertToValueType(f.derivative(cell,xi));
      }
 
 
    private:
      Function const& f;
 
      ValueType convertToValueType(Dune::FieldMatrix<Scalar,m,dim> const& fx) const
      {
        if constexpr (m==1)
          return fx[0];
        else if constexpr (asVector)
          return Dune::asVector(fx);
        else
          return fx;
      }
    };
 
 
    template <class Function>
    Gradient<Function,false> gradient(Function const& f)
    {
      return Gradient<Function,false>(f);
    }
 
    template <class Function>
    Gradient<Function,true> gradientAsVector(Function const& f)
    {
      return Gradient<Function,true>(f);
    }
 
    // --------------------------------------------------------------------------------------------
 
    template <typename Function>
    class GradientAbsSquare
    {
    public:
      typedef typename Function::Space Space;
      typedef typename Function::Scalar Scalar;
      typedef Scalar  ValueType;
 
      GradientAbsSquare(Function const& f_) : f(f_)
      { }
 
      Space const& space() const 
      {
        return f.space();
      }
 
      template <class SFS>
      int order(SFS const& sfs) const 
      { 
        return 2*std::max(f.order(sfs)-1,0); 
      }
 
      ValueType value(typename Function::Space::Evaluator const& evaluator) const
      {
        return f.derivative(evaluator).frobenius_norm2();
      }
 
      template <class Cell, class Position>
      ValueType value(Cell const& cell, Position const& xi) const
      {
        f.derivative(cell,xi).frobenius_norm2();
      }
 
    private:
      Function const& f;
    };
 
 
  }
 
  template<template<class Fct1,class Fct2> class View, class Fct1, class Fct2>
  View<Fct1, Fct2> makeView(Fct1 const& f1, Fct2 const& f2)
  {
    return View<Fct1,Fct2>(f1,f2);
  }
 
  template<template<typename Function> class View, typename Function>
  View<Function> makeView(Function const& f1)
  {
    return View<Function>(f1);
  }
 
  namespace WeakFunctionViews
  {
    struct ZeroOrderView
    {
      template<class SFS>
      int order(SFS const& sfs) const { return 0; }
 
      virtual ~ZeroOrderView() {};
    };
 
    struct ConstantGradient
    {
      typedef Dune::FieldVector<double,2> ValueType;
 
      template<class SFS>
      int order(SFS const& sfs) const { return 0; }
 
      template<class EPtr, class V>
      ValueType value(EPtr const& ci, V const&) const
      {
        ValueType v;
        v[0]=0;
        v[1]=1;
        return v;
      }
    };
 
    struct MightBeCoarsened : public ZeroOrderView
    {
      template<class EPtr, class V>
      double value(EPtr const& ci, V const&) const
      {
        return ci.mightBeCoarsened()/ci.geometry().volume();
      }
    };
 
    struct WasRefined : public ZeroOrderView
    {
      template<class EPtr, class V>
      double value(EPtr const& ci, V const&) const
      {
        return ci.wasRefined()/ci.geometry().volume();
      }
    };
 
    struct GridLevel : public ZeroOrderView
    {
      template<class EPtr, class V>
      double value(EPtr const& ci, V const&) const
      {
        return ci.level()/ci.geometry().volume();
      }
    };
 
    struct IsRegular : public ZeroOrderView
    {
      template<class EPtr, class V>
      double value(EPtr const& ci, V const&) const
      {
        return ci.isRegular()/ci.geometry().volume();
      }
    };
 
  }
 
  template<class Grid, class T> class CellData;
  template<class Space> class LocalIntegral;
 
  template<class View, class Space>
  typename CellData<typename Space::Grid, Dune::FieldVector<double,1> >::CellDataVector evalCellProperties(Space const& space)
  {
    LocalIntegral<Space> localIntegral;
    typename CellData<typename Space::Grid, Dune::FieldVector<double,1> >::CellDataVector
    errorIndicator(localIntegral(View(),space));
    return errorIndicator;
  }
 
  template <class Function>
  class ScalarProductView
  {
  public:
    ScalarProductView(Function const& f1_, Function const& f2_): f1(f1_), f2(f2_) {}
 
    typedef typename Function::Scalar Scalar;
    static int const components = Function::components;
    typedef Dune::FieldVector<Scalar,components> ValueType;
 
    template <class Cell>
    int order(Cell const& cell) const
    {
      if (std::max(f1.order(cell),f2.order(cell)) < std::numeric_limits<int>::max())
        return f1.order(cell)+f2.order(cell);
      else
        return std::numeric_limits<int>::max();
    }
 
    template <class Cell>
    ValueType value(Cell const& cell,
        Dune::FieldVector<typename Cell::Geometry::ctype,Cell::dimension> const& localCoordinate) const
    {
      return f1.value(cell,localCoordinate) * f2.value(cell,localCoordinate);
    }
 
 
  private:
    Function const& f1;
    Function const& f2;
  };
} /* end of namespace Kaskade */
 
#endif