composedgridfunction.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_FUNCTIONS_GRIDFUNCTIONS_COMPOSEDGRIDFUNCTION_HH
#define DUNE_FUNCTIONS_GRIDFUNCTIONS_COMPOSEDGRIDFUNCTION_HH
 
#include <type_traits>
#include <tuple>
 
#include <dune/common/referencehelper.hh>
#include <dune/common/typeutilities.hh>
 
#include <dune/functions/common/defaultderivativetraits.hh>
#include <dune/functions/common/differentiablefunction.hh>
#include <dune/functions/gridfunctions/gridfunction.hh>
 
 
namespace Dune {
namespace Functions {
 
 
 
template<class OF, class... IF>
class ComposedGridFunction
{
  using InnerFunctions = std::tuple<IF...>;
  using InnerLocalFunctions = std::tuple<decltype(localFunction(resolveRef(std::declval<const IF&>())))...>;
 
  template<std::size_t i>
  using InnerFunction = std::decay_t<ResolveRef_t<std::tuple_element_t<i, InnerFunctions>>>;
 
  using OuterFunction = OF;
 
public:
 
  using EntitySet = typename InnerFunction<0>::EntitySet;
  using Element = typename EntitySet::Element;
 
  using Domain = typename EntitySet::GlobalCoordinate;
  using LocalDomain = typename EntitySet::LocalCoordinate;
 
  using Range = decltype(std::declval<OF>()(std::declval<IF>()(std::declval<Domain>())...));
 
private:
 
  using Traits = Imp::GridFunctionTraits<Range(Domain), EntitySet, DefaultDerivativeTraits, 16>;
 
  class LocalFunction
  {
  public:
    LocalFunction(const ComposedGridFunction& globalFunction) :
      globalFunction_(globalFunction),
      innerLocalFunctions_(globalFunction.innerLocalFunctions())
    {}
 
    void bind(const Element& element)
    {
      std::apply([&](auto&... innerFunction) {
          (innerFunction.bind(element),...);
      }, innerLocalFunctions_);
    }
 
    void unbind()
    {
      std::apply([&](auto&... innerFunction) {
          (innerFunction.unbind(),...);
      }, innerLocalFunctions_);
    }
 
    bool bound() const
    {
      return std::apply([](const auto&... innerFunction) {
        return (innerFunction.bound() && ...);
      }, innerLocalFunctions_);
    }
 
    Range operator()(const LocalDomain& x) const
    {
      return std::apply([&](const auto&... innerFunction) {
          return globalFunction_.outerFunction_(innerFunction(x)...);
      }, innerLocalFunctions_);
    }
 
    const Element& localContext() const
    {
      return std::get<0>(innerLocalFunctions_).localContext();
    }
 
    friend typename Traits::LocalFunctionTraits::DerivativeInterface derivative(const LocalFunction& t)
    {
      DUNE_THROW(NotImplemented,"not implemented");
    }
 
  private:
    const ComposedGridFunction& globalFunction_;
    InnerLocalFunctions innerLocalFunctions_;
  };
 
public:
 
  template<class OFT, class... IFT,
    disableCopyMove<ComposedGridFunction, OFT> = 0,
    std::enable_if_t<(sizeof...(IFT) > 0), int> = 0>
  ComposedGridFunction(OFT&& outerFunction, IFT&&... innerFunctions) :
    outerFunction_(std::forward<OFT>(outerFunction)),
    innerFunctions_(std::forward<IFT>(innerFunctions)...)
  {}
 
  Range operator()(const Domain& x) const
  {
    return std::apply([&](const auto&... innerFunction) {
      return outerFunction_(innerFunction(x)...);
    }, innerFunctions_);
  }
 
  friend typename Traits::DerivativeInterface derivative(const ComposedGridFunction& t)
  {
    DUNE_THROW(NotImplemented,"not implemented");
  }
 
  friend LocalFunction localFunction(const ComposedGridFunction& cgf)
  {
    return LocalFunction(cgf);
  }
 
  const EntitySet& entitySet() const
  {
    return resolveRef(std::get<0>(innerFunctions_)).entitySet();
  }
 
protected:
 
  InnerLocalFunctions innerLocalFunctions() const
  {
    return std::apply([&](const auto&... innerFunction) {
        return std::make_tuple(localFunction(resolveRef(innerFunction))...);
    }, innerFunctions_);
  }
 
  OuterFunction outerFunction_;
  InnerFunctions innerFunctions_;
};
 
// deduction guides
template<class OF, class... IF>
ComposedGridFunction(const OF&, const IF&...)
  -> ComposedGridFunction<OF,IF...>;
 
 
template<class OF, class... IF>
auto makeComposedGridFunction(OF&& outerFunction, IF&&... innerFunction)
{
  using ComposedGridFunctionType = ComposedGridFunction<std::decay_t<OF>, std::decay_t<IF>...>;
  return ComposedGridFunctionType(std::forward<OF>(outerFunction), std::forward<IF>(innerFunction)...);
}
 
 
 
}} // namespace Dune::Functions
 
 
 
#endif // DUNE_FUNCTIONS_GRIDFUNCTIONS_COMPOSEDGRIDFUNCTION_HH