Simplify multigrid function naming

include/GMGPolar/igmgpolar.h

@@ -250,8 +250,7 @@ class IGMGPolar
 
     /* ------------------------------------------------------------------------- */
     /* Compute the extrapolated residual: res_ex = 4/3 res_fine - 1/3 res_coarse */
-    void extrapolatedResidual(const int current_level, Vector<double> residual,
-                              ConstVector<double> residual_next_level);
+    void extrapolatedResidual(int current_level, Vector<double> residual, ConstVector<double> residual_next_level);
 
     /* --------------- */
     /* Setup Functions */
@@ -278,24 +277,24 @@ class IGMGPolar
 
     /* ------------------- */
     /* Multigrid Functions */
-    void multigrid_V_Cycle(const int level_depth, Vector<double> solution, Vector<double> rhs, Vector<double> residual);
-    void multigrid_W_Cycle(const int level_depth, Vector<double> solution, Vector<double> rhs, Vector<double> residual);
-    void multigrid_F_Cycle(const int level_depth, Vector<double> solution, Vector<double> rhs, Vector<double> residual);
-    void implicitlyExtrapolatedMultigrid_V_Cycle(const int level_depth, Vector<double> solution, Vector<double> rhs,
-                                                 Vector<double> residual);
-    void implicitlyExtrapolatedMultigrid_W_Cycle(const int level_depth, Vector<double> solution, Vector<double> rhs,
-                                                 Vector<double> residual);
-    void implicitlyExtrapolatedMultigrid_F_Cycle(const int level_depth, Vector<double> solution, Vector<double> rhs,
-                                                 Vector<double> residual);
+    void multigrid_V_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs, Vector<double> residual);
+    void multigrid_W_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs, Vector<double> residual);
+    void multigrid_F_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs, Vector<double> residual);
+    void extrapolated_multigrid_V_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs,
+                                        Vector<double> residual);
+    void extrapolated_multigrid_W_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs,
+                                        Vector<double> residual);
+    void extrapolated_multigrid_F_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs,
+                                        Vector<double> residual);
 
     /* ----------------------- */
     /* Interpolation functions */
-    void prolongation(const int current_level, Vector<double> result, ConstVector<double> x) const;
-    void restriction(const int current_level, Vector<double> result, ConstVector<double> x) const;
-    void injection(const int current_level, Vector<double> result, ConstVector<double> x) const;
-    void extrapolatedProlongation(const int current_level, Vector<double> result, ConstVector<double> x) const;
-    void extrapolatedRestriction(const int current_level, Vector<double> result, ConstVector<double> x) const;
-    void FMGInterpolation(const int current_level, Vector<double> result, ConstVector<double> x) const;
+    void prolongation(int current_level, Vector<double> result, ConstVector<double> x) const;
+    void restriction(int current_level, Vector<double> result, ConstVector<double> x) const;
+    void injection(int current_level, Vector<double> result, ConstVector<double> x) const;
+    void extrapolatedProlongation(int current_level, Vector<double> result, ConstVector<double> x) const;
+    void extrapolatedRestriction(int current_level, Vector<double> result, ConstVector<double> x) const;
+    void FMGInterpolation(int current_level, Vector<double> result, ConstVector<double> x) const;
 
     /* ------------- */
     /* Visualization */

include/GMGPolar/solver.h

@@ -1,4 +1,3 @@
-
 // =============================================================================
 //   Main Solver Routine
 // =============================================================================
