1#ifndef __DUNE_ACFEM_OPERATORS_FUNCTIONALS_MODULES_MODELFUNCTIONAL_HH__
2#define __DUNE_ACFEM_OPERATORS_FUNCTIONALS_MODULES_MODELFUNCTIONAL_HH__
4#include "../../../common/literals.hh"
5#include "../../../expressions/terminal.hh"
7#include "../../generators.hh"
8#include "../linearfunctional.hh"
14 namespace LinearFunctional {
16 using namespace Literals;
18 template<
class Model,
class DomainFunction,
class DiscreteFunctionSpace>
20 :
public LinearFunctionalBase<DiscreteFunctionSpace>
21 , Expressions::SelfExpression<ModelFunctional<Model, DomainFunction, DiscreteFunctionSpace> >
23 using BaseType = LinearFunctionalBase<DiscreteFunctionSpace>;
25 using typename BaseType::DiscreteFunctionSpaceType;
26 using typename BaseType::RangeFieldType;
28 template<
class ModelArg,
class FctArg,
29 std::enable_if_t<(std::is_constructible<Model, ModelArg>::value
30 && std::is_constructible<DomainFunction, FctArg>::value
32 ModelFunctional(ModelArg&& model, FctArg&& fct,
const DiscreteFunctionSpaceType& space)
34 , model_(
std::forward<ModelArg>(model))
35 , domainFunction_(
std::forward<FctArg>(fct))
38 template<
class FieldArg,
class DiscreteFunction,
39 std::enable_if_t<std::is_constructible<RangeFieldType, FieldArg>::value,
int> = 0>
40 void coefficients(FieldArg&& s, DiscreteFunction& values)
const
42 if constexpr (ExpressionTraits<FieldArg>::isZero) {
45 auto pdeOperator = ellipticOperator(s*model_, domainFunction_, values);
46 pdeOperator(domainFunction_, values);
50 template<
class DiscreteFunction>
51 void coefficients(DiscreteFunction& df)
const
53 coefficients(1_f, df);
56 template<
class DiscreteFunction>
57 auto operator()(
const DiscreteFunction& df)
const
59 return inner(*
this, df);
62 std::string name()
const
64 return "Op(" + domainFunction_.name() +
",.)";
69 DomainFunction domainFunction_;
72 template<
class Model,
class DomainFunction,
class DiscreteFunctionSpace>
73 auto modelFunctional(Model&& model, DomainFunction&& fct,
const DiscreteFunctionSpace& space)
75 return ModelFunctional<Model, DomainFunction, DiscreteFunctionSpace>(
76 std::forward<Model>(model), std::forward<DomainFunction>(fct), space
80 template<
class DomainFunction,
class DiscreteFunctionSpace>
81 auto l2InnerProductFunctional(DomainFunction&& fct,
const DiscreteFunctionSpace& space)
87 template<
class DomainFunction,
class Indicator,
class DiscreteFunctionSpace>
88 auto l2BoundaryFunctional(DomainFunction&& fct, Indicator&& indicator,
const DiscreteFunctionSpace& space)
90 return modelFunctional(
neumannBoundaryModel(std::forward<DomainFunction>(fct), std::forward<Indicator>(indicator)),
95 template<
class Gr
idFunction,
class DiscreteFunctionSpace>
96 auto divergenceFunctional(GridFunction&& u,
const DiscreteFunctionSpace& space)
103 using LinearFunctional::modelFunctional;
104 using LinearFunctional::l2InnerProductFunctional;
105 using LinearFunctional::l2BoundaryFunctional;
106 using LinearFunctional::divergenceFunctional;
constexpr auto zero(T &&t)
Use the zero fraction as canonical zero element for scalars.
Definition: constantoperations.hh:80
constexpr auto divergenceLoadModel(GridFunction &&f, const std::string &name="")
Generate a divergence model which only contributes to the load-vector.
Definition: divergenceloadmodel.hh:126
constexpr auto bulkLoadFunctionModel(Fct &&f, const std::string &name="")
Generate a BulkLoadFunctionModel for the "right hand side".
Definition: bulkloadmodel.hh:112
constexpr auto neumannBoundaryModel(Fct &&values, Indicator &&where=std::decay_t< Indicator >{}, const std::string &name="")
Generate NeumannBoundaryModel from given grid-function and boundary indicator.
Definition: neumannmodel.hh:189
auto inner(T1 &&t1, T2 &&t2)
"scalar product"
Definition: expressions.hh:154