HierarchicNodeToRangeMap.hpp

#pragma once
 
#include <utility>
#include <type_traits>
 
#include <dune/common/concept.hh>
#include <dune/functions/common/indexaccess.hh>
 
#include <amdis/common/Concepts.hpp>
#include <amdis/common/DerivativeTraits.hpp>
 
namespace AMDiS
{
  template <class TreePath, class Range>
  decltype(auto) hierarchicNodeToRangeMap(const TreePath& treePath, Range&& y)
  {
    if constexpr(Concepts::HasIndexAccess<Range, Dune::index_constant<0>>)
      // Specialization for ranges with operator[] access
      return Dune::Functions::resolveStaticMultiIndex(y, treePath);
    else
      // Specialization for non-container ranges
      return std::forward<Range>(y);
  }
 
 
  template <class TreePath, class F>
  struct HierarchicNodeWrapper
  {
    HierarchicNodeWrapper(TreePath const& tp, F const& f)
      : tp_{tp}
      , f_{f}
    {}
 
    template <class Domain>
    auto operator() (Domain const& x) const
    {
      return hierarchicNodeToRangeMap(tp_, Dune::MatVec::as_vector(f_(x)));
    }
 
    decltype(auto) friend derivative(HierarchicNodeWrapper<TreePath,F> const& t)
    {
      auto df = derivativeOf(t.f_, tag::jacobian{});
      df.bind(t.f_.localContext());
      return HierarchicNodeWrapper<TreePath,decltype(df)>(t.tp_, df);
    }
 
    TreePath tp_;
    F f_;
  };
 
} // end namespace AMDiS