@@ -107,26 +106,23 @@ void IGMGPolar::solve(const BoundaryConditions& boundary_conditions, const Sourc
                 multigrid_V_Cycle(level.level_depth(), level.solution(), level.rhs(), level.residual());
             }
             else {
-                implicitlyExtrapolatedMultigrid_V_Cycle(level.level_depth(), level.solution(), level.rhs(),
-                                                        level.residual());
+                extrapolated_multigrid_V_Cycle(level.level_depth(), level.solution(), level.rhs(), level.residual());
             }
             break;
         case MultigridCycleType::W_CYCLE:
             if (extrapolation_ == ExtrapolationType::NONE) {
                 multigrid_W_Cycle(level.level_depth(), level.solution(), level.rhs(), level.residual());
             }
             else {
-                implicitlyExtrapolatedMultigrid_W_Cycle(level.level_depth(), level.solution(), level.rhs(),
-                                                        level.residual());
+                extrapolated_multigrid_W_Cycle(level.level_depth(), level.solution(), level.rhs(), level.residual());
             }
             break;
         case MultigridCycleType::F_CYCLE:
             if (extrapolation_ == ExtrapolationType::NONE) {
                 multigrid_F_Cycle(level.level_depth(), level.solution(), level.rhs(), level.residual());
             }
             else {
-                implicitlyExtrapolatedMultigrid_F_Cycle(level.level_depth(), level.solution(), level.rhs(),
-                                                        level.residual());
+                extrapolated_multigrid_F_Cycle(level.level_depth(), level.solution(), level.rhs(), level.residual());
             }
             break;
         default:

src/CMakeLists.txt

@@ -26,9 +26,9 @@ set(GMG_POLAR_SOURCES
 
 # file(GLOB_RECURSE MULTIGRID_METHODS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/*.cpp)
 set(MULTIGRID_METHODS_SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/implicitly_extrapolated_multigrid_F_Cycle.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/implicitly_extrapolated_multigrid_V_Cycle.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/implicitly_extrapolated_multigrid_W_Cycle.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/extrapolated_multigrid_F_Cycle.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/extrapolated_multigrid_V_Cycle.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/extrapolated_multigrid_W_Cycle.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/multigrid_F_Cycle.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/multigrid_V_Cycle.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/GMGPolar/MultigridMethods/multigrid_W_Cycle.cpp

src/GMGPolar/MultigridMethods/implicitly_extrapolated_multigrid_F_Cycle.cpp → src/GMGPolar/MultigridMethods/extrapolated_multigrid_F_Cycle.cpp

@@ -1,7 +1,7 @@
 #include "../../../include/GMGPolar/gmgpolar.h"
 
-void IGMGPolar::implicitlyExtrapolatedMultigrid_F_Cycle(const int level_depth, Vector<double> solution,
-                                                        Vector<double> rhs, Vector<double> residual)
+void IGMGPolar::extrapolated_multigrid_F_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs,
+                                               Vector<double> residual)
 {
     assert(0 <= level_depth && level_depth < number_of_levels_ - 1);
 
@@ -123,4 +123,4 @@ void IGMGPolar::implicitlyExtrapolatedMultigrid_F_Cycle(const int level_depth, V
         auto end_MGC = std::chrono::high_resolution_clock::now();
         t_avg_MGC_total_ += std::chrono::duration<double>(end_MGC - start_MGC).count();
     }
-}
+}

src/GMGPolar/MultigridMethods/implicitly_extrapolated_multigrid_V_Cycle.cpp → src/GMGPolar/MultigridMethods/extrapolated_multigrid_V_Cycle.cpp

@@ -1,7 +1,7 @@
 #include "../../../include/GMGPolar/gmgpolar.h"
 
-void IGMGPolar::implicitlyExtrapolatedMultigrid_V_Cycle(const int level_depth, Vector<double> solution,
-                                                        Vector<double> rhs, Vector<double> residual)
+void IGMGPolar::extrapolated_multigrid_V_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs,
+                                               Vector<double> residual)
 {
     assert(0 <= level_depth && level_depth < number_of_levels_ - 1);
 
@@ -122,4 +122,4 @@ void IGMGPolar::implicitlyExtrapolatedMultigrid_V_Cycle(const int level_depth, V
         auto end_MGC = std::chrono::high_resolution_clock::now();
         t_avg_MGC_total_ += std::chrono::duration<double>(end_MGC - start_MGC).count();
     }
-}
+}

src/GMGPolar/MultigridMethods/implicitly_extrapolated_multigrid_W_Cycle.cpp → src/GMGPolar/MultigridMethods/extrapolated_multigrid_W_Cycle.cpp

@@ -1,7 +1,7 @@
 #include "../../../include/GMGPolar/gmgpolar.h"
 
