Control iterations per algorithm

Also rename some parset options

src/one-body-sample.cc

@@ -185,8 +185,6 @@ int main(int argc, char *argv[]) {
 
     auto const E = parset.get<double>("body.E");
     auto const nu = parset.get<double>("body.nu");
-    auto const solver_maxIterations =
-        parset.get<size_t>("solver.maxiterations");
     auto const solver_tolerance = parset.get<double>("solver.tolerance");
 
     auto const refinements = parset.get<size_t>("grid.refinements");
@@ -325,20 +323,22 @@ int main(int argc, char *argv[]) {
       stiffnessMatrix.mmv(u3, b3);
       stiffnessMatrix.mmv(u4, b4);
 
-      if (parset.get<bool>("useNonlinearGS")) {
+      if (parset.get<bool>("solver.nonlineargs.use")) {
         MyConvexProblemType myConvexProblem(stiffnessMatrix,
                                             *myGlobalNonlinearity, b1, u1_diff);
         MyBlockProblemType myBlockProblem(parset, myConvexProblem);
         nonlinearGSStep.setProblem(u1_diff, myBlockProblem);
 
-        LoopSolver<VectorType> solver(&nonlinearGSStep, solver_maxIterations,
-                                      solver_tolerance, &energyNorm, verbosity);
+        LoopSolver<VectorType> solver(
+            &nonlinearGSStep,
+            parset.get<size_t>("solver.nonlineargs.maxiterations"),
+            solver_tolerance, &energyNorm, verbosity);
         solver.solve();
       }
 
       u1 += u1_diff;
 
-      if (parset.get<bool>("useTNNMG")) {
+      if (parset.get<bool>("solver.tnnmg.use")) {
         MyConvexProblemType myConvexProblem(stiffnessMatrix,
                                             *myGlobalNonlinearity, b4, u4_diff);
 
@@ -369,8 +369,8 @@ int main(int argc, char *argv[]) {
         multigridStep.setProblem(u4_diff, myBlockProblem);
 
         LoopSolver<VectorType> overallSolver(
-            &multigridStep, solver_maxIterations, solver_tolerance, &energyNorm,
-            verbosity);
+            &multigridStep, parset.get<size_t>("solver.tnnmg.maxiterations"),
+            solver_tolerance, &energyNorm, verbosity);
         overallSolver.solve();
       }
 
@@ -399,13 +399,14 @@ int main(int argc, char *argv[]) {
         writer.write(filename.c_str());
       }
 
-      if (parset.get<bool>("useGS")) {
+      if (parset.get<bool>("solver.gs.use")) {
         BlockGSStep<OperatorType, VectorType> blockGSStep(stiffnessMatrix,
                                                           u2_diff, b2);
         blockGSStep.ignoreNodes_ = &ignoreNodes;
 
-        LoopSolver<VectorType> solver(&blockGSStep, solver_maxIterations,
-                                      solver_tolerance, &energyNorm, verbosity);
+        LoopSolver<VectorType> solver(
+            &blockGSStep, parset.get<size_t>("solver.gs.maxiterations"),
+            solver_tolerance, &energyNorm, verbosity);
         solver.solve();
       }
 
@@ -413,13 +414,15 @@ int main(int argc, char *argv[]) {
 
       // Use a linear solver for comparison; should return roughly the
       // same results if phi vanishes (e.g. because the normalstress is zero)
-      if (parset.get<bool>("useTruncatedGS")) {
+      if (parset.get<bool>("solver.truncatedgs.use")) {
         TruncatedBlockGSStep<OperatorType, VectorType> blockGSStep(
             stiffnessMatrix, u3_diff, b3);
         blockGSStep.ignoreNodes_ = &ignoreNodes;
 
-        LoopSolver<VectorType> solver(&blockGSStep, solver_maxIterations,
-                                      solver_tolerance, &energyNorm, verbosity);
+        LoopSolver<VectorType> solver(
+            &blockGSStep,
+            parset.get<size_t>("solver.truncatedgs.maxiterations"),
+            solver_tolerance, &energyNorm, verbosity);
         solver.solve();
       }
 

src/one-body-sample.parset

@@ -6,11 +6,6 @@ printFrictionalBoundary = false
 printProgress = true
 printDifference = false
 
-useNonlinearGS = false # true
-useGS = false
-useTruncatedGS = false
-useTNNMG = true
-
 [grid]
 refinements = 3
 
@@ -22,9 +17,24 @@ E = 1e6 # 2e6 is okay; at 5e6 we basically have no convergence
 nu = 0.3 # WARNING: At 0.48 we hardly have convergence; at 0.45 it's weird
 
 [solver]
-maxiterations = 1000000
 tolerance = 1e-12
 
+[solver.nonlineargs]
+use = true
+maxiterations = 1000000
+
+[solver.gs]
+use = false
+maxiterations = 1000000
+
+[solver.truncatedgs]
+use = false
+maxiterations = 100000
+
+[solver.tnnmg]
+use = true
+maxiterations = 1000000
+
 [solver.tnnmg.linear]
 maxiterations = 1000000
 nu1 = 1