[Cleanup] Rename: problem_*

problem_rhs_initial -> accelerationRHS

problem_rhs         -> velocityRHS
problem_iterate     -> velocityIterate
problem_AM          -> velocityMatrix

src/one-body-sample.cc

@@ -399,17 +399,17 @@ int main(int argc, char *argv[]) {
       */
       MatrixType const &C = A;
       double const wc = 0.0; // watch out -- do not choose 1.0 here!
-      VectorType problem_rhs_initial(finestSize);
+      VectorType accelerationRHS(finestSize);
       {
-        problem_rhs_initial = 0.0;
-        Arithmetic::addProduct(problem_rhs_initial, A, u_initial);
-        Arithmetic::addProduct(problem_rhs_initial, wc, C, v_initial);
+        accelerationRHS = 0.0;
+        Arithmetic::addProduct(accelerationRHS, A, u_initial);
+        Arithmetic::addProduct(accelerationRHS, wc, C, v_initial);
         myGlobalNonlinearity->updateState(alpha_initial);
         // NOTE: We assume differentiability of Psi at v0 here!
-        myGlobalNonlinearity->addGradient(v_initial, problem_rhs_initial);
-        problem_rhs_initial -= ell;
+        myGlobalNonlinearity->addGradient(v_initial, accelerationRHS);
+        accelerationRHS -= ell;
         // instead of multiplying M by (1.0 - wc), we divide the RHS
-        problem_rhs_initial *= -1.0 / (1.0 - wc);
+        accelerationRHS *= -1.0 / (1.0 - wc);
       }
       LinearFactoryType accelerationFactory(parset.sub("solver.tnnmg"), // FIXME
                                             refinements, 1e-12, // FIXME,
@@ -418,7 +418,7 @@ int main(int argc, char *argv[]) {
       auto const verbosity = parset.get<Solver::VerbosityMode>("io.verbosity");
 
       typename LinearFactoryType::ConvexProblemType myConvexProblem(
-          1.0, M, zeroNonlinearity, problem_rhs_initial, a_initial);
+          1.0, M, zeroNonlinearity, accelerationRHS, a_initial);
       typename LinearFactoryType::BlockProblemType initialAccelerationProblem(
           parset, myConvexProblem);
 
@@ -492,30 +492,30 @@ int main(int argc, char *argv[]) {
       double const time = tau * run;
       createRHS(time, ell);
 
-      MatrixType problem_AM;
-      VectorType problem_rhs(finestSize);
-      VectorType problem_iterate(finestSize);
+      MatrixType velocityMatrix;
+      VectorType velocityRHS(finestSize);
+      VectorType velocityIterate(finestSize);
 
       stateUpdater->setup(tau);
-      timeSteppingScheme->setup(ell, tau, time, problem_rhs, problem_iterate,
-                                problem_AM);
+      timeSteppingScheme->setup(ell, tau, time, velocityRHS, velocityIterate,
+                                velocityMatrix);
 
       LoopSolver<VectorType> velocityProblemSolver(
           multigridStep, parset.get<size_t>("solver.tnnmg.maxiterations"),
           solverTolerance, &AMNorm, verbosity, false); // absolute error
 
       size_t iterationCounter;
-      auto solveVelocityProblem = [&](VectorType &_problem_iterate,
+      auto solveVelocityProblem = [&](VectorType &_velocityIterate,
                                       SingletonVectorType const &_alpha) {
         myGlobalNonlinearity->updateState(_alpha);
 
         // NIT: Do we really need to pass u here?
         typename NonlinearFactoryType::ConvexProblemType const myConvexProblem(
-            1.0, problem_AM, *myGlobalNonlinearity, problem_rhs,
-            _problem_iterate);
+            1.0, velocityMatrix, *myGlobalNonlinearity, velocityRHS,
+            _velocityIterate);
         typename NonlinearFactoryType::BlockProblemType velocityProblem(
             parset, myConvexProblem);
-        multigridStep->setProblem(_problem_iterate, velocityProblem);
+        multigridStep->setProblem(_velocityIterate, velocityProblem);
 
         velocityProblemSolver.preprocess();
         velocityProblemSolver.solve();
@@ -544,8 +544,8 @@ int main(int argc, char *argv[]) {
           lastCorrection = correction;
         }
 
-        solveVelocityProblem(problem_iterate, alpha);
-        timeSteppingScheme->postProcess(problem_iterate);
+        solveVelocityProblem(velocityIterate, alpha);
+        timeSteppingScheme->postProcess(velocityIterate);
         timeSteppingScheme->extractDisplacement(u);
         timeSteppingScheme->extractVelocity(v);