bulkloadmodel.hh

#ifndef __DUNE_ACFEM_MODELS_MODULES_BULKLOADMODEL_HH__
#define __DUNE_ACFEM_MODELS_MODULES_BULKLOADMODEL_HH__
 
#include "../../functions/localfunctiontraits.hh"
#include "../../functions/functiontraits.hh"
#include "../modelbase.hh"
 
namespace Dune {
 
  namespace ACFem::PDEModel {
 
    template<class GridFunction>
    class BulkLoadFunctionModel
      : public ModelBase<typename std::decay_t<GridFunction>::FunctionSpaceType>
      , public Expressions::SelfExpression<BulkLoadFunctionModel<GridFunction> >
      , public MPL::UniqueTags<ConditionalType<IsConstantExprArg<GridFunction>::value, ConstantExpression, void>,
                               ConditionalType<IsTypedValue<GridFunction>::value, TypedValueExpression, void> >
    {
      static_assert(HasTag<GridFunction, Fem::HasLocalFunction>::value,
                    "GridFunction must provide a local function");
 
      using ThisType = BulkLoadFunctionModel;
      using BaseType = ModelBase<typename std::decay_t<GridFunction>::FunctionSpaceType>;
      using LocalFunctionType = Fem::ConstLocalFunction<std::decay_t<GridFunction> >;
     public:
      using typename BaseType::RangeType;
 
      template<class FunctionArg, std::enable_if_t<std::is_constructible<LocalFunctionType, FunctionArg>::value, int> = 0>
      BulkLoadFunctionModel(FunctionArg&& function, const std::string& name = "")
        : localFunction_(std::forward<FunctionArg>(function))
        , name_(name == "" ? "(" + localFunction_.gridFunction().name() + ", . )" : name)
      {}
 
      std::string name() const
      {
        return name_;
      }
 
      template<class Entity>
      void bind(const Entity& entity)
      {
        localFunction_.bind(entity);
      }
 
      void unbind()
      {
        localFunction_.unbind();
      }
 
      template<class Quadrature>
      RangeType source(const QuadraturePoint<Quadrature> &x) const
      {
        return localFunction_.evaluate(x);
      }
 
     protected:
      LocalFunctionType localFunction_;
      std::string name_;
    };
 
 
    template<class Fct,
             std::enable_if_t<(IsWrappableByConstLocalFunction<Fct>::value
                               && !GridFunction::HasRegularity<Fct, 1>::value
      ), int> = 0>
    constexpr auto bulkLoadFunctionModel(Fct&& f, const std::string& name = "")
    {
      return expressionClosure(BulkLoadFunctionModel<Fct>(std::forward<Fct>(f), name));
    }
 
    template<class Fct, std::enable_if_t<GridFunction::HasRegularity<Fct, 1UL>::value, int> = 0>
    constexpr auto bulkLoadFunctionModel(Fct&& f, const std::string& name = "")
    {
      using namespace Literals;
      return bulkLoadFunctionModel(gridFunction(f.gridPart(), std::forward<Fct>(f), 0_c), name);
    }
 
    template<class Fct, std::enable_if_t<ExpressionTraits<Fct>::isZero, int> = 0>
    constexpr auto bulkLoadFunctionModel(Fct&& f, const std::string& name = "")
    {
      return zeroModel(f);
    }
 
 
 
 
  } // namespace ACFem::PDEModel
 
  namespace ACFem {
 
    using PDEModel::bulkLoadFunctionModel;
 
  }
 
}  //Namespace Dune
 
 
#endif // __DUNE_ACFEM_MODELS_MODULES_BULKLOADMODEL_HH__