Tests: Check if ignoreNodes are honoured

dune/solvers/test/cgsteptest.cc

@@ -148,6 +148,36 @@ struct CGTestSuite
 
             passed &= analyser.analyse(u_copy, testCase);
         }
+
+        // Test that ignoreNodes are honoured.
+        {
+          typename Problem::Vector u_copy = p.u;
+          for (size_t i = 0; i < p.u.size(); ++i)
+            if (p.ignore[i].any())
+              u_copy[i] += 1.0;
+          typename Problem::Vector rhs_copy = p.rhs;
+
+          Dune::Solvers::CGStep<typename Problem::Matrix,
+                                typename Problem::Vector>
+              cgStep(p.A, u_copy, rhs_copy);
+          cgStep.setIgnore(p.ignore);
+          ::LoopSolver<typename Problem::Vector> solver(
+              &cgStep, maxIterations, stepTol, &p.energyNorm, Solver::QUIET,
+              relativeErrors);
+          solver.check();
+          solver.preprocess();
+          solver.solve();
+
+          for (size_t i = 0; i < p.u.size(); ++i)
+            if (p.ignore[i].any())
+              if (std::abs(u_copy[i] - 1.0 - p.u_ex[i]) > solveTol) {
+                std::cerr << "### error: ignoredNodes not respected!"
+                          << std::endl;
+                passed = false;
+                break;
+              }
+        }
+
         return passed;
     }
 };

dune/solvers/test/gssteptest.cc

@@ -156,6 +156,36 @@ struct GSTestSuite {
       }
     }
 
+    // Test that ignoreNodes are honoured.
+    {
+      auto gsStep = Dune::Solvers::BlockGSStepFactory<Matrix, Vector>::create(
+          Dune::Solvers::BlockGS::LocalSolvers::ldlt(0.0));
+
+      Vector u_copy = p.u;
+      for (size_t i = 0; i < p.u.size(); ++i)
+        for (size_t j = 0; j < blocksize; ++j)
+          if (p.ignore[i][j])
+            u_copy[i][j] += 1.0;
+
+      gsStep.setProblem(p.A, u_copy, p.rhs);
+      gsStep.setIgnore(p.ignore);
+      LoopSolver solver(&gsStep, 2000, 1e-8, &p.energyNorm, Solver::QUIET,
+                        relativeErrors);
+      solver.check();
+      solver.preprocess();
+      solver.solve();
+
+      for (size_t i = 0; i < p.u.size(); ++i)
+        for (size_t j = 0; j < blocksize; ++j)
+          if (p.ignore[i][j])
+            if (std::abs(u_copy[i][j] - 1.0 - p.u_ex[i][j]) > 1e-8) {
+              std::cerr << "### error: ignoredNodes not respected!"
+                        << std::endl;
+              passed = false;
+              break;
+            }
+    }
+
     // test projected block GS
     if (trivialDirichletOnly) // TODO: missing feature in ProjectedBlockGS
     {