[Cleanup] Renaming vertex variables

src/one-body-sample.cc

@@ -193,7 +193,7 @@ int main(int argc, char *argv[]) {
 
     auto const refinements = parset.get<size_t>("grid.refinements");
     grid->globalRefine(refinements);
-    size_t const finestSize = grid->size(grid->maxLevel(), dims);
+    size_t const fineVertexCount = grid->size(grid->maxLevel(), dims);
 
     using GridView = GridType::LeafGridView;
     GridView const leafView = grid->leafView();
@@ -208,23 +208,22 @@ int main(int argc, char *argv[]) {
     Assembler<P1Basis, P1Basis> const p1Assembler(p1Basis, p1Basis);
 
     // Set up the boundary
-    Dune::BitSetVector<dims> velocityDirichletNodes(finestSize, false);
+    Dune::BitSetVector<dims> velocityDirichletNodes(fineVertexCount, false);
     Dune::BitSetVector<dims> const &displacementDirichletNodes =
         velocityDirichletNodes;
-    Dune::BitSetVector<dims> accelerationDirichletNodes(finestSize, false);
-    Dune::BitSetVector<1> neumannNodes(finestSize, false);
-    Dune::BitSetVector<1> frictionalNodes(finestSize, false);
+    Dune::BitSetVector<dims> accelerationDirichletNodes(fineVertexCount, false);
+    Dune::BitSetVector<1> neumannNodes(fineVertexCount, false);
+    Dune::BitSetVector<1> frictionalNodes(fineVertexCount, false);
 
-    VectorType coordinates(finestSize);
+    VectorType vertexCoordinates(fineVertexCount);
     {
       Dune::MultipleCodimMultipleGeomTypeMapper<
-          GridView, Dune::MCMGVertexLayout> const myVertexMapper(leafView);
-
+          GridView, Dune::MCMGVertexLayout> const vertexMapper(leafView);
       for (auto it = leafView.begin<dims>(); it != leafView.end<dims>(); ++it) {
         assert(it->geometry().corners() == 1);
-        size_t const id = myVertexMapper.map(*it);
-        coordinates[id] = it->geometry().corner(0);
-        auto const &localCoordinates = coordinates[id];
+        size_t const id = vertexMapper.map(*it);
+        vertexCoordinates[id] = it->geometry().corner(0);
+        auto const &localCoordinates = vertexCoordinates[id];
 
         // lower face
         if (localCoordinates[1] == lowerLeft[1]) {
@@ -350,11 +349,11 @@ int main(int argc, char *argv[]) {
                       neumannFunction, _relativeTime);
       _ell += gravityFunctional;
     };
-    VectorType ell(finestSize);
+    VectorType ell(fineVertexCount);
     createRHS(0.0, ell);
 
     // {{{ Initial conditions
-    SingletonVectorType alpha_initial(finestSize);
+    SingletonVectorType alpha_initial(fineVertexCount);
     alpha_initial =
         std::log(parset.get<double>("boundary.friction.initialState"));
 
@@ -365,7 +364,7 @@ int main(int argc, char *argv[]) {
     ZeroNonlinearity<SmallVector, SmallMatrix> zeroNonlinearity;
 
     // Solve the stationary problem
-    VectorType u_initial(finestSize);
+    VectorType u_initial(fineVertexCount);
     u_initial = 0.0;
     {
       LinearFactoryType displacementFactory(parset.sub("solver.tnnmg"), // FIXME
@@ -389,7 +388,7 @@ int main(int argc, char *argv[]) {
       initialDisplacementProblemSolver.preprocess();
       initialDisplacementProblemSolver.solve();
     }
-    VectorType v_initial(finestSize);
+    VectorType v_initial(fineVertexCount);
     v_initial = 0.0;
     {
       // Prescribe a homogeneous velocity field in the x-direction
@@ -400,13 +399,13 @@ int main(int argc, char *argv[]) {
       for (auto &x : v_initial)
         x[0] = v_initial_const;
     }
-    VectorType a_initial(finestSize);
+    VectorType a_initial(fineVertexCount);
     a_initial = 0.0;
     {
       /* We solve Au + Cv + Ma + Psi(v) = ell, thus
                                      Ma = - (Au + Cv + Psi(v) - ell)
       */
-      VectorType accelerationRHS(finestSize);
+      VectorType accelerationRHS(fineVertexCount);
       {
         accelerationRHS = 0.0;
         Arithmetic::addProduct(accelerationRHS, A, u_initial);
@@ -453,11 +452,11 @@ int main(int argc, char *argv[]) {
     auto multigridStep = factory.getSolver();
 
     {
-      std::fstream coordinateWriter("coordinates", std::fstream::out);
+      std::fstream vertexCoordinateWriter("coordinates", std::fstream::out);
       for (size_t i = 0; i < frictionalNodes.size(); ++i)
         if (frictionalNodes[i][0])
-          coordinateWriter << coordinates[i] << std::endl;
-      coordinateWriter.close();
+          vertexCoordinateWriter << vertexCoordinates[i] << std::endl;
+      vertexCoordinateWriter.close();
     }
     std::fstream iterationWriter("iterations", std::fstream::out),
         relaxationWriter("relaxation", std::fstream::out);
@@ -471,7 +470,7 @@ int main(int argc, char *argv[]) {
         alpha_initial, frictionalNodes, frictionData);
 
     VectorType v = v_initial;
-    SingletonVectorType alpha(finestSize);
+    SingletonVectorType alpha(fineVertexCount);
 
     auto const timesteps = parset.get<size_t>("timeSteps.number"),
                maximumStateFPI = parset.get<size_t>("v.fpi.maximumIterations"),
@@ -497,8 +496,8 @@ int main(int argc, char *argv[]) {
       createRHS(relativeTime, ell);
 
       MatrixType velocityMatrix;
-      VectorType velocityRHS(finestSize);
-      VectorType velocityIterate(finestSize);
+      VectorType velocityRHS(fineVertexCount);
+      VectorType velocityIterate(fineVertexCount);
 
       stateUpdater->setup(tau);
       timeSteppingScheme->setup(ell, tau, relativeTime, velocityRHS,