Merge branch 'pymor_paper_integration' into mmp

dune/stuff/functions/random_ellipsoids_function.hh

+// This file is part of the dune-stuff project:
+//   https://github.com/wwu-numerik/dune-stuff/
+// Copyright holders: Rene Milk, Felix Schindler
+// License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+
+#ifndef DUNE_STUFF_FUNCTION_RandomEllipsoidsFunction_HH
+#define DUNE_STUFF_FUNCTION_RandomEllipsoidsFunction_HH
+
+#include <vector>
+#include <cmath>
+#include <memory>
+
+#include <dune/common/exceptions.hh>
+
+#include <dune/stuff/common/configuration.hh>
+#include <dune/stuff/common/debug.hh>
+#include <dune/stuff/common/fvector.hh>
+#include <dune/stuff/common/random.hh>
+#include <dune/stuff/grid/information.hh>
+
+#include "interfaces.hh"
+
+namespace Dune {
+namespace Stuff {
+namespace Functions {
+
+template <size_t dim, class CoordType = double>
+struct Ellipsoid
+{
+  typedef DSC::FieldVector<CoordType, dim> DomainType;
+  DomainType center;
+  DomainType radii;
+
+  bool contains(DomainType point) const
+  {
+    const auto shifted = point - center;
+    double sum = 0;
+    for (auto ii : DSC::valueRange(dim)) {
+      const auto pii = shifted[ii];
+      sum += std::pow(pii, 2) / std::pow(radii[ii], 2);
+    }
+    return DSC::FloatCmp::le(sum, 1.);
+  }
+  bool intersects_cube(DomainType ll, DomainType ur) const
+  {
+    DUNE_THROW(NotImplemented, "");
+  }
+};
+
+template <class EntityImp, class DomainFieldImp, size_t domainDim, class RangeFieldImp, size_t rangeDim,
+          size_t rangeDimCols = 1>
+class RandomEllipsoidsFunction
+    : public LocalizableFunctionInterface<EntityImp, DomainFieldImp, domainDim, RangeFieldImp, rangeDim, rangeDimCols>
+{
+protected:
+  typedef LocalizableFunctionInterface<EntityImp, DomainFieldImp, domainDim, RangeFieldImp, rangeDim, rangeDimCols>
+      BaseType;
+  typedef RandomEllipsoidsFunction<EntityImp, DomainFieldImp, domainDim, RangeFieldImp, rangeDim, rangeDimCols>
+      ThisType;
+
+public:
+  typedef typename BaseType::EntityType EntityType;
+  typedef typename BaseType::LocalfunctionType LocalfunctionType;
+
+  typedef typename BaseType::DomainFieldType DomainFieldType;
+  static const size_t dimDomain = BaseType::dimDomain;
+
+  typedef typename BaseType::RangeFieldType RangeFieldType;
+  typedef typename BaseType::RangeType RangeType;
+  typedef Ellipsoid<dimDomain, DomainFieldType> EllipsoidType;
+  class Localfunction
+      : public LocalfunctionInterface<EntityImp, DomainFieldImp, domainDim, RangeFieldImp, rangeDim, rangeDimCols>
+  {
+    typedef LocalfunctionInterface<EntityImp, DomainFieldImp, domainDim, RangeFieldImp, rangeDim, rangeDimCols>
+        BaseType;
+
+  public:
+    typedef typename BaseType::EntityType EntityType;
+
+    typedef typename BaseType::DomainType DomainType;
+    typedef typename BaseType::RangeFieldType RangeFieldType;
+    typedef typename BaseType::RangeType RangeType;
+    typedef typename BaseType::JacobianRangeType JacobianRangeType;
+
+    Localfunction(const EntityType& ent, const RangeType value, std::vector<EllipsoidType>&& local_ellipsoids)
+      : BaseType(ent)
+      , geometry_(ent.geometry())
+      , value_(value)
+      , local_ellipsoids_(local_ellipsoids)
+    {
+      //      DSC_LOG_DEBUG_0 << "create local LF Ellips with " << local_ellipsoids_.size() << " instances\n";
+    }
+
+    Localfunction(const Localfunction& /*other*/) = delete;
+
+    Localfunction& operator=(const Localfunction& /*other*/) = delete;
+
+    virtual size_t order() const override
+    {
+      return 8;
+    }
+
+    virtual void evaluate(const DomainType& xx_local, RangeType& ret) const override
+    {
+      assert(this->is_a_valid_point(xx));
+      const auto xx_global = geometry_.global(xx_local);
+      for (const auto& ellipsoid : local_ellipsoids_) {
+        if (ellipsoid.contains(xx_global)) {
+          ret = value_;
+          //          DSC_LOG_DEBUG_0 << "ell  INSIDE " << ellipsoid.center << " with xx " << xx_global << "\n";
+          return;
+        }
+      }
+      ret = 0;
+    }
+
+    virtual void jacobian(const DomainType& UNUSED_UNLESS_DEBUG(xx), JacobianRangeType& ret) const override
+    {
+      assert(this->is_a_valid_point(xx));
+      ret *= RangeFieldType(0);
+    }
+
+  private:
+    const typename EntityImp::Geometry geometry_;
+    const RangeType value_;
+    const std::vector<EllipsoidType> local_ellipsoids_;
+  }; // class Localfunction
+
+public:
+  static const bool available = true;
+
+  static std::string static_id()
+  {
+    return BaseType::static_id() + ".RandomEllipsoidsFunction";
+  }
+
+  static Common::Configuration default_config(const std::string sub_name = "")
+  {
+    Common::Configuration config;
+    config["lower_left"]  = "[0.0 0.0 0.0]";
+    config["upper_right"] = "[1.0 1.0 1.0]";
+    config["name"] = static_id();
+    if (sub_name.empty())
+      return config;
+    else {
+      Common::Configuration tmp;
+      tmp.add(config, sub_name);
+      return tmp;
+    }
+  } // ... default_config(...)
+
+  static std::unique_ptr<ThisType> create(const Common::Configuration config = default_config(),
+                                          const std::string sub_name = static_id())
+  {
+    // get correct config
+    const Common::Configuration cfg         = config.has_sub(sub_name) ? config.sub(sub_name) : config;
+    const Common::Configuration default_cfg = default_config();
+    DUNE_THROW(NotImplemented, "");
+  } // ... create(...)
+
+  RandomEllipsoidsFunction(const Common::FieldVector<DomainFieldType, dimDomain>& lowerLeft,
+                           const Common::FieldVector<DomainFieldType, dimDomain>& upperRight,
+                           const Stuff::Common::Configuration& ellipsoid_cfg, const std::string nm = static_id())
+    : lowerLeft_(lowerLeft)
+    , upperRight_(upperRight)
+    , name_(nm)
+    , ellipsoid_cfg_(ellipsoid_cfg)
+  {
+    typedef unsigned long UL;
+    const UL level_0_count = ellipsoid_cfg.get("ellipsoids.count", 10);
+    const UL max_depth     = ellipsoid_cfg.get("ellipsoids.recursion_depth", 1);
+    const UL children      = ellipsoid_cfg.get<UL>("ellipsoids.children", 3u); //, DSC::ValidateLess<UL>(0));
+    const UL total_count = level_0_count + level_0_count * std::pow(children, max_depth + 1);
+    ellipsoids_.resize(level_0_count);
+    ellipsoids_.reserve(total_count);
+    const auto seed               = DomainFieldType(ellipsoid_cfg.get("ellipsoids.seed", 0));
+    const auto min_radius         = ellipsoid_cfg.get("ellipsoids.min_radius", 0.01);
+    const auto max_radius         = ellipsoid_cfg.get("ellipsoids.max_radius", 0.02);
+    const auto child_displacement = ellipsoid_cfg.get("ellipsoids.max_child_displacement", max_radius);
+    typedef DSC::DefaultRNG<DomainFieldType> RNG;
+    RNG center_rng(0, 1, seed);
+    RNG radii_rng(min_radius, max_radius, seed);
+    RNG dist_rng(min_radius, child_displacement, seed);
+    RNG sign_rng(-1, 1, seed);
+
+    const auto parent_range = DSC::valueRange(0ul, level_0_count);
+    for (auto ii : parent_range) {
+      std::generate(
+          ellipsoids_[ii].center.begin(), ellipsoids_[ii].center.end(), [&center_rng]() { return center_rng(); });
+      std::generate(ellipsoids_[ii].radii.begin(), ellipsoids_[ii].radii.end(), [&radii_rng]() { return radii_rng(); });
+    }
+
+    std::function<void(UL, const EllipsoidType&)> recurse_add = [&](UL current_level, const EllipsoidType& parent) {
+      if (current_level > max_depth)
+        return;
+      for (const auto unused_counter : DSC::valueRange(children)) {
+        EllipsoidType child = parent;
+        const double scale  = std::pow(ellipsoid_cfg.get("ellipsoids.recursion_scale", 0.5), current_level);
+        const auto displace = [&](DomainFieldType& coord) {
+          const auto disp   = dist_rng() * DSC::sign(sign_rng());
+          coord += disp;
+          DSC_LOG_DEBUG_0 << disp << ";";
+        };
+        std::for_each(child.center.begin(), child.center.end(), displace);
+        std::generate(child.radii.begin(), child.radii.end(), [&radii_rng, scale]() { return radii_rng() * scale; });
+        ellipsoids_.push_back(child);
+        recurse_add(current_level + 1, child);
+      }
+    };
+
+    for (auto ii : parent_range) {
+      recurse_add(0, ellipsoids_[ii]);
+    }
+    DSC_LOG_DEBUG_0 << "generated " << ellipsoids_.size() << " of " << total_count << "\n";
+    to_file(*DSC::make_ofstream("ellipsoids.txt"));
+  }
+
+  RandomEllipsoidsFunction(const ThisType& other) = default;
+
+  ThisType& operator=(const ThisType& other) = delete;
+
+  ThisType& operator=(ThisType&& source) = delete;
+
+  virtual std::string type() const override
+  {
+    return BaseType::static_id() + ".RandomEllipsoidsFunction";
+  }
+
+  virtual std::string name() const override
+  {
+    return name_;
+  }
+
+  void to_file(std::ostream& out) const
+  {
+    boost::format line("%d|%g;%g|%g;%g\n");
+    size_t id = 0;
+    for (const auto& ellipsoid : ellipsoids_) {
+      const auto str =
+          (line % id % ellipsoid.center[0] % ellipsoid.center[1] % ellipsoid.radii[0] % ellipsoid.radii[1]).str();
+      out << str;
+    }
+    out.flush();
+  }
+
+private:
+  std::tuple<typename EllipsoidType::DomainType, typename EllipsoidType::DomainType>
+  bounding_box(const EntityType& entity) const
+  {
+    typename EllipsoidType::DomainType ll, ur;
+    typedef Dune::Stuff::Common::MinMaxAvg<DomainFieldType> MinMaxAvgType;
+    std::array<MinMaxAvgType, dimDomain> coord_limits;
+    const auto& geo = entity.geometry();
+    for (auto i : DSC::valueRange(geo.corners())) {
+      const auto& corner(geo.corner(i));
+      for (size_t k = 0; k < dimDomain; ++k)
+        coord_limits[k](corner[k]);
+    }
+    for (auto ii : DSC::valueRange(dimDomain)) {
+      ll[ii] = coord_limits[ii].min();
+      ur[ii] = coord_limits[ii].max();
+
+      return std::make_pair(std::move(ll), std::move(ur));
+    }
+  }
+
+public:
+  virtual std::unique_ptr<LocalfunctionType> local_function(const EntityType& entity) const override
+  {
+    const auto local_value = DomainFieldType(ellipsoid_cfg_.get("ellipsoids.local_value", 1.));
+    // decide on the subdomain the center of the entity belongs to
+    const auto max_radius = ellipsoid_cfg_.get("ellipsoids.max_radius", 0.04);
+    typename EllipsoidType::DomainType ll, ur;
+    std::tie(ll, ur) = bounding_box(entity);
+    std::for_each(ll.begin(), ll.end(), [&max_radius](DomainFieldType& lc) { lc -= 1.1 * max_radius; });
+    std::for_each(ur.begin(), ur.end(), [&max_radius](DomainFieldType& uc) { uc += 1.1 * max_radius; });
+    std::vector<EllipsoidType> local_ellipsoids;
+    for (const auto& ellipsoid : ellipsoids_) {
+      bool inside = true;
+      for (auto ii : DSC::valueRange(dimDomain)) {
+        inside = inside && DSC::FloatCmp::ge(ellipsoid.center[ii], ll[ii]);
+        inside = inside && DSC::FloatCmp::le(ellipsoid.center[ii], ur[ii]);
+      }
+      if (inside) {
+        local_ellipsoids.push_back(ellipsoid);
+      }
+    }
+    std::vector<EllipsoidType> tmp = ellipsoids_;
+    return std::unique_ptr<Localfunction>(new Localfunction(entity, local_value, std::move(tmp)));
+  } // ... local_function(...)
+
+private:
+  const Common::FieldVector<DomainFieldType, dimDomain> lowerLeft_;
+  const Common::FieldVector<DomainFieldType, dimDomain> upperRight_;
+  const std::string name_;
+  const Stuff::Common::Configuration ellipsoid_cfg_;
+  std::vector<EllipsoidType> ellipsoids_;
+}; // class RandomEllipsoidsFunction
+
+
+} // namespace Functions
+} // namespace Stuff
+} // namespace Dune
+
+#endif // DUNE_STUFF_FUNCTION_RandomEllipsoidsFunction_HH

