fix last comments

Signed-off-by: Tony Xiang <[email protected]>

Author: TonyXiang8787

include/power_grid_model/math_solver/iterative_current_pf_solver.hpp

@@ -171,7 +171,7 @@ class IterativeCurrentPFSolver : public IterativePFSolver<sym, IterativeCurrentP
     // Solve the linear equations I_inj = YU
     // inplace
     void solve_matrix() {
-        sparse_solver_.solve_with_prefactorization(*mat_data_, *perm_, rhs_u_, rhs_u_);
+        sparse_solver_.solve_with_prefactorized_matrix(*mat_data_, *perm_, rhs_u_, rhs_u_);
     }
 
     // Find maximum deviation in voltage among all buses

include/power_grid_model/math_solver/iterative_linear_se_solver.hpp

@@ -621,7 +621,7 @@ class IterativeLinearSESolver {
             prepare_rhs(y_bus, measured_values, output.u);
             // solve with prefactorization
             sub_timer = Timer(calculation_info, 2225, "Solve sparse linear equation (pre-factorized)");
-            sparse_solver_.solve_with_prefactorization(data_gain_, perm_, x_rhs_, x_rhs_);
+            sparse_solver_.solve_with_prefactorized_matrix(data_gain_, perm_, x_rhs_, x_rhs_);
             sub_timer = Timer(calculation_info, 2226, "Iterate unknown");
             max_dev = iterate_unknown(output.u, measured_values.has_angle_measurement());
         }

include/power_grid_model/math_solver/sparse_lu_solver.hpp

@@ -96,13 +96,14 @@ class SparseLUSolver {
         std::vector<RHSVector> const& rhs, std::vector<XVector>& x) {
         prefactorize(data, block_perm_array);
         // call solve with const method
-        solve_with_prefactorization((std::vector<Tensor> const&)data, block_perm_array, rhs, x);
+        solve_with_prefactorized_matrix((std::vector<Tensor> const&)data, block_perm_array, rhs, x);
     }
 
     // solve with existing pre-factorization
-    void solve_with_prefactorization(std::vector<Tensor> const& data,         // pre-factoirzed data, const ref
-                                     BlockPermArray const& block_perm_array,  // pre-calculated permutation, const ref
-                                     std::vector<RHSVector> const& rhs, std::vector<XVector>& x) {
+    void solve_with_prefactorized_matrix(
+        std::vector<Tensor> const& data,         // pre-factoirzed data, const ref
+        BlockPermArray const& block_perm_array,  // pre-calculated permutation, const ref
+        std::vector<RHSVector> const& rhs, std::vector<XVector>& x) {
         // local reference
         auto const& row_indptr = *row_indptr_;
         auto const& col_indices = *col_indices_;

tests/cpp_unit_tests/test_sparse_lu_solver.cpp

@@ -73,7 +73,7 @@ TEST_CASE("Test Sparse LU solver") {
 
         SECTION("Test prefactorize") {
             solver.prefactorize(data, block_perm);
-            solver.solve_with_prefactorization((std::vector<double> const&)data, block_perm, rhs, x);
+            solver.solve_with_prefactorized_matrix((std::vector<double> const&)data, block_perm, rhs, x);
             check_result(x, x_ref);
         }
 
@@ -123,7 +123,7 @@ TEST_CASE("Test Sparse LU solver") {
 
         SECTION("Test prefactorize") {
             solver.prefactorize(data, block_perm);
-            solver.solve_with_prefactorization((std::vector<Tensor> const&)data, block_perm, rhs, x);
+            solver.solve_with_prefactorized_matrix((std::vector<Tensor> const&)data, block_perm, rhs, x);
             check_result(x, x_ref);
         }
     }