DiscreteFunction.hpp

#pragma once
 
#include <optional>
#include <vector>
 
#include <dune/common/ftraits.hh>
#include <dune/common/typeutilities.hh>
#include <dune/functions/common/defaultderivativetraits.hh>
#include <dune/functions/functionspacebases/flatvectorview.hh>
#include <dune/functions/gridfunctions/gridviewentityset.hh>
#include <dune/typetree/childextraction.hh>
 
#include <amdis/common/DerivativeTraits.hpp>
#include <amdis/common/Tags.hpp>
#include <amdis/functions/NodeCache.hpp>
#include <amdis/interpolators/SimpleInterpolator.hpp>
#include <amdis/linearalgebra/Access.hpp>
#include <amdis/typetree/FiniteElementType.hpp>
#include <amdis/typetree/RangeType.hpp>
#include <amdis/typetree/TreePath.hpp>
 
namespace AMDiS
{
 
  template <class Coeff, class GB, class TreePath, class Range = void>
  class DiscreteFunction;
 
 
  template <class Coeff, class GB, class TreePath, class R>
  class DiscreteFunction
      : public DiscreteFunction<Coeff const,GB,TreePath,R>
  {
    using Self = DiscreteFunction<Coeff,GB,TreePath,R>;
    using Super = DiscreteFunction<Coeff const,GB,TreePath,R>;
 
    using Coefficients = std::remove_const_t<Coeff>;
    using GlobalBasis = GB;
 
  public:
    template <class C, class B, class... Path,
      REQUIRES(Concepts::Similar<Underlying_t<C>, Coefficients>),
      REQUIRES(Concepts::Similar<Underlying_t<B>, GlobalBasis>)>
    DiscreteFunction(C&& coefficients, B&& basis, Path... path)
      : Super(FWD(coefficients), FWD(basis), path...)
      , mutableCoeff_(wrap_or_share<Coefficients>(FWD(coefficients)))
    {}
 
  public:
 
    template <class Expr, class Tag = tag::assign>
    void interpolate_noalias(Expr&& expr, Tag strategy = {});
 
 
    template <class Expr, class Tag = tag::assign>
    void interpolate(Expr&& expr, Tag strategy = {});
 
    template <class Expr>
    Self& operator<<(Expr&& expr)
    {
      interpolate(FWD(expr));
      return *this;
    }
 
    template <class Expr>
    Self& operator+=(Expr&& expr)
    {
      interpolate((*this) + expr);
      return *this;
    }
 
    template <class Expr>
    Self& operator-=(Expr&& expr)
    {
      interpolate((*this) - expr);
      return *this;
    }
 
    Coefficients& coefficients()
    {
      return *mutableCoeff_;
    }
 
    using Super::coefficients;
 
    template <class Range = void, class... Indices>
    auto child(Indices... ii)
    {
      auto tp = cat(Super::treePath_, makeTreePath(ii...));
      using Child = DiscreteFunction<Coeff, GB, TYPEOF(makeTreePath(tp)), Range>;
      return Child{mutableCoeff_, Super::basis_, tp};
    }
 
    using Super::child;
 
  protected:
    std::shared_ptr<Coefficients> mutableCoeff_;
  };
 
  template <class Coeff, class GB, class TreePath, class R>
  class DiscreteFunction<Coeff const,GB,TreePath,R>
  {
  private:
    using Coefficients = std::remove_const_t<Coeff>;
    using GlobalBasis = GB;
    using LocalView = typename GlobalBasis::LocalView;
    using GridView = typename GlobalBasis::GridView;
 
    using Coefficient = TYPEOF(std::declval<Traits::Access>()(std::declval<Coeff const>(), std::declval<typename GB::MultiIndex>()));
 
    using Tree = typename GlobalBasis::LocalView::Tree;
    using SubTree = typename Dune::TypeTree::ChildForTreePath<Tree, TreePath>;
 
  public:
    using EntitySet = Dune::Functions::GridViewEntitySet<GridView, 0>;
 
    using Domain = typename EntitySet::GlobalCoordinate;
 
    using Range = std::conditional_t<std::is_same_v<R,void>, RangeType_t<SubTree,Coefficient>, R>;
 
    enum { hasDerivative = false };
 
  private:
    template <class Type>
    class LocalFunction;
 
  public:
 
    template <class C, class B, class... Path,
      REQUIRES(Concepts::Similar<Underlying_t<C>, Coefficients>),
      REQUIRES(Concepts::Similar<Underlying_t<B>, GlobalBasis>)>
    DiscreteFunction(C&& coefficients, B&& basis, Path... path)
      : coefficients_{wrap_or_share(FWD(coefficients))}
      , basis_{wrap_or_share(FWD(basis))}
      , treePath_{makeTreePath(path...)}
      , entitySet_{basis_->gridView()}
    {}
 
    Range operator()(Domain const& x) const;
 
    LocalFunction<tag::value> makeLocalFunction() const
    {
      return {basis().localView(), treePath_, coefficients_, tag::value{}};
    }
 
    EntitySet const& entitySet() const
    {
      return entitySet_;
    }
 
    GlobalBasis const& basis() const
    {
      return *basis_;
    }
 
    TreePath const& treePath() const
    {
      return treePath_;
    }
 
    Coefficients const& coefficients() const
    {
      return *coefficients_;
    }
 
    template <class Range = void, class... Indices>
    auto child(Indices... ii) const
    {
      auto tp = cat(this->treePath_, makeTreePath(ii...));
      using Child = DiscreteFunction<Coeff const, GB, TYPEOF(makeTreePath(tp)), Range>;
      return Child{coefficients_, basis_, tp};
    }
 
  protected:
    std::shared_ptr<Coefficients const> coefficients_;
    std::shared_ptr<GlobalBasis const> basis_;
    TreePath treePath_;
    EntitySet entitySet_;
  };
 
 
  // deduction guides
 
  template <class Coefficients, class Basis, class... Indices,
    class C = Underlying_t<Coefficients>,
    class B = std::remove_const_t<Underlying_t<Basis>>,
    class TP = TYPEOF(makeTreePath(std::declval<Indices>()...)),
    REQUIRES(Concepts::GlobalBasis<B>)>
  DiscreteFunction(Coefficients&&, Basis&&, Indices...)
    -> DiscreteFunction<C,B,TP>;
 
 
  // Get the childs of a discrete function by using `valueOf`
  // -------------------------------------------------------
 
  template <class Range = void, class C, class GB, class TP, class R, class... Indices>
  auto valueOf(DiscreteFunction<C,GB,TP,R>& df, Indices... ii)
  {
    return df.template child<Range>(ii...);
  }
 
  template <class Range = void, class C, class GB, class TP, class R, class... Indices>
  auto valueOf(DiscreteFunction<C,GB,TP,R> const& df, Indices... ii)
  {
    return df.template child<Range>(ii...);
  }
 
} // end namespace AMDiS
 
#include "DiscreteLocalFunction.inc.hpp"
#include "DiscreteFunction.inc.hpp"