dune/stuff/functions/spe10model2.hh

+// This file is part of the dune-stuff project:
+//   https://github.com/wwu-numerik/dune-stuff/
+// Copyright holders: Rene Milk, Felix Schindler
+// License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+
+#ifndef DUNE_STUFF_FUNCTIONS_SPE10MODEL2_HH
+#define DUNE_STUFF_FUNCTIONS_SPE10MODEL2_HH
+
+#include <iostream>
+#include <memory>
+
+#include <dune/stuff/common/exceptions.hh>
+#include <dune/stuff/common/configuration.hh>
+#include <dune/stuff/common/color.hh>
+#include <dune/stuff/common/string.hh>
+#include <dune/stuff/common/fvector.hh>
+#include <dune/stuff/common/type_utils.hh>
+#include <dune/stuff/functions/global.hh>
+
+namespace Dune {
+namespace Stuff {
+namespace Functions {
+namespace Spe10 {
+
+/**
+ * Grid originally had LL (0,0,0) to UR (365.76, 670.56, 51.816) corners
+ *
+ */
+template <class EntityImp, class DomainFieldImp, size_t dim_domain, class RangeFieldImp, size_t r, size_t rC>
+class Model2 : public Stuff::GlobalFunctionInterface<EntityImp, DomainFieldImp, dim_domain, RangeFieldImp, r, rC>
+{
+  static_assert(r == rC, "");
+  static_assert(dim_domain == rC, "");
+  static_assert(dim_domain == 3, "");
+  typedef Stuff::GlobalFunctionInterface<EntityImp, DomainFieldImp, dim_domain, RangeFieldImp, r, rC> BaseType;
+
+public:
+  Model2(std::string data_filename = "perm_case2a.dat",
+         DSC::FieldVector<double, dim_domain> upper_right = default_upper_right)
+    : deltas_{{upper_right[0] / num_elements[0], upper_right[1] / num_elements[1], upper_right[2] / num_elements[2]}}
+    , permeability_(nullptr)
+    , permMatrix_(0.0)
+    , filename_(data_filename)
+  {
+    readPermeability();
+  }
+
+  static const DSC::FieldVector<double, dim_domain> default_upper_right;
+  // unsigned int mandated by CubeGrid provider
+  static const DSC::FieldVector<unsigned int, dim_domain> num_elements;
+
+  virtual ~Model2()
+  {
+    delete permeability_;
+    permeability_ = nullptr;
+  }
+
+  //! currently used in gdt assembler
+  virtual void evaluate(const typename BaseType::DomainType& x,
+                        typename BaseType::RangeType& diffusion) const final override
+  {
+
+    if (!permeability_) {
+      DSC_LOG_ERROR_0 << "The SPE10-permeability data file could not be opened. This file does\n"
+                      << "not come with the dune-multiscale repository due to file size. To download it\n"
+                      << "execute\n"
+                      << "wget http://www.spe.org/web/csp/datasets/por_perm_case2a.zip\n"
+                      << "unzip the file and move the file 'spe_perm.dat' to\n"
+                      << "dune-multiscale/dune/multiscale/problems/spe10_permeability.dat!\n";
+      DUNE_THROW(IOError, "Data file for Groundwaterflow permeability could not be opened!");
+    }
+
+    // 3 is the maximum space dimension
+    for (size_t dim = 0; dim < dim_domain; ++dim)
+      permIntervalls_[dim] = std::min(unsigned(std::floor(x[dim] / deltas_[dim])), num_elements[dim] - 1);
+
+    const int offset = permIntervalls_[0] + permIntervalls_[1] * num_elements[0]
+                       + permIntervalls_[2] * num_elements[1] * num_elements[0];
+    for (size_t dim = 0; dim < dim_domain; ++dim) {
+      const auto idx      = offset + dim * 1122000;
+      diffusion[dim][dim] = permeability_[idx];
+    }
+  }
+
+  virtual size_t order() const
+  {
+    return 0u;
+  }
+
+private:
+  void readPermeability()
+  {
+    std::ifstream file(filename_);
+    double val;
+    if (!file) { // file couldn't be opened
+      return;
+    }
+    file >> val;
+    int counter   = 0;
+    permeability_ = new double[3366000];
+    while (!file.eof()) {
+      // keep reading until end-of-file
+      permeability_[counter++] = val;
+      file >> val; // sets EOF flag if no value found
+    }
+    file.close();
+  }
+
+  std::array<double, dim_domain> deltas_;
+  double* permeability_; //! TODO automatic memory
+  mutable typename BaseType::DomainType permIntervalls_;
+  mutable Dune::FieldMatrix<double, BaseType::DomainType::dimension, BaseType::DomainType::dimension> permMatrix_;
+  const std::string filename_;
+};
+
+template <class EntityImp, class DomainFieldImp, size_t dim_domain, class RangeFieldImp, size_t r, size_t rC>
+const DSC::FieldVector<unsigned int, dim_domain>
+    Model2<EntityImp, DomainFieldImp, dim_domain, RangeFieldImp, r, rC>::num_elements{{60, 220, 85}};
+template <class EntityImp, class DomainFieldImp, size_t dim_domain, class RangeFieldImp, size_t r, size_t rC>
+const DSC::FieldVector<double, dim_domain>
+    Model2<EntityImp, DomainFieldImp, dim_domain, RangeFieldImp, r, rC>::default_upper_right{{1, 3.667, 1.417}};
+} // namespace Spe10
+} // namespace Functions
+} // namespace Stuff
+} // namespace Dune
+
+#endif // DUNE_STUFF_FUNCTIONS_SPE10MODEL2_HH

