[projection] make l2 projection work with parameter-dependent functions

dune/gdt/local/discretefunction.hh

@@ -109,14 +109,12 @@ public:
     return *localVector_;
   }
 
-  virtual size_t order(const XT::Common::Parameter& mu = XT::Common::Parameter()) const override final
+  virtual size_t order(const XT::Common::Parameter& mu = {}) const override final
   {
     return base_->order(mu);
   }
 
-  void evaluate(const DomainType& xx,
-                RangeType& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+  void evaluate(const DomainType& xx, RangeType& ret, const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(this->is_a_valid_point(xx));
     if (!GDT::is_fv_space<SpaceType>::value) {
@@ -133,9 +131,8 @@ public:
     }
   } // ... evaluate(...)
 
-  void jacobian(const DomainType& xx,
-                JacobianRangeType& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+  void
+  jacobian(const DomainType& xx, JacobianRangeType& ret, const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(this->is_a_valid_point(xx));
     if (!GDT::is_fv_space<SpaceType>::value) {

dune/gdt/local/integrands/fv.hh

@@ -143,7 +143,7 @@ public:
         const XT::Functions::LocalfunctionSetInterface<EntityType, DomainFieldType, dimDomain, R, r, rC>& /*test_base*/)
       const
   {
-    return std::get<0>(local_functions_tuple)->order(XT::Common::Parameter());
+    return std::get<0>(local_functions_tuple)->order({});
   }
 
   template <class R, size_t r, size_t rC>
@@ -154,7 +154,7 @@ public:
       Dune::DynamicVector<R>& ret) const
   {
     const auto u = std::get<1>(local_functions_tuple)->evaluate(x_local);
-    ret = std::get<0>(local_functions_tuple)->evaluate(x_local, u);
+    ret = DynamicVector<R>(std::get<0>(local_functions_tuple)->evaluate(x_local, u));
     ret /= std::get<2>(local_functions_tuple);
   }
 
@@ -205,7 +205,7 @@ public:
       const XT::Functions::
           LocalfunctionSetInterface<EntityType, DomainFieldType, dimDomain, R, rA, rCA>& /*ansatzBase*/) const
   {
-    return std::get<0>(local_functions_tuple)->order(XT::Common::Parameter());
+    return std::get<0>(local_functions_tuple)->order({});
   }
 
   template <class R, size_t rT, size_t rCT, size_t rA, size_t rCA>

dune/gdt/local/integrands/product.hh

@@ -85,8 +85,9 @@ public:
   typedef typename Traits::DomainFieldType DomainFieldType;
   static const size_t dimDomain = Traits::dimDomain;
 
-  LocalProductIntegrand(const LocalizableFunctionType& inducingFunction)
+  LocalProductIntegrand(const LocalizableFunctionType& inducingFunction, const XT::Common::Parameter& param = {})
     : inducingFunction_(inducingFunction)
+    , param_(param)
   {
   }
 
@@ -247,7 +248,7 @@ public:
   {
     ret *= 0.0;
     // evaluate local function
-    const auto functionValue = localFunction.evaluate(localPoint);
+    const auto functionValue = localFunction.evaluate(localPoint, param_);
     // evaluate test base
     const size_t size = testBase.size();
     const auto testValues = testBase.evaluate(localPoint);
@@ -272,7 +273,7 @@ public:
   {
     ret *= 0.0;
     // evaluate local function
-    const auto functionValue = localFunction.evaluate(localPoint);
+    const auto functionValue = localFunction.evaluate(localPoint, param_);
     // evaluate bases
     const auto rows = testBase.size();
     const auto cols = ansatzBase.size();
@@ -303,7 +304,7 @@ public:
     ret *= 0.0;
     // evaluate local function
     const auto localPointEntity = intersection.geometryInInside().global(localPoint);
-    const auto functionValue = localFunction.evaluate(localPointEntity);
+    const auto functionValue = localFunction.evaluate(localPointEntity, param_);
     // evaluate test base
     const size_t size = testBase.size();
     const auto testValues = testBase.evaluate(localPointEntity);
@@ -330,7 +331,7 @@ public:
     ret *= 0.0;
     const auto localPointEntity = intersection.geometryInInside().global(localPoint);
     // evaluate local function
-    const auto functionValue = localFunction.evaluate(localPointEntity);
+    const auto functionValue = localFunction.evaluate(localPointEntity, param_);
     // evaluate bases
     const size_t rows = testBase.size();
     const size_t cols = ansatzBase.size();
@@ -349,8 +350,9 @@ public:
 
   /// \}
 
-private:
+protected:
   const LocalizableFunctionType& inducingFunction_;
+  const XT::Common::Parameter param_;
 }; // class LocalProductIntegrand
 
 
@@ -371,8 +373,8 @@ public:
   using typename BaseType::DomainFieldType;
   using BaseType::dimDomain;
 
-  LocalFVProductIntegrand(const LocalizableFunctionType& inducingFunction)
-    : BaseType(inducingFunction)
+  LocalFVProductIntegrand(const LocalizableFunctionType& inducingFunction, const XT::Common::Parameter& param = {})
+    : BaseType(inducingFunction, param)
   {
   }
 
@@ -394,7 +396,7 @@ public:
            Dune::DynamicVector<R>& ret) const
   {
     // evaluate local function
-    const auto functionValue = localFunction.evaluate(localPoint);
+    const auto functionValue = localFunction.evaluate(localPoint, param_);
     // evaluate test base
     const size_t size = testBase.size();
     // compute product
@@ -418,7 +420,7 @@ public:
   {
     ret *= 0;
     // evaluate local function
-    const auto functionValue = localFunction.evaluate(localPoint);
+    const auto functionValue = localFunction.evaluate(localPoint, param_);
     // evaluate bases
     const auto rows = testBase.size();
     const auto cols = ansatzBase.size();
@@ -442,7 +444,7 @@ public:
   {
     // evaluate local function
     const auto localPointEntity = intersection.geometryInInside().global(localPoint);
-    const auto functionValue = localFunction.evaluate(localPointEntity);
+    const auto functionValue = localFunction.evaluate(localPointEntity, param_);
     // evaluate test base
     const size_t size = testBase.size();
     // compute product
@@ -467,7 +469,7 @@ public:
     ret *= 0.0;
     const auto localPointEntity = intersection.geometryInInside().global(localPoint);
     // evaluate local function
-    const auto functionValue = localFunction.evaluate(localPointEntity);
+    const auto functionValue = localFunction.evaluate(localPointEntity, param_);
     // evaluate bases
     const size_t rows = testBase.size();
     // compute product
@@ -479,6 +481,9 @@ public:
   } // ... evaluate(...)
 
   /// \}
+
+private:
+  using BaseType::param_;
 }; // class LocalFVProductIntegrand
 
 

dune/gdt/local/operators/l2-projection.hh

@@ -63,8 +63,9 @@ class LocalL2ProjectionOperator : public LocalOperatorInterface<internal::LocalL
 public:
   typedef internal::LocalL2ProjectionOperatorTraits Traits;
 
-  LocalL2ProjectionOperator(const size_t over_integrate = 0)
+  LocalL2ProjectionOperator(const size_t over_integrate = 0, const XT::Common::Parameter& param = {})
     : over_integrate_(over_integrate)
+    , param_(param)
   {
   }
 
@@ -82,13 +83,13 @@ public:
                                       typename RangeSpaceType::BaseFunctionSetType,
                                       typename RangeSpaceType::BaseFunctionSetType,
                                       R>
-        local_l2_operator(over_integrate_, one);
+        local_l2_operator(over_integrate_, one, param_);
     // and functional
     typedef XT::Functions::LocalizableFunctionInterface<E, D, d, R, r, rC> SourceType;
     const LocalVolumeIntegralFunctional<LocalProductIntegrand<SourceType>,
                                         typename RangeSpaceType::BaseFunctionSetType,
                                         R>
-        local_l2_functional(over_integrate_, source);
+        local_l2_functional(over_integrate_, source, param_);
     // create local lhs and rhs
     const auto& local_basis = local_range.basis();
     const size_t size = local_basis.size();
@@ -126,7 +127,7 @@ public:
     const LocalVolumeIntegralFunctional<LocalFVProductIntegrand<SourceType>,
                                         typename RangeSpaceType::BaseFunctionSetType,
                                         R>
-        local_l2_functional(over_integrate_, source);
+        local_l2_functional(over_integrate_, source, param_);
     Dune::DynamicVector<R> local_vector(local_range.basis().size(), 0.);
     const auto& entity = local_range.entity();
     local_l2_functional.apply(local_range.basis(), local_vector);
@@ -138,6 +139,7 @@ public:
 
 private:
   const size_t over_integrate_;
+  const XT::Common::Parameter param_;
 }; // class LocalL2ProjectionOperator
 
 

dune/gdt/playground/spaces/basefunctionset/dune-functions-wrapper.hh

@@ -117,7 +117,7 @@ public:
 
   void evaluate(const DomainType& xx,
                 std::vector<RangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(this->is_a_valid_point(xx));
     assert(ret.size() >= size());
@@ -129,7 +129,7 @@ public:
 
   void jacobian(const DomainType& xx,
                 std::vector<JacobianRangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(this->is_a_valid_point(xx));
     assert(ret.size() >= size());

dune/gdt/projections/l2-global.hh

@@ -75,8 +75,9 @@ public:
   L2GlobalProjectionLocalizableOperator(const size_t over_integrate,
                                         GridLayerType grd_vw,
                                         const SourceType& src,
-                                        RangeType& rng)
-    : BaseType(grd_vw, src, rng)
+                                        RangeType& rng,
+                                        const XT::Common::Parameter& param = {})
+    : BaseType(grd_vw, src, rng, param)
     , lhs_operator_(over_integrate, range_.space(), BaseType::grid_layer())
     , rhs_functional_(over_integrate, source_, range_.space(), BaseType::grid_layer())
     , solved_(false)

dune/gdt/projections/l2-local.hh

@@ -56,10 +56,13 @@ public:
   using typename BaseType::SourceType;
   using typename BaseType::RangeType;
 
-  template <class... Args>
-  explicit L2LocalProjectionLocalizableOperator(const size_t over_integrate, Args&&... args)
-    : BaseType(std::forward<Args>(args)...)
-    , local_operator_(over_integrate)
+  explicit L2LocalProjectionLocalizableOperator(const size_t over_integrate,
+                                                GridLayerType grd_layr,
+                                                const SourceType& src,
+                                                RangeType& rng,
+                                                const XT::Common::Parameter& param = {})
+    : BaseType(grd_layr, src, rng)
+    , local_operator_(over_integrate, param)
   {
     this->append(local_operator_);
     issue_warning(this->range().space());
@@ -121,12 +124,13 @@ typename std::
     make_local_l2_projection_localizable_operator(const GridLayerType& grid_layer,
                                                   const SourceType& source,
                                                   DiscreteFunction<SpaceType, VectorType>& range,
-                                                  const size_t over_integrate = 0)
+                                                  const size_t over_integrate = 0,
+                                                  const XT::Common::Parameter& param = {})
 {
   return Dune::XT::Common::make_unique<L2LocalProjectionLocalizableOperator<GridLayerType,
                                                                             SourceType,
                                                                             DiscreteFunction<SpaceType, VectorType>>>(
-      over_integrate, grid_layer, source, range);
+      over_integrate, grid_layer, source, range, param);
 } // ... make_local_l2_projection_localizable_operator(...)
 
 template <class SourceType, class SpaceType, class VectorType>
@@ -138,12 +142,13 @@ typename std::
                                                                    DiscreteFunction<SpaceType, VectorType>>>>::type
     make_local_l2_projection_localizable_operator(const SourceType& source,
                                                   DiscreteFunction<SpaceType, VectorType>& range,
-                                                  const size_t over_integrate = 0)
+                                                  const size_t over_integrate = 0,
+                                                  const XT::Common::Parameter& param = {})
 {
   return Dune::XT::Common::make_unique<L2LocalProjectionLocalizableOperator<typename SpaceType::GridLayerType,
                                                                             SourceType,
                                                                             DiscreteFunction<SpaceType, VectorType>>>(
-      over_integrate, range.space().grid_layer(), source, range);
+      over_integrate, range.space().grid_layer(), source, range, param);
 } // ... make_local_l2_projection_localizable_operator(...)
 
 
