From 1a3e6730edfa81903e9b76d750c0cfe71095c253 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Tue, 26 Mar 2019 16:05:56 +0100
Subject: [PATCH 01/38] initial commit of rewritten adaption interface to allow
 to attach bases to the grid-transfer

---
 src/amdis/CMakeLists.txt      | 1 -
 src/amdis/ProblemStat.inc.hpp | 1 +
 test/DOFVectorTest.cpp        | 1 +
 test/DataTransferTest.hpp     | 2 +-
 4 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/amdis/CMakeLists.txt b/src/amdis/CMakeLists.txt
index 35fe7555..4fe38438 100644
--- a/src/amdis/CMakeLists.txt
+++ b/src/amdis/CMakeLists.txt
@@ -18,7 +18,6 @@ install(FILES
     AdaptInfo.hpp
     AdaptInstationary.hpp
     AdaptionInterface.hpp
-    AdaptiveGlobalBasis.hpp
     AdaptStationary.hpp
     AMDiS.hpp
     Assembler.hpp
diff --git a/src/amdis/ProblemStat.inc.hpp b/src/amdis/ProblemStat.inc.hpp
index 0a942639..2aab43ac 100644
--- a/src/amdis/ProblemStat.inc.hpp
+++ b/src/amdis/ProblemStat.inc.hpp
@@ -170,6 +170,7 @@ void ProblemStat<Traits>::initGlobalBasis()
 {
   dirichletBCs_.init(*globalBasis_, *globalBasis_);
   periodicBCs_.init(*globalBasis_, *globalBasis_);
+  GridTransferManager::attach(*globalBasis_);
 }
 
 
diff --git a/test/DOFVectorTest.cpp b/test/DOFVectorTest.cpp
index 19bc9395..eab5908b 100644
--- a/test/DOFVectorTest.cpp
+++ b/test/DOFVectorTest.cpp
@@ -49,6 +49,7 @@ int main(int argc, char** argv)
   auto basis = makeBasis(gridView,
     composite(power<2>(lagrange<2>(), flatInterleaved()), lagrange<1>(), flatLexicographic()));
   using Basis = decltype(basis);
+  GridTransferManager::attach(basis);
 
   {
     DOFVector<Basis> vec1(basis);
diff --git a/test/DataTransferTest.hpp b/test/DataTransferTest.hpp
index e9c7c3d3..ddae1261 100644
--- a/test/DataTransferTest.hpp
+++ b/test/DataTransferTest.hpp
@@ -82,7 +82,7 @@ double calcError(Problem const& prob, Fcts const& funcs)
 {
   auto& globalBasis = *prob->globalBasis();
   auto localView = globalBasis.localView();
-  auto const& sol = prob->solution().coefficients();
+  auto const& sol = prob.solution().coefficients();
   std::vector<double> ref;
   ref.resize(globalBasis.size());
   double error = 0;
-- 
GitLab


From 0aac8188aca28855539ab43bd880f1ace1b0b4bd Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 27 Mar 2019 14:50:53 +0100
Subject: [PATCH 02/38] Wrapper for GlobalBasis with automatic adaption added

---
 src/amdis/AdaptionInterface.hpp   |   2 +-
 src/amdis/AdaptiveGlobalBasis.hpp | 107 ++++++++++++++++++++++++++++++
 src/amdis/CMakeLists.txt          |   1 +
 src/amdis/ProblemStat.hpp         |   7 +-
 src/amdis/ProblemStat.inc.hpp     |   3 +-
 test/DOFVectorTest.cpp            |   2 +-
 test/DataTransferTest.hpp         |   2 +-
 7 files changed, 116 insertions(+), 8 deletions(-)
 create mode 100644 src/amdis/AdaptiveGlobalBasis.hpp

diff --git a/src/amdis/AdaptionInterface.hpp b/src/amdis/AdaptionInterface.hpp
index 66a0baf6..04df4d3b 100644
--- a/src/amdis/AdaptionInterface.hpp
+++ b/src/amdis/AdaptionInterface.hpp
@@ -26,7 +26,7 @@ namespace AMDiS
       {
         template <class Basis>
         auto requires_(Basis const& basis) -> decltype(
-            const_cast<Basis&>(basis).update(basis.gridView())
+            const_cast<Basis&>(basis).update()
           );
       };
 
diff --git a/src/amdis/AdaptiveGlobalBasis.hpp b/src/amdis/AdaptiveGlobalBasis.hpp
new file mode 100644
index 00000000..5e78aca8
--- /dev/null
+++ b/src/amdis/AdaptiveGlobalBasis.hpp
@@ -0,0 +1,107 @@
+#pragma once
+
+#include <memory>
+
+#include <dune/common/shared_ptr.hh>
+
+#include <amdis/GridTransferManager.hpp>
+
+namespace AMDiS
+{
+  /**
+   * \addtogroup Adaption
+   * @{
+   **/
+
+  template <class GB>
+  class AdaptiveGlobalBasis
+  {
+    using GlobalBasis = GB;
+
+  public:
+    AdaptiveGlobalBasis() = default;
+
+    AdaptiveGlobalBasis(std::shared_ptr<GB> basis)
+      : basis_(basis) // use a custom deleter
+    {
+      GridTransferManager::attach(*this);
+    }
+
+    AdaptiveGlobalBasis(GB& basis)
+      : AdaptiveGlobalBasis(Dune::stackobject_to_shared_ptr(basis))
+    {}
+
+    AdaptiveGlobalBasis(AdaptiveGlobalBasis const&) = delete;
+    AdaptiveGlobalBasis(AdaptiveGlobalBasis&&) = delete;
+
+    ~AdaptiveGlobalBasis()
+    {
+      if (basis_)
+        GridTransferManager::detach(*this);
+    }
+
+    AdaptiveGlobalBasis& operator=(std::shared_ptr<GB> basis)
+    {
+      basis_ = basis;
+      GridTransferManager::attach(*this);
+      return *this;
+    }
+
+  public:
+    void update()
+    {
+      assert(basis_);
+      basis_->update(basis_->gridView());
+    }
+
+    typename GB::GridView const& gridView() const
+    {
+      return basis_->gridView();
+    }
+
+  public: // smart-pointer interface
+
+    GlobalBasis& operator*()
+    {
+      return *basis_;
+    }
+
+    GlobalBasis const& operator*() const
+    {
+      return *basis_;
+    }
+
+    GlobalBasis* operator->()
+    {
+      return basis_.get();
+    }
+
+    GlobalBasis const* operator->() const
+    {
+      return basis_.get();
+    }
+
+    operator bool() const
+    {
+      return bool(basis_);
+    }
+
+  public:
+
+    std::shared_ptr<GlobalBasis> get()
+    {
+      return basis_;
+    }
+
+    std::shared_ptr<GlobalBasis const> get() const
+    {
+      return basis_;
+    }
+
+  private:
+    std::shared_ptr<GlobalBasis> basis_;
+  };
+
+  /// @}
+
+} // end namespace AMDiS
diff --git a/src/amdis/CMakeLists.txt b/src/amdis/CMakeLists.txt
index 4fe38438..35fe7555 100644
--- a/src/amdis/CMakeLists.txt
+++ b/src/amdis/CMakeLists.txt
@@ -18,6 +18,7 @@ install(FILES
     AdaptInfo.hpp
     AdaptInstationary.hpp
     AdaptionInterface.hpp
+    AdaptiveGlobalBasis.hpp
     AdaptStationary.hpp
     AMDiS.hpp
     Assembler.hpp
diff --git a/src/amdis/ProblemStat.hpp b/src/amdis/ProblemStat.hpp
index 005cf68e..ecad2421 100644
--- a/src/amdis/ProblemStat.hpp
+++ b/src/amdis/ProblemStat.hpp
@@ -13,6 +13,7 @@
 #include <dune/grid/common/grid.hh>
 
 #include <amdis/AdaptInfo.hpp>
+#include <amdis/AdaptiveGlobalBasis.hpp>
 #include <amdis/CreatorInterface.hpp>
 #include <amdis/CreatorMap.hpp>
 #include <amdis/DirichletBC.hpp>
@@ -326,8 +327,8 @@ namespace AMDiS
     std::shared_ptr<BoundaryManager<Grid> const> boundaryManager() const { return boundaryManager_; }
 
     /// Return the \ref globalBasis_
-    std::shared_ptr<GlobalBasis>       globalBasis()       { return globalBasis_; }
-    std::shared_ptr<GlobalBasis const> globalBasis() const { return globalBasis_; }
+    std::shared_ptr<GlobalBasis>       globalBasis()       { return globalBasis_.get(); }
+    std::shared_ptr<GlobalBasis const> globalBasis() const { return globalBasis_.get(); }
 
     /// Return a reference to the linear solver, \ref linearSolver
     std::shared_ptr<LinearSolverType>       solver()       { return linearSolver_; }
@@ -484,7 +485,7 @@ namespace AMDiS
     std::shared_ptr<BoundaryManager<Grid>> boundaryManager_;
 
     /// FE spaces of this problem.
-    std::shared_ptr<GlobalBasis> globalBasis_;
+    AdaptiveGlobalBasis<GlobalBasis> globalBasis_;
 
     /// A FileWriter object
     std::list<std::shared_ptr<FileWriterInterface>> filewriter_;
diff --git a/src/amdis/ProblemStat.inc.hpp b/src/amdis/ProblemStat.inc.hpp
index 2aab43ac..164b49f2 100644
--- a/src/amdis/ProblemStat.inc.hpp
+++ b/src/amdis/ProblemStat.inc.hpp
@@ -68,7 +68,7 @@ void ProblemStat<Traits>::initialize(
 
     if (adoptProblem &&
         (adoptFlag.isSet(INIT_FE_SPACE) || adoptFlag.isSet(INIT_SYSTEM))) {
-      adoptGlobalBasis(adoptProblem->globalBasis_);
+      adoptGlobalBasis(adoptProblem->globalBasis_.get());
     }
   }
 
@@ -170,7 +170,6 @@ void ProblemStat<Traits>::initGlobalBasis()
 {
   dirichletBCs_.init(*globalBasis_, *globalBasis_);
   periodicBCs_.init(*globalBasis_, *globalBasis_);
-  GridTransferManager::attach(*globalBasis_);
 }
 
 
diff --git a/test/DOFVectorTest.cpp b/test/DOFVectorTest.cpp
index eab5908b..d67ba896 100644
--- a/test/DOFVectorTest.cpp
+++ b/test/DOFVectorTest.cpp
@@ -49,7 +49,6 @@ int main(int argc, char** argv)
   auto basis = makeBasis(gridView,
     composite(power<2>(lagrange<2>(), flatInterleaved()), lagrange<1>(), flatLexicographic()));
   using Basis = decltype(basis);
-  GridTransferManager::attach(basis);
 
   {
     DOFVector<Basis> vec1(basis);
@@ -72,6 +71,7 @@ int main(int argc, char** argv)
 
   // test GridTransferManager registration
   {
+    AdaptiveGlobalBasis adaptiveBasis(basis);
     DOFVector<Basis> vec1(basis);
     test_dofvector(basis, vec1);
     for (auto const& e : elements(gridView))
diff --git a/test/DataTransferTest.hpp b/test/DataTransferTest.hpp
index ddae1261..e9c7c3d3 100644
--- a/test/DataTransferTest.hpp
+++ b/test/DataTransferTest.hpp
@@ -82,7 +82,7 @@ double calcError(Problem const& prob, Fcts const& funcs)
 {
   auto& globalBasis = *prob->globalBasis();
   auto localView = globalBasis.localView();
-  auto const& sol = prob.solution().coefficients();
+  auto const& sol = prob->solution().coefficients();
   std::vector<double> ref;
   ref.resize(globalBasis.size());
   double error = 0;
-- 
GitLab


From 3c2a9d70baa51256bb1d184749ab90f81b3cc4fa Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 27 Mar 2019 17:16:53 +0100
Subject: [PATCH 03/38] register global basis in GridTransfer via DOFVector

---
 src/amdis/AdaptionInterface.hpp   |   2 +-
 src/amdis/AdaptiveGlobalBasis.hpp | 107 ------------------------------
 src/amdis/ProblemStat.hpp         |   7 +-
 src/amdis/ProblemStat.inc.hpp     |   2 +-
 test/DOFVectorTest.cpp            |   1 -
 5 files changed, 5 insertions(+), 114 deletions(-)
 delete mode 100644 src/amdis/AdaptiveGlobalBasis.hpp

diff --git a/src/amdis/AdaptionInterface.hpp b/src/amdis/AdaptionInterface.hpp
index 04df4d3b..66a0baf6 100644
--- a/src/amdis/AdaptionInterface.hpp
+++ b/src/amdis/AdaptionInterface.hpp
@@ -26,7 +26,7 @@ namespace AMDiS
       {
         template <class Basis>
         auto requires_(Basis const& basis) -> decltype(
-            const_cast<Basis&>(basis).update()
+            const_cast<Basis&>(basis).update(basis.gridView())
           );
       };
 
diff --git a/src/amdis/AdaptiveGlobalBasis.hpp b/src/amdis/AdaptiveGlobalBasis.hpp
deleted file mode 100644
index 5e78aca8..00000000
--- a/src/amdis/AdaptiveGlobalBasis.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include <dune/common/shared_ptr.hh>
-
-#include <amdis/GridTransferManager.hpp>
-
-namespace AMDiS
-{
-  /**
-   * \addtogroup Adaption
-   * @{
-   **/
-
-  template <class GB>
-  class AdaptiveGlobalBasis
-  {
-    using GlobalBasis = GB;
-
-  public:
-    AdaptiveGlobalBasis() = default;
-
-    AdaptiveGlobalBasis(std::shared_ptr<GB> basis)
-      : basis_(basis) // use a custom deleter
-    {
-      GridTransferManager::attach(*this);
-    }
-
-    AdaptiveGlobalBasis(GB& basis)
-      : AdaptiveGlobalBasis(Dune::stackobject_to_shared_ptr(basis))
-    {}
-
-    AdaptiveGlobalBasis(AdaptiveGlobalBasis const&) = delete;
-    AdaptiveGlobalBasis(AdaptiveGlobalBasis&&) = delete;
-
-    ~AdaptiveGlobalBasis()
-    {
-      if (basis_)
-        GridTransferManager::detach(*this);
-    }
-
-    AdaptiveGlobalBasis& operator=(std::shared_ptr<GB> basis)
-    {
-      basis_ = basis;
-      GridTransferManager::attach(*this);
-      return *this;
-    }
-
-  public:
-    void update()
-    {
-      assert(basis_);
-      basis_->update(basis_->gridView());
-    }
-
-    typename GB::GridView const& gridView() const
-    {
-      return basis_->gridView();
-    }
-
-  public: // smart-pointer interface
-
-    GlobalBasis& operator*()
-    {
-      return *basis_;
-    }
-
-    GlobalBasis const& operator*() const
-    {
-      return *basis_;
-    }
-
-    GlobalBasis* operator->()
-    {
-      return basis_.get();
-    }
-
-    GlobalBasis const* operator->() const
-    {
-      return basis_.get();
-    }
-
-    operator bool() const
-    {
-      return bool(basis_);
-    }
-
-  public:
-
-    std::shared_ptr<GlobalBasis> get()
-    {
-      return basis_;
-    }
-
-    std::shared_ptr<GlobalBasis const> get() const
-    {
-      return basis_;
-    }
-
-  private:
-    std::shared_ptr<GlobalBasis> basis_;
-  };
-
-  /// @}
-
-} // end namespace AMDiS
diff --git a/src/amdis/ProblemStat.hpp b/src/amdis/ProblemStat.hpp
index ecad2421..005cf68e 100644
--- a/src/amdis/ProblemStat.hpp
+++ b/src/amdis/ProblemStat.hpp
@@ -13,7 +13,6 @@
 #include <dune/grid/common/grid.hh>
 
 #include <amdis/AdaptInfo.hpp>
-#include <amdis/AdaptiveGlobalBasis.hpp>
 #include <amdis/CreatorInterface.hpp>
 #include <amdis/CreatorMap.hpp>
 #include <amdis/DirichletBC.hpp>
@@ -327,8 +326,8 @@ namespace AMDiS
     std::shared_ptr<BoundaryManager<Grid> const> boundaryManager() const { return boundaryManager_; }
 
     /// Return the \ref globalBasis_
-    std::shared_ptr<GlobalBasis>       globalBasis()       { return globalBasis_.get(); }
-    std::shared_ptr<GlobalBasis const> globalBasis() const { return globalBasis_.get(); }
+    std::shared_ptr<GlobalBasis>       globalBasis()       { return globalBasis_; }
+    std::shared_ptr<GlobalBasis const> globalBasis() const { return globalBasis_; }
 
     /// Return a reference to the linear solver, \ref linearSolver
     std::shared_ptr<LinearSolverType>       solver()       { return linearSolver_; }
@@ -485,7 +484,7 @@ namespace AMDiS
     std::shared_ptr<BoundaryManager<Grid>> boundaryManager_;
 
     /// FE spaces of this problem.
-    AdaptiveGlobalBasis<GlobalBasis> globalBasis_;
+    std::shared_ptr<GlobalBasis> globalBasis_;
 
     /// A FileWriter object
     std::list<std::shared_ptr<FileWriterInterface>> filewriter_;
diff --git a/src/amdis/ProblemStat.inc.hpp b/src/amdis/ProblemStat.inc.hpp
index 164b49f2..0a942639 100644
--- a/src/amdis/ProblemStat.inc.hpp
+++ b/src/amdis/ProblemStat.inc.hpp
@@ -68,7 +68,7 @@ void ProblemStat<Traits>::initialize(
 
     if (adoptProblem &&
         (adoptFlag.isSet(INIT_FE_SPACE) || adoptFlag.isSet(INIT_SYSTEM))) {
-      adoptGlobalBasis(adoptProblem->globalBasis_.get());
+      adoptGlobalBasis(adoptProblem->globalBasis_);
     }
   }
 
diff --git a/test/DOFVectorTest.cpp b/test/DOFVectorTest.cpp
index d67ba896..19bc9395 100644
--- a/test/DOFVectorTest.cpp
+++ b/test/DOFVectorTest.cpp
@@ -71,7 +71,6 @@ int main(int argc, char** argv)
 
   // test GridTransferManager registration
   {
-    AdaptiveGlobalBasis adaptiveBasis(basis);
     DOFVector<Basis> vec1(basis);
     test_dofvector(basis, vec1);
     for (auto const& e : elements(gridView))
-- 
GitLab


From b9ad5235faf2fd13b631607d977e860e3e5426e7 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Fri, 5 Apr 2019 17:46:10 +0200
Subject: [PATCH 04/38] Added Matrix and Vector wrapper for hierarchic
 insertion, resize and initialization, added MAtrixIndexSet and restructured
 the DOFVector and DOFMatrix to be build of MAtrixVectorTraits instead of a
 backend

---
 src/amdis/ProblemStat.inc.hpp                 |   4 +-
 src/amdis/common/CMakeLists.txt               |   2 -
 src/amdis/functions/Blocking.hpp              | 193 +++++++++++++++
 src/amdis/functions/MultiIndex.hpp            |  56 +++++
 src/amdis/linearalgebra/CMakeLists.txt        |   5 +
 src/amdis/linearalgebra/Common.hpp            |  39 +++
 src/amdis/linearalgebra/DOFMatrixBase.hpp     |  71 ++++--
 src/amdis/linearalgebra/DOFMatrixBase.inc.hpp |  84 ++++---
 src/amdis/linearalgebra/DOFVectorBase.hpp     |  86 ++++---
 src/amdis/linearalgebra/DOFVectorBase.inc.hpp |  41 ++--
 src/amdis/linearalgebra/MatrixIndexSet.hpp    |  72 ++++++
 .../linearalgebra/MatrixVectorGenerator.hpp   | 129 ++++++++++
 .../linearalgebra/MatrixVectorTraits.hpp      | 136 +++++++++++
 src/amdis/linearalgebra/MatrixWrapper.hpp     |  79 +++++++
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp | 222 ++++++++++++++++++
 .../MultiTypeMatrix.hpp                       |  16 +-
 .../MultiTypeVector.hpp                       |  21 +-
 src/amdis/linearalgebra/VectorWrapper.hpp     |  79 +++++++
 src/amdis/linearalgebra/VectorWrapper.inc.hpp | 188 +++++++++++++++
 src/amdis/linearalgebra/istl/BCRSMatrix.hpp   |  68 ++++++
 src/amdis/linearalgebra/istl/CMakeLists.txt   |   2 +
 src/amdis/linearalgebra/istl/DOFMatrix.hpp    | 107 +--------
 src/amdis/linearalgebra/istl/DOFVector.hpp    |  97 +-------
 .../linearalgebra/istl/MatrixVectorTraits.hpp |  61 +++++
 src/amdis/linearalgebra/mtl/CMakeLists.txt    |   3 +
 src/amdis/linearalgebra/mtl/DOFMatrix.hpp     | 118 +---------
 src/amdis/linearalgebra/mtl/DOFVector.hpp     |  88 +------
 .../linearalgebra/mtl/MatrixVectorTraits.hpp  |  33 +++
 src/amdis/linearalgebra/mtl/MtlMatrix.hpp     | 104 ++++++++
 src/amdis/linearalgebra/mtl/MtlVector.hpp     |  72 ++++++
 src/amdis/typetree/MultiIndex.hpp             |  23 --
 src/amdis/typetree/RangeType.hpp              |   2 +-
 test/BasisTester.hpp                          | 157 +++++++++++++
 test/BlockingTest.cpp                         |  93 ++++++++
 test/CMakeLists.txt                           |  12 +
 test/GeneratorsTest.cpp                       |  54 +++++
 test/MatrixTest.cpp                           | 159 +++++++++++++
 test/MultiTypeMatrixTest.cpp                  |   2 +-
 test/MultiTypeVectorTest.cpp                  |   2 +-
 test/VectorTest.cpp                           | 132 +++++++++++
 40 files changed, 2346 insertions(+), 566 deletions(-)
 create mode 100644 src/amdis/functions/Blocking.hpp
 create mode 100644 src/amdis/functions/MultiIndex.hpp
 create mode 100644 src/amdis/linearalgebra/MatrixIndexSet.hpp
 create mode 100644 src/amdis/linearalgebra/MatrixVectorGenerator.hpp
 create mode 100644 src/amdis/linearalgebra/MatrixVectorTraits.hpp
 create mode 100644 src/amdis/linearalgebra/MatrixWrapper.hpp
 create mode 100644 src/amdis/linearalgebra/MatrixWrapper.inc.hpp
 rename src/amdis/{common => linearalgebra}/MultiTypeMatrix.hpp (91%)
 rename src/amdis/{common => linearalgebra}/MultiTypeVector.hpp (81%)
 create mode 100644 src/amdis/linearalgebra/VectorWrapper.hpp
 create mode 100644 src/amdis/linearalgebra/VectorWrapper.inc.hpp
 create mode 100644 src/amdis/linearalgebra/istl/BCRSMatrix.hpp
 create mode 100644 src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp
 create mode 100644 src/amdis/linearalgebra/mtl/MatrixVectorTraits.hpp
 create mode 100644 src/amdis/linearalgebra/mtl/MtlMatrix.hpp
 create mode 100644 src/amdis/linearalgebra/mtl/MtlVector.hpp
 delete mode 100644 src/amdis/typetree/MultiIndex.hpp
 create mode 100644 test/BasisTester.hpp
 create mode 100644 test/BlockingTest.cpp
 create mode 100644 test/GeneratorsTest.cpp
 create mode 100644 test/MatrixTest.cpp
 create mode 100644 test/VectorTest.cpp

diff --git a/src/amdis/ProblemStat.inc.hpp b/src/amdis/ProblemStat.inc.hpp
index 0a942639..a6db2d44 100644
--- a/src/amdis/ProblemStat.inc.hpp
+++ b/src/amdis/ProblemStat.inc.hpp
@@ -450,8 +450,8 @@ buildAfterAdapt(AdaptInfo& /*adaptInfo*/, Flag /*flag*/, bool asmMatrix, bool as
   }
 
   // 3. finish matrix insertion and apply dirichlet boundary conditions
-  systemMatrix_->finish(asmMatrix);
-  rhs_->finish(asmVector);
+  systemMatrix_->finish();
+  rhs_->finish();
 
   for_each_node(localView.tree(), [&,this](auto const& rowNode, auto row_tp) -> void {
     for_each_node(localView.tree(), [&,this](auto const& colNode, auto col_tp) -> void {
diff --git a/src/amdis/common/CMakeLists.txt b/src/amdis/common/CMakeLists.txt
index d71fa706..695c0954 100644
--- a/src/amdis/common/CMakeLists.txt
+++ b/src/amdis/common/CMakeLists.txt
@@ -20,8 +20,6 @@ install(FILES
     Literals.hpp
     Logical.hpp
     Math.hpp
-    MultiTypeMatrix.hpp
-    MultiTypeVector.hpp
     Range.hpp
     Resize.hpp
     StaticSize.hpp
diff --git a/src/amdis/functions/Blocking.hpp b/src/amdis/functions/Blocking.hpp
new file mode 100644
index 00000000..cfd29206
--- /dev/null
+++ b/src/amdis/functions/Blocking.hpp
@@ -0,0 +1,193 @@
+#pragma once
+
+#include <tuple>
+#include <utility>
+#include <type_traits>
+
+#include <dune/common/indices.hh>
+#include <dune/common/typetraits.hh>
+#include <dune/common/std/type_traits.hh>
+
+#include <dune/functions/functionspacebases/basistags.hh>
+#include <dune/functions/functionspacebases/compositebasis.hh>
+#include <dune/functions/functionspacebases/powerbasis.hh>
+
+#include <amdis/common/ConceptsBase.hpp>
+#include <amdis/common/Index.hpp>
+#include <amdis/common/Logical.hpp>
+
+namespace AMDiS
+{
+  // Lightweight representation of (hierarchic) block structure
+  namespace Blocking
+  {
+    struct Unknown
+    {
+      enum { isFlat = false };
+      enum { isBlocked = false };
+    };
+
+    /// \brief Blocking structure corresponding to IndexMergingStrategies \ref FlatLexicographic and \ref FlatInterleaved
+    struct Flat
+    {
+      enum { isFlat = true };
+      enum { isBlocked = false };
+
+      template <class Index>
+      Flat operator[](const Index&) const { return {}; }
+    };
+
+    /// \brief Blocking structure corresponding to IndexMergingStrategy \ref LeafBlockedInterleaved
+    template <std::size_t N>
+    struct LeafBlocked
+    {
+      enum { isFlat = false };
+      enum { isBlocked = false };
+
+      template <class Index>
+      Flat operator[](const Index&) const { return {}; }
+    };
+
+    /// \brief Blocking structure corresponding to IndexMergingStrategy \ref BlockedLexicographic
+    template <class Tag0, class... Tags>
+    struct Blocked
+    {
+      enum { isFlat = false };
+      enum { isBlocked = true };
+
+      template <std::size_t i>
+      auto operator[](index_t<i>) const { return std::get<i>(t); }
+
+      Tag0 operator[](std::size_t /*i*/) const { return {}; }
+
+      std::tuple<Tag0,Tags...> t;
+    };
+
+  } // end namespace tag
+
+
+  namespace Impl
+  {
+    // Handle non-leaf nodes
+    template <template <class...> class Tag, class PreBasis>
+    struct CompositeBlocking
+    {
+      using type = Blocking::Flat;
+    };
+
+
+    // Type is unknown if 1. level flat, 2. level blocked
+    template <bool /*false*/, class... T>
+    struct FlatTag { using type = Blocking::Unknown; };
+
+    // Type is flat if all sub-Blockings are flat
+    template <class... T>
+    struct FlatTag<true, T...> { using type = Blocking::Flat; };
+
+    /// \brief collapse flat tags to flat, if hierarchy is all flat, otherwise to tag::unknown
+    template <class... T>
+    using FlatTag_t = typename FlatTag<all_of_v<T::isFlat...>>::type;
+
+
+    // Flat index-merging strategy
+    template <class PreBasis, class IndexMergingStrategy>
+    struct BlockingImpl
+    {
+      using type = typename Impl::CompositeBlocking<FlatTag_t,PreBasis>::type;
+    };
+
+    // Block index-merging strategy
+    template <class PB>
+    struct BlockingImpl<PB, Dune::Functions::BasisBuilder::BlockedLexicographic>
+    {
+      using type = typename Impl::CompositeBlocking<Blocking::Blocked, PB>::type;
+    };
+
+
+    template <class PB>
+    struct Children
+        : std::integral_constant<std::size_t, 0> {};
+
+    template <class MI, class IMS, class... SPB>
+    struct Children<Dune::Functions::CompositePreBasis<MI, IMS, SPB...>>
+        : std::integral_constant<std::size_t, sizeof...(SPB)> {};
+
+    template <class MI, class IMS, class SPB, std::size_t C>
+    struct Children<Dune::Functions::PowerPreBasis<MI, IMS, SPB, C>>
+        : std::integral_constant<std::size_t, C> {};
+
+
+    // Leaf-Block index-merging strategy
+    template <class PB>
+    struct BlockingImpl<PB, Dune::Functions::BasisFactory::BlockedInterleaved>
+    {
+      using type = Blocking::LeafBlocked<Children<PB>::value>;
+    };
+
+  } // end namespace Impl
+
+
+  // Handle leaf-nodes in basis-tree
+  template <class PreBasis, class = void>
+  struct BlockingPreBasis
+  {
+    using type = Blocking::Flat;
+  };
+
+  // Handle all nodes with an index-merging trategy
+  template <class PB>
+  struct BlockingPreBasis<PB, void_t<typename PB::IndexMergingStrategy>>
+  {
+    using type = typename Impl::BlockingImpl<PB, typename PB::IndexMergingStrategy>::type;
+  };
+
+  /// \brief Extract block structure of PreBasis
+  template <class PreBasis>
+  using BlockingPreBasis_t = typename BlockingPreBasis<PreBasis>::type;
+
+  namespace Impl
+  {
+    // defaultbasis
+    template <class Basis, class = void>
+    struct PreBasisImpl
+    {
+      using type = typename Basis::PreBasis;
+    };
+
+    // subspacebasis
+    template <class Basis>
+    struct PreBasisImpl<Basis, void_t<typename Basis::RootBasis>>
+    {
+      using type = typename Basis::RootBasis::PreBasis;
+    };
+  }
+
+  /// \brief Extract blocking structure of GlobalBasis
+  template <class GlobalBasis>
+  using Blocking_t = BlockingPreBasis_t<typename Impl::PreBasisImpl<GlobalBasis>::type>;
+
+
+  namespace Impl
+  {
+    template <template <class...> class Builder, class MI, class IMS, class... SPB>
+    struct CompositeBlocking<Builder, Dune::Functions::CompositePreBasis<MI, IMS, SPB...>>
+    {
+      using type = Builder<BlockingPreBasis_t<SPB>...>;
+    };
+
+    template <template <class...> class Builder, class MI, class IMS, class SPB, std::size_t C>
+    struct CompositeBlocking<Builder, Dune::Functions::PowerPreBasis<MI, IMS, SPB, C>>
+    {
+      template <std::size_t I> using SubPreBasis = SPB;
+      template <class Idx>        struct Expand;
+      template <std::size_t... I> struct Expand<std::index_sequence<I...>>
+      {
+        using type = Builder<BlockingPreBasis_t<SubPreBasis<I>>...>;
+      };
+
+      using type = typename Expand<std::make_index_sequence<C>>::type;
+    };
+
+  } // end namespace Impl
+
+} // end namespace AMDiS
diff --git a/src/amdis/functions/MultiIndex.hpp b/src/amdis/functions/MultiIndex.hpp
new file mode 100644
index 00000000..fd25c08e
--- /dev/null
+++ b/src/amdis/functions/MultiIndex.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <dune/common/reservedvector.hh>
+#include <dune/functions/functionspacebases/flatmultiindex.hh>
+
+namespace AMDiS
+{
+  inline std::size_t flatMultiIndex(std::size_t idx)
+  {
+    return idx;
+  }
+
+  inline std::size_t flatMultiIndex(Dune::Functions::FlatMultiIndex<std::size_t> const& idx)
+  {
+    return idx[0];
+  }
+
+  inline std::size_t flatMultiIndex(Dune::ReservedVector<std::size_t,1> const& idx)
+  {
+    return idx[0];
+  }
+
+
+  template <class Index>
+  class MultiIndex
+  {
+  public:
+    constexpr MultiIndex(Index const& index, std::size_t shift = 0)
+      : index_(index)
+      , shift_(shift)
+    {}
+
+    constexpr Index const& multiIndex() const { return index_; }
+
+    constexpr std::size_t index() const
+    {
+      return shift_ < index_.size() ? index_[shift_] : 0;
+    }
+
+    constexpr MultiIndex shift() const
+    {
+      return {index_, shift_+1};
+    }
+
+  private:
+    Index const& index_;
+    std::size_t shift_;
+  };
+
+  template <class Index>
+  constexpr MultiIndex<Index> multiIndex(Index const& index, std::size_t shift = 0)
+  {
+    return {index, shift};
+  }
+
+} // end namespace AMDiS
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/CMakeLists.txt b/src/amdis/linearalgebra/CMakeLists.txt
index 29239f9e..e03f2cef 100644
--- a/src/amdis/linearalgebra/CMakeLists.txt
+++ b/src/amdis/linearalgebra/CMakeLists.txt
@@ -8,6 +8,11 @@ install(FILES
     DOFVectorInterface.hpp
     LinearSolver.hpp
     LinearSolverInterface.hpp
+    MatrixIndexSet.hpp
+    MatrixVectorGenerator.hpp
+    MatrixVectorTraits.hpp
+    MatrixWrapper.hpp
+    MatrixWrapper.inc.hpp
     PreconditionerInterface.hpp
     RunnerInterface.hpp
     SolverInfo.hpp
diff --git a/src/amdis/linearalgebra/Common.hpp b/src/amdis/linearalgebra/Common.hpp
index 197cfe99..b8829dc8 100644
--- a/src/amdis/linearalgebra/Common.hpp
+++ b/src/amdis/linearalgebra/Common.hpp
@@ -2,6 +2,9 @@
 
 #include <cstddef>
 
+#include <amdis/common/ConceptsBase.hpp>
+#include <amdis/common/Index.hpp>
+
 namespace AMDiS
 {
   template <class T>
@@ -11,4 +14,40 @@ namespace AMDiS
     T value;
   };
 
+  template <class B, class = void>
+  struct BlockLevel
+    : int_t<0>
+  {};
+
+  template <class B>
+  struct BlockLevel<B, void_t<decltype(B::blocklevel)>>
+    : int_t<int(B::blocklevel)>
+  {};
+
+  // template <class K>
+  // struct BlockLevel<Dune::FieldVector<K,1>,void>
+  //   : int_t<0>
+  // {};
+
+  // template <class K>
+  // struct BlockLevel<Dune::FieldMatrix<K,1,1>,void>
+  //   : int_t<0>
+  // {};
+
+  template <class B>
+  constexpr int BlockLevel_v = BlockLevel<B>::value;
+
+
+  template <class B, class = void>
+  struct BlockType
+  {
+    using type = typename B::value_type;
+  };
+
+  template <class B>
+  struct BlockType<B, void_t<typename B::block_type>>
+  {
+    using type = typename B::block_type;
+  };
+
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index a197930c..d208397d 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -1,12 +1,15 @@
 #pragma once
 
-#include <cmath>
-
-#include <dune/common/timer.hh>
+#include <dune/functions/functionspacebases/sizeinfo.hh>
 
 #include <amdis/OperatorList.hpp>
 #include <amdis/common/Math.hpp>
-#include <amdis/typetree/MultiIndex.hpp>
+#include <amdis/functions/Blocking.hpp>
+#include <amdis/functions/MultiIndex.hpp>
+#include <amdis/linearalgebra/MatrixIndexSet.hpp>
+#include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
+#include <amdis/linearalgebra/MatrixWrapper.hpp>
+#include <amdis/operations/Assigner.hpp>
 #include <amdis/typetree/TreePath.hpp>
 
 namespace AMDiS
@@ -18,11 +21,15 @@ namespace AMDiS
    *
    * \tparam RB  Basis of the matrix rows
    * \tparam CB  Basis of matrix columns
-   * \tparam Backend  A linear-algebra backend for the matrix storage
+   * \tparam Traits  A linear-algebra backend for the matrix storage
+   * \tparam K   The field-type
    **/
-  template <class RB, class CB, class Backend>
+  template <class RB, class CB, class Traits, class K = double>
   class DOFMatrixBase
   {
+    using RowBlocking = Blocking_t<RB>;
+    using ColBlocking = Blocking_t<CB>;
+
   public:
     /// The type of the finite element space / basis of the row
     using RowBasis = RB;
@@ -37,14 +44,24 @@ namespace AMDiS
 
     /// The index/size - type
     using size_type = typename RowBasis::size_type;
-    using value_type = typename Backend::value_type;
+    using field_type = typename Dune::FieldTraits<K>::field_type;
+    using value_type = K;
 
     /// The type of the data matrix used in the backend
-    using BaseMatrix = typename Backend::BaseMatrix;
+    using BaseMatrix = MatrixGenerator_t<K,Traits,RowBlocking,ColBlocking>;
 
     /// The type of the matrix filled on an element with local contributions
     using ElementMatrix = Dune::DynamicMatrix<value_type>;
 
+    struct MatrixIndexSetTraits : Traits
+    {
+      template <class>
+      using FlatMatrix = AMDiS::MatrixIndexSet;
+    };
+
+    using HierarchicMatrixIndexSet
+      = MatrixGenerator_t<size_type,MatrixIndexSetTraits,RowBlocking,ColBlocking>;
+
   public:
     /// Constructor. Stores the shared_ptr to the bases.
     DOFMatrixBase(std::shared_ptr<RowBasis> rowBasis, std::shared_ptr<ColBasis> colBasis)
@@ -75,33 +92,40 @@ namespace AMDiS
     /// Return the data-matrix
     BaseMatrix const& matrix() const
     {
-      return backend_.matrix();
+      return matrix_;
     }
 
     /// Return the data-matrix
     BaseMatrix& matrix()
     {
-      return backend_.matrix();
+      return matrix_;
     }
 
-    /// Return the size of the \ref rowBasis_
-    size_type rows() const
+    void resize()
     {
-      return rowBasis_->dimension();
+      resize(sizeInfo(*rowBasis_), sizeInfo(*colBasis_));
     }
 
-    /// Return the size of the \ref colBasis_
-    size_type cols() const
+    template <class RowSize, class ColSize>
+    void resize(RowSize const& rowSize, ColSize const& colSize)
     {
-      return colBasis_->dimension();
+      typename RowSize::SizePrefix rowPrefix;
+      rowPrefix.resize(0);
+      typename ColSize::SizePrefix colPrefix;
+      colPrefix.resize(0);
+      matrixWrapper(matrix_).resize(rowSize, rowPrefix, colSize, colPrefix);
+      matrixWrapper(matrixIndexSet_).resize(rowSize, rowPrefix, colSize, colPrefix);
     }
 
     /// Initialize the matrix for insertion, e.g. allocate the non-zero pattern
     /// If \p setToZero is true, the matrix is set to 0
-    void init(bool asmMatrix);
+    void init(bool rebuild = true);
 
     /// Finish the matrix insertion, e.g. cleanup or final insertion
-    void finish(bool asmMatrix);
+    void finish()
+    {
+      matrixWrapper(matrix_).finish();
+    }
 
     /// Insert a block of values into the matrix (add to existing values)
     /// The global matrix indices are determined by the corresponding localviews.
@@ -111,9 +135,9 @@ namespace AMDiS
 
     /// Insert a single value into the matrix (add to existing value)
     template <class RowIndex, class ColIndex>
-    void insert(RowIndex row, ColIndex col, typename Backend::value_type const& value)
+    void insert(RowIndex row, ColIndex col, field_type const& value)
     {
-      backend_.insert(flatMultiIndex(row), flatMultiIndex(col), value);
+      matrixWrapper(matrix_).insert(multiIndex(row), multiIndex(col), value, Assigner::plus_assign{});
     }
 
     /// \brief Associate a local operator with this DOFMatrix
@@ -150,7 +174,7 @@ namespace AMDiS
     /// Number of nonzeros in the matrix
     size_type nnz() const
     {
-      return backend_.nnz();
+      return matrixWrapper(matrix_).nnz();
     }
 
   protected:
@@ -161,13 +185,16 @@ namespace AMDiS
     std::shared_ptr<ColBasis> colBasis_;
 
     /// Data backend
-    Backend backend_;
+    BaseMatrix matrix_;
 
     /// Dense matrix to store coefficients during \ref assemble()
     ElementMatrix elementMatrix_;
 
     /// List of operators associated to row/col node
     MatrixOperators<RowBasis,ColBasis,ElementMatrix> operators_;
+
+    /// The occupation pattern / nonzero structure of the matrix
+    HierarchicMatrixIndexSet matrixIndexSet_;
   };
 
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
index e37a52c2..c4fa1031 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
@@ -7,47 +7,77 @@
 
 namespace AMDiS {
 
-template <class RB, class CB, class B>
-void DOFMatrixBase<RB,CB,B>::
-init(bool asmMatrix)
+template <class RB, class CB, class T, class K>
+void DOFMatrixBase<RB,CB,T,K>::
+init(bool rebuild)
 {
-  backend_.init(*rowBasis_, *colBasis_, asmMatrix);
-
-  auto const rowSize = rowBasis_->localView().maxSize();
-  auto const colSize = colBasis_->localView().maxSize();
-  elementMatrix_.resize(rowSize, colSize);
-}
+  auto rowLocalView = rowBasis_->localView();
+  auto colLocalView = colBasis_->localView();
 
+  resize();
+  elementMatrix_.resize(rowLocalView.maxSize(), colLocalView.maxSize());
+
+  if (rebuild) {
+    auto matIndexSet = matrixWrapper(matrixIndexSet_);
+
+    // provide maximal sparsity pattern for whole matrix
+    for (const auto& e : elements(rowBasis_->gridView()))
+    {
+      rowLocalView.bind(e);
+      colLocalView.bind(e);
+
+      for_each_node(rowLocalView.tree(), [&](auto const& rowNode, auto&&) {
+        for_each_node(colLocalView.tree(), [&](auto const& colNode, auto&&) {
+          if (operators_[rowNode][colNode])
+	        {
+            for_each_leaf_node(rowNode, [&](auto const& rowLeafNode, auto&&) {
+              for_each_leaf_node(colNode, [&](auto const& colLeafNode, auto&&) {
+                std::size_t rowSize = rowLeafNode.finiteElement().size();
+                std::size_t colSize = colLeafNode.finiteElement().size();
+                for (std::size_t i = 0; i < rowSize; ++i)
+                  for (std::size_t j = 0; j < colSize; ++j)
+                    matIndexSet.insert(
+                      multiIndex(rowLocalView.index(rowLeafNode.localIndex(i))),
+                      multiIndex(colLocalView.index(colLeafNode.localIndex(j))),
+                      1, Assigner::assign{});
+              });
+            });
+          }
+        });
+      });
+
+      rowLocalView.unbind();
+      colLocalView.unbind();
+    }
+  }
 
-template <class RB, class CB, class B>
-void DOFMatrixBase<RB,CB,B>::
-finish(bool /*asmMatrix*/)
-{
-  backend_.finish();
+  // assign sub-pattern to matrix blocks
+  matrixWrapper(matrix_).init(matrixIndexSet_, rebuild);
 }
 
 
-template <class RB, class CB, class B>
-void DOFMatrixBase<RB,CB,B>::
+template <class RB, class CB, class T, class K>
+void DOFMatrixBase<RB,CB,T,K>::
 insert(RowLocalView const& rowLocalView, ColLocalView const& colLocalView,
        ElementMatrix const& elementMatrix)
 {
   using std::abs;
+  MatrixWrapper<BaseMatrix> wrapper(matrix_);
   for (size_type i = 0; i < rowLocalView.size(); ++i) {
-    size_type const row = flatMultiIndex(rowLocalView.index(i));
+    auto const row = rowLocalView.index(i);
     for (size_type j = 0; j < colLocalView.size(); ++j) {
       if (abs(elementMatrix[i][j]) > threshold<double>) {
-        size_type const col = flatMultiIndex(colLocalView.index(j));
-        backend_.insert(row, col, elementMatrix[i][j]);
+        auto const col = colLocalView.index(j);
+        wrapper.insert(multiIndex(row), multiIndex(col), elementMatrix[i][j], Assigner::plus_assign{});
       }
     }
   }
 }
 
 
-template <class RB, class CB, class B>
+template <class RB, class CB, class T, class K>
   template <class ContextTag, class Expr, class RowTreePath, class ColTreePath>
-void DOFMatrixBase<RB,CB,B>::
+void DOFMatrixBase<RB,CB,T,K>::
 addOperator(ContextTag contextTag, Expr const& expr,
             RowTreePath row, ColTreePath col)
 {
@@ -68,8 +98,8 @@ addOperator(ContextTag contextTag, Expr const& expr,
 }
 
 
-template <class RB, class CB, class B>
-void DOFMatrixBase<RB,CB,B>::
+template <class RB, class CB, class T, class K>
+void DOFMatrixBase<RB,CB,T,K>::
 assemble(RowLocalView const& rowLocalView, ColLocalView const& colLocalView)
 {
   elementMatrix_ = 0;
@@ -92,8 +122,8 @@ assemble(RowLocalView const& rowLocalView, ColLocalView const& colLocalView)
 }
 
 
-template <class RB, class CB, class B>
-void DOFMatrixBase<RB,CB,B>::
+template <class RB, class CB, class T, class K>
+void DOFMatrixBase<RB,CB,T,K>::
 assemble()
 {
   auto rowLocalView = rowBasis_->localView();
@@ -109,9 +139,9 @@ assemble()
       assemble(rowLocalView, colLocalView);
       colLocalView.unbind();
     }
-    rowLocalView.unbind(element);
+    rowLocalView.unbind();
   }
-  finish(true);
+  finish();
 }
 
 
diff --git a/src/amdis/linearalgebra/DOFVectorBase.hpp b/src/amdis/linearalgebra/DOFVectorBase.hpp
index c505124d..05367633 100644
--- a/src/amdis/linearalgebra/DOFVectorBase.hpp
+++ b/src/amdis/linearalgebra/DOFVectorBase.hpp
@@ -11,8 +11,12 @@
 #include <amdis/OperatorList.hpp>
 #include <amdis/common/Math.hpp>
 #include <amdis/common/TypeTraits.hpp>
+#include <amdis/functions/Blocking.hpp>
+#include <amdis/functions/MultiIndex.hpp>
 #include <amdis/linearalgebra/DOFVectorInterface.hpp>
-#include <amdis/typetree/MultiIndex.hpp>
+#include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
+#include <amdis/linearalgebra/VectorWrapper.hpp>
+#include <amdis/operations/Assigner.hpp>
 #include <amdis/typetree/TreePath.hpp>
 
 namespace AMDiS
@@ -47,13 +51,15 @@ namespace AMDiS
    * to a global basis.
    *
    * \tparam GB  Basis of the vector
-   * \tparam Backend  A linear algebra backend implementing the storage and operations.
+   * \tparam Traits  A linear algebra backend implementing the storage and operations.
+   * \tparam K   The field-type
    **/
-  template <class GB, class Backend>
+  template <class GB, class Traits, class K = double>
   class DOFVectorBase
       : public DOFVectorInterface
   {
     using Self = DOFVectorBase;
+    using Blocking = Blocking_t<GB>;
 
   public:
     /// The type of the functionspace basis associated to this vector
@@ -67,10 +73,11 @@ namespace AMDiS
     using size_type  = typename GB::size_type;
 
     /// The type of the elements of the DOFVector
-    using value_type = typename Backend::value_type;
+    using field_type = typename Dune::FieldTraits<K>::field_type;
+    using value_type = K;
 
     /// The type of the data vector used in the backend
-    using BaseVector = typename Backend::BaseVector;
+    using BaseVector = VectorGenerator_t<K,Traits,Blocking>;
 
     /// The type of the vector filled on an element with local contributions
     using ElementVector = Dune::DynamicVector<value_type>;
@@ -102,7 +109,7 @@ namespace AMDiS
     /// Copy constructor
     DOFVectorBase(Self const& that)
       : basis_(that.basis_)
-      , backend_(that.backend_)
+      , vector_(that.vector_)
       , elementVector_(that.elementVector_)
       , operators_(that.operators_)
       , dataTransfer_(that.dataTransfer_)
@@ -113,7 +120,7 @@ namespace AMDiS
     /// Move constructor
     DOFVectorBase(Self&& that)
       : basis_(std::move(that.basis_))
-      , backend_(std::move(that.backend_))
+      , vector_(std::move(that.vector_))
       , elementVector_(std::move(that.elementVector_))
       , operators_(std::move(that.operators_))
       , dataTransfer_(std::move(that.dataTransfer_))
@@ -132,8 +139,8 @@ namespace AMDiS
     {
       detachFromGridTransfer();
       basis_ = that.basis_;
-      backend_.resize(that.size());
-      backend_ = that.backend_;
+      resize();
+      vector_ = that.vector_;
       dataTransfer_ = that.dataTransfer_;
       attachToGridTransfer();
       return *this;
@@ -147,7 +154,7 @@ namespace AMDiS
       REQUIRES(Dune::IsNumber<Number>::value)>
     Self& operator=(Number value)
     {
-      backend_.set(value);
+      vectorWrapper(vector_).set(value);
       return *this;
     }
 
@@ -160,58 +167,61 @@ namespace AMDiS
     /// Return the data-vector
     BaseVector const& vector() const
     {
-      return backend_.vector();
+      return vector_;
     }
 
     /// Return the data-vector
     BaseVector& vector()
     {
-      return backend_.vector();
+      return vector_;
     }
 
-    /// Return the size of the \ref basis
-    size_type size() const
+    template <class MultiIndex>
+    value_type operator[](MultiIndex const& mi) const
     {
-      return basis_->dimension();
+      error_exit("Not yet implemented!");
+      return value_type(0);
     }
 
-    /// Resize the \ref vector to the size of the \ref basis
-    void resize(Dune::Functions::SizeInfo<GB> const& s)
+    template <class MultiIndex>
+    value_type& operator[](MultiIndex const& mi)
     {
-      backend_.resize(size_type(s));
+      static value_type value;
+      error_exit("Not yet implemented!");
+      return value;
     }
 
-    /// Resize the \ref vector to the size of the \ref basis and set to zero
-    void compress() override
+    void resize()
     {
-      if (size_type(backend_.size()) != size()) {
-        backend_.resize(size());
-        backend_.set(0);
-      }
+      resize(sizeInfo(*basis_));
     }
 
-    /// Access the entry \p idx of the \ref vector with read-access.
-    template <class Index>
-    auto const& operator[](Index idx) const
+    template <class SizeProvider>
+    void resize(SizeProvider const& sizeProvider)
     {
-      size_type i = flatMultiIndex(idx);
-      return backend_[i];
+      typename SizeProvider::SizePrefix prefix;
+      prefix.resize(0);
+      vectorWrapper(vector_).resize(sizeProvider, prefix);
     }
 
-    /// Access the entry \p idx of the \ref vector with write-access.
-    template <class Index>
-    auto& operator[](Index idx)
+    /// Resize the \ref vector to the size of the \ref basis and set to zero
+    void compress() override
     {
-      size_type i = flatMultiIndex(idx);
-      return backend_[i];
+      resize();
+      vectorWrapper(vector_).set(0);
     }
 
     /// Prepare the DOFVector for insertion of values, finish the insertion with
     /// \ref finish().
-    void init(bool asmVector);
-
+    void init(bool rebuild = true);
     /// Finish the insertion of values, see \ref init()
-    void finish(bool asmVector);
+    void finish();
+
+    template <class Index>
+    void insert(Index const& idx, value_type const& value)
+    {
+      vectorWrapper(vector_).insert(multiIndex(idx), value, Assigner::plus_assign{});
+    }
 
     /// Insert a block of values into the matrix (add to existing values)
     void insert(LocalView const& localView, ElementVector const& elementVector);
@@ -290,7 +300,7 @@ namespace AMDiS
     std::shared_ptr<GlobalBasis> basis_;
 
     /// Data backend
-    Backend backend_;
+    BaseVector vector_;
 
     /// Dense vector to store coefficients during \ref assemble()
     ElementVector elementVector_;
diff --git a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
index 96b82af9..edd5e5a9 100644
--- a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
@@ -11,42 +11,41 @@
 
 namespace AMDiS {
 
-template <class GB, class B>
-void DOFVectorBase<GB,B>::
-init(bool asmVector)
+template <class GB, class T, class K>
+void DOFVectorBase<GB,T,K>::
+init(bool rebuild)
 {
-  backend_.resize(size());
-  if (asmVector)
-    backend_.set(0);
+  resize();
+  if (rebuild)
+    vectorWrapper(vector_).set(0);
 
   auto const localSize = basis_->localView().maxSize();
   elementVector_.resize(localSize);
 }
 
 
-template <class GB, class B>
-void DOFVectorBase<GB,B>::
-finish(bool /*asmVector*/)
-{}
+template <class GB, class T, class K>
+void DOFVectorBase<GB,T,K>::
+finish() {}
 
 
-template <class GB, class B>
-void DOFVectorBase<GB,B>::
+template <class GB, class T, class K>
+void DOFVectorBase<GB,T,K>::
 insert(LocalView const& localView, ElementVector const& elementVector)
 {
   using std::abs;
+  VectorWrapper<BaseVector> wrapper(vector_);
   for (size_type i = 0; i < localView.size(); ++i) {
     if (abs(elementVector[i]) > threshold<double>) {
-      size_type const idx = flatMultiIndex(localView.index(i));
-      backend_[idx] += elementVector[i];
+      wrapper.insert(multiIndex(localView.index(i)), elementVector[i], Assigner::plus_assign{});
     }
   }
 }
 
 
-template <class GB, class B>
+template <class GB, class T, class K>
   template <class ContextTag, class Expr, class TreePath>
-void DOFVectorBase<GB,B>::
+void DOFVectorBase<GB,T,K>::
 addOperator(ContextTag contextTag, Expr const& expr, TreePath path)
 {
   static_assert( Concepts::PreTreePath<TreePath>,
@@ -63,8 +62,8 @@ addOperator(ContextTag contextTag, Expr const& expr, TreePath path)
 }
 
 
-template <class GB, class B>
-void DOFVectorBase<GB,B>::
+template <class GB, class T, class K>
+void DOFVectorBase<GB,T,K>::
 assemble(LocalView const& localView)
 {
   elementVector_ = 0;
@@ -85,8 +84,8 @@ assemble(LocalView const& localView)
 }
 
 
-template <class GB, class B>
-void DOFVectorBase<GB,B>::
+template <class GB, class T, class K>
+void DOFVectorBase<GB,T,K>::
 assemble()
 {
   auto localView = basis_->localView();
@@ -97,7 +96,7 @@ assemble()
     assemble(localView);
     localView.unbind();
   }
-  finish(true);
+  finish();
 }
 
 
diff --git a/src/amdis/linearalgebra/MatrixIndexSet.hpp b/src/amdis/linearalgebra/MatrixIndexSet.hpp
new file mode 100644
index 00000000..37e55d18
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixIndexSet.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <dune/istl/matrixindexset.hh>
+
+namespace AMDiS
+{
+  class MatrixIndexSet
+      : public Dune::MatrixIndexSet
+  {
+    using Self = MatrixIndexSet;
+    using Super = Dune::MatrixIndexSet;
+
+    struct AdderProxy
+    {
+      void operator =(int) { matrixIndexSet_->add(row_, col_); }
+      void operator+=(int) { matrixIndexSet_->add(row_, col_); }
+
+      Super* matrixIndexSet_;
+      std::size_t row_;
+      std::size_t col_;
+    };
+
+    struct RowProxy
+    {
+      AdderProxy& operator[](std::size_t col)
+      {
+        self_->proxy_.row_ = row_;
+        self_->proxy_.col_ = col;
+        return self_->proxy_;
+      }
+
+      std::size_t operator[](std::size_t /*col*/) const
+      {
+        return 0;
+      }
+
+      Self const* self_;
+      std::size_t row_;
+    };
+
+  public:
+    using value_type = std::size_t;
+    MatrixIndexSet()
+      : proxy_{this,0u,0u}
+    {}
+
+    MatrixIndexSet(std::size_t r, std::size_t c)
+      : Super(r,c)
+      , proxy_{this,0u,0u}
+    {}
+
+    RowProxy operator[](std::size_t row)
+    {
+      return {this, row};
+    }
+
+    RowProxy operator[](std::size_t row) const
+    {
+      return {this, row};
+    }
+
+    mutable AdderProxy proxy_;
+  };
+
+  template <class Traits>
+  struct MatrixIndexSetTraits : Traits
+  {
+    template <class>
+    using FlatMatrix = AMDiS::MatrixIndexSet;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/MatrixVectorGenerator.hpp b/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
new file mode 100644
index 00000000..161191a6
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
@@ -0,0 +1,129 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <type_traits>
+
+#include <amdis/common/Concepts.hpp>
+#include <amdis/functions/Blocking.hpp>
+
+namespace AMDiS
+{
+  namespace Impl
+  {
+    template <class Value, class Traits, class BlockingTag, class = void>
+    struct VectorGenerator;
+
+    template <class Value, class Traits, class RowBlocking, class ColBlocking, class = void>
+    struct MatrixGenerator;
+
+  } // end namespace Impl
+
+  /// \brief Generate a vector container compatible with the blocking structure
+  template <class Value, class Traits, class BlockingTag>
+  using VectorGenerator_t = typename Impl::VectorGenerator<Value, Traits, BlockingTag>::type;
+
+  /// \brief Generate a matrix container compatible with the blocking structure
+  template <class Value, class Traits, class RowBlocking, class ColBlocking = RowBlocking>
+  using MatrixGenerator_t = typename Impl::MatrixGenerator<Value, Traits, RowBlocking, ColBlocking>::type;
+
+
+  namespace Impl
+  {
+    // implementation details of the vector container
+    template <class Value, class Traits, class... T>
+    struct VectorGenerator<Value, Traits, Blocking::Blocked<T...>, std::enable_if_t<not Concepts::Same<T...>> >
+    {
+      using type = typename Traits::template CompositeVector<VectorGenerator_t<Value, Traits, T>...>;
+    };
+
+    template <class Value, class Traits, class T0, class... T>
+    struct VectorGenerator<Value, Traits, Blocking::Blocked<T0,T...>, std::enable_if_t<Concepts::Same<T0,T...>> >
+    {
+      using type = typename Traits::template PowerVector<VectorGenerator_t<Value, Traits, T0>, 1+sizeof...(T)>;
+    };
+
+    template <class Value, class Traits>
+    struct VectorGenerator<Value, Traits, Blocking::Flat>
+    {
+      using type = typename Traits::template FlatVector<Value>;
+    };
+
+    template <class Value, class Traits, std::size_t N>
+    struct VectorGenerator<Value, Traits, Blocking::LeafBlocked<N>>
+    {
+      using type = typename Traits::template LeafBlockVector<Value,N>;
+    };
+
+
+    // implementation details for the matrix-container
+    template <class Value, class Traits, class... S, class... T>
+    struct MatrixGenerator<Value, Traits, Blocking::Blocked<S...>, Blocking::Blocked<T...>,
+      std::enable_if_t<not(Concepts::Same<S...> && Concepts::Same<T...>)> >
+    {
+      template <class Si>
+      using Row = typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, Si, T>...>;
+
+      using type = typename Traits::template CompositeMatrix<Row<S>...>;
+    };
+
+    template <class Value, class Traits, class S0, class... S, class T0, class... T>
+    struct MatrixGenerator<Value, Traits, Blocking::Blocked<S0,S...>, Blocking::Blocked<T0,T...>,
+      std::enable_if_t<Concepts::Same<S0,S...> && Concepts::Same<T0,T...>> >
+    {
+      using type = typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, S0, T0>,
+                                                         1+sizeof...(S), 1+sizeof...(T)>;
+    };
+
+    template <class Value, class Traits>
+    struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::Flat>
+    {
+      using type = typename Traits::template FlatMatrix<Value>;
+    };
+
+    template <class Value, class Traits, std::size_t N, std::size_t M>
+    struct MatrixGenerator<Value, Traits, Blocking::LeafBlocked<N>, Blocking::LeafBlocked<M>>
+    {
+      using type = typename Traits::template LeafBlockMatrix<Value,N,M>;
+    };
+
+    template <class Value, class Traits, std::size_t N>
+    struct MatrixGenerator<Value, Traits, Blocking::LeafBlocked<N>, Blocking::Flat>
+    {
+      using type = typename Traits::template LeafBlockMatrix<Value,N,1>;
+    };
+
+    template <class Value, class Traits, std::size_t M>
+    struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::LeafBlocked<M>>
+    {
+      using type = typename Traits::template LeafBlockMatrix<Value,1,M>;
+    };
+
+    template <class Value, class Traits, class... T>
+    struct MatrixGenerator<Value, Traits, Blocking::Blocked<T...>, Blocking::Flat, std::enable_if_t<not Concepts::Same<T...>> >
+    {
+      using type = typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, T, Blocking::Flat>>...>;
+    };
+
+    template <class Value, class Traits, class T0, class... T>
+    struct MatrixGenerator<Value, Traits, Blocking::Blocked<T0,T...>, Blocking::Flat, std::enable_if_t<Concepts::Same<T0,T...>> >
+    {
+      using type = typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, T0, Blocking::Flat>,
+                                                         1+sizeof...(T),1>;
+    };
+
+    template <class Value, class Traits, class... T>
+    struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::Blocked<T...>, std::enable_if_t<not Concepts::Same<T...>> >
+    {
+      using type = typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, Blocking::Flat, T>...>>;
+    };
+
+    template <class Value, class Traits, class T0, class... T>
+    struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::Blocked<T0,T...>, std::enable_if_t<Concepts::Same<T0,T...>> >
+    {
+      using type = typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, Blocking::Flat, T0>,
+                                                         1,1+sizeof...(T)>;
+    };
+
+  } // end namespace Impl
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/MatrixVectorTraits.hpp b/src/amdis/linearalgebra/MatrixVectorTraits.hpp
new file mode 100644
index 00000000..ecfba32e
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixVectorTraits.hpp
@@ -0,0 +1,136 @@
+#pragma once
+
+#include <array>
+#include <vector>
+
+#include <dune/common/dynmatrix.hh>
+#include <dune/common/dynvector.hh>
+#include <dune/common/fmatrix.hh>
+#include <dune/common/fvector.hh>
+#include <dune/common/tuplevector.hh>
+#include <dune/common/bitsetvector.hh>
+
+#include <amdis/linearalgebra/MultiTypeMatrix.hpp>
+#include <amdis/linearalgebra/MultiTypeVector.hpp>
+
+namespace AMDiS
+{
+  namespace Impl
+  {
+    template <template <class> class FlatVectorType>
+    struct DefaultLeafBlockVector
+    {
+      template <class T, std::size_t N>
+      using type = FlatVectorType<Dune::FieldVector<T,N>>;
+    };
+
+    template <template <class> class FlatMatrixType>
+    struct DefaultLeafBlockMatrix
+    {
+      template <class T, std::size_t R, std::size_t C>
+      using type = FlatMatrixType<Dune::FieldMatrix<T,R,C>>;
+    };
+
+  } // end namespace Impl
+
+  // template <
+  //   template <class>                            class FlatVectorType,
+  //   template <class>                            class FlatMatrixType,
+  //   template <class, std::size_t>               class PowerVectorType = PowerBlockVector,
+  //   template <class...>                         class CompositeVectorType = CompositeBlockVector,
+  //   template <class, std::size_t, std::size_t>  class PowerMatrixType = PowerBlockMatrix,
+  //   template <class...>                         class CompositeMatrixType = CompositeBlockMatrix,
+  //   template <class, std::size_t>               class LeafBlockVectorType
+  //     = Impl::DefaultLeafBlockVector<FlatVectorType>::template type,
+  //   template <class, std::size_t, std::size_t>  class LeafBlockMatrixType
+  //     = Impl::DefaultLeafBlockMatrix<FlatMatrixType>::template type
+  //   >
+  // struct DefaultMatrixVectorTraits
+  // {
+  //   template <class B, std::size_t N>
+  //   using PowerVector = PowerVectorType<B,N>;
+
+  //   template <class... Rows>
+  //   using CompositeVector = CompositeVectorType<Rows...>;
+
+  //   template <class T>
+  //   using FlatVector = FlatVectorType<T>;
+
+  //   template <class T, std::size_t N>
+  //   using LeafBlockVector = LeafBlockVectorType<T,N>;
+
+  //   template <class B, std::size_t R, std::size_t C>
+  //   using PowerMatrix = PowerMatrixType<B,R,C>;
+
+  //   template <class... Rows>
+  //   using CompositeMatrix = CompositeMatrixType<Rows...>;
+
+  //   template <class T>
+  //   using FlatMatrix = FlatMatrixType<T>;
+
+  //   template <class T, std::size_t R, std::size_t C>
+  //   using LeafBlockMatrix = LeafBlockMatrixType<T,R,C>;
+  // };
+
+
+  // specified power-matrix/vector and composite-matrix/vector
+  struct DefaultMatrixVectorTraits
+  {
+    template <class B, std::size_t N>
+    using PowerVector = Dune::DynamicVector<B>; //Dune::FieldVector<B,N>;
+
+    template <class... Rows>
+    using CompositeVector = MultiTypeVector<Rows...>;
+
+    template <class T>
+    using FlatVector = Dune::DynamicVector<T>;
+
+    template <class T, std::size_t N>
+    using LeafBlockVector = typename Impl::DefaultLeafBlockVector<FlatVector>::template type<T,N>;
+
+    template <class B, std::size_t R, std::size_t C>
+    using PowerMatrix = Dune::DynamicMatrix<B>; //Dune::FieldMatrix<B,R,C>;
+
+    template <class... Rows>
+    using CompositeMatrix = MultiTypeMatrix<Rows...>;
+
+    template <class T>
+    using FlatMatrix = Dune::DynamicMatrix<T>;
+
+    template <class T, std::size_t R, std::size_t C>
+    using LeafBlockMatrix = typename Impl::DefaultLeafBlockMatrix<FlatMatrix>::template type<T,R,C>;
+  };
+
+  namespace Impl
+  {
+    template <class T, std::size_t N>
+    struct StdLeafBlockVector
+    {
+      using type = std::vector<std::array<T,N>>;
+    };
+
+    template <std::size_t N>
+    struct StdLeafBlockVector<bool,N>
+    {
+      using type = Dune::BitSetVector<N>;
+    };
+
+  } // end namespace Impl
+
+  struct StdTraits
+      : DefaultMatrixVectorTraits
+  {
+    template <class B, std::size_t N>
+    using PowerVector = std::array<B,N>;
+
+    template <class... Rows>
+    using CompositeVector = Dune::TupleVector<Rows...>;
+
+    template <class T>
+    using FlatVector = std::vector<T>;
+
+    template <class T, std::size_t N>
+    using LeafBlockVector = typename Impl::StdLeafBlockVector<T,N>::type;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
new file mode 100644
index 00000000..d2609204
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -0,0 +1,79 @@
+#pragma once
+
+#include <cassert>
+
+#include <dune/common/std/type_traits.hh>
+
+#include <amdis/common/ConceptsBase.hpp>
+#include <amdis/common/Index.hpp>
+#include <amdis/linearalgebra/Common.hpp>
+
+namespace AMDiS
+{
+  template <class BaseMatrix>
+  class MatrixWrapper;
+
+  template <class BaseMatrix>
+  MatrixWrapper<BaseMatrix> matrixWrapper(BaseMatrix& matrix)
+  {
+    return {matrix};
+  }
+
+
+  template <class Scalar>
+  class MatrixWrapperScalarImplementation;
+
+  template <class BaseMatrix>
+  class MatrixWrapperDynamicImplementation;
+
+  template <class BaseMatrix>
+  class MatrixWrapperStaticImplementation;
+
+  namespace Impl
+  {
+    template <class M>
+    using HasDynamicMatrixAccess = decltype(std::declval<M>()[0u][0u]);
+
+    template <class M>
+    using HasStaticMatrixAccess = decltype(std::declval<M>()[index_t<0>{}][index_t<0>{}]);
+
+    template <class M, class = void>
+    struct MatrixWrapperSelector
+    {
+      using type = MatrixWrapperScalarImplementation<M>;
+    };
+
+    template <class M>
+    struct MatrixWrapperSelector<M,
+      std::enable_if_t<Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value>>
+      // void_t<decltype(std::declval<M>()[0u][0u], std::declval<M>().resize(1u,1u), 0), typename M::size_type>>
+    {
+      using type = MatrixWrapperDynamicImplementation<M>;
+    };
+
+    template <class M>
+    struct MatrixWrapperSelector<M,
+      std::enable_if_t<not Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value && Dune::Std::is_detected<HasStaticMatrixAccess, M>::value>>
+      // void_t<decltype(std::declval<M>()[index_t<0>{}][index_t<0>{}], index_t<std::size_t(M::N())>{}, index_t<std::size_t(M::M())>{}, 0), typename M::size_type>>
+    {
+      using type = MatrixWrapperStaticImplementation<M>;
+    };
+
+  } // end namespace Impl
+
+
+  template <class BaseMatrix>
+  class MatrixWrapper
+      : public Impl::MatrixWrapperSelector<BaseMatrix>::type
+  {
+    using Super = typename Impl::MatrixWrapperSelector<BaseMatrix>::type;
+
+  public:
+    MatrixWrapper(BaseMatrix& matrix)
+      : Super(matrix)
+    {}
+  };
+
+} // end namespace AMDiS
+
+#include <amdis/linearalgebra/MatrixWrapper.inc.hpp>
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
new file mode 100644
index 00000000..c5bb491e
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -0,0 +1,222 @@
+#pragma once
+
+#include <cassert>
+
+#include <amdis/Output.hpp>
+#include <amdis/common/ForEach.hpp>
+#include <amdis/linearalgebra/Common.hpp>
+
+namespace AMDiS
+{
+  template <class Scalar>
+  class MatrixWrapperScalarImplementation
+  {
+  public:
+    MatrixWrapperScalarImplementation(Scalar& scalar)
+      : scalar_(scalar)
+    {}
+
+    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    template <class RowSize, class ColSize>
+    void resize(RowSize const& /*rowSize*/, typename RowSize::SizePrefix /*rowPrefix*/,
+                ColSize const& /*colSize*/, typename ColSize::SizePrefix /*colPrefix*/) {}
+
+    /// Prepare the matrix for insertion of values
+    template <class MatIndexSet>
+    void init(MatIndexSet const& /*matrixIndexSet*/, bool /*rebuild*/ = true) {}
+
+    /// Finish the insertion
+    void finish() {}
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert(Row const& /*row*/, Col const& /*col*/, ValueType const& value, Assigner assign)
+    {
+      assign(value, scalar_);
+    }
+
+    /// Return the number of nonzeros in the matrix
+    std::size_t nnz() const
+    {
+      return 1;
+    }
+
+  private:
+    Scalar& scalar_;
+  };
+
+
+  template <class BaseMatrix>
+  class MatrixWrapperDynamicImplementation
+  {
+    using size_type = typename BaseMatrix::size_type;
+    using block_type = typename BlockType<BaseMatrix>::type;
+
+    template <class M>
+    using HasResize = decltype(std::declval<M>().resize(0u, 0u),0);
+
+  public:
+    MatrixWrapperDynamicImplementation(BaseMatrix& matrix)
+      : matrix_(matrix)
+    {}
+
+    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    template <class RowSize, class ColSize>
+    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    {
+      size_type rows = rowSize.size(rowPrefix);
+      size_type cols = colSize.size(colPrefix);
+      msg("rows = {}, cols= {}", rows,cols);
+      assert(rows > 0 && cols > 0);
+
+      // resize this matrix
+      Dune::Hybrid::ifElse(Dune::Std::is_detected<HasResize,BaseMatrix>{}, [&](auto id) -> void {
+        id(matrix_).resize(rows, cols);
+      });
+
+      // NOTE: matrix-resize does not yet work, if blocking-depth is different for different blocks.
+
+      // resize all the blocks
+      if (BlockLevel<block_type>::value > 0) {
+        rowPrefix.push_back(0);
+        colPrefix.push_back(0);
+        for (size_type i = 0; i < rows; ++i) {
+          rowPrefix.back() = i;
+          for (size_type j = 0; j < cols; ++j) {
+            colPrefix.back() = j;
+            matrixWrapper(matrix_[i][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
+          }
+        }
+      }
+    }
+
+    /// Prepare the matrix for insertion of values
+    template <class MatIndexSet>
+    void init(MatIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      for (size_type i = 0; i < matrix_.N(); ++i)
+        for (size_type j = 0; j < matrix_.M(); ++j)
+          matrixWrapper(matrix_[i][j]).init(matrixIndexSet[i][j], rebuild);
+    }
+
+    /// Finish the insertion
+    void finish()
+    {
+      for (size_type i = 0; i < matrix_.N(); ++i)
+        for (size_type j = 0; j < matrix_.M(); ++j)
+          matrixWrapper(matrix_[i][j]).finish();
+    }
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    {
+      matrixWrapper(matrix_[row.index()][col.index()]).insert(row.shift(), col.shift(), value, assign);
+    }
+
+
+    /// Return the number of nonzeros in the matrix
+    std::size_t nnz() const
+    {
+      std::size_t num_nonzeros = 0;
+      for (size_type i = 0; i < matrix_.N(); ++i)
+        for (size_type j = 0; j < matrix_.M(); ++j)
+          num_nonzeros += matrixWrapper(matrix_[i][j]).nnz();
+      return num_nonzeros;
+    }
+
+  private:
+    BaseMatrix& matrix_;
+  };
+
+
+  template <class BaseMatrix>
+  class MatrixWrapperStaticImplementation
+  {
+    using size_type = typename BaseMatrix::size_type;
+
+    static constexpr size_type rows = BaseMatrix::N();
+    static constexpr size_type cols = BaseMatrix::M();
+
+  public:
+    MatrixWrapperStaticImplementation(BaseMatrix& matrix)
+      : matrix_(matrix)
+    {}
+
+    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    template <class RowSize, class ColSize>
+    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    {
+      DUNE_UNUSED size_type r = rowSize.size(rowPrefix);
+      DUNE_UNUSED size_type c = colSize.size(colPrefix);
+      msg("r = {}, c = {}", r,c);
+
+      // this matrix has fixed size, so check whether it is correct
+      assert(r == rows && c == cols);
+
+      // resize all the blocks
+      rowPrefix.push_back(0);
+      colPrefix.push_back(0);
+      Tools::for_range<0,rows>([&](auto const i) -> void {
+        rowPrefix.back() = i;
+        Tools::for_range<0,cols>([&](auto const j) -> void {
+          colPrefix.back() = j;
+          matrixWrapper(matrix_[i][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
+        });
+      });
+    }
+
+    /// Prepare the matrix for insertion of values
+    template <class MatrixIndexSet>
+    void init(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      Tools::for_range<0,rows>([&](auto const i) -> void {
+        Tools::for_range<0,cols>([&](auto const j) -> void {
+          matrixWrapper(matrix_[i][j]).init(matrixIndexSet[i][j], rebuild);
+        });
+      });
+    }
+
+    /// Finish the insertion
+    void finish()
+    {
+      Tools::for_range<0,rows>([&](auto const i) -> void {
+        Tools::for_range<0,cols>([&](auto const j) -> void {
+          matrixWrapper(matrix_[i][j]).finish();
+        });
+      });
+    }
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    {
+      Tools::for_range<0,rows>([&](auto const i) -> void {
+        if (std::size_t(i) == row.index())
+          Tools::for_range<0,cols>([&](auto const j) -> void {
+            if (std::size_t(j) == col.index())
+              matrixWrapper(matrix_[i][j]).insert(row.shift(), col.shift(), value, assign);
+          });
+      });
+    }
+
+
+    /// Return the number of nonzeros in the matrix
+    std::size_t nnz() const
+    {
+      std::size_t num_nonzeros = 0;
+      Tools::for_range<0,rows>([&](auto const i) -> void {
+        Tools::for_range<0,cols>([&](auto const j) -> void {
+          num_nonzeros += matrixWrapper(matrix_[i][j]).nnz();
+        });
+      });
+      return num_nonzeros;
+    }
+
+  private:
+    BaseMatrix& matrix_;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/common/MultiTypeMatrix.hpp b/src/amdis/linearalgebra/MultiTypeMatrix.hpp
similarity index 91%
rename from src/amdis/common/MultiTypeMatrix.hpp
rename to src/amdis/linearalgebra/MultiTypeMatrix.hpp
index e8a46ec8..a7ed52da 100644
--- a/src/amdis/common/MultiTypeMatrix.hpp
+++ b/src/amdis/linearalgebra/MultiTypeMatrix.hpp
@@ -9,11 +9,10 @@
 #include <amdis/common/ForEach.hpp>
 #include <amdis/common/Index.hpp>
 #include <amdis/common/Math.hpp>
-#include <amdis/common/MultiTypeVector.hpp>
 #include <amdis/common/Range.hpp>
 #include <amdis/common/StaticSize.hpp>
 #include <amdis/common/TypeTraits.hpp>
-#include <amdis/typetree/MultiIndex.hpp>
+#include <amdis/linearalgebra/MultiTypeVector.hpp>
 
 namespace AMDiS
 {
@@ -51,8 +50,8 @@ namespace AMDiS
     using real_type = typename Dune::FieldTraits<Self>::real_type;
     using size_type = std::size_t;
 
-    static constexpr int rows = std::tuple_size<Super>::value;
-    static constexpr int cols = Math::max(Rows::dimension...);
+    static constexpr size_type rows = std::tuple_size<Super>::value;
+    static constexpr size_type cols = Math::max(Rows::dimension...);
 
     template <class... Rows_,
       REQUIRES( Concepts::Similar<Types<Rows...>, Types<Rows_...>> )>
@@ -134,21 +133,16 @@ namespace AMDiS
     }
 
     /// Return number of elements of the tuple
-    static constexpr std::size_t num_rows()
+    static constexpr size_type N()
     {
       return rows;
     }
 
     /// Return number of elements of the tuple
-    static constexpr std::size_t num_cols()
+    static constexpr size_type M()
     {
       return cols;
     }
-
-    static constexpr std::size_t size()
-    {
-      return rows;
-    }
   };
 
   namespace Impl
diff --git a/src/amdis/common/MultiTypeVector.hpp b/src/amdis/linearalgebra/MultiTypeVector.hpp
similarity index 81%
rename from src/amdis/common/MultiTypeVector.hpp
rename to src/amdis/linearalgebra/MultiTypeVector.hpp
index 7bec7543..8a25f5d5 100644
--- a/src/amdis/common/MultiTypeVector.hpp
+++ b/src/amdis/linearalgebra/MultiTypeVector.hpp
@@ -4,7 +4,6 @@
 #include <type_traits>
 
 #include <dune/common/ftraits.hh>
-#include <dune/functions/common/indexaccess.hh>
 
 #include <amdis/common/Concepts.hpp>
 #include <amdis/common/ForEach.hpp>
@@ -45,7 +44,7 @@ namespace AMDiS
     using real_type = typename Dune::FieldTraits<Self>::real_type;
     using size_type = std::size_t;
 
-    static constexpr int dimension = std::tuple_size<Super>::value;
+    static constexpr size_type dimension = std::tuple_size<Super>::value;
 
     template <class... FV_,
       REQUIRES( Concepts::Similar<Types<FV...>, Types<FV_...>> )>
@@ -111,24 +110,8 @@ namespace AMDiS
       return std::get<I>(*this);
     }
 
-    /// Const access to the vector using multi-indices
-    template <class Index,
-      REQUIRES( Concepts::MultiIndex<Index> )>
-    decltype(auto) operator[](Index const& index) const
-    {
-      return Dune::Functions::hybridMultiIndexAccess<field_type const&>(*this, index);
-    }
-
-    /// Mutable access to the vector using multi-indices
-    template <class Index,
-      REQUIRES( Concepts::MultiIndex<Index> )>
-    decltype(auto) operator[](Index const& index)
-    {
-      return Dune::Functions::hybridMultiIndexAccess<field_type&>(*this, index);
-    }
-
     /// Return number of elements of the tuple
-    static constexpr std::size_t size()
+    static constexpr size_type size()
     {
       return dimension;
     }
diff --git a/src/amdis/linearalgebra/VectorWrapper.hpp b/src/amdis/linearalgebra/VectorWrapper.hpp
new file mode 100644
index 00000000..4f06ffd7
--- /dev/null
+++ b/src/amdis/linearalgebra/VectorWrapper.hpp
@@ -0,0 +1,79 @@
+#pragma once
+
+#include <iterator>
+
+#include <dune/common/std/type_traits.hh>
+
+#include <amdis/common/ConceptsBase.hpp>
+#include <amdis/common/Index.hpp>
+
+namespace AMDiS
+{
+  template <class BaseVector>
+  class VectorWrapper;
+
+  template <class BaseVector>
+  VectorWrapper<BaseVector> vectorWrapper(BaseVector& vector)
+  {
+    return {vector};
+  }
+
+
+  template <class Scalar>
+  class VectorWrapperScalarImplementation;
+
+  template <class BaseVector>
+  class VectorWrapperDynamicImplementation;
+
+  template <class BaseVector>
+  class VectorWrapperStaticImplementation;
+
+  namespace Impl
+  {
+    template <class V>
+    using HasDynamicAccess = decltype(std::declval<V>()[0u]);
+
+    template <class V>
+    using HasStaticAccess = decltype(std::declval<V>()[index_t<0>{}]);
+
+
+    template <class V, class = void>
+    struct VectorWrapperSelector
+    {
+      using type = VectorWrapperScalarImplementation<V>;
+    };
+
+    template <class V>
+    struct VectorWrapperSelector<V,
+      std::enable_if_t<Dune::Std::is_detected<HasDynamicAccess, V>::value>>
+      //void_t<decltype(std::declval<V>()[0u], std::declval<V>().resize(1u), std::begin(std::declval<V>()), std::end(std::declval<V>()), 0), typename V::size_type>>
+    {
+      using type = VectorWrapperDynamicImplementation<V>;
+    };
+
+    template <class V>
+    struct VectorWrapperSelector<V,
+      std::enable_if_t<not Dune::Std::is_detected<HasDynamicAccess, V>::value && Dune::Std::is_detected<HasStaticAccess, V>::value>>
+      //void_t<decltype(std::declval<V>()[index_t<0>{}], index_t<std::size_t(V::size())>{}, 0), typename V::size_type>>
+    {
+      using type = VectorWrapperStaticImplementation<V>;
+    };
+
+  } // end namespace Impl
+
+
+  template <class BaseVector>
+  class VectorWrapper
+      : public Impl::VectorWrapperSelector<BaseVector>::type
+  {
+    using Super = typename Impl::VectorWrapperSelector<BaseVector>::type;
+
+  public:
+    VectorWrapper(BaseVector& vector)
+      : Super(vector)
+    {}
+  };
+
+} // end namespace AMDiS
+
+#include <amdis/linearalgebra/VectorWrapper.inc.hpp>
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
new file mode 100644
index 00000000..18496baa
--- /dev/null
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -0,0 +1,188 @@
+#pragma once
+
+#include <cassert>
+
+#include <dune/common/hybridutilities.hh>
+
+#include <amdis/common/ForEach.hpp>
+#include <amdis/linearalgebra/Common.hpp>
+
+namespace AMDiS
+{
+  template <class Scalar>
+  class VectorWrapperScalarImplementation
+  {
+  public:
+    VectorWrapperScalarImplementation(Scalar& scalar)
+      : scalar_(scalar)
+    {}
+
+    /// Resize \ref vector_ to desired size
+    template <class SizeProvider>
+    void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    {
+      DUNE_UNUSED int size = sizeProvider.size(prefix);
+      assert(size == 0);
+    }
+
+    /// Prepare the vector for insertion of values
+    void init(bool /*rebuild*/ = true) {}
+
+    /// Finish the insertion
+    void finish() {}
+
+    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
+    template <class Index, class ValueType, class Assigner>
+    void insert(Index const& /*mi*/, ValueType const& value, Assigner assign)
+    {
+      assign(value, scalar_);
+    }
+
+    /// Set all entries to value
+    template <class ValueType>
+    void set(ValueType const& value)
+    {
+      scalar_ = value;
+    }
+
+  private:
+    Scalar& scalar_;
+  };
+
+
+  template <class BaseVector>
+  class VectorWrapperDynamicImplementation
+  {
+    using size_type = typename BaseVector::size_type;
+    using block_type = typename BlockType<BaseVector>::type;
+
+    template <class V>
+    using HasResize = decltype(std::declval<V>().resize(0u),0);
+
+  public:
+    VectorWrapperDynamicImplementation(BaseVector& vector)
+      : vector_(vector)
+    {}
+
+    /// Resize \ref vector_ to desired size
+    template <class SizeProvider>
+    void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    {
+      size_type size = sizeProvider.size(prefix);
+      assert(size > 0);
+
+      // resize this vector
+      Dune::Hybrid::ifElse(Dune::Std::is_detected<HasResize,BaseVector>{}, [&](auto id) -> void {
+        id(vector_).resize(size);
+      });
+
+      // resize all the blocks
+      if (BlockLevel<block_type>::value > 0) {
+        prefix.push_back(0);
+        for (size_type i = 0; i < size; ++i) {
+          prefix.back() = i;
+          vectorWrapper(vector_[i]).resize(sizeProvider, prefix);
+        }
+      }
+    }
+
+    /// Prepare the vector for insertion of values
+    void init(bool rebuild)
+    {
+      for (auto& v : vector_)
+        vectorWrapper(v).init(rebuild);
+    }
+
+    /// Finish the insertion
+    void finish()
+    {
+      for (auto& v : vector_)
+        vectorWrapper(v).finish();
+    }
+
+    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
+    template <class Index, class ValueType, class Assigner>
+    void insert(Index const& mi, ValueType const& value, Assigner assign)
+    {
+      vectorWrapper(vector_[mi.index()]).insert(mi.shift(), value, assign);
+    }
+
+    /// Set all entries to value
+    template <class ValueType>
+    void set(ValueType const& value)
+    {
+      for (auto& v : vector_)
+        vectorWrapper(v).set(value);
+    }
+
+  private:
+    BaseVector& vector_;
+  };
+
+  template <class BaseVector>
+  class VectorWrapperStaticImplementation
+  {
+    using size_type = typename BaseVector::size_type;
+
+    static constexpr size_type dimension = BaseVector::size();
+
+  public:
+    VectorWrapperStaticImplementation(BaseVector& vector)
+      : vector_(vector)
+    {}
+
+    /// Resize \ref vector_ to desired size
+    template <class SizeProvider>
+    void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    {
+      DUNE_UNUSED size_type size = sizeProvider.size(prefix);
+      assert(size == dimension);
+
+      // resize blocks
+      prefix.push_back(0);
+      Tools::for_range<0,dimension>([&](auto const i) -> void {
+        prefix.back() = i;
+        vectorWrapper(vector_[i]).resize(sizeProvider, prefix);
+      });
+    }
+
+    /// Prepare the vector for insertion of values
+    void init(bool rebuild)
+    {
+      Tools::for_each(vector_, [rebuild](auto& v) -> void {
+        vectorWrapper(v).init(rebuild);
+      });
+    }
+
+    /// Finish the insertion
+    void finish()
+    {
+      Tools::for_each(vector_, [](auto& v) -> void {
+        vectorWrapper(v).finish();
+      });
+    }
+
+    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
+    template <class Index, class ValueType, class Assigner>
+    void insert(Index const& mi, ValueType const& value, Assigner assign)
+    {
+      Tools::for_range<0,dimension>([&](auto const i) -> void {
+        if (std::size_t(i) == mi.index())
+          vectorWrapper(vector_[i]).insert(mi.shift(), value, assign);
+      });
+    }
+
+    /// Set all entries to value
+    template <class ValueType>
+    void set(ValueType const& value)
+    {
+      Tools::for_each(vector_, [value](auto& v) -> void {
+        vectorWrapper(v).set(value);
+      });
+    }
+
+  private:
+    BaseVector& vector_;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
new file mode 100644
index 00000000..2c982cc8
--- /dev/null
+++ b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
@@ -0,0 +1,68 @@
+#pragma once
+
+#include <dune/istl/bcrsmatrix.hh>
+
+#include <amdis/Output.hpp>
+#include <amdis/common/StaticSize.hpp>
+#include <amdis/linearalgebra/Common.hpp>
+#include <amdis/linearalgebra/MatrixIndexSet.hpp>
+#include <amdis/linearalgebra/MatrixWrapper.hpp>
+
+namespace AMDiS
+{
+  template <class B, class A>
+  class MatrixWrapper<Dune::BCRSMatrix<B,A>>
+  {
+    using BaseMatrix = Dune::BCRSMatrix<B,A>;
+    using size_type = typename BaseMatrix::size_type;
+
+  public:
+    /// Constructor. Constructs new BaseVector.
+    MatrixWrapper(BaseMatrix& matrix)
+      : matrix_(matrix)
+    {}
+
+    template <class RowSize, class ColSize>
+    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    {
+      // bcrs matrix is not resized directly, but using the init() method
+      // and a matrixIndexSet.
+    }
+
+    /// create occupation pattern and apply it to the matrix
+    template <class MatIndexSet>
+    void init(MatIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      matrixIndexSet.exportIdx(matrix_);
+      initialized_ = true;
+    }
+
+    void finish()
+    {
+      initialized_ = false;
+    }
+
+    /// Insert a single value into the matrix (add to existing value)
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    {
+      size_type r = row.index();
+      size_type c = col.index();
+      test_exit_dbg( initialized_, "Occupation pattern not initialized!");
+      test_exit_dbg( r < matrix_.N() && c < matrix_.M() ,
+          "Indices out of range [0,{})x[0,{})", matrix_.N(), matrix_.M() );
+      matrixWrapper(matrix_[r][c]).insert(row.shift(), col.shift(), value, assign);
+    }
+
+    std::size_t nnz() const
+    {
+      return matrix_.nonzeroes() * Rows_v<B> * Cols_v<B>;
+    }
+
+  private:
+    BaseMatrix& matrix_;
+    bool initialized_ = false;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/istl/CMakeLists.txt b/src/amdis/linearalgebra/istl/CMakeLists.txt
index f11fd2db..c6056fe4 100644
--- a/src/amdis/linearalgebra/istl/CMakeLists.txt
+++ b/src/amdis/linearalgebra/istl/CMakeLists.txt
@@ -1,4 +1,5 @@
 install(FILES
+    BCRSMatrix.hpp
     Constraints.hpp
     DirectRunner.hpp
     DOFMatrix.hpp
@@ -7,4 +8,5 @@ install(FILES
     ISTL_Preconditioner.hpp
     ISTL_Solver.hpp
     ISTLRunner.hpp
+    MatrixVectorTraits.hpp
 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/amdis/linearalgebra/istl)
diff --git a/src/amdis/linearalgebra/istl/DOFMatrix.hpp b/src/amdis/linearalgebra/istl/DOFMatrix.hpp
index eb3ab6cf..fbde3384 100644
--- a/src/amdis/linearalgebra/istl/DOFMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/DOFMatrix.hpp
@@ -1,114 +1,11 @@
 #pragma once
 
-#include <list>
-#include <string>
-#include <memory>
-
-#include <dune/istl/bcrsmatrix.hh>
-#include <dune/istl/matrixindexset.hh>
-
-#include <amdis/Output.hpp>
-#include <amdis/linearalgebra/Common.hpp>
 #include <amdis/linearalgebra/DOFMatrixBase.hpp>
+#include <amdis/linearalgebra/istl/MatrixVectorTraits.hpp>
 
 namespace AMDiS
 {
-  template <class T, class = void>
-  struct BlockMatrixType
-  {
-    using type = Dune::FieldMatrix<T,1,1>;
-  };
-
-  template <class T>
-  struct BlockMatrixType<T, typename T::field_type>
-  {
-    using type = T;
-  };
-
-  template <class ValueType>
-  class IstlMatrix
-  {
-  public:
-    /// The type of the elements of the DOFMatrix
-    using value_type = typename BlockMatrixType<ValueType>::type;
-
-    /// The matrix type of the underlying base matrix
-    using BaseMatrix = Dune::BCRSMatrix<value_type>;
-
-    /// The index/size - type
-    using size_type = typename BaseMatrix::size_type;
-
-  public:
-    /// Constructor. Constructs new BaseVector.
-    IstlMatrix() = default;
-
-    /// Return the data-vector \ref vector
-    BaseMatrix const& matrix() const
-    {
-      return matrix_;
-    }
-
-    /// Return the data-vector \ref vector
-    BaseMatrix& matrix()
-    {
-      return matrix_;
-    }
-
-
-    /// Insert a single value into the matrix (add to existing value)
-    void insert(size_type r, size_type c, value_type const& value)
-    {
-      test_exit_dbg( initialized_, "Occupation pattern not initialized!");
-      test_exit_dbg( r < matrix_.N() && c < matrix_.M() ,
-          "Indices out of range [0,{})x[0,{})", matrix_.N(), matrix_.M() );
-      matrix_[r][c] += value;
-    }
-
-    /// create occupation pattern and apply it to the matrix
-    template <class RowBasis, class ColBasis>
-    void init(RowBasis const& rowBasis, ColBasis const& colBasis,
-              bool prepareForInsertion)
-    {
-      auto occupationPattern = Dune::MatrixIndexSet{rowBasis.dimension(), colBasis.dimension()};
-
-      auto rowLocalView = rowBasis.localView();
-      auto colLocalView = colBasis.localView();
-      for (const auto& element : elements(rowBasis.gridView())) {
-        rowLocalView.bind(element);
-        colLocalView.bind(element);
-
-        for (std::size_t i = 0; i < rowLocalView.size(); ++i) {
-          // The global index of the i-th vertex of the element
-          auto row = rowLocalView.index(i);
-          for (std::size_t j = 0; j < colLocalView.size(); ++j) {
-            // The global index of the j-th vertex of the element
-            auto col = colLocalView.index(j);
-            occupationPattern.add(row, col);
-          }
-        }
-      }
-      occupationPattern.exportIdx(matrix_);
-
-      initialized_ = true;
-    }
-
-    void finish()
-    {
-      initialized_ = false;
-    }
-
-    std::size_t nnz() const
-    {
-      return matrix_.nonzeroes();
-    }
-
-  private:
-    BaseMatrix matrix_;
-
-    bool initialized_ = false;
-  };
-
   template <class RowBasisType, class ColBasisType, class ValueType = double>
-  using DOFMatrix = DOFMatrixBase<RowBasisType, ColBasisType, IstlMatrix<ValueType>>;
+  using DOFMatrix = DOFMatrixBase<RowBasisType, ColBasisType, ISTLTraits>;
 
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/istl/DOFVector.hpp b/src/amdis/linearalgebra/istl/DOFVector.hpp
index 9abde6cd..3c9a48f8 100644
--- a/src/amdis/linearalgebra/istl/DOFVector.hpp
+++ b/src/amdis/linearalgebra/istl/DOFVector.hpp
@@ -1,103 +1,14 @@
 #pragma once
 
-#include <dune/istl/bvector.hh>
-
-#include <amdis/Output.hpp>
 #include <amdis/linearalgebra/DOFVectorBase.hpp>
+#include <amdis/linearalgebra/istl/MatrixVectorTraits.hpp>
 
 namespace AMDiS
 {
-  template <class T, class = void>
-  struct BlockVectorType
-  {
-    using type = Dune::FieldVector<T,1>;
-  };
-
-  template <class T>
-  struct BlockVectorType<T, typename T::field_type>
-  {
-    using type = T;
-  };
-
-	template <class ValueType>
-	class IstlVector
-	{
-	public:
-    /// The type of the elements of the DOFVector
-	  using block_type = typename BlockVectorType<ValueType>::type;
-
-    /// The type of the elements of the DOFVector
-    using value_type = block_type;
-
-    /// The underlying field type
-    using field_type = typename block_type::field_type;
-
-    /// The vector type of the underlying base vector
-	  using BaseVector = Dune::BlockVector<block_type>;
-
-    /// The index/size - type
-	  using size_type  = typename BaseVector::size_type;
-
-  public:
-    /// Constructor. Constructs new BaseVector.
-    IstlVector() = default;
-
-    /// Return the data-vector \ref vector
-    BaseVector const& vector() const
-    {
-      return vector_;
-    }
-
-    /// Return the data-vector \ref vector
-    BaseVector& vector()
-    {
-      return vector_;
-    }
-
-
-    /// Return the current size of the \ref vector_
-    size_type size() const
-    {
-      return vector_.size();
-    }
-
-    /// Resize the \ref vector_ to the size \p s
-    void resize(size_type s)
-    {
-      vector_.resize(s);
-    }
-
-
-    /// Access the entry \p i of the \ref vector with read-access.
-    block_type const& operator[](size_type i) const
-    {
-      test_exit_dbg(i < vector_.size(),
-        "Index {} out of range [0,{})", i, vector_.size());
-      return vector_[i];
-    }
-
-    /// Access the entry \p i of the \ref vector with write-access.
-    block_type& operator[](size_type i)
-    {
-      test_exit_dbg(i < vector_.size(),
-        "Index {} out of range [0,{})", i, vector_.size());
-      return vector_[i];
-    }
-
-    void set(field_type value)
-    {
-      vector_ = value;
-    }
-
-	private:
-    BaseVector vector_;
-	};
-
-
-  template <class GlobalBasis, class ValueType>
-  class DOFVector : public DOFVectorBase<GlobalBasis, IstlVector<ValueType>>
+  template <class BasisType, class ValueType = double>
+  class DOFVector : public DOFVectorBase<BasisType, ISTLTraits>
   {
-    using Super = DOFVectorBase<GlobalBasis, IstlVector<ValueType>>;
+    using Super = DOFVectorBase<BasisType, ISTLTraits, ValueType>;
 
   public:
     DOFVector(std::shared_ptr<GlobalBasis> basis, DataTransferOperation op = DataTransferOperation::INTERPOLATE)
diff --git a/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp b/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp
new file mode 100644
index 00000000..3f0d5586
--- /dev/null
+++ b/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <dune/common/bitsetvector.hh>
+#include <dune/common/fmatrix.hh>
+#include <dune/common/fvector.hh>
+
+#include <dune/istl/matrix.hh>
+#include <dune/istl/bcrsmatrix.hh>
+#include <dune/istl/bvector.hh>
+#include <dune/istl/multitypeblockvector.hh>
+#include <dune/istl/multitypeblockmatrix.hh>
+
+#include <amdis/linearalgebra/MatrixVectorTraits.hpp>
+#include <amdis/linearalgebra/istl/BCRSMatrix.hpp>
+
+namespace AMDiS
+{
+  namespace Impl
+  {
+    template <class T, std::size_t N>
+    struct ISTLLeafBlockVector
+    {
+      using type = Dune::BlockVector<Dune::FieldVector<T,int(N)>>;
+    };
+
+    template <std::size_t N>
+    struct ISTLLeafBlockVector<bool,N>
+    {
+      using type = Dune::BitSetVector<N>;
+    };
+
+  } // end namespace Impl
+
+  struct ISTLTraits
+  {
+    template <class B, std::size_t N>
+    using PowerVector = Dune::BlockVector<B>;
+
+    template <class... Rows>
+    using CompositeVector = Dune::MultiTypeBlockVector<Rows...>;
+
+    template <class T>
+    using FlatVector = Dune::BlockVector<Dune::FieldVector<T,1>>;
+
+    template <class T, std::size_t N>
+    using LeafBlockVector = typename Impl::ISTLLeafBlockVector<T,N>::type;
+
+    template <class B, std::size_t R, std::size_t C>
+    using PowerMatrix = Dune::Matrix<B>;
+
+    template <class... Rows>
+    using CompositeMatrix = Dune::MultiTypeBlockMatrix<Rows...>;
+
+    template <class T>
+    using FlatMatrix = Dune::BCRSMatrix<Dune::FieldMatrix<T,1,1>>;
+
+    template <class T, std::size_t R, std::size_t C>
+    using LeafBlockMatrix = Dune::BCRSMatrix<Dune::FieldMatrix<T,int(R),int(C)>>;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/mtl/CMakeLists.txt b/src/amdis/linearalgebra/mtl/CMakeLists.txt
index 20fb45a1..c02d9f2f 100644
--- a/src/amdis/linearalgebra/mtl/CMakeLists.txt
+++ b/src/amdis/linearalgebra/mtl/CMakeLists.txt
@@ -5,6 +5,9 @@ install(FILES
     ITL_Preconditioner.hpp
     ITL_Solver.hpp
     KrylovRunner.hpp
+    MatrixVectorTraits.hpp
+    MtlMatrix.hpp
+    MtlVector.hpp
     Preconditioner.hpp
     UmfpackRunner.hpp
 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/amdis/linearalgebra/mtl)
diff --git a/src/amdis/linearalgebra/mtl/DOFMatrix.hpp b/src/amdis/linearalgebra/mtl/DOFMatrix.hpp
index 0e62a990..c4f4b2ed 100644
--- a/src/amdis/linearalgebra/mtl/DOFMatrix.hpp
+++ b/src/amdis/linearalgebra/mtl/DOFMatrix.hpp
@@ -1,125 +1,11 @@
 #pragma once
 
-#include <list>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <boost/numeric/mtl/matrix/compressed2D.hpp>
-#include <boost/numeric/mtl/matrix/inserter.hpp>
-#include <boost/numeric/mtl/utility/property_map.hpp>
-#include <boost/numeric/mtl/utility/range_wrapper.hpp>
-
-#include <amdis/Output.hpp>
-#include <amdis/linearalgebra/Common.hpp>
 #include <amdis/linearalgebra/DOFMatrixBase.hpp>
+#include <amdis/linearalgebra/mtl/MatrixVectorTraits.hpp>
 
 namespace AMDiS
 {
-  /// \brief The basic container that stores a base matrix
-  template <class ValueType>
-  class MtlMatrix
-  {
-  public:
-    /// The matrix type of the underlying base matrix
-    using BaseMatrix = mtl::compressed2D<ValueType>;
-
-    /// The type of the elements of the DOFMatrix
-    using value_type = ValueType;
-
-    /// The index/size - type
-    using size_type = typename BaseMatrix::size_type;
-
-    /// The type of the inserter used when filling the matrix. NOTE: need not be public
-    using Inserter = mtl::mat::inserter<BaseMatrix, mtl::operations::update_plus<value_type>>;
-
-  public:
-    /// Constructor. Constructs new BaseMatrix.
-    MtlMatrix() = default;
-
-    /// Return a reference to the data-matrix \ref matrix
-    BaseMatrix& matrix()
-    {
-      assert( !inserter_ );
-      return matrix_;
-    }
-
-    /// Return a reference to the data-matrix \ref matrix
-    BaseMatrix const& matrix() const
-    {
-      assert( !inserter_ );
-      return matrix_;
-    }
-
-
-    /// \brief Returns an update-proxy of the inserter, to inserte/update a value at
-    /// position (\p r, \p c) in the matrix. Need an insertionMode inserter, that can
-    /// be created by \ref init and must be closed by \ref finish after insertion.
-    void insert(size_type r, size_type c, value_type const& value)
-    {
-      test_exit_dbg(inserter_, "Inserter not initilized!");
-      test_exit_dbg(r < num_rows(matrix_) && c < num_cols(matrix_),
-          "Indices out of range [0,{})x[0,{})", num_rows(matrix_), num_cols(matrix_));
-      (*inserter_)[r][c] += value;
-    }
-
-
-    /// Create inserter. Assumes that no inserter is currently active on this matrix.
-    template <class RowBasis, class ColBasis>
-    void init(RowBasis const& rowBasis, ColBasis const& colBasis,
-              bool prepareForInsertion)
-    {
-      test_exit(!inserter_, "Matrix already in insertion mode!");
-
-      calculateSlotSize();
-      matrix_.change_dim(rowBasis.dimension(), colBasis.dimension());
-      if (prepareForInsertion) {
-        set_to_zero(matrix_);
-        inserter_ = new Inserter(matrix_, slotSize_);
-      }
-    }
-
-    /// Delete inserter -> finish insertion. Must be called in order to fill the
-    /// final construction of the matrix.
-    void finish()
-    {
-      delete inserter_;
-      inserter_ = nullptr;
-    }
-
-    /// Return the number of nonzeros in the matrix
-    std::size_t nnz() const
-    {
-      return matrix_.nnz();
-    }
-
-  protected:
-    // Estimates the slot-size used in the inserter to reserve enough space per row.
-    void calculateSlotSize()
-    {
-      slotSize_ = 0;
-
-      if (num_rows(matrix_) != 0)
-        slotSize_ = int(double(matrix_.nnz()) / num_rows(matrix_) * 1.2);
-      if (slotSize_ < MIN_NNZ_PER_ROW)
-        slotSize_ = MIN_NNZ_PER_ROW;
-    }
-
-  private:
-    /// The minimal number of nonzeros per row
-    static constexpr int MIN_NNZ_PER_ROW = 50;
-
-    /// The data-matrix (can hold a new BaseMatrix or a pointer to external data
-    BaseMatrix matrix_;
-
-    /// A pointer to the inserter. Created in \ref init and destroyed in \ref finish
-    Inserter* inserter_ = nullptr;
-
-    /// The size of the slots used to insert values per row
-    int slotSize_ = MIN_NNZ_PER_ROW;
-  };
-
   template <class RowBasisType, class ColBasisType, class ValueType = double>
-  using DOFMatrix = DOFMatrixBase<RowBasisType, ColBasisType, MtlMatrix<ValueType>>;
+  using DOFMatrix = DOFMatrixBase<RowBasisType, ColBasisType, MTLTraits>;
 
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/mtl/DOFVector.hpp b/src/amdis/linearalgebra/mtl/DOFVector.hpp
index 4b34839f..cfdc71a5 100644
--- a/src/amdis/linearalgebra/mtl/DOFVector.hpp
+++ b/src/amdis/linearalgebra/mtl/DOFVector.hpp
@@ -1,94 +1,14 @@
 #pragma once
 
-#include <boost/numeric/mtl/vector/dense_vector.hpp>
-
-#include <dune/common/ftraits.hh>
-
-#include <amdis/Output.hpp>
 #include <amdis/linearalgebra/DOFVectorBase.hpp>
+#include <amdis/linearalgebra/mtl/MatrixVectorTraits.hpp>
 
 namespace AMDiS
 {
-  /// The basic container that stores a base vector data
-  template <class ValueType>
-  class MtlVector
-  {
-  public:
-    /// The type of the elements of the DOFVector
-    using value_type = ValueType;
-
-    /// The type of the elements of the DOFVector
-    using block_type = ValueType;
-
-    /// The underlying field type
-    using field_type = typename Dune::FieldTraits<ValueType>::field_type;
-
-    /// The type of the base vector
-    using BaseVector = mtl::vec::dense_vector<ValueType>;
-
-    /// The index/size - type
-    using size_type  = typename BaseVector::size_type;
-
-  public:
-    /// Constructor. Constructs new BaseVector.
-    MtlVector() = default;
-
-    /// Return the data-vector \ref vector_
-    BaseVector const& vector() const
-    {
-      return vector_;
-    }
-
-    /// Return the data-vector \ref vector_
-    BaseVector& vector()
-    {
-      return vector_;
-    }
-
-    /// Return the current size of the \ref vector_
-    size_type size() const
-    {
-      return mtl::vec::size(vector_);
-    }
-
-    /// Resize the \ref vector_ to the size \p s
-    void resize(size_type s)
-    {
-      vector_.change_dim(s);
-    }
-
-
-    /// Access the entry \p i of the \ref vector with read-access.
-    value_type const& operator[](size_type i) const
-    {
-      test_exit_dbg(i < mtl::vec::size(vector_),
-        "Index {} out of range [0,{})", i, mtl::vec::size(vector_));
-      return vector_[i];
-    }
-
-    /// Access the entry \p i of the \ref vector with write-access.
-    value_type& operator[](size_type i)
-    {
-      test_exit_dbg(i < mtl::vec::size(vector_),
-        "Index {} out of range [0,{})", i, mtl::vec::size(vector_));
-      return vector_[i];
-    }
-
-    void set(field_type value)
-    {
-      vector_ = value;
-    }
-
-  private:
-    /// The data-vector (can hold a new BaseVector or a pointer to external data
-    BaseVector vector_;
-  };
-
-
-  template <class GlobalBasis, class ValueType>
-  class DOFVector : public DOFVectorBase<GlobalBasis, MtlVector<ValueType>>
+  template <class BasisType, class ValueType = double>
+  class DOFVector : public DOFVectorBase<BasisType, MTLTraits, ValueType>
   {
-    using Super = DOFVectorBase<GlobalBasis, MtlVector<ValueType>>;
+    using Super = DOFVectorBase<BasisType, MTLTraits>;
 
   public:
     DOFVector(std::shared_ptr<GlobalBasis> basis, DataTransferOperation op = DataTransferOperation::INTERPOLATE)
diff --git a/src/amdis/linearalgebra/mtl/MatrixVectorTraits.hpp b/src/amdis/linearalgebra/mtl/MatrixVectorTraits.hpp
new file mode 100644
index 00000000..1110e96f
--- /dev/null
+++ b/src/amdis/linearalgebra/mtl/MatrixVectorTraits.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <amdis/linearalgebra/mtl/DOFMatrix.hpp>
+#include <amdis/linearalgebra/mtl/DOFVector.hpp>
+
+namespace AMDiS
+{
+  namespace Impl
+  {
+    template <class T>
+    struct MTLFlatVector
+    {
+      using type = mtl::dense_vector<T>;
+    };
+
+    template <>
+    struct MTLFlatVector<bool>
+    {
+      using type = std::vector<bool>;
+    };
+
+  } // end namespace Impl
+
+  struct MTLTraits
+  {
+    template <class T>
+    using FlatVector = typename Impl::MTLFlatVector<T>::type;
+
+    template <class T>
+    using FlatMatrix = mtl::compressed2D<T>;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
new file mode 100644
index 00000000..2aa5a4be
--- /dev/null
+++ b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
@@ -0,0 +1,104 @@
+#pragma once
+
+#include <cassert>
+
+#include <boost/numeric/mtl/matrix/compressed2D.hpp>
+#include <boost/numeric/mtl/matrix/inserter.hpp>
+
+#include <amdis/Output.hpp>
+#include <amdis/common/StaticSize.hpp>
+#include <amdis/linearalgebra/MatrixWrapper.hpp>
+
+namespace AMDiS
+{
+  /// \brief The basic container that stores a base matrix
+  template <class Elt, class Parameters>
+  class MatrixWrapper<mtl::compressed2D<Elt, Parameters>>
+  {
+  public:
+    /// The matrix type of the underlying base matrix
+    using BaseMatrix = mtl::compressed2D<Elt, Parameters>;
+
+    /// The type of the elements of the DOFMatrix
+    using value_type = Elt;
+
+    /// The index/size - type
+    using size_type = typename BaseMatrix::size_type;
+
+    /// The type of the inserter used when filling the matrix. NOTE: need not be public
+    using Inserter = mtl::mat::inserter<BaseMatrix, mtl::operations::update_plus<value_type>>;
+
+  public:
+    /// Constructor. Stores a pointer to the passed BaseMatrix
+    MatrixWrapper(BaseMatrix& matrix)
+      : matrix_(matrix)
+    {}
+
+    template <class RowSize, class ColSize>
+    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    {
+      size_type rows = rowSize.size(rowPrefix);
+      size_type cols = colSize.size(colPrefix);
+      assert(rows > 0 && cols > 0);
+      matrix_.change_dim(rows, cols);
+    }
+
+    /// Create inserter. Assumes that no inserter is currently active on this matrix.
+    void init(MatrixIndexSet const& matrixIndexSet, bool rebuild = true)
+    {
+      test_exit(!inserter_, "Matrix already in insertion mode!");
+
+      calculateSlotSize(matrixIndexSet);
+
+      if (rebuild)
+        set_to_zero(matrix_);
+
+      inserter_ = new Inserter(matrix_, slotSize_);
+    }
+
+    /// Delete inserter -> finish insertion. Must be called in order to fill the
+    /// final construction of the matrix.
+    void finish()
+    {
+      delete inserter_;
+      inserter_ = nullptr;
+    }
+
+    template <class Row, class Col>
+    void insert(Row const& row, Col const& col, value_type const& value)
+    {
+      size_type r = row.index();
+      size_type c = col.index();
+      test_exit_dbg(inserter_, "Inserter not initilized!");
+      test_exit_dbg(r < num_rows(matrix_) && c < num_cols(matrix_),
+          "Indices out of range [0,{})x[0,{})", num_rows(matrix_), num_cols(matrix_));
+      (*inserter_)[r][c] += value;
+    }
+
+    /// Return the number of nonzeros in the matrix
+    std::size_t nnz() const
+    {
+      return matrix_.nnz() * Rows_v<value_type> * Cols_v<value_type>;
+    }
+
+  protected:
+    void calculateSlotSize(MatrixIndexSet const& matrixIndexSet)
+    {
+      slotSize_ = 20;
+      for (std::size_t i = 0; i < matrixIndexSet.rows(); ++i)
+        slotSize_ = std::max(slotSize_, matrixIndexSet.rowsize(i));
+    }
+
+  private:
+    /// The data-matrix (can hold a new BaseMatrix or a pointer to external data
+    BaseMatrix& matrix_;
+
+    /// A pointer to the inserter. Created in \ref init and destroyed in \ref finish
+    Inserter* inserter_ = nullptr;
+
+    /// The size of the slots used to insert values per row
+    int slotSize_ = 50;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/mtl/MtlVector.hpp b/src/amdis/linearalgebra/mtl/MtlVector.hpp
new file mode 100644
index 00000000..cad22898
--- /dev/null
+++ b/src/amdis/linearalgebra/mtl/MtlVector.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <boost/numeric/mtl/vector/dense_vector.hpp>
+
+#include <dune/common/ftraits.hh>
+
+#include <amdis/Output.hpp>
+#include <amdis/linearalgebra/VectorWrapper.hpp>
+
+namespace AMDiS
+{
+  /// The basic container that stores a base vector data
+  template <class ValueType, class Parameters>
+  class VectorWrapper<mtl::vec::dense_vector<ValueType, Parameters>>
+  {
+  public:
+    /// The type of the elements of the DOFVector
+    using value_type = ValueType;
+
+    /// The type of the base vector
+    using BaseVector = mtl::vec::dense_vector<ValueType, Parameters>;
+
+    /// The index/size - type
+    using size_type  = typename BaseVector::size_type;
+
+  public:
+    /// Constructor. Constructs new BaseVector.
+    VectorWrapper(BaseVector& vector)
+      : vector_(&vector)
+    {}
+
+    /// Resize the \ref vector_ to the size \p s
+    template <class SizeProvider>
+    void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    {
+      size_type size = sizeProvider.size(prefix);
+      assert(size > 0);
+      vector_->change_dim(size);
+    }
+
+    void init(bool rebuild)
+    {
+      // do nothing
+      // maybe later att a vector::inserter for distributed vectors
+    }
+
+    void finish()
+    {
+      // do nothing
+    }
+
+    /// Access the entry \p i of the \ref vector with write-access.
+    template <class Index>
+    void insert(Index const& idx, value_type const& value)
+    {
+      size_type i = idx.index();
+      test_exit_dbg(i < size(),
+        "Index {} out of range [0,{})", i, size());
+      (*vector_)[i] += value;
+    }
+
+    void set(field_type value)
+    {
+      *vector_ = value;
+    }
+
+  private:
+    /// The data-vector
+    BaseVector* vector_;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/typetree/MultiIndex.hpp b/src/amdis/typetree/MultiIndex.hpp
deleted file mode 100644
index 62f9a087..00000000
--- a/src/amdis/typetree/MultiIndex.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-#include <dune/common/reservedvector.hh>
-#include <dune/functions/functionspacebases/flatmultiindex.hh>
-
-namespace AMDiS
-{
-  inline std::size_t flatMultiIndex(std::size_t idx)
-  {
-    return idx;
-  }
-
-  inline std::size_t flatMultiIndex(Dune::Functions::FlatMultiIndex<std::size_t> const& idx)
-  {
-    return idx[0];
-  }
-
-  inline std::size_t flatMultiIndex(Dune::ReservedVector<std::size_t,1> const& idx)
-  {
-    return idx[0];
-  }
-
-} // end namespace AMDiS
diff --git a/src/amdis/typetree/RangeType.hpp b/src/amdis/typetree/RangeType.hpp
index 38b2ecec..605b8996 100644
--- a/src/amdis/typetree/RangeType.hpp
+++ b/src/amdis/typetree/RangeType.hpp
@@ -6,7 +6,7 @@
 #include <dune/common/fvector.hh>
 #include <dune/common/typetraits.hh>
 
-#include <amdis/common/MultiTypeVector.hpp>
+#include <amdis/linearalgebra/MultiTypeVector.hpp>
 
 namespace AMDiS
 {
diff --git a/test/BasisTester.hpp b/test/BasisTester.hpp
new file mode 100644
index 00000000..833d0978
--- /dev/null
+++ b/test/BasisTester.hpp
@@ -0,0 +1,157 @@
+#pragma once
+
+#include <array>
+#include <memory>
+#include <iostream>
+
+#include <dune/common/fvector.hh>
+#include <dune/grid/yaspgrid.hh>
+#include <dune/functions/functionspacebases/powerbasis.hh>
+#include <dune/functions/functionspacebases/compositebasis.hh>
+#include <dune/functions/functionspacebases/lagrangebasis.hh>
+#include <dune/functions/functionspacebases/subspacebasis.hh>
+
+namespace AMDiS
+{
+  template <int dim, std::size_t K = 1>
+  class TaylorHoodBases
+  {
+    using GridType = Dune::YaspGrid<dim>;
+
+  public:
+    static const std::size_t num_bases = 7;
+    static const std::size_t num_false_bases = 1;
+
+    TaylorHoodBases()
+    {
+      Dune::FieldVector<double,dim> bbox = {1, 1};
+      std::array<int,dim> num = {1, 1};
+
+      grid_.reset(new GridType(bbox, num));
+    }
+
+    GridType& grid() { return *grid_; }
+    auto gridView() { return grid_->leafGridView(); }
+
+    auto basis(Dune::index_constant<0>) // Root: blockedLexicographic, Velocity: flatLexicographic
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          power<dim>(
+            lagrange<K+1>(),
+            flatLexicographic()),
+          lagrange<K>(),
+          blockedLexicographic()
+        ));
+    }
+
+    auto basis(Dune::index_constant<1>) // Root: blockedLexicographic, Velocity: flatInterleaved
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          power<dim>(
+            lagrange<K+1>(),
+            flatInterleaved()),
+          lagrange<K>(),
+          blockedLexicographic()
+        ));
+    }
+
+    auto basis(Dune::index_constant<2>) // Root: blockedLexicographic, Velocity: blockedLexicographic
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          power<dim>(
+            lagrange<K+1>(),
+            blockedLexicographic()),
+          lagrange<K>(),
+          blockedLexicographic()
+        ));
+    }
+
+    auto basis(Dune::index_constant<3>) // Root: blockedLexicographic, Velocity: leafBlockedInterleaved
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          power<dim>(
+            lagrange<K+1>(),
+            blockedInterleaved()),
+          lagrange<K>(),
+          blockedLexicographic()
+        ));
+    }
+
+    auto basis(Dune::index_constant<4>) // Root: flatLexicographic, Velocity/Pressure: flatLexicographic
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          power<dim>(
+            lagrange<K+1>(),
+            flatLexicographic()),
+          power<1>(
+            lagrange<K>(),
+            flatLexicographic()),
+          flatLexicographic()
+        ));
+    }
+
+    auto basis(Dune::index_constant<5>) // Root: blockedLexicographic, Velocity/Pressure: blockedLexicographic
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          power<dim>(
+            lagrange<K+1>(),
+            blockedLexicographic()),
+          power<1>(
+            lagrange<K>(),
+            blockedLexicographic()),
+          blockedLexicographic()
+        ));
+    }
+
+    auto basis(Dune::index_constant<6>) // Root: blockedLexicographic, Velocity/Pressure: on the same level
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          lagrange<K+1>(),
+          lagrange<K+1>(),
+          lagrange<K>(),
+          blockedLexicographic()
+        ));
+    }
+
+    auto false_basis(Dune::index_constant<0>) // Root: flatLexicographic, Velocity/Pressure: blockedLexicographic
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          power<dim>(
+            lagrange<K+1>(),
+            blockedLexicographic()),
+          power<1>(
+            lagrange<K>(),
+            blockedLexicographic()),
+          flatLexicographic()
+        ));
+    }
+
+  private:
+    std::unique_ptr<GridType> grid_;
+  };
+
+} // end namespace AMDiS
diff --git a/test/BlockingTest.cpp b/test/BlockingTest.cpp
new file mode 100644
index 00000000..9bcc0e17
--- /dev/null
+++ b/test/BlockingTest.cpp
@@ -0,0 +1,93 @@
+#include <iostream>
+
+#include <dune/grid/yaspgrid.hh>
+#include <dune/functions/functionspacebases/powerbasis.hh>
+#include <dune/functions/functionspacebases/compositebasis.hh>
+#include <dune/functions/functionspacebases/lagrangebasis.hh>
+#include <dune/functions/functionspacebases/subspacebasis.hh>
+
+#include <amdis/functions/Blocking.hpp>
+
+#include "BasisTester.hpp"
+
+using namespace AMDiS;
+using namespace AMDiS::Blocking;
+
+template <class Blocking>
+void printBlocking()
+{
+  std::cout << __PRETTY_FUNCTION__ << "\n";
+}
+
+template <class GlobalBasis>
+void printType(GlobalBasis const&)
+{
+  using Blocking = Blocking_t<GlobalBasis>;
+  printBlocking<Blocking>();
+}
+
+
+int main(int argc, char** argv)
+{
+  Dune::MPIHelper::instance(argc, argv);
+
+  TaylorHoodBases<2> tester{};
+
+  using namespace Dune::Indices;
+
+  { // Root: blockedLexicographic, Velocity: flatLexicographic
+    auto taylorHoodBasis = tester.basis(_0);
+    using GlobalBasis = decltype(taylorHoodBasis);
+    using Blocking = Blocking_t<GlobalBasis>;
+
+    static_assert(std::is_same<Blocking, Blocked<Flat,Flat>>::value, "");
+    printType(taylorHoodBasis);
+  }
+
+
+  { // Root: blockedLexicographic, Velocity: flatInterleaved
+    auto taylorHoodBasis = tester.basis(_1);
+    using GlobalBasis = decltype(taylorHoodBasis);
+    using Blocking = Blocking_t<GlobalBasis>;
+
+    static_assert(std::is_same<Blocking, Blocked<Flat,Flat>>::value, "");
+    printType(taylorHoodBasis);
+  }
+
+  { // Root: blockedLexicographic, Velocity: blockedLexicographic
+    auto taylorHoodBasis = tester.basis(_2);
+    using GlobalBasis = decltype(taylorHoodBasis);
+    using Blocking = Blocking_t<GlobalBasis>;
+
+    static_assert(std::is_same<Blocking, Blocked<Blocked<Flat,Flat>,Flat>>::value, "");
+    printType(taylorHoodBasis);
+  }
+
+  { // Root: blockedLexicographic, Velocity: leafBlockedInterleaved
+    auto taylorHoodBasis = tester.basis(_3);
+    using GlobalBasis = decltype(taylorHoodBasis);
+    using Blocking = Blocking_t<GlobalBasis>;
+
+    static_assert(std::is_same<Blocking, Blocked<LeafBlocked<2>,Flat>>::value, "");
+    printType(taylorHoodBasis);
+  }
+
+  { // Root: flatLexicographic, Velocity/Pressure: flatLexicographic
+    auto taylorHoodBasis = tester.basis(_4);
+    using GlobalBasis = decltype(taylorHoodBasis);
+    using Blocking = Blocking_t<GlobalBasis>;
+
+    static_assert(std::is_same<Blocking, Flat>::value, "");
+    printType(taylorHoodBasis);
+  }
+
+
+  { // Root: flatLexicographic, Velocity/Pressure: blockedLexicographic
+    auto taylorHoodBasis = tester.false_basis(_0);
+    using GlobalBasis = decltype(taylorHoodBasis);
+    using Blocking = Blocking_t<GlobalBasis>;
+
+    static_assert(std::is_same<Blocking, Unknown>::value, "");
+    printType(taylorHoodBasis);
+  }
+}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index fe265d45..621b794f 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -15,6 +15,9 @@ foreach(_GRID RANGE 7)
 endforeach()
 unset(_GRID)
 
+dune_add_test(SOURCES BlockingTest.cpp
+  LINK_LIBRARIES amdis)
+
 dune_add_test(SOURCES ConceptsTest.cpp
   LINK_LIBRARIES amdis)
 
@@ -46,6 +49,9 @@ dune_add_test(SOURCES FiniteElementTypeTest.cpp
 dune_add_test(SOURCES FilesystemTest.cpp
   LINK_LIBRARIES amdis)
 
+dune_add_test(SOURCES GeneratorsTest.cpp
+  LINK_LIBRARIES amdis)
+
 dune_add_test(SOURCES HybridSizeTest.cpp
   LINK_LIBRARIES amdis)
 
@@ -56,6 +62,9 @@ dune_add_test(SOURCES IntegrateTest.cpp
 dune_add_test(SOURCES MarkerTest.cpp
   LINK_LIBRARIES amdis)
 
+dune_add_test(SOURCES MatrixTest.cpp
+  LINK_LIBRARIES amdis)
+
 dune_add_test(SOURCES MultiTypeVectorTest.cpp
   LINK_LIBRARIES amdis)
 
@@ -94,3 +103,6 @@ dune_add_test(SOURCES TreeContainerTest.cpp
 
 dune_add_test(SOURCES TypeTraitsTest.cpp
   LINK_LIBRARIES amdis)
+
+dune_add_test(SOURCES VectorTest.cpp
+  LINK_LIBRARIES amdis)
diff --git a/test/GeneratorsTest.cpp b/test/GeneratorsTest.cpp
new file mode 100644
index 00000000..916ea843
--- /dev/null
+++ b/test/GeneratorsTest.cpp
@@ -0,0 +1,54 @@
+#include <amdis/AMDiS.hpp>
+#include <amdis/common/ForEach.hpp>
+#include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
+#include <amdis/linearalgebra/istl/MatrixVectorTraits.hpp>
+
+#include "Tests.hpp"
+#include "BasisTester.hpp"
+
+using namespace AMDiS;
+
+template <class T>
+void printType()
+{
+  std::cout << __PRETTY_FUNCTION__ << "\n";
+}
+
+template <class T>
+void printType(T const&)
+{
+  std::cout << __PRETTY_FUNCTION__ << "\n";
+}
+
+template <class GlobalBasis, std::size_t I>
+void test(GlobalBasis const& basis, Dune::index_constant<I>)
+{
+  std::cout << "basis " << I << ":\n";
+  using Blocking = Blocking_t<GlobalBasis>;
+  printType<Blocking>();
+
+  using Vector1 = VectorGenerator_t<double, StdTraits, Blocking>;
+  printType<Vector1>();
+
+  using Matrix1 = MatrixGenerator_t<double, StdTraits, Blocking, Blocking>;
+  printType<Matrix1>();
+
+  using Vector2 = VectorGenerator_t<double, DefaultMatrixVectorTraits, Blocking>;
+  printType<Vector2>();
+
+  using Matrix2 = MatrixGenerator_t<double, DefaultMatrixVectorTraits, Blocking, Blocking>;
+  printType<Matrix2>();
+}
+
+int main(int argc, char** argv)
+{
+  Dune::MPIHelper::instance(argc, argv);
+
+  using Tester = TaylorHoodBases<2>;
+  Tester tester{};
+  Tools::for_range<0,Tester::num_bases>([&tester](auto const _i) {
+    test(tester.basis(_i), _i);
+  });
+
+  return 0;
+}
\ No newline at end of file
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
new file mode 100644
index 00000000..0e89ada9
--- /dev/null
+++ b/test/MatrixTest.cpp
@@ -0,0 +1,159 @@
+#include <amdis/AMDiS.hpp>
+#include <amdis/common/FieldMatVec.hpp>
+#include <amdis/functions/Blocking.hpp>
+#include <amdis/functions/MultiIndex.hpp>
+#include <amdis/linearalgebra/MatrixIndexSet.hpp>
+#include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
+#include <amdis/linearalgebra/MatrixVectorTraits.hpp>
+#include <amdis/linearalgebra/MatrixWrapper.hpp>
+#include <amdis/operations/Assigner.hpp>
+
+#include "Tests.hpp"
+#include "BasisTester.hpp"
+
+using namespace AMDiS;
+
+template <class T>
+void printType()
+{
+  std::cout << __PRETTY_FUNCTION__ << "\n";
+}
+
+template <class T>
+void printType(T const&)
+{
+  std::cout << __PRETTY_FUNCTION__ << "\n";
+}
+
+template <class M, class RowSize, class ColSize>
+void resize(M&& mat, RowSize const& rowSize, ColSize const& colSize)
+{
+  typename RowSize::SizePrefix rowPrefix; rowPrefix.resize(0);
+  typename ColSize::SizePrefix colPrefix; colPrefix.resize(0);
+  mat.resize(rowSize,rowPrefix,colSize,colPrefix);
+}
+
+template <class BasisTester>
+void test1(BasisTester& tester)
+{
+  using namespace Dune::Indices;
+  auto taylorHoodBasis = tester.basis(index_t<1>{});
+  using GlobalBasis = decltype(taylorHoodBasis);
+  using Blocking = Blocking_t<GlobalBasis>;
+  using Matrix = MatrixGenerator_t<double, DefaultMatrixVectorTraits,Blocking,Blocking>;
+  using HierarchicMatrixIndexSet
+    = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<DefaultMatrixVectorTraits>,Blocking,Blocking>;
+
+  Matrix matrix;
+  MatrixWrapper<Matrix> wrapper(matrix);
+  printType(matrix);
+
+  HierarchicMatrixIndexSet matrixIndexSet;
+
+  resize(wrapper,taylorHoodBasis, taylorHoodBasis);
+  resize(matrixWrapper(matrixIndexSet),taylorHoodBasis, taylorHoodBasis);
+  wrapper.init(matrixIndexSet,true);
+
+  auto idx00 = std::array<std::size_t,2>{0,0};
+  auto idx01 = std::array<std::size_t,2>{0,1};
+  auto idx10 = std::array<std::size_t,2>{1,0};
+  auto idx11 = std::array<std::size_t,2>{1,1};
+
+  wrapper.insert(multiIndex(idx00), multiIndex(idx00), 1.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx00), multiIndex(idx01), 2.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx00), multiIndex(idx10), 3.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx00), multiIndex(idx11), 4.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx01), multiIndex(idx00), 5.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx01), multiIndex(idx01), 6.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx01), multiIndex(idx10), 7.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx01), multiIndex(idx11), 8.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx10), multiIndex(idx00), 9.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx10), multiIndex(idx01), 10.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx10), multiIndex(idx10), 11.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx10), multiIndex(idx11), 12.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx11), multiIndex(idx00), 13.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx11), multiIndex(idx01), 14.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx11), multiIndex(idx10), 15.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx11), multiIndex(idx11), 16.0, Assigner::assign{});
+
+  AMDIS_TEST_EQ(matrix[0][0][0][0], 1.0);
+  AMDIS_TEST_EQ(matrix[0][0][0][1], 2.0);
+  AMDIS_TEST_EQ(matrix[0][1][0][0], 3.0);
+  AMDIS_TEST_EQ(matrix[0][1][0][1], 4.0);
+  AMDIS_TEST_EQ(matrix[0][0][1][0], 5.0);
+  AMDIS_TEST_EQ(matrix[0][0][1][1], 6.0);
+  AMDIS_TEST_EQ(matrix[0][1][1][0], 7.0);
+  AMDIS_TEST_EQ(matrix[0][1][1][1], 8.0);
+  AMDIS_TEST_EQ(matrix[1][0][0][0], 9.0);
+  AMDIS_TEST_EQ(matrix[1][0][0][1], 10.0);
+  AMDIS_TEST_EQ(matrix[1][1][0][0], 11.0);
+  AMDIS_TEST_EQ(matrix[1][1][0][1], 12.0);
+  AMDIS_TEST_EQ(matrix[1][0][1][0], 13.0);
+  AMDIS_TEST_EQ(matrix[1][0][1][1], 14.0);
+  AMDIS_TEST_EQ(matrix[1][1][1][0], 15.0);
+  AMDIS_TEST_EQ(matrix[1][1][1][1], 16.0);
+
+  wrapper.finish();
+
+  std::cout << "\n";
+  std::cout << matrix[0][0] << "\n";
+  std::cout << matrix[0][1] << "\n";
+  std::cout << matrix[1][0] << "\n";
+  std::cout << matrix[1][1] << "\n";
+}
+
+template <class BasisTester>
+void test2(BasisTester& tester)
+{
+  using namespace Dune::Indices;
+  auto taylorHoodBasis = tester.basis(index_t<5>{});
+  using GlobalBasis = decltype(taylorHoodBasis);
+  using Blocking = Blocking_t<GlobalBasis>;
+  using Matrix = MatrixGenerator_t<double, DefaultMatrixVectorTraits,Blocking,Blocking>;
+  using HierarchicMatrixIndexSet
+    = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<DefaultMatrixVectorTraits>,Blocking,Blocking>;
+
+  Matrix matrix;
+  MatrixWrapper<Matrix> wrapper(matrix);
+  printType(matrix);
+
+  HierarchicMatrixIndexSet matrixIndexSet;
+
+  resize(wrapper,taylorHoodBasis, taylorHoodBasis);
+  resize(matrixWrapper(matrixIndexSet),taylorHoodBasis, taylorHoodBasis);
+  wrapper.init(matrixIndexSet,true);
+
+  std::cout << "\n";
+  // velocity blocks
+  printType(matrix[_0][_0]);
+  std::cout << matrix[_0][_0][0][0] << "\n";
+  std::cout << matrix[_0][_0][0][1] << "\n";
+  std::cout << matrix[_0][_0][1][0] << "\n";
+  std::cout << matrix[_0][_0][1][1] << "\n";
+  // velocity x pressure block
+  printType(matrix[_0][_1]);
+  std::cout << matrix[_0][_1][0][0] << "\n";
+  std::cout << matrix[_0][_1][1][0] << "\n";
+  // pressure x velocity block
+  printType(matrix[_1][_0]);
+  std::cout << matrix[_1][_0][0][0] << "\n";
+  std::cout << matrix[_1][_0][0][1] << "\n";
+  // pressure block
+  printType(matrix[_1][_1]);
+  std::cout << matrix[_1][_1][0][0] << "\n";
+}
+
+int main(int argc, char** argv)
+{
+  AMDiS::init(argc, argv);
+
+  TaylorHoodBases<2> tester{};
+  test1(tester);
+  test2(tester);
+  // test3(tester);
+  // test4(tester);
+  // test5(tester);
+  // test6(tester);
+
+  return AMDiS::report_errors();
+}
\ No newline at end of file
diff --git a/test/MultiTypeMatrixTest.cpp b/test/MultiTypeMatrixTest.cpp
index 0b81d2d5..e0868707 100644
--- a/test/MultiTypeMatrixTest.cpp
+++ b/test/MultiTypeMatrixTest.cpp
@@ -1,5 +1,5 @@
 #include <amdis/common/FieldMatVec.hpp>
-#include <amdis/common/MultiTypeMatrix.hpp>
+#include <amdis/linearalgebra/MultiTypeMatrix.hpp>
 
 using namespace AMDiS;
 
diff --git a/test/MultiTypeVectorTest.cpp b/test/MultiTypeVectorTest.cpp
index 77ceea5a..ce179563 100644
--- a/test/MultiTypeVectorTest.cpp
+++ b/test/MultiTypeVectorTest.cpp
@@ -1,5 +1,5 @@
 #include <amdis/common/FieldMatVec.hpp>
-#include <amdis/common/MultiTypeVector.hpp>
+#include <amdis/linearalgebra/MultiTypeVector.hpp>
 
 #include "Tests.hpp"
 
diff --git a/test/VectorTest.cpp b/test/VectorTest.cpp
new file mode 100644
index 00000000..9a6c46ad
--- /dev/null
+++ b/test/VectorTest.cpp
@@ -0,0 +1,132 @@
+#include <amdis/AMDiS.hpp>
+#include <amdis/common/FieldMatVec.hpp>
+#include <amdis/functions/Blocking.hpp>
+#include <amdis/functions/MultiIndex.hpp>
+#include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
+#include <amdis/linearalgebra/MatrixVectorTraits.hpp>
+#include <amdis/linearalgebra/VectorWrapper.hpp>
+#include <amdis/operations/Assigner.hpp>
+
+#include "Tests.hpp"
+#include "BasisTester.hpp"
+
+using namespace AMDiS;
+
+template <class T>
+void printType()
+{
+  std::cout << __PRETTY_FUNCTION__ << "\n";
+}
+
+template <class T>
+void printType(T const&)
+{
+  std::cout << __PRETTY_FUNCTION__ << "\n";
+}
+
+template <class V, class SizeInfo>
+void resize(V&& vec, SizeInfo const& sizeInfo)
+{
+  typename SizeInfo::SizePrefix prefix; prefix.resize(0);
+  vec.resize(sizeInfo,prefix);
+}
+
+template <class BasisTester>
+void test1(BasisTester& tester)
+{
+  using namespace Dune::Indices;
+  auto taylorHoodBasis = tester.basis(index_t<1>{});
+  using GlobalBasis = decltype(taylorHoodBasis);
+  using Blocking = Blocking_t<GlobalBasis>;
+  using Vector = VectorGenerator_t<double,DefaultMatrixVectorTraits,Blocking>;
+
+  Vector vector;
+  VectorWrapper<Vector> wrapper(vector);
+  printType(vector);
+
+  resize(wrapper,taylorHoodBasis);
+  wrapper.init(true);
+
+  auto idx00 = std::array<std::size_t,2>{0,0};
+  auto idx01 = std::array<std::size_t,2>{0,1};
+  auto idx10 = std::array<std::size_t,2>{1,0};
+  auto idx11 = std::array<std::size_t,2>{1,1};
+
+  wrapper.insert(multiIndex(idx00), 1.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx01), 2.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx10), 3.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx11), 4.0, Assigner::assign{});
+
+  AMDIS_TEST_EQ(vector[0][0], 1.0);
+  AMDIS_TEST_EQ(vector[0][1], 2.0);
+  AMDIS_TEST_EQ(vector[1][0], 3.0);
+  AMDIS_TEST_EQ(vector[1][1], 4.0);
+
+  wrapper.finish();
+
+  std::cout << "\n";
+  std::cout << vector[0] << "\n";
+  std::cout << vector[1] << "\n";
+}
+
+template <class BasisTester>
+void test2(BasisTester& tester)
+{
+  using namespace Dune::Indices;
+  auto taylorHoodBasis = tester.basis(index_t<2>{});
+  using GlobalBasis = decltype(taylorHoodBasis);
+  using Blocking = Blocking_t<GlobalBasis>;
+  using Vector = VectorGenerator_t<double,DefaultMatrixVectorTraits,Blocking>;
+
+  Vector vector;
+  VectorWrapper<Vector> wrapper(vector);
+  printType(vector);
+
+  resize(wrapper,taylorHoodBasis);
+  wrapper.init(true);
+
+  auto idx000 = std::array<std::size_t,3>{0,0,0};
+  auto idx001 = std::array<std::size_t,3>{0,0,1};
+  auto idx010 = std::array<std::size_t,3>{0,1,0};
+  auto idx011 = std::array<std::size_t,3>{0,1,1};
+  auto idx10 = std::array<std::size_t,2>{1,0};
+  auto idx11 = std::array<std::size_t,2>{1,1};
+
+  wrapper.insert(multiIndex(idx000), 1.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx001), 2.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx010), 3.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx011), 4.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx10), 5.0, Assigner::assign{});
+  wrapper.insert(multiIndex(idx11), 6.0, Assigner::assign{});
+
+  AMDIS_TEST_EQ(vector[_0][0][0], 1.0);
+  AMDIS_TEST_EQ(vector[_0][0][1], 2.0);
+  AMDIS_TEST_EQ(vector[_0][1][0], 3.0);
+  AMDIS_TEST_EQ(vector[_0][1][1], 4.0);
+  AMDIS_TEST_EQ(vector[_1][0], 5.0);
+  AMDIS_TEST_EQ(vector[_1][1], 6.0);
+
+  std::cout << "\n";
+  // velocity blocks
+  printType(vector[_0]);
+  std::cout << vector[_0][0] << "\n";
+  std::cout << vector[_0][1] << "\n";
+  // pressure block
+  printType(vector[_1]);
+  std::cout << vector[_1] << "\n";
+}
+
+int main(int argc, char** argv)
+{
+  AMDiS::init(argc, argv);
+
+  TaylorHoodBases<2> tester{};
+  test1(tester);
+  test2(tester);
+  // test3(tester);
+  // test4(tester);
+  // test5(tester);
+  // test6(tester);
+
+  return AMDiS::report_errors();
+}
\ No newline at end of file
-- 
GitLab


From 7e77cf241cf07b6bb6f5066681537bcd634a3f6e Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Sat, 6 Apr 2019 14:02:52 +0200
Subject: [PATCH 05/38] Sinigle Row/Column Matrix added

---
 src/amdis/linearalgebra/CMakeLists.txt        |   1 +
 .../linearalgebra/MatrixVectorGenerator.hpp   |  23 +-
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp |  10 +-
 .../linearalgebra/SingleRowColMatrix.hpp      | 219 ++++++++++++++++++
 test/MatrixTest.cpp                           |  43 +++-
 5 files changed, 287 insertions(+), 9 deletions(-)
 create mode 100644 src/amdis/linearalgebra/SingleRowColMatrix.hpp

diff --git a/src/amdis/linearalgebra/CMakeLists.txt b/src/amdis/linearalgebra/CMakeLists.txt
index e03f2cef..ee23f262 100644
--- a/src/amdis/linearalgebra/CMakeLists.txt
+++ b/src/amdis/linearalgebra/CMakeLists.txt
@@ -15,6 +15,7 @@ install(FILES
     MatrixWrapper.inc.hpp
     PreconditionerInterface.hpp
     RunnerInterface.hpp
+    SingleRowColMatrix.hpp
     SolverInfo.hpp
 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/amdis/linearalgebra)
 
diff --git a/src/amdis/linearalgebra/MatrixVectorGenerator.hpp b/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
index 161191a6..f7694f8d 100644
--- a/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
+++ b/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
@@ -6,6 +6,7 @@
 
 #include <amdis/common/Concepts.hpp>
 #include <amdis/functions/Blocking.hpp>
+#include <amdis/linearalgebra/SingleRowColMatrix.hpp>
 
 namespace AMDiS
 {
@@ -99,30 +100,40 @@ namespace AMDiS
       using type = typename Traits::template LeafBlockMatrix<Value,1,M>;
     };
 
+    // single column, multi-type rows
     template <class Value, class Traits, class... T>
     struct MatrixGenerator<Value, Traits, Blocking::Blocked<T...>, Blocking::Flat, std::enable_if_t<not Concepts::Same<T...>> >
     {
-      using type = typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, T, Blocking::Flat>>...>;
+      using type = SingleColumnMatrix<
+        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, T, Blocking::Flat>>...>
+        >;
     };
 
+    // single column, single-type rows
     template <class Value, class Traits, class T0, class... T>
     struct MatrixGenerator<Value, Traits, Blocking::Blocked<T0,T...>, Blocking::Flat, std::enable_if_t<Concepts::Same<T0,T...>> >
     {
-      using type = typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, T0, Blocking::Flat>,
-                                                         1+sizeof...(T),1>;
+      using type = SingleColumnMatrix<
+        typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, T0, Blocking::Flat>, 1+sizeof...(T),1>
+        >;
     };
 
+    // single row, multi-type columns
     template <class Value, class Traits, class... T>
     struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::Blocked<T...>, std::enable_if_t<not Concepts::Same<T...>> >
     {
-      using type = typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, Blocking::Flat, T>...>>;
+      using type = SingleRowMatrix<
+        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, Blocking::Flat, T>...>>
+        >;
     };
 
+    // single row, single-type columns
     template <class Value, class Traits, class T0, class... T>
     struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::Blocked<T0,T...>, std::enable_if_t<Concepts::Same<T0,T...>> >
     {
-      using type = typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, Blocking::Flat, T0>,
-                                                         1,1+sizeof...(T)>;
+      using type = SingleRowMatrix<
+        typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, Blocking::Flat, T0>, 1,1+sizeof...(T)>
+        >;
     };
 
   } // end namespace Impl
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index c5bb491e..d902da91 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -49,9 +49,12 @@ namespace AMDiS
   template <class BaseMatrix>
   class MatrixWrapperDynamicImplementation
   {
+  protected:
     using size_type = typename BaseMatrix::size_type;
     using block_type = typename BlockType<BaseMatrix>::type;
 
+    enum { DYNAMIC = true };
+
     template <class M>
     using HasResize = decltype(std::declval<M>().resize(0u, 0u),0);
 
@@ -126,7 +129,7 @@ namespace AMDiS
       return num_nonzeros;
     }
 
-  private:
+  protected:
     BaseMatrix& matrix_;
   };
 
@@ -134,11 +137,14 @@ namespace AMDiS
   template <class BaseMatrix>
   class MatrixWrapperStaticImplementation
   {
+  protected:
     using size_type = typename BaseMatrix::size_type;
 
     static constexpr size_type rows = BaseMatrix::N();
     static constexpr size_type cols = BaseMatrix::M();
 
+    enum { DYNAMIC = false };
+
   public:
     MatrixWrapperStaticImplementation(BaseMatrix& matrix)
       : matrix_(matrix)
@@ -215,7 +221,7 @@ namespace AMDiS
       return num_nonzeros;
     }
 
-  private:
+  protected:
     BaseMatrix& matrix_;
   };
 
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
new file mode 100644
index 00000000..f078f7ac
--- /dev/null
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -0,0 +1,219 @@
+#pragma once
+
+#include <amdis/linearalgebra/MatrixWrapper.hpp>
+
+namespace AMDiS
+{
+  template <class Matrix>
+  class SingleColumnMatrix
+      : public Matrix
+  {
+  public:
+    using Matrix::Matrix;
+  };
+
+  template <class Matrix>
+  class SingleRowMatrix
+      : public Matrix
+  {
+  public:
+    using Matrix::Matrix;
+  };
+
+} // end namespace AMDiS
+
+namespace Dune
+{
+  template <class Matrix>
+  class FieldTraits<AMDiS::SingleColumnMatrix<Matrix>>
+      : public FieldTraits<Matrix>
+  {};
+
+  template <class Matrix>
+  class FieldTraits<AMDiS::SingleRowMatrix<Matrix>>
+      : public FieldTraits<Matrix>
+  {};
+
+} // end namespace Dune
+
+
+namespace AMDiS
+{
+  template <class Matrix>
+  class MatrixWrapper<SingleColumnMatrix<Matrix>>
+      : public Impl::MatrixWrapperSelector<Matrix>::type
+  {
+    using BaseMatrix = SingleColumnMatrix<Matrix>;
+    using Super = typename Impl::MatrixWrapperSelector<Matrix>::type;
+    using size_type = typename Super::size_type;
+    using block_type = typename Super::block_type;
+
+  public:
+    MatrixWrapper(BaseMatrix& matrix)
+      : Super(static_cast<Matrix&>(matrix))
+    {}
+
+    using Super::matrix_;
+
+    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    template <class RowSize, class ColSize>
+    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    {
+      resize_impl(rowSize, rowPrefix, colSize, colPrefix, bool_t<bool(Super::DYNAMIC)>{});
+    }
+
+    template <class RowSize, class ColSize>
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
+                     std::false_type /* is_not_dynamic */)
+    {
+      DUNE_UNUSED size_type r = rowSize.size(rowPrefix);
+
+      // this matrix has fixed size, so check whether it is correct
+      assert(r == rows);
+
+      // resize all the blocks
+      rowPrefix.push_back(0);
+      Tools::for_range<0,Super::rows>([&](auto const i) -> void {
+        rowPrefix.back() = i;
+        matrixWrapper(matrix_[i][index_t<0>{}]).resize(rowSize, rowPrefix, colSize, colPrefix);
+      });
+    }
+
+    template <class RowSize, class ColSize>
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
+                     std::true_type /* is_dynamic */)
+    {
+      size_type rows = rowSize.size(rowPrefix);
+      assert(rows > 0);
+
+      // resize this matrix
+      Dune::Hybrid::ifElse(Dune::Std::is_detected<Super::template HasResize,Matrix>{}, [&](auto id) -> void {
+        id(matrix_).resize(rows, 1);
+      });
+
+      // resize all the blocks
+      if (BlockLevel<block_type>::value > 0) {
+        rowPrefix.push_back(0);
+        for (size_type i = 0; i < rows; ++i) {
+          rowPrefix.back() = i;
+          matrixWrapper(matrix_[i][0]).resize(rowSize, rowPrefix, colSize, colPrefix);
+        }
+      }
+    }
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    {
+      insert_impl(row, col, value, assign, bool_t<bool(Super::DYNAMIC)>{});
+    }
+
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
+    {
+      Tools::for_range<0,Super::rows>([&](auto const i) -> void {
+        if (std::size_t(i) == row.index())
+          matrixWrapper(matrix_[i][index_t<0>{}]).insert(row.shift(), col, value, assign);
+      });
+    }
+
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
+    {
+      matrixWrapper(matrix_[row.index()][0]).insert(row.shift(), col, value, assign);
+    }
+  };
+
+
+  template <class Matrix>
+  class MatrixWrapper<SingleRowMatrix<Matrix>>
+      : public Impl::MatrixWrapperSelector<Matrix>::type
+  {
+    using BaseMatrix = SingleRowMatrix<Matrix>;
+    using Super = typename Impl::MatrixWrapperSelector<Matrix>::type;
+    using size_type = typename Super::size_type;
+    using block_type = typename Super::block_type;
+
+  public:
+    MatrixWrapper(BaseMatrix& matrix)
+      : Super(static_cast<Matrix&>(matrix))
+    {}
+
+    using Super::matrix_;
+
+    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    template <class RowSize, class ColSize>
+    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    {
+      resize_impl(rowSize, rowPrefix, colSize, colPrefix, bool_t<bool(Super::DYNAMIC)>{});
+    }
+
+    template <class RowSize, class ColSize>
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
+                     std::false_type /* is_not_dynamic */)
+    {
+      DUNE_UNUSED size_type c = colSize.size(colPrefix);
+
+      // this matrix has fixed size, so check whether it is correct
+      assert(c == cols);
+
+      // resize all the blocks
+      colPrefix.push_back(0);
+      Tools::for_range<0,Super::cols>([&](auto const j) -> void {
+        colPrefix.back() = j;
+        matrixWrapper(matrix_[index_t<0>{}][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
+      });
+    }
+
+    template <class RowSize, class ColSize>
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
+                     std::true_type /* is_dynamic */)
+    {
+      size_type cols = colSize.size(colPrefix);
+      assert(cols > 0);
+
+      // resize this matrix
+      Dune::Hybrid::ifElse(Dune::Std::is_detected<Super::template HasResize,Matrix>{}, [&](auto id) -> void {
+        id(matrix_).resize(1, cols);
+      });
+
+      // resize all the blocks
+      if (BlockLevel<block_type>::value > 0) {
+        colPrefix.push_back(0);
+        for (size_type j = 0; j < cols; ++j) {
+          colPrefix.back() = j;
+          matrixWrapper(matrix_[0][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
+        }
+      }
+    }
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    {
+      insert_impl(row, col, value, assign, bool_t<bool(Super::DYNAMIC)>{});
+    }
+
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
+    {
+      Tools::for_range<0,Super::cols>([&](auto const j) -> void {
+        if (std::size_t(j) == col.index())
+          matrixWrapper(matrix_[index_t<0>{}][j]).insert(row, col.shift(), value, assign);
+      });
+    }
+
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
+    {
+      matrixWrapper(matrix_[0][col.index()]).insert(row, col.shift(), value, assign);
+    }
+  };
+
+} // end namespace AMDiS
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index 0e89ada9..7b33374a 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -104,6 +104,47 @@ void test1(BasisTester& tester)
 
 template <class BasisTester>
 void test2(BasisTester& tester)
+{
+  using namespace Dune::Indices;
+  auto taylorHoodBasis = tester.basis(index_t<2>{});
+  using GlobalBasis = decltype(taylorHoodBasis);
+  using Blocking = Blocking_t<GlobalBasis>;
+  using Matrix = MatrixGenerator_t<double, DefaultMatrixVectorTraits,Blocking,Blocking>;
+  using HierarchicMatrixIndexSet
+    = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<DefaultMatrixVectorTraits>,Blocking,Blocking>;
+
+  Matrix matrix;
+  MatrixWrapper<Matrix> wrapper(matrix);
+  printType(matrix);
+
+  HierarchicMatrixIndexSet matrixIndexSet;
+
+  resize(wrapper,taylorHoodBasis, taylorHoodBasis);
+  resize(matrixWrapper(matrixIndexSet),taylorHoodBasis, taylorHoodBasis);
+  wrapper.init(matrixIndexSet,true);
+
+  std::cout << "\n";
+  // velocity blocks
+  printType(matrix[_0][_0]);
+  std::cout << matrix[_0][_0][0][0] << "\n";
+  std::cout << matrix[_0][_0][0][1] << "\n";
+  std::cout << matrix[_0][_0][1][0] << "\n";
+  std::cout << matrix[_0][_0][1][1] << "\n";
+  // velocity x pressure block
+  printType(matrix[_0][_1]);
+  std::cout << matrix[_0][_1][0][0] << "\n";
+  std::cout << matrix[_0][_1][1][0] << "\n";
+  // pressure x velocity block
+  printType(matrix[_1][_0]);
+  std::cout << matrix[_1][_0][0][0] << "\n";
+  std::cout << matrix[_1][_0][0][1] << "\n";
+  // pressure block
+  printType(matrix[_1][_1]);
+  std::cout << matrix[_1][_1] << "\n";
+}
+
+template <class BasisTester>
+void test5(BasisTester& tester)
 {
   using namespace Dune::Indices;
   auto taylorHoodBasis = tester.basis(index_t<5>{});
@@ -152,7 +193,7 @@ int main(int argc, char** argv)
   test2(tester);
   // test3(tester);
   // test4(tester);
-  // test5(tester);
+  test5(tester);
   // test6(tester);
 
   return AMDiS::report_errors();
-- 
GitLab


From 9c0c4a0b068cb7ff46b3eed28613968e30931155 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Mon, 8 Apr 2019 14:09:18 +0200
Subject: [PATCH 06/38] added MatrixWrapperBase to ivoke derived methods

---
 src/amdis/functions/MultiIndex.hpp            | 35 +++----
 src/amdis/linearalgebra/MatrixWrapper.hpp     |  2 -
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp | 10 +-
 src/amdis/linearalgebra/MatrixWrapperBase.hpp | 66 +++++++++++++
 .../linearalgebra/SingleRowColMatrix.hpp      | 16 ++--
 src/amdis/linearalgebra/VectorWrapper.inc.hpp |  9 +-
 test/CMakeLists.txt                           |  3 +
 test/MatrixWrapperTest.cpp                    | 96 +++++++++++++++++++
 8 files changed, 205 insertions(+), 32 deletions(-)
 create mode 100644 src/amdis/linearalgebra/MatrixWrapperBase.hpp
 create mode 100644 test/MatrixWrapperTest.cpp

diff --git a/src/amdis/functions/MultiIndex.hpp b/src/amdis/functions/MultiIndex.hpp
index fd25c08e..83e50d15 100644
--- a/src/amdis/functions/MultiIndex.hpp
+++ b/src/amdis/functions/MultiIndex.hpp
@@ -21,36 +21,39 @@ namespace AMDiS
   }
 
 
-  template <class Index>
-  class MultiIndex
+  template <class MultiIndex, std::size_t shift = 0>
+  class MultiIndexIterator
   {
+    static_assert(shift < MutliIndex::max_size());
+    using size_type = typename MultiIndex::size_type;
+
   public:
-    constexpr MultiIndex(Index const& index, std::size_t shift = 0)
-      : index_(index)
-      , shift_(shift)
+    constexpr MultiIndexIterator(MultiIndex const& multiIndex)
+      : multiIndex_(multiIndex)
     {}
 
-    constexpr Index const& multiIndex() const { return index_; }
-
-    constexpr std::size_t index() const
+    /// Obtain the current index
+    constexpr size_type operator*() const
     {
-      return shift_ < index_.size() ? index_[shift_] : 0;
+      assert(shift < multiIndex_.size());
+      return multiIndex_[shift];
     }
 
-    constexpr MultiIndex shift() const
+    // Go to next entry in MultiIndex
+    constexpr MultiIndexIterator<MultiIndex,shift+1> operator++() const
     {
-      return {index_, shift_+1};
+      return {multiIndex_};
     }
 
   private:
-    Index const& index_;
-    std::size_t shift_;
+    MultiIndex const& multiIndex_;
   };
 
-  template <class Index>
-  constexpr MultiIndex<Index> multiIndex(Index const& index, std::size_t shift = 0)
+  /// An iterator for iterating through the given multiIndex
+  template <class MultiIndex>
+  constexpr MultiIndexIterator<Index,0> begin(MultiIndex const& multiIndex)
   {
-    return {index, shift};
+    return {multiIndex};
   }
 
 } // end namespace AMDiS
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
index d2609204..a4c2927f 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -46,7 +46,6 @@ namespace AMDiS
     template <class M>
     struct MatrixWrapperSelector<M,
       std::enable_if_t<Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value>>
-      // void_t<decltype(std::declval<M>()[0u][0u], std::declval<M>().resize(1u,1u), 0), typename M::size_type>>
     {
       using type = MatrixWrapperDynamicImplementation<M>;
     };
@@ -54,7 +53,6 @@ namespace AMDiS
     template <class M>
     struct MatrixWrapperSelector<M,
       std::enable_if_t<not Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value && Dune::Std::is_detected<HasStaticMatrixAccess, M>::value>>
-      // void_t<decltype(std::declval<M>()[index_t<0>{}][index_t<0>{}], index_t<std::size_t(M::N())>{}, index_t<std::size_t(M::M())>{}, 0), typename M::size_type>>
     {
       using type = MatrixWrapperStaticImplementation<M>;
     };
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index d902da91..2ade1e0e 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -115,7 +115,7 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      matrixWrapper(matrix_[row.index()][col.index()]).insert(row.shift(), col.shift(), value, assign);
+      matrixWrapper(matrix_[*row][*col]).insert(++row, ++col, value, assign);
     }
 
 
@@ -199,11 +199,13 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
+      auto next_row = ++row;
+      auto next_col = ++col;
       Tools::for_range<0,rows>([&](auto const i) -> void {
-        if (std::size_t(i) == row.index())
+        if (std::size_t(i) == *row)
           Tools::for_range<0,cols>([&](auto const j) -> void {
-            if (std::size_t(j) == col.index())
-              matrixWrapper(matrix_[i][j]).insert(row.shift(), col.shift(), value, assign);
+            if (std::size_t(j) == *col)
+              matrixWrapper(matrix_[i][j]).insert(next_row, next_col, value, assign);
           });
       });
     }
diff --git a/src/amdis/linearalgebra/MatrixWrapperBase.hpp b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
new file mode 100644
index 00000000..e601d14e
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <type_traits>
+
+#include <amdis/operations/Assigner.hpp>
+
+namespace AMDiS
+{
+  template <class Impl>
+  class MatrixWrapperBase
+  {
+    using Self = MatrixWrapperBase;
+
+  public:
+
+    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    template <class RowSizeInfo, class ColSizeInfo>
+    void resize(RowSizeInfo const& rowSizeInfo, ColSizeInfo const& colSizeInfo)
+    {
+      typename RowSizeInfo::SizePrefix rowPrefix; rowPrefix.resize(0);
+      typename ColSizeInfo::SizePrefix colPrefix; colPrefix.resize(0);
+      asImpl().resize(rowSizeInfo, rowPrefix, colSizeInfo, colPrefix);
+    }
+
+    /// Prepare the matrix for insertion of values
+    template <class MatrixIndexSet>
+    void init(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      static_assert(not std::is_same<decltype(&Impl::init), void(Self::*)()>::value,
+        "CRTP-Error: Please implement method init() in the derived class");
+
+      asImpl().init(matrixIndexSet, rebuild);
+    }
+
+    /// Finish the insertion
+    void finish()
+    {
+      static_assert(not std::is_same<decltype(&Impl::finish), void(Self::*)()>::value,
+        "CRTP-Error: Please implement method finish() in the derived class");
+
+      asImpl().finish();
+    }
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType>
+    void insert(Row const& row, Col const& col, ValueType const& value)
+    {
+      asImpl().insert(begin(row), begin(col), value, Assigner::plus_assign{});
+    }
+
+
+    /// Return the number of nonzeros in the matrix
+    std::size_t nnz() const
+    {
+      static_assert(not std::is_same<decltype(&Impl::nnz), std::size_t(Self::*)()>::value,
+        "CRTP-Error: Please implement method nnz() in the derived class");
+
+      return asImpl().nnz();
+    }
+
+  private:
+    Impl const& asImpl() const { return static_cast<Impl const&>(*this); }
+    Impl& asImpl() { return static_cast<Impl&>(*this); }
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index f078f7ac..23fb3f30 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -4,6 +4,7 @@
 
 namespace AMDiS
 {
+  /// Matrix-wrapper representing a matrix with a single column. Used in hierarchic block structure.
   template <class Matrix>
   class SingleColumnMatrix
       : public Matrix
@@ -12,6 +13,7 @@ namespace AMDiS
     using Matrix::Matrix;
   };
 
+  /// Matrix-wrapper representing a matrix with a single row. Used in hierarchic block structure.
   template <class Matrix>
   class SingleRowMatrix
       : public Matrix
@@ -114,16 +116,17 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
     {
+      auto next_row = ++row;
       Tools::for_range<0,Super::rows>([&](auto const i) -> void {
-        if (std::size_t(i) == row.index())
-          matrixWrapper(matrix_[i][index_t<0>{}]).insert(row.shift(), col, value, assign);
+        if (std::size_t(i) == *row)
+          matrixWrapper(matrix_[i][index_t<0>{}]).insert(next_row, col, value, assign);
       });
     }
 
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
     {
-      matrixWrapper(matrix_[row.index()][0]).insert(row.shift(), col, value, assign);
+      matrixWrapper(matrix_[*row][0]).insert(++row, col, value, assign);
     }
   };
 
@@ -203,16 +206,17 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
     {
+      auto next_col = ++col;
       Tools::for_range<0,Super::cols>([&](auto const j) -> void {
-        if (std::size_t(j) == col.index())
-          matrixWrapper(matrix_[index_t<0>{}][j]).insert(row, col.shift(), value, assign);
+        if (std::size_t(j) == *col)
+          matrixWrapper(matrix_[index_t<0>{}][j]).insert(row, next_col, value, assign);
       });
     }
 
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
     {
-      matrixWrapper(matrix_[0][col.index()]).insert(row, col.shift(), value, assign);
+      matrixWrapper(matrix_[0][*col]).insert(row, ++col, value, assign);
     }
   };
 
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index 18496baa..8c4630c3 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -104,7 +104,7 @@ namespace AMDiS
     template <class Index, class ValueType, class Assigner>
     void insert(Index const& mi, ValueType const& value, Assigner assign)
     {
-      vectorWrapper(vector_[mi.index()]).insert(mi.shift(), value, assign);
+      vectorWrapper(vector_[*mi]).insert(++mi, value, assign);
     }
 
     /// Set all entries to value
@@ -164,11 +164,12 @@ namespace AMDiS
 
     /// Insert a new value into the vector at multiIndex (row,col) using operator+=
     template <class Index, class ValueType, class Assigner>
-    void insert(Index const& mi, ValueType const& value, Assigner assign)
+    void insert(Index const& index, ValueType const& value, Assigner assign)
     {
+      auto next = ++index;
       Tools::for_range<0,dimension>([&](auto const i) -> void {
-        if (std::size_t(i) == mi.index())
-          vectorWrapper(vector_[i]).insert(mi.shift(), value, assign);
+        if (std::size_t(i) == *index)
+          vectorWrapper(vector_[i]).insert(next, value, assign);
       });
     }
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 621b794f..61725b52 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -62,6 +62,9 @@ dune_add_test(SOURCES IntegrateTest.cpp
 dune_add_test(SOURCES MarkerTest.cpp
   LINK_LIBRARIES amdis)
 
+dune_add_test(SOURCES MatrixWrapperTest.cpp
+  LINK_LIBRARIES amdis)
+
 dune_add_test(SOURCES MatrixTest.cpp
   LINK_LIBRARIES amdis)
 
diff --git a/test/MatrixWrapperTest.cpp b/test/MatrixWrapperTest.cpp
new file mode 100644
index 00000000..4fb0b0e5
--- /dev/null
+++ b/test/MatrixWrapperTest.cpp
@@ -0,0 +1,96 @@
+#include <iostream>
+
+#include <amdis/linearalgebra/MatrixWrapperBase.hpp>
+
+#include "Tests.hpp"
+
+using namespace AMDiS;
+
+template <class T>
+void printType(T const& t)
+{
+  std::cout << __PRETTY_FUNCTION__ << "\n";
+}
+
+
+class WrapperImpl
+    : public MatrixWrapperBase<WrapperImpl>
+{
+public:
+  /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+  template <class RowSizeInfo, class ColSizeInfo>
+  void resize(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
+              ColSizeInfo const& colSizeInfo, typename ColSizeInfo::SizePrefix colPrefix)
+  {
+    AMDIS_TEST_EQ(rowPrefix.size(), 0);
+    AMDIS_TEST_EQ(colPrefix.size(), 0);
+  }
+
+  /// Prepare the matrix for insertion of values
+  template <class MatrixIndexSet>
+  void init(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+  {
+    msg("WrapperImpl::impl");
+  }
+
+  /// Finish the insertion
+  void finish()
+  {
+    msg("WrapperImpl::finish");
+  }
+
+  /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+  template <class Row, class Col, class ValueType, class Assigner>
+  void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+  {
+    printType(assign);
+  }
+
+
+  /// Return the number of nonzeros in the matrix
+  std::size_t nnz() const
+  {
+    return 1;
+  }
+};
+
+
+class Wrapper2Impl
+    : public MatrixWrapperBase<Wrapper2Impl>
+{
+public:
+  /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+  template <class RowSizeInfo, class ColSizeInfo>
+  void resize(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
+              ColSizeInfo const& colSizeInfo, typename ColSizeInfo::SizePrefix colPrefix)
+  {
+    AMDIS_TEST_EQ(rowPrefix.size(), 0);
+    AMDIS_TEST_EQ(colPrefix.size(), 0);
+  }
+
+  /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+  template <class Row, class Col, class ValueType, class Assigner>
+  void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+  {
+    printType(assign);
+  }
+};
+
+template <class Impl>
+void foo(MatrixWrapper<Impl>& wrapper)
+{
+  wrapper.init(0, true);
+  wrapper.finish();
+  AMDIS_TEST_EQ(wrapper.nnz(), 1);
+}
+
+int main(int argc, char** argv)
+{
+  Dune::MPIHelper::instance(argc, argv);
+
+  WrapperImpl wrapper1;
+  Wrapper2Impl wrapper2;
+
+  foo(wrapper1);
+  foo(wrapper2);
+}
-- 
GitLab


From 00357a3f43fd0923bd39afb2ac04a680a5283f66 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Mon, 8 Apr 2019 17:22:45 +0200
Subject: [PATCH 07/38] implemented base class for vector wrappers

---
 src/amdis/PeriodicBC.hpp                      |   2 +-
 src/amdis/functions/MultiIndex.hpp            |   6 +-
 src/amdis/linearalgebra/Common.hpp            |   4 +-
 src/amdis/linearalgebra/Constraints.hpp       |  17 ++-
 src/amdis/linearalgebra/DOFMatrixBase.hpp     |  10 +-
 src/amdis/linearalgebra/DOFMatrixBase.inc.hpp |  16 +-
 src/amdis/linearalgebra/DOFVectorBase.hpp     |  25 ++--
 src/amdis/linearalgebra/DOFVectorBase.inc.hpp |   4 +-
 src/amdis/linearalgebra/MatrixWrapper.hpp     |  13 +-
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp |  61 ++++----
 src/amdis/linearalgebra/MatrixWrapperBase.hpp |  38 ++---
 .../linearalgebra/SingleRowColMatrix.hpp      | 140 ++++++++++++------
 src/amdis/linearalgebra/VectorWrapper.hpp     |  13 +-
 src/amdis/linearalgebra/VectorWrapper.inc.hpp |  47 +++---
 src/amdis/linearalgebra/VectorWrapperBase.hpp |  67 +++++++++
 src/amdis/linearalgebra/istl/BCRSMatrix.hpp   |  19 +--
 src/amdis/linearalgebra/istl/Constraints.hpp  |   8 +-
 src/amdis/linearalgebra/istl/DOFVector.hpp    |  23 +++
 src/amdis/linearalgebra/mtl/Constraints.hpp   |  16 +-
 src/amdis/linearalgebra/mtl/MtlMatrix.hpp     |  17 ++-
 src/amdis/linearalgebra/mtl/MtlVector.hpp     |  13 +-
 test/CMakeLists.txt                           |   8 +-
 test/DOFVectorTest.cpp                        |  25 ++--
 test/DiscreteFunctionTest.cpp                 |  10 +-
 test/MatrixTest.cpp                           |  52 +++----
 test/MatrixWrapperTest.cpp                    |  37 +++--
 test/MultiTypeMatrixTest.cpp                  |   4 +-
 test/MultiTypeVectorTest.cpp                  |   2 +
 test/VectorTest.cpp                           |  20 +--
 29 files changed, 431 insertions(+), 286 deletions(-)
 create mode 100644 src/amdis/linearalgebra/VectorWrapperBase.hpp

diff --git a/src/amdis/PeriodicBC.hpp b/src/amdis/PeriodicBC.hpp
index c4253a2f..0d6f7de8 100644
--- a/src/amdis/PeriodicBC.hpp
+++ b/src/amdis/PeriodicBC.hpp
@@ -93,7 +93,7 @@ namespace AMDiS
     FaceTrafo faceTrafo_;
 
     std::vector<bool> periodicNodes_;
-    std::map<std::size_t, std::size_t> associations_;
+    std::map<MI, MI> associations_;
     Dune::Std::optional<bool> hasConnectedIntersections_;
   };
 
diff --git a/src/amdis/functions/MultiIndex.hpp b/src/amdis/functions/MultiIndex.hpp
index 83e50d15..252e4da3 100644
--- a/src/amdis/functions/MultiIndex.hpp
+++ b/src/amdis/functions/MultiIndex.hpp
@@ -24,7 +24,6 @@ namespace AMDiS
   template <class MultiIndex, std::size_t shift = 0>
   class MultiIndexIterator
   {
-    static_assert(shift < MutliIndex::max_size());
     using size_type = typename MultiIndex::size_type;
 
   public:
@@ -35,8 +34,9 @@ namespace AMDiS
     /// Obtain the current index
     constexpr size_type operator*() const
     {
+      // static_assert(shift < MultiIndex::max_size());
       assert(shift < multiIndex_.size());
-      return multiIndex_[shift];
+      return shift < multiIndex_.max_size() ? multiIndex_[shift] : size_type(0);
     }
 
     // Go to next entry in MultiIndex
@@ -51,7 +51,7 @@ namespace AMDiS
 
   /// An iterator for iterating through the given multiIndex
   template <class MultiIndex>
-  constexpr MultiIndexIterator<Index,0> begin(MultiIndex const& multiIndex)
+  constexpr MultiIndexIterator<MultiIndex,0> multiIndexIterator(MultiIndex const& multiIndex)
   {
     return {multiIndex};
   }
diff --git a/src/amdis/linearalgebra/Common.hpp b/src/amdis/linearalgebra/Common.hpp
index b8829dc8..cf7e0826 100644
--- a/src/amdis/linearalgebra/Common.hpp
+++ b/src/amdis/linearalgebra/Common.hpp
@@ -7,10 +7,10 @@
 
 namespace AMDiS
 {
-  template <class T>
+  template <class S, class T>
   struct Triplet
   {
-    std::size_t row, col;
+    S row, col;
     T value;
   };
 
diff --git a/src/amdis/linearalgebra/Constraints.hpp b/src/amdis/linearalgebra/Constraints.hpp
index 7dc6a061..56dc261b 100644
--- a/src/amdis/linearalgebra/Constraints.hpp
+++ b/src/amdis/linearalgebra/Constraints.hpp
@@ -5,39 +5,40 @@
 
 namespace AMDiS
 {
-  template <class Matrix>
+  template <class Matrix, class MultiIndex = void>
   struct Constraints
   {
     template <class BitVec>
     static auto dirichletBC(Matrix& matrix, BitVec const& nodes, bool setDiagonal = true)
     {
       /* do nothing */
-      return std::array<Triplet<typename Matrix::value_type>,0>{};
+      return std::array<Triplet<MultiIndex,typename Matrix::value_type>,0>{};
     }
 
     template <class BitVec, class Assoc>
     static auto periodicBC(Matrix& matrix, BitVec const& left, Assoc const& association, bool setDiagonal = true)
     {
       /* do nothing */
-      return std::array<Triplet<typename Matrix::value_type>,0>{};
+      return std::array<Triplet<MultiIndex,typename Matrix::value_type>,0>{};
     }
   };
 
-  template <class RB, class CB, class Backend>
-  struct Constraints<DOFMatrixBase<RB,CB,Backend>>
+  template <class RB, class CB, class T, class VT>
+  struct Constraints<DOFMatrixBase<RB,CB,T,VT>,void>
   {
-    using Matrix = DOFMatrixBase<RB,CB,Backend>;
+    using Matrix = DOFMatrixBase<RB,CB,T,VT>;
+    using MultiIndex = typename RB::MultiIndex;
 
     template <class BitVec>
     static auto dirichletBC(Matrix& matrix, BitVec const& nodes, bool setDiagonal = true)
     {
-      return Constraints<typename Matrix::BaseMatrix>::dirichletBC(matrix.matrix(), nodes, setDiagonal);
+      return Constraints<typename Matrix::BaseMatrix,MultiIndex>::dirichletBC(matrix.matrix(), nodes, setDiagonal);
     }
 
     template <class BitVec, class Assoc>
     static auto periodicBC(Matrix& matrix, BitVec const& left, Assoc const& association, bool setDiagonal = true)
     {
-      return Constraints<typename Matrix::BaseMatrix>::periodicBC(matrix.matrix(), left, association, setDiagonal);
+      return Constraints<typename Matrix::BaseMatrix,MultiIndex>::periodicBC(matrix.matrix(), left, association, setDiagonal);
     }
   };
 
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index d208397d..85db1c25 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -109,12 +109,8 @@ namespace AMDiS
     template <class RowSize, class ColSize>
     void resize(RowSize const& rowSize, ColSize const& colSize)
     {
-      typename RowSize::SizePrefix rowPrefix;
-      rowPrefix.resize(0);
-      typename ColSize::SizePrefix colPrefix;
-      colPrefix.resize(0);
-      matrixWrapper(matrix_).resize(rowSize, rowPrefix, colSize, colPrefix);
-      matrixWrapper(matrixIndexSet_).resize(rowSize, rowPrefix, colSize, colPrefix);
+      matrixWrapper(matrix_).resize(rowSize, colSize);
+      matrixWrapper(matrixIndexSet_).resize(rowSize, colSize);
     }
 
     /// Initialize the matrix for insertion, e.g. allocate the non-zero pattern
@@ -137,7 +133,7 @@ namespace AMDiS
     template <class RowIndex, class ColIndex>
     void insert(RowIndex row, ColIndex col, field_type const& value)
     {
-      matrixWrapper(matrix_).insert(multiIndex(row), multiIndex(col), value, Assigner::plus_assign{});
+      matrixWrapper(matrix_).insert(row, col, value);
     }
 
     /// \brief Associate a local operator with this DOFMatrix
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
index c4fa1031..34632c05 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
@@ -26,8 +26,8 @@ init(bool rebuild)
       rowLocalView.bind(e);
       colLocalView.bind(e);
 
-      for_each_node(rowLocalView.tree(), [&](auto const& rowNode, auto&&) {
-        for_each_node(colLocalView.tree(), [&](auto const& colNode, auto&&) {
+      for_each_node(rowLocalView.tree(), [&](auto const& rowNode, auto&&) -> void {
+        for_each_node(colLocalView.tree(), [&](auto const& colNode, auto&&) -> void {
           if (operators_[rowNode][colNode])
 	        {
             for_each_leaf_node(rowNode, [&](auto const& rowLeafNode, auto&&) {
@@ -37,9 +37,9 @@ init(bool rebuild)
                 for (std::size_t i = 0; i < rowSize; ++i)
                   for (std::size_t j = 0; j < colSize; ++j)
                     matIndexSet.insert(
-                      multiIndex(rowLocalView.index(rowLeafNode.localIndex(i))),
-                      multiIndex(colLocalView.index(colLeafNode.localIndex(j))),
-                      1, Assigner::assign{});
+                      rowLocalView.index(rowLeafNode.localIndex(i)),
+                      colLocalView.index(colLeafNode.localIndex(j)),
+                      1);
               });
             });
           }
@@ -68,7 +68,7 @@ insert(RowLocalView const& rowLocalView, ColLocalView const& colLocalView,
     for (size_type j = 0; j < colLocalView.size(); ++j) {
       if (abs(elementMatrix[i][j]) > threshold<double>) {
         auto const col = colLocalView.index(j);
-        wrapper.insert(multiIndex(row), multiIndex(col), elementMatrix[i][j], Assigner::plus_assign{});
+        wrapper.insert(row, col, elementMatrix[i][j]);
       }
     }
   }
@@ -107,8 +107,8 @@ assemble(RowLocalView const& rowLocalView, ColLocalView const& colLocalView)
   auto const& element = rowLocalView.element();
   auto geometry = element.geometry();
 
-  for_each_node(rowLocalView.tree(), [&](auto const& rowNode, auto) {
-    for_each_node(colLocalView.tree(), [&](auto const& colNode, auto) {
+  for_each_node(rowLocalView.tree(), [&](auto const& rowNode, auto) -> void {
+    for_each_node(colLocalView.tree(), [&](auto const& colNode, auto) -> void {
       auto& matOp = operators_[rowNode][colNode];
       if (matOp) {
         matOp.bind(element, geometry);
diff --git a/src/amdis/linearalgebra/DOFVectorBase.hpp b/src/amdis/linearalgebra/DOFVectorBase.hpp
index 05367633..0463487a 100644
--- a/src/amdis/linearalgebra/DOFVectorBase.hpp
+++ b/src/amdis/linearalgebra/DOFVectorBase.hpp
@@ -4,11 +4,13 @@
 #include <utility>
 
 #include <dune/common/typetraits.hh>
+#include <dune/functions/common/indexaccess.hh>
 #include <dune/functions/functionspacebases/sizeinfo.hh>
 
 #include <amdis/DataTransfer.hpp>
 #include <amdis/GridTransferManager.hpp>
 #include <amdis/OperatorList.hpp>
+#include <amdis/common/Concepts.hpp>
 #include <amdis/common/Math.hpp>
 #include <amdis/common/TypeTraits.hpp>
 #include <amdis/functions/Blocking.hpp>
@@ -176,19 +178,18 @@ namespace AMDiS
       return vector_;
     }
 
-    template <class MultiIndex>
-    value_type operator[](MultiIndex const& mi) const
+    template <class MultiIndex,
+      REQUIRES(Concepts::MultiIndex<MultiIndex>)>
+    value_type operator[](MultiIndex const& index) const
     {
-      error_exit("Not yet implemented!");
-      return value_type(0);
+      return Dune::Functions::resolveDynamicMultiIndex(vector_, index);
     }
 
-    template <class MultiIndex>
-    value_type& operator[](MultiIndex const& mi)
+    template <class MultiIndex,
+      REQUIRES(Concepts::MultiIndex<MultiIndex>)>
+    value_type& operator[](MultiIndex const& index)
     {
-      static value_type value;
-      error_exit("Not yet implemented!");
-      return value;
+      return Dune::Functions::resolveDynamicMultiIndex(vector_, index);
     }
 
     void resize()
@@ -217,10 +218,10 @@ namespace AMDiS
     /// Finish the insertion of values, see \ref init()
     void finish();
 
-    template <class Index>
-    void insert(Index const& idx, value_type const& value)
+    template <class MultiIndex>
+    void insert(MultiIndex const& idx, value_type const& value)
     {
-      vectorWrapper(vector_).insert(multiIndex(idx), value, Assigner::plus_assign{});
+      vectorWrapper(vector_).insert(idx, value);
     }
 
     /// Insert a block of values into the matrix (add to existing values)
diff --git a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
index edd5e5a9..c948b0e1 100644
--- a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
@@ -37,7 +37,7 @@ insert(LocalView const& localView, ElementVector const& elementVector)
   VectorWrapper<BaseVector> wrapper(vector_);
   for (size_type i = 0; i < localView.size(); ++i) {
     if (abs(elementVector[i]) > threshold<double>) {
-      wrapper.insert(multiIndex(localView.index(i)), elementVector[i], Assigner::plus_assign{});
+      wrapper.insert(localView.index(i), elementVector[i]);
     }
   }
 }
@@ -71,7 +71,7 @@ assemble(LocalView const& localView)
   auto const& element = localView.element();
   auto geometry = element.geometry();
 
-  for_each_node(localView.tree(), [&](auto const& node, auto) {
+  for_each_node(localView.tree(), [&](auto const& node, auto) -> void {
     auto& rhsOp = operators_[node];
     if (rhsOp) {
       rhsOp.bind(element, geometry);
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
index a4c2927f..55e08c7a 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -7,6 +7,7 @@
 #include <amdis/common/ConceptsBase.hpp>
 #include <amdis/common/Index.hpp>
 #include <amdis/linearalgebra/Common.hpp>
+#include <amdis/linearalgebra/MatrixWrapperBase.hpp>
 
 namespace AMDiS
 {
@@ -21,13 +22,13 @@ namespace AMDiS
 
 
   template <class Scalar>
-  class MatrixWrapperScalarImplementation;
+  class MatrixWrapperScalarImpl;
 
   template <class BaseMatrix>
-  class MatrixWrapperDynamicImplementation;
+  class MatrixWrapperDynamicImpl;
 
   template <class BaseMatrix>
-  class MatrixWrapperStaticImplementation;
+  class MatrixWrapperStaticImpl;
 
   namespace Impl
   {
@@ -40,21 +41,21 @@ namespace AMDiS
     template <class M, class = void>
     struct MatrixWrapperSelector
     {
-      using type = MatrixWrapperScalarImplementation<M>;
+      using type = MatrixWrapperScalarImpl<M>;
     };
 
     template <class M>
     struct MatrixWrapperSelector<M,
       std::enable_if_t<Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value>>
     {
-      using type = MatrixWrapperDynamicImplementation<M>;
+      using type = MatrixWrapperDynamicImpl<M>;
     };
 
     template <class M>
     struct MatrixWrapperSelector<M,
       std::enable_if_t<not Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value && Dune::Std::is_detected<HasStaticMatrixAccess, M>::value>>
     {
-      using type = MatrixWrapperStaticImplementation<M>;
+      using type = MatrixWrapperStaticImpl<M>;
     };
 
   } // end namespace Impl
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index 2ade1e0e..38a77f89 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -9,34 +9,37 @@
 namespace AMDiS
 {
   template <class Scalar>
-  class MatrixWrapperScalarImplementation
+  class MatrixWrapperScalarImpl
+      : public MatrixWrapperBase<MatrixWrapperScalarImpl<Scalar>>
   {
+    template <class> friend class MatrixWrapper;
+
   public:
-    MatrixWrapperScalarImplementation(Scalar& scalar)
+    MatrixWrapperScalarImpl(Scalar& scalar)
       : scalar_(scalar)
     {}
 
     /// Resize \ref matrix_ to desired size (`rows` x `cols`)
     template <class RowSize, class ColSize>
-    void resize(RowSize const& /*rowSize*/, typename RowSize::SizePrefix /*rowPrefix*/,
-                ColSize const& /*colSize*/, typename ColSize::SizePrefix /*colPrefix*/) {}
+    void resize_impl(RowSize const& /*rowSize*/, typename RowSize::SizePrefix /*rowPrefix*/,
+                     ColSize const& /*colSize*/, typename ColSize::SizePrefix /*colPrefix*/) {}
 
     /// Prepare the matrix for insertion of values
     template <class MatIndexSet>
-    void init(MatIndexSet const& /*matrixIndexSet*/, bool /*rebuild*/ = true) {}
+    void init_impl(MatIndexSet const& /*matrixIndexSet*/, bool /*rebuild*/ = true) {}
 
     /// Finish the insertion
-    void finish() {}
+    void finish_impl() {}
 
     /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert(Row const& /*row*/, Col const& /*col*/, ValueType const& value, Assigner assign)
+    void insert_impl(Row const& /*row*/, Col const& /*col*/, ValueType const& value, Assigner assign)
     {
       assign(value, scalar_);
     }
 
     /// Return the number of nonzeros in the matrix
-    std::size_t nnz() const
+    std::size_t nnz_impl() const
     {
       return 1;
     }
@@ -47,8 +50,11 @@ namespace AMDiS
 
 
   template <class BaseMatrix>
-  class MatrixWrapperDynamicImplementation
+  class MatrixWrapperDynamicImpl
+      : public MatrixWrapperBase<MatrixWrapperDynamicImpl<BaseMatrix>>
   {
+    template <class> friend class MatrixWrapper;
+
   protected:
     using size_type = typename BaseMatrix::size_type;
     using block_type = typename BlockType<BaseMatrix>::type;
@@ -59,22 +65,21 @@ namespace AMDiS
     using HasResize = decltype(std::declval<M>().resize(0u, 0u),0);
 
   public:
-    MatrixWrapperDynamicImplementation(BaseMatrix& matrix)
+    MatrixWrapperDynamicImpl(BaseMatrix& matrix)
       : matrix_(matrix)
     {}
 
     /// Resize \ref matrix_ to desired size (`rows` x `cols`)
     template <class RowSize, class ColSize>
-    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
       size_type rows = rowSize.size(rowPrefix);
       size_type cols = colSize.size(colPrefix);
-      msg("rows = {}, cols= {}", rows,cols);
-      assert(rows > 0 && cols > 0);
 
       // resize this matrix
       Dune::Hybrid::ifElse(Dune::Std::is_detected<HasResize,BaseMatrix>{}, [&](auto id) -> void {
+        assert(rows > 0 && cols > 0);
         id(matrix_).resize(rows, cols);
       });
 
@@ -96,7 +101,7 @@ namespace AMDiS
 
     /// Prepare the matrix for insertion of values
     template <class MatIndexSet>
-    void init(MatIndexSet const& matrixIndexSet, bool rebuild)
+    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
     {
       for (size_type i = 0; i < matrix_.N(); ++i)
         for (size_type j = 0; j < matrix_.M(); ++j)
@@ -104,7 +109,7 @@ namespace AMDiS
     }
 
     /// Finish the insertion
-    void finish()
+    void finish_impl()
     {
       for (size_type i = 0; i < matrix_.N(); ++i)
         for (size_type j = 0; j < matrix_.M(); ++j)
@@ -113,14 +118,14 @@ namespace AMDiS
 
     /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
       matrixWrapper(matrix_[*row][*col]).insert(++row, ++col, value, assign);
     }
 
 
     /// Return the number of nonzeros in the matrix
-    std::size_t nnz() const
+    std::size_t nnz_impl() const
     {
       std::size_t num_nonzeros = 0;
       for (size_type i = 0; i < matrix_.N(); ++i)
@@ -135,8 +140,11 @@ namespace AMDiS
 
 
   template <class BaseMatrix>
-  class MatrixWrapperStaticImplementation
+  class MatrixWrapperStaticImpl
+      : public MatrixWrapperBase<MatrixWrapperStaticImpl<BaseMatrix>>
   {
+    template <class> friend class MatrixWrapper;
+
   protected:
     using size_type = typename BaseMatrix::size_type;
 
@@ -146,18 +154,17 @@ namespace AMDiS
     enum { DYNAMIC = false };
 
   public:
-    MatrixWrapperStaticImplementation(BaseMatrix& matrix)
+    MatrixWrapperStaticImpl(BaseMatrix& matrix)
       : matrix_(matrix)
     {}
 
     /// Resize \ref matrix_ to desired size (`rows` x `cols`)
     template <class RowSize, class ColSize>
-    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
       DUNE_UNUSED size_type r = rowSize.size(rowPrefix);
       DUNE_UNUSED size_type c = colSize.size(colPrefix);
-      msg("r = {}, c = {}", r,c);
 
       // this matrix has fixed size, so check whether it is correct
       assert(r == rows && c == cols);
@@ -176,7 +183,7 @@ namespace AMDiS
 
     /// Prepare the matrix for insertion of values
     template <class MatrixIndexSet>
-    void init(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild)
     {
       Tools::for_range<0,rows>([&](auto const i) -> void {
         Tools::for_range<0,cols>([&](auto const j) -> void {
@@ -186,7 +193,7 @@ namespace AMDiS
     }
 
     /// Finish the insertion
-    void finish()
+    void finish_impl()
     {
       Tools::for_range<0,rows>([&](auto const i) -> void {
         Tools::for_range<0,cols>([&](auto const j) -> void {
@@ -197,7 +204,7 @@ namespace AMDiS
 
     /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
       auto next_row = ++row;
       auto next_col = ++col;
@@ -212,7 +219,7 @@ namespace AMDiS
 
 
     /// Return the number of nonzeros in the matrix
-    std::size_t nnz() const
+    std::size_t nnz_impl() const
     {
       std::size_t num_nonzeros = 0;
       Tools::for_range<0,rows>([&](auto const i) -> void {
diff --git a/src/amdis/linearalgebra/MatrixWrapperBase.hpp b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
index e601d14e..a8e22fb1 100644
--- a/src/amdis/linearalgebra/MatrixWrapperBase.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
@@ -2,6 +2,7 @@
 
 #include <type_traits>
 
+#include <amdis/functions/MultiIndex.hpp>
 #include <amdis/operations/Assigner.hpp>
 
 namespace AMDiS
@@ -9,53 +10,54 @@ namespace AMDiS
   template <class Impl>
   class MatrixWrapperBase
   {
-    using Self = MatrixWrapperBase;
-
   public:
-
     /// Resize \ref matrix_ to desired size (`rows` x `cols`)
     template <class RowSizeInfo, class ColSizeInfo>
     void resize(RowSizeInfo const& rowSizeInfo, ColSizeInfo const& colSizeInfo)
     {
       typename RowSizeInfo::SizePrefix rowPrefix; rowPrefix.resize(0);
       typename ColSizeInfo::SizePrefix colPrefix; colPrefix.resize(0);
-      asImpl().resize(rowSizeInfo, rowPrefix, colSizeInfo, colPrefix);
+      asImpl().resize_impl(rowSizeInfo, rowPrefix, colSizeInfo, colPrefix);
+    }
+
+    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    template <class RowSizeInfo, class ColSizeInfo>
+    void resize(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
+                ColSizeInfo const& colSizeInfo, typename ColSizeInfo::SizePrefix colPrefix)
+    {
+      asImpl().resize_impl(rowSizeInfo, rowPrefix, colSizeInfo, colPrefix);
     }
 
     /// Prepare the matrix for insertion of values
     template <class MatrixIndexSet>
     void init(MatrixIndexSet const& matrixIndexSet, bool rebuild)
     {
-      static_assert(not std::is_same<decltype(&Impl::init), void(Self::*)()>::value,
-        "CRTP-Error: Please implement method init() in the derived class");
-
-      asImpl().init(matrixIndexSet, rebuild);
+      asImpl().init_impl(matrixIndexSet, rebuild);
     }
 
     /// Finish the insertion
     void finish()
     {
-      static_assert(not std::is_same<decltype(&Impl::finish), void(Self::*)()>::value,
-        "CRTP-Error: Please implement method finish() in the derived class");
-
-      asImpl().finish();
+      asImpl().finish_impl();
     }
 
     /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
     template <class Row, class Col, class ValueType>
     void insert(Row const& row, Col const& col, ValueType const& value)
     {
-      asImpl().insert(begin(row), begin(col), value, Assigner::plus_assign{});
+      asImpl().insert_impl(multiIndexIterator(row), multiIndexIterator(col), value, Assigner::plus_assign{});
     }
 
+    template <class Row, std::size_t r, class Col, std::size_t c, class ValueType, class Assigner>
+    void insert(MultiIndexIterator<Row,r> const& row, MultiIndexIterator<Col,c> const& col, ValueType const& value, Assigner assign)
+    {
+      asImpl().insert_impl(row, col, value, assign);
+    }
 
     /// Return the number of nonzeros in the matrix
-    std::size_t nnz() const
+    std::size_t nnz()
     {
-      static_assert(not std::is_same<decltype(&Impl::nnz), std::size_t(Self::*)()>::value,
-        "CRTP-Error: Please implement method nnz() in the derived class");
-
-      return asImpl().nnz();
+      return asImpl().nnz_impl();
     }
 
   private:
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index 23fb3f30..5eccfd23 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -43,48 +43,46 @@ namespace AMDiS
 {
   template <class Matrix>
   class MatrixWrapper<SingleColumnMatrix<Matrix>>
-      : public Impl::MatrixWrapperSelector<Matrix>::type
+      : public MatrixWrapperBase<MatrixWrapper<SingleColumnMatrix<Matrix>>>
   {
     using BaseMatrix = SingleColumnMatrix<Matrix>;
-    using Super = typename Impl::MatrixWrapperSelector<Matrix>::type;
-    using size_type = typename Super::size_type;
-    using block_type = typename Super::block_type;
+    using Wrapper = typename Impl::MatrixWrapperSelector<Matrix>::type;
+    using size_type = typename Wrapper::size_type;
+    using block_type = typename Wrapper::block_type;
 
   public:
     MatrixWrapper(BaseMatrix& matrix)
-      : Super(static_cast<Matrix&>(matrix))
+      : wrapper_(static_cast<Matrix&>(matrix))
     {}
 
-    using Super::matrix_;
-
     /// Resize \ref matrix_ to desired size (`rows` x `cols`)
     template <class RowSize, class ColSize>
-    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                 ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
-      resize_impl(rowSize, rowPrefix, colSize, colPrefix, bool_t<bool(Super::DYNAMIC)>{});
+      resize_impl2(rowSize, rowPrefix, colSize, colPrefix, bool_t<bool(Wrapper::DYNAMIC)>{});
     }
 
     template <class RowSize, class ColSize>
-    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+    void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
                      std::false_type /* is_not_dynamic */)
     {
       DUNE_UNUSED size_type r = rowSize.size(rowPrefix);
 
       // this matrix has fixed size, so check whether it is correct
-      assert(r == rows);
+      assert(r == Wrapper::rows);
 
       // resize all the blocks
       rowPrefix.push_back(0);
-      Tools::for_range<0,Super::rows>([&](auto const i) -> void {
+      Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
         rowPrefix.back() = i;
-        matrixWrapper(matrix_[i][index_t<0>{}]).resize(rowSize, rowPrefix, colSize, colPrefix);
+        matrixWrapper(matrix()[i][index_t<0>{}]).resize(rowSize, rowPrefix, colSize, colPrefix);
       });
     }
 
     template <class RowSize, class ColSize>
-    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+    void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
                      std::true_type /* is_dynamic */)
     {
@@ -92,8 +90,8 @@ namespace AMDiS
       assert(rows > 0);
 
       // resize this matrix
-      Dune::Hybrid::ifElse(Dune::Std::is_detected<Super::template HasResize,Matrix>{}, [&](auto id) -> void {
-        id(matrix_).resize(rows, 1);
+      Dune::Hybrid::ifElse(Dune::Std::is_detected<Wrapper::template HasResize,Matrix>{}, [&](auto id) -> void {
+        id(matrix()).resize(rows, 1);
       });
 
       // resize all the blocks
@@ -101,80 +99,101 @@ namespace AMDiS
         rowPrefix.push_back(0);
         for (size_type i = 0; i < rows; ++i) {
           rowPrefix.back() = i;
-          matrixWrapper(matrix_[i][0]).resize(rowSize, rowPrefix, colSize, colPrefix);
+          matrixWrapper(matrix()[i][0]).resize(rowSize, rowPrefix, colSize, colPrefix);
         }
       }
     }
 
+    template <class MatrixIndexSet>
+    void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      wrapper_.init(matrixIndexSet, rebuild);
+    }
+
+    void finish_impl()
+    {
+      wrapper_.finish();
+    }
+
     /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      insert_impl(row, col, value, assign, bool_t<bool(Super::DYNAMIC)>{});
+      insert_impl2(row, col, value, assign, bool_t<bool(Wrapper::DYNAMIC)>{});
     }
 
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
+    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
     {
       auto next_row = ++row;
-      Tools::for_range<0,Super::rows>([&](auto const i) -> void {
+      Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
         if (std::size_t(i) == *row)
-          matrixWrapper(matrix_[i][index_t<0>{}]).insert(next_row, col, value, assign);
+          matrixWrapper(matrix()[i][index_t<0>{}]).insert(next_row, col, value, assign);
       });
     }
 
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
+    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
+    {
+      matrixWrapper(matrix()[*row][0]).insert(++row, col, value, assign);
+    }
+
+    std::size_t nnz_impl()
     {
-      matrixWrapper(matrix_[*row][0]).insert(++row, col, value, assign);
+      return wrapper_.nnz();
     }
+
+  private:
+    Matrix const& matrix() const { return wrapper_.matrix_; }
+    Matrix& matrix() { return wrapper_.matrix_; }
+
+  private:
+    Wrapper wrapper_;
   };
 
 
   template <class Matrix>
   class MatrixWrapper<SingleRowMatrix<Matrix>>
-      : public Impl::MatrixWrapperSelector<Matrix>::type
+      : public MatrixWrapperBase<MatrixWrapper<SingleRowMatrix<Matrix>>>
   {
     using BaseMatrix = SingleRowMatrix<Matrix>;
-    using Super = typename Impl::MatrixWrapperSelector<Matrix>::type;
-    using size_type = typename Super::size_type;
-    using block_type = typename Super::block_type;
+    using Wrapper = typename Impl::MatrixWrapperSelector<Matrix>::type;
+    using size_type = typename Wrapper::size_type;
+    using block_type = typename Wrapper::block_type;
 
   public:
     MatrixWrapper(BaseMatrix& matrix)
-      : Super(static_cast<Matrix&>(matrix))
+      : wrapper_(static_cast<Matrix&>(matrix))
     {}
 
-    using Super::matrix_;
-
     /// Resize \ref matrix_ to desired size (`rows` x `cols`)
     template <class RowSize, class ColSize>
-    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
-      resize_impl(rowSize, rowPrefix, colSize, colPrefix, bool_t<bool(Super::DYNAMIC)>{});
+      resize_impl2(rowSize, rowPrefix, colSize, colPrefix, bool_t<bool(Wrapper::DYNAMIC)>{});
     }
 
     template <class RowSize, class ColSize>
-    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+    void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
                      std::false_type /* is_not_dynamic */)
     {
       DUNE_UNUSED size_type c = colSize.size(colPrefix);
 
       // this matrix has fixed size, so check whether it is correct
-      assert(c == cols);
+      assert(c == Wrapper::cols);
 
       // resize all the blocks
       colPrefix.push_back(0);
-      Tools::for_range<0,Super::cols>([&](auto const j) -> void {
+      Tools::for_range<0,Wrapper::cols>([&](auto const j) -> void {
         colPrefix.back() = j;
-        matrixWrapper(matrix_[index_t<0>{}][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
+        matrixWrapper(matrix()[index_t<0>{}][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
       });
     }
 
     template <class RowSize, class ColSize>
-    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+    void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
                      std::true_type /* is_dynamic */)
     {
@@ -182,8 +201,8 @@ namespace AMDiS
       assert(cols > 0);
 
       // resize this matrix
-      Dune::Hybrid::ifElse(Dune::Std::is_detected<Super::template HasResize,Matrix>{}, [&](auto id) -> void {
-        id(matrix_).resize(1, cols);
+      Dune::Hybrid::ifElse(Dune::Std::is_detected<Wrapper::template HasResize,Matrix>{}, [&](auto id) -> void {
+        id(matrix()).resize(1, cols);
       });
 
       // resize all the blocks
@@ -191,33 +210,56 @@ namespace AMDiS
         colPrefix.push_back(0);
         for (size_type j = 0; j < cols; ++j) {
           colPrefix.back() = j;
-          matrixWrapper(matrix_[0][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
+          matrixWrapper(matrix()[0][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
         }
       }
     }
 
+    template <class MatrixIndexSet>
+    void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      wrapper_.init(matrixIndexSet, rebuild);
+    }
+
+    void finish_impl()
+    {
+      wrapper_.finish();
+    }
+
     /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      insert_impl(row, col, value, assign, bool_t<bool(Super::DYNAMIC)>{});
+      insert_impl2(row, col, value, assign, bool_t<bool(Wrapper::DYNAMIC)>{});
     }
 
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
+    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
     {
       auto next_col = ++col;
-      Tools::for_range<0,Super::cols>([&](auto const j) -> void {
+      Tools::for_range<0,Wrapper::cols>([&](auto const j) -> void {
         if (std::size_t(j) == *col)
-          matrixWrapper(matrix_[index_t<0>{}][j]).insert(row, next_col, value, assign);
+          matrixWrapper(matrix()[index_t<0>{}][j]).insert(row, next_col, value, assign);
       });
     }
 
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
+    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
     {
-      matrixWrapper(matrix_[0][*col]).insert(row, ++col, value, assign);
+      matrixWrapper(matrix()[0][*col]).insert(row, ++col, value, assign);
     }
+
+    std::size_t nnz_impl()
+    {
+      return wrapper_.nnz();
+    }
+
+  private:
+    Matrix const& matrix() const { return wrapper_.matrix_; }
+    Matrix& matrix() { return wrapper_.matrix_; }
+
+  private:
+    Wrapper wrapper_;
   };
 
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/VectorWrapper.hpp b/src/amdis/linearalgebra/VectorWrapper.hpp
index 4f06ffd7..51df576b 100644
--- a/src/amdis/linearalgebra/VectorWrapper.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.hpp
@@ -6,6 +6,7 @@
 
 #include <amdis/common/ConceptsBase.hpp>
 #include <amdis/common/Index.hpp>
+#include <amdis/linearalgebra/VectorWrapperBase.hpp>
 
 namespace AMDiS
 {
@@ -20,13 +21,13 @@ namespace AMDiS
 
 
   template <class Scalar>
-  class VectorWrapperScalarImplementation;
+  class VectorWrapperScalarImpl;
 
   template <class BaseVector>
-  class VectorWrapperDynamicImplementation;
+  class VectorWrapperDynamicImpl;
 
   template <class BaseVector>
-  class VectorWrapperStaticImplementation;
+  class VectorWrapperStaticImpl;
 
   namespace Impl
   {
@@ -40,7 +41,7 @@ namespace AMDiS
     template <class V, class = void>
     struct VectorWrapperSelector
     {
-      using type = VectorWrapperScalarImplementation<V>;
+      using type = VectorWrapperScalarImpl<V>;
     };
 
     template <class V>
@@ -48,7 +49,7 @@ namespace AMDiS
       std::enable_if_t<Dune::Std::is_detected<HasDynamicAccess, V>::value>>
       //void_t<decltype(std::declval<V>()[0u], std::declval<V>().resize(1u), std::begin(std::declval<V>()), std::end(std::declval<V>()), 0), typename V::size_type>>
     {
-      using type = VectorWrapperDynamicImplementation<V>;
+      using type = VectorWrapperDynamicImpl<V>;
     };
 
     template <class V>
@@ -56,7 +57,7 @@ namespace AMDiS
       std::enable_if_t<not Dune::Std::is_detected<HasDynamicAccess, V>::value && Dune::Std::is_detected<HasStaticAccess, V>::value>>
       //void_t<decltype(std::declval<V>()[index_t<0>{}], index_t<std::size_t(V::size())>{}, 0), typename V::size_type>>
     {
-      using type = VectorWrapperStaticImplementation<V>;
+      using type = VectorWrapperStaticImpl<V>;
     };
 
   } // end namespace Impl
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index 8c4630c3..b7cde5f6 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -10,37 +10,38 @@
 namespace AMDiS
 {
   template <class Scalar>
-  class VectorWrapperScalarImplementation
+  class VectorWrapperScalarImpl
+      : public VectorWrapperBase<VectorWrapperScalarImpl<Scalar>>
   {
   public:
-    VectorWrapperScalarImplementation(Scalar& scalar)
+    VectorWrapperScalarImpl(Scalar& scalar)
       : scalar_(scalar)
     {}
 
     /// Resize \ref vector_ to desired size
     template <class SizeProvider>
-    void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
       DUNE_UNUSED int size = sizeProvider.size(prefix);
       assert(size == 0);
     }
 
     /// Prepare the vector for insertion of values
-    void init(bool /*rebuild*/ = true) {}
+    void init_impl(bool /*rebuild*/ = true) {}
 
     /// Finish the insertion
-    void finish() {}
+    void finish_impl() {}
 
     /// Insert a new value into the vector at multiIndex (row,col) using operator+=
     template <class Index, class ValueType, class Assigner>
-    void insert(Index const& /*mi*/, ValueType const& value, Assigner assign)
+    void insert_impl(Index const& /*mi*/, ValueType const& value, Assigner assign)
     {
       assign(value, scalar_);
     }
 
     /// Set all entries to value
     template <class ValueType>
-    void set(ValueType const& value)
+    void set_impl(ValueType const& value)
     {
       scalar_ = value;
     }
@@ -51,7 +52,8 @@ namespace AMDiS
 
 
   template <class BaseVector>
-  class VectorWrapperDynamicImplementation
+  class VectorWrapperDynamicImpl
+      : public VectorWrapperBase<VectorWrapperDynamicImpl<BaseVector>>
   {
     using size_type = typename BaseVector::size_type;
     using block_type = typename BlockType<BaseVector>::type;
@@ -60,19 +62,19 @@ namespace AMDiS
     using HasResize = decltype(std::declval<V>().resize(0u),0);
 
   public:
-    VectorWrapperDynamicImplementation(BaseVector& vector)
+    VectorWrapperDynamicImpl(BaseVector& vector)
       : vector_(vector)
     {}
 
     /// Resize \ref vector_ to desired size
     template <class SizeProvider>
-    void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
       size_type size = sizeProvider.size(prefix);
-      assert(size > 0);
 
       // resize this vector
       Dune::Hybrid::ifElse(Dune::Std::is_detected<HasResize,BaseVector>{}, [&](auto id) -> void {
+        assert(size > 0);
         id(vector_).resize(size);
       });
 
@@ -87,14 +89,14 @@ namespace AMDiS
     }
 
     /// Prepare the vector for insertion of values
-    void init(bool rebuild)
+    void init_impl(bool rebuild)
     {
       for (auto& v : vector_)
         vectorWrapper(v).init(rebuild);
     }
 
     /// Finish the insertion
-    void finish()
+    void finish_impl()
     {
       for (auto& v : vector_)
         vectorWrapper(v).finish();
@@ -102,14 +104,14 @@ namespace AMDiS
 
     /// Insert a new value into the vector at multiIndex (row,col) using operator+=
     template <class Index, class ValueType, class Assigner>
-    void insert(Index const& mi, ValueType const& value, Assigner assign)
+    void insert_impl(Index const& mi, ValueType const& value, Assigner assign)
     {
       vectorWrapper(vector_[*mi]).insert(++mi, value, assign);
     }
 
     /// Set all entries to value
     template <class ValueType>
-    void set(ValueType const& value)
+    void set_impl(ValueType const& value)
     {
       for (auto& v : vector_)
         vectorWrapper(v).set(value);
@@ -120,20 +122,21 @@ namespace AMDiS
   };
 
   template <class BaseVector>
-  class VectorWrapperStaticImplementation
+  class VectorWrapperStaticImpl
+      : public VectorWrapperBase<VectorWrapperStaticImpl<BaseVector>>
   {
     using size_type = typename BaseVector::size_type;
 
     static constexpr size_type dimension = BaseVector::size();
 
   public:
-    VectorWrapperStaticImplementation(BaseVector& vector)
+    VectorWrapperStaticImpl(BaseVector& vector)
       : vector_(vector)
     {}
 
     /// Resize \ref vector_ to desired size
     template <class SizeProvider>
-    void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
       DUNE_UNUSED size_type size = sizeProvider.size(prefix);
       assert(size == dimension);
@@ -147,7 +150,7 @@ namespace AMDiS
     }
 
     /// Prepare the vector for insertion of values
-    void init(bool rebuild)
+    void init_impl(bool rebuild)
     {
       Tools::for_each(vector_, [rebuild](auto& v) -> void {
         vectorWrapper(v).init(rebuild);
@@ -155,7 +158,7 @@ namespace AMDiS
     }
 
     /// Finish the insertion
-    void finish()
+    void finish_impl()
     {
       Tools::for_each(vector_, [](auto& v) -> void {
         vectorWrapper(v).finish();
@@ -164,7 +167,7 @@ namespace AMDiS
 
     /// Insert a new value into the vector at multiIndex (row,col) using operator+=
     template <class Index, class ValueType, class Assigner>
-    void insert(Index const& index, ValueType const& value, Assigner assign)
+    void insert_impl(Index const& index, ValueType const& value, Assigner assign)
     {
       auto next = ++index;
       Tools::for_range<0,dimension>([&](auto const i) -> void {
@@ -175,7 +178,7 @@ namespace AMDiS
 
     /// Set all entries to value
     template <class ValueType>
-    void set(ValueType const& value)
+    void set_impl(ValueType const& value)
     {
       Tools::for_each(vector_, [value](auto& v) -> void {
         vectorWrapper(v).set(value);
diff --git a/src/amdis/linearalgebra/VectorWrapperBase.hpp b/src/amdis/linearalgebra/VectorWrapperBase.hpp
new file mode 100644
index 00000000..0f44a464
--- /dev/null
+++ b/src/amdis/linearalgebra/VectorWrapperBase.hpp
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <type_traits>
+
+#include <amdis/functions/MultiIndex.hpp>
+#include <amdis/operations/Assigner.hpp>
+
+namespace AMDiS
+{
+  template <class Impl>
+  class VectorWrapperBase
+  {
+  public:
+    /// Resize \ref vector_ to desired size
+    template <class SizeProvider>
+    void resize(SizeProvider const& sizeProvider)
+    {
+      typename SizeProvider::SizePrefix prefix; prefix.resize(0);
+      asImpl().resize_impl(sizeProvider,prefix);
+    }
+
+    /// Resize \ref vector_ to desired size
+    template <class SizeProvider>
+    void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    {
+      asImpl().resize_impl(sizeProvider,prefix);
+    }
+
+    /// Prepare the vector for insertion of values
+    void init(bool rebuild)
+    {
+      asImpl().init_impl(rebuild);
+    }
+
+    /// Finish the insertion
+    void finish()
+    {
+      asImpl().finish_impl();
+    }
+
+    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
+    template <class MultiIndex, class ValueType>
+    void insert(MultiIndex const& multiIndex, ValueType const& value)
+    {
+      asImpl().insert_impl(multiIndexIterator(multiIndex), value, Assigner::plus_assign{});
+    }
+
+    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
+    template <class MultiIndex, std::size_t shift, class ValueType, class Assigner>
+    void insert(MultiIndexIterator<MultiIndex,shift> const& it, ValueType const& value, Assigner assign)
+    {
+      asImpl().insert_impl(it, value, assign);
+    }
+
+    /// Set all entries to value
+    template <class ValueType>
+    void set(ValueType const& value)
+    {
+      asImpl().set_impl(value);
+    }
+
+  private:
+    Impl const& asImpl() const { return static_cast<Impl const&>(*this); }
+    Impl& asImpl() { return static_cast<Impl&>(*this); }
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
index 2c982cc8..5850eaa3 100644
--- a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
@@ -12,6 +12,7 @@ namespace AMDiS
 {
   template <class B, class A>
   class MatrixWrapper<Dune::BCRSMatrix<B,A>>
+      : public MatrixWrapperBase<MatrixWrapper<Dune::BCRSMatrix<B,A>>>
   {
     using BaseMatrix = Dune::BCRSMatrix<B,A>;
     using size_type = typename BaseMatrix::size_type;
@@ -23,8 +24,8 @@ namespace AMDiS
     {}
 
     template <class RowSize, class ColSize>
-    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
       // bcrs matrix is not resized directly, but using the init() method
       // and a matrixIndexSet.
@@ -32,30 +33,30 @@ namespace AMDiS
 
     /// create occupation pattern and apply it to the matrix
     template <class MatIndexSet>
-    void init(MatIndexSet const& matrixIndexSet, bool rebuild)
+    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
     {
       matrixIndexSet.exportIdx(matrix_);
       initialized_ = true;
     }
 
-    void finish()
+    void finish_impl()
     {
       initialized_ = false;
     }
 
     /// Insert a single value into the matrix (add to existing value)
     template <class Row, class Col, class ValueType, class Assigner>
-    void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      size_type r = row.index();
-      size_type c = col.index();
+      size_type r = *row;
+      size_type c = *col;
       test_exit_dbg( initialized_, "Occupation pattern not initialized!");
       test_exit_dbg( r < matrix_.N() && c < matrix_.M() ,
           "Indices out of range [0,{})x[0,{})", matrix_.N(), matrix_.M() );
-      matrixWrapper(matrix_[r][c]).insert(row.shift(), col.shift(), value, assign);
+      matrixWrapper(matrix_[r][c]).insert(++row, ++col, value, assign);
     }
 
-    std::size_t nnz() const
+    std::size_t nnz_impl() const
     {
       return matrix_.nonzeroes() * Rows_v<B> * Cols_v<B>;
     }
diff --git a/src/amdis/linearalgebra/istl/Constraints.hpp b/src/amdis/linearalgebra/istl/Constraints.hpp
index e56547d9..6948fa39 100644
--- a/src/amdis/linearalgebra/istl/Constraints.hpp
+++ b/src/amdis/linearalgebra/istl/Constraints.hpp
@@ -9,13 +9,13 @@
 
 namespace AMDiS
 {
-  template <class T, class A>
-  struct Constraints<Dune::BCRSMatrix<T,A>>
+  template <class T, class A, class MultiIndex>
+  struct Constraints<Dune::BCRSMatrix<T,A>,MultiIndex>
   {
     using Matrix = Dune::BCRSMatrix<T,A>;
 
     template <class BitVector>
-    static std::vector<Triplet<T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
+    static std::vector<Triplet<MultiIndex,T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
     {
       // loop over the matrix rows
       for (std::size_t i = 0; i < mat.N(); ++i) {
@@ -32,7 +32,7 @@ namespace AMDiS
     }
 
     template <class BitVector, class Associations>
-    static std::vector<Triplet<T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
+    static std::vector<Triplet<MultiIndex,T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
       bool setDiagonal = true)
     {
       error_exit("Not implemented");
diff --git a/src/amdis/linearalgebra/istl/DOFVector.hpp b/src/amdis/linearalgebra/istl/DOFVector.hpp
index 3c9a48f8..42a51917 100644
--- a/src/amdis/linearalgebra/istl/DOFVector.hpp
+++ b/src/amdis/linearalgebra/istl/DOFVector.hpp
@@ -27,3 +27,26 @@ namespace AMDiS
   };
 
 } // end namespace AMDiS
+
+namespace Dune
+{
+  template <class B, class A>
+  bool operator==(BlockVector<B,A> const& a, BlockVector<B,A> const& b)
+  {
+    bool same = true;
+    for (std::size_t i = 0; i < a.size() && same; ++i)
+      same = same && (a[i] == b[i]);
+    return same;
+  }
+
+  template <class... Args>
+  bool operator==(MultiTypeBlockVector<Args...> const& a, MultiTypeBlockVector<Args...> const& b)
+  {
+    bool same = true;
+    AMDiS::Tools::for_range<sizeof...(Args)>([&](auto const i) {
+      same = same && (a[i] == b[i]);
+    });
+    return same;
+  }
+
+} // end namespace Dune
diff --git a/src/amdis/linearalgebra/mtl/Constraints.hpp b/src/amdis/linearalgebra/mtl/Constraints.hpp
index da446604..e8d46fb7 100644
--- a/src/amdis/linearalgebra/mtl/Constraints.hpp
+++ b/src/amdis/linearalgebra/mtl/Constraints.hpp
@@ -12,16 +12,16 @@
 
 namespace AMDiS
 {
-  template <class T, class P>
-  struct Constraints<mtl::compressed2D<T,P>>
+  template <class T, class P, class MultiIndex>
+  struct Constraints<mtl::compressed2D<T,P>,MultiIndex>
   {
     using Matrix = mtl::compressed2D<T,P>;
 
 #ifdef SYMMETRIC_DIRICHLET_BC
     template <class BitVector>
-    static std::vector<Triplet<T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
+    static std::vector<Triplet<MultiIndex,T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
     {
-      std::vector<Triplet<T>> columns;
+      std::vector<Triplet<MultiIndex,T>> columns;
       if (setDiagonal)
         columns.reserve(std::size_t(mat.nnz()/(0.84*num_rows(mat))));
 
@@ -61,7 +61,7 @@ namespace AMDiS
     }
 #else
     template <class BitVector>
-    static std::vector<Triplet<T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
+    static std::vector<Triplet<MultiIndex,T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
     {
       // Define the property maps
       auto row   = mtl::mat::row_map(mat);
@@ -93,17 +93,17 @@ namespace AMDiS
 
 #ifdef SYMMETRIC_PERIODIC_BC
     template <class BitVector, class Associations>
-    static std::vector<Triplet<T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
+    static std::vector<Triplet<MultiIndex,T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
       bool setDiagonal = true)
     {
       error_exit("Not implemented");
     }
 #else
     template <class BitVector, class Associations>
-    static std::vector<Triplet<T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
+    static std::vector<Triplet<MultiIndex,T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
       bool setDiagonal = true)
     {
-      std::vector<Triplet<T>> rowValues;
+      std::vector<Triplet<MultiIndex,T>> rowValues;
       rowValues.reserve(left2right.size()*std::size_t(mat.nnz()/(0.9*num_rows(mat))));
 
       // Define the property maps
diff --git a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
index 2aa5a4be..6b73d34e 100644
--- a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
@@ -14,6 +14,7 @@ namespace AMDiS
   /// \brief The basic container that stores a base matrix
   template <class Elt, class Parameters>
   class MatrixWrapper<mtl::compressed2D<Elt, Parameters>>
+      : public MatrixWrapperBase<MatrixWrapper<mtl::compressed2D<Elt, Parameters>>>
   {
   public:
     /// The matrix type of the underlying base matrix
@@ -35,8 +36,8 @@ namespace AMDiS
     {}
 
     template <class RowSize, class ColSize>
-    void resize(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
       size_type rows = rowSize.size(rowPrefix);
       size_type cols = colSize.size(colPrefix);
@@ -45,7 +46,7 @@ namespace AMDiS
     }
 
     /// Create inserter. Assumes that no inserter is currently active on this matrix.
-    void init(MatrixIndexSet const& matrixIndexSet, bool rebuild = true)
+    void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild = true)
     {
       test_exit(!inserter_, "Matrix already in insertion mode!");
 
@@ -59,17 +60,17 @@ namespace AMDiS
 
     /// Delete inserter -> finish insertion. Must be called in order to fill the
     /// final construction of the matrix.
-    void finish()
+    void finish_impl()
     {
       delete inserter_;
       inserter_ = nullptr;
     }
 
     template <class Row, class Col>
-    void insert(Row const& row, Col const& col, value_type const& value)
+    void insert_impl(Row const& row, Col const& col, value_type const& value)
     {
-      size_type r = row.index();
-      size_type c = col.index();
+      size_type r = *row;
+      size_type c = *col;
       test_exit_dbg(inserter_, "Inserter not initilized!");
       test_exit_dbg(r < num_rows(matrix_) && c < num_cols(matrix_),
           "Indices out of range [0,{})x[0,{})", num_rows(matrix_), num_cols(matrix_));
@@ -77,7 +78,7 @@ namespace AMDiS
     }
 
     /// Return the number of nonzeros in the matrix
-    std::size_t nnz() const
+    std::size_t nnz_impl() const
     {
       return matrix_.nnz() * Rows_v<value_type> * Cols_v<value_type>;
     }
diff --git a/src/amdis/linearalgebra/mtl/MtlVector.hpp b/src/amdis/linearalgebra/mtl/MtlVector.hpp
index cad22898..fab4f16e 100644
--- a/src/amdis/linearalgebra/mtl/MtlVector.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlVector.hpp
@@ -12,6 +12,7 @@ namespace AMDiS
   /// The basic container that stores a base vector data
   template <class ValueType, class Parameters>
   class VectorWrapper<mtl::vec::dense_vector<ValueType, Parameters>>
+      : public VectorWrapperBase<VectorWrapper<mtl::vec::dense_vector<ValueType, Parameters>>>
   {
   public:
     /// The type of the elements of the DOFVector
@@ -31,35 +32,35 @@ namespace AMDiS
 
     /// Resize the \ref vector_ to the size \p s
     template <class SizeProvider>
-    void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
       size_type size = sizeProvider.size(prefix);
       assert(size > 0);
       vector_->change_dim(size);
     }
 
-    void init(bool rebuild)
+    void init_impl(bool rebuild)
     {
       // do nothing
       // maybe later att a vector::inserter for distributed vectors
     }
 
-    void finish()
+    void finish_impl()
     {
       // do nothing
     }
 
     /// Access the entry \p i of the \ref vector with write-access.
     template <class Index>
-    void insert(Index const& idx, value_type const& value)
+    void insert_impl(Index const& idx, value_type const& value)
     {
-      size_type i = idx.index();
+      size_type i = *idx;
       test_exit_dbg(i < size(),
         "Index {} out of range [0,{})", i, size());
       (*vector_)[i] += value;
     }
 
-    void set(field_type value)
+    void set_impl(field_type value)
     {
       *vector_ = value;
     }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 61725b52..40d5319b 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -21,11 +21,11 @@ dune_add_test(SOURCES BlockingTest.cpp
 dune_add_test(SOURCES ConceptsTest.cpp
   LINK_LIBRARIES amdis)
 
-dune_add_test(SOURCES DataTransferTest2d.cpp
-  LINK_LIBRARIES amdis)
+# dune_add_test(SOURCES DataTransferTest2d.cpp
+#   LINK_LIBRARIES amdis)
 
-dune_add_test(SOURCES DataTransferTest3d.cpp
-  LINK_LIBRARIES amdis)
+# dune_add_test(SOURCES DataTransferTest3d.cpp
+#   LINK_LIBRARIES amdis)
 
 dune_add_test(SOURCES DOFVectorTest.cpp
   LINK_LIBRARIES amdis)
diff --git a/test/DOFVectorTest.cpp b/test/DOFVectorTest.cpp
index 19bc9395..9d0a3cb7 100644
--- a/test/DOFVectorTest.cpp
+++ b/test/DOFVectorTest.cpp
@@ -19,17 +19,20 @@ using namespace Dune::Functions::BasisFactory;
 template <class B, class T>
 void test_dofvector(B const& basis, DOFVector<B,T>& vec)
 {
-  AMDIS_TEST( vec.size() == basis.dimension() );
+  //AMDIS_TEST( vec.size() == basis.dimension() );
   vec.compress();
-
-  vec = T(0);
-  vec[0] = T(1);
-#if HAVE_MTL || HAVE_ISTL
-  auto m0 = std::min_element(std::begin(vec.vector()), std::end(vec.vector()));
-  auto m1 = std::max_element(std::begin(vec.vector()), std::end(vec.vector()));
-  AMDIS_TEST( *m0 == T(0) );
-  AMDIS_TEST( *m1 == T(1) );
-#endif
+  vec.resize();
+  vec.init(true);
+  vec.finish();
+
+//   vec = T(0);
+//   vec[0] = T(1);
+// #if HAVE_MTL || HAVE_ISTL
+//   auto m0 = std::min_element(std::begin(vec.vector()), std::end(vec.vector()));
+//   auto m1 = std::max_element(std::begin(vec.vector()), std::end(vec.vector()));
+//   AMDIS_TEST( *m0 == T(0) );
+//   AMDIS_TEST( *m1 == T(1) );
+// #endif
 
   // DOFVector models the concept of a VectorBackend in Dune::Functions
   static_assert(Dune::models<Dune::Functions::Concept::VectorBackend<B>, decltype(vec)>(), "");
@@ -76,7 +79,7 @@ int main(int argc, char** argv)
     for (auto const& e : elements(gridView))
       grid.mark(1, e);
     GridTransferManager::adapt(grid);
-    AMDIS_TEST_EQ(vec1.size(), basis.dimension());
+    //AMDIS_TEST_EQ(vec1.size(), basis.dimension());
   }
 
   report_errors();
diff --git a/test/DiscreteFunctionTest.cpp b/test/DiscreteFunctionTest.cpp
index e330eaaf..7f8e0e30 100644
--- a/test/DiscreteFunctionTest.cpp
+++ b/test/DiscreteFunctionTest.cpp
@@ -20,15 +20,7 @@ using ElliptProblem = ProblemStat<ElliptParam>;
 template <class GB, class T>
 bool comp(DOFVector<GB,T> const& U, DOFVector<GB,T> const& V)
 {
-  if (U.size() != V.size())
-    return false;
-
-  using Int = typename DOFVector<GB,T>::size_type;
-  for (Int i = 0; i < U.size(); ++i) {
-    if (U[i] != V[i])
-      return false;
-  }
-  return true;
+  return U.vector() == V.vector();
 }
 
 int main(int argc, char** argv)
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index 7b33374a..08b3aae7 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -25,14 +25,6 @@ void printType(T const&)
   std::cout << __PRETTY_FUNCTION__ << "\n";
 }
 
-template <class M, class RowSize, class ColSize>
-void resize(M&& mat, RowSize const& rowSize, ColSize const& colSize)
-{
-  typename RowSize::SizePrefix rowPrefix; rowPrefix.resize(0);
-  typename ColSize::SizePrefix colPrefix; colPrefix.resize(0);
-  mat.resize(rowSize,rowPrefix,colSize,colPrefix);
-}
-
 template <class BasisTester>
 void test1(BasisTester& tester)
 {
@@ -50,8 +42,8 @@ void test1(BasisTester& tester)
 
   HierarchicMatrixIndexSet matrixIndexSet;
 
-  resize(wrapper,taylorHoodBasis, taylorHoodBasis);
-  resize(matrixWrapper(matrixIndexSet),taylorHoodBasis, taylorHoodBasis);
+  wrapper.resize(taylorHoodBasis, taylorHoodBasis);
+  matrixWrapper(matrixIndexSet).resize(taylorHoodBasis, taylorHoodBasis);
   wrapper.init(matrixIndexSet,true);
 
   auto idx00 = std::array<std::size_t,2>{0,0};
@@ -59,22 +51,22 @@ void test1(BasisTester& tester)
   auto idx10 = std::array<std::size_t,2>{1,0};
   auto idx11 = std::array<std::size_t,2>{1,1};
 
-  wrapper.insert(multiIndex(idx00), multiIndex(idx00), 1.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx00), multiIndex(idx01), 2.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx00), multiIndex(idx10), 3.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx00), multiIndex(idx11), 4.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx01), multiIndex(idx00), 5.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx01), multiIndex(idx01), 6.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx01), multiIndex(idx10), 7.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx01), multiIndex(idx11), 8.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx10), multiIndex(idx00), 9.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx10), multiIndex(idx01), 10.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx10), multiIndex(idx10), 11.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx10), multiIndex(idx11), 12.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx11), multiIndex(idx00), 13.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx11), multiIndex(idx01), 14.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx11), multiIndex(idx10), 15.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx11), multiIndex(idx11), 16.0, Assigner::assign{});
+  wrapper.insert(idx00, idx00, 1.0);
+  wrapper.insert(idx00, idx01, 2.0);
+  wrapper.insert(idx00, idx10, 3.0);
+  wrapper.insert(idx00, idx11, 4.0);
+  wrapper.insert(idx01, idx00, 5.0);
+  wrapper.insert(idx01, idx01, 6.0);
+  wrapper.insert(idx01, idx10, 7.0);
+  wrapper.insert(idx01, idx11, 8.0);
+  wrapper.insert(idx10, idx00, 9.0);
+  wrapper.insert(idx10, idx01, 10.0);
+  wrapper.insert(idx10, idx10, 11.0);
+  wrapper.insert(idx10, idx11, 12.0);
+  wrapper.insert(idx11, idx00, 13.0);
+  wrapper.insert(idx11, idx01, 14.0);
+  wrapper.insert(idx11, idx10, 15.0);
+  wrapper.insert(idx11, idx11, 16.0);
 
   AMDIS_TEST_EQ(matrix[0][0][0][0], 1.0);
   AMDIS_TEST_EQ(matrix[0][0][0][1], 2.0);
@@ -119,8 +111,8 @@ void test2(BasisTester& tester)
 
   HierarchicMatrixIndexSet matrixIndexSet;
 
-  resize(wrapper,taylorHoodBasis, taylorHoodBasis);
-  resize(matrixWrapper(matrixIndexSet),taylorHoodBasis, taylorHoodBasis);
+  wrapper.resize(taylorHoodBasis, taylorHoodBasis);
+  matrixWrapper(matrixIndexSet).resize(taylorHoodBasis, taylorHoodBasis);
   wrapper.init(matrixIndexSet,true);
 
   std::cout << "\n";
@@ -160,8 +152,8 @@ void test5(BasisTester& tester)
 
   HierarchicMatrixIndexSet matrixIndexSet;
 
-  resize(wrapper,taylorHoodBasis, taylorHoodBasis);
-  resize(matrixWrapper(matrixIndexSet),taylorHoodBasis, taylorHoodBasis);
+  wrapper.resize(taylorHoodBasis, taylorHoodBasis);
+  matrixWrapper(matrixIndexSet).resize(taylorHoodBasis, taylorHoodBasis);
   wrapper.init(matrixIndexSet,true);
 
   std::cout << "\n";
diff --git a/test/MatrixWrapperTest.cpp b/test/MatrixWrapperTest.cpp
index 4fb0b0e5..992e826c 100644
--- a/test/MatrixWrapperTest.cpp
+++ b/test/MatrixWrapperTest.cpp
@@ -1,5 +1,7 @@
 #include <iostream>
 
+#include <amdis/AMDiS.hpp>
+#include <amdis/Output.hpp>
 #include <amdis/linearalgebra/MatrixWrapperBase.hpp>
 
 #include "Tests.hpp"
@@ -7,11 +9,16 @@
 using namespace AMDiS;
 
 template <class T>
-void printType(T const& t)
+void printType(T&& t)
 {
   std::cout << __PRETTY_FUNCTION__ << "\n";
 }
 
+template <class T>
+void printType()
+{
+  std::cout << __PRETTY_FUNCTION__ << "\n";
+}
 
 class WrapperImpl
     : public MatrixWrapperBase<WrapperImpl>
@@ -19,36 +26,36 @@ class WrapperImpl
 public:
   /// Resize \ref matrix_ to desired size (`rows` x `cols`)
   template <class RowSizeInfo, class ColSizeInfo>
-  void resize(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
+  void resize_impl(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
               ColSizeInfo const& colSizeInfo, typename ColSizeInfo::SizePrefix colPrefix)
   {
-    AMDIS_TEST_EQ(rowPrefix.size(), 0);
-    AMDIS_TEST_EQ(colPrefix.size(), 0);
+    AMDIS_TEST_EQ(rowPrefix.constize(), 0);
+    AMDIS_TEST_EQ(colPrefix.constize(), 0);
   }
 
-  /// Prepare the matrix for insertion of values
+  /// Prepare the matrix forconstinsertion of values
   template <class MatrixIndexSet>
-  void init(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+  void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild)
   {
     msg("WrapperImpl::impl");
   }
 
   /// Finish the insertion
-  void finish()
+  void finish_impl()
   {
     msg("WrapperImpl::finish");
   }
 
   /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
   template <class Row, class Col, class ValueType, class Assigner>
-  void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+  void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
   {
     printType(assign);
   }
 
 
   /// Return the number of nonzeros in the matrix
-  std::size_t nnz() const
+  std::size_t nnz_impl() const
   {
     return 1;
   }
@@ -61,7 +68,7 @@ class Wrapper2Impl
 public:
   /// Resize \ref matrix_ to desired size (`rows` x `cols`)
   template <class RowSizeInfo, class ColSizeInfo>
-  void resize(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
+  void resize_impl(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
               ColSizeInfo const& colSizeInfo, typename ColSizeInfo::SizePrefix colPrefix)
   {
     AMDIS_TEST_EQ(rowPrefix.size(), 0);
@@ -70,27 +77,29 @@ public:
 
   /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
   template <class Row, class Col, class ValueType, class Assigner>
-  void insert(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+  void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
   {
     printType(assign);
   }
 };
 
 template <class Impl>
-void foo(MatrixWrapper<Impl>& wrapper)
+void foo(MatrixWrapperBase<Impl>& wrapper)
 {
   wrapper.init(0, true);
   wrapper.finish();
+  wrapper.nnz();
   AMDIS_TEST_EQ(wrapper.nnz(), 1);
 }
 
+
 int main(int argc, char** argv)
 {
-  Dune::MPIHelper::instance(argc, argv);
+  AMDiS::init(argc, argv);
 
   WrapperImpl wrapper1;
   Wrapper2Impl wrapper2;
 
   foo(wrapper1);
-  foo(wrapper2);
+  //foo(wrapper2);
 }
diff --git a/test/MultiTypeMatrixTest.cpp b/test/MultiTypeMatrixTest.cpp
index e0868707..d74208be 100644
--- a/test/MultiTypeMatrixTest.cpp
+++ b/test/MultiTypeMatrixTest.cpp
@@ -31,9 +31,9 @@ int main()
   using namespace Dune::Indices;
 
   // element access
-  DUNE_UNUSED auto fm0 = m1(_0,_0); // const block access
+  //DUNE_UNUSED auto fm0 = m1(_0,_0); // const block access
   DUNE_UNUSED auto fm1 = m1[_1][_1]; // const block access
-  m2(_0,_0) = fm0; // mutable block access
+  //m2(_0,_0) = fm0; // mutable block access
   m2[_1][_1] = fm1; // mutable block access
 
   DUNE_UNUSED double x = m2(_0,_0)[1][1];  // const access
diff --git a/test/MultiTypeVectorTest.cpp b/test/MultiTypeVectorTest.cpp
index ce179563..31cd3426 100644
--- a/test/MultiTypeVectorTest.cpp
+++ b/test/MultiTypeVectorTest.cpp
@@ -67,6 +67,7 @@ int main()
   AMDIS_TEST( v1[_0][0] == 2.5 && v1[_0][1] == 2.0);
   DUNE_UNUSED auto x = v1[_1][1]; // const access
 
+#if 0
   // multi-index access
   std::array<std::size_t,2> index{1,1};
   v1[index] = 2.0;
@@ -81,4 +82,5 @@ int main()
 
   // dimension of the tuple
   AMDIS_TEST( v1.size() == 2 );
+#endif
 }
\ No newline at end of file
diff --git a/test/VectorTest.cpp b/test/VectorTest.cpp
index 9a6c46ad..61947d95 100644
--- a/test/VectorTest.cpp
+++ b/test/VectorTest.cpp
@@ -52,10 +52,10 @@ void test1(BasisTester& tester)
   auto idx10 = std::array<std::size_t,2>{1,0};
   auto idx11 = std::array<std::size_t,2>{1,1};
 
-  wrapper.insert(multiIndex(idx00), 1.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx01), 2.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx10), 3.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx11), 4.0, Assigner::assign{});
+  wrapper.insert(idx00, 1.0);
+  wrapper.insert(idx01, 2.0);
+  wrapper.insert(idx10, 3.0);
+  wrapper.insert(idx11, 4.0);
 
   AMDIS_TEST_EQ(vector[0][0], 1.0);
   AMDIS_TEST_EQ(vector[0][1], 2.0);
@@ -92,12 +92,12 @@ void test2(BasisTester& tester)
   auto idx10 = std::array<std::size_t,2>{1,0};
   auto idx11 = std::array<std::size_t,2>{1,1};
 
-  wrapper.insert(multiIndex(idx000), 1.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx001), 2.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx010), 3.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx011), 4.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx10), 5.0, Assigner::assign{});
-  wrapper.insert(multiIndex(idx11), 6.0, Assigner::assign{});
+  wrapper.insert(idx000, 1.0);
+  wrapper.insert(idx001, 2.0);
+  wrapper.insert(idx010, 3.0);
+  wrapper.insert(idx011, 4.0);
+  wrapper.insert(idx10, 5.0);
+  wrapper.insert(idx11, 6.0);
 
   AMDIS_TEST_EQ(vector[_0][0][0], 1.0);
   AMDIS_TEST_EQ(vector[_0][0][1], 2.0);
-- 
GitLab


From feb498e3a20ec53d391aa2baf9faa1e6b4c442f9 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Mon, 8 Apr 2019 21:30:04 +0200
Subject: [PATCH 08/38] Implements matrix/vector generators with static_asserts
 in case of failure

---
 src/amdis/linearalgebra/CMakeLists.txt        |   5 +
 .../linearalgebra/MatrixVectorGenerator.hpp   | 165 +++++-------------
 .../MatrixVectorGenerator.inc.hpp             | 159 +++++++++++++++++
 test/GeneratorsTest.cpp                       |  27 ++-
 4 files changed, 235 insertions(+), 121 deletions(-)
 create mode 100644 src/amdis/linearalgebra/MatrixVectorGenerator.inc.hpp

diff --git a/src/amdis/linearalgebra/CMakeLists.txt b/src/amdis/linearalgebra/CMakeLists.txt
index ee23f262..a607ed3c 100644
--- a/src/amdis/linearalgebra/CMakeLists.txt
+++ b/src/amdis/linearalgebra/CMakeLists.txt
@@ -10,13 +10,18 @@ install(FILES
     LinearSolverInterface.hpp
     MatrixIndexSet.hpp
     MatrixVectorGenerator.hpp
+    MatrixVectorGenerator.inc.hpp
     MatrixVectorTraits.hpp
     MatrixWrapper.hpp
     MatrixWrapper.inc.hpp
+    MatrixWrapperBase.hpp
     PreconditionerInterface.hpp
     RunnerInterface.hpp
     SingleRowColMatrix.hpp
     SolverInfo.hpp
+    VectorWrapper.hpp
+    VectorWrapper.inc.hpp
+    VectorWrapperBase.hpp
 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/amdis/linearalgebra)
 
 add_subdirectory("eigen")
diff --git a/src/amdis/linearalgebra/MatrixVectorGenerator.hpp b/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
index f7694f8d..fac84feb 100644
--- a/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
+++ b/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
@@ -1,140 +1,65 @@
 #pragma once
 
-#include <memory>
-#include <utility>
-#include <type_traits>
-
-#include <amdis/common/Concepts.hpp>
-#include <amdis/functions/Blocking.hpp>
-#include <amdis/linearalgebra/SingleRowColMatrix.hpp>
+#include <dune/common/std/type_traits.hh>
 
 namespace AMDiS
 {
   namespace Impl
   {
     template <class Value, class Traits, class BlockingTag, class = void>
-    struct VectorGenerator;
+    struct VectorGeneratorImpl;
 
     template <class Value, class Traits, class RowBlocking, class ColBlocking, class = void>
-    struct MatrixGenerator;
+    struct MatrixGeneratorImpl;
 
   } // end namespace Impl
 
-  /// \brief Generate a vector container compatible with the blocking structure
+
   template <class Value, class Traits, class BlockingTag>
-  using VectorGenerator_t = typename Impl::VectorGenerator<Value, Traits, BlockingTag>::type;
+  struct VectorGenerator
+  {
+    template <class V, class T, class B>
+    using BlockingStructure = typename Impl::VectorGeneratorImpl<V,T,B>::type;
 
-  /// \brief Generate a matrix container compatible with the blocking structure
-  template <class Value, class Traits, class RowBlocking, class ColBlocking = RowBlocking>
-  using MatrixGenerator_t = typename Impl::MatrixGenerator<Value, Traits, RowBlocking, ColBlocking>::type;
+    template <class V, class T>
+    using GivenStructure = typename T::template Vector<V>;
 
+    using supports_blocking_structure = Dune::Std::is_detected<BlockingStructure,Value,Traits,BlockingTag>;
+    using has_vector = Dune::Std::is_detected<GivenStructure,Value,Traits>;
+    static_assert(supports_blocking_structure::value || has_vector::value,
+      "Vector backend does not support blocking structure. Provide explicit vector type Traits::template Vector<ValueType> instead!");
 
-  namespace Impl
+    using type = Dune::Std::detected_or_t<
+      Dune::Std::detected_t<GivenStructure,Value,Traits>, BlockingStructure,Value,Traits,BlockingTag>;
+  };
+
+  /// \brief Generate a vector container compatible with the blocking structure
+  template <class Value, class Traits, class BlockingTag>
+  using VectorGenerator_t = typename VectorGenerator<Value, Traits, BlockingTag>::type;
+
+
+  template <class Value, class Traits, class RowBlocking, class ColBlocking>
+  struct MatrixGenerator
   {
-    // implementation details of the vector container
-    template <class Value, class Traits, class... T>
-    struct VectorGenerator<Value, Traits, Blocking::Blocked<T...>, std::enable_if_t<not Concepts::Same<T...>> >
-    {
-      using type = typename Traits::template CompositeVector<VectorGenerator_t<Value, Traits, T>...>;
-    };
-
-    template <class Value, class Traits, class T0, class... T>
-    struct VectorGenerator<Value, Traits, Blocking::Blocked<T0,T...>, std::enable_if_t<Concepts::Same<T0,T...>> >
-    {
-      using type = typename Traits::template PowerVector<VectorGenerator_t<Value, Traits, T0>, 1+sizeof...(T)>;
-    };
-
-    template <class Value, class Traits>
-    struct VectorGenerator<Value, Traits, Blocking::Flat>
-    {
-      using type = typename Traits::template FlatVector<Value>;
-    };
-
-    template <class Value, class Traits, std::size_t N>
-    struct VectorGenerator<Value, Traits, Blocking::LeafBlocked<N>>
-    {
-      using type = typename Traits::template LeafBlockVector<Value,N>;
-    };
-
-
-    // implementation details for the matrix-container
-    template <class Value, class Traits, class... S, class... T>
-    struct MatrixGenerator<Value, Traits, Blocking::Blocked<S...>, Blocking::Blocked<T...>,
-      std::enable_if_t<not(Concepts::Same<S...> && Concepts::Same<T...>)> >
-    {
-      template <class Si>
-      using Row = typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, Si, T>...>;
-
-      using type = typename Traits::template CompositeMatrix<Row<S>...>;
-    };
-
-    template <class Value, class Traits, class S0, class... S, class T0, class... T>
-    struct MatrixGenerator<Value, Traits, Blocking::Blocked<S0,S...>, Blocking::Blocked<T0,T...>,
-      std::enable_if_t<Concepts::Same<S0,S...> && Concepts::Same<T0,T...>> >
-    {
-      using type = typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, S0, T0>,
-                                                         1+sizeof...(S), 1+sizeof...(T)>;
-    };
-
-    template <class Value, class Traits>
-    struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::Flat>
-    {
-      using type = typename Traits::template FlatMatrix<Value>;
-    };
-
-    template <class Value, class Traits, std::size_t N, std::size_t M>
-    struct MatrixGenerator<Value, Traits, Blocking::LeafBlocked<N>, Blocking::LeafBlocked<M>>
-    {
-      using type = typename Traits::template LeafBlockMatrix<Value,N,M>;
-    };
-
-    template <class Value, class Traits, std::size_t N>
-    struct MatrixGenerator<Value, Traits, Blocking::LeafBlocked<N>, Blocking::Flat>
-    {
-      using type = typename Traits::template LeafBlockMatrix<Value,N,1>;
-    };
-
-    template <class Value, class Traits, std::size_t M>
-    struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::LeafBlocked<M>>
-    {
-      using type = typename Traits::template LeafBlockMatrix<Value,1,M>;
-    };
-
-    // single column, multi-type rows
-    template <class Value, class Traits, class... T>
-    struct MatrixGenerator<Value, Traits, Blocking::Blocked<T...>, Blocking::Flat, std::enable_if_t<not Concepts::Same<T...>> >
-    {
-      using type = SingleColumnMatrix<
-        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, T, Blocking::Flat>>...>
-        >;
-    };
-
-    // single column, single-type rows
-    template <class Value, class Traits, class T0, class... T>
-    struct MatrixGenerator<Value, Traits, Blocking::Blocked<T0,T...>, Blocking::Flat, std::enable_if_t<Concepts::Same<T0,T...>> >
-    {
-      using type = SingleColumnMatrix<
-        typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, T0, Blocking::Flat>, 1+sizeof...(T),1>
-        >;
-    };
-
-    // single row, multi-type columns
-    template <class Value, class Traits, class... T>
-    struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::Blocked<T...>, std::enable_if_t<not Concepts::Same<T...>> >
-    {
-      using type = SingleRowMatrix<
-        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGenerator_t<Value, Traits, Blocking::Flat, T>...>>
-        >;
-    };
-
-    // single row, single-type columns
-    template <class Value, class Traits, class T0, class... T>
-    struct MatrixGenerator<Value, Traits, Blocking::Flat, Blocking::Blocked<T0,T...>, std::enable_if_t<Concepts::Same<T0,T...>> >
-    {
-      using type = SingleRowMatrix<
-        typename Traits::template PowerMatrix<MatrixGenerator_t<Value, Traits, Blocking::Flat, T0>, 1,1+sizeof...(T)>
-        >;
-    };
+    template <class V, class T, class R, class C>
+    using BlockingStructure = typename Impl::MatrixGeneratorImpl<V,T,R,C>::type;
+
+    template <class V, class T>
+    using GivenStructure = typename T::template Matrix<V>;
+
+    using supports_blocking_structure = Dune::Std::is_detected<BlockingStructure,Value,Traits,RowBlocking,ColBlocking>;
+    using has_matrix = Dune::Std::is_detected<GivenStructure,Value,Traits>;
+    static_assert(supports_blocking_structure::value || has_matrix::value,
+      "Matrix backend does not support blocking structure. Provide explicit matrix type Traits::template Matrix<ValueType> instead!");
+
+    using type = Dune::Std::detected_or_t<
+      Dune::Std::detected_t<GivenStructure,Value,Traits>, BlockingStructure,Value,Traits,RowBlocking,ColBlocking>;
+  };
+
+  /// \brief Generate a matrix container compatible with the blocking structure
+  template <class Value, class Traits, class RowBlocking, class ColBlocking = RowBlocking>
+  using MatrixGenerator_t = typename MatrixGenerator<Value, Traits, RowBlocking, ColBlocking>::type;
 
-  } // end namespace Impl
 } // end namespace AMDiS
+
+#include <amdis/linearalgebra/MatrixVectorGenerator.inc.hpp>
diff --git a/src/amdis/linearalgebra/MatrixVectorGenerator.inc.hpp b/src/amdis/linearalgebra/MatrixVectorGenerator.inc.hpp
new file mode 100644
index 00000000..c34e9bf3
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixVectorGenerator.inc.hpp
@@ -0,0 +1,159 @@
+#pragma once
+
+#include <amdis/common/Concepts.hpp>
+#include <amdis/common/TypeTraits.hpp>
+#include <amdis/functions/Blocking.hpp>
+#include <amdis/linearalgebra/SingleRowColMatrix.hpp>
+
+namespace Dune
+{
+  template <class K, int N>
+  class FieldVector;
+
+  template <class K, int N, int M>
+  class FieldMatrix;
+}
+
+
+namespace AMDiS
+{
+  namespace Impl
+  {
+    template <class Value, class Traits, class BlockingTag, class = void>
+    using VectorGeneratorImpl_t = typename VectorGeneratorImpl<Value,Traits,BlockingTag>::type;
+
+    // implementation details of the vector container
+    template <class Value, class Traits, class... T>
+    struct VectorGeneratorImpl<Value, Traits, Blocking::Blocked<T...>,
+      enable_if_all_t<not Concepts::Same<T...>,
+        is_template<Traits::template CompositeVector>()> >
+    {
+      using type = typename Traits::template CompositeVector<VectorGeneratorImpl_t<Value, Traits, T>...>;
+    };
+
+    template <class Value, class Traits, class T0, class... T>
+    struct VectorGeneratorImpl<Value, Traits, Blocking::Blocked<T0,T...>,
+      enable_if_all_t<Concepts::Same<T0,T...>,
+        is_template<Traits::template PowerVector>()> >
+    {
+      using type = typename Traits::template PowerVector<VectorGeneratorImpl_t<Value, Traits, T0>, 1+sizeof...(T)>;
+    };
+
+    template <class Value, class Traits>
+    struct VectorGeneratorImpl<Value, Traits, Blocking::Flat,
+      void_t<typename Traits::template FlatVector<Value>> >
+    {
+      using type = typename Traits::template FlatVector<Value>;
+    };
+
+    template <class Value, class Traits, std::size_t N>
+    struct VectorGeneratorImpl<Value, Traits, Blocking::LeafBlocked<N>,
+      void_t<typename Traits::template LeafBlockVector<Value,N>> >
+    {
+      using type = typename Traits::template LeafBlockVector<Value,N>;
+    };
+
+
+
+    // implementation details for the matrix-container
+    template <class Value, class Traits, class RowBlocking, class ColBlocking, class = void>
+    using MatrixGeneratorImpl_t = typename MatrixGeneratorImpl<Value,Traits,RowBlocking,ColBlocking>::type;
+
+
+    template <class Value, class Traits, class... S, class... T>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::Blocked<S...>, Blocking::Blocked<T...>,
+      enable_if_all_t<not (Concepts::Same<S...> && Concepts::Same<T...>),
+        is_template<Traits::template CompositeVector>(),
+        is_template<Traits::template CompositeMatrix>()> >
+    {
+      template <class Si>
+      using Row = typename Traits::template CompositeVector<MatrixGeneratorImpl_t<Value, Traits, Si, T>...>;
+
+      using type = typename Traits::template CompositeMatrix<Row<S>...>;
+    };
+
+    template <class Value, class Traits, class S0, class... S, class T0, class... T>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::Blocked<S0,S...>, Blocking::Blocked<T0,T...>,
+      enable_if_all_t<Concepts::Same<S0,S...> && Concepts::Same<T0,T...>,
+        is_template<Traits::template PowerMatrix>()> >
+    {
+      using type = typename Traits::template PowerMatrix<MatrixGeneratorImpl_t<Value, Traits, S0, T0>,
+                                                         1+sizeof...(S), 1+sizeof...(T)>;
+    };
+
+    template <class Value, class Traits>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::Flat, Blocking::Flat,
+      void_t<typename Traits::template FlatMatrix<Value>> >
+    {
+      using type = typename Traits::template FlatMatrix<Value>;
+    };
+
+    template <class Value, class Traits, std::size_t N, std::size_t M>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::LeafBlocked<N>, Blocking::LeafBlocked<M>,
+      void_t<typename Traits::template LeafBlockMatrix<Value,N,M>> >
+    {
+      using type = typename Traits::template LeafBlockMatrix<Value,N,M>;
+    };
+
+    template <class Value, class Traits, std::size_t N>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::LeafBlocked<N>, Blocking::Flat,
+      void_t<typename Traits::template LeafBlockMatrix<Value,N,1>> >
+    {
+      using type = typename Traits::template LeafBlockMatrix<Value,N,1>;
+    };
+
+    template <class Value, class Traits, std::size_t M>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::Flat, Blocking::LeafBlocked<M>,
+      void_t<typename Traits::template LeafBlockMatrix<Value,1,M>> >
+    {
+      using type = typename Traits::template LeafBlockMatrix<Value,1,M>;
+    };
+
+    // single column, multi-type rows
+    template <class Value, class Traits, class... T>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::Blocked<T...>, Blocking::Flat,
+      enable_if_all_t<not Concepts::Same<T...>,
+        is_template<Traits::template CompositeVector>(),
+        is_template<Traits::template CompositeMatrix>()> >
+    {
+      using type = SingleColumnMatrix<
+        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGeneratorImpl_t<Value, Traits, T, Blocking::Flat>>...>
+        >;
+    };
+
+    // single column, single-type rows
+    template <class Value, class Traits, class T0, class... T>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::Blocked<T0,T...>, Blocking::Flat,
+      enable_if_all_t<Concepts::Same<T0,T...>,
+        is_template<Traits::template PowerMatrix>()> >
+    {
+      using type = SingleColumnMatrix<
+        typename Traits::template PowerMatrix<MatrixGeneratorImpl_t<Value, Traits, T0, Blocking::Flat>, 1+sizeof...(T),1>
+        >;
+    };
+
+    // single row, multi-type columns
+    template <class Value, class Traits, class... T>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::Flat, Blocking::Blocked<T...>,
+      enable_if_all_t<not Concepts::Same<T...>,
+        is_template<Traits::template CompositeVector>(),
+        is_template<Traits::template CompositeMatrix>()> >
+    {
+      using type = SingleRowMatrix<
+        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGeneratorImpl_t<Value, Traits, Blocking::Flat, T>...>>
+        >;
+    };
+
+    // single row, single-type columns
+    template <class Value, class Traits, class T0, class... T>
+    struct MatrixGeneratorImpl<Value, Traits, Blocking::Flat, Blocking::Blocked<T0,T...>,
+      enable_if_all_t<Concepts::Same<T0,T...>,
+        is_template<Traits::template PowerMatrix>()> >
+    {
+      using type = SingleRowMatrix<
+        typename Traits::template PowerMatrix<MatrixGeneratorImpl_t<Value, Traits, Blocking::Flat, T0>, 1,1+sizeof...(T)>
+        >;
+    };
+
+  } // end namespace Impl
+} // end namespace AMDiS
diff --git a/test/GeneratorsTest.cpp b/test/GeneratorsTest.cpp
index 916ea843..3242d7fd 100644
--- a/test/GeneratorsTest.cpp
+++ b/test/GeneratorsTest.cpp
@@ -20,6 +20,16 @@ void printType(T const&)
   std::cout << __PRETTY_FUNCTION__ << "\n";
 }
 
+struct MyTraits
+{
+  template <class>
+  using Vector = int;
+  template <class>
+  using Matrix = int;
+};
+
+struct NoTraits {};
+
 template <class GlobalBasis, std::size_t I>
 void test(GlobalBasis const& basis, Dune::index_constant<I>)
 {
@@ -38,6 +48,21 @@ void test(GlobalBasis const& basis, Dune::index_constant<I>)
 
   using Matrix2 = MatrixGenerator_t<double, DefaultMatrixVectorTraits, Blocking, Blocking>;
   printType<Matrix2>();
+
+  using Vector3 = VectorGenerator_t<double, MyTraits, Blocking>;
+  printType<Vector3>();
+
+  using Matrix3 = MatrixGenerator_t<double, MyTraits, Blocking, Blocking>;
+  printType<Matrix3>();
+
+#if 0 
+  // the following code should produce a static_assert
+  using Vector4 = VectorGenerator_t<double, NoTraits, Blocking>;
+  printType<Vector4>();
+
+  using Matrix4 = MatrixGenerator_t<double, NoTraits, Blocking, Blocking>;
+  printType<Matrix4>();
+#endif
 }
 
 int main(int argc, char** argv)
@@ -51,4 +76,4 @@ int main(int argc, char** argv)
   });
 
   return 0;
-}
\ No newline at end of file
+}
-- 
GitLab


From 00400bb12f2b4976453f2e96773cef2fc3480d85 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 10 Apr 2019 11:27:13 +0200
Subject: [PATCH 09/38] MatrixIndexSet wrapped and tests extended

---
 src/amdis/linearalgebra/Common.hpp            | 10 ---
 src/amdis/linearalgebra/DOFMatrixBase.hpp     |  8 +-
 src/amdis/linearalgebra/MatrixIndexSet.hpp    | 86 +++++++++----------
 .../linearalgebra/MatrixVectorGenerator.hpp   | 12 +--
 .../linearalgebra/MatrixVectorTraits.hpp      | 47 +---------
 src/amdis/linearalgebra/MatrixWrapper.hpp     | 28 ++----
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp | 36 ++++----
 .../linearalgebra/SingleRowColMatrix.hpp      | 20 ++---
 src/amdis/linearalgebra/VectorWrapper.hpp     | 37 +++-----
 src/amdis/linearalgebra/VectorWrapper.inc.hpp | 10 +--
 src/amdis/linearalgebra/istl/BCRSMatrix.hpp   | 11 +++
 test/BasisTester.hpp                          | 34 +++++++-
 test/GeneratorsTest.cpp                       | 30 ++++++-
 test/MatrixTest.cpp                           | 44 ++++++----
 test/MatrixWrapperTest.cpp                    |  2 +-
 15 files changed, 200 insertions(+), 215 deletions(-)

diff --git a/src/amdis/linearalgebra/Common.hpp b/src/amdis/linearalgebra/Common.hpp
index cf7e0826..2bd499c6 100644
--- a/src/amdis/linearalgebra/Common.hpp
+++ b/src/amdis/linearalgebra/Common.hpp
@@ -24,16 +24,6 @@ namespace AMDiS
     : int_t<int(B::blocklevel)>
   {};
 
-  // template <class K>
-  // struct BlockLevel<Dune::FieldVector<K,1>,void>
-  //   : int_t<0>
-  // {};
-
-  // template <class K>
-  // struct BlockLevel<Dune::FieldMatrix<K,1,1>,void>
-  //   : int_t<0>
-  // {};
-
   template <class B>
   constexpr int BlockLevel_v = BlockLevel<B>::value;
 
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index 85db1c25..8a6f2894 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -53,14 +53,8 @@ namespace AMDiS
     /// The type of the matrix filled on an element with local contributions
     using ElementMatrix = Dune::DynamicMatrix<value_type>;
 
-    struct MatrixIndexSetTraits : Traits
-    {
-      template <class>
-      using FlatMatrix = AMDiS::MatrixIndexSet;
-    };
-
     using HierarchicMatrixIndexSet
-      = MatrixGenerator_t<size_type,MatrixIndexSetTraits,RowBlocking,ColBlocking>;
+      = MatrixGenerator_t<size_type,MatrixIndexSetTraits<Traits>,RowBlocking,ColBlocking>;
 
   public:
     /// Constructor. Stores the shared_ptr to the bases.
diff --git a/src/amdis/linearalgebra/MatrixIndexSet.hpp b/src/amdis/linearalgebra/MatrixIndexSet.hpp
index 37e55d18..a91f3872 100644
--- a/src/amdis/linearalgebra/MatrixIndexSet.hpp
+++ b/src/amdis/linearalgebra/MatrixIndexSet.hpp
@@ -1,72 +1,66 @@
 #pragma once
 
 #include <dune/istl/matrixindexset.hh>
+#include <amdis/linearalgebra/MatrixWrapper.hpp>
 
 namespace AMDiS
 {
   class MatrixIndexSet
       : public Dune::MatrixIndexSet
   {
-    using Self = MatrixIndexSet;
-    using Super = Dune::MatrixIndexSet;
-
-    struct AdderProxy
-    {
-      void operator =(int) { matrixIndexSet_->add(row_, col_); }
-      void operator+=(int) { matrixIndexSet_->add(row_, col_); }
-
-      Super* matrixIndexSet_;
-      std::size_t row_;
-      std::size_t col_;
-    };
+  public:
+    using Dune::MatrixIndexSet::MatrixIndexSet;
 
-    struct RowProxy
-    {
-      AdderProxy& operator[](std::size_t col)
-      {
-        self_->proxy_.row_ = row_;
-        self_->proxy_.col_ = col;
-        return self_->proxy_;
-      }
+    using size_type = std::size_t;
+    using value_type = std::size_t;
+    using field_type = std::size_t;
 
-      std::size_t operator[](std::size_t /*col*/) const
-      {
-        return 0;
-      }
+    static constexpr int blocklevel = 1;
+  };
 
-      Self const* self_;
-      std::size_t row_;
-    };
+  template <class Traits>
+  struct MatrixIndexSetTraits : Traits
+  {
+    template <class>
+    using FlatMatrix = AMDiS::MatrixIndexSet;
+  };
 
+  template <>
+  class MatrixWrapper<AMDiS::MatrixIndexSet>
+      : public MatrixWrapperBase<MatrixWrapper<AMDiS::MatrixIndexSet>>
+  {
   public:
-    using value_type = std::size_t;
-    MatrixIndexSet()
-      : proxy_{this,0u,0u}
-    {}
-
-    MatrixIndexSet(std::size_t r, std::size_t c)
-      : Super(r,c)
-      , proxy_{this,0u,0u}
+    MatrixWrapper(AMDiS::MatrixIndexSet& matrixIndexSet)
+      : matrixIndexSet_(matrixIndexSet)
     {}
 
-    RowProxy operator[](std::size_t row)
+    /// Resize \ref matrixIndexSet_ to desired size
+    template <class RowSizeInfo, class ColSizeInfo>
+    void resize_impl(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
+                     ColSizeInfo const& colSizeInfo, typename ColSizeInfo::SizePrefix colPrefix)
     {
-      return {this, row};
+      std::size_t rows = rowSizeInfo.size(rowPrefix);
+      std::size_t cols = colSizeInfo.size(colPrefix);
+      assert(rows > 0 && cols > 0);
+      matrixIndexSet_.resize(rows, cols);
     }
 
-    RowProxy operator[](std::size_t row) const
+    template <class MatIndexSet>
+    void init_impl(MatIndexSet const& /*matIndexSet*/, bool /*rebuild*/) {}
+
+    void finish_impl() {}
+
+    template <class Row, std::size_t r, class Col, std::size_t c, class ValueType, class Assigner>
+    void insert_impl(MultiIndexIterator<Row,r> const& row, MultiIndexIterator<Col,c> const& col,
+                     ValueType const& /*value*/, Assigner /*assign*/)
     {
-      return {this, row};
+      matrixIndexSet_.add(*row, *col);
     }
 
-    mutable AdderProxy proxy_;
-  };
+    std::size_t nnz_impl() { return 0; }
 
-  template <class Traits>
-  struct MatrixIndexSetTraits : Traits
-  {
-    template <class>
-    using FlatMatrix = AMDiS::MatrixIndexSet;
+  private:
+    AMDiS::MatrixIndexSet& matrixIndexSet_;
   };
 
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/MatrixVectorGenerator.hpp b/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
index fac84feb..8f530a30 100644
--- a/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
+++ b/src/amdis/linearalgebra/MatrixVectorGenerator.hpp
@@ -22,15 +22,15 @@ namespace AMDiS
     using BlockingStructure = typename Impl::VectorGeneratorImpl<V,T,B>::type;
 
     template <class V, class T>
-    using GivenStructure = typename T::template Vector<V>;
+    using HasVector = typename T::template Vector<V>;
 
     using supports_blocking_structure = Dune::Std::is_detected<BlockingStructure,Value,Traits,BlockingTag>;
-    using has_vector = Dune::Std::is_detected<GivenStructure,Value,Traits>;
+    using has_vector = Dune::Std::is_detected<HasVector,Value,Traits>;
     static_assert(supports_blocking_structure::value || has_vector::value,
       "Vector backend does not support blocking structure. Provide explicit vector type Traits::template Vector<ValueType> instead!");
 
     using type = Dune::Std::detected_or_t<
-      Dune::Std::detected_t<GivenStructure,Value,Traits>, BlockingStructure,Value,Traits,BlockingTag>;
+      Dune::Std::detected_t<HasVector,Value,Traits>, BlockingStructure,Value,Traits,BlockingTag>;
   };
 
   /// \brief Generate a vector container compatible with the blocking structure
@@ -45,15 +45,15 @@ namespace AMDiS
     using BlockingStructure = typename Impl::MatrixGeneratorImpl<V,T,R,C>::type;
 
     template <class V, class T>
-    using GivenStructure = typename T::template Matrix<V>;
+    using HasMatrix = typename T::template Matrix<V>;
 
     using supports_blocking_structure = Dune::Std::is_detected<BlockingStructure,Value,Traits,RowBlocking,ColBlocking>;
-    using has_matrix = Dune::Std::is_detected<GivenStructure,Value,Traits>;
+    using has_matrix = Dune::Std::is_detected<HasMatrix,Value,Traits>;
     static_assert(supports_blocking_structure::value || has_matrix::value,
       "Matrix backend does not support blocking structure. Provide explicit matrix type Traits::template Matrix<ValueType> instead!");
 
     using type = Dune::Std::detected_or_t<
-      Dune::Std::detected_t<GivenStructure,Value,Traits>, BlockingStructure,Value,Traits,RowBlocking,ColBlocking>;
+      Dune::Std::detected_t<HasMatrix,Value,Traits>, BlockingStructure,Value,Traits,RowBlocking,ColBlocking>;
   };
 
   /// \brief Generate a matrix container compatible with the blocking structure
diff --git a/src/amdis/linearalgebra/MatrixVectorTraits.hpp b/src/amdis/linearalgebra/MatrixVectorTraits.hpp
index ecfba32e..ae7ae8cb 100644
--- a/src/amdis/linearalgebra/MatrixVectorTraits.hpp
+++ b/src/amdis/linearalgebra/MatrixVectorTraits.hpp
@@ -33,51 +33,12 @@ namespace AMDiS
 
   } // end namespace Impl
 
-  // template <
-  //   template <class>                            class FlatVectorType,
-  //   template <class>                            class FlatMatrixType,
-  //   template <class, std::size_t>               class PowerVectorType = PowerBlockVector,
-  //   template <class...>                         class CompositeVectorType = CompositeBlockVector,
-  //   template <class, std::size_t, std::size_t>  class PowerMatrixType = PowerBlockMatrix,
-  //   template <class...>                         class CompositeMatrixType = CompositeBlockMatrix,
-  //   template <class, std::size_t>               class LeafBlockVectorType
-  //     = Impl::DefaultLeafBlockVector<FlatVectorType>::template type,
-  //   template <class, std::size_t, std::size_t>  class LeafBlockMatrixType
-  //     = Impl::DefaultLeafBlockMatrix<FlatMatrixType>::template type
-  //   >
-  // struct DefaultMatrixVectorTraits
-  // {
-  //   template <class B, std::size_t N>
-  //   using PowerVector = PowerVectorType<B,N>;
-
-  //   template <class... Rows>
-  //   using CompositeVector = CompositeVectorType<Rows...>;
-
-  //   template <class T>
-  //   using FlatVector = FlatVectorType<T>;
-
-  //   template <class T, std::size_t N>
-  //   using LeafBlockVector = LeafBlockVectorType<T,N>;
-
-  //   template <class B, std::size_t R, std::size_t C>
-  //   using PowerMatrix = PowerMatrixType<B,R,C>;
-
-  //   template <class... Rows>
-  //   using CompositeMatrix = CompositeMatrixType<Rows...>;
-
-  //   template <class T>
-  //   using FlatMatrix = FlatMatrixType<T>;
-
-  //   template <class T, std::size_t R, std::size_t C>
-  //   using LeafBlockMatrix = LeafBlockMatrixType<T,R,C>;
-  // };
-
 
   // specified power-matrix/vector and composite-matrix/vector
   struct DefaultMatrixVectorTraits
   {
     template <class B, std::size_t N>
-    using PowerVector = Dune::DynamicVector<B>; //Dune::FieldVector<B,N>;
+    using PowerVector = Dune::DynamicVector<B>; // Dune::FieldVector<B,N>;
 
     template <class... Rows>
     using CompositeVector = MultiTypeVector<Rows...>;
@@ -89,7 +50,7 @@ namespace AMDiS
     using LeafBlockVector = typename Impl::DefaultLeafBlockVector<FlatVector>::template type<T,N>;
 
     template <class B, std::size_t R, std::size_t C>
-    using PowerMatrix = Dune::DynamicMatrix<B>; //Dune::FieldMatrix<B,R,C>;
+    using PowerMatrix = Dune::DynamicMatrix<B>; // Dune::FieldMatrix<B,R,C>;
 
     template <class... Rows>
     using CompositeMatrix = MultiTypeMatrix<Rows...>;
@@ -123,8 +84,8 @@ namespace AMDiS
     template <class B, std::size_t N>
     using PowerVector = std::array<B,N>;
 
-    template <class... Rows>
-    using CompositeVector = Dune::TupleVector<Rows...>;
+    // template <class... Rows>
+    // using CompositeVector = Dune::TupleVector<Rows...>;
 
     template <class T>
     using FlatVector = std::vector<T>;
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
index 55e08c7a..a38101e3 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -38,34 +38,22 @@ namespace AMDiS
     template <class M>
     using HasStaticMatrixAccess = decltype(std::declval<M>()[index_t<0>{}][index_t<0>{}]);
 
-    template <class M, class = void>
-    struct MatrixWrapperSelector
-    {
-      using type = MatrixWrapperScalarImpl<M>;
-    };
-
-    template <class M>
-    struct MatrixWrapperSelector<M,
-      std::enable_if_t<Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value>>
-    {
-      using type = MatrixWrapperDynamicImpl<M>;
-    };
-
     template <class M>
-    struct MatrixWrapperSelector<M,
-      std::enable_if_t<not Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value && Dune::Std::is_detected<HasStaticMatrixAccess, M>::value>>
-    {
-      using type = MatrixWrapperStaticImpl<M>;
-    };
+    using MatrixWrapperSelector =
+      std::conditional_t<Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value,
+        MatrixWrapperDynamicImpl<M>,
+      std::conditional_t<Dune::Std::is_detected<HasStaticMatrixAccess, M>::value,
+        MatrixWrapperStaticImpl<M>,
+        MatrixWrapperScalarImpl<M> >>;
 
   } // end namespace Impl
 
 
   template <class BaseMatrix>
   class MatrixWrapper
-      : public Impl::MatrixWrapperSelector<BaseMatrix>::type
+      : public Impl::MatrixWrapperSelector<BaseMatrix>
   {
-    using Super = typename Impl::MatrixWrapperSelector<BaseMatrix>::type;
+    using Super = Impl::MatrixWrapperSelector<BaseMatrix>;
 
   public:
     MatrixWrapper(BaseMatrix& matrix)
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index 38a77f89..ef4e357b 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -41,7 +41,7 @@ namespace AMDiS
     /// Return the number of nonzeros in the matrix
     std::size_t nnz_impl() const
     {
-      return 1;
+      return scalar_ != Scalar(0);
     }
 
   private:
@@ -83,8 +83,6 @@ namespace AMDiS
         id(matrix_).resize(rows, cols);
       });
 
-      // NOTE: matrix-resize does not yet work, if blocking-depth is different for different blocks.
-
       // resize all the blocks
       if (BlockLevel<block_type>::value > 0) {
         rowPrefix.push_back(0);
@@ -103,9 +101,11 @@ namespace AMDiS
     template <class MatIndexSet>
     void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
     {
-      for (size_type i = 0; i < matrix_.N(); ++i)
-        for (size_type j = 0; j < matrix_.M(); ++j)
-          matrixWrapper(matrix_[i][j]).init(matrixIndexSet[i][j], rebuild);
+      Dune::Hybrid::ifElse(Dune::Std::is_detected<Impl::HasDynamicMatrixAccess,MatIndexSet>{}, [&](auto id) {
+        for (size_type i = 0; i < matrix_.N(); ++i)
+          for (size_type j = 0; j < matrix_.M(); ++j)
+            matrixWrapper(matrix_[i][j]).init(id(matrixIndexSet)[i][j], rebuild);
+      });
     }
 
     /// Finish the insertion
@@ -123,7 +123,6 @@ namespace AMDiS
       matrixWrapper(matrix_[*row][*col]).insert(++row, ++col, value, assign);
     }
 
-
     /// Return the number of nonzeros in the matrix
     std::size_t nnz_impl() const
     {
@@ -146,10 +145,8 @@ namespace AMDiS
     template <class> friend class MatrixWrapper;
 
   protected:
-    using size_type = typename BaseMatrix::size_type;
-
-    static constexpr size_type rows = BaseMatrix::N();
-    static constexpr size_type cols = BaseMatrix::M();
+    static constexpr std::size_t rows = BaseMatrix::N();
+    static constexpr std::size_t cols = BaseMatrix::M();
 
     enum { DYNAMIC = false };
 
@@ -163,11 +160,8 @@ namespace AMDiS
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
-      DUNE_UNUSED size_type r = rowSize.size(rowPrefix);
-      DUNE_UNUSED size_type c = colSize.size(colPrefix);
-
       // this matrix has fixed size, so check whether it is correct
-      assert(r == rows && c == cols);
+      assert(rowSize.size(rowPrefix) == rows && colSize.size(colPrefix) == cols);
 
       // resize all the blocks
       rowPrefix.push_back(0);
@@ -182,12 +176,14 @@ namespace AMDiS
     }
 
     /// Prepare the matrix for insertion of values
-    template <class MatrixIndexSet>
-    void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    template <class MatIndexSet>
+    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
     {
-      Tools::for_range<0,rows>([&](auto const i) -> void {
-        Tools::for_range<0,cols>([&](auto const j) -> void {
-          matrixWrapper(matrix_[i][j]).init(matrixIndexSet[i][j], rebuild);
+      Dune::Hybrid::ifElse(Dune::Std::is_detected<Impl::HasStaticMatrixAccess,MatIndexSet>{}, [&](auto id) {
+        Tools::for_range<0,rows>([&](auto const i) -> void {
+          Tools::for_range<0,cols>([&](auto const j) -> void {
+            matrixWrapper(matrix_[i][j]).init(id(matrixIndexSet)[i][j], rebuild);
+          });
         });
       });
     }
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index 5eccfd23..63037a9f 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -46,13 +46,13 @@ namespace AMDiS
       : public MatrixWrapperBase<MatrixWrapper<SingleColumnMatrix<Matrix>>>
   {
     using BaseMatrix = SingleColumnMatrix<Matrix>;
-    using Wrapper = typename Impl::MatrixWrapperSelector<Matrix>::type;
+    using Wrapper = Impl::MatrixWrapperSelector<Matrix>;
     using size_type = typename Wrapper::size_type;
     using block_type = typename Wrapper::block_type;
 
   public:
     MatrixWrapper(BaseMatrix& matrix)
-      : wrapper_(static_cast<Matrix&>(matrix))
+      : wrapper_(matrix)
     {}
 
     /// Resize \ref matrix_ to desired size (`rows` x `cols`)
@@ -68,10 +68,8 @@ namespace AMDiS
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
                      std::false_type /* is_not_dynamic */)
     {
-      DUNE_UNUSED size_type r = rowSize.size(rowPrefix);
-
       // this matrix has fixed size, so check whether it is correct
-      assert(r == Wrapper::rows);
+      assert(rowSize.size(rowPrefix) == Wrapper::rows);
 
       // resize all the blocks
       rowPrefix.push_back(0);
@@ -87,10 +85,10 @@ namespace AMDiS
                      std::true_type /* is_dynamic */)
     {
       size_type rows = rowSize.size(rowPrefix);
-      assert(rows > 0);
 
       // resize this matrix
       Dune::Hybrid::ifElse(Dune::Std::is_detected<Wrapper::template HasResize,Matrix>{}, [&](auto id) -> void {
+        assert(rows > 0);
         id(matrix()).resize(rows, 1);
       });
 
@@ -157,13 +155,13 @@ namespace AMDiS
       : public MatrixWrapperBase<MatrixWrapper<SingleRowMatrix<Matrix>>>
   {
     using BaseMatrix = SingleRowMatrix<Matrix>;
-    using Wrapper = typename Impl::MatrixWrapperSelector<Matrix>::type;
+    using Wrapper = Impl::MatrixWrapperSelector<Matrix>;
     using size_type = typename Wrapper::size_type;
     using block_type = typename Wrapper::block_type;
 
   public:
     MatrixWrapper(BaseMatrix& matrix)
-      : wrapper_(static_cast<Matrix&>(matrix))
+      : wrapper_(matrix)
     {}
 
     /// Resize \ref matrix_ to desired size (`rows` x `cols`)
@@ -179,10 +177,8 @@ namespace AMDiS
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
                      std::false_type /* is_not_dynamic */)
     {
-      DUNE_UNUSED size_type c = colSize.size(colPrefix);
-
       // this matrix has fixed size, so check whether it is correct
-      assert(c == Wrapper::cols);
+      assert(colSize.size(colPrefix) == Wrapper::cols);
 
       // resize all the blocks
       colPrefix.push_back(0);
@@ -198,10 +194,10 @@ namespace AMDiS
                      std::true_type /* is_dynamic */)
     {
       size_type cols = colSize.size(colPrefix);
-      assert(cols > 0);
 
       // resize this matrix
       Dune::Hybrid::ifElse(Dune::Std::is_detected<Wrapper::template HasResize,Matrix>{}, [&](auto id) -> void {
+        assert(cols > 0);
         id(matrix()).resize(1, cols);
       });
 
diff --git a/src/amdis/linearalgebra/VectorWrapper.hpp b/src/amdis/linearalgebra/VectorWrapper.hpp
index 51df576b..cae6bd95 100644
--- a/src/amdis/linearalgebra/VectorWrapper.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.hpp
@@ -32,42 +32,27 @@ namespace AMDiS
   namespace Impl
   {
     template <class V>
-    using HasDynamicAccess = decltype(std::declval<V>()[0u]);
+    using HasDynamicVectorAccess = decltype(std::declval<V>()[0u]);
 
     template <class V>
-    using HasStaticAccess = decltype(std::declval<V>()[index_t<0>{}]);
+    using HasStaticVectorAccess = decltype(std::declval<V>()[index_t<0>{}]);
 
-
-    template <class V, class = void>
-    struct VectorWrapperSelector
-    {
-      using type = VectorWrapperScalarImpl<V>;
-    };
-
-    template <class V>
-    struct VectorWrapperSelector<V,
-      std::enable_if_t<Dune::Std::is_detected<HasDynamicAccess, V>::value>>
-      //void_t<decltype(std::declval<V>()[0u], std::declval<V>().resize(1u), std::begin(std::declval<V>()), std::end(std::declval<V>()), 0), typename V::size_type>>
-    {
-      using type = VectorWrapperDynamicImpl<V>;
-    };
-
-    template <class V>
-    struct VectorWrapperSelector<V,
-      std::enable_if_t<not Dune::Std::is_detected<HasDynamicAccess, V>::value && Dune::Std::is_detected<HasStaticAccess, V>::value>>
-      //void_t<decltype(std::declval<V>()[index_t<0>{}], index_t<std::size_t(V::size())>{}, 0), typename V::size_type>>
-    {
-      using type = VectorWrapperStaticImpl<V>;
-    };
+    template <class M>
+    using VectorWrapperSelector =
+      std::conditional_t<Dune::Std::is_detected<HasDynamicVectorAccess, M>::value,
+        VectorWrapperDynamicImpl<M>,
+      std::conditional_t<Dune::Std::is_detected<HasStaticVectorAccess, M>::value,
+        VectorWrapperStaticImpl<M>,
+        VectorWrapperScalarImpl<M> >>;
 
   } // end namespace Impl
 
 
   template <class BaseVector>
   class VectorWrapper
-      : public Impl::VectorWrapperSelector<BaseVector>::type
+      : public Impl::VectorWrapperSelector<BaseVector>
   {
-    using Super = typename Impl::VectorWrapperSelector<BaseVector>::type;
+    using Super = Impl::VectorWrapperSelector<BaseVector>;
 
   public:
     VectorWrapper(BaseVector& vector)
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index b7cde5f6..4aec417c 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -22,8 +22,7 @@ namespace AMDiS
     template <class SizeProvider>
     void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
-      DUNE_UNUSED int size = sizeProvider.size(prefix);
-      assert(size == 0);
+      assert(sizeProvider.size(prefix) == 0);
     }
 
     /// Prepare the vector for insertion of values
@@ -125,9 +124,7 @@ namespace AMDiS
   class VectorWrapperStaticImpl
       : public VectorWrapperBase<VectorWrapperStaticImpl<BaseVector>>
   {
-    using size_type = typename BaseVector::size_type;
-
-    static constexpr size_type dimension = BaseVector::size();
+    static constexpr std::size_t dimension = BaseVector::size();
 
   public:
     VectorWrapperStaticImpl(BaseVector& vector)
@@ -138,8 +135,7 @@ namespace AMDiS
     template <class SizeProvider>
     void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
-      DUNE_UNUSED size_type size = sizeProvider.size(prefix);
-      assert(size == dimension);
+      assert(sizeProvider.size(prefix) == dimension);
 
       // resize blocks
       prefix.push_back(0);
diff --git a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
index 5850eaa3..02ad0b37 100644
--- a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <dune/istl/bcrsmatrix.hh>
+#include <dune/istl/io.hh>
 
 #include <amdis/Output.hpp>
 #include <amdis/common/StaticSize.hpp>
@@ -67,3 +68,13 @@ namespace AMDiS
   };
 
 } // end namespace AMDiS
+
+namespace Dune
+{
+  template <class B, class A>
+  std::ostream& operator<<(std::ostream& out, BCRSMatrix<B,A> const& mat)
+  {
+    printSparseMatrix(out, mat, "", "");
+    return out;
+  }
+}
diff --git a/test/BasisTester.hpp b/test/BasisTester.hpp
index 833d0978..0022a295 100644
--- a/test/BasisTester.hpp
+++ b/test/BasisTester.hpp
@@ -19,7 +19,7 @@ namespace AMDiS
     using GridType = Dune::YaspGrid<dim>;
 
   public:
-    static const std::size_t num_bases = 7;
+    static const std::size_t num_bases = 9;
     static const std::size_t num_false_bases = 1;
 
     TaylorHoodBases()
@@ -134,6 +134,38 @@ namespace AMDiS
         ));
     }
 
+    auto basis(Dune::index_constant<7>) // Root: flatLexicographic, Velocity: flatInterleaved
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          power<dim>(
+            lagrange<K+1>(),
+            flatInterleaved()),
+          lagrange<K>(),
+          flatLexicographic()
+        ));
+    }
+
+    auto basis(Dune::index_constant<8>) // Root: blockedLexicographic, Velocity: blockedLexicographic
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          lagrange<1>(),
+          composite(
+            power<dim>(
+              lagrange<K+1>(),
+              blockedLexicographic()),
+            lagrange<K>(),
+            blockedLexicographic()
+          ),
+          blockedLexicographic()
+        ));
+    }
+
     auto false_basis(Dune::index_constant<0>) // Root: flatLexicographic, Velocity/Pressure: blockedLexicographic
     {
       using namespace Dune::Functions::BasisBuilder;
diff --git a/test/GeneratorsTest.cpp b/test/GeneratorsTest.cpp
index 3242d7fd..2c21ec8e 100644
--- a/test/GeneratorsTest.cpp
+++ b/test/GeneratorsTest.cpp
@@ -30,6 +30,16 @@ struct MyTraits
 
 struct NoTraits {};
 
+struct FlatTraits
+{
+  template <class Value>
+  using FlatVector = std::vector<Value>;
+
+  template <class Value>
+  using FlatMatrix = Dune::DynamicMatrix<Value>;
+};
+
+
 template <class GlobalBasis, std::size_t I>
 void test(GlobalBasis const& basis, Dune::index_constant<I>)
 {
@@ -55,7 +65,7 @@ void test(GlobalBasis const& basis, Dune::index_constant<I>)
   using Matrix3 = MatrixGenerator_t<double, MyTraits, Blocking, Blocking>;
   printType<Matrix3>();
 
-#if 0 
+#if 0
   // the following code should produce a static_assert
   using Vector4 = VectorGenerator_t<double, NoTraits, Blocking>;
   printType<Vector4>();
@@ -65,6 +75,20 @@ void test(GlobalBasis const& basis, Dune::index_constant<I>)
 #endif
 }
 
+template <class GlobalBasis, std::size_t I>
+void test2(GlobalBasis const& basis, Dune::index_constant<I>)
+{
+  std::cout << "flat-basis " << I << ":\n";
+  using Blocking = Blocking_t<GlobalBasis>;
+  printType<Blocking>();
+
+  using Vector1 = VectorGenerator_t<double, FlatTraits, Blocking>;
+  printType<Vector1>();
+
+  using Matrix1 = MatrixGenerator_t<double, FlatTraits, Blocking, Blocking>;
+  printType<Matrix1>();
+}
+
 int main(int argc, char** argv)
 {
   Dune::MPIHelper::instance(argc, argv);
@@ -75,5 +99,9 @@ int main(int argc, char** argv)
     test(tester.basis(_i), _i);
   });
 
+  Tools::for_range(std::index_sequence<4,7>{}, [&tester](auto const _i) {
+    test2(tester.basis(_i), _i);
+  });
+
   return 0;
 }
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index 08b3aae7..e9490307 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -1,4 +1,5 @@
 #include <amdis/AMDiS.hpp>
+#include <amdis/LinearAlgebra.hpp>
 #include <amdis/common/FieldMatVec.hpp>
 #include <amdis/functions/Blocking.hpp>
 #include <amdis/functions/MultiIndex.hpp>
@@ -25,16 +26,16 @@ void printType(T const&)
   std::cout << __PRETTY_FUNCTION__ << "\n";
 }
 
-template <class BasisTester>
+template <class Traits, class BasisTester>
 void test1(BasisTester& tester)
 {
   using namespace Dune::Indices;
   auto taylorHoodBasis = tester.basis(index_t<1>{});
   using GlobalBasis = decltype(taylorHoodBasis);
   using Blocking = Blocking_t<GlobalBasis>;
-  using Matrix = MatrixGenerator_t<double, DefaultMatrixVectorTraits,Blocking,Blocking>;
+  using Matrix = MatrixGenerator_t<double, Traits,Blocking,Blocking>;
   using HierarchicMatrixIndexSet
-    = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<DefaultMatrixVectorTraits>,Blocking,Blocking>;
+    = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<Traits>,Blocking,Blocking>;
 
   Matrix matrix;
   MatrixWrapper<Matrix> wrapper(matrix);
@@ -68,6 +69,8 @@ void test1(BasisTester& tester)
   wrapper.insert(idx11, idx10, 15.0);
   wrapper.insert(idx11, idx11, 16.0);
 
+  AMDIS_TEST_EQ(wrapper.nnz(), 16u);
+
   AMDIS_TEST_EQ(matrix[0][0][0][0], 1.0);
   AMDIS_TEST_EQ(matrix[0][0][0][1], 2.0);
   AMDIS_TEST_EQ(matrix[0][1][0][0], 3.0);
@@ -94,16 +97,16 @@ void test1(BasisTester& tester)
   std::cout << matrix[1][1] << "\n";
 }
 
-template <class BasisTester>
+template <class Traits, class BasisTester>
 void test2(BasisTester& tester)
 {
   using namespace Dune::Indices;
   auto taylorHoodBasis = tester.basis(index_t<2>{});
   using GlobalBasis = decltype(taylorHoodBasis);
   using Blocking = Blocking_t<GlobalBasis>;
-  using Matrix = MatrixGenerator_t<double, DefaultMatrixVectorTraits,Blocking,Blocking>;
+  using Matrix = MatrixGenerator_t<double, Traits,Blocking,Blocking>;
   using HierarchicMatrixIndexSet
-    = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<DefaultMatrixVectorTraits>,Blocking,Blocking>;
+    = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<Traits>,Blocking,Blocking>;
 
   Matrix matrix;
   MatrixWrapper<Matrix> wrapper(matrix);
@@ -135,16 +138,16 @@ void test2(BasisTester& tester)
   std::cout << matrix[_1][_1] << "\n";
 }
 
-template <class BasisTester>
+template <class Traits, class BasisTester>
 void test5(BasisTester& tester)
 {
   using namespace Dune::Indices;
   auto taylorHoodBasis = tester.basis(index_t<5>{});
   using GlobalBasis = decltype(taylorHoodBasis);
   using Blocking = Blocking_t<GlobalBasis>;
-  using Matrix = MatrixGenerator_t<double, DefaultMatrixVectorTraits,Blocking,Blocking>;
+  using Matrix = MatrixGenerator_t<double, Traits,Blocking,Blocking>;
   using HierarchicMatrixIndexSet
-    = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<DefaultMatrixVectorTraits>,Blocking,Blocking>;
+    = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<Traits>,Blocking,Blocking>;
 
   Matrix matrix;
   MatrixWrapper<Matrix> wrapper(matrix);
@@ -181,12 +184,23 @@ int main(int argc, char** argv)
   AMDiS::init(argc, argv);
 
   TaylorHoodBases<2> tester{};
-  test1(tester);
-  test2(tester);
-  // test3(tester);
-  // test4(tester);
-  test5(tester);
-  // test6(tester);
+
+  auto traits = std::make_tuple(DefaultMatrixVectorTraits{}, StdTraits{}, ISTLTraits{}
+#if HAVE_MTL
+    , MTLTraits{}
+#endif
+    );
+
+  Tools::for_each(traits, [&](auto t) {
+    using Traits = TYPEOF(t);
+
+    test1<Traits>(tester);
+    test2<Traits>(tester);
+    // test3<Traits>(tester);
+    // test4<Traits>(tester);
+    test5<Traits>(tester);
+    // test6<Traits>(tester);
+  });
 
   return AMDiS::report_errors();
 }
\ No newline at end of file
diff --git a/test/MatrixWrapperTest.cpp b/test/MatrixWrapperTest.cpp
index 992e826c..c9508ca5 100644
--- a/test/MatrixWrapperTest.cpp
+++ b/test/MatrixWrapperTest.cpp
@@ -101,5 +101,5 @@ int main(int argc, char** argv)
   Wrapper2Impl wrapper2;
 
   foo(wrapper1);
-  //foo(wrapper2);
+  //foo(wrapper2); // should not compile
 }
-- 
GitLab


From 21f863ffc89b74830c22c21e205e6bcd325b9420 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Thu, 11 Apr 2019 18:15:39 +0200
Subject: [PATCH 10/38] Add matrix-inserter for inserting values and preparing
 the non-zero structure

---
 src/amdis/DirichletBC.hpp                     |  11 +-
 src/amdis/DirichletBC.inc.hpp                 |  21 +-
 src/amdis/ProblemStat.inc.hpp                 |   4 +-
 src/amdis/functions/MultiIndex.hpp            |   4 +-
 src/amdis/linearalgebra/CMakeLists.txt        |   3 +
 src/amdis/linearalgebra/Constraints.hpp       |  13 +-
 src/amdis/linearalgebra/DOFMatrixBase.hpp     |  19 +-
 src/amdis/linearalgebra/DOFMatrixBase.inc.hpp |   9 +-
 src/amdis/linearalgebra/MatrixIndexSet.hpp    |  36 +--
 src/amdis/linearalgebra/MatrixInserter.hpp    |  60 +++++
 .../linearalgebra/MatrixInserter.inc.hpp      | 177 ++++++++++++++
 .../linearalgebra/MatrixInserterBase.hpp      |  55 +++++
 src/amdis/linearalgebra/MatrixWrapper.hpp     |  30 +--
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp | 117 +++-------
 src/amdis/linearalgebra/MatrixWrapperBase.hpp |  37 ++-
 .../linearalgebra/SingleRowColMatrix.hpp      | 220 +++++++++++++-----
 src/amdis/linearalgebra/VectorWrapper.hpp     |  26 ++-
 src/amdis/linearalgebra/VectorWrapper.inc.hpp |  12 +-
 src/amdis/linearalgebra/istl/BCRSMatrix.hpp   |  54 +++--
 src/amdis/linearalgebra/istl/Constraints.hpp  |  21 +-
 src/amdis/linearalgebra/mtl/MtlMatrix.hpp     |  90 +++++--
 test/MatrixTest.cpp                           | 146 +++++++-----
 22 files changed, 820 insertions(+), 345 deletions(-)
 create mode 100644 src/amdis/linearalgebra/MatrixInserter.hpp
 create mode 100644 src/amdis/linearalgebra/MatrixInserter.inc.hpp
 create mode 100644 src/amdis/linearalgebra/MatrixInserterBase.hpp

diff --git a/src/amdis/DirichletBC.hpp b/src/amdis/DirichletBC.hpp
index c097c9bd..e5710855 100644
--- a/src/amdis/DirichletBC.hpp
+++ b/src/amdis/DirichletBC.hpp
@@ -10,6 +10,8 @@
 #include <amdis/Boundary.hpp>
 #include <amdis/BoundaryCondition.hpp>
 #include <amdis/common/Concepts.hpp>
+#include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
+#include <amdis/linearalgebra/MatrixVectorTraits.hpp>
 #include <amdis/typetree/RangeType.hpp>
 #include <amdis/typetree/Traversal.hpp>
 #include <amdis/typetree/TreeData.hpp>
@@ -31,12 +33,15 @@ namespace AMDiS
    * support this symmetric modification. As a result, this method returns a list
    * of columns values, that should be subtracted from the rhs.
    **/
-  template <class Domain, class Range = double>
+  template <class Domain, class Range, class MultiIndex>
   class DirichletBC
       : public BoundaryCondition
   {
     using Super = BoundaryCondition;
 
+    template <class Blocking>
+    using BitVector = VectorGenerator_t<bool, StdTraits, Blocking>;
+
   public:
     template <class BM, class Values,
       REQUIRES(Concepts::Functor<Values, Range(Domain)>) >
@@ -79,7 +84,7 @@ namespace AMDiS
   private:
     Dune::Std::optional<std::function<bool(Domain)>> predicate_;
     std::function<Range(Domain)> values_;
-    std::vector<bool> dirichletNodes_;
+    std::vector<MultiIndex> dirichletNodes_;
   };
 
 
@@ -89,7 +94,7 @@ namespace AMDiS
     using WorldVector = typename Basis::GridView::template Codim<0>::Geometry::GlobalCoordinate;
 
     template <class RN, class CN>
-    using type = std::list< std::shared_ptr<DirichletBC<WorldVector, RangeType_t<RN>>> >;
+    using type = std::list< std::shared_ptr<DirichletBC<WorldVector, RangeType_t<RN>, typename Basis::MultiIndex>> >;
   };
 
   template <class RowBasis, class ColBasis>
diff --git a/src/amdis/DirichletBC.inc.hpp b/src/amdis/DirichletBC.inc.hpp
index 6f285d24..53dc3013 100644
--- a/src/amdis/DirichletBC.inc.hpp
+++ b/src/amdis/DirichletBC.inc.hpp
@@ -11,32 +11,37 @@
 
 namespace AMDiS {
 
-template <class D, class R>
+template <class D, class R, class MI>
   template <class RB, class CB>
-void DirichletBC<D,R>::
+void DirichletBC<D,R,MI>::
 init(RB const& rowBasis, CB const& colBasis)
 {
   using Dune::Functions::forEachBoundaryDOF;
   using LV = typename CB::LocalView;
   using IS = typename CB::GridView::Intersection;
-  dirichletNodes_.resize(colBasis.dimension());
+  dirichletNodes_.clear();
   forEachBoundaryDOF(colBasis, [&](int localIndex, LV const& localView, IS const& intersection) {
-    dirichletNodes_[localView.index(localIndex)] = onBoundary(intersection);
+    if (onBoundary(intersection))
+      dirichletNodes_.push_back(localView.index(localIndex));
   });
 }
 
 
-template <class D, class R>
+template <class D, class R, class MI>
   template <class Mat, class Sol, class Rhs, class RN, class RTP, class CN, class CTP>
-void DirichletBC<D,R>::
+void DirichletBC<D,R,MI>::
 fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, RTP rowTreePath, CN const& colNode, CTP colTreePath)
 {
+  BitVector<typename Mat::RowBlocking> bitVector;
+  for (auto const& node : dirichletNodes_)
+    bitVector[node] = true;
+
   auto columns = Constraints<Mat>::dirichletBC(matrix, dirichletNodes_);
 
   Dune::Hybrid::ifElse(std::is_same<RangeType_t<RN>, R>{},
     [&](auto id) {
       auto subBasis = Dune::Functions::subspaceBasis(*rhs.basis(), rowTreePath);
-      Dune::Functions::interpolate(subBasis, rhs, values_, dirichletNodes_);
+      Dune::Functions::interpolate(subBasis, rhs, values_, bitVector);
     });
 
   // subtract columns of dirichlet nodes from rhs
@@ -46,7 +51,7 @@ fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, R
   Dune::Hybrid::ifElse(std::is_same<RangeType_t<CN>, R>{},
     [&](auto id) {
       auto subBasis = Dune::Functions::subspaceBasis(*solution.basis(), colTreePath);
-      Dune::Functions::interpolate(subBasis, solution, values_, dirichletNodes_);
+      Dune::Functions::interpolate(subBasis, solution, values_, bitVector);
     });
 }
 
diff --git a/src/amdis/ProblemStat.inc.hpp b/src/amdis/ProblemStat.inc.hpp
index a6db2d44..797b7c0e 100644
--- a/src/amdis/ProblemStat.inc.hpp
+++ b/src/amdis/ProblemStat.inc.hpp
@@ -259,7 +259,7 @@ addDirichletBC(Predicate const& predicate, RowTreePath row, ColTreePath col, Val
   auto valueGridFct = makeGridFunction(values, globalBasis_->gridView());
 
   using Range = RangeType_t<decltype(i)>;
-  using BcType = DirichletBC<WorldVector,Range>;
+  using BcType = DirichletBC<WorldVector,Range,typename GlobalBasis::MultiIndex>;
   auto bc = std::make_unique<BcType>(predicate, valueGridFct);
   dirichletBCs_[i][j].push_back(std::move(bc));
 }
@@ -278,7 +278,7 @@ addDirichletBC(BoundaryType id, RowTreePath row, ColTreePath col, Values const&
   auto valueGridFct = makeGridFunction(values, globalBasis_->gridView());
 
   using Range = RangeType_t<decltype(i)>;
-  using BcType = DirichletBC<WorldVector,Range>;
+  using BcType = DirichletBC<WorldVector,Range,typename GlobalBasis::MultiIndex>;
   auto bc = std::make_unique<BcType>(boundaryManager_, id, valueGridFct);
   dirichletBCs_[i][j].push_back(std::move(bc));
 }
diff --git a/src/amdis/functions/MultiIndex.hpp b/src/amdis/functions/MultiIndex.hpp
index 252e4da3..1f819785 100644
--- a/src/amdis/functions/MultiIndex.hpp
+++ b/src/amdis/functions/MultiIndex.hpp
@@ -34,9 +34,7 @@ namespace AMDiS
     /// Obtain the current index
     constexpr size_type operator*() const
     {
-      // static_assert(shift < MultiIndex::max_size());
-      assert(shift < multiIndex_.size());
-      return shift < multiIndex_.max_size() ? multiIndex_[shift] : size_type(0);
+      return shift < multiIndex_.size() ? multiIndex_[shift] : size_type(0);
     }
 
     // Go to next entry in MultiIndex
diff --git a/src/amdis/linearalgebra/CMakeLists.txt b/src/amdis/linearalgebra/CMakeLists.txt
index a607ed3c..c04e37e0 100644
--- a/src/amdis/linearalgebra/CMakeLists.txt
+++ b/src/amdis/linearalgebra/CMakeLists.txt
@@ -9,6 +9,9 @@ install(FILES
     LinearSolver.hpp
     LinearSolverInterface.hpp
     MatrixIndexSet.hpp
+    MatrixInserter.hpp
+    MatrixInserter.inc.hpp
+    MatrixInserterBase.hpp
     MatrixVectorGenerator.hpp
     MatrixVectorGenerator.inc.hpp
     MatrixVectorTraits.hpp
diff --git a/src/amdis/linearalgebra/Constraints.hpp b/src/amdis/linearalgebra/Constraints.hpp
index 56dc261b..d717171f 100644
--- a/src/amdis/linearalgebra/Constraints.hpp
+++ b/src/amdis/linearalgebra/Constraints.hpp
@@ -8,8 +8,8 @@ namespace AMDiS
   template <class Matrix, class MultiIndex = void>
   struct Constraints
   {
-    template <class BitVec>
-    static auto dirichletBC(Matrix& matrix, BitVec const& nodes, bool setDiagonal = true)
+    template <class DOFs>
+    static auto dirichletBC(Matrix& matrix, DOFs const& dofs, bool setDiagonal = true)
     {
       /* do nothing */
       return std::array<Triplet<MultiIndex,typename Matrix::value_type>,0>{};
@@ -29,10 +29,13 @@ namespace AMDiS
     using Matrix = DOFMatrixBase<RB,CB,T,VT>;
     using MultiIndex = typename RB::MultiIndex;
 
-    template <class BitVec>
-    static auto dirichletBC(Matrix& matrix, BitVec const& nodes, bool setDiagonal = true)
+    static auto dirichletBC(Matrix& matrix, std::vector<typename RB::MultiIndex> const& dofs, bool setDiagonal = true)
     {
-      return Constraints<typename Matrix::BaseMatrix,MultiIndex>::dirichletBC(matrix.matrix(), nodes, setDiagonal);
+      for (auto const& mi : dofs)
+        matrixWrapper(matrix.matrix()).clear_row(mi, setDiagonal);
+
+      return std::array<Triplet<MultiIndex,typename Matrix::field_type>,0>{};
+      // return Constraints<typename Matrix::BaseMatrix,MultiIndex>::dirichletBC(matrix.matrix(), dofs, setDiagonal);
     }
 
     template <class BitVec, class Assoc>
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index 8a6f2894..601c1b5c 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -7,6 +7,7 @@
 #include <amdis/functions/Blocking.hpp>
 #include <amdis/functions/MultiIndex.hpp>
 #include <amdis/linearalgebra/MatrixIndexSet.hpp>
+#include <amdis/linearalgebra/MatrixInserter.hpp>
 #include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
 #include <amdis/linearalgebra/MatrixWrapper.hpp>
 #include <amdis/operations/Assigner.hpp>
@@ -27,9 +28,6 @@ namespace AMDiS
   template <class RB, class CB, class Traits, class K = double>
   class DOFMatrixBase
   {
-    using RowBlocking = Blocking_t<RB>;
-    using ColBlocking = Blocking_t<CB>;
-
   public:
     /// The type of the finite element space / basis of the row
     using RowBasis = RB;
@@ -47,8 +45,12 @@ namespace AMDiS
     using field_type = typename Dune::FieldTraits<K>::field_type;
     using value_type = K;
 
+    using RowBlocking = Blocking_t<RB>;
+    using ColBlocking = Blocking_t<CB>;
+
     /// The type of the data matrix used in the backend
     using BaseMatrix = MatrixGenerator_t<K,Traits,RowBlocking,ColBlocking>;
+    using Inserter = MatrixInserter<BaseMatrix>;
 
     /// The type of the matrix filled on an element with local contributions
     using ElementMatrix = Dune::DynamicMatrix<value_type>;
@@ -114,7 +116,10 @@ namespace AMDiS
     /// Finish the matrix insertion, e.g. cleanup or final insertion
     void finish()
     {
-      matrixWrapper(matrix_).finish();
+      assert(inserter_ != nullptr);
+      inserter_->finish();
+      delete inserter_;
+      inserter_ = nullptr;
     }
 
     /// Insert a block of values into the matrix (add to existing values)
@@ -127,7 +132,8 @@ namespace AMDiS
     template <class RowIndex, class ColIndex>
     void insert(RowIndex row, ColIndex col, field_type const& value)
     {
-      matrixWrapper(matrix_).insert(row, col, value);
+      assert(inserter_ != nullptr);
+      inserter_->insert(row, col, value);
     }
 
     /// \brief Associate a local operator with this DOFMatrix
@@ -177,6 +183,9 @@ namespace AMDiS
     /// Data backend
     BaseMatrix matrix_;
 
+    // Wrapper for value insertion into the matrix
+    Inserter* inserter_ = nullptr;
+
     /// Dense matrix to store coefficients during \ref assemble()
     ElementMatrix elementMatrix_;
 
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
index 34632c05..cf9c5d11 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
@@ -18,7 +18,7 @@ init(bool rebuild)
   elementMatrix_.resize(rowLocalView.maxSize(), colLocalView.maxSize());
 
   if (rebuild) {
-    auto matIndexSet = matrixWrapper(matrixIndexSet_);
+    auto matIndexSet = matrixInserter(matrixIndexSet_);
 
     // provide maximal sparsity pattern for whole matrix
     for (const auto& e : elements(rowBasis_->gridView()))
@@ -52,7 +52,8 @@ init(bool rebuild)
   }
 
   // assign sub-pattern to matrix blocks
-  matrixWrapper(matrix_).init(matrixIndexSet_, rebuild);
+  inserter_ = new Inserter(matrix_);
+  inserter_->init(matrixIndexSet_, rebuild);
 }
 
 
@@ -62,13 +63,13 @@ insert(RowLocalView const& rowLocalView, ColLocalView const& colLocalView,
        ElementMatrix const& elementMatrix)
 {
   using std::abs;
-  MatrixWrapper<BaseMatrix> wrapper(matrix_);
+  assert(inserter_ != nullptr);
   for (size_type i = 0; i < rowLocalView.size(); ++i) {
     auto const row = rowLocalView.index(i);
     for (size_type j = 0; j < colLocalView.size(); ++j) {
       if (abs(elementMatrix[i][j]) > threshold<double>) {
         auto const col = colLocalView.index(j);
-        wrapper.insert(row, col, elementMatrix[i][j]);
+        inserter_->insert(row, col, elementMatrix[i][j]);
       }
     }
   }
diff --git a/src/amdis/linearalgebra/MatrixIndexSet.hpp b/src/amdis/linearalgebra/MatrixIndexSet.hpp
index a91f3872..a123743e 100644
--- a/src/amdis/linearalgebra/MatrixIndexSet.hpp
+++ b/src/amdis/linearalgebra/MatrixIndexSet.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <dune/istl/matrixindexset.hh>
+#include <amdis/linearalgebra/MatrixInserter.hpp>
 #include <amdis/linearalgebra/MatrixWrapper.hpp>
 
 namespace AMDiS
@@ -25,6 +26,27 @@ namespace AMDiS
     using FlatMatrix = AMDiS::MatrixIndexSet;
   };
 
+  template <>
+  class MatrixInserter<AMDiS::MatrixIndexSet>
+      : public MatrixInserterBase<MatrixInserter<AMDiS::MatrixIndexSet>>
+  {
+  public:
+    MatrixInserter(AMDiS::MatrixIndexSet& matrixIndexSet)
+      : matrixIndexSet_(matrixIndexSet)
+    {}
+
+    template <class Row, std::size_t r, class Col, std::size_t c, class ValueType, class Assigner>
+    void insert_impl(MultiIndexIterator<Row,r> const& row, MultiIndexIterator<Col,c> const& col,
+                     ValueType const& /*value*/, Assigner /*assign*/)
+    {
+      matrixIndexSet_.add(*row, *col);
+    }
+
+  private:
+    AMDiS::MatrixIndexSet& matrixIndexSet_;
+  };
+
+
   template <>
   class MatrixWrapper<AMDiS::MatrixIndexSet>
       : public MatrixWrapperBase<MatrixWrapper<AMDiS::MatrixIndexSet>>
@@ -45,20 +67,6 @@ namespace AMDiS
       matrixIndexSet_.resize(rows, cols);
     }
 
-    template <class MatIndexSet>
-    void init_impl(MatIndexSet const& /*matIndexSet*/, bool /*rebuild*/) {}
-
-    void finish_impl() {}
-
-    template <class Row, std::size_t r, class Col, std::size_t c, class ValueType, class Assigner>
-    void insert_impl(MultiIndexIterator<Row,r> const& row, MultiIndexIterator<Col,c> const& col,
-                     ValueType const& /*value*/, Assigner /*assign*/)
-    {
-      matrixIndexSet_.add(*row, *col);
-    }
-
-    std::size_t nnz_impl() { return 0; }
-
   private:
     AMDiS::MatrixIndexSet& matrixIndexSet_;
   };
diff --git a/src/amdis/linearalgebra/MatrixInserter.hpp b/src/amdis/linearalgebra/MatrixInserter.hpp
new file mode 100644
index 00000000..a86e87d6
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixInserter.hpp
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <cassert>
+#include <type_traits>
+
+#include <amdis/common/Access.hpp>
+#include <amdis/common/FieldMatVec.hpp>
+#include <amdis/common/Index.hpp>
+#include <amdis/linearalgebra/MatrixInserterBase.hpp>
+
+namespace AMDiS
+{
+  template <class BaseMatrix>
+  class MatrixInserter;
+
+  template <class BaseMatrix>
+  MatrixInserter<BaseMatrix> matrixInserter(BaseMatrix& matrix)
+  {
+    return {matrix};
+  }
+
+
+  template <class Scalar>
+  class MatrixInserterScalarImpl;
+
+  template <class BaseMatrix>
+  class MatrixInserterDynamicImpl;
+
+  template <class BaseMatrix>
+  class MatrixInserterStaticImpl;
+
+  namespace Impl
+  {
+    template <class M>
+    using MatrixInserterSelector =
+      std::conditional_t<Dune::MatVec::IsScalarMatrix<M>::value,
+        MatrixInserterScalarImpl<M>,
+      std::conditional_t<Concepts::MatrixAccessible_t<M,std::size_t,std::size_t>::value,
+        MatrixInserterDynamicImpl<M>,
+      std::conditional_t<Concepts::MatrixAccessible_t<M,index_t<0>,index_t<0>>::value,
+        MatrixInserterStaticImpl<M>,
+        MatrixInserterScalarImpl<M> >>>;
+
+  } // end namespace Impl
+
+  template <class BaseMatrix>
+  class MatrixInserter
+      : public Impl::MatrixInserterSelector<BaseMatrix>
+  {
+    using Super = Impl::MatrixInserterSelector<BaseMatrix>;
+
+  public:
+    MatrixInserter(BaseMatrix& matrix)
+      : Super(matrix)
+    {}
+  };
+
+} // end namespace AMDiS
+
+#include <amdis/linearalgebra/MatrixInserter.inc.hpp>
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
new file mode 100644
index 00000000..a71d92c6
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -0,0 +1,177 @@
+#pragma once
+
+#include <cassert>
+#include <vector>
+
+#include <dune/common/tuplevector.hh>
+
+#include <amdis/Output.hpp>
+#include <amdis/common/Access.hpp>
+#include <amdis/common/ForEach.hpp>
+#include <amdis/linearalgebra/Common.hpp>
+
+namespace AMDiS
+{
+  template <class Scalar>
+  class MatrixInserterScalarImpl
+      : public MatrixInserterBase<MatrixInserterScalarImpl<Scalar>>
+  {
+    template <class> friend class MatrixInserter;
+
+  public:
+    MatrixInserterScalarImpl(Scalar& scalar)
+      : scalar_(scalar)
+    {}
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    {
+      assert(*row == 0u && *col == 0u);
+      assign(value, scalar_);
+    }
+
+  protected:
+    template <class I, class J>
+    auto& inserter(I const& i, J const& j) { return scalar_; }
+
+  private:
+    Scalar& scalar_;
+  };
+
+
+  template <class BaseMatrix>
+  class MatrixInserterDynamicImpl
+      : public MatrixInserterBase<MatrixInserterDynamicImpl<BaseMatrix>>
+  {
+    template <class> friend class MatrixInserter;
+
+  protected:
+    using size_type = typename BaseMatrix::size_type;
+    using block_type = typename BlockType<BaseMatrix>::type;
+
+    using Inserter = std::vector<MatrixInserter<block_type>>;
+
+    enum { DYNAMIC = true };
+
+  public:
+    MatrixInserterDynamicImpl(BaseMatrix& matrix)
+      : rows_(matrix.N())
+      , cols_(matrix.M())
+    {
+      for (size_type i = 0; i < rows_; ++i)
+        for (size_type j = 0; j < cols_; ++j)
+          inserter_.emplace_back(access(matrix,i,j));
+    }
+
+    /// Prepare the matrix for insertion of values
+    template <class MatIndexSet>
+    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      for (size_type i = 0; i < rows_; ++i)
+        for (size_type j = 0; j < cols_; ++j)
+          inserter(i,j).init(access(matrixIndexSet,i,j), rebuild);
+    }
+
+    /// Finish the insertion
+    void finish_impl()
+    {
+      for (auto& ins : inserter_)
+        ins.finish();
+    }
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    {
+      inserter(*row,*col).insert(++row, ++col, value, assign);
+    }
+
+    auto& inserter(size_type i, size_type j) { return inserter_[i*cols_ + j]; }
+
+  protected:
+    Inserter inserter_;
+    size_type rows_;
+    size_type cols_;
+  };
+
+
+  template <class BaseMatrix>
+  class MatrixInserterStaticImpl
+      : public MatrixInserterBase<MatrixInserterStaticImpl<BaseMatrix>>
+  {
+    template <class> friend class MatrixInserter;
+
+  protected:
+    static constexpr std::size_t rows = BaseMatrix::N();
+    static constexpr std::size_t cols = BaseMatrix::M();
+
+    template <class Cols>
+    static auto create_cols(Cols& col)
+    {
+      return Tools::apply_indices<cols>([&](auto const... c) {
+        return Dune::makeTupleVector(matrixInserter(col[c])...);
+      });
+    }
+
+    template <class Rows>
+    static auto create(Rows& row)
+    {
+      return Tools::apply_indices<rows>([&](auto const... r) {
+        return Dune::makeTupleVector(create_cols(row[r])...);
+      });
+    }
+
+    using Inserter = TYPEOF(create(std::declval<BaseMatrix&>()));
+
+    enum { DYNAMIC = false };
+
+  public:
+    MatrixInserterStaticImpl(BaseMatrix& matrix)
+      : inserter_(create(matrix))
+    {}
+
+    /// Prepare the matrix for insertion of values
+    template <class MatIndexSet>
+    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      Tools::for_range<0,rows>([&](auto const i) -> void {
+        Tools::for_range<0,cols>([&](auto const j) -> void {
+          inserter(i,j).init(access(matrixIndexSet,i,j), rebuild);
+        });
+      });
+    }
+
+    /// Finish the insertion
+    void finish_impl()
+    {
+      Tools::for_range<0,rows>([&](auto const i) -> void {
+        Tools::for_range<0,cols>([&](auto const j) -> void {
+          inserter(i,j).finish();
+        });
+      });
+    }
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    {
+      auto next_row = ++row;
+      auto next_col = ++col;
+      Tools::for_range<0,rows>([&](auto const i) -> void {
+        if (std::size_t(i) == *row)
+          Tools::for_range<0,cols>([&](auto const j) -> void {
+            if (std::size_t(j) == *col)
+              inserter(i,j).insert(next_row, next_col, value, assign);
+          });
+      });
+    }
+
+    template <class I, class J>
+    auto& inserter(I const& i, J const& j) { return access(inserter_,i,j); }
+
+  protected:
+    Inserter inserter_;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/MatrixInserterBase.hpp b/src/amdis/linearalgebra/MatrixInserterBase.hpp
new file mode 100644
index 00000000..115f4675
--- /dev/null
+++ b/src/amdis/linearalgebra/MatrixInserterBase.hpp
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <type_traits>
+
+#include <amdis/functions/MultiIndex.hpp>
+#include <amdis/operations/Assigner.hpp>
+
+namespace AMDiS
+{
+  template <class Impl>
+  class MatrixInserterBase
+  {
+  public:
+    /// Prepare the matrix for insertion of values
+    template <class MatrixIndexSet>
+    void init(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      asImpl().init_impl(matrixIndexSet, rebuild);
+    }
+
+    /// Finish the insertion
+    void finish()
+    {
+      asImpl().finish_impl();
+    }
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType>
+    void insert(Row const& row, Col const& col, ValueType const& value)
+    {
+      asImpl().insert_impl(multiIndexIterator(row), multiIndexIterator(col), value, Assigner::plus_assign{});
+    }
+
+    template <class Row, std::size_t r, class Col, std::size_t c, class ValueType, class Assigner>
+    void insert(MultiIndexIterator<Row,r> const& row, MultiIndexIterator<Col,c> const& col, ValueType const& value, Assigner assign)
+    {
+      asImpl().insert_impl(row, col, value, assign);
+    }
+
+  protected: // default implementation:
+
+    template <class... Args>
+    void init_impl(Args&&...) { /* do nothing */ }
+
+    void finish_impl() { /* do nothing */ }
+
+    template <class... Args>
+    void insert_impl(Args&&...) { /* do nothing */ }
+
+  private:
+    Impl const& asImpl() const { return static_cast<Impl const&>(*this); }
+    Impl& asImpl() { return static_cast<Impl&>(*this); }
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
index a38101e3..29a8bc3e 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -4,7 +4,8 @@
 
 #include <dune/common/std/type_traits.hh>
 
-#include <amdis/common/ConceptsBase.hpp>
+#include <amdis/common/Access.hpp>
+#include <amdis/common/FieldMatVec.hpp>
 #include <amdis/common/Index.hpp>
 #include <amdis/linearalgebra/Common.hpp>
 #include <amdis/linearalgebra/MatrixWrapperBase.hpp>
@@ -20,35 +21,24 @@ namespace AMDiS
     return {matrix};
   }
 
-
-  template <class Scalar>
-  class MatrixWrapperScalarImpl;
-
-  template <class BaseMatrix>
-  class MatrixWrapperDynamicImpl;
-
-  template <class BaseMatrix>
-  class MatrixWrapperStaticImpl;
+  template <class Scalar> class MatrixWrapperScalarImpl;
+  template <class BaseMatrix> class MatrixWrapperDynamicImpl;
+  template <class BaseMatrix> class MatrixWrapperStaticImpl;
 
   namespace Impl
   {
-    template <class M>
-    using HasDynamicMatrixAccess = decltype(std::declval<M>()[0u][0u]);
-
-    template <class M>
-    using HasStaticMatrixAccess = decltype(std::declval<M>()[index_t<0>{}][index_t<0>{}]);
-
     template <class M>
     using MatrixWrapperSelector =
-      std::conditional_t<Dune::Std::is_detected<HasDynamicMatrixAccess, M>::value,
+      std::conditional_t<Dune::MatVec::IsScalarMatrix<M>::value,
+        MatrixWrapperScalarImpl<M>,
+      std::conditional_t<Concepts::MatrixAccessible_t<M,std::size_t,std::size_t>::value,
         MatrixWrapperDynamicImpl<M>,
-      std::conditional_t<Dune::Std::is_detected<HasStaticMatrixAccess, M>::value,
+      std::conditional_t<Concepts::MatrixAccessible_t<M,index_t<0>,index_t<0>>::value,
         MatrixWrapperStaticImpl<M>,
-        MatrixWrapperScalarImpl<M> >>;
+        MatrixWrapperScalarImpl<M> >>>;
 
   } // end namespace Impl
 
-
   template <class BaseMatrix>
   class MatrixWrapper
       : public Impl::MatrixWrapperSelector<BaseMatrix>
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index ef4e357b..e0c7adf0 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -3,7 +3,9 @@
 #include <cassert>
 
 #include <amdis/Output.hpp>
+#include <amdis/common/Access.hpp>
 #include <amdis/common/ForEach.hpp>
+#include <amdis/common/Resize.hpp>
 #include <amdis/linearalgebra/Common.hpp>
 
 namespace AMDiS
@@ -19,23 +21,10 @@ namespace AMDiS
       : scalar_(scalar)
     {}
 
-    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
-    template <class RowSize, class ColSize>
-    void resize_impl(RowSize const& /*rowSize*/, typename RowSize::SizePrefix /*rowPrefix*/,
-                     ColSize const& /*colSize*/, typename ColSize::SizePrefix /*colPrefix*/) {}
-
-    /// Prepare the matrix for insertion of values
-    template <class MatIndexSet>
-    void init_impl(MatIndexSet const& /*matrixIndexSet*/, bool /*rebuild*/ = true) {}
-
-    /// Finish the insertion
-    void finish_impl() {}
-
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl(Row const& /*row*/, Col const& /*col*/, ValueType const& value, Assigner assign)
+    template <class RowIter>
+    void clear_row_impl(RowIter const& /*row*/, bool setDiagonal)
     {
-      assign(value, scalar_);
+      scalar_ = setDiagonal ? Scalar(1) : Scalar(0);
     }
 
     /// Return the number of nonzeros in the matrix
@@ -44,6 +33,13 @@ namespace AMDiS
       return scalar_ != Scalar(0);
     }
 
+  protected:
+    template <class I, class J>
+    auto const& wrapper(I const& i, J const& j) const { return scalar_; }
+
+    template <class I, class J>
+    auto& wrapper(I const& i, J const& j) { return scalar_; }
+
   private:
     Scalar& scalar_;
   };
@@ -61,9 +57,6 @@ namespace AMDiS
 
     enum { DYNAMIC = true };
 
-    template <class M>
-    using HasResize = decltype(std::declval<M>().resize(0u, 0u),0);
-
   public:
     MatrixWrapperDynamicImpl(BaseMatrix& matrix)
       : matrix_(matrix)
@@ -78,9 +71,9 @@ namespace AMDiS
       size_type cols = colSize.size(colPrefix);
 
       // resize this matrix
-      Dune::Hybrid::ifElse(Dune::Std::is_detected<HasResize,BaseMatrix>{}, [&](auto id) -> void {
+      Dune::Hybrid::ifElse(Concepts::MatrixResizable_t<BaseMatrix>{}, [&](auto id) -> void {
         assert(rows > 0 && cols > 0);
-        id(matrix_).resize(rows, cols);
+        resize(id(matrix_), rows, cols);
       });
 
       // resize all the blocks
@@ -91,36 +84,18 @@ namespace AMDiS
           rowPrefix.back() = i;
           for (size_type j = 0; j < cols; ++j) {
             colPrefix.back() = j;
-            matrixWrapper(matrix_[i][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
+            wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
           }
         }
       }
     }
 
-    /// Prepare the matrix for insertion of values
-    template <class MatIndexSet>
-    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
-    {
-      Dune::Hybrid::ifElse(Dune::Std::is_detected<Impl::HasDynamicMatrixAccess,MatIndexSet>{}, [&](auto id) {
-        for (size_type i = 0; i < matrix_.N(); ++i)
-          for (size_type j = 0; j < matrix_.M(); ++j)
-            matrixWrapper(matrix_[i][j]).init(id(matrixIndexSet)[i][j], rebuild);
-      });
-    }
-
-    /// Finish the insertion
-    void finish_impl()
-    {
-      for (size_type i = 0; i < matrix_.N(); ++i)
-        for (size_type j = 0; j < matrix_.M(); ++j)
-          matrixWrapper(matrix_[i][j]).finish();
-    }
-
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    template <class RowIter>
+    void clear_row_impl(RowIter const& row, bool setDiagonal)
     {
-      matrixWrapper(matrix_[*row][*col]).insert(++row, ++col, value, assign);
+      size_type i = *row;
+      for (size_type j = 0; j < matrix_.M(); ++j)
+        wrapper(i,j).clear_row(++row, setDiagonal && i==j);
     }
 
     /// Return the number of nonzeros in the matrix
@@ -129,10 +104,14 @@ namespace AMDiS
       std::size_t num_nonzeros = 0;
       for (size_type i = 0; i < matrix_.N(); ++i)
         for (size_type j = 0; j < matrix_.M(); ++j)
-          num_nonzeros += matrixWrapper(matrix_[i][j]).nnz();
+          num_nonzeros += wrapper(i,j).nnz();
       return num_nonzeros;
     }
 
+  protected:
+    auto wrapper(size_type i, size_type j) const { return matrixWrapper(access(matrix_,i,j)); }
+    auto wrapper(size_type i, size_type j) { return matrixWrapper(access(matrix_,i,j)); }
+
   protected:
     BaseMatrix& matrix_;
   };
@@ -155,7 +134,6 @@ namespace AMDiS
       : matrix_(matrix)
     {}
 
-    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
     template <class RowSize, class ColSize>
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
@@ -170,62 +148,41 @@ namespace AMDiS
         rowPrefix.back() = i;
         Tools::for_range<0,cols>([&](auto const j) -> void {
           colPrefix.back() = j;
-          matrixWrapper(matrix_[i][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
-        });
-      });
-    }
-
-    /// Prepare the matrix for insertion of values
-    template <class MatIndexSet>
-    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
-    {
-      Dune::Hybrid::ifElse(Dune::Std::is_detected<Impl::HasStaticMatrixAccess,MatIndexSet>{}, [&](auto id) {
-        Tools::for_range<0,rows>([&](auto const i) -> void {
-          Tools::for_range<0,cols>([&](auto const j) -> void {
-            matrixWrapper(matrix_[i][j]).init(id(matrixIndexSet)[i][j], rebuild);
-          });
-        });
-      });
-    }
-
-    /// Finish the insertion
-    void finish_impl()
-    {
-      Tools::for_range<0,rows>([&](auto const i) -> void {
-        Tools::for_range<0,cols>([&](auto const j) -> void {
-          matrixWrapper(matrix_[i][j]).finish();
+          wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
         });
       });
     }
 
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    template <class RowIter>
+    void clear_row_impl(RowIter const& row, bool setDiagonal)
     {
       auto next_row = ++row;
-      auto next_col = ++col;
       Tools::for_range<0,rows>([&](auto const i) -> void {
         if (std::size_t(i) == *row)
           Tools::for_range<0,cols>([&](auto const j) -> void {
-            if (std::size_t(j) == *col)
-              matrixWrapper(matrix_[i][j]).insert(next_row, next_col, value, assign);
+            wrapper(i,j).clear_row(next_row, setDiagonal && i==j);
           });
       });
     }
 
-
-    /// Return the number of nonzeros in the matrix
     std::size_t nnz_impl() const
     {
       std::size_t num_nonzeros = 0;
       Tools::for_range<0,rows>([&](auto const i) -> void {
         Tools::for_range<0,cols>([&](auto const j) -> void {
-          num_nonzeros += matrixWrapper(matrix_[i][j]).nnz();
+          num_nonzeros += wrapper(i,j).nnz();
         });
       });
       return num_nonzeros;
     }
 
+  protected:
+    template <class I, class J>
+    auto wrapper(I const& i, J const& j) const { return matrixWrapper(access(matrix_,i,j)); }
+
+    template <class I, class J>
+    auto wrapper(I const& i, J const& j) { return matrixWrapper(access(matrix_,i,j)); }
+
   protected:
     BaseMatrix& matrix_;
   };
diff --git a/src/amdis/linearalgebra/MatrixWrapperBase.hpp b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
index a8e22fb1..09015de6 100644
--- a/src/amdis/linearalgebra/MatrixWrapperBase.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
@@ -28,30 +28,17 @@ namespace AMDiS
       asImpl().resize_impl(rowSizeInfo, rowPrefix, colSizeInfo, colPrefix);
     }
 
-    /// Prepare the matrix for insertion of values
-    template <class MatrixIndexSet>
-    void init(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    /// Eliminate a row in the matrix given by a multiIndex. Optionally set the diagonal entry to 1
+    template <class Row>
+    void clear_row(Row const& row, bool setDiagonal)
     {
-      asImpl().init_impl(matrixIndexSet, rebuild);
+      asImpl().clear_row_impl(multiIndexIterator(row), setDiagonal);
     }
 
-    /// Finish the insertion
-    void finish()
+    template <class Row, std::size_t r>
+    void clear_row(MultiIndexIterator<Row,r> const& row_iter, bool setDiagonal)
     {
-      asImpl().finish_impl();
-    }
-
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
-    template <class Row, class Col, class ValueType>
-    void insert(Row const& row, Col const& col, ValueType const& value)
-    {
-      asImpl().insert_impl(multiIndexIterator(row), multiIndexIterator(col), value, Assigner::plus_assign{});
-    }
-
-    template <class Row, std::size_t r, class Col, std::size_t c, class ValueType, class Assigner>
-    void insert(MultiIndexIterator<Row,r> const& row, MultiIndexIterator<Col,c> const& col, ValueType const& value, Assigner assign)
-    {
-      asImpl().insert_impl(row, col, value, assign);
+      asImpl().clear_row_impl(row_iter, setDiagonal);
     }
 
     /// Return the number of nonzeros in the matrix
@@ -60,6 +47,16 @@ namespace AMDiS
       return asImpl().nnz_impl();
     }
 
+  protected: // default implementation:
+
+    template <class... Args>
+    void resize_impl(Args&&...) { /* do nothing */ }
+
+    template <class... Args>
+    void clear_row_impl(Args&&...) { /* do nothing */ }
+
+    std::size_t nnz_impl() { return 0; }
+
   private:
     Impl const& asImpl() const { return static_cast<Impl const&>(*this); }
     Impl& asImpl() { return static_cast<Impl&>(*this); }
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index 63037a9f..de94739a 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <amdis/linearalgebra/MatrixInserter.hpp>
 #include <amdis/linearalgebra/MatrixWrapper.hpp>
 
 namespace AMDiS
@@ -41,6 +42,61 @@ namespace Dune
 
 namespace AMDiS
 {
+  template <class Matrix>
+  class MatrixInserter<SingleColumnMatrix<Matrix>>
+      : public MatrixInserterBase<MatrixInserter<SingleColumnMatrix<Matrix>>>
+  {
+    using BaseMatrix = SingleColumnMatrix<Matrix>;
+    using Inserter = Impl::MatrixInserterSelector<Matrix>;
+
+  public:
+    MatrixInserter(BaseMatrix& matrix)
+      : inserter_(matrix)
+    {}
+
+    template <class MatIndexSet>
+    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      inserter_.init(matrixIndexSet, rebuild);
+    }
+
+    void finish_impl()
+    {
+      inserter_.finish();
+    }
+
+    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+    {
+      insert_impl2(row, col, value, assign, bool_t<bool(Inserter::DYNAMIC)>{});
+    }
+
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
+    {
+      auto next_row = ++row;
+      Tools::for_range<0,Inserter::rows>([&](auto const i) -> void {
+        if (std::size_t(i) == *row)
+          inserter(i,index_t<0>{}).insert(next_row, col, value, assign);
+      });
+    }
+
+    template <class Row, class Col, class ValueType, class Assigner>
+    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
+    {
+      inserter(*row,0).insert(++row, col, value, assign);
+    }
+
+  protected:
+    template <class I, class J>
+    auto& inserter(I const& i, J const& j) { return inserter_.inserter(i,j); }
+
+  private:
+    Inserter inserter_;
+  };
+
+
   template <class Matrix>
   class MatrixWrapper<SingleColumnMatrix<Matrix>>
       : public MatrixWrapperBase<MatrixWrapper<SingleColumnMatrix<Matrix>>>
@@ -65,8 +121,8 @@ namespace AMDiS
 
     template <class RowSize, class ColSize>
     void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
-                     std::false_type /* is_not_dynamic */)
+                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
+                      std::false_type /* is_not_dynamic */)
     {
       // this matrix has fixed size, so check whether it is correct
       assert(rowSize.size(rowPrefix) == Wrapper::rows);
@@ -75,21 +131,21 @@ namespace AMDiS
       rowPrefix.push_back(0);
       Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
         rowPrefix.back() = i;
-        matrixWrapper(matrix()[i][index_t<0>{}]).resize(rowSize, rowPrefix, colSize, colPrefix);
+        wrapper(i,index_t<0>{}).resize(rowSize, rowPrefix, colSize, colPrefix);
       });
     }
 
     template <class RowSize, class ColSize>
     void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
-                     std::true_type /* is_dynamic */)
+                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
+                      std::true_type /* is_dynamic */)
     {
       size_type rows = rowSize.size(rowPrefix);
 
       // resize this matrix
-      Dune::Hybrid::ifElse(Dune::Std::is_detected<Wrapper::template HasResize,Matrix>{}, [&](auto id) -> void {
+      Dune::Hybrid::ifElse(Concepts::MatrixResizable_t<Matrix>{}, [&](auto id) -> void {
         assert(rows > 0);
-        id(matrix()).resize(rows, 1);
+        resize(id(wrapper_.matrix_), rows, 1);
       });
 
       // resize all the blocks
@@ -97,59 +153,107 @@ namespace AMDiS
         rowPrefix.push_back(0);
         for (size_type i = 0; i < rows; ++i) {
           rowPrefix.back() = i;
-          matrixWrapper(matrix()[i][0]).resize(rowSize, rowPrefix, colSize, colPrefix);
+          wrapper(i,0).resize(rowSize, rowPrefix, colSize, colPrefix);
         }
       }
     }
 
-    template <class MatrixIndexSet>
-    void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    template <class RowIter>
+    void clear_row_impl(RowIter const& row, bool setDiagonal)
+    {
+      clear_row_impl2(row, setDiagonal, bool_t<bool(Wrapper::DYNAMIC)>{});
+    }
+
+    template <class RowIter>
+    void clear_row_impl2(RowIter const& row, bool setDiagonal, std::false_type)
     {
-      wrapper_.init(matrixIndexSet, rebuild);
+      auto next_row = ++row;
+      Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
+        if (std::size_t(i) == *row)
+          wrapper(i,index_t<0>{}).clear_row(next_row, setDiagonal && size_type(*row)==size_type(0));
+      });
+    }
+
+    template <class RowIter>
+    void clear_row_impl2(RowIter const& row, bool setDiagonal, std::true_type)
+    {
+      wrapper(*row,0).clear_row(++row, setDiagonal && size_type(*row)==size_type(0));
+    }
+
+    std::size_t nnz_impl()
+    {
+      return wrapper_.nnz();
+    }
+
+  protected:
+    template <class I, class J>
+    auto wrapper(I const& i, J const& j) const { return wrapper_.wrapper(i,j); }
+
+    template <class I, class J>
+    auto wrapper(I const& i, J const& j) { return wrapper_.wrapper(i,j); }
+
+  private:
+    Wrapper wrapper_;
+  };
+
+
+  // ---------------------------------------------------------------------------
+
+
+  template <class Matrix>
+  class MatrixInserter<SingleRowMatrix<Matrix>>
+      : public MatrixInserterBase<MatrixInserter<SingleRowMatrix<Matrix>>>
+  {
+    using BaseMatrix = SingleRowMatrix<Matrix>;
+    using Inserter = Impl::MatrixInserterSelector<Matrix>;
+
+  public:
+    MatrixInserter(BaseMatrix& matrix)
+      : inserter_(matrix)
+    {}
+
+    template <class MatIndexSet>
+    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
+    {
+      inserter_.init(matrixIndexSet, rebuild);
     }
 
     void finish_impl()
     {
-      wrapper_.finish();
+      inserter_.finish();
     }
 
     /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      insert_impl2(row, col, value, assign, bool_t<bool(Wrapper::DYNAMIC)>{});
+      insert_impl2(row, col, value, assign, bool_t<bool(Inserter::DYNAMIC)>{});
     }
 
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
     {
-      auto next_row = ++row;
-      Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
-        if (std::size_t(i) == *row)
-          matrixWrapper(matrix()[i][index_t<0>{}]).insert(next_row, col, value, assign);
+      auto next_col = ++col;
+      Tools::for_range<0,Inserter::cols>([&](auto const j) -> void {
+        if (std::size_t(j) == *col)
+          inserter(index_t<0>{},j).insert(row, next_col, value, assign);
       });
     }
 
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
     {
-      matrixWrapper(matrix()[*row][0]).insert(++row, col, value, assign);
+      inserter(0,*col).insert(row, ++col, value, assign);
     }
 
-    std::size_t nnz_impl()
-    {
-      return wrapper_.nnz();
-    }
+  protected:
+    template <class I, class J>
+    auto& inserter(I const& i, J const& j) { return inserter_.inserter(i,j); }
 
   private:
-    Matrix const& matrix() const { return wrapper_.matrix_; }
-    Matrix& matrix() { return wrapper_.matrix_; }
-
-  private:
-    Wrapper wrapper_;
+    Inserter inserter_;
   };
 
-
   template <class Matrix>
   class MatrixWrapper<SingleRowMatrix<Matrix>>
       : public MatrixWrapperBase<MatrixWrapper<SingleRowMatrix<Matrix>>>
@@ -174,8 +278,8 @@ namespace AMDiS
 
     template <class RowSize, class ColSize>
     void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
-                     std::false_type /* is_not_dynamic */)
+                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
+                      std::false_type /* is_not_dynamic */)
     {
       // this matrix has fixed size, so check whether it is correct
       assert(colSize.size(colPrefix) == Wrapper::cols);
@@ -184,21 +288,21 @@ namespace AMDiS
       colPrefix.push_back(0);
       Tools::for_range<0,Wrapper::cols>([&](auto const j) -> void {
         colPrefix.back() = j;
-        matrixWrapper(matrix()[index_t<0>{}][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
+        wrapper(index_t<0>{},j).resize(rowSize, rowPrefix, colSize, colPrefix);
       });
     }
 
     template <class RowSize, class ColSize>
     void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
-                     std::true_type /* is_dynamic */)
+                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
+                      std::true_type /* is_dynamic */)
     {
       size_type cols = colSize.size(colPrefix);
 
       // resize this matrix
-      Dune::Hybrid::ifElse(Dune::Std::is_detected<Wrapper::template HasResize,Matrix>{}, [&](auto id) -> void {
+      Dune::Hybrid::ifElse(Concepts::MatrixResizable_t<Matrix>{}, [&](auto id) -> void {
         assert(cols > 0);
-        id(matrix()).resize(1, cols);
+        resize(id(wrapper_.matrix_), 1, cols);
       });
 
       // resize all the blocks
@@ -206,43 +310,32 @@ namespace AMDiS
         colPrefix.push_back(0);
         for (size_type j = 0; j < cols; ++j) {
           colPrefix.back() = j;
-          matrixWrapper(matrix()[0][j]).resize(rowSize, rowPrefix, colSize, colPrefix);
+          wrapper(0,j).resize(rowSize, rowPrefix, colSize, colPrefix);
         }
       }
     }
 
-    template <class MatrixIndexSet>
-    void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild)
+    template <class RowIter>
+    void clear_row_impl(RowIter const& row, bool setDiagonal)
     {
-      wrapper_.init(matrixIndexSet, rebuild);
+      clear_row_impl2(row, setDiagonal, bool_t<bool(Wrapper::DYNAMIC)>{});
     }
 
-    void finish_impl()
+    template <class RowIter>
+    void clear_row_impl2(RowIter const& row, bool setDiagonal, std::false_type)
     {
-      wrapper_.finish();
-    }
-
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
-    {
-      insert_impl2(row, col, value, assign, bool_t<bool(Wrapper::DYNAMIC)>{});
-    }
-
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
-    {
-      auto next_col = ++col;
+      assert(std::size_t(*row) == 0);
       Tools::for_range<0,Wrapper::cols>([&](auto const j) -> void {
-        if (std::size_t(j) == *col)
-          matrixWrapper(matrix()[index_t<0>{}][j]).insert(row, next_col, value, assign);
+        wrapper(index_t<0>{},j).clear_row(row, setDiagonal && size_type(j)==size_type(0));
       });
     }
 
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
+    template <class RowIter>
+    void clear_row_impl2(RowIter const& row, bool setDiagonal, std::true_type)
     {
-      matrixWrapper(matrix()[0][*col]).insert(row, ++col, value, assign);
+      assert(std::size_t(*row) == 0);
+      for (size_type j = 0; j < wrapper_.matrix_.M(); ++j)
+        wrapper(0,j).clear_row(row, setDiagonal && j==size_type(0));
     }
 
     std::size_t nnz_impl()
@@ -250,9 +343,12 @@ namespace AMDiS
       return wrapper_.nnz();
     }
 
-  private:
-    Matrix const& matrix() const { return wrapper_.matrix_; }
-    Matrix& matrix() { return wrapper_.matrix_; }
+  protected:
+    template <class I, class J>
+    auto wrapper(I const& i, J const& j) const { return wrapper_.wrapper(i,j); }
+
+    template <class I, class J>
+    auto wrapper(I const& i, J const& j) { return wrapper_.wrapper(i,j); }
 
   private:
     Wrapper wrapper_;
diff --git a/src/amdis/linearalgebra/VectorWrapper.hpp b/src/amdis/linearalgebra/VectorWrapper.hpp
index cae6bd95..b1da8f39 100644
--- a/src/amdis/linearalgebra/VectorWrapper.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.hpp
@@ -4,7 +4,7 @@
 
 #include <dune/common/std/type_traits.hh>
 
-#include <amdis/common/ConceptsBase.hpp>
+#include <amdis/common/Access.hpp>
 #include <amdis/common/Index.hpp>
 #include <amdis/linearalgebra/VectorWrapperBase.hpp>
 
@@ -32,18 +32,24 @@ namespace AMDiS
   namespace Impl
   {
     template <class V>
-    using HasDynamicVectorAccess = decltype(std::declval<V>()[0u]);
+    struct IsScalarVector
+    {
+      template <class K, class = std::enable_if_t<Dune::IsNumber<K>::value>>
+      static std::int16_t test(Dune::FieldVector<K,1> const&);
+      static std::int8_t test(...);
 
-    template <class V>
-    using HasStaticVectorAccess = decltype(std::declval<V>()[index_t<0>{}]);
+      static constexpr bool value = sizeof(decltype(test(std::declval<V>()))) == sizeof(std::int16_t);
+    };
 
-    template <class M>
+    template <class V>
     using VectorWrapperSelector =
-      std::conditional_t<Dune::Std::is_detected<HasDynamicVectorAccess, M>::value,
-        VectorWrapperDynamicImpl<M>,
-      std::conditional_t<Dune::Std::is_detected<HasStaticVectorAccess, M>::value,
-        VectorWrapperStaticImpl<M>,
-        VectorWrapperScalarImpl<M> >>;
+      std::conditional_t<IsScalarVector<V>::value,
+        VectorWrapperScalarImpl<V>,
+      std::conditional_t<Concepts::VectorAccessible_t<V,std::size_t>::value,
+        VectorWrapperDynamicImpl<V>,
+      std::conditional_t<Concepts::VectorAccessible_t<V,index_t<0>>::value,
+        VectorWrapperStaticImpl<V>,
+        VectorWrapperScalarImpl<V> >>>;
 
   } // end namespace Impl
 
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index 4aec417c..209b6ad6 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -72,9 +72,9 @@ namespace AMDiS
       size_type size = sizeProvider.size(prefix);
 
       // resize this vector
-      Dune::Hybrid::ifElse(Dune::Std::is_detected<HasResize,BaseVector>{}, [&](auto id) -> void {
+      Dune::Hybrid::ifElse(Concepts::VectorResizable_t<BaseVector>{}, [&](auto id) -> void {
         assert(size > 0);
-        id(vector_).resize(size);
+        resize(id(vector_), size);
       });
 
       // resize all the blocks
@@ -82,7 +82,7 @@ namespace AMDiS
         prefix.push_back(0);
         for (size_type i = 0; i < size; ++i) {
           prefix.back() = i;
-          vectorWrapper(vector_[i]).resize(sizeProvider, prefix);
+          vectorWrapper(access(vector_,i)).resize(sizeProvider, prefix);
         }
       }
     }
@@ -105,7 +105,7 @@ namespace AMDiS
     template <class Index, class ValueType, class Assigner>
     void insert_impl(Index const& mi, ValueType const& value, Assigner assign)
     {
-      vectorWrapper(vector_[*mi]).insert(++mi, value, assign);
+      vectorWrapper(access(vector_,*mi)).insert(++mi, value, assign);
     }
 
     /// Set all entries to value
@@ -141,7 +141,7 @@ namespace AMDiS
       prefix.push_back(0);
       Tools::for_range<0,dimension>([&](auto const i) -> void {
         prefix.back() = i;
-        vectorWrapper(vector_[i]).resize(sizeProvider, prefix);
+        vectorWrapper(access(vector_,i)).resize(sizeProvider, prefix);
       });
     }
 
@@ -168,7 +168,7 @@ namespace AMDiS
       auto next = ++index;
       Tools::for_range<0,dimension>([&](auto const i) -> void {
         if (std::size_t(i) == *index)
-          vectorWrapper(vector_[i]).insert(next, value, assign);
+          vectorWrapper(access(vector_,i)).insert(next, value, assign);
       });
     }
 
diff --git a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
index 02ad0b37..d1bf06d0 100644
--- a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
@@ -12,26 +12,18 @@
 namespace AMDiS
 {
   template <class B, class A>
-  class MatrixWrapper<Dune::BCRSMatrix<B,A>>
-      : public MatrixWrapperBase<MatrixWrapper<Dune::BCRSMatrix<B,A>>>
+  class MatrixInserter<Dune::BCRSMatrix<B,A>>
+      : public MatrixInserterBase<MatrixInserter<Dune::BCRSMatrix<B,A>>>
   {
     using BaseMatrix = Dune::BCRSMatrix<B,A>;
     using size_type = typename BaseMatrix::size_type;
 
   public:
     /// Constructor. Constructs new BaseVector.
-    MatrixWrapper(BaseMatrix& matrix)
+    MatrixInserter(BaseMatrix& matrix)
       : matrix_(matrix)
     {}
 
-    template <class RowSize, class ColSize>
-    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
-    {
-      // bcrs matrix is not resized directly, but using the init() method
-      // and a matrixIndexSet.
-    }
-
     /// create occupation pattern and apply it to the matrix
     template <class MatIndexSet>
     void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
@@ -49,12 +41,45 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
+      assert(initialized_);
       size_type r = *row;
       size_type c = *col;
-      test_exit_dbg( initialized_, "Occupation pattern not initialized!");
       test_exit_dbg( r < matrix_.N() && c < matrix_.M() ,
           "Indices out of range [0,{})x[0,{})", matrix_.N(), matrix_.M() );
-      matrixWrapper(matrix_[r][c]).insert(++row, ++col, value, assign);
+      matrixInserter(matrix_[r][c]).insert(++row, ++col, value, assign);
+    }
+
+  private:
+    BaseMatrix& matrix_;
+    bool initialized_ = false;
+  };
+
+
+  template <class B, class A>
+  class MatrixWrapper<Dune::BCRSMatrix<B,A>>
+      : public MatrixWrapperBase<MatrixWrapper<Dune::BCRSMatrix<B,A>>>
+  {
+    using BaseMatrix = Dune::BCRSMatrix<B,A>;
+    using size_type = typename BaseMatrix::size_type;
+
+  public:
+    /// Constructor. Constructs new BaseVector.
+    MatrixWrapper(BaseMatrix& matrix)
+      : matrix_(matrix)
+    {}
+
+    template <class RowIter>
+    void clear_row_impl(RowIter const& row, bool setDiagonal)
+    {
+      size_type i = *row;
+      auto cIt = matrix_[i].begin();
+      auto cEndIt = matrix_[i].end();
+      // loop over nonzero matrix entries in current row
+      for (; cIt != cEndIt; ++cIt)
+        matrixWrapper(*cIt).clear_row(++row, setDiagonal && i == cIt.index());
+
+      test_exit(!setDiagonal || matrix_.exists(i,i),
+        "Can not set DirichletBC since diagonal entry does not exist.");
     }
 
     std::size_t nnz_impl() const
@@ -64,7 +89,6 @@ namespace AMDiS
 
   private:
     BaseMatrix& matrix_;
-    bool initialized_ = false;
   };
 
 } // end namespace AMDiS
@@ -74,7 +98,7 @@ namespace Dune
   template <class B, class A>
   std::ostream& operator<<(std::ostream& out, BCRSMatrix<B,A> const& mat)
   {
-    printSparseMatrix(out, mat, "", "");
+    printmatrix(out, mat, "", "");
     return out;
   }
 }
diff --git a/src/amdis/linearalgebra/istl/Constraints.hpp b/src/amdis/linearalgebra/istl/Constraints.hpp
index 6948fa39..fe5c2217 100644
--- a/src/amdis/linearalgebra/istl/Constraints.hpp
+++ b/src/amdis/linearalgebra/istl/Constraints.hpp
@@ -14,18 +14,17 @@ namespace AMDiS
   {
     using Matrix = Dune::BCRSMatrix<T,A>;
 
-    template <class BitVector>
-    static std::vector<Triplet<MultiIndex,T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
+    template <class DOFs>
+    static std::vector<Triplet<MultiIndex,T>> dirichletBC(Matrix& mat, DOFs const& dofs, bool setDiagonal = true)
     {
-      // loop over the matrix rows
-      for (std::size_t i = 0; i < mat.N(); ++i) {
-        if (nodes[i]) {
-          auto cIt = mat[i].begin();
-          auto cEndIt = mat[i].end();
-          // loop over nonzero matrix entries in current row
-          for (; cIt != cEndIt; ++cIt)
-            *cIt = (setDiagonal && i == cIt.index() ? T(1) : T(0));
-        }
+      // loop over the dirichlet DOFs
+      for (auto const& dof : dofs) {
+        std::size_t i = *dof;
+        auto cIt = mat[i].begin();
+        auto cEndIt = mat[i].end();
+        // loop over nonzero matrix entries in current row
+        for (; cIt != cEndIt; ++cIt)
+          *cIt = (setDiagonal && i == cIt.index() ? T(1) : T(0));
       }
 
       return {};
diff --git a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
index 6b73d34e..ab8c214e 100644
--- a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
@@ -11,10 +11,8 @@
 
 namespace AMDiS
 {
-  /// \brief The basic container that stores a base matrix
   template <class Elt, class Parameters>
-  class MatrixWrapper<mtl::compressed2D<Elt, Parameters>>
-      : public MatrixWrapperBase<MatrixWrapper<mtl::compressed2D<Elt, Parameters>>>
+  class MatrixInserter
   {
   public:
     /// The matrix type of the underlying base matrix
@@ -31,22 +29,18 @@ namespace AMDiS
 
   public:
     /// Constructor. Stores a pointer to the passed BaseMatrix
-    MatrixWrapper(BaseMatrix& matrix)
+    MatrixInserter(BaseMatrix& matrix)
       : matrix_(matrix)
     {}
 
-    template <class RowSize, class ColSize>
-    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    ~MatrixInserter()
     {
-      size_type rows = rowSize.size(rowPrefix);
-      size_type cols = colSize.size(colPrefix);
-      assert(rows > 0 && cols > 0);
-      matrix_.change_dim(rows, cols);
+      delete inserter_;
     }
 
     /// Create inserter. Assumes that no inserter is currently active on this matrix.
-    void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild = true)
+    template <class MatIndexSet>
+    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild = true)
     {
       test_exit(!inserter_, "Matrix already in insertion mode!");
 
@@ -66,25 +60,20 @@ namespace AMDiS
       inserter_ = nullptr;
     }
 
-    template <class Row, class Col>
-    void insert_impl(Row const& row, Col const& col, value_type const& value)
+    template <class Row, class Col, class Assigner>
+    void insert_impl(Row const& row, Col const& col, value_type const& value, Assigner assign)
     {
       size_type r = *row;
       size_type c = *col;
       test_exit_dbg(inserter_, "Inserter not initilized!");
       test_exit_dbg(r < num_rows(matrix_) && c < num_cols(matrix_),
           "Indices out of range [0,{})x[0,{})", num_rows(matrix_), num_cols(matrix_));
-      (*inserter_)[r][c] += value;
-    }
-
-    /// Return the number of nonzeros in the matrix
-    std::size_t nnz_impl() const
-    {
-      return matrix_.nnz() * Rows_v<value_type> * Cols_v<value_type>;
+      assign(value, (*inserter_)[r][c]);
     }
 
   protected:
-    void calculateSlotSize(MatrixIndexSet const& matrixIndexSet)
+    template <class MatIndexSet>
+    void calculateSlotSize(MatIndexSet const& matrixIndexSet)
     {
       slotSize_ = 20;
       for (std::size_t i = 0; i < matrixIndexSet.rows(); ++i)
@@ -102,4 +91,61 @@ namespace AMDiS
     int slotSize_ = 50;
   };
 
+
+  /// \brief The basic container that stores a base matrix
+  template <class Elt, class Parameters>
+  class MatrixWrapper<mtl::compressed2D<Elt, Parameters>>
+      : public MatrixWrapperBase<MatrixWrapper<mtl::compressed2D<Elt, Parameters>>>
+  {
+  public:
+    /// The matrix type of the underlying base matrix
+    using BaseMatrix = mtl::compressed2D<Elt, Parameters>;
+
+    /// The type of the elements of the DOFMatrix
+    using value_type = Elt;
+
+    /// The index/size - type
+    using size_type = typename BaseMatrix::size_type;
+
+  public:
+    /// Constructor. Stores a pointer to the passed BaseMatrix
+    MatrixWrapper(BaseMatrix& matrix)
+      : matrix_(matrix)
+    {}
+
+    template <class RowSize, class ColSize>
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    {
+      size_type rows = rowSize.size(rowPrefix);
+      size_type cols = colSize.size(colPrefix);
+      assert(rows > 0 && cols > 0);
+      matrix_.change_dim(rows, cols);
+    }
+
+    template <class RowIter>
+    void clear_row_impl(RowIter const& row, bool setDiagonal)
+    {
+      // Define the property maps
+      auto row_of   = mtl::mat::row_map(matrix_);
+      auto col_of   = mtl::mat::col_map(matrix_);
+      auto set_value = mtl::mat::value_map(matrix_);
+
+      // iterate over the matrix
+	    auto r = begin<mtl::tag::row>(matrix_) + *row;
+      for (auto i : mtl::nz_of(r))  // non-zeros within row
+        set_value(i, (setDiagonal && row_of(i) == col_of(i) ? value_type(1) : value_type(0)) );
+    }
+
+    /// Return the number of nonzeros in the matrix
+    std::size_t nnz_impl() const
+    {
+      return matrix_.nnz() * Rows_v<value_type> * Cols_v<value_type>;
+    }
+
+  private:
+    /// The data-matrix (can hold a new BaseMatrix or a pointer to external data
+    BaseMatrix& matrix_;
+  };
+
 } // end namespace AMDiS
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index e9490307..9a4440c0 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -37,64 +37,98 @@ void test1(BasisTester& tester)
   using HierarchicMatrixIndexSet
     = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<Traits>,Blocking,Blocking>;
 
-  Matrix matrix;
-  MatrixWrapper<Matrix> wrapper(matrix);
-  printType(matrix);
+  Matrix matrix_data;
+  printType(matrix_data);
 
-  HierarchicMatrixIndexSet matrixIndexSet;
+  HierarchicMatrixIndexSet matrixIndexSet_data;
 
-  wrapper.resize(taylorHoodBasis, taylorHoodBasis);
-  matrixWrapper(matrixIndexSet).resize(taylorHoodBasis, taylorHoodBasis);
-  wrapper.init(matrixIndexSet,true);
+  matrixWrapper(matrix_data).resize(taylorHoodBasis, taylorHoodBasis);
+  matrixWrapper(matrixIndexSet_data).resize(taylorHoodBasis, taylorHoodBasis);
+
+  MatrixInserter<Matrix> matrix(matrix_data);
+  MatrixInserter<HierarchicMatrixIndexSet> matrixIndexSet(matrixIndexSet_data);
+  printType(matrix);
 
   auto idx00 = std::array<std::size_t,2>{0,0};
   auto idx01 = std::array<std::size_t,2>{0,1};
   auto idx10 = std::array<std::size_t,2>{1,0};
   auto idx11 = std::array<std::size_t,2>{1,1};
-
-  wrapper.insert(idx00, idx00, 1.0);
-  wrapper.insert(idx00, idx01, 2.0);
-  wrapper.insert(idx00, idx10, 3.0);
-  wrapper.insert(idx00, idx11, 4.0);
-  wrapper.insert(idx01, idx00, 5.0);
-  wrapper.insert(idx01, idx01, 6.0);
-  wrapper.insert(idx01, idx10, 7.0);
-  wrapper.insert(idx01, idx11, 8.0);
-  wrapper.insert(idx10, idx00, 9.0);
-  wrapper.insert(idx10, idx01, 10.0);
-  wrapper.insert(idx10, idx10, 11.0);
-  wrapper.insert(idx10, idx11, 12.0);
-  wrapper.insert(idx11, idx00, 13.0);
-  wrapper.insert(idx11, idx01, 14.0);
-  wrapper.insert(idx11, idx10, 15.0);
-  wrapper.insert(idx11, idx11, 16.0);
-
-  AMDIS_TEST_EQ(wrapper.nnz(), 16u);
-
-  AMDIS_TEST_EQ(matrix[0][0][0][0], 1.0);
-  AMDIS_TEST_EQ(matrix[0][0][0][1], 2.0);
-  AMDIS_TEST_EQ(matrix[0][1][0][0], 3.0);
-  AMDIS_TEST_EQ(matrix[0][1][0][1], 4.0);
-  AMDIS_TEST_EQ(matrix[0][0][1][0], 5.0);
-  AMDIS_TEST_EQ(matrix[0][0][1][1], 6.0);
-  AMDIS_TEST_EQ(matrix[0][1][1][0], 7.0);
-  AMDIS_TEST_EQ(matrix[0][1][1][1], 8.0);
-  AMDIS_TEST_EQ(matrix[1][0][0][0], 9.0);
-  AMDIS_TEST_EQ(matrix[1][0][0][1], 10.0);
-  AMDIS_TEST_EQ(matrix[1][1][0][0], 11.0);
-  AMDIS_TEST_EQ(matrix[1][1][0][1], 12.0);
-  AMDIS_TEST_EQ(matrix[1][0][1][0], 13.0);
-  AMDIS_TEST_EQ(matrix[1][0][1][1], 14.0);
-  AMDIS_TEST_EQ(matrix[1][1][1][0], 15.0);
-  AMDIS_TEST_EQ(matrix[1][1][1][1], 16.0);
-
-  wrapper.finish();
+  auto idx02 = std::array<std::size_t,2>{0,2};
+
+  // 1. fill the occupation pattern
+  matrixIndexSet.insert(idx00, idx00, 1);
+  matrixIndexSet.insert(idx00, idx01, 1);
+  matrixIndexSet.insert(idx00, idx10, 1);
+  matrixIndexSet.insert(idx00, idx11, 1);
+  matrixIndexSet.insert(idx01, idx00, 1);
+  matrixIndexSet.insert(idx01, idx01, 1);
+  matrixIndexSet.insert(idx01, idx10, 1);
+  matrixIndexSet.insert(idx01, idx11, 1);
+  matrixIndexSet.insert(idx10, idx00, 1);
+  matrixIndexSet.insert(idx10, idx01, 1);
+  matrixIndexSet.insert(idx10, idx10, 1);
+  matrixIndexSet.insert(idx10, idx11, 1);
+  matrixIndexSet.insert(idx11, idx00, 1);
+  matrixIndexSet.insert(idx11, idx01, 1);
+  matrixIndexSet.insert(idx11, idx10, 1);
+  matrixIndexSet.insert(idx11, idx11, 1);
+  matrixIndexSet.insert(idx02, idx02, 1);
+
+  // 2. apply the pattern to the matrix
+  matrix.init(matrixIndexSet_data,true);
+
+  // 3. fill the matrix
+  matrix.insert(idx00, idx00, 1.0);
+  matrix.insert(idx00, idx01, 2.0);
+  matrix.insert(idx00, idx10, 3.0);
+  matrix.insert(idx00, idx11, 4.0);
+  matrix.insert(idx01, idx00, 5.0);
+  matrix.insert(idx01, idx01, 6.0);
+  matrix.insert(idx01, idx10, 7.0);
+  matrix.insert(idx01, idx11, 8.0);
+  matrix.insert(idx10, idx00, 9.0);
+  matrix.insert(idx10, idx01, 10.0);
+  matrix.insert(idx10, idx10, 11.0);
+  matrix.insert(idx10, idx11, 12.0);
+  matrix.insert(idx11, idx00, 13.0);
+  matrix.insert(idx11, idx01, 14.0);
+  matrix.insert(idx11, idx10, 15.0);
+  matrix.insert(idx11, idx11, 16.0);
+
+  AMDIS_TEST_EQ(matrixWrapper(matrix_data).nnz(), 16u);
+
+  AMDIS_TEST_EQ(matrix_data[0][0][0][0], 1.0);
+  AMDIS_TEST_EQ(matrix_data[0][0][0][1], 2.0);
+  AMDIS_TEST_EQ(matrix_data[0][1][0][0], 3.0);
+  AMDIS_TEST_EQ(matrix_data[0][1][0][1], 4.0);
+  AMDIS_TEST_EQ(matrix_data[0][0][1][0], 5.0);
+  AMDIS_TEST_EQ(matrix_data[0][0][1][1], 6.0);
+  AMDIS_TEST_EQ(matrix_data[0][1][1][0], 7.0);
+  AMDIS_TEST_EQ(matrix_data[0][1][1][1], 8.0);
+  AMDIS_TEST_EQ(matrix_data[1][0][0][0], 9.0);
+  AMDIS_TEST_EQ(matrix_data[1][0][0][1], 10.0);
+  AMDIS_TEST_EQ(matrix_data[1][1][0][0], 11.0);
+  AMDIS_TEST_EQ(matrix_data[1][1][0][1], 12.0);
+  AMDIS_TEST_EQ(matrix_data[1][0][1][0], 13.0);
+  AMDIS_TEST_EQ(matrix_data[1][0][1][1], 14.0);
+  AMDIS_TEST_EQ(matrix_data[1][1][1][0], 15.0);
+  AMDIS_TEST_EQ(matrix_data[1][1][1][1], 16.0);
+
+  matrix.finish();
 
   std::cout << "\n";
-  std::cout << matrix[0][0] << "\n";
-  std::cout << matrix[0][1] << "\n";
-  std::cout << matrix[1][0] << "\n";
-  std::cout << matrix[1][1] << "\n";
+  std::cout << matrix_data[0][0] << "\n";
+  std::cout << matrix_data[0][1] << "\n";
+  std::cout << matrix_data[1][0] << "\n";
+  std::cout << matrix_data[1][1] << "\n";
+
+  std::cout << "clear_row...\n";
+  matrixWrapper(matrix_data).clear_row(idx02, true);
+
+  std::cout << matrix_data[0][0] << "\n";
+  std::cout << matrix_data[0][1] << "\n";
+  std::cout << matrix_data[1][0] << "\n";
+  std::cout << matrix_data[1][1] << "\n";
 }
 
 template <class Traits, class BasisTester>
@@ -109,14 +143,15 @@ void test2(BasisTester& tester)
     = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<Traits>,Blocking,Blocking>;
 
   Matrix matrix;
-  MatrixWrapper<Matrix> wrapper(matrix);
   printType(matrix);
 
   HierarchicMatrixIndexSet matrixIndexSet;
 
-  wrapper.resize(taylorHoodBasis, taylorHoodBasis);
+  matrixWrapper(matrix).resize(taylorHoodBasis, taylorHoodBasis);
   matrixWrapper(matrixIndexSet).resize(taylorHoodBasis, taylorHoodBasis);
-  wrapper.init(matrixIndexSet,true);
+
+  MatrixInserter<Matrix> inserter(matrix);
+  inserter.init(matrixIndexSet,true);
 
   std::cout << "\n";
   // velocity blocks
@@ -150,14 +185,15 @@ void test5(BasisTester& tester)
     = MatrixGenerator_t<std::size_t,MatrixIndexSetTraits<Traits>,Blocking,Blocking>;
 
   Matrix matrix;
-  MatrixWrapper<Matrix> wrapper(matrix);
   printType(matrix);
 
   HierarchicMatrixIndexSet matrixIndexSet;
 
-  wrapper.resize(taylorHoodBasis, taylorHoodBasis);
+  matrixWrapper(matrix).resize(taylorHoodBasis, taylorHoodBasis);
   matrixWrapper(matrixIndexSet).resize(taylorHoodBasis, taylorHoodBasis);
-  wrapper.init(matrixIndexSet,true);
+
+  MatrixInserter<Matrix> inserter(matrix);
+  inserter.init(matrixIndexSet,true);
 
   std::cout << "\n";
   // velocity blocks
-- 
GitLab


From c17e8f8320092c2922cc441995d40c80f50f4413 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Fri, 12 Apr 2019 12:28:25 +0200
Subject: [PATCH 11/38] cleaned up tests for new inserter and wrapper structure

---
 src/amdis/DirichletBC.hpp                   |  2 +-
 src/amdis/DirichletBC.inc.hpp               |  1 +
 src/amdis/linearalgebra/DOFMatrixBase.hpp   |  6 ++
 src/amdis/linearalgebra/VectorWrapper.hpp   | 13 +----
 src/amdis/linearalgebra/istl/BCRSMatrix.hpp |  2 +
 test/MatrixTest.cpp                         |  2 +-
 test/MatrixWrapperTest.cpp                  | 62 ++++++++++++++-------
 7 files changed, 54 insertions(+), 34 deletions(-)

diff --git a/src/amdis/DirichletBC.hpp b/src/amdis/DirichletBC.hpp
index e5710855..5b53d3f0 100644
--- a/src/amdis/DirichletBC.hpp
+++ b/src/amdis/DirichletBC.hpp
@@ -40,7 +40,7 @@ namespace AMDiS
     using Super = BoundaryCondition;
 
     template <class Blocking>
-    using BitVector = VectorGenerator_t<bool, StdTraits, Blocking>;
+    using BitVector = VectorGenerator_t<char, StdTraits, Blocking>;
 
   public:
     template <class BM, class Values,
diff --git a/src/amdis/DirichletBC.inc.hpp b/src/amdis/DirichletBC.inc.hpp
index 53dc3013..90b5346c 100644
--- a/src/amdis/DirichletBC.inc.hpp
+++ b/src/amdis/DirichletBC.inc.hpp
@@ -33,6 +33,7 @@ void DirichletBC<D,R,MI>::
 fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, RTP rowTreePath, CN const& colNode, CTP colTreePath)
 {
   BitVector<typename Mat::RowBlocking> bitVector;
+  vectorWrapper(bitVector).resize(matrix.rowBasis());
   for (auto const& node : dirichletNodes_)
     bitVector[node] = true;
 
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index 601c1b5c..f8ca4cce 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -15,6 +15,12 @@
 
 namespace AMDiS
 {
+  template <class T>
+  void _printType()
+  {
+    std::cout << __PRETTY_FUNCTION__ << "\n";
+  }
+
   /**
    * Basis implementation of DOFMatrix, i.e. a sparse matrix storing all the
    * assembled Operators indexed with DOF indices. The matrix data is associated
diff --git a/src/amdis/linearalgebra/VectorWrapper.hpp b/src/amdis/linearalgebra/VectorWrapper.hpp
index b1da8f39..25196d6b 100644
--- a/src/amdis/linearalgebra/VectorWrapper.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.hpp
@@ -5,6 +5,7 @@
 #include <dune/common/std/type_traits.hh>
 
 #include <amdis/common/Access.hpp>
+#include <amdis/common/FieldMatVec.hpp>
 #include <amdis/common/Index.hpp>
 #include <amdis/linearalgebra/VectorWrapperBase.hpp>
 
@@ -31,19 +32,9 @@ namespace AMDiS
 
   namespace Impl
   {
-    template <class V>
-    struct IsScalarVector
-    {
-      template <class K, class = std::enable_if_t<Dune::IsNumber<K>::value>>
-      static std::int16_t test(Dune::FieldVector<K,1> const&);
-      static std::int8_t test(...);
-
-      static constexpr bool value = sizeof(decltype(test(std::declval<V>()))) == sizeof(std::int16_t);
-    };
-
     template <class V>
     using VectorWrapperSelector =
-      std::conditional_t<IsScalarVector<V>::value,
+      std::conditional_t<Dune::MatVec::IsScalarVector<V>::value,
         VectorWrapperScalarImpl<V>,
       std::conditional_t<Concepts::VectorAccessible_t<V,std::size_t>::value,
         VectorWrapperDynamicImpl<V>,
diff --git a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
index d1bf06d0..52dff12e 100644
--- a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
@@ -6,6 +6,7 @@
 #include <amdis/Output.hpp>
 #include <amdis/common/StaticSize.hpp>
 #include <amdis/linearalgebra/Common.hpp>
+#include <amdis/linearalgebra/MatrixInserter.hpp>
 #include <amdis/linearalgebra/MatrixIndexSet.hpp>
 #include <amdis/linearalgebra/MatrixWrapper.hpp>
 
@@ -84,6 +85,7 @@ namespace AMDiS
 
     std::size_t nnz_impl() const
     {
+      assert(false);
       return matrix_.nonzeroes() * Rows_v<B> * Cols_v<B>;
     }
 
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index 9a4440c0..989003a5 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -95,7 +95,7 @@ void test1(BasisTester& tester)
   matrix.insert(idx11, idx10, 15.0);
   matrix.insert(idx11, idx11, 16.0);
 
-  AMDIS_TEST_EQ(matrixWrapper(matrix_data).nnz(), 16u);
+  AMDIS_TEST(matrixWrapper(matrix_data).nnz() >= 16u);
 
   AMDIS_TEST_EQ(matrix_data[0][0][0][0], 1.0);
   AMDIS_TEST_EQ(matrix_data[0][0][0][1], 2.0);
diff --git a/test/MatrixWrapperTest.cpp b/test/MatrixWrapperTest.cpp
index c9508ca5..0512394e 100644
--- a/test/MatrixWrapperTest.cpp
+++ b/test/MatrixWrapperTest.cpp
@@ -2,6 +2,7 @@
 
 #include <amdis/AMDiS.hpp>
 #include <amdis/Output.hpp>
+#include <amdis/linearalgebra/MatrixInserterBase.hpp>
 #include <amdis/linearalgebra/MatrixWrapperBase.hpp>
 
 #include "Tests.hpp"
@@ -20,19 +21,10 @@ void printType()
   std::cout << __PRETTY_FUNCTION__ << "\n";
 }
 
-class WrapperImpl
-    : public MatrixWrapperBase<WrapperImpl>
+class InserterImpl
+    : public MatrixInserterBase<InserterImpl>
 {
 public:
-  /// Resize \ref matrix_ to desired size (`rows` x `cols`)
-  template <class RowSizeInfo, class ColSizeInfo>
-  void resize_impl(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
-              ColSizeInfo const& colSizeInfo, typename ColSizeInfo::SizePrefix colPrefix)
-  {
-    AMDIS_TEST_EQ(rowPrefix.constize(), 0);
-    AMDIS_TEST_EQ(colPrefix.constize(), 0);
-  }
-
   /// Prepare the matrix forconstinsertion of values
   template <class MatrixIndexSet>
   void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild)
@@ -52,7 +44,20 @@ public:
   {
     printType(assign);
   }
+};
 
+class WrapperImpl
+    : public MatrixWrapperBase<WrapperImpl>
+{
+public:
+  /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+  template <class RowSizeInfo, class ColSizeInfo>
+  void resize_impl(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
+              ColSizeInfo const& colSizeInfo, typename ColSizeInfo::SizePrefix colPrefix)
+  {
+    AMDIS_TEST_EQ(rowPrefix.constize(), 0);
+    AMDIS_TEST_EQ(colPrefix.constize(), 0);
+  }
 
   /// Return the number of nonzeros in the matrix
   std::size_t nnz_impl() const
@@ -62,6 +67,18 @@ public:
 };
 
 
+class Inserter2Impl
+    : public MatrixInserterBase<Inserter2Impl>
+{
+public:
+  /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+  template <class Row, class Col, class ValueType, class Assigner>
+  void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
+  {
+    printType(assign);
+  }
+};
+
 class Wrapper2Impl
     : public MatrixWrapperBase<Wrapper2Impl>
 {
@@ -74,22 +91,19 @@ public:
     AMDIS_TEST_EQ(rowPrefix.size(), 0);
     AMDIS_TEST_EQ(colPrefix.size(), 0);
   }
-
-  /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
-  template <class Row, class Col, class ValueType, class Assigner>
-  void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
-  {
-    printType(assign);
-  }
 };
 
 template <class Impl>
 void foo(MatrixWrapperBase<Impl>& wrapper)
 {
-  wrapper.init(0, true);
-  wrapper.finish();
   wrapper.nnz();
-  AMDIS_TEST_EQ(wrapper.nnz(), 1);
+}
+
+template <class Impl>
+void foo(MatrixInserterBase<Impl>& inserter)
+{
+  inserter.init(0, true);
+  inserter.finish();
 }
 
 
@@ -100,6 +114,12 @@ int main(int argc, char** argv)
   WrapperImpl wrapper1;
   Wrapper2Impl wrapper2;
 
+  InserterImpl inserter1;
+  Inserter2Impl inserter2;
+
   foo(wrapper1);
   //foo(wrapper2); // should not compile
+
+  foo(inserter1);
+  //foo(inserter2); // should not compile
 }
-- 
GitLab


From d72d19e3f689cd9b9a22f7409f413f6e6fbdae9b Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Fri, 12 Apr 2019 17:57:47 +0200
Subject: [PATCH 12/38] Added Stokes-Test and SingleRowColMatrix matrix-vector
 products

---
 examples/stokes3.cc                           |   1 -
 src/amdis/DirichletBC.hpp                     |   2 +-
 src/amdis/DirichletBC.inc.hpp                 |   6 +-
 src/amdis/Output.hpp                          |   6 +
 src/amdis/PeriodicBC.hpp                      |   8 +-
 src/amdis/PeriodicBC.inc.hpp                  |  15 +-
 src/amdis/functions/MultiIndex.hpp            |  14 +-
 src/amdis/linearalgebra/Constraints.hpp       |   8 +-
 src/amdis/linearalgebra/DOFMatrixBase.hpp     |   8 +-
 src/amdis/linearalgebra/MatrixIndexSet.hpp    |   3 +
 .../linearalgebra/MatrixInserterBase.hpp      |   1 -
 src/amdis/linearalgebra/MatrixWrapper.hpp     |   8 +
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp |  13 +-
 src/amdis/linearalgebra/MatrixWrapperBase.hpp |   1 -
 .../linearalgebra/SingleRowColMatrix.hpp      |   6 -
 src/amdis/linearalgebra/VectorWrapper.hpp     |   8 +
 src/amdis/linearalgebra/VectorWrapperBase.hpp |   1 -
 src/amdis/linearalgebra/istl/BCRSMatrix.hpp   | 231 ++++++++++++++++-
 src/amdis/linearalgebra/istl/CMakeLists.txt   |   1 +
 .../istl/ISTL_Preconditioner.hpp              |  44 +++-
 src/amdis/linearalgebra/istl/ISTL_Solver.hpp  |  44 ++++
 .../linearalgebra/istl/MatrixVectorTraits.hpp |   1 +
 .../linearalgebra/istl/SingleRowColMatrix.hpp | 240 ++++++++++++++++++
 test/BasisTester.hpp                          |  34 +--
 test/CMakeLists.txt                           |   8 +
 test/GeneratorsTest.cpp                       |   2 +-
 test/MatrixTest.cpp                           |   2 +-
 test/StokesTest.cpp                           |  53 ++++
 28 files changed, 704 insertions(+), 65 deletions(-)
 create mode 100644 src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
 create mode 100644 test/StokesTest.cpp

diff --git a/examples/stokes3.cc b/examples/stokes3.cc
index 80937e8b..8690c60d 100644
--- a/examples/stokes3.cc
+++ b/examples/stokes3.cc
@@ -21,7 +21,6 @@ int main(int argc, char** argv)
 
   // tree-paths for components
   auto _v = Dune::Indices::_0;
-  auto _p = Dune::Indices::_1;
 
   auto opStokes = makeOperator(tag::stokes{}, viscosity);
   prob.addMatrixOperator(opStokes);
diff --git a/src/amdis/DirichletBC.hpp b/src/amdis/DirichletBC.hpp
index 5b53d3f0..415ef9b6 100644
--- a/src/amdis/DirichletBC.hpp
+++ b/src/amdis/DirichletBC.hpp
@@ -40,7 +40,7 @@ namespace AMDiS
     using Super = BoundaryCondition;
 
     template <class Blocking>
-    using BitVector = VectorGenerator_t<char, StdTraits, Blocking>;
+    using BitVector = VectorGenerator_t<char, DefaultMatrixVectorTraits, Blocking>;
 
   public:
     template <class BM, class Values,
diff --git a/src/amdis/DirichletBC.inc.hpp b/src/amdis/DirichletBC.inc.hpp
index 90b5346c..bfc1ca48 100644
--- a/src/amdis/DirichletBC.inc.hpp
+++ b/src/amdis/DirichletBC.inc.hpp
@@ -35,12 +35,12 @@ fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, R
   BitVector<typename Mat::RowBlocking> bitVector;
   vectorWrapper(bitVector).resize(matrix.rowBasis());
   for (auto const& node : dirichletNodes_)
-    bitVector[node] = true;
+    Dune::Functions::resolveDynamicMultiIndex(bitVector,node) = 1;
 
   auto columns = Constraints<Mat>::dirichletBC(matrix, dirichletNodes_);
 
   Dune::Hybrid::ifElse(std::is_same<RangeType_t<RN>, R>{},
-    [&](auto id) {
+    [&](auto id) -> void {
       auto subBasis = Dune::Functions::subspaceBasis(*rhs.basis(), rowTreePath);
       Dune::Functions::interpolate(subBasis, rhs, values_, bitVector);
     });
@@ -50,7 +50,7 @@ fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, R
     rhs[triplet.row] -= triplet.value * solution[triplet.col];
 
   Dune::Hybrid::ifElse(std::is_same<RangeType_t<CN>, R>{},
-    [&](auto id) {
+    [&](auto id) -> void {
       auto subBasis = Dune::Functions::subspaceBasis(*solution.basis(), colTreePath);
       Dune::Functions::interpolate(subBasis, solution, values_, bitVector);
     });
diff --git a/src/amdis/Output.hpp b/src/amdis/Output.hpp
index 91264e57..b65dd123 100644
--- a/src/amdis/Output.hpp
+++ b/src/amdis/Output.hpp
@@ -195,4 +195,10 @@ namespace AMDiS
   void test_exit_dbg(bool, Args&&...) {}
 #endif
 
+  template <class T>
+  void print_type(std::string prefix = "")
+  {
+    std::cout << prefix << __PRETTY_FUNCTION__ << "\n";
+  }
+
 } // end namespace AMDiS
diff --git a/src/amdis/PeriodicBC.hpp b/src/amdis/PeriodicBC.hpp
index 0d6f7de8..28ed2b33 100644
--- a/src/amdis/PeriodicBC.hpp
+++ b/src/amdis/PeriodicBC.hpp
@@ -9,7 +9,8 @@
 #include <amdis/Output.hpp>
 #include <amdis/common/ConceptsBase.hpp>
 #include <amdis/common/FieldMatVec.hpp>
-
+#include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
+#include <amdis/linearalgebra/MatrixVectorTraits.hpp>
 
 namespace AMDiS
 {
@@ -50,6 +51,9 @@ namespace AMDiS
   {
     using Super = BoundaryCondition;
 
+    template <class Blocking>
+    using BitVector = VectorGenerator_t<char, DefaultMatrixVectorTraits, Blocking>;
+
   public:
     using Domain = D;
     using MultiIndex = MI;
@@ -92,7 +96,7 @@ namespace AMDiS
   private:
     FaceTrafo faceTrafo_;
 
-    std::vector<bool> periodicNodes_;
+    std::vector<MI> periodicNodes_;
     std::map<MI, MI> associations_;
     Dune::Std::optional<bool> hasConnectedIntersections_;
   };
diff --git a/src/amdis/PeriodicBC.inc.hpp b/src/amdis/PeriodicBC.inc.hpp
index b8901f9f..90f82b2b 100644
--- a/src/amdis/PeriodicBC.inc.hpp
+++ b/src/amdis/PeriodicBC.inc.hpp
@@ -46,7 +46,7 @@ initAssociations(Basis const& basis)
   using std::sqrt;
   static const auto tol = sqrt(std::numeric_limits<typename D::field_type>::epsilon());
   periodicNodes_.clear();
-  periodicNodes_.resize(basis.dimension(), false);
+  //periodicNodes_.resize(basis.dimension(), false);
 
   auto localView = basis.localView();
   auto seDOFs = subEntityDOFs(basis);
@@ -85,7 +85,7 @@ initAssociations(Basis const& basis)
         for (std::size_t j = 0; j < outsideCoords.size(); ++j) {
           auto const& y = outsideCoords[j];
           if (distance(x,y) < tol) {
-            periodicNodes_[insideGlobalDOFs[i]] = true;
+            periodicNodes_.push_back(insideGlobalDOFs[i]);
             associations_[insideGlobalDOFs[i]] = localView.index(outsideDOFs[j]);
           }
         }
@@ -132,7 +132,7 @@ initAssociations2(Basis const& basis)
   using std::sqrt;
   static const auto tol = sqrt(std::numeric_limits<typename D::field_type>::epsilon());
   periodicNodes_.clear();
-  periodicNodes_.resize(basis.dimension(), false);
+  //periodicNodes_.resize(basis.dimension(), false);
 
   // Dune::ReservedVector<std::pair<EntitySeed,int>,2>
   using EntitySeed = typename Basis::GridView::Grid::template Codim<0>::EntitySeed;
@@ -184,7 +184,7 @@ initAssociations2(Basis const& basis)
       for (std::size_t j = 0; j < outsideCoords.size(); ++j) {
         auto const& y = outsideCoords[j];
         if (distance(x,y) < tol) {
-          periodicNodes_[insideGlobalDOFs[i]] = true;
+          periodicNodes_.push_back(insideGlobalDOFs[i]);
           associations_[insideGlobalDOFs[i]] = localView.index(outsideDOFs[j]);
         }
       }
@@ -238,13 +238,18 @@ template <class D, class MI>
 void PeriodicBC<D,MI>::
 fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, RTP rowTreePath, CN const& colNode, CTP colTreePath)
 {
+  BitVector<typename Mat::RowBlocking> bitVector;
+  vectorWrapper(bitVector).resize(matrix.rowBasis());
+  for (auto const& node : periodicNodes_)
+    Dune::Functions::resolveDynamicMultiIndex(bitVector,node) = 1;
+
   Constraints<Mat>::periodicBC(matrix, periodicNodes_, associations_);
 
   for (auto const& a : associations_) {
     rhs[a.second] += rhs[a.first];
     solution[a.second] = solution[a.first];
   }
-  Dune::Functions::interpolate(*rhs.basis(), rhs, [](auto const&) { return 0.0; }, periodicNodes_);
+  Dune::Functions::interpolate(*rhs.basis(), rhs, [](auto const&) { return 0.0; }, bitVector);
 }
 
 } // end namespace AMDiS
diff --git a/src/amdis/functions/MultiIndex.hpp b/src/amdis/functions/MultiIndex.hpp
index 1f819785..c6762e2e 100644
--- a/src/amdis/functions/MultiIndex.hpp
+++ b/src/amdis/functions/MultiIndex.hpp
@@ -54,4 +54,16 @@ namespace AMDiS
     return {multiIndex};
   }
 
-} // end namespace AMDiS
\ No newline at end of file
+} // end namespace AMDiS
+
+namespace Dune
+{
+  template<class T, int N>
+  bool operator<(ReservedVector<T,N> const& lhs, ReservedVector<T,N> const& rhs)
+  {
+    for (std::size_t i = 0; i < lhs.size(); ++i)
+      if (rhs[i] < lhs[i])
+        return false;
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/Constraints.hpp b/src/amdis/linearalgebra/Constraints.hpp
index d717171f..1ee4a71d 100644
--- a/src/amdis/linearalgebra/Constraints.hpp
+++ b/src/amdis/linearalgebra/Constraints.hpp
@@ -12,14 +12,14 @@ namespace AMDiS
     static auto dirichletBC(Matrix& matrix, DOFs const& dofs, bool setDiagonal = true)
     {
       /* do nothing */
-      return std::array<Triplet<MultiIndex,typename Matrix::value_type>,0>{};
+      return std::array<Triplet<MultiIndex,typename Matrix::field_type>,0>{};
     }
 
     template <class BitVec, class Assoc>
     static auto periodicBC(Matrix& matrix, BitVec const& left, Assoc const& association, bool setDiagonal = true)
     {
       /* do nothing */
-      return std::array<Triplet<MultiIndex,typename Matrix::value_type>,0>{};
+      return std::array<Triplet<MultiIndex,typename Matrix::field_type>,0>{};
     }
   };
 
@@ -38,8 +38,8 @@ namespace AMDiS
       // return Constraints<typename Matrix::BaseMatrix,MultiIndex>::dirichletBC(matrix.matrix(), dofs, setDiagonal);
     }
 
-    template <class BitVec, class Assoc>
-    static auto periodicBC(Matrix& matrix, BitVec const& left, Assoc const& association, bool setDiagonal = true)
+    template <class Assoc>
+    static auto periodicBC(Matrix& matrix, std::vector<typename RB::MultiIndex> const& left, Assoc const& association, bool setDiagonal = true)
     {
       return Constraints<typename Matrix::BaseMatrix,MultiIndex>::periodicBC(matrix.matrix(), left, association, setDiagonal);
     }
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index f8ca4cce..9d657f74 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -15,12 +15,6 @@
 
 namespace AMDiS
 {
-  template <class T>
-  void _printType()
-  {
-    std::cout << __PRETTY_FUNCTION__ << "\n";
-  }
-
   /**
    * Basis implementation of DOFMatrix, i.e. a sparse matrix storing all the
    * assembled Operators indexed with DOF indices. The matrix data is associated
@@ -176,7 +170,7 @@ namespace AMDiS
     /// Number of nonzeros in the matrix
     size_type nnz() const
     {
-      return matrixWrapper(matrix_).nnz();
+      return matrixWrapper(const_cast<BaseMatrix&>(matrix_)).nnz();
     }
 
   protected:
diff --git a/src/amdis/linearalgebra/MatrixIndexSet.hpp b/src/amdis/linearalgebra/MatrixIndexSet.hpp
index a123743e..a2e2bdef 100644
--- a/src/amdis/linearalgebra/MatrixIndexSet.hpp
+++ b/src/amdis/linearalgebra/MatrixIndexSet.hpp
@@ -24,6 +24,9 @@ namespace AMDiS
   {
     template <class>
     using FlatMatrix = AMDiS::MatrixIndexSet;
+
+    template <class T, std::size_t R, std::size_t C>
+    using LeafBlockMatrix = AMDiS::MatrixIndexSet;
   };
 
   template <>
diff --git a/src/amdis/linearalgebra/MatrixInserterBase.hpp b/src/amdis/linearalgebra/MatrixInserterBase.hpp
index 115f4675..7f975ac2 100644
--- a/src/amdis/linearalgebra/MatrixInserterBase.hpp
+++ b/src/amdis/linearalgebra/MatrixInserterBase.hpp
@@ -48,7 +48,6 @@ namespace AMDiS
     void insert_impl(Args&&...) { /* do nothing */ }
 
   private:
-    Impl const& asImpl() const { return static_cast<Impl const&>(*this); }
     Impl& asImpl() { return static_cast<Impl&>(*this); }
   };
 
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
index 29a8bc3e..a0b35a61 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -51,6 +51,14 @@ namespace AMDiS
     {}
   };
 
+  template <class BaseMatrix>
+  class MatrixWrapper<const BaseMatrix>
+      : public MatrixWrapper<BaseMatrix>
+  {
+  public:
+    using MatrixWrapper<BaseMatrix>::MatrixWrapper;
+  };
+
 } // end namespace AMDiS
 
 #include <amdis/linearalgebra/MatrixWrapper.inc.hpp>
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index e0c7adf0..a5ff1482 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -28,15 +28,12 @@ namespace AMDiS
     }
 
     /// Return the number of nonzeros in the matrix
-    std::size_t nnz_impl() const
+    std::size_t nnz_impl()
     {
       return scalar_ != Scalar(0);
     }
 
   protected:
-    template <class I, class J>
-    auto const& wrapper(I const& i, J const& j) const { return scalar_; }
-
     template <class I, class J>
     auto& wrapper(I const& i, J const& j) { return scalar_; }
 
@@ -99,7 +96,7 @@ namespace AMDiS
     }
 
     /// Return the number of nonzeros in the matrix
-    std::size_t nnz_impl() const
+    std::size_t nnz_impl()
     {
       std::size_t num_nonzeros = 0;
       for (size_type i = 0; i < matrix_.N(); ++i)
@@ -109,7 +106,6 @@ namespace AMDiS
     }
 
   protected:
-    auto wrapper(size_type i, size_type j) const { return matrixWrapper(access(matrix_,i,j)); }
     auto wrapper(size_type i, size_type j) { return matrixWrapper(access(matrix_,i,j)); }
 
   protected:
@@ -165,7 +161,7 @@ namespace AMDiS
       });
     }
 
-    std::size_t nnz_impl() const
+    std::size_t nnz_impl()
     {
       std::size_t num_nonzeros = 0;
       Tools::for_range<0,rows>([&](auto const i) -> void {
@@ -177,9 +173,6 @@ namespace AMDiS
     }
 
   protected:
-    template <class I, class J>
-    auto wrapper(I const& i, J const& j) const { return matrixWrapper(access(matrix_,i,j)); }
-
     template <class I, class J>
     auto wrapper(I const& i, J const& j) { return matrixWrapper(access(matrix_,i,j)); }
 
diff --git a/src/amdis/linearalgebra/MatrixWrapperBase.hpp b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
index 09015de6..302b51b1 100644
--- a/src/amdis/linearalgebra/MatrixWrapperBase.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
@@ -58,7 +58,6 @@ namespace AMDiS
     std::size_t nnz_impl() { return 0; }
 
   private:
-    Impl const& asImpl() const { return static_cast<Impl const&>(*this); }
     Impl& asImpl() { return static_cast<Impl&>(*this); }
   };
 
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index de94739a..dea98f94 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -186,9 +186,6 @@ namespace AMDiS
     }
 
   protected:
-    template <class I, class J>
-    auto wrapper(I const& i, J const& j) const { return wrapper_.wrapper(i,j); }
-
     template <class I, class J>
     auto wrapper(I const& i, J const& j) { return wrapper_.wrapper(i,j); }
 
@@ -344,9 +341,6 @@ namespace AMDiS
     }
 
   protected:
-    template <class I, class J>
-    auto wrapper(I const& i, J const& j) const { return wrapper_.wrapper(i,j); }
-
     template <class I, class J>
     auto wrapper(I const& i, J const& j) { return wrapper_.wrapper(i,j); }
 
diff --git a/src/amdis/linearalgebra/VectorWrapper.hpp b/src/amdis/linearalgebra/VectorWrapper.hpp
index 25196d6b..13418db7 100644
--- a/src/amdis/linearalgebra/VectorWrapper.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.hpp
@@ -57,6 +57,14 @@ namespace AMDiS
     {}
   };
 
+  template <class BaseVector>
+  class VectorWrapper<const BaseVector>
+      : public VectorWrapper<BaseVector>
+  {
+  public:
+    using VectorWrapper<BaseVector>::VectorWrapper;
+  };
+
 } // end namespace AMDiS
 
 #include <amdis/linearalgebra/VectorWrapper.inc.hpp>
diff --git a/src/amdis/linearalgebra/VectorWrapperBase.hpp b/src/amdis/linearalgebra/VectorWrapperBase.hpp
index 0f44a464..0e01edcf 100644
--- a/src/amdis/linearalgebra/VectorWrapperBase.hpp
+++ b/src/amdis/linearalgebra/VectorWrapperBase.hpp
@@ -60,7 +60,6 @@ namespace AMDiS
     }
 
   private:
-    Impl const& asImpl() const { return static_cast<Impl const&>(*this); }
     Impl& asImpl() { return static_cast<Impl&>(*this); }
   };
 
diff --git a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
index 52dff12e..1976e508 100644
--- a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
@@ -85,7 +85,6 @@ namespace AMDiS
 
     std::size_t nnz_impl() const
     {
-      assert(false);
       return matrix_.nonzeroes() * Rows_v<B> * Cols_v<B>;
     }
 
@@ -93,6 +92,236 @@ namespace AMDiS
     BaseMatrix& matrix_;
   };
 
+  template <class B, class A>
+  class SingleColumnMatrix<Dune::Matrix<B,A>>
+      : public Dune::Matrix<B,A>
+  {
+    using Super = Dune::Matrix<B,A>;
+  public:
+    using size_type = typename Super::size_type;
+    using field_type = typename Super::field_type;
+    using block_type = typename Super::block_type;
+
+    using Dune::Matrix<B,A>::Matrix;
+
+    //! y = A x
+    template <class X, class Y>
+    void mv(const X& x, Y& y) const
+    {
+      assert(this->N() == y.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].mv(x, y[i]);
+    }
+
+    //! y = A^T x
+    template<class X, class Y>
+    void mtv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      assert(this->N() > 0);
+      (*this)[0][0].mtv(x[0], y);
+      for (size_type i = 1; i < y.size(); ++i)
+        (*this)[i][0].umtv(x[i], y);
+    }
+
+    //! y += A x
+    template <class X, class Y>
+    void umv(const X& x, Y& y) const
+    {
+      assert(this->N() == y.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].umv(x, y[i]);
+    }
+
+    //! y -= A x
+    template<class X, class Y>
+    void mmv (const X& x, Y& y) const
+    {
+      assert(this->N() == y.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].mmv(x, y[i]);
+    }
+
+    /** \brief \f$ y += \alpha A x \f$ */
+    template <class X, class Y>
+    void usmv(const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->N() == y.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].usmv(alpha, x, y[i]);
+    }
+
+    //! y += A^T x
+    template<class X, class Y>
+    void umtv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].umtv(x[i], y);
+    }
+
+    //! y -= A^T x
+    template<class X, class Y>
+    void mmtv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].mmtv(x[i], y);
+    }
+
+    //! y += alpha A^T x
+    template<class X, class Y>
+    void usmtv (const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].usmtv(alpha, x[i], y);
+    }
+
+    //! y += A^H x
+    template<class X, class Y>
+    void umhv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].umhv(x[i], y);
+    }
+
+    //! y -= A^H x
+    template<class X, class Y>
+    void mmhv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].mmhv(x[i], y);
+    }
+
+    //! y += alpha A^H x
+    template<class X, class Y>
+    void usmhv (const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].usmhv(alpha, x[i], y);
+    }
+  };
+
+
+
+  template <class B, class A>
+  class SingleRowMatrix<Dune::Matrix<B,A>>
+      : public Dune::Matrix<B,A>
+  {
+    using Super = Dune::Matrix<B,A>;
+  public:
+    using size_type = typename Super::size_type;
+    using field_type = typename Super::field_type;
+    using block_type = typename Super::block_type;
+
+    using Dune::Matrix<B,A>::Matrix;
+
+    //! y = A x
+    template <class X, class Y>
+    void mv(const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      (*this)[0][0].mv(x[0], y);
+      for (size_type j = 1; j < this->M(); ++j)
+        (*this)[0][j].umv(x[j], y);
+    }
+
+    //! y = A^T x
+    template<class X, class Y>
+    void mtv (const X& x, Y& y) const
+    {
+      assert(this->M() == y.size());
+      assert(this->M() > 0);
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].mtv(x, y[j]);
+    }
+
+    //! y += A x
+    template <class X, class Y>
+    void umv(const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].umv(x[j], y);
+    }
+
+    //! y -= A x
+    template<class X, class Y>
+    void mmv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].mmv(x[j], y);
+    }
+
+    /** \brief \f$ y += \alpha A x \f$ */
+    template <class X, class Y>
+    void usmv(const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].usmv(alpha, x[j], y);
+    }
+
+    //! y += A^T x
+    template<class X, class Y>
+    void umtv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].umv(x[j], y);
+    }
+
+    //! y -= A^T x
+    template<class X, class Y>
+    void mmtv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].mmtv(x[j], y);
+    }
+
+    //! y += alpha A^T x
+    template<class X, class Y>
+    void usmtv (const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].usmtv(alpha, x[j], y);
+    }
+
+    //! y += A^H x
+    template<class X, class Y>
+    void umhv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].umhv(x[j], y);
+    }
+
+    //! y -= A^H x
+    template<class X, class Y>
+    void mmhv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].mmhv(x[j], y);
+    }
+
+    //! y += alpha A^H x
+    template<class X, class Y>
+    void usmhv (const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].usmtv(alpha, x[j], y);
+    }
+  };
+
 } // end namespace AMDiS
 
 namespace Dune
diff --git a/src/amdis/linearalgebra/istl/CMakeLists.txt b/src/amdis/linearalgebra/istl/CMakeLists.txt
index c6056fe4..230f5701 100644
--- a/src/amdis/linearalgebra/istl/CMakeLists.txt
+++ b/src/amdis/linearalgebra/istl/CMakeLists.txt
@@ -9,4 +9,5 @@ install(FILES
     ISTL_Solver.hpp
     ISTLRunner.hpp
     MatrixVectorTraits.hpp
+    SingleRowColMatrix.hpp
 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/amdis/linearalgebra/istl)
diff --git a/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp b/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
index ca8c16e4..b9808474 100644
--- a/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
+++ b/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
@@ -76,9 +76,11 @@ namespace AMDiS
    * - *gmres*: Generalized minimal residula method, \see Dune::RestartedGMResSolver
    * - *umfpack*: external UMFPACK solver, \see Dune::UMFPack
    **/
-  template <class Mat, class Sol, class Rhs>
-  class DefaultCreators<ISTLPreconCreatorInterface<Mat, Sol, Rhs>>
+  template <class B, class A, class Sol, class Rhs>
+  class DefaultCreators<ISTLPreconCreatorInterface<Dune::BCRSMatrix<B,A>, Sol, Rhs>>
   {
+    using Mat = Dune::BCRSMatrix<B,A>;
+
     template <class Precon>
     using PreconCreator
       = typename ISTLPreconCreator<Precon, Mat>::Creator;
@@ -129,4 +131,42 @@ namespace AMDiS
 
   };
 
+  template <class BlockMatrix, class VectorX, class VectorB>
+  class DefaultCreators<ISTLPreconInterface<BlockMatrix, VectorX, VectorB>>
+  {
+    using Matrix = BlockMatrix;
+
+    template <class Precon>
+    using PreconCreator
+      = typename ISTLPrecon<Precon, Matrix>::Creator;
+
+    using Map = CreatorMap<ISTLPreconInterface<Matrix, VectorX, VectorB>>;
+
+  public:
+    static void init()
+    {
+      // auto jacobi = new PreconCreator<Dune::SeqJac<Matrix, VectorX, VectorB>>;
+      // Map::addCreator("diag", jacobi);
+      // Map::addCreator("jacobi", jacobi);
+
+      // auto gs = new PreconCreator<Dune::SeqGS<Matrix, VectorX, VectorB>>;
+      // Map::addCreator("gs", gs);
+      // Map::addCreator("gauss_seidel", gs);
+
+      // auto sor = new PreconCreator<Dune::SeqSOR<Matrix, VectorX, VectorB>>;
+      // Map::addCreator("sor", sor);
+
+      // auto ssor = new PreconCreator<Dune::SeqSSOR<Matrix, VectorX, VectorB>>;
+      // Map::addCreator("ssor", ssor);
+
+      // auto ilu = new PreconCreator<Dune::SeqILU<Matrix, VectorX, VectorB>>;
+      // Map::addCreator("ilu", ilu);
+      // Map::addCreator("ilu0", ilu);
+
+      auto richardson = new PreconCreator<Dune::Richardson<VectorX, VectorB>>;
+      Map::addCreator("richardson", richardson);
+      Map::addCreator("default", richardson);
+    }
+  };
+
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/istl/ISTL_Solver.hpp b/src/amdis/linearalgebra/istl/ISTL_Solver.hpp
index 700cb1fa..c360f50f 100644
--- a/src/amdis/linearalgebra/istl/ISTL_Solver.hpp
+++ b/src/amdis/linearalgebra/istl/ISTL_Solver.hpp
@@ -203,4 +203,48 @@ namespace AMDiS
     }
   };
 
+
+  template <class BlockMatrix, class VectorX, class VectorB>
+  class DefaultCreators<LinearSolverInterface<BlockMatrix, VectorX, VectorB>>
+  {
+    using Matrix = BlockMatrix;
+    using SolverBase = LinearSolverInterface<Matrix, VectorX, VectorB>;
+
+    template <class ISTLSolver>
+    using SolverCreator
+      = typename LinearSolver<Matrix, VectorX, VectorB,
+          ISTLRunner<ISTLSolver, Matrix, VectorX, VectorB>>::Creator;
+
+    template <class ISTLSolver>
+    using DirectSolverCreator
+      = typename LinearSolver<Matrix, VectorX, VectorB,
+          DirectRunner<ISTLSolver, Matrix, VectorX, VectorB>>::Creator;
+
+    using Map = CreatorMap<SolverBase>;
+
+  public:
+    static void init()
+    {
+      auto cg = new SolverCreator<Dune::CGSolver<VectorX>>;
+      Map::addCreator("cg", cg);
+
+      auto bicgstab = new SolverCreator<Dune::BiCGSTABSolver<VectorX>>;
+      Map::addCreator("bicgstab", bicgstab);
+      Map::addCreator("bcgs", bicgstab);
+
+      auto minres = new SolverCreator<Dune::MINRESSolver<VectorX>>;
+      Map::addCreator("minres", minres);
+
+      auto gmres = new SolverCreator<Dune::RestartedGMResSolver<VectorX>>;
+      Map::addCreator("gmres", gmres);
+
+      // Generalized preconditioned conjugate gradient solver.
+      auto fcg = new SolverCreator<Dune::GeneralizedPCGSolver<VectorX>>;
+      Map::addCreator("fcg", fcg);
+
+      // default iterative solver
+      Map::addCreator("default", gmres);
+    }
+  };
+
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp b/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp
index 3f0d5586..aa4e8675 100644
--- a/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp
+++ b/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp
@@ -12,6 +12,7 @@
 
 #include <amdis/linearalgebra/MatrixVectorTraits.hpp>
 #include <amdis/linearalgebra/istl/BCRSMatrix.hpp>
+#include <amdis/linearalgebra/istl/SingleRowColMatrix.hpp>
 
 namespace AMDiS
 {
diff --git a/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
new file mode 100644
index 00000000..1aa896d4
--- /dev/null
+++ b/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
@@ -0,0 +1,240 @@
+#pragma once
+
+#include <cassert>
+
+#include <dune/istl/matrix.hh>
+#include <amdis/linearalgebra/SingleRowColMatrix.hpp>
+
+namespace AMDiS
+{
+  template <class B, class A>
+  class SingleColumnMatrix<Dune::Matrix<B,A>>
+      : public Dune::Matrix<B,A>
+  {
+    using Super = Dune::Matrix<B,A>;
+  public:
+    using size_type = typename Super::size_type;
+    using field_type = typename Super::field_type;
+    using block_type = typename Super::block_type;
+
+    using Dune::Matrix<B,A>::Matrix;
+
+    //! y = A x
+    template <class X, class Y>
+    void mv(const X& x, Y& y) const
+    {
+      assert(this->N() == y.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].mv(x, y[i]);
+    }
+
+    //! y = A^T x
+    template<class X, class Y>
+    void mtv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      assert(this->N() > 0);
+      (*this)[0][0].mtv(x[0], y);
+      for (size_type i = 1; i < y.size(); ++i)
+        (*this)[i][0].umtv(x[i], y);
+    }
+
+    //! y += A x
+    template <class X, class Y>
+    void umv(const X& x, Y& y) const
+    {
+      assert(this->N() == y.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].umv(x, y[i]);
+    }
+
+    //! y -= A x
+    template<class X, class Y>
+    void mmv (const X& x, Y& y) const
+    {
+      assert(this->N() == y.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].mmv(x, y[i]);
+    }
+
+    /** \brief \f$ y += \alpha A x \f$ */
+    template <class X, class Y>
+    void usmv(const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->N() == y.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].usmv(alpha, x, y[i]);
+    }
+
+    //! y += A^T x
+    template<class X, class Y>
+    void umtv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].umtv(x[i], y);
+    }
+
+    //! y -= A^T x
+    template<class X, class Y>
+    void mmtv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].mmtv(x[i], y);
+    }
+
+    //! y += alpha A^T x
+    template<class X, class Y>
+    void usmtv (const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].usmtv(alpha, x[i], y);
+    }
+
+    //! y += A^H x
+    template<class X, class Y>
+    void umhv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].umhv(x[i], y);
+    }
+
+    //! y -= A^H x
+    template<class X, class Y>
+    void mmhv (const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].mmhv(x[i], y);
+    }
+
+    //! y += alpha A^H x
+    template<class X, class Y>
+    void usmhv (const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->N() == x.size());
+      for (size_type i = 0; i < this->N(); ++i)
+        (*this)[i][0].usmhv(alpha, x[i], y);
+    }
+  };
+
+
+
+  template <class B, class A>
+  class SingleRowMatrix<Dune::Matrix<B,A>>
+      : public Dune::Matrix<B,A>
+  {
+    using Super = Dune::Matrix<B,A>;
+  public:
+    using size_type = typename Super::size_type;
+    using field_type = typename Super::field_type;
+    using block_type = typename Super::block_type;
+
+    using Dune::Matrix<B,A>::Matrix;
+
+    //! y = A x
+    template <class X, class Y>
+    void mv(const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      (*this)[0][0].mv(x[0], y);
+      for (size_type j = 1; j < this->M(); ++j)
+        (*this)[0][j].umv(x[j], y);
+    }
+
+    //! y = A^T x
+    template<class X, class Y>
+    void mtv (const X& x, Y& y) const
+    {
+      assert(this->M() == y.size());
+      assert(this->M() > 0);
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].mtv(x, y[j]);
+    }
+
+    //! y += A x
+    template <class X, class Y>
+    void umv(const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].umv(x[j], y);
+    }
+
+    //! y -= A x
+    template<class X, class Y>
+    void mmv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].mmv(x[j], y);
+    }
+
+    /** \brief \f$ y += \alpha A x \f$ */
+    template <class X, class Y>
+    void usmv(const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].usmv(alpha, x[j], y);
+    }
+
+    //! y += A^T x
+    template<class X, class Y>
+    void umtv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].umv(x[j], y);
+    }
+
+    //! y -= A^T x
+    template<class X, class Y>
+    void mmtv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].mmtv(x[j], y);
+    }
+
+    //! y += alpha A^T x
+    template<class X, class Y>
+    void usmtv (const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].usmtv(alpha, x[j], y);
+    }
+
+    //! y += A^H x
+    template<class X, class Y>
+    void umhv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].umhv(x[j], y);
+    }
+
+    //! y -= A^H x
+    template<class X, class Y>
+    void mmhv (const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].mmhv(x[j], y);
+    }
+
+    //! y += alpha A^H x
+    template<class X, class Y>
+    void usmhv (const field_type& alpha, const X& x, Y& y) const
+    {
+      assert(this->M() == x.size());
+      for (size_type j = 0; j < this->M(); ++j)
+        (*this)[0][j].usmtv(alpha, x[j], y);
+    }
+  };
+
+} // end namespace AMDiS
diff --git a/test/BasisTester.hpp b/test/BasisTester.hpp
index 0022a295..9d93c924 100644
--- a/test/BasisTester.hpp
+++ b/test/BasisTester.hpp
@@ -89,7 +89,21 @@ namespace AMDiS
         ));
     }
 
-    auto basis(Dune::index_constant<4>) // Root: flatLexicographic, Velocity/Pressure: flatLexicographic
+    auto basis(Dune::index_constant<4>) // Root: flatLexicographic, Velocity: flatInterleaved
+    {
+      using namespace Dune::Functions::BasisBuilder;
+      return makeBasis(
+        gridView(),
+        composite(
+          power<dim>(
+            lagrange<K+1>(),
+            flatInterleaved()),
+          lagrange<K>(),
+          flatLexicographic()
+        ));
+    }
+
+    auto basis(Dune::index_constant<5>) // Root: flatLexicographic, Velocity/Pressure: flatLexicographic
     {
       using namespace Dune::Functions::BasisBuilder;
       return makeBasis(
@@ -105,7 +119,7 @@ namespace AMDiS
         ));
     }
 
-    auto basis(Dune::index_constant<5>) // Root: blockedLexicographic, Velocity/Pressure: blockedLexicographic
+    auto basis(Dune::index_constant<6>) // Root: blockedLexicographic, Velocity/Pressure: blockedLexicographic
     {
       using namespace Dune::Functions::BasisBuilder;
       return makeBasis(
@@ -121,7 +135,7 @@ namespace AMDiS
         ));
     }
 
-    auto basis(Dune::index_constant<6>) // Root: blockedLexicographic, Velocity/Pressure: on the same level
+    auto basis(Dune::index_constant<7>) // Root: blockedLexicographic, Velocity/Pressure: on the same level
     {
       using namespace Dune::Functions::BasisBuilder;
       return makeBasis(
@@ -134,20 +148,6 @@ namespace AMDiS
         ));
     }
 
-    auto basis(Dune::index_constant<7>) // Root: flatLexicographic, Velocity: flatInterleaved
-    {
-      using namespace Dune::Functions::BasisBuilder;
-      return makeBasis(
-        gridView(),
-        composite(
-          power<dim>(
-            lagrange<K+1>(),
-            flatInterleaved()),
-          lagrange<K>(),
-          flatLexicographic()
-        ));
-    }
-
     auto basis(Dune::index_constant<8>) // Root: blockedLexicographic, Velocity: blockedLexicographic
     {
       using namespace Dune::Functions::BasisBuilder;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 40d5319b..1c9d0289 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -92,6 +92,14 @@ dune_add_test(SOURCES ResizeTest.cpp
 dune_add_test(SOURCES StaticSizeTest.cpp
   LINK_LIBRARIES amdis)
 
+foreach (BASIS_ID 0;1;2;3;4)
+  dune_add_test(NAME "StokesTest_${BASIS_ID}"
+    SOURCES StokesTest.cpp
+    LINK_LIBRARIES amdis
+    COMPILE_DEFINITIONS "BASIS_ID=${BASIS_ID}")
+endforeach ()
+unset(BASIS_ID)
+
 dune_add_test(SOURCES StringTest.cpp
   LINK_LIBRARIES amdis)
 
diff --git a/test/GeneratorsTest.cpp b/test/GeneratorsTest.cpp
index 2c21ec8e..0814936f 100644
--- a/test/GeneratorsTest.cpp
+++ b/test/GeneratorsTest.cpp
@@ -99,7 +99,7 @@ int main(int argc, char** argv)
     test(tester.basis(_i), _i);
   });
 
-  Tools::for_range(std::index_sequence<4,7>{}, [&tester](auto const _i) {
+  Tools::for_range(std::index_sequence<4,5>{}, [&tester](auto const _i) {
     test2(tester.basis(_i), _i);
   });
 
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index 989003a5..0fd87604 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -177,7 +177,7 @@ template <class Traits, class BasisTester>
 void test5(BasisTester& tester)
 {
   using namespace Dune::Indices;
-  auto taylorHoodBasis = tester.basis(index_t<5>{});
+  auto taylorHoodBasis = tester.basis(index_t<6>{});
   using GlobalBasis = decltype(taylorHoodBasis);
   using Blocking = Blocking_t<GlobalBasis>;
   using Matrix = MatrixGenerator_t<double, Traits,Blocking,Blocking>;
diff --git a/test/StokesTest.cpp b/test/StokesTest.cpp
new file mode 100644
index 00000000..43fe076f
--- /dev/null
+++ b/test/StokesTest.cpp
@@ -0,0 +1,53 @@
+#include <amdis/AMDiS.hpp>
+#include <amdis/LocalOperators.hpp>
+#include <amdis/ProblemStat.hpp>
+#include <amdis/localoperators/StokesOperator.hpp>
+
+#include "BasisTester.hpp"
+
+using namespace AMDiS;
+#ifndef BASIS_ID
+#define BASIS_ID 0
+#endif
+
+int main(int argc, char** argv)
+{
+  AMDiS::init(argc, argv);
+
+  TaylorHoodBases<2,1> tester;
+
+  auto basis = tester.basis(index_t< BASIS_ID >{});
+  auto prob = makeProblemStat("stokes", tester.grid(), basis);
+  prob.initialize(INIT_ALL);
+
+  double viscosity = 1.0;
+  Parameters::get("stokes->viscosity", viscosity);
+
+  // tree-paths for components
+  auto _v = Dune::Indices::_0;
+
+  auto opStokes = makeOperator(tag::stokes{}, viscosity);
+  prob.addMatrixOperator(opStokes);
+
+  // define boundary values
+  auto parabolic_y = [](auto const& x)
+  {
+    return FieldVector<double,2>{0.0, x[1]*(1.0 - x[1])};
+  };
+
+  FieldVector<double,2> zero(0);
+
+  // set boundary conditions for velocity
+  prob.boundaryManager()->setBoxBoundary({1,2,2,2});
+  prob.addDirichletBC(1, _v, _v, parabolic_y);
+  prob.addDirichletBC(2, _v, _v, zero);
+
+  AdaptInfo adaptInfo("adapt");
+
+  // assemble and solve system
+  prob.assemble(adaptInfo);
+  prob.solve(adaptInfo);
+
+  AMDiS::finalize();
+  return 0;
+}
-- 
GitLab


From e6c0837c54a89747b3de47528f9756d8f28890c7 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Fri, 12 Apr 2019 18:59:20 +0200
Subject: [PATCH 13/38] Single-row/col-matrix generalized to multi-type
 matrices

---
 .../linearalgebra/SingleRowColMatrix.hpp      |  29 +--
 .../linearalgebra/istl/SingleRowColMatrix.hpp | 190 ++++++++++++------
 test/StokesTest.cpp                           |   1 +
 3 files changed, 136 insertions(+), 84 deletions(-)

diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index dea98f94..8b23cd7f 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -7,39 +7,14 @@ namespace AMDiS
 {
   /// Matrix-wrapper representing a matrix with a single column. Used in hierarchic block structure.
   template <class Matrix>
-  class SingleColumnMatrix
-      : public Matrix
-  {
-  public:
-    using Matrix::Matrix;
-  };
+  class SingleColumnMatrix;
 
   /// Matrix-wrapper representing a matrix with a single row. Used in hierarchic block structure.
   template <class Matrix>
-  class SingleRowMatrix
-      : public Matrix
-  {
-  public:
-    using Matrix::Matrix;
-  };
+  class SingleRowMatrix;
 
 } // end namespace AMDiS
 
-namespace Dune
-{
-  template <class Matrix>
-  class FieldTraits<AMDiS::SingleColumnMatrix<Matrix>>
-      : public FieldTraits<Matrix>
-  {};
-
-  template <class Matrix>
-  class FieldTraits<AMDiS::SingleRowMatrix<Matrix>>
-      : public FieldTraits<Matrix>
-  {};
-
-} // end namespace Dune
-
-
 namespace AMDiS
 {
   template <class Matrix>
diff --git a/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
index 1aa896d4..c22bb4df 100644
--- a/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
@@ -2,30 +2,55 @@
 
 #include <cassert>
 
+#include <dune/common/hybridutilities.hh>
+#include <dune/common/rangeutilities.hh>
+
 #include <dune/istl/matrix.hh>
+#include <dune/istl/multitypeblockmatrix.hh>
+
+#include <amdis/common/Index.hpp>
+#include <amdis/common/TypeTraits.hpp>
 #include <amdis/linearalgebra/SingleRowColMatrix.hpp>
 
 namespace AMDiS
 {
-  template <class B, class A>
-  class SingleColumnMatrix<Dune::Matrix<B,A>>
-      : public Dune::Matrix<B,A>
+  template <class Matrix>
+  class SingleColumnMatrix
+      : public Matrix
   {
-    using Super = Dune::Matrix<B,A>;
+    using Super = Matrix;
+
   public:
     using size_type = typename Super::size_type;
     using field_type = typename Super::field_type;
     using block_type = typename Super::block_type;
 
-    using Dune::Matrix<B,A>::Matrix;
+  private:
+    static constexpr index_t<0> zero = {};
+
+    template <size_type I0 = 0, class B, class A>
+    static constexpr Dune::IntegralRange<size_type> row_range(Dune::Matrix<B,A> const& mat)
+    {
+      return {I0, mat.N()};
+    }
+
+    template <size_type I0 = 0, class... Rows>
+    static constexpr auto row_range(Dune::MultiTypeBlockMatrix<Rows...> const& mat)
+    {
+      return Dune::StaticIntegralRange<size_type,TYPEOF(mat)::N(),I0>{};
+    }
+
+  public:
+    using Matrix::Matrix;
 
     //! y = A x
     template <class X, class Y>
     void mv(const X& x, Y& y) const
     {
       assert(this->N() == y.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].mv(x, y[i]);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].mv(x, y[i]);
+      });
     }
 
     //! y = A^T x
@@ -34,9 +59,10 @@ namespace AMDiS
     {
       assert(this->N() == x.size());
       assert(this->N() > 0);
-      (*this)[0][0].mtv(x[0], y);
-      for (size_type i = 1; i < y.size(); ++i)
-        (*this)[i][0].umtv(x[i], y);
+      (*this)[zero][zero].mtv(x[zero], y);
+      Dune::Hybrid::forEach(row_range<1>(*this), [&](auto i) -> void {
+        (*this)[i][zero].umtv(x[i], y);
+      });
     }
 
     //! y += A x
@@ -44,8 +70,9 @@ namespace AMDiS
     void umv(const X& x, Y& y) const
     {
       assert(this->N() == y.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].umv(x, y[i]);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].umv(x, y[i]);
+      });
     }
 
     //! y -= A x
@@ -53,8 +80,9 @@ namespace AMDiS
     void mmv (const X& x, Y& y) const
     {
       assert(this->N() == y.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].mmv(x, y[i]);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].mmv(x, y[i]);
+      });
     }
 
     /** \brief \f$ y += \alpha A x \f$ */
@@ -62,8 +90,9 @@ namespace AMDiS
     void usmv(const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->N() == y.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].usmv(alpha, x, y[i]);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].usmv(alpha, x, y[i]);
+      });
     }
 
     //! y += A^T x
@@ -71,8 +100,9 @@ namespace AMDiS
     void umtv (const X& x, Y& y) const
     {
       assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].umtv(x[i], y);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].umtv(x[i], y);
+      });
     }
 
     //! y -= A^T x
@@ -80,8 +110,9 @@ namespace AMDiS
     void mmtv (const X& x, Y& y) const
     {
       assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].mmtv(x[i], y);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].mmtv(x[i], y);
+      });
     }
 
     //! y += alpha A^T x
@@ -89,8 +120,9 @@ namespace AMDiS
     void usmtv (const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].usmtv(alpha, x[i], y);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].usmtv(alpha, x[i], y);
+      });
     }
 
     //! y += A^H x
@@ -98,8 +130,9 @@ namespace AMDiS
     void umhv (const X& x, Y& y) const
     {
       assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].umhv(x[i], y);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].umhv(x[i], y);
+      });
     }
 
     //! y -= A^H x
@@ -107,8 +140,9 @@ namespace AMDiS
     void mmhv (const X& x, Y& y) const
     {
       assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].mmhv(x[i], y);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].mmhv(x[i], y);
+      });
     }
 
     //! y += alpha A^H x
@@ -116,33 +150,51 @@ namespace AMDiS
     void usmhv (const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].usmhv(alpha, x[i], y);
+      Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
+        (*this)[i][zero].usmhv(alpha, x[i], y);
+      });
     }
   };
 
 
-
-  template <class B, class A>
-  class SingleRowMatrix<Dune::Matrix<B,A>>
-      : public Dune::Matrix<B,A>
+  template <class Matrix>
+  class SingleRowMatrix
+      : public Matrix
   {
-    using Super = Dune::Matrix<B,A>;
+    using Super = Matrix;
+
   public:
     using size_type = typename Super::size_type;
     using field_type = typename Super::field_type;
     using block_type = typename Super::block_type;
 
-    using Dune::Matrix<B,A>::Matrix;
+  private:
+    static constexpr index_t<0> zero = {};
+
+    template <size_type I0 = 0, class B, class A>
+    static constexpr Dune::IntegralRange<size_type> col_range(Dune::Matrix<B,A> const& mat)
+    {
+      return {I0, mat.M()};
+    }
+
+    template <size_type I0 = 0, class... Rows>
+    static constexpr auto col_range(Dune::MultiTypeBlockMatrix<Rows...> const& mat)
+    {
+      return Dune::StaticIntegralRange<size_type,TYPEOF(mat)::M(),I0>{};
+    }
+
+  public:
+    using Matrix::Matrix;
 
     //! y = A x
     template <class X, class Y>
     void mv(const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      (*this)[0][0].mv(x[0], y);
-      for (size_type j = 1; j < this->M(); ++j)
-        (*this)[0][j].umv(x[j], y);
+      (*this)[zero][zero].mv(x[zero], y);
+      Dune::Hybrid::forEach(col_range<1>(*this), [&](auto j) -> void {
+        (*this)[zero][j].umv(x[j], y);
+      });
     }
 
     //! y = A^T x
@@ -151,8 +203,9 @@ namespace AMDiS
     {
       assert(this->M() == y.size());
       assert(this->M() > 0);
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].mtv(x, y[j]);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].mtv(x, y[j]);
+      });
     }
 
     //! y += A x
@@ -160,8 +213,9 @@ namespace AMDiS
     void umv(const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].umv(x[j], y);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].umv(x[j], y);
+      });
     }
 
     //! y -= A x
@@ -169,8 +223,9 @@ namespace AMDiS
     void mmv (const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].mmv(x[j], y);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].mmv(x[j], y);
+      });
     }
 
     /** \brief \f$ y += \alpha A x \f$ */
@@ -178,8 +233,9 @@ namespace AMDiS
     void usmv(const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].usmv(alpha, x[j], y);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].usmv(alpha, x[j], y);
+      });
     }
 
     //! y += A^T x
@@ -187,8 +243,9 @@ namespace AMDiS
     void umtv (const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].umv(x[j], y);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].umv(x[j], y);
+      });
     }
 
     //! y -= A^T x
@@ -196,8 +253,9 @@ namespace AMDiS
     void mmtv (const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].mmtv(x[j], y);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].mmtv(x[j], y);
+      });
     }
 
     //! y += alpha A^T x
@@ -205,8 +263,9 @@ namespace AMDiS
     void usmtv (const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].usmtv(alpha, x[j], y);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].usmtv(alpha, x[j], y);
+      });
     }
 
     //! y += A^H x
@@ -214,8 +273,9 @@ namespace AMDiS
     void umhv (const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].umhv(x[j], y);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].umhv(x[j], y);
+      });
     }
 
     //! y -= A^H x
@@ -223,8 +283,9 @@ namespace AMDiS
     void mmhv (const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].mmhv(x[j], y);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].mmhv(x[j], y);
+      });
     }
 
     //! y += alpha A^H x
@@ -232,9 +293,24 @@ namespace AMDiS
     void usmhv (const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].usmtv(alpha, x[j], y);
+      Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
+        (*this)[zero][j].usmtv(alpha, x[j], y);
+      });
     }
   };
 
 } // end namespace AMDiS
+
+namespace Dune
+{
+  template <class Matrix>
+  class FieldTraits<AMDiS::SingleColumnMatrix<Matrix>>
+      : public FieldTraits<Matrix>
+  {};
+
+  template <class Matrix>
+  class FieldTraits<AMDiS::SingleRowMatrix<Matrix>>
+      : public FieldTraits<Matrix>
+  {};
+
+} // end namespace Dune
diff --git a/test/StokesTest.cpp b/test/StokesTest.cpp
index 43fe076f..4e064bfb 100644
--- a/test/StokesTest.cpp
+++ b/test/StokesTest.cpp
@@ -15,6 +15,7 @@ int main(int argc, char** argv)
   AMDiS::init(argc, argv);
 
   TaylorHoodBases<2,1> tester;
+  // tester.grid().globalRefine(4);
 
   auto basis = tester.basis(index_t< BASIS_ID >{});
   auto prob = makeProblemStat("stokes", tester.grid(), basis);
-- 
GitLab


From 6d2f39a2490e37a666fc254801bf661d318cc674 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Tue, 16 Apr 2019 16:39:16 +0200
Subject: [PATCH 14/38] clear_row and clear_col for constraints implemented

---
 examples/init/stokes.dat.2d                   |   4 +-
 examples/stokes3.cc                           |   2 +
 src/amdis/DirichletBC.hpp                     |   7 +-
 src/amdis/DirichletBC.inc.hpp                 |  25 ++--
 src/amdis/PeriodicBC.hpp                      |   4 +-
 src/amdis/PeriodicBC.inc.hpp                  |   6 +-
 src/amdis/ProblemStat.inc.hpp                 |  18 +--
 src/amdis/functions/MultiIndex.hpp            |  39 +++++-
 src/amdis/linearalgebra/Common.hpp            |  12 +-
 src/amdis/linearalgebra/Constraints.hpp       | 100 ++++++++++++--
 src/amdis/linearalgebra/DOFMatrixBase.hpp     |  17 ++-
 src/amdis/linearalgebra/DOFMatrixBase.inc.hpp |  19 ++-
 src/amdis/linearalgebra/MatrixIndexSet.hpp    | 129 +++++++++++++++++-
 .../linearalgebra/MatrixInserter.inc.hpp      |   6 +-
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp |  60 ++++++--
 src/amdis/linearalgebra/MatrixWrapperBase.hpp |  56 +++++++-
 .../linearalgebra/SingleRowColMatrix.hpp      | 104 ++++++++++----
 src/amdis/linearalgebra/VectorWrapper.inc.hpp |   4 +-
 src/amdis/linearalgebra/istl/BCRSMatrix.hpp   |  64 +++++----
 src/amdis/linearalgebra/mtl/MtlMatrix.hpp     |  79 +++++++++--
 test/MatrixTest.cpp                           |   3 +-
 test/StokesTest.cpp                           |   3 +-
 22 files changed, 624 insertions(+), 137 deletions(-)

diff --git a/examples/init/stokes.dat.2d b/examples/init/stokes.dat.2d
index 54542825..31650555 100644
--- a/examples/init/stokes.dat.2d
+++ b/examples/init/stokes.dat.2d
@@ -1,6 +1,6 @@
-stokesMesh->global refinements: 0
+stokesMesh->global refinements: 4
 stokesMesh->dimension: 1.0 1.0
-stokesMesh->num cells: 4 4
+stokesMesh->num cells: 2 2
 
 stokes->mesh: stokesMesh
 
diff --git a/examples/stokes3.cc b/examples/stokes3.cc
index 8690c60d..6533b163 100644
--- a/examples/stokes3.cc
+++ b/examples/stokes3.cc
@@ -3,6 +3,8 @@
 #include <amdis/ProblemStat.hpp>
 #include <amdis/localoperators/StokesOperator.hpp>
 
+#include <dune/istl/matrixmarket.hh>
+
 using namespace AMDiS;
 
 using Grid = Dune::YaspGrid<2>;
diff --git a/src/amdis/DirichletBC.hpp b/src/amdis/DirichletBC.hpp
index 415ef9b6..bacd3648 100644
--- a/src/amdis/DirichletBC.hpp
+++ b/src/amdis/DirichletBC.hpp
@@ -3,6 +3,7 @@
 #include <functional>
 #include <list>
 #include <memory>
+#include <set>
 #include <vector>
 
 #include <dune/common/std/optional.hh>
@@ -66,8 +67,8 @@ namespace AMDiS
     }
 
     // fill \ref dirichletNodes_ with 1 or 0 whether DOF corresponds to the boundary or not.
-    template <class RB, class CB>
-    void init(RB const& rowBasis, CB const& colBasis);
+    template <class RB, class CB, class MatIndexSet>
+    void init(RB const& rowBasis, CB const& colBasis, MatIndexSet& matIndexSet);
 
     /// \brief Apply dirichlet BC to matrix and vector, i.e., add a unit-row
     /// to the matrix and optionally delete the corresponding matrix-column.
@@ -84,7 +85,7 @@ namespace AMDiS
   private:
     Dune::Std::optional<std::function<bool(Domain)>> predicate_;
     std::function<Range(Domain)> values_;
-    std::vector<MultiIndex> dirichletNodes_;
+    std::set<MultiIndex> dirichletNodes_;
   };
 
 
diff --git a/src/amdis/DirichletBC.inc.hpp b/src/amdis/DirichletBC.inc.hpp
index bfc1ca48..d458ac59 100644
--- a/src/amdis/DirichletBC.inc.hpp
+++ b/src/amdis/DirichletBC.inc.hpp
@@ -12,9 +12,9 @@
 namespace AMDiS {
 
 template <class D, class R, class MI>
-  template <class RB, class CB>
+  template <class RB, class CB, class MatIndexSet>
 void DirichletBC<D,R,MI>::
-init(RB const& rowBasis, CB const& colBasis)
+init(RB const& rowBasis, CB const& colBasis, MatIndexSet& matIndexSet)
 {
   using Dune::Functions::forEachBoundaryDOF;
   using LV = typename CB::LocalView;
@@ -22,8 +22,12 @@ init(RB const& rowBasis, CB const& colBasis)
   dirichletNodes_.clear();
   forEachBoundaryDOF(colBasis, [&](int localIndex, LV const& localView, IS const& intersection) {
     if (onBoundary(intersection))
-      dirichletNodes_.push_back(localView.index(localIndex));
+      dirichletNodes_.insert(localView.index(localIndex));
   });
+
+  // insert diagonal entry into non-zero pattern
+  for (auto const& index : dirichletNodes_)
+    matIndexSet.insert(index,index,1);
 }
 
 
@@ -34,25 +38,26 @@ fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, R
 {
   BitVector<typename Mat::RowBlocking> bitVector;
   vectorWrapper(bitVector).resize(matrix.rowBasis());
+  vectorWrapper(bitVector).set(0);
   for (auto const& node : dirichletNodes_)
     Dune::Functions::resolveDynamicMultiIndex(bitVector,node) = 1;
 
-  auto columns = Constraints<Mat>::dirichletBC(matrix, dirichletNodes_);
+  auto columns = Constraints<Mat>::dirichletBC(matrix, dirichletNodes_, true);
 
-  Dune::Hybrid::ifElse(std::is_same<RangeType_t<RN>, R>{},
+  Dune::Hybrid::ifElse(std::is_same<RangeType_t<CN>, R>{},
     [&](auto id) -> void {
-      auto subBasis = Dune::Functions::subspaceBasis(*rhs.basis(), rowTreePath);
-      Dune::Functions::interpolate(subBasis, rhs, values_, bitVector);
+      auto subBasis = Dune::Functions::subspaceBasis(*solution.basis(), colTreePath);
+      Dune::Functions::interpolate(subBasis, solution, values_, bitVector);
     });
 
   // subtract columns of dirichlet nodes from rhs
   for (auto const& triplet : columns)
     rhs[triplet.row] -= triplet.value * solution[triplet.col];
 
-  Dune::Hybrid::ifElse(std::is_same<RangeType_t<CN>, R>{},
+  Dune::Hybrid::ifElse(std::is_same<RangeType_t<RN>, R>{},
     [&](auto id) -> void {
-      auto subBasis = Dune::Functions::subspaceBasis(*solution.basis(), colTreePath);
-      Dune::Functions::interpolate(subBasis, solution, values_, bitVector);
+      auto subBasis = Dune::Functions::subspaceBasis(*rhs.basis(), rowTreePath);
+      Dune::Functions::interpolate(subBasis, rhs, values_, bitVector);
     });
 }
 
diff --git a/src/amdis/PeriodicBC.hpp b/src/amdis/PeriodicBC.hpp
index 28ed2b33..b3864457 100644
--- a/src/amdis/PeriodicBC.hpp
+++ b/src/amdis/PeriodicBC.hpp
@@ -66,8 +66,8 @@ namespace AMDiS
       , faceTrafo_(std::move(faceTrafo))
     {}
 
-    template <class RB, class CB>
-    void init(RB const& rowBasis, CB const& colBasis);
+    template <class RB, class CB, class MatIndexSet>
+    void init(RB const& rowBasis, CB const& colBasis, MatIndexSet& matIndexSet);
 
     template <class Mat, class Sol, class Rhs, class RN, class RTP, class CN, class CTP>
     void fillBoundaryCondition(Mat& A, Sol& x, Rhs& b, RN const& rowNode, RTP rowTreePath, CN const& colNode, CTP colTreePath);
diff --git a/src/amdis/PeriodicBC.inc.hpp b/src/amdis/PeriodicBC.inc.hpp
index 90f82b2b..528bd27c 100644
--- a/src/amdis/PeriodicBC.inc.hpp
+++ b/src/amdis/PeriodicBC.inc.hpp
@@ -11,9 +11,9 @@
 namespace AMDiS {
 
 template <class D, class MI>
-  template <class RB, class CB>
+  template <class RB, class CB, class MatIndexSet>
 void PeriodicBC<D,MI>::
-init(RB const& basis, CB const& /*colBasis*/)
+init(RB const& basis, CB const& /*colBasis*/, MatIndexSet& /*matIndexSet*/)
 {
   if (!bool(hasConnectedIntersections_)) {
     hasConnectedIntersections_ = true;
@@ -35,6 +35,8 @@ init(RB const& basis, CB const& /*colBasis*/)
     initAssociations(basis);
   else
     initAssociations2(basis);
+
+  // TODO: fill matrixIndexSet with associated indices
 }
 
 
diff --git a/src/amdis/ProblemStat.inc.hpp b/src/amdis/ProblemStat.inc.hpp
index 797b7c0e..eab89fd5 100644
--- a/src/amdis/ProblemStat.inc.hpp
+++ b/src/amdis/ProblemStat.inc.hpp
@@ -421,23 +421,13 @@ buildAfterAdapt(AdaptInfo& /*adaptInfo*/, Flag /*flag*/, bool asmMatrix, bool as
   Dune::Timer t;
 
   // 1. init matrix and rhs vector and initialize dirichlet boundary conditions
-  systemMatrix_->init(asmMatrix);
+  systemMatrix_->init(asmMatrix, dirichletBCs_, periodicBCs_);
   rhs_->init(asmVector);
 
-  auto localView = globalBasis_->localView();
-  for_each_node(localView.tree(), [&,this](auto const& rowNode, auto rowTp) -> void {
-    auto rowBasis = Dune::Functions::subspaceBasis(*globalBasis_, rowTp);
-    for_each_node(localView.tree(), [&,this](auto const& colNode, auto colTp) -> void {
-      auto colBasis = Dune::Functions::subspaceBasis(*globalBasis_, colTp);
-      for (auto bc : dirichletBCs_[rowNode][colNode])
-        bc->init(rowBasis, colBasis);
-      for (auto bc : periodicBCs_[rowNode][colNode])
-        bc->init(rowBasis, colBasis);
-    });
-  });
   msg("{} total DOFs", globalBasis_->dimension());
 
   // 2. traverse grid and assemble operators on the elements
+  auto localView = globalBasis_->localView();
   for (auto const& element : elements(gridView())) {
     localView.bind(element);
 
@@ -453,8 +443,8 @@ buildAfterAdapt(AdaptInfo& /*adaptInfo*/, Flag /*flag*/, bool asmMatrix, bool as
   systemMatrix_->finish();
   rhs_->finish();
 
-  for_each_node(localView.tree(), [&,this](auto const& rowNode, auto row_tp) -> void {
-    for_each_node(localView.tree(), [&,this](auto const& colNode, auto col_tp) -> void {
+  for_each_node(localView.tree(), [&](auto const& rowNode, auto row_tp) -> void {
+    for_each_node(localView.tree(), [&](auto const& colNode, auto col_tp) -> void {
       // finish boundary condition
       for (auto bc : dirichletBCs_[rowNode][colNode])
         bc->fillBoundaryCondition(*systemMatrix_, *solution_, *rhs_, rowNode, row_tp, colNode, col_tp);
diff --git a/src/amdis/functions/MultiIndex.hpp b/src/amdis/functions/MultiIndex.hpp
index c6762e2e..9a2720ad 100644
--- a/src/amdis/functions/MultiIndex.hpp
+++ b/src/amdis/functions/MultiIndex.hpp
@@ -3,6 +3,8 @@
 #include <dune/common/reservedvector.hh>
 #include <dune/functions/functionspacebases/flatmultiindex.hh>
 
+#include <amdis/common/ConceptsBase.hpp>
+
 namespace AMDiS
 {
   inline std::size_t flatMultiIndex(std::size_t idx)
@@ -21,6 +23,36 @@ namespace AMDiS
   }
 
 
+  /// Enlarge multiIndex to allow to store another index
+  /// @{
+  template <class T>
+  void push_back(Dune::Functions::FlatMultiIndex<T>& idx) {}
+
+  template <class Vector,
+    class = void_t<decltype(std::declval<Vector>().push_back(0))>>
+  void push_back(Vector& idx)
+  {
+    idx.push_back(0);
+  }
+  /// @}
+
+  /// Return reference to last entry in multiIndex
+  // @{
+  template <class T>
+  T& back(Dune::Functions::FlatMultiIndex<T>& idx)
+  {
+    return idx[0];
+  }
+
+  template <class Vector,
+    class = void_t<decltype(std::declval<Vector>().back())>>
+  typename Vector::value_type& back(Vector& idx)
+  {
+    return idx.back();
+  }
+  /// @}
+
+
   template <class MultiIndex, std::size_t shift = 0>
   class MultiIndexIterator
   {
@@ -38,11 +70,16 @@ namespace AMDiS
     }
 
     // Go to next entry in MultiIndex
-    constexpr MultiIndexIterator<MultiIndex,shift+1> operator++() const
+    constexpr MultiIndexIterator<MultiIndex,shift+1> next() const
     {
       return {multiIndex_};
     }
 
+    constexpr MultiIndex const& multiIndex() const
+    {
+      return multiIndex_;
+    }
+
   private:
     MultiIndex const& multiIndex_;
   };
diff --git a/src/amdis/linearalgebra/Common.hpp b/src/amdis/linearalgebra/Common.hpp
index 2bd499c6..d4f72d5b 100644
--- a/src/amdis/linearalgebra/Common.hpp
+++ b/src/amdis/linearalgebra/Common.hpp
@@ -10,8 +10,16 @@ namespace AMDiS
   template <class S, class T>
   struct Triplet
   {
-    S row, col;
-    T value;
+    constexpr Triplet() = default;
+
+    template <class Row, class Col, class Values>
+    constexpr Triplet(Row&& r, Col&& c, Values&& v)
+      : row(FWD(r)), col(FWD(c)), value(FWD(v))
+    {}
+
+    S row = {};
+    S col = {};
+    T value = {};
   };
 
   template <class B, class = void>
diff --git a/src/amdis/linearalgebra/Constraints.hpp b/src/amdis/linearalgebra/Constraints.hpp
index 1ee4a71d..c5e831a4 100644
--- a/src/amdis/linearalgebra/Constraints.hpp
+++ b/src/amdis/linearalgebra/Constraints.hpp
@@ -9,17 +9,16 @@ namespace AMDiS
   struct Constraints
   {
     template <class DOFs>
-    static auto dirichletBC(Matrix& matrix, DOFs const& dofs, bool setDiagonal = true)
+    static auto dirichletBC(Matrix& matrix, DOFs const& dofs, bool symmetric = true)
     {
       /* do nothing */
       return std::array<Triplet<MultiIndex,typename Matrix::field_type>,0>{};
     }
 
-    template <class BitVec, class Assoc>
-    static auto periodicBC(Matrix& matrix, BitVec const& left, Assoc const& association, bool setDiagonal = true)
+    template <class DOFs, class Assoc>
+    static void periodicBC(Matrix& matrix, DOFs const& left, Assoc const& association, bool symmetric = true)
     {
       /* do nothing */
-      return std::array<Triplet<MultiIndex,typename Matrix::field_type>,0>{};
     }
   };
 
@@ -28,20 +27,99 @@ namespace AMDiS
   {
     using Matrix = DOFMatrixBase<RB,CB,T,VT>;
     using MultiIndex = typename RB::MultiIndex;
+    using field_type = typename Matrix::field_type;
+
+    using MatrixIndexSet = typename Matrix::HierarchicMatrixIndexSet;
+    using Inserter = typename Matrix::Inserter;
 
-    static auto dirichletBC(Matrix& matrix, std::vector<typename RB::MultiIndex> const& dofs, bool setDiagonal = true)
+    static auto dirichletBC(Matrix& matrix, std::set<MultiIndex> const& dofs, bool symmetric = true)
     {
-      for (auto const& mi : dofs)
-        matrixWrapper(matrix.matrix()).clear_row(mi, setDiagonal);
+      std::vector<Triplet<MultiIndex,field_type>> columns;
+      if (symmetric) {
+        FakeContainer col;
+        for (auto const& index : dofs) {
+          MultiIndex row;
+          matrixWrapper(matrix.matrix()).clear_col(row, index, columns);
+          matrixWrapper(matrix.matrix()).clear_row(index, col);
+        }
+      } else {
+        FakeContainer col;
+        for (auto const& index : dofs)
+          matrixWrapper(matrix.matrix()).clear_row(index, col);
+      }
 
-      return std::array<Triplet<MultiIndex,typename Matrix::field_type>,0>{};
-      // return Constraints<typename Matrix::BaseMatrix,MultiIndex>::dirichletBC(matrix.matrix(), dofs, setDiagonal);
+      Inserter inserter(matrix.matrix());
+      inserter.init(NoMatrixIndexSet{1}, false);
+      for (auto const& index : dofs)
+        inserter.insert(index, index, field_type(1));
+      inserter.finish();
+
+      return columns;
+    }
+
+
+    template <class Associations>
+    static MultiIndex const& at(Associations const& m, MultiIndex const& idx)
+    {
+      auto it = m.find(idx);
+      assert(it != m.end());
+      return it->second;
     }
 
     template <class Assoc>
-    static auto periodicBC(Matrix& matrix, std::vector<typename RB::MultiIndex> const& left, Assoc const& association, bool setDiagonal = true)
+    static void periodicBC(Matrix& matrix, std::vector<MultiIndex> const& left, Assoc const& association,
+                           bool symmetric = true)
     {
-      return Constraints<typename Matrix::BaseMatrix,MultiIndex>::periodicBC(matrix.matrix(), left, association, setDiagonal);
+      std::vector<Triplet<MultiIndex,field_type>> rowValues;
+      std::vector<Triplet<MultiIndex,field_type>> colValues;
+
+      if (symmetric) {
+        for (auto const& index : left) {
+          MultiIndex row, col;
+          matrixWrapper(matrix.matrix()).clear_col(row, index, colValues);
+          matrixWrapper(matrix.matrix()).clear_row(index, col, rowValues);
+        }
+      } else {
+        for (auto const& index : left) {
+          MultiIndex col;
+          matrixWrapper(matrix.matrix()).clear_row(index, col, rowValues);
+        }
+      }
+
+      Inserter inserter(matrix.matrix());
+      inserter.init(NoMatrixIndexSet{50}, false);
+
+      // inserter {+1, -1} into left-row / right.column
+      for (auto const& l : left) {
+        auto&& r = at(association,l);
+
+        inserter.insert(l, l, field_type(1));
+        inserter.insert(l, r, field_type(-1));
+        if (symmetric) {
+          inserter.insert(r, r, field_type(1));
+          inserter.insert(r, l, field_type(-1));
+        }
+      }
+
+      // add left-row to right-row
+      for (auto const& triple : rowValues) {
+        auto&& row = at(association,triple.row);
+        auto&& col = triple.col;
+
+        inserter.insert(row, col, triple.value);
+      }
+
+      // add left-column to right-column
+      if (symmetric) {
+        for (auto const& triple : colValues) {
+          auto&& col = at(association,triple.col);
+          auto&& row = triple.row;
+
+          inserter.insert(row, col, triple.value);
+        }
+      }
+
+      inserter.finish();
     }
   };
 
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index 9d657f74..0b42df80 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -97,6 +97,18 @@ namespace AMDiS
       return matrix_;
     }
 
+    /// Return the non-zero structure of the matrix
+    HierarchicMatrixIndexSet const& matrixIndexSet() const
+    {
+      return matrixIndexSet_;
+    }
+
+    /// Return the non-zero structure of the matrix
+    HierarchicMatrixIndexSet& matrixIndexSet()
+    {
+      return matrixIndexSet_;
+    }
+
     void resize()
     {
       resize(sizeInfo(*rowBasis_), sizeInfo(*colBasis_));
@@ -110,8 +122,9 @@ namespace AMDiS
     }
 
     /// Initialize the matrix for insertion, e.g. allocate the non-zero pattern
-    /// If \p setToZero is true, the matrix is set to 0
-    void init(bool rebuild = true);
+    /// If \p rebuild is true, the nonzero structure is rebuild and the matrix is set to 0
+    template <class... BoundaryConditions>
+    void init(bool rebuild, BoundaryConditions&... bc);
 
     /// Finish the matrix insertion, e.g. cleanup or final insertion
     void finish()
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
index cf9c5d11..a36b27b1 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <dune/functions/functionspacebases/subspacebasis.hh>
+
 #include <amdis/Assembler.hpp>
 #include <amdis/LocalOperator.hpp>
 #include <amdis/typetree/Traversal.hpp>
@@ -8,14 +10,14 @@
 namespace AMDiS {
 
 template <class RB, class CB, class T, class K>
+  template <class... BoundaryConditions>
 void DOFMatrixBase<RB,CB,T,K>::
-init(bool rebuild)
+init(bool rebuild, BoundaryConditions&... bc)
 {
   auto rowLocalView = rowBasis_->localView();
   auto colLocalView = colBasis_->localView();
 
   resize();
-  elementMatrix_.resize(rowLocalView.maxSize(), colLocalView.maxSize());
 
   if (rebuild) {
     auto matIndexSet = matrixInserter(matrixIndexSet_);
@@ -49,11 +51,24 @@ init(bool rebuild)
       rowLocalView.unbind();
       colLocalView.unbind();
     }
+
+    // init boundary conditions and maybe insert nodes into matrixIndexSet
+    for_each_node(rowLocalView.tree(), [&,this](auto const& rowNode, auto rowTp) -> void {
+      auto rowBasis = Dune::Functions::subspaceBasis(*rowBasis_, rowTp);
+      for_each_node(colLocalView.tree(), [&,this](auto const& colNode, auto colTp) -> void {
+        auto colBasis = Dune::Functions::subspaceBasis(*colBasis_, colTp);
+        Tools::for_each(std::forward_as_tuple(bc...), [&](auto& BCs) {
+          for (auto bc : BCs[rowNode][colNode])
+            bc->init(rowBasis, colBasis, matIndexSet);
+        });
+      });
+    });
   }
 
   // assign sub-pattern to matrix blocks
   inserter_ = new Inserter(matrix_);
   inserter_->init(matrixIndexSet_, rebuild);
+  elementMatrix_.resize(rowLocalView.maxSize(), colLocalView.maxSize());
 }
 
 
diff --git a/src/amdis/linearalgebra/MatrixIndexSet.hpp b/src/amdis/linearalgebra/MatrixIndexSet.hpp
index a2e2bdef..1405d23b 100644
--- a/src/amdis/linearalgebra/MatrixIndexSet.hpp
+++ b/src/amdis/linearalgebra/MatrixIndexSet.hpp
@@ -1,24 +1,145 @@
 #pragma once
 
-#include <dune/istl/matrixindexset.hh>
 #include <amdis/linearalgebra/MatrixInserter.hpp>
 #include <amdis/linearalgebra/MatrixWrapper.hpp>
 
 namespace AMDiS
 {
   class MatrixIndexSet
-      : public Dune::MatrixIndexSet
   {
   public:
-    using Dune::MatrixIndexSet::MatrixIndexSet;
-
     using size_type = std::size_t;
     using value_type = std::size_t;
     using field_type = std::size_t;
 
     static constexpr int blocklevel = 1;
+
+  public:
+    /// \brief Default constructor
+    MatrixIndexSet() = default;
+
+    /// \brief Constructor setting the matrix size
+    MatrixIndexSet(size_type rows, size_type cols)
+      : rows_(rows)
+      , cols_(cols)
+    {
+      indices_.resize(rows_);
+    }
+
+    /// \brief Reset the size of an index set
+    void resize(size_type rows, size_type cols)
+    {
+      rows_ = rows;
+      cols_ = cols;
+      indices_.resize(rows_);
+    }
+
+    /// \brief Add an index to the index set
+    void add(size_type i, size_type j)
+    {
+      indices_[i].insert(j);
+    }
+
+    /// \brief Return the number of entries
+    size_type size() const
+    {
+      size_type entries = 0;
+      for (size_type i = 0; i < rows_; ++i)
+        entries += indices_[i].size();
+
+      return entries;
+    }
+
+    /// \brief Return the number of rows
+    size_type rows() const { return rows_; }
+
+    /// \brief Return the number of entries in a given row
+    size_type rowsize(size_type row) const { return indices_[row].size(); }
+
+    std::set<size_type>& rowindices(size_type row) { return indices_[row]; }
+    std::set<size_type> const& rowindices(size_type row) const { return indices_[row]; }
+
+    /// \brief Import all nonzero entries of a sparse matrix into the index set.
+    /**
+     * \tparam Matrix Needs to be BCRSMatrix<...>
+     * \param matrix reference to the MatrixType object
+     * \param rowOffset don't write to rows<rowOffset
+     * \param colOffset don't write to cols<colOffset
+     **/
+    template <class Matrix>
+    void import(Matrix const& matrix, size_type rowOffset = 0, size_type colOffset = 0)
+    {
+      using RowType = typename Matrix::row_type;
+      using ColumnIterator = typename RowType::ConstIterator;
+
+      for (size_type r = 0; r < matrix.N(); ++r) {
+        RowType const& row = matrix[r];
+
+        ColumnIterator cIt    = row.begin();
+        ColumnIterator cEndIt = row.end();
+
+        for(; cIt != cEndIt; ++cIt)
+          add(r+rowOffset, cIt.index()+colOffset);
+      }
+    }
+
+    /// \brief Initializes a BCRSMatrix with the indices contained in this MatrixIndexSet.
+    template <class Matrix>
+    void exportIdx(Matrix& matrix) const
+    {
+      matrix.setSize(rows_, cols_);
+      matrix.setBuildMode(Matrix::random);
+
+      for (size_type i = 0; i < rows_; ++i)
+        matrix.setrowsize(i, indices_[i].size());
+
+      matrix.endrowsizes();
+
+      for (size_type i = 0; i < rows_; ++i) {
+        for (size_type index : indices_[i])
+          matrix.addindex(i, index);
+      }
+
+      matrix.endindices();
+    }
+
+  protected:
+    std::vector<std::set<size_type>> indices_;
+    size_type rows_ = 0;
+    size_type cols_ = 0;
   };
 
+  class NoMatrixIndexSet
+  {
+  public:
+    NoMatrixIndexSet(std::size_t slotSize = 1)
+      : slotSize_(slotSize)
+    {}
+
+    std::size_t rows() const
+    {
+      return 1;
+    }
+
+    std::size_t rowsize(std::size_t i) const
+    {
+      return slotSize_;
+    }
+
+    template <class MatrixType>
+    void exportIdx(MatrixType& matrix) const {}
+
+    template <class I>
+    NoMatrixIndexSet& operator[](I const& i) { return *this; }
+
+    template <class I>
+    NoMatrixIndexSet const& operator[](I const& i) const { return *this; }
+
+  private:
+    std::size_t slotSize_;
+  };
+
+
   template <class Traits>
   struct MatrixIndexSetTraits : Traits
   {
diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
index a71d92c6..0e56d460 100644
--- a/src/amdis/linearalgebra/MatrixInserter.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -84,7 +84,7 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      inserter(*row,*col).insert(++row, ++col, value, assign);
+      inserter(*row,*col).insert(row.next(), col.next(), value, assign);
     }
 
     auto& inserter(size_type i, size_type j) { return inserter_[i*cols_ + j]; }
@@ -156,8 +156,8 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      auto next_row = ++row;
-      auto next_col = ++col;
+      auto next_row = row.next();
+      auto next_col = col.next();
       Tools::for_range<0,rows>([&](auto const i) -> void {
         if (std::size_t(i) == *row)
           Tools::for_range<0,cols>([&](auto const j) -> void {
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index a5ff1482..b0254db4 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -21,10 +21,18 @@ namespace AMDiS
       : scalar_(scalar)
     {}
 
-    template <class RowIter>
-    void clear_row_impl(RowIter const& /*row*/, bool setDiagonal)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl(RowIter const& row, Col const& col, RowValues& row_values)
     {
-      scalar_ = setDiagonal ? Scalar(1) : Scalar(0);
+      row_values.emplace_back(row.multiIndex(), col, scalar_);
+      scalar_ = Scalar(0);
+    }
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl(Row const& row, ColIter const& col, ColValues& col_values)
+    {
+      col_values.emplace_back(row, col.multiIndex(), scalar_);
+      scalar_ = Scalar(0);
     }
 
     /// Return the number of nonzeros in the matrix
@@ -87,12 +95,26 @@ namespace AMDiS
       }
     }
 
-    template <class RowIter>
-    void clear_row_impl(RowIter const& row, bool setDiagonal)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
       size_type i = *row;
-      for (size_type j = 0; j < matrix_.M(); ++j)
-        wrapper(i,j).clear_row(++row, setDiagonal && i==j);
+      push_back(col);
+      for (size_type j = 0; j < matrix_.M(); ++j) {
+        back(col) = j;
+        wrapper(i,j).clear_row(row.next(), col, row_values);
+      }
+    }
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
+    {
+      size_type j = *col;
+      push_back(row);
+      for (size_type i = 0; i < matrix_.N(); ++i) {
+        back(row) = i;
+        wrapper(i,j).clear_col(row, col.next(), col_values);
+      }
     }
 
     /// Return the number of nonzeros in the matrix
@@ -149,14 +171,30 @@ namespace AMDiS
       });
     }
 
-    template <class RowIter>
-    void clear_row_impl(RowIter const& row, bool setDiagonal)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
-      auto next_row = ++row;
+      auto next_row = row.next();
+      push_back(col);
       Tools::for_range<0,rows>([&](auto const i) -> void {
         if (std::size_t(i) == *row)
           Tools::for_range<0,cols>([&](auto const j) -> void {
-            wrapper(i,j).clear_row(next_row, setDiagonal && i==j);
+            back(col) = j;
+            wrapper(i,j).clear_row(next_row, col, row_values);
+          });
+      });
+    }
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
+    {
+      auto next_col = col.next();
+      push_back(row);
+      Tools::for_range<0,cols>([&](auto const j) -> void {
+        if (std::size_t(j) == *col)
+          Tools::for_range<0,rows>([&](auto const i) -> void {
+            back(row) = i;
+            wrapper(i,j).clear_col(row, next_col, col_values);
           });
       });
     }
diff --git a/src/amdis/linearalgebra/MatrixWrapperBase.hpp b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
index 302b51b1..c16f559a 100644
--- a/src/amdis/linearalgebra/MatrixWrapperBase.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
@@ -2,6 +2,7 @@
 
 #include <type_traits>
 
+#include <amdis/common/FakeContainer.hpp>
 #include <amdis/functions/MultiIndex.hpp>
 #include <amdis/operations/Assigner.hpp>
 
@@ -30,15 +31,57 @@ namespace AMDiS
 
     /// Eliminate a row in the matrix given by a multiIndex. Optionally set the diagonal entry to 1
     template <class Row>
-    void clear_row(Row const& row, bool setDiagonal)
+    void clear_row(Row const& row)
     {
-      asImpl().clear_row_impl(multiIndexIterator(row), setDiagonal);
+      FakeContainer col;
+      clear_row(row, col);
     }
 
-    template <class Row, std::size_t r>
-    void clear_row(MultiIndexIterator<Row,r> const& row_iter, bool setDiagonal)
+    template <class Row, class Col>
+    void clear_row(Row const& row, Col&& col)
     {
-      asImpl().clear_row_impl(row_iter, setDiagonal);
+      FakeContainer row_values;
+      clear_row(row, FWD(col), row_values);
+    }
+
+    template <class Row, class Col, class RowValues>
+    void clear_row(Row const& row, Col&& col, RowValues& row_values)
+    {
+      asImpl().clear_row_impl(multiIndexIterator(row), FWD(col), row_values);
+    }
+
+    template <class Row, std::size_t r, class Col, class RowValues>
+    void clear_row(MultiIndexIterator<Row,r> const& row, Col&& col, RowValues& row_values)
+    {
+      asImpl().clear_row_impl(row, FWD(col), row_values);
+    }
+
+    /// Eliminate a row and column in the matrix given by a multiIndex. Store the column values
+    /// in the vector `columns` and optionally set the diagonal entry to 1
+    template <class Col>
+    void clear_col(Col const& col)
+    {
+      FakeContainer row;
+      clear_col(row, col);
+    }
+
+    template <class Row, class Col>
+    void clear_col(Row&& row, Col const& col)
+    {
+      FakeContainer col_values;
+      clear_col(FWD(row), col, col_values);
+    }
+
+    template <class Row, class Col, class ColValues>
+    void clear_col(Row&& row, Col const& col, ColValues& col_values)
+    {
+      asImpl().clear_col_impl(FWD(row), multiIndexIterator(col), col_values);
+    }
+
+    template <class Row, class Col, std::size_t c, class ColValues>
+    void clear_col(Row&& row, MultiIndexIterator<Col,c> const& col, ColValues& col_values)
+    {
+      asImpl().clear_col_impl(FWD(row), col, col_values);
     }
 
     /// Return the number of nonzeros in the matrix
@@ -52,6 +95,9 @@ namespace AMDiS
     template <class... Args>
     void resize_impl(Args&&...) { /* do nothing */ }
 
+    template <class... Args>
+    void clear_col_impl(Args&&...) { /* do nothing */ }
+
     template <class... Args>
     void clear_row_impl(Args&&...) { /* do nothing */ }
 
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index 8b23cd7f..bb7b1426 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -50,7 +50,7 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
     {
-      auto next_row = ++row;
+      auto next_row = row.next();
       Tools::for_range<0,Inserter::rows>([&](auto const i) -> void {
         if (std::size_t(i) == *row)
           inserter(i,index_t<0>{}).insert(next_row, col, value, assign);
@@ -60,7 +60,7 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
     {
-      inserter(*row,0).insert(++row, col, value, assign);
+      inserter(*row,0).insert(row.next(), col, value, assign);
     }
 
   protected:
@@ -133,26 +133,56 @@ namespace AMDiS
       }
     }
 
-    template <class RowIter>
-    void clear_row_impl(RowIter const& row, bool setDiagonal)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
-      clear_row_impl2(row, setDiagonal, bool_t<bool(Wrapper::DYNAMIC)>{});
+      clear_row_impl2(row, col, row_values, bool_t<bool(Wrapper::DYNAMIC)>{});
     }
 
-    template <class RowIter>
-    void clear_row_impl2(RowIter const& row, bool setDiagonal, std::false_type)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl2(RowIter const& row, Col col, RowValues& row_values, std::false_type)
     {
-      auto next_row = ++row;
+      auto next_row = row.next();
       Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
         if (std::size_t(i) == *row)
-          wrapper(i,index_t<0>{}).clear_row(next_row, setDiagonal && size_type(*row)==size_type(0));
+          wrapper(i,index_t<0>{}).clear_row(next_row, col, row_values);
       });
     }
 
-    template <class RowIter>
-    void clear_row_impl2(RowIter const& row, bool setDiagonal, std::true_type)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl2(RowIter const& row, Col col, RowValues& row_values, std::true_type)
     {
-      wrapper(*row,0).clear_row(++row, setDiagonal && size_type(*row)==size_type(0));
+      wrapper(*row,0).clear_row(row.next(), col, row_values);
+    }
+
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
+    {
+      clear_col_impl2(row, col, col_values, bool_t<bool(Wrapper::DYNAMIC)>{});
+    }
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl2(Row row, ColIter const& col, ColValues& col_values, std::false_type)
+    {
+      assert(std::size_t(*col) == 0u);
+      auto next_col = col.next();
+      push_back(row);
+      Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
+        back(row) = i;
+        wrapper(i,index_t<0>{}).clear_col(row, next_col, col_values);
+      });
+    }
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl2(Row row, ColIter const& col, ColValues& col_values, std::true_type)
+    {
+      assert(std::size_t(*col) == 0u);
+      push_back(row);
+      for (size_type i = 0; i < wrapper_.matrix_.N(); ++i) {
+        back(row) = i;
+        wrapper(i,0).clear_col(row, col.next(), col_values);
+      }
     }
 
     std::size_t nnz_impl()
@@ -205,7 +235,7 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
     {
-      auto next_col = ++col;
+      auto next_col = col.next();
       Tools::for_range<0,Inserter::cols>([&](auto const j) -> void {
         if (std::size_t(j) == *col)
           inserter(index_t<0>{},j).insert(row, next_col, value, assign);
@@ -215,7 +245,7 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
     {
-      inserter(0,*col).insert(row, ++col, value, assign);
+      inserter(0,*col).insert(row, col.next(), value, assign);
     }
 
   protected:
@@ -287,27 +317,53 @@ namespace AMDiS
       }
     }
 
-    template <class RowIter>
-    void clear_row_impl(RowIter const& row, bool setDiagonal)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
-      clear_row_impl2(row, setDiagonal, bool_t<bool(Wrapper::DYNAMIC)>{});
+      clear_row_impl2(row, col, row_values, bool_t<bool(Wrapper::DYNAMIC)>{});
     }
 
-    template <class RowIter>
-    void clear_row_impl2(RowIter const& row, bool setDiagonal, std::false_type)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl2(RowIter const& row, Col col, RowValues& row_values, std::false_type)
     {
       assert(std::size_t(*row) == 0);
+      auto next_row = row.next();
+      push_back(col);
       Tools::for_range<0,Wrapper::cols>([&](auto const j) -> void {
-        wrapper(index_t<0>{},j).clear_row(row, setDiagonal && size_type(j)==size_type(0));
+        back(col) = j;
+        wrapper(index_t<0>{},j).clear_row(next_row, col, row_values);
       });
     }
 
-    template <class RowIter>
-    void clear_row_impl2(RowIter const& row, bool setDiagonal, std::true_type)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl2(RowIter const& row, Col col, RowValues& row_values, std::true_type)
     {
       assert(std::size_t(*row) == 0);
-      for (size_type j = 0; j < wrapper_.matrix_.M(); ++j)
-        wrapper(0,j).clear_row(row, setDiagonal && j==size_type(0));
+      push_back(col);
+      for (size_type j = 0; j < wrapper_.matrix_.M(); ++j) {
+        back(col) = j;
+        wrapper(0,j).clear_row(row.next(), col, row_values);
+      }
+    }
+
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
+    {
+      clear_col_impl2(row, col, col_values, bool_t<bool(Wrapper::DYNAMIC)>{});
+    }
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl2(Row row, ColIter const& col, ColValues& col_values, std::false_type)
+    {
+      auto next_col = col.next();
+      wrapper(index_t<0>{},*col).clear_col(row, next_col, col_values);
+    }
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl2(Row row, ColIter const& col, ColValues& col_values, std::true_type)
+    {
+      wrapper(0,*col).clear_col(row, col.next(), col_values);
     }
 
     std::size_t nnz_impl()
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index 209b6ad6..cb576fea 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -105,7 +105,7 @@ namespace AMDiS
     template <class Index, class ValueType, class Assigner>
     void insert_impl(Index const& mi, ValueType const& value, Assigner assign)
     {
-      vectorWrapper(access(vector_,*mi)).insert(++mi, value, assign);
+      vectorWrapper(access(vector_,*mi)).insert(mi.next(), value, assign);
     }
 
     /// Set all entries to value
@@ -165,7 +165,7 @@ namespace AMDiS
     template <class Index, class ValueType, class Assigner>
     void insert_impl(Index const& index, ValueType const& value, Assigner assign)
     {
-      auto next = ++index;
+      auto next = index.next();
       Tools::for_range<0,dimension>([&](auto const i) -> void {
         if (std::size_t(i) == *index)
           vectorWrapper(access(vector_,i)).insert(next, value, assign);
diff --git a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
index 1976e508..81865621 100644
--- a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
@@ -47,7 +47,7 @@ namespace AMDiS
       size_type c = *col;
       test_exit_dbg( r < matrix_.N() && c < matrix_.M() ,
           "Indices out of range [0,{})x[0,{})", matrix_.N(), matrix_.M() );
-      matrixInserter(matrix_[r][c]).insert(++row, ++col, value, assign);
+      matrixInserter(matrix_[r][c]).insert(row.next(), col.next(), value, assign);
     }
 
   private:
@@ -69,18 +69,36 @@ namespace AMDiS
       : matrix_(matrix)
     {}
 
-    template <class RowIter>
-    void clear_row_impl(RowIter const& row, bool setDiagonal)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
       size_type i = *row;
       auto cIt = matrix_[i].begin();
       auto cEndIt = matrix_[i].end();
       // loop over nonzero matrix entries in current row
-      for (; cIt != cEndIt; ++cIt)
-        matrixWrapper(*cIt).clear_row(++row, setDiagonal && i == cIt.index());
+      push_back(col);
+      for (; cIt != cEndIt; ++cIt) {
+        back(col) = cIt.index();
+        matrixWrapper(*cIt).clear_row(row.next(), col, row_values);
+      }
+    }
 
-      test_exit(!setDiagonal || matrix_.exists(i,i),
-        "Can not set DirichletBC since diagonal entry does not exist.");
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
+    {
+      // iterate over the column
+      push_back(row);
+      for (size_type i = 0; i < matrix_.N(); ++i) {
+        auto cIt = matrix_[i].begin();
+        auto cEndIt = matrix_[i].end();
+        for (; cIt != cEndIt; ++cIt) {
+          if (cIt.index() == *col) {
+            back(row) = i;
+            matrixWrapper(*cIt).clear_col(row, col.next(), col_values);
+            break;
+          }
+        }
+      }
     }
 
     std::size_t nnz_impl() const
@@ -115,7 +133,7 @@ namespace AMDiS
 
     //! y = A^T x
     template<class X, class Y>
-    void mtv (const X& x, Y& y) const
+    void mtv(const X& x, Y& y) const
     {
       assert(this->N() == x.size());
       assert(this->N() > 0);
@@ -135,7 +153,7 @@ namespace AMDiS
 
     //! y -= A x
     template<class X, class Y>
-    void mmv (const X& x, Y& y) const
+    void mmv(const X& x, Y& y) const
     {
       assert(this->N() == y.size());
       for (size_type i = 0; i < this->N(); ++i)
@@ -153,7 +171,7 @@ namespace AMDiS
 
     //! y += A^T x
     template<class X, class Y>
-    void umtv (const X& x, Y& y) const
+    void umtv(const X& x, Y& y) const
     {
       assert(this->N() == x.size());
       for (size_type i = 0; i < this->N(); ++i)
@@ -162,7 +180,7 @@ namespace AMDiS
 
     //! y -= A^T x
     template<class X, class Y>
-    void mmtv (const X& x, Y& y) const
+    void mmtv(const X& x, Y& y) const
     {
       assert(this->N() == x.size());
       for (size_type i = 0; i < this->N(); ++i)
@@ -171,7 +189,7 @@ namespace AMDiS
 
     //! y += alpha A^T x
     template<class X, class Y>
-    void usmtv (const field_type& alpha, const X& x, Y& y) const
+    void usmtv(const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->N() == x.size());
       for (size_type i = 0; i < this->N(); ++i)
@@ -180,7 +198,7 @@ namespace AMDiS
 
     //! y += A^H x
     template<class X, class Y>
-    void umhv (const X& x, Y& y) const
+    void umhv(const X& x, Y& y) const
     {
       assert(this->N() == x.size());
       for (size_type i = 0; i < this->N(); ++i)
@@ -189,7 +207,7 @@ namespace AMDiS
 
     //! y -= A^H x
     template<class X, class Y>
-    void mmhv (const X& x, Y& y) const
+    void mmhv(const X& x, Y& y) const
     {
       assert(this->N() == x.size());
       for (size_type i = 0; i < this->N(); ++i)
@@ -198,7 +216,7 @@ namespace AMDiS
 
     //! y += alpha A^H x
     template<class X, class Y>
-    void usmhv (const field_type& alpha, const X& x, Y& y) const
+    void usmhv(const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->N() == x.size());
       for (size_type i = 0; i < this->N(); ++i)
@@ -232,7 +250,7 @@ namespace AMDiS
 
     //! y = A^T x
     template<class X, class Y>
-    void mtv (const X& x, Y& y) const
+    void mtv(const X& x, Y& y) const
     {
       assert(this->M() == y.size());
       assert(this->M() > 0);
@@ -251,7 +269,7 @@ namespace AMDiS
 
     //! y -= A x
     template<class X, class Y>
-    void mmv (const X& x, Y& y) const
+    void mmv(const X& x, Y& y) const
     {
       assert(this->M() == x.size());
       for (size_type j = 0; j < this->M(); ++j)
@@ -269,7 +287,7 @@ namespace AMDiS
 
     //! y += A^T x
     template<class X, class Y>
-    void umtv (const X& x, Y& y) const
+    void umtv(const X& x, Y& y) const
     {
       assert(this->M() == x.size());
       for (size_type j = 0; j < this->M(); ++j)
@@ -278,7 +296,7 @@ namespace AMDiS
 
     //! y -= A^T x
     template<class X, class Y>
-    void mmtv (const X& x, Y& y) const
+    void mmtv(const X& x, Y& y) const
     {
       assert(this->M() == x.size());
       for (size_type j = 0; j < this->M(); ++j)
@@ -287,7 +305,7 @@ namespace AMDiS
 
     //! y += alpha A^T x
     template<class X, class Y>
-    void usmtv (const field_type& alpha, const X& x, Y& y) const
+    void usmtv(const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->M() == x.size());
       for (size_type j = 0; j < this->M(); ++j)
@@ -296,7 +314,7 @@ namespace AMDiS
 
     //! y += A^H x
     template<class X, class Y>
-    void umhv (const X& x, Y& y) const
+    void umhv(const X& x, Y& y) const
     {
       assert(this->M() == x.size());
       for (size_type j = 0; j < this->M(); ++j)
@@ -305,7 +323,7 @@ namespace AMDiS
 
     //! y -= A^H x
     template<class X, class Y>
-    void mmhv (const X& x, Y& y) const
+    void mmhv(const X& x, Y& y) const
     {
       assert(this->M() == x.size());
       for (size_type j = 0; j < this->M(); ++j)
@@ -314,7 +332,7 @@ namespace AMDiS
 
     //! y += alpha A^H x
     template<class X, class Y>
-    void usmhv (const field_type& alpha, const X& x, Y& y) const
+    void usmhv(const field_type& alpha, const X& x, Y& y) const
     {
       assert(this->M() == x.size());
       for (size_type j = 0; j < this->M(); ++j)
diff --git a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
index ab8c214e..a0cf2241 100644
--- a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
@@ -75,9 +75,10 @@ namespace AMDiS
     template <class MatIndexSet>
     void calculateSlotSize(MatIndexSet const& matrixIndexSet)
     {
-      slotSize_ = 20;
+      slotSize_ = 0;
       for (std::size_t i = 0; i < matrixIndexSet.rows(); ++i)
-        slotSize_ = std::max(slotSize_, matrixIndexSet.rowsize(i));
+        slotSize_ += matrixIndexSet.rowsize(i);
+      slotSize_ = (slotSize_ + matrixIndexSet.rows() - 1) / matrixIndexSet.rows();
     }
 
   private:
@@ -123,18 +124,72 @@ namespace AMDiS
       matrix_.change_dim(rows, cols);
     }
 
-    template <class RowIter>
-    void clear_row_impl(RowIter const& row, bool setDiagonal)
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
+      size_type node = *row;
+
+      // Define the property maps
+      auto row_of = mtl::mat::row_map(matrix_);
+      auto col_of = mtl::mat::col_map(matrix_);
+      auto value  = mtl::mat::value_map(matrix_);
+
+      // iterate over the row
+      push_back(col);
+      if (std::is_same<typename BaseMatrix::orientation, mtl::mat::row_major>::value)
+      {
+        auto r = begin<mtl::tag::row>(matrix_) + node;
+        for (auto i : mtl::nz_of(r)) {  // non-zeros within row
+          back(col) = col_of(i);
+          row_values.emplace_back(row.multiIndex(), col, value(i));
+          value(i, value_type(0));
+        }
+      } else {
+        for (auto c : mtl::cols_of(matrix_)) {
+          for (auto i : mtl::nz_of(c)) {
+            if (row_of(i) == node) {
+              back(col) = col_of(i);
+              row_values.emplace_back(row.multiIndex(), col, value(i));
+              value(i, value_type(0));
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
+    {
+      size_type node = *col;
+
       // Define the property maps
-      auto row_of   = mtl::mat::row_map(matrix_);
-      auto col_of   = mtl::mat::col_map(matrix_);
-      auto set_value = mtl::mat::value_map(matrix_);
-
-      // iterate over the matrix
-	    auto r = begin<mtl::tag::row>(matrix_) + *row;
-      for (auto i : mtl::nz_of(r))  // non-zeros within row
-        set_value(i, (setDiagonal && row_of(i) == col_of(i) ? value_type(1) : value_type(0)) );
+      auto row_of = mtl::mat::row_map(matrix_);
+      auto col_of = mtl::mat::col_map(matrix_);
+      auto value  = mtl::mat::value_map(matrix_);
+
+      // iterate over the column
+      push_back(row);
+      if (std::is_same<typename BaseMatrix::orientation, mtl::mat::row_major>::value)
+      {
+        for (auto r : mtl::rows_of(matrix_)) {
+          for (auto i : mtl::nz_of(r)) {
+            if (col_of(i) == node) {
+              back(row) = row_of(i);
+              col_values.emplace_back(row, col.multiIndex(), value(i));
+              value(i, value_type(0));
+              break;
+            }
+          }
+        }
+      } else {
+        auto c = begin<mtl::tag::col>(matrix_) + node;
+        for (auto i : mtl::nz_of(c)) {
+          back(row) = row_of(i);
+          col_values.emplace_back(row, col.multiIndex(), value(i));
+          value(i, value_type(0));
+        }
+      }
     }
 
     /// Return the number of nonzeros in the matrix
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index 0fd87604..cee695e4 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -123,7 +123,8 @@ void test1(BasisTester& tester)
   std::cout << matrix_data[1][1] << "\n";
 
   std::cout << "clear_row...\n";
-  matrixWrapper(matrix_data).clear_row(idx02, true);
+  matrixWrapper(matrix_data).clear_row(idx01);
+  matrixWrapper(matrix_data).clear_row(idx02);
 
   std::cout << matrix_data[0][0] << "\n";
   std::cout << matrix_data[0][1] << "\n";
diff --git a/test/StokesTest.cpp b/test/StokesTest.cpp
index 4e064bfb..e2ffc296 100644
--- a/test/StokesTest.cpp
+++ b/test/StokesTest.cpp
@@ -15,7 +15,7 @@ int main(int argc, char** argv)
   AMDiS::init(argc, argv);
 
   TaylorHoodBases<2,1> tester;
-  // tester.grid().globalRefine(4);
+  tester.grid().globalRefine(1);
 
   auto basis = tester.basis(index_t< BASIS_ID >{});
   auto prob = makeProblemStat("stokes", tester.grid(), basis);
@@ -49,6 +49,7 @@ int main(int argc, char** argv)
   prob.assemble(adaptInfo);
   prob.solve(adaptInfo);
 
+
   AMDiS::finalize();
   return 0;
 }
-- 
GitLab


From 232dcae0b45b6469841f1a9d5e014e6e6df64a00 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 17 Apr 2019 12:36:16 +0200
Subject: [PATCH 15/38] add this-> to access member functions from lambda

---
 src/amdis/linearalgebra/MatrixInserter.inc.hpp |  6 +++---
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp  |  8 ++++----
 src/amdis/linearalgebra/SingleRowColMatrix.hpp | 14 +++++++-------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
index 0e56d460..514a896f 100644
--- a/src/amdis/linearalgebra/MatrixInserter.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -137,7 +137,7 @@ namespace AMDiS
     {
       Tools::for_range<0,rows>([&](auto const i) -> void {
         Tools::for_range<0,cols>([&](auto const j) -> void {
-          inserter(i,j).init(access(matrixIndexSet,i,j), rebuild);
+          this->inserter(i,j).init(access(matrixIndexSet,i,j), rebuild);
         });
       });
     }
@@ -147,7 +147,7 @@ namespace AMDiS
     {
       Tools::for_range<0,rows>([&](auto const i) -> void {
         Tools::for_range<0,cols>([&](auto const j) -> void {
-          inserter(i,j).finish();
+          this->inserter(i,j).finish();
         });
       });
     }
@@ -162,7 +162,7 @@ namespace AMDiS
         if (std::size_t(i) == *row)
           Tools::for_range<0,cols>([&](auto const j) -> void {
             if (std::size_t(j) == *col)
-              inserter(i,j).insert(next_row, next_col, value, assign);
+              this->inserter(i,j).insert(next_row, next_col, value, assign);
           });
       });
     }
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index b0254db4..5d519db2 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -166,7 +166,7 @@ namespace AMDiS
         rowPrefix.back() = i;
         Tools::for_range<0,cols>([&](auto const j) -> void {
           colPrefix.back() = j;
-          wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
+          this->wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
         });
       });
     }
@@ -180,7 +180,7 @@ namespace AMDiS
         if (std::size_t(i) == *row)
           Tools::for_range<0,cols>([&](auto const j) -> void {
             back(col) = j;
-            wrapper(i,j).clear_row(next_row, col, row_values);
+            this->wrapper(i,j).clear_row(next_row, col, row_values);
           });
       });
     }
@@ -194,7 +194,7 @@ namespace AMDiS
         if (std::size_t(j) == *col)
           Tools::for_range<0,rows>([&](auto const i) -> void {
             back(row) = i;
-            wrapper(i,j).clear_col(row, next_col, col_values);
+            this->wrapper(i,j).clear_col(row, next_col, col_values);
           });
       });
     }
@@ -204,7 +204,7 @@ namespace AMDiS
       std::size_t num_nonzeros = 0;
       Tools::for_range<0,rows>([&](auto const i) -> void {
         Tools::for_range<0,cols>([&](auto const j) -> void {
-          num_nonzeros += wrapper(i,j).nnz();
+          num_nonzeros += this->wrapper(i,j).nnz();
         });
       });
       return num_nonzeros;
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index bb7b1426..6bb6de61 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -53,7 +53,7 @@ namespace AMDiS
       auto next_row = row.next();
       Tools::for_range<0,Inserter::rows>([&](auto const i) -> void {
         if (std::size_t(i) == *row)
-          inserter(i,index_t<0>{}).insert(next_row, col, value, assign);
+          this->inserter(i,index_t<0>{}).insert(next_row, col, value, assign);
       });
     }
 
@@ -106,7 +106,7 @@ namespace AMDiS
       rowPrefix.push_back(0);
       Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
         rowPrefix.back() = i;
-        wrapper(i,index_t<0>{}).resize(rowSize, rowPrefix, colSize, colPrefix);
+        this->wrapper(i,index_t<0>{}).resize(rowSize, rowPrefix, colSize, colPrefix);
       });
     }
 
@@ -145,7 +145,7 @@ namespace AMDiS
       auto next_row = row.next();
       Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
         if (std::size_t(i) == *row)
-          wrapper(i,index_t<0>{}).clear_row(next_row, col, row_values);
+          this->wrapper(i,index_t<0>{}).clear_row(next_row, col, row_values);
       });
     }
 
@@ -170,7 +170,7 @@ namespace AMDiS
       push_back(row);
       Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
         back(row) = i;
-        wrapper(i,index_t<0>{}).clear_col(row, next_col, col_values);
+        this->wrapper(i,index_t<0>{}).clear_col(row, next_col, col_values);
       });
     }
 
@@ -238,7 +238,7 @@ namespace AMDiS
       auto next_col = col.next();
       Tools::for_range<0,Inserter::cols>([&](auto const j) -> void {
         if (std::size_t(j) == *col)
-          inserter(index_t<0>{},j).insert(row, next_col, value, assign);
+          this->inserter(index_t<0>{},j).insert(row, next_col, value, assign);
       });
     }
 
@@ -290,7 +290,7 @@ namespace AMDiS
       colPrefix.push_back(0);
       Tools::for_range<0,Wrapper::cols>([&](auto const j) -> void {
         colPrefix.back() = j;
-        wrapper(index_t<0>{},j).resize(rowSize, rowPrefix, colSize, colPrefix);
+        this->wrapper(index_t<0>{},j).resize(rowSize, rowPrefix, colSize, colPrefix);
       });
     }
 
@@ -331,7 +331,7 @@ namespace AMDiS
       push_back(col);
       Tools::for_range<0,Wrapper::cols>([&](auto const j) -> void {
         back(col) = j;
-        wrapper(index_t<0>{},j).clear_row(next_row, col, row_values);
+        this->wrapper(index_t<0>{},j).clear_row(next_row, col, row_values);
       });
     }
 
-- 
GitLab


From 48d41e1db475f2d05f47b6a04429d82901493e6f Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 17 Apr 2019 15:50:51 +0200
Subject: [PATCH 16/38] added hybridSize and invokeIf to shorted
 Matrix-/Vector-Wrapper

---
 src/amdis/common/CMakeLists.txt               |   1 +
 src/amdis/common/InvokeIf.hpp                 |  42 ++++
 src/amdis/linearalgebra/Constraints.hpp       |   6 +-
 src/amdis/linearalgebra/MatrixInserter.hpp    |  11 +-
 .../linearalgebra/MatrixInserter.inc.hpp      | 106 ++++-----
 src/amdis/linearalgebra/MatrixWrapper.hpp     |  14 +-
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp | 137 +++---------
 .../linearalgebra/SingleRowColMatrix.hpp      | 204 +++---------------
 src/amdis/linearalgebra/VectorWrapper.hpp     |  11 +-
 src/amdis/linearalgebra/VectorWrapper.inc.hpp |  99 ++-------
 10 files changed, 196 insertions(+), 435 deletions(-)
 create mode 100644 src/amdis/common/InvokeIf.hpp

diff --git a/src/amdis/common/CMakeLists.txt b/src/amdis/common/CMakeLists.txt
index 695c0954..1f729e3d 100644
--- a/src/amdis/common/CMakeLists.txt
+++ b/src/amdis/common/CMakeLists.txt
@@ -17,6 +17,7 @@ install(FILES
     ForEach.hpp
     HybridSize.hpp
     Index.hpp
+    InvokeIf.hpp
     Literals.hpp
     Logical.hpp
     Math.hpp
diff --git a/src/amdis/common/InvokeIf.hpp b/src/amdis/common/InvokeIf.hpp
new file mode 100644
index 00000000..0ea099ed
--- /dev/null
+++ b/src/amdis/common/InvokeIf.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <cassert>
+
+#include <dune/common/hybridutilities.hh>
+#include <dune/common/rangeutilities.hh>
+
+namespace AMDiS
+{
+  template <class T, T to, T from, class Value, class Then, class Else>
+  constexpr decltype(auto) invokeIfElse(const Dune::StaticIntegralRange<T,to,from>& cases, const Value& value,
+                                        Then&& thenBranch, Else&& elseBranch)
+  {
+    using integer_sequence = typename Dune::StaticIntegralRange<T,to,from>::integer_sequence;
+    return Dune::Hybrid::switchCases(integer_sequence{}, value, FWD(thenBranch), FWD(elseBranch));
+  }
+
+  template <class T, class Value, class Then, class Else>
+  constexpr decltype(auto) invokeIfElse(const Dune::IntegralRange<T>& cases, const Value& value,
+                                        Then&& thenBranch, Else&& elseBranch)
+  {
+    if (value >= cases[0] && value < cases[cases.size()-1])
+      return thenBranch(value);
+    else
+      return elseBranch(value);
+  }
+
+  template<class T, T to, T from, class Value, class Then>
+  constexpr void invokeIf(const Dune::StaticIntegralRange<T,to,from>& cases, const Value& value, Then&& thenBranch)
+  {
+    using integer_sequence = typename Dune::StaticIntegralRange<T,to,from>::integer_sequence;
+    Dune::Hybrid::switchCases(integer_sequence{}, value, FWD(thenBranch));
+  }
+
+  template<class T, class Value, class Then>
+  constexpr void invokeIf(const Dune::IntegralRange<T>& cases, const Value& value, Then&& thenBranch)
+  {
+    assert(value >= cases[0] && value < cases[cases.size()-1]);
+    thenBranch(value);
+  }
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/Constraints.hpp b/src/amdis/linearalgebra/Constraints.hpp
index c5e831a4..3d5dddc9 100644
--- a/src/amdis/linearalgebra/Constraints.hpp
+++ b/src/amdis/linearalgebra/Constraints.hpp
@@ -38,7 +38,7 @@ namespace AMDiS
       if (symmetric) {
         FakeContainer col;
         for (auto const& index : dofs) {
-          MultiIndex row;
+          MultiIndex row{};
           matrixWrapper(matrix.matrix()).clear_col(row, index, columns);
           matrixWrapper(matrix.matrix()).clear_row(index, col);
         }
@@ -75,13 +75,13 @@ namespace AMDiS
 
       if (symmetric) {
         for (auto const& index : left) {
-          MultiIndex row, col;
+          MultiIndex row{}, col{};
           matrixWrapper(matrix.matrix()).clear_col(row, index, colValues);
           matrixWrapper(matrix.matrix()).clear_row(index, col, rowValues);
         }
       } else {
         for (auto const& index : left) {
-          MultiIndex col;
+          MultiIndex col{};
           matrixWrapper(matrix.matrix()).clear_row(index, col, rowValues);
         }
       }
diff --git a/src/amdis/linearalgebra/MatrixInserter.hpp b/src/amdis/linearalgebra/MatrixInserter.hpp
index a86e87d6..24781a73 100644
--- a/src/amdis/linearalgebra/MatrixInserter.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.hpp
@@ -23,11 +23,14 @@ namespace AMDiS
   template <class Scalar>
   class MatrixInserterScalarImpl;
 
+  template <class BaseMatrix, class Inserter>
+  class MatrixInserterImpl;
+
   template <class BaseMatrix>
-  class MatrixInserterDynamicImpl;
+  class MatrixDynamicInserter;
 
   template <class BaseMatrix>
-  class MatrixInserterStaticImpl;
+  class MatrixStaticInserter;
 
   namespace Impl
   {
@@ -36,9 +39,9 @@ namespace AMDiS
       std::conditional_t<Dune::MatVec::IsScalarMatrix<M>::value,
         MatrixInserterScalarImpl<M>,
       std::conditional_t<Concepts::MatrixAccessible_t<M,std::size_t,std::size_t>::value,
-        MatrixInserterDynamicImpl<M>,
+        MatrixInserterImpl<M, MatrixDynamicInserter<M>>,
       std::conditional_t<Concepts::MatrixAccessible_t<M,index_t<0>,index_t<0>>::value,
-        MatrixInserterStaticImpl<M>,
+        MatrixInserterImpl<M, MatrixStaticInserter<M>>,
         MatrixInserterScalarImpl<M> >>>;
 
   } // end namespace Impl
diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
index 514a896f..5fee2125 100644
--- a/src/amdis/linearalgebra/MatrixInserter.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -8,6 +8,8 @@
 #include <amdis/Output.hpp>
 #include <amdis/common/Access.hpp>
 #include <amdis/common/ForEach.hpp>
+#include <amdis/common/HybridSize.hpp>
+#include <amdis/common/InvokeIf.hpp>
 #include <amdis/linearalgebra/Common.hpp>
 
 namespace AMDiS
@@ -41,21 +43,23 @@ namespace AMDiS
 
 
   template <class BaseMatrix>
-  class MatrixInserterDynamicImpl
-      : public MatrixInserterBase<MatrixInserterDynamicImpl<BaseMatrix>>
+  class MatrixDynamicInserter
   {
-    template <class> friend class MatrixInserter;
-
-  protected:
     using size_type = typename BaseMatrix::size_type;
     using block_type = typename BlockType<BaseMatrix>::type;
-
     using Inserter = std::vector<MatrixInserter<block_type>>;
 
-    enum { DYNAMIC = true };
+    struct AccessProxy
+    {
+      auto& operator[](size_type j) { return inserter_[i_*cols_ + j]; }
+
+      Inserter& inserter_;
+      size_type i_;
+      size_type cols_;
+    };
 
   public:
-    MatrixInserterDynamicImpl(BaseMatrix& matrix)
+    MatrixDynamicInserter(BaseMatrix& matrix)
       : rows_(matrix.N())
       , cols_(matrix.M())
     {
@@ -64,30 +68,10 @@ namespace AMDiS
           inserter_.emplace_back(access(matrix,i,j));
     }
 
-    /// Prepare the matrix for insertion of values
-    template <class MatIndexSet>
-    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
-    {
-      for (size_type i = 0; i < rows_; ++i)
-        for (size_type j = 0; j < cols_; ++j)
-          inserter(i,j).init(access(matrixIndexSet,i,j), rebuild);
-    }
-
-    /// Finish the insertion
-    void finish_impl()
-    {
-      for (auto& ins : inserter_)
-        ins.finish();
-    }
-
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
-    {
-      inserter(*row,*col).insert(row.next(), col.next(), value, assign);
-    }
+    size_type N() const { return rows_; }
+    size_type M() const { return cols_; }
 
-    auto& inserter(size_type i, size_type j) { return inserter_[i*cols_ + j]; }
+    AccessProxy operator[](size_type i) { return {inserter_,i,cols_}; }
 
   protected:
     Inserter inserter_;
@@ -97,15 +81,13 @@ namespace AMDiS
 
 
   template <class BaseMatrix>
-  class MatrixInserterStaticImpl
-      : public MatrixInserterBase<MatrixInserterStaticImpl<BaseMatrix>>
+  class MatrixStaticInserter
   {
-    template <class> friend class MatrixInserter;
-
-  protected:
+  public:
     static constexpr std::size_t rows = BaseMatrix::N();
     static constexpr std::size_t cols = BaseMatrix::M();
 
+  private:
     template <class Cols>
     static auto create_cols(Cols& col)
     {
@@ -124,19 +106,45 @@ namespace AMDiS
 
     using Inserter = TYPEOF(create(std::declval<BaseMatrix&>()));
 
-    enum { DYNAMIC = false };
+    template <std::size_t i>
+    struct AccessProxy
+    {
+      template <std::size_t j>
+      auto& operator[](index_t<j>) { return access(inserter_, index_t<i>{}, index_t<j>{}); }
+
+      Inserter& inserter_;
+    };
 
   public:
-    MatrixInserterStaticImpl(BaseMatrix& matrix)
+    MatrixStaticInserter(BaseMatrix& matrix)
       : inserter_(create(matrix))
     {}
 
+    template <std::size_t i>
+    AccessProxy<i> operator[](index_t<i>) { return {inserter_}; }
+
+  protected:
+    Inserter inserter_;
+  };
+
+
+  template <class BaseMatrix, class Inserter>
+  class MatrixInserterImpl
+      : public MatrixInserterBase<MatrixInserterImpl<BaseMatrix,Inserter>>
+  {
+    template <class> friend class MatrixInserter;
+
+  public:
+    MatrixInserterImpl(BaseMatrix& matrix)
+      : inserter_(matrix)
+    {}
+
     /// Prepare the matrix for insertion of values
     template <class MatIndexSet>
     void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
     {
-      Tools::for_range<0,rows>([&](auto const i) -> void {
-        Tools::for_range<0,cols>([&](auto const j) -> void {
+      Dune::Hybrid::forEach(hybridRows(inserter_), [&](auto i) {
+        Dune::Hybrid::forEach(hybridCols(inserter_), [&](auto j) {
           this->inserter(i,j).init(access(matrixIndexSet,i,j), rebuild);
         });
       });
@@ -145,8 +153,8 @@ namespace AMDiS
     /// Finish the insertion
     void finish_impl()
     {
-      Tools::for_range<0,rows>([&](auto const i) -> void {
-        Tools::for_range<0,cols>([&](auto const j) -> void {
+      Dune::Hybrid::forEach(hybridRows(inserter_), [&](auto i) {
+        Dune::Hybrid::forEach(hybridCols(inserter_), [&](auto j) {
           this->inserter(i,j).finish();
         });
       });
@@ -156,19 +164,15 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      auto next_row = row.next();
-      auto next_col = col.next();
-      Tools::for_range<0,rows>([&](auto const i) -> void {
-        if (std::size_t(i) == *row)
-          Tools::for_range<0,cols>([&](auto const j) -> void {
-            if (std::size_t(j) == *col)
-              this->inserter(i,j).insert(next_row, next_col, value, assign);
-          });
+      invokeIf(hybridRows(inserter_), *row, [&](auto i) {
+        invokeIf(hybridCols(inserter_), *col, [&](auto j) {
+          this->inserter(i,j).insert(row.next(), col.next(), value, assign);
+        });
       });
     }
 
     template <class I, class J>
-    auto& inserter(I const& i, J const& j) { return access(inserter_,i,j); }
+    auto& inserter(I const& i, J const& j) { return inserter_[i][j]; }
 
   protected:
     Inserter inserter_;
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
index a0b35a61..a3c3234f 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -21,9 +21,11 @@ namespace AMDiS
     return {matrix};
   }
 
-  template <class Scalar> class MatrixWrapperScalarImpl;
-  template <class BaseMatrix> class MatrixWrapperDynamicImpl;
-  template <class BaseMatrix> class MatrixWrapperStaticImpl;
+  template <class Scalar>
+  class MatrixWrapperScalarImpl;
+
+  template <class BaseMatrix>
+  class MatrixWrapperImpl;
 
   namespace Impl
   {
@@ -31,11 +33,9 @@ namespace AMDiS
     using MatrixWrapperSelector =
       std::conditional_t<Dune::MatVec::IsScalarMatrix<M>::value,
         MatrixWrapperScalarImpl<M>,
-      std::conditional_t<Concepts::MatrixAccessible_t<M,std::size_t,std::size_t>::value,
-        MatrixWrapperDynamicImpl<M>,
       std::conditional_t<Concepts::MatrixAccessible_t<M,index_t<0>,index_t<0>>::value,
-        MatrixWrapperStaticImpl<M>,
-        MatrixWrapperScalarImpl<M> >>>;
+        MatrixWrapperImpl<M>,
+        MatrixWrapperScalarImpl<M> >>;
 
   } // end namespace Impl
 
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index 5d519db2..61d35cb4 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -5,6 +5,8 @@
 #include <amdis/Output.hpp>
 #include <amdis/common/Access.hpp>
 #include <amdis/common/ForEach.hpp>
+#include <amdis/common/HybridSize.hpp>
+#include <amdis/common/InvokeIf.hpp>
 #include <amdis/common/Resize.hpp>
 #include <amdis/linearalgebra/Common.hpp>
 
@@ -51,19 +53,17 @@ namespace AMDiS
 
 
   template <class BaseMatrix>
-  class MatrixWrapperDynamicImpl
-      : public MatrixWrapperBase<MatrixWrapperDynamicImpl<BaseMatrix>>
+  class MatrixWrapperImpl
+      : public MatrixWrapperBase<MatrixWrapperImpl<BaseMatrix>>
   {
     template <class> friend class MatrixWrapper;
 
   protected:
-    using size_type = typename BaseMatrix::size_type;
-    using block_type = typename BlockType<BaseMatrix>::type;
-
-    enum { DYNAMIC = true };
+    //using size_type = typename BaseMatrix::size_type;
+    //using block_type = typename BlockType<BaseMatrix>::type;
 
   public:
-    MatrixWrapperDynamicImpl(BaseMatrix& matrix)
+    MatrixWrapperImpl(BaseMatrix& matrix)
       : matrix_(matrix)
     {}
 
@@ -72,8 +72,8 @@ namespace AMDiS
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
-      size_type rows = rowSize.size(rowPrefix);
-      size_type cols = colSize.size(colPrefix);
+      auto rows = rowSize.size(rowPrefix);
+      auto cols = colSize.size(colPrefix);
 
       // resize this matrix
       Dune::Hybrid::ifElse(Concepts::MatrixResizable_t<BaseMatrix>{}, [&](auto id) -> void {
@@ -82,128 +82,49 @@ namespace AMDiS
       });
 
       // resize all the blocks
-      if (BlockLevel<block_type>::value > 0) {
+      //if (BlockLevel<BaseMatrix>::value > 1) {
         rowPrefix.push_back(0);
         colPrefix.push_back(0);
-        for (size_type i = 0; i < rows; ++i) {
+
+        Dune::Hybrid::forEach(hybridRows(matrix_), [&](auto i) -> void {
           rowPrefix.back() = i;
-          for (size_type j = 0; j < cols; ++j) {
+          Dune::Hybrid::forEach(hybridCols(matrix_), [&](auto j) -> void {
             colPrefix.back() = j;
             wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
-          }
-        }
-      }
-    }
-
-    template <class RowIter, class Col, class RowValues>
-    void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
-    {
-      size_type i = *row;
-      push_back(col);
-      for (size_type j = 0; j < matrix_.M(); ++j) {
-        back(col) = j;
-        wrapper(i,j).clear_row(row.next(), col, row_values);
-      }
-    }
-
-    template <class Row, class ColIter, class ColValues>
-    void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
-    {
-      size_type j = *col;
-      push_back(row);
-      for (size_type i = 0; i < matrix_.N(); ++i) {
-        back(row) = i;
-        wrapper(i,j).clear_col(row, col.next(), col_values);
-      }
-    }
-
-    /// Return the number of nonzeros in the matrix
-    std::size_t nnz_impl()
-    {
-      std::size_t num_nonzeros = 0;
-      for (size_type i = 0; i < matrix_.N(); ++i)
-        for (size_type j = 0; j < matrix_.M(); ++j)
-          num_nonzeros += wrapper(i,j).nnz();
-      return num_nonzeros;
-    }
-
-  protected:
-    auto wrapper(size_type i, size_type j) { return matrixWrapper(access(matrix_,i,j)); }
-
-  protected:
-    BaseMatrix& matrix_;
-  };
-
-
-  template <class BaseMatrix>
-  class MatrixWrapperStaticImpl
-      : public MatrixWrapperBase<MatrixWrapperStaticImpl<BaseMatrix>>
-  {
-    template <class> friend class MatrixWrapper;
-
-  protected:
-    static constexpr std::size_t rows = BaseMatrix::N();
-    static constexpr std::size_t cols = BaseMatrix::M();
-
-    enum { DYNAMIC = false };
-
-  public:
-    MatrixWrapperStaticImpl(BaseMatrix& matrix)
-      : matrix_(matrix)
-    {}
-
-    template <class RowSize, class ColSize>
-    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
-    {
-      // this matrix has fixed size, so check whether it is correct
-      assert(rowSize.size(rowPrefix) == rows && colSize.size(colPrefix) == cols);
-
-      // resize all the blocks
-      rowPrefix.push_back(0);
-      colPrefix.push_back(0);
-      Tools::for_range<0,rows>([&](auto const i) -> void {
-        rowPrefix.back() = i;
-        Tools::for_range<0,cols>([&](auto const j) -> void {
-          colPrefix.back() = j;
-          this->wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
+          });
         });
-      });
+      //}
     }
 
     template <class RowIter, class Col, class RowValues>
     void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
-      auto next_row = row.next();
-      push_back(col);
-      Tools::for_range<0,rows>([&](auto const i) -> void {
-        if (std::size_t(i) == *row)
-          Tools::for_range<0,cols>([&](auto const j) -> void {
-            back(col) = j;
-            this->wrapper(i,j).clear_row(next_row, col, row_values);
-          });
+      invokeIf(hybridRows(matrix_), *row, [&](auto i) -> void {
+        push_back(col);
+        Dune::Hybrid::forEach(hybridCols(matrix_), [&](auto j) -> void {
+          this->wrapper(i,j).clear_row(row.next(), col, row_values);
+        });
       });
     }
 
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
     {
-      auto next_col = col.next();
-      push_back(row);
-      Tools::for_range<0,cols>([&](auto const j) -> void {
-        if (std::size_t(j) == *col)
-          Tools::for_range<0,rows>([&](auto const i) -> void {
-            back(row) = i;
-            this->wrapper(i,j).clear_col(row, next_col, col_values);
-          });
+      invokeIf(hybridCols(matrix_), *col, [&](auto j) -> void {
+        push_back(row);
+        Dune::Hybrid::forEach(hybridRows(matrix_), [&](auto i) -> void {
+          back(row) = i;
+          this->wrapper(i,j).clear_col(row, col.next(), col_values);
+        });
       });
     }
 
+    /// Return the number of nonzeros in the matrix
     std::size_t nnz_impl()
     {
       std::size_t num_nonzeros = 0;
-      Tools::for_range<0,rows>([&](auto const i) -> void {
-        Tools::for_range<0,cols>([&](auto const j) -> void {
+      Dune::Hybrid::forEach(hybridRows(matrix_), [&](auto i) -> void {
+        Dune::Hybrid::forEach(hybridCols(matrix_), [&](auto j) -> void {
           num_nonzeros += this->wrapper(i,j).nnz();
         });
       });
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index 6bb6de61..ee9106af 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -44,25 +44,11 @@ namespace AMDiS
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      insert_impl2(row, col, value, assign, bool_t<bool(Inserter::DYNAMIC)>{});
-    }
-
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
-    {
-      auto next_row = row.next();
-      Tools::for_range<0,Inserter::rows>([&](auto const i) -> void {
-        if (std::size_t(i) == *row)
-          this->inserter(i,index_t<0>{}).insert(next_row, col, value, assign);
+      invokeIf(hybridRows(inserter_.inserter_), *row, [&](auto i) {
+        this->inserter(i,index_t<0>{}).insert(row.next(), col, value, assign);
       });
     }
 
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
-    {
-      inserter(*row,0).insert(row.next(), col, value, assign);
-    }
-
   protected:
     template <class I, class J>
     auto& inserter(I const& i, J const& j) { return inserter_.inserter(i,j); }
@@ -78,44 +64,19 @@ namespace AMDiS
   {
     using BaseMatrix = SingleColumnMatrix<Matrix>;
     using Wrapper = Impl::MatrixWrapperSelector<Matrix>;
-    using size_type = typename Wrapper::size_type;
-    using block_type = typename Wrapper::block_type;
+    //using size_type = typename Wrapper::size_type;
+    //using block_type = typename Wrapper::block_type;
 
   public:
     MatrixWrapper(BaseMatrix& matrix)
       : wrapper_(matrix)
     {}
 
-    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
     template <class RowSize, class ColSize>
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
-    {
-      resize_impl2(rowSize, rowPrefix, colSize, colPrefix, bool_t<bool(Wrapper::DYNAMIC)>{});
-    }
-
-    template <class RowSize, class ColSize>
-    void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
-                      std::false_type /* is_not_dynamic */)
-    {
-      // this matrix has fixed size, so check whether it is correct
-      assert(rowSize.size(rowPrefix) == Wrapper::rows);
-
-      // resize all the blocks
-      rowPrefix.push_back(0);
-      Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
-        rowPrefix.back() = i;
-        this->wrapper(i,index_t<0>{}).resize(rowSize, rowPrefix, colSize, colPrefix);
-      });
-    }
-
-    template <class RowSize, class ColSize>
-    void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
-                      std::true_type /* is_dynamic */)
+                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
-      size_type rows = rowSize.size(rowPrefix);
+      auto rows = rowSize.size(rowPrefix);
 
       // resize this matrix
       Dune::Hybrid::ifElse(Concepts::MatrixResizable_t<Matrix>{}, [&](auto id) -> void {
@@ -124,67 +85,34 @@ namespace AMDiS
       });
 
       // resize all the blocks
-      if (BlockLevel<block_type>::value > 0) {
+      //if (BlockLevel<Matrix>::value > 1) {
         rowPrefix.push_back(0);
-        for (size_type i = 0; i < rows; ++i) {
+        Dune::Hybrid::forEach(hybridRows(wrapper_.matrix_), [&](auto i) {
           rowPrefix.back() = i;
-          wrapper(i,0).resize(rowSize, rowPrefix, colSize, colPrefix);
-        }
-      }
+          this->wrapper(i,index_t<0>{}).resize(rowSize, rowPrefix, colSize, colPrefix);
+        });
+      //}
     }
 
     template <class RowIter, class Col, class RowValues>
     void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
-      clear_row_impl2(row, col, row_values, bool_t<bool(Wrapper::DYNAMIC)>{});
-    }
-
-    template <class RowIter, class Col, class RowValues>
-    void clear_row_impl2(RowIter const& row, Col col, RowValues& row_values, std::false_type)
-    {
-      auto next_row = row.next();
-      Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
-        if (std::size_t(i) == *row)
-          this->wrapper(i,index_t<0>{}).clear_row(next_row, col, row_values);
+      invokeIf(hybridRows(wrapper_.matrix_), *row, [&](auto i) {
+        this->wrapper(i,index_t<0>{}).clear_row(row.next(), col, row_values);
       });
     }
 
-    template <class RowIter, class Col, class RowValues>
-    void clear_row_impl2(RowIter const& row, Col col, RowValues& row_values, std::true_type)
-    {
-      wrapper(*row,0).clear_row(row.next(), col, row_values);
-    }
-
-
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
-    {
-      clear_col_impl2(row, col, col_values, bool_t<bool(Wrapper::DYNAMIC)>{});
-    }
-
-    template <class Row, class ColIter, class ColValues>
-    void clear_col_impl2(Row row, ColIter const& col, ColValues& col_values, std::false_type)
     {
       assert(std::size_t(*col) == 0u);
-      auto next_col = col.next();
       push_back(row);
-      Tools::for_range<0,Wrapper::rows>([&](auto const i) -> void {
+      Dune::Hybrid::forEach(hybridRows(wrapper_.matrix_), [&](auto i) {
         back(row) = i;
-        this->wrapper(i,index_t<0>{}).clear_col(row, next_col, col_values);
+        this->wrapper(i,index_t<0>{}).clear_col(row, col.next(), col_values);
       });
     }
 
-    template <class Row, class ColIter, class ColValues>
-    void clear_col_impl2(Row row, ColIter const& col, ColValues& col_values, std::true_type)
-    {
-      assert(std::size_t(*col) == 0u);
-      push_back(row);
-      for (size_type i = 0; i < wrapper_.matrix_.N(); ++i) {
-        back(row) = i;
-        wrapper(i,0).clear_col(row, col.next(), col_values);
-      }
-    }
-
     std::size_t nnz_impl()
     {
       return wrapper_.nnz();
@@ -225,29 +153,14 @@ namespace AMDiS
       inserter_.finish();
     }
 
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      insert_impl2(row, col, value, assign, bool_t<bool(Inserter::DYNAMIC)>{});
-    }
-
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::false_type)
-    {
-      auto next_col = col.next();
-      Tools::for_range<0,Inserter::cols>([&](auto const j) -> void {
-        if (std::size_t(j) == *col)
-          this->inserter(index_t<0>{},j).insert(row, next_col, value, assign);
+      invokeIf(hybridCols(inserter_.inserter_), *col, [&](auto j) {
+        this->inserter(index_t<0>{},j).insert(row, col.next(), value, assign);
       });
     }
 
-    template <class Row, class Col, class ValueType, class Assigner>
-    void insert_impl2(Row const& row, Col const& col, ValueType const& value, Assigner assign, std::true_type)
-    {
-      inserter(0,*col).insert(row, col.next(), value, assign);
-    }
-
   protected:
     template <class I, class J>
     auto& inserter(I const& i, J const& j) { return inserter_.inserter(i,j); }
@@ -262,44 +175,19 @@ namespace AMDiS
   {
     using BaseMatrix = SingleRowMatrix<Matrix>;
     using Wrapper = Impl::MatrixWrapperSelector<Matrix>;
-    using size_type = typename Wrapper::size_type;
-    using block_type = typename Wrapper::block_type;
+    //using size_type = typename Wrapper::size_type;
+    //using block_type = typename Wrapper::block_type;
 
   public:
     MatrixWrapper(BaseMatrix& matrix)
       : wrapper_(matrix)
     {}
 
-    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
     template <class RowSize, class ColSize>
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
-    {
-      resize_impl2(rowSize, rowPrefix, colSize, colPrefix, bool_t<bool(Wrapper::DYNAMIC)>{});
-    }
-
-    template <class RowSize, class ColSize>
-    void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
-                      std::false_type /* is_not_dynamic */)
-    {
-      // this matrix has fixed size, so check whether it is correct
-      assert(colSize.size(colPrefix) == Wrapper::cols);
-
-      // resize all the blocks
-      colPrefix.push_back(0);
-      Tools::for_range<0,Wrapper::cols>([&](auto const j) -> void {
-        colPrefix.back() = j;
-        this->wrapper(index_t<0>{},j).resize(rowSize, rowPrefix, colSize, colPrefix);
-      });
-    }
-
-    template <class RowSize, class ColSize>
-    void resize_impl2(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
-                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix,
-                      std::true_type /* is_dynamic */)
+                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
-      size_type cols = colSize.size(colPrefix);
+      auto cols = colSize.size(colPrefix);
 
       // resize this matrix
       Dune::Hybrid::ifElse(Concepts::MatrixResizable_t<Matrix>{}, [&](auto id) -> void {
@@ -308,62 +196,32 @@ namespace AMDiS
       });
 
       // resize all the blocks
-      if (BlockLevel<block_type>::value > 0) {
+      //if (BlockLevel<Matrix>::value > 1) {
         colPrefix.push_back(0);
-        for (size_type j = 0; j < cols; ++j) {
+        Dune::Hybrid::forEach(hybridCols(wrapper_.matrix_), [&](auto j) {
           colPrefix.back() = j;
-          wrapper(0,j).resize(rowSize, rowPrefix, colSize, colPrefix);
-        }
-      }
+          this->wrapper(index_t<0>{},j).resize(rowSize, rowPrefix, colSize, colPrefix);
+        });
+      //}
     }
 
     template <class RowIter, class Col, class RowValues>
     void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
-    {
-      clear_row_impl2(row, col, row_values, bool_t<bool(Wrapper::DYNAMIC)>{});
-    }
-
-    template <class RowIter, class Col, class RowValues>
-    void clear_row_impl2(RowIter const& row, Col col, RowValues& row_values, std::false_type)
     {
       assert(std::size_t(*row) == 0);
-      auto next_row = row.next();
       push_back(col);
-      Tools::for_range<0,Wrapper::cols>([&](auto const j) -> void {
+      Dune::Hybrid::forEach(hybridCols(wrapper_.matrix_), [&](auto j) {
         back(col) = j;
-        this->wrapper(index_t<0>{},j).clear_row(next_row, col, row_values);
+        this->wrapper(index_t<0>{},j).clear_row(row.next(), col, row_values);
       });
     }
 
-    template <class RowIter, class Col, class RowValues>
-    void clear_row_impl2(RowIter const& row, Col col, RowValues& row_values, std::true_type)
-    {
-      assert(std::size_t(*row) == 0);
-      push_back(col);
-      for (size_type j = 0; j < wrapper_.matrix_.M(); ++j) {
-        back(col) = j;
-        wrapper(0,j).clear_row(row.next(), col, row_values);
-      }
-    }
-
-
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
     {
-      clear_col_impl2(row, col, col_values, bool_t<bool(Wrapper::DYNAMIC)>{});
-    }
-
-    template <class Row, class ColIter, class ColValues>
-    void clear_col_impl2(Row row, ColIter const& col, ColValues& col_values, std::false_type)
-    {
-      auto next_col = col.next();
-      wrapper(index_t<0>{},*col).clear_col(row, next_col, col_values);
-    }
-
-    template <class Row, class ColIter, class ColValues>
-    void clear_col_impl2(Row row, ColIter const& col, ColValues& col_values, std::true_type)
-    {
-      wrapper(0,*col).clear_col(row, col.next(), col_values);
+      invokeIf(hybridCols(wrapper_.matrix_), *col, [&](auto j) {
+        this->wrapper(index_t<0>{},j).clear_col(row, col.next(), col_values);
+      });
     }
 
     std::size_t nnz_impl()
diff --git a/src/amdis/linearalgebra/VectorWrapper.hpp b/src/amdis/linearalgebra/VectorWrapper.hpp
index 13418db7..2341eb9d 100644
--- a/src/amdis/linearalgebra/VectorWrapper.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.hpp
@@ -25,10 +25,7 @@ namespace AMDiS
   class VectorWrapperScalarImpl;
 
   template <class BaseVector>
-  class VectorWrapperDynamicImpl;
-
-  template <class BaseVector>
-  class VectorWrapperStaticImpl;
+  class VectorWrapperImpl;
 
   namespace Impl
   {
@@ -36,11 +33,9 @@ namespace AMDiS
     using VectorWrapperSelector =
       std::conditional_t<Dune::MatVec::IsScalarVector<V>::value,
         VectorWrapperScalarImpl<V>,
-      std::conditional_t<Concepts::VectorAccessible_t<V,std::size_t>::value,
-        VectorWrapperDynamicImpl<V>,
       std::conditional_t<Concepts::VectorAccessible_t<V,index_t<0>>::value,
-        VectorWrapperStaticImpl<V>,
-        VectorWrapperScalarImpl<V> >>>;
+        VectorWrapperImpl<V>,
+        VectorWrapperScalarImpl<V> >>;
 
   } // end namespace Impl
 
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index cb576fea..f2da9741 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -51,17 +51,14 @@ namespace AMDiS
 
 
   template <class BaseVector>
-  class VectorWrapperDynamicImpl
-      : public VectorWrapperBase<VectorWrapperDynamicImpl<BaseVector>>
+  class VectorWrapperImpl
+      : public VectorWrapperBase<VectorWrapperImpl<BaseVector>>
   {
-    using size_type = typename BaseVector::size_type;
-    using block_type = typename BlockType<BaseVector>::type;
-
-    template <class V>
-    using HasResize = decltype(std::declval<V>().resize(0u),0);
+    //using size_type = typename BaseVector::size_type;
+    //using block_type = typename BlockType<BaseVector>::type;
 
   public:
-    VectorWrapperDynamicImpl(BaseVector& vector)
+    VectorWrapperImpl(BaseVector& vector)
       : vector_(vector)
     {}
 
@@ -69,7 +66,7 @@ namespace AMDiS
     template <class SizeProvider>
     void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
-      size_type size = sizeProvider.size(prefix);
+      auto size = sizeProvider.size(prefix);
 
       // resize this vector
       Dune::Hybrid::ifElse(Concepts::VectorResizable_t<BaseVector>{}, [&](auto id) -> void {
@@ -78,86 +75,28 @@ namespace AMDiS
       });
 
       // resize all the blocks
-      if (BlockLevel<block_type>::value > 0) {
+      //if (BlockLevel<BaseVector>::value > 1) {
         prefix.push_back(0);
-        for (size_type i = 0; i < size; ++i) {
+        Dune::Hybrid::forEach(hybridElements(vector_), [&] (auto i) {
           prefix.back() = i;
           vectorWrapper(access(vector_,i)).resize(sizeProvider, prefix);
-        }
-      }
-    }
-
-    /// Prepare the vector for insertion of values
-    void init_impl(bool rebuild)
-    {
-      for (auto& v : vector_)
-        vectorWrapper(v).init(rebuild);
-    }
-
-    /// Finish the insertion
-    void finish_impl()
-    {
-      for (auto& v : vector_)
-        vectorWrapper(v).finish();
-    }
-
-    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
-    template <class Index, class ValueType, class Assigner>
-    void insert_impl(Index const& mi, ValueType const& value, Assigner assign)
-    {
-      vectorWrapper(access(vector_,*mi)).insert(mi.next(), value, assign);
-    }
-
-    /// Set all entries to value
-    template <class ValueType>
-    void set_impl(ValueType const& value)
-    {
-      for (auto& v : vector_)
-        vectorWrapper(v).set(value);
-    }
-
-  private:
-    BaseVector& vector_;
-  };
-
-  template <class BaseVector>
-  class VectorWrapperStaticImpl
-      : public VectorWrapperBase<VectorWrapperStaticImpl<BaseVector>>
-  {
-    static constexpr std::size_t dimension = BaseVector::size();
-
-  public:
-    VectorWrapperStaticImpl(BaseVector& vector)
-      : vector_(vector)
-    {}
-
-    /// Resize \ref vector_ to desired size
-    template <class SizeProvider>
-    void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
-    {
-      assert(sizeProvider.size(prefix) == dimension);
-
-      // resize blocks
-      prefix.push_back(0);
-      Tools::for_range<0,dimension>([&](auto const i) -> void {
-        prefix.back() = i;
-        vectorWrapper(access(vector_,i)).resize(sizeProvider, prefix);
-      });
+        });
+      //}
     }
 
     /// Prepare the vector for insertion of values
     void init_impl(bool rebuild)
     {
-      Tools::for_each(vector_, [rebuild](auto& v) -> void {
-        vectorWrapper(v).init(rebuild);
+      Dune::Hybrid::forEach(hybridElements(vector_), [&] (auto i) {
+        vectorWrapper(access(vector_,i)).init(rebuild);
       });
     }
 
     /// Finish the insertion
     void finish_impl()
     {
-      Tools::for_each(vector_, [](auto& v) -> void {
-        vectorWrapper(v).finish();
+      Dune::Hybrid::forEach(hybridElements(vector_), [&] (auto i) {
+        vectorWrapper(access(vector_,i)).finish();
       });
     }
 
@@ -165,10 +104,8 @@ namespace AMDiS
     template <class Index, class ValueType, class Assigner>
     void insert_impl(Index const& index, ValueType const& value, Assigner assign)
     {
-      auto next = index.next();
-      Tools::for_range<0,dimension>([&](auto const i) -> void {
-        if (std::size_t(i) == *index)
-          vectorWrapper(access(vector_,i)).insert(next, value, assign);
+      invokeIf(hybridElements(vector_), *index, [&](auto i) {
+        vectorWrapper(access(vector_,i)).insert(index.next(), value, assign);
       });
     }
 
@@ -176,8 +113,8 @@ namespace AMDiS
     template <class ValueType>
     void set_impl(ValueType const& value)
     {
-      Tools::for_each(vector_, [value](auto& v) -> void {
-        vectorWrapper(v).set(value);
+      Dune::Hybrid::forEach(hybridElements(vector_), [&] (auto i) {
+        vectorWrapper(access(vector_,i)).set(value);
       });
     }
 
-- 
GitLab


From ed55f11055d6d81ff929ace3ba563d5f4c807fe0 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 17 Apr 2019 17:57:13 +0200
Subject: [PATCH 17/38] cleaned up hybrid switchCases

---
 src/amdis/common/CMakeLists.txt               |  1 -
 src/amdis/common/InvokeIf.hpp                 | 42 -------------
 src/amdis/functions/MultiIndex.hpp            |  3 +-
 src/amdis/linearalgebra/DOFMatrixBase.hpp     |  4 +-
 src/amdis/linearalgebra/DOFMatrixBase.inc.hpp | 49 ++++++++-------
 .../linearalgebra/MatrixInserter.inc.hpp      | 23 +++----
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp | 43 +++++++------
 .../linearalgebra/SingleRowColMatrix.hpp      | 57 ++++++++++--------
 src/amdis/linearalgebra/VectorWrapper.inc.hpp | 60 +++++++------------
 src/amdis/linearalgebra/VectorWrapperBase.hpp | 16 +++++
 test/MatrixWrapperTest.cpp                    |  4 +-
 11 files changed, 133 insertions(+), 169 deletions(-)
 delete mode 100644 src/amdis/common/InvokeIf.hpp

diff --git a/src/amdis/common/CMakeLists.txt b/src/amdis/common/CMakeLists.txt
index 1f729e3d..695c0954 100644
--- a/src/amdis/common/CMakeLists.txt
+++ b/src/amdis/common/CMakeLists.txt
@@ -17,7 +17,6 @@ install(FILES
     ForEach.hpp
     HybridSize.hpp
     Index.hpp
-    InvokeIf.hpp
     Literals.hpp
     Logical.hpp
     Math.hpp
diff --git a/src/amdis/common/InvokeIf.hpp b/src/amdis/common/InvokeIf.hpp
deleted file mode 100644
index 0ea099ed..00000000
--- a/src/amdis/common/InvokeIf.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include <cassert>
-
-#include <dune/common/hybridutilities.hh>
-#include <dune/common/rangeutilities.hh>
-
-namespace AMDiS
-{
-  template <class T, T to, T from, class Value, class Then, class Else>
-  constexpr decltype(auto) invokeIfElse(const Dune::StaticIntegralRange<T,to,from>& cases, const Value& value,
-                                        Then&& thenBranch, Else&& elseBranch)
-  {
-    using integer_sequence = typename Dune::StaticIntegralRange<T,to,from>::integer_sequence;
-    return Dune::Hybrid::switchCases(integer_sequence{}, value, FWD(thenBranch), FWD(elseBranch));
-  }
-
-  template <class T, class Value, class Then, class Else>
-  constexpr decltype(auto) invokeIfElse(const Dune::IntegralRange<T>& cases, const Value& value,
-                                        Then&& thenBranch, Else&& elseBranch)
-  {
-    if (value >= cases[0] && value < cases[cases.size()-1])
-      return thenBranch(value);
-    else
-      return elseBranch(value);
-  }
-
-  template<class T, T to, T from, class Value, class Then>
-  constexpr void invokeIf(const Dune::StaticIntegralRange<T,to,from>& cases, const Value& value, Then&& thenBranch)
-  {
-    using integer_sequence = typename Dune::StaticIntegralRange<T,to,from>::integer_sequence;
-    Dune::Hybrid::switchCases(integer_sequence{}, value, FWD(thenBranch));
-  }
-
-  template<class T, class Value, class Then>
-  constexpr void invokeIf(const Dune::IntegralRange<T>& cases, const Value& value, Then&& thenBranch)
-  {
-    assert(value >= cases[0] && value < cases[cases.size()-1]);
-    thenBranch(value);
-  }
-
-} // end namespace AMDiS
diff --git a/src/amdis/functions/MultiIndex.hpp b/src/amdis/functions/MultiIndex.hpp
index 9a2720ad..81f9058d 100644
--- a/src/amdis/functions/MultiIndex.hpp
+++ b/src/amdis/functions/MultiIndex.hpp
@@ -69,12 +69,13 @@ namespace AMDiS
       return shift < multiIndex_.size() ? multiIndex_[shift] : size_type(0);
     }
 
-    // Go to next entry in MultiIndex
+    /// Return an iterator to the next entry in MultiIndex
     constexpr MultiIndexIterator<MultiIndex,shift+1> next() const
     {
       return {multiIndex_};
     }
 
+    /// Return the managed multiIndex
     constexpr MultiIndex const& multiIndex() const
     {
       return multiIndex_;
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index 0b42df80..6c51fe2f 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -123,8 +123,8 @@ namespace AMDiS
 
     /// Initialize the matrix for insertion, e.g. allocate the non-zero pattern
     /// If \p rebuild is true, the nonzero structure is rebuild and the matrix is set to 0
-    template <class... BoundaryConditions>
-    void init(bool rebuild, BoundaryConditions&... bc);
+    template <class DBC, class PBC>
+    void init(bool rebuild, DBC& dbc, PBC& pbc);
 
     /// Finish the matrix insertion, e.g. cleanup or final insertion
     void finish()
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
index a36b27b1..beedff7c 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
@@ -10,9 +10,9 @@
 namespace AMDiS {
 
 template <class RB, class CB, class T, class K>
-  template <class... BoundaryConditions>
+  template <class DBC, class PBC>
 void DOFMatrixBase<RB,CB,T,K>::
-init(bool rebuild, BoundaryConditions&... bc)
+init(bool rebuild, DBC& dbc, PBC& pbc)
 {
   auto rowLocalView = rowBasis_->localView();
   auto colLocalView = colBasis_->localView();
@@ -29,23 +29,22 @@ init(bool rebuild, BoundaryConditions&... bc)
       colLocalView.bind(e);
 
       for_each_node(rowLocalView.tree(), [&](auto const& rowNode, auto&&) -> void {
-        for_each_node(colLocalView.tree(), [&](auto const& colNode, auto&&) -> void {
-          if (operators_[rowNode][colNode])
-	        {
-            for_each_leaf_node(rowNode, [&](auto const& rowLeafNode, auto&&) {
-              for_each_leaf_node(colNode, [&](auto const& colLeafNode, auto&&) {
-                std::size_t rowSize = rowLeafNode.finiteElement().size();
-                std::size_t colSize = colLeafNode.finiteElement().size();
-                for (std::size_t i = 0; i < rowSize; ++i)
-                  for (std::size_t j = 0; j < colSize; ++j)
-                    matIndexSet.insert(
-                      rowLocalView.index(rowLeafNode.localIndex(i)),
-                      colLocalView.index(colLeafNode.localIndex(j)),
-                      1);
-              });
-            });
-          }
-        });
+      for_each_node(colLocalView.tree(), [&](auto const& colNode, auto&&) -> void {
+        if (operators_[rowNode][colNode]) {
+          for_each_leaf_node(rowNode, [&](auto const& rowLeafNode, auto&&) -> void {
+          for_each_leaf_node(colNode, [&](auto const& colLeafNode, auto&&) -> void {
+            std::size_t rowSize = rowLeafNode.finiteElement().size();
+            std::size_t colSize = colLeafNode.finiteElement().size();
+            for (std::size_t i = 0; i < rowSize; ++i)
+              for (std::size_t j = 0; j < colSize; ++j)
+                matIndexSet.insert(
+                  rowLocalView.index(rowLeafNode.localIndex(i)),
+                  colLocalView.index(colLeafNode.localIndex(j)),
+                  1);
+          });
+          });
+        }
+      });
       });
 
       rowLocalView.unbind();
@@ -53,14 +52,14 @@ init(bool rebuild, BoundaryConditions&... bc)
     }
 
     // init boundary conditions and maybe insert nodes into matrixIndexSet
-    for_each_node(rowLocalView.tree(), [&,this](auto const& rowNode, auto rowTp) -> void {
+    for_each_node(rowLocalView.tree(), [&](auto const& rowNode, auto rowTp) -> void {
       auto rowBasis = Dune::Functions::subspaceBasis(*rowBasis_, rowTp);
-      for_each_node(colLocalView.tree(), [&,this](auto const& colNode, auto colTp) -> void {
+      for_each_node(colLocalView.tree(), [&](auto const& colNode, auto colTp) -> void {
         auto colBasis = Dune::Functions::subspaceBasis(*colBasis_, colTp);
-        Tools::for_each(std::forward_as_tuple(bc...), [&](auto& BCs) {
-          for (auto bc : BCs[rowNode][colNode])
-            bc->init(rowBasis, colBasis, matIndexSet);
-        });
+        for (auto bc : dbc[rowNode][colNode])
+          bc->init(rowBasis, colBasis, matIndexSet);
+        for (auto bc : pbc[rowNode][colNode])
+          bc->init(rowBasis, colBasis, matIndexSet);
       });
     });
   }
diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
index 5fee2125..549e6673 100644
--- a/src/amdis/linearalgebra/MatrixInserter.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -9,7 +9,7 @@
 #include <amdis/common/Access.hpp>
 #include <amdis/common/ForEach.hpp>
 #include <amdis/common/HybridSize.hpp>
-#include <amdis/common/InvokeIf.hpp>
+#include <amdis/common/SwitchCases.hpp>
 #include <amdis/linearalgebra/Common.hpp>
 
 namespace AMDiS
@@ -25,7 +25,7 @@ namespace AMDiS
       : scalar_(scalar)
     {}
 
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    /// Implements \ref MatrixInserterBase::insert
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
@@ -139,38 +139,39 @@ namespace AMDiS
       : inserter_(matrix)
     {}
 
-    /// Prepare the matrix for insertion of values
+    /// Implements \ref MatrixInserterBase::init
     template <class MatIndexSet>
     void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
     {
-      Dune::Hybrid::forEach(hybridRows(inserter_), [&](auto i) {
-        Dune::Hybrid::forEach(hybridCols(inserter_), [&](auto j) {
+      Dune::Hybrid::forEach(hybridRows(inserter_), [&](auto i) -> void {
+        Dune::Hybrid::forEach(hybridCols(inserter_), [&](auto j) -> void {
           this->inserter(i,j).init(access(matrixIndexSet,i,j), rebuild);
         });
       });
     }
 
-    /// Finish the insertion
+    /// Implements \ref MatrixInserterBase::finish
     void finish_impl()
     {
-      Dune::Hybrid::forEach(hybridRows(inserter_), [&](auto i) {
-        Dune::Hybrid::forEach(hybridCols(inserter_), [&](auto j) {
+      Dune::Hybrid::forEach(hybridRows(inserter_), [&](auto i) -> void {
+        Dune::Hybrid::forEach(hybridCols(inserter_), [&](auto j) -> void {
           this->inserter(i,j).finish();
         });
       });
     }
 
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    /// Implements \ref MatrixInserterBase::insert
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      invokeIf(hybridRows(inserter_), *row, [&](auto i) {
-        invokeIf(hybridCols(inserter_), *col, [&](auto j) {
+      switchCases(hybridRows(inserter_), *row, [&](auto i) -> void {
+        switchCases(hybridCols(inserter_), *col, [&](auto j) -> void {
           this->inserter(i,j).insert(row.next(), col.next(), value, assign);
         });
       });
     }
 
+  protected:
     template <class I, class J>
     auto& inserter(I const& i, J const& j) { return inserter_[i][j]; }
 
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index 61d35cb4..a5db2583 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -6,8 +6,8 @@
 #include <amdis/common/Access.hpp>
 #include <amdis/common/ForEach.hpp>
 #include <amdis/common/HybridSize.hpp>
-#include <amdis/common/InvokeIf.hpp>
 #include <amdis/common/Resize.hpp>
+#include <amdis/common/SwitchCases.hpp>
 #include <amdis/linearalgebra/Common.hpp>
 
 namespace AMDiS
@@ -23,6 +23,7 @@ namespace AMDiS
       : scalar_(scalar)
     {}
 
+    /// Implements \ref MatrixWrapperBase::clear_row
     template <class RowIter, class Col, class RowValues>
     void clear_row_impl(RowIter const& row, Col const& col, RowValues& row_values)
     {
@@ -30,6 +31,7 @@ namespace AMDiS
       scalar_ = Scalar(0);
     }
 
+    /// Implements \ref MatrixWrapperBase::clear_col
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row const& row, ColIter const& col, ColValues& col_values)
     {
@@ -37,7 +39,7 @@ namespace AMDiS
       scalar_ = Scalar(0);
     }
 
-    /// Return the number of nonzeros in the matrix
+    /// Implements \ref MatrixWrapperBase::nnz
     std::size_t nnz_impl()
     {
       return scalar_ != Scalar(0);
@@ -58,16 +60,12 @@ namespace AMDiS
   {
     template <class> friend class MatrixWrapper;
 
-  protected:
-    //using size_type = typename BaseMatrix::size_type;
-    //using block_type = typename BlockType<BaseMatrix>::type;
-
   public:
     MatrixWrapperImpl(BaseMatrix& matrix)
       : matrix_(matrix)
     {}
 
-    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    /// Implements \ref MatrixWrapperBase::resize
     template <class RowSize, class ColSize>
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
@@ -82,36 +80,37 @@ namespace AMDiS
       });
 
       // resize all the blocks
-      //if (BlockLevel<BaseMatrix>::value > 1) {
-        rowPrefix.push_back(0);
-        colPrefix.push_back(0);
+      rowPrefix.push_back(0);
+      colPrefix.push_back(0);
 
-        Dune::Hybrid::forEach(hybridRows(matrix_), [&](auto i) -> void {
-          rowPrefix.back() = i;
-          Dune::Hybrid::forEach(hybridCols(matrix_), [&](auto j) -> void {
-            colPrefix.back() = j;
-            wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
-          });
+      Dune::Hybrid::forEach(hybridRows(matrix_), [&](auto i) -> void {
+        rowPrefix.back() = i;
+        Dune::Hybrid::forEach(hybridCols(matrix_), [&](auto j) -> void {
+          colPrefix.back() = j;
+          wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
         });
-      //}
+      });
     }
 
+    /// Implements \ref MatrixWrapperBase::clear_row
     template <class RowIter, class Col, class RowValues>
     void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
-      invokeIf(hybridRows(matrix_), *row, [&](auto i) -> void {
-        push_back(col);
+      push_back(col);
+      switchCases(hybridRows(matrix_), *row, [&](auto i) -> void {
         Dune::Hybrid::forEach(hybridCols(matrix_), [&](auto j) -> void {
+          back(col) = j;
           this->wrapper(i,j).clear_row(row.next(), col, row_values);
         });
       });
     }
 
+    /// Implements \ref MatrixWrapperBase::clear_col
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
     {
-      invokeIf(hybridCols(matrix_), *col, [&](auto j) -> void {
-        push_back(row);
+      push_back(row);
+      switchCases(hybridCols(matrix_), *col, [&](auto j) -> void {
         Dune::Hybrid::forEach(hybridRows(matrix_), [&](auto i) -> void {
           back(row) = i;
           this->wrapper(i,j).clear_col(row, col.next(), col_values);
@@ -119,7 +118,7 @@ namespace AMDiS
       });
     }
 
-    /// Return the number of nonzeros in the matrix
+    /// Implements \ref MatrixWrapperBase::nnz
     std::size_t nnz_impl()
     {
       std::size_t num_nonzeros = 0;
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index ee9106af..53812cd8 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <amdis/common/HybridSize.hpp>
+#include <amdis/common/SwitchCases.hpp>
 #include <amdis/linearalgebra/MatrixInserter.hpp>
 #include <amdis/linearalgebra/MatrixWrapper.hpp>
 
@@ -29,22 +31,24 @@ namespace AMDiS
       : inserter_(matrix)
     {}
 
+    /// Implements \ref MatrixInserterBase::init
     template <class MatIndexSet>
     void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
     {
       inserter_.init(matrixIndexSet, rebuild);
     }
 
+    /// Implements \ref MatrixInserterBase::finish
     void finish_impl()
     {
       inserter_.finish();
     }
 
-    /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
+    /// Implements \ref MatrixInserterBase::insert
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      invokeIf(hybridRows(inserter_.inserter_), *row, [&](auto i) {
+      switchCases(hybridRows(inserter_.inserter_), *row, [&](auto i) -> void {
         this->inserter(i,index_t<0>{}).insert(row.next(), col, value, assign);
       });
     }
@@ -64,14 +68,13 @@ namespace AMDiS
   {
     using BaseMatrix = SingleColumnMatrix<Matrix>;
     using Wrapper = Impl::MatrixWrapperSelector<Matrix>;
-    //using size_type = typename Wrapper::size_type;
-    //using block_type = typename Wrapper::block_type;
 
   public:
     MatrixWrapper(BaseMatrix& matrix)
       : wrapper_(matrix)
     {}
 
+    /// Implements \ref MatrixWrapperBase::resize
     template <class RowSize, class ColSize>
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                       ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
@@ -85,34 +88,35 @@ namespace AMDiS
       });
 
       // resize all the blocks
-      //if (BlockLevel<Matrix>::value > 1) {
-        rowPrefix.push_back(0);
-        Dune::Hybrid::forEach(hybridRows(wrapper_.matrix_), [&](auto i) {
-          rowPrefix.back() = i;
-          this->wrapper(i,index_t<0>{}).resize(rowSize, rowPrefix, colSize, colPrefix);
-        });
-      //}
+      rowPrefix.push_back(0);
+      Dune::Hybrid::forEach(hybridRows(wrapper_.matrix_), [&](auto i) -> void {
+        rowPrefix.back() = i;
+        this->wrapper(i,index_t<0>{}).resize(rowSize, rowPrefix, colSize, colPrefix);
+      });
     }
 
+    /// Implements \ref MatrixWrapperBase::clear_row
     template <class RowIter, class Col, class RowValues>
     void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
-      invokeIf(hybridRows(wrapper_.matrix_), *row, [&](auto i) {
+      switchCases(hybridRows(wrapper_.matrix_), *row, [&](auto i) -> void {
         this->wrapper(i,index_t<0>{}).clear_row(row.next(), col, row_values);
       });
     }
 
+    /// Implements \ref MatrixWrapperBase::clear_col
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
     {
       assert(std::size_t(*col) == 0u);
       push_back(row);
-      Dune::Hybrid::forEach(hybridRows(wrapper_.matrix_), [&](auto i) {
+      Dune::Hybrid::forEach(hybridRows(wrapper_.matrix_), [&](auto i) -> void {
         back(row) = i;
         this->wrapper(i,index_t<0>{}).clear_col(row, col.next(), col_values);
       });
     }
 
+    /// Implements \ref MatrixWrapperBase::nnz
     std::size_t nnz_impl()
     {
       return wrapper_.nnz();
@@ -142,21 +146,24 @@ namespace AMDiS
       : inserter_(matrix)
     {}
 
+    /// Implements \ref MatrixInserterBase::init
     template <class MatIndexSet>
     void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
     {
       inserter_.init(matrixIndexSet, rebuild);
     }
 
+    /// Implements \ref MatrixInserterBase::finish
     void finish_impl()
     {
       inserter_.finish();
     }
 
+    /// Implements \ref MatrixInserterBase::insert
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      invokeIf(hybridCols(inserter_.inserter_), *col, [&](auto j) {
+      switchCases(hybridCols(inserter_.inserter_), *col, [&](auto j) -> void {
         this->inserter(index_t<0>{},j).insert(row, col.next(), value, assign);
       });
     }
@@ -175,14 +182,13 @@ namespace AMDiS
   {
     using BaseMatrix = SingleRowMatrix<Matrix>;
     using Wrapper = Impl::MatrixWrapperSelector<Matrix>;
-    //using size_type = typename Wrapper::size_type;
-    //using block_type = typename Wrapper::block_type;
 
   public:
     MatrixWrapper(BaseMatrix& matrix)
       : wrapper_(matrix)
     {}
 
+    /// Implements \ref MatrixWrapperBase::resize
     template <class RowSize, class ColSize>
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                       ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
@@ -196,34 +202,35 @@ namespace AMDiS
       });
 
       // resize all the blocks
-      //if (BlockLevel<Matrix>::value > 1) {
-        colPrefix.push_back(0);
-        Dune::Hybrid::forEach(hybridCols(wrapper_.matrix_), [&](auto j) {
-          colPrefix.back() = j;
-          this->wrapper(index_t<0>{},j).resize(rowSize, rowPrefix, colSize, colPrefix);
-        });
-      //}
+      colPrefix.push_back(0);
+      Dune::Hybrid::forEach(hybridCols(wrapper_.matrix_), [&](auto j) -> void {
+        colPrefix.back() = j;
+        this->wrapper(index_t<0>{},j).resize(rowSize, rowPrefix, colSize, colPrefix);
+      });
     }
 
+    /// Implements \ref MatrixWrapperBase::clear_row
     template <class RowIter, class Col, class RowValues>
     void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
       assert(std::size_t(*row) == 0);
       push_back(col);
-      Dune::Hybrid::forEach(hybridCols(wrapper_.matrix_), [&](auto j) {
+      Dune::Hybrid::forEach(hybridCols(wrapper_.matrix_), [&](auto j) -> void {
         back(col) = j;
         this->wrapper(index_t<0>{},j).clear_row(row.next(), col, row_values);
       });
     }
 
+    /// Implements \ref MatrixWrapperBase::clear_col
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
     {
-      invokeIf(hybridCols(wrapper_.matrix_), *col, [&](auto j) {
+      switchCases(hybridCols(wrapper_.matrix_), *col, [&](auto j) -> void {
         this->wrapper(index_t<0>{},j).clear_col(row, col.next(), col_values);
       });
     }
 
+    /// Implements \ref MatrixWrapperBase::nnz
     std::size_t nnz_impl()
     {
       return wrapper_.nnz();
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index f2da9741..ad97f172 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -5,6 +5,8 @@
 #include <dune/common/hybridutilities.hh>
 
 #include <amdis/common/ForEach.hpp>
+#include <amdis/common/HybridSize.hpp>
+#include <amdis/common/SwitchCases.hpp>
 #include <amdis/linearalgebra/Common.hpp>
 
 namespace AMDiS
@@ -18,27 +20,14 @@ namespace AMDiS
       : scalar_(scalar)
     {}
 
-    /// Resize \ref vector_ to desired size
-    template <class SizeProvider>
-    void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
-    {
-      assert(sizeProvider.size(prefix) == 0);
-    }
-
-    /// Prepare the vector for insertion of values
-    void init_impl(bool /*rebuild*/ = true) {}
-
-    /// Finish the insertion
-    void finish_impl() {}
-
-    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
+    /// Implements \ref VectorWrapperBase::insert
     template <class Index, class ValueType, class Assigner>
-    void insert_impl(Index const& /*mi*/, ValueType const& value, Assigner assign)
+    void insert_impl(Index const& /*index*/, ValueType const& value, Assigner assign)
     {
       assign(value, scalar_);
     }
 
-    /// Set all entries to value
+    /// Implements \ref VectorWrapperBase::set
     template <class ValueType>
     void set_impl(ValueType const& value)
     {
@@ -54,15 +43,12 @@ namespace AMDiS
   class VectorWrapperImpl
       : public VectorWrapperBase<VectorWrapperImpl<BaseVector>>
   {
-    //using size_type = typename BaseVector::size_type;
-    //using block_type = typename BlockType<BaseVector>::type;
-
   public:
     VectorWrapperImpl(BaseVector& vector)
       : vector_(vector)
     {}
 
-    /// Resize \ref vector_ to desired size
+    /// Implements \ref VectorWrapperBase::resize
     template <class SizeProvider>
     void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
@@ -75,46 +61,44 @@ namespace AMDiS
       });
 
       // resize all the blocks
-      //if (BlockLevel<BaseVector>::value > 1) {
-        prefix.push_back(0);
-        Dune::Hybrid::forEach(hybridElements(vector_), [&] (auto i) {
-          prefix.back() = i;
-          vectorWrapper(access(vector_,i)).resize(sizeProvider, prefix);
-        });
-      //}
+      prefix.push_back(0);
+      Dune::Hybrid::forEach(hybridElements(vector_), [&](auto i) -> void {
+        prefix.back() = i;
+        vectorWrapper(vector_[i]).resize(sizeProvider, prefix);
+      });
     }
 
-    /// Prepare the vector for insertion of values
+    /// Implements \ref VectorWrapperBase::init
     void init_impl(bool rebuild)
     {
-      Dune::Hybrid::forEach(hybridElements(vector_), [&] (auto i) {
-        vectorWrapper(access(vector_,i)).init(rebuild);
+      Dune::Hybrid::forEach(hybridElements(vector_), [&](auto i) -> void {
+        vectorWrapper(vector_[i]).init(rebuild);
       });
     }
 
-    /// Finish the insertion
+    /// Implements \ref VectorWrapperBase::finish
     void finish_impl()
     {
-      Dune::Hybrid::forEach(hybridElements(vector_), [&] (auto i) {
-        vectorWrapper(access(vector_,i)).finish();
+      Dune::Hybrid::forEach(hybridElements(vector_), [&](auto i) -> void {
+        vectorWrapper(vector_[i]).finish();
       });
     }
 
-    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
+    /// Implements \ref VectorWrapperBase::insert
     template <class Index, class ValueType, class Assigner>
     void insert_impl(Index const& index, ValueType const& value, Assigner assign)
     {
-      invokeIf(hybridElements(vector_), *index, [&](auto i) {
-        vectorWrapper(access(vector_,i)).insert(index.next(), value, assign);
+      switchCases(hybridElements(vector_), *index, [&](auto i) {
+        vectorWrapper(vector_[i]).insert(index.next(), value, assign);
       });
     }
 
-    /// Set all entries to value
+    /// Implements \ref VectorWrapperBase::set
     template <class ValueType>
     void set_impl(ValueType const& value)
     {
       Dune::Hybrid::forEach(hybridElements(vector_), [&] (auto i) {
-        vectorWrapper(access(vector_,i)).set(value);
+        vectorWrapper(vector_[i]).set(value);
       });
     }
 
diff --git a/src/amdis/linearalgebra/VectorWrapperBase.hpp b/src/amdis/linearalgebra/VectorWrapperBase.hpp
index 0e01edcf..7fa86fa3 100644
--- a/src/amdis/linearalgebra/VectorWrapperBase.hpp
+++ b/src/amdis/linearalgebra/VectorWrapperBase.hpp
@@ -59,6 +59,22 @@ namespace AMDiS
       asImpl().set_impl(value);
     }
 
+  protected: // default implementation:
+
+    template <class... Args>
+    void resize_impl(Args&&...) { /* do nothing */ }
+
+    template <class... Args>
+    void init_impl(Args&&...) { /* do nothing */ }
+
+    void finish_impl() { /* do nothing */ }
+
+    template <class... Args>
+    void insert_impl(Args&&...) { /* do nothing */ }
+
+    template <class... Args>
+    void set_impl(Args&&...) { /* do nothing */ }
+
   private:
     Impl& asImpl() { return static_cast<Impl&>(*this); }
   };
diff --git a/test/MatrixWrapperTest.cpp b/test/MatrixWrapperTest.cpp
index 0512394e..69914d75 100644
--- a/test/MatrixWrapperTest.cpp
+++ b/test/MatrixWrapperTest.cpp
@@ -112,10 +112,10 @@ int main(int argc, char** argv)
   AMDiS::init(argc, argv);
 
   WrapperImpl wrapper1;
-  Wrapper2Impl wrapper2;
+  //Wrapper2Impl wrapper2;
 
   InserterImpl inserter1;
-  Inserter2Impl inserter2;
+  //Inserter2Impl inserter2;
 
   foo(wrapper1);
   //foo(wrapper2); // should not compile
-- 
GitLab


From f65ec30e5bceef734e5e4a570243f332e2eec3d3 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 17 Apr 2019 18:13:42 +0200
Subject: [PATCH 18/38] do not resize vector if not resizable

---
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp  | 10 ++--------
 src/amdis/linearalgebra/SingleRowColMatrix.hpp | 14 ++------------
 src/amdis/linearalgebra/VectorWrapper.inc.hpp  |  7 +------
 3 files changed, 5 insertions(+), 26 deletions(-)

diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index a5db2583..fc4e2708 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -70,14 +70,8 @@ namespace AMDiS
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                      ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
-      auto rows = rowSize.size(rowPrefix);
-      auto cols = colSize.size(colPrefix);
-
       // resize this matrix
-      Dune::Hybrid::ifElse(Concepts::MatrixResizable_t<BaseMatrix>{}, [&](auto id) -> void {
-        assert(rows > 0 && cols > 0);
-        resize(id(matrix_), rows, cols);
-      });
+      resize(matrix_, rowSize.size(rowPrefix), colSize.size(colPrefix));
 
       // resize all the blocks
       rowPrefix.push_back(0);
@@ -87,7 +81,7 @@ namespace AMDiS
         rowPrefix.back() = i;
         Dune::Hybrid::forEach(hybridCols(matrix_), [&](auto j) -> void {
           colPrefix.back() = j;
-          wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
+          this->wrapper(i,j).resize(rowSize, rowPrefix, colSize, colPrefix);
         });
       });
     }
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index 53812cd8..549aa94a 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -79,13 +79,8 @@ namespace AMDiS
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                       ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
-      auto rows = rowSize.size(rowPrefix);
-
       // resize this matrix
-      Dune::Hybrid::ifElse(Concepts::MatrixResizable_t<Matrix>{}, [&](auto id) -> void {
-        assert(rows > 0);
-        resize(id(wrapper_.matrix_), rows, 1);
-      });
+      resize(wrapper_.matrix_, rowSize.size(rowPrefix), 1);
 
       // resize all the blocks
       rowPrefix.push_back(0);
@@ -193,13 +188,8 @@ namespace AMDiS
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                       ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
     {
-      auto cols = colSize.size(colPrefix);
-
       // resize this matrix
-      Dune::Hybrid::ifElse(Concepts::MatrixResizable_t<Matrix>{}, [&](auto id) -> void {
-        assert(cols > 0);
-        resize(id(wrapper_.matrix_), 1, cols);
-      });
+      resize(wrapper_.matrix_, 1, colSize.size(colPrefix));
 
       // resize all the blocks
       colPrefix.push_back(0);
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index ad97f172..5d1e9d0b 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -52,13 +52,8 @@ namespace AMDiS
     template <class SizeProvider>
     void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
-      auto size = sizeProvider.size(prefix);
-
       // resize this vector
-      Dune::Hybrid::ifElse(Concepts::VectorResizable_t<BaseVector>{}, [&](auto id) -> void {
-        assert(size > 0);
-        resize(id(vector_), size);
-      });
+      resize(vector_, sizeProvider.size(prefix));
 
       // resize all the blocks
       prefix.push_back(0);
-- 
GitLab


From 05fcb6c28ba25fe88238e259bb12982b97a757d8 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 17 Apr 2019 19:11:18 +0200
Subject: [PATCH 19/38] removed separate constraints implementation in favor of
 matrix-wrapper functions

---
 src/amdis/DirichletBC.hpp                     |   5 +-
 src/amdis/DirichletBC.inc.hpp                 |  30 ++++-
 src/amdis/LinearAlgebra.hpp                   |   3 -
 src/amdis/PeriodicBC.hpp                      |   2 +
 src/amdis/PeriodicBC.inc.hpp                  |  67 +++++++++-
 src/amdis/linearalgebra/CMakeLists.txt        |   5 +-
 src/amdis/linearalgebra/Constraints.hpp       | 126 ------------------
 src/amdis/linearalgebra/MatrixIndexSet.hpp    |   3 +
 src/amdis/linearalgebra/VectorWrapper.inc.hpp |  14 +-
 9 files changed, 107 insertions(+), 148 deletions(-)
 delete mode 100644 src/amdis/linearalgebra/Constraints.hpp

diff --git a/src/amdis/DirichletBC.hpp b/src/amdis/DirichletBC.hpp
index bacd3648..35e88d8e 100644
--- a/src/amdis/DirichletBC.hpp
+++ b/src/amdis/DirichletBC.hpp
@@ -34,11 +34,12 @@ namespace AMDiS
    * support this symmetric modification. As a result, this method returns a list
    * of columns values, that should be subtracted from the rhs.
    **/
-  template <class Domain, class Range, class MultiIndex>
+  template <class Domain, class Range, class MI>
   class DirichletBC
       : public BoundaryCondition
   {
     using Super = BoundaryCondition;
+    using MultiIndex = MI;
 
     template <class Blocking>
     using BitVector = VectorGenerator_t<char, DefaultMatrixVectorTraits, Blocking>;
@@ -86,6 +87,8 @@ namespace AMDiS
     Dune::Std::optional<std::function<bool(Domain)>> predicate_;
     std::function<Range(Domain)> values_;
     std::set<MultiIndex> dirichletNodes_;
+
+    bool symmetric_ = true;
   };
 
 
diff --git a/src/amdis/DirichletBC.inc.hpp b/src/amdis/DirichletBC.inc.hpp
index d458ac59..fda07154 100644
--- a/src/amdis/DirichletBC.inc.hpp
+++ b/src/amdis/DirichletBC.inc.hpp
@@ -8,6 +8,7 @@
 #include <dune/functions/functionspacebases/subspacebasis.hh>
 
 #include <amdis/LinearAlgebra.hpp>
+#include <amdis/linearalgebra/Common.hpp>
 
 namespace AMDiS {
 
@@ -36,14 +37,36 @@ template <class D, class R, class MI>
 void DirichletBC<D,R,MI>::
 fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, RTP rowTreePath, CN const& colNode, CTP colTreePath)
 {
+  std::vector<Triplet<MI,typename Mat::field_type>> columns;
+
+  // clear row (and column) of dirichlet nodes
+  if (symmetric_) {
+    FakeContainer col;
+    for (auto const& index : dirichletNodes_) {
+      MultiIndex row{};
+      matrixWrapper(matrix.matrix()).clear_col(row, index, columns);
+      matrixWrapper(matrix.matrix()).clear_row(index, col);
+    }
+  } else {
+    FakeContainer col;
+    for (auto const& index : dirichletNodes_)
+      matrixWrapper(matrix.matrix()).clear_row(index, col);
+  }
+
+  // insert diagonal 1 value
+  typename Mat::Inserter inserter(matrix.matrix());
+  inserter.init(NoMatrixIndexSet{1}, false);
+  for (auto const& index : dirichletNodes_)
+    inserter.insert(index, index, 1);
+  inserter.finish();
+
+  // create indicator for interpolation
   BitVector<typename Mat::RowBlocking> bitVector;
   vectorWrapper(bitVector).resize(matrix.rowBasis());
-  vectorWrapper(bitVector).set(0);
   for (auto const& node : dirichletNodes_)
     Dune::Functions::resolveDynamicMultiIndex(bitVector,node) = 1;
 
-  auto columns = Constraints<Mat>::dirichletBC(matrix, dirichletNodes_, true);
-
+  // set dirichlet values in solution vector
   Dune::Hybrid::ifElse(std::is_same<RangeType_t<CN>, R>{},
     [&](auto id) -> void {
       auto subBasis = Dune::Functions::subspaceBasis(*solution.basis(), colTreePath);
@@ -54,6 +77,7 @@ fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, R
   for (auto const& triplet : columns)
     rhs[triplet.row] -= triplet.value * solution[triplet.col];
 
+  // set dirichlet values in rhs vector
   Dune::Hybrid::ifElse(std::is_same<RangeType_t<RN>, R>{},
     [&](auto id) -> void {
       auto subBasis = Dune::Functions::subspaceBasis(*rhs.basis(), rowTreePath);
diff --git a/src/amdis/LinearAlgebra.hpp b/src/amdis/LinearAlgebra.hpp
index 9a32bd9a..b7e725a3 100644
--- a/src/amdis/LinearAlgebra.hpp
+++ b/src/amdis/LinearAlgebra.hpp
@@ -5,7 +5,6 @@
 
 #if HAVE_MTL
 
-#include <amdis/linearalgebra/mtl/Constraints.hpp>
 #include <amdis/linearalgebra/mtl/DOFMatrix.hpp>
 #include <amdis/linearalgebra/mtl/DOFVector.hpp>
 #include <amdis/linearalgebra/mtl/ITL_Solver.hpp>
@@ -13,14 +12,12 @@
 
 #elif HAVE_EIGEN
 
-#include <amdis/linearalgebra/eigen/Constraints.hpp>
 #include <amdis/linearalgebra/eigen/DOFMatrix.hpp>
 #include <amdis/linearalgebra/eigen/DOFVector.hpp>
 #include <amdis/linearalgebra/eigen/SolverCreator.hpp>
 
 #else // ISTL
 
-#include <amdis/linearalgebra/istl/Constraints.hpp>
 #include <amdis/linearalgebra/istl/DOFMatrix.hpp>
 #include <amdis/linearalgebra/istl/DOFVector.hpp>
 #include <amdis/linearalgebra/istl/ISTL_Solver.hpp>
diff --git a/src/amdis/PeriodicBC.hpp b/src/amdis/PeriodicBC.hpp
index b3864457..62e96921 100644
--- a/src/amdis/PeriodicBC.hpp
+++ b/src/amdis/PeriodicBC.hpp
@@ -99,6 +99,8 @@ namespace AMDiS
     std::vector<MI> periodicNodes_;
     std::map<MI, MI> associations_;
     Dune::Std::optional<bool> hasConnectedIntersections_;
+
+    bool symmetric_ = true;
   };
 
 
diff --git a/src/amdis/PeriodicBC.inc.hpp b/src/amdis/PeriodicBC.inc.hpp
index 528bd27c..0da2c055 100644
--- a/src/amdis/PeriodicBC.inc.hpp
+++ b/src/amdis/PeriodicBC.inc.hpp
@@ -6,7 +6,9 @@
 #include <dune/functions/common/functionfromcallable.hh>
 #include <dune/functions/functionspacebases/interpolate.hh>
 #include <dune/functions/functionspacebases/subentitydofs.hh>
+
 #include <amdis/LinearAlgebra.hpp>
+#include <amdis/linearalgebra/Common.hpp>
 
 namespace AMDiS {
 
@@ -240,18 +242,71 @@ template <class D, class MI>
 void PeriodicBC<D,MI>::
 fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, RTP rowTreePath, CN const& colNode, CTP colTreePath)
 {
-  BitVector<typename Mat::RowBlocking> bitVector;
-  vectorWrapper(bitVector).resize(matrix.rowBasis());
-  for (auto const& node : periodicNodes_)
-    Dune::Functions::resolveDynamicMultiIndex(bitVector,node) = 1;
+  std::vector<Triplet<MultiIndex,typename Mat::field_type>> rowValues;
+  std::vector<Triplet<MultiIndex,typename Mat::field_type>> colValues;
+
+  // delete the rows (and columns) of the periodic nodes
+  if (symmetric_) {
+    for (auto const& index : periodicNodes_) {
+      MultiIndex row{}, col{};
+      matrixWrapper(matrix.matrix()).clear_col(row, index, colValues);
+      matrixWrapper(matrix.matrix()).clear_row(index, col, rowValues);
+    }
+  } else {
+    for (auto const& index : periodicNodes_) {
+      MultiIndex col{};
+      matrixWrapper(matrix.matrix()).clear_row(index, col, rowValues);
+    }
+  }
+
+  typename Mat::Inserter inserter(matrix.matrix());
+  inserter.init(NoMatrixIndexSet{50}, false);
+
+  // get the association or assert
+  auto association = [&](auto const& idx)
+  {
+      auto it = associations_.find(idx);
+      assert(it != associations_.end());
+      return it->second;
+  };
+
+  // inserter {+1, -1} into left-row / right-column
+  for (auto const& l : periodicNodes_) {
+    auto&& r = association(l);
+
+    inserter.insert(l, l, 1);
+    inserter.insert(l, r, -1);
+    if (symmetric_) {
+      inserter.insert(r, r, 1);
+      inserter.insert(r, l, -1);
+    }
+  }
+
+  // add left-row to right-row
+  for (auto const& triple : rowValues) {
+    auto&& row = association(triple.row);
+    auto&& col = triple.col;
+
+    inserter.insert(row, col, triple.value);
+  }
+
+  // add left-column to right-column
+  if (symmetric_) {
+    for (auto const& triple : colValues) {
+      auto&& col = association(triple.col);
+      auto&& row = triple.row;
+
+      inserter.insert(row, col, triple.value);
+    }
+  }
 
-  Constraints<Mat>::periodicBC(matrix, periodicNodes_, associations_);
+  inserter.finish();
 
   for (auto const& a : associations_) {
     rhs[a.second] += rhs[a.first];
+    rhs[a.first] = 0;
     solution[a.second] = solution[a.first];
   }
-  Dune::Functions::interpolate(*rhs.basis(), rhs, [](auto const&) { return 0.0; }, bitVector);
 }
 
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/CMakeLists.txt b/src/amdis/linearalgebra/CMakeLists.txt
index c04e37e0..e751d61a 100644
--- a/src/amdis/linearalgebra/CMakeLists.txt
+++ b/src/amdis/linearalgebra/CMakeLists.txt
@@ -1,6 +1,5 @@
 install(FILES
     Common.hpp
-    Constraints.hpp
     DOFMatrixBase.hpp
     DOFMatrixBase.inc.hpp
     DOFVectorBase.hpp
@@ -18,6 +17,8 @@ install(FILES
     MatrixWrapper.hpp
     MatrixWrapper.inc.hpp
     MatrixWrapperBase.hpp
+    MultiTypeMatrix.hpp
+    MultiTypeVector.hpp
     PreconditionerInterface.hpp
     RunnerInterface.hpp
     SingleRowColMatrix.hpp
@@ -27,6 +28,6 @@ install(FILES
     VectorWrapperBase.hpp
 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/amdis/linearalgebra)
 
-add_subdirectory("eigen")
+#add_subdirectory("eigen")
 add_subdirectory("istl")
 add_subdirectory("mtl")
diff --git a/src/amdis/linearalgebra/Constraints.hpp b/src/amdis/linearalgebra/Constraints.hpp
deleted file mode 100644
index 3d5dddc9..00000000
--- a/src/amdis/linearalgebra/Constraints.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#pragma once
-
-#include <amdis/linearalgebra/Common.hpp>
-#include <amdis/linearalgebra/DOFMatrixBase.hpp>
-
-namespace AMDiS
-{
-  template <class Matrix, class MultiIndex = void>
-  struct Constraints
-  {
-    template <class DOFs>
-    static auto dirichletBC(Matrix& matrix, DOFs const& dofs, bool symmetric = true)
-    {
-      /* do nothing */
-      return std::array<Triplet<MultiIndex,typename Matrix::field_type>,0>{};
-    }
-
-    template <class DOFs, class Assoc>
-    static void periodicBC(Matrix& matrix, DOFs const& left, Assoc const& association, bool symmetric = true)
-    {
-      /* do nothing */
-    }
-  };
-
-  template <class RB, class CB, class T, class VT>
-  struct Constraints<DOFMatrixBase<RB,CB,T,VT>,void>
-  {
-    using Matrix = DOFMatrixBase<RB,CB,T,VT>;
-    using MultiIndex = typename RB::MultiIndex;
-    using field_type = typename Matrix::field_type;
-
-    using MatrixIndexSet = typename Matrix::HierarchicMatrixIndexSet;
-    using Inserter = typename Matrix::Inserter;
-
-    static auto dirichletBC(Matrix& matrix, std::set<MultiIndex> const& dofs, bool symmetric = true)
-    {
-      std::vector<Triplet<MultiIndex,field_type>> columns;
-      if (symmetric) {
-        FakeContainer col;
-        for (auto const& index : dofs) {
-          MultiIndex row{};
-          matrixWrapper(matrix.matrix()).clear_col(row, index, columns);
-          matrixWrapper(matrix.matrix()).clear_row(index, col);
-        }
-      } else {
-        FakeContainer col;
-        for (auto const& index : dofs)
-          matrixWrapper(matrix.matrix()).clear_row(index, col);
-      }
-
-      Inserter inserter(matrix.matrix());
-      inserter.init(NoMatrixIndexSet{1}, false);
-      for (auto const& index : dofs)
-        inserter.insert(index, index, field_type(1));
-      inserter.finish();
-
-      return columns;
-    }
-
-
-    template <class Associations>
-    static MultiIndex const& at(Associations const& m, MultiIndex const& idx)
-    {
-      auto it = m.find(idx);
-      assert(it != m.end());
-      return it->second;
-    }
-
-    template <class Assoc>
-    static void periodicBC(Matrix& matrix, std::vector<MultiIndex> const& left, Assoc const& association,
-                           bool symmetric = true)
-    {
-      std::vector<Triplet<MultiIndex,field_type>> rowValues;
-      std::vector<Triplet<MultiIndex,field_type>> colValues;
-
-      if (symmetric) {
-        for (auto const& index : left) {
-          MultiIndex row{}, col{};
-          matrixWrapper(matrix.matrix()).clear_col(row, index, colValues);
-          matrixWrapper(matrix.matrix()).clear_row(index, col, rowValues);
-        }
-      } else {
-        for (auto const& index : left) {
-          MultiIndex col{};
-          matrixWrapper(matrix.matrix()).clear_row(index, col, rowValues);
-        }
-      }
-
-      Inserter inserter(matrix.matrix());
-      inserter.init(NoMatrixIndexSet{50}, false);
-
-      // inserter {+1, -1} into left-row / right.column
-      for (auto const& l : left) {
-        auto&& r = at(association,l);
-
-        inserter.insert(l, l, field_type(1));
-        inserter.insert(l, r, field_type(-1));
-        if (symmetric) {
-          inserter.insert(r, r, field_type(1));
-          inserter.insert(r, l, field_type(-1));
-        }
-      }
-
-      // add left-row to right-row
-      for (auto const& triple : rowValues) {
-        auto&& row = at(association,triple.row);
-        auto&& col = triple.col;
-
-        inserter.insert(row, col, triple.value);
-      }
-
-      // add left-column to right-column
-      if (symmetric) {
-        for (auto const& triple : colValues) {
-          auto&& col = at(association,triple.col);
-          auto&& row = triple.row;
-
-          inserter.insert(row, col, triple.value);
-        }
-      }
-
-      inserter.finish();
-    }
-  };
-
-} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/MatrixIndexSet.hpp b/src/amdis/linearalgebra/MatrixIndexSet.hpp
index 1405d23b..7f28aea0 100644
--- a/src/amdis/linearalgebra/MatrixIndexSet.hpp
+++ b/src/amdis/linearalgebra/MatrixIndexSet.hpp
@@ -1,5 +1,8 @@
 #pragma once
 
+#include <set>
+#include <vector>
+
 #include <amdis/linearalgebra/MatrixInserter.hpp>
 #include <amdis/linearalgebra/MatrixWrapper.hpp>
 
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index 5d1e9d0b..9fc86bf3 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -66,16 +66,16 @@ namespace AMDiS
     /// Implements \ref VectorWrapperBase::init
     void init_impl(bool rebuild)
     {
-      Dune::Hybrid::forEach(hybridElements(vector_), [&](auto i) -> void {
-        vectorWrapper(vector_[i]).init(rebuild);
+      Dune::Hybrid::forEach(vector_, [&](auto& v) -> void {
+        vectorWrapper(v).init(rebuild);
       });
     }
 
     /// Implements \ref VectorWrapperBase::finish
     void finish_impl()
     {
-      Dune::Hybrid::forEach(hybridElements(vector_), [&](auto i) -> void {
-        vectorWrapper(vector_[i]).finish();
+      Dune::Hybrid::forEach(vector_, [&](auto& v) -> void {
+        vectorWrapper(v).finish();
       });
     }
 
@@ -83,7 +83,7 @@ namespace AMDiS
     template <class Index, class ValueType, class Assigner>
     void insert_impl(Index const& index, ValueType const& value, Assigner assign)
     {
-      switchCases(hybridElements(vector_), *index, [&](auto i) {
+      switchCases(hybridElements(vector_), *index, [&](auto i) -> void {
         vectorWrapper(vector_[i]).insert(index.next(), value, assign);
       });
     }
@@ -92,8 +92,8 @@ namespace AMDiS
     template <class ValueType>
     void set_impl(ValueType const& value)
     {
-      Dune::Hybrid::forEach(hybridElements(vector_), [&] (auto i) {
-        vectorWrapper(vector_[i]).set(value);
+      Dune::Hybrid::forEach(vector_, [&](auto& v) -> void {
+        vectorWrapper(v).set(value);
       });
     }
 
-- 
GitLab


From f307716e7ec72c8492d042845875368bce94a73d Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Thu, 18 Apr 2019 14:14:44 +0200
Subject: [PATCH 20/38] make DBC by default non-symmetric

---
 src/amdis/DirichletBC.hpp     | 10 ++++++----
 src/amdis/DirichletBC.inc.hpp | 12 ++++++++++--
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/amdis/DirichletBC.hpp b/src/amdis/DirichletBC.hpp
index 35e88d8e..1a7a1efc 100644
--- a/src/amdis/DirichletBC.hpp
+++ b/src/amdis/DirichletBC.hpp
@@ -47,17 +47,19 @@ namespace AMDiS
   public:
     template <class BM, class Values,
       REQUIRES(Concepts::Functor<Values, Range(Domain)>) >
-    DirichletBC(BM&& boundaryManager, BoundaryType id, Values&& values)
+    DirichletBC(BM&& boundaryManager, BoundaryType id, Values&& values, bool symmetric = false)
       : Super(FWD(boundaryManager), id)
       , values_(FWD(values))
+      , symmetric_(symmetric)
     {}
 
     template <class Predicate, class Values,
       REQUIRES(Concepts::Functor<Predicate, bool(Domain)>),
       REQUIRES(Concepts::Functor<Values, Range(Domain)>)>
-    DirichletBC(Predicate&& predicate, Values&& values)
+    DirichletBC(Predicate&& predicate, Values&& values, bool symmetric = false)
       : predicate_(FWD(predicate))
       , values_(FWD(values))
+      , symmetric_(symmetric)
     {}
 
     template <class IS>
@@ -86,9 +88,9 @@ namespace AMDiS
   private:
     Dune::Std::optional<std::function<bool(Domain)>> predicate_;
     std::function<Range(Domain)> values_;
-    std::set<MultiIndex> dirichletNodes_;
+    std::vector<MultiIndex> dirichletNodes_;
 
-    bool symmetric_ = true;
+    bool symmetric_ = false;
   };
 
 
diff --git a/src/amdis/DirichletBC.inc.hpp b/src/amdis/DirichletBC.inc.hpp
index fda07154..21c1eecc 100644
--- a/src/amdis/DirichletBC.inc.hpp
+++ b/src/amdis/DirichletBC.inc.hpp
@@ -20,10 +20,18 @@ init(RB const& rowBasis, CB const& colBasis, MatIndexSet& matIndexSet)
   using Dune::Functions::forEachBoundaryDOF;
   using LV = typename CB::LocalView;
   using IS = typename CB::GridView::Intersection;
+
+  BitVector<Blocking_t<RB>> bitVector;
+  vectorWrapper(bitVector).resize(rowBasis);
+
   dirichletNodes_.clear();
   forEachBoundaryDOF(colBasis, [&](int localIndex, LV const& localView, IS const& intersection) {
-    if (onBoundary(intersection))
-      dirichletNodes_.insert(localView.index(localIndex));
+    auto idx = localView.index(localIndex);
+    auto& visited = Dune::Functions::resolveDynamicMultiIndex(bitVector,idx);
+    if (onBoundary(intersection) && !visited) {
+      dirichletNodes_.push_back(idx);
+      visited = 1;
+    }
   });
 
   // insert diagonal entry into non-zero pattern
-- 
GitLab


From de06dd20183ac389284eee9ad3b45f9df313d627 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Thu, 18 Apr 2019 18:00:24 +0200
Subject: [PATCH 21/38] cleanup mtl implementation

---
 examples/init/stokes.dat.2d                   |   4 +-
 examples/stokes3.cc                           |   3 +-
 src/amdis/DirichletBC.inc.hpp                 |   9 +-
 src/amdis/PeriodicBC.inc.hpp                  |  50 +-
 src/amdis/linearalgebra/DOFMatrixBase.hpp     |   1 -
 src/amdis/linearalgebra/DOFMatrixBase.inc.hpp |   3 +-
 src/amdis/linearalgebra/MatrixIndexSet.hpp    |   3 +-
 src/amdis/linearalgebra/MatrixInserter.hpp    |  16 +-
 .../linearalgebra/MatrixInserter.inc.hpp      |  53 +-
 .../linearalgebra/MatrixInserterBase.hpp      |  18 -
 .../linearalgebra/SingleRowColMatrix.hpp      |  36 +-
 src/amdis/linearalgebra/istl/BCRSMatrix.hpp   | 477 +++++++++---------
 src/amdis/linearalgebra/istl/CMakeLists.txt   |   1 -
 src/amdis/linearalgebra/istl/Constraints.hpp  |  42 --
 src/amdis/linearalgebra/mtl/CMakeLists.txt    |   1 -
 src/amdis/linearalgebra/mtl/Constraints.hpp   | 146 ------
 .../linearalgebra/mtl/MatrixVectorTraits.hpp  |   5 +-
 src/amdis/linearalgebra/mtl/MtlMatrix.hpp     |  62 +--
 src/amdis/linearalgebra/mtl/MtlVector.hpp     |  19 +-
 test/CMakeLists.txt                           |  28 +-
 test/MatrixTest.cpp                           |  97 ++--
 test/MatrixWrapperTest.cpp                    |  17 +-
 22 files changed, 407 insertions(+), 684 deletions(-)
 delete mode 100644 src/amdis/linearalgebra/istl/Constraints.hpp
 delete mode 100644 src/amdis/linearalgebra/mtl/Constraints.hpp

diff --git a/examples/init/stokes.dat.2d b/examples/init/stokes.dat.2d
index 31650555..54542825 100644
--- a/examples/init/stokes.dat.2d
+++ b/examples/init/stokes.dat.2d
@@ -1,6 +1,6 @@
-stokesMesh->global refinements: 4
+stokesMesh->global refinements: 0
 stokesMesh->dimension: 1.0 1.0
-stokesMesh->num cells: 2 2
+stokesMesh->num cells: 4 4
 
 stokes->mesh: stokesMesh
 
diff --git a/examples/stokes3.cc b/examples/stokes3.cc
index 6533b163..80937e8b 100644
--- a/examples/stokes3.cc
+++ b/examples/stokes3.cc
@@ -3,8 +3,6 @@
 #include <amdis/ProblemStat.hpp>
 #include <amdis/localoperators/StokesOperator.hpp>
 
-#include <dune/istl/matrixmarket.hh>
-
 using namespace AMDiS;
 
 using Grid = Dune::YaspGrid<2>;
@@ -23,6 +21,7 @@ int main(int argc, char** argv)
 
   // tree-paths for components
   auto _v = Dune::Indices::_0;
+  auto _p = Dune::Indices::_1;
 
   auto opStokes = makeOperator(tag::stokes{}, viscosity);
   prob.addMatrixOperator(opStokes);
diff --git a/src/amdis/DirichletBC.inc.hpp b/src/amdis/DirichletBC.inc.hpp
index 21c1eecc..2c6baf22 100644
--- a/src/amdis/DirichletBC.inc.hpp
+++ b/src/amdis/DirichletBC.inc.hpp
@@ -62,11 +62,10 @@ fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, R
   }
 
   // insert diagonal 1 value
-  typename Mat::Inserter inserter(matrix.matrix());
-  inserter.init(NoMatrixIndexSet{1}, false);
-  for (auto const& index : dirichletNodes_)
-    inserter.insert(index, index, 1);
-  inserter.finish();
+  { auto inserter = matrixInserter(matrix.matrix());
+    for (auto const& index : dirichletNodes_)
+      inserter.insert(index, index, 1);
+  }
 
   // create indicator for interpolation
   BitVector<typename Mat::RowBlocking> bitVector;
diff --git a/src/amdis/PeriodicBC.inc.hpp b/src/amdis/PeriodicBC.inc.hpp
index 0da2c055..2031d507 100644
--- a/src/amdis/PeriodicBC.inc.hpp
+++ b/src/amdis/PeriodicBC.inc.hpp
@@ -259,9 +259,6 @@ fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, R
     }
   }
 
-  typename Mat::Inserter inserter(matrix.matrix());
-  inserter.init(NoMatrixIndexSet{50}, false);
-
   // get the association or assert
   auto association = [&](auto const& idx)
   {
@@ -270,38 +267,39 @@ fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, R
       return it->second;
   };
 
-  // inserter {+1, -1} into left-row / right-column
-  for (auto const& l : periodicNodes_) {
-    auto&& r = association(l);
+  { auto inserter = matrixInserter(matrix.matrix(), NoMatrixIndexSet{2}, false);
 
-    inserter.insert(l, l, 1);
-    inserter.insert(l, r, -1);
-    if (symmetric_) {
-      inserter.insert(r, r, 1);
-      inserter.insert(r, l, -1);
+    // inserter {+1, -1} into left-row / right-column
+    for (auto const& l : periodicNodes_) {
+      auto&& r = association(l);
+
+      inserter.insert(l, l, 1);
+      inserter.insert(l, r, -1);
+      if (symmetric_) {
+        inserter.insert(r, r, 1);
+        inserter.insert(r, l, -1);
+      }
     }
-  }
 
-  // add left-row to right-row
-  for (auto const& triple : rowValues) {
-    auto&& row = association(triple.row);
-    auto&& col = triple.col;
+    // add left-row to right-row
+    for (auto const& triple : rowValues) {
+      auto&& row = association(triple.row);
+      auto&& col = triple.col;
 
-    inserter.insert(row, col, triple.value);
-  }
+      inserter.insert(row, col, triple.value);
+    }
 
-  // add left-column to right-column
-  if (symmetric_) {
-    for (auto const& triple : colValues) {
-      auto&& col = association(triple.col);
-      auto&& row = triple.row;
+    // add left-column to right-column
+    if (symmetric_) {
+      for (auto const& triple : colValues) {
+        auto&& col = association(triple.col);
+        auto&& row = triple.row;
 
-      inserter.insert(row, col, triple.value);
+        inserter.insert(row, col, triple.value);
+      }
     }
   }
 
-  inserter.finish();
-
   for (auto const& a : associations_) {
     rhs[a.second] += rhs[a.first];
     rhs[a.first] = 0;
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index 6c51fe2f..6b907d2e 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -130,7 +130,6 @@ namespace AMDiS
     void finish()
     {
       assert(inserter_ != nullptr);
-      inserter_->finish();
       delete inserter_;
       inserter_ = nullptr;
     }
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
index beedff7c..96bbb607 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
@@ -65,8 +65,7 @@ init(bool rebuild, DBC& dbc, PBC& pbc)
   }
 
   // assign sub-pattern to matrix blocks
-  inserter_ = new Inserter(matrix_);
-  inserter_->init(matrixIndexSet_, rebuild);
+  inserter_ = new Inserter(matrix_, matrixIndexSet_, rebuild);
   elementMatrix_.resize(rowLocalView.maxSize(), colLocalView.maxSize());
 }
 
diff --git a/src/amdis/linearalgebra/MatrixIndexSet.hpp b/src/amdis/linearalgebra/MatrixIndexSet.hpp
index 7f28aea0..223acb62 100644
--- a/src/amdis/linearalgebra/MatrixIndexSet.hpp
+++ b/src/amdis/linearalgebra/MatrixIndexSet.hpp
@@ -158,7 +158,8 @@ namespace AMDiS
       : public MatrixInserterBase<MatrixInserter<AMDiS::MatrixIndexSet>>
   {
   public:
-    MatrixInserter(AMDiS::MatrixIndexSet& matrixIndexSet)
+    template <class... Args>
+    MatrixInserter(AMDiS::MatrixIndexSet& matrixIndexSet, Args&&... /*args*/)
       : matrixIndexSet_(matrixIndexSet)
     {}
 
diff --git a/src/amdis/linearalgebra/MatrixInserter.hpp b/src/amdis/linearalgebra/MatrixInserter.hpp
index 24781a73..1d43b650 100644
--- a/src/amdis/linearalgebra/MatrixInserter.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.hpp
@@ -13,13 +13,22 @@ namespace AMDiS
   template <class BaseMatrix>
   class MatrixInserter;
 
+  class NoMatrixIndexSet;
+
+  template <class BaseMatrix, class MatIndexSet>
+  MatrixInserter<BaseMatrix> matrixInserter(BaseMatrix& matrix, MatIndexSet const& matIndexSet, bool rebuild)
+  {
+    return MatrixInserter<BaseMatrix>{matrix, matIndexSet, rebuild};
+  }
+
   template <class BaseMatrix>
   MatrixInserter<BaseMatrix> matrixInserter(BaseMatrix& matrix)
   {
-    return {matrix};
+    return MatrixInserter<BaseMatrix>{matrix, NoMatrixIndexSet{}, false};
   }
 
 
+
   template <class Scalar>
   class MatrixInserterScalarImpl;
 
@@ -53,8 +62,9 @@ namespace AMDiS
     using Super = Impl::MatrixInserterSelector<BaseMatrix>;
 
   public:
-    MatrixInserter(BaseMatrix& matrix)
-      : Super(matrix)
+    template <class... Args>
+    MatrixInserter(Args&&... args)
+      : Super(FWD(args)...)
     {}
   };
 
diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
index 549e6673..e66ac2db 100644
--- a/src/amdis/linearalgebra/MatrixInserter.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -21,7 +21,8 @@ namespace AMDiS
     template <class> friend class MatrixInserter;
 
   public:
-    MatrixInserterScalarImpl(Scalar& scalar)
+    template <class... Args>
+    MatrixInserterScalarImpl(Scalar& scalar, Args&&... /*args*/)
       : scalar_(scalar)
     {}
 
@@ -59,13 +60,14 @@ namespace AMDiS
     };
 
   public:
-    MatrixDynamicInserter(BaseMatrix& matrix)
+    template <class MatIndexSet>
+    MatrixDynamicInserter(BaseMatrix& matrix, MatIndexSet const& matIndexSet, bool rebuild)
       : rows_(matrix.N())
       , cols_(matrix.M())
     {
       for (size_type i = 0; i < rows_; ++i)
         for (size_type j = 0; j < cols_; ++j)
-          inserter_.emplace_back(access(matrix,i,j));
+          inserter_.emplace_back(access(matrix,i,j), access(matIndexSet,i,j), rebuild);
     }
 
     size_type N() const { return rows_; }
@@ -88,23 +90,23 @@ namespace AMDiS
     static constexpr std::size_t cols = BaseMatrix::M();
 
   private:
-    template <class Cols>
-    static auto create_cols(Cols& col)
+    template <class Cols, class MIS>
+    static auto create_cols(Cols& col, MIS const& mis, bool rebuild)
     {
       return Tools::apply_indices<cols>([&](auto const... c) {
-        return Dune::makeTupleVector(matrixInserter(col[c])...);
+        return Dune::makeTupleVector(matrixInserter(col[c], mis[c], rebuild)...);
       });
     }
 
-    template <class Rows>
-    static auto create(Rows& row)
+    template <class Rows, class MIS>
+    static auto create(Rows& row, MIS const& mis, bool rebuild)
     {
       return Tools::apply_indices<rows>([&](auto const... r) {
-        return Dune::makeTupleVector(create_cols(row[r])...);
+        return Dune::makeTupleVector(create_cols(row[r],mis[r],rebuild)...);
       });
     }
 
-    using Inserter = TYPEOF(create(std::declval<BaseMatrix&>()));
+    using Inserter = TYPEOF(create(std::declval<BaseMatrix&>(),std::declval<NoMatrixIndexSet>(),true));
 
     template <std::size_t i>
     struct AccessProxy
@@ -116,8 +118,9 @@ namespace AMDiS
     };
 
   public:
-    MatrixStaticInserter(BaseMatrix& matrix)
-      : inserter_(create(matrix))
+    template <class MatIndexSet>
+    MatrixStaticInserter(BaseMatrix& matrix, MatIndexSet const& matIndexSet, bool rebuild)
+      : inserter_(create(matrix, matIndexSet, rebuild))
     {}
 
     template <std::size_t i>
@@ -135,30 +138,10 @@ namespace AMDiS
     template <class> friend class MatrixInserter;
 
   public:
-    MatrixInserterImpl(BaseMatrix& matrix)
-      : inserter_(matrix)
-    {}
-
-    /// Implements \ref MatrixInserterBase::init
     template <class MatIndexSet>
-    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
-    {
-      Dune::Hybrid::forEach(hybridRows(inserter_), [&](auto i) -> void {
-        Dune::Hybrid::forEach(hybridCols(inserter_), [&](auto j) -> void {
-          this->inserter(i,j).init(access(matrixIndexSet,i,j), rebuild);
-        });
-      });
-    }
-
-    /// Implements \ref MatrixInserterBase::finish
-    void finish_impl()
-    {
-      Dune::Hybrid::forEach(hybridRows(inserter_), [&](auto i) -> void {
-        Dune::Hybrid::forEach(hybridCols(inserter_), [&](auto j) -> void {
-          this->inserter(i,j).finish();
-        });
-      });
-    }
+    MatrixInserterImpl(BaseMatrix& matrix, MatIndexSet const& matrixIndexSet, bool rebuild)
+      : inserter_(matrix, matrixIndexSet, rebuild)
+    {}
 
     /// Implements \ref MatrixInserterBase::insert
     template <class Row, class Col, class ValueType, class Assigner>
diff --git a/src/amdis/linearalgebra/MatrixInserterBase.hpp b/src/amdis/linearalgebra/MatrixInserterBase.hpp
index 7f975ac2..7a1846d2 100644
--- a/src/amdis/linearalgebra/MatrixInserterBase.hpp
+++ b/src/amdis/linearalgebra/MatrixInserterBase.hpp
@@ -11,19 +11,6 @@ namespace AMDiS
   class MatrixInserterBase
   {
   public:
-    /// Prepare the matrix for insertion of values
-    template <class MatrixIndexSet>
-    void init(MatrixIndexSet const& matrixIndexSet, bool rebuild)
-    {
-      asImpl().init_impl(matrixIndexSet, rebuild);
-    }
-
-    /// Finish the insertion
-    void finish()
-    {
-      asImpl().finish_impl();
-    }
-
     /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
     template <class Row, class Col, class ValueType>
     void insert(Row const& row, Col const& col, ValueType const& value)
@@ -39,11 +26,6 @@ namespace AMDiS
 
   protected: // default implementation:
 
-    template <class... Args>
-    void init_impl(Args&&...) { /* do nothing */ }
-
-    void finish_impl() { /* do nothing */ }
-
     template <class... Args>
     void insert_impl(Args&&...) { /* do nothing */ }
 
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index 549aa94a..4352bb53 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -27,23 +27,11 @@ namespace AMDiS
     using Inserter = Impl::MatrixInserterSelector<Matrix>;
 
   public:
-    MatrixInserter(BaseMatrix& matrix)
-      : inserter_(matrix)
+    template <class... Args>
+    MatrixInserter(Args&&... args)
+      : inserter_(FWD(args)...)
     {}
 
-    /// Implements \ref MatrixInserterBase::init
-    template <class MatIndexSet>
-    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
-    {
-      inserter_.init(matrixIndexSet, rebuild);
-    }
-
-    /// Implements \ref MatrixInserterBase::finish
-    void finish_impl()
-    {
-      inserter_.finish();
-    }
-
     /// Implements \ref MatrixInserterBase::insert
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
@@ -137,23 +125,11 @@ namespace AMDiS
     using Inserter = Impl::MatrixInserterSelector<Matrix>;
 
   public:
-    MatrixInserter(BaseMatrix& matrix)
-      : inserter_(matrix)
+    template <class... Args>
+    MatrixInserter(Args&&... args)
+      : inserter_(FWD(args)...)
     {}
 
-    /// Implements \ref MatrixInserterBase::init
-    template <class MatIndexSet>
-    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
-    {
-      inserter_.init(matrixIndexSet, rebuild);
-    }
-
-    /// Implements \ref MatrixInserterBase::finish
-    void finish_impl()
-    {
-      inserter_.finish();
-    }
-
     /// Implements \ref MatrixInserterBase::insert
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
diff --git a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
index 81865621..6fa5a361 100644
--- a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
@@ -21,28 +21,18 @@ namespace AMDiS
 
   public:
     /// Constructor. Constructs new BaseVector.
-    MatrixInserter(BaseMatrix& matrix)
-      : matrix_(matrix)
-    {}
-
-    /// create occupation pattern and apply it to the matrix
     template <class MatIndexSet>
-    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild)
-    {
-      matrixIndexSet.exportIdx(matrix_);
-      initialized_ = true;
-    }
-
-    void finish_impl()
+    MatrixInserter(BaseMatrix& matrix, MatIndexSet const& matrixIndexSet, bool rebuild)
+      : matrix_(matrix)
     {
-      initialized_ = false;
+      if (rebuild)
+        matrixIndexSet.exportIdx(matrix_);
     }
 
     /// Insert a single value into the matrix (add to existing value)
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
-      assert(initialized_);
       size_type r = *row;
       size_type c = *col;
       test_exit_dbg( r < matrix_.N() && c < matrix_.M() ,
@@ -52,7 +42,6 @@ namespace AMDiS
 
   private:
     BaseMatrix& matrix_;
-    bool initialized_ = false;
   };
 
 
@@ -110,235 +99,235 @@ namespace AMDiS
     BaseMatrix& matrix_;
   };
 
-  template <class B, class A>
-  class SingleColumnMatrix<Dune::Matrix<B,A>>
-      : public Dune::Matrix<B,A>
-  {
-    using Super = Dune::Matrix<B,A>;
-  public:
-    using size_type = typename Super::size_type;
-    using field_type = typename Super::field_type;
-    using block_type = typename Super::block_type;
-
-    using Dune::Matrix<B,A>::Matrix;
-
-    //! y = A x
-    template <class X, class Y>
-    void mv(const X& x, Y& y) const
-    {
-      assert(this->N() == y.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].mv(x, y[i]);
-    }
-
-    //! y = A^T x
-    template<class X, class Y>
-    void mtv(const X& x, Y& y) const
-    {
-      assert(this->N() == x.size());
-      assert(this->N() > 0);
-      (*this)[0][0].mtv(x[0], y);
-      for (size_type i = 1; i < y.size(); ++i)
-        (*this)[i][0].umtv(x[i], y);
-    }
-
-    //! y += A x
-    template <class X, class Y>
-    void umv(const X& x, Y& y) const
-    {
-      assert(this->N() == y.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].umv(x, y[i]);
-    }
-
-    //! y -= A x
-    template<class X, class Y>
-    void mmv(const X& x, Y& y) const
-    {
-      assert(this->N() == y.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].mmv(x, y[i]);
-    }
-
-    /** \brief \f$ y += \alpha A x \f$ */
-    template <class X, class Y>
-    void usmv(const field_type& alpha, const X& x, Y& y) const
-    {
-      assert(this->N() == y.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].usmv(alpha, x, y[i]);
-    }
-
-    //! y += A^T x
-    template<class X, class Y>
-    void umtv(const X& x, Y& y) const
-    {
-      assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].umtv(x[i], y);
-    }
-
-    //! y -= A^T x
-    template<class X, class Y>
-    void mmtv(const X& x, Y& y) const
-    {
-      assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].mmtv(x[i], y);
-    }
-
-    //! y += alpha A^T x
-    template<class X, class Y>
-    void usmtv(const field_type& alpha, const X& x, Y& y) const
-    {
-      assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].usmtv(alpha, x[i], y);
-    }
-
-    //! y += A^H x
-    template<class X, class Y>
-    void umhv(const X& x, Y& y) const
-    {
-      assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].umhv(x[i], y);
-    }
-
-    //! y -= A^H x
-    template<class X, class Y>
-    void mmhv(const X& x, Y& y) const
-    {
-      assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].mmhv(x[i], y);
-    }
-
-    //! y += alpha A^H x
-    template<class X, class Y>
-    void usmhv(const field_type& alpha, const X& x, Y& y) const
-    {
-      assert(this->N() == x.size());
-      for (size_type i = 0; i < this->N(); ++i)
-        (*this)[i][0].usmhv(alpha, x[i], y);
-    }
-  };
-
-
-
-  template <class B, class A>
-  class SingleRowMatrix<Dune::Matrix<B,A>>
-      : public Dune::Matrix<B,A>
-  {
-    using Super = Dune::Matrix<B,A>;
-  public:
-    using size_type = typename Super::size_type;
-    using field_type = typename Super::field_type;
-    using block_type = typename Super::block_type;
-
-    using Dune::Matrix<B,A>::Matrix;
-
-    //! y = A x
-    template <class X, class Y>
-    void mv(const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      (*this)[0][0].mv(x[0], y);
-      for (size_type j = 1; j < this->M(); ++j)
-        (*this)[0][j].umv(x[j], y);
-    }
-
-    //! y = A^T x
-    template<class X, class Y>
-    void mtv(const X& x, Y& y) const
-    {
-      assert(this->M() == y.size());
-      assert(this->M() > 0);
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].mtv(x, y[j]);
-    }
-
-    //! y += A x
-    template <class X, class Y>
-    void umv(const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].umv(x[j], y);
-    }
-
-    //! y -= A x
-    template<class X, class Y>
-    void mmv(const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].mmv(x[j], y);
-    }
-
-    /** \brief \f$ y += \alpha A x \f$ */
-    template <class X, class Y>
-    void usmv(const field_type& alpha, const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].usmv(alpha, x[j], y);
-    }
-
-    //! y += A^T x
-    template<class X, class Y>
-    void umtv(const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].umv(x[j], y);
-    }
-
-    //! y -= A^T x
-    template<class X, class Y>
-    void mmtv(const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].mmtv(x[j], y);
-    }
-
-    //! y += alpha A^T x
-    template<class X, class Y>
-    void usmtv(const field_type& alpha, const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].usmtv(alpha, x[j], y);
-    }
-
-    //! y += A^H x
-    template<class X, class Y>
-    void umhv(const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].umhv(x[j], y);
-    }
-
-    //! y -= A^H x
-    template<class X, class Y>
-    void mmhv(const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].mmhv(x[j], y);
-    }
-
-    //! y += alpha A^H x
-    template<class X, class Y>
-    void usmhv(const field_type& alpha, const X& x, Y& y) const
-    {
-      assert(this->M() == x.size());
-      for (size_type j = 0; j < this->M(); ++j)
-        (*this)[0][j].usmtv(alpha, x[j], y);
-    }
-  };
+  // template <class B, class A>
+  // class SingleColumnMatrix<Dune::Matrix<B,A>>
+  //     : public Dune::Matrix<B,A>
+  // {
+  //   using Super = Dune::Matrix<B,A>;
+  // public:
+  //   using size_type = typename Super::size_type;
+  //   using field_type = typename Super::field_type;
+  //   using block_type = typename Super::block_type;
+
+  //   using Dune::Matrix<B,A>::Matrix;
+
+  //   //! y = A x
+  //   template <class X, class Y>
+  //   void mv(const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == y.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].mv(x, y[i]);
+  //   }
+
+  //   //! y = A^T x
+  //   template<class X, class Y>
+  //   void mtv(const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == x.size());
+  //     assert(this->N() > 0);
+  //     (*this)[0][0].mtv(x[0], y);
+  //     for (size_type i = 1; i < y.size(); ++i)
+  //       (*this)[i][0].umtv(x[i], y);
+  //   }
+
+  //   //! y += A x
+  //   template <class X, class Y>
+  //   void umv(const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == y.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].umv(x, y[i]);
+  //   }
+
+  //   //! y -= A x
+  //   template<class X, class Y>
+  //   void mmv(const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == y.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].mmv(x, y[i]);
+  //   }
+
+  //   /** \brief \f$ y += \alpha A x \f$ */
+  //   template <class X, class Y>
+  //   void usmv(const field_type& alpha, const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == y.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].usmv(alpha, x, y[i]);
+  //   }
+
+  //   //! y += A^T x
+  //   template<class X, class Y>
+  //   void umtv(const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == x.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].umtv(x[i], y);
+  //   }
+
+  //   //! y -= A^T x
+  //   template<class X, class Y>
+  //   void mmtv(const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == x.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].mmtv(x[i], y);
+  //   }
+
+  //   //! y += alpha A^T x
+  //   template<class X, class Y>
+  //   void usmtv(const field_type& alpha, const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == x.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].usmtv(alpha, x[i], y);
+  //   }
+
+  //   //! y += A^H x
+  //   template<class X, class Y>
+  //   void umhv(const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == x.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].umhv(x[i], y);
+  //   }
+
+  //   //! y -= A^H x
+  //   template<class X, class Y>
+  //   void mmhv(const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == x.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].mmhv(x[i], y);
+  //   }
+
+  //   //! y += alpha A^H x
+  //   template<class X, class Y>
+  //   void usmhv(const field_type& alpha, const X& x, Y& y) const
+  //   {
+  //     assert(this->N() == x.size());
+  //     for (size_type i = 0; i < this->N(); ++i)
+  //       (*this)[i][0].usmhv(alpha, x[i], y);
+  //   }
+  // };
+
+
+
+  // template <class B, class A>
+  // class SingleRowMatrix<Dune::Matrix<B,A>>
+  //     : public Dune::Matrix<B,A>
+  // {
+  //   using Super = Dune::Matrix<B,A>;
+  // public:
+  //   using size_type = typename Super::size_type;
+  //   using field_type = typename Super::field_type;
+  //   using block_type = typename Super::block_type;
+
+  //   using Dune::Matrix<B,A>::Matrix;
+
+  //   //! y = A x
+  //   template <class X, class Y>
+  //   void mv(const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     (*this)[0][0].mv(x[0], y);
+  //     for (size_type j = 1; j < this->M(); ++j)
+  //       (*this)[0][j].umv(x[j], y);
+  //   }
+
+  //   //! y = A^T x
+  //   template<class X, class Y>
+  //   void mtv(const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == y.size());
+  //     assert(this->M() > 0);
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].mtv(x, y[j]);
+  //   }
+
+  //   //! y += A x
+  //   template <class X, class Y>
+  //   void umv(const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].umv(x[j], y);
+  //   }
+
+  //   //! y -= A x
+  //   template<class X, class Y>
+  //   void mmv(const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].mmv(x[j], y);
+  //   }
+
+  //   /** \brief \f$ y += \alpha A x \f$ */
+  //   template <class X, class Y>
+  //   void usmv(const field_type& alpha, const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].usmv(alpha, x[j], y);
+  //   }
+
+  //   //! y += A^T x
+  //   template<class X, class Y>
+  //   void umtv(const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].umv(x[j], y);
+  //   }
+
+  //   //! y -= A^T x
+  //   template<class X, class Y>
+  //   void mmtv(const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].mmtv(x[j], y);
+  //   }
+
+  //   //! y += alpha A^T x
+  //   template<class X, class Y>
+  //   void usmtv(const field_type& alpha, const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].usmtv(alpha, x[j], y);
+  //   }
+
+  //   //! y += A^H x
+  //   template<class X, class Y>
+  //   void umhv(const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].umhv(x[j], y);
+  //   }
+
+  //   //! y -= A^H x
+  //   template<class X, class Y>
+  //   void mmhv(const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].mmhv(x[j], y);
+  //   }
+
+  //   //! y += alpha A^H x
+  //   template<class X, class Y>
+  //   void usmhv(const field_type& alpha, const X& x, Y& y) const
+  //   {
+  //     assert(this->M() == x.size());
+  //     for (size_type j = 0; j < this->M(); ++j)
+  //       (*this)[0][j].usmtv(alpha, x[j], y);
+  //   }
+  // };
 
 } // end namespace AMDiS
 
diff --git a/src/amdis/linearalgebra/istl/CMakeLists.txt b/src/amdis/linearalgebra/istl/CMakeLists.txt
index 230f5701..9ce97b96 100644
--- a/src/amdis/linearalgebra/istl/CMakeLists.txt
+++ b/src/amdis/linearalgebra/istl/CMakeLists.txt
@@ -1,6 +1,5 @@
 install(FILES
     BCRSMatrix.hpp
-    Constraints.hpp
     DirectRunner.hpp
     DOFMatrix.hpp
     DOFVector.hpp
diff --git a/src/amdis/linearalgebra/istl/Constraints.hpp b/src/amdis/linearalgebra/istl/Constraints.hpp
deleted file mode 100644
index fe5c2217..00000000
--- a/src/amdis/linearalgebra/istl/Constraints.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include <list>
-
-#include <dune/istl/bcrsmatrix.hh>
-
-#include <amdis/linearalgebra/Common.hpp>
-#include <amdis/linearalgebra/Constraints.hpp>
-
-namespace AMDiS
-{
-  template <class T, class A, class MultiIndex>
-  struct Constraints<Dune::BCRSMatrix<T,A>,MultiIndex>
-  {
-    using Matrix = Dune::BCRSMatrix<T,A>;
-
-    template <class DOFs>
-    static std::vector<Triplet<MultiIndex,T>> dirichletBC(Matrix& mat, DOFs const& dofs, bool setDiagonal = true)
-    {
-      // loop over the dirichlet DOFs
-      for (auto const& dof : dofs) {
-        std::size_t i = *dof;
-        auto cIt = mat[i].begin();
-        auto cEndIt = mat[i].end();
-        // loop over nonzero matrix entries in current row
-        for (; cIt != cEndIt; ++cIt)
-          *cIt = (setDiagonal && i == cIt.index() ? T(1) : T(0));
-      }
-
-      return {};
-    }
-
-    template <class BitVector, class Associations>
-    static std::vector<Triplet<MultiIndex,T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
-      bool setDiagonal = true)
-    {
-      error_exit("Not implemented");
-      return {};
-    }
-  };
-
-} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/mtl/CMakeLists.txt b/src/amdis/linearalgebra/mtl/CMakeLists.txt
index c02d9f2f..e662f4a5 100644
--- a/src/amdis/linearalgebra/mtl/CMakeLists.txt
+++ b/src/amdis/linearalgebra/mtl/CMakeLists.txt
@@ -1,5 +1,4 @@
 install(FILES
-    Constraints.hpp
     DOFMatrix.hpp
     DOFVector.hpp
     ITL_Preconditioner.hpp
diff --git a/src/amdis/linearalgebra/mtl/Constraints.hpp b/src/amdis/linearalgebra/mtl/Constraints.hpp
deleted file mode 100644
index e8d46fb7..00000000
--- a/src/amdis/linearalgebra/mtl/Constraints.hpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#pragma once
-
-#include <list>
-
-#include <boost/numeric/mtl/matrix/compressed2D.hpp>
-#include <boost/numeric/mtl/matrix/inserter.hpp>
-#include <boost/numeric/mtl/utility/property_map.hpp>
-#include <boost/numeric/mtl/utility/range_wrapper.hpp>
-
-#include <amdis/linearalgebra/Common.hpp>
-#include <amdis/linearalgebra/Constraints.hpp>
-
-namespace AMDiS
-{
-  template <class T, class P, class MultiIndex>
-  struct Constraints<mtl::compressed2D<T,P>,MultiIndex>
-  {
-    using Matrix = mtl::compressed2D<T,P>;
-
-#ifdef SYMMETRIC_DIRICHLET_BC
-    template <class BitVector>
-    static std::vector<Triplet<MultiIndex,T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
-    {
-      std::vector<Triplet<MultiIndex,T>> columns;
-      if (setDiagonal)
-        columns.reserve(std::size_t(mat.nnz()/(0.84*num_rows(mat))));
-
-      // Define the property maps
-      auto row   = mtl::mat::row_map(mat);
-      auto col   = mtl::mat::col_map(mat);
-      auto value = mtl::mat::value_map(mat);
-
-      // iterate over the matrix
-      std::size_t slotSize = 0;
-      for (auto r : mtl::rows_of(mat)) {   // rows or columns
-        std::size_t rowSize = 0;
-        for (auto i : mtl::nz_of(r)) {          // non-zeros within
-          ++rowSize;
-          if (nodes[row(i)]) {
-            // set identity row
-            value(i, T(0));
-          }
-          else if (setDiagonal && nodes[col(i)]) {
-            columns.push_back({row(i), col(i), value(i)});
-            value(i, T(0));
-          }
-        }
-        slotSize = std::max(slotSize, rowSize);
-      }
-
-      // set diagonal entry
-      if (setDiagonal) {
-        mtl::mat::inserter<Matrix, mtl::update_store<T> > ins(mat, slotSize);
-        for (std::size_t i = 0; i < nodes.size(); ++i) {
-          if (nodes[i])
-            ins[i][i] = T(1);
-        }
-      }
-
-      return columns;
-    }
-#else
-    template <class BitVector>
-    static std::vector<Triplet<MultiIndex,T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
-    {
-      // Define the property maps
-      auto row   = mtl::mat::row_map(mat);
-      auto col   = mtl::mat::col_map(mat);
-      auto value = mtl::mat::value_map(mat);
-
-      // iterate over the matrix
-      for (auto r : mtl::rows_of(mat)) {   // rows of the matrix
-        if (nodes[r.value()]) {
-          for (auto i : mtl::nz_of(r)) {          // non-zeros within
-            // set identity row
-            value(i, (setDiagonal && row(i) == col(i) ? T(1) : T(0)) );
-          }
-        }
-      }
-
-      return {};
-    }
-#endif
-
-
-    template <class Associations>
-    static std::size_t at(Associations const& m, std::size_t idx)
-    {
-      auto it = m.find(idx);
-      assert(it != m.end());
-      return it->second;
-    }
-
-#ifdef SYMMETRIC_PERIODIC_BC
-    template <class BitVector, class Associations>
-    static std::vector<Triplet<MultiIndex,T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
-      bool setDiagonal = true)
-    {
-      error_exit("Not implemented");
-    }
-#else
-    template <class BitVector, class Associations>
-    static std::vector<Triplet<MultiIndex,T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
-      bool setDiagonal = true)
-    {
-      std::vector<Triplet<MultiIndex,T>> rowValues;
-      rowValues.reserve(left2right.size()*std::size_t(mat.nnz()/(0.9*num_rows(mat))));
-
-      // Define the property maps
-      // auto row   = mtl::mat::row_map(mat);
-      auto col   = mtl::mat::col_map(mat);
-      auto value = mtl::mat::value_map(mat);
-
-      // iterate over the matrix
-      std::size_t slotSize = 0;
-      for (auto r : mtl::rows_of(mat)) {
-        if (left[r.value()]) {
-          slotSize = std::max(slotSize, std::size_t(mat.nnz_local(r.value())));
-          std::size_t right = at(left2right,r.value());
-
-          for (auto i : mtl::nz_of(r)) {
-            rowValues.push_back({right,col(i),value(i)});
-            value(i, T(0));
-          }
-        }
-      }
-
-      mtl::mat::inserter<Matrix, mtl::update_plus<T> > ins(mat, 2*slotSize);
-      for (auto const& t : rowValues)
-        ins[t.row][t.col] += t.value;
-
-      if (setDiagonal) {
-        for (std::size_t i = 0; i < mtl::size(left); ++i) {
-          if (left[i]) {
-            ins[i][i] = T(1);
-            ins[i][at(left2right,i)] = T(-1);
-          }
-        }
-      }
-
-      return {};
-    }
-#endif
-  };
-
-} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/mtl/MatrixVectorTraits.hpp b/src/amdis/linearalgebra/mtl/MatrixVectorTraits.hpp
index 1110e96f..b00e82fc 100644
--- a/src/amdis/linearalgebra/mtl/MatrixVectorTraits.hpp
+++ b/src/amdis/linearalgebra/mtl/MatrixVectorTraits.hpp
@@ -1,7 +1,8 @@
 #pragma once
 
-#include <amdis/linearalgebra/mtl/DOFMatrix.hpp>
-#include <amdis/linearalgebra/mtl/DOFVector.hpp>
+#include <vector>
+#include <amdis/linearalgebra/mtl/MtlMatrix.hpp>
+#include <amdis/linearalgebra/mtl/MtlVector.hpp>
 
 namespace AMDiS
 {
diff --git a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
index a0cf2241..c61338ab 100644
--- a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
@@ -4,15 +4,20 @@
 
 #include <boost/numeric/mtl/matrix/compressed2D.hpp>
 #include <boost/numeric/mtl/matrix/inserter.hpp>
+#include <boost/numeric/mtl/utility/property_map.hpp>
+#include <boost/numeric/mtl/utility/range_generator.hpp>
+#include <boost/numeric/mtl/utility/range_wrapper.hpp>
 
 #include <amdis/Output.hpp>
 #include <amdis/common/StaticSize.hpp>
+#include <amdis/linearalgebra/MatrixInserter.hpp>
 #include <amdis/linearalgebra/MatrixWrapper.hpp>
 
 namespace AMDiS
 {
   template <class Elt, class Parameters>
-  class MatrixInserter
+  class MatrixInserter<mtl::compressed2D<Elt, Parameters>>
+      : public MatrixInserterBase<MatrixInserter<mtl::compressed2D<Elt, Parameters>>>
   {
   public:
     /// The matrix type of the underlying base matrix
@@ -29,35 +34,14 @@ namespace AMDiS
 
   public:
     /// Constructor. Stores a pointer to the passed BaseMatrix
-    MatrixInserter(BaseMatrix& matrix)
-      : matrix_(matrix)
-    {}
-
-    ~MatrixInserter()
-    {
-      delete inserter_;
-    }
-
-    /// Create inserter. Assumes that no inserter is currently active on this matrix.
     template <class MatIndexSet>
-    void init_impl(MatIndexSet const& matrixIndexSet, bool rebuild = true)
+    MatrixInserter(BaseMatrix& matrix, MatIndexSet const& matIndexSet, bool rebuild)
+      : matrix_(matrix)
     {
-      test_exit(!inserter_, "Matrix already in insertion mode!");
-
-      calculateSlotSize(matrixIndexSet);
-
       if (rebuild)
         set_to_zero(matrix_);
 
-      inserter_ = new Inserter(matrix_, slotSize_);
-    }
-
-    /// Delete inserter -> finish insertion. Must be called in order to fill the
-    /// final construction of the matrix.
-    void finish_impl()
-    {
-      delete inserter_;
-      inserter_ = nullptr;
+      inserter_ = std::make_unique<Inserter>(matrix_, slotSize(matIndexSet));
     }
 
     template <class Row, class Col, class Assigner>
@@ -65,20 +49,21 @@ namespace AMDiS
     {
       size_type r = *row;
       size_type c = *col;
-      test_exit_dbg(inserter_, "Inserter not initilized!");
+      test_exit_dbg(bool(inserter_), "Inserter not initilized!");
       test_exit_dbg(r < num_rows(matrix_) && c < num_cols(matrix_),
           "Indices out of range [0,{})x[0,{})", num_rows(matrix_), num_cols(matrix_));
       assign(value, (*inserter_)[r][c]);
     }
 
   protected:
+    // return the average number of nz per row
     template <class MatIndexSet>
-    void calculateSlotSize(MatIndexSet const& matrixIndexSet)
+    static int slotSize(MatIndexSet const& matrixIndexSet)
     {
-      slotSize_ = 0;
+      int s = 0;
       for (std::size_t i = 0; i < matrixIndexSet.rows(); ++i)
-        slotSize_ += matrixIndexSet.rowsize(i);
-      slotSize_ = (slotSize_ + matrixIndexSet.rows() - 1) / matrixIndexSet.rows();
+        s += matrixIndexSet.rowsize(i);
+      return (s + matrixIndexSet.rows() - 1) / matrixIndexSet.rows();
     }
 
   private:
@@ -86,10 +71,7 @@ namespace AMDiS
     BaseMatrix& matrix_;
 
     /// A pointer to the inserter. Created in \ref init and destroyed in \ref finish
-    Inserter* inserter_ = nullptr;
-
-    /// The size of the slots used to insert values per row
-    int slotSize_ = 50;
+    std::unique_ptr<Inserter> inserter_ = nullptr;
   };
 
 
@@ -136,16 +118,16 @@ namespace AMDiS
 
       // iterate over the row
       push_back(col);
-      if (std::is_same<typename BaseMatrix::orientation, mtl::mat::row_major>::value)
+      if (std::is_same<typename BaseMatrix::orientation, mtl::tag::row_major>::value)
       {
-        auto r = begin<mtl::tag::row>(matrix_) + node;
+        auto r = mtl::begin<mtl::tag::major>(matrix_) + node;
         for (auto i : mtl::nz_of(r)) {  // non-zeros within row
           back(col) = col_of(i);
           row_values.emplace_back(row.multiIndex(), col, value(i));
           value(i, value_type(0));
         }
       } else {
-        for (auto c : mtl::cols_of(matrix_)) {
+        for (auto c : mtl::major_of(matrix_)) {
           for (auto i : mtl::nz_of(c)) {
             if (row_of(i) == node) {
               back(col) = col_of(i);
@@ -170,9 +152,9 @@ namespace AMDiS
 
       // iterate over the column
       push_back(row);
-      if (std::is_same<typename BaseMatrix::orientation, mtl::mat::row_major>::value)
+      if (std::is_same<typename BaseMatrix::orientation, mtl::tag::row_major>::value)
       {
-        for (auto r : mtl::rows_of(matrix_)) {
+        for (auto r : mtl::major_of(matrix_)) {
           for (auto i : mtl::nz_of(r)) {
             if (col_of(i) == node) {
               back(row) = row_of(i);
@@ -183,7 +165,7 @@ namespace AMDiS
           }
         }
       } else {
-        auto c = begin<mtl::tag::col>(matrix_) + node;
+        auto c = mtl::begin<mtl::tag::major>(matrix_) + node;
         for (auto i : mtl::nz_of(c)) {
           back(row) = row_of(i);
           col_values.emplace_back(row, col.multiIndex(), value(i));
diff --git a/src/amdis/linearalgebra/mtl/MtlVector.hpp b/src/amdis/linearalgebra/mtl/MtlVector.hpp
index fab4f16e..d446abd0 100644
--- a/src/amdis/linearalgebra/mtl/MtlVector.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlVector.hpp
@@ -17,6 +17,7 @@ namespace AMDiS
   public:
     /// The type of the elements of the DOFVector
     using value_type = ValueType;
+    using field_type = typename Dune::FieldTraits<ValueType>::field_type;
 
     /// The type of the base vector
     using BaseVector = mtl::vec::dense_vector<ValueType, Parameters>;
@@ -27,7 +28,7 @@ namespace AMDiS
   public:
     /// Constructor. Constructs new BaseVector.
     VectorWrapper(BaseVector& vector)
-      : vector_(&vector)
+      : vector_(vector)
     {}
 
     /// Resize the \ref vector_ to the size \p s
@@ -36,7 +37,7 @@ namespace AMDiS
     {
       size_type size = sizeProvider.size(prefix);
       assert(size > 0);
-      vector_->change_dim(size);
+      vector_.change_dim(size);
     }
 
     void init_impl(bool rebuild)
@@ -51,23 +52,23 @@ namespace AMDiS
     }
 
     /// Access the entry \p i of the \ref vector with write-access.
-    template <class Index>
-    void insert_impl(Index const& idx, value_type const& value)
+    template <class Index, class Assigner>
+    void insert_impl(Index const& idx, value_type const& value, Assigner assign)
     {
       size_type i = *idx;
-      test_exit_dbg(i < size(),
-        "Index {} out of range [0,{})", i, size());
-      (*vector_)[i] += value;
+      test_exit_dbg(i < size(vector_),
+        "Index {} out of range [0,{})", i, size(vector_));
+      assign(value, vector_[i]);
     }
 
     void set_impl(field_type value)
     {
-      *vector_ = value;
+      vector_ = value;
     }
 
   private:
     /// The data-vector
-    BaseVector* vector_;
+    BaseVector& vector_;
   };
 
 } // end namespace AMDiS
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 1c9d0289..947b937a 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -65,9 +65,6 @@ dune_add_test(SOURCES MarkerTest.cpp
 dune_add_test(SOURCES MatrixWrapperTest.cpp
   LINK_LIBRARIES amdis)
 
-dune_add_test(SOURCES MatrixTest.cpp
-  LINK_LIBRARIES amdis)
-
 dune_add_test(SOURCES MultiTypeVectorTest.cpp
   LINK_LIBRARIES amdis)
 
@@ -92,14 +89,6 @@ dune_add_test(SOURCES ResizeTest.cpp
 dune_add_test(SOURCES StaticSizeTest.cpp
   LINK_LIBRARIES amdis)
 
-foreach (BASIS_ID 0;1;2;3;4)
-  dune_add_test(NAME "StokesTest_${BASIS_ID}"
-    SOURCES StokesTest.cpp
-    LINK_LIBRARIES amdis
-    COMPILE_DEFINITIONS "BASIS_ID=${BASIS_ID}")
-endforeach ()
-unset(BASIS_ID)
-
 dune_add_test(SOURCES StringTest.cpp
   LINK_LIBRARIES amdis)
 
@@ -115,5 +104,18 @@ dune_add_test(SOURCES TreeContainerTest.cpp
 dune_add_test(SOURCES TypeTraitsTest.cpp
   LINK_LIBRARIES amdis)
 
-dune_add_test(SOURCES VectorTest.cpp
-  LINK_LIBRARIES amdis)
+if (NOT HAVE_MTL AND NOT HAVE_EIGEN)
+  dune_add_test(SOURCES MatrixTest.cpp
+    LINK_LIBRARIES amdis)
+
+  dune_add_test(SOURCES VectorTest.cpp
+    LINK_LIBRARIES amdis)
+
+  foreach (BASIS_ID 0;1;2;3;4)
+  dune_add_test(NAME "StokesTest_${BASIS_ID}"
+    SOURCES StokesTest.cpp
+    LINK_LIBRARIES amdis
+    COMPILE_DEFINITIONS "BASIS_ID=${BASIS_ID}")
+  endforeach ()
+  unset(BASIS_ID)
+endif ()
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index cee695e4..6279c86d 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -45,10 +45,6 @@ void test1(BasisTester& tester)
   matrixWrapper(matrix_data).resize(taylorHoodBasis, taylorHoodBasis);
   matrixWrapper(matrixIndexSet_data).resize(taylorHoodBasis, taylorHoodBasis);
 
-  MatrixInserter<Matrix> matrix(matrix_data);
-  MatrixInserter<HierarchicMatrixIndexSet> matrixIndexSet(matrixIndexSet_data);
-  printType(matrix);
-
   auto idx00 = std::array<std::size_t,2>{0,0};
   auto idx01 = std::array<std::size_t,2>{0,1};
   auto idx10 = std::array<std::size_t,2>{1,0};
@@ -56,44 +52,51 @@ void test1(BasisTester& tester)
   auto idx02 = std::array<std::size_t,2>{0,2};
 
   // 1. fill the occupation pattern
-  matrixIndexSet.insert(idx00, idx00, 1);
-  matrixIndexSet.insert(idx00, idx01, 1);
-  matrixIndexSet.insert(idx00, idx10, 1);
-  matrixIndexSet.insert(idx00, idx11, 1);
-  matrixIndexSet.insert(idx01, idx00, 1);
-  matrixIndexSet.insert(idx01, idx01, 1);
-  matrixIndexSet.insert(idx01, idx10, 1);
-  matrixIndexSet.insert(idx01, idx11, 1);
-  matrixIndexSet.insert(idx10, idx00, 1);
-  matrixIndexSet.insert(idx10, idx01, 1);
-  matrixIndexSet.insert(idx10, idx10, 1);
-  matrixIndexSet.insert(idx10, idx11, 1);
-  matrixIndexSet.insert(idx11, idx00, 1);
-  matrixIndexSet.insert(idx11, idx01, 1);
-  matrixIndexSet.insert(idx11, idx10, 1);
-  matrixIndexSet.insert(idx11, idx11, 1);
-  matrixIndexSet.insert(idx02, idx02, 1);
+  {
+    auto matrixIndexSet = matrixInserter(matrixIndexSet_data);
+
+    matrixIndexSet.insert(idx00, idx00, 1);
+    matrixIndexSet.insert(idx00, idx01, 1);
+    matrixIndexSet.insert(idx00, idx10, 1);
+    matrixIndexSet.insert(idx00, idx11, 1);
+    matrixIndexSet.insert(idx01, idx00, 1);
+    matrixIndexSet.insert(idx01, idx01, 1);
+    matrixIndexSet.insert(idx01, idx10, 1);
+    matrixIndexSet.insert(idx01, idx11, 1);
+    matrixIndexSet.insert(idx10, idx00, 1);
+    matrixIndexSet.insert(idx10, idx01, 1);
+    matrixIndexSet.insert(idx10, idx10, 1);
+    matrixIndexSet.insert(idx10, idx11, 1);
+    matrixIndexSet.insert(idx11, idx00, 1);
+    matrixIndexSet.insert(idx11, idx01, 1);
+    matrixIndexSet.insert(idx11, idx10, 1);
+    matrixIndexSet.insert(idx11, idx11, 1);
+    matrixIndexSet.insert(idx02, idx02, 1);
+  }
 
   // 2. apply the pattern to the matrix
-  matrix.init(matrixIndexSet_data,true);
-
-  // 3. fill the matrix
-  matrix.insert(idx00, idx00, 1.0);
-  matrix.insert(idx00, idx01, 2.0);
-  matrix.insert(idx00, idx10, 3.0);
-  matrix.insert(idx00, idx11, 4.0);
-  matrix.insert(idx01, idx00, 5.0);
-  matrix.insert(idx01, idx01, 6.0);
-  matrix.insert(idx01, idx10, 7.0);
-  matrix.insert(idx01, idx11, 8.0);
-  matrix.insert(idx10, idx00, 9.0);
-  matrix.insert(idx10, idx01, 10.0);
-  matrix.insert(idx10, idx10, 11.0);
-  matrix.insert(idx10, idx11, 12.0);
-  matrix.insert(idx11, idx00, 13.0);
-  matrix.insert(idx11, idx01, 14.0);
-  matrix.insert(idx11, idx10, 15.0);
-  matrix.insert(idx11, idx11, 16.0);
+  {
+    auto matrix = matrixInserter(matrix_data,matrixIndexSet_data,true);
+    printType(matrix);
+
+    // 3. fill the matrix
+    matrix.insert(idx00, idx00, 1.0);
+    matrix.insert(idx00, idx01, 2.0);
+    matrix.insert(idx00, idx10, 3.0);
+    matrix.insert(idx00, idx11, 4.0);
+    matrix.insert(idx01, idx00, 5.0);
+    matrix.insert(idx01, idx01, 6.0);
+    matrix.insert(idx01, idx10, 7.0);
+    matrix.insert(idx01, idx11, 8.0);
+    matrix.insert(idx10, idx00, 9.0);
+    matrix.insert(idx10, idx01, 10.0);
+    matrix.insert(idx10, idx10, 11.0);
+    matrix.insert(idx10, idx11, 12.0);
+    matrix.insert(idx11, idx00, 13.0);
+    matrix.insert(idx11, idx01, 14.0);
+    matrix.insert(idx11, idx10, 15.0);
+    matrix.insert(idx11, idx11, 16.0);
+  }
 
   AMDIS_TEST(matrixWrapper(matrix_data).nnz() >= 16u);
 
@@ -114,8 +117,6 @@ void test1(BasisTester& tester)
   AMDIS_TEST_EQ(matrix_data[1][1][1][0], 15.0);
   AMDIS_TEST_EQ(matrix_data[1][1][1][1], 16.0);
 
-  matrix.finish();
-
   std::cout << "\n";
   std::cout << matrix_data[0][0] << "\n";
   std::cout << matrix_data[0][1] << "\n";
@@ -151,8 +152,10 @@ void test2(BasisTester& tester)
   matrixWrapper(matrix).resize(taylorHoodBasis, taylorHoodBasis);
   matrixWrapper(matrixIndexSet).resize(taylorHoodBasis, taylorHoodBasis);
 
-  MatrixInserter<Matrix> inserter(matrix);
-  inserter.init(matrixIndexSet,true);
+  // create non-zero structure
+  {
+    auto inserter = matrixInserter(matrix,matrixIndexSet,true);
+  }
 
   std::cout << "\n";
   // velocity blocks
@@ -193,8 +196,10 @@ void test5(BasisTester& tester)
   matrixWrapper(matrix).resize(taylorHoodBasis, taylorHoodBasis);
   matrixWrapper(matrixIndexSet).resize(taylorHoodBasis, taylorHoodBasis);
 
-  MatrixInserter<Matrix> inserter(matrix);
-  inserter.init(matrixIndexSet,true);
+  // create non-zero structure
+  {
+    auto inserter = matrixInserter(matrix,matrixIndexSet,true);
+  }
 
   std::cout << "\n";
   // velocity blocks
diff --git a/test/MatrixWrapperTest.cpp b/test/MatrixWrapperTest.cpp
index 69914d75..969c8d89 100644
--- a/test/MatrixWrapperTest.cpp
+++ b/test/MatrixWrapperTest.cpp
@@ -25,19 +25,6 @@ class InserterImpl
     : public MatrixInserterBase<InserterImpl>
 {
 public:
-  /// Prepare the matrix forconstinsertion of values
-  template <class MatrixIndexSet>
-  void init_impl(MatrixIndexSet const& matrixIndexSet, bool rebuild)
-  {
-    msg("WrapperImpl::impl");
-  }
-
-  /// Finish the insertion
-  void finish_impl()
-  {
-    msg("WrapperImpl::finish");
-  }
-
   /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
   template <class Row, class Col, class ValueType, class Assigner>
   void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
@@ -102,8 +89,8 @@ void foo(MatrixWrapperBase<Impl>& wrapper)
 template <class Impl>
 void foo(MatrixInserterBase<Impl>& inserter)
 {
-  inserter.init(0, true);
-  inserter.finish();
+  FakeContainer r,c;
+  inserter.insert(r,c,1.0);
 }
 
 
-- 
GitLab


From fe67ac55cb985a8204c640e23012723dc213f7aa Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Tue, 23 Apr 2019 15:15:26 +0200
Subject: [PATCH 22/38] removed undefined reference to index_t<0> by
 introducing a global constant zero_

---
 src/amdis/common/Index.hpp                    |  7 +++
 .../linearalgebra/SingleRowColMatrix.hpp      | 16 +++---
 .../linearalgebra/istl/SingleRowColMatrix.hpp | 50 +++++++++----------
 3 files changed, 39 insertions(+), 34 deletions(-)

diff --git a/src/amdis/common/Index.hpp b/src/amdis/common/Index.hpp
index ab44576f..dd2609a9 100644
--- a/src/amdis/common/Index.hpp
+++ b/src/amdis/common/Index.hpp
@@ -34,6 +34,13 @@ namespace AMDiS
   template <std::size_t I>
   constexpr index_t<I> index_ = {};
 
+  // some predefined constants
+
+  using zero_t = index_t<0>;
+  static constexpr zero_t zero_ = {};
+
+  using one_t  = index_t<1>;
+  static constexpr one_t one_ = {};
 
   /// class that represents a sequence of indices
   template <std::size_t... I>
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index 4352bb53..d2ec5dfc 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -37,7 +37,7 @@ namespace AMDiS
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
       switchCases(hybridRows(inserter_.inserter_), *row, [&](auto i) -> void {
-        this->inserter(i,index_t<0>{}).insert(row.next(), col, value, assign);
+        this->inserter(i,zero_).insert(row.next(), col, value, assign);
       });
     }
 
@@ -74,7 +74,7 @@ namespace AMDiS
       rowPrefix.push_back(0);
       Dune::Hybrid::forEach(hybridRows(wrapper_.matrix_), [&](auto i) -> void {
         rowPrefix.back() = i;
-        this->wrapper(i,index_t<0>{}).resize(rowSize, rowPrefix, colSize, colPrefix);
+        this->wrapper(i,zero_).resize(rowSize, rowPrefix, colSize, colPrefix);
       });
     }
 
@@ -83,7 +83,7 @@ namespace AMDiS
     void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
       switchCases(hybridRows(wrapper_.matrix_), *row, [&](auto i) -> void {
-        this->wrapper(i,index_t<0>{}).clear_row(row.next(), col, row_values);
+        this->wrapper(i,zero_).clear_row(row.next(), col, row_values);
       });
     }
 
@@ -95,7 +95,7 @@ namespace AMDiS
       push_back(row);
       Dune::Hybrid::forEach(hybridRows(wrapper_.matrix_), [&](auto i) -> void {
         back(row) = i;
-        this->wrapper(i,index_t<0>{}).clear_col(row, col.next(), col_values);
+        this->wrapper(i,zero_).clear_col(row, col.next(), col_values);
       });
     }
 
@@ -135,7 +135,7 @@ namespace AMDiS
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
       switchCases(hybridCols(inserter_.inserter_), *col, [&](auto j) -> void {
-        this->inserter(index_t<0>{},j).insert(row, col.next(), value, assign);
+        this->inserter(zero_,j).insert(row, col.next(), value, assign);
       });
     }
 
@@ -171,7 +171,7 @@ namespace AMDiS
       colPrefix.push_back(0);
       Dune::Hybrid::forEach(hybridCols(wrapper_.matrix_), [&](auto j) -> void {
         colPrefix.back() = j;
-        this->wrapper(index_t<0>{},j).resize(rowSize, rowPrefix, colSize, colPrefix);
+        this->wrapper(zero_,j).resize(rowSize, rowPrefix, colSize, colPrefix);
       });
     }
 
@@ -183,7 +183,7 @@ namespace AMDiS
       push_back(col);
       Dune::Hybrid::forEach(hybridCols(wrapper_.matrix_), [&](auto j) -> void {
         back(col) = j;
-        this->wrapper(index_t<0>{},j).clear_row(row.next(), col, row_values);
+        this->wrapper(zero_,j).clear_row(row.next(), col, row_values);
       });
     }
 
@@ -192,7 +192,7 @@ namespace AMDiS
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
     {
       switchCases(hybridCols(wrapper_.matrix_), *col, [&](auto j) -> void {
-        this->wrapper(index_t<0>{},j).clear_col(row, col.next(), col_values);
+        this->wrapper(zero_,j).clear_col(row, col.next(), col_values);
       });
     }
 
diff --git a/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
index c22bb4df..8df3bb5a 100644
--- a/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
@@ -26,8 +26,6 @@ namespace AMDiS
     using block_type = typename Super::block_type;
 
   private:
-    static constexpr index_t<0> zero = {};
-
     template <size_type I0 = 0, class B, class A>
     static constexpr Dune::IntegralRange<size_type> row_range(Dune::Matrix<B,A> const& mat)
     {
@@ -49,7 +47,7 @@ namespace AMDiS
     {
       assert(this->N() == y.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].mv(x, y[i]);
+        (*this)[i][zero_].mv(x, y[i]);
       });
     }
 
@@ -59,9 +57,9 @@ namespace AMDiS
     {
       assert(this->N() == x.size());
       assert(this->N() > 0);
-      (*this)[zero][zero].mtv(x[zero], y);
+      (*this)[zero_][zero_].mtv(x[zero_], y);
       Dune::Hybrid::forEach(row_range<1>(*this), [&](auto i) -> void {
-        (*this)[i][zero].umtv(x[i], y);
+        (*this)[i][zero_].umtv(x[i], y);
       });
     }
 
@@ -71,7 +69,7 @@ namespace AMDiS
     {
       assert(this->N() == y.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].umv(x, y[i]);
+        (*this)[i][zero_].umv(x, y[i]);
       });
     }
 
@@ -81,7 +79,7 @@ namespace AMDiS
     {
       assert(this->N() == y.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].mmv(x, y[i]);
+        (*this)[i][zero_].mmv(x, y[i]);
       });
     }
 
@@ -91,7 +89,7 @@ namespace AMDiS
     {
       assert(this->N() == y.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].usmv(alpha, x, y[i]);
+        (*this)[i][zero_].usmv(alpha, x, y[i]);
       });
     }
 
@@ -101,7 +99,7 @@ namespace AMDiS
     {
       assert(this->N() == x.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].umtv(x[i], y);
+        (*this)[i][zero_].umtv(x[i], y);
       });
     }
 
@@ -111,7 +109,7 @@ namespace AMDiS
     {
       assert(this->N() == x.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].mmtv(x[i], y);
+        (*this)[i][zero_].mmtv(x[i], y);
       });
     }
 
@@ -121,7 +119,7 @@ namespace AMDiS
     {
       assert(this->N() == x.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].usmtv(alpha, x[i], y);
+        (*this)[i][zero_].usmtv(alpha, x[i], y);
       });
     }
 
@@ -131,7 +129,7 @@ namespace AMDiS
     {
       assert(this->N() == x.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].umhv(x[i], y);
+        (*this)[i][zero_].umhv(x[i], y);
       });
     }
 
@@ -141,7 +139,7 @@ namespace AMDiS
     {
       assert(this->N() == x.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].mmhv(x[i], y);
+        (*this)[i][zero_].mmhv(x[i], y);
       });
     }
 
@@ -151,7 +149,7 @@ namespace AMDiS
     {
       assert(this->N() == x.size());
       Dune::Hybrid::forEach(row_range(*this), [&](auto i) -> void {
-        (*this)[i][zero].usmhv(alpha, x[i], y);
+        (*this)[i][zero_].usmhv(alpha, x[i], y);
       });
     }
   };
@@ -191,9 +189,9 @@ namespace AMDiS
     void mv(const X& x, Y& y) const
     {
       assert(this->M() == x.size());
-      (*this)[zero][zero].mv(x[zero], y);
+      (*this)[zero_][zero_].mv(x[zero_], y);
       Dune::Hybrid::forEach(col_range<1>(*this), [&](auto j) -> void {
-        (*this)[zero][j].umv(x[j], y);
+        (*this)[zero_][j].umv(x[j], y);
       });
     }
 
@@ -204,7 +202,7 @@ namespace AMDiS
       assert(this->M() == y.size());
       assert(this->M() > 0);
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].mtv(x, y[j]);
+        (*this)[zero_][j].mtv(x, y[j]);
       });
     }
 
@@ -214,7 +212,7 @@ namespace AMDiS
     {
       assert(this->M() == x.size());
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].umv(x[j], y);
+        (*this)[zero_][j].umv(x[j], y);
       });
     }
 
@@ -224,7 +222,7 @@ namespace AMDiS
     {
       assert(this->M() == x.size());
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].mmv(x[j], y);
+        (*this)[zero_][j].mmv(x[j], y);
       });
     }
 
@@ -234,7 +232,7 @@ namespace AMDiS
     {
       assert(this->M() == x.size());
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].usmv(alpha, x[j], y);
+        (*this)[zero_][j].usmv(alpha, x[j], y);
       });
     }
 
@@ -244,7 +242,7 @@ namespace AMDiS
     {
       assert(this->M() == x.size());
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].umv(x[j], y);
+        (*this)[zero_][j].umv(x[j], y);
       });
     }
 
@@ -254,7 +252,7 @@ namespace AMDiS
     {
       assert(this->M() == x.size());
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].mmtv(x[j], y);
+        (*this)[zero_][j].mmtv(x[j], y);
       });
     }
 
@@ -264,7 +262,7 @@ namespace AMDiS
     {
       assert(this->M() == x.size());
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].usmtv(alpha, x[j], y);
+        (*this)[zero_][j].usmtv(alpha, x[j], y);
       });
     }
 
@@ -274,7 +272,7 @@ namespace AMDiS
     {
       assert(this->M() == x.size());
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].umhv(x[j], y);
+        (*this)[zero_][j].umhv(x[j], y);
       });
     }
 
@@ -284,7 +282,7 @@ namespace AMDiS
     {
       assert(this->M() == x.size());
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].mmhv(x[j], y);
+        (*this)[zero_][j].mmhv(x[j], y);
       });
     }
 
@@ -294,7 +292,7 @@ namespace AMDiS
     {
       assert(this->M() == x.size());
       Dune::Hybrid::forEach(col_range(*this), [&](auto j) -> void {
-        (*this)[zero][j].usmtv(alpha, x[j], y);
+        (*this)[zero_][j].usmtv(alpha, x[j], y);
       });
     }
   };
-- 
GitLab


From 99785141440195ccd3534ddc1acb6db9d91e786d Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Tue, 23 Apr 2019 15:56:04 +0200
Subject: [PATCH 23/38] NoMatrixIndexSet extracted from MatrixIndexSet.hpp to
 solve cyclic dependencies

---
 src/amdis/PeriodicBC.inc.hpp                  |  1 +
 src/amdis/functions/MultiIndex.hpp            |  7 ++++
 src/amdis/linearalgebra/CMakeLists.txt        |  1 +
 src/amdis/linearalgebra/MatrixIndexSet.hpp    | 30 ---------------
 src/amdis/linearalgebra/MatrixInserter.hpp    | 38 ++++++++++++++-----
 .../linearalgebra/MatrixInserter.inc.hpp      |  5 +++
 .../linearalgebra/MatrixInserterBase.hpp      | 13 ++-----
 src/amdis/linearalgebra/MatrixWrapper.hpp     | 28 ++++++++++----
 src/amdis/linearalgebra/MatrixWrapper.inc.hpp |  2 +
 src/amdis/linearalgebra/MatrixWrapperBase.hpp | 32 ++++++++--------
 src/amdis/linearalgebra/NoMatrixIndexSet.hpp  | 37 ++++++++++++++++++
 11 files changed, 123 insertions(+), 71 deletions(-)
 create mode 100644 src/amdis/linearalgebra/NoMatrixIndexSet.hpp

diff --git a/src/amdis/PeriodicBC.inc.hpp b/src/amdis/PeriodicBC.inc.hpp
index 2031d507..1fe0d4d3 100644
--- a/src/amdis/PeriodicBC.inc.hpp
+++ b/src/amdis/PeriodicBC.inc.hpp
@@ -9,6 +9,7 @@
 
 #include <amdis/LinearAlgebra.hpp>
 #include <amdis/linearalgebra/Common.hpp>
+#include <amdis/linearalgebra/NoMatrixIndexSet.hpp>
 
 namespace AMDiS {
 
diff --git a/src/amdis/functions/MultiIndex.hpp b/src/amdis/functions/MultiIndex.hpp
index 81f9058d..b7942495 100644
--- a/src/amdis/functions/MultiIndex.hpp
+++ b/src/amdis/functions/MultiIndex.hpp
@@ -92,6 +92,13 @@ namespace AMDiS
     return {multiIndex};
   }
 
+  /// Forard the passed \ref MultiIndex
+  template <class MultiIndex, std::size_t shift>
+  constexpr MultiIndexIterator<MultiIndex,shift> const& multiIndexIterator(MultiIndexIterator<MultiIndex,shift> const& multiIndex)
+  {
+    return multiIndex;
+  }
+
 } // end namespace AMDiS
 
 namespace Dune
diff --git a/src/amdis/linearalgebra/CMakeLists.txt b/src/amdis/linearalgebra/CMakeLists.txt
index e751d61a..789335f6 100644
--- a/src/amdis/linearalgebra/CMakeLists.txt
+++ b/src/amdis/linearalgebra/CMakeLists.txt
@@ -19,6 +19,7 @@ install(FILES
     MatrixWrapperBase.hpp
     MultiTypeMatrix.hpp
     MultiTypeVector.hpp
+    NoMatrixIndexSet.hpp
     PreconditionerInterface.hpp
     RunnerInterface.hpp
     SingleRowColMatrix.hpp
diff --git a/src/amdis/linearalgebra/MatrixIndexSet.hpp b/src/amdis/linearalgebra/MatrixIndexSet.hpp
index 223acb62..1afd48eb 100644
--- a/src/amdis/linearalgebra/MatrixIndexSet.hpp
+++ b/src/amdis/linearalgebra/MatrixIndexSet.hpp
@@ -112,36 +112,6 @@ namespace AMDiS
     size_type cols_ = 0;
   };
 
-  class NoMatrixIndexSet
-  {
-  public:
-    NoMatrixIndexSet(std::size_t slotSize = 1)
-      : slotSize_(slotSize)
-    {}
-
-    std::size_t rows() const
-    {
-      return 1;
-    }
-
-    std::size_t rowsize(std::size_t i) const
-    {
-      return slotSize_;
-    }
-
-    template <class MatrixType>
-    void exportIdx(MatrixType& matrix) const {}
-
-    template <class I>
-    NoMatrixIndexSet& operator[](I const& i) { return *this; }
-
-    template <class I>
-    NoMatrixIndexSet const& operator[](I const& i) const { return *this; }
-
-  private:
-    std::size_t slotSize_;
-  };
-
 
   template <class Traits>
   struct MatrixIndexSetTraits : Traits
diff --git a/src/amdis/linearalgebra/MatrixInserter.hpp b/src/amdis/linearalgebra/MatrixInserter.hpp
index 1d43b650..044c585d 100644
--- a/src/amdis/linearalgebra/MatrixInserter.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.hpp
@@ -7,42 +7,55 @@
 #include <amdis/common/FieldMatVec.hpp>
 #include <amdis/common/Index.hpp>
 #include <amdis/linearalgebra/MatrixInserterBase.hpp>
+#include <amdis/linearalgebra/NoMatrixIndexSet.hpp>
 
 namespace AMDiS
 {
   template <class BaseMatrix>
   class MatrixInserter;
 
-  class NoMatrixIndexSet;
-
+  /// \brief Creator for the \ref MatrixInserter. Forward the arguments to the constructor of the class.
+  /**
+   * A \ref MatrixInserter is created from a `BaseMatrix` and a \ref MatrixIndexSet.
+   * It is expected that the matrix and the matrixIndexSet are already resized correctly.
+   * The option `rebuild` enforces that the matrix is set to *zero* if `rebuild==true`.
+   **/
   template <class BaseMatrix, class MatIndexSet>
   MatrixInserter<BaseMatrix> matrixInserter(BaseMatrix& matrix, MatIndexSet const& matIndexSet, bool rebuild)
   {
     return MatrixInserter<BaseMatrix>{matrix, matIndexSet, rebuild};
   }
 
+  /// \brief Creator for the \ref MatrixInserter that does not use a \ref MatrixIndexSet.
+  /**
+   * A \ref MatrixInserter is created from a `BaseMatrix` and a \ref NoMatrixIndexSet.
+   * It is expected that the matrix and the matrixIndexSet are already resized correctly.
+   * The option `rebuild` enforces that the matrix is set to *zero* if `rebuild==true`.
+   **/
   template <class BaseMatrix>
   MatrixInserter<BaseMatrix> matrixInserter(BaseMatrix& matrix)
   {
     return MatrixInserter<BaseMatrix>{matrix, NoMatrixIndexSet{}, false};
   }
 
-
-
+  // some forward declarations
   template <class Scalar>
   class MatrixInserterScalarImpl;
 
   template <class BaseMatrix, class Inserter>
   class MatrixInserterImpl;
 
-  template <class BaseMatrix>
-  class MatrixDynamicInserter;
-
-  template <class BaseMatrix>
-  class MatrixStaticInserter;
+  template <class BaseMatrix> class MatrixDynamicInserter;
+  template <class BaseMatrix> class MatrixStaticInserter;
 
   namespace Impl
   {
+    // select the matrix inserter by properties of the matrix, if not explicitly specialized
+    // 1. If matrix is a scalar-matrix (1x1), use the scalar inserter
+    // 2. If matrix allows dynamic indices, use the \ref MatrixDynamicInserter
+    // 3. If the matrix only allows static indices (i.e. integral_constant<std::size_t>), use
+    //    the \ref MatrixStaticInserter
+    // 4. Otherwise treat the matrix as scalar.
     template <class M>
     using MatrixInserterSelector =
       std::conditional_t<Dune::MatVec::IsScalarMatrix<M>::value,
@@ -55,6 +68,13 @@ namespace AMDiS
 
   } // end namespace Impl
 
+
+  /// \brief Generic implementation of a matrix inserter that provides the \ref insert() method.
+  /**
+   * Select a Matrix inserter using the \ref MatrixInserterSelector, especially the \ref MatrixInserterImpl.
+   * This class implements a \ref MatrixInserterBase.
+   * This template is used if not explicit template specialization for a given matrixtype is found.
+   **/
   template <class BaseMatrix>
   class MatrixInserter
       : public Impl::MatrixInserterSelector<BaseMatrix>
diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
index e66ac2db..c0930e91 100644
--- a/src/amdis/linearalgebra/MatrixInserter.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -11,9 +11,11 @@
 #include <amdis/common/HybridSize.hpp>
 #include <amdis/common/SwitchCases.hpp>
 #include <amdis/linearalgebra/Common.hpp>
+#include <amdis/linearalgebra/NoMatrixIndexSet.hpp>
 
 namespace AMDiS
 {
+  /// Implementation of a \ref MatrixInserter for scalar types
   template <class Scalar>
   class MatrixInserterScalarImpl
       : public MatrixInserterBase<MatrixInserterScalarImpl<Scalar>>
@@ -43,6 +45,7 @@ namespace AMDiS
   };
 
 
+  /// A Container representing the inserter for a matrix with dynamic indexing.
   template <class BaseMatrix>
   class MatrixDynamicInserter
   {
@@ -82,6 +85,7 @@ namespace AMDiS
   };
 
 
+  /// A Container representing the inserter for a matrix with static indexing.
   template <class BaseMatrix>
   class MatrixStaticInserter
   {
@@ -131,6 +135,7 @@ namespace AMDiS
   };
 
 
+  /// The general implementation of a \ref MatrixInserter.
   template <class BaseMatrix, class Inserter>
   class MatrixInserterImpl
       : public MatrixInserterBase<MatrixInserterImpl<BaseMatrix,Inserter>>
diff --git a/src/amdis/linearalgebra/MatrixInserterBase.hpp b/src/amdis/linearalgebra/MatrixInserterBase.hpp
index 7a1846d2..95527da0 100644
--- a/src/amdis/linearalgebra/MatrixInserterBase.hpp
+++ b/src/amdis/linearalgebra/MatrixInserterBase.hpp
@@ -7,21 +7,16 @@
 
 namespace AMDiS
 {
+  /// \brief CRTP-base class for \ref MatrixInserter.
   template <class Impl>
   class MatrixInserterBase
   {
   public:
     /// Insert a new value into the matrix at multiIndex (row,col) using operator+=
-    template <class Row, class Col, class ValueType>
-    void insert(Row const& row, Col const& col, ValueType const& value)
+    template <class Row, class Col, class ValueType, class Assign = Assigner::plus_assign>
+    void insert(Row const& row, Col const& col, ValueType const& value, Assign assign = {})
     {
-      asImpl().insert_impl(multiIndexIterator(row), multiIndexIterator(col), value, Assigner::plus_assign{});
-    }
-
-    template <class Row, std::size_t r, class Col, std::size_t c, class ValueType, class Assigner>
-    void insert(MultiIndexIterator<Row,r> const& row, MultiIndexIterator<Col,c> const& col, ValueType const& value, Assigner assign)
-    {
-      asImpl().insert_impl(row, col, value, assign);
+      asImpl().insert_impl(multiIndexIterator(row), multiIndexIterator(col), value, assign);
     }
 
   protected: // default implementation:
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
index a3c3234f..361d05a0 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -15,12 +15,14 @@ namespace AMDiS
   template <class BaseMatrix>
   class MatrixWrapper;
 
+  /// \brief Creator for the \ref MatrixWrapper from a given `BaseMatrix`.
   template <class BaseMatrix>
   MatrixWrapper<BaseMatrix> matrixWrapper(BaseMatrix& matrix)
   {
     return {matrix};
   }
 
+  // some forward declarations
   template <class Scalar>
   class MatrixWrapperScalarImpl;
 
@@ -29,6 +31,10 @@ namespace AMDiS
 
   namespace Impl
   {
+    // select the matrix wrapper by properties of the matrix, if not explicitly specialized
+    // 1. If matrix is a scalar-matrix (1x1), use the scalar wrapper
+    // 2. If matrix allows indexing, use the \ref MatrixWrapperImpl
+    // 3. Otherwise treat the matrix as scalar.
     template <class M>
     using MatrixWrapperSelector =
       std::conditional_t<Dune::MatVec::IsScalarMatrix<M>::value,
@@ -39,6 +45,14 @@ namespace AMDiS
 
   } // end namespace Impl
 
+
+  /// \brief Generic implementation of a matrix wrapper that provides the \ref resize(), \ref clear_row(),
+  /// \ref clear_col(), and \ref nnz() methods.
+  /**
+   * Select a Matrix wrapper using the \ref MatrixWrapperSelector, especially the \ref MatrixWrapperImpl.
+   * This class implements a \ref MatrixWrapperBase.
+   * This template is used if not explicit template specialization for a given matrixtype is found.
+   **/
   template <class BaseMatrix>
   class MatrixWrapper
       : public Impl::MatrixWrapperSelector<BaseMatrix>
@@ -51,13 +65,13 @@ namespace AMDiS
     {}
   };
 
-  template <class BaseMatrix>
-  class MatrixWrapper<const BaseMatrix>
-      : public MatrixWrapper<BaseMatrix>
-  {
-  public:
-    using MatrixWrapper<BaseMatrix>::MatrixWrapper;
-  };
+  // template <class BaseMatrix>
+  // class MatrixWrapper<const BaseMatrix>
+  //     : public MatrixWrapper<BaseMatrix>
+  // {
+  // public:
+  //   using MatrixWrapper<BaseMatrix>::MatrixWrapper;
+  // };
 
 } // end namespace AMDiS
 
diff --git a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
index fc4e2708..39fa6b6b 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.inc.hpp
@@ -12,6 +12,7 @@
 
 namespace AMDiS
 {
+  /// Implementation of a \ref MatrixWrapper for scalar types
   template <class Scalar>
   class MatrixWrapperScalarImpl
       : public MatrixWrapperBase<MatrixWrapperScalarImpl<Scalar>>
@@ -54,6 +55,7 @@ namespace AMDiS
   };
 
 
+  /// The general implementation of a \ref MatrixWrapper.
   template <class BaseMatrix>
   class MatrixWrapperImpl
       : public MatrixWrapperBase<MatrixWrapperImpl<BaseMatrix>>
diff --git a/src/amdis/linearalgebra/MatrixWrapperBase.hpp b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
index c16f559a..c5bd251f 100644
--- a/src/amdis/linearalgebra/MatrixWrapperBase.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapperBase.hpp
@@ -8,11 +8,12 @@
 
 namespace AMDiS
 {
+  /// \brief CRTP-base class for \ref MatrixWrapper.
   template <class Impl>
   class MatrixWrapperBase
   {
   public:
-    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    /// Resize matrix to desired size given by the SizeProviders. See \ref Dune::SizeInfo.
     template <class RowSizeInfo, class ColSizeInfo>
     void resize(RowSizeInfo const& rowSizeInfo, ColSizeInfo const& colSizeInfo)
     {
@@ -21,7 +22,12 @@ namespace AMDiS
       asImpl().resize_impl(rowSizeInfo, rowPrefix, colSizeInfo, colPrefix);
     }
 
-    /// Resize \ref matrix_ to desired size (`rows` x `cols`)
+    /// Resize the matrix to desired size
+    /**
+     * Resize the underlying matrix to `rowSizeInfo(rowPrefix) x colSizeInfo(colPrefix)`,
+     * append another prefix index to the row/col-Prefix containers and forward to the
+     * next block-level.
+     **/
     template <class RowSizeInfo, class ColSizeInfo>
     void resize(RowSizeInfo const& rowSizeInfo, typename RowSizeInfo::SizePrefix rowPrefix,
                 ColSizeInfo const& colSizeInfo, typename ColSizeInfo::SizePrefix colPrefix)
@@ -29,7 +35,7 @@ namespace AMDiS
       asImpl().resize_impl(rowSizeInfo, rowPrefix, colSizeInfo, colPrefix);
     }
 
-    /// Eliminate a row in the matrix given by a multiIndex. Optionally set the diagonal entry to 1
+    /// Eliminate a row in the matrix given by a multiIndex.
     template <class Row>
     void clear_row(Row const& row)
     {
@@ -37,6 +43,7 @@ namespace AMDiS
       clear_row(row, col);
     }
 
+    /// Eliminate a row in the matrix given by a multiIndex `row` and traverse all columns, filled into `col`.
     template <class Row, class Col>
     void clear_row(Row const& row, Col&& col)
     {
@@ -44,20 +51,16 @@ namespace AMDiS
       clear_row(row, FWD(col), row_values);
     }
 
+    /// Eliminate a row in the matrix given by a multiIndex `row`, traverse all columns, filled into `col` and store the
+    /// eliminated row values in the container `row_values`.
     template <class Row, class Col, class RowValues>
     void clear_row(Row const& row, Col&& col, RowValues& row_values)
     {
       asImpl().clear_row_impl(multiIndexIterator(row), FWD(col), row_values);
     }
 
-    template <class Row, std::size_t r, class Col, class RowValues>
-    void clear_row(MultiIndexIterator<Row,r> const& row, Col&& col, RowValues& row_values)
-    {
-      asImpl().clear_row_impl(row, FWD(col), row_values);
-    }
 
-    /// Eliminate a row and column in the matrix given by a multiIndex. Store the column values
-    /// in the vector `columns` and optionally set the diagonal entry to 1
+    /// Eliminate a columns in the matrix given by a multiIndex `col`.
     template <class Col>
     void clear_col(Col const& col)
     {
@@ -65,6 +68,7 @@ namespace AMDiS
       clear_col(row, col);
     }
 
+    /// Eliminate a columns in the matrix given by a multiIndex `col` and traverse all rows, filled into `row`.
     template <class Row, class Col>
     void clear_col(Row&& row, Col const& col)
     {
@@ -72,18 +76,14 @@ namespace AMDiS
       clear_col(FWD(row), col, col_values);
     }
 
+    /// Eliminate a columns in the matrix given by a multiIndex `col`, traverse all rows, filled into `row` and store the
+    /// eliminated column values in the container `col_values`.
     template <class Row, class Col, class ColValues>
     void clear_col(Row&& row, Col const& col, ColValues& col_values)
     {
       asImpl().clear_col_impl(FWD(row), multiIndexIterator(col), col_values);
     }
 
-    template <class Row, class Col, std::size_t c, class ColValues>
-    void clear_col(Row&& row, MultiIndexIterator<Col,c> const& col, ColValues& col_values)
-    {
-      asImpl().clear_col_impl(FWD(row), col, col_values);
-    }
-
     /// Return the number of nonzeros in the matrix
     std::size_t nnz()
     {
diff --git a/src/amdis/linearalgebra/NoMatrixIndexSet.hpp b/src/amdis/linearalgebra/NoMatrixIndexSet.hpp
new file mode 100644
index 00000000..c6592ff3
--- /dev/null
+++ b/src/amdis/linearalgebra/NoMatrixIndexSet.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <cstddef>
+
+namespace AMDiS
+{
+  class NoMatrixIndexSet
+  {
+  public:
+    NoMatrixIndexSet(std::size_t slotSize = 1)
+      : slotSize_(slotSize)
+    {}
+
+    std::size_t rows() const
+    {
+      return 1;
+    }
+
+    std::size_t rowsize(std::size_t i) const
+    {
+      return slotSize_;
+    }
+
+    template <class MatrixType>
+    void exportIdx(MatrixType& matrix) const {}
+
+    template <class I>
+    NoMatrixIndexSet& operator[](I const& i) { return *this; }
+
+    template <class I>
+    NoMatrixIndexSet const& operator[](I const& i) const { return *this; }
+
+  private:
+    std::size_t slotSize_;
+  };
+
+} // end namespace AMDiS
-- 
GitLab


From 147be494256b37b5d87ba011341cb97b8614db6d Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Tue, 23 Apr 2019 16:53:27 +0200
Subject: [PATCH 24/38] added documentation and a vector-inserter

---
 src/amdis/linearalgebra/CMakeLists.txt        |   3 +
 src/amdis/linearalgebra/DOFVectorBase.hpp     |   7 +-
 src/amdis/linearalgebra/DOFVectorBase.inc.hpp |  15 +-
 .../linearalgebra/MatrixInserter.inc.hpp      |  25 ++--
 src/amdis/linearalgebra/MatrixWrapper.hpp     |  10 +-
 .../linearalgebra/SingleRowColMatrix.hpp      |  34 +++++
 src/amdis/linearalgebra/VectorInserter.hpp    |  81 +++++++++++
 .../linearalgebra/VectorInserter.inc.hpp      | 137 ++++++++++++++++++
 .../linearalgebra/VectorInserterBase.hpp      |  31 ++++
 src/amdis/linearalgebra/VectorWrapper.hpp     |  21 ++-
 src/amdis/linearalgebra/VectorWrapper.inc.hpp |  35 +----
 src/amdis/linearalgebra/VectorWrapperBase.hpp |  43 +-----
 src/amdis/linearalgebra/mtl/MtlMatrix.hpp     |   2 +-
 src/amdis/linearalgebra/mtl/MtlVector.hpp     |  69 ++++++---
 14 files changed, 387 insertions(+), 126 deletions(-)
 create mode 100644 src/amdis/linearalgebra/VectorInserter.hpp
 create mode 100644 src/amdis/linearalgebra/VectorInserter.inc.hpp
 create mode 100644 src/amdis/linearalgebra/VectorInserterBase.hpp

diff --git a/src/amdis/linearalgebra/CMakeLists.txt b/src/amdis/linearalgebra/CMakeLists.txt
index 789335f6..7505b37a 100644
--- a/src/amdis/linearalgebra/CMakeLists.txt
+++ b/src/amdis/linearalgebra/CMakeLists.txt
@@ -24,6 +24,9 @@ install(FILES
     RunnerInterface.hpp
     SingleRowColMatrix.hpp
     SolverInfo.hpp
+    VectorInserter.hpp
+    VectorInserter.inc.hpp
+    VectorInserterBase.hpp
     VectorWrapper.hpp
     VectorWrapper.inc.hpp
     VectorWrapperBase.hpp
diff --git a/src/amdis/linearalgebra/DOFVectorBase.hpp b/src/amdis/linearalgebra/DOFVectorBase.hpp
index 0463487a..33fbcc04 100644
--- a/src/amdis/linearalgebra/DOFVectorBase.hpp
+++ b/src/amdis/linearalgebra/DOFVectorBase.hpp
@@ -17,6 +17,7 @@
 #include <amdis/functions/MultiIndex.hpp>
 #include <amdis/linearalgebra/DOFVectorInterface.hpp>
 #include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
+#include <amdis/linearalgebra/VectorInserter.hpp>
 #include <amdis/linearalgebra/VectorWrapper.hpp>
 #include <amdis/operations/Assigner.hpp>
 #include <amdis/typetree/TreePath.hpp>
@@ -80,6 +81,7 @@ namespace AMDiS
 
     /// The type of the data vector used in the backend
     using BaseVector = VectorGenerator_t<K,Traits,Blocking>;
+    using Inserter = VectorInserter<BaseVector>;
 
     /// The type of the vector filled on an element with local contributions
     using ElementVector = Dune::DynamicVector<value_type>;
@@ -221,7 +223,8 @@ namespace AMDiS
     template <class MultiIndex>
     void insert(MultiIndex const& idx, value_type const& value)
     {
-      vectorWrapper(vector_).insert(idx, value);
+      assert(inserter_ != nullptr);
+      inserter_->insert(idx, value);
     }
 
     /// Insert a block of values into the matrix (add to existing values)
@@ -303,6 +306,8 @@ namespace AMDiS
     /// Data backend
     BaseVector vector_;
 
+    Inserter* inserter_ = nullptr;
+
     /// Dense vector to store coefficients during \ref assemble()
     ElementVector elementVector_;
 
diff --git a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
index c948b0e1..d5bf992d 100644
--- a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
@@ -16,8 +16,7 @@ void DOFVectorBase<GB,T,K>::
 init(bool rebuild)
 {
   resize();
-  if (rebuild)
-    vectorWrapper(vector_).set(0);
+  inserter_ = new Inserter(vector_, rebuild);
 
   auto const localSize = basis_->localView().maxSize();
   elementVector_.resize(localSize);
@@ -26,7 +25,11 @@ init(bool rebuild)
 
 template <class GB, class T, class K>
 void DOFVectorBase<GB,T,K>::
-finish() {}
+finish()
+{
+  delete inserter_;
+  inserter_ = nullptr;
+}
 
 
 template <class GB, class T, class K>
@@ -34,10 +37,10 @@ void DOFVectorBase<GB,T,K>::
 insert(LocalView const& localView, ElementVector const& elementVector)
 {
   using std::abs;
-  VectorWrapper<BaseVector> wrapper(vector_);
+  assert(inserter_ != nullptr);
   for (size_type i = 0; i < localView.size(); ++i) {
-    if (abs(elementVector[i]) > threshold<double>) {
-      wrapper.insert(localView.index(i), elementVector[i]);
+    if (std::abs(elementVector[i]) > threshold<double>) {
+      inserter_->insert(localView.index(i), elementVector[i]);
     }
   }
 }
diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
index c0930e91..213cfcc8 100644
--- a/src/amdis/linearalgebra/MatrixInserter.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -23,10 +23,13 @@ namespace AMDiS
     template <class> friend class MatrixInserter;
 
   public:
-    template <class... Args>
-    MatrixInserterScalarImpl(Scalar& scalar, Args&&... /*args*/)
+    template <class MIS>
+    MatrixInserterScalarImpl(Scalar& scalar, MIS const& /*matrixIndexSt*/, bool rebuild)
       : scalar_(scalar)
-    {}
+    {
+      if (rebuild)
+        scalar_ = 0;
+    }
 
     /// Implements \ref MatrixInserterBase::insert
     template <class Row, class Col, class ValueType, class Assigner>
@@ -63,14 +66,14 @@ namespace AMDiS
     };
 
   public:
-    template <class MatIndexSet>
-    MatrixDynamicInserter(BaseMatrix& matrix, MatIndexSet const& matIndexSet, bool rebuild)
+    template <class MIS>
+    MatrixDynamicInserter(BaseMatrix& matrix, MIS const& matIndexSet, bool rebuild)
       : rows_(matrix.N())
       , cols_(matrix.M())
     {
       for (size_type i = 0; i < rows_; ++i)
         for (size_type j = 0; j < cols_; ++j)
-          inserter_.emplace_back(access(matrix,i,j), access(matIndexSet,i,j), rebuild);
+          inserter_.emplace_back(matrix[i][j], matIndexSet[i][j], rebuild);
     }
 
     size_type N() const { return rows_; }
@@ -116,14 +119,14 @@ namespace AMDiS
     struct AccessProxy
     {
       template <std::size_t j>
-      auto& operator[](index_t<j>) { return access(inserter_, index_t<i>{}, index_t<j>{}); }
+      auto& operator[](index_t<j>) { return inserter_[index_t<i>{}][index_t<j>{}]; }
 
       Inserter& inserter_;
     };
 
   public:
-    template <class MatIndexSet>
-    MatrixStaticInserter(BaseMatrix& matrix, MatIndexSet const& matIndexSet, bool rebuild)
+    template <class MIS>
+    MatrixStaticInserter(BaseMatrix& matrix, MIS const& matIndexSet, bool rebuild)
       : inserter_(create(matrix, matIndexSet, rebuild))
     {}
 
@@ -143,8 +146,8 @@ namespace AMDiS
     template <class> friend class MatrixInserter;
 
   public:
-    template <class MatIndexSet>
-    MatrixInserterImpl(BaseMatrix& matrix, MatIndexSet const& matrixIndexSet, bool rebuild)
+    template <class MIS>
+    MatrixInserterImpl(BaseMatrix& matrix, MIS const& matrixIndexSet, bool rebuild)
       : inserter_(matrix, matrixIndexSet, rebuild)
     {}
 
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
index 361d05a0..04f5304a 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -51,7 +51,7 @@ namespace AMDiS
   /**
    * Select a Matrix wrapper using the \ref MatrixWrapperSelector, especially the \ref MatrixWrapperImpl.
    * This class implements a \ref MatrixWrapperBase.
-   * This template is used if not explicit template specialization for a given matrixtype is found.
+   * This template is used if not explicit template specialization for a given matrix-type is found.
    **/
   template <class BaseMatrix>
   class MatrixWrapper
@@ -65,14 +65,6 @@ namespace AMDiS
     {}
   };
 
-  // template <class BaseMatrix>
-  // class MatrixWrapper<const BaseMatrix>
-  //     : public MatrixWrapper<BaseMatrix>
-  // {
-  // public:
-  //   using MatrixWrapper<BaseMatrix>::MatrixWrapper;
-  // };
-
 } // end namespace AMDiS
 
 #include <amdis/linearalgebra/MatrixWrapper.inc.hpp>
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index d2ec5dfc..cec750c6 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -33,6 +33,10 @@ namespace AMDiS
     {}
 
     /// Implements \ref MatrixInserterBase::insert
+    /**
+     * Call the \ref insert() method on the provided (row,col) block, where we implicitly assume a
+     * column index zero and simply forward the column multiIndex without shifting.
+     **/
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
@@ -63,6 +67,10 @@ namespace AMDiS
     {}
 
     /// Implements \ref MatrixWrapperBase::resize
+    /**
+     * Call the \ref resize(rows,1) where `rows` is given by the rowSize provider. Calls recursively
+     * the `resize()` method on all rows in the single column 0.
+     **/
     template <class RowSize, class ColSize>
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                       ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
@@ -79,6 +87,9 @@ namespace AMDiS
     }
 
     /// Implements \ref MatrixWrapperBase::clear_row
+    /**
+     * Calls `clear_row` on the provided `row` and simply forward the column index.
+     **/
     template <class RowIter, class Col, class RowValues>
     void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
@@ -88,6 +99,9 @@ namespace AMDiS
     }
 
     /// Implements \ref MatrixWrapperBase::clear_col
+    /**
+     * Calls `clear_col` on all rows, where we assume, that the provided column index is zero.
+     **/
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
     {
@@ -100,6 +114,9 @@ namespace AMDiS
     }
 
     /// Implements \ref MatrixWrapperBase::nnz
+    /**
+     * Returns the number of nonzeros of the original matrix-wrapper
+     **/
     std::size_t nnz_impl()
     {
       return wrapper_.nnz();
@@ -131,6 +148,10 @@ namespace AMDiS
     {}
 
     /// Implements \ref MatrixInserterBase::insert
+    /**
+     * Call the \ref insert() method on the provided (row,col) block, where we implicitly assume a
+     * row index zero and simply forward the row multiIndex without shifting.
+     **/
     template <class Row, class Col, class ValueType, class Assigner>
     void insert_impl(Row const& row, Col const& col, ValueType const& value, Assigner assign)
     {
@@ -160,6 +181,10 @@ namespace AMDiS
     {}
 
     /// Implements \ref MatrixWrapperBase::resize
+    /**
+     * Call the \ref resize(1,cols) where `cols` is given by the colSize provider. Calls recursively
+     * the `resize()` method on all columns in the single row 0.
+     **/
     template <class RowSize, class ColSize>
     void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
                       ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
@@ -176,6 +201,9 @@ namespace AMDiS
     }
 
     /// Implements \ref MatrixWrapperBase::clear_row
+    /**
+     * Calls `clear_row` on all columns, where we assume, that the provided row index is zero.
+     **/
     template <class RowIter, class Col, class RowValues>
     void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
     {
@@ -188,6 +216,9 @@ namespace AMDiS
     }
 
     /// Implements \ref MatrixWrapperBase::clear_col
+    /**
+     * Calls `clear_col` on the provided `col` and simply forward the row index.
+     **/
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
     {
@@ -197,6 +228,9 @@ namespace AMDiS
     }
 
     /// Implements \ref MatrixWrapperBase::nnz
+    /**
+     * Returns the number of nonzeros of the original matrix-wrapper
+     **/
     std::size_t nnz_impl()
     {
       return wrapper_.nnz();
diff --git a/src/amdis/linearalgebra/VectorInserter.hpp b/src/amdis/linearalgebra/VectorInserter.hpp
new file mode 100644
index 00000000..b88b6b4f
--- /dev/null
+++ b/src/amdis/linearalgebra/VectorInserter.hpp
@@ -0,0 +1,81 @@
+#pragma once
+
+#include <cassert>
+#include <type_traits>
+
+#include <amdis/common/Access.hpp>
+#include <amdis/common/FieldMatVec.hpp>
+#include <amdis/common/Index.hpp>
+#include <amdis/linearalgebra/VectorInserterBase.hpp>
+
+namespace AMDiS
+{
+  template <class BaseVector>
+  class VectorInserter;
+
+  /// \brief Creator for the \ref VectorInserter. Forward the arguments to the constructor of the class.
+  /**
+   * A \ref VectorInserter is created from a `BaseVector` and a \ref VectorIndexSet.
+   * It is expected that the vector and the vectorIndexSet are already resized correctly.
+   * The option `rebuild` enforces that the vector is set to *zero* if `rebuild==true`.
+   **/
+  template <class BaseVector>
+  VectorInserter<BaseVector> vectorInserter(BaseVector& vector, bool rebuild = false)
+  {
+    return VectorInserter<BaseVector>{vector, rebuild};
+  }
+
+
+  // some forward declarations
+  template <class Scalar>
+  class VectorInserterScalarImpl;
+
+  template <class BaseVector, class Inserter>
+  class VectorInserterImpl;
+
+  template <class BaseVector> class VectorDynamicInserter;
+  template <class BaseVector> class VectorStaticInserter;
+
+  namespace Impl
+  {
+    // select the vector inserter by properties of the vector, if not explicitly specialized
+    // 1. If vector is a scalar-vector (size 1), use the scalar inserter
+    // 2. If vector allows dynamic indices, use the \ref VectorDynamicInserter
+    // 3. If the vector only allows static indices (i.e. integral_constant<std::size_t>), use
+    //    the \ref VectorStaticInserter
+    // 4. Otherwise treat the vector as scalar.
+    template <class M>
+    using VectorInserterSelector =
+      std::conditional_t<Dune::MatVec::IsScalarVector<M>::value,
+        VectorInserterScalarImpl<M>,
+      std::conditional_t<Concepts::VectorAccessible_t<M,std::size_t>::value,
+        VectorInserterImpl<M, VectorDynamicInserter<M>>,
+      std::conditional_t<Concepts::VectorAccessible_t<M,index_t<0>>::value,
+        VectorInserterImpl<M, VectorStaticInserter<M>>,
+        VectorInserterScalarImpl<M> >>>;
+
+  } // end namespace Impl
+
+
+  /// \brief Generic implementation of a vector inserter that provides the \ref insert() method.
+  /**
+   * Select a Vector inserter using the \ref VectorInserterSelector, especially the \ref VectorInserterImpl.
+   * This class implements a \ref VectorInserterBase.
+   * This template is used if not explicit template specialization for a given vector-type is found.
+   **/
+  template <class BaseVector>
+  class VectorInserter
+      : public Impl::VectorInserterSelector<BaseVector>
+  {
+    using Super = Impl::VectorInserterSelector<BaseVector>;
+
+  public:
+    template <class... Args>
+    VectorInserter(Args&&... args)
+      : Super(FWD(args)...)
+    {}
+  };
+
+} // end namespace AMDiS
+
+#include <amdis/linearalgebra/VectorInserter.inc.hpp>
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/VectorInserter.inc.hpp b/src/amdis/linearalgebra/VectorInserter.inc.hpp
new file mode 100644
index 00000000..7eeb421b
--- /dev/null
+++ b/src/amdis/linearalgebra/VectorInserter.inc.hpp
@@ -0,0 +1,137 @@
+#pragma once
+
+#include <cassert>
+#include <vector>
+
+#include <dune/common/tuplevector.hh>
+
+#include <amdis/Output.hpp>
+#include <amdis/common/Access.hpp>
+#include <amdis/common/ForEach.hpp>
+#include <amdis/common/HybridSize.hpp>
+#include <amdis/common/SwitchCases.hpp>
+#include <amdis/linearalgebra/Common.hpp>
+
+namespace AMDiS
+{
+  /// Implementation of a \ref VectorInserter for scalar types
+  template <class Scalar>
+  class VectorInserterScalarImpl
+      : public VectorInserterBase<VectorInserterScalarImpl<Scalar>>
+  {
+    template <class> friend class VectorInserter;
+
+  public:
+    VectorInserterScalarImpl(Scalar& scalar, bool rebuild)
+      : scalar_(scalar)
+    {
+      if (rebuild)
+        scalar_ = 0;
+    }
+
+    /// Implements \ref VectorInserterBase::insert
+    template <class MultiIndex, class ValueType, class Assigner>
+    void insert_impl(MultiIndex const& index, ValueType const& value, Assigner assign)
+    {
+      assert(*index == 0u);
+      assign(value, scalar_);
+    }
+
+  protected:
+    template <class I>
+    auto& inserter(I const& i) { return scalar_; }
+
+  private:
+    Scalar& scalar_;
+  };
+
+
+  /// A Container representing the inserter for a vector with dynamic indexing.
+  template <class BaseVector>
+  class VectorDynamicInserter
+  {
+    using size_type = typename BaseVector::size_type;
+    using block_type = typename BlockType<BaseVector>::type;
+    using Inserter = std::vector<VectorInserter<block_type>>;
+
+  public:
+    VectorDynamicInserter(BaseVector& vector, bool rebuild)
+      : size_(vector.size())
+    {
+      inserter_.reserve(size_);
+      for (size_type i = 0; i < size_; ++i)
+        inserter_.emplace_back(vector[i], rebuild);
+    }
+
+    size_type size() const { return size_; }
+
+    auto& operator[](size_type i) { return inserter_[i]; }
+
+  protected:
+    Inserter inserter_;
+    size_type size_;
+  };
+
+
+  /// A Container representing the inserter for a vector with static indexing.
+  template <class BaseVector>
+  class VectorStaticInserter
+  {
+  public:
+    static constexpr std::size_t dimension = BaseVector::size();
+
+  private:
+
+    template <class Vector>
+    static auto create(Vector& vec, bool rebuild)
+    {
+      return Tools::apply_indices<dimension>([&](auto const... i) {
+        return Dune::makeTupleVector(vectorInserter(vec[i],rebuild)...);
+      });
+    }
+
+    using Inserter = TYPEOF(create(std::declval<BaseVector&>(),true));
+
+  public:
+    VectorStaticInserter(BaseVector& vector, bool rebuild)
+      : inserter_(create(vector, rebuild))
+    {}
+
+    template <std::size_t i>
+    auto& operator[](index_t<i>) { return inserter_[index_t<i>{}]; }
+
+  protected:
+    Inserter inserter_;
+  };
+
+
+  /// The general implementation of a \ref VectorInserter.
+  template <class BaseVector, class Inserter>
+  class VectorInserterImpl
+      : public VectorInserterBase<VectorInserterImpl<BaseVector,Inserter>>
+  {
+    template <class> friend class VectorInserter;
+
+  public:
+    VectorInserterImpl(BaseVector& vector, bool rebuild)
+      : inserter_(vector, rebuild)
+    {}
+
+    /// Implements \ref VectorInserterBase::insert
+    template <class MultiIndex, class ValueType, class Assigner>
+    void insert_impl(MultiIndex const& index, ValueType const& value, Assigner assign)
+    {
+      switchCases(hybridElements(inserter_), *index, [&](auto i) -> void {
+        this->inserter(i).insert(index.next(), value, assign);
+      });
+    }
+
+  protected:
+    template <class I>
+    auto& inserter(I const& i) { return inserter_[i]; }
+
+  protected:
+    Inserter inserter_;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/VectorInserterBase.hpp b/src/amdis/linearalgebra/VectorInserterBase.hpp
new file mode 100644
index 00000000..bb407c2a
--- /dev/null
+++ b/src/amdis/linearalgebra/VectorInserterBase.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <type_traits>
+
+#include <amdis/functions/MultiIndex.hpp>
+#include <amdis/operations/Assigner.hpp>
+
+namespace AMDiS
+{
+  /// \brief CRTP-base class for \ref VectorInserter.
+  template <class Impl>
+  class VectorInserterBase
+  {
+  public:
+    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
+    template <class MultiIndex, class ValueType, class Assign = Assigner::plus_assign>
+    void insert(MultiIndex const& index, ValueType const& value, Assign assign = {})
+    {
+      asImpl().insert_impl(multiIndexIterator(index), value, assign);
+    }
+
+  protected: // default implementation:
+
+    template <class... Args>
+    void insert_impl(Args&&...) { /* do nothing */ }
+
+  private:
+    Impl& asImpl() { return static_cast<Impl&>(*this); }
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/VectorWrapper.hpp b/src/amdis/linearalgebra/VectorWrapper.hpp
index 2341eb9d..70c40dae 100644
--- a/src/amdis/linearalgebra/VectorWrapper.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.hpp
@@ -14,6 +14,7 @@ namespace AMDiS
   template <class BaseVector>
   class VectorWrapper;
 
+  /// \brief Creator for the \ref VectorWrapper from a given `BaseVector`.
   template <class BaseVector>
   VectorWrapper<BaseVector> vectorWrapper(BaseVector& vector)
   {
@@ -21,6 +22,7 @@ namespace AMDiS
   }
 
 
+  // some forward declarations
   template <class Scalar>
   class VectorWrapperScalarImpl;
 
@@ -29,6 +31,10 @@ namespace AMDiS
 
   namespace Impl
   {
+    // select the vector wrapper by properties of the vector, if not explicitly specialized
+    // 1. If vector is a scalar-vector (size=1), use the scalar wrapper
+    // 2. If vector allows indexing, use the \ref VectorWrapperImpl
+    // 3. Otherwise treat the vector as scalar.
     template <class V>
     using VectorWrapperSelector =
       std::conditional_t<Dune::MatVec::IsScalarVector<V>::value,
@@ -40,6 +46,13 @@ namespace AMDiS
   } // end namespace Impl
 
 
+  /// \brief Generic implementation of a vector wrapper that provides the \ref resize(), \ref init(),
+  /// \ref finish(), \ref insert() and \ref set() methods.
+  /**
+   * Select a Vector wrapper using the \ref VectorWrapperSelector, especially the \ref VectorWrapperImpl.
+   * This class implements a \ref VectorWrapperBase.
+   * This template is used if not explicit template specialization for a given vector-type is found.
+   **/
   template <class BaseVector>
   class VectorWrapper
       : public Impl::VectorWrapperSelector<BaseVector>
@@ -52,14 +65,6 @@ namespace AMDiS
     {}
   };
 
-  template <class BaseVector>
-  class VectorWrapper<const BaseVector>
-      : public VectorWrapper<BaseVector>
-  {
-  public:
-    using VectorWrapper<BaseVector>::VectorWrapper;
-  };
-
 } // end namespace AMDiS
 
 #include <amdis/linearalgebra/VectorWrapper.inc.hpp>
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index 9fc86bf3..ca4c7b42 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -6,11 +6,11 @@
 
 #include <amdis/common/ForEach.hpp>
 #include <amdis/common/HybridSize.hpp>
-#include <amdis/common/SwitchCases.hpp>
 #include <amdis/linearalgebra/Common.hpp>
 
 namespace AMDiS
 {
+  /// Implementation of a \ref VectorWrapper for scalar types
   template <class Scalar>
   class VectorWrapperScalarImpl
       : public VectorWrapperBase<VectorWrapperScalarImpl<Scalar>>
@@ -20,13 +20,6 @@ namespace AMDiS
       : scalar_(scalar)
     {}
 
-    /// Implements \ref VectorWrapperBase::insert
-    template <class Index, class ValueType, class Assigner>
-    void insert_impl(Index const& /*index*/, ValueType const& value, Assigner assign)
-    {
-      assign(value, scalar_);
-    }
-
     /// Implements \ref VectorWrapperBase::set
     template <class ValueType>
     void set_impl(ValueType const& value)
@@ -39,6 +32,7 @@ namespace AMDiS
   };
 
 
+  /// The general implementation of a \ref VectorWrapper.
   template <class BaseVector>
   class VectorWrapperImpl
       : public VectorWrapperBase<VectorWrapperImpl<BaseVector>>
@@ -63,31 +57,6 @@ namespace AMDiS
       });
     }
 
-    /// Implements \ref VectorWrapperBase::init
-    void init_impl(bool rebuild)
-    {
-      Dune::Hybrid::forEach(vector_, [&](auto& v) -> void {
-        vectorWrapper(v).init(rebuild);
-      });
-    }
-
-    /// Implements \ref VectorWrapperBase::finish
-    void finish_impl()
-    {
-      Dune::Hybrid::forEach(vector_, [&](auto& v) -> void {
-        vectorWrapper(v).finish();
-      });
-    }
-
-    /// Implements \ref VectorWrapperBase::insert
-    template <class Index, class ValueType, class Assigner>
-    void insert_impl(Index const& index, ValueType const& value, Assigner assign)
-    {
-      switchCases(hybridElements(vector_), *index, [&](auto i) -> void {
-        vectorWrapper(vector_[i]).insert(index.next(), value, assign);
-      });
-    }
-
     /// Implements \ref VectorWrapperBase::set
     template <class ValueType>
     void set_impl(ValueType const& value)
diff --git a/src/amdis/linearalgebra/VectorWrapperBase.hpp b/src/amdis/linearalgebra/VectorWrapperBase.hpp
index 7fa86fa3..4024ad07 100644
--- a/src/amdis/linearalgebra/VectorWrapperBase.hpp
+++ b/src/amdis/linearalgebra/VectorWrapperBase.hpp
@@ -7,11 +7,12 @@
 
 namespace AMDiS
 {
+  /// \brief CRTP-base class for \ref VectorWrapper.
   template <class Impl>
   class VectorWrapperBase
   {
   public:
-    /// Resize \ref vector_ to desired size
+    /// Resize vector to desired size using the `SizeProvider`. See \ref Dune::SizeInfo.
     template <class SizeProvider>
     void resize(SizeProvider const& sizeProvider)
     {
@@ -19,39 +20,17 @@ namespace AMDiS
       asImpl().resize_impl(sizeProvider,prefix);
     }
 
-    /// Resize \ref vector_ to desired size
+    /// Resize the vector to desired size
+    /**
+     * Resize the underlying vector to `sizeProvider(prefix)`, append another index
+     * to the prefix containers and forward to the next block-level.
+     **/
     template <class SizeProvider>
     void resize(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
     {
       asImpl().resize_impl(sizeProvider,prefix);
     }
 
-    /// Prepare the vector for insertion of values
-    void init(bool rebuild)
-    {
-      asImpl().init_impl(rebuild);
-    }
-
-    /// Finish the insertion
-    void finish()
-    {
-      asImpl().finish_impl();
-    }
-
-    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
-    template <class MultiIndex, class ValueType>
-    void insert(MultiIndex const& multiIndex, ValueType const& value)
-    {
-      asImpl().insert_impl(multiIndexIterator(multiIndex), value, Assigner::plus_assign{});
-    }
-
-    /// Insert a new value into the vector at multiIndex (row,col) using operator+=
-    template <class MultiIndex, std::size_t shift, class ValueType, class Assigner>
-    void insert(MultiIndexIterator<MultiIndex,shift> const& it, ValueType const& value, Assigner assign)
-    {
-      asImpl().insert_impl(it, value, assign);
-    }
-
     /// Set all entries to value
     template <class ValueType>
     void set(ValueType const& value)
@@ -64,14 +43,6 @@ namespace AMDiS
     template <class... Args>
     void resize_impl(Args&&...) { /* do nothing */ }
 
-    template <class... Args>
-    void init_impl(Args&&...) { /* do nothing */ }
-
-    void finish_impl() { /* do nothing */ }
-
-    template <class... Args>
-    void insert_impl(Args&&...) { /* do nothing */ }
-
     template <class... Args>
     void set_impl(Args&&...) { /* do nothing */ }
 
diff --git a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
index c61338ab..68078f5c 100644
--- a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
@@ -70,7 +70,7 @@ namespace AMDiS
     /// The data-matrix (can hold a new BaseMatrix or a pointer to external data
     BaseMatrix& matrix_;
 
-    /// A pointer to the inserter. Created in \ref init and destroyed in \ref finish
+    /// A pointer to the inserter. Created in the constructor. Must be destroyed to be actually applied.
     std::unique_ptr<Inserter> inserter_ = nullptr;
   };
 
diff --git a/src/amdis/linearalgebra/mtl/MtlVector.hpp b/src/amdis/linearalgebra/mtl/MtlVector.hpp
index d446abd0..b1d9023d 100644
--- a/src/amdis/linearalgebra/mtl/MtlVector.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlVector.hpp
@@ -5,10 +5,58 @@
 #include <dune/common/ftraits.hh>
 
 #include <amdis/Output.hpp>
+#include <amdis/linearalgebra/VectorInserter.hpp>
 #include <amdis/linearalgebra/VectorWrapper.hpp>
 
 namespace AMDiS
 {
+  /// The basic container that stores a base vector data
+  template <class ValueType, class Parameters>
+  class VectorInserter<mtl::vec::dense_vector<ValueType, Parameters>>
+      : public VectorInserterBase<VectorInserter<mtl::vec::dense_vector<ValueType, Parameters>>>
+  {
+  public:
+    /// The type of the elements of the DOFVector
+    using value_type = ValueType;
+    using field_type = typename Dune::FieldTraits<ValueType>::field_type;
+
+    /// The type of the base vector
+    using BaseVector = mtl::vec::dense_vector<ValueType, Parameters>;
+    using Inserter = mtl::vec::inserter<BaseVector, mtl::operations::update_plus<value_type>>;
+
+    /// The index/size - type
+    using size_type  = typename BaseVector::size_type;
+
+  public:
+    /// Constructor. Constructs new BaseVector.
+    VectorInserter(BaseVector& vector, bool rebuild)
+      : vector_(vector)
+    {
+      if (rebuild)
+        set_to_zero(vector_);
+
+      inserter_ = std::make_unique<Inserter>(vector_);
+    }
+
+    /// Access the entry \p i of the \ref vector with write-access.
+    template <class MultiIndex, class Assigner>
+    void insert_impl(MultiIndex const& idx, value_type const& value, Assigner assign)
+    {
+      size_type i = *idx;
+      test_exit_dbg(i < size(vector_),
+        "Index {} out of range [0,{})", i, size(vector_));
+      assign(value, vector_[i]);
+    }
+
+  private:
+    /// The data-vector
+    BaseVector& vector_;
+
+    /// A pointer to the inserter. Created in the constructor. Must be destroyed to be actually applied.
+    std::unique_ptr<Inserter> inserter_ = nullptr;
+  };
+
+
   /// The basic container that stores a base vector data
   template <class ValueType, class Parameters>
   class VectorWrapper<mtl::vec::dense_vector<ValueType, Parameters>>
@@ -40,27 +88,6 @@ namespace AMDiS
       vector_.change_dim(size);
     }
 
-    void init_impl(bool rebuild)
-    {
-      // do nothing
-      // maybe later att a vector::inserter for distributed vectors
-    }
-
-    void finish_impl()
-    {
-      // do nothing
-    }
-
-    /// Access the entry \p i of the \ref vector with write-access.
-    template <class Index, class Assigner>
-    void insert_impl(Index const& idx, value_type const& value, Assigner assign)
-    {
-      size_type i = *idx;
-      test_exit_dbg(i < size(vector_),
-        "Index {} out of range [0,{})", i, size(vector_));
-      assign(value, vector_[i]);
-    }
-
     void set_impl(field_type value)
     {
       vector_ = value;
-- 
GitLab


From 28629f103d314412abea591289b3ccf12016ce15 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Tue, 23 Apr 2019 17:47:39 +0200
Subject: [PATCH 25/38] corrected some ci errors

---
 .../linearalgebra/MatrixInserter.inc.hpp      |  2 +-
 test/VectorTest.cpp                           | 43 ++++++++-----------
 2 files changed, 19 insertions(+), 26 deletions(-)

diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
index 213cfcc8..ebede09e 100644
--- a/src/amdis/linearalgebra/MatrixInserter.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -73,7 +73,7 @@ namespace AMDiS
     {
       for (size_type i = 0; i < rows_; ++i)
         for (size_type j = 0; j < cols_; ++j)
-          inserter_.emplace_back(matrix[i][j], matIndexSet[i][j], rebuild);
+          inserter_.emplace_back(access(matrix,i,j), access(matIndexSet,i,j), rebuild);
     }
 
     size_type N() const { return rows_; }
diff --git a/test/VectorTest.cpp b/test/VectorTest.cpp
index 61947d95..478339c3 100644
--- a/test/VectorTest.cpp
+++ b/test/VectorTest.cpp
@@ -4,6 +4,7 @@
 #include <amdis/functions/MultiIndex.hpp>
 #include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
 #include <amdis/linearalgebra/MatrixVectorTraits.hpp>
+#include <amdis/linearalgebra/VectorInserter.hpp>
 #include <amdis/linearalgebra/VectorWrapper.hpp>
 #include <amdis/operations/Assigner.hpp>
 
@@ -24,13 +25,6 @@ void printType(T const&)
   std::cout << __PRETTY_FUNCTION__ << "\n";
 }
 
-template <class V, class SizeInfo>
-void resize(V&& vec, SizeInfo const& sizeInfo)
-{
-  typename SizeInfo::SizePrefix prefix; prefix.resize(0);
-  vec.resize(sizeInfo,prefix);
-}
-
 template <class BasisTester>
 void test1(BasisTester& tester)
 {
@@ -41,29 +35,27 @@ void test1(BasisTester& tester)
   using Vector = VectorGenerator_t<double,DefaultMatrixVectorTraits,Blocking>;
 
   Vector vector;
-  VectorWrapper<Vector> wrapper(vector);
   printType(vector);
 
-  resize(wrapper,taylorHoodBasis);
-  wrapper.init(true);
+  vectorWrapper(vector).resize(taylorHoodBasis);
 
   auto idx00 = std::array<std::size_t,2>{0,0};
   auto idx01 = std::array<std::size_t,2>{0,1};
   auto idx10 = std::array<std::size_t,2>{1,0};
   auto idx11 = std::array<std::size_t,2>{1,1};
 
-  wrapper.insert(idx00, 1.0);
-  wrapper.insert(idx01, 2.0);
-  wrapper.insert(idx10, 3.0);
-  wrapper.insert(idx11, 4.0);
+  { VectorInserter<Vector> inserter(vector, true);
+    inserter.insert(idx00, 1.0);
+    inserter.insert(idx01, 2.0);
+    inserter.insert(idx10, 3.0);
+    inserter.insert(idx11, 4.0);
+  }
 
   AMDIS_TEST_EQ(vector[0][0], 1.0);
   AMDIS_TEST_EQ(vector[0][1], 2.0);
   AMDIS_TEST_EQ(vector[1][0], 3.0);
   AMDIS_TEST_EQ(vector[1][1], 4.0);
 
-  wrapper.finish();
-
   std::cout << "\n";
   std::cout << vector[0] << "\n";
   std::cout << vector[1] << "\n";
@@ -79,11 +71,9 @@ void test2(BasisTester& tester)
   using Vector = VectorGenerator_t<double,DefaultMatrixVectorTraits,Blocking>;
 
   Vector vector;
-  VectorWrapper<Vector> wrapper(vector);
   printType(vector);
 
-  resize(wrapper,taylorHoodBasis);
-  wrapper.init(true);
+  vectorWrapper(vector).resize(taylorHoodBasis);
 
   auto idx000 = std::array<std::size_t,3>{0,0,0};
   auto idx001 = std::array<std::size_t,3>{0,0,1};
@@ -92,12 +82,15 @@ void test2(BasisTester& tester)
   auto idx10 = std::array<std::size_t,2>{1,0};
   auto idx11 = std::array<std::size_t,2>{1,1};
 
-  wrapper.insert(idx000, 1.0);
-  wrapper.insert(idx001, 2.0);
-  wrapper.insert(idx010, 3.0);
-  wrapper.insert(idx011, 4.0);
-  wrapper.insert(idx10, 5.0);
-  wrapper.insert(idx11, 6.0);
+  { VectorInserter<Vector> inserter(vector, true);
+
+    inserter.insert(idx000, 1.0);
+    inserter.insert(idx001, 2.0);
+    inserter.insert(idx010, 3.0);
+    inserter.insert(idx011, 4.0);
+    inserter.insert(idx10, 5.0);
+    inserter.insert(idx11, 6.0);
+  }
 
   AMDIS_TEST_EQ(vector[_0][0][0], 1.0);
   AMDIS_TEST_EQ(vector[_0][0][1], 2.0);
-- 
GitLab


From ca93f003967c2ad7e86d6dcfaa3bd0b9386d5481 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Thu, 25 Apr 2019 17:29:55 +0200
Subject: [PATCH 26/38] added block preconditioner examples

---
 examples/CMakeLists.txt                       |  10 +-
 examples/PfcPrecon.hpp                        | 188 ++++++++++++++++++
 examples/PfcSolver.hpp                        |  67 +++++++
 examples/init/pfc.dat.2d                      |  27 +++
 examples/init/stokes.dat.2d                   |   6 +-
 examples/pfc1.cc                              | 107 ++++++++++
 examples/pfc2.cc                              |  81 ++++++++
 examples/pfc3.cc                              |  83 ++++++++
 examples/stokes4.cc                           | 168 ++++++++++++++++
 src/amdis/linearalgebra/DOFMatrixBase.hpp     |   4 +-
 src/amdis/linearalgebra/DOFMatrixBase.inc.hpp |  22 +-
 src/amdis/linearalgebra/istl/ISTL_Solver.hpp  |  43 +++-
 12 files changed, 786 insertions(+), 20 deletions(-)
 create mode 100644 examples/PfcPrecon.hpp
 create mode 100644 examples/PfcSolver.hpp
 create mode 100644 examples/init/pfc.dat.2d
 create mode 100644 examples/pfc1.cc
 create mode 100644 examples/pfc2.cc
 create mode 100644 examples/pfc3.cc
 create mode 100644 examples/stokes4.cc

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 15799aaa..0ea739be 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -31,4 +31,12 @@ add_dependencies(examples
 if (dune-foamgrid_FOUND)
   add_amdis_executable(NAME surface.2d SOURCES surface.cc DIM 2 DOW 3 ALBERTA_GRID)
   add_dependencies(examples surface.2d)
-endif ()
\ No newline at end of file
+endif ()
+
+if (NOT HAVE_MTL AND NOT HAVE_EIGEN)
+  add_amdis_executable(NAME stokes4.2d SOURCES stokes4.cc DIM 2 DOW 2)
+  add_amdis_executable(NAME pfc1.2d SOURCES pfc1.cc DIM 2 DOW 2)
+  add_amdis_executable(NAME pfc2.2d SOURCES pfc2.cc DIM 2 DOW 2)
+  add_amdis_executable(NAME pfc3.2d SOURCES pfc3.cc DIM 2 DOW 2)
+  add_dependencies(examples stokes4.2d pfc1.2d pfc2.2d pfc3.2d)
+endif()
diff --git a/examples/PfcPrecon.hpp b/examples/PfcPrecon.hpp
new file mode 100644
index 00000000..85d0fddc
--- /dev/null
+++ b/examples/PfcPrecon.hpp
@@ -0,0 +1,188 @@
+#include <memory>
+
+#include <dune/istl/preconditioners.hh>
+#include <dune/istl/solvers.hh>
+
+#include <amdis/Initfile.hpp>
+#include <amdis/common/TypeTraits.hpp>
+#include <amdis/functions/Blocking.hpp>
+#include <amdis/linearalgebra/MatrixVectorGenerator.hpp>
+#include <amdis/linearalgebra/istl/MatrixVectorTraits.hpp>
+
+namespace AMDiS {
+
+template <class M, class X, class Y = X>
+class PfcPrecon
+    : public Dune::Preconditioner<X,Y>
+{
+  using Matrix = M;
+
+  // cg solver with preconditioner
+  template <class SubMatrix, class SubVector, template <class,class,class,int> class P>
+  struct SubSolver
+  {
+    using Solver = Dune::CGSolver<SubVector>;
+    using Operator = Dune::MatrixAdapter<SubMatrix,SubVector,SubVector>;
+    using Preconditioner = P<SubMatrix,SubVector,SubVector,1>;
+
+    SubSolver(std::string const& prefix)
+    {
+      Parameters::get(prefix + "->max iteration", maxIt_);
+      Parameters::get(prefix + "->reduction", reduction_);
+    }
+
+    void update(SubMatrix const& mat)
+    {
+      op_ = std::make_unique<Operator>(mat);
+      precon_ = std::make_unique<Preconditioner>(mat, 1, 1.0);
+      solver_ = std::make_unique<Solver>(*op_, *precon_, reduction_, maxIt_, 0);
+    }
+
+    void apply(SubVector& x, SubVector& b)
+    {
+      Dune::InverseOperatorResult stat;
+      solver_->apply(x, b, stat);
+    }
+
+  private:
+    int maxIt_ = 10;
+    double reduction_ = 1.e-3;
+    std::unique_ptr<Operator> op_;
+    std::unique_ptr<Preconditioner> precon_;
+    std::unique_ptr<Solver> solver_;
+  };
+
+public:
+  PfcPrecon(M const& matrix, double const& tau)
+    : matrix_(matrix)
+    , solverM_("pfc->solverM")
+    , solverMpK1_("pfc->solverMpK1")
+    , solverMpK2_("pfc->solverMpK2")
+    , tau_(tau)
+  {}
+
+  void update()
+  {
+    delta_ = std::sqrt(tau_);
+
+    auto const& matrixM = matrix_[0][0];
+    auto const& matrixK = matrix_[0][2];
+
+    solverM_.update(matrixM);
+
+    matrixMpK1_ = matrixM;
+    matrixMpK1_.axpy(delta_, matrixK);
+    solverMpK1_.update(matrixMpK1_);
+
+    matrixMpK2_ = matrixM;
+    matrixMpK2_.axpy(std::sqrt(delta_), matrixK);
+    solverMpK2_.update(matrixMpK2_);
+  }
+
+  void pre(X& /*x*/, Y& /*b*/) override { /* do nothing */ }
+  void post(X& /*x*/) override { /* do nothing */ }
+
+  void apply(X& x, Y const& d) override
+  {
+    X y(x);
+    Y b(d);
+
+    auto const& matrixM = matrix_[0][0];
+    auto const& matrixK = matrix_[0][2];
+
+    // 1.
+    solverM_.apply(y[0], b[0]);
+    // 2.
+    matrixK.usmv(-tau_, y[0], b[1]);
+    solverMpK1_.apply(y[1], b[1]);
+    // 3.a
+    matrixM.mv(y[1], b[0]);
+    solverMpK2_.apply(x[0], b[0]);
+    // 3.b
+    matrixM.mv(x[0], b[1]);
+    solverMpK2_.apply(x[1], b[1]);
+    // 4.
+    x[0] = y[0];
+    x[0].axpy(1.0/delta_, y[1]);
+    x[0].axpy(-1.0/delta_, x[1]);
+    // 5.
+    matrixK.usmv(-1.0, x[1], b[2]);
+    solverM_.apply(x[2], b[2]);
+  }
+
+  Dune::SolverCategory::Category category() const override
+  {
+    return Dune::SolverCategory::sequential;
+  }
+
+private:
+  Matrix const& matrix_;
+
+  using SubMat = TYPEOF(std::declval<M>()[0][0]);
+  using SubVec = TYPEOF(std::declval<X>()[0]);
+
+  SubMat matrixMpK1_;
+  SubMat matrixMpK2_;
+
+  SubSolver<SubMat, SubVec, Dune::SeqJac> solverM_;
+  SubSolver<SubMat, SubVec, Dune::SeqILU> solverMpK1_;
+  SubSolver<SubMat, SubVec, Dune::SeqILU> solverMpK2_;
+
+  double delta_ = 1.0;
+  double tau_ = 1.0;
+};
+
+
+
+template <class M, class X, class Y>
+struct ISTLPrecon<PfcPrecon<M,X,Y>, M>
+    : public ISTLPreconInterface<M,X,Y>
+{
+  using Super = ISTLPreconInterface<M,X,Y>;
+  using Precon = PfcPrecon<M,X,Y>;
+  using Self = ISTLPrecon;
+
+  struct Creator
+      : public CreatorInterfaceName<ISTLPreconInterface<M,X,Y>>
+  {
+    Creator(double const& tau)
+      : tau_(&tau)
+    {}
+
+    std::unique_ptr<ISTLPreconInterface<M,X,Y>> createWithString(std::string /*prefix*/) override
+    {
+      return std::make_unique<Self>(*tau_);
+    }
+
+    double const* tau_;
+  };
+
+  ISTLPrecon(double const& tau)
+    : tau_(&tau)
+  {}
+
+  using PreconBase = Dune::Preconditioner<X, Y>;
+  std::unique_ptr<PreconBase> create(M const& mat) const override
+  {
+    auto precon = std::make_unique<Precon>(mat, *tau_);
+    precon->update();
+    return std::move(precon);
+  }
+
+  double const* tau_;
+};
+
+
+template <class Basis>
+inline void registerPfcPrecon(Basis const& basis, double const& tau)
+{
+  using B = Blocking_t<Basis>;
+  using M = MatrixGenerator_t<double,ISTLTraits,B,B>;
+  using X = VectorGenerator_t<double,ISTLTraits,B>;
+
+  auto pfcPrecon = new typename ISTLPrecon<PfcPrecon<M,X,X>, M>::Creator(tau);
+  CreatorMap<ISTLPreconInterface<M,X,X>>::addCreator("pfc", pfcPrecon);
+}
+
+
+} // end namespace AMDiS
diff --git a/examples/PfcSolver.hpp b/examples/PfcSolver.hpp
new file mode 100644
index 00000000..eb6f819a
--- /dev/null
+++ b/examples/PfcSolver.hpp
@@ -0,0 +1,67 @@
+#include <amdis/linearalgebra/LinearSolverInterface.hpp>
+
+#include "PfcPrecon.hpp"
+
+namespace AMDiS
+{
+
+  template <class Mat, class X, class Y>
+  class PfcSolver
+      : public LinearSolverInterface<Mat, X, Y>
+  {
+    using Self = PfcSolver;
+    using Super = LinearSolverInterface<Mat, X, Y>;
+
+    using LinOp = Dune::MatrixAdapter<Mat,X,Y>;
+    using Solver = Dune::RestartedFlexibleGMResSolver<X,Y>;
+    using Precon = PfcPrecon<Mat,X,Y>;
+
+  public:
+    /// Constructor
+    explicit PfcSolver(std::string prefix, double const& tau)
+      : tau_(&tau)
+    {
+      Parameters::get(prefix + "->max iteration", maxIter_);
+    }
+
+  private:
+    /// Implements \ref LinearSolverInterface::solveSystemImpl()
+    void solveImpl(Mat const& A, X& x, Y const& b, SolverInfo& solverInfo) override
+    {
+      Dune::Timer t;
+
+      if (solverInfo.doCreateMatrixData()) {
+        linOp_ = std::make_unique<LinOp>(A);
+        precon_ = std::make_unique<Precon>(A, *tau_);
+        solver_ = std::make_unique<Solver>(*linOp_, *precon_, solverInfo.relTolerance(), 30, maxIter_, solverInfo.info());
+      }
+
+      precon_->update();
+      if (solverInfo.info() > 0)
+        msg("creation of istl solver needed {} seconds", t.elapsed());
+
+      Dune::InverseOperatorResult statistics;
+
+      Y b_(b);
+      solver_->apply(x, b_, statistics);
+      solverInfo.setError(statistics.converged ? 0 : 1);
+      solverInfo.setRelResidual(statistics.reduction);
+
+      if (!solverInfo.doStoreMatrixData()) {
+        linOp_.reset();
+        precon_.reset();
+        solver_.reset();
+      }
+
+    }
+
+  private:
+    double const* tau_;
+    int maxIter_ = 1000;
+
+    std::unique_ptr<LinOp> linOp_;
+    std::unique_ptr<Precon> precon_;
+    std::unique_ptr<Solver> solver_;
+  };
+
+} // end namespace AMDiS
\ No newline at end of file
diff --git a/examples/init/pfc.dat.2d b/examples/init/pfc.dat.2d
new file mode 100644
index 00000000..11838b71
--- /dev/null
+++ b/examples/init/pfc.dat.2d
@@ -0,0 +1,27 @@
+pfcMesh->global refinements: 7
+pfcMesh->num cells: 4 4
+pfcMesh->dimension: 200 200
+
+pfc->mesh:  pfcMesh
+
+pfc->solver->name:           fgmres
+pfc->solver->max iteration:  10000
+pfc->solver->relative tolerance: 1.e-10
+pfc->solver->info:           2
+pfc->solver->precon->name:   pfc
+
+pfc->solver1->max iteration: 10
+pfc->solver1->reduction: 1.e-5
+
+pfc->solver2->max iteration: 10
+pfc->solver2->reduction: 1.e-5
+
+pfc->output[1]->filename: pfc.2d
+pfc->output[1]->output directory: output
+pfc->output[1]->ParaView format: 1
+pfc->output[1]->ParaView animation: 1
+pfc->output[1]->ParaView mode: 1
+
+adapt->timestep:    0.001
+adapt->start time:  0.0
+adapt->end time:    10.0
diff --git a/examples/init/stokes.dat.2d b/examples/init/stokes.dat.2d
index 54542825..68a8b329 100644
--- a/examples/init/stokes.dat.2d
+++ b/examples/init/stokes.dat.2d
@@ -1,10 +1,10 @@
-stokesMesh->global refinements: 0
+stokesMesh->global refinements: 7
 stokesMesh->dimension: 1.0 1.0
 stokesMesh->num cells: 4 4
 
 stokes->mesh: stokesMesh
 
-stokes->solver->name: bicgstag
+stokes->solver->name: bicgstab
 stokes->solver->ell: 3
 stokes->solver->max iteration: 1000
 stokes->solver->relative tolerance: 1e-8
@@ -12,6 +12,8 @@ stokes->solver->restart: 50
 stokes->solver->precon->name: ilu
 stokes->solver->info:	2
 
+stokes->innersolver->max iteration: 2
+
 stokes->output[0]->filename: stokes_u.2d
 stokes->output[0]->name: u
 stokes->output[0]->subsampling: 2
diff --git a/examples/pfc1.cc b/examples/pfc1.cc
new file mode 100644
index 00000000..5afb90ce
--- /dev/null
+++ b/examples/pfc1.cc
@@ -0,0 +1,107 @@
+#include <amdis/AMDiS.hpp>
+#include <amdis/GridFunctions.hpp>
+#include <amdis/LocalOperators.hpp>
+#include <amdis/ProblemStat.hpp>
+
+#include "PfcPrecon.hpp"
+
+using namespace AMDiS;
+
+int main(int argc, char** argv)
+{
+  AMDiS::init(argc, argv);
+
+  auto grid = MeshCreator<Dune::YaspGrid<2>>::create("pfcMesh");
+
+  using namespace Dune::Functions::BasisFactory;
+  auto basis = makeBasis(grid->leafGridView(), power<3>(lagrange<1>(), blockedLexicographic()) );
+
+  auto prob = makeProblemStat("pfc", *grid, basis);
+  prob.initialize(INIT_ALL);
+
+  AdaptInfo adaptInfo("adapt");
+
+  double r = -0.4;
+  Parameters::get("pfc->r", r);
+
+  double psi_mean = -0.3;
+  Parameters::get("pfc->psi_mean", psi_mean);
+
+  auto psi = prob.solution(1);
+  auto M = 1.0; //max(1.e-5, psi + 1.5);
+  auto tau = std::ref(adaptInfo.timestep());
+
+  // mu
+  prob.addMatrixOperator(zot(1.0), 0, 0);
+  // -(1+r)*psi
+  prob.addMatrixOperator(zot(-(1.0+r)), 0, 1);
+  // -3*psi'^2*psi
+  prob.addMatrixOperator(zot(-3.0*pow<2>(psi)), 0, 1);
+  // -2*laplace(psi)
+  prob.addMatrixOperator(sot(2.0), 0, 1);
+  // -laplace(nu)
+  prob.addMatrixOperator(sot(1.0), 0, 2);
+  // -2*psi'^3
+  prob.addVectorOperator(zot(-2.0*pow<3>(psi)), 0);
+
+  // psi
+  prob.addMatrixOperator(zot(1.0), 1, 1);
+  // -tau*div(M(psi')grad(mu))
+  prob.addMatrixOperator(sot(tau*M,1), 1, 0);
+  // psi'
+  prob.addVectorOperator(zot(psi), 1);
+
+  // -laplace(psi)
+  prob.addMatrixOperator(sot(1.0), 2, 1);
+  // nu
+  prob.addMatrixOperator(zot(1.0), 2, 2);
+
+  // create the linear solver
+  // @{
+
+  using MatrixType = TYPEOF(prob.systemMatrix()->matrix());
+  using VectorType = TYPEOF(prob.solutionVector()->vector());
+
+  // Turn the matrix into a linear operator
+  Dune::MatrixAdapter<MatrixType,VectorType,VectorType> linOp(prob.systemMatrix()->matrix());
+
+  // Define a pfc block preconditioner
+  PfcPrecon<MatrixType,VectorType> precon(prob.systemMatrix()->matrix(), adaptInfo.timestep());
+
+  int solverInfo = 1;
+  Parameters::get("pfc->solver->info", solverInfo);
+
+  // Construct the actual iterative solver
+  Dune::RestartedFlexibleGMResSolver<VectorType> solver(linOp, precon, 1e-7, 30, 10000, solverInfo);
+
+  // @}
+
+
+  std::srand(12345);
+  psi << [psi_mean](auto const& x) {
+    return psi_mean + 0.2*(double(std::rand())/RAND_MAX - 0.5);
+  };
+
+  prob.writeFiles(adaptInfo);
+  while (!adaptInfo.reachedEndTime())
+  {
+    // update time
+    adaptInfo.setTime(adaptInfo.time() + adaptInfo.timestep());
+
+    // assemble the linear system
+    prob.assemble(adaptInfo);
+
+    // Object storing some statistics about the solving process
+    Dune::InverseOperatorResult statistics;
+
+    // Solve the linear system
+    precon.update();
+    solver.apply(prob.solutionVector()->vector(), prob.rhsVector()->vector(), statistics);
+
+    // output solution
+    prob.writeFiles(adaptInfo);
+  }
+
+  AMDiS::finalize();
+  return 0;
+}
diff --git a/examples/pfc2.cc b/examples/pfc2.cc
new file mode 100644
index 00000000..06269932
--- /dev/null
+++ b/examples/pfc2.cc
@@ -0,0 +1,81 @@
+#include <amdis/AMDiS.hpp>
+#include <amdis/AdaptInstationary.hpp>
+#include <amdis/GridFunctions.hpp>
+#include <amdis/LocalOperators.hpp>
+#include <amdis/ProblemInstat.hpp>
+#include <amdis/ProblemStat.hpp>
+
+#include "PfcPrecon.hpp"
+
+using namespace AMDiS;
+
+int main(int argc, char** argv)
+{
+  AMDiS::init(argc, argv);
+
+  auto grid = MeshCreator<Dune::YaspGrid<2>>::create("pfcMesh");
+
+  using namespace Dune::Functions::BasisFactory;
+  auto basis = makeBasis(grid->leafGridView(), power<3>(lagrange<1>(), blockedLexicographic()) );
+
+  AdaptInfo adaptInfo("adapt");
+
+  // Register the linear solver so that it can be selected in the initfile.
+  // This must be done before prob.initialize() is called.
+  registerPfcPrecon(basis,adaptInfo.timestep());
+
+  auto prob = makeProblemStat("pfc", *grid, basis);
+  prob.initialize(INIT_ALL);
+
+  auto probInstat = makeProblemInstat("pfc", prob);
+  probInstat.initialize(INIT_UH_OLD);
+
+  double r = -0.4;
+  Parameters::get("pfc->r", r);
+
+  double psi_mean = -0.3;
+  Parameters::get("pfc->psi_mean", psi_mean);
+
+  auto psi = prob.solution(1);
+  auto psiOld = probInstat.oldSolution(1);
+
+  auto M = 1.0; //max(1.e-5, psi + 1.5);
+  auto tau = std::ref(adaptInfo.timestep());
+
+  // mu
+  prob.addMatrixOperator(zot(1.0), 0, 0);
+  // -(1+r)*psi
+  prob.addMatrixOperator(zot(-(1.0+r)), 0, 1);
+  // -3*psi'^2*psi
+  prob.addMatrixOperator(zot(-3.0*pow<2>(psi)), 0, 1);
+  // -2*laplace(psi)
+  prob.addMatrixOperator(sot(2.0), 0, 1);
+  // -laplace(nu)
+  prob.addMatrixOperator(sot(1.0), 0, 2);
+  // -2*psi'^3
+  prob.addVectorOperator(zot(-2.0*pow<3>(psi)), 0);
+
+  // psi
+  prob.addMatrixOperator(zot(1.0), 1, 1);
+  // -tau*div(M(psi')grad(mu))
+  prob.addMatrixOperator(sot(tau*M,1), 1, 0);
+  // psi'
+  prob.addVectorOperator(zot(psi), 1);
+
+  // -laplace(psi)
+  prob.addMatrixOperator(sot(1.0), 2, 1);
+  // nu
+  prob.addMatrixOperator(zot(1.0), 2, 2);
+
+  // set initial condition
+  std::srand(12345);
+  psi << [psi_mean](auto const& x) {
+    return psi_mean + 0.2*(double(std::rand())/RAND_MAX - 0.5);
+  };
+
+  AdaptInstationary adaptInstat("adapt", prob, adaptInfo, probInstat, adaptInfo);
+  adaptInstat.adapt();
+
+  AMDiS::finalize();
+  return 0;
+}
diff --git a/examples/pfc3.cc b/examples/pfc3.cc
new file mode 100644
index 00000000..871b35f5
--- /dev/null
+++ b/examples/pfc3.cc
@@ -0,0 +1,83 @@
+#include <amdis/AMDiS.hpp>
+#include <amdis/AdaptInstationary.hpp>
+#include <amdis/GridFunctions.hpp>
+#include <amdis/LocalOperators.hpp>
+#include <amdis/ProblemInstat.hpp>
+#include <amdis/ProblemStat.hpp>
+
+#include "PfcSolver.hpp"
+
+using namespace AMDiS;
+
+int main(int argc, char** argv)
+{
+  AMDiS::init(argc, argv);
+
+  auto grid = MeshCreator<Dune::YaspGrid<2>>::create("pfcMesh");
+
+  using namespace Dune::Functions::BasisFactory;
+  auto basis = makeBasis(grid->leafGridView(), power<3>(lagrange<1>(), blockedLexicographic()) );
+
+  AdaptInfo adaptInfo("adapt");
+
+  auto prob = makeProblemStat("pfc", *grid, basis);
+  prob.initialize(INIT_ALL);
+
+  // register a solver in the problem after initialization
+  using MatrixType = TYPEOF(prob.systemMatrix()->matrix());
+  using VectorType = TYPEOF(prob.solutionVector()->vector());
+  PfcSolver<MatrixType,VectorType,VectorType> solver("pfc->solver", adaptInfo.timestep());
+  prob.setSolver(solver);
+
+  auto probInstat = makeProblemInstat("pfc", prob);
+  probInstat.initialize(INIT_UH_OLD);
+
+  double r = -0.4;
+  Parameters::get("pfc->r", r);
+
+  double psi_mean = -0.3;
+  Parameters::get("pfc->psi_mean", psi_mean);
+
+  auto psi = prob.solution(1);
+  auto psiOld = probInstat.oldSolution(1);
+
+  auto M = 1.0; //max(1.e-5, psi + 1.5);
+  auto tau = std::ref(adaptInfo.timestep());
+
+  // mu
+  prob.addMatrixOperator(zot(1.0), 0, 0);
+  // -(1+r)*psi
+  prob.addMatrixOperator(zot(-(1.0+r)), 0, 1);
+  // -3*psi'^2*psi
+  prob.addMatrixOperator(zot(-3.0*pow<2>(psi)), 0, 1);
+  // -2*laplace(psi)
+  prob.addMatrixOperator(sot(2.0), 0, 1);
+  // -laplace(nu)
+  prob.addMatrixOperator(sot(1.0), 0, 2);
+  // -2*psi'^3
+  prob.addVectorOperator(zot(-2.0*pow<3>(psi)), 0);
+
+  // psi
+  prob.addMatrixOperator(zot(1.0), 1, 1);
+  // -tau*div(M(psi')grad(mu))
+  prob.addMatrixOperator(sot(tau*M,1), 1, 0);
+  // psi'
+  prob.addVectorOperator(zot(psi), 1);
+
+  // -laplace(psi)
+  prob.addMatrixOperator(sot(1.0), 2, 1);
+  // nu
+  prob.addMatrixOperator(zot(1.0), 2, 2);
+
+  // set initial condition
+  std::srand(12345);
+  psi << [psi_mean](auto const& x) {
+    return psi_mean + 0.2*(double(std::rand())/RAND_MAX - 0.5);
+  };
+
+  AdaptInstationary adaptInstat("adapt", prob, adaptInfo, probInstat, adaptInfo);
+  adaptInstat.adapt();
+
+  AMDiS::finalize();
+  return 0;
+}
diff --git a/examples/stokes4.cc b/examples/stokes4.cc
new file mode 100644
index 00000000..881d2ec4
--- /dev/null
+++ b/examples/stokes4.cc
@@ -0,0 +1,168 @@
+#include <amdis/AMDiS.hpp>
+#include <amdis/LocalOperators.hpp>
+#include <amdis/ProblemStat.hpp>
+#include <amdis/localoperators/StokesOperator.hpp>
+
+#include <dune/istl/paamg/amg.hh>
+#include <dune/istl/paamg/fastamg.hh>
+
+using namespace AMDiS;
+
+template <class M, class X, class Y = X>
+class StokesPrecon
+    : public Dune::Preconditioner<X,Y>
+{
+  using Matrix = M;
+
+  template <class SubMatrix, class SubVector>
+  struct SubSolver
+  {
+    using Solver = Dune::GeneralizedPCGSolver<SubVector>;
+
+    using Operator = Dune::MatrixAdapter<SubMatrix,SubVector,SubVector>;
+    using CriterionBase = Dune::Amg::AggregationCriterion<Dune::Amg::SymmetricMatrixDependency<SubMatrix,Dune::Amg::FirstDiagonal> >;
+    using Criterion = Dune::Amg::CoarsenCriterion<CriterionBase>;
+    using Smoother = Dune::SeqSSOR<SubMatrix,SubVector,SubVector>;
+    using SmootherArgs = typename Dune::Amg::SmootherTraits<Smoother>::Arguments;
+    using Preconditioner = Dune::Amg::FastAMG<Operator,SubVector>;
+
+    SubSolver(SubMatrix const& mat)
+      : op_(mat)
+    {
+      int maxIt = 1;
+      Parameters::get("stokes->innersolver->max iteration", maxIt);
+
+      criterion_.setDebugLevel(0);
+      parms_.setNoPreSmoothSteps(1);
+      parms_.setNoPostSmoothSteps(1);
+      parms_.setDebugLevel(0);
+      precon_ = std::make_unique<Preconditioner>(op_, criterion_, parms_);
+      solver_ = std::make_unique<Solver>(op_, *precon_, 1.e-3, maxIt, 0);
+    }
+
+    void apply(SubVector& x, SubVector const& b)
+    {
+      Dune::InverseOperatorResult stat;
+      SubVector b_(b);
+      solver_->apply(x, b_, stat);
+    }
+
+    Operator op_;
+    Criterion criterion_;
+    SmootherArgs smootherArgs_;
+    Dune::Amg::Parameters parms_;
+    std::unique_ptr<Preconditioner> precon_;
+    std::unique_ptr<Solver> solver_;
+  };
+
+
+public:
+  template <class Q>
+  StokesPrecon(M const& matrix, Q const& pressureMassMatrix)
+    : velSolver_(matrix[zero_][zero_][0][0])
+    , preSolver_(pressureMassMatrix)
+  {}
+
+  void pre(X& /*x*/, Y& /*b*/) override { /* do nothing */ }
+  void post(X& /*x*/) override { /* do nothing */ }
+
+  void apply(X& v, Y const& d) override
+  {
+    for (int i = 0; i < 2; ++i)
+      velSolver_.apply(v[zero_][i], d[zero_][i]);
+    preSolver_.apply(v[one_], d[one_]);
+  }
+
+  Dune::SolverCategory::Category category() const override
+  {
+    return Dune::SolverCategory::sequential;
+  }
+
+private:
+  using VelMatrix = TYPEOF(std::declval<M>()[zero_][zero_][0][0]);
+  using VelVector = TYPEOF(std::declval<X>()[zero_][0]);
+  SubSolver<VelMatrix, VelVector> velSolver_;
+
+  using PreMatrix = TYPEOF(std::declval<M>()[one_][one_]);
+  using PreVector = TYPEOF(std::declval<X>()[one_]);
+  SubSolver<PreMatrix, PreVector> preSolver_;
+};
+
+
+
+int main(int argc, char** argv)
+{
+  AMDiS::init(argc, argv);
+
+  using namespace Dune::Functions::BasisFactory;
+
+  Dune::YaspGrid<2> grid({1.0, 1.0}, {4,4});
+  auto basis = makeBasis(grid.leafGridView(),
+    composite(power<2>(lagrange<2>(), blockedLexicographic()), lagrange<1>(), blockedLexicographic()) );
+
+  auto prob = makeProblemStat("stokes", grid, basis);
+  prob.initialize(INIT_ALL);
+
+  double viscosity = 1.0;
+  Parameters::get("stokes->viscosity", viscosity);
+
+  // tree-paths for components
+  auto _v = Dune::Indices::_0;
+
+  auto opStokes = makeOperator(tag::stokes{}, viscosity);
+  prob.addMatrixOperator(opStokes);
+
+  // define boundary values
+  auto parabolic_y = [](auto const& x)
+  {
+    return FieldVector<double,2>{0.0, x[1]*(1.0 - x[1])};
+  };
+
+  FieldVector<double,2> zero(0);
+
+  // set boundary conditions for velocity
+  prob.boundaryManager()->setBoxBoundary({1,2,2,2});
+  prob.addDirichletBC(1, _v, _v, parabolic_y);
+  prob.addDirichletBC(2, _v, _v, zero);
+
+  AdaptInfo adaptInfo("adapt");
+
+  // assemble and solve system
+  prob.assemble(adaptInfo);
+
+  // assemble a mass matrix on the pressure space
+  auto pBasis = makeBasis(grid.leafGridView(), lagrange<1>());
+  DOFMatrix<TYPEOF(pBasis),TYPEOF(pBasis)> pMassMatrix(pBasis, pBasis);
+  using Element = TYPEOF(grid)::Codim<0>::Entity;
+  pMassMatrix.addOperator(tag::element_operator<Element>{}, zot(1.0));
+  pMassMatrix.assemble();
+
+
+  // create and apply an ISTL solver
+  using MatrixType = TYPEOF(prob.systemMatrix()->matrix());
+  using VectorType = TYPEOF(prob.solutionVector()->vector());
+
+  // Technicality:  turn the matrix into a linear operator
+  Dune::MatrixAdapter<MatrixType,VectorType,VectorType> linOp(prob.systemMatrix()->matrix());
+  StokesPrecon<MatrixType,VectorType> precon(prob.systemMatrix()->matrix(), pMassMatrix.matrix());
+
+  // Construct the actual iterative solver
+  Dune::MINRESSolver<VectorType> solver(
+          linOp,      // operator to invert
+          precon,     // preconditioner for interation
+          1e-10,      // desired residual reduction factor
+          500,        // maximum number of iterations
+          2);         // verbosity of the solver
+
+  // Object storing some statistics about the solving process
+  Dune::InverseOperatorResult statistics;
+
+  // Solve the linear system
+  solver.apply(prob.solutionVector()->vector(), prob.rhsVector()->vector(), statistics);
+
+  // output solution
+  prob.writeFiles(adaptInfo);
+
+  AMDiS::finalize();
+  return 0;
+}
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.hpp b/src/amdis/linearalgebra/DOFMatrixBase.hpp
index 6b907d2e..18dc5a76 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.hpp
@@ -123,8 +123,8 @@ namespace AMDiS
 
     /// Initialize the matrix for insertion, e.g. allocate the non-zero pattern
     /// If \p rebuild is true, the nonzero structure is rebuild and the matrix is set to 0
-    template <class DBC, class PBC>
-    void init(bool rebuild, DBC& dbc, PBC& pbc);
+    template <class... BC>
+    void init(bool rebuild, BC&&... boundaryConditions);
 
     /// Finish the matrix insertion, e.g. cleanup or final insertion
     void finish()
diff --git a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
index 96bbb607..4e66cc04 100644
--- a/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFMatrixBase.inc.hpp
@@ -10,9 +10,9 @@
 namespace AMDiS {
 
 template <class RB, class CB, class T, class K>
-  template <class DBC, class PBC>
+  template <class... BC>
 void DOFMatrixBase<RB,CB,T,K>::
-init(bool rebuild, DBC& dbc, PBC& pbc)
+init(bool rebuild, BC&&... boundaryConditions)
 {
   auto rowLocalView = rowBasis_->localView();
   auto colLocalView = colBasis_->localView();
@@ -52,16 +52,16 @@ init(bool rebuild, DBC& dbc, PBC& pbc)
     }
 
     // init boundary conditions and maybe insert nodes into matrixIndexSet
-    for_each_node(rowLocalView.tree(), [&](auto const& rowNode, auto rowTp) -> void {
-      auto rowBasis = Dune::Functions::subspaceBasis(*rowBasis_, rowTp);
-      for_each_node(colLocalView.tree(), [&](auto const& colNode, auto colTp) -> void {
-        auto colBasis = Dune::Functions::subspaceBasis(*colBasis_, colTp);
-        for (auto bc : dbc[rowNode][colNode])
-          bc->init(rowBasis, colBasis, matIndexSet);
-        for (auto bc : pbc[rowNode][colNode])
-          bc->init(rowBasis, colBasis, matIndexSet);
+    Tools::for_variadic([&](auto& bcs) {
+      for_each_node(rowLocalView.tree(), [&](auto const& rowNode, auto rowTp) -> void {
+        auto rowBasis = Dune::Functions::subspaceBasis(*rowBasis_, rowTp);
+        for_each_node(colLocalView.tree(), [&](auto const& colNode, auto colTp) -> void {
+          auto colBasis = Dune::Functions::subspaceBasis(*colBasis_, colTp);
+          for (auto bc : bcs[rowNode][colNode])
+            bc->init(rowBasis, colBasis, matIndexSet);
+        });
       });
-    });
+    }, boundaryConditions...);
   }
 
   // assign sub-pattern to matrix blocks
diff --git a/src/amdis/linearalgebra/istl/ISTL_Solver.hpp b/src/amdis/linearalgebra/istl/ISTL_Solver.hpp
index c360f50f..cd1ad859 100644
--- a/src/amdis/linearalgebra/istl/ISTL_Solver.hpp
+++ b/src/amdis/linearalgebra/istl/ISTL_Solver.hpp
@@ -2,6 +2,7 @@
 
 #include <memory>
 
+#include <dune/common/version.hh>
 #include <dune/istl/solvers.hh>
 #include <dune/istl/umfpack.hh>
 #include <dune/istl/superlu.hh>
@@ -36,11 +37,34 @@ namespace AMDiS
     double rTol_ = 1.e-6;
   };
 
-  template <class VectorX>
-  struct ISTLSolverCreator<Dune::RestartedGMResSolver<VectorX>, true>
-      : public ISTLSolverCreator<Dune::RestartedGMResSolver<VectorX>, false>
+  template <class X, class Y>
+  struct ISTLSolverCreator<Dune::RestartedGMResSolver<X,Y>, true>
+      : public ISTLSolverCreator<Dune::RestartedGMResSolver<X,Y>, false>
+  {
+    using ISTLSolver = Dune::RestartedGMResSolver<X,Y>;
+    using Super = ISTLSolverCreator<ISTLSolver, false>;
+
+    ISTLSolverCreator(std::string const& prefix)
+      : Super(prefix)
+    {
+      Parameters::get(prefix + "->restart", restart_);
+    }
+
+    template <class LinOperator, class Precon>
+    std::unique_ptr<ISTLSolver> create(LinOperator& A, Precon& P) const
+    {
+      return std::make_unique<ISTLSolver>(A, P, this->rTol_, restart_, this->maxIter_, this->info_);
+    }
+
+    int restart_ = 30;
+  };
+
+#if DUNE_VERSION_GT(DUNE_ISTL,2,6)
+  template <class X, class Y, class F>
+  struct ISTLSolverCreator<Dune::RestartedFlexibleGMResSolver<X,Y,F>, true>
+      : public ISTLSolverCreator<Dune::RestartedFlexibleGMResSolver<X,Y,F>, false>
   {
-    using ISTLSolver = Dune::RestartedGMResSolver<VectorX>;
+    using ISTLSolver = Dune::RestartedFlexibleGMResSolver<X,Y,F>;
     using Super = ISTLSolverCreator<ISTLSolver, false>;
 
     ISTLSolverCreator(std::string const& prefix)
@@ -57,6 +81,7 @@ namespace AMDiS
 
     int restart_ = 30;
   };
+#endif
 
   template <class VectorX>
   struct ISTLSolverCreator<Dune::GeneralizedPCGSolver<VectorX>, true>
@@ -171,6 +196,11 @@ namespace AMDiS
       auto gmres = new SolverCreator<Dune::RestartedGMResSolver<VectorX>>;
       Map::addCreator("gmres", gmres);
 
+#if DUNE_VERSION_GT(DUNE_ISTL,2,6)
+      auto fgmres = new SolverCreator<Dune::RestartedFlexibleGMResSolver<VectorX>>;
+      Map::addCreator("fgmres", fgmres);
+#endif
+
       // Generalized preconditioned conjugate gradient solver.
       auto fcg = new SolverCreator<Dune::GeneralizedPCGSolver<VectorX>>;
       Map::addCreator("fcg", fcg);
@@ -238,6 +268,11 @@ namespace AMDiS
       auto gmres = new SolverCreator<Dune::RestartedGMResSolver<VectorX>>;
       Map::addCreator("gmres", gmres);
 
+#if DUNE_VERSION_GT(DUNE_ISTL,2,6)
+      auto fgmres = new SolverCreator<Dune::RestartedFlexibleGMResSolver<VectorX>>;
+      Map::addCreator("fgmres", fgmres);
+#endif
+
       // Generalized preconditioned conjugate gradient solver.
       auto fcg = new SolverCreator<Dune::GeneralizedPCGSolver<VectorX>>;
       Map::addCreator("fcg", fcg);
-- 
GitLab


From dbdf593cc57e0b081c067a317fb5dbfc13f88102 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Thu, 25 Apr 2019 22:14:37 +0200
Subject: [PATCH 27/38] replaced fgmres with gmres for old dune

---
 examples/PfcSolver.hpp | 4 ++++
 examples/pfc1.cc       | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/examples/PfcSolver.hpp b/examples/PfcSolver.hpp
index eb6f819a..35417864 100644
--- a/examples/PfcSolver.hpp
+++ b/examples/PfcSolver.hpp
@@ -13,7 +13,11 @@ namespace AMDiS
     using Super = LinearSolverInterface<Mat, X, Y>;
 
     using LinOp = Dune::MatrixAdapter<Mat,X,Y>;
+#if DUNE_VERSION_GT(DUNE_ISTL,2,6)
     using Solver = Dune::RestartedFlexibleGMResSolver<X,Y>;
+#else
+    using Solver = Dune::RestartedGMResSolver<X,Y>;
+#endif
     using Precon = PfcPrecon<Mat,X,Y>;
 
   public:
diff --git a/examples/pfc1.cc b/examples/pfc1.cc
index 5afb90ce..41d91a82 100644
--- a/examples/pfc1.cc
+++ b/examples/pfc1.cc
@@ -72,7 +72,11 @@ int main(int argc, char** argv)
   Parameters::get("pfc->solver->info", solverInfo);
 
   // Construct the actual iterative solver
+#if DUNE_VERSION_GT(DUNE_ISTL,2,6)
   Dune::RestartedFlexibleGMResSolver<VectorType> solver(linOp, precon, 1e-7, 30, 10000, solverInfo);
+#else
+  Dune::RestartedGMResSolver<VectorType> solver(linOp, precon, 1e-7, 30, 10000, solverInfo);
+#endif
 
   // @}
 
-- 
GitLab


From e9e16797784f75b2fd217f9f317c98785cc69b8c Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Fri, 26 Apr 2019 18:02:34 +0200
Subject: [PATCH 28/38] Eigen backend adapted to new blocking structure

---
 src/amdis/linearalgebra/CMakeLists.txt        |   3 +-
 src/amdis/linearalgebra/MatrixInserter.hpp    |   4 +-
 .../linearalgebra/MatrixInserter.inc.hpp      |  11 +-
 .../linearalgebra/MatrixVectorTraits.hpp      |   1 +
 src/amdis/linearalgebra/MatrixWrapper.hpp     |   2 +-
 src/amdis/linearalgebra/NoMatrixIndexSet.hpp  |   5 +
 .../linearalgebra/SingleRowColMatrix.hpp      |   2 +
 ...lMatrix.hpp => SingleRowColMatrix.inc.hpp} |  47 +++--
 .../linearalgebra/VectorInserter.inc.hpp      |   2 +-
 src/amdis/linearalgebra/eigen/Constraints.hpp |  60 ------
 src/amdis/linearalgebra/eigen/DOFMatrix.hpp   |  90 +--------
 src/amdis/linearalgebra/eigen/DOFVector.hpp   |  88 +--------
 .../eigen/MatrixVectorTraits.hpp              |  26 +++
 .../linearalgebra/eigen/SparseMatrix.hpp      | 173 ++++++++++++++++++
 src/amdis/linearalgebra/eigen/Vector.hpp      |  95 ++++++++++
 .../istl/ISTL_Preconditioner.hpp              |  76 ++++----
 .../linearalgebra/istl/MatrixVectorTraits.hpp |   1 -
 test/CMakeLists.txt                           |   5 +
 test/MatrixTest.cpp                           |  17 +-
 19 files changed, 401 insertions(+), 307 deletions(-)
 rename src/amdis/linearalgebra/{istl/SingleRowColMatrix.hpp => SingleRowColMatrix.inc.hpp} (87%)
 delete mode 100644 src/amdis/linearalgebra/eigen/Constraints.hpp
 create mode 100644 src/amdis/linearalgebra/eigen/MatrixVectorTraits.hpp
 create mode 100644 src/amdis/linearalgebra/eigen/SparseMatrix.hpp
 create mode 100644 src/amdis/linearalgebra/eigen/Vector.hpp

diff --git a/src/amdis/linearalgebra/CMakeLists.txt b/src/amdis/linearalgebra/CMakeLists.txt
index 7505b37a..44e1d6ac 100644
--- a/src/amdis/linearalgebra/CMakeLists.txt
+++ b/src/amdis/linearalgebra/CMakeLists.txt
@@ -23,6 +23,7 @@ install(FILES
     PreconditionerInterface.hpp
     RunnerInterface.hpp
     SingleRowColMatrix.hpp
+    SingleRowColMatrix.inc.hpp
     SolverInfo.hpp
     VectorInserter.hpp
     VectorInserter.inc.hpp
@@ -32,6 +33,6 @@ install(FILES
     VectorWrapperBase.hpp
 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/amdis/linearalgebra)
 
-#add_subdirectory("eigen")
+add_subdirectory("eigen")
 add_subdirectory("istl")
 add_subdirectory("mtl")
diff --git a/src/amdis/linearalgebra/MatrixInserter.hpp b/src/amdis/linearalgebra/MatrixInserter.hpp
index 044c585d..54e1d59c 100644
--- a/src/amdis/linearalgebra/MatrixInserter.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.hpp
@@ -60,9 +60,9 @@ namespace AMDiS
     using MatrixInserterSelector =
       std::conditional_t<Dune::MatVec::IsScalarMatrix<M>::value,
         MatrixInserterScalarImpl<M>,
-      std::conditional_t<Concepts::MatrixAccessible_t<M,std::size_t,std::size_t>::value,
+      std::conditional_t<Concepts::MatrixAccessible_t<M,std::size_t,std::size_t>::value || Concepts::Callable<M,std::size_t,std::size_t>,
         MatrixInserterImpl<M, MatrixDynamicInserter<M>>,
-      std::conditional_t<Concepts::MatrixAccessible_t<M,index_t<0>,index_t<0>>::value,
+      std::conditional_t<Concepts::MatrixAccessible_t<M,index_t<0>,index_t<0>>::value || Concepts::Callable<M,index_t<0>,index_t<0>>,
         MatrixInserterImpl<M, MatrixStaticInserter<M>>,
         MatrixInserterScalarImpl<M> >>>;
 
diff --git a/src/amdis/linearalgebra/MatrixInserter.inc.hpp b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
index ebede09e..96b3b715 100644
--- a/src/amdis/linearalgebra/MatrixInserter.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixInserter.inc.hpp
@@ -9,6 +9,7 @@
 #include <amdis/common/Access.hpp>
 #include <amdis/common/ForEach.hpp>
 #include <amdis/common/HybridSize.hpp>
+#include <amdis/common/StaticSize.hpp>
 #include <amdis/common/SwitchCases.hpp>
 #include <amdis/linearalgebra/Common.hpp>
 #include <amdis/linearalgebra/NoMatrixIndexSet.hpp>
@@ -52,7 +53,7 @@ namespace AMDiS
   template <class BaseMatrix>
   class MatrixDynamicInserter
   {
-    using size_type = typename BaseMatrix::size_type;
+    using size_type = std::size_t;
     using block_type = typename BlockType<BaseMatrix>::type;
     using Inserter = std::vector<MatrixInserter<block_type>>;
 
@@ -68,8 +69,8 @@ namespace AMDiS
   public:
     template <class MIS>
     MatrixDynamicInserter(BaseMatrix& matrix, MIS const& matIndexSet, bool rebuild)
-      : rows_(matrix.N())
-      , cols_(matrix.M())
+      : rows_(hybridNumRows(matrix))
+      , cols_(hybridNumCols(matrix))
     {
       for (size_type i = 0; i < rows_; ++i)
         for (size_type j = 0; j < cols_; ++j)
@@ -93,8 +94,8 @@ namespace AMDiS
   class MatrixStaticInserter
   {
   public:
-    static constexpr std::size_t rows = BaseMatrix::N();
-    static constexpr std::size_t cols = BaseMatrix::M();
+    static constexpr std::size_t rows = Rows_v<BaseMatrix>;
+    static constexpr std::size_t cols = Cols_v<BaseMatrix>;
 
   private:
     template <class Cols, class MIS>
diff --git a/src/amdis/linearalgebra/MatrixVectorTraits.hpp b/src/amdis/linearalgebra/MatrixVectorTraits.hpp
index ae7ae8cb..c3072508 100644
--- a/src/amdis/linearalgebra/MatrixVectorTraits.hpp
+++ b/src/amdis/linearalgebra/MatrixVectorTraits.hpp
@@ -12,6 +12,7 @@
 
 #include <amdis/linearalgebra/MultiTypeMatrix.hpp>
 #include <amdis/linearalgebra/MultiTypeVector.hpp>
+#include <amdis/linearalgebra/SingleRowColMatrix.hpp>
 
 namespace AMDiS
 {
diff --git a/src/amdis/linearalgebra/MatrixWrapper.hpp b/src/amdis/linearalgebra/MatrixWrapper.hpp
index 04f5304a..728014a3 100644
--- a/src/amdis/linearalgebra/MatrixWrapper.hpp
+++ b/src/amdis/linearalgebra/MatrixWrapper.hpp
@@ -39,7 +39,7 @@ namespace AMDiS
     using MatrixWrapperSelector =
       std::conditional_t<Dune::MatVec::IsScalarMatrix<M>::value,
         MatrixWrapperScalarImpl<M>,
-      std::conditional_t<Concepts::MatrixAccessible_t<M,index_t<0>,index_t<0>>::value,
+      std::conditional_t<Concepts::MatrixAccessible_t<M,index_t<0>,index_t<0>>::value || Concepts::Callable<M,index_t<0>,index_t<0>>,
         MatrixWrapperImpl<M>,
         MatrixWrapperScalarImpl<M> >>;
 
diff --git a/src/amdis/linearalgebra/NoMatrixIndexSet.hpp b/src/amdis/linearalgebra/NoMatrixIndexSet.hpp
index c6592ff3..0f3bbd06 100644
--- a/src/amdis/linearalgebra/NoMatrixIndexSet.hpp
+++ b/src/amdis/linearalgebra/NoMatrixIndexSet.hpp
@@ -21,6 +21,11 @@ namespace AMDiS
       return slotSize_;
     }
 
+    std::size_t size() const
+    {
+      return slotSize_;
+    }
+
     template <class MatrixType>
     void exportIdx(MatrixType& matrix) const {}
 
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
index cec750c6..3e45fa1b 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.hpp
@@ -245,3 +245,5 @@ namespace AMDiS
   };
 
 } // end namespace AMDiS
+
+#include <amdis/linearalgebra/SingleRowColMatrix.inc.hpp>
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.inc.hpp
similarity index 87%
rename from src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
rename to src/amdis/linearalgebra/SingleRowColMatrix.inc.hpp
index 8df3bb5a..3973f93b 100644
--- a/src/amdis/linearalgebra/istl/SingleRowColMatrix.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.inc.hpp
@@ -5,12 +5,9 @@
 #include <dune/common/hybridutilities.hh>
 #include <dune/common/rangeutilities.hh>
 
-#include <dune/istl/matrix.hh>
-#include <dune/istl/multitypeblockmatrix.hh>
-
+#include <amdis/common/HybridSize.hpp>
 #include <amdis/common/Index.hpp>
 #include <amdis/common/TypeTraits.hpp>
-#include <amdis/linearalgebra/SingleRowColMatrix.hpp>
 
 namespace AMDiS
 {
@@ -26,16 +23,17 @@ namespace AMDiS
     using block_type = typename Super::block_type;
 
   private:
-    template <size_type I0 = 0, class B, class A>
-    static constexpr Dune::IntegralRange<size_type> row_range(Dune::Matrix<B,A> const& mat)
+    template <size_type I0 = 0, class Mat>
+    static constexpr auto row_range(Mat const& mat)
     {
-      return {I0, mat.N()};
-    }
-
-    template <size_type I0 = 0, class... Rows>
-    static constexpr auto row_range(Dune::MultiTypeBlockMatrix<Rows...> const& mat)
-    {
-      return Dune::StaticIntegralRange<size_type,TYPEOF(mat)::N(),I0>{};
+      auto rows = hybridNumRows(std::declval<Mat>());
+      return Dune::Hybrid::ifElse(std::is_integral<decltype(rows)>{},
+        [&](auto id) {
+          return Dune::IntegralRange<size_type>{I0, size_type(rows)};
+        },
+        [&](auto id) {
+          return Dune::StaticIntegralRange<size_type,rows.value,I0>{};
+        });
     }
 
   public:
@@ -162,23 +160,22 @@ namespace AMDiS
     using Super = Matrix;
 
   public:
-    using size_type = typename Super::size_type;
+    using size_type = std::size_t;
     using field_type = typename Super::field_type;
     using block_type = typename Super::block_type;
 
   private:
-    static constexpr index_t<0> zero = {};
-
-    template <size_type I0 = 0, class B, class A>
-    static constexpr Dune::IntegralRange<size_type> col_range(Dune::Matrix<B,A> const& mat)
-    {
-      return {I0, mat.M()};
-    }
-
-    template <size_type I0 = 0, class... Rows>
-    static constexpr auto col_range(Dune::MultiTypeBlockMatrix<Rows...> const& mat)
+    template <size_type I0 = 0, class Mat>
+    static constexpr auto col_range(Mat const& mat)
     {
-      return Dune::StaticIntegralRange<size_type,TYPEOF(mat)::M(),I0>{};
+      auto cols = hybridNumCols(std::declval<Mat>());
+      return Dune::Hybrid::ifElse(std::is_integral<decltype(cols)>{},
+        [&](auto id) {
+          return Dune::IntegralRange<size_type>{I0, size_type(cols)};
+        },
+        [&](auto id) {
+          return Dune::StaticIntegralRange<size_type,cols.value,I0>{};
+        });
     }
 
   public:
diff --git a/src/amdis/linearalgebra/VectorInserter.inc.hpp b/src/amdis/linearalgebra/VectorInserter.inc.hpp
index 7eeb421b..ecabb806 100644
--- a/src/amdis/linearalgebra/VectorInserter.inc.hpp
+++ b/src/amdis/linearalgebra/VectorInserter.inc.hpp
@@ -78,7 +78,7 @@ namespace AMDiS
   class VectorStaticInserter
   {
   public:
-    static constexpr std::size_t dimension = BaseVector::size();
+    static constexpr std::size_t dimension = Size_v<BaseVector>;
 
   private:
 
diff --git a/src/amdis/linearalgebra/eigen/Constraints.hpp b/src/amdis/linearalgebra/eigen/Constraints.hpp
deleted file mode 100644
index 46b99b92..00000000
--- a/src/amdis/linearalgebra/eigen/Constraints.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-
-#include <list>
-
-#include <Eigen/SparseCore>
-
-#include <amdis/common/Index.hpp>
-#include <amdis/linearalgebra/Common.hpp>
-#include <amdis/linearalgebra/Constraints.hpp>
-
-namespace AMDiS
-{
-  template <class T, int O>
-  struct Constraints<Eigen::SparseMatrix<T,O>>
-  {
-    using Matrix = Eigen::SparseMatrix<T,O>;
-
-    template <class BitVector>
-    static std::vector<Triplet<T>> dirichletBC(Matrix& mat, BitVector const& nodes, bool setDiagonal = true)
-    {
-      clearDirichletRow(mat, nodes, setDiagonal, int_<O>);
-      return {};
-    }
-
-    template <class BitVector, class Associations>
-    static std::vector<Triplet<T>> periodicBC(Matrix& mat, BitVector const& left, Associations const& left2right,
-      bool setDiagonal = true)
-    {
-      error_exit("Not implemented");
-      return {};
-    }
-
-  protected:
-    template <class BitVector>
-    static void clearDirichletRow(Matrix& mat, BitVector const& nodes, bool setDiagonal, int_t<Eigen::ColMajor>)
-    {
-      for (typename Matrix::Index c = 0; c < mat.outerSize(); ++c) {
-        for (typename Matrix::InnerIterator it(mat, c); it; ++it) {
-          if (nodes[it.row()]) {
-            it.valueRef() = (setDiagonal && it.row() == it.col() ? T(1) : T(0));
-            break;
-          }
-        }
-      }
-    }
-
-    template <class BitVector>
-    static void clearDirichletRow(Matrix& mat, BitVector const& nodes, bool setDiagonal, int_t<Eigen::RowMajor>)
-    {
-      for (typename Matrix::Index r = 0; r < mat.outerSize(); ++r) {
-        if (nodes[r]) {
-          for (typename Matrix::InnerIterator it(mat, r); it; ++it) {
-            it.valueRef() = (setDiagonal && it.row() == it.col() ? T(1) : T(0));
-          }
-        }
-      }
-    }
-  };
-
-} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/eigen/DOFMatrix.hpp b/src/amdis/linearalgebra/eigen/DOFMatrix.hpp
index 7e5fc0cc..9327500d 100644
--- a/src/amdis/linearalgebra/eigen/DOFMatrix.hpp
+++ b/src/amdis/linearalgebra/eigen/DOFMatrix.hpp
@@ -1,100 +1,14 @@
 #pragma once
 
-#include <list>
-#include <memory>
-#include <string>
-#include <vector>
-
 #include <Eigen/SparseCore>
 
-#include <dune/common/timer.hh>
-
-#include <amdis/Output.hpp>
-#include <amdis/linearalgebra/Common.hpp>
 #include <amdis/linearalgebra/DOFMatrixBase.hpp>
+#include <amdis/linearalgebra/eigen/MatrixVectorTraits.hpp>
 
 namespace AMDiS
 {
-  /// \brief The basic container that stores a base matrix and a corresponding
-  /// row/column feSpace.
-  template <class ValueType, int Orientation = Eigen::RowMajor>
-  class EigenMatrix
-  {
-  public:
-    /// The matrix type of the underlying base matrix
-    using BaseMatrix = Eigen::SparseMatrix<ValueType, Orientation>;
-
-    /// The type of the elements of the DOFMatrix
-    using value_type = ValueType;
-
-    /// The index/size - type
-    using size_type = typename BaseMatrix::Index;
-
-  public:
-    /// Constructor. Constructs new BaseMatrix.
-    EigenMatrix() = default;
-
-    /// Return a reference to the data-matrix \ref matrix
-    BaseMatrix& matrix()
-    {
-      return matrix_;
-    }
-
-    /// Return a reference to the data-matrix \ref matrix
-    BaseMatrix const& matrix() const
-    {
-      return matrix_;
-    }
-
-
-    /// \brief Returns an update-proxy of the inserter, to inserte/update a value at
-    /// position (\p r, \p c) in the matrix. Need an insertionMode inserter, that can
-    /// be created by \ref init and must be closed by \ref finish after insertion.
-    void insert(size_type r, size_type c, value_type const& value)
-    {
-      test_exit_dbg(r < matrix_.rows() && c < matrix_.cols(),
-          "Indices out of range [0,{})x[0,{})", matrix_.rows(), matrix_.cols());
-      tripletList_.emplace_back(r, c, value);
-    }
-
-
-    /// Create inserter. Assumes that no inserter is currently active on this matrix.
-    template <class RowBasis, class ColBasis>
-    void init(RowBasis const& rowBasis, ColBasis const& colBasis,
-              bool prepareForInsertion)
-    {
-      matrix_.resize(rowBasis.dimension(), colBasis.dimension());
-      if (prepareForInsertion) {
-        matrix_.setZero(); // maybe not necessary
-      }
-    }
-
-    /// Delete inserter -> finish insertion. Must be called in order to fill the
-    /// final construction of the matrix.
-    void finish()
-    {
-      matrix_.setFromTriplets(tripletList_.begin(), tripletList_.end());
-      matrix_.makeCompressed();
-
-      tripletList_.clear(); // NOTE: this does not free the memory
-    }
-
-    /// Return the number of nonzeros in the matrix
-    std::size_t nnz() const
-    {
-      return matrix_.nonZeros();
-    }
-
-  private:
-    /// The data-matrix
-    BaseMatrix matrix_;
-
-    /// A list of row,col indices and values
-    std::vector<Eigen::Triplet<ValueType, Eigen::Index>> tripletList_;
-  };
-
   template <class RowBasisType, class ColBasisType,
             class T = double, int O = Eigen::RowMajor>
-  using DOFMatrix = DOFMatrixBase<RowBasisType, ColBasisType, EigenMatrix<T, O>>;
+  using DOFMatrix = DOFMatrixBase<RowBasisType, ColBasisType, EigenTraits<O>>;
 
 } // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/eigen/DOFVector.hpp b/src/amdis/linearalgebra/eigen/DOFVector.hpp
index 0c33a621..bc9346f9 100644
--- a/src/amdis/linearalgebra/eigen/DOFVector.hpp
+++ b/src/amdis/linearalgebra/eigen/DOFVector.hpp
@@ -1,94 +1,14 @@
 #pragma once
 
-#include <Eigen/Dense>
-
-#include <dune/common/ftraits.hh>
-
-#include <amdis/Output.hpp>
 #include <amdis/linearalgebra/DOFVectorBase.hpp>
+#include <amdis/linearalgebra/eigen/MatrixVectorTraits.hpp>
 
 namespace AMDiS
 {
-  /// The basic container that stores a base vector and a corresponding basis
-  template <class ValueType>
-  class EigenVector
-  {
-  public:
-    /// The type of the elements of the DOFVector
-    using value_type = ValueType;
-
-    /// The type of the elements of the DOFVector
-    using block_type = ValueType;
-
-    /// The underlying field type
-    using field_type = typename Dune::FieldTraits<ValueType>::field_type;
-
-    /// The type of the base vector
-    using BaseVector = Eigen::Matrix<ValueType, Eigen::Dynamic, 1>;
-
-    /// The index/size - type
-    using size_type  = typename BaseVector::Index;
-
-  public:
-    /// Constructor. Constructs new BaseVector.
-    EigenVector() = default;
-
-    /// Return the data-vector \ref vector_
-    BaseVector const& vector() const
-    {
-      return vector_;
-    }
-
-    /// Return the data-vector \ref vector_
-    BaseVector& vector()
-    {
-      return vector_;
-    }
-
-    /// Return the current size of the \ref vector_
-    size_type size() const
-    {
-      return vector_.size();
-    }
-
-    /// Resize the \ref vector_ to the size \p s
-    void resize(size_type s)
-    {
-      vector_.resize(s);
-    }
-
-
-    /// Access the entry \p i of the \ref vector with read-access.
-    value_type const& operator[](size_type i) const
-    {
-      test_exit_dbg(i < size(),
-        "Index {} out of range [0,{})", i, size());
-      return vector_.coeff(i);
-    }
-
-    /// Access the entry \p i of the \ref vector with write-access.
-    value_type& operator[](size_type i)
-    {
-      test_exit_dbg(i < size(),
-        "Index {} out of range [0,{})", i, size());
-      return vector_.coeffRef(i);
-    }
-
-    void set(field_type value)
-    {
-      vector_.setConstant(value);
-    }
-
-  private:
-    /// The data-vector (can hold a new BaseVector or a pointer to external data
-    BaseVector vector_;
-  };
-
-
-  template <class GlobalBasis, class ValueType>
-  class DOFVector : public DOFVectorBase<GlobalBasis, EigenVector<ValueType>>
+  template <class BasisType, class ValueType = double>
+  class DOFVector : public DOFVectorBase<BasisType, EigenTraits<>, ValueType>
   {
-    using Super = DOFVectorBase<GlobalBasis, EigenVector<ValueType>>;
+    using Super = DOFVectorBase<BasisType, EigenTraits<>, ValueType>;
 
   public:
     DOFVector(std::shared_ptr<GlobalBasis> basis, DataTransferOperation op = DataTransferOperation::INTERPOLATE)
diff --git a/src/amdis/linearalgebra/eigen/MatrixVectorTraits.hpp b/src/amdis/linearalgebra/eigen/MatrixVectorTraits.hpp
new file mode 100644
index 00000000..747a0212
--- /dev/null
+++ b/src/amdis/linearalgebra/eigen/MatrixVectorTraits.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <vector>
+#include <amdis/linearalgebra/eigen/SparseMatrix.hpp>
+#include <amdis/linearalgebra/eigen/Vector.hpp>
+
+namespace AMDiS
+{
+  template <int Orientation = Eigen::RowMajor>
+  struct EigenTraits
+  {
+    template <class ValueType>
+    using FlatVector = Eigen::Matrix<ValueType, Eigen::Dynamic, 1>;
+
+    template <class ValueType>
+    using FlatMatrix = Eigen::SparseMatrix<ValueType, Orientation>;
+
+
+    template <class B, std::size_t N>
+    using PowerVector = Eigen::Matrix<B, int(N), 1>;
+
+    template <class B, std::size_t R, std::size_t C>
+    using PowerMatrix = Eigen::Matrix<B, int(R), int(C)>;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/eigen/SparseMatrix.hpp b/src/amdis/linearalgebra/eigen/SparseMatrix.hpp
new file mode 100644
index 00000000..40d67107
--- /dev/null
+++ b/src/amdis/linearalgebra/eigen/SparseMatrix.hpp
@@ -0,0 +1,173 @@
+#pragma once
+
+#include <cassert>
+#include <vector>
+#include <Eigen/SparseCore>
+
+#include <amdis/Output.hpp>
+#include <amdis/common/StaticSize.hpp>
+#include <amdis/linearalgebra/MatrixInserter.hpp>
+#include <amdis/linearalgebra/MatrixWrapper.hpp>
+
+namespace AMDiS
+{
+  template <class ValueType, int Orientation>
+  class MatrixInserter<Eigen::SparseMatrix<ValueType, Orientation>>
+      : public MatrixInserterBase<MatrixInserter<Eigen::SparseMatrix<ValueType, Orientation>>>
+  {
+  public:
+    /// The matrix type of the underlying base matrix
+    using BaseMatrix = Eigen::SparseMatrix<ValueType, Orientation>;
+
+    /// The type of the elements of the DOFMatrix
+    using value_type = ValueType;
+
+    /// The index/size - type
+    using size_type = typename BaseMatrix::Index;
+
+    /// The type of the inserter used when filling the matrix. NOTE: need not be public
+    using TripletList = std::vector<Eigen::Triplet<ValueType, Eigen::Index>>;
+
+  public:
+    /// Constructor. Stores a pointer to the passed BaseMatrix
+    template <class MatIndexSet>
+    MatrixInserter(BaseMatrix& matrix, MatIndexSet const& matIndexSet, bool rebuild)
+      : matrix_(matrix)
+    {
+      if (rebuild)
+        matrix_.setZero();
+
+      tripletList_.reserve(matIndexSet.size());
+    }
+
+    MatrixInserter(MatrixInserter&&) = default;
+    MatrixInserter(MatrixInserter const&) = delete;
+
+    ~MatrixInserter()
+    {
+      matrix_.setFromTriplets(tripletList_.begin(), tripletList_.end());
+      matrix_.makeCompressed();
+    }
+
+    template <class Row, class Col>
+    void insert_impl(Row const& row, Col const& col, value_type const& value, Assigner::plus_assign)
+    {
+      size_type r = *row;
+      size_type c = *col;
+      test_exit_dbg(r < matrix_.rows() && c < matrix_.cols(),
+          "Indices out of range [0,{})x[0,{})", matrix_.rows(), matrix_.cols());
+
+      tripletList_.emplace_back(r,c,value);
+    }
+
+  private:
+    /// The data-matrix
+    BaseMatrix& matrix_;
+
+    /// A list of triplets (row, col, value) is used to fill the actual matrix
+    TripletList tripletList_;
+  };
+
+
+  /// \brief The basic container that stores a base matrix
+  template <class ValueType, int Orientation>
+  class MatrixWrapper<Eigen::SparseMatrix<ValueType, Orientation>>
+      : public MatrixWrapperBase<MatrixWrapper<Eigen::SparseMatrix<ValueType, Orientation>>>
+  {
+  public:
+    /// The matrix type of the underlying base matrix
+    using BaseMatrix = Eigen::SparseMatrix<ValueType, Orientation>;
+
+    /// The type of the elements of the DOFMatrix
+    using value_type = ValueType;
+
+    /// The index/size - type
+    using size_type = typename BaseMatrix::Index;
+
+  public:
+    /// Constructor. Stores a pointer to the passed BaseMatrix
+    MatrixWrapper(BaseMatrix& matrix)
+      : matrix_(matrix)
+    {}
+
+    template <class RowSize, class ColSize>
+    void resize_impl(RowSize const& rowSize, typename RowSize::SizePrefix rowPrefix,
+                     ColSize const& colSize, typename ColSize::SizePrefix colPrefix)
+    {
+      size_type rows = rowSize.size(rowPrefix);
+      size_type cols = colSize.size(colPrefix);
+      assert(rows > 0 && cols > 0);
+      matrix_.resize(rows, cols);
+    }
+
+    template <class RowIter, class Col, class RowValues>
+    void clear_row_impl(RowIter const& row, Col col, RowValues& row_values)
+    {
+      size_type node = *row;
+
+      // iterate over the row
+      push_back(col);
+      if (Orientation == Eigen::RowMajor)
+      {
+        size_type r = node;
+        for (typename BaseMatrix::InnerIterator it(matrix_, r); it; ++it) {
+          back(col) = it.col();
+          row_values.emplace_back(row.multiIndex(), col, it.valueRef());
+          it.valueRef() = value_type(0);
+        }
+
+      } else {
+        for (size_type c = 0; c < matrix_.outerSize(); ++c) {
+          back(col) = c;
+          for (typename BaseMatrix::InnerIterator it(matrix_, c); it; ++it) {
+            if (it.row() == node) {
+              row_values.emplace_back(row.multiIndex(), col, it.valueRef());
+              it.valueRef() = value_type(0);
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    template <class Row, class ColIter, class ColValues>
+    void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
+    {
+      size_type node = *col;
+
+      // iterate over the column
+      push_back(row);
+      if (Orientation == Eigen::RowMajor)
+      {
+        for (size_type r = 0; r < matrix_.outerSize(); ++r) {
+          back(row) = r;
+          for (typename BaseMatrix::InnerIterator it(matrix_, r); it; ++it) {
+            if (it.col() == node) {
+              col_values.emplace_back(row, col.multiIndex(), it.valueRef());
+              it.valueRef() = value_type(0);
+              break;
+            }
+          }
+        }
+      } else {
+        size_type c = node;
+        for (typename BaseMatrix::InnerIterator it(matrix_, c); it; ++it) {
+          back(row) = it.row();
+          col_values.emplace_back(row, col.multiIndex(), it.valueRef());
+          it.valueRef() = value_type(0);
+        }
+      }
+    }
+
+    /// Return the number of nonzeros in the matrix
+    std::size_t nnz_impl() const
+    {
+      return matrix_.nonZeros() * Rows_v<value_type> * Cols_v<value_type>;
+    }
+
+  private:
+    /// The data-matrix (can hold a new BaseMatrix or a pointer to external data
+    BaseMatrix& matrix_;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/eigen/Vector.hpp b/src/amdis/linearalgebra/eigen/Vector.hpp
new file mode 100644
index 00000000..bf90649a
--- /dev/null
+++ b/src/amdis/linearalgebra/eigen/Vector.hpp
@@ -0,0 +1,95 @@
+#pragma once
+
+#include <Eigen/Dense>
+
+#include <dune/common/ftraits.hh>
+
+#include <amdis/Output.hpp>
+#include <amdis/linearalgebra/VectorInserter.hpp>
+#include <amdis/linearalgebra/VectorWrapper.hpp>
+
+namespace AMDiS
+{
+  /// The basic container that stores a base vector data
+  template <class ValueType>
+  class VectorInserter<Eigen::Matrix<ValueType, Eigen::Dynamic, 1>>
+      : public VectorInserterBase<VectorInserter<Eigen::Matrix<ValueType, Eigen::Dynamic, 1>>>
+  {
+  public:
+    /// The type of the elements of the DOFVector
+    using value_type = ValueType;
+    using field_type = typename Dune::FieldTraits<ValueType>::field_type;
+
+    /// The type of the base vector
+    using BaseVector = Eigen::Matrix<ValueType, Eigen::Dynamic, 1>;
+
+    /// The index/size - type
+    using size_type  = typename BaseVector::Index;
+
+  public:
+    /// Constructor. Constructs new BaseVector.
+    VectorInserter(BaseVector& vector, bool rebuild)
+      : vector_(vector)
+    {
+      if (rebuild)
+        vector_.setZero();
+    }
+
+    /// Access the entry \p i of the \ref vector with write-access.
+    template <class MultiIndex, class Assigner>
+    void insert_impl(MultiIndex const& idx, value_type const& value, Assigner assign)
+    {
+      size_type i = *idx;
+      test_exit_dbg(i < vector_.size(),
+        "Index {} out of range [0,{})", i, vector_.size());
+      assign(value, vector_.coeffRef(i));
+    }
+
+  private:
+    /// The data-vector
+    BaseVector& vector_;
+  };
+
+
+  /// The basic container that stores a base vector data
+  template <class ValueType>
+  class VectorWrapper<Eigen::Matrix<ValueType, Eigen::Dynamic, 1>>
+      : public VectorWrapperBase<VectorWrapper<Eigen::Matrix<ValueType, Eigen::Dynamic, 1>>>
+  {
+  public:
+    /// The type of the elements of the DOFVector
+    using value_type = ValueType;
+    using field_type = typename Dune::FieldTraits<ValueType>::field_type;
+
+    /// The type of the base vector
+    using BaseVector = Eigen::Matrix<ValueType, Eigen::Dynamic, 1>;
+
+    /// The index/size - type
+    using size_type  = typename BaseVector::Index;
+
+  public:
+    /// Constructor. Constructs new BaseVector.
+    VectorWrapper(BaseVector& vector)
+      : vector_(vector)
+    {}
+
+    /// Resize the \ref vector_ to the size \p s
+    template <class SizeProvider>
+    void resize_impl(SizeProvider const& sizeProvider, typename SizeProvider::SizePrefix prefix)
+    {
+      size_type size = sizeProvider.size(prefix);
+      assert(size > 0);
+      vector_.resize(size);
+    }
+
+    void set_impl(field_type value)
+    {
+      vector_.setConstant(value);
+    }
+
+  private:
+    /// The data-vector
+    BaseVector& vector_;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp b/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
index b9808474..96f2b09c 100644
--- a/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
+++ b/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
@@ -18,9 +18,9 @@ namespace AMDiS
   struct ISTLPreconCreator
       : public ISTLPreconCreatorInterface<Matrix, typename Precon::domain_type, typename Precon::range_type>
   {
-    using Sol = typename Precon::domain_type;
-    using Rhs = typename Precon::range_type;
-    using Super = ISTLPreconCreatorInterface<Matrix, Sol, Rhs>;
+    using X = typename Precon::domain_type;
+    using Y = typename Precon::range_type;
+    using Super = ISTLPreconCreatorInterface<Matrix, X, Y>;
     using Self = ISTLPreconCreator;
 
     struct Creator : CreatorInterfaceName<Super>
@@ -37,7 +37,7 @@ namespace AMDiS
       Parameters::get(prefix + "->iterations", iter_);
     }
 
-    using PreconBase = Dune::Preconditioner<Sol, Rhs>;
+    using PreconBase = Dune::Preconditioner<X, Y>;
     std::unique_ptr<PreconBase> create(Matrix const& A) const override
     {
       return createImpl(A, Type<Precon>{});
@@ -50,16 +50,16 @@ namespace AMDiS
       return std::make_unique<P>(A, iter_, w_);
     }
 
-    std::unique_ptr<Dune::SeqILU<Matrix, Sol, Rhs>>
-    createImpl(Matrix const& A, Type<Dune::SeqILU<Matrix, Sol, Rhs>>) const
+    std::unique_ptr<Dune::SeqILU<Matrix, X, Y>>
+    createImpl(Matrix const& A, Type<Dune::SeqILU<Matrix, X, Y>>) const
     {
-      return std::make_unique<Dune::SeqILU<Matrix, Sol, Rhs>>(A, iter_, w_);
+      return std::make_unique<Dune::SeqILU<Matrix, X, Y>>(A, iter_, w_);
     }
 
-    std::unique_ptr<Dune::Richardson<Sol, Rhs>>
-    createImpl(Matrix const& /*A*/, Type<Dune::Richardson<Sol, Rhs>>) const
+    std::unique_ptr<Dune::Richardson<X, Y>>
+    createImpl(Matrix const& /*A*/, Type<Dune::Richardson<X, Y>>) const
     {
-      return std::make_unique<Dune::Richardson<Sol, Rhs>>(w_);
+      return std::make_unique<Dune::Richardson<X, Y>>(w_);
     }
 
     double w_ = 1.0;
@@ -70,52 +70,52 @@ namespace AMDiS
   /// Adds default creators for linear solvers based on `Dune::BCRSMatrix`.
   /**
    * Adds creators for full-matrix aware solvers.
-   * - *cg*: conjugate gradient method, \see Dune::CGSolver
-   * - *bcgs*: stabilized bi-conjugate gradient method, \see Dune::BiCGSTABSolver
-   * - *minres*: Minimal residul method, \see Dune::MINRESSolver
-   * - *gmres*: Generalized minimal residula method, \see Dune::RestartedGMResSolver
+   * - *cg*: conjugate gradient method, \see Dune::CGXver
+   * - *bcgs*: stabilized bi-conjugate gradient method, \see Dune::BiCGSTABXver
+   * - *minres*: Minimal residul method, \see Dune::MINRESXver
+   * - *gmres*: Generalized minimal residula method, \see Dune::RestartedGMResXver
    * - *umfpack*: external UMFPACK solver, \see Dune::UMFPack
    **/
-  template <class B, class A, class Sol, class Rhs>
-  class DefaultCreators<ISTLPreconCreatorInterface<Dune::BCRSMatrix<B,A>, Sol, Rhs>>
+  template <class B, class A, class X, class Y>
+  class DefaultCreators<ISTLPreconCreatorInterface<Dune::BCRSMatrix<B,A>, X, Y>>
   {
-    using Mat = Dune::BCRSMatrix<B,A>;
+    using Matrix = Dune::BCRSMatrix<B,A>;
 
     template <class Precon>
     using PreconCreator
       = typename ISTLPreconCreator<Precon, Mat>::Creator;
 
-    using Map = CreatorMap<ISTLPreconCreatorInterface<Mat, Sol, Rhs>>;
+    using Map = CreatorMap<ISTLPreconCreatorInterface<Matrix, X, Y>>;
 
   public:
     static void init()
     {
-      auto jacobi = new PreconCreator<Dune::SeqJac<Mat, Sol, Rhs>>;
+      auto jacobi = new PreconCreator<Dune::SeqJac<Matrix, X, Y>>;
       Map::addCreator("diag", jacobi);
       Map::addCreator("jacobi", jacobi);
 
-      auto gs = new PreconCreator<Dune::SeqGS<Mat, Sol, Rhs>>;
+      auto gs = new PreconCreator<Dune::SeqGS<Matrix, X, Y>>;
       Map::addCreator("gs", gs);
       Map::addCreator("gauss_seidel", gs);
 
-      auto sor = new PreconCreator<Dune::SeqSOR<Mat, Sol, Rhs>>;
+      auto sor = new PreconCreator<Dune::SeqSOR<Matrix, X, Y>>;
       Map::addCreator("sor", sor);
 
-      auto ssor = new PreconCreator<Dune::SeqSSOR<Mat, Sol, Rhs>>;
+      auto ssor = new PreconCreator<Dune::SeqSSOR<Matrix, X, Y>>;
       Map::addCreator("ssor", ssor);
 
-      init_ilu(std::is_arithmetic<typename Dune::FieldTraits<Mat>::field_type>{});
-      init_amg(std::is_same<typename Dune::FieldTraits<Mat>::real_type, double>{});
-
-      auto richardson = new PreconCreator<Dune::Richardson<Sol, Rhs>>;
+      auto richardson = new PreconCreator<Dune::Richardson<X, Y>>;
       Map::addCreator("richardson", richardson);
       Map::addCreator("default", richardson);
+
+      init_ilu(std::is_arithmetic<typename Dune::FieldTraits<Matrix>::field_type>{});
+      init_amg(std::is_same<typename Dune::FieldTraits<Matrix>::real_type, double>{});
     }
 
     static void init_ilu(std::false_type) {}
     static void init_ilu(std::true_type)
     {
-      auto ilu = new PreconCreator<Dune::SeqILU<Mat, Sol, Rhs>>;
+      auto ilu = new PreconCreator<Dune::SeqILU<Matrix, Sol, Rhs>>;
       Map::addCreator("ilu", id(ilu));
       Map::addCreator("ilu0", id(ilu));
     }
@@ -123,16 +123,16 @@ namespace AMDiS
     static void init_amg(std::false_type) {}
     static void init_amg(std::true_type)
     {
-      auto amg = new AMGPreconCreator<Dune::Amg::AMG, Mat, Sol, Rhs>;
+      auto amg = new AMGPreconCreator<Dune::Amg::AMG, Matrix, Sol, Rhs>;
       Map::addCreator("amg", amg);
-      auto fastamg = new AMGPreconCreator<Dune::Amg::FastAMG, Mat, Sol, Rhs>;
+      auto fastamg = new AMGPreconCreator<Dune::Amg::FastAMG, Matrix, X, Y>;
       Map::addCreator("fastamg", fastamg);
     }
 
   };
 
-  template <class BlockMatrix, class VectorX, class VectorB>
-  class DefaultCreators<ISTLPreconInterface<BlockMatrix, VectorX, VectorB>>
+  template <class BlockMatrix, class X, class Y>
+  class DefaultCreators<ISTLPreconCreatorInterface<BlockMatrix, X, Y>>
   {
     using Matrix = BlockMatrix;
 
@@ -140,30 +140,30 @@ namespace AMDiS
     using PreconCreator
       = typename ISTLPrecon<Precon, Matrix>::Creator;
 
-    using Map = CreatorMap<ISTLPreconInterface<Matrix, VectorX, VectorB>>;
+    using Map = CreatorMap<ISTLPreconCreatorInterface<Matrix, X, Y>>;
 
   public:
     static void init()
     {
-      // auto jacobi = new PreconCreator<Dune::SeqJac<Matrix, VectorX, VectorB>>;
+      // auto jacobi = new PreconCreator<Dune::SeqJac<Matrix, X, Y>>;
       // Map::addCreator("diag", jacobi);
       // Map::addCreator("jacobi", jacobi);
 
-      // auto gs = new PreconCreator<Dune::SeqGS<Matrix, VectorX, VectorB>>;
+      // auto gs = new PreconCreator<Dune::SeqGS<Matrix, X, Y>>;
       // Map::addCreator("gs", gs);
       // Map::addCreator("gauss_seidel", gs);
 
-      // auto sor = new PreconCreator<Dune::SeqSOR<Matrix, VectorX, VectorB>>;
+      // auto sor = new PreconCreator<Dune::SeqSOR<Matrix, X, Y>>;
       // Map::addCreator("sor", sor);
 
-      // auto ssor = new PreconCreator<Dune::SeqSSOR<Matrix, VectorX, VectorB>>;
+      // auto ssor = new PreconCreator<Dune::SeqSSOR<Matrix, X, Y>>;
       // Map::addCreator("ssor", ssor);
 
-      // auto ilu = new PreconCreator<Dune::SeqILU<Matrix, VectorX, VectorB>>;
+      // auto ilu = new PreconCreator<Dune::SeqILU<Matrix, X, Y>>;
       // Map::addCreator("ilu", ilu);
       // Map::addCreator("ilu0", ilu);
 
-      auto richardson = new PreconCreator<Dune::Richardson<VectorX, VectorB>>;
+      auto richardson = new PreconCreator<Dune::Richardson<X, Y>>;
       Map::addCreator("richardson", richardson);
       Map::addCreator("default", richardson);
     }
diff --git a/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp b/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp
index aa4e8675..3f0d5586 100644
--- a/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp
+++ b/src/amdis/linearalgebra/istl/MatrixVectorTraits.hpp
@@ -12,7 +12,6 @@
 
 #include <amdis/linearalgebra/MatrixVectorTraits.hpp>
 #include <amdis/linearalgebra/istl/BCRSMatrix.hpp>
-#include <amdis/linearalgebra/istl/SingleRowColMatrix.hpp>
 
 namespace AMDiS
 {
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 947b937a..7552e25f 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -104,6 +104,11 @@ dune_add_test(SOURCES TreeContainerTest.cpp
 dune_add_test(SOURCES TypeTraitsTest.cpp
   LINK_LIBRARIES amdis)
 
+if (NOT HAVE_MTL)
+  dune_add_test(SOURCES MatrixTest.cpp
+    LINK_LIBRARIES amdis)
+endif ()
+
 if (NOT HAVE_MTL AND NOT HAVE_EIGEN)
   dune_add_test(SOURCES MatrixTest.cpp
     LINK_LIBRARIES amdis)
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index 6279c86d..602bccce 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -100,6 +100,7 @@ void test1(BasisTester& tester)
 
   AMDIS_TEST(matrixWrapper(matrix_data).nnz() >= 16u);
 
+#if !HAVE_EIGEN
   AMDIS_TEST_EQ(matrix_data[0][0][0][0], 1.0);
   AMDIS_TEST_EQ(matrix_data[0][0][0][1], 2.0);
   AMDIS_TEST_EQ(matrix_data[0][1][0][0], 3.0);
@@ -116,21 +117,26 @@ void test1(BasisTester& tester)
   AMDIS_TEST_EQ(matrix_data[1][0][1][1], 14.0);
   AMDIS_TEST_EQ(matrix_data[1][1][1][0], 15.0);
   AMDIS_TEST_EQ(matrix_data[1][1][1][1], 16.0);
+#endif
 
+#if !HAVE_EIGEN
   std::cout << "\n";
   std::cout << matrix_data[0][0] << "\n";
   std::cout << matrix_data[0][1] << "\n";
   std::cout << matrix_data[1][0] << "\n";
   std::cout << matrix_data[1][1] << "\n";
+#endif
 
   std::cout << "clear_row...\n";
   matrixWrapper(matrix_data).clear_row(idx01);
   matrixWrapper(matrix_data).clear_row(idx02);
 
+#if !HAVE_EIGEN
   std::cout << matrix_data[0][0] << "\n";
   std::cout << matrix_data[0][1] << "\n";
   std::cout << matrix_data[1][0] << "\n";
   std::cout << matrix_data[1][1] << "\n";
+#endif
 }
 
 template <class Traits, class BasisTester>
@@ -201,6 +207,7 @@ void test5(BasisTester& tester)
     auto inserter = matrixInserter(matrix,matrixIndexSet,true);
   }
 
+
   std::cout << "\n";
   // velocity blocks
   printType(matrix[_0][_0]);
@@ -227,9 +234,13 @@ int main(int argc, char** argv)
 
   TaylorHoodBases<2> tester{};
 
-  auto traits = std::make_tuple(DefaultMatrixVectorTraits{}, StdTraits{}, ISTLTraits{}
+  auto traits = std::make_tuple(DefaultMatrixVectorTraits{}, StdTraits{}
 #if HAVE_MTL
     , MTLTraits{}
+#elif HAVE_EIGEN
+    , EigenTraits<>{}
+#else
+    , ISTLTraits{}
 #endif
     );
 
@@ -237,10 +248,14 @@ int main(int argc, char** argv)
     using Traits = TYPEOF(t);
 
     test1<Traits>(tester);
+#if !HAVE_EIGEN
     test2<Traits>(tester);
+#endif
     // test3<Traits>(tester);
     // test4<Traits>(tester);
+#if !HAVE_EIGEN
     test5<Traits>(tester);
+#endif
     // test6<Traits>(tester);
   });
 
-- 
GitLab


From 447c985741714b1bfff474020552607a26643b43 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Fri, 26 Apr 2019 22:17:14 +0200
Subject: [PATCH 29/38] cleanup after merge and eigen implementation

---
 examples/PfcPrecon.hpp                         | 18 +++++++++---------
 .../linearalgebra/SingleRowColMatrix.inc.hpp   | 12 ++++++------
 .../linearalgebra/istl/ISTL_Preconditioner.hpp |  4 ++--
 test/CMakeLists.txt                            |  3 ---
 4 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/examples/PfcPrecon.hpp b/examples/PfcPrecon.hpp
index 85d0fddc..095c830b 100644
--- a/examples/PfcPrecon.hpp
+++ b/examples/PfcPrecon.hpp
@@ -135,21 +135,21 @@ private:
 
 
 template <class M, class X, class Y>
-struct ISTLPrecon<PfcPrecon<M,X,Y>, M>
-    : public ISTLPreconInterface<M,X,Y>
+struct ISTLPreconCreator<PfcPrecon<M,X,Y>, M>
+    : public ISTLPreconCreatorInterface<M,X,Y>
 {
-  using Super = ISTLPreconInterface<M,X,Y>;
+  using Super = ISTLPreconCreatorInterface<M,X,Y>;
   using Precon = PfcPrecon<M,X,Y>;
-  using Self = ISTLPrecon;
+  using Self = ISTLPreconCreator;
 
   struct Creator
-      : public CreatorInterfaceName<ISTLPreconInterface<M,X,Y>>
+      : public CreatorInterfaceName<ISTLPreconCreatorInterface<M,X,Y>>
   {
     Creator(double const& tau)
       : tau_(&tau)
     {}
 
-    std::unique_ptr<ISTLPreconInterface<M,X,Y>> createWithString(std::string /*prefix*/) override
+    std::unique_ptr<ISTLPreconCreatorInterface<M,X,Y>> createWithString(std::string /*prefix*/) override
     {
       return std::make_unique<Self>(*tau_);
     }
@@ -157,7 +157,7 @@ struct ISTLPrecon<PfcPrecon<M,X,Y>, M>
     double const* tau_;
   };
 
-  ISTLPrecon(double const& tau)
+  ISTLPreconCreator(double const& tau)
     : tau_(&tau)
   {}
 
@@ -180,8 +180,8 @@ inline void registerPfcPrecon(Basis const& basis, double const& tau)
   using M = MatrixGenerator_t<double,ISTLTraits,B,B>;
   using X = VectorGenerator_t<double,ISTLTraits,B>;
 
-  auto pfcPrecon = new typename ISTLPrecon<PfcPrecon<M,X,X>, M>::Creator(tau);
-  CreatorMap<ISTLPreconInterface<M,X,X>>::addCreator("pfc", pfcPrecon);
+  auto pfcPrecon = new typename ISTLPreconCreator<PfcPrecon<M,X,X>, M>::Creator(tau);
+  CreatorMap<ISTLPreconCreatorInterface<M,X,X>>::addCreator("pfc", pfcPrecon);
 }
 
 
diff --git a/src/amdis/linearalgebra/SingleRowColMatrix.inc.hpp b/src/amdis/linearalgebra/SingleRowColMatrix.inc.hpp
index 3973f93b..4c3b8629 100644
--- a/src/amdis/linearalgebra/SingleRowColMatrix.inc.hpp
+++ b/src/amdis/linearalgebra/SingleRowColMatrix.inc.hpp
@@ -26,13 +26,13 @@ namespace AMDiS
     template <size_type I0 = 0, class Mat>
     static constexpr auto row_range(Mat const& mat)
     {
-      auto rows = hybridNumRows(std::declval<Mat>());
-      return Dune::Hybrid::ifElse(std::is_integral<decltype(rows)>{},
+      auto rows = hybridNumRows(mat);
+      return Dune::Hybrid::ifElse(std::is_integral<TYPEOF(rows)>{},
         [&](auto id) {
           return Dune::IntegralRange<size_type>{I0, size_type(rows)};
         },
         [&](auto id) {
-          return Dune::StaticIntegralRange<size_type,rows.value,I0>{};
+          return Dune::StaticIntegralRange<size_type,VALUE(id(rows)),I0>{};
         });
     }
 
@@ -168,13 +168,13 @@ namespace AMDiS
     template <size_type I0 = 0, class Mat>
     static constexpr auto col_range(Mat const& mat)
     {
-      auto cols = hybridNumCols(std::declval<Mat>());
-      return Dune::Hybrid::ifElse(std::is_integral<decltype(cols)>{},
+      auto cols = hybridNumCols(mat);
+      return Dune::Hybrid::ifElse(std::is_integral<TYPEOF(cols)>{},
         [&](auto id) {
           return Dune::IntegralRange<size_type>{I0, size_type(cols)};
         },
         [&](auto id) {
-          return Dune::StaticIntegralRange<size_type,cols.value,I0>{};
+          return Dune::StaticIntegralRange<size_type,VALUE(id(cols)),I0>{};
         });
     }
 
diff --git a/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp b/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
index 96f2b09c..190a93ae 100644
--- a/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
+++ b/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
@@ -83,7 +83,7 @@ namespace AMDiS
 
     template <class Precon>
     using PreconCreator
-      = typename ISTLPreconCreator<Precon, Mat>::Creator;
+      = typename ISTLPreconCreator<Precon, Matrix>::Creator;
 
     using Map = CreatorMap<ISTLPreconCreatorInterface<Matrix, X, Y>>;
 
@@ -138,7 +138,7 @@ namespace AMDiS
 
     template <class Precon>
     using PreconCreator
-      = typename ISTLPrecon<Precon, Matrix>::Creator;
+      = typename ISTLPreconCreator<Precon, Matrix>::Creator;
 
     using Map = CreatorMap<ISTLPreconCreatorInterface<Matrix, X, Y>>;
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 7552e25f..abc9c1a6 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -110,9 +110,6 @@ if (NOT HAVE_MTL)
 endif ()
 
 if (NOT HAVE_MTL AND NOT HAVE_EIGEN)
-  dune_add_test(SOURCES MatrixTest.cpp
-    LINK_LIBRARIES amdis)
-
   dune_add_test(SOURCES VectorTest.cpp
     LINK_LIBRARIES amdis)
 
-- 
GitLab


From ca0a4f619442a9f1f1e490d211e5f64c667cb752 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 1 May 2019 14:29:35 +0200
Subject: [PATCH 30/38] added elementwise operations to vector

---
 examples/init/stokes.dat.2d                   |  2 +-
 src/amdis/DirichletBC.inc.hpp                 |  2 +-
 src/amdis/gridfunctions/DOFVectorView.hpp     | 15 +++++----
 src/amdis/linearalgebra/DOFVectorBase.hpp     | 11 ++++---
 src/amdis/linearalgebra/DOFVectorBase.inc.hpp | 24 +++++++-------
 src/amdis/linearalgebra/VectorWrapper.hpp     |  4 +--
 src/amdis/linearalgebra/VectorWrapper.inc.hpp | 32 +++++++++++++++++++
 src/amdis/linearalgebra/VectorWrapperBase.hpp | 17 ++++++++++
 src/amdis/linearalgebra/eigen/DOFVector.hpp   |  6 ++--
 src/amdis/linearalgebra/eigen/Vector.hpp      | 18 +++++++++++
 src/amdis/linearalgebra/istl/DOFVector.hpp    |  6 ++--
 src/amdis/linearalgebra/mtl/DOFVector.hpp     |  6 ++--
 src/amdis/linearalgebra/mtl/MtlVector.hpp     | 18 +++++++++++
 13 files changed, 125 insertions(+), 36 deletions(-)

diff --git a/examples/init/stokes.dat.2d b/examples/init/stokes.dat.2d
index 68a8b329..53d92c96 100644
--- a/examples/init/stokes.dat.2d
+++ b/examples/init/stokes.dat.2d
@@ -1,4 +1,4 @@
-stokesMesh->global refinements: 7
+stokesMesh->global refinements: 4
 stokesMesh->dimension: 1.0 1.0
 stokesMesh->num cells: 4 4
 
diff --git a/src/amdis/DirichletBC.inc.hpp b/src/amdis/DirichletBC.inc.hpp
index 2c6baf22..666cdceb 100644
--- a/src/amdis/DirichletBC.inc.hpp
+++ b/src/amdis/DirichletBC.inc.hpp
@@ -69,7 +69,7 @@ fillBoundaryCondition(Mat& matrix, Sol& solution, Rhs& rhs, RN const& rowNode, R
 
   // create indicator for interpolation
   BitVector<typename Mat::RowBlocking> bitVector;
-  vectorWrapper(bitVector).resize(matrix.rowBasis());
+  vectorWrapper(bitVector).resize(*matrix.rowBasis());
   for (auto const& node : dirichletNodes_)
     Dune::Functions::resolveDynamicMultiIndex(bitVector,node) = 1;
 
diff --git a/src/amdis/gridfunctions/DOFVectorView.hpp b/src/amdis/gridfunctions/DOFVectorView.hpp
index 8a443e2f..c737c9e2 100644
--- a/src/amdis/gridfunctions/DOFVectorView.hpp
+++ b/src/amdis/gridfunctions/DOFVectorView.hpp
@@ -56,15 +56,18 @@ namespace AMDiS
       auto&& gridFct = makeGridFunction(FWD(expr), basis.gridView());
 
       if (std::is_same<Tag, tag::average>::value) {
-        thread_local std::vector<std::uint8_t> counter;
-        counter.clear();
+        using Traits = typename DOFVector<GB,VT>::Traits;
+        using Blocking = Blocking_t<GB>;
+        thread_local VectorGenerator_t<std::uint8_t, Traits, Blocking> counter;
+        vectorWrapper(counter).set(0);
         AMDiS::interpolate(basis, treePath, coefficients(), counter, FWD(gridFct), std::true_type{});
 
         auto& coeff = coefficients().vector();
-        for (std::size_t i = 0; i < counter.size(); ++i) {
-          if (counter[i] > 0)
-            coeff[i] /= double(counter[i]);
-        }
+        vectorWrapper(coeff).elementwise(counter, [](auto const& num, auto& c) -> void
+        {
+          if (num > 0)
+            c /= double(num);
+        });
       } else {
         AMDiS::interpolate(basis, treePath, coefficients(), FWD(gridFct));
       }
diff --git a/src/amdis/linearalgebra/DOFVectorBase.hpp b/src/amdis/linearalgebra/DOFVectorBase.hpp
index 33fbcc04..dc444d8d 100644
--- a/src/amdis/linearalgebra/DOFVectorBase.hpp
+++ b/src/amdis/linearalgebra/DOFVectorBase.hpp
@@ -54,10 +54,10 @@ namespace AMDiS
    * to a global basis.
    *
    * \tparam GB  Basis of the vector
-   * \tparam Traits  A linear algebra backend implementing the storage and operations.
+   * \tparam TR  A linear algebra backend implementing the storage and operations.
    * \tparam K   The field-type
    **/
-  template <class GB, class Traits, class K = double>
+  template <class GB, class TR, class K = double>
   class DOFVectorBase
       : public DOFVectorInterface
   {
@@ -67,20 +67,21 @@ namespace AMDiS
   public:
     /// The type of the functionspace basis associated to this vector
     using GlobalBasis = GB;
-    using LocalView = typename GB::LocalView;
+    using Traits = TR;
 
+    using LocalView = typename GlobalBasis::LocalView;
     using Element = typename LocalView::Element;
     using Geometry = typename Element::Geometry;
 
     /// The index/size - type
-    using size_type  = typename GB::size_type;
+    using size_type  = typename GlobalBasis::size_type;
 
     /// The type of the elements of the DOFVector
     using field_type = typename Dune::FieldTraits<K>::field_type;
     using value_type = K;
 
     /// The type of the data vector used in the backend
-    using BaseVector = VectorGenerator_t<K,Traits,Blocking>;
+    using BaseVector = VectorGenerator_t<K,TR,Blocking>;
     using Inserter = VectorInserter<BaseVector>;
 
     /// The type of the vector filled on an element with local contributions
diff --git a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
index d5bf992d..eb36299e 100644
--- a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
@@ -11,8 +11,8 @@
 
 namespace AMDiS {
 
-template <class GB, class T, class K>
-void DOFVectorBase<GB,T,K>::
+template <class GB, class TR, class K>
+void DOFVectorBase<GB,TR,K>::
 init(bool rebuild)
 {
   resize();
@@ -23,8 +23,8 @@ init(bool rebuild)
 }
 
 
-template <class GB, class T, class K>
-void DOFVectorBase<GB,T,K>::
+template <class GB, class TR, class K>
+void DOFVectorBase<GB,TR,K>::
 finish()
 {
   delete inserter_;
@@ -32,8 +32,8 @@ finish()
 }
 
 
-template <class GB, class T, class K>
-void DOFVectorBase<GB,T,K>::
+template <class GB, class TR, class K>
+void DOFVectorBase<GB,TR,K>::
 insert(LocalView const& localView, ElementVector const& elementVector)
 {
   using std::abs;
@@ -46,9 +46,9 @@ insert(LocalView const& localView, ElementVector const& elementVector)
 }
 
 
-template <class GB, class T, class K>
+template <class GB, class TR, class K>
   template <class ContextTag, class Expr, class TreePath>
-void DOFVectorBase<GB,T,K>::
+void DOFVectorBase<GB,TR,K>::
 addOperator(ContextTag contextTag, Expr const& expr, TreePath path)
 {
   static_assert( Concepts::PreTreePath<TreePath>,
@@ -65,8 +65,8 @@ addOperator(ContextTag contextTag, Expr const& expr, TreePath path)
 }
 
 
-template <class GB, class T, class K>
-void DOFVectorBase<GB,T,K>::
+template <class GB, class TR, class K>
+void DOFVectorBase<GB,TR,K>::
 assemble(LocalView const& localView)
 {
   elementVector_ = 0;
@@ -87,8 +87,8 @@ assemble(LocalView const& localView)
 }
 
 
-template <class GB, class T, class K>
-void DOFVectorBase<GB,T,K>::
+template <class GB, class TR, class K>
+void DOFVectorBase<GB,TR,K>::
 assemble()
 {
   auto localView = basis_->localView();
diff --git a/src/amdis/linearalgebra/VectorWrapper.hpp b/src/amdis/linearalgebra/VectorWrapper.hpp
index 70c40dae..a87a8d9b 100644
--- a/src/amdis/linearalgebra/VectorWrapper.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.hpp
@@ -46,8 +46,8 @@ namespace AMDiS
   } // end namespace Impl
 
 
-  /// \brief Generic implementation of a vector wrapper that provides the \ref resize(), \ref init(),
-  /// \ref finish(), \ref insert() and \ref set() methods.
+  /// \brief Generic implementation of a vector wrapper that provides the \ref resize(),
+  /// \ref elementwise() and \ref set() methods.
   /**
    * Select a Vector wrapper using the \ref VectorWrapperSelector, especially the \ref VectorWrapperImpl.
    * This class implements a \ref VectorWrapperBase.
diff --git a/src/amdis/linearalgebra/VectorWrapper.inc.hpp b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
index ca4c7b42..57c782bd 100644
--- a/src/amdis/linearalgebra/VectorWrapper.inc.hpp
+++ b/src/amdis/linearalgebra/VectorWrapper.inc.hpp
@@ -27,6 +27,20 @@ namespace AMDiS
       scalar_ = value;
     }
 
+    /// Implements \ref VectorWrapperBase::elementwise
+    template <class Operation>
+    void elementwise_impl(Operation op)
+    {
+      op(scalar_);
+    }
+
+    /// Implements \ref VectorWrapperBase::elementwise
+    template <class Other, class Operation>
+    void elementwise_impl(Other const& other, Operation binary_op)
+    {
+      binary_op(other, scalar_);
+    }
+
   private:
     Scalar& scalar_;
   };
@@ -66,6 +80,24 @@ namespace AMDiS
       });
     }
 
+    /// Implements \ref VectorWrapperBase::elementwise
+    template <class Operation>
+    void elementwise_impl(Operation op)
+    {
+      Dune::Hybrid::forEach(vector_, [&](auto& v) -> void {
+        vectorWrapper(v).elementwise(op);
+      });
+    }
+
+    /// Implements \ref VectorWrapperBase::elementwise
+    template <class Vector, class Operation>
+    void elementwise_impl(Vector const& other, Operation binary_op)
+    {
+      Dune::Hybrid::forEach(hybridElements(vector_), [&](auto i) -> void {
+        vectorWrapper(vector_[i]).elementwise(other[i], binary_op);
+      });
+    }
+
   private:
     BaseVector& vector_;
   };
diff --git a/src/amdis/linearalgebra/VectorWrapperBase.hpp b/src/amdis/linearalgebra/VectorWrapperBase.hpp
index 4024ad07..bc25d349 100644
--- a/src/amdis/linearalgebra/VectorWrapperBase.hpp
+++ b/src/amdis/linearalgebra/VectorWrapperBase.hpp
@@ -31,6 +31,20 @@ namespace AMDiS
       asImpl().resize_impl(sizeProvider,prefix);
     }
 
+    /// An elementwise operation applied to the this vector
+    template <class Operation>
+    void elementwise(Operation op)
+    {
+      asImpl().elementwise_impl(op);
+    }
+
+    /// An elementwise operation applied to the pair (this,other)
+    template <class Vector, class Operation>
+    void elementwise(Vector const& other, Operation binary_op)
+    {
+      asImpl().elementwise_impl(other,binary_op);
+    }
+
     /// Set all entries to value
     template <class ValueType>
     void set(ValueType const& value)
@@ -46,6 +60,9 @@ namespace AMDiS
     template <class... Args>
     void set_impl(Args&&...) { /* do nothing */ }
 
+    template <class... Args>
+    void elementwise_impl(Args&&...) { /* do nothing */ }
+
   private:
     Impl& asImpl() { return static_cast<Impl&>(*this); }
   };
diff --git a/src/amdis/linearalgebra/eigen/DOFVector.hpp b/src/amdis/linearalgebra/eigen/DOFVector.hpp
index bc9346f9..9e38d27e 100644
--- a/src/amdis/linearalgebra/eigen/DOFVector.hpp
+++ b/src/amdis/linearalgebra/eigen/DOFVector.hpp
@@ -5,10 +5,10 @@
 
 namespace AMDiS
 {
-  template <class BasisType, class ValueType = double>
-  class DOFVector : public DOFVectorBase<BasisType, EigenTraits<>, ValueType>
+  template <class GlobalBasis, class ValueType>
+  class DOFVector : public DOFVectorBase<GlobalBasis, EigenTraits<>, ValueType>
   {
-    using Super = DOFVectorBase<BasisType, EigenTraits<>, ValueType>;
+    using Super = DOFVectorBase<GlobalBasis, EigenTraits<>, ValueType>;
 
   public:
     DOFVector(std::shared_ptr<GlobalBasis> basis, DataTransferOperation op = DataTransferOperation::INTERPOLATE)
diff --git a/src/amdis/linearalgebra/eigen/Vector.hpp b/src/amdis/linearalgebra/eigen/Vector.hpp
index bf90649a..be25e533 100644
--- a/src/amdis/linearalgebra/eigen/Vector.hpp
+++ b/src/amdis/linearalgebra/eigen/Vector.hpp
@@ -82,11 +82,29 @@ namespace AMDiS
       vector_.resize(size);
     }
 
+    /// Implements \ref VectorWrapperBase::set
     void set_impl(field_type value)
     {
       vector_.setConstant(value);
     }
 
+    /// Implements \ref VectorWrapperBase::elementwise
+    template <class Operation>
+    void elementwise_impl(Operation op)
+    {
+      for (auto& v : vector_)
+        op(v);
+    }
+
+    /// Implements \ref VectorWrapperBase::elementwise
+    template <class Vector, class Operation>
+    void elementwise_impl(Vector const& other, Operation binary_op)
+    {
+      assert(vector_.size() == other.size());
+      for (size_type i = 0; i < vector_.size(); ++i)
+        binary_op(other[i], vector_[i]);
+    }
+
   private:
     /// The data-vector
     BaseVector& vector_;
diff --git a/src/amdis/linearalgebra/istl/DOFVector.hpp b/src/amdis/linearalgebra/istl/DOFVector.hpp
index 42a51917..028d2ed5 100644
--- a/src/amdis/linearalgebra/istl/DOFVector.hpp
+++ b/src/amdis/linearalgebra/istl/DOFVector.hpp
@@ -5,10 +5,10 @@
 
 namespace AMDiS
 {
-  template <class BasisType, class ValueType = double>
-  class DOFVector : public DOFVectorBase<BasisType, ISTLTraits>
+  template <class GlobalBasis, class ValueType>
+  class DOFVector : public DOFVectorBase<GlobalBasis, ISTLTraits, ValueType>
   {
-    using Super = DOFVectorBase<BasisType, ISTLTraits, ValueType>;
+    using Super = DOFVectorBase<GlobalBasis, ISTLTraits, ValueType>;
 
   public:
     DOFVector(std::shared_ptr<GlobalBasis> basis, DataTransferOperation op = DataTransferOperation::INTERPOLATE)
diff --git a/src/amdis/linearalgebra/mtl/DOFVector.hpp b/src/amdis/linearalgebra/mtl/DOFVector.hpp
index cfdc71a5..aa1a666c 100644
--- a/src/amdis/linearalgebra/mtl/DOFVector.hpp
+++ b/src/amdis/linearalgebra/mtl/DOFVector.hpp
@@ -5,10 +5,10 @@
 
 namespace AMDiS
 {
-  template <class BasisType, class ValueType = double>
-  class DOFVector : public DOFVectorBase<BasisType, MTLTraits, ValueType>
+  template <class GlobalBasis, class ValueType>
+  class DOFVector : public DOFVectorBase<GlobalBasis, MTLTraits, ValueType>
   {
-    using Super = DOFVectorBase<BasisType, MTLTraits>;
+    using Super = DOFVectorBase<GlobalBasis, MTLTraits, ValueType>;
 
   public:
     DOFVector(std::shared_ptr<GlobalBasis> basis, DataTransferOperation op = DataTransferOperation::INTERPOLATE)
diff --git a/src/amdis/linearalgebra/mtl/MtlVector.hpp b/src/amdis/linearalgebra/mtl/MtlVector.hpp
index b1d9023d..8eed088b 100644
--- a/src/amdis/linearalgebra/mtl/MtlVector.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlVector.hpp
@@ -88,11 +88,29 @@ namespace AMDiS
       vector_.change_dim(size);
     }
 
+    /// Implements \ref VectorWrapperBase::set
     void set_impl(field_type value)
     {
       vector_ = value;
     }
 
+    /// Implements \ref VectorWrapperBase::elementwise
+    template <class Operation>
+    void elementwise_impl(Operation op)
+    {
+      for (auto& v : vector_)
+        op(v);
+    }
+
+    /// Implements \ref VectorWrapperBase::elementwise
+    template <class Vector, class Operation>
+    void elementwise_impl(Vector const& other, Operation binary_op)
+    {
+      assert(mtl::size(vector_) == mtl::size(other));
+      for (size_type i = 0; i < mtl::size(vector_); ++i)
+        binary_op(other[i], vector_[i]);
+    }
+
   private:
     /// The data-vector
     BaseVector& vector_;
-- 
GitLab


From eabf95adbb0344ee2f52db07e8bfa0174e8886ca Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 1 May 2019 14:52:56 +0200
Subject: [PATCH 31/38] rebase to master

---
 src/amdis/ProblemStatTraits.hpp               |  4 +-
 .../istl/ISTL_Preconditioner.hpp              |  4 +-
 src/amdis/linearalgebra/istl/ISTL_Solver.hpp  | 62 +++++++++----------
 3 files changed, 34 insertions(+), 36 deletions(-)

diff --git a/src/amdis/ProblemStatTraits.hpp b/src/amdis/ProblemStatTraits.hpp
index 6bd0c49b..f35d0879 100644
--- a/src/amdis/ProblemStatTraits.hpp
+++ b/src/amdis/ProblemStatTraits.hpp
@@ -57,10 +57,12 @@ namespace AMDiS
   } // end namespace Impl
 
   /// An Exemplar for ProblemStatTraits
-  template <class GlobalBasisType>
+  template <class GlobalBasisType, class T = double>
   struct DefaultProblemTraits
   {
     using GlobalBasis = GlobalBasisType;
+    using GridView = typename GlobalBasis::GridView;
+    using CoefficientType = T;
   };
 
 
diff --git a/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp b/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
index 190a93ae..a7fa12e9 100644
--- a/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
+++ b/src/amdis/linearalgebra/istl/ISTL_Preconditioner.hpp
@@ -115,7 +115,7 @@ namespace AMDiS
     static void init_ilu(std::false_type) {}
     static void init_ilu(std::true_type)
     {
-      auto ilu = new PreconCreator<Dune::SeqILU<Matrix, Sol, Rhs>>;
+      auto ilu = new PreconCreator<Dune::SeqILU<Matrix, X, Y>>;
       Map::addCreator("ilu", id(ilu));
       Map::addCreator("ilu0", id(ilu));
     }
@@ -123,7 +123,7 @@ namespace AMDiS
     static void init_amg(std::false_type) {}
     static void init_amg(std::true_type)
     {
-      auto amg = new AMGPreconCreator<Dune::Amg::AMG, Matrix, Sol, Rhs>;
+      auto amg = new AMGPreconCreator<Dune::Amg::AMG, Matrix, X, Y>;
       Map::addCreator("amg", amg);
       auto fastamg = new AMGPreconCreator<Dune::Amg::FastAMG, Matrix, X, Y>;
       Map::addCreator("fastamg", fastamg);
diff --git a/src/amdis/linearalgebra/istl/ISTL_Solver.hpp b/src/amdis/linearalgebra/istl/ISTL_Solver.hpp
index cd1ad859..23c8fc05 100644
--- a/src/amdis/linearalgebra/istl/ISTL_Solver.hpp
+++ b/src/amdis/linearalgebra/istl/ISTL_Solver.hpp
@@ -83,11 +83,11 @@ namespace AMDiS
   };
 #endif
 
-  template <class VectorX>
-  struct ISTLSolverCreator<Dune::GeneralizedPCGSolver<VectorX>, true>
-      : public ISTLSolverCreator<Dune::GeneralizedPCGSolver<VectorX>, false>
+  template <class X>
+  struct ISTLSolverCreator<Dune::GeneralizedPCGSolver<X>, true>
+      : public ISTLSolverCreator<Dune::GeneralizedPCGSolver<X>, false>
   {
-    using ISTLSolver = Dune::GeneralizedPCGSolver<VectorX>;
+    using ISTLSolver = Dune::GeneralizedPCGSolver<X>;
     using Super = ISTLSolverCreator<ISTLSolver, false>;
 
     ISTLSolverCreator(std::string const& prefix)
@@ -162,47 +162,47 @@ namespace AMDiS
    * - *umfpack*: external UMFPACK solver, \see Dune::UMFPack
    * - *superlu*: external SuperLU solver, \see Dune::SuperLU
    **/
-  template <class Block, class Alloc, class VectorX, class VectorB>
-  class DefaultCreators<LinearSolverInterface<Dune::BCRSMatrix<Block,Alloc>, VectorX, VectorB>>
+  template <class Block, class Alloc, class X, class Y>
+  class DefaultCreators<LinearSolverInterface<Dune::BCRSMatrix<Block,Alloc>, X, Y>>
   {
     using Matrix = Dune::BCRSMatrix<Block,Alloc>;
-    using SolverBase = LinearSolverInterface<Matrix, VectorX, VectorB>;
+    using SolverBase = LinearSolverInterface<Matrix, X, Y>;
 
     template <class Solver>
     using SolverCreator
-      = typename LinearSolver<Matrix, VectorX, VectorB,
-          ISTLRunner<Solver, Matrix, VectorX, VectorB>>::Creator;
+      = typename LinearSolver<Matrix, X, Y,
+          ISTLRunner<Solver, Matrix, X, Y>>::Creator;
 
     template <template <class M> class Solver>
     using DirectSolverCreator
-      = typename LinearSolver<Matrix, VectorX, VectorB,
-          DirectRunner<Solver, Matrix, VectorX, VectorB>>::Creator;
+      = typename LinearSolver<Matrix, X, Y,
+          DirectRunner<Solver, Matrix, X, Y>>::Creator;
 
     using Map = CreatorMap<SolverBase>;
 
   public:
     static void init()
     {
-      auto cg = new SolverCreator<Dune::CGSolver<VectorX>>;
+      auto cg = new SolverCreator<Dune::CGSolver<X>>;
       Map::addCreator("cg", cg);
 
-      auto bicgstab = new SolverCreator<Dune::BiCGSTABSolver<VectorX>>;
+      auto bicgstab = new SolverCreator<Dune::BiCGSTABSolver<X>>;
       Map::addCreator("bicgstab", bicgstab);
       Map::addCreator("bcgs", bicgstab);
 
-      auto minres = new SolverCreator<Dune::MINRESSolver<VectorX>>;
+      auto minres = new SolverCreator<Dune::MINRESSolver<X>>;
       Map::addCreator("minres", minres);
 
-      auto gmres = new SolverCreator<Dune::RestartedGMResSolver<VectorX>>;
+      auto gmres = new SolverCreator<Dune::RestartedGMResSolver<X,Y>>;
       Map::addCreator("gmres", gmres);
 
 #if DUNE_VERSION_GT(DUNE_ISTL,2,6)
-      auto fgmres = new SolverCreator<Dune::RestartedFlexibleGMResSolver<VectorX>>;
+      auto fgmres = new SolverCreator<Dune::RestartedFlexibleGMResSolver<X,Y>>;
       Map::addCreator("fgmres", fgmres);
 #endif
 
       // Generalized preconditioned conjugate gradient solver.
-      auto fcg = new SolverCreator<Dune::GeneralizedPCGSolver<VectorX>>;
+      auto fcg = new SolverCreator<Dune::GeneralizedPCGSolver<X>>;
       Map::addCreator("fcg", fcg);
 
       // default iterative solver
@@ -234,47 +234,43 @@ namespace AMDiS
   };
 
 
-  template <class BlockMatrix, class VectorX, class VectorB>
-  class DefaultCreators<LinearSolverInterface<BlockMatrix, VectorX, VectorB>>
+  /// Adds default creators for linear solvers based on dune block matrices
+  template <class BlockMatrix, class X, class Y>
+  class DefaultCreators<LinearSolverInterface<BlockMatrix, X, Y>>
   {
     using Matrix = BlockMatrix;
-    using SolverBase = LinearSolverInterface<Matrix, VectorX, VectorB>;
+    using SolverBase = LinearSolverInterface<Matrix, X, Y>;
 
     template <class ISTLSolver>
     using SolverCreator
-      = typename LinearSolver<Matrix, VectorX, VectorB,
-          ISTLRunner<ISTLSolver, Matrix, VectorX, VectorB>>::Creator;
-
-    template <class ISTLSolver>
-    using DirectSolverCreator
-      = typename LinearSolver<Matrix, VectorX, VectorB,
-          DirectRunner<ISTLSolver, Matrix, VectorX, VectorB>>::Creator;
+      = typename LinearSolver<Matrix, X, Y,
+          ISTLRunner<ISTLSolver, Matrix, X, Y>>::Creator;
 
     using Map = CreatorMap<SolverBase>;
 
   public:
     static void init()
     {
-      auto cg = new SolverCreator<Dune::CGSolver<VectorX>>;
+      auto cg = new SolverCreator<Dune::CGSolver<X>>;
       Map::addCreator("cg", cg);
 
-      auto bicgstab = new SolverCreator<Dune::BiCGSTABSolver<VectorX>>;
+      auto bicgstab = new SolverCreator<Dune::BiCGSTABSolver<X>>;
       Map::addCreator("bicgstab", bicgstab);
       Map::addCreator("bcgs", bicgstab);
 
-      auto minres = new SolverCreator<Dune::MINRESSolver<VectorX>>;
+      auto minres = new SolverCreator<Dune::MINRESSolver<X>>;
       Map::addCreator("minres", minres);
 
-      auto gmres = new SolverCreator<Dune::RestartedGMResSolver<VectorX>>;
+      auto gmres = new SolverCreator<Dune::RestartedGMResSolver<X,Y>>;
       Map::addCreator("gmres", gmres);
 
 #if DUNE_VERSION_GT(DUNE_ISTL,2,6)
-      auto fgmres = new SolverCreator<Dune::RestartedFlexibleGMResSolver<VectorX>>;
+      auto fgmres = new SolverCreator<Dune::RestartedFlexibleGMResSolver<X,Y>>;
       Map::addCreator("fgmres", fgmres);
 #endif
 
       // Generalized preconditioned conjugate gradient solver.
-      auto fcg = new SolverCreator<Dune::GeneralizedPCGSolver<VectorX>>;
+      auto fcg = new SolverCreator<Dune::GeneralizedPCGSolver<X>>;
       Map::addCreator("fcg", fcg);
 
       // default iterative solver
-- 
GitLab


From 6a24cbcdf4937bf35ff02aa10809bfb2e2ce203e Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Mon, 6 May 2019 11:03:00 +0200
Subject: [PATCH 32/38] rebase to master

---
 examples/init/pfc.dat.2d   | 2 +-
 examples/pfc1.cc           | 3 +--
 examples/pfc2.cc           | 3 +--
 examples/pfc3.cc           | 3 +--
 examples/stokes4.cc        | 3 +--
 test/BlockingTest.cpp      | 7 ++++---
 test/GeneratorsTest.cpp    | 2 +-
 test/MatrixTest.cpp        | 2 +-
 test/MatrixWrapperTest.cpp | 2 +-
 test/StokesTest.cpp        | 4 +---
 test/VectorTest.cpp        | 2 +-
 11 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/examples/init/pfc.dat.2d b/examples/init/pfc.dat.2d
index 11838b71..18571bf5 100644
--- a/examples/init/pfc.dat.2d
+++ b/examples/init/pfc.dat.2d
@@ -1,4 +1,4 @@
-pfcMesh->global refinements: 7
+pfcMesh->global refinements: 4
 pfcMesh->num cells: 4 4
 pfcMesh->dimension: 200 200
 
diff --git a/examples/pfc1.cc b/examples/pfc1.cc
index 41d91a82..0d3b7ff2 100644
--- a/examples/pfc1.cc
+++ b/examples/pfc1.cc
@@ -9,7 +9,7 @@ using namespace AMDiS;
 
 int main(int argc, char** argv)
 {
-  AMDiS::init(argc, argv);
+  Environment env(argc, argv);
 
   auto grid = MeshCreator<Dune::YaspGrid<2>>::create("pfcMesh");
 
@@ -106,6 +106,5 @@ int main(int argc, char** argv)
     prob.writeFiles(adaptInfo);
   }
 
-  AMDiS::finalize();
   return 0;
 }
diff --git a/examples/pfc2.cc b/examples/pfc2.cc
index 06269932..9ac73179 100644
--- a/examples/pfc2.cc
+++ b/examples/pfc2.cc
@@ -11,7 +11,7 @@ using namespace AMDiS;
 
 int main(int argc, char** argv)
 {
-  AMDiS::init(argc, argv);
+  Environment env(argc, argv);
 
   auto grid = MeshCreator<Dune::YaspGrid<2>>::create("pfcMesh");
 
@@ -76,6 +76,5 @@ int main(int argc, char** argv)
   AdaptInstationary adaptInstat("adapt", prob, adaptInfo, probInstat, adaptInfo);
   adaptInstat.adapt();
 
-  AMDiS::finalize();
   return 0;
 }
diff --git a/examples/pfc3.cc b/examples/pfc3.cc
index 871b35f5..3cfb4399 100644
--- a/examples/pfc3.cc
+++ b/examples/pfc3.cc
@@ -11,7 +11,7 @@ using namespace AMDiS;
 
 int main(int argc, char** argv)
 {
-  AMDiS::init(argc, argv);
+  Environment env(argc, argv);
 
   auto grid = MeshCreator<Dune::YaspGrid<2>>::create("pfcMesh");
 
@@ -78,6 +78,5 @@ int main(int argc, char** argv)
   AdaptInstationary adaptInstat("adapt", prob, adaptInfo, probInstat, adaptInfo);
   adaptInstat.adapt();
 
-  AMDiS::finalize();
   return 0;
 }
diff --git a/examples/stokes4.cc b/examples/stokes4.cc
index 881d2ec4..f5862ee3 100644
--- a/examples/stokes4.cc
+++ b/examples/stokes4.cc
@@ -92,7 +92,7 @@ private:
 
 int main(int argc, char** argv)
 {
-  AMDiS::init(argc, argv);
+  Environment env(argc, argv);
 
   using namespace Dune::Functions::BasisFactory;
 
@@ -163,6 +163,5 @@ int main(int argc, char** argv)
   // output solution
   prob.writeFiles(adaptInfo);
 
-  AMDiS::finalize();
   return 0;
 }
diff --git a/test/BlockingTest.cpp b/test/BlockingTest.cpp
index 9bcc0e17..1d567277 100644
--- a/test/BlockingTest.cpp
+++ b/test/BlockingTest.cpp
@@ -1,13 +1,14 @@
 #include <iostream>
 
+#include <amdis/AMDiS.hpp>
+#include <amdis/functions/Blocking.hpp>
+
 #include <dune/grid/yaspgrid.hh>
 #include <dune/functions/functionspacebases/powerbasis.hh>
 #include <dune/functions/functionspacebases/compositebasis.hh>
 #include <dune/functions/functionspacebases/lagrangebasis.hh>
 #include <dune/functions/functionspacebases/subspacebasis.hh>
 
-#include <amdis/functions/Blocking.hpp>
-
 #include "BasisTester.hpp"
 
 using namespace AMDiS;
@@ -29,7 +30,7 @@ void printType(GlobalBasis const&)
 
 int main(int argc, char** argv)
 {
-  Dune::MPIHelper::instance(argc, argv);
+  Environment env(argc, argv);
 
   TaylorHoodBases<2> tester{};
 
diff --git a/test/GeneratorsTest.cpp b/test/GeneratorsTest.cpp
index 0814936f..06fe39bb 100644
--- a/test/GeneratorsTest.cpp
+++ b/test/GeneratorsTest.cpp
@@ -91,7 +91,7 @@ void test2(GlobalBasis const& basis, Dune::index_constant<I>)
 
 int main(int argc, char** argv)
 {
-  Dune::MPIHelper::instance(argc, argv);
+  Environment env(argc, argv);
 
   using Tester = TaylorHoodBases<2>;
   Tester tester{};
diff --git a/test/MatrixTest.cpp b/test/MatrixTest.cpp
index 602bccce..b794e5a9 100644
--- a/test/MatrixTest.cpp
+++ b/test/MatrixTest.cpp
@@ -230,7 +230,7 @@ void test5(BasisTester& tester)
 
 int main(int argc, char** argv)
 {
-  AMDiS::init(argc, argv);
+  Environment env(argc, argv);
 
   TaylorHoodBases<2> tester{};
 
diff --git a/test/MatrixWrapperTest.cpp b/test/MatrixWrapperTest.cpp
index 969c8d89..aea0cb96 100644
--- a/test/MatrixWrapperTest.cpp
+++ b/test/MatrixWrapperTest.cpp
@@ -96,7 +96,7 @@ void foo(MatrixInserterBase<Impl>& inserter)
 
 int main(int argc, char** argv)
 {
-  AMDiS::init(argc, argv);
+  Environment env(argc, argv);
 
   WrapperImpl wrapper1;
   //Wrapper2Impl wrapper2;
diff --git a/test/StokesTest.cpp b/test/StokesTest.cpp
index e2ffc296..925b8eaf 100644
--- a/test/StokesTest.cpp
+++ b/test/StokesTest.cpp
@@ -12,7 +12,7 @@ using namespace AMDiS;
 
 int main(int argc, char** argv)
 {
-  AMDiS::init(argc, argv);
+  Environment env(argc, argv);
 
   TaylorHoodBases<2,1> tester;
   tester.grid().globalRefine(1);
@@ -49,7 +49,5 @@ int main(int argc, char** argv)
   prob.assemble(adaptInfo);
   prob.solve(adaptInfo);
 
-
-  AMDiS::finalize();
   return 0;
 }
diff --git a/test/VectorTest.cpp b/test/VectorTest.cpp
index 478339c3..b5d9c60f 100644
--- a/test/VectorTest.cpp
+++ b/test/VectorTest.cpp
@@ -111,7 +111,7 @@ void test2(BasisTester& tester)
 
 int main(int argc, char** argv)
 {
-  AMDiS::init(argc, argv);
+  Environment env(argc, argv);
 
   TaylorHoodBases<2> tester{};
   test1(tester);
-- 
GitLab


From b0bc0d6601b4e8d8d64226e356ea52bc6794bf0a Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Sun, 12 May 2019 11:31:58 +0200
Subject: [PATCH 33/38] resolved merge error

---
 src/amdis/linearalgebra/DOFVectorBase.inc.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
index eb36299e..b0ea03cf 100644
--- a/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
+++ b/src/amdis/linearalgebra/DOFVectorBase.inc.hpp
@@ -103,8 +103,8 @@ assemble()
 }
 
 
-template <class GB, class B>
-void DOFVectorBase<GB,B>::
+template <class GB, class B, class K>
+void DOFVectorBase<GB,B,K>::
 backup(std::string const& filename)
 {
   std::ofstream out(filename, std::ios::binary);
@@ -134,8 +134,8 @@ backup(std::string const& filename)
   }
 }
 
-template <class GB, class B>
-void DOFVectorBase<GB,B>::
+template <class GB, class B, class K>
+void DOFVectorBase<GB,B,K>::
 restore(std::string const& filename)
 {
   std::ifstream in(filename, std::ios::binary);
-- 
GitLab


From ca6a87ba6aee9cc125975e1e6b080da656843019 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Sun, 12 May 2019 14:27:34 +0200
Subject: [PATCH 34/38] filled CMakeLists and renamed blocking tags

---
 src/amdis/common/Logical.hpp                  |  24 +--
 src/amdis/functions/Blocking.hpp              | 178 ++----------------
 src/amdis/functions/Blocking.inc.hpp          | 119 ++++++++++++
 src/amdis/functions/CMakeLists.txt            |   3 +
 .../MatrixVectorGenerator.inc.hpp             |  36 ++--
 src/amdis/linearalgebra/MultiTypeMatrix.hpp   |   2 +-
 src/amdis/typetree/CMakeLists.txt             |   1 -
 test/BlockingTest.cpp                         |  13 +-
 8 files changed, 174 insertions(+), 202 deletions(-)
 create mode 100644 src/amdis/functions/Blocking.inc.hpp

diff --git a/src/amdis/common/Logical.hpp b/src/amdis/common/Logical.hpp
index 98e8fac4..727c493d 100644
--- a/src/amdis/common/Logical.hpp
+++ b/src/amdis/common/Logical.hpp
@@ -72,26 +72,16 @@ namespace AMDiS
   template <bool B>
   constexpr bool_t<!B> operator!(bool_t<B>) { return {}; }
 
-
-  namespace Impl
+  template <class T, class... Ts>
+  struct IsEqual
   {
-    template <class T, T... Is>
-    struct IsEqualImpl;
-
-    template <class T, T I0, T... Is>
-    struct IsEqualImpl<T, I0, Is...>
-        : public std::is_same<std::integer_sequence<T,I0,Is...>,
-                              std::integer_sequence<T,Is...,I0>> {};
+    using type = std::is_same<std::tuple<T,Ts...>, std::tuple<Ts...,T>>;
+  };
 
-    template <class T>
-    struct IsEqualImpl<T> { enum { value = true }; };
-
-  } // end namespace Impl
+  template <class... Ts>
+  using IsEqual_t = typename IsEqual<Ts...>::type;
 
   template <class T, T... values>
-  using IsEqual = Impl::IsEqualImpl<T,values...>;
-
-  template <class T, class... Ts>
-  using is_one_of = or_t<std::is_same<T, Ts>::value...>;
+  using IsEqualValue_t = IsEqual_t<std::integral_constant<T,values>...>;
 
 } // end namespace AMDiS
diff --git a/src/amdis/functions/Blocking.hpp b/src/amdis/functions/Blocking.hpp
index cfd29206..859eeef1 100644
--- a/src/amdis/functions/Blocking.hpp
+++ b/src/amdis/functions/Blocking.hpp
@@ -1,63 +1,40 @@
 #pragma once
 
+#include <cstddef>
 #include <tuple>
-#include <utility>
-#include <type_traits>
 
-#include <dune/common/indices.hh>
-#include <dune/common/typetraits.hh>
-#include <dune/common/std/type_traits.hh>
-
-#include <dune/functions/functionspacebases/basistags.hh>
-#include <dune/functions/functionspacebases/compositebasis.hh>
-#include <dune/functions/functionspacebases/powerbasis.hh>
-
-#include <amdis/common/ConceptsBase.hpp>
 #include <amdis/common/Index.hpp>
-#include <amdis/common/Logical.hpp>
+#include <amdis/common/Tags.hpp>
 
 namespace AMDiS
 {
   // Lightweight representation of (hierarchic) block structure
-  namespace Blocking
+  namespace tag
   {
-    struct Unknown
-    {
-      enum { isFlat = false };
-      enum { isBlocked = false };
-    };
-
-    /// \brief Blocking structure corresponding to IndexMergingStrategies \ref FlatLexicographic and \ref FlatInterleaved
-    struct Flat
+    /// \brief Blocking structure corresponding to IndexMergingStrategies
+    /// \ref FlatLexicographic and \ref FlatInterleaved
+    struct flat
     {
-      enum { isFlat = true };
-      enum { isBlocked = false };
-
       template <class Index>
-      Flat operator[](const Index&) const { return {}; }
+      flat operator[](const Index&) const { return {}; }
     };
 
-    /// \brief Blocking structure corresponding to IndexMergingStrategy \ref LeafBlockedInterleaved
+    /// \brief Blocking structure corresponding to IndexMergingStrategy
+    /// \ref LeafBlockedInterleaved
     template <std::size_t N>
-    struct LeafBlocked
+    struct leaf_blocked
     {
-      enum { isFlat = false };
-      enum { isBlocked = false };
-
       template <class Index>
-      Flat operator[](const Index&) const { return {}; }
+      flat operator[](const Index&) const { return {}; }
     };
 
-    /// \brief Blocking structure corresponding to IndexMergingStrategy \ref BlockedLexicographic
+    /// \brief Blocking structure corresponding to IndexMergingStrategy
+    /// \ref BlockedLexicographic
     template <class Tag0, class... Tags>
-    struct Blocked
+    struct blocked
     {
-      enum { isFlat = false };
-      enum { isBlocked = true };
-
       template <std::size_t i>
       auto operator[](index_t<i>) const { return std::get<i>(t); }
-
       Tag0 operator[](std::size_t /*i*/) const { return {}; }
 
       std::tuple<Tag0,Tags...> t;
@@ -65,129 +42,14 @@ namespace AMDiS
 
   } // end namespace tag
 
-
-  namespace Impl
-  {
-    // Handle non-leaf nodes
-    template <template <class...> class Tag, class PreBasis>
-    struct CompositeBlocking
-    {
-      using type = Blocking::Flat;
-    };
-
-
-    // Type is unknown if 1. level flat, 2. level blocked
-    template <bool /*false*/, class... T>
-    struct FlatTag { using type = Blocking::Unknown; };
-
-    // Type is flat if all sub-Blockings are flat
-    template <class... T>
-    struct FlatTag<true, T...> { using type = Blocking::Flat; };
-
-    /// \brief collapse flat tags to flat, if hierarchy is all flat, otherwise to tag::unknown
-    template <class... T>
-    using FlatTag_t = typename FlatTag<all_of_v<T::isFlat...>>::type;
-
-
-    // Flat index-merging strategy
-    template <class PreBasis, class IndexMergingStrategy>
-    struct BlockingImpl
-    {
-      using type = typename Impl::CompositeBlocking<FlatTag_t,PreBasis>::type;
-    };
-
-    // Block index-merging strategy
-    template <class PB>
-    struct BlockingImpl<PB, Dune::Functions::BasisBuilder::BlockedLexicographic>
-    {
-      using type = typename Impl::CompositeBlocking<Blocking::Blocked, PB>::type;
-    };
-
-
-    template <class PB>
-    struct Children
-        : std::integral_constant<std::size_t, 0> {};
-
-    template <class MI, class IMS, class... SPB>
-    struct Children<Dune::Functions::CompositePreBasis<MI, IMS, SPB...>>
-        : std::integral_constant<std::size_t, sizeof...(SPB)> {};
-
-    template <class MI, class IMS, class SPB, std::size_t C>
-    struct Children<Dune::Functions::PowerPreBasis<MI, IMS, SPB, C>>
-        : std::integral_constant<std::size_t, C> {};
-
-
-    // Leaf-Block index-merging strategy
-    template <class PB>
-    struct BlockingImpl<PB, Dune::Functions::BasisFactory::BlockedInterleaved>
-    {
-      using type = Blocking::LeafBlocked<Children<PB>::value>;
-    };
-
-  } // end namespace Impl
-
-
-  // Handle leaf-nodes in basis-tree
-  template <class PreBasis, class = void>
-  struct BlockingPreBasis
-  {
-    using type = Blocking::Flat;
-  };
-
-  // Handle all nodes with an index-merging trategy
-  template <class PB>
-  struct BlockingPreBasis<PB, void_t<typename PB::IndexMergingStrategy>>
-  {
-    using type = typename Impl::BlockingImpl<PB, typename PB::IndexMergingStrategy>::type;
-  };
-
-  /// \brief Extract block structure of PreBasis
-  template <class PreBasis>
-  using BlockingPreBasis_t = typename BlockingPreBasis<PreBasis>::type;
-
-  namespace Impl
-  {
-    // defaultbasis
-    template <class Basis, class = void>
-    struct PreBasisImpl
-    {
-      using type = typename Basis::PreBasis;
-    };
-
-    // subspacebasis
-    template <class Basis>
-    struct PreBasisImpl<Basis, void_t<typename Basis::RootBasis>>
-    {
-      using type = typename Basis::RootBasis::PreBasis;
-    };
-  }
+  // forward declaration
+  template <class GlobalBasis>
+  struct Blocking;
 
   /// \brief Extract blocking structure of GlobalBasis
   template <class GlobalBasis>
-  using Blocking_t = BlockingPreBasis_t<typename Impl::PreBasisImpl<GlobalBasis>::type>;
-
-
-  namespace Impl
-  {
-    template <template <class...> class Builder, class MI, class IMS, class... SPB>
-    struct CompositeBlocking<Builder, Dune::Functions::CompositePreBasis<MI, IMS, SPB...>>
-    {
-      using type = Builder<BlockingPreBasis_t<SPB>...>;
-    };
-
-    template <template <class...> class Builder, class MI, class IMS, class SPB, std::size_t C>
-    struct CompositeBlocking<Builder, Dune::Functions::PowerPreBasis<MI, IMS, SPB, C>>
-    {
-      template <std::size_t I> using SubPreBasis = SPB;
-      template <class Idx>        struct Expand;
-      template <std::size_t... I> struct Expand<std::index_sequence<I...>>
-      {
-        using type = Builder<BlockingPreBasis_t<SubPreBasis<I>>...>;
-      };
-
-      using type = typename Expand<std::make_index_sequence<C>>::type;
-    };
-
-  } // end namespace Impl
+  using Blocking_t = typename Blocking<GlobalBasis>::type;
 
 } // end namespace AMDiS
+
+#include <amdis/functions/Blocking.inc.hpp>
diff --git a/src/amdis/functions/Blocking.inc.hpp b/src/amdis/functions/Blocking.inc.hpp
new file mode 100644
index 00000000..297399ec
--- /dev/null
+++ b/src/amdis/functions/Blocking.inc.hpp
@@ -0,0 +1,119 @@
+#pragma once
+
+#include <tuple>
+#include <type_traits>
+
+#include <dune/common/version.hh>
+#include <dune/functions/functionspacebases/basistags.hh>
+#include <dune/functions/functionspacebases/compositebasis.hh>
+#include <dune/functions/functionspacebases/powerbasis.hh>
+
+#include <amdis/common/ConceptsBase.hpp>
+#include <amdis/common/Index.hpp>
+#include <amdis/common/Logical.hpp>
+
+namespace AMDiS
+{
+  namespace Impl
+  {
+    // Handle non-leaf nodes
+    template <template <class...> class Tag, class PreBasis>
+    struct CompositeBlocking
+    {
+      using type = tag::flat;
+    };
+
+
+    // Flat index-merging strategy
+    template <class PB, class IndexMergingStrategy>
+    struct BlockingImpl
+    {
+      // Collapse flat tags to flat, if hierarchy is all flat, otherwise
+      // to tag::unknown
+      template <class... T>
+      using FlatTag_t = std::conditional_t<IsEqual_t<tag::flat,T...>::value,
+        tag::flat, tag::unknown>;
+
+      using type = typename Impl::CompositeBlocking<FlatTag_t, PB>::type;
+    };
+
+    // Block index-merging strategy
+    template <class PB>
+    struct BlockingImpl<PB, Dune::Functions::BasisBuilder::BlockedLexicographic>
+    {
+      using type = typename Impl::CompositeBlocking<tag::blocked, PB>::type;
+    };
+
+    // Leaf-Block index-merging strategy
+    template <class PB>
+    struct BlockingImpl<PB, Dune::Functions::BasisFactory::BlockedInterleaved>
+    {
+#if DUNE_VERSION_LT(DUNE_FUNCTIONS,2,7)
+      using RootTreePath = decltype(Dune::TypeTree::hybridTreePath());
+      using Node = typename PB::template Node<RootTreePath>;
+#else
+      using Node = typename PB::Node;
+#endif
+      using type = tag::leaf_blocked<Node::CHILDREN>;
+    };
+
+    // Handle leaf-nodes in basis-tree
+    template <class PreBasis, class = void>
+    struct BlockingPreBasis
+    {
+      using type = tag::flat;
+    };
+
+    // Handle all nodes with an index-merging strategy
+    template <class PB>
+    struct BlockingPreBasis<PB, void_t<typename PB::IndexMergingStrategy>>
+    {
+      using type = typename Impl::BlockingImpl<PB, typename PB::IndexMergingStrategy>::type;
+    };
+
+    // Extract block structure of PreBasis
+    template <class PreBasis>
+    using BlockingPreBasis_t = typename BlockingPreBasis<PreBasis>::type;
+
+    // defaultbasis
+    template <class Basis, class = void>
+    struct PreBasisImpl
+    {
+      using type = typename Basis::PreBasis;
+    };
+
+    // subspacebasis
+    template <class Basis>
+    struct PreBasisImpl<Basis, void_t<typename Basis::RootBasis>>
+    {
+      using type = typename Basis::RootBasis::PreBasis;
+    };
+
+    template <template <class...> class Builder, class MI, class IMS, class... SPB>
+    struct CompositeBlocking<Builder, Dune::Functions::CompositePreBasis<MI, IMS, SPB...>>
+    {
+      using type = Builder<BlockingPreBasis_t<SPB>...>;
+    };
+
+    template <template <class...> class Builder, class MI, class IMS, class SPB, std::size_t C>
+    struct CompositeBlocking<Builder, Dune::Functions::PowerPreBasis<MI, IMS, SPB, C>>
+    {
+      template <std::size_t I> using SubPreBasis = SPB;
+      template <class Idx>        struct Expand;
+      template <std::size_t... I> struct Expand<std::index_sequence<I...>>
+      {
+        using type = Builder<BlockingPreBasis_t<SubPreBasis<I>>...>;
+      };
+
+      using type = typename Expand<std::make_index_sequence<C>>::type;
+    };
+
+  } // end namespace Impl
+
+  template <class GlobalBasis>
+  struct Blocking
+  {
+    using type = Impl::BlockingPreBasis_t<typename Impl::PreBasisImpl<GlobalBasis>::type>;
+  };
+
+} // end namespace AMDiS
diff --git a/src/amdis/functions/CMakeLists.txt b/src/amdis/functions/CMakeLists.txt
index 13244525..5ed23130 100644
--- a/src/amdis/functions/CMakeLists.txt
+++ b/src/amdis/functions/CMakeLists.txt
@@ -1,6 +1,9 @@
 #install headers
 
 install(FILES
+    Blocking.hpp
+    Blocking.inc.hpp
     HierarchicNodeToRangeMap.hpp
     Interpolate.hpp
+    MultiIndex.hpp
 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/amdis/functions)
diff --git a/src/amdis/linearalgebra/MatrixVectorGenerator.inc.hpp b/src/amdis/linearalgebra/MatrixVectorGenerator.inc.hpp
index c34e9bf3..5c89efb6 100644
--- a/src/amdis/linearalgebra/MatrixVectorGenerator.inc.hpp
+++ b/src/amdis/linearalgebra/MatrixVectorGenerator.inc.hpp
@@ -24,7 +24,7 @@ namespace AMDiS
 
     // implementation details of the vector container
     template <class Value, class Traits, class... T>
-    struct VectorGeneratorImpl<Value, Traits, Blocking::Blocked<T...>,
+    struct VectorGeneratorImpl<Value, Traits, tag::blocked<T...>,
       enable_if_all_t<not Concepts::Same<T...>,
         is_template<Traits::template CompositeVector>()> >
     {
@@ -32,7 +32,7 @@ namespace AMDiS
     };
 
     template <class Value, class Traits, class T0, class... T>
-    struct VectorGeneratorImpl<Value, Traits, Blocking::Blocked<T0,T...>,
+    struct VectorGeneratorImpl<Value, Traits, tag::blocked<T0,T...>,
       enable_if_all_t<Concepts::Same<T0,T...>,
         is_template<Traits::template PowerVector>()> >
     {
@@ -40,14 +40,14 @@ namespace AMDiS
     };
 
     template <class Value, class Traits>
-    struct VectorGeneratorImpl<Value, Traits, Blocking::Flat,
+    struct VectorGeneratorImpl<Value, Traits, tag::flat,
       void_t<typename Traits::template FlatVector<Value>> >
     {
       using type = typename Traits::template FlatVector<Value>;
     };
 
     template <class Value, class Traits, std::size_t N>
-    struct VectorGeneratorImpl<Value, Traits, Blocking::LeafBlocked<N>,
+    struct VectorGeneratorImpl<Value, Traits, tag::leaf_blocked<N>,
       void_t<typename Traits::template LeafBlockVector<Value,N>> >
     {
       using type = typename Traits::template LeafBlockVector<Value,N>;
@@ -61,7 +61,7 @@ namespace AMDiS
 
 
     template <class Value, class Traits, class... S, class... T>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::Blocked<S...>, Blocking::Blocked<T...>,
+    struct MatrixGeneratorImpl<Value, Traits, tag::blocked<S...>, tag::blocked<T...>,
       enable_if_all_t<not (Concepts::Same<S...> && Concepts::Same<T...>),
         is_template<Traits::template CompositeVector>(),
         is_template<Traits::template CompositeMatrix>()> >
@@ -73,7 +73,7 @@ namespace AMDiS
     };
 
     template <class Value, class Traits, class S0, class... S, class T0, class... T>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::Blocked<S0,S...>, Blocking::Blocked<T0,T...>,
+    struct MatrixGeneratorImpl<Value, Traits, tag::blocked<S0,S...>, tag::blocked<T0,T...>,
       enable_if_all_t<Concepts::Same<S0,S...> && Concepts::Same<T0,T...>,
         is_template<Traits::template PowerMatrix>()> >
     {
@@ -82,28 +82,28 @@ namespace AMDiS
     };
 
     template <class Value, class Traits>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::Flat, Blocking::Flat,
+    struct MatrixGeneratorImpl<Value, Traits, tag::flat, tag::flat,
       void_t<typename Traits::template FlatMatrix<Value>> >
     {
       using type = typename Traits::template FlatMatrix<Value>;
     };
 
     template <class Value, class Traits, std::size_t N, std::size_t M>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::LeafBlocked<N>, Blocking::LeafBlocked<M>,
+    struct MatrixGeneratorImpl<Value, Traits, tag::leaf_blocked<N>, tag::leaf_blocked<M>,
       void_t<typename Traits::template LeafBlockMatrix<Value,N,M>> >
     {
       using type = typename Traits::template LeafBlockMatrix<Value,N,M>;
     };
 
     template <class Value, class Traits, std::size_t N>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::LeafBlocked<N>, Blocking::Flat,
+    struct MatrixGeneratorImpl<Value, Traits, tag::leaf_blocked<N>, tag::flat,
       void_t<typename Traits::template LeafBlockMatrix<Value,N,1>> >
     {
       using type = typename Traits::template LeafBlockMatrix<Value,N,1>;
     };
 
     template <class Value, class Traits, std::size_t M>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::Flat, Blocking::LeafBlocked<M>,
+    struct MatrixGeneratorImpl<Value, Traits, tag::flat, tag::leaf_blocked<M>,
       void_t<typename Traits::template LeafBlockMatrix<Value,1,M>> >
     {
       using type = typename Traits::template LeafBlockMatrix<Value,1,M>;
@@ -111,47 +111,47 @@ namespace AMDiS
 
     // single column, multi-type rows
     template <class Value, class Traits, class... T>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::Blocked<T...>, Blocking::Flat,
+    struct MatrixGeneratorImpl<Value, Traits, tag::blocked<T...>, tag::flat,
       enable_if_all_t<not Concepts::Same<T...>,
         is_template<Traits::template CompositeVector>(),
         is_template<Traits::template CompositeMatrix>()> >
     {
       using type = SingleColumnMatrix<
-        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGeneratorImpl_t<Value, Traits, T, Blocking::Flat>>...>
+        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGeneratorImpl_t<Value, Traits, T, tag::flat>>...>
         >;
     };
 
     // single column, single-type rows
     template <class Value, class Traits, class T0, class... T>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::Blocked<T0,T...>, Blocking::Flat,
+    struct MatrixGeneratorImpl<Value, Traits, tag::blocked<T0,T...>, tag::flat,
       enable_if_all_t<Concepts::Same<T0,T...>,
         is_template<Traits::template PowerMatrix>()> >
     {
       using type = SingleColumnMatrix<
-        typename Traits::template PowerMatrix<MatrixGeneratorImpl_t<Value, Traits, T0, Blocking::Flat>, 1+sizeof...(T),1>
+        typename Traits::template PowerMatrix<MatrixGeneratorImpl_t<Value, Traits, T0, tag::flat>, 1+sizeof...(T),1>
         >;
     };
 
     // single row, multi-type columns
     template <class Value, class Traits, class... T>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::Flat, Blocking::Blocked<T...>,
+    struct MatrixGeneratorImpl<Value, Traits, tag::flat, tag::blocked<T...>,
       enable_if_all_t<not Concepts::Same<T...>,
         is_template<Traits::template CompositeVector>(),
         is_template<Traits::template CompositeMatrix>()> >
     {
       using type = SingleRowMatrix<
-        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGeneratorImpl_t<Value, Traits, Blocking::Flat, T>...>>
+        typename Traits::template CompositeMatrix<typename Traits::template CompositeVector<MatrixGeneratorImpl_t<Value, Traits, tag::flat, T>...>>
         >;
     };
 
     // single row, single-type columns
     template <class Value, class Traits, class T0, class... T>
-    struct MatrixGeneratorImpl<Value, Traits, Blocking::Flat, Blocking::Blocked<T0,T...>,
+    struct MatrixGeneratorImpl<Value, Traits, tag::flat, tag::blocked<T0,T...>,
       enable_if_all_t<Concepts::Same<T0,T...>,
         is_template<Traits::template PowerMatrix>()> >
     {
       using type = SingleRowMatrix<
-        typename Traits::template PowerMatrix<MatrixGeneratorImpl_t<Value, Traits, Blocking::Flat, T0>, 1,1+sizeof...(T)>
+        typename Traits::template PowerMatrix<MatrixGeneratorImpl_t<Value, Traits, tag::flat, T0>, 1,1+sizeof...(T)>
         >;
     };
 
diff --git a/src/amdis/linearalgebra/MultiTypeMatrix.hpp b/src/amdis/linearalgebra/MultiTypeMatrix.hpp
index a7ed52da..69326226 100644
--- a/src/amdis/linearalgebra/MultiTypeMatrix.hpp
+++ b/src/amdis/linearalgebra/MultiTypeMatrix.hpp
@@ -42,7 +42,7 @@ namespace AMDiS
     using Self = MultiTypeMatrix;
     using Super = std::tuple<Rows...>;
 
-    static_assert(IsEqual<int, Rows::dimension...>::value,
+    static_assert(IsEqualValue_t<int, Rows::dimension...>::value,
       "All columns must have the same length.");
 
   public:
diff --git a/src/amdis/typetree/CMakeLists.txt b/src/amdis/typetree/CMakeLists.txt
index e2544920..7c4b5df3 100644
--- a/src/amdis/typetree/CMakeLists.txt
+++ b/src/amdis/typetree/CMakeLists.txt
@@ -1,7 +1,6 @@
 
 install(FILES
     FiniteElementType.hpp
-    MultiIndex.hpp
     RangeType.hpp
     Traversal.hpp
     TreeContainer.hpp
diff --git a/test/BlockingTest.cpp b/test/BlockingTest.cpp
index 1d567277..53480e20 100644
--- a/test/BlockingTest.cpp
+++ b/test/BlockingTest.cpp
@@ -12,7 +12,6 @@
 #include "BasisTester.hpp"
 
 using namespace AMDiS;
-using namespace AMDiS::Blocking;
 
 template <class Blocking>
 void printBlocking()
@@ -41,7 +40,7 @@ int main(int argc, char** argv)
     using GlobalBasis = decltype(taylorHoodBasis);
     using Blocking = Blocking_t<GlobalBasis>;
 
-    static_assert(std::is_same<Blocking, Blocked<Flat,Flat>>::value, "");
+    static_assert(std::is_same<Blocking, tag::blocked<tag::flat,tag::flat>>::value, "");
     printType(taylorHoodBasis);
   }
 
@@ -51,7 +50,7 @@ int main(int argc, char** argv)
     using GlobalBasis = decltype(taylorHoodBasis);
     using Blocking = Blocking_t<GlobalBasis>;
 
-    static_assert(std::is_same<Blocking, Blocked<Flat,Flat>>::value, "");
+    static_assert(std::is_same<Blocking, tag::blocked<tag::flat,tag::flat>>::value, "");
     printType(taylorHoodBasis);
   }
 
@@ -60,7 +59,7 @@ int main(int argc, char** argv)
     using GlobalBasis = decltype(taylorHoodBasis);
     using Blocking = Blocking_t<GlobalBasis>;
 
-    static_assert(std::is_same<Blocking, Blocked<Blocked<Flat,Flat>,Flat>>::value, "");
+    static_assert(std::is_same<Blocking, tag::blocked<tag::blocked<tag::flat,tag::flat>,tag::flat>>::value, "");
     printType(taylorHoodBasis);
   }
 
@@ -69,7 +68,7 @@ int main(int argc, char** argv)
     using GlobalBasis = decltype(taylorHoodBasis);
     using Blocking = Blocking_t<GlobalBasis>;
 
-    static_assert(std::is_same<Blocking, Blocked<LeafBlocked<2>,Flat>>::value, "");
+    static_assert(std::is_same<Blocking, tag::blocked<tag::leaf_blocked<2>,tag::flat>>::value, "");
     printType(taylorHoodBasis);
   }
 
@@ -78,7 +77,7 @@ int main(int argc, char** argv)
     using GlobalBasis = decltype(taylorHoodBasis);
     using Blocking = Blocking_t<GlobalBasis>;
 
-    static_assert(std::is_same<Blocking, Flat>::value, "");
+    static_assert(std::is_same<Blocking, tag::flat>::value, "");
     printType(taylorHoodBasis);
   }
 
@@ -88,7 +87,7 @@ int main(int argc, char** argv)
     using GlobalBasis = decltype(taylorHoodBasis);
     using Blocking = Blocking_t<GlobalBasis>;
 
-    static_assert(std::is_same<Blocking, Unknown>::value, "");
+    static_assert(std::is_same<Blocking, tag::unknown>::value, "");
     printType(taylorHoodBasis);
   }
 }
-- 
GitLab


From 8b2db3c7293fccaaddca165326984e808f4bfaa8 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Mon, 13 May 2019 17:34:22 +0200
Subject: [PATCH 35/38] added DataTransferTest after correcting calcError
 function

---
 test/CMakeLists.txt       |  8 ++++----
 test/DataTransferTest.hpp | 15 ++++++++-------
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index abc9c1a6..611ae689 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -21,11 +21,11 @@ dune_add_test(SOURCES BlockingTest.cpp
 dune_add_test(SOURCES ConceptsTest.cpp
   LINK_LIBRARIES amdis)
 
-# dune_add_test(SOURCES DataTransferTest2d.cpp
-#   LINK_LIBRARIES amdis)
+dune_add_test(SOURCES DataTransferTest2d.cpp
+  LINK_LIBRARIES amdis)
 
-# dune_add_test(SOURCES DataTransferTest3d.cpp
-#   LINK_LIBRARIES amdis)
+dune_add_test(SOURCES DataTransferTest3d.cpp
+  LINK_LIBRARIES amdis)
 
 dune_add_test(SOURCES DOFVectorTest.cpp
   LINK_LIBRARIES amdis)
diff --git a/test/DataTransferTest.hpp b/test/DataTransferTest.hpp
index e9c7c3d3..fdad15e1 100644
--- a/test/DataTransferTest.hpp
+++ b/test/DataTransferTest.hpp
@@ -82,10 +82,9 @@ double calcError(Problem const& prob, Fcts const& funcs)
 {
   auto& globalBasis = *prob->globalBasis();
   auto localView = globalBasis.localView();
-  auto const& sol = prob->solution().coefficients();
-  std::vector<double> ref;
-  ref.resize(globalBasis.size());
-  double error = 0;
+  auto const& sol = *prob->solutionVector();
+  auto ref = sol;
+
   double maxError = 0;
   int k = 0;
 
@@ -97,11 +96,13 @@ double calcError(Problem const& prob, Fcts const& funcs)
   });
 
   // compare the solution with the reference
-  for (std::size_t i = 0; i < ref.size(); ++i)
+  auto const& ref_vec = ref.vector();
+  auto const& sol_vec = sol.vector();
+  vectorWrapper(ref_vec).elementwise(sol_vec, [&maxError](auto const& ref_i, auto const& sol_i)
   {
-    error = std::abs(ref[i]-sol[i]);
+    double error = std::abs(ref_i - sol_i);
     maxError = std::max(maxError, error);
-  }
+  });
   return maxError;
 }
 
-- 
GitLab


From b3c35a1756211dee1865bf99ea9526f113236b87 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Tue, 21 May 2019 17:32:26 +0200
Subject: [PATCH 36/38] improved performance of symmetric Dirichlet BC

---
 src/amdis/ProblemStat.inc.hpp               |   4 +-
 src/amdis/common/CMakeLists.txt             |   1 +
 src/amdis/common/Iterator.hpp               | 265 ++++++++++++++++++++
 src/amdis/linearalgebra/istl/BCRSMatrix.hpp |  16 +-
 src/amdis/linearalgebra/mtl/MtlMatrix.hpp   |  46 ++--
 5 files changed, 304 insertions(+), 28 deletions(-)
 create mode 100644 src/amdis/common/Iterator.hpp

diff --git a/src/amdis/ProblemStat.inc.hpp b/src/amdis/ProblemStat.inc.hpp
index eab89fd5..26f31d76 100644
--- a/src/amdis/ProblemStat.inc.hpp
+++ b/src/amdis/ProblemStat.inc.hpp
@@ -260,7 +260,7 @@ addDirichletBC(Predicate const& predicate, RowTreePath row, ColTreePath col, Val
 
   using Range = RangeType_t<decltype(i)>;
   using BcType = DirichletBC<WorldVector,Range,typename GlobalBasis::MultiIndex>;
-  auto bc = std::make_unique<BcType>(predicate, valueGridFct);
+  auto bc = std::make_unique<BcType>(predicate, valueGridFct, true);
   dirichletBCs_[i][j].push_back(std::move(bc));
 }
 
@@ -279,7 +279,7 @@ addDirichletBC(BoundaryType id, RowTreePath row, ColTreePath col, Values const&
 
   using Range = RangeType_t<decltype(i)>;
   using BcType = DirichletBC<WorldVector,Range,typename GlobalBasis::MultiIndex>;
-  auto bc = std::make_unique<BcType>(boundaryManager_, id, valueGridFct);
+  auto bc = std::make_unique<BcType>(boundaryManager_, id, valueGridFct, true);
   dirichletBCs_[i][j].push_back(std::move(bc));
 }
 
diff --git a/src/amdis/common/CMakeLists.txt b/src/amdis/common/CMakeLists.txt
index 695c0954..7c5d6cbb 100644
--- a/src/amdis/common/CMakeLists.txt
+++ b/src/amdis/common/CMakeLists.txt
@@ -17,6 +17,7 @@ install(FILES
     ForEach.hpp
     HybridSize.hpp
     Index.hpp
+    Iterator.hpp
     Literals.hpp
     Logical.hpp
     Math.hpp
diff --git a/src/amdis/common/Iterator.hpp b/src/amdis/common/Iterator.hpp
new file mode 100644
index 00000000..4f6f2a15
--- /dev/null
+++ b/src/amdis/common/Iterator.hpp
@@ -0,0 +1,265 @@
+#pragma once
+
+#include <iterator>
+
+namespace AMDiS
+{
+  namespace Impl
+  {
+    // forward declaration
+    template <class Category, class... Iterators>
+    class ZipIteratorImpl;
+
+    // forward declaration
+    template <class... Categories>
+    struct MinimalIteratorCategory;
+  }
+
+  template <class... Iterators>
+  using MinimalIteratorCategory_t
+    = typename Impl::MinimalIteratorCategory<typename std::iterator_traits<Iterators>::iterator_category...>::type;
+
+  template <class... Iterators>
+  using ZipIterator
+    = Impl::ZipIteratorImpl<MinimalIteratorCategory_t<Iterators...>, Iterators...>;
+
+  /// Zip the passed iterator to form a new iterator that parallel iterates through the individual elements
+  template <class... Iterators>
+  ZipIterator<Iterators...> zip_iterator(Iterators... iterators)
+  {
+    return ZipIterator<Iterators...>{iterators...};
+  }
+
+
+  namespace Impl
+  {
+    template <class Cat0, class... Categories>
+    struct MinimalIteratorCategory<Cat0, Categories...>
+    {
+      using type = typename MinimalIteratorCategory<Cat0, typename MinimalIteratorCategory<Categories...>::type>::type;
+    };
+
+    template <class Cat0, class Cat1>
+    struct MinimalIteratorCategory<Cat0, Cat1>
+    {
+      using type = std::conditional_t<std::is_convertible<Cat0, Cat1>::value, Cat1, Cat0>;
+    };
+
+    template <class Cat>
+    struct MinimalIteratorCategory<Cat>
+    {
+      using type = Cat;
+    };
+
+
+    template <class... Iterators>
+    class ZipIteratorImpl<std::forward_iterator_tag, Iterators...>
+    {
+    public:
+      using iterator_category = std::forward_iterator_tag;
+      using value_type = std::tuple<typename std::iterator_traits<Iterators>::value_type...>;
+      using difference_type = std::common_type_t<typename std::iterator_traits<Iterators>::difference_type...>;
+      using reference = std::tuple<typename std::iterator_traits<Iterators>::reference...>;
+
+    public:
+      explicit ZipIteratorImpl(Iterators... iterators)
+        : iterators_(iterators...)
+      {}
+
+      // preincrement
+      ZipIteratorImpl& operator++()
+      {
+        Tools::for_each(iterators_, [](auto& it) { ++it; });
+        return *this;
+      }
+
+      // postincrement
+      ZipIteratorImpl operator++(int)
+      {
+        ZipIteratorImpl tmp = *this;
+        ++(*this);
+        return tmp;
+      }
+
+      /// Compar all iterators by equality
+      template <class... Its>
+      bool operator==(ZipIterator<Its...> const& other) const
+      {
+        static_assert(sizeof...(Iterators) == sizeof...(Its), "");
+        return iterators_ == other.iterators_;
+      }
+
+      /// Compar all iterators by inequality
+      template <class... Its>
+      bool operator!=(ZipIterator<Its...> const& other) const
+      {
+        return !(*this == other);
+      }
+
+      /// Return a tuple of const references to the derenferenced iterators
+      auto operator*() const
+      {
+        return Tools::apply([](auto... it) { return std::tie(*it...); }, iterators_);
+      }
+
+      /// Return a tuple of mutable references to the derenferenced iterators
+      auto operator*()
+      {
+        return Tools::apply([](auto... it) { return std::tie(*it...); }, iterators_);
+      }
+
+    protected:
+      std::tuple<Iterators...> iterators_;
+    };
+
+
+    template <class... Iterators>
+    class ZipIteratorImpl<std::bidirectional_iterator_tag, Iterators...>
+        : public ZipIteratorImpl<std::forward_iterator_tag, Iterators...>
+    {
+      using Super = ZipIteratorImpl<std::forward_iterator_tag, Iterators...>;
+
+    public:
+      using iterator_category = std::bidirectional_iterator_tag;
+      using value_type = typename Super::value_type;
+      using difference_type = typename Super::difference_type;
+      using reference = typename Super::reference;
+
+    public:
+      using Super::ZipIteratorImpl;
+
+      // predecrement
+      ZipIteratorImpl& operator--()
+      {
+        Tools::for_each(iterators_, [](auto& it) { --it; });
+        return *this;
+      }
+
+      // postdecrement
+      ZipIteratorImpl operator--(int)
+      {
+        ZipIteratorImpl tmp = *this;
+        --(*this);
+        return tmp;
+      }
+
+    protected:
+      using Super::iterators_;
+    };
+
+
+    template <class... Iterators>
+    class ZipIteratorImpl<std::random_access_iterator_tag, Iterators...>
+        : public ZipIteratorImpl<std::bidirectional_iterator_tag, Iterators...>
+    {
+      using Super = ZipIteratorImpl<std::bidirectional_iterator_tag, Iterators...>;
+
+    public:
+      using iterator_category = std::random_access_iterator_tag;
+      using value_type = typename Super::value_type;
+      using difference_type = typename Super::difference_type;
+      using reference = typename Super::reference;
+
+    public:
+      using Super::ZipIteratorImpl;
+
+      // less-than comparison of all iterators
+      template <class... Its>
+      bool operator<(ZipIterator<Its...> const& other) const
+      {
+        static_assert(sizeof...(Iterators) == sizeof...(Its), "");
+        return iterators_ < other.iterators_;
+      }
+
+      // hreater-than comparison of all iterators
+      template <class... Its>
+      bool operator>(ZipIterator<Its...> const& other) const
+      {
+        static_assert(sizeof...(Iterators) == sizeof...(Its), "");
+        return iterators_ > other.iterators_;
+      }
+
+      // less-than-or-equals comparison of all iterators
+      template <class... Its>
+      bool operator<=(ZipIterator<Its...> const& other) const
+      {
+        static_assert(sizeof...(Iterators) == sizeof...(Its), "");
+        return iterators_ <= other.iterators_;
+      }
+
+      // greater-than-or-equals comparison of all iterators
+      template <class... Its>
+      bool operator>=(ZipIterator<Its...> const& other) const
+      {
+        static_assert(sizeof...(Iterators) == sizeof...(Its), "");
+        return iterators_ >= other.iterators_;
+      }
+
+      /// Increment all iterators by shift n
+      ZipIteratorImpl& operator+=(difference_type n)
+      {
+        Tools::for_each(iterators_, [n](auto& it) { it += n; });
+        return *this;
+      }
+
+      /// Decrement all iterators by shift n
+      ZipIteratorImpl& operator-=(difference_type n)
+      {
+        Tools::for_each(iterators_, [n](auto& it) { it -= n; });
+        return *this;
+      }
+
+      /// Return shifted iterator
+      friend ZipIteratorImpl operator+(ZipIteratorImpl const& zip, difference_type n)
+      {
+        auto shift = [n](auto it) { return it + n; };
+        return Tools::apply([&](auto... it) { return ZipIteratorImpl(shift(it)...); }, zip.iterators_);
+      }
+
+      /// Return shifted iterator
+      friend ZipIteratorImpl operator+(difference_type n, ZipIteratorImpl const& zip)
+      {
+        auto shift = [n](auto it) { return n + it; };
+        return Tools::apply([&](auto... it) { return ZipIteratorImpl(shift(it)...); }, zip.iterators_);
+      }
+
+      /// Return shifted iterator
+      friend ZipIteratorImpl operator-(ZipIteratorImpl const& zip, difference_type n)
+      {
+        auto shift = [n](auto it) { return it - n; };
+        return Tools::apply([&](auto... it) { return ZipIteratorImpl(shift(it)...); }, zip.iterators_);
+      }
+
+
+      /// Return minimal difference between two zipped iterators
+      template <class... Its>
+      difference_type operator-(ZipIteratorImpl<std::random_access_iterator_tag, Its...> const& other)
+      {
+        static_assert(sizeof...(Iterators) == sizeof...(Its), "");
+        auto diff = [&](auto i) -> difference_type
+        {
+          using std::get;
+          return get<VALUE(i)>(this->iterators_) - get<VALUE(i)>(other.iterators_);
+        };
+        return Tools::apply_indices<sizeof...(Iterators)>([diff](auto... i) { return Math::min(diff(i)...); });
+      }
+
+
+      /// Return a tuple of const references to the derenferenced iterators
+      auto operator[](difference_type n) const
+      {
+        return Tools::apply([n](auto... it) { return std::tie(it[n]...); }, iterators_);
+      }
+
+      /// Return a tuple of mutable references to the derenferenced iterators
+      auto operator[](difference_type n)
+      {
+        return Tools::apply([n](auto... it) { return std::tie(it[n]...); }, iterators_);
+      }
+
+    protected:
+      using Super::iterators_;
+    };
+
+  } // end namespace Impl
+}
\ No newline at end of file
diff --git a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
index 6fa5a361..cd52ef85 100644
--- a/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
+++ b/src/amdis/linearalgebra/istl/BCRSMatrix.hpp
@@ -75,17 +75,17 @@ namespace AMDiS
     template <class Row, class ColIter, class ColValues>
     void clear_col_impl(Row row, ColIter const& col, ColValues& col_values)
     {
+      if (matrix_.nonzeroes() == 0u)
+        return;
+
       // iterate over the column
       push_back(row);
+      size_type j = *col;
       for (size_type i = 0; i < matrix_.N(); ++i) {
-        auto cIt = matrix_[i].begin();
-        auto cEndIt = matrix_[i].end();
-        for (; cIt != cEndIt; ++cIt) {
-          if (cIt.index() == *col) {
-            back(row) = i;
-            matrixWrapper(*cIt).clear_col(row, col.next(), col_values);
-            break;
-          }
+        auto cIt = matrix_[i].find(j);
+        if (cIt != matrix_[i].end()) {
+          back(row) = i;
+          matrixWrapper(*cIt).clear_col(row, col.next(), col_values);
         }
       }
     }
diff --git a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
index 68078f5c..6620696b 100644
--- a/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
+++ b/src/amdis/linearalgebra/mtl/MtlMatrix.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <cassert>
 
 #include <boost/numeric/mtl/matrix/compressed2D.hpp>
@@ -9,6 +10,7 @@
 #include <boost/numeric/mtl/utility/range_wrapper.hpp>
 
 #include <amdis/Output.hpp>
+#include <amdis/common/Iterator.hpp>
 #include <amdis/common/StaticSize.hpp>
 #include <amdis/linearalgebra/MatrixInserter.hpp>
 #include <amdis/linearalgebra/MatrixWrapper.hpp>
@@ -112,7 +114,6 @@ namespace AMDiS
       size_type node = *row;
 
       // Define the property maps
-      auto row_of = mtl::mat::row_map(matrix_);
       auto col_of = mtl::mat::col_map(matrix_);
       auto value  = mtl::mat::value_map(matrix_);
 
@@ -127,14 +128,19 @@ namespace AMDiS
           value(i, value_type(0));
         }
       } else {
-        for (auto c : mtl::major_of(matrix_)) {
-          for (auto i : mtl::nz_of(c)) {
-            if (row_of(i) == node) {
-              back(col) = col_of(i);
-              row_values.emplace_back(row.multiIndex(), col, value(i));
-              value(i, value_type(0));
-              break;
-            }
+        for (size_type c = 0; c < num_rows(matrix_); ++c) {
+          size_type offset = matrix_.ref_major()[c];
+
+          const size_type* row_begin     = matrix_.address_minor() + offset;
+          const size_type* const row_end = matrix_.address_minor() + offset + matrix_.nnz_local(c);
+          value_type* val_begin          = matrix_.address_data() + offset;
+
+          auto it = std::lower_bound(row_begin, row_end, node);
+          if (it != row_end && *it == node) {
+            back(col) = c;
+            auto val_it = val_begin + std::distance(row_begin, it);
+            row_values.emplace_back(row.multiIndex(), col, *val_it);
+            *val_it = value_type(0);
           }
         }
       }
@@ -147,21 +153,25 @@ namespace AMDiS
 
       // Define the property maps
       auto row_of = mtl::mat::row_map(matrix_);
-      auto col_of = mtl::mat::col_map(matrix_);
       auto value  = mtl::mat::value_map(matrix_);
 
       // iterate over the column
       push_back(row);
       if (std::is_same<typename BaseMatrix::orientation, mtl::tag::row_major>::value)
       {
-        for (auto r : mtl::major_of(matrix_)) {
-          for (auto i : mtl::nz_of(r)) {
-            if (col_of(i) == node) {
-              back(row) = row_of(i);
-              col_values.emplace_back(row, col.multiIndex(), value(i));
-              value(i, value_type(0));
-              break;
-            }
+        for (size_type r = 0; r < num_rows(matrix_); ++r) {
+          size_type offset = matrix_.ref_major()[r];
+
+          const size_type* col_begin     = matrix_.address_minor() + offset;
+          const size_type* const col_end = matrix_.address_minor() + offset + matrix_.nnz_local(r);
+          value_type* val_begin          = matrix_.address_data() + offset;
+
+          auto it = std::lower_bound(col_begin, col_end, node);
+          if (it != col_end && *it == node) {
+            back(row) = r;
+            auto val_it = val_begin + std::distance(col_begin, it);
+            col_values.emplace_back(row, col.multiIndex(), *val_it);
+            *val_it = value_type(0);
           }
         }
       } else {
-- 
GitLab


From c6785bd36673e4df192761be9cb6b60c4c81d842 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 22 May 2019 12:42:59 +0200
Subject: [PATCH 37/38] add test for zip iterator

---
 src/amdis/common/Iterator.hpp | 75 +++++++++++++++++++++++++----------
 test/CMakeLists.txt           |  3 ++
 test/IteratorTest.cpp         | 73 ++++++++++++++++++++++++++++++++++
 3 files changed, 131 insertions(+), 20 deletions(-)
 create mode 100644 test/IteratorTest.cpp

diff --git a/src/amdis/common/Iterator.hpp b/src/amdis/common/Iterator.hpp
index 4f6f2a15..8002bc5b 100644
--- a/src/amdis/common/Iterator.hpp
+++ b/src/amdis/common/Iterator.hpp
@@ -1,6 +1,14 @@
 #pragma once
 
 #include <iterator>
+#include <tuple>
+#include <type_traits>
+
+#include <amdis/common/Apply.hpp>
+#include <amdis/common/ForEach.hpp>
+#include <amdis/common/Logical.hpp>
+#include <amdis/common/Math.hpp>
+#include <amdis/common/TypeTraits.hpp>
 
 namespace AMDiS
 {
@@ -15,15 +23,17 @@ namespace AMDiS
     struct MinimalIteratorCategory;
   }
 
+  /// The minimal iterator categories the passed iterators have in common
   template <class... Iterators>
   using MinimalIteratorCategory_t
     = typename Impl::MinimalIteratorCategory<typename std::iterator_traits<Iterators>::iterator_category...>::type;
 
+  /// Type of a zipped iterator created by \ref zip_iterator
   template <class... Iterators>
   using ZipIterator
     = Impl::ZipIteratorImpl<MinimalIteratorCategory_t<Iterators...>, Iterators...>;
 
-  /// Zip the passed iterator to form a new iterator that parallel iterates through the individual elements
+  /// Zip the passed iterator to form a new iterator that iterates in parallel through the individual elements
   template <class... Iterators>
   ZipIterator<Iterators...> zip_iterator(Iterators... iterators)
   {
@@ -52,6 +62,7 @@ namespace AMDiS
     };
 
 
+    // implementation for forward iterators
     template <class... Iterators>
     class ZipIteratorImpl<std::forward_iterator_tag, Iterators...>
     {
@@ -60,20 +71,24 @@ namespace AMDiS
       using value_type = std::tuple<typename std::iterator_traits<Iterators>::value_type...>;
       using difference_type = std::common_type_t<typename std::iterator_traits<Iterators>::difference_type...>;
       using reference = std::tuple<typename std::iterator_traits<Iterators>::reference...>;
+      using pointer = void;
+
+      template <class Cat, class... Its>
+      friend class ZipIteratorImpl;
 
     public:
       explicit ZipIteratorImpl(Iterators... iterators)
         : iterators_(iterators...)
       {}
 
-      // preincrement
+      /// pre-increment all iterators
       ZipIteratorImpl& operator++()
       {
         Tools::for_each(iterators_, [](auto& it) { ++it; });
         return *this;
       }
 
-      // postincrement
+      /// post-increment all iterators
       ZipIteratorImpl operator++(int)
       {
         ZipIteratorImpl tmp = *this;
@@ -81,7 +96,7 @@ namespace AMDiS
         return tmp;
       }
 
-      /// Compar all iterators by equality
+      /// Compare all iterators by ==
       template <class... Its>
       bool operator==(ZipIterator<Its...> const& other) const
       {
@@ -89,20 +104,20 @@ namespace AMDiS
         return iterators_ == other.iterators_;
       }
 
-      /// Compar all iterators by inequality
+      /// Compare all iterators by !=
       template <class... Its>
       bool operator!=(ZipIterator<Its...> const& other) const
       {
         return !(*this == other);
       }
 
-      /// Return a tuple of const references to the derenferenced iterators
+      /// Return a tuple of const references to the dereferenced iterators
       auto operator*() const
       {
         return Tools::apply([](auto... it) { return std::tie(*it...); }, iterators_);
       }
 
-      /// Return a tuple of mutable references to the derenferenced iterators
+      /// Return a tuple of mutable references to the dereferenced iterators
       auto operator*()
       {
         return Tools::apply([](auto... it) { return std::tie(*it...); }, iterators_);
@@ -113,6 +128,7 @@ namespace AMDiS
     };
 
 
+    // Implementation for bidirectional iterators. Derived the methods from the forward iterators implementation.
     template <class... Iterators>
     class ZipIteratorImpl<std::bidirectional_iterator_tag, Iterators...>
         : public ZipIteratorImpl<std::forward_iterator_tag, Iterators...>
@@ -124,18 +140,22 @@ namespace AMDiS
       using value_type = typename Super::value_type;
       using difference_type = typename Super::difference_type;
       using reference = typename Super::reference;
+      using pointer = typename Super::pointer;
+
+      template <class Cat, class... Its>
+      friend class ZipIteratorImpl;
 
     public:
       using Super::ZipIteratorImpl;
 
-      // predecrement
+      /// pre-decrement of all iterators
       ZipIteratorImpl& operator--()
       {
         Tools::for_each(iterators_, [](auto& it) { --it; });
         return *this;
       }
 
-      // postdecrement
+      /// post-decrement of all iterators
       ZipIteratorImpl operator--(int)
       {
         ZipIteratorImpl tmp = *this;
@@ -148,6 +168,7 @@ namespace AMDiS
     };
 
 
+    // Implementation for random-access iterators. Derived the methods from the bidirectional iterators implementation.
     template <class... Iterators>
     class ZipIteratorImpl<std::random_access_iterator_tag, Iterators...>
         : public ZipIteratorImpl<std::bidirectional_iterator_tag, Iterators...>
@@ -159,13 +180,17 @@ namespace AMDiS
       using value_type = typename Super::value_type;
       using difference_type = typename Super::difference_type;
       using reference = typename Super::reference;
+      using pointer = typename Super::pointer;
+
+      template <class Cat, class... Its>
+      friend class ZipIteratorImpl;
 
     public:
       using Super::ZipIteratorImpl;
 
       // less-than comparison of all iterators
       template <class... Its>
-      bool operator<(ZipIterator<Its...> const& other) const
+      bool operator<(ZipIteratorImpl<std::random_access_iterator_tag, Its...> const& other) const
       {
         static_assert(sizeof...(Iterators) == sizeof...(Its), "");
         return iterators_ < other.iterators_;
@@ -173,7 +198,7 @@ namespace AMDiS
 
       // hreater-than comparison of all iterators
       template <class... Its>
-      bool operator>(ZipIterator<Its...> const& other) const
+      bool operator>(ZipIteratorImpl<std::random_access_iterator_tag, Its...> const& other) const
       {
         static_assert(sizeof...(Iterators) == sizeof...(Its), "");
         return iterators_ > other.iterators_;
@@ -181,7 +206,7 @@ namespace AMDiS
 
       // less-than-or-equals comparison of all iterators
       template <class... Its>
-      bool operator<=(ZipIterator<Its...> const& other) const
+      bool operator<=(ZipIteratorImpl<std::random_access_iterator_tag, Its...> const& other) const
       {
         static_assert(sizeof...(Iterators) == sizeof...(Its), "");
         return iterators_ <= other.iterators_;
@@ -189,7 +214,7 @@ namespace AMDiS
 
       // greater-than-or-equals comparison of all iterators
       template <class... Its>
-      bool operator>=(ZipIterator<Its...> const& other) const
+      bool operator>=(ZipIteratorImpl<std::random_access_iterator_tag, Its...> const& other) const
       {
         static_assert(sizeof...(Iterators) == sizeof...(Its), "");
         return iterators_ >= other.iterators_;
@@ -210,24 +235,24 @@ namespace AMDiS
       }
 
       /// Return shifted iterator
-      friend ZipIteratorImpl operator+(ZipIteratorImpl const& zip, difference_type n)
+      ZipIteratorImpl operator+(difference_type n) const
       {
         auto shift = [n](auto it) { return it + n; };
-        return Tools::apply([&](auto... it) { return ZipIteratorImpl(shift(it)...); }, zip.iterators_);
+        return Tools::apply([shift](auto... it) { return ZipIteratorImpl(shift(it)...); }, iterators_);
       }
 
       /// Return shifted iterator
       friend ZipIteratorImpl operator+(difference_type n, ZipIteratorImpl const& zip)
       {
         auto shift = [n](auto it) { return n + it; };
-        return Tools::apply([&](auto... it) { return ZipIteratorImpl(shift(it)...); }, zip.iterators_);
+        return Tools::apply([shift](auto... it) { return ZipIteratorImpl(shift(it)...); }, zip.iterators_);
       }
 
       /// Return shifted iterator
-      friend ZipIteratorImpl operator-(ZipIteratorImpl const& zip, difference_type n)
+      ZipIteratorImpl operator-(difference_type n) const
       {
         auto shift = [n](auto it) { return it - n; };
-        return Tools::apply([&](auto... it) { return ZipIteratorImpl(shift(it)...); }, zip.iterators_);
+        return Tools::apply([shift](auto... it) { return ZipIteratorImpl(shift(it)...); }, iterators_);
       }
 
 
@@ -245,13 +270,13 @@ namespace AMDiS
       }
 
 
-      /// Return a tuple of const references to the derenferenced iterators
+      /// Return a tuple of const references to the dereferenced iterators
       auto operator[](difference_type n) const
       {
         return Tools::apply([n](auto... it) { return std::tie(it[n]...); }, iterators_);
       }
 
-      /// Return a tuple of mutable references to the derenferenced iterators
+      /// Return a tuple of mutable references to the dereferenced iterators
       auto operator[](difference_type n)
       {
         return Tools::apply([n](auto... it) { return std::tie(it[n]...); }, iterators_);
@@ -262,4 +287,14 @@ namespace AMDiS
     };
 
   } // end namespace Impl
+} // end namespace AMDiS
+
+namespace std
+{
+  template <class... Types,
+    enable_if_t<AMDiS::all_of_v<is_swappable<Types>::value...>, int> = 0>
+  void swap(tuple<Types&...> lhs, tuple<Types&...> rhs)
+  {
+    AMDiS::Tools::for_range<0,sizeof...(Types)>([&](auto i) { swap(get<VALUE(i)>(lhs), get<VALUE(i)>(rhs)); });
+  }
 }
\ No newline at end of file
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 611ae689..c4808364 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -59,6 +59,9 @@ dune_add_test(SOURCES IntegrateTest.cpp
   LINK_LIBRARIES amdis
   CMD_ARGS "${CMAKE_SOURCE_DIR}/examples/init/ellipt.dat.2d")
 
+dune_add_test(SOURCES IteratorTest.cpp
+  LINK_LIBRARIES amdis)
+
 dune_add_test(SOURCES MarkerTest.cpp
   LINK_LIBRARIES amdis)
 
diff --git a/test/IteratorTest.cpp b/test/IteratorTest.cpp
new file mode 100644
index 00000000..b0b43541
--- /dev/null
+++ b/test/IteratorTest.cpp
@@ -0,0 +1,73 @@
+#include <algorithm>
+#include <array>
+#include <forward_list>
+#include <iostream>
+#include <list>
+#include <string>
+#include <vector>
+
+#include <amdis/common/Iterator.hpp>
+
+using namespace AMDiS;
+
+template <class First, class Last>
+void print(First first, Last last)
+{
+  std::transform(first, last, std::ostream_iterator<std::string>(std::cout, " "), [](auto const& t)
+  {
+    std::string out = "{" + std::to_string(std::get<0>(t));
+    Tools::for_range<1,std::tuple_size<TYPEOF(t)>::value>([&](auto i) { out += ", " + std::to_string(std::get<VALUE(i)>(t)); });
+    return out + "}";
+  });
+  std::cout << "\n";
+}
+
+int main()
+{
+  std::array<double, 5> a{1.0, 2.0, 3.0, 4.0, 5.0};
+  std::list<int> l{5, 4, 3, 2, 1};
+  std::forward_list<float> f{3.f, 2.f, 5.f, 1.f, 4.f};
+  std::vector<char> v{'a', 'b', 'c', 'd', 'e'};
+
+
+  // zip all iterators -> forward_iterator
+  auto zip_begin = zip_iterator(std::begin(a), std::begin(l), std::begin(f), std::begin(v));
+  auto zip_end = zip_iterator(std::end(a), std::end(l), std::end(f), std::end(v));
+
+  static_assert(std::is_same<typename std::iterator_traits<TYPEOF(zip_begin)>::iterator_category, std::forward_iterator_tag>::value, "");
+
+  std::cout << "zip...\n";
+  print(zip_begin, zip_end);
+
+  std::for_each(zip_begin, zip_end, [](auto&& t) { std::get<0>(t) += 2.0; std::get<1>(t) -= 2; });
+  std::cout << "for_each...\n";
+  print(zip_begin, zip_end);
+
+
+  // zip only the bidirectional iterators
+  auto bd_begin = zip_iterator(std::begin(a), std::begin(l), std::begin(v));
+  auto bd_end = zip_iterator(std::end(a), std::end(l), std::end(v));
+
+  static_assert(std::is_same<typename std::iterator_traits<TYPEOF(bd_begin)>::iterator_category, std::bidirectional_iterator_tag>::value, "");
+
+  std::cout << "bd...\n";
+  print(bd_begin, bd_end);
+
+  std::reverse(bd_begin, bd_end);
+  std::cout << "reversed...\n";
+  print(bd_begin, bd_end);
+
+
+  // zip only the random-access iterators
+  auto ra_begin = zip_iterator(std::begin(a), std::begin(v));
+  auto ra_end = zip_iterator(std::end(a), std::end(v));
+
+  static_assert(std::is_same<typename std::iterator_traits<TYPEOF(ra_begin)>::iterator_category, std::random_access_iterator_tag>::value, "");
+
+  std::cout << "ra...\n";
+  print(ra_begin, ra_end);
+
+  std::random_shuffle(ra_begin, ra_end);
+  std::cout << "random_shuffle...\n";
+  print(ra_begin, ra_end);
+}
-- 
GitLab


From 25bba5b5b4b66637672286111526dc377f147a38 Mon Sep 17 00:00:00 2001
From: Simon Praetorius <simon.praetorius@tu-dresden.de>
Date: Wed, 22 May 2019 13:24:49 +0200
Subject: [PATCH 38/38] removed is_swappable concept check for tuple swapping

---
 src/amdis/common/Iterator.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/amdis/common/Iterator.hpp b/src/amdis/common/Iterator.hpp
index 8002bc5b..aac66c3b 100644
--- a/src/amdis/common/Iterator.hpp
+++ b/src/amdis/common/Iterator.hpp
@@ -291,8 +291,7 @@ namespace AMDiS
 
 namespace std
 {
-  template <class... Types,
-    enable_if_t<AMDiS::all_of_v<is_swappable<Types>::value...>, int> = 0>
+  template <class... Types>
   void swap(tuple<Types&...> lhs, tuple<Types&...> rhs)
   {
     AMDiS::Tools::for_range<0,sizeof...(Types)>([&](auto i) { swap(get<VALUE(i)>(lhs), get<VALUE(i)>(rhs)); });
-- 
GitLab