-void IGMGPolar::implicitlyExtrapolatedMultigrid_W_Cycle(const int level_depth, Vector<double> solution,
-                                                        Vector<double> rhs, Vector<double> residual)
+void IGMGPolar::extrapolated_multigrid_W_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs,
+                                               Vector<double> residual)
 {
     assert(0 <= level_depth && level_depth < number_of_levels_ - 1);
 
@@ -123,4 +123,4 @@ void IGMGPolar::implicitlyExtrapolatedMultigrid_W_Cycle(const int level_depth, V
         auto end_MGC = std::chrono::high_resolution_clock::now();
         t_avg_MGC_total_ += std::chrono::duration<double>(end_MGC - start_MGC).count();
     }
-}
+}

src/GMGPolar/MultigridMethods/multigrid_F_Cycle.cpp

@@ -1,7 +1,6 @@
 #include "../../../include/GMGPolar/gmgpolar.h"
 
-void IGMGPolar::multigrid_F_Cycle(const int level_depth, Vector<double> solution, Vector<double> rhs,
-                                  Vector<double> residual)
+void IGMGPolar::multigrid_F_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs, Vector<double> residual)
 {
     assert(0 <= level_depth && level_depth < number_of_levels_ - 1);
 
@@ -91,4 +90,4 @@ void IGMGPolar::multigrid_F_Cycle(const int level_depth, Vector<double> solution
         auto end_MGC = std::chrono::high_resolution_clock::now();
         t_avg_MGC_total_ += std::chrono::duration<double>(end_MGC - start_MGC).count();
     }
-}
+}

src/GMGPolar/MultigridMethods/multigrid_V_Cycle.cpp

@@ -1,7 +1,6 @@
 #include "../../../include/GMGPolar/gmgpolar.h"
 
-void IGMGPolar::multigrid_V_Cycle(const int level_depth, Vector<double> solution, Vector<double> rhs,
-                                  Vector<double> residual)
+void IGMGPolar::multigrid_V_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs, Vector<double> residual)
 {
     assert(0 <= level_depth && level_depth < number_of_levels_ - 1);
 
@@ -90,4 +89,4 @@ void IGMGPolar::multigrid_V_Cycle(const int level_depth, Vector<double> solution
         auto end_MGC = std::chrono::high_resolution_clock::now();
         t_avg_MGC_total_ += std::chrono::duration<double>(end_MGC - start_MGC).count();
     }
-}
+}

src/GMGPolar/MultigridMethods/multigrid_W_Cycle.cpp

@@ -1,7 +1,6 @@
 #include "../../../include/GMGPolar/gmgpolar.h"
 
-void IGMGPolar::multigrid_W_Cycle(const int level_depth, Vector<double> solution, Vector<double> rhs,
-                                  Vector<double> residual)
+void IGMGPolar::multigrid_W_Cycle(int level_depth, Vector<double> solution, Vector<double> rhs, Vector<double> residual)
 {
     assert(0 <= level_depth && level_depth < number_of_levels_ - 1);
 
@@ -91,4 +90,4 @@ void IGMGPolar::multigrid_W_Cycle(const int level_depth, Vector<double> solution
         auto end_MGC = std::chrono::high_resolution_clock::now();
         t_avg_MGC_total_ += std::chrono::duration<double>(end_MGC - start_MGC).count();
     }
-}
+}

src/GMGPolar/level_interpolation.cpp

@@ -1,6 +1,6 @@
 #include "../../include/GMGPolar/gmgpolar.h"
 
