From fbfbc9d97915567b76bd5cfdcac09d0ec71f3e86 Mon Sep 17 00:00:00 2001 From: julianlitz Date: Tue, 19 May 2026 20:29:23 +0200 Subject: [PATCH 1/2] Improve code compilation --- include/ConfigParser/config_parser.h | 4 +- src/CMakeLists.txt | 4 + src/ConfigParser/select_solver_circular.cpp | 243 ++++++ src/ConfigParser/select_solver_culham.cpp | 78 ++ src/ConfigParser/select_solver_czarny.cpp | 242 ++++++ src/ConfigParser/select_solver_shafranov.cpp | 243 ++++++ src/ConfigParser/select_test_case.cpp | 775 ------------------- 7 files changed, 813 insertions(+), 776 deletions(-) create mode 100644 src/ConfigParser/select_solver_circular.cpp create mode 100644 src/ConfigParser/select_solver_culham.cpp create mode 100644 src/ConfigParser/select_solver_czarny.cpp create mode 100644 src/ConfigParser/select_solver_shafranov.cpp diff --git a/include/ConfigParser/config_parser.h b/include/ConfigParser/config_parser.h index 37d83a5f4..f12b74b6e 100644 --- a/include/ConfigParser/config_parser.h +++ b/include/ConfigParser/config_parser.h @@ -10,12 +10,14 @@ #include "../../include/PolarGrid/polargrid.h" #include "../../include/GMGPolar/test_cases.h" #include "../../include/GMGPolar/igmgpolar.h" -#include "../../include/GMGPolar/gmgpolar.h" #include "test_selection.h" namespace gmgpolar { +template +class GMGPolar; + class ConfigParser { public: diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index eff7760db..d292366b7 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -44,6 +44,10 @@ set(INTERPOLATION_SOURCES set(CONFIG_PARSER_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/ConfigParser/config_parser.cpp ${CMAKE_CURRENT_SOURCE_DIR}/ConfigParser/select_test_case.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/ConfigParser/select_solver_circular.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/ConfigParser/select_solver_shafranov.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/ConfigParser/select_solver_czarny.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/ConfigParser/select_solver_culham.cpp ) # Create the main library diff --git a/src/ConfigParser/select_solver_circular.cpp b/src/ConfigParser/select_solver_circular.cpp new file mode 100644 index 000000000..cd754c062 --- /dev/null +++ b/src/ConfigParser/select_solver_circular.cpp @@ -0,0 +1,243 @@ +#include "../include/ConfigParser/config_parser.h" +#include "../include/GMGPolar/gmgpolar.h" + +using namespace gmgpolar; + +template +void ConfigParser::solve(GMGPolar& solver) const +{ + if constexpr (std::is_same_v) { + + switch (problem_type_) { + + /* ------------------------------------------------------------------ */ + case ProblemType::CARTESIAN_R2: { + CartesianR2_Boundary_CircularGeometry bc(Rmax_); + switch (alpha_type_) { + case AlphaCoeff::POISSON: { + CartesianR2_Poisson_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case AlphaCoeff::SONNENDRUCKER: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR2_Sonnendrucker_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR2_SonnendruckerGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR2_Zoni_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR2_ZoniGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR2_ZoniShifted_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR2_ZoniShiftedGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::CARTESIAN_R6: { + CartesianR6_Boundary_CircularGeometry bc(Rmax_); + switch (alpha_type_) { + case AlphaCoeff::POISSON: { + CartesianR6_Poisson_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case AlphaCoeff::SONNENDRUCKER: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR6_Sonnendrucker_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR6_SonnendruckerGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR6_Zoni_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR6_ZoniGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR6_ZoniShifted_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR6_ZoniShiftedGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::POLAR_R6: { + PolarR6_Boundary_CircularGeometry bc(Rmax_); + switch (alpha_type_) { + case AlphaCoeff::POISSON: { + PolarR6_Poisson_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case AlphaCoeff::SONNENDRUCKER: + switch (beta_type_) { + case BetaCoeff::ZERO: { + PolarR6_Sonnendrucker_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_SonnendruckerGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI: + switch (beta_type_) { + case BetaCoeff::ZERO: { + PolarR6_Zoni_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_ZoniGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ZERO: { + PolarR6_ZoniShifted_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_ZoniShiftedGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::REFINED_RADIUS: { + Refined_Boundary_CircularGeometry bc(Rmax_); + switch (alpha_type_) { + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ALPHA_INVERSE: { + Refined_ZoniShiftedGyro_CircularGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta for configuration.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha for configuration.\n"); + } + break; + } + + default: + throw std::runtime_error("Invalid problem.\n"); + } + } +} + +// Explicit instantiations — CircularGeometry for all coefficient types +template void +ConfigParser::solve(GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void +ConfigParser::solve(GMGPolar&) const; +template void +ConfigParser::solve(GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; \ No newline at end of file diff --git a/src/ConfigParser/select_solver_culham.cpp b/src/ConfigParser/select_solver_culham.cpp new file mode 100644 index 000000000..54633952c --- /dev/null +++ b/src/ConfigParser/select_solver_culham.cpp @@ -0,0 +1,78 @@ +#include "../include/ConfigParser/config_parser.h" +#include "../include/GMGPolar/gmgpolar.h" + +using namespace gmgpolar; + +template +void ConfigParser::solve(GMGPolar& solver) const +{ + if constexpr (std::is_same_v) { + + switch (problem_type_) { + + /* ------------------------------------------------------------------ */ + /* Culham only supports POLAR_R6 and REFINED_RADIUS. */ + /* CARTESIAN_R2 and CARTESIAN_R6 are not defined for this geometry. */ + /* ------------------------------------------------------------------ */ + + case ProblemType::POLAR_R6: { + PolarR6_Boundary_CulhamGeometry bc(Rmax_); + switch (alpha_type_) { + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_ZoniShiftedGyro_CulhamGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta for configuration.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha for configuration.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::REFINED_RADIUS: { + Refined_Boundary_CulhamGeometry bc(Rmax_); + switch (alpha_type_) { + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ALPHA_INVERSE: { + Refined_ZoniShiftedGyro_CulhamGeometry src(grid_, Rmax_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta for configuration.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha for configuration.\n"); + } + break; + } + + default: + throw std::runtime_error("Invalid geometry for configuration.\n"); + } + } +} + +// Explicit instantiations — CulhamGeometry for all coefficient types +template void +ConfigParser::solve(GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void ConfigParser::solve(GMGPolar&) const; +template void +ConfigParser::solve(GMGPolar&) const; +template void +ConfigParser::solve(GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; \ No newline at end of file diff --git a/src/ConfigParser/select_solver_czarny.cpp b/src/ConfigParser/select_solver_czarny.cpp new file mode 100644 index 000000000..3a347c5dc --- /dev/null +++ b/src/ConfigParser/select_solver_czarny.cpp @@ -0,0 +1,242 @@ +#include "../include/ConfigParser/config_parser.h" +#include "../include/GMGPolar/gmgpolar.h" + +using namespace gmgpolar; + +template +void ConfigParser::solve(GMGPolar& solver) const +{ + if constexpr (std::is_same_v) { + + switch (problem_type_) { + + /* ------------------------------------------------------------------ */ + case ProblemType::CARTESIAN_R2: { + CartesianR2_Boundary_CzarnyGeometry bc(Rmax_, kappa_eps_, delta_e_); + switch (alpha_type_) { + case AlphaCoeff::POISSON: { + CartesianR2_Poisson_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case AlphaCoeff::SONNENDRUCKER: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR2_Sonnendrucker_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR2_SonnendruckerGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR2_Zoni_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR2_ZoniGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR2_ZoniShifted_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR2_ZoniShiftedGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::CARTESIAN_R6: { + CartesianR6_Boundary_CzarnyGeometry bc(Rmax_, kappa_eps_, delta_e_); + switch (alpha_type_) { + case AlphaCoeff::POISSON: { + CartesianR6_Poisson_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case AlphaCoeff::SONNENDRUCKER: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR6_Sonnendrucker_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR6_SonnendruckerGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR6_Zoni_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR6_ZoniGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR6_ZoniShifted_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR6_ZoniShiftedGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::POLAR_R6: { + PolarR6_Boundary_CzarnyGeometry bc(Rmax_, kappa_eps_, delta_e_); + switch (alpha_type_) { + case AlphaCoeff::POISSON: { + PolarR6_Poisson_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case AlphaCoeff::SONNENDRUCKER: + switch (beta_type_) { + case BetaCoeff::ZERO: { + PolarR6_Sonnendrucker_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_SonnendruckerGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI: + switch (beta_type_) { + case BetaCoeff::ZERO: { + PolarR6_Zoni_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_ZoniGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ZERO: { + PolarR6_ZoniShifted_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_ZoniShiftedGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::REFINED_RADIUS: { + Refined_Boundary_CzarnyGeometry bc(Rmax_, kappa_eps_, delta_e_); + switch (alpha_type_) { + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ALPHA_INVERSE: { + Refined_ZoniShiftedGyro_CzarnyGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta for configuration.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha for configuration.\n"); + } + break; + } + + default: + throw std::runtime_error("Invalid problem.\n"); + } + } +} + +// Explicit instantiations — CzarnyGeometry for all coefficient types +template void +ConfigParser::solve(GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void ConfigParser::solve(GMGPolar&) const; +template void +ConfigParser::solve(GMGPolar&) const; +template void +ConfigParser::solve(GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; \ No newline at end of file diff --git a/src/ConfigParser/select_solver_shafranov.cpp b/src/ConfigParser/select_solver_shafranov.cpp new file mode 100644 index 000000000..d58b616ca --- /dev/null +++ b/src/ConfigParser/select_solver_shafranov.cpp @@ -0,0 +1,243 @@ +#include "../include/ConfigParser/config_parser.h" +#include "../include/GMGPolar/gmgpolar.h" + +using namespace gmgpolar; + +template +void ConfigParser::solve(GMGPolar& solver) const +{ + if constexpr (std::is_same_v) { + + switch (problem_type_) { + + /* ------------------------------------------------------------------ */ + case ProblemType::CARTESIAN_R2: { + CartesianR2_Boundary_ShafranovGeometry bc(Rmax_, kappa_eps_, delta_e_); + switch (alpha_type_) { + case AlphaCoeff::POISSON: { + CartesianR2_Poisson_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case AlphaCoeff::SONNENDRUCKER: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR2_Sonnendrucker_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR2_SonnendruckerGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR2_Zoni_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR2_ZoniGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR2_ZoniShifted_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR2_ZoniShiftedGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::CARTESIAN_R6: { + CartesianR6_Boundary_ShafranovGeometry bc(Rmax_, kappa_eps_, delta_e_); + switch (alpha_type_) { + case AlphaCoeff::POISSON: { + CartesianR6_Poisson_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case AlphaCoeff::SONNENDRUCKER: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR6_Sonnendrucker_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR6_SonnendruckerGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR6_Zoni_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR6_ZoniGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ZERO: { + CartesianR6_ZoniShifted_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + CartesianR6_ZoniShiftedGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::POLAR_R6: { + PolarR6_Boundary_ShafranovGeometry bc(Rmax_, kappa_eps_, delta_e_); + switch (alpha_type_) { + case AlphaCoeff::POISSON: { + PolarR6_Poisson_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case AlphaCoeff::SONNENDRUCKER: + switch (beta_type_) { + case BetaCoeff::ZERO: { + PolarR6_Sonnendrucker_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_SonnendruckerGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI: + switch (beta_type_) { + case BetaCoeff::ZERO: { + PolarR6_Zoni_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_ZoniGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ZERO: { + PolarR6_ZoniShifted_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + case BetaCoeff::ALPHA_INVERSE: { + PolarR6_ZoniShiftedGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha.\n"); + } + break; + } + + /* ------------------------------------------------------------------ */ + case ProblemType::REFINED_RADIUS: { + Refined_Boundary_ShafranovGeometry bc(Rmax_, kappa_eps_, delta_e_); + switch (alpha_type_) { + case AlphaCoeff::ZONI_SHIFTED: + switch (beta_type_) { + case BetaCoeff::ALPHA_INVERSE: { + Refined_ZoniShiftedGyro_ShafranovGeometry src(grid_, Rmax_, kappa_eps_, delta_e_); + solver.solve(bc, src); + break; + } + default: + throw std::runtime_error("Invalid beta for configuration.\n"); + } + break; + default: + throw std::runtime_error("Invalid alpha for configuration.\n"); + } + break; + } + + default: + throw std::runtime_error("Invalid problem.\n"); + } + } +} + +// Explicit instantiations — ShafranovGeometry all coefficient types +template void +ConfigParser::solve(GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void +ConfigParser::solve(GMGPolar&) const; +template void +ConfigParser::solve(GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; +template void ConfigParser::solve( + GMGPolar&) const; \ No newline at end of file diff --git a/src/ConfigParser/select_test_case.cpp b/src/ConfigParser/select_test_case.cpp index cf12c8972..a594fee31 100644 --- a/src/ConfigParser/select_test_case.cpp +++ b/src/ConfigParser/select_test_case.cpp @@ -194,778 +194,3 @@ void ConfigParser::selectTestCase(GeometryType geometry_type, ProblemType proble throw std::runtime_error("Invalid problem.\n"); } } - -template -void ConfigParser::solve(GMGPolar& solver) const -{ - assert(domain_geometry_ != nullptr); - /* ------------------------------------------ */ - /* Source Term (rhs_f) and BoundaryConditions */ - switch (problem_type_) { - case ProblemType::CARTESIAN_R2: - - switch (geometry_type_) { - case GeometryType::CIRCULAR: { - CartesianR2_Boundary_CircularGeometry boundary_conditions(Rmax_); - - switch (alpha_type_) { - case AlphaCoeff::POISSON: { - CartesianR2_Poisson_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case AlphaCoeff::SONNENDRUCKER: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR2_Sonnendrucker_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR2_SonnendruckerGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR2_Zoni_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR2_ZoniGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR2_ZoniShifted_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR2_ZoniShiftedGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha.\n"); - } - break; - } - - case GeometryType::SHAFRANOV: { - CartesianR2_Boundary_ShafranovGeometry boundary_conditions(Rmax_, kappa_eps_, delta_e_); - - switch (alpha_type_) { - case AlphaCoeff::POISSON: { - CartesianR2_Poisson_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case AlphaCoeff::SONNENDRUCKER: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR2_Sonnendrucker_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR2_SonnendruckerGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR2_Zoni_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR2_ZoniGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR2_ZoniShifted_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR2_ZoniShiftedGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha.\n"); - } - break; - } - - case GeometryType::CZARNY: { - CartesianR2_Boundary_CzarnyGeometry boundary_conditions(Rmax_, kappa_eps_, delta_e_); - - switch (alpha_type_) { - case AlphaCoeff::POISSON: { - CartesianR2_Poisson_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case AlphaCoeff::SONNENDRUCKER: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR2_Sonnendrucker_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR2_SonnendruckerGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR2_Zoni_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR2_ZoniGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR2_ZoniShifted_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR2_ZoniShiftedGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha.\n"); - } - break; - } - - default: - throw std::runtime_error("Invalid geometry for configuration.\n"); - } - break; - - case ProblemType::CARTESIAN_R6: - - switch (geometry_type_) { - case GeometryType::CIRCULAR: { - CartesianR6_Boundary_CircularGeometry boundary_conditions(Rmax_); - - switch (alpha_type_) { - case AlphaCoeff::POISSON: { - CartesianR6_Poisson_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case AlphaCoeff::SONNENDRUCKER: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR6_Sonnendrucker_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR6_SonnendruckerGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR6_Zoni_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR6_ZoniGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR6_ZoniShifted_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR6_ZoniShiftedGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha.\n"); - } - break; - } - - case GeometryType::SHAFRANOV: { - CartesianR6_Boundary_ShafranovGeometry boundary_conditions(Rmax_, kappa_eps_, delta_e_); - - switch (alpha_type_) { - case AlphaCoeff::POISSON: { - CartesianR6_Poisson_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case AlphaCoeff::SONNENDRUCKER: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR6_Sonnendrucker_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR6_SonnendruckerGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR6_Zoni_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR6_ZoniGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR6_ZoniShifted_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR6_ZoniShiftedGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha.\n"); - } - break; - } - - case GeometryType::CZARNY: { - CartesianR6_Boundary_CzarnyGeometry boundary_conditions(Rmax_, kappa_eps_, delta_e_); - - switch (alpha_type_) { - case AlphaCoeff::POISSON: { - CartesianR6_Poisson_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case AlphaCoeff::SONNENDRUCKER: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR6_Sonnendrucker_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR6_SonnendruckerGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR6_Zoni_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR6_ZoniGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ZERO: { - CartesianR6_ZoniShifted_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - CartesianR6_ZoniShiftedGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha.\n"); - } - break; - } - - default: - throw std::runtime_error("Invalid geometry for configuration.\n"); - } - break; - - case ProblemType::POLAR_R6: - - switch (geometry_type_) { - case GeometryType::CIRCULAR: { - PolarR6_Boundary_CircularGeometry boundary_conditions(Rmax_); - - switch (alpha_type_) { - case AlphaCoeff::POISSON: { - PolarR6_Poisson_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case AlphaCoeff::SONNENDRUCKER: - switch (beta_type_) { - case BetaCoeff::ZERO: { - PolarR6_Sonnendrucker_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_SonnendruckerGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI: - switch (beta_type_) { - case BetaCoeff::ZERO: { - PolarR6_Zoni_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_ZoniGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ZERO: { - PolarR6_ZoniShifted_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_ZoniShiftedGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha.\n"); - } - break; - } - - case GeometryType::SHAFRANOV: { - PolarR6_Boundary_ShafranovGeometry boundary_conditions(Rmax_, kappa_eps_, delta_e_); - - switch (alpha_type_) { - case AlphaCoeff::POISSON: { - PolarR6_Poisson_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case AlphaCoeff::SONNENDRUCKER: - switch (beta_type_) { - case BetaCoeff::ZERO: { - PolarR6_Sonnendrucker_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_SonnendruckerGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI: - switch (beta_type_) { - case BetaCoeff::ZERO: { - PolarR6_Zoni_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_ZoniGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ZERO: { - PolarR6_ZoniShifted_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_ZoniShiftedGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha.\n"); - } - break; - } - - case GeometryType::CZARNY: { - PolarR6_Boundary_CzarnyGeometry boundary_conditions(Rmax_, kappa_eps_, delta_e_); - - switch (alpha_type_) { - case AlphaCoeff::POISSON: { - PolarR6_Poisson_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case AlphaCoeff::SONNENDRUCKER: - switch (beta_type_) { - case BetaCoeff::ZERO: { - PolarR6_Sonnendrucker_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_SonnendruckerGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI: - switch (beta_type_) { - case BetaCoeff::ZERO: { - PolarR6_Zoni_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_ZoniGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ZERO: { - PolarR6_ZoniShifted_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_ZoniShiftedGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha.\n"); - } - break; - } - - case GeometryType::CULHAM: { - PolarR6_Boundary_CulhamGeometry boundary_conditions(Rmax_); - switch (alpha_type_) { - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ALPHA_INVERSE: { - PolarR6_ZoniShiftedGyro_CulhamGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta for configuration.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha for configuration.\n"); - } - break; - } - - default: - throw std::runtime_error("Invalid geometry for configuration.\n"); - } - break; - - case ProblemType::REFINED_RADIUS: - - switch (geometry_type_) { - case GeometryType::CIRCULAR: { - Refined_Boundary_CircularGeometry boundary_conditions(Rmax_); - - switch (alpha_type_) { - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ALPHA_INVERSE: { - Refined_ZoniShiftedGyro_CircularGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta for configuration.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha for configuration.\n"); - } - break; - } - - case GeometryType::SHAFRANOV: { - Refined_Boundary_ShafranovGeometry boundary_conditions(Rmax_, kappa_eps_, delta_e_); - - switch (alpha_type_) { - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ALPHA_INVERSE: { - Refined_ZoniShiftedGyro_ShafranovGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta for configuration.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha for configuration.\n"); - } - break; - } - - case GeometryType::CZARNY: { - Refined_Boundary_CzarnyGeometry boundary_conditions(Rmax_, kappa_eps_, delta_e_); - - switch (alpha_type_) { - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ALPHA_INVERSE: { - Refined_ZoniShiftedGyro_CzarnyGeometry source_term(grid_, Rmax_, kappa_eps_, delta_e_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta for configuration.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha for configuration.\n"); - } - break; - } - - case GeometryType::CULHAM: { - Refined_Boundary_CulhamGeometry boundary_conditions(Rmax_); - - switch (alpha_type_) { - case AlphaCoeff::ZONI_SHIFTED: - switch (beta_type_) { - case BetaCoeff::ALPHA_INVERSE: { - Refined_ZoniShiftedGyro_CulhamGeometry source_term(grid_, Rmax_); - solver.solve(boundary_conditions, source_term); - break; - } - default: - throw std::runtime_error("Invalid beta for configuration.\n"); - } - break; - default: - throw std::runtime_error("Invalid alpha for configuration.\n"); - } - break; - } - - default: - throw std::runtime_error("Invalid geometry for configuration.\n"); - } - break; - - default: - throw std::runtime_error("Invalid problem.\n"); - } -} - -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void -ConfigParser::solve(GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; - -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void -ConfigParser::solve(GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; - -template void -ConfigParser::solve(GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void -ConfigParser::solve(GMGPolar& solver) const; -template void -ConfigParser::solve(GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; - -template void -ConfigParser::solve(GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void -ConfigParser::solve(GMGPolar& solver) const; -template void -ConfigParser::solve(GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; -template void ConfigParser::solve( - GMGPolar& solver) const; From 90862d7159498f2564b41919ff1455d885335650 Mon Sep 17 00:00:00 2001 From: julianlitz Date: Tue, 19 May 2026 20:40:16 +0200 Subject: [PATCH 2/2] Fix --- scripts/tutorial/run.sh | 3 +-- src/ConfigParser/config_parser.cpp | 13 ++++++++++++- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/scripts/tutorial/run.sh b/scripts/tutorial/run.sh index 62f49351c..fb9ea8a58 100755 --- a/scripts/tutorial/run.sh +++ b/scripts/tutorial/run.sh @@ -131,10 +131,9 @@ fi export OMP_NUM_THREADS=$maxOpenMPThreads -"$GMGPOLAR_EXEC" \ +"$GMGPOLAR_EXEC" --kokkos-threads $maxOpenMPThreads \ --verbose $verbose \ --paraview $paraview \ - --kokkos-threads $maxOpenMPThreads \ --stencilDistributionMethod $stencilDistributionMethod \ --cacheDensityProfileCoefficients $cacheDensityProfileCoefficients \ --cacheDomainGeometry $cacheDomainGeometry \ diff --git a/src/ConfigParser/config_parser.cpp b/src/ConfigParser/config_parser.cpp index 32478ad02..61f0e91e5 100644 --- a/src/ConfigParser/config_parser.cpp +++ b/src/ConfigParser/config_parser.cpp @@ -71,8 +71,19 @@ bool ConfigParser::parse(int argc, char* argv[]) { if (argc != 0) { + // Filter out Kokkos arguments before cmdline parser sees them + std::vector filtered_argv; + for (int i = 0; i < argc; ++i) { + std::string arg(argv[i]); + if (arg.rfind("--kokkos-", 0) == 0 || arg.rfind("--kokkos_", 0) == 0) { + continue; + } + filtered_argv.push_back(argv[i]); + } + int filtered_argc = static_cast(filtered_argv.size()); + try { - parser_.parse_check(argc, argv); + parser_.parse_check(filtered_argc, filtered_argv.data()); } catch (const cmdline::cmdline_error& parse_error) { std::cerr << "Error: " << parse_error.what() << std::endl;