Use lambda

src/one-body-sample.org

@@ -394,27 +394,30 @@
       timeSteppingScheme->setup(ell, tau, time,
                                 problem_rhs, problem_iterate, problem_A);
   
+      auto solveDisplacementProblem = [&](VectorType &_problem_iterate,
+                                          SingletonVectorType const &_alpha) {
+        auto myGlobalNonlinearity = assemble_nonlinearity<MatrixType, VectorType>
+        (parset.sub("boundary.friction"), *nodalIntegrals, _alpha,
+         surfaceNormalStress);
+  
+        MyConvexProblemType const myConvexProblem
+        (problem_A, *myGlobalNonlinearity, problem_rhs);
+        MyBlockProblemType myBlockProblem(parset, myConvexProblem);
+        auto multigridStep = mySolver.getSolver();
+        multigridStep->setProblem(_problem_iterate, myBlockProblem);
+  
+        LoopSolver<VectorType> overallSolver
+        (multigridStep, parset.get<size_t>("solver.tnnmg.maxiterations"),
+         parset.get<double>("solver.tolerance"), &energyNorm, verbosity,
+         false); // absolute error
+        overallSolver.solve();
+      };
+  
       // Since the velocity explodes in the quasistatic case, use the
       // displacement as a convergence criterion
       VectorType u_saved;
       for (size_t state_fpi = 1; state_fpi <= state_fpi_max; ++state_fpi) {
-        {
-          auto myGlobalNonlinearity
-            = assemble_nonlinearity<MatrixType, VectorType>
-            (parset.sub("boundary.friction"), *nodalIntegrals, alpha,
-             surfaceNormalStress);
-  
-          MyConvexProblemType const myConvexProblem
-            (problem_A, *myGlobalNonlinearity, problem_rhs);
-          MyBlockProblemType myBlockProblem(parset, myConvexProblem);
-          auto multigridStep = mySolver.getSolver();
-          multigridStep->setProblem(problem_iterate, myBlockProblem);
-  
-          LoopSolver<VectorType> overallSolver
-            (multigridStep, parset.get<size_t>("solver.tnnmg.maxiterations"),
-             solver_tolerance, &energyNorm, verbosity, false); // absolute error
-          overallSolver.solve();
-        }
+        solveDisplacementProblem(problem_iterate, alpha);
   
         timeSteppingScheme->postProcess(problem_iterate);
         timeSteppingScheme->extractDisplacement(u);