-void IGMGPolar::prolongation(const int current_level, Vector<double> result, ConstVector<double> x) const
+void IGMGPolar::prolongation(int current_level, Vector<double> result, ConstVector<double> x) const
 {
     assert(current_level < number_of_levels_ && 1 <= current_level);
     if (!interpolation_)
@@ -9,7 +9,7 @@ void IGMGPolar::prolongation(const int current_level, Vector<double> result, Con
     interpolation_->applyProlongation(levels_[current_level].grid(), levels_[current_level - 1].grid(), result, x);
 }
 
-void IGMGPolar::restriction(const int current_level, Vector<double> result, ConstVector<double> x) const
+void IGMGPolar::restriction(int current_level, Vector<double> result, ConstVector<double> x) const
 {
     assert(current_level < number_of_levels_ - 1 && 0 <= current_level);
     if (!interpolation_)
@@ -18,7 +18,7 @@ void IGMGPolar::restriction(const int current_level, Vector<double> result, Cons
     interpolation_->applyRestriction(levels_[current_level].grid(), levels_[current_level + 1].grid(), result, x);
 }
 
-void IGMGPolar::injection(const int current_level, Vector<double> result, ConstVector<double> x) const
+void IGMGPolar::injection(int current_level, Vector<double> result, ConstVector<double> x) const
 {
     assert(current_level < number_of_levels_ - 1 && 0 <= current_level);
     if (!interpolation_)
@@ -27,7 +27,7 @@ void IGMGPolar::injection(const int current_level, Vector<double> result, ConstV
     interpolation_->applyInjection(levels_[current_level].grid(), levels_[current_level + 1].grid(), result, x);
 }
 
-void IGMGPolar::extrapolatedProlongation(const int current_level, Vector<double> result, ConstVector<double> x) const
+void IGMGPolar::extrapolatedProlongation(int current_level, Vector<double> result, ConstVector<double> x) const
 {
     assert(current_level < number_of_levels_ && 1 <= current_level);
     if (!interpolation_)
@@ -37,7 +37,7 @@ void IGMGPolar::extrapolatedProlongation(const int current_level, Vector<double>
                                                   result, x);
 }
 
-void IGMGPolar::extrapolatedRestriction(const int current_level, Vector<double> result, ConstVector<double> x) const
+void IGMGPolar::extrapolatedRestriction(int current_level, Vector<double> result, ConstVector<double> x) const
 {
     assert(current_level < number_of_levels_ - 1 && 0 <= current_level);
     if (!interpolation_)
@@ -47,7 +47,7 @@ void IGMGPolar::extrapolatedRestriction(const int current_level, Vector<double>
                                                  result, x);
 }
 
-void IGMGPolar::FMGInterpolation(const int current_level, Vector<double> result, ConstVector<double> x) const
+void IGMGPolar::FMGInterpolation(int current_level, Vector<double> result, ConstVector<double> x) const
 {
     assert(current_level < number_of_levels_ && 1 <= current_level);
     if (!interpolation_)

src/GMGPolar/solver.cpp

@@ -35,18 +35,18 @@ void IGMGPolar::initializeSolution()
                 if (fine_level.level_depth() == 0 && (extrapolation_ != ExtrapolationType::NONE)) {
                     switch (FMG_cycle_) {
                     case MultigridCycleType::V_CYCLE:
-                        implicitlyExtrapolatedMultigrid_V_Cycle(fine_level.level_depth(), fine_level.solution(),
-                                                                fine_level.rhs(), fine_level.residual());
+                        extrapolated_multigrid_V_Cycle(fine_level.level_depth(), fine_level.solution(),
+                                                       fine_level.rhs(), fine_level.residual());
                         break;
 
                     case MultigridCycleType::W_CYCLE:
-                        implicitlyExtrapolatedMultigrid_W_Cycle(fine_level.level_depth(), fine_level.solution(),
-                                                                fine_level.rhs(), fine_level.residual());
+                        extrapolated_multigrid_W_Cycle(fine_level.level_depth(), fine_level.solution(),
+                                                       fine_level.rhs(), fine_level.residual());
                         break;
 
                     case MultigridCycleType::F_CYCLE:
-                        implicitlyExtrapolatedMultigrid_F_Cycle(fine_level.level_depth(), fine_level.solution(),
-                                                                fine_level.rhs(), fine_level.residual());
+                        extrapolated_multigrid_F_Cycle(fine_level.level_depth(), fine_level.solution(),
+                                                       fine_level.rhs(), fine_level.residual());
                         break;
 
                     default:
@@ -135,7 +135,7 @@ void IGMGPolar::updateResidualNorms(Level& level, int iteration, double& initial
     }
 }
 
-void IGMGPolar::extrapolatedResidual(const int current_level, Vector<double> residual,
+void IGMGPolar::extrapolatedResidual(int current_level, Vector<double> residual,
                                      ConstVector<double> residual_next_level)
 {
     const PolarGrid& fineGrid   = levels_[current_level].grid();