DUNE-ACFEM (2.5.1)

gridfunctionexpression.hh
1 #ifndef __DUNE_ACFEM_GRIDFUNCTIONEXPRESSION_HH__
2 #define __DUNE_ACFEM_GRIDFUNCTIONEXPRESSION_HH__
3 
4 #include <dune/fem/version.hh>
5 #include <dune/fem/function/common/discretefunction.hh>
6 
7 #include "../functions/gridfunctionexpressionbase.hh"
8 #include "../functions/parameterfunction.hh"
9 #include "../functions/functionoperations.hh"
10 #include "../functions/functionexpression.hh"
11 #include "../functions/localfunctionwrapper.hh"
12 #include "../functions/gridfunctionwrapper.hh"
13 #include "../functions/gridfunctionwrapperexpression.hh"
14 #include "../functions/boundarysupportedfunction.hh"
15 #include "../expressions/parameterinterface.hh"
16 #include "../expressions/parameterexpression.hh"
17 
18 namespace Dune
19 {
20 
21  namespace ACFem
22  {
23 
58  template<class GridFunction>
59  static inline
60  const Fem::Function<typename GridFunction::FunctionSpaceType, GridFunction>&
61  asExprFunction(const GridFunction& arg)
62  {
63  typedef Fem::Function<typename GridFunction::FunctionSpaceType, GridFunction> Interface;
64  return static_cast<const Interface&>(arg);
65  };
66 
71  template<class UnOp, class Function>
72  static inline
73  const UnaryGridFunctionExpression<UnOp, Function>&
74  asExprFunction(const UnaryGridFunctionExpression<UnOp, Function>& arg)
75  {
76  return arg;
77  };
78 
83  template<class BinOp, class LeftFunction, class RightFunction>
84  static inline
85  const BinaryGridFunctionExpression<BinOp, LeftFunction, RightFunction>&
86  asExprFunction(const BinaryGridFunctionExpression<BinOp, LeftFunction, RightFunction>& arg)
87  {
88  return arg;
89  };
90 
110  template<class F1, class F2>
111  static inline
112  ZeroGridFunction<
113  typename FunctionMultiplicationResultTraits<typename F1::FunctionSpaceType,
114  typename F2::FunctionSpaceType>::FunctionSpaceType,
115  typename F1::GridPartType>
116  zeroProduct(const F1& f1, const F2& f2)
117  {
118  typedef
119  FunctionMultiplicationResultTraits<typename F1::FunctionSpaceType,
120  typename F2::FunctionSpaceType>
121  TraitsType;
122  typedef typename TraitsType::FunctionSpaceType FunctionSpaceType;
123  typedef typename F1::GridPartType GridPartType;
124 
125  return
126  ZeroGridFunction<FunctionSpaceType, GridPartType>(f1.gridPart());
127  }
128 
130  template<class GridFunction>
131  typename GridFunction::LocalFunctionType localFunction(const GridFunction& f)
132  {
133  return typename GridFunction::LocalFunctionType(f);
134  }
135 
136  template<class DiscreteSpace, class Dof = typename DiscreteSpace::RangeFieldType>
137  Fem::TemporaryLocalFunction<DiscreteSpace, Dof>
138  temporaryLocalFunction(const DiscreteSpace& space, const Dof& dummy = Dof())
139  {
140  return Fem::TemporaryLocalFunction<DiscreteSpace, Dof>(space);
141  }
142 
155  template<class FunctionSpace, class GridPart>
156  FractionGridFunction<typename FunctionSpace::FunctionSpaceType::ScalarFunctionSpaceType, GridPart, 1L, 1UL>
157  oneFunction(const FunctionSpace& space, const GridPart& gridPart)
158  {
159  typedef
160  FractionGridFunction<typename FunctionSpace::FunctionSpaceType::ScalarFunctionSpaceType, GridPart, 1L, 1UL>
161  ResultType;
162 
163  return ResultType(gridPart);
164  }
165 
174  template<class F>
175  auto oneFunction(const F& f)
176  -> decltype(oneFunction(f.space(), f.gridPart()))
177  {
178  return oneFunction(f.space(), f.gridPart());
179  }
180 
182  template<class F>
183  auto zeroFunction(const Fem::Function<typename F::FunctionSpaceType, F>& f_)
184  -> ZeroGridFunction<typename F::FunctionSpaceType, typename F::GridPartType>
185  {
186  return ZeroGridFunction<typename F::FunctionSpaceType, typename F::GridPartType>(asImp(f_).gridPart());
187  }
188 
190  template<class F>
191  auto constantFunction(const Fem::Function<typename F::FunctionSpaceType, F>& f_, const typename F::FunctionSpaceType::RangeType& c)
192  -> ConstantGridFunction<typename F::FunctionSpaceType, typename F::GridPartType>
193  {
194  return ConstantGridFunction<typename F::FunctionSpaceType, typename F::GridPartType>(c, asImp(f_).gridPart());
195  }
196 
197  /******************************************************************************
198  *
199  * Traits and helpers
200  *
201  */
202 
203  template<class BinOp, class LeftFunctionType, class RightFunctionType>
204  struct BinaryGridFunctionExpressionBaseTraits;
205 
206  template<class LeftFunction, class RightFunction>
207  struct BinaryGridFunctionExpressionBaseTraits<PlusOperation, LeftFunction, RightFunction>
208  : public BinaryFunctionExpressionTraits<PlusOperation, LeftFunction, RightFunction>
209  {
210  typedef LeftFunction LeftFunctionType;
211  typedef RightFunction RightFunctionType;
212  typedef typename LeftFunctionType::DiscreteFunctionSpaceType LeftDiscreteFunctionSpaceType;
213  typedef typename RightFunctionType::DiscreteFunctionSpaceType RightDiscreteFunctionSpaceType;
214 
215  static_assert(std::is_same<typename LeftFunctionType::FunctionSpaceType,
216  typename RightFunctionType::FunctionSpaceType>::value,
217  "Cannot add functions over differing function spaces");
218  static_assert(std::is_same<typename LeftFunctionType::GridPartType,
219  typename RightFunctionType::GridPartType>::value,
220  "Cannot add functions over different grid-parts");
221  typedef
222  Fem::DiscreteFunctionSpaceAdapter<typename LeftFunctionType::FunctionSpaceType,
223  typename LeftFunctionType::GridPartType>
224  DiscreteFunctionSpaceType;
225 
226  // p.w. constant tag
227  typedef
228  std::integral_constant<bool, std::is_base_of<IsPieceWiseConstant, LeftFunction>::value>
229  LeftPieceWiseConstantType;
230  typedef
231  std::integral_constant<bool, std::is_base_of<IsPieceWiseConstant, RightFunction>::value>
232  RightPieceWiseConstantType;
233  typedef
234  std::integral_constant<bool, LeftPieceWiseConstantType::value && RightPieceWiseConstantType::value>
235  PieceWiseConstantType;
236 
237  typedef
238  typename std::conditional<PieceWiseConstantType::value,
239  IsPieceWiseConstant, IsNotPieceWiseConstant>::type
240  PieceWiseConstantTagType;
241 
242  // max. polynomial order
243  constexpr static unsigned combinedOrder(unsigned order1, unsigned order2) {
244  return PieceWiseConstantType() ? 0 : (order1 > order2 ? order1 : order2);
245  }
246 
247  // Note that std::max is not const ... grin.
248  static const unsigned int order = combinedOrder(LeftDiscreteFunctionSpaceType::polynomialOrder,
249  RightDiscreteFunctionSpaceType::polynomialOrder);
250 
251  // BoundarySupportedFunction support
252  typedef BoundaryFunctionTraits<LeftFunction> LeftBoundaryTraits;
253  typedef BoundaryFunctionTraits<RightFunction> RightBoundaryTraits;
254  enum {
255  hasBoundarySupport = LeftBoundaryTraits::hasBoundarySupport || RightBoundaryTraits::hasBoundarySupport
256  };
257  typedef
258  typename std::conditional<hasBoundarySupport,
259  HasBoundarySupport, HasNoBoundarySupport>::type
260  BoundarySupportTagType;
261 
262  typedef typename LeftBoundaryTraits::IndicatorType LeftIndicatorType;
263  typedef typename RightBoundaryTraits::IndicatorType RightIndicatorType;
264  typedef
265  typename std::remove_reference<
266  typename std::remove_const<decltype(std::declval<LeftIndicatorType>()
267  ||
268  std::declval<RightIndicatorType>())>::type
269  >::type
270  IndicatorType;
271 
272  enum {
273  emptySupport = ExpressionTraits<IndicatorType>::isZero,
274  globalSupport = std::is_same<IndicatorType, EntireBoundaryIndicatorType>::value
275  };
276 
277  static const bool boundarySupported(bool left, bool right)
278  {
279  return globalSupport || (!emptySupport && (left || right));
280  }
281 
282  static IndicatorType indicator(const LeftFunction& left, const RightFunction& right)
283  {
284  return LeftBoundaryTraits::indicator(left) || RightBoundaryTraits::indicator(right);
285  }
286  };
287 
288  template<class LeftFunction, class RightFunction>
289  struct BinaryGridFunctionExpressionBaseTraits<MinusOperation, LeftFunction, RightFunction>
290  : public BinaryGridFunctionExpressionBaseTraits<PlusOperation, LeftFunction, RightFunction>
291  {};
292 
293  template<class LeftFunction, class RightFunction>
294  struct BinaryGridFunctionExpressionBaseTraits<MultiplyOperation, LeftFunction, RightFunction>
295  {
296  typedef LeftFunction LeftFunctionType;
297  typedef RightFunction RightFunctionType;
298  typedef typename LeftFunctionType::FunctionSpaceType LeftFunctionSpaceType;
299  typedef typename RightFunctionType::FunctionSpaceType RightFunctionSpaceType;
300 
301  typedef typename
302  FunctionMultiplicationResultTraits<LeftFunctionSpaceType, RightFunctionSpaceType>::FunctionSpaceType
303  FunctionSpaceType;
304 
305  typedef typename LeftFunctionType::DiscreteFunctionSpaceType LeftDiscreteFunctionSpaceType;
306  typedef typename RightFunctionType::DiscreteFunctionSpaceType RightDiscreteFunctionSpaceType;
307 
308  typedef typename LeftDiscreteFunctionSpaceType::GridPartType GridPartType;
309 
310  typedef Fem::DiscreteFunctionSpaceAdapter<FunctionSpaceType, GridPartType> DiscreteFunctionSpaceType;
311 
312  // p.w. constant tag
313  typedef
314  std::integral_constant<bool, std::is_base_of<IsPieceWiseConstant, LeftFunction>::value>
315  LeftPieceWiseConstantType;
316  typedef
317  std::integral_constant<bool, std::is_base_of<IsPieceWiseConstant, RightFunction>::value>
318  RightPieceWiseConstantType;
319  typedef
320  std::integral_constant<bool, LeftPieceWiseConstantType::value && RightPieceWiseConstantType::value>
321  PieceWiseConstantType;
322 
323  typedef
324  typename std::conditional<PieceWiseConstantType::value,
325  IsPieceWiseConstant, IsNotPieceWiseConstant>::type
326  PieceWiseConstantTagType;
327 
328  // Compute the new polynomial order "guess"
329  constexpr static unsigned combinedOrder(unsigned order1, unsigned order2)
330  {
331  return PieceWiseConstantType() ? 0 : order1 + order2;
332  }
333 
334  // polynomialOrder is only an upper bound, and in the special case
335  // of DiscreteFunctionSpaceAdapter tied to 111 (why not 42?)
336  static const unsigned int order = combinedOrder(LeftDiscreteFunctionSpaceType::polynomialOrder,
337  RightDiscreteFunctionSpaceType::polynomialOrder);
338 
339  // BoundarySupportedFunction support
340  typedef BoundaryFunctionTraits<LeftFunction> LeftBoundaryTraits;
341  typedef BoundaryFunctionTraits<RightFunction> RightBoundaryTraits;
342  enum {
343  hasBoundarySupport = LeftBoundaryTraits::hasBoundarySupport || RightBoundaryTraits::hasBoundarySupport
344  };
345  typedef
346  typename std::conditional<hasBoundarySupport,
347  HasBoundarySupport, HasNoBoundarySupport>::type
348  BoundarySupportTagType;
349  typedef typename LeftBoundaryTraits::IndicatorType LeftIndicatorType;
350  typedef typename RightBoundaryTraits::IndicatorType RightIndicatorType;
351  typedef
352  typename std::remove_reference<
353  typename std::remove_const<decltype(std::declval<LeftIndicatorType>()
354  &&
355  std::declval<RightIndicatorType>())>::type
356  >::type
357  IndicatorType;
358  enum {
359  emptySupport = ExpressionTraits<IndicatorType>::isZero,
360  globalSupport = std::is_same<IndicatorType, EntireBoundaryIndicatorType>::value
361  };
362 
363  static const bool boundarySupported(bool left, bool right)
364  {
365  return globalSupport || (!emptySupport && (left && right));
366  }
367 
368  static IndicatorType indicator(const LeftFunction& left, const RightFunction& right)
369  {
370  return LeftBoundaryTraits::indicator(left) && RightBoundaryTraits::indicator(right);
371  }
372  };
373 
375  template<class BinOp, class LeftFunction, class RightFunction>
376  struct BinaryGridFunctionExpressionTraits
377  : public BinaryGridFunctionExpressionBaseTraits<BinOp, LeftFunction, RightFunction>
378  {
379  typedef
380  BinaryGridFunctionExpressionBaseTraits<BinOp, LeftFunction, RightFunction>
381  BaseType;
382 
383  typedef LeftFunction LeftFunctionType;
384  typedef RightFunction RightFunctionType;
385 
386  typedef typename BaseType::FunctionSpaceType FunctionSpaceType;
387  typedef typename BaseType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
388 
389  typedef typename FunctionSpaceType::RangeFieldType RangeFieldType;
390  typedef typename FunctionSpaceType::DomainFieldType DomainFieldType;
391  typedef typename FunctionSpaceType::RangeType RangeType;
392  typedef typename FunctionSpaceType::DomainType DomainType;
393  typedef typename FunctionSpaceType::JacobianRangeType JacobianRangeType;
394  typedef typename FunctionSpaceType::HessianRangeType HessianRangeType;
395 
396  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
397  typedef typename GridPartType::GridType GridType;
398  typedef typename GridPartType::template Codim<0>::EntityType EntityType;
400  typedef typename GridPartType::template Codim<0>::IteratorType IteratorType;
402  typedef typename GridPartType::IndexSetType IndexSetType;
403 
404  typedef BinaryGridFunctionExpression<BinOp, LeftFunctionType, RightFunctionType> DiscreteFunctionType;
405 
406  using BaseType::order;
407  using BaseType::combinedOrder;
408  };
409 
410  // BinaryGridFunctionExpression
411  // -------------------
412 
416  template<class BinOp, class LeftFunction, class RightFunction>
417  class BinaryGridFunctionExpression
418  : public GridFunctionExpression<typename
419  BinaryGridFunctionExpressionTraits<BinOp, LeftFunction, RightFunction>::FunctionSpaceType,
420  BinaryGridFunctionExpression<BinOp, LeftFunction, RightFunction> >,
421  public BinaryGridFunctionExpressionTraits<BinOp, LeftFunction, RightFunction>::BoundarySupportTagType,
422  public BinaryGridFunctionExpressionTraits<BinOp, LeftFunction, RightFunction>::PieceWiseConstantTagType
423  {
424  typedef LeftFunction LeftFunctionType;
425  typedef RightFunction RightFunctionType;
426  public:
428  typedef BinaryGridFunctionExpressionTraits<BinOp, LeftFunctionType, RightFunctionType> TraitsType;
429  private:
430  typedef BinaryGridFunctionExpression<BinOp, LeftFunctionType, RightFunctionType> ThisType;
431  typedef Fem::Function<typename TraitsType::FunctionSpaceType, ThisType> BaseType;
432  typedef BinOp OperationTagType;
433  typedef BinaryFunctionExpressionOperation<BinOp> OperationType;
434 
435  typedef typename TraitsType::LeftPieceWiseConstantType LeftPieceWiseConstantType;
436  typedef typename TraitsType::RightPieceWiseConstantType RightPieceWiseConstantType;
437  typedef typename TraitsType::PieceWiseConstantType PieceWiseConstantType;
438 
439  public:
441  typedef ThisType DiscreteFunctionType;
442 
444  typedef typename TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
445 
446  // type of discrete function space
447  typedef typename TraitsType::FunctionSpaceType FunctionSpaceType;
448 
450  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
451 
453  typedef typename DiscreteFunctionSpaceType::GridType GridType;
454 
455  static const int dimRange = DiscreteFunctionSpaceType::dimRange;
456  static const int dimDomain = GridPartType::GridType::dimensionworld;
457  static const int dimLocal = GridPartType::GridType::dimension;
458 
460  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
462  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
464  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
466  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
468  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
470  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
471 
473  typedef typename TraitsType::EntityType EntityType;
474 
476  typedef typename GridPartType::IntersectionType IntersectionType;
477 
478  private:
479  class LocalFunction;
480  //class LocalFunctionStorage;
481  typedef GridFunctionExpression<FunctionSpaceType, ThisType> ExpressionBaseType;
482  using ExpressionBaseType::expressionName_;
483 
484  public:
486  typedef LocalFunction LocalFunctionType;
487 
489  BinaryGridFunctionExpression(const LeftFunctionType &f,
490  const RightFunctionType &g)
491  : space_(f.space().gridPart(), TraitsType::combinedOrder(f.space().order(), g.space().order())),
492  leftFunction_(f),
493  rightFunction_(g)
494  {}
495 
496  // We DO allow copying
497  BinaryGridFunctionExpression(const ThisType &other)
498  : space_(other.space_),
499  leftFunction_(other.leftFunction_),
500  rightFunction_(other.rightFunction_)
501  {}
502 
504  void evaluate(const DomainType &global, RangeType &result) const
505  {
506  OperationType::evaluate(leftFunction_(), rightFunction_(), global, result);
507  }
508 
510  void jacobian(const DomainType &global, JacobianRangeType &result) const
511  {
512  if (PieceWiseConstantType()) {
513  result = 0.;
514  return;
515  }
516  OperationType::jacobian(leftFunction_(), rightFunction_(), global, result,
517  LeftPieceWiseConstantType(), RightPieceWiseConstantType());
518  }
519 
521  void hessian(const DomainType &global, HessianRangeType &result) const
522  {
523  if (PieceWiseConstantType()) {
524  result = 0.;
525  return;
526  }
527  OperationType::hessian(leftFunction_(), rightFunction_(), global, result);
528  }
529 
531  const LocalFunctionType localFunction(const EntityType &entity) const
532  {
533  return LocalFunctionType(entity, *this);
534  }
535 
537  LocalFunctionType localFunction(const EntityType &entity)
538  {
539  return LocalFunctionType(entity, *this);
540  }
541 
543  const std::string &expressionName() const
544  {
545  expressionName_ = operationName(OperationTagType(), leftFunction().name(), rightFunction().name());
546  return expressionName_;
547  }
548 
550  const DiscreteFunctionSpaceType &space() const
551  {
552  return space_;
553  }
554 
555  const GridPartType &gridPart() const
556  {
557  return space().gridPart();
558  }
559 
565  typedef typename TraitsType::IndicatorType IndicatorType;
566 
567  enum {
569  emptySupport = ExpressionTraits<IndicatorType>::isZero,
571  globalSupport = std::is_same<IndicatorType, EntireBoundaryIndicatorType>::value
572  };
573 
575  const LocalFunctionType localFunction(const EntityType& entity,
576  const IntersectionType &intersection) const
577  {
578  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
579  return LocalFunctionType(entity, intersection, *this);
580  }
581 
583  LocalFunctionType localFunction(const EntityType& entity, const IntersectionType &intersection)
584  {
585  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
586  return LocalFunctionType(entity, intersection, *this);
587  }
588 
589  IndicatorType indicator() const
590  {
591  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
592  return TraitsType::indicator(leftFunction_(), rightFunction_());
593  }
594 
596 
597  public:
598  const LeftFunctionType& leftFunction() const { return leftFunction_(); }
599  const RightFunctionType& rightFunction() const { return rightFunction_(); }
600  protected:
601  DiscreteFunctionSpaceType space_;
602  ExpressionStorage<LeftFunctionType> leftFunction_;
603  ExpressionStorage<RightFunctionType> rightFunction_;
604  mutable std::string name_;
605  };
606 
607  // BinaryGridFunctionExpression::LocalFunction
608  // ----------------------------------
609 
611  template<class BinOp, class LeftFunctionType, class RightFunctionType>
612  class BinaryGridFunctionExpression<BinOp, LeftFunctionType, RightFunctionType>::LocalFunction
613  {
614  typedef LocalFunction ThisType;
615  typedef BinOp OperationTagType;
616  typedef BinaryFunctionExpressionOperation<BinOp> OperationType;
617  public:
618  typedef BinaryGridFunctionExpression<BinOp, LeftFunctionType, RightFunctionType> DiscreteFunctionType;
619  typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
620  private:
621  typedef typename LeftFunctionType::LocalFunctionType LeftLocalFunctionType;
622  typedef typename RightFunctionType::LocalFunctionType RightLocalFunctionType;
623  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
624  typedef typename EntityType::Geometry GeometryType;
625 
626  public:
627 
628  static const int dimRange = DiscreteFunctionSpaceType::dimRange;
629  static const int dimDomain = GridPartType::GridType::dimensionworld;
630  static const int dimLocal = GridPartType::GridType::dimension;
631 
633  typedef typename DiscreteFunctionSpaceType::FunctionSpaceType FunctionSpaceType;
634 
636  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
638  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
640  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
642  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
644  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
646  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
647 
649  LocalFunction(const EntityType &entity, const DiscreteFunctionType &df)
650  : intersection_(0),
651  supported_(true),
652  df_(df),
653  leftLocalFunction_(df.leftFunction().localFunction(entity)),
654  rightLocalFunction_(df.rightFunction().localFunction(entity)),
655  entity_(&entity),
656  order_(df.space().order())
657  {}
658 
659  LocalFunction(const DiscreteFunctionType &df)
660  : intersection_(0),
661  supported_(true),
662  df_(df),
663  leftLocalFunction_(df.leftFunction()),
664  rightLocalFunction_(df.rightFunction()),
665  entity_(0),
666  order_(df.space().order())
667  {}
668 
670  template<class PointType>
671  void evaluate(const PointType &x, RangeType &ret) const
672  {
673  if (!supported()) {
674  ret = 0.;
675  return;
676  }
677  OperationType::evaluate(leftLocalFunction_, rightLocalFunction_, x, ret);
678  }
679 
681  template<class PointType>
682  void jacobian(const PointType &x, JacobianRangeType &ret) const
683  {
684  if (DiscreteFunctionType::PieceWiseConstantType() || !supported()) {
685  ret = 0.;
686  return;
687  }
688  OperationType::jacobian(leftLocalFunction_, rightLocalFunction_, x, ret);
689  }
690 
692  template<class PointType>
693  void hessian(const PointType &x, HessianRangeType &ret) const
694  {
695  if (DiscreteFunctionType::PieceWiseConstantType() || !supported()) {
696  ret = 0.;
697  return;
698  }
699  OperationType::hessian(leftLocalFunction_, rightLocalFunction_, x, ret);
700  }
701 
703  template<class QuadratureType, class VectorType>
704  void evaluateQuadrature(const QuadratureType& quadrature, VectorType& values) const
705  {
706  assert(values.size() == quadrature.nop());
707  DiscreteFunctionType::evaluateQuadratureImp(*this, quadrature, values, values[0]);
708  }
709 
711  int order() const { return order_; }
712 
714  void init(const EntityType &entity)
715  {
716  leftLocalFunction_.init(entity);
717  rightLocalFunction_.init(entity);
718  entity_ = &entity;
719  supported_ = true;
720  }
721 
723  const EntityType &entity() const
724  {
725  assert(entity_);
726  return *entity_;
727  }
728 
733  enum {
735  emptySupport = DiscreteFunctionType::emptySupport,
737  globalSupport = DiscreteFunctionType::globalSupport
738  };
739 
741  LocalFunction(const EntityType& entity,
742  const IntersectionType &intersection,
743  const DiscreteFunctionType &df)
744  : df_(df),
745  leftLocalFunction_(LeftLocalFunctionType(df.leftFunction())),
746  rightLocalFunction_(RightLocalFunctionType(df.rightFunction())),
747  order_(df.space().order())
748  {
749  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
750  init(entity, intersection);
751  }
752 
754  void init(const EntityType& entity, const IntersectionType& intersection)
755  {
756  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
757 
758  BoundaryFunctionTraits<LeftFunctionType>::init(leftLocalFunction_, entity, intersection);
759  BoundaryFunctionTraits<RightFunctionType>::init(rightLocalFunction_, entity, intersection);
760 
761  supported_ = TraitsType::boundarySupported(BoundaryFunctionTraits<LeftFunctionType>::supported(leftLocalFunction_),
762  BoundaryFunctionTraits<RightFunctionType>::supported(rightLocalFunction_));
763 
764  entity_ = &entity;
765  intersection_ = &intersection;
766  }
767 
769  const IntersectionType &intersection() const
770  {
771  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
772  assert(intersection_);
773  return *intersection_;
774  }
775 
776  bool supported() const
777  {
778  return globalSupport || (!emptySupport && supported_);
779  }
780 
781  private:
782  const IntersectionType *intersection_;
783  bool supported_;
784 
786 
787  private:
788  const DiscreteFunctionType& df_;
789  LeftLocalFunctionType leftLocalFunction_;
790  RightLocalFunctionType rightLocalFunction_;
791  const EntityType *entity_;
792  int order_;
793  };
794 
796  //
797  // Specialization for left- and right multiplication. Seems better
798  // than to construct first scalar function with constant values ...
799 
801  template<class Factor, class Function>
802  struct BinaryGridFunctionExpressionTraits<SMultiplyOperation, Factor, Function>
803  : public BinaryFunctionExpressionTraits<SMultiplyOperation, Factor, Function>
804  {
805  typedef Factor FactorType;
806  typedef Function FunctionType;
807 
808  typedef typename FunctionType::FunctionSpaceType FunctionSpaceType;
809  typedef typename FunctionType::DiscreteFunctionSpaceType FunctionDiscreteFunctionSpaceType;
810 
811  typedef typename FunctionDiscreteFunctionSpaceType::GridPartType GridPartType;
812 
813  // ALWAYS use a DiscreteFunctionSpaceAdapter
814  typedef Fem::DiscreteFunctionSpaceAdapter<FunctionSpaceType, GridPartType> DiscreteFunctionSpaceType;
815 
816  typedef typename GridPartType::GridType GridType;
817  typedef typename GridPartType::template Codim<0>::EntityType EntityType;
819  typedef typename GridPartType::template Codim<0>::IteratorType IteratorType;
821  typedef typename GridPartType::IndexSetType IndexSetType;
822 
823  typedef BinaryGridFunctionExpression<SMultiplyOperation, FactorType, FunctionType> DiscreteFunctionType;
824 
825  // p.w. constant tag
826  enum {
827  isPieceWiseConstant = std::is_base_of<IsPieceWiseConstant, Function>::value
828  };
829 
830  // p.w. constant tag
831  typedef
832  typename std::conditional<isPieceWiseConstant,
833  IsPieceWiseConstant, IsNotPieceWiseConstant>::type
834  PieceWiseConstantTagType;
835 
836  static const unsigned int order =
837  isPieceWiseConstant ? 0 : DiscreteFunctionSpaceType::polynomialOrder;
838 
839  // Boundary function stuff
840  typedef BoundaryFunctionTraits<Function> BoundaryTraits;
841  enum {
842  hasBoundarySupport = BoundaryTraits::hasBoundarySupport
843  };
844  typedef
845  typename std::conditional<hasBoundarySupport,
846  HasBoundarySupport, HasNoBoundarySupport>::type
847  BoundarySupportTagType;
848 
849  typedef
850  typename BoundaryFunctionTraits<FunctionType>::IndicatorType
851  IndicatorType;
852 
853  enum {
854  emptySupport = ExpressionTraits<IndicatorType>::isZero,
855  globalSupport = std::is_same<IndicatorType, EntireBoundaryIndicatorType>::value
856  };
857  };
858 
859  // BinaryGridFunctionExpression
860  // -------------------
861 
863  template<class Factor, class Function>
864  class BinaryGridFunctionExpression<SMultiplyOperation, Factor, Function>
865  : public GridFunctionExpression<typename Function::FunctionSpaceType,
866  BinaryGridFunctionExpression<SMultiplyOperation, Factor, Function> >,
867  public BinaryGridFunctionExpressionTraits<SMultiplyOperation, Factor, Function>::BoundarySupportTagType,
868  public BinaryGridFunctionExpressionTraits<SMultiplyOperation, Factor, Function>::PieceWiseConstantTagType
869  {
870  typedef BinaryGridFunctionExpression<SMultiplyOperation, Factor, Function> ThisType;
871  typedef Fem::Function<typename Function::FunctionSpaceType, ThisType> BaseType;
872  typedef SMultiplyOperation OperationTagType;
873  typedef BinaryFunctionExpressionOperation<SMultiplyOperation> OperationType;
874 
875  // Make sure the functions are discrete functions
876  static_assert((std::is_base_of<Fem::HasLocalFunction, Function>::value),
877  "FunctionType must be a discrete function type.");
878 
879  public:
881  typedef Factor FactorType;
882 
884  typedef Function ContainedFunctionType;
885 
887  typedef BinaryGridFunctionExpressionTraits<SMultiplyOperation, Factor, ContainedFunctionType> TraitsType;
888 
890  enum {
891  isPieceWiseConstant = TraitsType::isPieceWiseConstant
892  };
893 
895  typedef ThisType DiscreteFunctionType;
896 
898  typedef typename TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
899 
900  // type of discrete function space
901  typedef typename TraitsType::FunctionSpaceType FunctionSpaceType;
902 
904  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
905 
907  typedef typename DiscreteFunctionSpaceType::GridType GridType;
908 
910  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
912  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
914  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
916  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
918  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
920  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
921 
923  typedef typename TraitsType::EntityType EntityType;
924  typedef typename GridPartType::IntersectionType IntersectionType;
925 
926  private:
927  class LocalFunction;
928  typedef GridFunctionExpression<FunctionSpaceType, ThisType> ExpressionBaseType;
929  using ExpressionBaseType::expressionName_;
930 
931  public:
933  typedef LocalFunction LocalFunctionType;
934 
935  // reference to function this local belongs to
936  BinaryGridFunctionExpression(const FactorType &s, const ContainedFunctionType &f)
937  : space_(f.space().gridPart(), f.space().order()),
938  scalar_(s),
939  function_(f)
940  {}
941 
942  // We DO allow copying of expressions
943  BinaryGridFunctionExpression(const ThisType &other)
944  : space_(other.space_),
945  scalar_(other.scalar_),
946  function_(other.function_)
947  {}
948 
950  void evaluate(const DomainType &global, RangeType &result) const
951  {
952  function().evaluate(global, result);
953  result *= parameterValue(scalar());
954  }
955 
957  void jacobian(const DomainType &global, JacobianRangeType &result) const
958  {
959  if (isPieceWiseConstant) {
960  result = 0.;
961  return;
962  }
963  function().jacobian(global, result);
964  result *= parameterValue(scalar());
965  }
966 
968  void hessian(const DomainType &global, HessianRangeType &result) const
969  {
970  if (isPieceWiseConstant) {
971  result = 0.;
972  return;
973  }
974  function().hessian(global, result);
975  for (int k = 0; k < HessianRangeType::dimension; ++k) {
976  result[k] *= parameterValue(scalar());
977  }
978  }
979 
981  const LocalFunctionType localFunction(const EntityType &entity) const
982  {
983  return LocalFunctionType(entity, *this);
984  }
985 
987  LocalFunctionType localFunction(const EntityType &entity)
988  {
989  return LocalFunctionType(entity, *this);
990  }
991 
993  const std::string &expressionName() const
994  {
995  std::string factorName = std::to_string(parameterValue(scalar()));
996  if (ParameterValue<FactorType>::isParameter) {
997  factorName = "P(" + factorName + ")";
998  }
999  expressionName_ = operationName(OperationTagType(), factorName, function().name());
1000  return expressionName_;
1001  }
1002 
1004  const DiscreteFunctionSpaceType &space() const { return space_; }
1005 
1006  const GridPartType &gridPart() const { return space().gridPart(); }
1007 
1013  typedef typename BoundaryFunctionTraits<ContainedFunctionType>::IndicatorType IndicatorType;
1014 
1015  enum {
1017  emptySupport = ExpressionTraits<IndicatorType>::isZero,
1019  globalSupport = std::is_same<IndicatorType, EntireBoundaryIndicatorType>::value
1020  };
1021 
1022  const LocalFunctionType localFunction(const EntityType& entity,
1023  const IntersectionType &intersection) const
1024  {
1025  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1026  return LocalFunctionType(entity, intersection, *this);
1027  }
1028 
1029  LocalFunctionType localFunction(const EntityType& entity,
1030  const IntersectionType &intersection)
1031  {
1032  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1033  return LocalFunctionType(entity, intersection, *this);
1034  }
1035 
1036  IndicatorType indicator() const
1037  {
1038  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1039  return BoundaryFunctionTraits<ContainedFunctionType>::indicator(function());
1040  }
1041 
1043 
1044  public:
1045  const FactorType& scalar() const { return scalar_(); }
1046  const ContainedFunctionType& function() const { return function_(); }
1047  protected:
1048  DiscreteFunctionSpaceType space_;
1049  ExpressionStorage<FactorType> scalar_;
1050  ExpressionStorage<ContainedFunctionType> function_;
1051  mutable std::string name_;
1052  };
1053 
1055  template<class FactorType, class FunctionType>
1056  class BinaryGridFunctionExpression<SMultiplyOperation, FactorType, FunctionType>::LocalFunction
1057  {
1058  typedef LocalFunction ThisType;
1059  typedef SMultiplyOperation OperationTagType;
1060  typedef BinaryFunctionExpressionOperation<SMultiplyOperation> OperationType;
1061  public:
1062  typedef BinaryGridFunctionExpression<SMultiplyOperation, FactorType, FunctionType> DiscreteFunctionType;
1063  typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
1064  typedef typename DiscreteFunctionType::FunctionSpaceType FunctionSpaceType;
1065  private:
1066  typedef typename FunctionType::LocalFunctionType SubLocalFunctionType;
1067  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
1068  typedef typename EntityType::Geometry GeometryType;
1069  public:
1070 
1071  static const int dimRange = DiscreteFunctionSpaceType::dimRange;
1072  static const int dimDomain = GridPartType::GridType::dimensionworld;
1073  static const int dimLocal = GridPartType::GridType::dimension;
1074 
1076  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
1078  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
1080  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
1082  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
1084  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
1086  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
1087 
1089  LocalFunction(const EntityType &entity, const DiscreteFunctionType &df)
1090  : intersection_(0),
1091  supported_(true),
1092  scalar_(df.scalar()),
1093  localFunction_(df.function().localFunction(entity)),
1094  entity_(&entity),
1095  order_(df.space().order())
1096  {}
1097 
1098  LocalFunction(const DiscreteFunctionType &df)
1099  : intersection_(0),
1100  supported_(true),
1101  scalar_(df.scalar()),
1102  localFunction_(df.function()),
1103  entity_(0),
1104  order_(df.space().order())
1105  {}
1106 
1108  template<class PointType>
1109  void evaluate(const PointType &x, RangeType &ret) const
1110  {
1111  if (!supported()) {
1112  ret = 0.;
1113  return;
1114  }
1115  localFunction_.evaluate(x, ret);
1116  ret *= parameterValue(scalar_);
1117  }
1118 
1120  template<class PointType>
1121  void jacobian(const PointType &x, JacobianRangeType &ret) const
1122  {
1123  if (DiscreteFunctionType::isPieceWiseConstant || !supported()) {
1124  ret = 0.;
1125  return;
1126  }
1127  localFunction_.jacobian(x, ret);
1128  ret *= parameterValue(scalar_);
1129  }
1130 
1132  template<class PointType>
1133  void hessian(const PointType &x, HessianRangeType &ret) const
1134  {
1135  if (DiscreteFunctionType::isPieceWiseConstant || !supported()) {
1136  ret = 0.;
1137  return;
1138  }
1139  localFunction_.hessian(x, ret);
1140  for (int k = 0; k < HessianRangeType::dimension; ++k) {
1141  ret[k] *= parameterValue(scalar_);
1142  }
1143  }
1144 
1146  template<class QuadratureType, class VectorType>
1147  void evaluateQuadrature(const QuadratureType& quadrature, VectorType& values) const
1148  {
1149  assert(values.size() == quadrature.nop());
1150  DiscreteFunctionType::evaluateQuadratureImp(*this, quadrature, values, values[0]);
1151  }
1152 
1154  int order() const
1155  {
1156  return DiscreteFunctionType::isPieceWiseConstant ? 0 : order_;
1157  }
1158 
1160  void init(const EntityType &entity)
1161  {
1162  // scalar_ is as a constant unaffected from the entity
1163  localFunction_.init(entity);
1164  entity_ = &entity;
1165  supported_ = true;
1166  }
1167 
1168  const EntityType &entity() const
1169  {
1170  assert(entity_);
1171  return *entity_;
1172  }
1173 
1178  enum {
1180  emptySupport = DiscreteFunctionType::emptySupport,
1182  globalSupport = DiscreteFunctionType::globalSupport
1183  };
1184 
1185  LocalFunction(const EntityType& entity,
1186  const IntersectionType &intersection, const DiscreteFunctionType &df)
1187  : scalar_(df.scalar()),
1188  localFunction_(LocalFunctiontype(df.function())),
1189  order_(df.space().order())
1190  {
1191  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1192  init(entity, intersection);
1193  }
1194 
1196  void init(const EntityType& entity, const IntersectionType& intersection)
1197  {
1198  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1199 
1200  BoundaryFunctionTraits<FunctionType>::init(localFunction_, entity, intersection);
1201  supported_ = BoundaryFunctionTraits<FunctionType>::supported(localFunction_);
1202 
1203  entity_ = &entity;
1204  intersection_ = &intersection;
1205  }
1206 
1208  const IntersectionType &intersection() const
1209  {
1210  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1211  assert(intersection_);
1212  return *intersection_;
1213  }
1214 
1215  bool supported() const
1216  {
1217  return globalSupport || (!emptySupport && supported_);
1218  }
1219 
1221 
1222  private:
1223  const IntersectionType *intersection_;
1224  bool supported_;
1225 
1226  private:
1227  const FactorType& scalar_;
1228  SubLocalFunctionType localFunction_;
1229  const EntityType *entity_;
1230  int order_;
1231  };
1232 
1234  //
1235  // Unary expressions
1236 
1237  // The result space may depend on the operation. The default is to
1238  // have the result space equal to the function space (inversion,
1239  // negation etc.)
1240  template<class UnOp, class FunctionType>
1241  struct UnaryGridFunctionExpressionBaseTraits
1242  {
1243  typedef typename FunctionType::FunctionSpaceType FunctionSpaceType;
1244  typedef typename FunctionType::DiscreteFunctionSpaceType FunctionDiscreteFunctionSpaceType;
1245  typedef typename FunctionDiscreteFunctionSpaceType::GridPartType GridPartType;
1246 
1247  typedef Fem::DiscreteFunctionSpaceAdapter<FunctionSpaceType, GridPartType> DiscreteFunctionSpaceType;
1248 
1249  static const unsigned int order =
1250  UnaryExpressionTraits<UnOp, typename FunctionType::RangeType>::polynomialOrder(
1251  FunctionDiscreteFunctionSpaceType::polynomialOrder);
1252  };
1253 
1254  template<class FunctionType>
1255  struct UnaryGridFunctionExpressionBaseTraits<SquareOperation, FunctionType>
1256  {
1257  typedef typename FunctionType::DiscreteFunctionSpaceType::ScalarFunctionSpaceType FunctionSpaceType;
1258  typedef typename FunctionType::DiscreteFunctionSpaceType FunctionDiscreteFunctionSpaceType;
1259  typedef typename FunctionDiscreteFunctionSpaceType::GridPartType GridPartType;
1260 
1261  typedef Fem::DiscreteFunctionSpaceAdapter<FunctionSpaceType, GridPartType> DiscreteFunctionSpaceType;
1262 
1263  static const unsigned int order = 2*FunctionDiscreteFunctionSpaceType::polynomialOrder;
1264  };
1265 
1267  template <class UnOp, class Function>
1268  struct UnaryGridFunctionExpressionTraits
1269  : public UnaryGridFunctionExpressionBaseTraits<UnOp, Function>
1270  {
1271  typedef UnaryGridFunctionExpressionBaseTraits<UnOp, Function> BaseType;
1272  typedef Function FunctionType;
1273  typedef typename BaseType::FunctionSpaceType FunctionSpaceType;
1274 
1275  typedef typename FunctionSpaceType::RangeFieldType RangeFieldType;
1276  typedef typename FunctionSpaceType::DomainFieldType DomainFieldType;
1277  typedef typename FunctionSpaceType::RangeType RangeType;
1278  typedef typename FunctionSpaceType::DomainType DomainType;
1279  typedef typename FunctionSpaceType::JacobianRangeType JacobianRangeType;
1280 
1281  typedef typename BaseType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
1282 
1283  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
1284  typedef typename GridPartType::GridType GridType;
1285  typedef typename GridPartType::template Codim<0>::EntityType EntityType;
1287  typedef typename GridPartType::template Codim<0>::IteratorType IteratorType;
1289  typedef typename GridPartType::IndexSetType IndexSetType;
1290 
1291  typedef UnaryGridFunctionExpression<UnOp, FunctionType> DiscreteFunctionType;
1292 
1293  // p.w. constant tag
1294  enum {
1295  isPieceWiseConstant = std::is_base_of<IsPieceWiseConstant, Function>::value
1296  };
1297 
1298  typedef
1299  typename std::conditional<isPieceWiseConstant,
1300  IsPieceWiseConstant, IsNotPieceWiseConstant>::type
1301  PieceWiseConstantTagType;
1302 
1303  static const unsigned int order = isPieceWiseConstant ? 0 : BaseType::order;
1304 
1305  // Boundary function stuff
1306  typedef BoundaryFunctionTraits<Function> BoundaryTraits;
1307  enum {
1308  hasBoundarySupport = BoundaryTraits::hasBoundarySupport
1309  };
1310  typedef
1311  typename std::conditional<hasBoundarySupport,
1312  HasBoundarySupport, HasNoBoundarySupport>::type
1313  BoundarySupportTagType;
1314  };
1315 
1316  // UnaryGridFunctionExpression
1317  // -------------------
1318 
1322  template<class UnOp, class FunctionType>
1323  class UnaryGridFunctionExpression
1324  : public GridFunctionExpression<typename UnaryGridFunctionExpressionTraits<UnOp, FunctionType>::FunctionSpaceType,
1325  UnaryGridFunctionExpression<UnOp, FunctionType> >,
1326  public UnaryGridFunctionExpressionTraits<UnOp, FunctionType>::BoundarySupportTagType,
1327  public UnaryGridFunctionExpressionTraits<UnOp, FunctionType>::PieceWiseConstantTagType
1328  {
1329  public:
1331  typedef UnaryGridFunctionExpressionTraits<UnOp, FunctionType> TraitsType;
1332  private:
1333  typedef UnaryGridFunctionExpression<UnOp, FunctionType> ThisType;
1334  typedef Fem::Function<typename TraitsType::FunctionSpaceType, ThisType> BaseType;
1335  typedef UnOp OperationTagType;
1336  typedef UnaryFunctionExpressionOperation<UnOp> OperationType;
1337 
1338  // Make sure the functions are discrete functions
1339  static_assert((std::is_base_of<Fem::HasLocalFunction, FunctionType>::value),
1340  "FunctionType must have a LocalFunctionType type.");
1341 
1342  enum {
1343  isPieceWiseConstant = TraitsType::isPieceWiseConstant
1344  };
1345 
1346  public:
1348  typedef ThisType DiscreteFunctionType;
1349 
1351  typedef typename TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
1352 
1353  // type of discrete function space
1354  typedef typename TraitsType::FunctionSpaceType FunctionSpaceType;
1355 
1357  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
1358 
1360  typedef typename DiscreteFunctionSpaceType::GridType GridType;
1361 
1363  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
1365  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
1367  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
1369  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
1371  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
1373  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
1374 
1376  typedef typename TraitsType::EntityType EntityType;
1377  typedef typename GridPartType::IntersectionType IntersectionType;
1378 
1379  private:
1380  class LocalFunction;
1381  typedef GridFunctionExpression<FunctionSpaceType, ThisType> ExpressionBaseType;
1382  using ExpressionBaseType::expressionName_;
1383 
1384  public:
1386  typedef LocalFunction LocalFunctionType;
1387 
1388  // reference to function this local belongs to
1389  UnaryGridFunctionExpression(const FunctionType &f)
1390  : space_(f.space().gridPart(), TraitsType::order),
1391  function_(f)
1392  {}
1393 
1394  // reference to function this local belongs to
1395  UnaryGridFunctionExpression(const ThisType &other)
1396  : space_(other.space_),
1397  function_(other.function_)
1398  {}
1399 
1401  void evaluate(const DomainType &global, RangeType &result) const
1402  {
1403  OperationType::evaluate(function(), global, result);
1404  }
1405 
1407  void jacobian(const DomainType &global, JacobianRangeType &result) const
1408  {
1409  if (isPieceWiseConstant) {
1410  result = 0.;
1411  return;
1412  }
1413  OperationType::jacobian(function(), global, result);
1414  }
1415 
1417  void hessian(const DomainType &global, HessianRangeType &result) const
1418  {
1419  if (isPieceWiseConstant) {
1420  result = 0.;
1421  return;
1422  }
1423  OperationType::hessian(function(), global, result);
1424  }
1425 
1427  const LocalFunctionType localFunction(const EntityType &entity) const
1428  {
1429  return LocalFunctionType(entity, *this);
1430  }
1431 
1433  LocalFunctionType localFunction(const EntityType &entity)
1434  {
1435  return LocalFunctionType(entity, *this);
1436  }
1437 
1439  const std::string &expressionName() const
1440  {
1441  expressionName_ = operationName(OperationTagType(), function().name());
1442  return expressionName_;
1443  }
1444 
1446  const DiscreteFunctionSpaceType &space() const { return space_; }
1447 
1448  const GridPartType &gridPart() const { return space().gridPart(); }
1449 
1455  typedef typename BoundaryFunctionTraits<FunctionType>::IndicatorType IndicatorType;
1456 
1457  enum {
1459  emptySupport = ExpressionTraits<IndicatorType>::isZero,
1461  globalSupport = std::is_same<IndicatorType, EntireBoundaryIndicatorType>::value
1462  };
1463 
1465  const LocalFunctionType localFunction(const EntityType& entity,
1466  const IntersectionType &intersection) const
1467  {
1468  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1469  return LocalFunctionType(entity, intersection, *this);
1470  }
1471 
1473  LocalFunctionType localFunction(const EntityType& entity,
1474  const IntersectionType &intersection)
1475  {
1476  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1477  return LocalFunctionType(entity, intersection, *this);
1478  }
1479 
1480  IndicatorType indicator() const
1481  {
1482  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1483  return BoundaryFunctionTraits<FunctionType>::indicator(function());
1484  }
1485 
1487 
1488  public:
1489  const FunctionType& function() const { return function_(); }
1490  private:
1491  DiscreteFunctionSpaceType space_;
1492  ExpressionStorage<FunctionType> function_;
1493  mutable std::string name_;
1494  };
1495 
1496  // UnaryGridFunctionExpression::LocalFunction
1497  // ----------------------------------
1498 
1499  template<class UnOp, class FunctionType>
1500  class UnaryGridFunctionExpression<UnOp, FunctionType>::LocalFunction
1501  {
1502  typedef LocalFunction ThisType;
1503  typedef UnOp OperationTagType;
1504  typedef UnaryFunctionExpressionOperation<UnOp> OperationType;
1505  public:
1506  typedef UnaryGridFunctionExpression<UnOp, FunctionType> DiscreteFunctionType;
1507  typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
1508  typedef typename DiscreteFunctionType::FunctionSpaceType FunctionSpaceType;
1509  private:
1510  typedef typename FunctionType::LocalFunctionType LocalFunctionType;
1511  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
1512  typedef typename EntityType::Geometry GeometryType;
1513  public:
1514 
1515  static const int dimRange = DiscreteFunctionSpaceType::dimRange;
1516  static const int dimDomain = GridPartType::GridType::dimensionworld;
1517  static const int dimLocal = GridPartType::GridType::dimension;
1518 
1520  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
1522  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
1524  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
1526  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
1528  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
1530  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
1531 
1533  LocalFunction(const EntityType &entity, const DiscreteFunctionType &df)
1534  : intersection_(0),
1535  supported_(true),
1536  localFunction_(df.function().localFunction(entity)),
1537  order_(df.space().order())
1538  {}
1539 
1540  LocalFunction(const DiscreteFunctionType &df)
1541  : intersection_(0),
1542  supported_(true),
1543  localFunction_(df.function()),
1544  order_(df.space().order())
1545  {}
1546 
1548  template<class PointType>
1549  void evaluate(const PointType &x, RangeType &ret) const
1550  {
1551  if (!supported()) {
1552  ret = 0.;
1553  return;
1554  }
1555  OperationType::evaluate(localFunction_, x, ret);
1556  }
1557 
1559  template<class PointType>
1560  void jacobian(const PointType &x, JacobianRangeType &ret) const
1561  {
1562  if (DiscreteFunctionType::isPieceWiseConstant || !supported()) {
1563  ret = 0.;
1564  return;
1565  }
1566  OperationType::jacobian(localFunction_, x, ret);
1567  }
1568 
1570  template<class PointType>
1571  void hessian(const PointType &x, HessianRangeType &ret) const
1572  {
1573  if (DiscreteFunctionType::isPieceWiseConstant || !supported()) {
1574  ret = 0.;
1575  return;
1576  }
1577  OperationType::hessian(localFunction_, x, ret);
1578  }
1579 
1581  template<class QuadratureType, class VectorType>
1582  void evaluateQuadrature(const QuadratureType& quadrature, VectorType& values) const
1583  {
1584  assert(values.size() == quadrature.nop());
1585  DiscreteFunctionType::evaluateQuadratureImp(*this, quadrature, values, values[0]);
1586  }
1587 
1589  int order() const { return order_; }
1590 
1592  void init(const EntityType &entity)
1593  {
1594  localFunction_.init(entity);
1595  }
1596 
1597  const EntityType &entity() const
1598  {
1599  localFunction_.entity();
1600  }
1601 
1606  enum {
1608  emptySupport = DiscreteFunctionType::emptySupport,
1610  globalSupport = DiscreteFunctionType::globalSupport
1611  };
1612 
1613  LocalFunction(const EntityType& entity,
1614  const IntersectionType &intersection,
1615  const DiscreteFunctionType &df)
1616  : localFunction_(LocalFunctiontype(df.function())),
1617  order_(df.space().order())
1618  {
1619  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1620  init(entity, intersection);
1621  }
1622 
1624  void init(const EntityType& entity, const IntersectionType& intersection)
1625  {
1626  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1627 
1628  BoundaryFunctionTraits<FunctionType>::init(localFunction_, entity, intersection);
1629  supported_ = BoundaryFunctionTraits<FunctionType>::supported(localFunction_);
1630 
1631  intersection_ = &intersection;
1632  }
1633 
1635  const IntersectionType &intersection() const
1636  {
1637  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1638  assert(intersection_);
1639  return *intersection_;
1640  }
1641 
1642  bool supported() const
1643  {
1644  return globalSupport || (!emptySupport && supported_);
1645  }
1646 
1647  private:
1648  const IntersectionType *intersection_;
1649  bool supported_;
1650 
1652 
1653  private:
1654  LocalFunctionType localFunction_;
1655  int order_;
1656  };
1657 
1658  // UnaryGridFunctionExpression<IdentityOperation>
1659  // -------------------
1660 
1662  template<class FunctionType>
1663  class UnaryGridFunctionExpression<IdentityOperation, FunctionType>
1664  : public GridFunctionExpression<typename FunctionType::FunctionSpaceType,
1665  UnaryGridFunctionExpression<IdentityOperation, FunctionType> >,
1666  public UnaryGridFunctionExpressionTraits<IdentityOperation, FunctionType>::BoundarySupportTagType,
1667  public UnaryGridFunctionExpressionTraits<IdentityOperation, FunctionType>::PieceWiseConstantTagType
1668  {
1669  typedef UnaryGridFunctionExpression<IdentityOperation, FunctionType> ThisType;
1670  typedef Fem::Function<typename FunctionType::FunctionSpaceType, ThisType> BaseType;
1671  typedef IdentityOperation OperationTagType;
1672  typedef UnaryFunctionExpressionOperation<OperationTagType> OperationType;
1673 
1674  // Make sure the functions are discrete functions
1675  static_assert((std::is_base_of<Fem::HasLocalFunction, FunctionType>::value),
1676  "FunctionType must be a discrete function type.");
1677 
1678  public:
1680  typedef UnaryGridFunctionExpressionTraits<OperationTagType, FunctionType> TraitsType;
1681 
1682  enum {
1683  isPieceWiseConstant = TraitsType::isPieceWiseConstant
1684  };
1685 
1686  typedef ThisType DiscreteFunctionType;
1687 
1689  typedef typename TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
1690 
1691  // type of discrete function space
1692  typedef typename TraitsType::FunctionSpaceType FunctionSpaceType;
1693 
1695  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
1696 
1698  typedef typename DiscreteFunctionSpaceType::GridType GridType;
1699 
1701  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
1703  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
1705  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
1707  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
1709  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
1711  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
1712 
1714  typedef typename TraitsType::EntityType EntityType;
1715  typedef typename GridPartType::IntersectionType IntersectionType;
1716 
1717  private:
1718  class LocalFunction;
1719  typedef GridFunctionExpression<FunctionSpaceType, ThisType> ExpressionBaseType;
1720  using ExpressionBaseType::expressionName_;
1721 
1722  public:
1724  typedef LocalFunction LocalFunctionType;
1725 
1726  // reference to function this local belongs to
1727  UnaryGridFunctionExpression(const FunctionType &f)
1728  : space_(f.space().gridPart(), TraitsType::order),
1729  function_(f)
1730  {}
1731 
1732  // reference to function this local belongs to
1733  UnaryGridFunctionExpression(const ThisType &other)
1734  : space_(other.space_),
1735  function_(other.function_)
1736  {}
1737 
1739  void evaluate(const DomainType &global, RangeType &result) const
1740  {
1741  function().evaluate(global, result);
1742  }
1743 
1745  void jacobian(const DomainType &global, JacobianRangeType &result) const
1746  {
1747  if (isPieceWiseConstant) {
1748  result = 0.;
1749  return;
1750  }
1751  function().jacobian(global, result);
1752  }
1753 
1755  void hessian(const DomainType &global, HessianRangeType &result) const
1756  {
1757  if (isPieceWiseConstant) {
1758  result = 0.;
1759  return;
1760  }
1761  function().hessian(global, result);
1762  }
1763 
1765  const LocalFunctionType localFunction(const EntityType &entity) const
1766  {
1767  return LocalFunctionType(entity, *this);
1768  }
1769 
1771  LocalFunctionType localFunction(const EntityType &entity)
1772  {
1773  return LocalFunctionType(entity, *this);
1774  }
1775 
1777  const std::string &expressionName() const
1778  {
1779  expressionName_ = operationName(OperationTagType(), function().name());
1780  return expressionName_;
1781  }
1782 
1784  const DiscreteFunctionSpaceType &space() const { return space_; }
1785 
1786  const GridPartType &gridPart() const { return space().gridPart(); }
1787 
1793  typedef typename BoundaryFunctionTraits<FunctionType>::IndicatorType IndicatorType;
1794 
1795  enum {
1797  emptySupport = ExpressionTraits<IndicatorType>::isZero,
1799  globalSupport = std::is_same<IndicatorType, EntireBoundaryIndicatorType>::value
1800  };
1801 
1803  const LocalFunctionType localFunction(const EntityType& entity,
1804  const IntersectionType &intersection) const
1805  {
1806  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1807  return LocalFunctionType(entity, intersection, *this);
1808  }
1809 
1811  LocalFunctionType localFunction(const EntityType& entity,
1812  const IntersectionType &intersection)
1813  {
1814  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1815  return LocalFunctionType(entity, intersection, *this);
1816  }
1817 
1818  IndicatorType indicator() const
1819  {
1820  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1821  return BoundaryFunctionTraits<FunctionType>::indicator(function());
1822  }
1823 
1825 
1826  private:
1827  const FunctionType& function() const { return function_(); }
1828  private:
1829  DiscreteFunctionSpaceType space_;
1830  ExpressionStorage<FunctionType> function_;
1831  mutable std::string name_;
1832  };
1833 
1834  // UnaryGridFunctionExpression::LocalFunction
1835  // ----------------------------------
1836  template<class FunctionType>
1837  class UnaryGridFunctionExpression<IdentityOperation, FunctionType>::LocalFunction
1838  {
1839  typedef LocalFunction ThisType;
1840  typedef IdentityOperation OperationTagType;
1841  typedef UnaryFunctionExpressionOperation<OperationTagType> OperationType;
1842  public:
1843  typedef UnaryGridFunctionExpression<IdentityOperation, FunctionType> DiscreteFunctionType;
1844  typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
1845  typedef typename DiscreteFunctionType::FunctionSpaceType FunctionSpaceType;
1846  private:
1847  typedef typename FunctionType::LocalFunctionType LocalFunctionType;
1848  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
1849  typedef typename EntityType::Geometry GeometryType;
1850  public:
1851 
1852  static const int dimRange = DiscreteFunctionSpaceType::dimRange;
1853  static const int dimDomain = GridPartType::GridType::dimensionworld;
1854  static const int dimLocal = GridPartType::GridType::dimension;
1855 
1857  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
1859  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
1861  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
1863  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
1865  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
1867  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
1868 
1870  LocalFunction(const EntityType &entity, const DiscreteFunctionType &df)
1871  : intersection_(0),
1872  supported_(true),
1873  localFunction_(df.function().localFunction(entity))
1874  {}
1875 
1876  LocalFunction(const DiscreteFunctionType &df)
1877  : intersection_(0),
1878  supported_(true),
1879  localFunction_(df.function())
1880  {}
1881 
1883  template<class PointType>
1884  void evaluate(const PointType &x, RangeType &ret) const
1885  {
1886  if (!supported()) {
1887  ret = 0.;
1888  return;
1889  }
1890  localFunction_.evaluate(x, ret);
1891  }
1892 
1894  template<class PointType>
1895  void jacobian(const PointType &x, JacobianRangeType &ret) const
1896  {
1897  if (DiscreteFunctionType::isPieceWiseConstant || !supported()) {
1898  ret = 0.;
1899  return;
1900  }
1901  localFunction_.jacobian(x, ret);
1902  }
1903 
1905  template<class PointType>
1906  void hessian(const PointType &x, HessianRangeType &ret) const
1907  {
1908  if (DiscreteFunctionType::isPieceWiseConstant || !supported()) {
1909  ret = 0.;
1910  return;
1911  }
1912  localFunction_.hessian(x, ret);
1913  }
1914 
1916  template<class QuadratureType, class VectorType>
1917  void evaluateQuadrature(const QuadratureType& quadrature, VectorType& values) const
1918  {
1919  assert(values.size() == quadrature.nop());
1920  DiscreteFunctionType::evaluateQuadratureImp(*this, quadrature, values, values[0]);
1921  }
1922 
1924  int order() const { return localFunction_.order(); }
1925 
1927  void init(const EntityType &entity)
1928  {
1929  localFunction_.init(entity);
1930  supported_ = true;
1931  }
1932 
1933  const EntityType &entity() const
1934  {
1935  return localFunction_.entity();
1936  }
1937 
1942  enum {
1944  emptySupport = DiscreteFunctionType::emptySupport,
1946  globalSupport = DiscreteFunctionType::globalSupport
1947  };
1948 
1949  LocalFunction(const EntityType& entity,
1950  const IntersectionType &intersection,
1951  const DiscreteFunctionType &df)
1952  : localFunction_(LocalFunctiontype(df.function()))
1953  {
1954  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1955  init(entity, intersection);
1956  }
1957 
1959  void init(const EntityType& entity, const IntersectionType& intersection)
1960  {
1961  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1962 
1963  BoundaryFunctionTraits<FunctionType>::init(localFunction_, entity, intersection);
1964  supported_ = BoundaryFunctionTraits<FunctionType>::supported(localFunction_);
1965 
1966  intersection_ = &intersection;
1967  }
1968 
1970  const IntersectionType &intersection() const
1971  {
1972  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
1973  assert(intersection_);
1974  return *intersection_;
1975  }
1976 
1977  bool supported() const
1978  {
1979  return globalSupport || (!emptySupport && supported_);
1980  }
1981 
1982  private:
1983  const IntersectionType *intersection_;
1984  bool supported_;
1985 
1987 
1988  private:
1989  LocalFunctionType localFunction_;
1990  };
1991 
1992  // UnaryGridFunctionExpression<InvertOperation>
1993  // -------------------
1994 
2003  template<class FunctionType>
2004  class UnaryGridFunctionExpression<InvertOperation, FunctionType>
2005  : public GridFunctionExpression<typename FunctionType::FunctionSpaceType,
2006  UnaryGridFunctionExpression<InvertOperation, FunctionType> >,
2007  public UnaryGridFunctionExpressionTraits<InvertOperation, FunctionType>::BoundarySupportTagType
2008  {
2009  typedef UnaryGridFunctionExpression<InvertOperation, FunctionType> ThisType;
2010  typedef Fem::Function<typename FunctionType::FunctionSpaceType, ThisType> BaseType;
2011  typedef InvertOperation OperationTagType;
2012  typedef UnaryFunctionExpressionOperation<OperationTagType> OperationType;
2013 
2014  // Make sure the functions are discrete functions
2015  static_assert((std::is_base_of<Fem::HasLocalFunction, FunctionType>::value),
2016  "FunctionType must be a discrete function type.");
2017 
2018  public:
2020  typedef UnaryGridFunctionExpressionTraits<OperationTagType, FunctionType> TraitsType;
2021 
2022  enum {
2023  isPieceWiseConstant = TraitsType::isPieceWiseConstant
2024  };
2025 
2026  typedef ThisType DiscreteFunctionType;
2027 
2029  typedef typename TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
2030 
2031  // type of discrete function space
2032  typedef typename TraitsType::FunctionSpaceType FunctionSpaceType;
2033 
2035  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
2036 
2038  typedef typename DiscreteFunctionSpaceType::GridType GridType;
2039 
2041  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
2043  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
2045  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
2047  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
2049  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
2051  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
2052 
2054  typedef typename TraitsType::EntityType EntityType;
2055  typedef typename GridPartType::IntersectionType IntersectionType;
2056 
2057  private:
2058  class LocalFunction;
2059  typedef GridFunctionExpression<FunctionSpaceType, ThisType> ExpressionBaseType;
2060  using ExpressionBaseType::expressionName_;
2061 
2062  public:
2064  typedef LocalFunction LocalFunctionType;
2065 
2066  // reference to function this local belongs to
2067  UnaryGridFunctionExpression(const FunctionType &f)
2068  : space_(f.space().gridPart(), TraitsType::order),
2069  function_(f)
2070  {}
2071 
2072  // reference to function this local belongs to
2073  UnaryGridFunctionExpression(const ThisType &other)
2074  : space_(other.space_),
2075  function_(other.function_)
2076  {}
2077 
2079  void evaluate(const DomainType &global, RangeType &result) const
2080  {
2081  OperationType::evaluate(function(), global, result);
2082  }
2083 
2085  void jacobian(const DomainType &global, JacobianRangeType &result) const
2086  {
2087  if (isPieceWiseConstant) {
2088  result = 0.;
2089  return;
2090  }
2091  OperationType::jacobian(function(), global, result);
2092  }
2093 
2095  void hessian(const DomainType &global, HessianRangeType &result) const
2096  {
2097  if (isPieceWiseConstant) {
2098  result = 0.;
2099  return;
2100  }
2101  OperationType::hessian(function(), global, result);
2102  }
2103 
2105  const LocalFunctionType localFunction(const EntityType &entity) const
2106  {
2107  return LocalFunctionType(entity, *this);
2108  }
2109 
2111  LocalFunctionType localFunction(const EntityType &entity)
2112  {
2113  return LocalFunctionType(entity, *this);
2114  }
2115 
2117  const std::string &expressionName() const
2118  {
2119  expressionName_ = operationName(OperationTagType(), function().name());
2120  return expressionName_;
2121  }
2122 
2124  const DiscreteFunctionSpaceType &space() const { return space_; }
2125 
2126  const GridPartType &gridPart() const { return space().gridPart(); }
2127 
2133  typedef EntireBoundaryIndicatorType IndicatorType;
2134 
2135  enum {
2137  emptySupport = false,
2139  globalSupport = true
2140  };
2141 
2143  const LocalFunctionType localFunction(const EntityType& entity,
2144  const IntersectionType &intersection) const
2145  {
2146  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
2147  return LocalFunctionType(entity, intersection, *this);
2148  }
2149 
2151  LocalFunctionType localFunction(const EntityType& entity,
2152  const IntersectionType &intersection)
2153  {
2154  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
2155  return LocalFunctionType(entity, intersection, *this);
2156  }
2157 
2158  IndicatorType indicator() const
2159  {
2160  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
2161  return IndicatorType();
2162  }
2163 
2165 
2166  private:
2167  const FunctionType& function() const { return function_(); }
2168  private:
2169  DiscreteFunctionSpaceType space_;
2170  ExpressionStorage<FunctionType> function_;
2171  mutable std::string name_;
2172  };
2173 
2174  // UnaryGridFunctionExpression::LocalFunction
2175  // ----------------------------------
2176  template<class FunctionType>
2177  class UnaryGridFunctionExpression<InvertOperation, FunctionType>::LocalFunction
2178  {
2179  typedef LocalFunction ThisType;
2180  public:
2181  typedef UnaryGridFunctionExpression<InvertOperation, FunctionType> DiscreteFunctionType;
2182  typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
2183  typedef typename DiscreteFunctionType::FunctionSpaceType FunctionSpaceType;
2184  private:
2185  typedef InvertOperation OperationTagType;
2186  typedef UnaryFunctionExpressionOperation<OperationTagType> OperationType;
2187  private:
2188  typedef typename FunctionType::LocalFunctionType LocalFunctionType;
2189  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
2190  typedef typename EntityType::Geometry GeometryType;
2191  public:
2192 
2193  static const int dimRange = DiscreteFunctionSpaceType::dimRange;
2194  static const int dimDomain = GridPartType::GridType::dimensionworld;
2195  static const int dimLocal = GridPartType::GridType::dimension;
2196 
2198  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
2200  typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
2202  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
2204  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
2206  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
2208  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
2209 
2211  LocalFunction(const EntityType &entity, const DiscreteFunctionType &df)
2212  : intersection_(0),
2213  supported_(true),
2214  localFunction_(df.function().localFunction(entity))
2215  {}
2216 
2217  LocalFunction(const DiscreteFunctionType &df)
2218  : intersection_(0),
2219  supported_(true),
2220  localFunction_(df.function()) {}
2221 
2223  template<class PointType>
2224  void evaluate(const PointType &x, RangeType &ret) const
2225  {
2226  if (!supported()) {
2227  ret = 0.;
2228  return;
2229  }
2230  OperationType::evaluate(localFunction_, x, ret);
2231  }
2232 
2234  template<class PointType>
2235  void jacobian(const PointType &x, JacobianRangeType &ret) const
2236  {
2237  if (DiscreteFunctionType::isPieceWiseConstant || !supported()) {
2238  ret = 0.;
2239  return;
2240  }
2241  OperationType::jacobian(localFunction_, x, ret);
2242  }
2243 
2245  template<class PointType>
2246  void hessian(const PointType &x, HessianRangeType &ret) const
2247  {
2248  if (DiscreteFunctionType::isPieceWiseConstant || !supported()) {
2249  ret = 0.;
2250  return;
2251  }
2252  OperationType::hessian(localFunction_, x, ret);
2253  }
2254 
2256  template<class QuadratureType, class VectorType>
2257  void evaluateQuadrature(const QuadratureType& quadrature, VectorType& values) const
2258  {
2259  assert(values.size() == quadrature.nop());
2260  DiscreteFunctionType::evaluateQuadratureImp(*this, quadrature, values, values[0]);
2261  }
2262 
2264  int order() const
2265  {
2266  return DiscreteFunctionType::isPieceWiseConstant ? 0 : 111;
2267  }
2268 
2270  void init(const EntityType &entity)
2271  {
2272  localFunction_.init(entity);
2273  supported_ = true;
2274  }
2275 
2276  const EntityType &entity() const
2277  {
2278  return localFunction_.entity();
2279  }
2280 
2285  enum {
2287  emptySupport = DiscreteFunctionType::emptySupport,
2289  globalSupport = DiscreteFunctionType::globalSupport
2290  };
2291 
2292  LocalFunction(const EntityType& entity,
2293  const IntersectionType &intersection,
2294  const DiscreteFunctionType &df)
2295  : localFunction_(LocalFunctiontype(df.function()))
2296  {
2297  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
2298  init(entity, intersection);
2299  }
2300 
2302  void init(const EntityType& entity, const IntersectionType& intersection)
2303  {
2304  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
2305 
2306  BoundaryFunctionTraits<FunctionType>::init(localFunction_, entity, intersection);
2307  supported_ = BoundaryFunctionTraits<FunctionType>::supported(localFunction_);
2308 
2309  intersection_ = &intersection;
2310  }
2311 
2313  const IntersectionType &intersection() const
2314  {
2315  static_assert(TraitsType::hasBoundarySupport, "This is not a BoundarySupportedFunction");
2316  assert(intersection_);
2317  return *intersection_;
2318  }
2319 
2320  bool supported() const
2321  {
2322  return globalSupport || (!emptySupport && supported_);
2323  }
2324 
2325  private:
2326  const IntersectionType *intersection_;
2327  bool supported_;
2328 
2330 
2331  private:
2332  LocalFunctionType localFunction_;
2333  };
2334 
2336  //
2337  // Multiplication
2338 
2339  template<class LeftFunction, class RightFunction>
2340  static inline
2341  BinaryGridFunctionExpression<MultiplyOperation, LeftFunction, RightFunction>
2342  operator*(const Fem::Function<typename LeftFunction::FunctionSpaceType, LeftFunction>& f_,
2343  const Fem::Function<typename RightFunction::FunctionSpaceType, RightFunction>& g_)
2344  {
2345  typedef LeftFunction LeftFunctionType;
2346  typedef RightFunction RightFunctionType;
2347 
2348  static_assert(std::is_base_of<Fem::HasLocalFunction, LeftFunctionType>::value,
2349  "Left operand must be a GridFunction");
2350  static_assert(std::is_base_of<Fem::HasLocalFunction, RightFunctionType>::value,
2351  "Right operand must be a GridFunction");
2352 
2353  const LeftFunctionType& f(static_cast<const LeftFunctionType&>(f_));
2354  const RightFunctionType& g(static_cast<const RightFunctionType&>(g_));
2355 
2356  typedef BinaryGridFunctionExpression<MultiplyOperation, LeftFunctionType, RightFunctionType> ExpressionType;
2357  return ExpressionType(f, g);
2358  }
2359 
2360  // Multiplication by scalars
2361 
2362  // s * f
2363  template<class Function>
2364  static inline
2365  BinaryGridFunctionExpression<SMultiplyOperation, typename Function::RangeFieldType, Function>
2366  operator*(const typename Function::RangeFieldType& s,
2367  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2368  {
2369  typedef Function FunctionType;
2370 
2371  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2372  "Right operand must be a GridFunction");
2373 
2374  const FunctionType& f(static_cast<const FunctionType&>(f_));
2375  typedef typename FunctionType::RangeFieldType RangeFieldType;
2376  typedef BinaryGridFunctionExpression<SMultiplyOperation, RangeFieldType, FunctionType> ExpressionType;
2377 
2378  return ExpressionType(s, f);
2379  }
2380 
2382  template<class Function>
2383  static inline
2384  auto operator*(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
2385  const typename Function::RangeFieldType& s)
2386  -> decltype(s * asImp(f_))
2387  {
2388  return s * asImp(f_);
2389  }
2390 
2392  template<class Parameter, class Function>
2393  static inline
2394  BinaryGridFunctionExpression<SMultiplyOperation, Parameter, Function>
2395  operator*(const ParameterInterface<Parameter>& s_,
2396  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2397  {
2398  typedef Function FunctionType;
2399  typedef Parameter ParameterType;
2400 
2401  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2402  "Right operand must be a GridFunction");
2403 
2404  const ParameterType& s(static_cast<const ParameterType&>(s_));
2405  const FunctionType& f(static_cast<const FunctionType&>(f_));
2406  typedef BinaryGridFunctionExpression<SMultiplyOperation, ParameterType, FunctionType> ExpressionType;
2407 
2408  return ExpressionType(s, f);
2409  }
2410 
2412  template<class Parameter, class Function>
2413  static inline
2414  auto operator*(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
2415  const ParameterInterface<Parameter>& s_)
2416  -> decltype(asImp(s_) * asImp(f_))
2417 
2418  {
2419  return asImp(s_) * asImp(f_);
2420  }
2421 
2423  //
2424  // Division by multiplication with inverse.
2425 
2427  template<class LeftFunction, class RightFunction>
2428  auto operator/(const Fem::Function<typename LeftFunction::FunctionSpaceType, LeftFunction>& l_,
2429  const Fem::Function<typename RightFunction::FunctionSpaceType::ScalarFunctionSpaceType, RightFunction>& r_)
2430  -> decltype(asImp(l_) * std::declval<UnaryGridFunctionExpression<InvertOperation, RightFunction> >())
2431  {
2432  typedef RightFunction RightFunctionType;
2433 
2434  static_assert(std::is_base_of<Fem::HasLocalFunction, RightFunctionType>::value,
2435  "Right operand must be a GridFunction");
2436 
2437  typedef UnaryGridFunctionExpression<InvertOperation, RightFunctionType> InvertExpressionType;
2438 
2439  return asImp(l_) * InvertExpressionType(asImp(r_));
2440  }
2441 
2443  template<class RightFunction>
2444  auto operator/(const typename RightFunction::RangeFieldType& l_,
2445  const Fem::Function<typename RightFunction::FunctionSpaceType::ScalarFunctionSpaceType, RightFunction>& r_)
2446  -> decltype(l_ * std::declval<UnaryGridFunctionExpression<InvertOperation, RightFunction> >())
2447  {
2448  typedef RightFunction RightFunctionType;
2449 
2450  static_assert(std::is_base_of<Fem::HasLocalFunction, RightFunctionType>::value,
2451  "Right operand must be a GridFunction");
2452 
2453  typedef UnaryGridFunctionExpression<InvertOperation, RightFunctionType> InvertExpressionType;
2454 
2455  return l_ * InvertExpressionType(asImp(r_));
2456  }
2457 
2459  template<class LeftParameter, class RightFunction>
2460  auto operator/(const ParameterInterface<LeftParameter>& l_,
2461  const Fem::Function<typename RightFunction::FunctionSpaceType::ScalarFunctionSpaceType, RightFunction>& r_)
2462  -> decltype(asImp(l_) * std::declval<UnaryGridFunctionExpression<InvertOperation, RightFunction> >())
2463  {
2464  typedef RightFunction RightFunctionType;
2465 
2466  static_assert(std::is_base_of<Fem::HasLocalFunction, RightFunctionType>::value,
2467  "Right operand must be a GridFunction");
2468 
2469  typedef UnaryGridFunctionExpression<InvertOperation, RightFunctionType> InvertExpressionType;
2470 
2471  return asImp(l_) * InvertExpressionType(asImp(r_));
2472  }
2473 
2475  template<class Function>
2476  static inline
2477  auto operator/(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
2478  const typename Function::RangeFieldType& s)
2479  -> decltype((1.0/s) * asImp(f_))
2480  {
2481  return (1.0/s) * asImp(f_);
2482  }
2483 
2484  // there is no operator/ yet for parameters, so what.
2485 
2487  //
2488  // Addition
2489 
2490  template<class LeftFunction, class RightFunction>
2491  static inline
2492  BinaryGridFunctionExpression<PlusOperation, LeftFunction, RightFunction>
2493  operator+(const Fem::Function<typename LeftFunction::FunctionSpaceType, LeftFunction>& f_,
2494  const Fem::Function<typename RightFunction::FunctionSpaceType, RightFunction>& g_)
2495  {
2496  typedef LeftFunction LeftFunctionType;
2497  typedef RightFunction RightFunctionType;
2498 
2499  static_assert(std::is_base_of<Fem::HasLocalFunction, LeftFunctionType>::value,
2500  "Left operand must be a GridFunction");
2501  static_assert(std::is_base_of<Fem::HasLocalFunction, RightFunctionType>::value,
2502  "Right operand must be a GridFunction");
2503 
2504  const LeftFunctionType& f(static_cast<const LeftFunctionType&>(f_));
2505  const RightFunctionType& g(static_cast<const RightFunctionType&>(g_));
2506 
2507  typedef BinaryGridFunctionExpression<PlusOperation, LeftFunctionType, RightFunctionType> ExpressionType;
2508 
2509  return ExpressionType(f, g);
2510  }
2511 
2517  template<class Function>
2518  static inline
2519  BinaryGridFunctionExpression<PlusOperation,
2520  ConstantGridFunction<typename Function::FunctionSpaceType, typename Function::GridPartType>,
2521  Function>
2522  operator+(const typename Function::RangeType& s,
2523  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2524  {
2525  typedef Function FunctionType;
2526 
2527  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2528  "Right operand must be a GridFunction");
2529 
2530  const FunctionType& f(static_cast<const FunctionType&>(f_));
2531 
2532  typedef typename FunctionType::GridPartType GridPartType;
2533  typedef typename FunctionType::FunctionSpaceType FunctionSpaceType;
2534  typedef ConstantGridFunction<FunctionSpaceType, GridPartType> ConstantFunctionType;
2535  typedef BinaryGridFunctionExpression<PlusOperation, ConstantFunctionType, FunctionType>
2536  ExpressionType;
2537 
2538  ConstantFunctionType constant(s, f.space().gridPart());
2539 
2540  return ExpressionType(constant, f);
2541  }
2542 
2548  template<class Function>
2549  static inline
2550  auto
2551  operator+(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
2552  const typename Function::RangeType& s_)
2553  -> decltype(s_ + f_)
2554  {
2555  return s_ + f_;
2556  }
2557 
2563  template<class Parameter, class Function>
2564  static inline
2565  BinaryGridFunctionExpression<PlusOperation,
2566  ParameterGridFunction<Parameter, typename Function::FunctionSpaceType,
2567  typename Function::GridPartType>,
2568  Function>
2569  operator+(const ParameterInterface<Parameter>& s_,
2570  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2571  {
2572  typedef Function FunctionType;
2573  typedef Parameter ParameterType;
2574 
2575  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2576  "Right operand must be a GridFunction");
2577 
2578  const ParameterType& s(static_cast<const ParameterType&>(s_));
2579  const FunctionType& f(static_cast<const FunctionType&>(f_));
2580 
2581  typedef typename FunctionType::GridPartType GridPartType;
2582  typedef typename FunctionType::FunctionSpaceType FunctionSpaceType;
2583  typedef ParameterGridFunction<ParameterType, FunctionSpaceType, GridPartType> ParameterFunctionType;
2584  typedef BinaryGridFunctionExpression<PlusOperation, ParameterFunctionType, FunctionType>
2585  ExpressionType;
2586 
2587  ParameterFunctionType parameter(s, f.space().gridPart());
2588 
2589  return ExpressionType(parameter, f);
2590  }
2591 
2597  template<class Parameter, class Function>
2598  static inline
2599  auto
2600  operator+(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
2601  const ParameterInterface<Parameter>& s_)
2602  -> decltype(s_ + f_)
2603  {
2604  return s_ + f_;
2605  }
2606 
2608  //
2609  // Subtraction
2610 
2611  template<class LeftFunction, class RightFunction>
2612  static inline
2613  BinaryGridFunctionExpression<MinusOperation, LeftFunction, RightFunction>
2614  operator-(const Fem::Function<typename LeftFunction::FunctionSpaceType, LeftFunction>& f_,
2615  const Fem::Function<typename RightFunction::FunctionSpaceType, RightFunction>& g_)
2616  {
2617  typedef LeftFunction LeftFunctionType;
2618  typedef RightFunction RightFunctionType;
2619 
2620  static_assert(std::is_base_of<Fem::HasLocalFunction, LeftFunctionType>::value,
2621  "Left operand must be a GridFunction");
2622  static_assert(std::is_base_of<Fem::HasLocalFunction, RightFunctionType>::value,
2623  "Right operand must be a GridFunction");
2624 
2625  const LeftFunctionType& f(static_cast<const LeftFunctionType&>(f_));
2626  const RightFunctionType& g(static_cast<const RightFunctionType&>(g_));
2627 
2628  typedef BinaryGridFunctionExpression<MinusOperation, LeftFunctionType, RightFunctionType> ExpressionType;
2629 
2630  return ExpressionType(f, g);
2631  }
2632 
2633  template<class Function>
2634  static inline
2635  BinaryGridFunctionExpression<MinusOperation,
2636  ConstantGridFunction<typename Function::FunctionSpaceType::ScalarFunctionSpaceType, typename Function::GridPartType>,
2637  Function>
2638  operator-(const typename Function::RangeFieldType& s,
2639  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2640  {
2641  typedef Function FunctionType;
2642 
2643  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2644  "Right operand must be a GridFunction");
2645 
2646  const FunctionType& f(static_cast<const FunctionType&>(f_));
2647 
2648  typedef typename FunctionType::GridPartType GridPartType;
2649  typedef typename FunctionType::FunctionSpaceType FunctionSpaceType;
2650  typedef typename FunctionSpaceType::ScalarFunctionSpaceType ScalarFunctionSpaceType;
2651  typedef ConstantGridFunction<ScalarFunctionSpaceType, GridPartType> ConstantFunctionType;
2652  typedef BinaryGridFunctionExpression<MinusOperation, ConstantFunctionType, FunctionType>
2653  ExpressionType;
2654 
2655  ConstantFunctionType scalar(s, f.space().gridPart());
2656 
2657  return ExpressionType(scalar, f);
2658  }
2659 
2660  template<class Function>
2661  static inline
2662  BinaryGridFunctionExpression<MinusOperation,
2663  Function,
2664  ConstantGridFunction<typename Function::FunctionSpaceType::ScalarFunctionSpaceType, typename Function::GridPartType> >
2665  operator-(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
2666  const typename Function::RangeFieldType& s)
2667  {
2668  typedef Function FunctionType;
2669 
2670  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2671  "Left operand must be a GridFunction");
2672 
2673  const FunctionType& f(static_cast<const FunctionType&>(f_));
2674 
2675  typedef typename FunctionType::GridPartType GridPartType;
2676  typedef typename FunctionType::FunctionSpaceType FunctionSpaceType;
2677  typedef typename FunctionSpaceType::ScalarFunctionSpaceType ScalarFunctionSpaceType;
2678  typedef ConstantGridFunction<ScalarFunctionSpaceType, GridPartType> ConstantFunctionType;
2679  typedef BinaryGridFunctionExpression<MinusOperation, FunctionType, ConstantFunctionType>
2680  ExpressionType;
2681  ConstantFunctionType scalar(s, f.space().gridPart());
2682 
2683  return ExpressionType(f, scalar);
2684  }
2685 
2691  template<class Parameter, class Function>
2692  static inline
2693  BinaryGridFunctionExpression<MinusOperation,
2694  ParameterGridFunction<Parameter, typename Function::FunctionSpaceType,
2695  typename Function::GridPartType>,
2696  Function>
2697  operator-(const ParameterInterface<Parameter>& s_,
2698  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2699  {
2700  typedef Function FunctionType;
2701  typedef Parameter ParameterType;
2702 
2703  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2704  "Right operand must be a GridFunction");
2705 
2706  const ParameterType& s(static_cast<const ParameterType&>(s_));
2707  const FunctionType& f(static_cast<const FunctionType&>(f_));
2708 
2709  typedef typename FunctionType::GridPartType GridPartType;
2710  typedef typename FunctionType::FunctionSpaceType FunctionSpaceType;
2711  typedef ParameterGridFunction<ParameterType, FunctionSpaceType, GridPartType> ParameterFunctionType;
2712  typedef BinaryGridFunctionExpression<MinusOperation, ParameterFunctionType, FunctionType>
2713  ExpressionType;
2714 
2715  ParameterFunctionType parameter(s, f.space().gridPart());
2716 
2717  return ExpressionType(parameter, f);
2718  }
2719 
2725  template<class Parameter, class Function>
2726  static inline
2727  BinaryGridFunctionExpression<MinusOperation,
2728  Function,
2729  ParameterGridFunction<Parameter, typename Function::FunctionSpaceType,
2730  typename Function::GridPartType> >
2731  operator-(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
2732  const ParameterInterface<Parameter>& s_)
2733 
2734  {
2735  typedef Function FunctionType;
2736  typedef Parameter ParameterType;
2737 
2738  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2739  "Right operand must be a GridFunction");
2740 
2741  const ParameterType& s(static_cast<const ParameterType&>(s_));
2742  const FunctionType& f(static_cast<const FunctionType&>(f_));
2743 
2744  typedef typename FunctionType::GridPartType GridPartType;
2745  typedef typename FunctionType::FunctionSpaceType FunctionSpaceType;
2746  typedef ParameterGridFunction<ParameterType, FunctionSpaceType, GridPartType> ParameterFunctionType;
2747  typedef BinaryGridFunctionExpression<MinusOperation, FunctionType, ParameterFunctionType>
2748  ExpressionType;
2749 
2750  ParameterFunctionType parameter(s, f.space().gridPart());
2751 
2752  return ExpressionType(f, parameter);
2753  }
2754 
2756  //
2757  // Identity
2758 
2762  template<class Function>
2763  static inline
2764  UnaryGridFunctionExpression<IdentityOperation, Function>
2765  operator*(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2766  {
2767  typedef Function FunctionType;
2768 
2769  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2770  "Operand must be a GridFunction");
2771 
2772  const FunctionType& f(static_cast<const FunctionType&>(f_));
2773 
2774  typedef UnaryGridFunctionExpression<IdentityOperation, FunctionType> ExpressionType;
2775 
2776  return ExpressionType(f);
2777  }
2778 
2780  //
2781  // unary plus is redirected to unary operator*()
2782 
2784  template<class Function>
2785  static inline
2786  auto
2787  operator+(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2788  -> decltype(*asImp(f_))
2789  {
2790  return *asImp(f_);
2791  }
2792 
2794  //
2795  // Unary minus
2796 
2797  template<class Function>
2798  static inline
2799  UnaryGridFunctionExpression<MinusOperation, Function>
2800  operator-(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2801  {
2802  typedef Function FunctionType;
2803 
2804  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2805  "Operand must be a GridFunction");
2806 
2807  const FunctionType& f(static_cast<const FunctionType&>(f_));
2808 
2809  typedef UnaryGridFunctionExpression<MinusOperation, FunctionType> ExpressionType;
2810 
2811  return ExpressionType(f);
2812  }
2813 
2815  //
2816  // Component-wise exponentiation
2817 
2819  template<class Function>
2820  static inline
2821  UnaryGridFunctionExpression<ExpOperation, Function>
2822  exp(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2823  {
2824  typedef Function FunctionType;
2825 
2826  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2827  "Operand must be a GridFunction");
2828 
2829  const FunctionType& f(static_cast<const FunctionType&>(f_));
2830 
2831  typedef UnaryGridFunctionExpression<ExpOperation, FunctionType> ExpressionType;
2832 
2833  return ExpressionType(f);
2834  }
2835 
2837  //
2838  // Component-wise log
2839 
2841  template<class Function>
2842  static inline
2843  UnaryGridFunctionExpression<LogOperation, Function>
2844  log(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2845  {
2846  typedef Function FunctionType;
2847 
2848  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2849  "Operand must be a GridFunction");
2850 
2851  const FunctionType& f(static_cast<const FunctionType&>(f_));
2852 
2853  typedef UnaryGridFunctionExpression<LogOperation, FunctionType> ExpressionType;
2854 
2855  return ExpressionType(f);
2856  }
2857 
2859  //
2860  // Component-wise square-root
2861 
2863  template<class Function>
2864  static inline
2865  UnaryGridFunctionExpression<SqrtOperation, Function>
2866  sqrt(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2867  {
2868  typedef Function FunctionType;
2869 
2870  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2871  "Operand must be a GridFunction");
2872 
2873  const FunctionType& f(static_cast<const FunctionType&>(f_));
2874 
2875  typedef UnaryGridFunctionExpression<SqrtOperation, FunctionType> ExpressionType;
2876 
2877  return ExpressionType(f);
2878  }
2879 
2881  template<class Function>
2882  static inline
2883  UnaryGridFunctionExpression<SquareOperation, Function>
2884  sqr(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2885  {
2886  typedef Function FunctionType;
2887 
2888  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2889  "Operand must be a GridFunction");
2890 
2891  const FunctionType& f(static_cast<const FunctionType&>(f_));
2892 
2893  typedef UnaryGridFunctionExpression<SquareOperation, FunctionType> ExpressionType;
2894 
2895  return ExpressionType(f);
2896  }
2897 
2899  //
2900  // Component-wise sin
2901 
2903  template<class Function>
2904  static inline
2905  UnaryGridFunctionExpression<SinOperation, Function>
2906  sin(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2907  {
2908  typedef Function FunctionType;
2909 
2910  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2911  "Operand must be a GridFunction");
2912 
2913  const FunctionType& f(static_cast<const FunctionType&>(f_));
2914 
2915  typedef UnaryGridFunctionExpression<SinOperation, FunctionType> ExpressionType;
2916 
2917  return ExpressionType(f);
2918  }
2919 
2921  //
2922  // Component-wise cos
2923 
2925  template<class Function>
2926  static inline
2927  UnaryGridFunctionExpression<CosOperation, Function>
2928  cos(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2929  {
2930  typedef Function FunctionType;
2931 
2932  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2933  "Operand must be a GridFunction");
2934 
2935  const FunctionType& f(static_cast<const FunctionType&>(f_));
2936 
2937  typedef UnaryGridFunctionExpression<CosOperation, FunctionType> ExpressionType;
2938 
2939  return ExpressionType(f);
2940  }
2941 
2943  //
2944  // Component-wise tan
2945 
2947  template<class Function>
2948  static inline
2949  UnaryGridFunctionExpression<TanOperation, Function>
2950  tan(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2951  {
2952  typedef Function FunctionType;
2953 
2954  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2955  "Operand must be a GridFunction");
2956 
2957  const FunctionType& f(static_cast<const FunctionType&>(f_));
2958 
2959  typedef UnaryGridFunctionExpression<TanOperation, FunctionType> ExpressionType;
2960 
2961  return ExpressionType(f);
2962  }
2963 
2965  //
2966  // Component-wise arctan
2967 
2969  template<class Function>
2970  static inline
2971  UnaryGridFunctionExpression<AtanOperation, Function>
2972  atan(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2973  {
2974  typedef Function FunctionType;
2975 
2976  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2977  "Operand must be a GridFunction");
2978 
2979  const FunctionType& f(static_cast<const FunctionType&>(f_));
2980 
2981  typedef UnaryGridFunctionExpression<AtanOperation, FunctionType> ExpressionType;
2982 
2983  return ExpressionType(f);
2984  }
2985 
2987  //
2988  // Component-wise arcsin
2989 
2991  template<class Function>
2992  static inline
2993  UnaryGridFunctionExpression<AsinOperation, Function>
2994  asin(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
2995  {
2996  typedef Function FunctionType;
2997 
2998  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
2999  "Operand must be a GridFunction");
3000 
3001  const FunctionType& f(static_cast<const FunctionType&>(f_));
3002 
3003  typedef UnaryGridFunctionExpression<AsinOperation, FunctionType> ExpressionType;
3004 
3005  return ExpressionType(f);
3006  }
3007 
3009  //
3010  // Component-wise arccos
3011 
3013  template<class Function>
3014  static inline
3015  UnaryGridFunctionExpression<AcosOperation, Function>
3016  acos(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
3017  {
3018  typedef Function FunctionType;
3019 
3020  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
3021  "Operand must be a GridFunction");
3022 
3023  const FunctionType& f(static_cast<const FunctionType&>(f_));
3024 
3025  typedef UnaryGridFunctionExpression<AcosOperation, FunctionType> ExpressionType;
3026 
3027  return ExpressionType(f);
3028  }
3029 
3040  template<class FunctionSpace, class Expression>
3041  static inline
3042  Expression
3043  operator*(const GridFunctionExpression<FunctionSpace, Expression>& f_)
3044  {
3045  return f_.expression();
3046  }
3047 
3049  template<class FunctionSpace, class GridPart>
3050  static inline
3051  ZeroGridFunction<FunctionSpace, GridPart>
3052  operator*(const ZeroGridFunction<FunctionSpace, GridPart>& f_)
3053  {
3054  return f_;
3055  }
3056 
3063  template<class F>
3064  static inline
3065  auto operator-(const UnaryGridFunctionExpression<MinusOperation, F>& expr)
3066  -> decltype(+expr.function())
3067  {
3068  return +expr.function();
3069  };
3070 
3072  template<class F1, class F2>
3073  static inline
3074  auto operator-(const BinaryGridFunctionExpression<MinusOperation, F1, F2>& expr)
3075  -> decltype(expr.rightFunction() - expr.leftFunction())
3076  {
3077  return expr.rightFunction() - expr.leftFunction();
3078  };
3079 
3081  template<class F1, class F2>
3082  static inline
3083  auto operator-(const BinaryGridFunctionExpression<PlusOperation,
3084  UnaryGridFunctionExpression<MinusOperation, F1>, F2>& expr)
3085  -> decltype(expr.leftFunction().function() - expr.rightFunction())
3086  {
3087  return expr.leftFunction().function() - expr.rightFunction();
3088  };
3089 
3091 
3092 
3099  template<class Field, class Function>
3100  static inline
3101  auto operator*(const Field& s_,
3102  const Fem::Function<typename Function::FunctionSpaceType,
3103  BinaryGridFunctionExpression<SMultiplyOperation, Field, Function> >& f_)
3104  -> decltype((s_ * asImp(f_).scalar()) * asImp(f_).function())
3105  {
3106  return (s_ * asImp(f_).scalar()) * asImp(f_).function();
3107  }
3108 
3110  template<class Field, class Function1, class Function2>
3111  static inline
3112  auto operator*(const Fem::Function<typename Function1::FunctionSpaceType,
3113  BinaryGridFunctionExpression<SMultiplyOperation, Field, Function1> >& f1_,
3114  const Fem::Function<typename Function2::FunctionSpaceType, Function2>& f2_)
3115  -> decltype(asImp(f1_).scalar() * (asImp(f1_).function() * asImp(f2_)))
3116  {
3117  return asImp(f1_).scalar() * (asImp(f1_).function() * asImp(f2_));
3118  }
3119 
3121  template<class Field, class Function1, class Function2>
3122  static inline
3123  auto operator*(const Fem::Function<typename Function1::FunctionSpaceType, Function1>& f1_,
3124  const Fem::Function<typename Function2::FunctionSpaceType,
3125  BinaryGridFunctionExpression<SMultiplyOperation, Field, Function2> >& f2_)
3126  -> decltype(asImp(f2_).scalar() * (asImp(f1_) * asImp(f2_).function()))
3127  {
3128  return asImp(f2_).scalar() * (asImp(f1_) * asImp(f2_).function());
3129  }
3130 
3132  template<class Field1, class Field2, class Function1, class Function2>
3133  static inline
3134  auto operator*(const Fem::Function<typename Function1::FunctionSpaceType,
3135  BinaryGridFunctionExpression<SMultiplyOperation, Field1, Function1> >& f1_,
3136  const Fem::Function<typename Function2::FunctionSpaceType,
3137  BinaryGridFunctionExpression<SMultiplyOperation, Field2, Function2> >& f2_)
3138  -> decltype((asImp(f1_).scalar() * asImp(f2_).scalar()) * (asImp(f1_).function() * asImp(f2_).function()))
3139  {
3140  return (asImp(f1_).scalar() * asImp(f2_).scalar()) * (asImp(f1_).function() * asImp(f2_).function());
3141  }
3142 
3144  template<class Parameter, class Function>
3145  static inline
3146  auto operator*(const ParameterInterface<Parameter>& p_,
3147  const Fem::Function<typename Function::FunctionSpaceType,
3148  BinaryGridFunctionExpression<SMultiplyOperation, typename Function::RangeFieldType, Function> >& f_)
3149  -> decltype(asImp(f_).scalar() * (asImp(p_) * asImp(f_).function()))
3150  {
3151  return asImp(f_).scalar() * (asImp(p_) * asImp(f_).function());
3152  }
3153 
3155  template<class Field, class Parameter, class Function>
3156  static inline
3157  auto operator*(const BinaryParameterExpression<SMultiplyOperation, Field, Parameter>& p_,
3158  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
3159  -> decltype(p_.left() * (p_.right() * asImp(f_)))
3160  {
3161  return p_.left() * (p_.right() * asImp(f_));
3162  }
3163 
3167  template<class Parameter, class ZeroExpression>
3168  static inline
3169  ZeroExpression
3170  operator*(const BinaryParameterExpression<SMultiplyOperation, typename ZeroExpression::RangeFieldType, Parameter>& p_,
3171  const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_)
3172  {
3173  return *z_;
3174  }
3175 
3177 
3183  template<class ZeroExpression>
3184  static inline
3185  ZeroExpression
3186  operator*(const typename ZeroExpression::RangeFieldType& s,
3187  const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z)
3188  {
3189  return *z;
3190  }
3191 
3193  template<class Parameter, class ZeroExpression>
3194  static inline
3195  ZeroExpression
3196  operator*(const ParameterInterface<Parameter>& s_,
3197  const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z)
3198  {
3199  return *z;
3200  }
3201 
3203  template<class Function, class ZeroExpression>
3204  static inline
3205  auto
3206  operator*(const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_,
3207  const Fem::Function<typename Function::FunctionSpaceType, Function>& g_)
3208  -> decltype(zeroProduct(*z_, g_))
3209  {
3210  return zeroProduct(*z_, g_);
3211  }
3212 
3214  template<class Function, class ZeroExpression>
3215  static inline
3216  auto
3217  operator*(const Fem::Function<typename Function::FunctionSpaceType, Function>& g_,
3218  const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_)
3219  -> decltype(z_ * g_)
3220  {
3221  return z_ * g_;
3222  }
3223 
3225  template<class ZeroExpression1, class ZeroExpression2>
3226  static inline
3227  auto
3228  operator*(const ZeroGridFunctionExpression<typename ZeroExpression1::FunctionSpaceType, ZeroExpression1>& z1,
3229  const ZeroGridFunctionExpression<typename ZeroExpression2::FunctionSpaceType, ZeroExpression2>& z2)
3230  -> decltype(zeroProduct(*z1, z2))
3231  {
3232  return zeroProduct(*z1, z2);
3233  }
3234 
3237  template<class Function, class ZeroExpression>
3238  static inline
3239  auto
3240  operator+(const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_,
3241  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
3242  -> decltype(*asImp(f_))
3243  {
3244  typedef Function FunctionType;
3245 
3246  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
3247  "Operand must be a GridFunction");
3248  // should also assert same space, maybe
3249 
3250  return *asImp(f_);
3251  }
3252 
3255  template<class Function, class ZeroExpression>
3256  static inline
3257  auto
3258  operator+(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
3259  const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_)
3260  -> decltype(*asImp(f_))
3261  {
3262  typedef Function FunctionType;
3263 
3264  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
3265  "Operand must be a GridFunction");
3266 
3267  return *asImp(f_);
3268  }
3269 
3272  template<class ZeroExpression1, class ZeroExpression2>
3273  static inline
3274  ZeroExpression1
3275  operator+(const ZeroGridFunctionExpression<typename ZeroExpression1::FunctionSpaceType, ZeroExpression1>& z1_,
3276  const ZeroGridFunctionExpression<typename ZeroExpression2::FunctionSpaceType, ZeroExpression2>& z2_)
3277  {
3278  return *z1_; // just choose one
3279  }
3280 
3283  template<class Function, class ZeroExpression>
3284  static inline
3285  auto
3286  operator-(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
3287  const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_)
3288  -> decltype(*asImp(f_))
3289  {
3290  typedef Function FunctionType;
3291 
3292  static_assert(std::is_base_of<Fem::HasLocalFunction, FunctionType>::value,
3293  "Operand must be a GridFunction");
3294 
3295  return *asImp(f_);
3296  }
3297 
3300  template<class Function, class ZeroExpression>
3301  static inline
3302  auto
3303  operator-(const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_,
3304  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
3305  -> decltype(-asImp(f_))
3306  {
3307  return -asImp(f_);
3308  }
3309 
3313  template<class ZeroExpression1, class ZeroExpression2>
3314  static inline
3315  ZeroExpression1
3316  operator-(const ZeroGridFunctionExpression<typename ZeroExpression1::FunctionSpaceType, ZeroExpression1>& z1_,
3317  const ZeroGridFunctionExpression<typename ZeroExpression2::FunctionSpaceType, ZeroExpression2>& z2_)
3318  {
3319  return *z1_; // just choose one
3320  }
3321 
3323  template<class ZeroExpression>
3324  static inline
3325  ZeroExpression
3326  operator-(const ZeroGridFunctionExpression<typename ZeroExpression::FunctionSpaceType, ZeroExpression>& z_)
3327  {
3328  return *z_;
3329  }
3330 
3332 
3340  template<class Function>
3341  static inline
3342  auto operator*(const decltype(oneFunction(std::declval<Function>()))& one,
3343  const Fem::Function<typename Function::FunctionSpaceType, Function>& f_)
3344  -> decltype(*asImp(f_))
3345  {
3346  return *asImp(f_);
3347  }
3348 
3349  template<class Function>
3350  static inline
3351  auto operator*(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
3352  const decltype(oneFunction(std::declval<Function>()))& one)
3353  -> decltype(*asImp(f_))
3354  {
3355  return *asImp(f_);
3356  }
3357 
3358  template<class FunctionSpace, class GridPart>
3359  static inline
3360  FractionGridFunction<typename FunctionSpace::ScalarFunctionSpaceType, GridPart, 1L, 1UL>
3361  operator*(const FractionGridFunction<FunctionSpace, GridPart, 1L, 1UL>& l,
3362  const FractionGridFunction<FunctionSpace, GridPart, 1L, 1UL>& r)
3363  {
3364  typedef
3365  FractionGridFunction<typename FunctionSpace::ScalarFunctionSpaceType, GridPart, 1L, 1UL>
3366  ExpressionType;
3367 
3368  return ExpressionType(l.gridPart());
3369  }
3370 
3371  template<class Function>
3372  static inline
3373  auto operator/(const Fem::Function<typename Function::FunctionSpaceType, Function>& f_,
3374  const decltype(oneFunction(std::declval<Function>()))& one)
3375  -> decltype(*asImp(f_))
3376  {
3377  return *asImp(f_);
3378  }
3379 
3380  template<class FunctionSpace, class GridPart>
3381  static inline
3382  FractionGridFunction<typename FunctionSpace::ScalarFunctionSpaceType, GridPart, 1L, 1UL>
3383  operator/(const FractionGridFunction<FunctionSpace, GridPart, 1L, 1UL>& l,
3384  const FractionGridFunction<FunctionSpace, GridPart, 1L, 1UL>& r)
3385  {
3386  typedef
3387  FractionGridFunction<typename FunctionSpace::ScalarFunctionSpaceType, GridPart, 1L, 1UL>
3388  ExpressionType;
3389 
3390  return ExpressionType(l.gridPart());
3391  }
3392 
3394 
3396 
3398 
3400 
3401  } // namespace ACFem
3402 
3403  namespace Fem {
3404  using ACFem::operator+;
3405  using ACFem::operator-;
3406  using ACFem::operator*;
3407  using ACFem::operator/;
3408  }
3409 
3410 } // namespace Dune
3411 
3412 #endif // __DUNE_ACFEM_GRIDFUNCTIONEXPRESSION_HH__
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction
General local function object for binary grid-function expressions.
Definition: gridfunctionexpression.hh:613
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::intersection
const IntersectionType & intersection() const
Definition: gridfunctionexpression.hh:769
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::LocalFunction
LocalFunction(const EntityType &entity, const DiscreteFunctionType &df)
constructor initializing local function
Definition: gridfunctionexpression.hh:649
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::LocalFunction
LocalFunction(const EntityType &entity, const IntersectionType &intersection, const DiscreteFunctionType &df)
Construct from intersection.
Definition: gridfunctionexpression.hh:741
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::FunctionSpaceType
DiscreteFunctionSpaceType::FunctionSpaceType FunctionSpaceType
function space type
Definition: gridfunctionexpression.hh:633
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::HessianRangeType
DiscreteFunctionSpaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: gridfunctionexpression.hh:646
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::DomainType
DiscreteFunctionSpaceType::DomainType DomainType
domain type (from function space)
Definition: gridfunctionexpression.hh:640
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::order
int order() const
Return a bound on or suggestion for the piece-wise polynomial order.
Definition: gridfunctionexpression.hh:711
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::init
void init(const EntityType &entity, const IntersectionType &intersection)
Definition: gridfunctionexpression.hh:754
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::entity
const EntityType & entity() const
Return a reference to the currently active entity.
Definition: gridfunctionexpression.hh:723
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::supported
bool supported() const
Construct from intersection.
Definition: gridfunctionexpression.hh:776
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::JacobianRangeType
DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: gridfunctionexpression.hh:644
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::init
void init(const EntityType &entity)
init local function
Definition: gridfunctionexpression.hh:714
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::evaluateQuadrature
void evaluateQuadrature(const QuadratureType &quadrature, VectorType &values) const
evaluate function or jacobian of function for given quadrature
Definition: gridfunctionexpression.hh:704
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::evaluate
void evaluate(const PointType &x, RangeType &ret) const
evaluate local function
Definition: gridfunctionexpression.hh:671
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::hessian
void hessian(const PointType &x, HessianRangeType &ret) const
hessian of local function
Definition: gridfunctionexpression.hh:693
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::jacobian
void jacobian(const PointType &x, JacobianRangeType &ret) const
jacobian of local function
Definition: gridfunctionexpression.hh:682
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::DomainFieldType
DiscreteFunctionSpaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: gridfunctionexpression.hh:636
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::RangeType
DiscreteFunctionSpaceType::RangeType RangeType
range type (from function space)
Definition: gridfunctionexpression.hh:642
Dune::ACFem::BinaryGridFunctionExpression::LocalFunction::RangeFieldType
DiscreteFunctionSpaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: gridfunctionexpression.hh:638
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >
S-multiplication with RangeFieldType scalars.
Definition: gridfunctionexpression.hh:869
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::localFunction
LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection)
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:1029
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::hessian
void hessian(const DomainType &global, HessianRangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:968
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::JacobianRangeType
DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: gridfunctionexpression.hh:918
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::DiscreteFunctionSpaceType
TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
type of discrete function space
Definition: gridfunctionexpression.hh:898
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::TraitsType
BinaryGridFunctionExpressionTraits< SMultiplyOperation, Factor, ContainedFunctionType > TraitsType
type of traits
Definition: gridfunctionexpression.hh:887
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::FactorType
Factor FactorType
type of factor
Definition: gridfunctionexpression.hh:877
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::GridPartType
DiscreteFunctionSpaceType::GridPartType GridPartType
type of gridPart
Definition: gridfunctionexpression.hh:904
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::RangeFieldType
DiscreteFunctionSpaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: gridfunctionexpression.hh:912
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::DomainFieldType
DiscreteFunctionSpaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: gridfunctionexpression.hh:910
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::space
const DiscreteFunctionSpaceType & space() const
See Fem::DiscreteFunctionInterface::space() const.
Definition: gridfunctionexpression.hh:1004
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::localFunction
const LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection) const
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:1022
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::localFunction
const LocalFunctionType localFunction(const EntityType &entity) const
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity) const.
Definition: gridfunctionexpression.hh:981
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::jacobian
void jacobian(const DomainType &global, JacobianRangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:957
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::DiscreteFunctionType
ThisType DiscreteFunctionType
type of discrete function (self)
Definition: gridfunctionexpression.hh:895
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::GridType
DiscreteFunctionSpaceType::GridType GridType
type of grid
Definition: gridfunctionexpression.hh:907
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::DomainType
DiscreteFunctionSpaceType::DomainType DomainType
domain type (from function space)
Definition: gridfunctionexpression.hh:914
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::IndicatorType
BoundaryFunctionTraits< ContainedFunctionType >::IndicatorType IndicatorType
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:1013
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::RangeType
DiscreteFunctionSpaceType::RangeType RangeType
range type (from function space)
Definition: gridfunctionexpression.hh:916
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::evaluate
void evaluate(const DomainType &global, RangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:950
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::ContainedFunctionType
Function ContainedFunctionType
type of function
Definition: gridfunctionexpression.hh:884
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::localFunction
LocalFunctionType localFunction(const EntityType &entity)
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)
Definition: gridfunctionexpression.hh:987
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::HessianRangeType
DiscreteFunctionSpaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: gridfunctionexpression.hh:920
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::EntityType
TraitsType::EntityType EntityType
type of codim 0 entity
Definition: gridfunctionexpression.hh:923
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::LocalFunctionType
LocalFunction LocalFunctionType
type of local function to export
Definition: gridfunctionexpression.hh:933
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::expressionName
const std::string & expressionName() const
See Fem::DiscreteFunctionInterface::name() const.
Definition: gridfunctionexpression.hh:993
Dune::ACFem::BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >::indicator
IndicatorType indicator() const
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:1036
Dune::ACFem::BinaryGridFunctionExpression
BinaryGridFunctionExpression implements point-wise vector-space operations for GridFunction-types.
Definition: gridfunctionexpression.hh:423
Dune::ACFem::BinaryGridFunctionExpression::DomainFieldType
DiscreteFunctionSpaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: gridfunctionexpression.hh:460
Dune::ACFem::BinaryGridFunctionExpression::space
const DiscreteFunctionSpaceType & space() const
See Fem::DiscreteFunctionInterface::space() const.
Definition: gridfunctionexpression.hh:550
Dune::ACFem::BinaryGridFunctionExpression::evaluate
void evaluate(const DomainType &global, RangeType &result) const
evaluate function at global coordinates
Definition: gridfunctionexpression.hh:504
Dune::ACFem::BinaryGridFunctionExpression::HessianRangeType
DiscreteFunctionSpaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: gridfunctionexpression.hh:470
Dune::ACFem::BinaryGridFunctionExpression::TraitsType
BinaryGridFunctionExpressionTraits< BinOp, LeftFunctionType, RightFunctionType > TraitsType
type of traits
Definition: gridfunctionexpression.hh:428
Dune::ACFem::BinaryGridFunctionExpression::IntersectionType
GridPartType::IntersectionType IntersectionType
type of intersection
Definition: gridfunctionexpression.hh:476
Dune::ACFem::BinaryGridFunctionExpression::localFunction
const LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection) const
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)> const.
Definition: gridfunctionexpression.hh:575
Dune::ACFem::BinaryGridFunctionExpression::hessian
void hessian(const DomainType &global, HessianRangeType &result) const
hessian at global coordinates
Definition: gridfunctionexpression.hh:521
Dune::ACFem::BinaryGridFunctionExpression::GridType
DiscreteFunctionSpaceType::GridType GridType
type of grid
Definition: gridfunctionexpression.hh:453
Dune::ACFem::BinaryGridFunctionExpression::EntityType
TraitsType::EntityType EntityType
type of codim 0 entity
Definition: gridfunctionexpression.hh:473
Dune::ACFem::BinaryGridFunctionExpression::JacobianRangeType
DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: gridfunctionexpression.hh:468
Dune::ACFem::BinaryGridFunctionExpression::DiscreteFunctionSpaceType
TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
type of discrete function space
Definition: gridfunctionexpression.hh:444
Dune::ACFem::BinaryGridFunctionExpression::IndicatorType
TraitsType::IndicatorType IndicatorType
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:565
Dune::ACFem::BinaryGridFunctionExpression::DiscreteFunctionType
ThisType DiscreteFunctionType
type of discrete function (self)
Definition: gridfunctionexpression.hh:441
Dune::ACFem::BinaryGridFunctionExpression::BinaryGridFunctionExpression
BinaryGridFunctionExpression(const LeftFunctionType &f, const RightFunctionType &g)
Constructor.
Definition: gridfunctionexpression.hh:489
Dune::ACFem::BinaryGridFunctionExpression::localFunction
const LocalFunctionType localFunction(const EntityType &entity) const
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)> const.
Definition: gridfunctionexpression.hh:531
Dune::ACFem::BinaryGridFunctionExpression::RangeType
DiscreteFunctionSpaceType::RangeType RangeType
range type (from function space)
Definition: gridfunctionexpression.hh:466
Dune::ACFem::BinaryGridFunctionExpression::localFunction
LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection)
See Fem::DiscreteFunctionInterface::localFunction(const IntersectionType &intersection)
Definition: gridfunctionexpression.hh:583
Dune::ACFem::BinaryGridFunctionExpression::GridPartType
DiscreteFunctionSpaceType::GridPartType GridPartType
type of gridPart
Definition: gridfunctionexpression.hh:450
Dune::ACFem::BinaryGridFunctionExpression::expressionName
const std::string & expressionName() const
See Fem::DiscreteFunctionInterface::name() const.
Definition: gridfunctionexpression.hh:543
Dune::ACFem::BinaryGridFunctionExpression::LocalFunctionType
LocalFunction LocalFunctionType
type of local function to export
Definition: gridfunctionexpression.hh:486
Dune::ACFem::BinaryGridFunctionExpression::localFunction
LocalFunctionType localFunction(const EntityType &entity)
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)
Definition: gridfunctionexpression.hh:537
Dune::ACFem::BinaryGridFunctionExpression::indicator
IndicatorType indicator() const
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:589
Dune::ACFem::BinaryGridFunctionExpression::DomainType
DiscreteFunctionSpaceType::DomainType DomainType
domain type (from function space)
Definition: gridfunctionexpression.hh:464
Dune::ACFem::BinaryGridFunctionExpression::emptySupport
@ emptySupport
Definition: gridfunctionexpression.hh:569
Dune::ACFem::BinaryGridFunctionExpression::globalSupport
@ globalSupport
Definition: gridfunctionexpression.hh:571
Dune::ACFem::BinaryGridFunctionExpression::RangeFieldType
DiscreteFunctionSpaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: gridfunctionexpression.hh:462
Dune::ACFem::BinaryGridFunctionExpression::jacobian
void jacobian(const DomainType &global, JacobianRangeType &result) const
jacobian at global coordinates
Definition: gridfunctionexpression.hh:510
Dune::ACFem::ConstantGridFunction
ConstantGridFunction implements a constant function.
Definition: constantfunction.hh:108
Dune::ACFem::FractionGridFunction
A grid-function which is constant with a scalar fractional value.
Definition: constantfunction.hh:598
Dune::ACFem::GridFunctionExpression
A class providing some basic functionality common to all expressions.
Definition: gridfunctionexpressionbase.hh:35
Dune::ACFem::ParameterGridFunction
ParameterGridFunction implements a constant function where the value is defined by something which fu...
Definition: parameterfunction.hh:112
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::UnaryGridFunctionExpression< IdentityOperation, FunctionType >
Specialize for the identity wrapper operation.
Definition: gridfunctionexpression.hh:1668
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::DiscreteFunctionSpaceType
TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
type of discrete function space
Definition: gridfunctionexpression.hh:1689
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::space
const DiscreteFunctionSpaceType & space() const
See Fem::DiscreteFunctionInterface::space() const.
Definition: gridfunctionexpression.hh:1784
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::GridType
DiscreteFunctionSpaceType::GridType GridType
type of grid
Definition: gridfunctionexpression.hh:1698
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::DomainType
DiscreteFunctionSpaceType::DomainType DomainType
domain type (from function space)
Definition: gridfunctionexpression.hh:1705
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::localFunction
LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection)
See Fem::DiscreteFunctionInterface::localFunction(const IntersectionType &intersection)
Definition: gridfunctionexpression.hh:1811
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::HessianRangeType
DiscreteFunctionSpaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: gridfunctionexpression.hh:1711
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::GridPartType
DiscreteFunctionSpaceType::GridPartType GridPartType
type of gridPart
Definition: gridfunctionexpression.hh:1695
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::localFunction
const LocalFunctionType localFunction(const EntityType &entity) const
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity) const.
Definition: gridfunctionexpression.hh:1765
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::localFunction
LocalFunctionType localFunction(const EntityType &entity)
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)
Definition: gridfunctionexpression.hh:1771
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::indicator
IndicatorType indicator() const
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:1818
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::hessian
void hessian(const DomainType &global, HessianRangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:1755
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::LocalFunctionType
LocalFunction LocalFunctionType
type of local function to export
Definition: gridfunctionexpression.hh:1724
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::localFunction
const LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection) const
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)> const.
Definition: gridfunctionexpression.hh:1803
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::IndicatorType
BoundaryFunctionTraits< FunctionType >::IndicatorType IndicatorType
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:1793
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::RangeType
DiscreteFunctionSpaceType::RangeType RangeType
range type (from function space)
Definition: gridfunctionexpression.hh:1707
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::evaluate
void evaluate(const DomainType &global, RangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:1739
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::TraitsType
UnaryGridFunctionExpressionTraits< OperationTagType, FunctionType > TraitsType
type of traits
Definition: gridfunctionexpression.hh:1676
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::expressionName
const std::string & expressionName() const
See Fem::DiscreteFunctionInterface::name() const.
Definition: gridfunctionexpression.hh:1777
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::RangeFieldType
DiscreteFunctionSpaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: gridfunctionexpression.hh:1703
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::EntityType
TraitsType::EntityType EntityType
type of codim 0 entity
Definition: gridfunctionexpression.hh:1714
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::JacobianRangeType
DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: gridfunctionexpression.hh:1709
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::jacobian
void jacobian(const DomainType &global, JacobianRangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:1745
Dune::ACFem::UnaryGridFunctionExpression< IdentityOperation, FunctionType >::DomainFieldType
DiscreteFunctionSpaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: gridfunctionexpression.hh:1701
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >
For the sake of BoundarySupportedFunction we need to specialize the InvertOperation.
Definition: gridfunctionexpression.hh:2008
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::hessian
void hessian(const DomainType &global, HessianRangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:2095
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::RangeFieldType
DiscreteFunctionSpaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: gridfunctionexpression.hh:2043
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::localFunction
const LocalFunctionType localFunction(const EntityType &entity) const
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity) const.
Definition: gridfunctionexpression.hh:2105
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::DomainFieldType
DiscreteFunctionSpaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: gridfunctionexpression.hh:2041
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::space
const DiscreteFunctionSpaceType & space() const
See Fem::DiscreteFunctionInterface::space() const.
Definition: gridfunctionexpression.hh:2124
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::JacobianRangeType
DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: gridfunctionexpression.hh:2049
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::GridType
DiscreteFunctionSpaceType::GridType GridType
type of grid
Definition: gridfunctionexpression.hh:2038
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::EntityType
TraitsType::EntityType EntityType
type of codim 0 entity
Definition: gridfunctionexpression.hh:2054
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::TraitsType
UnaryGridFunctionExpressionTraits< OperationTagType, FunctionType > TraitsType
type of traits
Definition: gridfunctionexpression.hh:2016
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::localFunction
LocalFunctionType localFunction(const EntityType &entity)
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)
Definition: gridfunctionexpression.hh:2111
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::localFunction
const LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection) const
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)> const.
Definition: gridfunctionexpression.hh:2143
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::localFunction
LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection)
See Fem::DiscreteFunctionInterface::localFunction(const IntersectionType &intersection)
Definition: gridfunctionexpression.hh:2151
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::DiscreteFunctionSpaceType
TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
type of discrete function space
Definition: gridfunctionexpression.hh:2029
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::indicator
IndicatorType indicator() const
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:2158
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::LocalFunctionType
LocalFunction LocalFunctionType
type of local function to export
Definition: gridfunctionexpression.hh:2064
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::IndicatorType
EntireBoundaryIndicatorType IndicatorType
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:2133
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::RangeType
DiscreteFunctionSpaceType::RangeType RangeType
range type (from function space)
Definition: gridfunctionexpression.hh:2047
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::expressionName
const std::string & expressionName() const
See Fem::DiscreteFunctionInterface::name() const.
Definition: gridfunctionexpression.hh:2117
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::evaluate
void evaluate(const DomainType &global, RangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:2079
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::DomainType
DiscreteFunctionSpaceType::DomainType DomainType
domain type (from function space)
Definition: gridfunctionexpression.hh:2045
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::jacobian
void jacobian(const DomainType &global, JacobianRangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:2085
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::GridPartType
DiscreteFunctionSpaceType::GridPartType GridPartType
type of gridPart
Definition: gridfunctionexpression.hh:2035
Dune::ACFem::UnaryGridFunctionExpression< InvertOperation, FunctionType >::HessianRangeType
DiscreteFunctionSpaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: gridfunctionexpression.hh:2051
Dune::ACFem::UnaryGridFunctionExpression
UnaryGridFunctionExpression implements point-wise unary operations for GridFunction-types.
Definition: gridfunctionexpression.hh:1328
Dune::ACFem::UnaryGridFunctionExpression::JacobianRangeType
DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType
jacobian type (from function space)
Definition: gridfunctionexpression.hh:1371
Dune::ACFem::UnaryGridFunctionExpression::localFunction
LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection)
See Fem::DiscreteFunctionInterface::localFunction(const IntersectionType &intersection)
Definition: gridfunctionexpression.hh:1473
Dune::ACFem::UnaryGridFunctionExpression::GridType
DiscreteFunctionSpaceType::GridType GridType
type of grid
Definition: gridfunctionexpression.hh:1360
Dune::ACFem::UnaryGridFunctionExpression::DiscreteFunctionType
ThisType DiscreteFunctionType
export DiscreteFunctionType
Definition: gridfunctionexpression.hh:1348
Dune::ACFem::UnaryGridFunctionExpression::TraitsType
UnaryGridFunctionExpressionTraits< UnOp, FunctionType > TraitsType
type of traits
Definition: gridfunctionexpression.hh:1331
Dune::ACFem::UnaryGridFunctionExpression::space
const DiscreteFunctionSpaceType & space() const
See Fem::DiscreteFunctionInterface::space() const.
Definition: gridfunctionexpression.hh:1446
Dune::ACFem::UnaryGridFunctionExpression::evaluate
void evaluate(const DomainType &global, RangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:1401
Dune::ACFem::UnaryGridFunctionExpression::localFunction
LocalFunctionType localFunction(const EntityType &entity)
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)
Definition: gridfunctionexpression.hh:1433
Dune::ACFem::UnaryGridFunctionExpression::RangeType
DiscreteFunctionSpaceType::RangeType RangeType
range type (from function space)
Definition: gridfunctionexpression.hh:1369
Dune::ACFem::UnaryGridFunctionExpression::globalSupport
@ globalSupport
Definition: gridfunctionexpression.hh:1461
Dune::ACFem::UnaryGridFunctionExpression::emptySupport
@ emptySupport
Definition: gridfunctionexpression.hh:1459
Dune::ACFem::UnaryGridFunctionExpression::RangeFieldType
DiscreteFunctionSpaceType::RangeFieldType RangeFieldType
range type (from function space)
Definition: gridfunctionexpression.hh:1365
Dune::ACFem::UnaryGridFunctionExpression::hessian
void hessian(const DomainType &global, HessianRangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:1417
Dune::ACFem::UnaryGridFunctionExpression::GridPartType
DiscreteFunctionSpaceType::GridPartType GridPartType
type of gridPart
Definition: gridfunctionexpression.hh:1357
Dune::ACFem::UnaryGridFunctionExpression::EntityType
TraitsType::EntityType EntityType
type of codim 0 entity
Definition: gridfunctionexpression.hh:1376
Dune::ACFem::UnaryGridFunctionExpression::DomainType
DiscreteFunctionSpaceType::DomainType DomainType
domain type (from function space)
Definition: gridfunctionexpression.hh:1367
Dune::ACFem::UnaryGridFunctionExpression::DomainFieldType
DiscreteFunctionSpaceType::DomainFieldType DomainFieldType
domain type (from function space)
Definition: gridfunctionexpression.hh:1363
Dune::ACFem::UnaryGridFunctionExpression::IndicatorType
BoundaryFunctionTraits< FunctionType >::IndicatorType IndicatorType
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:1455
Dune::ACFem::UnaryGridFunctionExpression::jacobian
void jacobian(const DomainType &global, JacobianRangeType &result) const
evaluate function on local coordinate local
Definition: gridfunctionexpression.hh:1407
Dune::ACFem::UnaryGridFunctionExpression::indicator
IndicatorType indicator() const
Resulting Boundary indicator type.
Definition: gridfunctionexpression.hh:1480
Dune::ACFem::UnaryGridFunctionExpression::DiscreteFunctionSpaceType
TraitsType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
type of discrete function space
Definition: gridfunctionexpression.hh:1351
Dune::ACFem::UnaryGridFunctionExpression::localFunction
const LocalFunctionType localFunction(const EntityType &entity, const IntersectionType &intersection) const
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity)> const.
Definition: gridfunctionexpression.hh:1465
Dune::ACFem::UnaryGridFunctionExpression::LocalFunctionType
LocalFunction LocalFunctionType
type of local function to export
Definition: gridfunctionexpression.hh:1386
Dune::ACFem::UnaryGridFunctionExpression::expressionName
const std::string & expressionName() const
See Fem::DiscreteFunctionInterface::name() const.
Definition: gridfunctionexpression.hh:1439
Dune::ACFem::UnaryGridFunctionExpression::localFunction
const LocalFunctionType localFunction(const EntityType &entity) const
See Fem::DiscreteFunctionInterface::localFunction(const EntityType &entity) const.
Definition: gridfunctionexpression.hh:1427
Dune::ACFem::UnaryGridFunctionExpression::HessianRangeType
DiscreteFunctionSpaceType::HessianRangeType HessianRangeType
hessian type (from function space)
Definition: gridfunctionexpression.hh:1373
Dune::ACFem::ZeroGridFunctionExpression
A base class for zero function expression.
Definition: gridfunctionexpressionbase.hh:110
Dune::ACFem::ZeroGridFunction
A grid-function always returning 0.
Definition: constantfunction.hh:352
Dune::ACFem::operator/
static auto operator/(const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(asEssBndryFct(f_/asExprArg(g_))))
f / Wrapped(g) = Wrapped(f / g)
Definition: boundaryfunctionexpression.hh:657
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::constantFunction
auto constantFunction(const Fem::Function< typename F::FunctionSpaceType, F > &f_, const typename F::FunctionSpaceType::RangeType &c) -> ConstantGridFunction< typename F::FunctionSpaceType, typename F::GridPartType >
Generate a ConstantGridFunction on the same function space.
Definition: gridfunctionexpression.hh:191
Dune::ACFem::oneFunction
FractionGridFunction< typename FunctionSpace::FunctionSpaceType::ScalarFunctionSpaceType, GridPart, 1L, 1UL > oneFunction(const FunctionSpace &space, const GridPart &gridPart)
Generate a proper constant-one function from the given Fem::FunctionSpace and Fem::GridPart.
Definition: gridfunctionexpression.hh:157
Dune::ACFem::log
static UnaryGridFunctionExpression< LogOperation, Function > log(const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
Component-wise logarithm, log(f)(x) = [log(f(x)_0),...,log(f(x)_N].
Definition: gridfunctionexpression.hh:2844
Dune::ACFem::zeroFunction
auto zeroFunction(const Fem::Function< typename F::FunctionSpaceType, F > &f_) -> ZeroGridFunction< typename F::FunctionSpaceType, typename F::GridPartType >
Generate a ZeroGridFunction on the same function space.
Definition: gridfunctionexpression.hh:183
Dune::ACFem::asExprFunction
static const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > & asExprFunction(const GridFunction &arg)
Cast to the proper underlying expression class; for the generic case this is just the underlying Fem:...
Definition: gridfunctionexpression.hh:61
Dune::ACFem::zeroProduct
static ZeroGridFunction< typename FunctionMultiplicationResultTraits< typename F1::FunctionSpaceType, typename F2::FunctionSpaceType >::FunctionSpaceType, typename F1::GridPartType > zeroProduct(const F1 &f1, const F2 &f2)
Generate the proper zero-functions for products evaluating to zero.
Definition: gridfunctionexpression.hh:116
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::BinaryFunctionExpressionOperation< SMultiplyOperation >
Multiplication from the left by a scalar constant.
Definition: functionoperations.hh:567
Dune::ACFem::BinaryFunctionExpressionTraits
traits of BinaryFunctionExpression
Definition: functionexpression.hh:96
Dune::ACFem::BinaryGridFunctionExpressionTraits< SMultiplyOperation, Factor, Function >::IndexSetType
GridPartType::IndexSetType IndexSetType
type of IndexSet
Definition: gridfunctionexpression.hh:821
Dune::ACFem::BinaryGridFunctionExpressionTraits< SMultiplyOperation, Factor, Function >::IteratorType
GridPartType::template Codim< 0 >::IteratorType IteratorType
type of iterator
Definition: gridfunctionexpression.hh:819
Dune::ACFem::BinaryGridFunctionExpressionTraits
traits of BinaryGridFunctionExpression
Definition: gridfunctionexpression.hh:378
Dune::ACFem::BinaryGridFunctionExpressionTraits::IndexSetType
GridPartType::IndexSetType IndexSetType
type of IndexSet
Definition: gridfunctionexpression.hh:402
Dune::ACFem::BinaryGridFunctionExpressionTraits::IteratorType
GridPartType::template Codim< 0 >::IteratorType IteratorType
type of iterator
Definition: gridfunctionexpression.hh:400
Dune::ACFem::BoundaryFunctionTraits
Helper traits in order to treat function w/o dedicated boundary support in the same way,...
Definition: boundarysupportedfunction.hh:52
Dune::ACFem::ExpressionTemplate::expression
const ExpressionType & expression() const
Return a const reference to the underlying expression.
Definition: expressionoperations.hh:42
Dune::ACFem::ExpressionTraits
A traits class in order to collect properties of expressions.
Definition: expressionoperations.hh:465
Dune::ACFem::IdentityOperation
Identity, i.e. just wrap the object.
Definition: expressionoperations.hh:284
Dune::ACFem::InvertOperation
Inversion of an object.
Definition: expressionoperations.hh:275
Dune::ACFem::IsNotPieceWiseConstant
Negation of IsPieceWiseConstant, in order to have something to branch to with std::conditional.
Definition: gridfunctionexpressionbase.hh:119
Dune::ACFem::IsPieceWiseConstant
Tag type, consequences are zero Jacobian and Hessian.
Definition: gridfunctionexpressionbase.hh:114
Dune::ACFem::PlusOperation
Addition of two objects.
Definition: expressionoperations.hh:230
Dune::ACFem::SMultiplyOperation
Multiplication by scalars from the left.
Definition: expressionoperations.hh:257
Dune::ACFem::UnaryExpressionTraits
The default result type is void in order to trigger compilation errors.
Definition: expressionoperations.hh:589
Dune::ACFem::UnaryGridFunctionExpressionTraits
traits of UnaryGridFunctionExpression
Definition: gridfunctionexpression.hh:1270
Dune::ACFem::UnaryGridFunctionExpressionTraits::IteratorType
GridPartType::template Codim< 0 >::IteratorType IteratorType
type of iterator
Definition: gridfunctionexpression.hh:1287
Dune::ACFem::UnaryGridFunctionExpressionTraits::IndexSetType
GridPartType::IndexSetType IndexSetType
type of IndexSet
Definition: gridfunctionexpression.hh:1289
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.80.0 (May 16, 22:29, 2024)