From 201dac88afc7ac3f0fdea742b3f8ffd641cb5e15 Mon Sep 17 00:00:00 2001
From: Elias Pipping <elias.pipping@fu-berlin.de>
Date: Sun, 21 Jul 2013 15:22:06 +0200
Subject: [PATCH] [Cleanup] Rename: problem_*
problem_rhs_initial -> accelerationRHS
problem_rhs -> velocityRHS
problem_iterate -> velocityIterate
problem_AM -> velocityMatrix
---
src/one-body-sample.cc | 38 +++++++++++++++++++-------------------
1 file changed, 19 insertions(+), 19 deletions(-)
diff --git a/src/one-body-sample.cc b/src/one-body-sample.cc
index 1b3c9ab9..19a42384 100644
--- a/src/one-body-sample.cc
+++ b/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);
--
GitLab