dune/stuff/test/functions_spe10.cc

+// This file is part of the dune-stuff project:
+//   https://github.com/wwu-numerik/dune-stuff
+// Copyright holders: Rene Milk, Felix Schindler
+// License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+
+#include "main.hxx"
+
+#include <memory>
+
+#include <dune/common/exceptions.hh>
+
+#include <dune/stuff/functions/interfaces.hh>
+#include <dune/stuff/functions/spe10.hh>
+#include <dune/stuff/functions/spe10model2.hh>
+
+// we need this nasty code generation because the testing::Types< ... > only accepts 50 arguments
+// and all combinations of functions and entities and dimensions and fieldtypes would be way too much
+#define TEST_STRUCT_GENERATOR(ftype, etype)                                                                            \
+  template <class Spe10Model2FunctionType>                                                                             \
+  struct ftype##etype##Test : public ::testing::Test                                                                   \
+  {                                                                                                                    \
+    typedef typename Spe10Model2FunctionType::EntityType EntityType;                                                   \
+    typedef typename Spe10Model2FunctionType::LocalfunctionType LocalfunctionType;                                     \
+    typedef typename Spe10Model2FunctionType::DomainFieldType DomainFieldType;                                         \
+    static const size_t dimDomain = Spe10Model2FunctionType::dimDomain;                                                \
+    typedef typename Spe10Model2FunctionType::DomainType DomainType;                                                   \
+    typedef typename Spe10Model2FunctionType::RangeFieldType RangeFieldType;                                           \
+    static const size_t dimRange     = Spe10Model2FunctionType::dimRange;                                              \
+    static const size_t dimRangeCols = Spe10Model2FunctionType::dimRangeCols;                                          \
+    typedef typename Spe10Model2FunctionType::RangeType RangeType;                                                     \
+    typedef typename Spe10Model2FunctionType::JacobianRangeType JacobianRangeType;                                     \
+                                                                                                                       \
+    void check() const                                                                                                 \
+    {                                                                                                                  \
+      const Spe10Model2FunctionType zero;                                                                              \
+    }                                                                                                                  \
+  };
+// TEST_STRUCT_GENERATOR
+
+
+#if HAVE_DUNE_GRID
+
+//# include <dune/grid/sgrid.hh>
+
+// typedef Dune::SGrid< 1, 1 >::Codim< 0 >::Entity DuneSGrid1dEntityType;
+// typedef Dune::SGrid< 2, 2 >::Codim< 0 >::Entity DuneSGrid2dEntityType;
+// typedef Dune::SGrid< 3, 3 >::Codim< 0 >::Entity DuneSGrid3dEntityType;
+
+// typedef testing::Types< Dune::Stuff::Functions::Spe10::Model2< DuneSGrid1dEntityType, double, 1, double, 1, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid1dEntityType, double, 1, double, 1, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid1dEntityType, double, 1, double, 1, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid1dEntityType, double, 1, double, 2, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid1dEntityType, double, 1, double, 2, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid1dEntityType, double, 1, double, 2, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid1dEntityType, double, 1, double, 3, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid1dEntityType, double, 1, double, 3, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid1dEntityType, double, 1, double, 3, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid2dEntityType, double, 2, double, 1, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid2dEntityType, double, 2, double, 1, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid2dEntityType, double, 2, double, 1, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid2dEntityType, double, 2, double, 2, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid2dEntityType, double, 2, double, 2, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid2dEntityType, double, 2, double, 2, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid2dEntityType, double, 2, double, 3, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid2dEntityType, double, 2, double, 3, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid2dEntityType, double, 2, double, 3, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid3dEntityType, double, 3, double, 1, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid3dEntityType, double, 3, double, 1, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid3dEntityType, double, 3, double, 1, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid3dEntityType, double, 3, double, 2, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid3dEntityType, double, 3, double, 2, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid3dEntityType, double, 3, double, 2, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid3dEntityType, double, 3, double, 3, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid3dEntityType, double, 3, double, 3, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneSGrid3dEntityType, double, 3, double, 3, 3 >
+//                        > Spe10Model2FunctionSGridEntityTypes;
+
+// TEST_STRUCT_GENERATOR(Spe10Model2FunctionTest, SGridEntity)
+// TYPED_TEST_CASE(Spe10Model2FunctionTestSGridEntityTest, Spe10Model2FunctionSGridEntityTypes);
+// TYPED_TEST(Spe10Model2FunctionTestSGridEntityTest, provides_required_methods) {
+//  this->check();
+//}
+
+#include <dune/grid/yaspgrid.hh>
+
+typedef Dune::YaspGrid<3>::Codim<0>::Entity DuneYaspGrid3dEntityType;
+
+typedef testing::Types<Dune::Stuff::Functions::Spe10::Model2<DuneYaspGrid3dEntityType, double, 3, double, 3, 3>>
+    Spe10Model2FunctionYaspGridEntityTypes;
+
+TEST_STRUCT_GENERATOR(Spe10Model2FunctionTest, YaspGridEntity)
+TYPED_TEST_CASE(Spe10Model2FunctionTestYaspGridEntityTest, Spe10Model2FunctionYaspGridEntityTypes);
+TYPED_TEST(Spe10Model2FunctionTestYaspGridEntityTest, provides_required_methods)
+{
+  this->check();
+}
+
+//# if HAVE_ALUGRID
+//#   include <dune/stuff/common/disable_warnings.hh>
+//#     include <dune/grid/alugrid.hh>
+//#   include <dune/stuff/common/reenable_warnings.hh>
+
+// typedef Dune::ALUGrid< 2, 2, Dune::simplex, Dune::nonconforming >::Codim< 0 >::Entity DuneAluSimplexGrid2dEntityType;
+// typedef Dune::ALUGrid< 3, 3, Dune::simplex, Dune::nonconforming >::Codim< 0 >::Entity DuneAluSimplexGrid3dEntityType;
+// typedef Dune::ALUGrid< 3, 3, Dune::cube, Dune::nonconforming >::Codim< 0 >::Entity     DuneAluCubeGrid3dEntityType;
+
+// typedef testing::Types< Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid2dEntityType, double, 2, double, 1,
+// 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid2dEntityType, double, 2, double, 1, 2
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid2dEntityType, double, 2, double, 1, 3
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid2dEntityType, double, 2, double, 2, 1
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid2dEntityType, double, 2, double, 2, 2
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid2dEntityType, double, 2, double, 2, 3
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid2dEntityType, double, 2, double, 3, 1
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid2dEntityType, double, 2, double, 3, 2
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid2dEntityType, double, 2, double, 3, 3
+//                      >
+
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid3dEntityType, double, 3, double, 1, 1
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid3dEntityType, double, 3, double, 1, 2
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid3dEntityType, double, 3, double, 1, 3
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid3dEntityType, double, 3, double, 2, 1
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid3dEntityType, double, 3, double, 2, 2
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid3dEntityType, double, 3, double, 2, 3
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid3dEntityType, double, 3, double, 3, 1
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid3dEntityType, double, 3, double, 3, 2
+//                      >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluSimplexGrid3dEntityType, double, 3, double, 3, 3
+//                      >
+
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluCubeGrid3dEntityType, double, 3, double, 1, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluCubeGrid3dEntityType, double, 3, double, 1, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluCubeGrid3dEntityType, double, 3, double, 1, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluCubeGrid3dEntityType, double, 3, double, 2, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluCubeGrid3dEntityType, double, 3, double, 2, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluCubeGrid3dEntityType, double, 3, double, 2, 3 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluCubeGrid3dEntityType, double, 3, double, 3, 1 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluCubeGrid3dEntityType, double, 3, double, 3, 2 >
+//                      , Dune::Stuff::Functions::Spe10::Model2< DuneAluCubeGrid3dEntityType, double, 3, double, 3, 3 >
+//                        > Spe10Model2FunctionAluGridEntityTypes;
+
+// TEST_STRUCT_GENERATOR(Spe10Model2FunctionTest, AluGridEntity)
+// TYPED_TEST_CASE(Spe10Model2FunctionTestAluGridEntityTest, Spe10Model2FunctionAluGridEntityTypes);
+// TYPED_TEST(Spe10Model2FunctionTestAluGridEntityTest, provides_required_methods) {
+//  this->check();
+//}
+
+//# endif // HAVE_ALUGRID
+#endif // HAVE_DUNE_GRID