localfunctionplaceholder.hh

#ifndef __DUNE_ACFEM_FUNCTIONS_PLACEHOLDERS_LOCALFUNCTIONPLACEHOLDER_HH__
#define __DUNE_ACFEM_FUNCTIONS_PLACEHOLDERS_LOCALFUNCTIONPLACEHOLDER_HH__
 
#include <dune/fem/function/localfunction/const.hh>
 
#include "../policy.hh"
#include "../localfunctiontraits.hh"
#include "../../tensors/operations/placeholder.hh"
#include "../../tensors/bindings/dune/fieldtensor.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    namespace GridFunction {
 
      using namespace Literals;
      using Tensor::PlaceholderTensor;
      using Tensor::FieldVectorTensor;
      using Tensor::ScalarDecayFieldTensor;
 
      template<class LocalFunction, std::size_t IndeterminateId = Policy::indeterminateId()>
      class LocalFunctionPlaceholder
        : public PlaceholderTensor<ScalarDecayFieldTensor<typename std::decay_t<LocalFunction>::RangeType>, LocalFunctionPlaceholder<LocalFunction, IndeterminateId> >
      {
        using ThisType = LocalFunctionPlaceholder;
        using BaseType = PlaceholderTensor<ScalarDecayFieldTensor<typename std::decay_t<LocalFunction>::RangeType>, ThisType>;
       public:
        using LocalFunctionType = std::decay_t<LocalFunction>;
        using GridFunctionType = typename LocalFunctionType::GridFunctionType;
        using RangeType = typename LocalFunctionType::RangeType;
        using DomainType = typename LocalFunctionType::DomainType;
        using TensorType = ScalarDecayFieldTensor<RangeType>;
        using GridPartType = typename LocalFunctionType::GridPartType;
        using EntityType = typename LocalFunctionType::EntityType;
 
        static_assert(!RefersConst<LocalFunction>::value,
                      "LocalFunction placeholders cannot be built from const qualified local functions");
 
        static constexpr std::size_t indeterminateId_ = IndeterminateId;
 
        using BaseType::operand;
 
        template<class Arg, std::enable_if_t<std::is_constructible<LocalFunctionType, Arg>::value, int> = 0>
        LocalFunctionPlaceholder(Arg&& localFunction)
          : BaseType(TensorType(), Expressions::Functor<BaseType>{})
          , localFunction_(std::forward<Arg>(localFunction))
        {}
 
        constexpr unsigned int order() const
        {
          return localFunction_.gridFunction().order();
        }
 
        template<class Point,
                 std::enable_if_t<(IsQuadraturePoint<Point>::value || IsFieldVector<Point>::value), int> = 0>
        void setValue(const Point& point)
        {
          assert(localFunction_.entity() != EntityType());
          operand(0_c) = localFunction_.evaluate(point);
        }
 
        void bind(const EntityType& entity)
        {
          localFunction_.bind(entity);
        }
 
        void unbind()
        {
          localFunction_.unbind();
        }
 
        LocalFunction localFunction() &&
        {
          return localFunction_;
        }
 
        auto& localFunction() &
        {
          return localFunction_;
        }
 
        const auto& localFunction() const&
        {
          return localFunction_;
        }
 
        const auto& gridFunction() const
        {
          return localFunction_.gridFunction();
        }
 
        const auto& gridPart() const
        {
          return localFunction_.gridFunction().gridPart();
        }
 
        static constexpr auto indeterminateId()
        {
          return IndexConstant<indeterminateId_>::value;
        }
 
        std::string name() const
        {
          // use gridFunction name
          return localFunction_.gridFunction().name() + "(X["+toString(indeterminateId_)+"])";
        }
 
       private:
        LocalFunction localFunction_;
      };
 
      template<class T>
      struct IsLocalFunctionPlaceholder
        : FalseType
      {};
 
      template<class T>
      struct IsLocalFunctionPlaceholder<T&>
        : IsLocalFunctionPlaceholder<std::decay_t<T> >
      {};
 
      template<class T>
      struct IsLocalFunctionPlaceholder<T&&>
        : IsLocalFunctionPlaceholder<std::decay_t<T> >
      {};
 
      template<class LocalFunction>
      struct IsLocalFunctionPlaceholder<LocalFunctionPlaceholder<LocalFunction> >
        : TrueType
      {};
 
      template<class F, std::size_t IndeterminateId = Policy::indeterminateId(), class Closure = Expressions::Closure,
               std::enable_if_t<IsConstLocalFunction<F>::value, int> = 0>
      auto localFunctionPlaceholder(F&& f, IndexConstant<IndeterminateId> id = IndexConstant<IndeterminateId>{}, Closure closure = Closure{})
      {
        static_assert(!RefersConst<F>::value, "F must not be const.");
 
        return closure(LocalFunctionPlaceholder<F, IndeterminateId>(std::forward<F>(f)));
      }
 
      template<class F, std::size_t IndeterminateId = Policy::indeterminateId(), class Closure = Expressions::Closure,
               std::enable_if_t<IsWrappableByConstLocalFunction<F>::value, int> = 0>
      auto localFunctionPlaceholder(F&& f, IndexConstant<IndeterminateId> id = IndexConstant<IndeterminateId>{}, Closure closure = Closure{})
      {
        return localFunctionPlaceholder(ensureConstLocalFunction(std::forward<F>(f)), id, Closure{});
      }
 
 
    } // NS GridFunction
 
    using GridFunction::IsLocalFunctionPlaceholder;
    using GridFunction::localFunctionPlaceholder;
 
  } // NS ACFem
 
  template<class LocalFunction, std::size_t IndeterminateId>
  struct FieldTraits<ACFem::GridFunction::LocalFunctionPlaceholder<LocalFunction, IndeterminateId> >
    : FieldTraits<ACFem::GridFunction::PlaceholderTensor<ACFem::GridFunction::FieldVectorTensor<typename std::decay_t<LocalFunction>::RangeType>, ACFem::GridFunction::LocalFunctionPlaceholder<LocalFunction, IndeterminateId> > >
  {};
 
} // NS Dune
 
#endif //  __DUNE_ACFEM_FUNCTIONS_PLACEHOLDERS_LOCALFUNCTIONPLACEHOLDER_HH__