diff --git a/include/DirectSolver/DirectSolver-COO-MUMPS-Give/directSolverGive.h b/include/DirectSolver/DirectSolver-COO-MUMPS-Give/directSolverGive.h index ebf962f2..a03474c4 100644 --- a/include/DirectSolver/DirectSolver-COO-MUMPS-Give/directSolverGive.h +++ b/include/DirectSolver/DirectSolver-COO-MUMPS-Give/directSolverGive.h @@ -9,8 +9,7 @@ class DirectSolver_COO_MUMPS_Give : public DirectSolver { public: explicit DirectSolver_COO_MUMPS_Give(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, - int num_omp_threads); + bool DirBC_Interior, int num_omp_threads); // Note: The rhs (right-hand side) vector gets overwritten during the solution process. void solveInPlace(Vector solution) override; diff --git a/include/DirectSolver/DirectSolver-COO-MUMPS-Give/directSolverGive.inl b/include/DirectSolver/DirectSolver-COO-MUMPS-Give/directSolverGive.inl index 27d5667a..f505ccf2 100644 --- a/include/DirectSolver/DirectSolver-COO-MUMPS-Give/directSolverGive.inl +++ b/include/DirectSolver/DirectSolver-COO-MUMPS-Give/directSolverGive.inl @@ -5,9 +5,8 @@ template DirectSolver_COO_MUMPS_Give::DirectSolver_COO_MUMPS_Give(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads) - : DirectSolver(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : DirectSolver(grid, level_cache, DirBC_Interior, num_omp_threads) , mumps_solver_(buildSolverMatrix()) { } diff --git a/include/DirectSolver/DirectSolver-COO-MUMPS-Take/directSolverTake.h b/include/DirectSolver/DirectSolver-COO-MUMPS-Take/directSolverTake.h index b8ef79e4..40334fc7 100644 --- a/include/DirectSolver/DirectSolver-COO-MUMPS-Take/directSolverTake.h +++ b/include/DirectSolver/DirectSolver-COO-MUMPS-Take/directSolverTake.h @@ -9,8 +9,7 @@ class DirectSolver_COO_MUMPS_Take : public DirectSolver { public: explicit DirectSolver_COO_MUMPS_Take(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, - int num_omp_threads); + bool DirBC_Interior, int num_omp_threads); // Note: The rhs (right-hand side) vector gets overwritten during the solution process. void solveInPlace(Vector solution) override; diff --git a/include/DirectSolver/DirectSolver-COO-MUMPS-Take/directSolverTake.inl b/include/DirectSolver/DirectSolver-COO-MUMPS-Take/directSolverTake.inl index 8598652e..4da6f250 100644 --- a/include/DirectSolver/DirectSolver-COO-MUMPS-Take/directSolverTake.inl +++ b/include/DirectSolver/DirectSolver-COO-MUMPS-Take/directSolverTake.inl @@ -5,9 +5,8 @@ template DirectSolver_COO_MUMPS_Take::DirectSolver_COO_MUMPS_Take(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads) - : DirectSolver(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : DirectSolver(grid, level_cache, DirBC_Interior, num_omp_threads) , mumps_solver_(buildSolverMatrix()) { } diff --git a/include/DirectSolver/DirectSolver-CSR-LU-Give/directSolverGive.inl b/include/DirectSolver/DirectSolver-CSR-LU-Give/directSolverGive.inl index f26a76cf..84faa1b3 100644 --- a/include/DirectSolver/DirectSolver-CSR-LU-Give/directSolverGive.inl +++ b/include/DirectSolver/DirectSolver-CSR-LU-Give/directSolverGive.inl @@ -3,9 +3,8 @@ template DirectSolver_CSR_LU_Give::DirectSolver_CSR_LU_Give(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads) - : DirectSolver(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : DirectSolver(grid, level_cache, DirBC_Interior, num_omp_threads) { solver_matrix_ = buildSolverMatrix(); lu_solver_ = SparseLUSolver(solver_matrix_); diff --git a/include/DirectSolver/DirectSolver-CSR-LU-Give/directSolverGiveCustomLU.h b/include/DirectSolver/DirectSolver-CSR-LU-Give/directSolverGiveCustomLU.h index 8c0d45a3..9ba98075 100644 --- a/include/DirectSolver/DirectSolver-CSR-LU-Give/directSolverGiveCustomLU.h +++ b/include/DirectSolver/DirectSolver-CSR-LU-Give/directSolverGiveCustomLU.h @@ -7,7 +7,7 @@ class DirectSolver_CSR_LU_Give : public DirectSolver { public: explicit DirectSolver_CSR_LU_Give(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads); + bool DirBC_Interior, int num_omp_threads); // Note: The rhs (right-hand side) vector gets overwritten with the solution. void solveInPlace(Vector solution) override; diff --git a/include/DirectSolver/DirectSolver-CSR-LU-Take/directSolverTake.inl b/include/DirectSolver/DirectSolver-CSR-LU-Take/directSolverTake.inl index 0a6688d7..f4bd7412 100644 --- a/include/DirectSolver/DirectSolver-CSR-LU-Take/directSolverTake.inl +++ b/include/DirectSolver/DirectSolver-CSR-LU-Take/directSolverTake.inl @@ -3,9 +3,8 @@ template DirectSolver_CSR_LU_Take::DirectSolver_CSR_LU_Take(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads) - : DirectSolver(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : DirectSolver(grid, level_cache, DirBC_Interior, num_omp_threads) { solver_matrix_ = buildSolverMatrix(); lu_solver_ = SparseLUSolver(solver_matrix_); diff --git a/include/DirectSolver/DirectSolver-CSR-LU-Take/directSolverTakeCustomLU.h b/include/DirectSolver/DirectSolver-CSR-LU-Take/directSolverTakeCustomLU.h index dd98da32..4a9fece1 100644 --- a/include/DirectSolver/DirectSolver-CSR-LU-Take/directSolverTakeCustomLU.h +++ b/include/DirectSolver/DirectSolver-CSR-LU-Take/directSolverTakeCustomLU.h @@ -7,7 +7,7 @@ class DirectSolver_CSR_LU_Take : public DirectSolver { public: explicit DirectSolver_CSR_LU_Take(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads); + bool DirBC_Interior, int num_omp_threads); // Note: The rhs (right-hand side) vector gets overwritten with the solution. void solveInPlace(Vector solution) override; diff --git a/include/DirectSolver/directSolver.h b/include/DirectSolver/directSolver.h index 7429cfd6..9106b91c 100644 --- a/include/DirectSolver/directSolver.h +++ b/include/DirectSolver/directSolver.h @@ -31,11 +31,10 @@ template class DirectSolver { public: - explicit DirectSolver(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads) + explicit DirectSolver(const PolarGrid& grid, const LevelCache& level_cache, bool DirBC_Interior, + int num_omp_threads) : grid_(grid) , level_cache_(level_cache) - , domain_geometry_(domain_geometry) , DirBC_Interior_(DirBC_Interior) , num_omp_threads_(num_omp_threads) { @@ -49,7 +48,6 @@ class DirectSolver protected: const PolarGrid& grid_; const LevelCache& level_cache_; - const DomainGeometry& domain_geometry_; const bool DirBC_Interior_; const int num_omp_threads_; }; diff --git a/include/ExtrapolatedSmoother/ExtrapolatedSmootherGive/extrapolatedSmootherGive.h b/include/ExtrapolatedSmoother/ExtrapolatedSmootherGive/extrapolatedSmootherGive.h index 588da9ad..63305277 100644 --- a/include/ExtrapolatedSmoother/ExtrapolatedSmootherGive/extrapolatedSmootherGive.h +++ b/include/ExtrapolatedSmoother/ExtrapolatedSmootherGive/extrapolatedSmootherGive.h @@ -58,7 +58,7 @@ class ExtrapolatedSmootherGive : public ExtrapolatedSmoother // Constructs the coupled circle-radial extrapolated smoother. // Builds the A_sc smoother matrices and prepares the solvers. explicit ExtrapolatedSmootherGive(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads); + bool DirBC_Interior, int num_omp_threads); // If MUMPS is enabled, this cleans up the inner boundary solver. ~ExtrapolatedSmootherGive() override; diff --git a/include/ExtrapolatedSmoother/ExtrapolatedSmootherGive/extrapolatedSmootherGive.inl b/include/ExtrapolatedSmoother/ExtrapolatedSmootherGive/extrapolatedSmootherGive.inl index fd8f08b5..1f1956b5 100644 --- a/include/ExtrapolatedSmoother/ExtrapolatedSmootherGive/extrapolatedSmootherGive.inl +++ b/include/ExtrapolatedSmoother/ExtrapolatedSmootherGive/extrapolatedSmootherGive.inl @@ -3,9 +3,8 @@ template ExtrapolatedSmootherGive::ExtrapolatedSmootherGive(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, const bool DirBC_Interior, const int num_omp_threads) - : ExtrapolatedSmoother(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : ExtrapolatedSmoother(grid, level_cache, DirBC_Interior, num_omp_threads) , circle_tridiagonal_solver_(grid.ntheta(), grid.numberSmootherCircles(), true) , radial_tridiagonal_solver_(grid.lengthSmootherRadial(), grid.ntheta(), false) { diff --git a/include/ExtrapolatedSmoother/ExtrapolatedSmootherTake/extrapolatedSmootherTake.h b/include/ExtrapolatedSmoother/ExtrapolatedSmootherTake/extrapolatedSmootherTake.h index 3b1baba4..c3036983 100644 --- a/include/ExtrapolatedSmoother/ExtrapolatedSmootherTake/extrapolatedSmootherTake.h +++ b/include/ExtrapolatedSmoother/ExtrapolatedSmootherTake/extrapolatedSmootherTake.h @@ -58,7 +58,7 @@ class ExtrapolatedSmootherTake : public ExtrapolatedSmoother // Constructs the coupled circle-radial extrapolated smoother. // Builds the A_sc smoother matrices and prepares the solvers. explicit ExtrapolatedSmootherTake(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads); + bool DirBC_Interior, int num_omp_threads); // Performs one full coupled extrapolated smoothing sweep: // BC -> WC -> BR -> WR diff --git a/include/ExtrapolatedSmoother/ExtrapolatedSmootherTake/extrapolatedSmootherTake.inl b/include/ExtrapolatedSmoother/ExtrapolatedSmootherTake/extrapolatedSmootherTake.inl index 86aafbd5..19c90aae 100644 --- a/include/ExtrapolatedSmoother/ExtrapolatedSmootherTake/extrapolatedSmootherTake.inl +++ b/include/ExtrapolatedSmoother/ExtrapolatedSmootherTake/extrapolatedSmootherTake.inl @@ -3,9 +3,8 @@ template ExtrapolatedSmootherTake::ExtrapolatedSmootherTake(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, const bool DirBC_Interior, const int num_omp_threads) - : ExtrapolatedSmoother(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : ExtrapolatedSmoother(grid, level_cache, DirBC_Interior, num_omp_threads) , circle_tridiagonal_solver_(grid.ntheta(), grid.numberSmootherCircles(), true) , radial_tridiagonal_solver_(grid.lengthSmootherRadial(), grid.ntheta(), false) #ifdef GMGPOLAR_USE_MUMPS diff --git a/include/ExtrapolatedSmoother/extrapolatedSmoother.h b/include/ExtrapolatedSmoother/extrapolatedSmoother.h index c804fa87..abf8aee3 100644 --- a/include/ExtrapolatedSmoother/extrapolatedSmoother.h +++ b/include/ExtrapolatedSmoother/extrapolatedSmoother.h @@ -35,10 +35,9 @@ class ExtrapolatedSmoother { public: explicit ExtrapolatedSmoother(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads) + bool DirBC_Interior, int num_omp_threads) : grid_(grid) , level_cache_(level_cache) - , domain_geometry_(domain_geometry) , DirBC_Interior_(DirBC_Interior) , num_omp_threads_(num_omp_threads) { @@ -50,7 +49,6 @@ class ExtrapolatedSmoother protected: const PolarGrid& grid_; const LevelCache& level_cache_; - const DomainGeometry& domain_geometry_; const bool DirBC_Interior_; const int num_omp_threads_; }; diff --git a/include/GMGPolar/setup.h b/include/GMGPolar/setup.h index b5e9c57d..a8db96e2 100644 --- a/include/GMGPolar/setup.h +++ b/include/GMGPolar/setup.h @@ -99,15 +99,14 @@ void GMGPolar::setup() // Define residual operator on all multigrid levels // // ------------------------------------------------ // for (int level_depth = 0; level_depth < number_of_levels_; level_depth++) { - levels_[level_depth].initializeResidual(domain_geometry_, DirBC_Interior_, max_omp_threads_, - stencil_distribution_method_); + levels_[level_depth].initializeResidual(DirBC_Interior_, max_omp_threads_, stencil_distribution_method_); } // ----------------------------------------- // // Build direct solver on the coarsest level // // ----------------------------------------- // auto start_setup_directSolver = std::chrono::high_resolution_clock::now(); - levels_[number_of_levels_ - 1].initializeDirectSolver(domain_geometry_, DirBC_Interior_, max_omp_threads_, + levels_[number_of_levels_ - 1].initializeDirectSolver(DirBC_Interior_, max_omp_threads_, stencil_distribution_method_); auto end_setup_directSolver = std::chrono::high_resolution_clock::now(); t_setup_directSolver_ += std::chrono::duration(end_setup_directSolver - start_setup_directSolver).count(); @@ -145,17 +144,14 @@ void GMGPolar::setup() if (number_of_levels_ > 1) { // PCG uses non-extrapolated smoothing on level 0, so we need to initialize it if PCG is enabled. if (do_full_grid_smoothing || (PCG_ && PCG_MG_iterations_ > 0)) { - levels_[0].initializeSmoothing(domain_geometry_, DirBC_Interior_, max_omp_threads_, - stencil_distribution_method_); + levels_[0].initializeSmoothing(DirBC_Interior_, max_omp_threads_, stencil_distribution_method_); } // PCG doesn't use extrapolated smoothing, so we only initialize it if PCG is disabled. if (do_extrapolated_smoothing && !PCG_) { - levels_[0].initializeExtrapolatedSmoothing(domain_geometry_, DirBC_Interior_, max_omp_threads_, - stencil_distribution_method_); + levels_[0].initializeExtrapolatedSmoothing(DirBC_Interior_, max_omp_threads_, stencil_distribution_method_); } for (int level_depth = 1; level_depth < number_of_levels_ - 1; level_depth++) { - levels_[level_depth].initializeSmoothing(domain_geometry_, DirBC_Interior_, max_omp_threads_, - stencil_distribution_method_); + levels_[level_depth].initializeSmoothing(DirBC_Interior_, max_omp_threads_, stencil_distribution_method_); } } auto end_setup_smoother = std::chrono::high_resolution_clock::now(); diff --git a/include/Level/level.h b/include/Level/level.h index b2b02258..6bb43b1b 100644 --- a/include/Level/level.h +++ b/include/Level/level.h @@ -69,28 +69,27 @@ class Level // -------------- // // Apply Residual // - void initializeResidual(const DomainGeometry& domain_geometry, const bool DirBC_Interior, const int num_omp_threads, + void initializeResidual(const bool DirBC_Interior, const int num_omp_threads, const StencilDistributionMethod stencil_distribution_method); void computeResidual(Vector result, ConstVector rhs, ConstVector x) const; void applySystemOperator(Vector result, ConstVector x) const; // ------------------- // // Solve coarse System // - void initializeDirectSolver(const DomainGeometry& domain_geometry, const bool DirBC_Interior, - const int num_omp_threads, const StencilDistributionMethod stencil_distribution_method); + void initializeDirectSolver(const bool DirBC_Interior, const int num_omp_threads, + const StencilDistributionMethod stencil_distribution_method); // Note: The rhs (right-hand side) vector gets overwritten by the solution. void directSolveInPlace(Vector x) const; // --------------- // // Apply Smoothing // - void initializeSmoothing(const DomainGeometry& domain_geometry, const bool DirBC_Interior, - const int num_omp_threads, const StencilDistributionMethod stencil_distribution_method); + void initializeSmoothing(const bool DirBC_Interior, const int num_omp_threads, + const StencilDistributionMethod stencil_distribution_method); void smoothing(Vector x, ConstVector rhs, Vector temp) const; // ---------------------------- // // Apply Extrapolated Smoothing // - void initializeExtrapolatedSmoothing(const DomainGeometry& domain_geometry, const bool DirBC_Interior, - const int num_omp_threads, + void initializeExtrapolatedSmoothing(const bool DirBC_Interior, const int num_omp_threads, const StencilDistributionMethod stencil_distribution_method); void extrapolatedSmoothing(Vector x, ConstVector rhs, Vector temp) const; diff --git a/include/Level/level.inl b/include/Level/level.inl index 64b98565..17008c63 100644 --- a/include/Level/level.inl +++ b/include/Level/level.inl @@ -102,16 +102,16 @@ ConstVector Level::error_correction() const // -------------- // // Apply Residual // template -void Level::initializeResidual(const DomainGeometry& domain_geometry, const bool DirBC_Interior, +void Level::initializeResidual(const bool DirBC_Interior, const int num_omp_threads, const StencilDistributionMethod stencil_distribution_method) { if (stencil_distribution_method == StencilDistributionMethod::CPU_TAKE) { - op_residual_ = std::make_unique>(*grid_, *level_cache_, domain_geometry, + op_residual_ = std::make_unique>(*grid_, *level_cache_, DirBC_Interior, num_omp_threads); } else if (stencil_distribution_method == StencilDistributionMethod::CPU_GIVE) { - op_residual_ = std::make_unique>(*grid_, *level_cache_, domain_geometry, + op_residual_ = std::make_unique>(*grid_, *level_cache_, DirBC_Interior, num_omp_threads); } if (!op_residual_) @@ -136,27 +136,27 @@ void Level::applySystemOperator(Vector result, ConstVect // ------------------- // // Solve coarse System // template -void Level::initializeDirectSolver(const DomainGeometry& domain_geometry, const bool DirBC_Interior, +void Level::initializeDirectSolver(const bool DirBC_Interior, const int num_omp_threads, const StencilDistributionMethod stencil_distribution_method) { #ifdef GMGPOLAR_USE_MUMPS if (stencil_distribution_method == StencilDistributionMethod::CPU_TAKE) { op_directSolver_ = std::make_unique>( - *grid_, *level_cache_, domain_geometry, DirBC_Interior, num_omp_threads); + *grid_, *level_cache_, DirBC_Interior, num_omp_threads); } else if (stencil_distribution_method == StencilDistributionMethod::CPU_GIVE) { op_directSolver_ = std::make_unique>( - *grid_, *level_cache_, domain_geometry, DirBC_Interior, num_omp_threads); + *grid_, *level_cache_, DirBC_Interior, num_omp_threads); } #else if (stencil_distribution_method == StencilDistributionMethod::CPU_TAKE) { op_directSolver_ = std::make_unique>( - *grid_, *level_cache_, domain_geometry, DirBC_Interior, num_omp_threads); + *grid_, *level_cache_, DirBC_Interior, num_omp_threads); } else if (stencil_distribution_method == StencilDistributionMethod::CPU_GIVE) { op_directSolver_ = std::make_unique>( - *grid_, *level_cache_, domain_geometry, DirBC_Interior, num_omp_threads); + *grid_, *level_cache_, DirBC_Interior, num_omp_threads); } #endif if (!op_directSolver_) @@ -174,16 +174,16 @@ void Level::directSolveInPlace(Vector x) const // --------------- // // Apply Smoothing // template -void Level::initializeSmoothing(const DomainGeometry& domain_geometry, const bool DirBC_Interior, +void Level::initializeSmoothing(const bool DirBC_Interior, const int num_omp_threads, const StencilDistributionMethod stencil_distribution_method) { if (stencil_distribution_method == StencilDistributionMethod::CPU_TAKE) { - op_smoother_ = std::make_unique>(*grid_, *level_cache_, domain_geometry, + op_smoother_ = std::make_unique>(*grid_, *level_cache_, DirBC_Interior, num_omp_threads); } else if (stencil_distribution_method == StencilDistributionMethod::CPU_GIVE) { - op_smoother_ = std::make_unique>(*grid_, *level_cache_, domain_geometry, + op_smoother_ = std::make_unique>(*grid_, *level_cache_, DirBC_Interior, num_omp_threads); } if (!op_smoother_) @@ -201,17 +201,16 @@ void Level::smoothing(Vector x, ConstVector rhs, // ---------------------------- // // Apply Extrapolated Smoothing // template -void Level::initializeExtrapolatedSmoothing(const DomainGeometry& domain_geometry, - const bool DirBC_Interior, const int num_omp_threads, +void Level::initializeExtrapolatedSmoothing(const bool DirBC_Interior, const int num_omp_threads, const StencilDistributionMethod stencil_distribution_method) { if (stencil_distribution_method == StencilDistributionMethod::CPU_TAKE) { op_extrapolated_smoother_ = std::make_unique>( - *grid_, *level_cache_, domain_geometry, DirBC_Interior, num_omp_threads); + *grid_, *level_cache_, DirBC_Interior, num_omp_threads); } else if (stencil_distribution_method == StencilDistributionMethod::CPU_GIVE) { op_extrapolated_smoother_ = std::make_unique>( - *grid_, *level_cache_, domain_geometry, DirBC_Interior, num_omp_threads); + *grid_, *level_cache_, DirBC_Interior, num_omp_threads); } if (!op_extrapolated_smoother_) throw std::runtime_error("Failed to initialize Extrapolated Smoother."); diff --git a/include/Residual/ResidualGive/residualGive.h b/include/Residual/ResidualGive/residualGive.h index 8a0503ab..452e8408 100644 --- a/include/Residual/ResidualGive/residualGive.h +++ b/include/Residual/ResidualGive/residualGive.h @@ -7,7 +7,7 @@ class ResidualGive : public Residual { public: explicit ResidualGive(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, const bool DirBC_Interior, const int num_omp_threads); + const bool DirBC_Interior, const int num_omp_threads); ~ResidualGive() override = default; void computeResidual(Vector result, ConstVector rhs, ConstVector x) const final; diff --git a/include/Residual/ResidualGive/residualGive.inl b/include/Residual/ResidualGive/residualGive.inl index 67eb18eb..2c96141d 100644 --- a/include/Residual/ResidualGive/residualGive.inl +++ b/include/Residual/ResidualGive/residualGive.inl @@ -2,9 +2,9 @@ template ResidualGive::ResidualGive(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, + bool DirBC_Interior, int num_omp_threads) - : Residual(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : Residual(grid, level_cache, DirBC_Interior, num_omp_threads) { } diff --git a/include/Residual/ResidualTake/residualTake.h b/include/Residual/ResidualTake/residualTake.h index b9b48da4..8a7c106f 100644 --- a/include/Residual/ResidualTake/residualTake.h +++ b/include/Residual/ResidualTake/residualTake.h @@ -7,7 +7,7 @@ class ResidualTake : public Residual { public: explicit ResidualTake(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, const bool DirBC_Interior, const int num_omp_threads); + const bool DirBC_Interior, const int num_omp_threads); ~ResidualTake() override = default; void computeResidual(Vector result, ConstVector rhs, ConstVector x) const override; diff --git a/include/Residual/ResidualTake/residualTake.inl b/include/Residual/ResidualTake/residualTake.inl index bf92a7e5..b935e763 100644 --- a/include/Residual/ResidualTake/residualTake.inl +++ b/include/Residual/ResidualTake/residualTake.inl @@ -2,9 +2,9 @@ template ResidualTake::ResidualTake(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, + bool DirBC_Interior, int num_omp_threads) - : Residual(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : Residual(grid, level_cache, DirBC_Interior, num_omp_threads) { } diff --git a/include/Residual/residual.h b/include/Residual/residual.h index 30406adc..f71e12b1 100644 --- a/include/Residual/residual.h +++ b/include/Residual/residual.h @@ -22,11 +22,10 @@ template class Residual { public: - explicit Residual(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, const bool DirBC_Interior, const int num_omp_threads) + explicit Residual(const PolarGrid& grid, const LevelCache& level_cache, const bool DirBC_Interior, + const int num_omp_threads) : grid_(grid) , level_cache_(level_cache) - , domain_geometry_(domain_geometry) , DirBC_Interior_(DirBC_Interior) , num_omp_threads_(num_omp_threads) { @@ -42,7 +41,6 @@ class Residual /* Constructor members */ const PolarGrid& grid_; const LevelCache& level_cache_; - const DomainGeometry& domain_geometry_; const bool DirBC_Interior_; const int num_omp_threads_; }; diff --git a/include/Smoother/SmootherGive/smootherGive.h b/include/Smoother/SmootherGive/smootherGive.h index 71289ae5..638520f9 100644 --- a/include/Smoother/SmootherGive/smootherGive.h +++ b/include/Smoother/SmootherGive/smootherGive.h @@ -50,8 +50,8 @@ class SmootherGive : public Smoother public: // Constructs the coupled circle-radial smoother. // Builds the A_sc smoother matrices and prepares the solvers. - explicit SmootherGive(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads); + explicit SmootherGive(const PolarGrid& grid, const LevelCache& level_cache, bool DirBC_Interior, + int num_omp_threads); // If MUMPS is enabled, this cleans up the inner boundary solver. ~SmootherGive() override; diff --git a/include/Smoother/SmootherGive/smootherGive.inl b/include/Smoother/SmootherGive/smootherGive.inl index c68300c5..009e472a 100644 --- a/include/Smoother/SmootherGive/smootherGive.inl +++ b/include/Smoother/SmootherGive/smootherGive.inl @@ -2,9 +2,9 @@ template SmootherGive::SmootherGive(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, + bool DirBC_Interior, int num_omp_threads) - : Smoother(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : Smoother(grid, level_cache, DirBC_Interior, num_omp_threads) , circle_tridiagonal_solver_(grid.ntheta(), grid.numberSmootherCircles(), true) , radial_tridiagonal_solver_(grid.lengthSmootherRadial(), grid.ntheta(), false) { diff --git a/include/Smoother/SmootherTake/smootherTake.h b/include/Smoother/SmootherTake/smootherTake.h index 7fecb6b4..d3041d79 100644 --- a/include/Smoother/SmootherTake/smootherTake.h +++ b/include/Smoother/SmootherTake/smootherTake.h @@ -50,8 +50,8 @@ class SmootherTake : public Smoother public: // Constructs the coupled circle-radial smoother. // Builds the A_sc smoother matrices and prepares the solvers. - explicit SmootherTake(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads); + explicit SmootherTake(const PolarGrid& grid, const LevelCache& level_cache, bool DirBC_Interior, + int num_omp_threads); // Performs one full coupled smoothing sweep: // BC -> WC -> BR -> WR diff --git a/include/Smoother/SmootherTake/smootherTake.inl b/include/Smoother/SmootherTake/smootherTake.inl index 9a7919af..15f2932d 100644 --- a/include/Smoother/SmootherTake/smootherTake.inl +++ b/include/Smoother/SmootherTake/smootherTake.inl @@ -2,9 +2,9 @@ template SmootherTake::SmootherTake(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, + bool DirBC_Interior, int num_omp_threads) - : Smoother(grid, level_cache, domain_geometry, DirBC_Interior, num_omp_threads) + : Smoother(grid, level_cache, DirBC_Interior, num_omp_threads) , circle_tridiagonal_solver_(grid.ntheta(), grid.numberSmootherCircles(), true) , radial_tridiagonal_solver_(grid.lengthSmootherRadial(), grid.ntheta(), false) #ifdef GMGPOLAR_USE_MUMPS diff --git a/include/Smoother/smoother.h b/include/Smoother/smoother.h index 00cf41c3..d6d18ab5 100644 --- a/include/Smoother/smoother.h +++ b/include/Smoother/smoother.h @@ -33,11 +33,10 @@ template class Smoother { public: - explicit Smoother(const PolarGrid& grid, const LevelCache& level_cache, - const DomainGeometry& domain_geometry, bool DirBC_Interior, int num_omp_threads) + explicit Smoother(const PolarGrid& grid, const LevelCache& level_cache, bool DirBC_Interior, + int num_omp_threads) : grid_(grid) , level_cache_(level_cache) - , domain_geometry_(domain_geometry) , DirBC_Interior_(DirBC_Interior) , num_omp_threads_(num_omp_threads) { @@ -49,7 +48,6 @@ class Smoother protected: const PolarGrid& grid_; const LevelCache& level_cache_; - const DomainGeometry& domain_geometry_; const bool DirBC_Interior_; const int num_omp_threads_; }; diff --git a/tests/DirectSolver/directSolver.cpp b/tests/DirectSolver/directSolver.cpp index 7db37b20..362b7539 100644 --- a/tests/DirectSolver/directSolver.cpp +++ b/tests/DirectSolver/directSolver.cpp @@ -78,10 +78,10 @@ TEST(DirectSolverTest, directSolver_DirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Take directSolverGive_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); - DirectSolver_COO_MUMPS_Give directSolverTake_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take directSolverGive_operator(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give directSolverTake_operator(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); Vector rhs = generate_random_sample_data(level.grid(), 69); @@ -133,10 +133,10 @@ TEST(DirectSolverTest, directSolver_AcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Give directSolverGive_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); - DirectSolver_COO_MUMPS_Take directSolverTake_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give directSolverGive_operator(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take directSolverTake_operator(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); Vector rhs = generate_random_sample_data(level.grid(), 69); @@ -190,10 +190,9 @@ TEST(DirectSolverTest_CircularGeometry, SequentialDirectSolverDirBC_Interior_Cir std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -235,10 +234,9 @@ TEST(DirectSolverTest_CircularGeometry, ParallelDirectSolverDirBC_Interior_Circu std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -280,10 +278,9 @@ TEST(DirectSolverTest_CircularGeometry, SequentialDirectSolverAcrossOrigin_Circu std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -325,10 +322,9 @@ TEST(DirectSolverTest_CircularGeometry, ParallelDirectSolverAcrossOrigin_Circula std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -375,10 +371,9 @@ TEST(DirectSolverTest_ShafranovGeometry, DirectSolverDirBC_Interior_ShafranovGeo std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -421,10 +416,9 @@ TEST(DirectSolverTest_ShafranovGeometry, DirectSolverAcrossOrigin_ShafranovGeome std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -472,10 +466,9 @@ TEST(DirectSolverTest_CzarnyGeometry, DirectSolverDirBC_Interior_CzarnyGeometry) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -519,10 +512,9 @@ TEST(DirectSolverTest_CzarnyGeometry, DirectSolverAcrossOrigin_CzarnyGeometry) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -568,10 +560,9 @@ TEST(DirectSolverTest_CulhamGeometry, DirectSolverDirBC_Interior_CulhamGeometry) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -613,10 +604,9 @@ TEST(DirectSolverTest_CulhamGeometry, DirectSolverAcrossOrigin_CulhamGeometry) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -670,10 +660,9 @@ TEST(DirectSolverTest_CircularGeometry, DirectSolverAcrossOriginHigherPrecision_ std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -715,10 +704,9 @@ TEST(DirectSolverTest_CircularGeometry, DirectSolverAcrossOriginHigherPrecision2 std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -761,10 +749,9 @@ TEST(DirectSolverTakeTest_CircularGeometry, SequentialDirectSolverDirBC_Interior std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -806,10 +793,9 @@ TEST(DirectSolverTakeTest_CircularGeometry, ParallelDirectSolverDirBC_Interior_C std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -851,10 +837,9 @@ TEST(DirectSolverTakeTest_CircularGeometry, SequentialDirectSolverAcrossOrigin_C std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -896,10 +881,9 @@ TEST(DirectSolverTakeTest_CircularGeometry, ParallelDirectSolverAcrossOrigin_Cir std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -946,10 +930,9 @@ TEST(DirectSolverTakeTest_ShafranovGeometry, DirectSolverDirBC_Interior_Shafrano std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -992,10 +975,9 @@ TEST(DirectSolverTakeTest_ShafranovGeometry, DirectSolverAcrossOrigin_ShafranovG std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -1043,10 +1025,9 @@ TEST(DirectSolverTakeTest_CzarnyGeometry, DirectSolverDirBC_Interior_CzarnyGeome std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -1090,10 +1071,9 @@ TEST(DirectSolverTakeTest_CzarnyGeometry, DirectSolverAcrossOrigin_CzarnyGeometr std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -1139,10 +1119,9 @@ TEST(DirectSolverTakeTest_CulhamGeometry, DirectSolverDirBC_Interior_CulhamGeome std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -1184,10 +1163,9 @@ TEST(DirectSolverTakeTest_CulhamGeometry, DirectSolverAcrossOrigin_CulhamGeometr std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -1239,10 +1217,9 @@ TEST(DirectSolverTakeTest_CircularGeometry, DirectSolverAcrossOriginHigherPrecis std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); @@ -1284,10 +1261,9 @@ TEST(DirectSolverTakeTest_CircularGeometry, DirectSolverAcrossOriginHigherPrecis std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_COO_MUMPS_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("sol", rhs.size()); diff --git a/tests/DirectSolver/directSolverNoMumps.cpp b/tests/DirectSolver/directSolverNoMumps.cpp index 2585184e..9ac9c87b 100644 --- a/tests/DirectSolver/directSolverNoMumps.cpp +++ b/tests/DirectSolver/directSolverNoMumps.cpp @@ -77,10 +77,10 @@ TEST(DirectSolverTestNoMumps, directSolver_DirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take directSolverGive_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); - DirectSolver_CSR_LU_Give directSolverTake_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take directSolverGive_operator(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give directSolverTake_operator(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); Vector rhs = generate_random_sample_data(level.grid(), 69); @@ -133,10 +133,10 @@ TEST(DirectSolverTestNoMumps, directSolver_AcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give directSolverGive_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); - DirectSolver_CSR_LU_Take directSolverTake_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give directSolverGive_operator(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take directSolverTake_operator(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); Vector rhs = generate_random_sample_data(level.grid(), 69); @@ -190,10 +190,9 @@ TEST(DirectSolverTestNoMumps_CircularGeometry, SequentialDirectSolverDirBC_Inter std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -235,10 +234,9 @@ TEST(DirectSolverTestNoMumps_CircularGeometry, ParallelDirectSolverDirBC_Interio std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -280,10 +278,9 @@ TEST(DirectSolverTestNoMumps_CircularGeometry, SequentialDirectSolverAcrossOrigi std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -325,10 +322,9 @@ TEST(DirectSolverTestNoMumps_CircularGeometry, ParallelDirectSolverAcrossOrigin_ std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -376,10 +372,9 @@ TEST(DirectSolverTestNoMumps_ShafranovGeometry, DirectSolverDirBC_Interior_Shafr std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -423,10 +418,9 @@ TEST(DirectSolverTestNoMumps_ShafranovGeometry, DirectSolverAcrossOrigin_Shafran std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -475,10 +469,9 @@ TEST(DirectSolverTestNoMumps_CzarnyGeometry, DirectSolverDirBC_Interior_CzarnyGe std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -523,10 +516,9 @@ TEST(DirectSolverTestNoMumps_CzarnyGeometry, DirectSolverAcrossOrigin_CzarnyGeom std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -572,10 +564,9 @@ TEST(DirectSolverTestNoMumps_CulhamGeometry, DirectSolverDirBC_Interior_CulhamGe std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -617,10 +608,9 @@ TEST(DirectSolverTestNoMumps_CulhamGeometry, DirectSolverAcrossOrigin_CulhamGeom std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -674,10 +664,9 @@ TEST(DirectSolverTestNoMumps_CircularGeometry, DirectSolverAcrossOriginHigherPre std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -719,10 +708,9 @@ TEST(DirectSolverTestNoMumps_CircularGeometry, DirectSolverAcrossOriginHigherPre std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -765,10 +753,9 @@ TEST(DirectSolverTakeCustomLUTest_CircularGeometry, SequentialDirectSolverDirBC_ std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -810,10 +797,9 @@ TEST(DirectSolverTakeCustomLUTest_CircularGeometry, ParallelDirectSolverDirBC_In std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -855,10 +841,9 @@ TEST(DirectSolverTakeCustomLUTest_CircularGeometry, SequentialDirectSolverAcross std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -900,10 +885,9 @@ TEST(DirectSolverTakeCustomLUTest_CircularGeometry, ParallelDirectSolverAcrossOr std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -951,10 +935,9 @@ TEST(DirectSolverTakeCustomLUTest_ShafranovGeometry, DirectSolverDirBC_Interior_ std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -998,10 +981,9 @@ TEST(DirectSolverTakeCustomLUTest_ShafranovGeometry, DirectSolverAcrossOrigin_Sh std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -1050,10 +1032,9 @@ TEST(DirectSolverTakeCustomLUTest_CzarnyGeometry, DirectSolverDirBC_Interior_Cza std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -1098,10 +1079,9 @@ TEST(DirectSolverTakeCustomLUTest_CzarnyGeometry, DirectSolverAcrossOrigin_Czarn std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -1147,10 +1127,9 @@ TEST(DirectSolverTakeCustomLUTest_CulhamGeometry, DirectSolverDirBC_Interior_Cul std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -1192,10 +1171,9 @@ TEST(DirectSolverTakeCustomLUTest_CulhamGeometry, DirectSolverAcrossOrigin_Culha std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -1247,10 +1225,9 @@ TEST(DirectSolverTakeCustomLUTest_CircularGeometry, DirectSolverAcrossOriginHigh std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); @@ -1292,10 +1269,9 @@ TEST(DirectSolverTakeCustomLUTest_CircularGeometry, DirectSolverAcrossOriginHigh std::unique_ptr source_term = std::make_unique(level.grid(), Rmax); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector solution("solution", rhs.size()); diff --git a/tests/ExtrapolatedSmoother/extrapolated_smoother.cpp b/tests/ExtrapolatedSmoother/extrapolated_smoother.cpp index e6ad2304..4caad3ff 100644 --- a/tests/ExtrapolatedSmoother/extrapolated_smoother.cpp +++ b/tests/ExtrapolatedSmoother/extrapolated_smoother.cpp @@ -61,10 +61,10 @@ TEST(ExtrapolatedSmootherTest, extrapolatedSmoother_DirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - ExtrapolatedSmootherGive smootherGive_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); - ExtrapolatedSmootherTake smootherTake_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive smootherGive_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ExtrapolatedSmootherTake smootherTake_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); Vector rhs = generate_random_sample_data(level.grid(), 69); Vector start = generate_random_sample_data(level.grid(), 24); @@ -122,10 +122,10 @@ TEST(ExtrapolatedSmootherTest, extrapolatedSmoother_AcossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - ExtrapolatedSmootherGive smootherGive_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); - ExtrapolatedSmootherTake smootherTake_operator( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive smootherGive_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ExtrapolatedSmootherTake smootherTake_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); Vector rhs = generate_random_sample_data(level.grid(), 69); Vector start = generate_random_sample_data(level.grid(), 24); @@ -185,12 +185,11 @@ TEST(ExtrapolatedSmootherTest, SequentialExtrapolatedSmootherDirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherGive extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -270,12 +269,11 @@ TEST(ExtrapolatedSmootherTest, ParallelExtrapolatedSmootherDirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherGive extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -355,12 +353,11 @@ TEST(ExtrapolatedSmootherTest, SequentialExtrapolatedSmootherAcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherGive extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -442,12 +439,11 @@ TEST(ExtrapolatedSmootherTest, ParallelExtrapolatedSmootherAcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherGive extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -528,12 +524,11 @@ TEST(ExtrapolatedSmootherTest, SequentialExtrapolatedSmootherDirBC_Interior_Smal std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherGive extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -614,12 +609,11 @@ TEST(ExtrapolatedSmootherTest, ParallelExtrapolatedSmootherDirBC_Interior_Smalle std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherGive extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -700,12 +694,11 @@ TEST(ExtrapolatedSmootherTest, SequentialExtrapolatedSmootherAcrossOrigin_Smalle std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherGive extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -784,12 +777,11 @@ TEST(ExtrapolatedSmootherTest, ParallelExtrapolatedSmootherAcrossOrigin_Smallest std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherGive extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherGive extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -871,12 +863,11 @@ TEST(ExtrapolatedSmootherTest, SequentialExtrapolatedSmootherTakeDirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherTake extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherTake extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -958,12 +949,11 @@ TEST(ExtrapolatedSmootherTest, ParallelExtrapolatedSmootherTakeDirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherTake extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherTake extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1043,12 +1033,11 @@ TEST(ExtrapolatedSmootherTest, SequentialExtrapolatedSmootherTakeAcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherTake extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherTake extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1128,12 +1117,11 @@ TEST(ExtrapolatedSmootherTest, ParallelExtrapolatedSmootherTakeAcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherTake extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherTake extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1212,12 +1200,11 @@ TEST(ExtrapolatedSmootherTest, SequentialExtrapolatedSmootherTakeDirBC_Interior_ std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherTake extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherTake extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1296,12 +1283,11 @@ TEST(ExtrapolatedSmootherTest, ParallelExtrapolatedSmootherTakeDirBC_Interior_Sm std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherTake extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherTake extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1380,12 +1366,11 @@ TEST(ExtrapolatedSmootherTest, SequentialExtrapolatedSmootherTakeAcrossOrigin_Sm std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherTake extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherTake extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1464,12 +1449,11 @@ TEST(ExtrapolatedSmootherTest, ParallelExtrapolatedSmootherTakeAcrossOrigin_Smal std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - ExtrapolatedSmootherTake extrapolated_smoother_op( - level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, maxOpenMPThreads); + DirectSolver_CSR_LU_Take solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + ExtrapolatedSmootherTake extrapolated_smoother_op(level.grid(), level.levelCache(), + DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); diff --git a/tests/Residual/residual.cpp b/tests/Residual/residual.cpp index 1538a165..46d88ded 100644 --- a/tests/Residual/residual.cpp +++ b/tests/Residual/residual.cpp @@ -55,10 +55,10 @@ TEST(OperatorATest, applyA_DirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - ResidualGive residualGive_operator(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residualTake_operator(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); + ResidualGive residualGive_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residualTake_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); Vector x = generate_random_sample_data(level.grid(), 42); Vector rhs = generate_random_sample_data(level.grid(), 69); @@ -111,10 +111,10 @@ TEST(OperatorATest, applyA_AcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - ResidualGive residualGive_operator(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualTake residualTake_operator(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); + ResidualGive residualGive_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualTake residualTake_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); Vector x = generate_random_sample_data(level.grid(), 42); Vector rhs = generate_random_sample_data(level.grid(), 69); diff --git a/tests/Smoother/smoother.cpp b/tests/Smoother/smoother.cpp index c19977fd..e733da89 100644 --- a/tests/Smoother/smoother.cpp +++ b/tests/Smoother/smoother.cpp @@ -60,10 +60,10 @@ TEST(SmootherTest, smoother_DirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - SmootherGive smootherGive_operator(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - SmootherTake smootherTake_operator(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); + SmootherGive smootherGive_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + SmootherTake smootherTake_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); Vector rhs = generate_random_sample_data(level.grid(), 69); Vector start = generate_random_sample_data(level.grid(), 24); @@ -120,10 +120,10 @@ TEST(SmootherTest, smoother_AcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - SmootherGive smootherGive_operator(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - SmootherTake smootherTake_operator(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); + SmootherGive smootherGive_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + SmootherTake smootherTake_operator(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); Vector rhs = generate_random_sample_data(level.grid(), 69); Vector start = generate_random_sample_data(level.grid(), 24); @@ -182,12 +182,10 @@ TEST(SmootherTest, SequentialSmootherDirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherGive smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherGive smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -261,12 +259,10 @@ TEST(SmootherTest, ParallelSmootherDirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherGive smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherGive smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -340,12 +336,10 @@ TEST(SmootherTest, SequentialSmootherAcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherGive smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherGive smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -419,12 +413,10 @@ TEST(SmootherTest, ParallelSmootherAcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherGive smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherGive smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -497,12 +489,10 @@ TEST(SmootherTest, SequentialSmootherDirBC_Interior_SmallestGrid) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherGive smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherGive smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -575,12 +565,10 @@ TEST(SmootherTest, ParallelSmootherDirBC_Interior_SmallestGrid) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherGive smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherGive smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -653,12 +641,10 @@ TEST(SmootherTest, SequentialSmootherAcrossOrigin_SmallestGrid) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherGive smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherGive smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -731,12 +717,10 @@ TEST(SmootherTest, ParallelSmootherAcrossOrigin_SmallestGrid) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherGive smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherGive smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -812,12 +796,10 @@ TEST(SmootherTest, SequentialSmootherTakeDirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherTake smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherTake smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -891,12 +873,10 @@ TEST(SmootherTest, ParallelSmootherTakeDirBC_Interior) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherTake smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherTake smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -970,12 +950,10 @@ TEST(SmootherTest, SequentialSmootherTakeAcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherTake smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherTake smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1049,12 +1027,10 @@ TEST(SmootherTest, ParallelSmootherTakeAcrossOrigin) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherTake smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherTake smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1127,12 +1103,10 @@ TEST(SmootherTest, SequentialSmootherTakeDirBC_Interior_SmallestGrid) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherTake smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherTake smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1205,12 +1179,10 @@ TEST(SmootherTest, ParallelSmootherTakeDirBC_Interior_SmallestGrid) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherTake smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherTake smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1283,12 +1255,10 @@ TEST(SmootherTest, SequentialSmootherTakeAcrossOrigin_SmallestGrid) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherTake smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherTake smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size()); @@ -1361,12 +1331,10 @@ TEST(SmootherTest, ParallelSmootherTakeAcrossOrigin_SmallestGrid) std::unique_ptr source_term = std::make_unique(level.grid(), Rmax, kappa_eps, delta_e); - DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), domain_geometry, - DirBC_Interior, maxOpenMPThreads); - ResidualGive residual_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); - SmootherTake smoother_op(level.grid(), level.levelCache(), domain_geometry, DirBC_Interior, - maxOpenMPThreads); + DirectSolver_CSR_LU_Give solver_op(level.grid(), level.levelCache(), DirBC_Interior, + maxOpenMPThreads); + ResidualGive residual_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); + SmootherTake smoother_op(level.grid(), level.levelCache(), DirBC_Interior, maxOpenMPThreads); ConstVector rhs = generate_random_sample_data(level.grid(), 42); Vector discrete_solution("discrete_solution", rhs.size());