From 24f739cce35472a2ad7744d630f4f379d596444e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9=20Milk?= <rene.milk@wwu.de>
Date: Fri, 2 Feb 2018 15:44:22 +0100
Subject: [PATCH] [bindings] adjust for disc module dropping

---
 dune/gdt/assembler/system.bindings.hh         |  15 ++-
 dune/gdt/assembler/system.bindings/alu.cc     |   2 +-
 dune/gdt/assembler/system.bindings/yasp.cc    |   2 +-
 dune/gdt/assembler/system.lib.hh              |   2 -
 dune/gdt/discretefunction/default.bindings.hh |  22 ++--
 dune/gdt/discretefunction/default.hh          |   4 +-
 .../gdt/functionals/elliptic-ipdg.bindings.cc |  12 +-
 .../elliptic-ipdg.bindings/yasp_istl.cc       |   6 +-
 dune/gdt/functionals/l2.bindings.cc           |  12 +-
 dune/gdt/functionals/l2.bindings.hh           |  12 +-
 dune/gdt/operators/elliptic-ipdg.bindings.cc  |  12 +-
 dune/gdt/operators/elliptic.bindings.hh       |   8 +-
 dune/gdt/operators/l2.bindings.cc             |  10 +-
 .../playground/operators/ESV2007.bindings.cc  |   7 +-
 dune/gdt/playground/operators/ESV2007.hh      |   6 +-
 .../playground/operators/OS2015.bindings.cc   |   6 +-
 dune/gdt/playground/operators/OS2015.hh       |   8 +-
 .../playground/operators/RS2017.bindings.cc   | 107 +++++++++---------
 dune/gdt/playground/operators/RS2017.hh       |  70 ++++++------
 dune/gdt/playground/spaces/block.bindings.hh  |  17 +--
 dune/gdt/playground/spaces/block.hh           |   6 +-
 dune/gdt/playground/spaces/mapper/block.hh    |   2 +-
 dune/gdt/projections.bindings.hh              |  15 +--
 dune/gdt/spaces/constraints.bindings.hh       |   6 +-
 dune/gdt/spaces/interface.bindings.hh         |   9 +-
 dune/gdt/spaces/interface.hh                  |   1 -
 dune/gdt/test/grids.hh                        |  42 -------
 27 files changed, 188 insertions(+), 233 deletions(-)

diff --git a/dune/gdt/assembler/system.bindings.hh b/dune/gdt/assembler/system.bindings.hh
index ed437b320..bbc5d0dd6 100644
--- a/dune/gdt/assembler/system.bindings.hh
+++ b/dune/gdt/assembler/system.bindings.hh
@@ -15,6 +15,7 @@
 
 #include <dune/xt/common/memory.hh>
 #include <dune/xt/la/container.hh>
+#include <dune/xt/grid/grids.hh>
 #include <dune/xt/grid/grids.bindings.hh>
 #include <dune/xt/grid/layers.bindings.hh>
 #include <dune/xt/grid/walker.hh>
@@ -372,16 +373,14 @@ DUNE_GDT_ASSEMBLER_SYSTEM_BIND_LIB(extern template);
   _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_YASP(_m, _g_layer, _g_backend, _s_type, _s_backend, _s_grid_layer, _p, _r, _rC);     \
   _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALU(_m, _g_layer, _g_backend, _s_type, _s_backend, _s_grid_layer, _p, _r, _rC)
 
-#define _DUNE_GDT_ASSEMBLER_SYSTEM_BIND(_m, _s_type, _p, _r, _rC)                                                      \
-  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, leaf, view, _s_type, gdt, leaf, _p, 1, 1);                             \
-  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, level, view, _s_type, gdt, level, _p, 1, 1)
 
 #define DUNE_GDT_ASSEMBLER_SYSTEM_BIND(_m)                                                                             \
-  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND(_m, cg, 1, 1, 1);                                                                    \
-  /*_DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, dd_subdomain_boundary, view, dg, gdt, dd_subdomain, 1, 1, 1);*/      \
-  /*_DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, dd_subdomain_coupling, view, dg, gdt, dd_subdomain, 1, 1, 1);*/      \
-  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND(_m, fv, 0, 1, 1)
-
+  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, dd_subdomain_boundary, view, dg, gdt, dd_subdomain, 1, 1, 1);          \
+  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, dd_subdomain_coupling, view, dg, gdt, dd_subdomain, 1, 1, 1);          \
+  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, leaf, view, cg, gdt, leaf, 1, 1, 1);                                   \
+  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, level, view, cg, gdt, level, 1, 1, 1);                                 \
+  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, leaf, view, fv, gdt, leaf, 0, 1, 1);                                   \
+  _DUNE_GDT_ASSEMBLER_SYSTEM_BIND_ALL_GRIDS(_m, level, view, fv, gdt, level, 0, 1, 1)
 // end: this is what we need for the .so
 
 