@@ -178,11 +183,12 @@ public:
 
   template <class R, size_t r, size_t rC, class S, class V>
   void apply(const XT::Functions::LocalizableFunctionInterface<E, D, d, R, r, rC>& source,
-             DiscreteFunction<S, V>& range) const
+             DiscreteFunction<S, V>& range,
+             const XT::Common::Parameter& param = {}) const
   {
     typedef XT::Functions::LocalizableFunctionInterface<E, D, d, R, r, rC> SourceType;
     L2LocalProjectionLocalizableOperator<GridLayerType, SourceType, DiscreteFunction<S, V>> op(
-        over_integrate_, grid_layer_, source, range);
+        over_integrate_, grid_layer_, source, range, param);
     op.apply();
   }
 

dune/gdt/projections/l2.hh

@@ -145,9 +145,10 @@ public:
 
   template <class R, size_t r, size_t rC, class S, class V>
   void apply(const XT::Functions::LocalizableFunctionInterface<E, D, d, R, r, rC>& source,
-             DiscreteFunction<S, V>& range) const
+             DiscreteFunction<S, V>& range,
+             const XT::Common::Parameter& param = {}) const
   {
-    redirect<S::continuous>::apply(grid_layer_, source, range, over_integrate_);
+    redirect<S::continuous>::apply(grid_layer_, source, range, over_integrate_, param);
   }
 
   template <class RangeType, class SourceType>
