Refactor GSStepTest.

dune/solvers/test/gssteptest.cc

@@ -71,66 +71,44 @@ struct GSTestSuite
     using Vector = typename Problem::Vector;
 
     Analyser<Vector> analyser(p.u_ex, p.energyNorm, solveTol);
-    {
-      Vector u_copy = p.u;
-      Vector rhs_copy = p.rhs;
 
-      using GSStep = BlockGSStep<Matrix, Vector>;
-      GSStep gsStep;
-      gsStep.setProblem(p.A, u_copy, rhs_copy);
-      typename GSStep::BitVector ignore(u_copy.size(), false);
-      gsStep.ignoreNodes_ = &ignore;
+    using LoopSolver = ::LoopSolver<Vector>;
+    using Step = LinearIterationStep<Matrix, Vector>;
 
-      ::LoopSolver<typename Problem::Vector> solver(
-            &gsStep, maxIterations, stepTol, &p.energyNorm, verbosity,
-            relativeErrors);
-      solver.check();
-      solver.preprocess();
-      solver.solve();
-
-      passed = passed and analyser.analyse(u_copy, "BlockGS");
-    }
-    {
+    auto test = [&](Step* step, std::string name) {
       Vector u_copy = p.u;
       Vector rhs_copy = p.rhs;
 
-      using GSStep = SemiDefiniteBlockGSStep<Matrix, Vector>;
-      GSStep gsStep;
-      gsStep.setProblem(p.A, u_copy, rhs_copy);
-      typename GSStep::BitVector ignore(u_copy.size(), false);
-      gsStep.ignoreNodes_ = &ignore;
+      step->setProblem(p.A, u_copy, rhs_copy);
+      typename Step::BitVector ignore(u_copy.size(), false);
+      step->ignoreNodes_ = &ignore;
 
-      ::LoopSolver<typename Problem::Vector> solver(
-            &gsStep, maxIterations, stepTol, &p.energyNorm, verbosity,
-            relativeErrors);
+      LoopSolver solver(step, maxIterations, stepTol,
+                        &p.energyNorm, verbosity, relativeErrors);
       solver.check();
       solver.preprocess();
       solver.solve();
 
-      passed = passed and analyser.analyse(u_copy, "SemiDefiniteBlockGS");
-    }
+      passed = passed and analyser.analyse(u_copy, name);
+    };
+
     {
-      Vector u_copy = p.u;
-      Vector rhs_copy = p.rhs;
+      BlockGSStep<Matrix, Vector> gsStep;
+      test(&gsStep, "BlockGS");
+    }
 
-      using GSStep = SemiDefiniteBlockGSStep<Matrix, Vector>;
+    for(auto reg : {false, true}) {
+      for(auto type : {"direct", "ldlt", "cg"}) {
         Dune::ParameterTree config;
-      config["regularize_diagonal"] = "true";
-
-      GSStep gsStep;
-      gsStep.setProblem(p.A, u_copy, rhs_copy);
-      typename GSStep::BitVector ignore(u_copy.size(), false);
-      gsStep.ignoreNodes_ = &ignore;
+        config["type"] = type;
+        config["regularize_diagonal"] = reg ? "1" : "0";
 
-      ::LoopSolver<typename Problem::Vector> solver(
-            &gsStep, maxIterations, stepTol, &p.energyNorm, verbosity,
-            relativeErrors);
-      solver.check();
-      solver.preprocess();
-      solver.solve();
-
-      passed = passed and analyser.analyse(u_copy, "SemiDefiniteBlockGS regularized");
+        SemiDefiniteBlockGSStep<Matrix, Vector> gsStep(config);
+        test(&gsStep, Dune::formatString("SemiDefiniteBlockGS %s %s",
+                                         type, reg ? "regularized" : ""));
       }
+    }
+
     return passed;
   }
 };