variationalfunctional.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                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
class unspecified;
 
class VariationalFunctional 
{
public:
  typedef unspecified Scalar;
 
  typedef unspecified AnsatzVars;
 
 
  typedef unspecified TestVars;
 
  typedef unspecified OriginVars;
 
  static ProblemType const type;
 
  typedef typename Vars::Grid::template Codim<0>::Entity Entity;
 
  struct DomainCache 
  {
 
    void moveTo(Cell const&)
    {
    }
 
    template<class Position, class Evaluators>
    void evaluateAt(Position const& x, Evaluators const& evaluators) 
    {
    }
 
    Scalar d0() const;
 
    template <int row, int dim>
    Dune::FieldVector<Scalar,TestVars::template Components<row>::m> d1(VariationalArg<Scalar,dim> const& arg) const;
 
    template <int row, int col, int dim>
    Dune::FieldMatrix<Scalar,TestVars::template Components<row>::m,AnsatzVars::template Components<row>::m>
    d2(VariationalArg<Scalar,dim> const& argT, VariationalArg<Scalar,dim> const& argA) const;
  };
 
  struct BoundaryCache    
  {
    void moveTo(typename Vars::GridView::IntersectionIterator const&);
 
    template<class Position, class Evaluators>
    void evaluateAt(Position const& xi, Evaluators const& evaluators);
 
    Scalar d0() const;
 
    template <int row, int dim>
    Dune::FieldVector<Scalar,TestVars::template Components<row>::m> d1(VariationalArg<Scalar,dim> const& argT) const;
 
    template <int row, int col, int dim>
    Dune::FieldMatrix<Scalar,TestVars::template Components<row>::m,AnsatzVars::template Components<row>::m>
    d2(VariationalArg<Scalar,dim> const& argT, VariationalArg<Scalar,dim> const& argA) const;
  };
 
  struct InnerBoundaryCache
  {
    template <class FaceIterator>
    void moveTo(FaceIterator const&);
    
    template <class Position, class Evaluators>
    void evaluateAt(Position const& x, Evaluators const& evaluators, Evaluators const& neighbourEvaluators);
 
    Scalar d0() const;
 
    template <int row, int dim>
    Dune::FieldVector<Scalar,TestVars::template Components<row>::m> d1(VariationalArg<Scalar,dim> const& argT) const;
 
    template <int row, int col, int dim>
    Dune::FieldMatrix<Scalar,TestVars::::template Components<row>::m,AnsatzVars::::template Components<row>::m>
    d2(VariationalArg<Scalar,dim> const& argT, VariationalArg<Scalar,dim> const& argA, bool centerCell) const;
  };
 
  template <int row>
  struct D1
  {
    static bool const present;
    
    static int const derivatives;
  };
 
  template <int row, int col>
  struct D2 
  {
    static bool const present;
 
    static bool const symmetric;
 
    static const bool makePositive;
 
    static bool const lumped;
    
    static int const derivatives;
  };
  
  DomainCache createDomainCache(int flags) const {}
  
  BoundaryCache createBoundaryCache(int flags) const {}
  
  InnerBoundaryCache createInnerBoundaryCache(int flags) const {}
 
 
  int integrationOrder(typename Variables::Grid::template Codim<0>::Entity const& cell,
                       int shapeFunctionOrder, bool boundary) const;
 
  bool considerFace(Face<typename Variables::GridView> const& face) const;
 
};
 
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
 
class NonlinearVariationalFunctional 
{
public:
  typedef unspecified Scalar;
 
  typedef unspecified AnsatzVars;
 
 
  typedef unspecified TestVars;
  
  typedef unspecified OriginVars;
 
  static ProblemType const type;
 
  typedef typename Vars::Grid::template Codim<0>::Entity Entity;
 
  struct DomainCache : public EvalCacheBase    
  {
 
    DomainCache(Functional const& f, typename Vars::VariableSet const& u, int flags)  {};
 
    template<class Entity>
    void moveTo(Entity const&) 
    {
    }
 
    template<class Position, class Evaluators>
    void evaluateAt(Position const& x, Evaluators const& evaluators) 
    {
    }
 
    Scalar d0() const;
 
    template <int row, int dim>
    Dune::FieldVector<Scalar,Variables::template Components<row>::m> d1(VariationalArg<Scalar,dim> const& arg) const;
 
    template <int row, int col, int dim>
    Dune::FieldMatrix<Scalar,Variables::template Components<row>::m,Variables::template Components<col>::m>
    d2(VariationalArg<Scalar,dim> const& argT, VariationalArg<Scalar,dim> const& argA) const;
  };
 
  struct BoundaryCache : public EvalCacheBase    
  {
    typedef typename AnsatzVars::Grid::LeafIntersectionIterator FaceIterator;
 
