From 3262a9c7c7627162ea5d7c57e73c1aa3f80aadd5 Mon Sep 17 00:00:00 2001
From: Felix Schindler <felix.schindler@wwu.de>
Date: Thu, 9 Feb 2017 18:53:44 +0100
Subject: [PATCH] [bindings] split into multiple compile units
---
dune/gdt/CMakeLists.txt | 43 ++-
dune/gdt/assembler/system.bindings.cc | 45 +++
dune/gdt/assembler/system.bindings.hh | 134 ++++++++
dune/gdt/assembler/system.pbh | 114 -------
dune/gdt/bindings.cc | 316 +++++++++--------
dune/gdt/bindings.hh | 22 ++
dune/gdt/discretefunction.pbh | 79 -----
dune/gdt/discretefunction/default.bindings.cc | 72 ++++
dune/gdt/discretefunction/default.bindings.hh | 233 +++++++++++++
dune/gdt/operators/base.bindings.hh | 131 +++++++
dune/gdt/operators/base.pbh | 121 -------
dune/gdt/operators/elliptic-ipdg.bindings.hh | 319 ++++++++++++++++++
.../elliptic-ipdg.bindings/alu_common_fem.cc | 24 ++
.../elliptic-ipdg.bindings/alu_common_gdt.cc | 21 ++
.../alu_common_pdelab.cc | 23 ++
.../elliptic-ipdg.bindings/alu_eigen_fem.cc | 27 ++
.../elliptic-ipdg.bindings/alu_eigen_gdt.cc | 24 ++
.../alu_eigen_pdelab.cc | 26 ++
.../elliptic-ipdg.bindings/alu_istl_fem.cc | 26 ++
.../elliptic-ipdg.bindings/alu_istl_gdt.cc | 23 ++
.../elliptic-ipdg.bindings/alu_istl_pdelab.cc | 25 ++
.../elliptic-ipdg.bindings/yasp_common_fem.cc | 22 ++
.../elliptic-ipdg.bindings/yasp_common_gdt.cc | 19 ++
.../yasp_common_pdelab.cc | 21 ++
.../elliptic-ipdg.bindings/yasp_eigen_fem.cc | 25 ++
.../elliptic-ipdg.bindings/yasp_eigen_gdt.cc | 22 ++
.../yasp_eigen_pdelab.cc | 24 ++
.../elliptic-ipdg.bindings/yasp_istl_fem.cc | 24 ++
.../elliptic-ipdg.bindings/yasp_istl_gdt.cc | 21 ++
.../yasp_istl_pdelab.cc | 23 ++
dune/gdt/operators/elliptic-ipdg.pbh | 182 ----------
dune/gdt/operators/elliptic.bindings.hh | 269 +++++++++++++++
.../operators/elliptic.bindings/common_fem.cc | 28 ++
.../operators/elliptic.bindings/common_gdt.cc | 24 ++
.../elliptic.bindings/common_pdelab.cc | 28 ++
.../operators/elliptic.bindings/eigen_fem.cc | 34 ++
.../operators/elliptic.bindings/eigen_gdt.cc | 30 ++
.../elliptic.bindings/eigen_pdelab.cc | 34 ++
.../operators/elliptic.bindings/istl_fem.cc | 32 ++
.../operators/elliptic.bindings/istl_gdt.cc | 28 ++
.../elliptic.bindings/istl_pdelab.cc | 32 ++
dune/gdt/operators/elliptic.pbh | 151 ---------
dune/gdt/projections/dirichlet.bindings.cc | 58 ++++
dune/gdt/projections/dirichlet.bindings.hh | 135 ++++++++
dune/gdt/projections/dirichlet.pbh | 56 ---
dune/gdt/spaces.bindings.hh | 11 +
dune/gdt/spaces/cg.bindings.cc | 34 ++
dune/gdt/spaces/cg.bindings.hh | 78 +++++
dune/gdt/spaces/constraints.bindings.cc | 58 ++++
dune/gdt/spaces/constraints.bindings.hh | 190 +++++++++++
dune/gdt/spaces/constraints.pbh | 109 ------
dune/gdt/spaces/dg.bindings.cc | 28 ++
dune/gdt/spaces/dg.bindings.hh | 66 ++++
dune/gdt/spaces/fv.bindings.cc | 23 ++
dune/gdt/spaces/fv.bindings.hh | 55 +++
dune/gdt/spaces/interface.bindings.hh | 54 +++
56 files changed, 2921 insertions(+), 955 deletions(-)
create mode 100644 dune/gdt/assembler/system.bindings.cc
create mode 100644 dune/gdt/assembler/system.bindings.hh
delete mode 100644 dune/gdt/assembler/system.pbh
create mode 100644 dune/gdt/bindings.hh
delete mode 100644 dune/gdt/discretefunction.pbh
create mode 100644 dune/gdt/discretefunction/default.bindings.cc
create mode 100644 dune/gdt/discretefunction/default.bindings.hh
create mode 100644 dune/gdt/operators/base.bindings.hh
delete mode 100644 dune/gdt/operators/base.pbh
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings.hh
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/alu_common_fem.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/alu_common_gdt.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/alu_common_pdelab.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_fem.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_gdt.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_pdelab.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_fem.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_gdt.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_pdelab.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_fem.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_gdt.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_pdelab.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_fem.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_gdt.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_pdelab.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_fem.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_gdt.cc
create mode 100644 dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_pdelab.cc
delete mode 100644 dune/gdt/operators/elliptic-ipdg.pbh
create mode 100644 dune/gdt/operators/elliptic.bindings.hh
create mode 100644 dune/gdt/operators/elliptic.bindings/common_fem.cc
create mode 100644 dune/gdt/operators/elliptic.bindings/common_gdt.cc
create mode 100644 dune/gdt/operators/elliptic.bindings/common_pdelab.cc
create mode 100644 dune/gdt/operators/elliptic.bindings/eigen_fem.cc
create mode 100644 dune/gdt/operators/elliptic.bindings/eigen_gdt.cc
create mode 100644 dune/gdt/operators/elliptic.bindings/eigen_pdelab.cc
create mode 100644 dune/gdt/operators/elliptic.bindings/istl_fem.cc
create mode 100644 dune/gdt/operators/elliptic.bindings/istl_gdt.cc
create mode 100644 dune/gdt/operators/elliptic.bindings/istl_pdelab.cc
delete mode 100644 dune/gdt/operators/elliptic.pbh
create mode 100644 dune/gdt/projections/dirichlet.bindings.cc
create mode 100644 dune/gdt/projections/dirichlet.bindings.hh
delete mode 100644 dune/gdt/projections/dirichlet.pbh
create mode 100644 dune/gdt/spaces.bindings.hh
create mode 100644 dune/gdt/spaces/cg.bindings.cc
create mode 100644 dune/gdt/spaces/cg.bindings.hh
create mode 100644 dune/gdt/spaces/constraints.bindings.cc
create mode 100644 dune/gdt/spaces/constraints.bindings.hh
delete mode 100644 dune/gdt/spaces/constraints.pbh
create mode 100644 dune/gdt/spaces/dg.bindings.cc
create mode 100644 dune/gdt/spaces/dg.bindings.hh
create mode 100644 dune/gdt/spaces/fv.bindings.cc
create mode 100644 dune/gdt/spaces/fv.bindings.hh
create mode 100644 dune/gdt/spaces/interface.bindings.hh
diff --git a/dune/gdt/CMakeLists.txt b/dune/gdt/CMakeLists.txt
index a947bbf66..efa0f6721 100644
--- a/dune/gdt/CMakeLists.txt
+++ b/dune/gdt/CMakeLists.txt
@@ -1,13 +1,52 @@
# This file is part of the dune-gdt project:
# https://github.com/dune-community/dune-gdt
# Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
-# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+# License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+# or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
+# with "runtime exception" (http://www.dune-project.org/license.html)
# Authors:
-# Felix Schindler (2010, 2013 - 2016)
+# Felix Schindler (2010, 2013 - 2017)
if(dune-pybindxi_FOUND)
+ dune_pybindxi_add_helper_lib(_gdt_bindings_helper
+ assembler/system.bindings.cc
+ discretefunction/default.bindings.cc
+ operators/elliptic-ipdg.bindings/alu_common_fem.cc
+ operators/elliptic-ipdg.bindings/alu_common_gdt.cc
+ operators/elliptic-ipdg.bindings/alu_common_pdelab.cc
+ operators/elliptic-ipdg.bindings/alu_eigen_fem.cc
+ operators/elliptic-ipdg.bindings/alu_eigen_gdt.cc
+ operators/elliptic-ipdg.bindings/alu_eigen_pdelab.cc
+ operators/elliptic-ipdg.bindings/alu_istl_fem.cc
+ operators/elliptic-ipdg.bindings/alu_istl_gdt.cc
+ operators/elliptic-ipdg.bindings/alu_istl_pdelab.cc
+ operators/elliptic-ipdg.bindings/yasp_common_fem.cc
+ operators/elliptic-ipdg.bindings/yasp_common_gdt.cc
+ operators/elliptic-ipdg.bindings/yasp_common_pdelab.cc
+ operators/elliptic-ipdg.bindings/yasp_eigen_fem.cc
+ operators/elliptic-ipdg.bindings/yasp_eigen_gdt.cc
+ operators/elliptic-ipdg.bindings/yasp_eigen_pdelab.cc
+ operators/elliptic-ipdg.bindings/yasp_istl_fem.cc
+ operators/elliptic-ipdg.bindings/yasp_istl_gdt.cc
+ operators/elliptic-ipdg.bindings/yasp_istl_pdelab.cc
+ operators/elliptic.bindings/common_fem.cc
+ operators/elliptic.bindings/common_gdt.cc
+ operators/elliptic.bindings/common_pdelab.cc
+ operators/elliptic.bindings/eigen_fem.cc
+ operators/elliptic.bindings/eigen_gdt.cc
+ operators/elliptic.bindings/eigen_pdelab.cc
+ operators/elliptic.bindings/istl_fem.cc
+ operators/elliptic.bindings/istl_gdt.cc
+ operators/elliptic.bindings/istl_pdelab.cc
+ projections/dirichlet.bindings.cc
+ spaces/cg.bindings.cc
+ spaces/constraints.bindings.cc
+ spaces/dg.bindings.cc
+ spaces/fv.bindings.cc
+ )
dune_pybindxi_add_module(_gdt bindings.cc)
target_link_dune_default_libraries(_gdt)
+ target_link_libraries(_gdt _gdt_bindings_helper)
if(DUNE_XT_WITH_PYTHON_BINDINGS)
add_custom_target(bindings ALL DEPENDS _gdt)
else()
diff --git a/dune/gdt/assembler/system.bindings.cc b/dune/gdt/assembler/system.bindings.cc
new file mode 100644
index 000000000..841c53500
--- /dev/null
+++ b/dune/gdt/assembler/system.bindings.cc
@@ -0,0 +1,45 @@
+// This file is part of the dune-gdt project:
+// https://github.com/dune-community/dune-gdt
+// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
+// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
+// with "runtime exception" (http://www.dune-project.org/license.html)
+// Authors:
+// Felix Schindler (2017)
+
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "system.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET);
+#if HAVE_DUNE_FEM
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING);
+#if HAVE_DUNE_FEM
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/assembler/system.bindings.hh b/dune/gdt/assembler/system.bindings.hh
new file mode 100644
index 000000000..df13e64bd
--- /dev/null
+++ b/dune/gdt/assembler/system.bindings.hh
@@ -0,0 +1,134 @@
+// This file is part of the dune-gdt project:
+// https://github.com/dune-community/dune-gdt
+// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
+// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
+// with "runtime exception" (http://www.dune-project.org/license.html)
+// Authors:
+// Felix Schindler (2017)
+
+#ifndef DUNE_GDT_ASSEMBLER_SYSTEM_BINDINGS_HH
+#define DUNE_GDT_ASSEMBLER_SYSTEM_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <dune/pybindxi/pybind11.h>
+
+#include <dune/xt/common/memory.hh>
+#include <dune/xt/grid/grids.bindings.hh>
+
+#include <dune/gdt/spaces.bindings.hh>
+
+#include "system.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+template <class T /*, class GV = typename T::GridViewType, class A = T*/>
+class SystemAssembler
+{
+ static_assert(is_space<T>::value, "");
+
+public:
+ typedef GDT::SystemAssembler<T /*, G, A*/> type;
+ typedef pybind11::class_<type> bound_type;
+
+private:
+ typedef typename type::TestSpaceType TestSpaceType;
+ typedef typename type::GridViewType GridViewType;
+ typedef typename type::AnsatzSpaceType AnsatzSpaceType;
+
+ template <bool do_bind = (std::is_same<TestSpaceType, AnsatzSpaceType>::value
+ && std::is_same<GridViewType, typename TestSpaceType::GridViewType>::value),
+ bool anything = true>
+ struct addbind_ctor_single
+ {
+ void operator()(bound_type& c)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+ c.def(py::init<T>(),
+ "space"_a,
+ "Uses given space as test and ansatz space, and the grid view of the given space as grid view.",
+ py::keep_alive<1, 2>());
+ }
+ }; // struct addbind_ctor_single
+
+ template <bool anything>
+ struct addbind_ctor_single<false, anything>
+ {
+ void operator()(bound_type& /*c*/)
+ {
+ }
+ }; // struct addbind_ctor_single
+
+public:
+ static bound_type bind(pybind11::module& m, const std::string& space_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ bound_type c(
+ m, std::string("SystemAssembler__" + space_id).c_str(), std::string("SystemAssembler__" + space_id).c_str());
+ addbind_ctor_single<>()(c);
+
+ c.def("append", [](type& self, type& other) { self.append(other); }, "system_assembler"_a, py::keep_alive<1, 2>());
+ c.def("append",
+ [](type& self, XT::Grid::Walker<GridViewType>& other) { self.append(other); },
+ "grid_walker"_a,
+ py::keep_alive<1, 2>());
+ c.def("assemble", [](type& self, const bool use_tbb) { self.assemble(use_tbb); }, "use_tbb"_a = false);
+
+ m.def("make_system_assembler",
+ [](const TestSpaceType& space) { return new type(space); },
+ "space"_a,
+ py::keep_alive<0, 1>());
+ return c;
+ } // ... bind(...)
+}; // class SystemAssembler
+
+
+#define DUNE_GDT_ASSEMBLER_SYSTEM_BIND_GDT(_prefix, _GRID) \
+ _prefix class SystemAssembler<FV_SPACE(_GRID, leaf, gdt, 1, 1)>; \
+ _prefix class SystemAssembler<FV_SPACE(_GRID, level, gdt, 1, 1)>
+
+#define DUNE_GDT_ASSEMBLER_SYSTEM_BIND_FEM(_prefix, _GRID) \
+ _prefix class SystemAssembler<CG_SPACE(_GRID, leaf, fem, 1, 1, 1)>; \
+ _prefix class SystemAssembler<CG_SPACE(_GRID, level, fem, 1, 1, 1)>; \
+ _prefix class SystemAssembler<DG_SPACE(_GRID, leaf, fem, 1, 1, 1)>; \
+ _prefix class SystemAssembler<DG_SPACE(_GRID, level, fem, 1, 1, 1)>; \
+ _prefix class SystemAssembler<DG_SPACE(_GRID, leaf, fem, 2, 1, 1)>; \
+ _prefix class SystemAssembler<DG_SPACE(_GRID, level, fem, 2, 1, 1)>
+
+#define DUNE_GDT_ASSEMBLER_SYSTEM_BIND_PDELAB(_prefix, _GRID) \
+ _prefix class SystemAssembler<CG_SPACE(_GRID, leaf, pdelab, 1, 1, 1)>; \
+ _prefix class SystemAssembler<CG_SPACE(_GRID, level, pdelab, 1, 1, 1)>
+
+
+// these lines have to match the corresponding ones in the .cc source file
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_GDT(extern template, YASP_2D_EQUIDISTANT_OFFSET);
+#if HAVE_DUNE_FEM
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_GDT(extern template, ALU_2D_SIMPLEX_CONFORMING);
+#if HAVE_DUNE_FEM
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_ASSEMBLER_SYSTEM_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_ASSEMBLER_SYSTEM_BINDINGS_HH
diff --git a/dune/gdt/assembler/system.pbh b/dune/gdt/assembler/system.pbh
deleted file mode 100644
index d37a7788c..000000000
--- a/dune/gdt/assembler/system.pbh
+++ /dev/null
@@ -1,114 +0,0 @@
-// This file is part of the dune-gdt project:
-// https://github.com/dune-community/dune-gdt
-// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
-// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
-// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
-// with "runtime exception" (http://www.dune-project.org/license.html)
-// Authors:
-// Felix Schindler (2017)
-
-#ifndef DUNE_GDT_ASSEMBLER_SYSTEM_PBH
-#define DUNE_GDT_ASSEMBLER_SYSTEM_PBH
-
-#include <dune/pybindxi/pybind11.h>
-
-#include <dune/xt/common/memory.hh>
-
-#include "system.hh"
-
-namespace Dune {
-namespace GDT {
-namespace internal {
-
-
-template <class T,
- class G,
- class A,
- bool do_bind = (std::is_same<T, A>::value && std::is_same<G, typename T::GridViewType>::value)>
-struct addbind_SystemAssembler_ctor_single
-{
- template <class C>
- void operator()(C& c)
- {
- namespace py = pybind11;
- using namespace pybind11::literals;
- c.def(py::init<T>(),
- "space"_a,
- "Uses given space as test and ansatz space, and the grid view of the given space as grid view.",
- py::keep_alive<1, 2>());
- }
-}; // struct addbind_SystemAssembler_ctor_single
-
-template <class T, class G, class A>
-struct addbind_SystemAssembler_ctor_single<T, G, A, false>
-{
- template <class C>
- void operator()(C& /*c*/)
- {
- }
-}; // struct addbind_SystemAssembler_ctor_single
-
-
-template <class T, class G, class A, bool do_bind = (std::is_same<G, typename T::GridViewType>::value)>
-struct addbind_SystemAssembler_ctor_double
-{
- template <class C>
- void operator()(C& c)
- {
- namespace py = pybind11;
- using namespace pybind11::literals;
- c.def(py::init<T, A>(),
- "test_space"_a,
- "ansatz_space"_a,
- "Uses given spaces and the grid view of the test space as grid view.",
- py::keep_alive<1, 2>(),
- py::keep_alive<1, 3>());
- }
-}; // struct addbind_SystemAssembler_ctor_double
-
-template <class T, class G, class A>
-struct addbind_SystemAssembler_ctor_double<T, G, A, false>
-{
- template <class C>
- void operator()(C& /*c*/)
- {
- }
-}; // struct addbind_SystemAssembler_ctor_double
-
-
-} // namespace internal
-
-
-template <class TestSpace /*, class GridView = typename TestSpace::GridViewType, class AnsatzSpace = TestSpace*/>
-pybind11::class_<SystemAssembler<TestSpace /*, GridView, AnsatzSpace*/>>
-bind_system_assembler(pybind11::module& m, const std::string& space_id)
-{
- namespace py = pybind11;
- using namespace pybind11::literals;
- typedef typename TestSpace::GridViewType GridView;
- typedef TestSpace AnsatzSpace;
-
- typedef SystemAssembler<TestSpace /*, GridView, AnsatzSpace*/> C;
- py::class_<C, Dune::XT::Grid::Walker<GridView>> c(
- m, std::string("SystemAssembler__" + space_id).c_str(), std::string("SystemAssembler__" + space_id).c_str());
- internal::addbind_SystemAssembler_ctor_single<TestSpace, GridView, AnsatzSpace>()(c);
- // internal::addbind_SystemAssembler_ctor_double<TestSpace, GridView, AnsatzSpace>()(c);
-
- c.def("append", [](C& self, C& other) { self.append(other); }, "system_assembler"_a, py::keep_alive<1, 2>());
- c.def("append",
- [](C& self, XT::Grid::Walker<GridView>& other) { self.append(other); },
- "grid_walker"_a,
- py::keep_alive<1, 2>());
- c.def("assemble", [](C& self, const bool use_tbb) { self.assemble(use_tbb); }, "use_tbb"_a = false);
-
- m.def(
- "make_system_assembler", [](const TestSpace& space) { return new C(space); }, "space"_a, py::keep_alive<0, 1>());
-
- return c;
-} // ... bind_system_assembler(...)
-
-
-} // namespace GDT
-} // namespace Dune
-
-#endif // DUNE_GDT_ASSEMBLER_SYSTEM_PBH
diff --git a/dune/gdt/bindings.cc b/dune/gdt/bindings.cc
index 0904ef9dc..471f2edcc 100644
--- a/dune/gdt/bindings.cc
+++ b/dune/gdt/bindings.cc
@@ -7,7 +7,7 @@
// Authors:
// Felix Schindler (2017)
-#include <config.h>
+#include "config.h"
#if HAVE_DUNE_PYBINDXI
@@ -25,30 +25,20 @@
#include <dune/xt/common/configuration.pbh>
#include <dune/xt/common/fvector.pbh>
-#include <dune/xt/grid/grids.hh>
#include <dune/xt/grid/intersection.hh>
-#include <dune/xt/grid/layers.hh>
#include <dune/xt/grid/type_traits.hh>
#include <dune/xt/la/container.hh>
-#include <dune/gdt/spaces/cg.hh>
-#include <dune/gdt/spaces/dg.hh>
-#include <dune/gdt/spaces/fv.hh>
-#include <dune/gdt/spaces/rt.hh>
-
-#include <dune/gdt/assembler/system.pbh>
-#include <dune/gdt/discretefunction.pbh>
#include <dune/gdt/functionals/l2.pbh>
#include <dune/gdt/functionals/elliptic-ipdg.pbh>
-#include <dune/gdt/operators/elliptic.pbh>
-#include <dune/gdt/operators/elliptic-ipdg.pbh>
-#include <dune/gdt/projections/dirichlet.pbh>
-#include <dune/gdt/spaces.pbh>
-#include <dune/gdt/spaces/constraints.pbh>
+
+#include "bindings.hh"
namespace py = pybind11;
using namespace pybind11::literals;
+using namespace Dune;
+using namespace Dune::GDT::bindings;
template <class I, bool required = true>
@@ -57,7 +47,15 @@ struct for_Grid_and_Intersection
template <class G>
static void addbind(py::module& m, const std::string& grid_id, const std::string& id)
{
- Dune::GDT::bind_DirichletConstraints<I, Dune::XT::LA::Backends::istl_sparse>(m, grid_id + id, "istl_sparse");
+ auto constraints = DirichletConstraints<I>::bind(m, grid_id + id);
+ DirichletConstraints<I>::template addbind<Dune::XT::LA::Backends::common_dense>(constraints);
+#if HAVE_EIGEN
+ DirichletConstraints<I>::template addbind<Dune::XT::LA::Backends::eigen_dense>(constraints);
+ DirichletConstraints<I>::template addbind<Dune::XT::LA::Backends::eigen_sparse>(constraints);
+#endif
+#if HAVE_DUNE_ISTL
+ DirichletConstraints<I>::template addbind<Dune::XT::LA::Backends::istl_sparse>(constraints);
+#endif
}
};
@@ -78,11 +76,11 @@ struct addbind_for_lagrange_space
void operator()(py::module& m, BSA& bound_system_assembler, const std::string& space_id, const std::string& la_id)
{
// DirichletProjectionLocalizableOperator
- Dune::GDT::bind_DirichletProjectionLocalizableOperator<typename S::GridViewType,
- F,
- Dune::GDT::DiscreteFunction<S, V>>(m, space_id, la_id);
+ DirichletProjectionLocalizableOperator<typename S::GridViewType, F, Dune::GDT::DiscreteFunction<S, V>>::bind(
+ m, space_id, la_id);
// DirichletConstraints
- addbind_Dirichlet_Constraints_to_SystemAssembler(bound_system_assembler);
+ DirichletConstraints<typename XT::Grid::Intersection<typename S::GridViewType>::type>::addbind(
+ bound_system_assembler);
} // ... operator()(...)
}; // struct addbind_for_lagrange_space
@@ -108,7 +106,6 @@ void addbind_for_space(py::module& m,
{
using namespace Dune;
using namespace Dune::XT;
- using namespace Dune::GDT;
using Common::to_string;
using Common::to_lower;
@@ -129,150 +126,187 @@ void addbind_for_space(py::module& m,
const std::string p_ = to_string(int(S::polOrder)); // without the int(...) we get linker errors on module import
const std::string space_suffix = r_ + "x" + rC_ + "__p" + p_ + backend;
// Space
- bind_space<S>(m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix);
+ SpaceInterface<S>::bind(m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix);
m.def(std::string("make_" + to_lower(space_id) + "_space__" + space_suffix + "__" + layer_id).c_str(),
[](XT::Grid::GridProvider<G>& grid_provider, const int level) { return SP::create(grid_provider, level); },
"grid_provider"_a,
"level"_a = 0,
py::keep_alive<0, 1>());
// DiscreteFunction
- bind_DiscreteFunction<S, V>(
- m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse");
+ ConstDiscreteFunction<S, COMMON_DENSE_VECTOR>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "common_dense");
+ DiscreteFunction<S, COMMON_DENSE_VECTOR>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "common_dense");
+#if HAVE_EIGEN
+ ConstDiscreteFunction<S, EIGEN_DENSE_VECTOR>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "eigen_dense");
+ DiscreteFunction<S, EIGEN_DENSE_VECTOR>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "eigen_dense");
+#endif // HAVE_EIGEN
+#if HAVE_DUNE_ISTL
+ ConstDiscreteFunction<S, ISTL_DENSE_VECTOR>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_dense");
+ DiscreteFunction<S, ISTL_DENSE_VECTOR>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_dense");
+#endif // HAVE_DUNE_ISTL
// SystemAssembler
auto system_assembler =
- bind_system_assembler<S>(m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix);
- addbind_for_lagrange_space<S, V, ScalarFunction>()(
- m, system_assembler, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse");
- // addbind_Dirichlet_Constraints_to_SystemAssembler(system_assembler);
+ SystemAssembler<S>::bind(m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix);
+ addbind_for_lagrange_space<S, COMMON_DENSE_VECTOR, ScalarFunction>()(
+ m, system_assembler, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "common_dense");
+#if HAVE_EIGEN
+ addbind_for_lagrange_space<S, EIGEN_DENSE_VECTOR, ScalarFunction>()(
+ m, system_assembler, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "eigen_dense");
+#endif
+#if HAVE_DUNE_ISTL
+ addbind_for_lagrange_space<S, ISTL_DENSE_VECTOR, ScalarFunction>()(
+ m, system_assembler, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_dense");
+#endif
// EllipticMatrixOperator
- bind_elliptic_matrix_operator<ScalarFunction, TensorFunction, S, M>(
+ EllipticMatrixOperator<ScalarFunction, TensorFunction, S, COMMON_DENSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "common_dense");
+ EllipticMatrixOperator<ScalarFunction, void, S, COMMON_DENSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "common_dense");
+ EllipticMatrixOperator<TensorFunction, void, S, COMMON_DENSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "common_dense");
+#if HAVE_EIGEN
+ EllipticMatrixOperator<ScalarFunction, TensorFunction, S, EIGEN_DENSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "eigen_dense");
+ EllipticMatrixOperator<ScalarFunction, void, S, EIGEN_DENSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "eigen_dense");
+ EllipticMatrixOperator<TensorFunction, void, S, EIGEN_DENSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "eigen_dense");
+ EllipticMatrixOperator<ScalarFunction, TensorFunction, S, EIGEN_SPARSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "eigen_sparse");
+ EllipticMatrixOperator<ScalarFunction, void, S, EIGEN_SPARSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "eigen_sparse");
+ EllipticMatrixOperator<TensorFunction, void, S, EIGEN_SPARSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "eigen_sparse");
+#endif // HAVE_EIGEN
+#if HAVE_DUNE_ISTL
+ EllipticMatrixOperator<ScalarFunction, TensorFunction, S, ISTL_SPARSE_MATRIX>::bind(
m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse");
- bind_elliptic_matrix_operator<ScalarFunction, void, S, M>(
+ EllipticMatrixOperator<ScalarFunction, void, S, ISTL_SPARSE_MATRIX>::bind(
m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse");
- // EllipticIpdgMatrixOperator
- // - SIPDG
- bind_elliptic_ipdg_matrix_operator<ScalarFunction, TensorFunction, S, LocalEllipticIpdgIntegrands::Method::sipdg, M>(
- m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse", "Sipdg");
- bind_elliptic_ipdg_matrix_operator<ScalarFunction, void, S, LocalEllipticIpdgIntegrands::Method::sipdg, M>(
- m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse", "Sipdg");
- // - SWIPDG
- bind_elliptic_ipdg_matrix_operator<ScalarFunction, TensorFunction, S, LocalEllipticIpdgIntegrands::Method::swipdg, M>(
- m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse", "Swipdg");
- bind_elliptic_ipdg_matrix_operator<ScalarFunction, void, S, LocalEllipticIpdgIntegrands::Method::swipdg, M>(
- m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse", "Swipdg");
- // SWIPDG, affine wrt diffusion factor
- bind_elliptic_ipdg_matrix_operator<ScalarFunction,
- TensorFunction,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg_affine_factor,
- M>(m,
- space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix,
- "istl_sparse",
- "Swipdg_Affine_Factor");
- bind_elliptic_ipdg_matrix_operator<ScalarFunction,
- void,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg_affine_factor,
- M>(m,
- space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix,
- "istl_sparse",
- "Swipdg_Affine_Factor");
- // SWIPDG, affine wrt diffusion tensor
- bind_elliptic_ipdg_matrix_operator<ScalarFunction,
- TensorFunction,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg_affine_tensor,
- M>(m,
- space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix,
- "istl_sparse",
- "Swipdg_Affine_Tensor");
- bind_elliptic_ipdg_matrix_operator<ScalarFunction,
- void,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg_affine_tensor,
- M>(m,
- space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix,
- "istl_sparse",
- "Swipdg_Affine_Tensor");
+ EllipticMatrixOperator<TensorFunction, void, S, ISTL_SPARSE_MATRIX>::bind(
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse");
+#endif // HAVE_DUNE_ISTL
+// EllipticIpdgMatrixOperator
+#define BIND_ELLIPTIT_IPDG_OP(_MAT, _la, _MET, _met) \
+ EllipticIpdgMatrixOperator<ScalarFunction, \
+ TensorFunction, \
+ S, \
+ GDT::LocalEllipticIpdgIntegrands::Method::_MET, \
+ _MAT>::bind(m, \
+ space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, \
+ _la, \
+ _met); \
+ EllipticIpdgMatrixOperator<ScalarFunction, void, S, GDT::LocalEllipticIpdgIntegrands::Method::_MET, _MAT>::bind( \
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, _la, _met); \
+ EllipticIpdgMatrixOperator<TensorFunction, void, S, GDT::LocalEllipticIpdgIntegrands::Method::_MET, _MAT>::bind( \
+ m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, _la, _met)
+
+ BIND_ELLIPTIT_IPDG_OP(COMMON_DENSE_MATRIX, "common_dense", sipdg, "Sipdg");
+ BIND_ELLIPTIT_IPDG_OP(COMMON_DENSE_MATRIX, "common_dense", swipdg, "Swipdg");
+ BIND_ELLIPTIT_IPDG_OP(COMMON_DENSE_MATRIX, "common_dense", swipdg_affine_factor, "SwipdgAffineFactor");
+ BIND_ELLIPTIT_IPDG_OP(COMMON_DENSE_MATRIX, "common_dense", swipdg_affine_tensor, "SwipdgAffineTensor");
+#if HAVE_EIGEN
+ BIND_ELLIPTIT_IPDG_OP(EIGEN_DENSE_MATRIX, "eigen_dense", sipdg, "Sipdg");
+ BIND_ELLIPTIT_IPDG_OP(EIGEN_DENSE_MATRIX, "eigen_dense", swipdg, "Swipdg");
+ BIND_ELLIPTIT_IPDG_OP(EIGEN_DENSE_MATRIX, "eigen_dense", swipdg_affine_factor, "SwipdgAffineFactor");
+ BIND_ELLIPTIT_IPDG_OP(EIGEN_DENSE_MATRIX, "eigen_dense", swipdg_affine_tensor, "SwipdgAffineTensor");
+ BIND_ELLIPTIT_IPDG_OP(EIGEN_SPARSE_MATRIX, "eigen_sparse", sipdg, "SIPDG");
+ BIND_ELLIPTIT_IPDG_OP(EIGEN_SPARSE_MATRIX, "eigen_sparse", sipdg, "Sipdg");
+ BIND_ELLIPTIT_IPDG_OP(EIGEN_SPARSE_MATRIX, "eigen_sparse", swipdg, "Swipdg");
+ BIND_ELLIPTIT_IPDG_OP(EIGEN_SPARSE_MATRIX, "eigen_sparse", swipdg_affine_factor, "SwipdgAffineFactor");
+ BIND_ELLIPTIT_IPDG_OP(EIGEN_SPARSE_MATRIX, "eigen_sparse", swipdg_affine_tensor, "SwipdgAffineTensor");
+#endif
+#if HAVE_DUNE_ISTL
+ BIND_ELLIPTIT_IPDG_OP(ISTL_SPARSE_MATRIX, "istl_sparse", sipdg, "Sipdg");
+ BIND_ELLIPTIT_IPDG_OP(ISTL_SPARSE_MATRIX, "istl_sparse", swipdg, "Swipdg");
+ BIND_ELLIPTIT_IPDG_OP(ISTL_SPARSE_MATRIX, "istl_sparse", swipdg_affine_factor, "SwipdgAffineFactor");
+ BIND_ELLIPTIT_IPDG_OP(ISTL_SPARSE_MATRIX, "istl_sparse", swipdg_affine_tensor, "SwipdgAffineTensor");
+#endif
+
// L2VolumeVectorFunctional
- bind_l2_volume_vector_functional<ScalarFunction, S, V>(
+ GDT::bind_l2_volume_vector_functional<ScalarFunction, S, V>(
m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse");
// L2FaceVectorFunctional
- bind_l2_face_vector_functional<ScalarFunction, S, V>(
+ GDT::bind_l2_face_vector_functional<ScalarFunction, S, V>(
m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse");
// EllipticIpdgDirichletVectorFunctional
// - SIPDG
- bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
- ScalarFunction,
- TensorFunction,
- S,
- LocalEllipticIpdgIntegrands::Method::sipdg,
- V>(
+ GDT::bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
+ ScalarFunction,
+ TensorFunction,
+ S,
+ GDT::LocalEllipticIpdgIntegrands::Method::sipdg,
+ V>(
m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse", "Sipdg");
- bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
- ScalarFunction,
- void,
- S,
- LocalEllipticIpdgIntegrands::Method::sipdg,
- V>(
+ GDT::bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
+ ScalarFunction,
+ void,
+ S,
+ GDT::LocalEllipticIpdgIntegrands::Method::sipdg,
+ V>(
m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse", "Sipdg");
// - SWIPDG
- bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
- ScalarFunction,
- TensorFunction,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg,
- V>(
+ GDT::bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
+ ScalarFunction,
+ TensorFunction,
+ S,
+ GDT::LocalEllipticIpdgIntegrands::Method::swipdg,
+ V>(
m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse", "Swipdg");
- bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
- ScalarFunction,
- void,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg,
- V>(
+ GDT::bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
+ ScalarFunction,
+ void,
+ S,
+ GDT::LocalEllipticIpdgIntegrands::Method::swipdg,
+ V>(
m, space_id + "Space__" + grid_id + "_" + layer_id + "_to_" + space_suffix, "istl_sparse", "Swipdg");
// SWIPDG, affine wrt diffusion factor
- bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
- ScalarFunction,
- TensorFunction,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg_affine_factor,
- V>(m,
- space_id + "Space__" + grid_id + "_" + layer_id + "_to_"
- + space_suffix,
- "istl_sparse",
- "Swipdg_Affine_Factor");
- bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
- ScalarFunction,
- void,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg_affine_factor,
- V>(m,
- space_id + "Space__" + grid_id + "_" + layer_id + "_to_"
- + space_suffix,
- "istl_sparse",
- "Swipdg_Affine_Factor");
+ GDT::bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
+ ScalarFunction,
+ TensorFunction,
+ S,
+ GDT::LocalEllipticIpdgIntegrands::Method::swipdg_affine_factor,
+ V>(m,
+ space_id + "Space__" + grid_id + "_" + layer_id + "_to_"
+ + space_suffix,
+ "istl_sparse",
+ "Swipdg_Affine_Factor");
+ GDT::bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
+ ScalarFunction,
+ void,
+ S,
+ GDT::LocalEllipticIpdgIntegrands::Method::swipdg_affine_factor,
+ V>(m,
+ space_id + "Space__" + grid_id + "_" + layer_id + "_to_"
+ + space_suffix,
+ "istl_sparse",
+ "Swipdg_Affine_Factor");
// SWIPDG, affine wrt diffusion tensor
- bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
- ScalarFunction,
- TensorFunction,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg_affine_tensor,
- V>(m,
- space_id + "Space__" + grid_id + "_" + layer_id + "_to_"
- + space_suffix,
- "istl_sparse",
- "Swipdg_Affine_Tensor");
- bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
- ScalarFunction,
- void,
- S,
- LocalEllipticIpdgIntegrands::Method::swipdg_affine_tensor,
- V>(m,
- space_id + "Space__" + grid_id + "_" + layer_id + "_to_"
- + space_suffix,
- "istl_sparse",
- "Swipdg_Affine_Tensor");
+ GDT::bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
+ ScalarFunction,
+ TensorFunction,
+ S,
+ GDT::LocalEllipticIpdgIntegrands::Method::swipdg_affine_tensor,
+ V>(m,
+ space_id + "Space__" + grid_id + "_" + layer_id + "_to_"
+ + space_suffix,
+ "istl_sparse",
+ "Swipdg_Affine_Tensor");
+ GDT::bind_elliptic_ipdg_dirichlet_vector_functional<ScalarFunction,
+ ScalarFunction,
+ void,
+ S,
+ GDT::LocalEllipticIpdgIntegrands::Method::swipdg_affine_tensor,
+ V>(m,
+ space_id + "Space__" + grid_id + "_" + layer_id + "_to_"
+ + space_suffix,
+ "istl_sparse",
+ "Swipdg_Affine_Tensor");
} // ... addbind_for_space(...)
diff --git a/dune/gdt/bindings.hh b/dune/gdt/bindings.hh
new file mode 100644
index 000000000..9eac5a3ec
--- /dev/null
+++ b/dune/gdt/bindings.hh
@@ -0,0 +1,22 @@
+#ifndef DUNE_GDT_BINDINGS_HH
+#define DUNE_GDT_BINDINGS_HH
+
+#include <dune/xt/grid/grids.bindings.hh>
+#include <dune/xt/la/container.bindings.hh>
+
+#include <dune/gdt/assembler/system.bindings.hh>
+#include <dune/gdt/discretefunction/default.bindings.hh>
+#include <dune/gdt/operators/elliptic.bindings.hh>
+#include <dune/gdt/operators/elliptic-ipdg.bindings.hh>
+#include <dune/gdt/projections/dirichlet.bindings.hh>
+#include <dune/gdt/spaces.bindings.hh>
+#include <dune/gdt/spaces/constraints.bindings.hh>
+
+namespace Dune {
+namespace GDT {
+
+
+} // namespace GDT
+} // namespace Dune
+
+#endif // DUNE_GDT_BINDINGS_HH
diff --git a/dune/gdt/discretefunction.pbh b/dune/gdt/discretefunction.pbh
deleted file mode 100644
index d379c8311..000000000
--- a/dune/gdt/discretefunction.pbh
+++ /dev/null
@@ -1,79 +0,0 @@
-// This file is part of the dune-gdt project:
-// https://github.com/dune-community/dune-gdt
-// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
-// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
-// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
-// with "runtime exception" (http://www.dune-project.org/license.html)
-// Authors:
-// Felix Schindler (2017)
-
-#ifndef DUNE_GDT_DISCRETEFUNCTION_PBH
-#define DUNE_GDT_DISCRETEFUNCTION_PBH
-#if HAVE_DUNE_PYBINDXI
-
-#include <dune/pybindxi/pybind11.h>
-
-#include "discretefunction/default.hh"
-
-namespace Dune {
-namespace GDT {
-
-
-template <class S, class V>
-pybind11::class_<DiscreteFunction<S, V>,
- XT::Functions::LocalizableFunctionInterface<typename S::EntityType,
- typename S::DomainFieldType,
- S::dimDomain,
- typename S::RangeFieldType,
- S::dimRange,
- S::dimRangeCols>>
-bind_DiscreteFunction(pybind11::module& m, const std::string& space_id, const std::string& la_id)
-{
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef DiscreteFunction<S, V> C;
- py::class_<C,
- XT::Functions::LocalizableFunctionInterface<typename S::EntityType,
- typename S::DomainFieldType,
- S::dimDomain,
- typename S::RangeFieldType,
- S::dimRange,
- S::dimRangeCols>>
- c(m, std::string("DiscreteFunction__" + space_id + "__" + la_id).c_str());
- c.def(py::init<const S&, V&, const std::string>(),
- "space"_a,
- "vector"_a,
- "name"_a = "gdt.discretefunction",
- py::keep_alive<1, 2>(),
- py::keep_alive<1, 3>());
- c.def("space", [](C& self) { return self.space(); });
- c.def("vector", [](C& self) { return self.vector(); });
- c.def(
- "visualize",
- [](C& self, const std::string filename, const bool subsampling) { return self.visualize(filename, subsampling); },
- "filename"_a,
- "subsampling"_a = (S::polOrder > 1));
-
- m.def(std::string("make_discrete_function__" + la_id).c_str(),
- [](const S& space, const std::string& name) { return make_discrete_function<V>(space, name); },
- "space"_a,
- "name"_a = "gdt.discretefunction",
- py::keep_alive<0, 1>());
- m.def(std::string("make_discrete_function").c_str(),
- [](const S& space, V& vector, const std::string& name) { return make_discrete_function(space, vector, name); },
- "space"_a,
- "vector"_a,
- "name"_a = "gdt.discretefunction",
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>());
-
- return c;
-} // ... bind_DiscreteFunction(...)
-
-
-} // namespace GDT
-} // namespace Dune
-
-#endif // HAVE_DUNE_PYBINDXI
-#endif // DUNE_GDT_DISCRETEFUNCTION_PBH
diff --git a/dune/gdt/discretefunction/default.bindings.cc b/dune/gdt/discretefunction/default.bindings.cc
new file mode 100644
index 000000000..7d09001cb
--- /dev/null
+++ b/dune/gdt/discretefunction/default.bindings.cc
@@ -0,0 +1,72 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "default.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_FEM
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_PDELAB
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_FEM
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/discretefunction/default.bindings.hh b/dune/gdt/discretefunction/default.bindings.hh
new file mode 100644
index 000000000..31809ab5e
--- /dev/null
+++ b/dune/gdt/discretefunction/default.bindings.hh
@@ -0,0 +1,233 @@
+// This file is part of the dune-gdt project:
+// https://github.com/dune-community/dune-gdt
+// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
+// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
+// with "runtime exception" (http://www.dune-project.org/license.html)
+// Authors:
+// Felix Schindler (2017)
+
+#ifndef DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BINDINGS_HH
+#define DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <dune/pybindxi/pybind11.h>
+
+#include <dune/xt/grid/grids.bindings.hh>
+#include <dune/xt/la/type_traits.hh>
+#include <dune/xt/la/container.bindings.hh>
+
+#include <dune/gdt/type_traits.hh>
+#include <dune/gdt/spaces.bindings.hh>
+
+#include "default.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+template <class S, class V>
+class ConstDiscreteFunction
+{
+ static_assert(is_space<S>::value, "");
+ static_assert(XT::LA::is_vector<V>::value, "");
+
+public:
+ typedef GDT::ConstDiscreteFunction<S, V> type;
+
+private:
+ typedef XT::Functions::LocalizableFunctionInterface<typename S::EntityType,
+ typename S::DomainFieldType,
+ S::dimDomain,
+ typename S::RangeFieldType,
+ S::dimRange,
+ S::dimRangeCols>
+ BaseType;
+
+public:
+ typedef pybind11::class_<type, BaseType> bound_type;
+
+ static bound_type bind(pybind11::module& m, const std::string& space_id, const std::string& la_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ bound_type c(m, std::string("ConstDiscreteFunction__" + space_id + "__" + la_id).c_str());
+ c.def(py::init<const S&, V&, const std::string>(),
+ "space"_a,
+ "vector"_a,
+ "name"_a = "gdt.constdiscretefunction",
+ py::keep_alive<1, 2>(),
+ py::keep_alive<1, 3>());
+ c.def("space", [](type& self) { return self.space(); });
+ c.def("vector", [](type& self) { return self.vector(); });
+ c.def("visualize",
+ [](type& self, const std::string filename, const bool subsampling) {
+ return self.visualize(filename, subsampling);
+ },
+ "filename"_a,
+ "subsampling"_a = (S::polOrder > 1));
+
+ m.def(std::string("make_const_discrete_function").c_str(),
+ [](const S& space, V& vector, const std::string& name) {
+ return make_const_discrete_function(space, vector, name);
+ },
+ "space"_a,
+ "vector"_a,
+ "name"_a = "gdt.constdiscretefunction",
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>());
+
+ return c;
+ } // ... bind(...)
+}; // class ConstDiscreteFunction
+
+
+template <class S, class V>
+class DiscreteFunction
+{
+ static_assert(is_space<S>::value, "");
+ static_assert(XT::LA::is_vector<V>::value, "");
+
+public:
+ typedef GDT::DiscreteFunction<S, V> type;
+
+private:
+ typedef XT::Functions::LocalizableFunctionInterface<typename S::EntityType,
+ typename S::DomainFieldType,
+ S::dimDomain,
+ typename S::RangeFieldType,
+ S::dimRange,
+ S::dimRangeCols>
+ BaseType;
+
+public:
+ typedef pybind11::class_<type, BaseType> bound_type;
+
+ static bound_type bind(pybind11::module& m, const std::string& space_id, const std::string& la_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ bound_type c(m, std::string("DiscreteFunction__" + space_id + "__" + la_id).c_str());
+ c.def(py::init<const S&, V&, const std::string>(),
+ "space"_a,
+ "vector"_a,
+ "name"_a = "gdt.discretefunction",
+ py::keep_alive<1, 2>(),
+ py::keep_alive<1, 3>());
+ c.def("space", [](type& self) { return self.space(); });
+ c.def("vector", [](type& self) { return self.vector(); });
+ c.def("visualize",
+ [](type& self, const std::string filename, const bool subsampling) {
+ return self.visualize(filename, subsampling);
+ },
+ "filename"_a,
+ "subsampling"_a = (S::polOrder > 1));
+
+ m.def(
+ std::string("make_discrete_function").c_str(),
+ [](const S& space, V& vector, const std::string& name) { return make_discrete_function(space, vector, name); },
+ "space"_a,
+ "vector"_a,
+ "name"_a = "gdt.discretefunction",
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>());
+
+ return c;
+ } // ... bind(...)
+
+}; // class DiscreteFunction
+
+
+#define DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(_prefix, _GRID, _LA) \
+ _prefix class ConstDiscreteFunction<FV_SPACE(_GRID, leaf, gdt, 1, 1), _LA>; \
+ _prefix class ConstDiscreteFunction<FV_SPACE(_GRID, level, gdt, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<FV_SPACE(_GRID, leaf, gdt, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<FV_SPACE(_GRID, level, gdt, 1, 1), _LA>
+
+#define DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(_prefix, _GRID, _LA) \
+ _prefix class ConstDiscreteFunction<CG_SPACE(_GRID, leaf, fem, 1, 1, 1), _LA>; \
+ _prefix class ConstDiscreteFunction<CG_SPACE(_GRID, level, fem, 1, 1, 1), _LA>; \
+ _prefix class ConstDiscreteFunction<DG_SPACE(_GRID, leaf, fem, 1, 1, 1), _LA>; \
+ _prefix class ConstDiscreteFunction<DG_SPACE(_GRID, level, fem, 1, 1, 1), _LA>; \
+ _prefix class ConstDiscreteFunction<DG_SPACE(_GRID, leaf, fem, 2, 1, 1), _LA>; \
+ _prefix class ConstDiscreteFunction<DG_SPACE(_GRID, level, fem, 2, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<CG_SPACE(_GRID, leaf, fem, 1, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<CG_SPACE(_GRID, level, fem, 1, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<DG_SPACE(_GRID, leaf, fem, 1, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<DG_SPACE(_GRID, level, fem, 1, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<DG_SPACE(_GRID, leaf, fem, 2, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<DG_SPACE(_GRID, level, fem, 2, 1, 1), _LA>
+
+
+#define DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(_prefix, _GRID, _LA) \
+ _prefix class ConstDiscreteFunction<CG_SPACE(_GRID, leaf, pdelab, 1, 1, 1), _LA>; \
+ _prefix class ConstDiscreteFunction<CG_SPACE(_GRID, level, pdelab, 1, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<CG_SPACE(_GRID, leaf, pdelab, 1, 1, 1), _LA>; \
+ _prefix class DiscreteFunction<CG_SPACE(_GRID, level, pdelab, 1, 1, 1), _LA>
+
+
+// these lines have to match the corresponding ones in the .cc source file
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(extern template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(extern template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(extern template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_FEM
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_PDELAB
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(extern template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(extern template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_GDT(extern template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_FEM
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_DISCRETEFUNCTION_DEFAULT_BINDINGS_HH
diff --git a/dune/gdt/operators/base.bindings.hh b/dune/gdt/operators/base.bindings.hh
new file mode 100644
index 000000000..99a300af7
--- /dev/null
+++ b/dune/gdt/operators/base.bindings.hh
@@ -0,0 +1,131 @@
+// This file is part of the dune-gdt project:
+// https://github.com/dune-community/dune-gdt
+// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
+// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
+// with "runtime exception" (http://www.dune-project.org/license.html)
+// Authors:
+// Felix Schindler (2017)
+
+#ifndef DUNE_GDT_OPERATORS_BASE_BINDINGS_HH
+#define DUNE_GDT_OPERATORS_BASE_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <dune/pybindxi/pybind11.h>
+
+#include <dune/xt/la/container.hh>
+
+#include "base.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+template <class OperatorType>
+class MatrixOperatorBase
+{
+public:
+ typedef OperatorType type;
+ typedef GDT::SystemAssembler<typename OperatorType::RangeSpaceType,
+ typename OperatorType::GridViewType,
+ typename OperatorType::SourceSpaceType>
+ BaseType;
+ typedef pybind11::class_<type, BaseType> bound_type;
+
+ static bound_type bind(pybind11::module& m, const std::string& class_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ typedef typename type::RangeSpaceType R;
+ typedef typename type::SourceSpaceType S;
+ typedef GDT::SystemAssembler<R, typename type::GridViewType, typename type::SourceSpaceType> I;
+ typedef typename XT::LA::Container<typename type::RangeFieldType, type::MatrixType::vector_type>::VectorType V;
+
+ bound_type c(m, std::string(class_id).c_str(), std::string(class_id).c_str());
+
+ // from MatrixOperatorBase
+ c.def_static("pattern", [](const R& space) { return type::pattern(space); });
+
+ c.def("pattern", [](type& self) { return self.pattern(self.range_space()); });
+ c.def("matrix", [](type& self) { return self.matrix(); });
+ c.def("source_space", [](type& self) { return self.source_space(); });
+ c.def("range_space", [](type& self) { return self.range_space(); });
+ c.def("apply", [](type& self, const V& source, V& range) { self.apply(source, range); }, "source"_a, "range"_a);
+ c.def("apply",
+ [](type& self, const GDT::ConstDiscreteFunction<S, V>& source, GDT::DiscreteFunction<R, V>& range) {
+ self.apply(source, range);
+ },
+ "source"_a,
+ "range"_a);
+ c.def("apply2",
+ [](type& self, const V& range, const V& source) { return self.apply2(range, source); },
+ "range"_a,
+ "source"_a);
+ c.def("apply2",
+ [](type& self,
+ const GDT::ConstDiscreteFunction<R, V>& range,
+ const GDT::ConstDiscreteFunction<S, V>& source) { return self.apply2(range, source); },
+ "range"_a,
+ "source"_a);
+ c.def("apply_inverse",
+ [](type& self, const V& range, V& source, const XT::Common::Configuration& opts) {
+ self.apply_inverse(range, source, opts);
+ },
+ "range"_a,
+ "source"_a,
+ "opts"_a);
+ c.def("apply_inverse",
+ [](type& self,
+ const GDT::ConstDiscreteFunction<R, V>& range,
+ GDT::ConstDiscreteFunction<S, V>& source,
+ const XT::Common::Configuration& opts) { self.apply_inverse(range, source, opts); },
+ "range"_a,
+ "source"_a,
+ "opts"_a);
+ c.def("invert_options", [](type& self) { return self.invert_options(); });
+ c.def("invert_options", [](type& self, const std::string& type) { return self.invert_options(type); }, "type"_a);
+
+ // from OperatorInterface
+ c.def(
+ "apply_inverse",
+ [](type& self, const V& range, V& source, const std::string& type) { self.apply_inverse(range, source, type); },
+ "range"_a,
+ "source"_a,
+ "type"_a);
+ c.def("apply_inverse",
+ [](type& self,
+ const GDT::ConstDiscreteFunction<R, V>& range,
+ GDT::ConstDiscreteFunction<S, V>& source,
+ const std::string& type) { self.apply_inverse(range, source, type); },
+ "range"_a,
+ "source"_a,
+ "type"_a);
+ c.def("apply_inverse",
+ [](type& self, const V& range, V& source) { self.apply_inverse(range, source); },
+ "range"_a,
+ "source"_a);
+ c.def("apply_inverse",
+ [](type& self, const GDT::ConstDiscreteFunction<R, V>& range, GDT::ConstDiscreteFunction<S, V>& source) {
+ self.apply_inverse(range, source);
+ },
+ "range"_a,
+ "source"_a);
+ c.def("induced_norm", [](type& self, const V& range) { return self.induced_norm(range); }, "range"_a);
+ c.def("induced_norm",
+ [](type& self, const GDT::ConstDiscreteFunction<R, V>& range) { return self.induced_norm(range); },
+ "range"_a);
+
+ return c;
+ } // ... bind(...)
+
+}; // class MatrixOperatorBase
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_OPERATORS_BASE_BINDINGS_HH
diff --git a/dune/gdt/operators/base.pbh b/dune/gdt/operators/base.pbh
deleted file mode 100644
index 5328b7f5d..000000000
--- a/dune/gdt/operators/base.pbh
+++ /dev/null
@@ -1,121 +0,0 @@
-// This file is part of the dune-gdt project:
-// https://github.com/dune-community/dune-gdt
-// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
-// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
-// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
-// with "runtime exception" (http://www.dune-project.org/license.html)
-// Authors:
-// Felix Schindler (2017)
-
-#ifndef DUNE_GDT_OPERATORS_BASE_PBH
-#define DUNE_GDT_OPERATORS_BASE_PBH
-#if HAVE_DUNE_PYBINDXI
-
-#include <dune/pybindxi/pybind11.h>
-
-#include <dune/xt/la/container.hh>
-
-#include "base.hh"
-
-namespace Dune {
-namespace GDT {
-
-
-template <class OperatorType>
-pybind11::class_<OperatorType,
- SystemAssembler<typename OperatorType::RangeSpaceType,
- typename OperatorType::GridViewType,
- typename OperatorType::SourceSpaceType>>
-bind_matrix_operator(pybind11::module& m, const std::string& class_id)
-{
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef OperatorType C;
- typedef typename C::RangeSpaceType R;
- typedef typename C::SourceSpaceType S;
- typedef SystemAssembler<R, typename C::GridViewType, typename C::SourceSpaceType> I;
- typedef typename XT::LA::Container<typename C::RangeFieldType, C::MatrixType::vector_type>::VectorType V;
-
- py::class_<C, I> c(m, std::string(class_id).c_str(), std::string(class_id).c_str());
-
- // from MatrixOperatorBase
- c.def_static("pattern", [](const R& space) { return C::pattern(space); });
-
- c.def("pattern", [](C& self) { return self.pattern(self.range_space()); });
- c.def("matrix", [](C& self) { return self.matrix(); });
- c.def("source_space", [](C& self) { return self.source_space(); });
- c.def("range_space", [](C& self) { return self.range_space(); });
- c.def("apply", [](C& self, const V& source, V& range) { self.apply(source, range); }, "source"_a, "range"_a);
- c.def("apply",
- [](C& self, const ConstDiscreteFunction<S, V>& source, DiscreteFunction<R, V>& range) {
- self.apply(source, range);
- },
- "source"_a,
- "range"_a);
- c.def("apply2",
- [](C& self, const V& range, const V& source) { return self.apply2(range, source); },
- "range"_a,
- "source"_a);
- c.def("apply2",
- [](C& self, const ConstDiscreteFunction<R, V>& range, const ConstDiscreteFunction<S, V>& source) {
- return self.apply2(range, source);
- },
- "range"_a,
- "source"_a);
- c.def("apply_inverse",
- [](C& self, const V& range, V& source, const XT::Common::Configuration& opts) {
- self.apply_inverse(range, source, opts);
- },
- "range"_a,
- "source"_a,
- "opts"_a);
- c.def("apply_inverse",
- [](C& self,
- const ConstDiscreteFunction<R, V>& range,
- ConstDiscreteFunction<S, V>& source,
- const XT::Common::Configuration& opts) { self.apply_inverse(range, source, opts); },
- "range"_a,
- "source"_a,
- "opts"_a);
- c.def("invert_options", [](C& self) { return self.invert_options(); });
- c.def("invert_options", [](C& self, const std::string& type) { return self.invert_options(type); }, "type"_a);
-
- // from OperatorInterface
- c.def("apply_inverse",
- [](C& self, const V& range, V& source, const std::string& type) { self.apply_inverse(range, source, type); },
- "range"_a,
- "source"_a,
- "type"_a);
- c.def("apply_inverse",
- [](C& self,
- const ConstDiscreteFunction<R, V>& range,
- ConstDiscreteFunction<S, V>& source,
- const std::string& type) { self.apply_inverse(range, source, type); },
- "range"_a,
- "source"_a,
- "type"_a);
- c.def("apply_inverse",
- [](C& self, const V& range, V& source) { self.apply_inverse(range, source); },
- "range"_a,
- "source"_a);
- c.def("apply_inverse",
- [](C& self, const ConstDiscreteFunction<R, V>& range, ConstDiscreteFunction<S, V>& source) {
- self.apply_inverse(range, source);
- },
- "range"_a,
- "source"_a);
- c.def("induced_norm", [](C& self, const V& range) { return self.induced_norm(range); }, "range"_a);
- c.def("induced_norm",
- [](C& self, const ConstDiscreteFunction<R, V>& range) { return self.induced_norm(range); },
- "range"_a);
-
- return c;
-} // ... bind_matrix_operator(...)
-
-
-} // namespace GDT
-} // namespace Dune
-
-#endif // HAVE_DUNE_PYBINDXI
-#endif // DUNE_GDT_OPERATORS_BASE_PBH
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings.hh b/dune/gdt/operators/elliptic-ipdg.bindings.hh
new file mode 100644
index 000000000..fb14a063c
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings.hh
@@ -0,0 +1,319 @@
+// This file is part of the dune-gdt project:
+// https://github.com/dune-community/dune-gdt
+// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
+// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
+// with "runtime exception" (http://www.dune-project.org/license.html)
+// Authors:
+// Felix Schindler (2017)
+
+#ifndef DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BINDINGS_HH
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <dune/pybindxi/pybind11.h>
+
+#include <dune/xt/common/string.hh>
+#include <dune/xt/grid/grids.bindings.hh>
+
+#include <dune/gdt/spaces.bindings.hh>
+
+#include "elliptic-ipdg.hh"
+#include "base.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+template <class DF,
+ typename DT, // may be void
+ class R,
+ LocalEllipticIpdgIntegrands::Method method,
+ class M = typename XT::LA::Container<typename R::RangeFieldType>::MatrixType /*,
+ class GV = typename R::GridViewType,
+ class S = R,
+ class F = typename R::RangeFieldType*/>
+class EllipticIpdgMatrixOperator
+{
+public:
+ typedef GDT::EllipticIpdgMatrixOperator<DF, DT, R, method, M /*, GV, S, F*/> type;
+ typedef pybind11::class_<type> bound_type;
+
+private:
+ template <bool single_diffusion = std::is_same<DT, void>::value, bool anything = false>
+ struct diffusion_switch
+ {
+ static std::string suffix()
+ {
+ return "diffusion_factor_and_tensor";
+ }
+
+ template <class C>
+ static void addbind_factory_methods(pybind11::module& m, const std::string& method_id, const std::string& la_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ m.def(
+ std::string(method_id + "__" + la_id).c_str(),
+ [](const DF& diffusion_factor,
+ const DT& diffusion_tensor,
+ const XT::Grid::BoundaryInfo<typename R::GridViewType::Intersection>& boundary_info,
+ const R& space,
+ const size_t over_integrate) {
+ return make_elliptic_ipdg_matrix_operator<M, method>(
+ diffusion_factor, diffusion_tensor, boundary_info, space, over_integrate)
+ .release(); // <- b.c. EllipticIpdgMatrixOperator is not movable, returning the raw pointer lets
+ }, // pybind11 correctly manage the memory
+ "diffusion_factor"_a,
+ "diffusion_tensor"_a,
+ "boundary_info"_a,
+ "space"_a,
+ "over_integrate"_a = 0,
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>(),
+ py::keep_alive<0, 3>(),
+ py::keep_alive<0, 4>());
+
+ m.def(
+ std::string(method_id).c_str(),
+ [](const DF& diffusion_factor,
+ const DT& diffusion_tensor,
+ const XT::Grid::BoundaryInfo<typename R::GridViewType::Intersection>& boundary_info,
+ M& matrix,
+ const R& space,
+ const size_t over_integrate) {
+ return make_elliptic_ipdg_matrix_operator<method>(
+ diffusion_factor, diffusion_tensor, boundary_info, matrix, space, over_integrate)
+ .release(); // <- s.a. for release()
+ },
+ "diffusion_factor"_a,
+ "diffusion_tensor"_a,
+ "boundary_info"_a,
+ "matrix"_a,
+ "space"_a,
+ "over_integrate"_a = 0,
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>(),
+ py::keep_alive<0, 3>(),
+ py::keep_alive<0, 4>(),
+ py::keep_alive<0, 5>());
+ } // ... addbind_factory_methods(...)
+
+ }; // struct diffusion_switch
+
+ template <bool anything>
+ struct diffusion_switch<true, anything>
+ {
+ static std::string suffix()
+ {
+ return "single_diffusion";
+ }
+
+ template <class C>
+ static void addbind_factory_methods(pybind11::module& m, const std::string& method_id, const std::string& la_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ m.def(
+ std::string(method_id + "__" + la_id).c_str(),
+ [](const DF& diffusion,
+ const XT::Grid::BoundaryInfo<typename R::GridViewType::Intersection>& boundary_info,
+ const R& space,
+ const size_t over_integrate) {
+ return make_elliptic_ipdg_matrix_operator<M, method>(diffusion, boundary_info, space, over_integrate)
+ .release(); // <- s.a. for release()
+ },
+ "diffusion"_a,
+ "boundary_info"_a,
+ "space"_a,
+ "over_integrate"_a = 0,
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>(),
+ py::keep_alive<0, 3>());
+
+ m.def(
+ std::string(method_id).c_str(),
+ [](const DF& diffusion,
+ const XT::Grid::BoundaryInfo<typename R::GridViewType::Intersection>& boundary_info,
+ M& matrix,
+ const R& space,
+ const size_t over_integrate) {
+ return make_elliptic_ipdg_matrix_operator<method>(diffusion, boundary_info, matrix, space, over_integrate)
+ .release(); // <- s.a. for release()
+ },
+ "diffusion"_a,
+ "boundary_info"_a,
+ "matrix"_a,
+ "space"_a,
+ "over_integrate"_a = 0,
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>(),
+ py::keep_alive<0, 3>(),
+ py::keep_alive<0, 4>());
+ } // ... addbind_factory_methods(...)
+ }; // struct diffusion_switch<..., void>
+
+public:
+ static bound_type
+ bind(pybind11::module& m, const std::string& space_id, const std::string& la_id, const std::string& method_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ const std::string suffix = la_id + "__" + space_id + "_" + diffusion_switch<>::suffix();
+
+ auto c = MatrixOperatorBase<type>::bind(m, "Elliptic" + method_id + "MatrixOperator__" + suffix);
+
+ diffusion_switch<>::template addbind_factory_methods<type>(
+ m, "make_elliptic_" + XT::Common::to_lower(method_id) + "_matrix_operator", la_id);
+
+ return c;
+ } // ... bind(...)
+
+}; // EllipticIpdgMatrixOperator
+
+
+// If everyone just had enough memory, we could just use a single line
+// DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND(template);
+// in a source file to instantiate everything (together with
+// DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND(extern template);
+// in this header. Alas, we can use the latter in this header, but need to distribute the load over several sources by
+// using the specialized macros below...
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic" // because of the extra ; in some places
+#endif
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND(_PRE) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_YASPGRID(_PRE); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ALUGRID(_PRE)
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_YASPGRID(_PRE) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_LA(_PRE, YASP_2D_EQUIDISTANT_OFFSET)
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ALUGRID(_PRE) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_LA(_PRE, ALU_2D_SIMPLEX_CONFORMING)
+#else
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ALUGRID(_PRE)
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_LA(_PRE, _GRID) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_COMMON(_PRE, _GRID); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_EIGEN(_PRE, _GRID); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ISTL(_PRE, _GRID)
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_COMMON(_PRE, _GRID) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(_PRE, _GRID, common_dense); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(_PRE, _GRID, common_dense); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(_PRE, _GRID, common_dense)
+
+#if HAVE_EIGEN
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_EIGEN(_PRE, _GRID) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(_PRE, _GRID, eigen_dense); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(_PRE, _GRID, eigen_sparse); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(_PRE, _GRID, eigen_dense); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(_PRE, _GRID, eigen_sparse); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(_PRE, _GRID, eigen_dense); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(_PRE, _GRID, eigen_sparse)
+#else
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_EIGEN(_PRE, _GRID)
+#endif
+
+#if HAVE_DUNE_ISTL
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ISTL(_PRE, _GRID) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(_PRE, _GRID, istl_dense); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(_PRE, _GRID, istl_dense); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(_PRE, _GRID, istl_dense)
+#else
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_ISTL(_PRE, _GRID)
+#endif
+
+#if HAVE_DUNE_FEM
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(_PRE, _GRID, _LA) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, CG_SPACE(_GRID, leaf, fem, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, CG_SPACE(_GRID, level, fem, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, DG_SPACE(_GRID, leaf, fem, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, DG_SPACE(_GRID, level, fem, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, DG_SPACE(_GRID, leaf, fem, 2, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, DG_SPACE(_GRID, level, fem, 2, 1, 1), _LA)
+#else // HAVE_DUNE_FEM
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(_PRE, _GRID)
+#endif
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(_PRE, _GRID, _LA) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, FV_SPACE(_GRID, leaf, gdt, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, FV_SPACE(_GRID, level, gdt, 1, 1), _LA)
+
+#if HAVE_DUNE_PDELAB
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(_PRE, _GRID, _LA) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, CG_SPACE(_GRID, leaf, pdelab, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, CG_SPACE(_GRID, level, pdelab, 1, 1, 1), _LA)
+#else
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(_PRE, _GRID, _LA)
+#endif
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_METHODS(_PRE, _SPACE, _LA) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_(_PRE, _SPACE, sipdg, _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_(_PRE, _SPACE, swipdg, _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_(_PRE, _SPACE, swipdg_affine_factor, _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_(_PRE, _SPACE, swipdg_affine_tensor, _LA)
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_(_PRE, _SPACE, _METHOD, _LA) \
+ _PRE class EllipticIpdgMatrixOperator<XT::Functions::LocalizableFunctionInterface<typename _SPACE::EntityType, \
+ typename _SPACE::DomainFieldType, \
+ _SPACE::dimDomain, \
+ typename _SPACE::RangeFieldType, \
+ 1, \
+ 1>, \
+ XT::Functions::LocalizableFunctionInterface<typename _SPACE::EntityType, \
+ typename _SPACE::DomainFieldType, \
+ _SPACE::dimDomain, \
+ typename _SPACE::RangeFieldType, \
+ _SPACE::dimDomain, \
+ _SPACE::dimDomain>, \
+ _SPACE, \
+ LocalEllipticIpdgIntegrands::Method::_METHOD, \
+ typename XT::LA::Container<typename _SPACE::RangeFieldType, \
+ XT::LA::Backends::_LA>::MatrixType>; \
+ _PRE class EllipticIpdgMatrixOperator<XT::Functions::LocalizableFunctionInterface<typename _SPACE::EntityType, \
+ typename _SPACE::DomainFieldType, \
+ _SPACE::dimDomain, \
+ typename _SPACE::RangeFieldType, \
+ 1, \
+ 1>, \
+ void, \
+ _SPACE, \
+ LocalEllipticIpdgIntegrands::Method::_METHOD, \
+ typename XT::LA::Container<typename _SPACE::RangeFieldType, \
+ XT::LA::Backends::_LA>::MatrixType>; \
+ _PRE class EllipticIpdgMatrixOperator<XT::Functions::LocalizableFunctionInterface<typename _SPACE::EntityType, \
+ typename _SPACE::DomainFieldType, \
+ _SPACE::dimDomain, \
+ typename _SPACE::RangeFieldType, \
+ _SPACE::dimDomain, \
+ _SPACE::dimDomain>, \
+ void, \
+ _SPACE, \
+ LocalEllipticIpdgIntegrands::Method::_METHOD, \
+ typename XT::LA::Container<typename _SPACE::RangeFieldType, \
+ XT::LA::Backends::_LA>::MatrixType>
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND(extern template);
+
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+
+} // naemspace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BINDINGS_HH
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/alu_common_fem.cc b/dune/gdt/operators/elliptic-ipdg.bindings/alu_common_fem.cc
new file mode 100644
index 000000000..fe7bb2acc
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/alu_common_fem.cc
@@ -0,0 +1,24 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, common_dense);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+
+#endif // HAVE_DUNE_FEM
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/alu_common_gdt.cc b/dune/gdt/operators/elliptic-ipdg.bindings/alu_common_gdt.cc
new file mode 100644
index 000000000..79731c120
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/alu_common_gdt.cc
@@ -0,0 +1,21 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, common_dense);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/alu_common_pdelab.cc b/dune/gdt/operators/elliptic-ipdg.bindings/alu_common_pdelab.cc
new file mode 100644
index 000000000..27e63eda4
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/alu_common_pdelab.cc
@@ -0,0 +1,23 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_PDELAB
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, common_dense);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_fem.cc b/dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_fem.cc
new file mode 100644
index 000000000..8b3e4b688
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_fem.cc
@@ -0,0 +1,27 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_EIGEN
+#if HAVE_DUNE_FEM
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, eigen_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+
+#endif // HAVE_DUNE_FEM
+#endif // HAVE_EIGEN
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_gdt.cc b/dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_gdt.cc
new file mode 100644
index 000000000..24890e6ee
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_gdt.cc
@@ -0,0 +1,24 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_EIGEN
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, eigen_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_EIGEN
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_pdelab.cc b/dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_pdelab.cc
new file mode 100644
index 000000000..75aa407c0
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/alu_eigen_pdelab.cc
@@ -0,0 +1,26 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_EIGEN
+#if HAVE_DUNE_PDELAB
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, eigen_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_EIGEN
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_fem.cc b/dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_fem.cc
new file mode 100644
index 000000000..3a26b7573
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_fem.cc
@@ -0,0 +1,26 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_ISTL
+#if HAVE_DUNE_FEM
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, istl_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+
+#endif // HAVE_DUNE_FEM
+#endif // HAVE_DUNE_ISTL
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_gdt.cc b/dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_gdt.cc
new file mode 100644
index 000000000..994c35559
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_gdt.cc
@@ -0,0 +1,23 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_ISTL
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, istl_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_ISTL
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_pdelab.cc b/dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_pdelab.cc
new file mode 100644
index 000000000..0c942528f
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/alu_istl_pdelab.cc
@@ -0,0 +1,25 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_ISTL
+#if HAVE_DUNE_PDELAB
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, istl_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_DUNE_ISTL
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_fem.cc b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_fem.cc
new file mode 100644
index 000000000..f68491626
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_fem.cc
@@ -0,0 +1,22 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_DUNE_FEM
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, common_dense);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+
+#endif // HAVE_DUNE_FEM
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_gdt.cc b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_gdt.cc
new file mode 100644
index 000000000..2f68e50b0
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_gdt.cc
@@ -0,0 +1,19 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, common_dense);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_pdelab.cc b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_pdelab.cc
new file mode 100644
index 000000000..ea5b39843
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_common_pdelab.cc
@@ -0,0 +1,21 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_DUNE_PDELAB
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, common_dense);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_fem.cc b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_fem.cc
new file mode 100644
index 000000000..19c1262c1
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_fem.cc
@@ -0,0 +1,25 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_EIGEN
+#if HAVE_DUNE_FEM
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+
+#endif // HAVE_DUNE_FEM
+#endif // HAVE_EIGEN
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_gdt.cc b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_gdt.cc
new file mode 100644
index 000000000..6fe9327fa
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_gdt.cc
@@ -0,0 +1,22 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_EIGEN
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_EIGEN
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_pdelab.cc b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_pdelab.cc
new file mode 100644
index 000000000..78c8789d4
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_eigen_pdelab.cc
@@ -0,0 +1,24 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_EIGEN
+#if HAVE_DUNE_PDELAB
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_EIGEN
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_fem.cc b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_fem.cc
new file mode 100644
index 000000000..c5363d57a
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_fem.cc
@@ -0,0 +1,24 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_DUNE_ISTL
+#if HAVE_DUNE_FEM
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, istl_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+
+#endif // HAVE_DUNE_FEM
+#endif // HAVE_DUNE_ISTL
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_gdt.cc b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_gdt.cc
new file mode 100644
index 000000000..8d08b5a2f
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_gdt.cc
@@ -0,0 +1,21 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_DUNE_ISTL
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, istl_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_ISTL
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_pdelab.cc b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_pdelab.cc
new file mode 100644
index 000000000..034b00594
--- /dev/null
+++ b/dune/gdt/operators/elliptic-ipdg.bindings/yasp_istl_pdelab.cc
@@ -0,0 +1,23 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+#if HAVE_DUNE_ISTL
+#if HAVE_DUNE_PDELAB
+
+#include "../elliptic-ipdg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, istl_sparse);
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_DUNE_ISTL
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic-ipdg.pbh b/dune/gdt/operators/elliptic-ipdg.pbh
deleted file mode 100644
index d51ccfd46..000000000
--- a/dune/gdt/operators/elliptic-ipdg.pbh
+++ /dev/null
@@ -1,182 +0,0 @@
-// This file is part of the dune-gdt project:
-// https://github.com/dune-community/dune-gdt
-// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
-// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
-// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
-// with "runtime exception" (http://www.dune-project.org/license.html)
-// Authors:
-// Felix Schindler (2017)
-
-#ifndef DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_PBH
-#define DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_PBH
-#if HAVE_DUNE_PYBINDXI
-
-#include <dune/pybindxi/pybind11.h>
-
-#include <dune/xt/common/string.hh>
-
-#include "elliptic-ipdg.hh"
-#include "base.pbh"
-
-namespace Dune {
-namespace GDT {
-namespace internal {
-
-
-template <class DF, typename DT, LocalEllipticIpdgIntegrands::Method ipdg_method>
-struct elliptic_ipdg_matrix_operator_bind_helper
-{
- static std::string suffix()
- {
- return "diffusion_factor_and_tensor";
- }
-
- template <class C>
- static void addbind_factory_methods(pybind11::module& m, const std::string& method_id, const std::string& la_id)
- {
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef typename C::RangeSpaceType R;
- typedef typename C::MatrixType MatrixType;
-
- m.def(std::string(method_id + "__" + la_id).c_str(),
- [](const DF& diffusion_factor,
- const DT& diffusion_tensor,
- const XT::Grid::BoundaryInfo<typename R::GridViewType::Intersection>& boundary_info,
- const R& space,
- const size_t over_integrate) {
- return make_elliptic_ipdg_matrix_operator<MatrixType, ipdg_method>(
- diffusion_factor, diffusion_tensor, boundary_info, space, over_integrate)
- .release(); // <- b.c. EllipticIpdgMatrixOperator is not movable, returning the raw pointer lets
- }, // pybind11 correctly manage the memory
- "diffusion_factor"_a,
- "diffusion_tensor"_a,
- "boundary_info"_a,
- "space"_a,
- "over_integrate"_a = 0,
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>(),
- py::keep_alive<0, 3>(),
- py::keep_alive<0, 4>());
-
- m.def(std::string(method_id).c_str(),
- [](const DF& diffusion_factor,
- const DT& diffusion_tensor,
- const XT::Grid::BoundaryInfo<typename R::GridViewType::Intersection>& boundary_info,
- MatrixType& matrix,
- const R& space,
- const size_t over_integrate) {
- return make_elliptic_ipdg_matrix_operator<ipdg_method>(
- diffusion_factor, diffusion_tensor, boundary_info, matrix, space, over_integrate)
- .release(); // <- s.a. for release()
- },
- "diffusion_factor"_a,
- "diffusion_tensor"_a,
- "boundary_info"_a,
- "matrix"_a,
- "space"_a,
- "over_integrate"_a = 0,
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>(),
- py::keep_alive<0, 3>(),
- py::keep_alive<0, 4>(),
- py::keep_alive<0, 5>());
- } // ... addbind_factory_methods(...)
-}; // struct elliptic_ipdg_matrix_operator_bind_helper
-
-template <class D, LocalEllipticIpdgIntegrands::Method ipdg_method>
-struct elliptic_ipdg_matrix_operator_bind_helper<D, void, ipdg_method>
-{
- static std::string suffix()
- {
- return "single_diffusion";
- }
-
- template <class C>
- static void addbind_factory_methods(pybind11::module& m, const std::string& method_id, const std::string& la_id)
- {
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef typename C::RangeSpaceType R;
- typedef typename C::MatrixType MatrixType;
-
- m.def(std::string(method_id + "__" + la_id).c_str(),
- [](const D& diffusion,
- const XT::Grid::BoundaryInfo<typename R::GridViewType::Intersection>& boundary_info,
- const R& space,
- const size_t over_integrate) {
- return make_elliptic_ipdg_matrix_operator<MatrixType, ipdg_method>(
- diffusion, boundary_info, space, over_integrate)
- .release(); // <- s.a. for release()
- },
- "diffusion"_a,
- "boundary_info"_a,
- "space"_a,
- "over_integrate"_a = 0,
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>(),
- py::keep_alive<0, 3>());
-
- m.def(std::string(method_id).c_str(),
- [](const D& diffusion,
- const XT::Grid::BoundaryInfo<typename R::GridViewType::Intersection>& boundary_info,
- MatrixType& matrix,
- const R& space,
- const size_t over_integrate) {
- return make_elliptic_ipdg_matrix_operator<ipdg_method>(
- diffusion, boundary_info, matrix, space, over_integrate)
- .release(); // <- s.a. for release()
- },
- "diffusion"_a,
- "boundary_info"_a,
- "matrix"_a,
- "space"_a,
- "over_integrate"_a = 0,
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>(),
- py::keep_alive<0, 3>(),
- py::keep_alive<0, 4>());
- } // ... addbind_factory_methods(...)
-}; // struct elliptic_ipdg_matrix_operator_bind_helper<..., void>
-
-
-} // namespace internal
-
-
-template <class DF,
- typename DT, // may be void
- class R,
- LocalEllipticIpdgIntegrands::Method method,
- class M = typename XT::LA::Container<typename R::RangeFieldType>::MatrixType,
- class GV = typename R::GridViewType,
- class S = R,
- class F = typename R::RangeFieldType>
-pybind11::class_<EllipticIpdgMatrixOperator<DF, DT, R, method, M, GV, S, F>> bind_elliptic_ipdg_matrix_operator(
- pybind11::module& m, const std::string& space_id, const std::string& la_id, const std::string& method_id)
-{
- static_assert(std::is_same<R, S>::value, "");
- static_assert(std::is_same<GV, typename R::GridViewType>::value, "");
-
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef EllipticIpdgMatrixOperator<DF, DT, R, method, M, GV, S, F> C;
- const std::string suffix =
- la_id + "__" + space_id + "_" + internal::elliptic_ipdg_matrix_operator_bind_helper<DF, DT, method>::suffix();
-
- auto c = bind_matrix_operator<C>(m, "Elliptic" + method_id + "MatrixOperator__" + suffix);
-
- internal::elliptic_ipdg_matrix_operator_bind_helper<DF, DT, method>::template addbind_factory_methods<C>(
- m, "make_elliptic_" + XT::Common::to_lower(method_id) + "_matrix_operator", la_id);
-
- return c;
-} // ... bind_elliptic_ipdg_matrix_operator(...)
-
-
-} // namespace GDT
-} // namespace Dune
-
-#endif // HAVE_DUNE_PYBINDXI
-#endif // DUNE_GDT_OPERATORS_ELLIPTIC_IPDG_PBH
diff --git a/dune/gdt/operators/elliptic.bindings.hh b/dune/gdt/operators/elliptic.bindings.hh
new file mode 100644
index 000000000..15681e708
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings.hh
@@ -0,0 +1,269 @@
+// This file is part of the dune-gdt project:
+// https://github.com/dune-community/dune-gdt
+// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
+// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
+// with "runtime exception" (http://www.dune-project.org/license.html)
+// Authors:
+// Felix Schindler (2017)
+
+#ifndef DUNE_GDT_OPERATORS_ELLIPTIC_BINDINGS_HH
+#define DUNE_GDT_OPERATORS_ELLIPTIC_BINDINGS_HH
+//#if HAVE_DUNE_PYBINDXI
+
+#include <dune/pybindxi/pybind11.h>
+
+#include <dune/xt/grid/grids.bindings.hh>
+
+#include <dune/gdt/spaces.bindings.hh>
+
+#include "base.bindings.hh"
+#include "elliptic.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+template <class DF,
+ typename DT, // may be void
+ class R,
+ class M = typename XT::LA::Container<typename R::RangeFieldType>::MatrixType /*,
+ class GV = typename R::GridViewType,
+ class S = R,
+ class F = typename R::RangeFieldType*/>
+class EllipticMatrixOperator
+{
+public:
+ typedef GDT::EllipticMatrixOperator<DF, DT, R, M /*, GV, S, F*/> type;
+ typedef pybind11::class_<type> bound_type;
+
+private:
+ template <bool single_diffusion = std::is_same<DT, void>::value, bool anything = false>
+ struct diffusion_switch
+ {
+ static std::string suffix()
+ {
+ return "diffusion_factor_and_tensor";
+ }
+
+ template <class C>
+ static void addbind_factory_methods(pybind11::module& m, const std::string& method_id, const std::string& la_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ m.def(
+ std::string(method_id + "__" + la_id).c_str(),
+ [](const DF& diffusion_factor, const DT& diffusion_tensor, const R& space, const size_t over_integrate) {
+ return make_elliptic_matrix_operator<M>(diffusion_factor, diffusion_tensor, space, over_integrate)
+ .release(); // <- b.c. EllipticMatrixOperator is not movable, returning the raw pointer lets pybind11
+ }, // correctly manage the memory
+ "diffusion_factor"_a,
+ "diffusion_tensor"_a,
+ "space"_a,
+ "over_integrate"_a = 0,
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>(),
+ py::keep_alive<0, 3>());
+
+ m.def(
+ std::string(method_id).c_str(),
+ [](const DF& diffusion_factor,
+ const DT& diffusion_tensor,
+ M& matrix,
+ const R& space,
+ const size_t over_integrate) {
+ return make_elliptic_matrix_operator(diffusion_factor, diffusion_tensor, matrix, space, over_integrate)
+ .release(); // <- s.a. for release()
+ },
+ "diffusion_factor"_a,
+ "diffusion_tensor"_a,
+ "matrix"_a,
+ "space"_a,
+ "over_integrate"_a = 0,
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>(),
+ py::keep_alive<0, 3>());
+ } // ... addbind_factory_methods(...)
+ }; // struct diffusion_switch
+
+ template <bool anything>
+ struct diffusion_switch<true, anything>
+ {
+ static std::string suffix()
+ {
+ return "single_diffusion";
+ }
+
+ template <class C>
+ static void addbind_factory_methods(pybind11::module& m, const std::string& method_id, const std::string& la_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ m.def(
+ std::string(method_id + "__" + la_id).c_str(),
+ [](const DF& diffusion, const R& space, const size_t over_integrate) {
+ return make_elliptic_matrix_operator<M>(diffusion, space, over_integrate).release(); // <- s.a. for
+ }, // .release()
+ "diffusion"_a,
+ "space"_a,
+ "over_integrate"_a = 0,
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>());
+
+ m.def(
+ std::string(method_id).c_str(),
+ [](const DF& diffusion, M& matrix, const R& space, const size_t over_integrate) {
+ return make_elliptic_matrix_operator(diffusion, matrix, space, over_integrate).release(); // <- s.a. for
+ }, // .release()
+ "diffusion"_a,
+ "matrix"_a,
+ "space"_a,
+ "over_integrate"_a = 0,
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>());
+ } // ... addbind_factory_methods(...)
+ }; // struct diffusion_switch<..., void>
+
+public:
+ static bound_type bind(pybind11::module& m, const std::string& space_id, const std::string& la_id)
+ {
+
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ const std::string suffix = la_id + "__" + space_id + diffusion_switch<>::suffix();
+
+ auto c = MatrixOperatorBase<type>::bind(m, "EllipticMatrixOperator__" + suffix);
+
+ diffusion_switch<>::template addbind_factory_methods<type>(m, "make_elliptic_matrix_operator", la_id);
+
+ return c;
+ } // ... bind(...)
+}; // class EllipticMatrixOperator
+
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(_prefix, _GRID, _LA) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, FV_SPACE(_GRID, leaf, gdt, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, FV_SPACE(_GRID, level, gdt, 1, 1), _LA)
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(_prefix, _GRID, _LA) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, CG_SPACE(_GRID, leaf, fem, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, CG_SPACE(_GRID, level, fem, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, DG_SPACE(_GRID, leaf, fem, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, DG_SPACE(_GRID, level, fem, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, DG_SPACE(_GRID, leaf, fem, 2, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, DG_SPACE(_GRID, level, fem, 2, 1, 1), _LA)
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(_prefix, _GRID, _LA) \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, CG_SPACE(_GRID, leaf, pdelab, 1, 1, 1), _LA); \
+ DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, CG_SPACE(_GRID, level, pdelab, 1, 1, 1), _LA)
+
+#define DUNE_GDT_OPERATORS_ELLIPTIC_BIND_(_prefix, _SPACE, _LA) \
+ _prefix class EllipticMatrixOperator<XT::Functions::LocalizableFunctionInterface<typename _SPACE::EntityType, \
+ typename _SPACE::DomainFieldType, \
+ _SPACE::dimDomain, \
+ typename _SPACE::RangeFieldType, \
+ 1, \
+ 1>, \
+ XT::Functions::LocalizableFunctionInterface<typename _SPACE::EntityType, \
+ typename _SPACE::DomainFieldType, \
+ _SPACE::dimDomain, \
+ typename _SPACE::RangeFieldType, \
+ _SPACE::dimDomain, \
+ _SPACE::dimDomain>, \
+ _SPACE, \
+ typename XT::LA::Container<typename _SPACE::RangeFieldType, \
+ XT::LA::Backends::_LA>::MatrixType>; \
+ _prefix class EllipticMatrixOperator<XT::Functions::LocalizableFunctionInterface<typename _SPACE::EntityType, \
+ typename _SPACE::DomainFieldType, \
+ _SPACE::dimDomain, \
+ typename _SPACE::RangeFieldType, \
+ 1, \
+ 1>, \
+ void, \
+ _SPACE, \
+ typename XT::LA::Container<typename _SPACE::RangeFieldType, \
+ XT::LA::Backends::_LA>::MatrixType>; \
+ _prefix class EllipticMatrixOperator<XT::Functions::LocalizableFunctionInterface<typename _SPACE::EntityType, \
+ typename _SPACE::DomainFieldType, \
+ _SPACE::dimDomain, \
+ typename _SPACE::RangeFieldType, \
+ _SPACE::dimDomain, \
+ _SPACE::dimDomain>, \
+ void, \
+ _SPACE, \
+ typename XT::LA::Container<typename _SPACE::RangeFieldType, \
+ XT::LA::Backends::_LA>::MatrixType>
+
+
+// these lines have to match the corresponding ones in the .cc source file
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(extern template, YASP_2D_EQUIDISTANT_OFFSET, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(extern template, YASP_2D_EQUIDISTANT_OFFSET, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(extern template, YASP_2D_EQUIDISTANT_OFFSET, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(extern template, YASP_2D_EQUIDISTANT_OFFSET, istl_sparse);
+#endif
+#if HAVE_DUNE_FEM
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, istl_sparse);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, istl_sparse);
+#endif
+#endif // HAVE_DUNE_PDELAB
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(extern template, ALU_2D_SIMPLEX_CONFORMING, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(extern template, ALU_2D_SIMPLEX_CONFORMING, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(extern template, ALU_2D_SIMPLEX_CONFORMING, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(extern template, ALU_2D_SIMPLEX_CONFORMING, istl_sparse);
+#endif
+#if HAVE_DUNE_FEM
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, istl_sparse);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, istl_sparse);
+#endif
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+//#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_OPERATORS_ELLIPTIC_BINDINGS_HH
diff --git a/dune/gdt/operators/elliptic.bindings/common_fem.cc b/dune/gdt/operators/elliptic.bindings/common_fem.cc
new file mode 100644
index 000000000..954684df2
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings/common_fem.cc
@@ -0,0 +1,28 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_FEM
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, common_dense);
+#endif // HAVE_DUNE_FEM
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, common_dense);
+#endif // HAVE_DUNE_FEM
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic.bindings/common_gdt.cc b/dune/gdt/operators/elliptic.bindings/common_gdt.cc
new file mode 100644
index 000000000..a27a62144
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings/common_gdt.cc
@@ -0,0 +1,24 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, common_dense);
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, common_dense);
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic.bindings/common_pdelab.cc b/dune/gdt/operators/elliptic.bindings/common_pdelab.cc
new file mode 100644
index 000000000..1bc439156
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings/common_pdelab.cc
@@ -0,0 +1,28 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, common_dense);
+#endif // HAVE_DUNE_PDELAB
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, common_dense);
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic.bindings/eigen_fem.cc b/dune/gdt/operators/elliptic.bindings/eigen_fem.cc
new file mode 100644
index 000000000..ad4d50da2
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings/eigen_fem.cc
@@ -0,0 +1,34 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_FEM
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_sparse);
+#endif
+#endif // HAVE_DUNE_FEM
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, eigen_sparse);
+#endif
+#endif // HAVE_DUNE_FEM
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic.bindings/eigen_gdt.cc b/dune/gdt/operators/elliptic.bindings/eigen_gdt.cc
new file mode 100644
index 000000000..43279ba8d
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings/eigen_gdt.cc
@@ -0,0 +1,30 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_sparse);
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, eigen_sparse);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic.bindings/eigen_pdelab.cc b/dune/gdt/operators/elliptic.bindings/eigen_pdelab.cc
new file mode 100644
index 000000000..ddb007d93
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings/eigen_pdelab.cc
@@ -0,0 +1,34 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_PDELAB
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, eigen_sparse);
+#endif
+#endif // HAVE_DUNE_PDELAB
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_PDELAB
+#if HAVE_EIGEN
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, eigen_dense);
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, eigen_sparse);
+#endif
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic.bindings/istl_fem.cc b/dune/gdt/operators/elliptic.bindings/istl_fem.cc
new file mode 100644
index 000000000..d7ac5b12e
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings/istl_fem.cc
@@ -0,0 +1,32 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_FEM
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, istl_sparse);
+#endif
+#endif // HAVE_DUNE_FEM
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, istl_sparse);
+#endif
+#endif // HAVE_DUNE_FEM
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic.bindings/istl_gdt.cc b/dune/gdt/operators/elliptic.bindings/istl_gdt.cc
new file mode 100644
index 000000000..fb9433d9f
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings/istl_gdt.cc
@@ -0,0 +1,28 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET, istl_sparse);
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING, istl_sparse);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic.bindings/istl_pdelab.cc b/dune/gdt/operators/elliptic.bindings/istl_pdelab.cc
new file mode 100644
index 000000000..dbf5c9160
--- /dev/null
+++ b/dune/gdt/operators/elliptic.bindings/istl_pdelab.cc
@@ -0,0 +1,32 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "../elliptic.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_PDELAB
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, istl_sparse);
+#endif
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_PDELAB
+#if HAVE_DUNE_ISTL
+DUNE_GDT_OPERATORS_ELLIPTIC_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, istl_sparse);
+#endif
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/operators/elliptic.pbh b/dune/gdt/operators/elliptic.pbh
deleted file mode 100644
index 7bde709a5..000000000
--- a/dune/gdt/operators/elliptic.pbh
+++ /dev/null
@@ -1,151 +0,0 @@
-// This file is part of the dune-gdt project:
-// https://github.com/dune-community/dune-gdt
-// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
-// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
-// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
-// with "runtime exception" (http://www.dune-project.org/license.html)
-// Authors:
-// Felix Schindler (2017)
-
-#ifndef DUNE_GDT_OPERATORS_ELLIPTIC_PBH
-#define DUNE_GDT_OPERATORS_ELLIPTIC_PBH
-#if HAVE_DUNE_PYBINDXI
-
-#include <dune/pybindxi/pybind11.h>
-
-#include "elliptic.hh"
-#include "base.pbh"
-
-namespace Dune {
-namespace GDT {
-namespace internal {
-
-
-template <class DF, typename DT>
-struct elliptic_matrix_operator_bind_helper
-{
- static std::string suffix()
- {
- return "diffusion_factor_and_tensor";
- }
-
- template <class C>
- static void addbind_factory_methods(pybind11::module& m, const std::string& method_id, const std::string& la_id)
- {
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef typename C::RangeSpaceType R;
- typedef typename C::MatrixType MatrixType;
-
- m.def(std::string(method_id + "__" + la_id).c_str(),
- [](const DF& diffusion_factor, const DT& diffusion_tensor, const R& space, const size_t over_integrate) {
- return make_elliptic_matrix_operator<MatrixType>(diffusion_factor, diffusion_tensor, space, over_integrate)
- .release(); // <- b.c. EllipticMatrixOperator is not movable, returning the raw pointer lets pybind11
- }, // correctly manage the memory
- "diffusion_factor"_a,
- "diffusion_tensor"_a,
- "space"_a,
- "over_integrate"_a = 0,
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>(),
- py::keep_alive<0, 3>());
-
- m.def(std::string(method_id).c_str(),
- [](const DF& diffusion_factor,
- const DT& diffusion_tensor,
- MatrixType& matrix,
- const R& space,
- const size_t over_integrate) {
- return make_elliptic_matrix_operator(diffusion_factor, diffusion_tensor, matrix, space, over_integrate)
- .release(); // <- s.a. for release()
- },
- "diffusion_factor"_a,
- "diffusion_tensor"_a,
- "matrix"_a,
- "space"_a,
- "over_integrate"_a = 0,
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>(),
- py::keep_alive<0, 3>());
- } // ... addbind_factory_methods(...)
-}; // struct elliptic_matrix_operator_bind_helper
-
-template <class D>
-struct elliptic_matrix_operator_bind_helper<D, void>
-{
- static std::string suffix()
- {
- return "single_diffusion";
- }
-
- template <class C>
- static void addbind_factory_methods(pybind11::module& m, const std::string& method_id, const std::string& la_id)
- {
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef typename C::RangeSpaceType R;
- typedef typename C::MatrixType MatrixType;
-
- m.def(std::string(method_id + "__" + la_id).c_str(),
- [](const D& diffusion, const R& space, const size_t over_integrate) {
- return make_elliptic_matrix_operator<MatrixType>(diffusion, space, over_integrate).release(); // <- s.a. for
- }, // .release()
- "diffusion"_a,
- "space"_a,
- "over_integrate"_a = 0,
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>());
-
- m.def(std::string(method_id).c_str(),
- [](const D& diffusion, MatrixType& matrix, const R& space, const size_t over_integrate) {
- return make_elliptic_matrix_operator(diffusion, matrix, space, over_integrate).release(); // <- s.a. for
- }, // .release()
- "diffusion"_a,
- "matrix"_a,
- "space"_a,
- "over_integrate"_a = 0,
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>());
- } // ... addbind_factory_methods(...)
-}; // struct elliptic_matrix_operator_bind_helper<..., void>
-
-
-} // namespace internal
-
-
-template <class DF,
- typename DT, // may be void
- class R,
- class M = typename XT::LA::Container<typename R::RangeFieldType>::MatrixType,
- class GV = typename R::GridViewType,
- class S = R,
- class F = typename R::RangeFieldType>
-pybind11::class_<EllipticMatrixOperator<DF, DT, R, M, GV, S, F>>
-bind_elliptic_matrix_operator(pybind11::module& m, const std::string& space_id, const std::string& la_id)
-{
- static_assert(std::is_same<R, S>::value, "");
- static_assert(std::is_same<GV, typename R::GridViewType>::value, "");
-
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef EllipticMatrixOperator<DF, DT, R, M, GV, S, F> C;
- const std::string suffix = la_id + "__" + space_id + internal::elliptic_matrix_operator_bind_helper<DF, DT>::suffix();
-
- auto c = bind_matrix_operator<C>(m, "EllipticMatrixOperator__" + suffix);
-
- internal::elliptic_matrix_operator_bind_helper<DF, DT>::template addbind_factory_methods<C>(
- m, "make_elliptic_matrix_operator", la_id);
-
- return c;
-
-} // ... bind_elliptic_matrix_operator(...)
-
-
-} // namespace GDT
-} // namespace Dune
-
-#endif // HAVE_DUNE_PYBINDXI
-#endif // DUNE_GDT_OPERATORS_ELLIPTIC_PBH
diff --git a/dune/gdt/projections/dirichlet.bindings.cc b/dune/gdt/projections/dirichlet.bindings.cc
new file mode 100644
index 000000000..ee2b71e38
--- /dev/null
+++ b/dune/gdt/projections/dirichlet.bindings.cc
@@ -0,0 +1,58 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "dirichlet.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_FEM
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_PDELAB
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/projections/dirichlet.bindings.hh b/dune/gdt/projections/dirichlet.bindings.hh
new file mode 100644
index 000000000..83cfd1dd5
--- /dev/null
+++ b/dune/gdt/projections/dirichlet.bindings.hh
@@ -0,0 +1,135 @@
+// This file is part of the dune-gdt project:
+// https://github.com/dune-community/dune-gdt
+// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
+// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
+// with "runtime exception" (http://www.dune-project.org/license.html)
+// Authors:
+// Felix Schindler (2017)
+
+#ifndef DUNE_GDT_PROJECTIONS_DIRICHLET_BINDINGS_HH
+#define DUNE_GDT_PROJECTIONS_DIRICHLET_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <dune/pybindxi/pybind11.h>
+
+#include <dune/xt/grid/grids.bindings.hh>
+#include <dune/xt/la/container.bindings.hh>
+
+#include <dune/gdt/spaces.bindings.hh>
+
+#include "dirichlet.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+template <class GV, class S, class R, class F = double>
+class DirichletProjectionLocalizableOperator
+{
+public:
+ typedef GDT::DirichletProjectionLocalizableOperator<GV, S, R, F> type;
+
+private:
+ typedef XT::Grid::Walker<GV> BaseType;
+
+public:
+ typedef pybind11::class_<type, BaseType> bound_type;
+
+ static bound_type bind(pybind11::module& m, const std::string& space_id, const std::string& la_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ bound_type c(m, std::string("DirichletProjectionLocalizableOperator__" + space_id + "__" + la_id).c_str());
+ c.def("apply", [](type& self) { self.apply(); });
+
+ m.def(std::string("make_localizable_dirichlet_projection_operator").c_str(),
+ [](const XT::Grid::BoundaryInfo<typename XT::Grid::Intersection<GV>::Type>& boundary_info,
+ const S& source,
+ R& range) {
+ return make_localizable_dirichlet_projection_operator(
+ range.space().grid_view(), boundary_info, source, range)
+ .release();
+ },
+ "boundary_info"_a,
+ "source"_a,
+ "range"_a,
+ py::keep_alive<0, 1>(),
+ py::keep_alive<0, 2>(),
+ py::keep_alive<0, 3>());
+
+ return c;
+ } // ... bind(...)
+}; // class DirichletProjectionLocalizableOperator
+
+
+#define DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(_prefix, _GRID, _LA) \
+ _prefix DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_(CG_SPACE(_GRID, leaf, fem, 1, 1, 1), _LA); \
+ _prefix DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_(CG_SPACE(_GRID, level, fem, 1, 1, 1), _LA)
+
+#define DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(_prefix, _GRID, _LA) \
+ _prefix DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_(CG_SPACE(_GRID, leaf, pdelab, 1, 1, 1), _LA); \
+ _prefix DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_(CG_SPACE(_GRID, level, pdelab, 1, 1, 1), _LA)
+
+#define DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_(_SPACE, _LA) \
+ class DirichletProjectionLocalizableOperator< \
+ typename _SPACE::GridViewType, \
+ XT::Functions::LocalizableFunctionInterface<typename _SPACE::EntityType, \
+ typename _SPACE::DomainFieldType, \
+ _SPACE::dimDomain, \
+ typename _SPACE::RangeFieldType, \
+ _SPACE::dimRange, \
+ _SPACE::dimRangeCols>, \
+ DiscreteFunction<_SPACE, _LA>>
+
+
+// these lines have to match the corresponding ones in the .cc source file
+#if HAVE_DUNE_FEM
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_PDELAB
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_FEM
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, COMMON_DENSE_VECTOR);
+#if HAVE_EIGEN
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, EIGEN_DENSE_VECTOR);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_PROJECTIONS_DIRICHLET_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING, ISTL_DENSE_VECTOR);
+#endif
+#endif // HAVE_DUNE_PDELAB
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_PROJECTIONS_DIRICHLET_BINDINGS_HH
diff --git a/dune/gdt/projections/dirichlet.pbh b/dune/gdt/projections/dirichlet.pbh
deleted file mode 100644
index ed7404cd0..000000000
--- a/dune/gdt/projections/dirichlet.pbh
+++ /dev/null
@@ -1,56 +0,0 @@
-// This file is part of the dune-gdt project:
-// https://github.com/dune-community/dune-gdt
-// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
-// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
-// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
-// with "runtime exception" (http://www.dune-project.org/license.html)
-// Authors:
-// Felix Schindler (2017)
-
-#ifndef DUNE_GDT_PROJECTIONS_DIRICHLET_PBH
-#define DUNE_GDT_PROJECTIONS_DIRICHLET_PBH
-#if HAVE_DUNE_PYBINDXI
-
-#include <dune/pybindxi/pybind11.h>
-
-#include "dirichlet.hh"
-
-namespace Dune {
-namespace GDT {
-
-
-template <class GV, class S, class R, class F = double>
-pybind11::class_<DirichletProjectionLocalizableOperator<GV, S, R, F>, XT::Grid::Walker<GV>>
-bind_DirichletProjectionLocalizableOperator(pybind11::module& m, const std::string& space_id, const std::string& la_id)
-{
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef DirichletProjectionLocalizableOperator<GV, S, R, F> C;
- py::class_<C, XT::Grid::Walker<GV>> c(
- m, std::string("DirichletProjectionLocalizableOperator__" + space_id + "__" + la_id).c_str());
- c.def("apply", [](C& self) { self.apply(); });
-
- m.def(std::string("make_localizable_dirichlet_projection_operator").c_str(),
- [](const XT::Grid::BoundaryInfo<typename XT::Grid::Intersection<GV>::Type>& boundary_info,
- const S& source,
- R& range) {
- return make_localizable_dirichlet_projection_operator(range.space().grid_view(), boundary_info, source, range)
- .release();
- },
- "boundary_info"_a,
- "source"_a,
- "range"_a,
- py::keep_alive<0, 1>(),
- py::keep_alive<0, 2>(),
- py::keep_alive<0, 3>());
-
- return c;
-} // ... bind_DirichletProjectionLocalizableOperator(...)
-
-
-} // namespace GDT
-} // namespace Dune
-
-#endif // HAVE_DUNE_PYBINDXI
-#endif // DUNE_GDT_PROJECTIONS_DIRICHLET_PBH
diff --git a/dune/gdt/spaces.bindings.hh b/dune/gdt/spaces.bindings.hh
new file mode 100644
index 000000000..84ba87598
--- /dev/null
+++ b/dune/gdt/spaces.bindings.hh
@@ -0,0 +1,11 @@
+#ifndef DUNE_GDT_SPACES_BINDINGS_HH
+#define DUNE_GDT_SPACES_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include "spaces/interface.bindings.hh"
+#include "spaces/cg.bindings.hh"
+#include "spaces/dg.bindings.hh"
+#include "spaces/fv.bindings.hh"
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_SPACES_BINDINGS_HH
diff --git a/dune/gdt/spaces/cg.bindings.cc b/dune/gdt/spaces/cg.bindings.cc
new file mode 100644
index 000000000..6ecdaf4ba
--- /dev/null
+++ b/dune/gdt/spaces/cg.bindings.cc
@@ -0,0 +1,34 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "cg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_CG_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_SPACES_CG_BIND_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_CG_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_SPACES_CG_BIND_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/spaces/cg.bindings.hh b/dune/gdt/spaces/cg.bindings.hh
new file mode 100644
index 000000000..31f7c3631
--- /dev/null
+++ b/dune/gdt/spaces/cg.bindings.hh
@@ -0,0 +1,78 @@
+#ifndef DUNE_GDT_SPACES_CG_BINDINGS_HH
+#define DUNE_GDT_SPACES_CG_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <dune/xt/grid/grids.bindings.hh>
+
+#include "cg.hh"
+#include "interface.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+#define _DEFINE_CG_SPACE(_G, _layer, _backend, _p, _r, _rC) \
+ typedef \
+ typename CgSpaceProvider<_G, XT::Grid::Layers::_layer, ChooseSpaceBackend::_backend, _p, double, _r, _rC>::type \
+ Cg_##_G##_##_layer##_to_##_r##x##_rC##_##p##_p##_##_backend##_Space
+
+#if HAVE_DUNE_FEM
+_DEFINE_CG_SPACE(YASP_2D_EQUIDISTANT_OFFSET, leaf, fem, 1, 1, 1);
+_DEFINE_CG_SPACE(YASP_2D_EQUIDISTANT_OFFSET, level, fem, 1, 1, 1);
+#endif
+#if HAVE_DUNE_PDELAB
+_DEFINE_CG_SPACE(YASP_2D_EQUIDISTANT_OFFSET, leaf, pdelab, 1, 1, 1);
+_DEFINE_CG_SPACE(YASP_2D_EQUIDISTANT_OFFSET, level, pdelab, 1, 1, 1);
+#endif
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+_DEFINE_CG_SPACE(ALU_2D_SIMPLEX_CONFORMING, leaf, fem, 1, 1, 1);
+_DEFINE_CG_SPACE(ALU_2D_SIMPLEX_CONFORMING, level, fem, 1, 1, 1);
+#endif
+#if HAVE_DUNE_PDELAB
+_DEFINE_CG_SPACE(ALU_2D_SIMPLEX_CONFORMING, leaf, pdelab, 1, 1, 1);
+_DEFINE_CG_SPACE(ALU_2D_SIMPLEX_CONFORMING, level, pdelab, 1, 1, 1);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+#undef _DEFINE_CG_SPACE
+
+
+// this is used by other headers
+#define CG_SPACE(_G, _layer, _backend, _p, _r, _rC) Cg_##_G##_##_layer##_to_##_r##x##_rC##_##p##_p##_##_backend##_Space
+
+
+#define DUNE_GDT_SPACES_CG_BIND_FEM(_prefix, _GRID) \
+ _prefix class SpaceInterface<CG_SPACE(_GRID, leaf, fem, 1, 1, 1)>; \
+ _prefix class SpaceInterface<CG_SPACE(_GRID, level, fem, 1, 1, 1)>
+
+#define DUNE_GDT_SPACES_CG_BIND_PDELAB(_prefix, _GRID) \
+ _prefix class SpaceInterface<CG_SPACE(_GRID, leaf, pdelab, 1, 1, 1)>; \
+ _prefix class SpaceInterface<CG_SPACE(_GRID, level, pdelab, 1, 1, 1)>
+
+
+// these lines have to match the corresponding ones in the .cc source file
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_CG_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_SPACES_CG_BIND_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_CG_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_SPACES_CG_BIND_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_SPACES_CG_BINDINGS_HH
diff --git a/dune/gdt/spaces/constraints.bindings.cc b/dune/gdt/spaces/constraints.bindings.cc
new file mode 100644
index 000000000..88fb4bc79
--- /dev/null
+++ b/dune/gdt/spaces/constraints.bindings.cc
@@ -0,0 +1,58 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "constraints.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .cc source file
+DUNE_GDT_SPACES_CONSTRAINTS_BIND(template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view);
+
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view, eigen_dense);
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view, istl_sparse);
+#endif
+
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_FEM(template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_PDELAB(template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_SPACES_CONSTRAINTS_BIND(template, ALU_2D_SIMPLEX_CONFORMING, leaf, view);
+DUNE_GDT_SPACES_CONSTRAINTS_BIND(template, ALU_2D_SIMPLEX_CONFORMING, level, view);
+
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(template, ALU_2D_SIMPLEX_CONFORMING, leaf, view, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(template, ALU_2D_SIMPLEX_CONFORMING, leaf, view, eigen_dense);
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(template, ALU_2D_SIMPLEX_CONFORMING, leaf, view, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(template, ALU_2D_SIMPLEX_CONFORMING, leaf, view, istl_sparse);
+#endif
+
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_FEM(template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_PDELAB(template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#endif
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/spaces/constraints.bindings.hh b/dune/gdt/spaces/constraints.bindings.hh
new file mode 100644
index 000000000..fdf53eeb3
--- /dev/null
+++ b/dune/gdt/spaces/constraints.bindings.hh
@@ -0,0 +1,190 @@
+// This file is part of the dune-gdt project:
+// https://github.com/dune-community/dune-gdt
+// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
+// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
+// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
+// with "runtime exception" (http://www.dune-project.org/license.html)
+// Authors:
+// Felix Schindler (2017)
+
+#ifndef DUNE_GDT_SPACES_CONSTRAINTS_BINDINGS_HH
+#define DUNE_GDT_SPACES_CONSTRAINTS_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <dune/pybindxi/pybind11.h>
+
+#include <dune/xt/common/exceptions.hh>
+#include <dune/xt/common/type_traits.hh>
+#include <dune/xt/grid/intersection.hh>
+#include <dune/xt/grid/grids.bindings.hh>
+
+#include <dune/xt/la/container.hh>
+#include <dune/xt/la/container.bindings.hh>
+
+#include <dune/gdt/assembler/system.hh>
+#include <dune/gdt/spaces/cg.bindings.hh>
+
+#include "constraints.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+template <class I>
+class DirichletConstraints
+{
+public:
+ typedef GDT::DirichletConstraints<I> type;
+ typedef pybind11::class_<type> bound_type;
+
+ static bound_type bind(pybind11::module& m, const std::string& intersection_id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ bound_type c(m, std::string("DirichletConstraints__" + intersection_id).c_str());
+ c.def("__init__",
+ [](type& self, const XT::Grid::BoundaryInfo<I>& boundary_info, const ssize_t size, const bool set) {
+ try {
+ new (&self) type(boundary_info, boost::numeric_cast<size_t>(size), set);
+ } catch (boost::bad_numeric_cast& ee) {
+ DUNE_THROW(XT::Common::Exceptions::wrong_input_given,
+ "Given size has to be positive!\n\n The error in boost while converting '"
+ << size
+ << "' to '"
+ << XT::Common::Typename<size_t>::value()
+ << "' was: "
+ << ee.what());
+ }
+ },
+ "boundary_info"_a,
+ "size"_a,
+ "set_diagonal_entries"_a = true,
+ py::keep_alive<1, 2>());
+ c.def("boundary_info", &type::boundary_info);
+ c.def("size", &type::size);
+
+ m.def(std::string("make_dirichlet_constraints").c_str(),
+ [](const XT::Grid::BoundaryInfo<I>& boundary_info, const ssize_t size, const bool set) {
+ size_t size__as_size_t = 0;
+ try {
+ size__as_size_t = boost::numeric_cast<size_t>(size);
+ } catch (boost::bad_numeric_cast& ee) {
+ DUNE_THROW(XT::Common::Exceptions::wrong_input_given,
+ "Given size has to be positive!\n\n The error in boost while converting '"
+ << size
+ << "' to '"
+ << XT::Common::Typename<size_t>::value()
+ << "' was: "
+ << ee.what());
+ }
+ return type(boundary_info, size__as_size_t, set);
+ },
+ "boundary_info"_a,
+ "size"_a,
+ "set_diagonal_entries"_a,
+ py::keep_alive<0, 1>());
+
+ return c;
+ } // ... bind(...)
+
+ template <XT::LA::Backends la_backend, class R = double>
+ static void addbind(bound_type& c)
+ {
+ typedef typename XT::LA::Container<R, la_backend>::MatrixType M;
+ typedef typename XT::LA::Container<R, la_backend>::VectorType V;
+ using namespace pybind11::literals;
+
+ c.def("apply", [](const type& self, M& matrix) { self.apply(matrix); }, "matrix"_a);
+ c.def("apply", [](const type& self, V& vector) { self.apply(vector); }, "vector"_a);
+ c.def("apply", [](const type& self, M& matrix, V& vector) { self.apply(matrix, vector); }, "matrix"_a, "vector"_a);
+ }
+
+ template <class T, class GV, class A>
+ static void addbind(pybind11::class_<GDT::SystemAssembler<T, GV, A>>& bound_system_assembler)
+ {
+ using namespace pybind11::literals;
+
+ bound_system_assembler.def("append",
+ [](GDT::SystemAssembler<T, GV, A>& self,
+ GDT::DirichletConstraints<typename XT::Grid::Intersection<GV>::type>& constraints) {
+ self.append(constraints);
+ },
+ "dirichlet_constraints"_a);
+ } // ... addbind_to_SystemAssembler(...)
+}; // class addbind_to_SystemAssembler
+
+
+#define DUNE_GDT_SPACES_CONSTRAINTS_BIND(_prefix, _GRID, _layer, _backend) \
+ _prefix class DirichletConstraints<typename XT::Grid::Intersection< \
+ typename XT::Grid::Layer<_GRID, XT::Grid::Layers::_layer, XT::Grid::Backends::_backend>::type>::type>
+
+#define DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(_prefix, _GRID, _layer, _backend, _la) \
+ _prefix void DirichletConstraints<typename XT::Grid::Intersection< \
+ typename XT::Grid::Layer<_GRID, XT::Grid::Layers::_layer, XT::Grid::Backends::_backend>::type>::type>:: \
+ addbind<XT::LA::Backends::_la>( \
+ typename DirichletConstraints<typename XT::Grid::Intersection< \
+ typename XT::Grid::Layer<_GRID, XT::Grid::Layers::_layer, XT::Grid::Backends::_backend>::type>::type>:: \
+ bound_type&)
+
+#define DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_FEM(_prefix, _GRID) \
+ DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_(_prefix, CG_SPACE(_GRID, leaf, fem, 1, 1, 1)); \
+ DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_(_prefix, CG_SPACE(_GRID, level, fem, 1, 1, 1))
+
+#define DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_PDELAB(_prefix, _GRID) \
+ DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_(_prefix, CG_SPACE(_GRID, leaf, pdelab, 1, 1, 1)); \
+ DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_(_prefix, CG_SPACE(_GRID, level, pdelab, 1, 1, 1))
+
+#define DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_(_prefix, _SPACE) \
+ _prefix void DirichletConstraints<typename XT::Grid::Intersection<typename _SPACE::GridViewType>::type>:: \
+ addbind<_SPACE, typename _SPACE::GridViewType, _SPACE>( \
+ pybind11::class_<GDT::SystemAssembler<_SPACE, typename _SPACE::GridViewType, _SPACE>>&)
+
+
+// these lines have to match the corresponding ones in the .hh header file
+DUNE_GDT_SPACES_CONSTRAINTS_BIND(extern template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view);
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(extern template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(extern template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view, eigen_dense);
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(extern template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(extern template, YASP_2D_EQUIDISTANT_OFFSET, leaf, view, istl_sparse);
+#endif
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_PDELAB(extern template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_SPACES_CONSTRAINTS_BIND(extern template, ALU_2D_SIMPLEX_CONFORMING, leaf, view);
+DUNE_GDT_SPACES_CONSTRAINTS_BIND(extern template, ALU_2D_SIMPLEX_CONFORMING, level, view);
+DUNE_GDT_SPACES_CONSTRAINTS_BIND(extern template, ALU_2D_SIMPLEX_CONFORMING, leaf, view);
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(extern template, ALU_2D_SIMPLEX_CONFORMING, leaf, view, common_dense);
+#if HAVE_EIGEN
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(extern template, ALU_2D_SIMPLEX_CONFORMING, leaf, view, eigen_dense);
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(extern template, ALU_2D_SIMPLEX_CONFORMING, leaf, view, eigen_sparse);
+#endif
+#if HAVE_DUNE_ISTL
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_LA(extern template, ALU_2D_SIMPLEX_CONFORMING, leaf, view, istl_sparse);
+#endif
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#if HAVE_DUNE_PDELAB
+DUNE_GDT_SPACES_CONSTRAINTS_ADDBIND_ASSEMBLER_PDELAB(extern template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#endif
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_SPACES_CONSTRAINTS_BINDINGS_HH
diff --git a/dune/gdt/spaces/constraints.pbh b/dune/gdt/spaces/constraints.pbh
deleted file mode 100644
index 9b4fc7bf6..000000000
--- a/dune/gdt/spaces/constraints.pbh
+++ /dev/null
@@ -1,109 +0,0 @@
-// This file is part of the dune-gdt project:
-// https://github.com/dune-community/dune-gdt
-// Copyright 2010-2016 dune-gdt developers and contributors. All rights reserved.
-// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
-// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
-// with "runtime exception" (http://www.dune-project.org/license.html)
-// Authors:
-// Felix Schindler (2017)
-
-#ifndef DUNE_GDT_SPACES_CONSTRAINTS_PBH
-#define DUNE_GDT_SPACES_CONSTRAINTS_PBH
-#if HAVE_DUNE_PYBINDXI
-
-#include <boost/numeric/conversion/cast.hpp>
-
-#include <dune/pybindxi/pybind11.h>
-
-#include <dune/xt/common/exceptions.hh>
-#include <dune/xt/common/type_traits.hh>
-
-#include <dune/xt/grid/intersection.hh>
-
-#include <dune/xt/la/container.hh>
-
-#include "constraints.hh"
-
-namespace Dune {
-namespace GDT {
-
-
-template <class I, XT::LA::Backends la_backend, class R = double>
-pybind11::class_<DirichletConstraints<I>>
-bind_DirichletConstraints(pybind11::module& m, const std::string& intersection_id, const std::string& la_id)
-{
- namespace py = pybind11;
- using namespace pybind11::literals;
-
- typedef DirichletConstraints<I> C;
- typedef typename XT::LA::Container<R, la_backend>::MatrixType M;
- typedef typename XT::LA::Container<R, la_backend>::VectorType V;
- py::class_<C> c(m, std::string("DirichletConstraints__" + intersection_id + "__" + la_id).c_str());
- c.def("__init__",
- [](C& self, const XT::Grid::BoundaryInfo<I>& boundary_info, const ssize_t size, const bool set) {
- try {
- new (&self) C(boundary_info, boost::numeric_cast<size_t>(size), set);
- } catch (boost::bad_numeric_cast& ee) {
- DUNE_THROW(XT::Common::Exceptions::wrong_input_given,
- "Given size has to be positive!\n\n The error in boost while converting '"
- << size
- << "' to '"
- << XT::Common::Typename<size_t>::value()
- << "' was: "
- << ee.what());
- }
- },
- "boundary_info"_a,
- "size"_a,
- "set_diagonal_entries"_a = true,
- py::keep_alive<1, 2>());
- c.def("boundary_info", &C::boundary_info);
- c.def("size", &C::size);
- c.def("apply", [](const C& self, M& matrix) { self.apply(matrix); }, "matrix"_a);
- c.def("apply", [](const C& self, V& vector) { self.apply(vector); }, "vector"_a);
- c.def("apply", [](const C& self, M& matrix, V& vector) { self.apply(matrix, vector); }, "matrix"_a, "vector"_a);
-
- m.def(std::string("make_dirichlet_constraints__" + la_id).c_str(),
- [](const XT::Grid::BoundaryInfo<I>& boundary_info, const ssize_t size, const bool set) {
- size_t size__as_size_t = 0;
- try {
- size__as_size_t = boost::numeric_cast<size_t>(size);
- } catch (boost::bad_numeric_cast& ee) {
- DUNE_THROW(XT::Common::Exceptions::wrong_input_given,
- "Given size has to be positive!\n\n The error in boost while converting '"
- << size
- << "' to '"
- << XT::Common::Typename<size_t>::value()
- << "' was: "
- << ee.what());
- }
- return C(boundary_info, size__as_size_t, set);
- },
- "boundary_info"_a,
- "size"_a,
- "set_diagonal_entries"_a,
- py::keep_alive<0, 1>());
-
- return c;
-} // ... bind_DirichletConstraints(...)
-
-
-template <class S>
-void addbind_Dirichlet_Constraints_to_SystemAssembler(pybind11::class_<S>& bound_system_assembler)
-{
- using namespace pybind11::literals;
-
- bound_system_assembler.def(
- "append",
- [](S& self, DirichletConstraints<typename XT::Grid::Intersection<typename S::GridViewType>::type>& constraints) {
- self.append(constraints);
- },
- "dirichlet_constraints"_a);
-}
-
-
-} // namespace GDT
-} // namespace Dune
-
-#endif // HAVE_DUNE_PYBINDXI
-#endif // DUNE_GDT_SPACES_CONSTRAINTS_PBH
diff --git a/dune/gdt/spaces/dg.bindings.cc b/dune/gdt/spaces/dg.bindings.cc
new file mode 100644
index 000000000..36e5da3b6
--- /dev/null
+++ b/dune/gdt/spaces/dg.bindings.cc
@@ -0,0 +1,28 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "dg.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_DG_BIND_FEM(template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_DG_BIND_FEM(template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/spaces/dg.bindings.hh b/dune/gdt/spaces/dg.bindings.hh
new file mode 100644
index 000000000..9b770542a
--- /dev/null
+++ b/dune/gdt/spaces/dg.bindings.hh
@@ -0,0 +1,66 @@
+#ifndef DUNE_GDT_SPACES_DG_BINDINGS_HH
+#define DUNE_GDT_SPACES_DG_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <dune/xt/grid/grids.bindings.hh>
+
+#include "dg.hh"
+#include "interface.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+#define _DEFINE_DG_SPACE(_G, _layer, _backend, _p, _r, _rC) \
+ typedef \
+ typename DgSpaceProvider<_G, XT::Grid::Layers::_layer, ChooseSpaceBackend::_backend, _p, double, _r, _rC>::type \
+ Dg_##_G##_##_layer##_to_##_r##x##_rC##_##p##_p##_##_backend##_Space
+
+#if HAVE_DUNE_FEM
+_DEFINE_DG_SPACE(YASP_2D_EQUIDISTANT_OFFSET, leaf, fem, 1, 1, 1);
+_DEFINE_DG_SPACE(YASP_2D_EQUIDISTANT_OFFSET, leaf, fem, 2, 1, 1);
+_DEFINE_DG_SPACE(YASP_2D_EQUIDISTANT_OFFSET, level, fem, 1, 1, 1);
+_DEFINE_DG_SPACE(YASP_2D_EQUIDISTANT_OFFSET, level, fem, 2, 1, 1);
+#endif
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+_DEFINE_DG_SPACE(ALU_2D_SIMPLEX_CONFORMING, leaf, fem, 1, 1, 1);
+_DEFINE_DG_SPACE(ALU_2D_SIMPLEX_CONFORMING, leaf, fem, 2, 1, 1);
+_DEFINE_DG_SPACE(ALU_2D_SIMPLEX_CONFORMING, level, fem, 1, 1, 1);
+_DEFINE_DG_SPACE(ALU_2D_SIMPLEX_CONFORMING, level, fem, 2, 1, 1);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+#undef _DEFINE_DG_SPACE
+
+
+// this is used by other headers
+#define DG_SPACE(_G, _layer, _backend, _p, _r, _rC) Dg_##_G##_##_layer##_to_##_r##x##_rC##_##p##_p##_##_backend##_Space
+
+
+#define DUNE_GDT_SPACES_DG_BIND_FEM(_prefix, _GRID) \
+ _prefix class SpaceInterface<DG_SPACE(_GRID, leaf, fem, 1, 1, 1)>; \
+ _prefix class SpaceInterface<DG_SPACE(_GRID, level, fem, 1, 1, 1)>; \
+ _prefix class SpaceInterface<DG_SPACE(_GRID, leaf, fem, 2, 1, 1)>; \
+ _prefix class SpaceInterface<DG_SPACE(_GRID, level, fem, 2, 1, 1)>
+
+
+// these lines have to match the corresponding ones in the .cc source file
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_DG_BIND_FEM(extern template, YASP_2D_EQUIDISTANT_OFFSET);
+#endif
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+#if HAVE_DUNE_FEM
+DUNE_GDT_SPACES_DG_BIND_FEM(extern template, ALU_2D_SIMPLEX_CONFORMING);
+#endif
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_SPACES_DG_BINDINGS_HH
diff --git a/dune/gdt/spaces/fv.bindings.cc b/dune/gdt/spaces/fv.bindings.cc
new file mode 100644
index 000000000..d2a186edb
--- /dev/null
+++ b/dune/gdt/spaces/fv.bindings.cc
@@ -0,0 +1,23 @@
+#include "config.h"
+
+#if HAVE_DUNE_PYBINDXI
+
+#include "fv.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+// these lines have to match the corresponding ones in the .hh header file
+DUNE_GDT_SPACES_FV_BIND_GDT(template, YASP_2D_EQUIDISTANT_OFFSET);
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_SPACES_FV_BIND_GDT(template, ALU_2D_SIMPLEX_CONFORMING);
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
diff --git a/dune/gdt/spaces/fv.bindings.hh b/dune/gdt/spaces/fv.bindings.hh
new file mode 100644
index 000000000..09e7c7516
--- /dev/null
+++ b/dune/gdt/spaces/fv.bindings.hh
@@ -0,0 +1,55 @@
+#ifndef DUNE_GDT_SPACES_FV_BINDINGS_HH
+#define DUNE_GDT_SPACES_FV_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <dune/xt/grid/grids.bindings.hh>
+
+#include "fv.hh"
+#include "interface.bindings.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+#define _DEFINE_FV_SPACE(_G, _layer, _backend, _r, _rC) \
+ typedef typename FvSpaceProvider<_G, XT::Grid::Layers::_layer, ChooseSpaceBackend::_backend, double, _r, _rC>::type \
+ Fv_##_G##_##_layer##_to_##_r##x##_rC##_##_backend##_Space
+
+_DEFINE_FV_SPACE(YASP_2D_EQUIDISTANT_OFFSET, leaf, gdt, 1, 1);
+_DEFINE_FV_SPACE(YASP_2D_EQUIDISTANT_OFFSET, leaf, gdt, 1, 1);
+_DEFINE_FV_SPACE(YASP_2D_EQUIDISTANT_OFFSET, level, gdt, 1, 1);
+_DEFINE_FV_SPACE(YASP_2D_EQUIDISTANT_OFFSET, level, gdt, 1, 1);
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+_DEFINE_FV_SPACE(ALU_2D_SIMPLEX_CONFORMING, leaf, gdt, 1, 1);
+_DEFINE_FV_SPACE(ALU_2D_SIMPLEX_CONFORMING, leaf, gdt, 1, 1);
+_DEFINE_FV_SPACE(ALU_2D_SIMPLEX_CONFORMING, level, gdt, 1, 1);
+_DEFINE_FV_SPACE(ALU_2D_SIMPLEX_CONFORMING, level, gdt, 1, 1);
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+#undef _DEFINE_FV_SPACE
+
+
+// this is used by other headers
+#define FV_SPACE(_G, _layer, _backend, _r, _rC) Fv_##_G##_##_layer##_to_##_r##x##_rC##_##_backend##_Space
+
+
+#define DUNE_GDT_SPACES_FV_BIND_GDT(_prefix, _GRID) \
+ _prefix class SpaceInterface<FV_SPACE(_GRID, leaf, gdt, 1, 1)>; \
+ _prefix class SpaceInterface<FV_SPACE(_GRID, level, gdt, 1, 1)>
+
+
+// these lines have to match the corresponding ones in the .cc source file
+DUNE_GDT_SPACES_FV_BIND_GDT(extern template, YASP_2D_EQUIDISTANT_OFFSET);
+
+#if HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+DUNE_GDT_SPACES_FV_BIND_GDT(extern template, ALU_2D_SIMPLEX_CONFORMING);
+#endif // HAVE_ALUGRID || HAVE_DUNE_ALUGRID
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_SPACES_FV_BINDINGS_HH
diff --git a/dune/gdt/spaces/interface.bindings.hh b/dune/gdt/spaces/interface.bindings.hh
new file mode 100644
index 000000000..437d873f8
--- /dev/null
+++ b/dune/gdt/spaces/interface.bindings.hh
@@ -0,0 +1,54 @@
+#ifndef DUNE_GDT_SPACES_INTERFACE_BINDINGS_HH
+#define DUNE_GDT_SPACES_INTERFACE_BINDINGS_HH
+#if HAVE_DUNE_PYBINDXI
+
+#include <dune/pybindxi/pybind11.h>
+
+#include "interface.hh"
+
+namespace Dune {
+namespace GDT {
+namespace bindings {
+
+
+template <class S>
+class SpaceInterface
+{
+ static_assert(is_space<S>::value, "");
+
+public:
+ typedef S type;
+ typedef pybind11::class_<type> bound_type;
+
+ static bound_type bind(pybind11::module& m, const std::string& id)
+ {
+ namespace py = pybind11;
+ using namespace pybind11::literals;
+
+ bound_type c(m, id.c_str(), id.c_str(), py::metaclass());
+
+ c.def_property_readonly_static("dimDomain", [](const type& /*self*/) { return S::dimDomain; });
+ c.def_property_readonly_static("dimRange", [](const type& /*self*/) { return S::dimRange; });
+ c.def_property_readonly_static("dimRangeCols", [](const type& /*self*/) { return S::dimRangeCols; });
+ c.def_property_readonly_static("polOrder", [](const type& /*self*/) { return S::polOrder; });
+
+ c.def("size", [](const type& self) { return self.mapper().size(); });
+ c.def("visualize",
+ [](const type& self, const std::string& filename) { self.visualize(filename); },
+ "filename"_a = "");
+ c.def("compute_pattern", [](const type& self) { return self.compute_pattern(); });
+ c.def("compute_volume_pattern", [](const type& self) { return self.compute_volume_pattern(); });
+ c.def("compute_face_pattern", [](const type& self) { return self.compute_face_pattern(); });
+ c.def("compute_face_and_volume_pattern", [](const type& self) { return self.compute_face_and_volume_pattern(); });
+
+ return c;
+ } // ... bind(...)
+}; // class SpaceInterface
+
+
+} // namespace bindings
+} // namespace GDT
+} // namespace Dune
+
+#endif // HAVE_DUNE_PYBINDXI
+#endif // DUNE_GDT_SPACES_INTERFACE_BINDINGS_HH
--
GitLab