@@ -178,9 +179,14 @@ private:
   struct redirect
   {
     template <class SourceType, class RangeType>
-    static void apply(const GridLayerType& grd_vw, const SourceType& src, RangeType& rng, const size_t over_integrate)
+    static void apply(const GridLayerType& grd_vw,
+                      const SourceType& src,
+                      RangeType& rng,
+                      const size_t over_integrate,
+                      const XT::Common::Parameter& param = {})
     {
-      L2GlobalProjectionLocalizableOperator<GridLayerType, SourceType, RangeType>(over_integrate, grd_vw, src, rng)
+      L2GlobalProjectionLocalizableOperator<GridLayerType, SourceType, RangeType>(
+          over_integrate, grd_vw, src, rng, param)
           .apply();
     }
   };
@@ -189,9 +195,14 @@ private:
   struct redirect<false, anything>
   {
     template <class SourceType, class RangeType>
-    static void apply(const GridLayerType& grd_vw, const SourceType& src, RangeType& rng, const size_t over_integrate)
+    static void apply(const GridLayerType& grd_vw,
+                      const SourceType& src,
+                      RangeType& rng,
+                      const size_t over_integrate,
+                      const XT::Common::Parameter& param = {})
     {
-      L2LocalProjectionLocalizableOperator<GridLayerType, SourceType, RangeType>(over_integrate, grd_vw, src, rng)
+      L2LocalProjectionLocalizableOperator<GridLayerType, SourceType, RangeType>(
+          over_integrate, grd_vw, src, rng, param)
           .apply();
     }
   };