    BoundaryCache(Functional const& f, typename Vars::VariableSet const& u, int const flags=7)  {};
 
    template<class FaceIterator>
    void moveTo(FaceIterator const&) 
    {
    }
 
    template<class Position, class Evaluators>
    void evaluateAt(Position const& x, Evaluators const& evaluators) 
    {
    }
 
    Scalar d0() const;
 
    template <int row, int dim>
    Dune::FieldVector<Scalar,Variables::template Components<row>::m> d1(VariationalArg<Scalar,dim> const& arg) const;
 
    template <int row, int col, int dim>
    Dune::FieldMatrix<Scalar,Variables::template Components<row>::m,Variables::template Components<col>::m>
    d2(VariationalArg<Scalar,dim> const& argT, VariationalArg<Scalar,dim> const& argA) const;
  };
 
 
  template <int row>
  struct D1
  {
    static bool const present;
  };
 
  template <int row, int col>
  struct D2 
  {
    static bool const present;
 
    static bool const symmetric;
 
    static bool const lumped;
  };
 
  int integrationOrder(typename Variables::Grid::template Codim<0>::Entity const& cell,
                       int shapeFunctionOrder, bool boundary) const;
 
  bool considerFace(Face<typename Variables::GridView> const& face) const;
};
 
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
 
class ParabolicEquation 
{
public:
  typedef unspecified Scalar;
 
  typedef unspecified AnsatzVars;
 
 
  typedef unspecified TestVars;
  
  typedef unspecified OriginVars;
 
  static ProblemType const type;
 
  using Cell = Kaskade::Cell<typename AnsatzVars::GridView>;
 
  struct DomainCache : public EvalCacheBase    
  {
 
    DomainCache(Functional const& f, typename OriginVars::VariableSet const& u, int flags)  {};
 
    void moveTo(Cell const&) 
    {
    }
 
    template<class Position, class Evaluators>
    void evaluateAt(Position const& x, Evaluators const& evaluators) 
    {
    }
 
    template <int row, int dim>
    Dune::FieldVector<Scalar,Variables::template components<row>> 
    d1(VariationalArg<Scalar,dim> const& arg) const;
 
    template <int row, int col, int dim>
    Dune::FieldMatrix<Scalar,Variables::template components<row>,
                             Variables::template components<col>>
    d2(VariationalArg<Scalar,dim> const& argT, VariationalArg<Scalar,dim> const& argA) const;
 
    template <int row, int col, int dim>
    Dune::FieldMatrix<Scalar,Variables::template components<row>,
                             Variables::template components<col>>
    b2(VariationalArg<Scalar,dim> const& argT, VariationalArg<Scalar,dim> const& argA) const;
  };
 
  struct BoundaryCache : public EvalCacheBase    
  {
    typedef typename AnsatzVars::Grid::LeafIntersectionIterator FaceIterator;
 
    BoundaryCache(Functional const& f, typename OriginVars::VariableSet const& u, int const flags=7)  {};
 
    template<class FaceIterator>
    void moveTo(FaceIterator const&) 
    {
    }
 
    template<class Position, class Evaluators>
    void evaluateAt(Position const& x, Evaluators const& evaluators) 
    {
    }
 
    template <int row, int dim>
    Dune::FieldVector<Scalar,Variables::template Components<row>::m> d1(VariationalArg<Scalar,dim> const& arg) const;
 
    template <int row, int col, int dim>
    Dune::FieldMatrix<Scalar,Variables::template components<row>,
                             Variables::template Components<col>>
    d2(VariationalArg<Scalar,dim> const& argT, VariationalArg<Scalar,dim> const& argA) const;
 
    template <int row, int col, int dim>
    Dune::FieldMatrix<Scalar,Variables::template components<row>,
                             Variables::template Components<col>>
    b2(VariationalArg<Scalar,dim> const& argT, VariationalArg<Scalar,dim> const& argA) const;
  };
 
 
  template <int row>
  struct D1
  {
    static bool const present;
  };
 
  template <int row, int col>
  struct D2 
  {
    static bool const present;
 
    static bool const symmetric;
 
    static bool const lumped;
  };
 
  template <int row, int col>
  struct B2 
  {
    static bool const present;
 
    static bool const symmetric;
 
    static bool const lumped;
    
    static bool const constant;
  };
 
  double time() const;
 
  ParabolicEquation& setTime(double t);
 
  void temporalEvaluationRange(double t0, double t1);
 
  int integrationOrder(typename Variables::Grid::template Codim<0>::Entity const& cell,
                       int shapeFunctionOrder, bool boundary) const;
};
 
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
 
struct HierarchicErrorEstimatorD2Info 
{
  template <int row, int col> class D2;
};