diff --git a/dune/stuff/functions/random_ellipsoids_function.hh b/dune/stuff/functions/random_ellipsoids_function.hh
new file mode 100644
index 0000000000000000000000000000000000000000..d36ef9123428763e0d328c518b34851c7e3926ac
--- /dev/null
+++ b/dune/stuff/functions/random_ellipsoids_function.hh
@@ -0,0 +1,305 @@
+// 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(), [¢er_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
diff --git a/dune/stuff/functions/spe10model2.hh b/dune/stuff/functions/spe10model2.hh
new file mode 100644
index 0000000000000000000000000000000000000000..e30a6b36a4dbdce36e64776bc3d79dd30ff41ed5
--- /dev/null
+++ b/dune/stuff/functions/spe10model2.hh
@@ -0,0 +1,127 @@
+// 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
diff --git a/dune/stuff/test/functions_spe10.cc b/dune/stuff/test/functions_spe10.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d70f56740078d326c0b7f15a6f0c2e980a479a5c
--- /dev/null
+++ b/dune/stuff/test/functions_spe10.cc
@@ -0,0 +1,163 @@
+// 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