concepts.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-2023 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
class unspecified;
 
class LocalToGlobalMapperConcept
{
public:
  typedef unspecified Scalar;
 
  using GridView = unspecified;
 
  typedef unspecified Grid;
 
  typedef unspecified IndexSet;
 
  typedef unspecified ShapeFunctionSet;
  
  typedef unspecified GlobalIndexRange;
 
  typedef unspecified SortedIndexRange;
 
  typedef ConverterConcept Converter;
 
 
  typedef CombinerConcept Combiner;
 
  using Cell = Kaskade::Cell<Grid>;
 
  GridView const& gridView() const;
 
  ShapeFunctionSet const& shapefunctions(Cell const& cell) const;
 
  ShapeFunctionSet const& shapefunctions(size_t index) const;
 
 
  size_t size() const;
  
  int maxOrder() const;
 
  SortedIndexRange sortedIndices(Cell const& cell) const;
 
  SortedIndexRange sortedIndices(size_t n) const;
 
  GlobalIndexRange globalIndices(Cell const& cell) const;
 
  GlobalIndexRange globalIndices(size_t index) const;
 
 
  Combiner combiner(Cell const& cell, size_t index) const;
 
  void update();
};
 
 
class ConverterConcept
{
public:
  ConverterConcept();
 
  ConverterConcept(Cell<Grid> const& cell);
 
  void moveTo(Cell<Grid> const& cell);
 
  void setLocalPosition(LocalPosition<Grid> const& x);
 
  Dune::FieldMatrix<RT,k,1> global(Dune::FieldMatrix<RT,k,1> const& sf) const;
 
  VariationalArg<RT,dim,k> global(VariationalArg<RT,dim,k> const& sf, int deriv=1) const;
 
  template <class Scalar>
  VariationalArg<Scalar,dim,1> global(std::tuple<Dune::FieldVector<Scalar,1>,
                                                 Dune::FieldMatrix<Scalar,1,dim>,
                                                 Tensor<Scalar,1,dim,dim>> const& sf) const;
                                                 
  Dune::FieldMatrix<RT,k,1> local(Dune::FieldMatrix<RT,k,1>) const;
};
 
 
class CombinerConcept
{
public:
  template <int n, int m>
  void rightTransform(DynamicMatrix<Dune::FieldMatrix<Real,n,m>>& A) const;
 
  template <int n, int m>
  void rightTransform(std::vector<VariationalArg<Real,n,m>>& v) const;
 
  template <int n, int m>
  void leftPseudoInverse(DynamicMatrix<Dune::FieldMatrix<Real,n,m>>& A) const;
 
  operator Dune::BCRSMatrix<Dune::FieldMatrix<Real,1,1>>() const;
};
 
//---------------------------------------------------------------------
 
class Function
{
public:
  typedef unspecified Scalar;
 
  static int const components = unspecified;
 
  typedef Dune::FieldVector<Scalar,components> ValueType;
 
  template <class Cell>
  int order(Cell const& cell) const;
 
  template <class Cell>
  ValueType value(Cell const& cell,
                  Dune::FieldVector<typename Cell::Geometry::ctype,
                  Cell::dimension> const& localCoordinate) const;
};
 
//---------------------------------------------------------------------
 
struct Weighing
{
  template<class Cell>
  double operator()(Cell const& c) const;
  double scalingFactor() const;
  double offset() const;
};
 
//---------------------------------------------------------------------
 
class Scaling
{
public:
  template <class Cell, class Sequence>
  void operator()(Cell const& cell,
                  Dune::FieldVector<typename Cell::Geometry::ctype,Cell::dimension> const& localPos,
                  Sequence& values) const;
};
 
//---------------------------------------------------------------------
 
class HierarchicErrorEstimator_D2BlockInfo
{
  template <int row, int col>
  class D2
  {
    static bool const present;
    static bool const lumped;
  };
};
 
//---------------------------------------------------------------------
 
template <class X, class Y>
class MatrixRepresentedOperator: public Dune::LinearOperator<X,Y>
{
public:
  typedef X domain_type;
  typedef Y range_type;
 
  template <class MatrixType>
  MatrixType get() const;
 
 
  template <class Vector>
  void rangeToVector(Y const& y, Vector& coord) const;
 
 
  template <class Vector>
  void vectorToDomain(Vector const& coord, X& x) const;
};
 
 
class Collector
{
public:
  Collector(Collector const&); 
  
    template <class Cell>
    int integrationOrder(Cell const& /* ci */, int shapeFunctionOrder) const;
    
  template <class Cell, class Index, class Values>
  void operator()(Cell const& cell, Index idx,
                  LocalPosition xi, double weight,
                  Values const& x);
  
  void join(Collector& c);
};
 
class FunctionView
{
public:
  using Space = unspecified;
  
  Space const& space() const;
  
  Dune::FieldVector<unspecified,unspecified> value(typename Space::Evaluator const& evaluator) const;
};
 
class WeakFunctionView
{
public:
  Dune::FieldVector<unspecified,unspecified> value(Cell const& cell, Position const& xloc) const;
};
 
 
 
class HyperelasticMaterialLaw
{
public:
  using Scalar = unspecified;
  
  static int const dim = unspecified;
  
  using Tensor = unspecified; 
      
  using VoigtTensor = unspecified; 
  
  void setLinearizationPoint(Tensor const& e);
      
  Scalar d0() const;
  
  Scalar d1(Tensor const& e1) const;
  
  Scalar d2(Tensor const& e1, Tensor const& e2) const;
  
  Tensor stress() const;
  
   VoigtTensor strainToStressMatrix() const;
};
 
class InvariantsMaterialConcept
{
public:
  using Scalar = unspecified;
  
  static int const dim = unspecified;
  
  using Invariants = Dune::FieldVector<Scalar,dim>;
  
  void InvariantsMaterialConcept(Invariants const& i, ... );
  
  Scalar d0() const;
  
  Scalar d1(Invariants const& i1) const;
  
  Scalar d2(Invariants const& i1, Invariants const& i2) const;  
};
 
// ------------------------------------------------------------------------------------------------
 
struct BlockFilter
{
  template <int row>          struct D1 { static bool const assemble = unspecified; };
  template <int row, int col> struct D2 { static bool const assemble = unspecified; };
};