Loading [MathJax]/extensions/TeX/AMSsymbols.js

DUNE-ACFEM (unstable)

modelfunctional.hh
1#ifndef __DUNE_ACFEM_OPERATORS_FUNCTIONALS_MODULES_MODELFUNCTIONAL_HH__
2#define __DUNE_ACFEM_OPERATORS_FUNCTIONALS_MODULES_MODELFUNCTIONAL_HH__
3
4#include "../../../common/literals.hh"
5#include "../../../expressions/terminal.hh"
6
7#include "../../generators.hh"
8#include "../linearfunctional.hh"
9
10namespace Dune {
11
12 namespace ACFem {
13
14 namespace LinearFunctional {
15
16 using namespace Literals;
17
18 template<class Model, class DomainFunction, class DiscreteFunctionSpace>
19 class ModelFunctional
20 : public LinearFunctionalBase<DiscreteFunctionSpace>
21 , Expressions::SelfExpression<ModelFunctional<Model, DomainFunction, DiscreteFunctionSpace> >
22 {
23 using BaseType = LinearFunctionalBase<DiscreteFunctionSpace>;
24 public:
25 using typename BaseType::DiscreteFunctionSpaceType;
26 using typename BaseType::RangeFieldType;
27
28 template<class ModelArg, class FctArg,
29 std::enable_if_t<(std::is_constructible<Model, ModelArg>::value
30 && std::is_constructible<DomainFunction, FctArg>::value
31 ), int> = 0>
32 ModelFunctional(ModelArg&& model, FctArg&& fct, const DiscreteFunctionSpaceType& space)
33 : BaseType(space)
34 , model_(std::forward<ModelArg>(model))
35 , domainFunction_(std::forward<FctArg>(fct))
36 {}
37
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
41 {
42 if constexpr (ExpressionTraits<FieldArg>::isZero) {
43 values.clear();
44 } else {
45 auto pdeOperator = ellipticOperator(s*model_, domainFunction_, values);
46 pdeOperator(domainFunction_, values);
47 }
48 }
49
50 template<class DiscreteFunction>
51 void coefficients(DiscreteFunction& df) const
52 {
53 coefficients(1_f, df);
54 }
55
56 template<class DiscreteFunction>
57 auto operator()(const DiscreteFunction& df) const
58 {
59 return inner(*this, df);
60 }
61
62 std::string name() const
63 {
64 return "Op(" + domainFunction_.name() + ",.)";
65 }
66
67 protected:
68 Model model_;
69 DomainFunction domainFunction_;
70 };
71
72 template<class Model, class DomainFunction, class DiscreteFunctionSpace>
73 auto modelFunctional(Model&& model, DomainFunction&& fct, const DiscreteFunctionSpace& space)
74 {
75 return ModelFunctional<Model, DomainFunction, DiscreteFunctionSpace>(
76 std::forward<Model>(model), std::forward<DomainFunction>(fct), space
77 );
78 }
79
80 template<class DomainFunction, class DiscreteFunctionSpace>
81 auto l2InnerProductFunctional(DomainFunction&& fct, const DiscreteFunctionSpace& space)
82 {
83 // return modelFunctional(massModel(fct), std::forward<DomainFunction>(fct), space);
84 return modelFunctional(bulkLoadFunctionModel(std::forward<DomainFunction>(fct)), zero(fct), space);
85 }
86
87 template<class DomainFunction, class Indicator, class DiscreteFunctionSpace>
88 auto l2BoundaryFunctional(DomainFunction&& fct, Indicator&& indicator, const DiscreteFunctionSpace& space)
89 {
90 return modelFunctional(neumannBoundaryModel(std::forward<DomainFunction>(fct), std::forward<Indicator>(indicator)),
91 zero(fct), space);
92 }
93
95 template<class GridFunction, class DiscreteFunctionSpace>
96 auto divergenceFunctional(GridFunction&& u, const DiscreteFunctionSpace& space)
97 {
98 return modelFunctional(divergenceLoadModel(std::forward<GridFunction>(u), zero(u), space));
99 }
100
101 } // LinearFunctional::
102
103 using LinearFunctional::modelFunctional;
104 using LinearFunctional::l2InnerProductFunctional;
105 using LinearFunctional::l2BoundaryFunctional;
106 using LinearFunctional::divergenceFunctional;
107
108 } // ACFem::
109
110} // Dune::
111
112#endif // __DUNE_ACFEM_OPERATORS_FUNCTIONALS_MODULES_MODELFUNCTIONAL_HH__
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
STL namespace.
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden & Uni Heidelberg  |  generated with Hugo v0.111.3 (Mar 12, 23:28, 2025)