@@ -219,9 +230,10 @@ typename std::enable_if<XT::Grid::is_layer<GridLayerType>::value
 project_l2(const GridLayerType& grid_layer,
            const SourceType& source,
            DiscreteFunction<SpaceType, VectorType>& range,
-           const size_t over_integrate = 0)
+           const size_t over_integrate = 0,
+           const XT::Common::Parameter& param = {})
 {
-  make_l2_projection_operator(grid_layer, over_integrate)->apply(source, range);
+  make_l2_projection_operator(grid_layer, over_integrate)->apply(source, range, param);
 }
 
 
@@ -229,9 +241,12 @@ template <class SourceType, class SpaceType, class VectorType>
 typename std::enable_if<XT::Functions::is_localizable_function<SourceType>::value && is_space<SpaceType>::value
                             && XT::LA::is_vector<VectorType>::value,
                         void>::type
-project_l2(const SourceType& source, DiscreteFunction<SpaceType, VectorType>& range, const size_t over_integrate = 0)
+project_l2(const SourceType& source,
+           DiscreteFunction<SpaceType, VectorType>& range,
+           const size_t over_integrate = 0,
+           const XT::Common::Parameter& param = {})
 {
-  make_l2_projection_operator(range.space().grid_layer(), over_integrate)->apply(source, range);
+  make_l2_projection_operator(range.space().grid_layer(), over_integrate)->apply(source, range, param);
 }
 
 

