[Extend] Give each solver its own parameters

The solvers for u0/a0 and v now each have parameters tolerance,
maximumIterations, verbosity

src/one-body-sample.cc

@@ -363,19 +363,19 @@ int main(int argc, char *argv[]) {
                                             refinements, *grid,
                                             displacementDirichletNodes);
       auto multigridStep = displacementFactory.getSolver();
-      auto const verbosity = parset.get<Solver::VerbosityMode>("io.verbosity");
 
       typename LinearFactoryType::ConvexProblemType myConvexProblem(
           1.0, A, zeroNonlinearity, ell, u_initial);
       typename LinearFactoryType::BlockProblemType initialDisplacementProblem(
           parset, myConvexProblem);
 
+      Dune::ParameterTree const &localParset = parset.sub("u0.solver");
       multigridStep->setProblem(u_initial, initialDisplacementProblem);
       LoopSolver<VectorType> initialDisplacementProblemSolver(
-          multigridStep,
-          parset.get<size_t>("solver.tnnmg.maxiterations"), // FIXME
-          1e-12,                                            // FIXME
-          &ANorm, verbosity, false);                        // absolute error
+          multigridStep, localParset.get<size_t>("maximumIterations"),
+          localParset.get<double>("tolerance"), &ANorm,
+          localParset.get<Solver::VerbosityMode>("verbosity"),
+          false); // absolute error
 
       initialDisplacementProblemSolver.preprocess();
       initialDisplacementProblemSolver.solve();
@@ -411,23 +411,23 @@ int main(int argc, char *argv[]) {
         // instead of multiplying M by (1.0 - wc), we divide the RHS
         accelerationRHS *= -1.0 / (1.0 - wc);
       }
-      LinearFactoryType accelerationFactory(parset.sub("solver.tnnmg"),
+      LinearFactoryType accelerationFactory(parset.sub("solver.tnnmg"), // FIXME
                                             refinements, *grid,
                                             accelerationDirichletNodes);
       auto multigridStep = accelerationFactory.getSolver();
-      auto const verbosity = parset.get<Solver::VerbosityMode>("io.verbosity");
 
       typename LinearFactoryType::ConvexProblemType myConvexProblem(
           1.0, M, zeroNonlinearity, accelerationRHS, a_initial);
       typename LinearFactoryType::BlockProblemType initialAccelerationProblem(
           parset, myConvexProblem);
 
+      Dune::ParameterTree const &localParset = parset.sub("a0.solver");
       multigridStep->setProblem(a_initial, initialAccelerationProblem);
       LoopSolver<VectorType> initialAccelerationProblemSolver(
-          multigridStep,
-          parset.get<size_t>("solver.tnnmg.maxiterations"), // FIXME
-          1e-12,                                            // FIXME
-          &MNorm, verbosity, false);                        // absolute error
+          multigridStep, localParset.get<size_t>("maximumIterations"),
+          localParset.get<double>("tolerance"), &MNorm,
+          localParset.get<Solver::VerbosityMode>("verbosity"),
+          false); // absolute error
 
       initialAccelerationProblemSolver.preprocess();
       initialAccelerationProblemSolver.solve();
@@ -435,7 +435,6 @@ int main(int argc, char *argv[]) {
     // }}}
 
     // Set up TNNMG solver
-    auto const solverTolerance = parset.get<double>("solver.tolerance");
     using NonlinearFactoryType = SolverFactory<
         dims,
         MyBlockProblem<ConvexProblem<
@@ -444,7 +443,6 @@ int main(int argc, char *argv[]) {
     NonlinearFactoryType factory(parset.sub("solver.tnnmg"), refinements, *grid,
                                  velocityDirichletNodes);
     auto multigridStep = factory.getSolver();
-    auto const verbosity = parset.get<Solver::VerbosityMode>("io.verbosity");
 
     {
       std::fstream coordinateWriter("coordinates", std::fstream::out);
@@ -481,6 +479,11 @@ int main(int argc, char *argv[]) {
     auto const requiredReduction =
         parset.get<double>("solver.requiredReduction");
     auto const printProgress = parset.get<bool>("io.printProgress");
+    auto const verbosity =
+        parset.get<Solver::VerbosityMode>("v.solver.verbosity");
+    auto const maximumIterations =
+        parset.get<size_t>("v.solver.maximumIterations");
+    auto const tolerance = parset.get<double>("v.solver.tolerance");
     for (size_t run = 1; run <= timesteps; ++run) {
       VectorType u;
       double lastCorrection;
@@ -500,8 +503,8 @@ int main(int argc, char *argv[]) {
                                 velocityMatrix);
 
       LoopSolver<VectorType> velocityProblemSolver(
-          multigridStep, parset.get<size_t>("solver.tnnmg.maxiterations"),
-          solverTolerance, &AMNorm, verbosity, false); // absolute error
+          multigridStep, maximumIterations, tolerance, &AMNorm, verbosity,
+          false); // absolute error
 
       size_t iterationCounter;
       auto solveVelocityProblem = [&](VectorType &_velocityIterate,

src/one-body-sample.parset

 # -*- mode:conf -*-
 [io]
-verbosity     = quiet
 printProgress = false
 enableTimer   = false
 writeVTK      = false
@@ -32,6 +31,21 @@ scheme = newmark
 [grid]
 refinements = 4
 
+[u0.solver]
+tolerance         = 1e-10
+maximumIterations = 100000
+verbosity         = quiet
+
+[a0.solver]
+tolerance         = 1e-10
+maximumIterations = 100000
+verbosity         = quiet
+
+[v.solver]
+tolerance         = 1e-10
+maximumIterations = 100000
+verbosity         = quiet
+
 [solver]
 tolerance         = 1e-10
 damping           = 0.5