Tests: Clean up output and add benchmarking

dune/solvers/test/cgsteptest.cc

@@ -6,6 +6,7 @@
 #include <iostream>
 
 #include <dune/common/parallel/mpihelper.hh>
+#include <dune/common/timer.hh>
 
 #include <dune/solvers/solvers/loopsolver.hh>
 #include <dune/solvers/iterationsteps/blockgssteps.hh>
@@ -22,10 +23,11 @@ public:
     {}
 
     bool
-    analyse(typename Problem::Vector const &candidate, std::string testCase) {
+    analyse(typename Problem::Vector const &candidate,
+            SolverResult solverResult, double t, std::string testCase) {
         const auto twoNormDiff = p_.twoNorm.diff(p_.u_ex, candidate);
-        std::cout << "Defect two norm |u-u_n| for solver \"" << testCase
-                  << "\": " << twoNormDiff << std::endl;
+        printf("%f | %3zu | %11g | %11g | %s\n", t, solverResult.iterations,
+               solverResult.conv_rate, twoNormDiff, testCase.c_str());
         if (twoNormDiff > tolerance_) {
             std::cerr << "### Error too large for solver \"" << testCase << "\"."
                       << std::endl;
@@ -59,12 +61,44 @@ struct CGTestSuite
             SymmetricSampleProblem<1, typename GridType::LevelGridView>;
         Problem p(grid.levelGridView(grid.maxLevel()));
 
-        const auto verbosity = Solver::REDUCED;
+        const auto verbosity = Solver::QUIET;
         const bool relativeErrors = false;
 
+        // 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.twoNorm, 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;
+              }
+        }
+
+        // Test if we get the right solution and benchmark
         Analyser<Problem> analyser(p, solveTol);
+        Dune::Timer timer;
+        printf("time [s] | #it |  conv. rate | abs. error  | preconditioner\n");
         {
-            std::string const testCase = "Dune::Solvers::CGStep                ";
+            std::string const testCase = "none";
 
             typename Problem::Vector u_copy = p.u;
             typename Problem::Vector rhs_copy = p.rhs;
@@ -77,13 +111,15 @@ struct CGTestSuite
                 &cgStep, maxIterations, stepTol, &p.twoNorm, verbosity,
                 relativeErrors);
             solver.check();
+            timer.reset();
             solver.preprocess();
             solver.solve();
 
-            passed &= analyser.analyse(u_copy, testCase);
+            passed &= analyser.analyse(u_copy, solver.getResult(),
+                                       timer.elapsed(), testCase);
         }
         {
-            std::string const testCase = "Dune::Solvers::CGStep, preconditioned";
+            std::string const testCase = "BlockGS";
 
             typename Problem::Vector u_copy = p.u;
             typename Problem::Vector rhs_copy = p.rhs;
@@ -102,41 +138,13 @@ struct CGTestSuite
                 &cgStep, maxIterations, stepTol, &p.twoNorm, verbosity,
                 relativeErrors);
             solver.check();
+            timer.reset();
             solver.preprocess();
             solver.solve();
 
-            passed &= analyser.analyse(u_copy, testCase);
+            passed &= analyser.analyse(u_copy, solver.getResult(),
+                                       timer.elapsed(), 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.twoNorm, 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;
     }
 };