dune/gdt/spaces/basefunctionset/dune-fem-localfunctions-wrapper.hh

@@ -132,7 +132,7 @@ public:
 
   void evaluate(const DomainType& x,
                 std::vector<RangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= size());
     backend_->evaluateAll(x, ret);
@@ -142,7 +142,7 @@ public:
 
   void jacobian(const DomainType& x,
                 std::vector<JacobianRangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= size());
     backend_->jacobianAll(x, this->entity().geometry().jacobianInverseTransposed(x), ret);

dune/gdt/spaces/basefunctionset/dune-fem-wrapper.hh

@@ -153,7 +153,7 @@ public:
 
   void evaluate(const DomainType& xx,
                 std::vector<RangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= size());
     backend_->evaluateAll(xx, ret);
@@ -163,7 +163,7 @@ public:
 
   void jacobian(const DomainType& xx,
                 std::vector<JacobianRangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= size());
     backend_->jacobianAll(xx, ret);

dune/gdt/spaces/basefunctionset/dune-pdelab-wrapper.hh

@@ -216,7 +216,7 @@ public:
 
   void evaluate(const DomainType& xx,
                 std::vector<RangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= backend_->size());
     backend_->evaluateFunction(xx, ret);
@@ -226,7 +226,7 @@ public:
 
   void jacobian(const DomainType& xx,
                 std::vector<JacobianRangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= backend_->size());
     backend_->evaluateJacobian(xx, ret);
@@ -331,7 +331,7 @@ public:
 
   void evaluate(const DomainType& xx,
                 std::vector<RangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= size());
     const size_t size_of_factor_basefunctionset = backend_->size();
@@ -350,7 +350,7 @@ public:
 
   void jacobian(const DomainType& xx,
                 std::vector<JacobianRangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= backend_->size());
     const size_t size_of_factor_basefunctionset = backend_->size();
@@ -483,7 +483,7 @@ public:
 
   void evaluate(const DomainType& xx,
                 std::vector<RangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(lfs_);
     assert(backend_);
@@ -503,7 +503,7 @@ public:
 
   void jacobian(const DomainType& xx,
                 std::vector<JacobianRangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(lfs_);
     assert(backend_);

dune/gdt/spaces/basefunctionset/fv.hh

@@ -104,14 +104,14 @@ public:
     return 1;
   }
 
-  virtual size_t order(const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+  virtual size_t order(const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     return 0;
   }
 
   void evaluate(const DomainType& /*xx*/,
                 std::vector<RangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= 0);
     ret[0] = 1.0;
@@ -121,7 +121,7 @@ public:
 
   void jacobian(const DomainType& /*xx*/,
                 std::vector<JacobianRangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= 0);
     ret[0] *= 0.0;
@@ -194,14 +194,14 @@ public:
     return dimRange;
   }
 
-  virtual size_t order(const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+  virtual size_t order(const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     return 0;
   }
 
   void evaluate(const DomainType& /*xx*/,
                 std::vector<RangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= dimRange);
     for (size_t ii = 0; ii < dimRange; ++ii) {
@@ -214,7 +214,7 @@ public:
 
   void jacobian(const DomainType& /*xx*/,
                 std::vector<JacobianRangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     assert(ret.size() >= dimRange);
     for (size_t ii = 0; ii < dimRange; ++ii)

dune/gdt/spaces/basefunctionset/product.hh

@@ -231,7 +231,7 @@ public:
 
   void evaluate(const DomainType& xx,
                 std::vector<RangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     internal::DynamicTupleGetter<0>::evaluate(basefunctionsets_, xx, ret);
   } // ... evaluate(...)
@@ -240,7 +240,7 @@ public:
 
   void jacobian(const DomainType& xx,
                 std::vector<JacobianRangeType>& ret,
-                const XT::Common::Parameter& /*mu*/ = XT::Common::Parameter()) const override final
+                const XT::Common::Parameter& /*mu*/ = {}) const override final
   {
     internal::DynamicTupleGetter<0>::jacobian(basefunctionsets_, xx, ret);
   } // ... jacobian(...)