diff --git a/dune/gdt/assembler/system.bindings/alu.cc b/dune/gdt/assembler/system.bindings/alu.cc
index 258294b62..997f09331 100644
--- a/dune/gdt/assembler/system.bindings/alu.cc
+++ b/dune/gdt/assembler/system.bindings/alu.cc
@@ -19,7 +19,7 @@ namespace GDT {
 namespace bindings {
 
 
-DUNE_GDT_ASSEMBLER_SYSTEM_BIND_LIB_ALU_GDT(template);
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_LIB_ALU(template);
 
 
 } // namespace bindings
diff --git a/dune/gdt/assembler/system.bindings/yasp.cc b/dune/gdt/assembler/system.bindings/yasp.cc
index ccf33ec99..eeed2e626 100644
--- a/dune/gdt/assembler/system.bindings/yasp.cc
+++ b/dune/gdt/assembler/system.bindings/yasp.cc
@@ -19,7 +19,7 @@ namespace GDT {
 namespace bindings {
 
 
-DUNE_GDT_ASSEMBLER_SYSTEM_BIND_LIB_YASP_GDT(template);
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_LIB_YASP(template);
 
 
 } // namespace bindings
diff --git a/dune/gdt/assembler/system.lib.hh b/dune/gdt/assembler/system.lib.hh
index e7e0b68db..eacbd6f15 100644
--- a/dune/gdt/assembler/system.lib.hh
+++ b/dune/gdt/assembler/system.lib.hh
@@ -355,8 +355,6 @@
 
 #define DUNE_GDT_ASSEMBLER_SYSTEM_LIB_DD_SUBDOMAIN(_pre, _G, _s_type, _s_backend, _p, _r, _rC)                         \
   DUNE_GDT_ASSEMBLER_SYSTEM_LIB(_pre, _G, _s_type, _s_backend, _p, _r, _rC);                                           \
-  _DUNE_GDT_ASSEMBLER_SYSTEM_LIB_DD_SUBDOMAIN(                                                                         \
-      _pre, _G, adaptive_leaf, view, _s_type, _s_backend, adaptive_leaf, _p, _r, _rC);                                 \
   _DUNE_GDT_ASSEMBLER_SYSTEM_LIB_DD_SUBDOMAIN(_pre, _G, leaf, view, _s_type, _s_backend, leaf, _p, _r, _rC);           \
   _DUNE_GDT_ASSEMBLER_SYSTEM_LIB_DD_SUBDOMAIN(_pre, _G, level, view, _s_type, _s_backend, level, _p, _r, _rC);         \
   _DUNE_GDT_ASSEMBLER_SYSTEM_LIB_DD_SUBDOMAIN(                                                                         \
diff --git a/dune/gdt/discretefunction/default.bindings.hh b/dune/gdt/discretefunction/default.bindings.hh
index 9bd49aa4c..8b64af469 100644
--- a/dune/gdt/discretefunction/default.bindings.hh
+++ b/dune/gdt/discretefunction/default.bindings.hh
@@ -118,13 +118,13 @@ public:
                              path,
                              subsampling);
             else if (layer == "dd_subdomain")
-              self.visualize(dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::part>(
+              self.visualize(dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::view>(
                                  level_or_subdomain),
                              path,
                              subsampling);
             else if (layer == "dd_subdomain_oversampled")
               self.visualize(
-                  dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::part>(
+                  dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::view>(
                       level_or_subdomain),
                   path,
                   subsampling);
@@ -234,14 +234,9 @@ public:
     const auto sp_name = space_name<SP>::value();
     auto c = internal::DiscreteFunction<S, V>::bind(m, sp_name);
 
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::adaptive_leaf>(m, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::dd_subdomain>(m, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::dd_subdomain_boundary>(m, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::dd_subdomain_coupling>(m, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::dd_subdomain_oversampled>(m, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::leaf>(m, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::level>(m, sp_name);
     addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::dd_subdomain>(m, sp_name);
+    addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::dd_subdomain_boundary>(m, sp_name);
+    addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::dd_subdomain_coupling>(m, sp_name);
     addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::dd_subdomain_oversampled>(m, sp_name);
     addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::leaf>(m, sp_name);
     addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::level>(m, sp_name);
@@ -312,13 +307,18 @@ public:
   _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALU(_m, _g_layer, _s_type, _s_backend, _p, _r, _rC)
 
 #define DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND(_m)                                                                     \
+  _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, leaf, dg, gdt, 1, 1, 1);                                       \
+  _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, level, dg, gdt, 1, 1, 1);                                      \
   _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, leaf, fv, gdt, 0, 1, 1);                                       \
   _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, level, fv, gdt, 0, 1, 1);                                      \
   _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, leaf, cg, gdt, 1, 1, 1);                                       \
   _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, level, cg, gdt, 1, 1, 1);
-//  _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, dd_subdomain, cg, gdt, 1, 1, 1);                               \
-//  _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, dd_subdomain, block_cg, gdt, 1, 1, 1);
 
+#define DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_DD(_m)                                                                  \
+  _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, dd_subdomain, dg, gdt, 1, 1, 1);                               \
+  _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, dd_subdomain, block_dg, gdt, 1, 1, 1);                         \
+  _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, dd_subdomain, cg, gdt, 1, 1, 1);                               \
+  _DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_ALL_GRIDS(_m, dd_subdomain, block_cg, gdt, 1, 1, 1);
 
 // end: this is what we need for the .so
 
diff --git a/dune/gdt/discretefunction/default.hh b/dune/gdt/discretefunction/default.hh
index 31993dc2d..c61854338 100644
--- a/dune/gdt/discretefunction/default.hh
+++ b/dune/gdt/discretefunction/default.hh
@@ -173,8 +173,8 @@ public:
   typedef SpaceImp SpaceType;
   typedef typename SpaceType::Traits SpaceTraits;
   typedef VectorImp VectorType;
-  using typename BaseType::EntityType;
-  using typename BaseType::LocalfunctionType;
+  using EntityType = typename BaseType::EntityType;
+  using LocalfunctionType = typename BaseType::LocalfunctionType;
 
   typedef ConstLocalDiscreteFunction<SpaceType, VectorType> ConstLocalDiscreteFunctionType;
 
diff --git a/dune/gdt/functionals/elliptic-ipdg.bindings.cc b/dune/gdt/functionals/elliptic-ipdg.bindings.cc
index 90b4cfbad..a4f348a24 100644
--- a/dune/gdt/functionals/elliptic-ipdg.bindings.cc
+++ b/dune/gdt/functionals/elliptic-ipdg.bindings.cc
@@ -42,16 +42,16 @@ PYBIND11_PLUGIN(__functionals_elliptic_ipdg)
 
 // alu_istl.cc
 #if HAVE_DUNE_ALUGRID && HAVE_DUNE_ISTL
-  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_ALU(m, leaf, part, dg, gdt, 1, istl_dense);
-  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_ALU(m, level, part, dg, gdt, 1, istl_dense);
-  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_ALU(m, dd_subdomain, part, dg, gdt, 1, istl_dense);
+  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_ALU(m, leaf, view, dg, gdt, 1, istl_dense);
+  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_ALU(m, level, view, dg, gdt, 1, istl_dense);
+  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_ALU(m, dd_subdomain, view, dg, gdt, 1, istl_dense);
 #endif
 
 // yasp_istl.cc
 #if HAVE_DUNE_ISTL
-  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_YASP(m, leaf, part, dg, gdt, 1, istl_dense);
-  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_YASP(m, level, part, dg, gdt, 1, istl_dense);
-  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_YASP(m, dd_subdomain, part, dg, gdt, 1, istl_dense);
+  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_YASP(m, leaf, view, dg, gdt, 1, istl_dense);
+  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_YASP(m, level, view, dg, gdt, 1, istl_dense);
+  DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_YASP(m, dd_subdomain, view, dg, gdt, 1, istl_dense);
 #endif
 
   m.def("_init_mpi",
diff --git a/dune/gdt/functionals/elliptic-ipdg.bindings/yasp_istl.cc b/dune/gdt/functionals/elliptic-ipdg.bindings/yasp_istl.cc
index 50b0c646b..801b628ea 100644
--- a/dune/gdt/functionals/elliptic-ipdg.bindings/yasp_istl.cc
+++ b/dune/gdt/functionals/elliptic-ipdg.bindings/yasp_istl.cc
@@ -15,9 +15,9 @@
 
 
 #if HAVE_DUNE_ISTL
-DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_LIB_YASP(template, leaf, part, dg, gdt, 1, istl_sparse);
-DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_LIB_YASP(template, level, part, dg, gdt, 1, istl_sparse);
-DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_LIB_YASP(template, dd_subdomain, part, dg, gdt, 1, istl_sparse);
+DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_LIB_YASP(template, leaf, view, dg, gdt, 1, istl_sparse);
+DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_LIB_YASP(template, level, view, dg, gdt, 1, istl_sparse);
+DUNE_GDT_FUNCTIONALS_ELLIPTIC_IPDG_BIND_LIB_YASP(template, dd_subdomain, view, dg, gdt, 1, istl_sparse);
 #endif
 
 
diff --git a/dune/gdt/functionals/l2.bindings.cc b/dune/gdt/functionals/l2.bindings.cc
index 986d4c86c..8fcd6f0bd 100644
--- a/dune/gdt/functionals/l2.bindings.cc
+++ b/dune/gdt/functionals/l2.bindings.cc
@@ -40,18 +40,24 @@ PYBIND11_PLUGIN(__functionals_l2)
   py::module::import("dune.xt.la");
   py::module::import("dune.gdt.__spaces");
 
-// alu_istl.cc
+  // alu_istl.cc
+  DUNE_GDT_FUNCTIONALS_L2_BIND_ALU(m, leaf, view, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_FUNCTIONALS_L2_BIND_ALU(m, level, view, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_FUNCTIONALS_L2_BIND_ALU(m, dd_subdomain, view, dg, gdt, 1, istl_sparse);
 #if HAVE_DUNE_ALUGRID && HAVE_DUNE_ISTL
   DUNE_GDT_FUNCTIONALS_L2_BIND_ALU(m, leaf, view, cg, gdt, 1, istl_sparse);
   DUNE_GDT_FUNCTIONALS_L2_BIND_ALU(m, level, view, cg, gdt, 1, istl_sparse);
-//  DUNE_GDT_FUNCTIONALS_L2_BIND_ALU(m, dd_subdomain, view, cg, gdt, 1, istl_sparse);
+  DUNE_GDT_FUNCTIONALS_L2_BIND_ALU(m, dd_subdomain, view, cg, gdt, 1, istl_sparse);
 #endif
 
 // yasp_istl.cc
 #if HAVE_DUNE_ISTL
+  DUNE_GDT_FUNCTIONALS_L2_BIND_YASP(m, leaf, view, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_FUNCTIONALS_L2_BIND_YASP(m, level, view, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_FUNCTIONALS_L2_BIND_YASP(m, dd_subdomain, view, dg, gdt, 1, istl_sparse);
   DUNE_GDT_FUNCTIONALS_L2_BIND_YASP(m, leaf, view, cg, gdt, 1, istl_sparse);
   DUNE_GDT_FUNCTIONALS_L2_BIND_YASP(m, level, view, cg, gdt, 1, istl_sparse);
-//  DUNE_GDT_FUNCTIONALS_L2_BIND_YASP(m, dd_subdomain, part, cg, gdt, 1, istl_sparse);
+  DUNE_GDT_FUNCTIONALS_L2_BIND_YASP(m, dd_subdomain, view, cg, gdt, 1, istl_sparse);
 #endif
 
   m.def("_init_mpi",
diff --git a/dune/gdt/functionals/l2.bindings.hh b/dune/gdt/functionals/l2.bindings.hh
index 623762da7..742fd4d9e 100644
--- a/dune/gdt/functionals/l2.bindings.hh
+++ b/dune/gdt/functionals/l2.bindings.hh
@@ -235,16 +235,16 @@ public:
 
 // alu_istl.cc
 #if HAVE_DUNE_ALUGRID && HAVE_DUNE_ISTL
-DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_ALU(extern template, leaf, part, cg, gdt, 1, istl_sparse);
-DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_ALU(extern template, level, part, cg, gdt, 1, istl_sparse);
-// DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_ALU(extern template, dd_subdomain, part, cg, gdt, 1, istl_sparse);
+DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_ALU(extern template, leaf, view, cg, gdt, 1, istl_sparse);
+DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_ALU(extern template, level, view, cg, gdt, 1, istl_sparse);
+DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_ALU(extern template, dd_subdomain, view, cg, gdt, 1, istl_sparse);
 #endif
 
 // yasp_istl.cc
 #if HAVE_DUNE_ISTL
-DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_YASP(extern template, leaf, part, cg, gdt, 1, istl_sparse);
-DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_YASP(extern template, level, part, cg, gdt, 1, istl_sparse);
-// DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_YASP(extern template, dd_subdomain, part, cg, gdt, 1, istl_sparse);
+DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_YASP(extern template, leaf, view, cg, gdt, 1, istl_sparse);
+DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_YASP(extern template, level, view, cg, gdt, 1, istl_sparse);
+DUNE_GDT_FUNCTIONALS_L2_BIND_LIB_YASP(extern template, dd_subdomain, view, cg, gdt, 1, istl_sparse);
 #endif
 
 // end: this is what we need for the lib
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings.cc b/dune/gdt/operators/elliptic-ipdg.bindings.cc
index 2c9797c07..68b0b9ec5 100644
--- a/dune/gdt/operators/elliptic-ipdg.bindings.cc
+++ b/dune/gdt/operators/elliptic-ipdg.bindings.cc
@@ -43,16 +43,16 @@ PYBIND11_PLUGIN(__operators_elliptic_ipdg)
 
 // alu_istl.cc
 #if HAVE_DUNE_ALUGRID && HAVE_DUNE_ISTL
-  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ALU(m, leaf, part, dg, gdt, 1, istl_sparse);
-  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ALU(m, level, part, dg, gdt, 1, istl_sparse);
-  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ALU(m, dd_subdomain, part, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ALU(m, leaf, view, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ALU(m, level, view, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ALU(m, dd_subdomain, view, dg, gdt, 1, istl_sparse);
 #endif
 
 // yasp_istl.cc
 #if HAVE_DUNE_ISTL
-  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_YASP(m, leaf, part, dg, gdt, 1, istl_sparse);
-  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_YASP(m, level, part, dg, gdt, 1, istl_sparse);
-  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_YASP(m, dd_subdomain, part, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_YASP(m, leaf, view, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_YASP(m, level, view, dg, gdt, 1, istl_sparse);
+  DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_YASP(m, dd_subdomain, view, dg, gdt, 1, istl_sparse);
 #endif
 
   m.def("_init_mpi",
diff --git a/dune/gdt/operators/elliptic.bindings.hh b/dune/gdt/operators/elliptic.bindings.hh
index d9ebb9275..089b9098a 100644
--- a/dune/gdt/operators/elliptic.bindings.hh
+++ b/dune/gdt/operators/elliptic.bindings.hh
@@ -302,12 +302,10 @@ public:
 
 
 #define _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB(_prefix, _la)                                                            \
-  _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_GRIDS(_prefix, leaf, part, cg, gdt, 1, _la);                                   \
-  _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_GRIDS(_prefix, level, part, cg, gdt, 1, _la);                                  \
-  _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_GRIDS(_prefix, dd_subdomain, part, cg, gdt, 1, _la);                           \
   _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_GRIDS(_prefix, leaf, view, dg, gdt, 1, _la);                                   \
   _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_GRIDS(_prefix, level, view, dg, gdt, 1, _la);                                  \
-  _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_GRIDS(_prefix, dd_subdomain, view, dg, gdt, 1, _la)
+  _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_GRIDS(_prefix, dd_subdomain, view, dg, gdt, 1, _la);                           \
+  _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_GRIDS(_prefix, dd_subdomain, view, cg, gdt, 1, _la)
 
 #if HAVE_DUNE_ISTL
 #define DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_ISTL(_prefix) _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB(_prefix, istl_sparse)
@@ -454,7 +452,7 @@ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_LIB_ISTL(extern template);
   _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GRIDS(_m, level, view, cg, gdt, 1, _la);                                           \
   _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GRIDS(_m, leaf, view, dg, gdt, 1, _la);                                            \
   _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GRIDS(_m, level, view, dg, gdt, 1, _la);                                           \
-  _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GRIDS(_m, dd_subdomain, view, cg, gdt, 1, _la);                                    \
+  _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GRIDS(_m, dd_subdomain, view, dg, gdt, 1, _la);                                    \
   _DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GRIDS(_m, dd_subdomain, view, dg, gdt, 1, _la)
 #define DUNE_GDT_OPERATORS_ELLIPTIC_BIND_COMMON(_m)
 //_DUNE_GDT_OPERATORS_ELLIPTIC_BIND(_m, common_dense)
diff --git a/dune/gdt/operators/l2.bindings.cc b/dune/gdt/operators/l2.bindings.cc
index d7168d4b8..e594f1d42 100644
--- a/dune/gdt/operators/l2.bindings.cc
+++ b/dune/gdt/operators/l2.bindings.cc
@@ -65,7 +65,8 @@ PYBIND11_PLUGIN(__operators_l2)
   py::module::import("dune.gdt.__discretefunction");
 
 #if HAVE_DUNE_ALUGRID
-  bind_l2_localizable_product<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, XT::Grid::Backends::part>(m);
+  bind_l2_localizable_product<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, XT::Grid::Backends::view>(m);
+
   Dune::GDT::bindings::L2MatrixOperator<ALU_2D_SIMPLEX_CONFORMING,
                                         Layers::dd_subdomain,
                                         SpaceType::dg,
@@ -98,11 +99,12 @@ PYBIND11_PLUGIN(__operators_l2)
                                                        2>::type,
                            typename XT::Grid::Layer<ALU_2D_SIMPLEX_CONFORMING,
                                                     Layers::dd_subdomain,
-                                                    XT::Grid::Backends::part,
+                                                    XT::Grid::Backends::view,
                                                     XT::Grid::DD::SubdomainGrid<ALU_2D_SIMPLEX_CONFORMING>>::type>,
                        XT::LA::IstlRowMajorSparseMatrix<double>>::bind(m,
                                                                        "RtAlu2dSimplexLeafRestrictedSubdomainPartSpace",
                                                                        "istl_row_major_sparse_matrix_double");
+
 #endif // HAVE_DUNE_ALUGRID
 
   m.def("_init_mpi",
@@ -110,12 +112,10 @@ PYBIND11_PLUGIN(__operators_l2)
           int argc = Dune::XT::Common::numeric_cast<int>(args.size());
           char** argv = Dune::XT::Common::vector_to_main_args(args);
           Dune::MPIHelper::instance(argc, argv);
-#if HAVE_DUNE_FEM
-          Dune::Fem::MPIManager::initialize(argc, argv);
-#endif
         },
         "args"_a = std::vector<std::string>());
 
+
   m.def("_init_logger",
         [](const ssize_t max_info_level,
            const ssize_t max_debug_level,
diff --git a/dune/gdt/playground/operators/ESV2007.bindings.cc b/dune/gdt/playground/operators/ESV2007.bindings.cc
index 08ff3202b..e894fe643 100644
--- a/dune/gdt/playground/operators/ESV2007.bindings.cc
+++ b/dune/gdt/playground/operators/ESV2007.bindings.cc
@@ -50,7 +50,7 @@ struct NonconformityProduct
   typedef GDT::ESV2007::NonconformityProduct<GL, IGL> type;
   typedef py::class_<type, XT::Grid::Walker<GL>> bound_type;
 
-  template <bool is_same = (interpolation_layer_type == layer_type) && (layer_backend == Backends::part),
+  template <bool is_same = (interpolation_layer_type == layer_type) && (layer_backend == Backends::view),
             bool anything = true>
   struct interpolation_layer_suffix
   {
@@ -66,7 +66,7 @@ struct NonconformityProduct
     static std::string value()
     {
       return "_" + XT::Grid::bindings::layer_name<interpolation_layer_type>::value() + "_"
-             + XT::Grid::bindings::backend_name<Backends::part>::value();
+             + XT::Grid::bindings::backend_name<Backends::view>::value();
     }
   }; // struct interpolation_layer_suffix<false, ...>
 
@@ -513,11 +513,12 @@ PYBIND11_PLUGIN(__operators_ESV2007)
                        Backends::view,
                        Layers::dd_subdomain_oversampled>::bind(m);
   ResidualProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::leaf, Backends::view>::bind(m);
-  // This is not efficient: we reconstruct on the whole leaf instead of only the neighborhood, but the rt space
+  ResidualProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::leaf, Backends::view>::bind(m);
   //                        on a dd_subdomain_oversampled grid view is broken, if based on
   //                        a 2d simplex alugrid.
   ResidualProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, Backends::view, Layers::leaf>::bind(m);
   DiffusiveFluxProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::leaf, Backends::view>::bind(m);
+  DiffusiveFluxProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::leaf, Backends::view>::bind(m);
   // s.a.
   DiffusiveFluxProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, Backends::view, Layers::leaf>::bind(m);
 #endif
diff --git a/dune/gdt/playground/operators/ESV2007.hh b/dune/gdt/playground/operators/ESV2007.hh
index a26836362..79de1a98b 100644
--- a/dune/gdt/playground/operators/ESV2007.hh
+++ b/dune/gdt/playground/operators/ESV2007.hh
@@ -266,8 +266,10 @@ public:
             const auto center = entity.geometry().local(entity.geometry().center());
             auto diffusion = kappa_.local_function(entity)->evaluate(center);
             diffusion *= lambda_.local_function(entity)->evaluate(center);
-            const auto min_ev =
-                XT::LA::make_eigen_solver(diffusion, {"assert_positive_eigenvalues", 1e-15}).min_eigenvalues(1).at(0);
+            const auto min_ev = XT::LA::make_eigen_solver(
+                                    diffusion, XT::Common::Configuration{{"assert_positive_eigenvalues"}, {1e-15}})
+                                    .min_eigenvalues(1)
+                                    .at(0);
             const auto h = XT::Grid::entity_diameter(entity);
             ret[0][0] = (poincare_constant_ / min_ev) * h * h
                         * local_f_minus_divergence_of_reconstructed_u.evaluate(local_point).at(0)[0]
diff --git a/dune/gdt/playground/operators/OS2015.bindings.cc b/dune/gdt/playground/operators/OS2015.bindings.cc
index 3be24d21f..cf694ddce 100644
--- a/dune/gdt/playground/operators/OS2015.bindings.cc
+++ b/dune/gdt/playground/operators/OS2015.bindings.cc
@@ -370,11 +370,11 @@ PYBIND11_PLUGIN(__operators_OS2015)
   // This is not efficient: we reconstruct on the whole leaf instead of only the neighborhood, but the rt space
   //                        on a dd_subdomain_oversampled grid view (which is a wrapped part) is broken, if based on
   //                        a 2d simplex alugrid.
-  ResidualProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, Backends::part, Layers::leaf>::bind(m);
+  ResidualProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, Backends::view, Layers::leaf>::bind(m);
+  DiffusiveFluxProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::leaf, Backends::view>::bind(m);
   DiffusiveFluxProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::leaf, Backends::view>::bind(m);
-  DiffusiveFluxProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::leaf, Backends::part>::bind(m);
   // s.a.
-  DiffusiveFluxProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, Backends::part, Layers::leaf>::bind(m);
+  DiffusiveFluxProduct<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, Backends::view, Layers::leaf>::bind(m);
 #endif
 
   m.def("_init_mpi",
diff --git a/dune/gdt/playground/operators/OS2015.hh b/dune/gdt/playground/operators/OS2015.hh
index f67415d9c..570fc7906 100644
--- a/dune/gdt/playground/operators/OS2015.hh
+++ b/dune/gdt/playground/operators/OS2015.hh
@@ -199,7 +199,9 @@ public:
         diffusion *= local_lambda->evaluate(xx);
         min_diffusion_ev_ = std::min(
             min_diffusion_ev_,
-            XT::LA::make_eigen_solver(diffusion, {"assert_positive_eigenvalues", 1e-15}).min_eigenvalues(1).at(0));
+            XT::LA::make_eigen_solver(diffusion, XT::Common::Configuration{{"assert_positive_eigenvalues"}, {1e-15}})
+                .min_eigenvalues(1)
+                .at(0));
       }
       // * and in the corners of the gigen entity.
       const auto& reference_element = ReferenceElements<D, d>::general(entity.type());
@@ -209,7 +211,9 @@ public:
         diffusion *= local_lambda->evaluate(xx);
         min_diffusion_ev_ = std::min(
             min_diffusion_ev_,
-            XT::LA::make_eigen_solver(diffusion, {"assert_positive_eigenvalues", 1e-15}).min_eigenvalues(1).at(0));
+            XT::LA::make_eigen_solver(diffusion, XT::Common::Configuration{{"assert_positive_eigenvalues"}, {1e-15}})
+                .min_eigenvalues(1)
+                .at(0));
       }
     });
   } // ResidualProduct(...)
diff --git a/dune/gdt/playground/operators/RS2017.bindings.cc b/dune/gdt/playground/operators/RS2017.bindings.cc
index f17c70365..b803a79d2 100644
--- a/dune/gdt/playground/operators/RS2017.bindings.cc
+++ b/dune/gdt/playground/operators/RS2017.bindings.cc
@@ -65,60 +65,63 @@ PYBIND11_PLUGIN(__operators_RS2017)
   typedef XT::LA::IstlDenseVector<R> V;
   typedef XT::LA::IstlRowMajorSparseMatrix<R> M;
 
-  m.def(
-      "RS2017_residual_indicator_min_diffusion_eigenvalue",
-      [](XT::Grid::GridProvider<ALU_2D_SIMPLEX_CONFORMING, XT::Grid::DD::SubdomainGrid<ALU_2D_SIMPLEX_CONFORMING>>&
-             dd_grid_provider,
-         const ssize_t subdomain,
-         const XT::Functions::LocalizableFunctionInterface<E, D, d, R, 1>& lambda,
-         const XT::Functions::LocalizableFunctionInterface<E, D, d, R, d, d>& kappa,
-         const ssize_t over_int) {
-        py::gil_scoped_release DUNE_UNUSED(release);
-        const auto over_integrate = XT::Common::numeric_cast<size_t>(over_int);
-        auto subdomain_layer = dd_grid_provider.template layer<Layers::dd_subdomain, Backends::part>(
-            XT::Common::numeric_cast<size_t>(subdomain));
-        typedef decltype(subdomain_layer) GL;
-        XT::Grid::Walker<GL> walker(subdomain_layer);
-        double min_ev = std::numeric_limits<double>::max();
-        walker.append([&](const E& entity) {
-          const auto local_lambda = lambda.local_function(entity);
-          const auto local_kappa = kappa.local_function(entity);
-          // To find the minimum of a function we evaluate it
-          // * in all quadrature points of a quadrature which would integrate such a function exactly
-          for (const auto& quadrature_point : QuadratureRules<D, d>::rule(
-                   entity.type(), local_lambda->order() + local_kappa->order() + over_integrate)) {
-            const auto xx = quadrature_point.position();
-            auto diffusion = local_kappa->evaluate(xx);
-            diffusion *= local_lambda->evaluate(xx);
-            min_ev = std::min(
-                min_ev,
-                XT::LA::make_eigen_solver(diffusion, {"assert_positive_eigenvalues", 1e-15}).min_eigenvalues(1).at(0));
-          }
-          // * and in the corners of the gigen entity.
-          const auto& reference_element = ReferenceElements<D, d>::general(entity.type());
-          for (int ii = 0; ii < reference_element.size(d); ++ii) {
-            const auto xx = reference_element.position(ii, d);
-            auto diffusion = local_kappa->evaluate(xx);
-            diffusion *= local_lambda->evaluate(xx);
-            min_ev = std::min(
-                min_ev,
-                XT::LA::make_eigen_solver(diffusion, {"assert_positive_eigenvalues", 1e-15}).min_eigenvalues(1).at(0));
-          }
-        });
-        walker.walk();
-        return min_ev;
-      },
-      "dd_grid_provider"_a,
-      "subdomain"_a,
-      "lambda"_a,
-      "kappa"_a,
-      "over_integrate"_a = 2);
+  m.def("RS2017_residual_indicator_min_diffusion_eigenvalue",
+        [](XT::Grid::GridProvider<ALU_2D_SIMPLEX_CONFORMING, XT::Grid::DD::SubdomainGrid<ALU_2D_SIMPLEX_CONFORMING>>&
+               dd_grid_provider,
+           const ssize_t subdomain,
+           const XT::Functions::LocalizableFunctionInterface<E, D, d, R, 1>& lambda,
+           const XT::Functions::LocalizableFunctionInterface<E, D, d, R, d, d>& kappa,
+           const ssize_t over_int) {
+          py::gil_scoped_release DUNE_UNUSED(release);
+          const auto over_integrate = XT::Common::numeric_cast<size_t>(over_int);
+          auto subdomain_layer = dd_grid_provider.template layer<Layers::dd_subdomain, Backends::view>(
+              XT::Common::numeric_cast<size_t>(subdomain));
+          typedef decltype(subdomain_layer) GL;
+          XT::Grid::Walker<GL> walker(subdomain_layer);
+          double min_ev = std::numeric_limits<double>::max();
+          walker.append([&](const E& entity) {
+            const auto local_lambda = lambda.local_function(entity);
+            const auto local_kappa = kappa.local_function(entity);
+            // To find the minimum of a function we evaluate it
+            // * in all quadrature points of a quadrature which would integrate such a function exactly
+            for (const auto& quadrature_point : QuadratureRules<D, d>::rule(
+                     entity.type(), local_lambda->order() + local_kappa->order() + over_integrate)) {
+              const auto xx = quadrature_point.position();
+              auto diffusion = local_kappa->evaluate(xx);
+              diffusion *= local_lambda->evaluate(xx);
+              min_ev = std::min(min_ev,
+                                XT::LA::make_eigen_solver(
+                                    diffusion, XT::Common::Configuration{{"assert_positive_eigenvalues"}, {1e-15}})
+                                    .min_eigenvalues(1)
+                                    .at(0));
+            }
+            // * and in the corners of the gigen entity.
+            const auto& reference_element = ReferenceElements<D, d>::general(entity.type());
+            for (int ii = 0; ii < reference_element.size(d); ++ii) {
+              const auto xx = reference_element.position(ii, d);
+              auto diffusion = local_kappa->evaluate(xx);
+              diffusion *= local_lambda->evaluate(xx);
+              min_ev = std::min(min_ev,
+                                XT::LA::make_eigen_solver(
+                                    diffusion, XT::Common::Configuration{{"assert_positive_eigenvalues"}, {1e-15}})
+                                    .min_eigenvalues(1)
+                                    .at(0));
+            }
+          });
+          walker.walk();
+          return min_ev;
+        },
+        "dd_grid_provider"_a,
+        "subdomain"_a,
+        "lambda"_a,
+        "kappa"_a,
+        "over_integrate"_a = 2);
   m.def("RS2017_residual_indicator_subdomain_diameter",
         [](XT::Grid::GridProvider<ALU_2D_SIMPLEX_CONFORMING, XT::Grid::DD::SubdomainGrid<ALU_2D_SIMPLEX_CONFORMING>>&
                dd_grid_provider,
            const ssize_t subdomain) {
           py::gil_scoped_release DUNE_UNUSED(release);
-          auto subdomain_layer = dd_grid_provider.template layer<Layers::dd_subdomain, Backends::part>(
+          auto subdomain_layer = dd_grid_provider.template layer<Layers::dd_subdomain, Backends::view>(
               XT::Common::numeric_cast<size_t>(subdomain));
           typedef decltype(subdomain_layer) GL;
           XT::Grid::Walker<GL> walker(subdomain_layer);
@@ -144,7 +147,7 @@ PYBIND11_PLUGIN(__operators_RS2017)
            const XT::Functions::LocalizableFunctionInterface<E, D, d, R, 1>& v,
            const ssize_t over_integrate) {
           py::gil_scoped_release DUNE_UNUSED(release);
-          return GDT::make_l2_operator(dd_grid_provider.template layer<Layers::dd_subdomain, Backends::part>(
+          return GDT::make_l2_operator(dd_grid_provider.template layer<Layers::dd_subdomain, Backends::view>(
                                            XT::Common::numeric_cast<size_t>(subdomain)),
                                        XT::Common::numeric_cast<size_t>(over_integrate))
               ->apply2(u, v);
@@ -166,7 +169,7 @@ PYBIND11_PLUGIN(__operators_RS2017)
                                                                   1>::type,
                                       XT::LA::IstlRowMajorSparseMatrix<double>,
                                       typename XT::Grid::
-                                          Layer<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, Backends::part>::type>
+                                          Layer<ALU_2D_SIMPLEX_CONFORMING, Layers::dd_subdomain, Backends::view>::type>
       EllipticMatrixOperatorType;
   try { // we might not be the first to add this
     py::class_<EllipticMatrixOperatorType,
@@ -188,7 +191,7 @@ PYBIND11_PLUGIN(__operators_RS2017)
                                                 lambda,
                                                 kappa,
                                                 space,
-                                                dd_grid_provider.template layer<Layers::dd_subdomain, Backends::part>(
+                                                dd_grid_provider.template layer<Layers::dd_subdomain, Backends::view>(
                                                     XT::Common::numeric_cast<int>(subdomain)));
         },
         "dd_grid_provider"_a,
diff --git a/dune/gdt/playground/operators/RS2017.hh b/dune/gdt/playground/operators/RS2017.hh
index 78b535b62..79734a769 100644
--- a/dune/gdt/playground/operators/RS2017.hh
+++ b/dune/gdt/playground/operators/RS2017.hh
@@ -58,7 +58,7 @@ class DiffusiveFluxAaProduct
                                                                  1>::type,
                                      typename XT::Grid::Layer<G,
                                                               XT::Grid::Layers::dd_subdomain,
-                                                              XT::Grid::Backends::part,
+                                                              XT::Grid::Backends::view,
                                                               XT::Grid::DD::SubdomainGrid<G>>::type>
 {
   static_assert(XT::Grid::is_grid<G>::value, "");
@@ -69,7 +69,7 @@ class DiffusiveFluxAaProduct
                                   typename SP::type,
                                   typename XT::Grid::Layer<G,
                                                            XT::Grid::Layers::dd_subdomain,
-                                                           XT::Grid::Backends::part,
+                                                           XT::Grid::Backends::view,
                                                            XT::Grid::DD::SubdomainGrid<G>>::type>
       BaseType;
   typedef DiffusiveFluxAaProduct<G> ThisType;
@@ -109,7 +109,7 @@ public:
              const size_t over_integrate) {
             return new ThisType(
                 space,
-                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::part>(
+                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::view>(
                     XT::Common::numeric_cast<size_t>(subdomain)),
                 lambda_hat,
                 lambda_u,
@@ -216,7 +216,7 @@ class DiffusiveFluxAbProduct
                                                          1>::type,
                              typename XT::Grid::Layer<G,
                                                       XT::Grid::Layers::dd_subdomain,
-                                                      XT::Grid::Backends::part,
+                                                      XT::Grid::Backends::view,
                                                       XT::Grid::DD::SubdomainGrid<G>>::type,
                              GDT::RestrictedSpace<typename GDT::SpaceProvider<G,
                                                                               XT::Grid::Layers::leaf,
@@ -227,7 +227,7 @@ class DiffusiveFluxAbProduct
                                                                               G::dimension>::type,
                                                   typename XT::Grid::Layer<G,
                                                                            XT::Grid::Layers::dd_subdomain,
-                                                                           XT::Grid::Backends::part,
+                                                                           XT::Grid::Backends::view,
                                                                            XT::Grid::DD::SubdomainGrid<G>>::type>>
 {
   static_assert(XT::Grid::is_grid<G>::value, "");
@@ -241,7 +241,7 @@ class DiffusiveFluxAbProduct
                                                               1>::type,
                                   typename XT::Grid::Layer<G,
                                                            XT::Grid::Layers::dd_subdomain,
-                                                           XT::Grid::Backends::part,
+                                                           XT::Grid::Backends::view,
                                                            XT::Grid::DD::SubdomainGrid<G>>::type,
                                   GDT::RestrictedSpace<typename GDT::SpaceProvider<G,
                                                                                    XT::Grid::Layers::leaf,
@@ -252,7 +252,7 @@ class DiffusiveFluxAbProduct
                                                                                    G::dimension>::type,
                                                        typename XT::Grid::Layer<G,
                                                                                 XT::Grid::Layers::dd_subdomain,
-                                                                                XT::Grid::Backends::part,
+                                                                                XT::Grid::Backends::view,
                                                                                 XT::Grid::DD::SubdomainGrid<G>>::type>>
       BaseType;
   typedef DiffusiveFluxAbProduct<G> ThisType;
@@ -297,7 +297,7 @@ public:
             return new ThisType(
                 range_space,
                 source_space,
-                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::part>(
+                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::view>(
                     XT::Common::numeric_cast<size_t>(subdomain)),
                 lambda_hat,
                 lambda_range,
@@ -400,11 +400,11 @@ class DiffusiveFluxBbProduct
                                                                               G::dimension>::type,
                                                   typename XT::Grid::Layer<G,
                                                                            XT::Grid::Layers::dd_subdomain,
-                                                                           XT::Grid::Backends::part,
+                                                                           XT::Grid::Backends::view,
                                                                            XT::Grid::DD::SubdomainGrid<G>>::type>,
                              typename XT::Grid::Layer<G,
                                                       XT::Grid::Layers::dd_subdomain,
-                                                      XT::Grid::Backends::part,
+                                                      XT::Grid::Backends::view,
                                                       XT::Grid::DD::SubdomainGrid<G>>::type>
 {
   static_assert(XT::Grid::is_grid<G>::value, "");
@@ -418,11 +418,11 @@ class DiffusiveFluxBbProduct
                                                                                    G::dimension>::type,
                                                        typename XT::Grid::Layer<G,
                                                                                 XT::Grid::Layers::dd_subdomain,
-                                                                                XT::Grid::Backends::part,
+                                                                                XT::Grid::Backends::view,
                                                                                 XT::Grid::DD::SubdomainGrid<G>>::type>,
                                   typename XT::Grid::Layer<G,
                                                            XT::Grid::Layers::dd_subdomain,
-                                                           XT::Grid::Backends::part,
+                                                           XT::Grid::Backends::view,
                                                            XT::Grid::DD::SubdomainGrid<G>>::type>
       BaseType;
   typedef DiffusiveFluxBbProduct<G> ThisType;
@@ -462,7 +462,7 @@ public:
              const size_t over_integrate) {
             return new ThisType(
                 space,
-                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::part>(
+                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::view>(
                     XT::Common::numeric_cast<size_t>(subdomain)),
                 lambda_hat,
                 kappa,
@@ -552,7 +552,7 @@ class SwipdgPenaltySubdomainProduct
                                                                  1>::type,
                                      typename XT::Grid::Layer<G,
                                                               XT::Grid::Layers::dd_subdomain,
-                                                              XT::Grid::Backends::part,
+                                                              XT::Grid::Backends::view,
                                                               XT::Grid::DD::SubdomainGrid<G>>::type>
 {
   static_assert(XT::Grid::is_grid<G>::value, "");
@@ -562,7 +562,7 @@ class SwipdgPenaltySubdomainProduct
                                   typename SP::type,
                                   typename XT::Grid::Layer<G,
                                                            XT::Grid::Layers::dd_subdomain,
-                                                           XT::Grid::Backends::part,
+                                                           XT::Grid::Backends::view,
                                                            XT::Grid::DD::SubdomainGrid<G>>::type>
       BaseType;
   typedef SwipdgPenaltySubdomainProduct<G> ThisType;
@@ -601,7 +601,7 @@ public:
              const size_t over_integrate) {
             return new ThisType(
                 space,
-                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::part>(
+                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::view>(
                     XT::Common::numeric_cast<size_t>(subdomain)),
                 boundary_info,
                 lambda,
@@ -791,7 +791,7 @@ void bind_neighborhood_discretization(pybind11::module& m)
 
   typedef typename XT::Grid::Layer<G,
                                    XT::Grid::Layers::dd_subdomain_oversampled,
-                                   XT::Grid::Backends::part,
+                                   XT::Grid::Backends::view,
                                    XT::Grid::DD::SubdomainGrid<G>>::type NGL;
   typedef GDT::
       SpaceProvider<G, XT::Grid::Layers::dd_subdomain, GDT::SpaceType::block_dg, GDT::Backends::gdt, 1, double, 1>
@@ -801,7 +801,7 @@ void bind_neighborhood_discretization(pybind11::module& m)
   typedef XT::LA::IstlRowMajorSparseMatrix<R> M;
 
   try { // we might not be the first to add this SystemAssembler
-    GDT::bindings::SystemAssembler<SP, XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::part>::bind(m);
+    GDT::bindings::SystemAssembler<SP, XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::view>::bind(m);
   } catch (std::runtime_error&) {
   }
 
@@ -811,7 +811,7 @@ void bind_neighborhood_discretization(pybind11::module& m)
            const S& neighborhood_space) {
           return new GDT::SystemAssembler<S, NGL>(
               neighborhood_space,
-              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::part>(
+              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::view>(
                   XT::Common::numeric_cast<size_t>(subdomain)));
         });
 
@@ -836,7 +836,7 @@ void bind_neighborhood_discretization(pybind11::module& m)
               lambda,
               kappa,
               neighborhood_space,
-              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::part>(
+              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::view>(
                   XT::Common::numeric_cast<size_t>(subdomain)));
         },
         "dd_grid_provider"_a,
@@ -875,7 +875,7 @@ void bind_neighborhood_discretization(pybind11::module& m)
               lambda,
               kappa,
               neighborhood_space,
-              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::part>(
+              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::view>(
                   XT::Common::numeric_cast<size_t>(subdomain)));
         },
         "dd_grid_provider"_a,
@@ -902,7 +902,7 @@ void bind_neighborhood_discretization(pybind11::module& m)
               over_integrate,
               f,
               neighborhood_space,
-              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::part>(
+              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::view>(
                   XT::Common::numeric_cast<size_t>(subdomain)));
         },
         "dd_grid_provider"_a,
@@ -926,11 +926,11 @@ class HdivSemiProduct
                                                                               G::dimension>::type,
                                                   typename XT::Grid::Layer<G,
                                                                            XT::Grid::Layers::dd_subdomain,
-                                                                           XT::Grid::Backends::part,
+                                                                           XT::Grid::Backends::view,
                                                                            XT::Grid::DD::SubdomainGrid<G>>::type>,
                              typename XT::Grid::Layer<G,
                                                       XT::Grid::Layers::dd_subdomain,
-                                                      XT::Grid::Backends::part,
+                                                      XT::Grid::Backends::view,
                                                       XT::Grid::DD::SubdomainGrid<G>>::type>
 {
   static_assert(XT::Grid::is_grid<G>::value, "");
@@ -944,11 +944,11 @@ class HdivSemiProduct
                                                                                    G::dimension>::type,
                                                        typename XT::Grid::Layer<G,
                                                                                 XT::Grid::Layers::dd_subdomain,
-                                                                                XT::Grid::Backends::part,
+                                                                                XT::Grid::Backends::view,
                                                                                 XT::Grid::DD::SubdomainGrid<G>>::type>,
                                   typename XT::Grid::Layer<G,
                                                            XT::Grid::Layers::dd_subdomain,
-                                                           XT::Grid::Backends::part,
+                                                           XT::Grid::Backends::view,
                                                            XT::Grid::DD::SubdomainGrid<G>>::type>
       BaseType;
   typedef HdivSemiProduct<G> ThisType;
@@ -984,7 +984,7 @@ public:
              const size_t over_integrate) {
             return new ThisType(
                 space,
-                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::part>(
+                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::view>(
                     XT::Common::numeric_cast<size_t>(subdomain)),
                 over_integrate);
           },
@@ -1043,11 +1043,11 @@ class ResidualPartFunctional
                                                                                 G::dimension>::type,
                                                     typename XT::Grid::Layer<G,
                                                                              XT::Grid::Layers::dd_subdomain,
-                                                                             XT::Grid::Backends::part,
+                                                                             XT::Grid::Backends::view,
                                                                              XT::Grid::DD::SubdomainGrid<G>>::type>,
                                typename XT::Grid::Layer<G,
                                                         XT::Grid::Layers::dd_subdomain,
-                                                        XT::Grid::Backends::part,
+                                                        XT::Grid::Backends::view,
                                                         XT::Grid::DD::SubdomainGrid<G>>::type>
 {
   static_assert(XT::Grid::is_grid<G>::value, "");
@@ -1056,13 +1056,13 @@ class ResidualPartFunctional
           SpaceProvider<G, XT::Grid::Layers::leaf, GDT::SpaceType::rt, GDT::Backends::gdt, 0, double, G::dimension>::
               type,
       typename XT::Grid::
-          Layer<G, XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::part, XT::Grid::DD::SubdomainGrid<G>>::type>
+          Layer<G, XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::view, XT::Grid::DD::SubdomainGrid<G>>::type>
       RtSpaceType;
   typedef GDT::VectorFunctionalBase<XT::LA::IstlDenseVector<double>,
                                     RtSpaceType,
                                     typename XT::Grid::Layer<G,
                                                              XT::Grid::Layers::dd_subdomain,
-                                                             XT::Grid::Backends::part,
+                                                             XT::Grid::Backends::view,
                                                              XT::Grid::DD::SubdomainGrid<G>>::type>
       BaseType;
   typedef ResidualPartFunctional<G> ThisType;
@@ -1100,7 +1100,7 @@ public:
              const size_t over_integrate) {
             return new ThisType(
                 space,
-                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::part>(
+                dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain, XT::Grid::Backends::view>(
                     XT::Common::numeric_cast<size_t>(subdomain)),
                 f,
                 over_integrate);
@@ -1164,7 +1164,7 @@ void bind_neighborhood_reconstruction(pybind11::module& m)
   typedef GDT::RaviartThomasSpace<LeafViewType, 0> RtSpaceType;
   typedef typename XT::Grid::Layer<G,
                                    XT::Grid::Layers::dd_subdomain_oversampled,
-                                   XT::Grid::Backends::part,
+                                   XT::Grid::Backends::view,
                                    XT::Grid::DD::SubdomainGrid<G>>::type NeighborHoodGridLayer;
   typedef GDT::RestrictedSpace<RtSpaceType, NeighborHoodGridLayer> NeighborhoodRtSpaceType;
   typedef XT::LA::IstlDenseVector<R> VectorType;
@@ -1185,7 +1185,7 @@ void bind_neighborhood_reconstruction(pybind11::module& m)
            const ssize_t over_integrate) {
           py::gil_scoped_release DUNE_UNUSED(release);
           LocalizableDiffusiveFluxReconstructionOperatorForRestrictedSpaceType(
-              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::part>(
+              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::view>(
                   XT::Common::numeric_cast<size_t>(subdomain)),
               lambda,
               kappa,
@@ -1219,7 +1219,7 @@ void bind_neighborhood_reconstruction(pybind11::module& m)
            const ssize_t over_integrate) {
           py::gil_scoped_release DUNE_UNUSED(release);
           LocalizableDiffusiveFluxReconstructionOperatorForLeafSpaceType(
-              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::part>(
+              dd_grid_provider.template layer<XT::Grid::Layers::dd_subdomain_oversampled, XT::Grid::Backends::view>(
                   XT::Common::numeric_cast<size_t>(subdomain)),
               lambda,
               kappa,
diff --git a/dune/gdt/playground/spaces/block.bindings.hh b/dune/gdt/playground/spaces/block.bindings.hh
index 69211dfb1..9b8bcf207 100644
--- a/dune/gdt/playground/spaces/block.bindings.hh
+++ b/dune/gdt/playground/spaces/block.bindings.hh
@@ -318,11 +318,11 @@ public:
           [](const type& self, const ssize_t block, const std::string tp) {
             auto bb = XT::Common::numeric_cast<size_t>(block);
             if (tp == "volume")
-              return self.local_space(bb).compute_volume_pattern(self.dd_grid().boundaryGridPart(bb));
+              return self.local_space(bb).compute_volume_pattern(self.dd_grid().boundary_grid_view(bb));
             else if (tp == "face")
-              return self.local_space(bb).compute_face_pattern(self.dd_grid().boundaryGridPart(bb));
+              return self.local_space(bb).compute_face_pattern(self.dd_grid().boundary_grid_view(bb));
             else if (tp == "face_and_volume")
-              return self.local_space(bb).compute_face_and_volume_pattern(self.dd_grid().boundaryGridPart(bb));
+              return self.local_space(bb).compute_face_and_volume_pattern(self.dd_grid().boundary_grid_view(bb));
             else
               DUNE_THROW(XT::Common::Exceptions::wrong_input_given,
                          "  type has to be one of ('volume', 'face', 'face_and_volume'), is '" << tp << "'!");
@@ -336,13 +336,13 @@ public:
             auto ss = XT::Common::numeric_cast<size_t>(subdomain);
             auto nn = XT::Common::numeric_cast<size_t>(neighbor);
             if (tp == "volume")
-              return self.local_space(ss).compute_volume_pattern(self.dd_grid().couplingGridPart(ss, nn),
+              return self.local_space(ss).compute_volume_pattern(self.dd_grid().coupling_grid_view(ss, nn),
                                                                  self.local_space(nn));
             else if (tp == "face")
-              return self.local_space(ss).compute_face_pattern(self.dd_grid().couplingGridPart(ss, nn),
+              return self.local_space(ss).compute_face_pattern(self.dd_grid().coupling_grid_view(ss, nn),
                                                                self.local_space(nn));
             else if (tp == "face_and_volume")
-              return self.local_space(ss).compute_face_and_volume_pattern(self.dd_grid().couplingGridPart(ss, nn),
+              return self.local_space(ss).compute_face_and_volume_pattern(self.dd_grid().coupling_grid_view(ss, nn),
                                                                           self.local_space(nn));
             else
               DUNE_THROW(XT::Common::Exceptions::wrong_input_given,
@@ -356,7 +356,7 @@ public:
     c.def("boundary_assembler",
           [](const type& self, const ssize_t subdomain) {
             auto ss = XT::Common::numeric_cast<size_t>(subdomain);
-            auto boundary_grid_part = self.dd_grid().boundaryGridPart(ss);
+            auto boundary_grid_part = self.dd_grid().boundary_grid_view(ss);
             return new GDT::SystemAssembler<S, decltype(boundary_grid_part), S>(self.local_space(ss), // see below for
                                                                                 boundary_grid_part); //  the 'new'
           },
@@ -365,7 +365,7 @@ public:
           [](const type& self, const ssize_t subdomain, const ssize_t neighbor) {
             auto ss = XT::Common::numeric_cast<size_t>(subdomain);
             auto nn = XT::Common::numeric_cast<size_t>(neighbor);
-            auto coupling_grid_part = self.dd_grid().couplingGridPart(ss, nn);
+            auto coupling_grid_part = self.dd_grid().coupling_grid_view(ss, nn);
             return new GDT::SystemAssembler<S, decltype(coupling_grid_part), S>(coupling_grid_part, //   SystemAssembler
                                                                                 self.local_space(ss), // is not copyable
                                                                                 self.local_space(ss), // or movable,
@@ -441,6 +441,7 @@ public:
 
 
 #define DUNE_GDT_SPACES_BLOCK_BIND(_m) _DUNE_GDT_SPACES_BLOCK_BIND_ALL_GRIDS(_m, dg, gdt, 1)
+#define _DUNE_GDT_SPACES_BLOCK_BIND_FEM(_m) _DUNE_GDT_SPACES_BLOCK_BIND_ALL_GRIDS(_m, dg, gdt, 1)
 
 // end: this is what we need for the .so
 
diff --git a/dune/gdt/playground/spaces/block.hh b/dune/gdt/playground/spaces/block.hh
index 70b375b2a..3c5beaf15 100644
--- a/dune/gdt/playground/spaces/block.hh
+++ b/dune/gdt/playground/spaces/block.hh
@@ -47,10 +47,10 @@ public:
   typedef std::vector<std::shared_ptr<const LocalSpaceType>> BackendType;
   typedef BlockMapper<LocalSpaceType> MapperType;
   typedef typename LocalSpaceType::BaseFunctionSetType BaseFunctionSetType;
-  typedef typename DdSubdomainsGridType::GlobalGridPartType GridLayerType;
+  typedef typename DdSubdomainsGridType::GlobalGridViewType GridLayerType;
   typedef typename LocalSpaceType::RangeFieldType RangeFieldType;
 
-  static const XT::Grid::Backends layer_backend = XT::Grid::Backends::part;
+  static const XT::Grid::Backends layer_backend = XT::Grid::Backends::view;
   static const constexpr Backends backend_type{Backends::gdt};
   using DofCommunicationChooserType = DofCommunicationChooser<GridLayerType, true>;
   using DofCommunicatorType = typename DofCommunicationChooserType::Type;
@@ -94,7 +94,7 @@ public:
   BlockSpace(const DdSubdomainsGridType& grid, const std::vector<std::shared_ptr<const LocalSpaceType>>& spaces)
     : dd_grid_(grid)
     , entity_to_subdomain_map_(dd_grid_.entityToSubdomainMap())
-    , global_grid_part_(new GridLayerType(dd_grid_.globalGridPart()))
+    , global_grid_part_(new GridLayerType(dd_grid_.global_grid_view()))
     , local_spaces_(new std::vector<std::shared_ptr<const LocalSpaceType>>(spaces))
     , mapper_(new MapperType(dd_grid_, global_grid_part_, local_spaces_))
     , communicator_(Traits::DofCommunicationChooserType::create(*global_grid_part_))
diff --git a/dune/gdt/playground/spaces/mapper/block.hh b/dune/gdt/playground/spaces/mapper/block.hh
index 52106eda8..747edf41e 100644
--- a/dune/gdt/playground/spaces/mapper/block.hh
+++ b/dune/gdt/playground/spaces/mapper/block.hh
@@ -63,7 +63,7 @@ public:
       DdSubdomainsGridType;
 
 private:
-  typedef typename DdSubdomainsGridType::GlobalGridPartType GridLayerType;
+  typedef typename DdSubdomainsGridType::GlobalGridViewType GridLayerType;
   typedef typename DdSubdomainsGridType::EntityToSubdomainMapType EntityToSubdomainMapType;
 
   template <class L, class E>
diff --git a/dune/gdt/projections.bindings.hh b/dune/gdt/projections.bindings.hh
index 284182a6e..e8b532254 100644
--- a/dune/gdt/projections.bindings.hh
+++ b/dune/gdt/projections.bindings.hh
@@ -107,20 +107,11 @@ public:
 #define _DUNE_GDT_PROJECTIONS_BIND_DEFAULT(_m, _la)                                                                    \
   _DUNE_GDT_PROJECTIONS_BIND_ALL_GRIDS(_m, leaf, gdt, fv, 0, _la);                                                     \
   _DUNE_GDT_PROJECTIONS_BIND_ALL_GRIDS(_m, dd_subdomain, gdt, cg, 1, _la);                                             \
-  _DUNE_GDT_PROJECTIONS_BIND_ALL_GRIDS(_m, level, gdt, fv, 0, _la)
+  _DUNE_GDT_PROJECTIONS_BIND_ALL_GRIDS(_m, level, gdt, fv, 0, _la);                                                    \
+  _DUNE_GDT_PROJECTIONS_BIND_ALL_GRIDS(_m, dd_subdomain, gdt, dg, 1, _la)
 
-#define _DUNE_GDT_PROJECTIONS_BIND(_m, _la) _DUNE_GDT_PROJECTIONS_BIND_ALL_GRIDS(_m, dd_subdomain, gdt, dg, 1, _la)
 
-//#if HAVE_DUNE_FUNCTIONS
-//  ...
-//#else
-#define _DUNE_GDT_PROJECTIONS_BIND_FUNCTIONS(_m, _la)
-//#endif
-
-#define _DUNE_GDT_PROJECTIONS_BIND_ALL_SPACES(_m, _la)                                                                 \
-  _DUNE_GDT_PROJECTIONS_BIND_DEFAULT(_m, _la);                                                                         \
-  _DUNE_GDT_PROJECTIONS_BIND(_m, _la);                                                                                 \
-  _DUNE_GDT_PROJECTIONS_BIND_FUNCTIONS(_m, _la)
+#define _DUNE_GDT_PROJECTIONS_BIND_ALL_SPACES(_m, _la) _DUNE_GDT_PROJECTIONS_BIND_DEFAULT(_m, _la);
 
 // for each la backend
 
diff --git a/dune/gdt/spaces/constraints.bindings.hh b/dune/gdt/spaces/constraints.bindings.hh
index c54f060ab..73431cfb8 100644
--- a/dune/gdt/spaces/constraints.bindings.hh
+++ b/dune/gdt/spaces/constraints.bindings.hh
@@ -204,7 +204,7 @@ public:
 #define _DUNE_GDT_SPACES_CONSTRAINTS_BIND_ALU(_m)                                                                      \
   _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, ALU_2D_SIMPLEX_CONFORMING, leaf, view, "leaf");                                \
   _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, ALU_2D_SIMPLEX_CONFORMING, level, view, "level");                              \
-  _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, ALU_2D_SIMPLEX_CONFORMING, dd_subdomain, part, "dd_subdomain")
+  _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, ALU_2D_SIMPLEX_CONFORMING, dd_subdomain, view, "dd_subdomain")
 #else
 #define _DUNE_GDT_SPACES_CONSTRAINTS_BIND_ALU(_m)
 #endif
@@ -220,9 +220,9 @@ public:
 
 #define _DUNE_GDT_SPACES_CONSTRAINTS_BIND_YASP(_m)                                                                     \
   _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, YASP_1D_EQUIDISTANT_OFFSET, leaf, view, "");                                   \
-  _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, YASP_1D_EQUIDISTANT_OFFSET, dd_subdomain, part, "dd_subdomain");               \
+  _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, YASP_1D_EQUIDISTANT_OFFSET, dd_subdomain, view, "dd_subdomain");               \
   _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, YASP_2D_EQUIDISTANT_OFFSET, leaf, view, "");                                   \
-  _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, YASP_2D_EQUIDISTANT_OFFSET, dd_subdomain, part, "dd_subdomain")
+  _DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m, YASP_2D_EQUIDISTANT_OFFSET, dd_subdomain, view, "dd_subdomain")
 
 #define DUNE_GDT_SPACES_CONSTRAINTS_BIND(_m)                                                                           \
   _DUNE_GDT_SPACES_CONSTRAINTS_BIND_ALBERTA(_m);                                                                       \
diff --git a/dune/gdt/spaces/interface.bindings.hh b/dune/gdt/spaces/interface.bindings.hh
index 754d5724e..828a1d3b1 100644
--- a/dune/gdt/spaces/interface.bindings.hh
+++ b/dune/gdt/spaces/interface.bindings.hh
@@ -534,14 +534,9 @@ public:
     const auto sp_name = space_name<SP>::value();
     auto c = SpaceInterfaceWoFactory<S>::bind(m, sp_name);
 
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::adaptive_leaf>(m, c, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::dd_subdomain>(m, c, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::dd_subdomain_boundary>(m, c, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::dd_subdomain_coupling>(m, c, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::dd_subdomain_oversampled>(m, c, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::leaf>(m, c, sp_name);
-    addbind_restricted<XT::Grid::Backends::part, XT::Grid::Layers::level>(m, c, sp_name);
     addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::dd_subdomain>(m, c, sp_name);
+    addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::dd_subdomain_boundary>(m, c, sp_name);
+    addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::dd_subdomain_coupling>(m, c, sp_name);
     addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::dd_subdomain_oversampled>(m, c, sp_name);
     addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::leaf>(m, c, sp_name);
     addbind_restricted<XT::Grid::Backends::view, XT::Grid::Layers::level>(m, c, sp_name);
diff --git a/dune/gdt/spaces/interface.hh b/dune/gdt/spaces/interface.hh
index c8460b430..5c9f00173 100644
--- a/dune/gdt/spaces/interface.hh
+++ b/dune/gdt/spaces/interface.hh
@@ -99,7 +99,6 @@ struct space_type_dependent_typename
 
 static constexpr Backends default_space_backend = Backends::gdt;
 
-
 enum class ChoosePattern
 {
   volume,
diff --git a/dune/gdt/test/grids.hh b/dune/gdt/test/grids.hh
index c513c3c72..a90ad870a 100644
--- a/dune/gdt/test/grids.hh
+++ b/dune/gdt/test/grids.hh
@@ -21,12 +21,6 @@
 #include <dune/xt/grid/type_traits.hh>
 
 #define YASPGRID_TYPES(dim)                                                                                            \
-  typedef typename Dune::XT::Grid::Layer<Dune::YaspGrid<dim, Dune::EquidistantOffsetCoordinates<double, dim>>,         \
-                                         Dune::XT::Grid::Layers::leaf,                                                 \
-                                         Dune::XT::Grid::Backends::part>::type Yasp##dim##dLeafGridPartType;           \
-  typedef typename Dune::XT::Grid::Layer<Dune::YaspGrid<dim, Dune::EquidistantOffsetCoordinates<double, dim>>,         \
-                                         Dune::XT::Grid::Layers::level,                                                \
-                                         Dune::XT::Grid::Backends::part>::type Yasp##dim##dLevelGridPartType;          \
   typedef typename Dune::XT::Grid::Layer<Dune::YaspGrid<dim, Dune::EquidistantOffsetCoordinates<double, dim>>,         \
                                          Dune::XT::Grid::Layers::leaf,                                                 \
                                          Dune::XT::Grid::Backends::view>::type Yasp##dim##dLeafGridViewType;           \
@@ -47,12 +41,6 @@ typedef Dune::ALUGridNoComm AluComm;
 #endif
 
 typedef Dune::ALUGrid<2, 2, Dune::simplex, Dune::conforming, AluComm> AluConform2dGridType;
-typedef typename Dune::XT::Grid::Layer<AluConform2dGridType,
-                                       Dune::XT::Grid::Layers::leaf,
-                                       Dune::XT::Grid::Backends::part>::type AluConform2dLeafGridPartType;
-typedef typename Dune::XT::Grid::Layer<AluConform2dGridType,
-                                       Dune::XT::Grid::Layers::level,
-                                       Dune::XT::Grid::Backends::part>::type AluConform2dLevelGridPartType;
 typedef typename Dune::XT::Grid::Layer<AluConform2dGridType,
                                        Dune::XT::Grid::Layers::leaf,
                                        Dune::XT::Grid::Backends::view>::type AluConform2dLeafGridViewType;
@@ -62,12 +50,6 @@ typedef typename Dune::XT::Grid::Layer<AluConform2dGridType,
 
 // typedef Dune::ALUGrid<3, 3, Dune::simplex, Dune::conforming, AluComm> AluConform3dGridType;
 typedef Dune::YaspGrid<3, Dune::EquidistantOffsetCoordinates<double, 3>> AluConform3dGridType;
-typedef typename Dune::XT::Grid::Layer<AluConform3dGridType,
-                                       Dune::XT::Grid::Layers::leaf,
-                                       Dune::XT::Grid::Backends::part>::type AluConform3dLeafGridPartType;
-typedef typename Dune::XT::Grid::Layer<AluConform3dGridType,
-                                       Dune::XT::Grid::Layers::level,
-                                       Dune::XT::Grid::Backends::part>::type AluConform3dLevelGridPartType;
 typedef typename Dune::XT::Grid::Layer<AluConform3dGridType,
                                        Dune::XT::Grid::Layers::leaf,
                                        Dune::XT::Grid::Backends::view>::type AluConform3dLeafGridViewType;
@@ -76,12 +58,6 @@ typedef typename Dune::XT::Grid::Layer<AluConform3dGridType,
                                        Dune::XT::Grid::Backends::view>::type AluConform3dLevelGridViewType;
 
 typedef Dune::ALUGrid<2, 2, Dune::simplex, Dune::nonconforming, AluComm> AluSimplex2dGridType;
-typedef typename Dune::XT::Grid::Layer<AluSimplex2dGridType,
-                                       Dune::XT::Grid::Layers::leaf,
-                                       Dune::XT::Grid::Backends::part>::type AluSimplex2dLeafGridPartType;
-typedef typename Dune::XT::Grid::Layer<AluSimplex2dGridType,
-                                       Dune::XT::Grid::Layers::level,
-                                       Dune::XT::Grid::Backends::part>::type AluSimplex2dLevelGridPartType;
 typedef typename Dune::XT::Grid::Layer<AluSimplex2dGridType,
                                        Dune::XT::Grid::Layers::leaf,
                                        Dune::XT::Grid::Backends::view>::type AluSimplex2dLeafGridViewType;
@@ -90,12 +66,6 @@ typedef typename Dune::XT::Grid::Layer<AluSimplex2dGridType,
                                        Dune::XT::Grid::Backends::view>::type AluSimplex2dLevelGridViewType;
 
 typedef Dune::ALUGrid<3, 3, Dune::simplex, Dune::nonconforming, AluComm> AluSimplex3dGridType;
-typedef typename Dune::XT::Grid::Layer<AluSimplex3dGridType,
-                                       Dune::XT::Grid::Layers::leaf,
-                                       Dune::XT::Grid::Backends::part>::type AluSimplex3dLeafGridPartType;
-typedef typename Dune::XT::Grid::Layer<AluSimplex3dGridType,
-                                       Dune::XT::Grid::Layers::level,
-                                       Dune::XT::Grid::Backends::part>::type AluSimplex3dLevelGridPartType;
 typedef typename Dune::XT::Grid::Layer<AluSimplex3dGridType,
                                        Dune::XT::Grid::Layers::leaf,
                                        Dune::XT::Grid::Backends::view>::type AluSimplex3dLeafGridViewType;
@@ -104,12 +74,6 @@ typedef typename Dune::XT::Grid::Layer<AluSimplex3dGridType,
                                        Dune::XT::Grid::Backends::view>::type AluSimplex3dLevelGridViewType;
 
 typedef Dune::ALUGrid<2, 2, Dune::cube, Dune::nonconforming, AluComm> AluCube2dGridType;
-typedef typename Dune::XT::Grid::Layer<AluCube2dGridType,
-                                       Dune::XT::Grid::Layers::leaf,
-                                       Dune::XT::Grid::Backends::part>::type AluCube2dLeafGridPartType;
-typedef typename Dune::XT::Grid::Layer<AluCube2dGridType,
-                                       Dune::XT::Grid::Layers::level,
-                                       Dune::XT::Grid::Backends::part>::type AluCube2dLevelGridPartType;
 typedef typename Dune::XT::Grid::Layer<AluCube2dGridType,
                                        Dune::XT::Grid::Layers::leaf,
                                        Dune::XT::Grid::Backends::view>::type AluCube2dLeafGridViewType;
@@ -118,12 +82,6 @@ typedef typename Dune::XT::Grid::Layer<AluCube2dGridType,
                                        Dune::XT::Grid::Backends::view>::type AluCube2dLevelGridViewType;
 
 typedef Dune::ALUGrid<3, 3, Dune::cube, Dune::nonconforming, AluComm> AluCube3dGridType;
-typedef typename Dune::XT::Grid::Layer<AluCube3dGridType,
-                                       Dune::XT::Grid::Layers::leaf,
-                                       Dune::XT::Grid::Backends::part>::type AluCube3dLeafGridPartType;
-typedef typename Dune::XT::Grid::Layer<AluCube3dGridType,
-                                       Dune::XT::Grid::Layers::level,
-                                       Dune::XT::Grid::Backends::part>::type AluCube3dLevelGridPartType;
 typedef typename Dune::XT::Grid::Layer<AluCube3dGridType,
                                        Dune::XT::Grid::Layers::leaf,
                                        Dune::XT::Grid::Backends::view>::type AluCube3dLeafGridViewType;
-- 
GitLab