DUNE-ACFEM (2.5.1)

modelexpression.hh
1 #ifndef __MODELEXPRESSION_HH__
2 #define __MODELEXPRESSION_HH__
3 
4 #include "../models/modelinterface.hh"
5 #include "../models/modelexpressionbase.hh"
6 #include "../models/modeloperations.hh"
7 #include "../models/zeromodel.hh"
8 #include "operatorparts/operatorpartsexpression.hh"
9 #include "../functions/gridfunctionexpression.hh"
10 #include "../functions/gridfunctionwrapper.hh"
11 #include "../operators/functionals/l2innerproductfunctional.hh"
12 #include "../operators/functionals/functionalexpression.hh"
13 
14 namespace Dune
15 {
16 
17  namespace ACFem
18  {
19 
33  template<class BinOp, class LeftModelType, class RightModelType>
34  class BinaryModelExpression;
35 
37  template<class UnOp, class ModelType>
38  class UnaryModelExpression;
39 
41  template<class Model>
42  class UnaryModelExpression<IdentityOperation, Model>
43  : public ModelExpression<UnaryModelExpression<IdentityOperation, Model> >
44  {
45  typedef Model ModelType;
46  typedef IdentityOperation OpType;
47  typedef UnaryModelExpression<OpType, ModelType> ThisType;
48  typedef ModelExpression<ThisType> BaseType;
49  typedef ModelInterface<ThisType> InterfaceType;
50  typedef ModelTraits<ThisType> TraitsType;
51  public:
53  typedef ModelType ContainedExpressionType;
54 
56  typedef typename InterfaceType::FunctionSpaceType FunctionSpaceType;
57 
59  typedef typename InterfaceType::GridPartType GridPartType;
60 
62  typedef typename InterfaceType::EntityType EntityType;
63  typedef typename InterfaceType::IntersectionType IntersectionType;
64 
66  typedef typename InterfaceType::DomainFieldType DomainFieldType ;
68  typedef typename InterfaceType::RangeFieldType RangeFieldType ;
70  typedef typename InterfaceType::DomainType DomainType ;
72  typedef typename InterfaceType::RangeType RangeType ;
74  typedef typename InterfaceType::JacobianRangeType JacobianRangeType;
76  typedef typename InterfaceType::HessianRangeType HessianRangeType;
77 
78  enum { dimDomain = FunctionSpaceType::dimDomain, dimRange = FunctionSpaceType::dimRange };
79 
80  typedef typename InterfaceType::OperatorPartsType OperatorPartsType;
81 
82  typedef typename InterfaceType::BulkForcesFunctionType BulkForcesFunctionType;
83  typedef typename InterfaceType::DirichletBoundaryFunctionType DirichletBoundaryFunctionType;
84  typedef typename InterfaceType::NeumannBoundaryFunctionType NeumannBoundaryFunctionType;
85 
86  typedef typename InterfaceType::DirichletIndicatorType DirichletIndicatorType;
87  typedef typename InterfaceType::NeumannIndicatorType NeumannIndicatorType;
88 
89  public:
90 
91  // constructor
92  UnaryModelExpression(const ModelType& f)
93  : model_(f)
94  {}
95 
96  // copy constructor
97  UnaryModelExpression(const ThisType &other)
98  : model_( other.model_ )
99  {}
100 
102  std::string name() const
103  {
104  return OpType::name() + "(" + model_().name() + ")";
105  }
106 
108  OperatorPartsType operatorParts() const
109  {
110  return model_().operatorParts();
111  }
112 
114  BulkForcesFunctionType
115  bulkForcesFunction(const GridPartType& gridPart) const
116  {
117  return model_().bulkForcesFunction(gridPart);
118  }
119 
121  template<class DiscreteFunctionSpace>
122  typename TraitsType::template ForcesFunctionalTraits<DiscreteFunctionSpace>::FunctionalType
123  forcesFunctional(const DiscreteFunctionSpace& space) const
124  {
125  return model_().forcesFunctional(space);
126  }
127 
129  DirichletBoundaryFunctionType
130  dirichletBoundaryFunction(const GridPartType& gridPart) const
131  {
132  return model_().dirichletBoundaryFunction(gridPart);
133  }
134 
136  NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType& gridPart) const
137  {
138  return model_().neumannBoundaryFunction(gridPart);
139  }
140 
142  DirichletIndicatorType dirichletIndicator() const {
143  return model_().dirichletIndicator();
144  }
145 
147  NeumannIndicatorType neumannIndicator() const {
148  return model_().neumannIndicator();
149  }
150 
151  const ContainedExpressionType& containedExpression() const
152  {
153  return model_();
154  }
155 
156  protected:
157  ExpressionStorage<ModelType> model_;
158  };
159 
160  //traits
161  template<class Model>
162  struct ModelTraits<UnaryModelExpression<IdentityOperation, Model> >
163  : public DefaultModelTraits<typename Model::FunctionSpaceType, typename Model::GridPartType>
164  {
165  protected:
166  typedef Model ModelType;
167  public:
169  template<class DiscreteFunctionSpace>
170  struct ForcesFunctionalTraits
171  : public ModelType::template ForcesFunctionalTraits<DiscreteFunctionSpace>
172  {};
173 
174  typedef IdentityOperation OpType;
175  typedef typename ModelType::FunctionSpaceType FunctionSpaceType;
176  typedef typename ModelType::GridPartType GridPartType;
177 
178  typedef typename ModelType::OperatorPartsType OperatorPartsType;
179 
180  typedef typename ModelType::BulkForcesFunctionType BulkForcesFunctionType;
181  typedef typename ModelType::NeumannBoundaryFunctionType NeumannBoundaryFunctionType;
182  typedef typename ModelType::DirichletBoundaryFunctionType DirichletBoundaryFunctionType;
183  typedef typename ModelType::DirichletWeightFunctionType DirichletWeightFunctionType;
184 
185  typedef typename ModelType::DirichletIndicatorType DirichletIndicatorType;
186  typedef typename ModelType::NeumannIndicatorType NeumannIndicatorType;
187  };
188 
190  template<class Model>
191  class UnaryModelExpression<MinusOperation, Model>
192  : public ModelExpression<UnaryModelExpression<MinusOperation, Model> >
193  {
194  typedef Model ModelType;
195  typedef MinusOperation OpType;
196  typedef UnaryModelExpression<OpType, ModelType> ThisType;
197  typedef ModelExpression<ThisType> BaseType;
198  typedef ModelInterface<ThisType> InterfaceType;
199  typedef ModelTraits<ThisType> TraitsType;
200  public:
202  typedef ModelType ContainedExpressionType;
203 
205  typedef typename InterfaceType::FunctionSpaceType FunctionSpaceType;
206 
208  typedef typename InterfaceType::GridPartType GridPartType;
209 
211  typedef typename InterfaceType::EntityType EntityType;
212  typedef typename InterfaceType::IntersectionType IntersectionType;
213 
215  typedef typename InterfaceType::DomainFieldType DomainFieldType ;
217  typedef typename InterfaceType::RangeFieldType RangeFieldType ;
219  typedef typename InterfaceType::DomainType DomainType ;
221  typedef typename InterfaceType::RangeType RangeType ;
223  typedef typename InterfaceType::JacobianRangeType JacobianRangeType;
225  typedef typename InterfaceType::HessianRangeType HessianRangeType;
226 
227  enum { dimDomain = FunctionSpaceType::dimDomain, dimRange = FunctionSpaceType::dimRange };
228 
229  typedef typename InterfaceType::OperatorPartsType OperatorPartsType;
230 
231  typedef typename InterfaceType::BulkForcesFunctionType BulkForcesFunctionType;
232  typedef typename InterfaceType::DirichletBoundaryFunctionType DirichletBoundaryFunctionType;
233  typedef typename InterfaceType::DirichletWeightFunctionType DirichletWeightFunctionType;
234  typedef typename InterfaceType::NeumannBoundaryFunctionType NeumannBoundaryFunctionType;
235 
236  typedef typename InterfaceType::DirichletIndicatorType DirichletIndicatorType;
237  typedef typename InterfaceType::NeumannIndicatorType NeumannIndicatorType;
238 
239  public:
240 
241  // constructor
242  UnaryModelExpression(const ModelType& f)
243  : model_(f)
244  {}
245 
246  // copy constructor
247  UnaryModelExpression(const ThisType &other)
248  : model_( other.model_ )
249  {}
250 
251 
253  std::string name() const
254  {
255  return OpType::name() + "(" + model_().name() + ")";
256  }
257 
259  OperatorPartsType operatorParts() const
260  {
261  return -model_().operatorParts();
262  }
263 
265  BulkForcesFunctionType
266  bulkForcesFunction(const GridPartType& gridPart) const
267  {
268  return -model_().bulkForcesFunction(gridPart);
269  }
270 
272  template<class DiscreteFunctionSpace>
273  typename TraitsType::template ForcesFunctionalTraits<DiscreteFunctionSpace>::FunctionalType
274  forcesFunctional(const DiscreteFunctionSpace& space) const
275  {
276  return -model_().forcesFunctional(space);
277  }
278 
280  DirichletBoundaryFunctionType
281  dirichletBoundaryFunction(const GridPartType& gridPart) const
282  {
283  return -model_().dirichletBoundaryFunction(gridPart);
284  }
285 
287  DirichletWeightFunctionType
288  dirichletWeightFunction(const GridPartType& gridPart) const
289  {
290  return -model_().dirichletWeightFunction(gridPart);
291  }
292 
294  NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType& gridPart) const
295  {
296  return -model_().neumannBoundaryFunction(gridPart);
297  }
298 
300  DirichletIndicatorType dirichletIndicator() const {
301  return model_().dirichletIndicator();
302  }
303 
305  NeumannIndicatorType neumannIndicator() const {
306  return model_().neumannIndicator();
307  }
308 
309  const ContainedExpressionType& containedExpression() const
310  {
311  return model_();
312  }
313 
314  protected:
315  ExpressionStorage<ModelType> model_;
316  };
317 
318  //traits
319  template<class Model>
320  struct ModelTraits<UnaryModelExpression<MinusOperation, Model> >
321  : public DefaultModelTraits<typename Model::FunctionSpaceType, typename Model::GridPartType>
322  {
323  protected:
324  typedef Model ModelType;
325  public:
327  template<class DiscreteFunctionSpace>
328  struct ForcesFunctionalTraits
329  : public ModelType::template ForcesFunctionalTraits<DiscreteFunctionSpace>
330  {
331  protected:
332  typedef typename ModelType::template ForcesFunctionalTraits<DiscreteFunctionSpace> BaseType;
333  public:
334  typedef
335  typename ExpressionResult<MinusOperation, typename BaseType::FunctionalType>::Type
336  FunctionalType;
337  };
338 
339  typedef typename ModelType::FunctionSpaceType FunctionSpaceType;
340  typedef typename ModelType::GridPartType GridPartType;
341 
342  typedef
343  typename ExpressionResult<MinusOperation, typename ModelType::OperatorPartsType>::Type
344  OperatorPartsType;
345 
346  typedef
347  typename ExpressionResult<MinusOperation, typename ModelType::BulkForcesFunctionType>::Type
348  BulkForcesFunctionType;
349  typedef
350  typename ExpressionResult<MinusOperation, typename ModelType::NeumannBoundaryFunctionType>::Type
351  NeumannBoundaryFunctionType;
352  typedef
353  typename ExpressionResult<MinusOperation, typename ModelType::DirichletBoundaryFunctionType>::Type
354  DirichletBoundaryFunctionType;
355  typedef
356  typename ExpressionResult<MinusOperation, typename ModelType::DirichletWeightFunctionType>::Type
357  DirichletWeightFunctionType;
358 
359  typedef typename ModelType::DirichletIndicatorType DirichletIndicatorType;
360  typedef typename ModelType::NeumannIndicatorType NeumannIndicatorType;
361  };
362 
363  // BinaryModelExpression
364  // -------------------
365 
369  template<class BinOp, class LeftModelType, class RightModelType>
370  class BinaryModelExpression
371  : public ModelExpression<BinaryModelExpression<BinOp, LeftModelType, RightModelType> >
372  {
373  typedef BinOp BinOpType;
374  typedef BinaryModelExpression<BinOpType, LeftModelType, RightModelType> ThisType;
375  typedef ModelExpression<ThisType> BaseType;
376  typedef ModelInterface<ThisType> InterfaceType;
377  typedef BinaryModelExpressionOperation<BinOpType> OperationType;
378  typedef ModelTraits<ThisType> TraitsType;
379  public:
381  typedef typename InterfaceType::FunctionSpaceType FunctionSpaceType;
382 
384  typedef typename InterfaceType::GridPartType GridPartType;
385 
387  typedef typename InterfaceType::EntityType EntityType;
388  typedef typename InterfaceType::IntersectionType IntersectionType;
389 
391  typedef typename InterfaceType::DomainFieldType DomainFieldType ;
393  typedef typename InterfaceType::RangeFieldType RangeFieldType ;
395  typedef typename InterfaceType::DomainType DomainType ;
397  typedef typename InterfaceType::RangeType RangeType ;
399  typedef typename InterfaceType::JacobianRangeType JacobianRangeType;
401  typedef typename InterfaceType::HessianRangeType HessianRangeType;
402 
403  enum { dimDomain = FunctionSpaceType::dimDomain, dimRange = FunctionSpaceType::dimRange };
404 
405  typedef typename InterfaceType::OperatorPartsType OperatorPartsType;
406 
407  typedef typename InterfaceType::BulkForcesFunctionType BulkForcesFunctionType;
408  typedef typename InterfaceType::DirichletBoundaryFunctionType DirichletBoundaryFunctionType;
409  typedef typename InterfaceType::DirichletWeightFunctionType DirichletWeightFunctionType;
410  typedef typename InterfaceType::NeumannBoundaryFunctionType NeumannBoundaryFunctionType;
411 
412  typedef typename InterfaceType::DirichletIndicatorType DirichletIndicatorType;
413  typedef typename InterfaceType::NeumannIndicatorType NeumannIndicatorType;
414 
415  public:
416 
417  // constructor
418  BinaryModelExpression(const LeftModelType &f,
419  const RightModelType &g)
420  : leftModel_( f ), rightModel_( g )
421  {}
422 
423  // copy constructor
424  BinaryModelExpression(const ThisType &other )
425  : leftModel_( other.leftModel_ ),
426  rightModel_( other.rightModel_ )
427  {}
428 
430  std::string name() const
431  {
432  return "(" + leftModel_().name() + " " + BinOpType::name() + " " + rightModel_().name() + ")";
433  }
434 
436  OperatorPartsType operatorParts() const
437  {
438  return makeExpression(BinOpType(),
439  leftModel_().operatorParts(),
440  rightModel_().operatorParts());
441  }
442 
444  BulkForcesFunctionType
445  bulkForcesFunction(const GridPartType& gridPart) const
446  {
447  return makeExpression(BinOpType(),
448  leftModel_().bulkForcesFunction(gridPart),
449  rightModel_().bulkForcesFunction(gridPart));
450  }
451 
453  template<class DiscreteFunctionSpace>
454  typename TraitsType::template ForcesFunctionalTraits<DiscreteFunctionSpace>::FunctionalType
455  forcesFunctional(const DiscreteFunctionSpace& space) const
456  {
457  return makeExpression(BinOpType(),
458  leftModel_().forcesFunctional(space),
459  rightModel_().forcesFunctional(space));
460  }
461 
463  DirichletBoundaryFunctionType
464  dirichletBoundaryFunction(const GridPartType& gridPart) const
465  {
466  return makeExpression(BinOpType(),
467  leftModel_().dirichletBoundaryFunction(gridPart),
468  rightModel_().dirichletBoundaryFunction(gridPart));
469  }
470 
472  DirichletWeightFunctionType
473  dirichletWeightFunction(const GridPartType& gridPart) const
474  {
475  return makeExpression(BinOpType(),
476  leftModel_().dirichletWeightFunction(gridPart),
477  rightModel_().dirichletWeightFunction(gridPart));
478  }
479 
481  NeumannBoundaryFunctionType
482  neumannBoundaryFunction(const GridPartType& gridPart) const
483  {
484  return makeExpression(BinOpType(),
485  leftModel_().neumannBoundaryFunction(gridPart),
486  rightModel_().neumannBoundaryFunction(gridPart));
487  }
488 
490  DirichletIndicatorType dirichletIndicator() const {
491  return *leftModel_().dirichletIndicator() || *rightModel_().dirichletIndicator();
492  }
493 
495  NeumannIndicatorType neumannIndicator() const {
496  return *leftModel_().neumannIndicator() || *rightModel_().neumannIndicator();
497  }
498 
499  protected:
500  ExpressionStorage<LeftModelType> leftModel_;
501  ExpressionStorage<RightModelType> rightModel_;
502  };
503 
507  template<class BinOp, class LeftModel, class RightModel>
508  struct ModelTraits<BinaryModelExpression<BinOp, LeftModel, RightModel> >
509  : public DefaultModelTraits<typename LeftModel::FunctionSpaceType, typename LeftModel::GridPartType>
510  {
511  private:
512  typedef LeftModel LeftModelType;
513  typedef RightModel RightModelType;
514  typedef typename LeftModelType::FunctionSpaceType LeftFunctionSpaceType;
515  typedef typename RightModelType::FunctionSpaceType RightFunctionSpaceType;
516  typedef typename LeftModelType::GridPartType LeftGridPartType;
517  typedef typename RightModelType::GridPartType RightGridPartType;
518 
519  typedef BinaryModelExpression<BinOp, LeftModelType, RightModelType> ModelType;
520 
521  static_assert((std::is_same<LeftFunctionSpaceType, RightFunctionSpaceType>::value),
522  "Function spaces must agree, cannot combine them");
523  static_assert((std::is_same<LeftGridPartType, RightGridPartType>::value),
524  "Grid-parts must agree, cannot combine them");
525  public:
527  template<class DiscreteFunctionSpace>
528  struct ForcesFunctionalTraits
529  {
530  protected:
531  typedef
532  typename LeftModelType::template ForcesFunctionalTraits<DiscreteFunctionSpace>::FunctionalType
533  LeftFunctionalType;
534  typedef
535  typename RightModelType::template ForcesFunctionalTraits<DiscreteFunctionSpace>::FunctionalType
536  RightFunctionalType;
537  public:
538  typedef DiscreteFunctionSpace DiscreteFunctionSpaceType;
539  typedef
540  typename ExpressionResult<BinOp, LeftFunctionalType, RightFunctionalType>::Type
541  FunctionalType;
542  };
543 
544  typedef LeftFunctionSpaceType FunctionSpaceType;
545  typedef LeftGridPartType GridPartType;
546 
547  typedef
548  typename ExpressionResult<BinOp,
549  typename LeftModelType::OperatorPartsType,
550  typename RightModelType::OperatorPartsType>::Type
551  OperatorPartsType;
552 
553  typedef
554  typename ExpressionResult<BinOp,
555  typename LeftModelType::BulkForcesFunctionType,
556  typename RightModelType::BulkForcesFunctionType>::Type
557  BulkForcesFunctionType;
558  typedef
559  typename ExpressionResult<BinOp,
560  typename LeftModelType::DirichletBoundaryFunctionType,
561  typename RightModelType::DirichletBoundaryFunctionType>::Type
562  DirichletBoundaryFunctionType;
563  typedef
564  typename ExpressionResult<BinOp,
565  typename LeftModelType::DirichletWeightFunctionType,
566  typename RightModelType::DirichletWeightFunctionType>::Type
567  DirichletWeightFunctionType;
568  typedef
569  typename ExpressionResult<BinOp,
570  typename LeftModelType::NeumannBoundaryFunctionType,
571  typename RightModelType::NeumannBoundaryFunctionType>::Type
572  NeumannBoundaryFunctionType;
573 
578  typedef
579  decltype(*std::declval<typename LeftModelType::DirichletIndicatorType>()
580  ||
581  *std::declval<typename RightModelType::DirichletIndicatorType>())
582  DirichletIndicatorType;
583 
588  typedef
589  decltype(*std::declval<typename LeftModelType::NeumannIndicatorType>()
590  ||
591  *std::declval<typename RightModelType::NeumannIndicatorType>())
592  NeumannIndicatorType;
593  };
594 
596  //
597  // Addition
598 
600  template<class LeftModelType, class RightModelType>
601  BinaryModelExpression<PlusOperation, LeftModelType, RightModelType>
602  operator+(const ModelInterface<LeftModelType>& f_,
603  const ModelInterface<RightModelType>& g_)
604  {
605  const LeftModelType& f(static_cast<const LeftModelType&>(f_));
606  const RightModelType& g(static_cast<const RightModelType&>(g_));
607 
608  typedef BinaryModelExpression<PlusOperation, LeftModelType, RightModelType> ExpressionType;
609 
610  return ExpressionType(f, g);
611  }
612 
613 
615  //
616  // Subtraction
617 
619  template<class LeftModelType, class RightModelType>
620  BinaryModelExpression<MinusOperation, LeftModelType, RightModelType>
621  operator-(const ModelInterface<LeftModelType>& f_,
622  const ModelInterface<RightModelType>& g_)
623  {
624  const LeftModelType& f(static_cast<const LeftModelType&>(f_));
625  const RightModelType& g(static_cast<const RightModelType&>(g_));
626 
627  typedef BinaryModelExpression<MinusOperation, LeftModelType, RightModelType> ExpressionType;
628 
629  return ExpressionType(f, g);
630  }
631 
647  template<class Factor, class ModelType>
648  class BinaryModelExpression<SMultiplyOperation, Factor, ModelType>
649  : public ModelExpression<BinaryModelExpression<SMultiplyOperation, Factor, ModelType> >
650  {
651  typedef SMultiplyOperation BinOpType;
652  typedef BinaryModelExpression<BinOpType, Factor, ModelType> ThisType;
653  typedef ModelExpression<ThisType> BaseType;
654  typedef ModelInterface<ThisType> InterfaceType;
655  typedef ModelTraits<ThisType> TraitsType;
656  public:
657  typedef Factor FactorType;
658 
660  typedef typename InterfaceType::FunctionSpaceType FunctionSpaceType;
661 
663  typedef typename InterfaceType::GridPartType GridPartType;
664 
666  typedef typename InterfaceType::EntityType EntityType;
667  typedef typename InterfaceType::IntersectionType IntersectionType;
668 
670  typedef typename InterfaceType::DomainFieldType DomainFieldType ;
672  typedef typename InterfaceType::RangeFieldType RangeFieldType ;
674  typedef typename InterfaceType::DomainType DomainType ;
676  typedef typename InterfaceType::RangeType RangeType ;
678  typedef typename InterfaceType::JacobianRangeType JacobianRangeType;
680  typedef typename InterfaceType::HessianRangeType HessianRangeType;
681 
682  enum { dimDomain = FunctionSpaceType::dimDomain, dimRange = FunctionSpaceType::dimRange };
683 
684  typedef typename InterfaceType::OperatorPartsType OperatorPartsType;
685 
686  typedef typename InterfaceType::BulkForcesFunctionType BulkForcesFunctionType;
687  typedef typename InterfaceType::DirichletBoundaryFunctionType DirichletBoundaryFunctionType;
688  typedef typename InterfaceType::DirichletWeightFunctionType DirichletWeightFunctionType;
689  typedef typename InterfaceType::NeumannBoundaryFunctionType NeumannBoundaryFunctionType;
690 
691  typedef typename InterfaceType::DirichletIndicatorType DirichletIndicatorType;
692  typedef typename InterfaceType::NeumannIndicatorType NeumannIndicatorType;
693 
694  public:
695 
696  // constructor
697  BinaryModelExpression(const FactorType& s, const ModelType& f)
698  : scalar_(s), model_(f)
699  {}
700 
701  // copy constructor
702  BinaryModelExpression (const ThisType &other)
703  : scalar_( other.scalar_ ), model_( other.model_ )
704  {}
705 
707  std::string name() const
708  {
709  return "(" + std::to_string(parameterValue(scalar_())) + " " + BinOpType::name() + " " + model_().name() + ")";
710  }
711 
713  OperatorPartsType operatorParts() const
714  {
715  return makeExpression(BinOpType(), scalar_(), model_().operatorParts());
716  }
717 
719  BulkForcesFunctionType
720  bulkForcesFunction(const GridPartType& gridPart) const
721  {
722  typedef BulkForcesFunctionType FunctionType;
723 
724  return makeExpression(BinOpType(), scalar_(), model_().bulkForcesFunction(gridPart));
725  }
726 
728  template<class DiscreteFunctionSpace>
729  typename TraitsType::template ForcesFunctionalTraits<DiscreteFunctionSpace>::FunctionalType
730  forcesFunctional(const DiscreteFunctionSpace& space) const
731  {
732  return makeExpression(BinOpType(), scalar_(), model_().forcesFunctional(space));
733  }
734 
736  DirichletBoundaryFunctionType dirichletBoundaryFunction(const GridPartType& gridPart) const
737  {
738  // We treat even Dirichlet Boundary Values in a natural way,
739  // i.e. as one half of some functional having its origin in a
740  // bilinear form.
741  return makeExpression(BinOpType(), scalar_(), model_().dirichletBoundaryFunction(gridPart));
742  }
743 
745  DirichletWeightFunctionType dirichletWeightFunction(const GridPartType& gridPart) const
746  {
747  return makeExpression(BinOpType(), scalar_(), model_().dirichletWeightFunction(gridPart));
748  }
749 
751  NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType& gridPart) const
752  {
753  return makeExpression(BinOpType(), scalar_(), model_().neumannBoundaryFunction(gridPart));
754  }
755 
757  DirichletIndicatorType dirichletIndicator() const {
758  return model_().dirichletIndicator();
759  }
760 
762  NeumannIndicatorType neumannIndicator() const {
763  return model_().neumannIndicator();
764  }
765 
766  public:
767  const FactorType& scalar() const { return scalar_(); }
768  const ModelType& model() const { return model_(); }
769  protected:
770  ExpressionStorage<FactorType> scalar_;
771  ExpressionStorage<ModelType> model_;
772  };
773 
774  //traits
775  template<class Factor, class Model>
776  struct ModelTraits<BinaryModelExpression<SMultiplyOperation, Factor, Model> >
777  : public DefaultModelTraits<typename Model::FunctionSpaceType, typename Model::GridPartType>
778  {
779  protected:
780  typedef Model ModelType;
781  typedef Factor FactorType;
782  typedef typename ModelType::FunctionSpaceType::ScalarFunctionSpaceType ScalarFunctionSpaceType;
783  public:
784  typedef SMultiplyOperation BinOpType;
785  typedef typename ModelType::FunctionSpaceType FunctionSpaceType;
786  typedef typename ModelType::GridPartType GridPartType;
787 
789  template<class DiscreteFunctionSpace>
790  struct ForcesFunctionalTraits
791  {
792  protected:
793  typedef
794  typename ModelType::template ForcesFunctionalTraits<DiscreteFunctionSpace>::FunctionalType
795  ModelFunctionalType;
796  public:
797  typedef DiscreteFunctionSpace DiscreteFunctionSpaceType;
798  typedef
799  typename ExpressionResult<BinOpType, FactorType, ModelFunctionalType>::Type
800  FunctionalType;
801  };
802 
803  typedef
804  typename ExpressionResult<BinOpType, FactorType, typename ModelType::OperatorPartsType>::Type
805  OperatorPartsType;
806 
807  typedef
808  typename ExpressionResult<BinOpType, FactorType, typename ModelType::BulkForcesFunctionType>::Type
809  BulkForcesFunctionType;
810  typedef
811  typename ExpressionResult<BinOpType, FactorType, typename ModelType::NeumannBoundaryFunctionType>::Type
812  NeumannBoundaryFunctionType;
813  typedef
814  typename ExpressionResult<BinOpType, FactorType, typename ModelType::DirichletBoundaryFunctionType>::Type
815  DirichletBoundaryFunctionType;
816  typedef
817  typename ExpressionResult<BinOpType, FactorType, typename ModelType::DirichletWeightFunctionType>::Type
818  DirichletWeightFunctionType;
819 
820  typedef typename ModelType::DirichletIndicatorType DirichletIndicatorType;
821  typedef typename ModelType::NeumannIndicatorType NeumannIndicatorType;
822  };
823 
824 
826  template<class ModelType>
827  BinaryModelExpression<SMultiplyOperation, typename ModelType::RangeFieldType, ModelType>
828  operator*(const typename ModelType::RangeFieldType& s_,
829  const ModelInterface<ModelType>& f_)
830  {
831  typedef typename ModelType::RangeFieldType RangeFieldType;
832  const ModelType& f(static_cast<const ModelType&>(f_));
833 
834  typedef BinaryModelExpression<SMultiplyOperation, RangeFieldType, ModelType> ExpressionType;
835 
836  return ExpressionType(s_, f);
837  }
838 
840  template<class ModelType>
841  auto operator*(const ModelInterface<ModelType>& m_,
842  const typename ModelType::RangeFieldType& s_)
843  -> decltype(s_ * asImp(m_))
844  {
845  return s_ * asImp(m_);
846  }
847 
849  template<class Parameter, class ModelType>
850  BinaryModelExpression<SMultiplyOperation, Parameter, ModelType>
851  operator*(const ParameterInterface<Parameter>& s_,
852  const ModelInterface<ModelType>& f_)
853  {
854  typedef Parameter ParameterType;
855 
856  const ParameterType& s(static_cast<const ParameterType&>(s_));
857  const ModelType& f(static_cast<const ModelType&>(f_));
858 
859  typedef BinaryModelExpression<SMultiplyOperation, ParameterType, ModelType> ExpressionType;
860 
861  return ExpressionType(s, f);
862  }
863 
865  template<class Parameter, class ModelType>
866  auto operator*(const ModelInterface<ModelType>& m_,
867  const ParameterInterface<Parameter>& s_)
868  -> decltype(asImp(s_) * asImp(m_))
869  {
870  return asImp(s_) * asImp(m_);
871  }
872 
873 #if 0
874  // We have real unary minus by now.
875  // unary minus operator
876  template<class ModelType>
877  BinaryModelExpression<SMultiplyOperation, typename ModelType::RangeFieldType, ModelType>
878  operator*(const ModelInterface<ModelType>& f_)
879  {
880  typedef typename ModelType::RangeFieldType RangeFieldType;
881  const ModelType& f(static_cast<const ModelType&>(f_));
882 
883  typedef BinaryModelExpression<SMultiplyOperation, RangeFieldType, ModelType> ExpressionType;
884 
885  return ExpressionType(-1.0, f);
886  }
887 #endif
888 
910  template<class FactorFunction, class ModelType>
911  class BinaryModelExpression<MultiplyOperation, FactorFunction, ModelType>
912  : public ModelExpression<BinaryModelExpression<MultiplyOperation, FactorFunction, ModelType> >
913  {
914  typedef SMultiplyOperation BinOpType;
915  typedef BinaryModelExpression ThisType;
916  typedef ModelExpression<ThisType> BaseType;
917  typedef ModelInterface<ThisType> InterfaceType;
918  typedef ModelTraits<ThisType> TraitsType;
919  typedef FactorFunction FactorFunctionType;
920  typedef typename FactorFunctionType::LocalFunctionType FactorLocalFunctionType;
921  typedef typename FactorFunctionType::RangeType FactorRangeType;
922  typedef typename FactorFunctionType::JacobianRangeType FactorJacobianRangeType;
923 
924  public:
926  typedef typename InterfaceType::FunctionSpaceType FunctionSpaceType;
927 
929  typedef typename InterfaceType::GridPartType GridPartType;
930 
932  typedef typename InterfaceType::EntityType EntityType;
933  typedef typename InterfaceType::IntersectionType IntersectionType;
934 
936  typedef typename InterfaceType::DomainFieldType DomainFieldType ;
938  typedef typename InterfaceType::RangeFieldType RangeFieldType ;
940  typedef typename InterfaceType::DomainType DomainType ;
942  typedef typename InterfaceType::RangeType RangeType ;
944  typedef typename InterfaceType::JacobianRangeType JacobianRangeType;
946  typedef typename InterfaceType::HessianRangeType HessianRangeType;
947 
948  enum { dimDomain = FunctionSpaceType::dimDomain, dimRange = FunctionSpaceType::dimRange };
949 
950  typedef typename InterfaceType::OperatorPartsType OperatorPartsType;
951 
952  typedef typename InterfaceType::BulkForcesFunctionType BulkForcesFunctionType;
953  typedef typename InterfaceType::DirichletBoundaryFunctionType DirichletBoundaryFunctionType;
954  typedef typename InterfaceType::DirichletWeightFunctionType DirichletWeightFunctionType;
955  typedef typename InterfaceType::NeumannBoundaryFunctionType NeumannBoundaryFunctionType;
956 
957  typedef typename InterfaceType::DirichletIndicatorType DirichletIndicatorType;
958  typedef typename InterfaceType::NeumannIndicatorType NeumannIndicatorType;
959 
960  public:
961 
962  // constructor
963  BinaryModelExpression(const FactorFunctionType& f, const ModelType& m)
964  : factor_(f), model_(m), localFactor_(factor_())
965  {}
966 
967  // copy constructor
968  BinaryModelExpression(const ThisType &other)
969  : factor_(other.factor_), model_(other.model_), localFactor_(factor_())
970  {}
971 
973  std::string name() const
974  {
975  return "(" + factor_().name() + " " + BinOpType::name() + " " + model_().name() + ")";
976  }
977 
979  OperatorPartsType operatorParts() const
980  {
981  return makeExpression(BinOpType(), factor_(), model_().operatorParts());
982  }
983 
985  BulkForcesFunctionType bulkForcesFunction(const GridPartType& gridPart) const
986  {
987  return makeExpression(BinOpType(), factor_(), model_().bulkForcesFunction(gridPart));
988  }
989 
991  DirichletBoundaryFunctionType dirichletBoundaryFunction(const GridPartType& gridPart) const
992  {
993  return makeExpression(BinOpType(), factor_(), model_().dirichletBoundaryFunction(gridPart));
994  }
995 
997  DirichletWeightFunctionType dirichletWeightFunction(const GridPartType& gridPart) const
998  {
999  return makeExpression(BinOpType(), factor_(), model_().dirichletWeightFunction(gridPart));
1000  }
1001 
1003  NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType& gridPart) const
1004  {
1005  return makeExpression(BinOpType(), factor_(), model_().neumannBoundaryFunction(gridPart));
1006  }
1007 
1009  DirichletIndicatorType dirichletIndicator() const {
1010  return model_().dirichletIndicator();
1011  }
1012 
1014  NeumannIndicatorType neumannIndicator() const {
1015  return model_().neumannIndicator();
1016  }
1017 
1018  protected:
1019  ExpressionStorage<FactorFunctionType> factor_;
1020  ExpressionStorage<ModelType> model_;
1021  mutable FactorLocalFunctionType localFactor_;
1022  };
1023 
1024  //traits
1025  template<class FactorFunction, class Model>
1026  struct ModelTraits<BinaryModelExpression<MultiplyOperation, FactorFunction, Model> >
1027  : public DefaultModelTraits<typename Model::FunctionSpaceType, typename Model::GridPartType>
1028  {
1029  protected:
1030  typedef MultiplyOperation BinOpType;
1031  typedef FactorFunction FactorFunctionType;
1032  typedef Model FactorModelType;
1033  enum {
1034  hasForcesFunctional = ModelConstituents<FactorModelType>::hasForcesFunctional
1035  };
1036 
1037  static_assert(!hasForcesFunctional,
1038  "Multiplication by functions is not allowed if the model carries a forces-functional.");
1039  public:
1040 
1041  typedef typename FactorModelType::FunctionSpaceType FunctionSpaceType;
1042  typedef typename FactorModelType::GridPartType GridPartType;
1043 
1044  typedef
1045  typename ExpressionResult<BinOpType,
1046  FactorFunctionType,
1047  typename FactorModelType::OperatorPartsType>::Type
1048  OperatorPartsType;
1049 
1050  typedef
1051  typename ExpressionResult<BinOpType,
1052  FactorFunctionType,
1053  typename FactorModelType::BulkForcesFunctionType>::Type
1054  BulkForcesFunctionType;
1055  typedef
1056  typename ExpressionResult<BinOpType,
1057  FactorFunctionType,
1058  typename FactorModelType::NeumannBoundaryFunctionType>::Type
1059  NeumannBoundaryFunctionType;
1060  typedef
1061  typename ExpressionResult<BinOpType,
1062  FactorFunctionType,
1063  typename FactorModelType::DirichletBoundaryFunctionType>::Type
1064  DirichletBoundaryFunctionType;
1065  typedef
1066  typename ExpressionResult<BinOpType,
1067  FactorFunctionType,
1068  typename FactorModelType::DirichletWeightFunctionType>::Type
1069  DirichletWeightFunctionType;
1070 
1071  typedef typename FactorModelType::DirichletIndicatorType DirichletIndicatorType;
1072  typedef typename FactorModelType::NeumannIndicatorType NeumannIndicatorType;
1073  };
1074 
1089  template<class FactorFunction, class ModelType>
1090  BinaryModelExpression<MultiplyOperation, FactorFunction, ModelType>
1091  operator*(const Fem::Function<typename FactorFunction::FunctionSpaceType::ScalarFunctionSpaceType, FactorFunction>& f_,
1092  const ModelInterface<ModelType>& m_)
1093  {
1094  const FactorFunction& f(static_cast<const FactorFunction&>(f_));
1095  const ModelType& m(static_cast<const ModelType&>(m_));
1096 
1097  typedef BinaryModelExpression<MultiplyOperation, FactorFunction, ModelType> ExpressionType;
1098 
1099  return ExpressionType(f, m);
1100  }
1101 
1103  template<class FactorFunction, class ModelType>
1104  BinaryModelExpression<MultiplyOperation, FactorFunction, ModelType>
1105  operator*(const ModelInterface<ModelType>& m_,
1106  const Fem::Function<typename FactorFunction::FunctionSpaceType::ScalarFunctionSpaceType, FactorFunction>& f_)
1107  {
1108  const FactorFunction& f(static_cast<const FactorFunction&>(f_));
1109  const ModelType& m(static_cast<const ModelType&>(m_));
1110 
1111  return f * m;
1112  }
1113 
1115  template<class Model>
1116  class UnaryModelExpression<MinusOperation, Model>
1117  operator-(const ModelInterface<Model>& m_)
1118  {
1119  const Model& m(static_cast<const Model&>(m_));
1120 
1121  typedef UnaryModelExpression<MinusOperation, Model> ExpressionType;
1122 
1123  return ExpressionType(m);
1124  }
1125 
1131  template<class Model>
1132  class UnaryModelExpression<IdentityOperation, Model>
1133  operator*(const ModelInterface<Model>& m_)
1134  {
1135  const Model& m(static_cast<const Model&>(m_));
1136 
1137  typedef UnaryModelExpression<IdentityOperation, Model> ExpressionType;
1138 
1139  return ExpressionType(m);
1140  }
1141 
1143  template<class Model>
1144  auto
1145  operator+(const ModelInterface<Model>& m_)
1146  -> decltype(*m_)
1147  {
1148  return *m_;
1149  }
1150 
1161  template<class Model, class DiscreteFunctionSpace, class Traits>
1162  auto
1163  operator-(const ModelInterface<Model>& m_,
1164  const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& phi_)
1165  -> decltype(m_
1166  + // PLUS __IS__ CORRECT HERE (see above)
1167  std::declval<ForcesFunctionalModel<typename Traits::GlobalFunctionalType> >())
1168  {
1169  typedef ForcesFunctionalModel<typename Traits::GlobalFunctionalType> FunctionalModelType;
1170 
1171  return m_ + FunctionalModelType(phi_);
1172  }
1173 
1187  template<class Model, class DiscreteFunctionSpace, class Traits>
1188  auto
1189  operator+(const ModelInterface<Model>& m_,
1190  const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& phi_)
1191  -> decltype(m_
1192  - // MINUS __IS__ CORRECT HERE (see above)
1193  std::declval<ForcesFunctionalModel<typename Traits::GlobalFunctionalType> >())
1194  {
1195  typedef ForcesFunctionalModel<typename Traits::GlobalFunctionalType> FunctionalModelType;
1196 
1197  return m_ - FunctionalModelType(phi_);
1198  }
1199 
1211  template<class Model, class GridFunction>
1212  auto
1213  operator-(const ModelInterface<Model>& m,
1214  const Fem::Function<typename Model::FunctionSpaceType, GridFunction>& f)
1215  -> decltype(m
1216  + // PLUS __IS__ CORRECT HERE (see above)
1217  std::declval<BulkForcesFunctionModel<GridFunction> >())
1218  {
1219  typedef BulkForcesFunctionModel<GridFunction> BulkForcesModelType;
1220 
1221  return m + BulkForcesModelType(f);
1222  }
1223 
1239  template<class Model, class GridFunction>
1240  auto
1241  operator+(const ModelInterface<Model>& m_,
1242  const Fem::Function<typename Model::FunctionSpaceType, GridFunction>& f)
1243  -> decltype(m_
1244  - // MINUS __IS__ CORRECT HERE (see above)
1245  std::declval<BulkForcesFunctionModel<GridFunction> >())
1246  {
1247  typedef BulkForcesFunctionModel<GridFunction> BulkForcesModelType;
1248 
1249  return m_ - BulkForcesModelType(f);
1250  }
1251 
1260  template<class Expression>
1261  Expression
1262  operator*(const ModelExpression<Expression>& m_)
1263  {
1264  return m_.expression();
1265  }
1266 
1268  template<class Model>
1269  static inline
1270  auto operator*(const typename Model::RangeFieldType& s_,
1271  const BinaryModelExpression<SMultiplyOperation, typename Model::RangeFieldType, Model>& m_)
1272  -> decltype((s_ * m_.scalar()) * m_.model())
1273  {
1274  return (s_ * m_.scalar()) * m_.model();
1275  }
1276 
1277 #if 0
1279  template<class Parameter, class Field, class Model>
1280  static inline
1281  auto operator*(const ParameterInterface<Parameter>& p_,
1282  const BinaryModelExpression<SMultiplyOperation, Field, Model>& m_)
1283  -> decltype(m_.scalar() * (asImp(p_) * m_.model()))
1284  {
1285  return m_.scalar() * (asImp(p_) * m_.model());
1286  }
1287 #else
1289  template<class Parameter, class Model>
1290  static inline
1291  auto operator*(const ParameterInterface<Parameter>& p_,
1292  const ModelInterface<BinaryModelExpression<SMultiplyOperation, typename Model::RangeFieldType, Model> >& m_)
1293  -> decltype(asImp(m_).scalar() * (asImp(p_) * asImp(m_).model()))
1294  {
1295  return asImp(m_).scalar() * (asImp(p_) * asImp(m_).model());
1296  }
1297 #endif
1298 
1300  template<class Field, class Parameter, class Model>
1301  static inline
1302  auto operator*(const BinaryParameterExpression<SMultiplyOperation, Field, Parameter>& p_,
1303  const ModelInterface<Model>& m_)
1304  -> decltype(p_.left() * (p_.right() * asImp(m_)))
1305  {
1306  return p_.left() * (p_.right() * asImp(m_));
1307  }
1308 
1310  template<class Function, class Field, class Model>
1311  static inline
1312  auto operator*(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
1313  const BinaryModelExpression<SMultiplyOperation, Field, Model>& m_)
1314  -> decltype(m_.scalar() * (asImp(f_) * m_.model()))
1315  {
1316  return m_.scalar() * (asImp(f_) * m_.model());
1317  }
1318 
1320  template<class Field, class Function, class Model>
1321  static inline
1322  auto operator*(const BinaryGridFunctionExpression<SMultiplyOperation, Field, Function>& f_,
1323  const ModelInterface<Model>& m_)
1324  -> decltype(f_.scalar() * (f_.function() * asImp(m_)))
1325  {
1326  return f_.scalar() * (f_.function() * asImp(m_));
1327  }
1328 
1336  template<class Model>
1337  auto
1338  operator-(const UnaryModelExpression<MinusOperation, Model>& m_)
1339  -> decltype(*m_.containedExpression())
1340  {
1341  return *m_.containedExpression();
1342  }
1343 
1345  template<class Model,
1346  class DiscreteFunctionSpace,
1347  class GridFunction, template<class> class QuadratureTraits>
1348  auto
1349  operator-(const ModelInterface<Model>& m_,
1350  const L2InnerProductFunctional<DiscreteFunctionSpace, GridFunction, QuadratureTraits>& phi_)
1351  -> decltype(m_ - phi_.function())
1352  {
1353  return m_ - phi_.function();
1354  }
1355 
1357  template<class Model>
1358  auto
1359  operator+(const ModelInterface<Model>& m,
1360  const ZeroModel<typename Model::FunctionSpaceType, typename Model::GridPartType>& z)
1361  -> decltype(*asImp(m))
1362  {
1363  return *asImp(m);
1364  }
1365 
1367  template<class Model>
1368  auto
1369  operator+(const ZeroModel<typename Model::FunctionSpaceType, typename Model::GridPartType>& z,
1370  const ModelInterface<Model>& m)
1371  -> decltype(*asImp(m))
1372  {
1373  return *asImp(m);
1374  }
1375 
1377  template<class FunctionSpace, class GridPart>
1378  auto
1379  operator+(const ZeroModel<FunctionSpace, GridPart>& z1,
1380  const ZeroModel<FunctionSpace, GridPart>& z2)
1381  -> decltype(*z1)
1382  {
1383  return *z1;
1384  }
1385 
1387  template<class Model>
1388  auto
1389  operator-(const ModelInterface<Model>& m,
1390  const ZeroModel<typename Model::FunctionSpaceType, typename Model::GridPartType>& z)
1391  -> decltype(*asImp(m))
1392  {
1393  return *asImp(m);
1394  }
1395 
1397  template<class Model>
1398  auto
1399  operator-(const ZeroModel<typename Model::FunctionSpaceType, typename Model::GridPartType>& z,
1400  const ModelInterface<Model>& m)
1401  -> decltype(-m)
1402  {
1403  return -m;
1404  }
1405 
1407  template<class FunctionSpace, class GridPart>
1408  auto
1409  operator-(const ZeroModel<FunctionSpace, GridPart>& z1,
1410  const ZeroModel<FunctionSpace, GridPart>& z2)
1411  -> decltype(*z1)
1412  {
1413  return *z1;
1414  }
1415 
1417  template<class FunctionSpace, class GridPart>
1418  auto
1419  operator*(const typename FunctionSpace::RangeFieldType& s_,
1420  const ZeroModel<FunctionSpace, GridPart>& z)
1421  ->decltype(*z)
1422  {
1423  return *z;
1424  }
1425 
1427  template<class FunctionSpace, class GridPart>
1428  auto
1429  operator*(const ZeroModel<FunctionSpace, GridPart>& z,
1430  const typename FunctionSpace::RangeFieldType& s)
1431  ->decltype(*z)
1432  {
1433  return *z;
1434  }
1435 
1437  template<class Parameter, class FunctionSpace, class GridPart>
1438  auto
1439  operator*(const ParameterInterface<Parameter>& s,
1440  const ZeroModel<FunctionSpace, GridPart>& z)
1441  ->decltype(*z)
1442  {
1443  return *z;
1444  }
1445 
1447  template<class Parameter, class FunctionSpace, class GridPart>
1448  auto
1449  operator*(const ZeroModel<FunctionSpace, GridPart>& z,
1450  const ParameterInterface<Parameter>& s)
1451  ->decltype(*z)
1452  {
1453  return *z;
1454  }
1455 
1457  template<class Function, class ScalarSpace, class FunctionSpace, class GridPart>
1458  auto
1459  operator*(const Fem::Function<ScalarSpace, Function>& f,
1460  const ZeroModel<FunctionSpace, GridPart>& z)
1461  ->decltype(*z)
1462  {
1463  static_assert(std::is_same<ScalarSpace, typename FunctionSpace::ScalarFunctionSpaceType>::value,
1464  "Incompatible function spaces.");
1465  return *z;
1466  }
1467 
1469  template<class Function, class ScalarSpace, class FunctionSpace, class GridPart>
1470  auto
1471  operator*(const ZeroModel<FunctionSpace, GridPart>& z,
1472  const Fem::Function<ScalarSpace, Function>& f)
1473  ->decltype(*z)
1474  {
1475  static_assert(std::is_same<ScalarSpace, typename FunctionSpace::ScalarFunctionSpaceType>::value,
1476  "Incompatible function spaces.");
1477  return *z;
1478  }
1479 
1481 
1483 
1485 
1486  } // namespace ACFem
1487 
1488 } // namespace Dune
1489 
1490 #endif // __MODELEXPRESSION_HH__
Dune::ACFem::BinaryGridFunctionExpression
BinaryGridFunctionExpression implements point-wise vector-space operations for GridFunction-types.
Definition: gridfunctionexpression.hh:423
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >
Multiplication with grid-functions.
Definition: modelexpression.hh:913
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::dirichletWeightFunction
DirichletWeightFunctionType dirichletWeightFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Dirichlet boundary values as a Fem grid-function.
Definition: modelexpression.hh:997
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::RangeType
InterfaceType::RangeType RangeType
range type (from function space)
Definition: modelexpression.hh:942
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::JacobianRangeType
InterfaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: modelexpression.hh:944
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::name
std::string name() const
Print a descriptive name for debugging and output.
Definition: modelexpression.hh:973
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::DomainFieldType
InterfaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: modelexpression.hh:936
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::neumannBoundaryFunction
NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Neumann boundary values as a Fem grid-function.
Definition: modelexpression.hh:1003
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::neumannIndicator
NeumannIndicatorType neumannIndicator() const
Generate an object to identify parts of the boundary subject to Neumann boundary conditions.
Definition: modelexpression.hh:1014
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::dirichletBoundaryFunction
DirichletBoundaryFunctionType dirichletBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Dirichlet boundary values as a Fem grid-function.
Definition: modelexpression.hh:991
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::DomainType
InterfaceType::DomainType DomainType
domain type (from function space)
Definition: modelexpression.hh:940
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::GridPartType
InterfaceType::GridPartType GridPartType
type of the grid-part we live on
Definition: modelexpression.hh:929
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::HessianRangeType
InterfaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: modelexpression.hh:946
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::bulkForcesFunction
BulkForcesFunctionType bulkForcesFunction(const GridPartType &gridPart) const
Generate an instance of a class defining the bulk-forces the model is subject to.
Definition: modelexpression.hh:985
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::dirichletIndicator
DirichletIndicatorType dirichletIndicator() const
Generate an object to identify parts of the boundary subject to Dirichlet boundary conditions.
Definition: modelexpression.hh:1009
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::RangeFieldType
InterfaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: modelexpression.hh:938
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::operatorParts
OperatorPartsType operatorParts() const
Return the integral kernels for the bilinear form.
Definition: modelexpression.hh:979
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::EntityType
InterfaceType::EntityType EntityType
type of the codim-0 Entity from the GridPartType
Definition: modelexpression.hh:932
Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >::FunctionSpaceType
InterfaceType::FunctionSpaceType FunctionSpaceType
type of discrete function space
Definition: modelexpression.hh:926
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::dirichletIndicator
DirichletIndicatorType dirichletIndicator() const
Generate an object to identify parts of the boundary subject to Dirichlet boundary conditions.
Definition: modelexpression.hh:757
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::name
std::string name() const
Print a descriptive name for debugging and output.
Definition: modelexpression.hh:707
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::neumannBoundaryFunction
NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Neumann boundary values as a Fem grid-function.
Definition: modelexpression.hh:751
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::forcesFunctional
TraitsType::template ForcesFunctionalTraits< DiscreteFunctionSpace >::FunctionalType forcesFunctional(const DiscreteFunctionSpace &space) const
Generate an instance of a class defining a functional which forms part of the force-terms for the mod...
Definition: modelexpression.hh:730
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::GridPartType
InterfaceType::GridPartType GridPartType
type of the grid-part we live on
Definition: modelexpression.hh:663
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::JacobianRangeType
InterfaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: modelexpression.hh:678
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::RangeType
InterfaceType::RangeType RangeType
range type (from function space)
Definition: modelexpression.hh:676
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::bulkForcesFunction
BulkForcesFunctionType bulkForcesFunction(const GridPartType &gridPart) const
Generate an instance of a class defining the bulk-forces the model is subject to.
Definition: modelexpression.hh:720
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::dirichletBoundaryFunction
DirichletBoundaryFunctionType dirichletBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Dirichlet boundary values as a Fem grid-function.
Definition: modelexpression.hh:736
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::neumannIndicator
NeumannIndicatorType neumannIndicator() const
Generate an object to identify parts of the boundary subject to Neumann boundary conditions.
Definition: modelexpression.hh:762
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::RangeFieldType
InterfaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: modelexpression.hh:672
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::operatorParts
OperatorPartsType operatorParts() const
Return the integral kernels for the bilinear form.
Definition: modelexpression.hh:713
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::FunctionSpaceType
InterfaceType::FunctionSpaceType FunctionSpaceType
type of discrete function space
Definition: modelexpression.hh:660
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::DomainFieldType
InterfaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: modelexpression.hh:670
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::DomainType
InterfaceType::DomainType DomainType
domain type (from function space)
Definition: modelexpression.hh:674
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::HessianRangeType
InterfaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: modelexpression.hh:680
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::dirichletWeightFunction
DirichletWeightFunctionType dirichletWeightFunction(const GridPartType &gridPart) const
Generate an instance of a class defining a "left hand side" weight on the Dirichlet boundary conditio...
Definition: modelexpression.hh:745
Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >::EntityType
InterfaceType::EntityType EntityType
type of the codim-0 Entity from the GridPartType
Definition: modelexpression.hh:666
Dune::ACFem::BinaryModelExpression
Template for binary operations.
Definition: modelexpression.hh:372
Dune::ACFem::BinaryModelExpression::FunctionSpaceType
InterfaceType::FunctionSpaceType FunctionSpaceType
type of discrete function space
Definition: modelexpression.hh:381
Dune::ACFem::BinaryModelExpression::bulkForcesFunction
BulkForcesFunctionType bulkForcesFunction(const GridPartType &gridPart) const
Generate an instance of a class defining the bulk-forces the model is subject to.
Definition: modelexpression.hh:445
Dune::ACFem::BinaryModelExpression::forcesFunctional
TraitsType::template ForcesFunctionalTraits< DiscreteFunctionSpace >::FunctionalType forcesFunctional(const DiscreteFunctionSpace &space) const
Generate an instance of a class defining a functional which forms part of the force-terms for the mod...
Definition: modelexpression.hh:455
Dune::ACFem::BinaryModelExpression::RangeFieldType
InterfaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: modelexpression.hh:393
Dune::ACFem::BinaryModelExpression::DomainFieldType
InterfaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: modelexpression.hh:391
Dune::ACFem::BinaryModelExpression::dirichletIndicator
DirichletIndicatorType dirichletIndicator() const
Generate an object to identify parts of the boundary subject to Dirichlet boundary conditions.
Definition: modelexpression.hh:490
Dune::ACFem::BinaryModelExpression::operatorParts
OperatorPartsType operatorParts() const
Return the integral kernels for the bilinear form.
Definition: modelexpression.hh:436
Dune::ACFem::BinaryModelExpression::neumannBoundaryFunction
NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Neumann boundary values as a Fem grid-function.
Definition: modelexpression.hh:482
Dune::ACFem::BinaryModelExpression::JacobianRangeType
InterfaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: modelexpression.hh:399
Dune::ACFem::BinaryModelExpression::GridPartType
InterfaceType::GridPartType GridPartType
type of the grid-part we live on
Definition: modelexpression.hh:384
Dune::ACFem::BinaryModelExpression::RangeType
InterfaceType::RangeType RangeType
range type (from function space)
Definition: modelexpression.hh:397
Dune::ACFem::BinaryModelExpression::neumannIndicator
NeumannIndicatorType neumannIndicator() const
Generate an object to identify parts of the boundary subject to Neumann boundary conditions.
Definition: modelexpression.hh:495
Dune::ACFem::BinaryModelExpression::dirichletWeightFunction
DirichletWeightFunctionType dirichletWeightFunction(const GridPartType &gridPart) const
Definition: modelexpression.hh:473
Dune::ACFem::BinaryModelExpression::DomainType
InterfaceType::DomainType DomainType
domain type (from function space)
Definition: modelexpression.hh:395
Dune::ACFem::BinaryModelExpression::EntityType
InterfaceType::EntityType EntityType
type of the codim-0 Entity from the GridPartType
Definition: modelexpression.hh:387
Dune::ACFem::BinaryModelExpression::name
std::string name() const
Print a descriptive name for debugging and output.
Definition: modelexpression.hh:430
Dune::ACFem::BinaryModelExpression::HessianRangeType
InterfaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: modelexpression.hh:401
Dune::ACFem::BinaryModelExpression::dirichletBoundaryFunction
DirichletBoundaryFunctionType dirichletBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Dirichlet boundary values as a Fem grid-function.
Definition: modelexpression.hh:464
Dune::ACFem::DiscreteLinearFunctional
Interface class for a discrete linear functional.
Definition: linearfunctional.hh:52
Dune::ACFem::ModelInterface
Interface class for second order elliptic models.
Definition: modelinterface.hh:192
Dune::ACFem::ModelInterface::DirichletBoundaryFunctionType
TraitsType::DirichletBoundaryFunctionType DirichletBoundaryFunctionType
A BoundarySupportedFunction which must be sub-ordinate to the DirichletIndicatorType.
Definition: modelinterface.hh:241
Dune::ACFem::ModelInterface::DirichletIndicatorType
TraitsType::DirichletIndicatorType DirichletIndicatorType
A BoundarySupportedFunction which must be sub-ordinate to the DirichletIndicatorType.
Definition: modelinterface.hh:243
Dune::ACFem::ModelInterface::BulkForcesFunctionType
TraitsType::BulkForcesFunctionType BulkForcesFunctionType
A function modelling "force" terms in the bulk-phase.
Definition: modelinterface.hh:226
Dune::ACFem::ModelInterface::DirichletWeightFunctionType
TraitsType::DirichletWeightFunctionType DirichletWeightFunctionType
A BoundarySupportedFunction which must be sub-ordinate to the DirichletIndicatorType.
Definition: modelinterface.hh:242
Dune::ACFem::ModelInterface::NeumannBoundaryFunctionType
TraitsType::NeumannBoundaryFunctionType NeumannBoundaryFunctionType
A function modelling "force" terms in the bulk-phase.
Definition: modelinterface.hh:227
Dune::ACFem::ModelInterface::NeumannIndicatorType
TraitsType::NeumannIndicatorType NeumannIndicatorType
A function modelling "force" terms in the bulk-phase.
Definition: modelinterface.hh:228
Dune::ACFem::ParameterInterface
Parameters are quasi-constant quantities, like the time-step size in one time-step when solving trans...
Definition: parameterinterface.hh:80
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::operatorParts
OperatorPartsType operatorParts() const
Return the integral kernels for the bilinear form.
Definition: modelexpression.hh:108
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::name
std::string name() const
Print a descriptive name for debugging and output.
Definition: modelexpression.hh:102
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::bulkForcesFunction
BulkForcesFunctionType bulkForcesFunction(const GridPartType &gridPart) const
Generate an instance of a class defining the bulk-forces the model is subject to.
Definition: modelexpression.hh:115
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::RangeFieldType
InterfaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: modelexpression.hh:68
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::EntityType
InterfaceType::EntityType EntityType
type of the codim-0 Entity from the GridPartType
Definition: modelexpression.hh:62
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::neumannIndicator
NeumannIndicatorType neumannIndicator() const
Generate an object to identify parts of the boundary subject to Neumann boundary conditions.
Definition: modelexpression.hh:147
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::FunctionSpaceType
InterfaceType::FunctionSpaceType FunctionSpaceType
type of discrete function space
Definition: modelexpression.hh:56
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::RangeType
InterfaceType::RangeType RangeType
range type (from function space)
Definition: modelexpression.hh:72
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::GridPartType
InterfaceType::GridPartType GridPartType
type of the grid-part we live on
Definition: modelexpression.hh:59
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::forcesFunctional
TraitsType::template ForcesFunctionalTraits< DiscreteFunctionSpace >::FunctionalType forcesFunctional(const DiscreteFunctionSpace &space) const
Generate an instance of a class defining a functional which forms part of the force-terms for the mod...
Definition: modelexpression.hh:123
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::HessianRangeType
InterfaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: modelexpression.hh:76
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::DomainFieldType
InterfaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: modelexpression.hh:66
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::JacobianRangeType
InterfaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: modelexpression.hh:74
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::dirichletIndicator
DirichletIndicatorType dirichletIndicator() const
Generate an object to identify parts of the boundary subject to Dirichlet boundary conditions.
Definition: modelexpression.hh:142
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::neumannBoundaryFunction
NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Neumann boundary values as a Fem grid-function.
Definition: modelexpression.hh:136
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::DomainType
InterfaceType::DomainType DomainType
domain type (from function space)
Definition: modelexpression.hh:70
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::ContainedExpressionType
ModelType ContainedExpressionType
type of the contained expression
Definition: modelexpression.hh:53
Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >::dirichletBoundaryFunction
DirichletBoundaryFunctionType dirichletBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Dirichlet boundary values as a Fem grid-function.
Definition: modelexpression.hh:130
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >
Unary minus.
Definition: modelexpression.hh:193
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::dirichletWeightFunction
DirichletWeightFunctionType dirichletWeightFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Dirichlet boundary values as a Fem grid-function.
Definition: modelexpression.hh:288
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::dirichletBoundaryFunction
DirichletBoundaryFunctionType dirichletBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Dirichlet boundary values as a Fem grid-function.
Definition: modelexpression.hh:281
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::EntityType
InterfaceType::EntityType EntityType
type of the codim-0 Entity from the GridPartType
Definition: modelexpression.hh:211
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::RangeType
InterfaceType::RangeType RangeType
range type (from function space)
Definition: modelexpression.hh:221
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::DomainFieldType
InterfaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: modelexpression.hh:215
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::FunctionSpaceType
InterfaceType::FunctionSpaceType FunctionSpaceType
type of discrete function space
Definition: modelexpression.hh:205
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::neumannIndicator
NeumannIndicatorType neumannIndicator() const
Generate an object to identify parts of the boundary subject to Neumann boundary conditions.
Definition: modelexpression.hh:305
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::HessianRangeType
InterfaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: modelexpression.hh:225
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::ContainedExpressionType
ModelType ContainedExpressionType
type of the contained expression
Definition: modelexpression.hh:202
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::bulkForcesFunction
BulkForcesFunctionType bulkForcesFunction(const GridPartType &gridPart) const
Generate an instance of a class defining the bulk-forces the model is subject to.
Definition: modelexpression.hh:266
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::DomainType
InterfaceType::DomainType DomainType
domain type (from function space)
Definition: modelexpression.hh:219
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::RangeFieldType
InterfaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: modelexpression.hh:217
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::dirichletIndicator
DirichletIndicatorType dirichletIndicator() const
Generate an object to identify parts of the boundary subject to Dirichlet boundary conditions.
Definition: modelexpression.hh:300
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::name
std::string name() const
Print a descriptive name for debugging and output.
Definition: modelexpression.hh:253
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::forcesFunctional
TraitsType::template ForcesFunctionalTraits< DiscreteFunctionSpace >::FunctionalType forcesFunctional(const DiscreteFunctionSpace &space) const
Generate an instance of a class defining a functional which forms part of the force-terms for the mod...
Definition: modelexpression.hh:274
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::GridPartType
InterfaceType::GridPartType GridPartType
type of the grid-part we live on
Definition: modelexpression.hh:208
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::JacobianRangeType
InterfaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: modelexpression.hh:223
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::operatorParts
OperatorPartsType operatorParts() const
Return the integral kernels for the bilinear form.
Definition: modelexpression.hh:259
Dune::ACFem::UnaryModelExpression< MinusOperation, Model >::neumannBoundaryFunction
NeumannBoundaryFunctionType neumannBoundaryFunction(const GridPartType &gridPart) const
Generate an instance of a class defining Neumann boundary values as a Fem grid-function.
Definition: modelexpression.hh:294
Dune::ACFem::UnaryModelExpression
Template for unary operations.
Definition: modelexpression.hh:38
Dune::ACFem::ZeroModel
Define a simple zero model to optimize expression templates.
Definition: zeromodel.hh:28
Dune::ACFem::asImp
const Implementation & asImp(const Fem::BartonNackmanInterface< Interface, Implementation > &arg)
Up-cast to the implementation for any Fem::BartonNackmanInterface.
Definition: expressionoperations.hh:71
Dune::ACFem::operator-
auto operator-(const ZeroModel< FunctionSpace, GridPart > &z1, const ZeroModel< FunctionSpace, GridPart > &z2) -> decltype(*z1)
Zero - Zero = Zero.
Definition: modelexpression.hh:1409
Dune::ACFem::operator+
auto operator+(const ZeroModel< FunctionSpace, GridPart > &z1, const ZeroModel< FunctionSpace, GridPart > &z2) -> decltype(*z1)
Zero + Zero = Zero.
Definition: modelexpression.hh:1379
Dune::ACFem::parameterValue
ParameterValue< Value >::ResultType parameterValue(const Value &value)
Return the unaltered argument for non-parameters and otherwise the parameter value.
Definition: parameterinterface.hh:263
Dune::ACFem::operator*
BinaryParameterExpression< MultiplyOperation, Left, Right > operator*(const ParameterInterface< Left > &left, const ParameterInterface< Right > &right)
Scalar product between parameters.
Definition: parameterexpression.hh:321
Dune::ACFem::BulkForcesFunctionModel
Wrap an existing GridFunction into a model which only conatains this ModelConstituent.
Definition: bulkforcesmodel.hh:42
Dune::ACFem::DefaultModelTraits
A structure defining some trivial default values for the template structure ModelTraits<ModelType>,...
Definition: modelinterface.hh:57
Dune::ACFem::DefaultModelTraits< LeftModel::FunctionSpaceType, LeftModel::GridPartType >::NeumannIndicatorType
EmptyBoundaryIndicatorType NeumannIndicatorType
Something satisfying the BoundaryIndicatorInterface.
Definition: modelinterface.hh:138
Dune::ACFem::DefaultModelTraits< LeftModel::FunctionSpaceType, LeftModel::GridPartType >::DirichletIndicatorType
EmptyBoundaryIndicatorType DirichletIndicatorType
Something satisfying the BoundaryIndicatorInterface.
Definition: modelinterface.hh:80
Dune::ACFem::ExpressionResult
Automatically deduce the type by applying the respective operation.
Definition: expressionoperations.hh:476
Dune::ACFem::ForcesFunctionalModel
Wrap an existing DiscreteLinearFunctional into a model which only conatains this ModelConstituent.
Definition: forcesfunctionalmodel.hh:42
Dune::ACFem::IdentityOperation
Identity, i.e. just wrap the object.
Definition: expressionoperations.hh:284
Dune::ACFem::MinusOperation
Subtraction of two objects and unary minus.
Definition: expressionoperations.hh:239
Dune::ACFem::ModelTraits
Traits-template which has to be specialized for each individual model.
Definition: modelinterface.hh:48
Dune::ACFem::MultiplyOperation
Multiplication of two objects.
Definition: expressionoperations.hh:248
Dune::ACFem::PlusOperation
Addition of two objects.
Definition: expressionoperations.hh:230
Dune::ACFem::SMultiplyOperation
Multiplication by scalars from the left.
Definition: expressionoperations.hh:257
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.80.0 (May 16, 22:29, 2024)