Add checkpoint/resume for LinearSolverOptions default values

src/utils/checkpointing/Checkpoint.cpp

@@ -20,6 +20,7 @@
 
 #ifdef PUGS_HAS_HDF5
 
+#include <algebra/LinearSolverOptions.hpp>
 #include <language/utils/ASTNodeDataTypeTraits.hpp>
 #include <language/utils/CheckpointResumeRepository.hpp>
 #include <language/utils/DataHandler.hpp>
@@ -27,6 +28,8 @@
 #include <utils/GlobalVariableManager.hpp>
 #include <utils/RandomEngine.hpp>
 
+#include <utils/checkpointing/LinearSolverOptionsHFType.hpp>
+
 void
 checkpoint()
 {
@@ -80,6 +83,20 @@ checkpoint()
       execution_info_group.createAttribute("cumulative_total_cpu_time",
                                            ExecutionStatManager::getInstance().getCumulativeTotalCPUTime());
     }
+    {
+      HighFive::Group linear_solver_options_default_group =
+        checkpoint.createGroup("singleton/linear_solver_options_default");
+
+      const LinearSolverOptions& default_options = LinearSolverOptions::default_options;
+
+      linear_solver_options_default_group.createAttribute("epsilon", default_options.epsilon());
+      linear_solver_options_default_group.createAttribute("maximum_iteration", default_options.maximumIteration());
+      linear_solver_options_default_group.createAttribute("verbose", default_options.verbose());
+
+      linear_solver_options_default_group.createAttribute("library", default_options.library());
+      linear_solver_options_default_group.createAttribute("method", default_options.method());
+      linear_solver_options_default_group.createAttribute("precond", default_options.precond());
+    }
     {
       std::cout << rang::fgB::magenta << "Checkpoint DualConnectivityManager NIY" << rang::fg::reset << '\n';
       std::cout << rang::fgB::magenta << "Checkpoint DualMeshManager NIY" << rang::fg::reset << '\n';

src/utils/checkpointing/LinearSolverOptionsHFType.hpp

+#ifndef LINEAR_SOLVER_OPTIONS_H_F_TYPE_HPP
+#define LINEAR_SOLVER_OPTIONS_H_F_TYPE_HPP
+
+#include <algebra/LinearSolverOptions.hpp>
+#include <utils/checkpointing/CheckpointUtils.hpp>
+
+HighFive::EnumType<LSLibrary> PUGS_INLINE
+create_enum_LSOptions_library_type()
+{
+  return {{"builtin", LSLibrary::builtin}, {"petsc", LSLibrary::petsc}};
+}
+HIGHFIVE_REGISTER_TYPE(LSLibrary, create_enum_LSOptions_library_type)
+
+HighFive::EnumType<LSMethod> PUGS_INLINE
+create_enum_LSOptions_method_type()
+{
+  return {{"cg", LSMethod::cg},
+          {"bicgstab", LSMethod::bicgstab},
+          {"bicgstab2", LSMethod::bicgstab2},
+          {"gmres", LSMethod::gmres},
+          {"lu", LSMethod::lu},
+          {"cholesky", LSMethod::cholesky}};
+}
+HIGHFIVE_REGISTER_TYPE(LSMethod, create_enum_LSOptions_method_type)
+
+HighFive::EnumType<LSPrecond> PUGS_INLINE
+create_enum_LSOptions_precond_type()
+{
+  return {{"none", LSPrecond::none},
+          {"diagonal", LSPrecond::diagonal},
+          {"incomplete_cholesky", LSPrecond::incomplete_cholesky},
+          {"incomplete_LU", LSPrecond::incomplete_LU},
+          {"amg", LSPrecond::amg}};
+}
+HIGHFIVE_REGISTER_TYPE(LSPrecond, create_enum_LSOptions_precond_type)
+
+#endif   // LINEAR_SOLVER_OPTIONS_H_F_TYPE_HPP

src/utils/checkpointing/Resume.cpp

@@ -17,6 +17,7 @@
 
 #ifdef PUGS_HAS_HDF5
 
+#include <algebra/LinearSolverOptions.hpp>
 #include <mesh/Connectivity.hpp>
 #include <utils/ExecutionStatManager.hpp>
 #include <utils/RandomEngine.hpp>
@@ -24,6 +25,8 @@
 #include <utils/checkpointing/ResumingData.hpp>
 #include <utils/checkpointing/ResumingManager.hpp>
 
+#include <utils/checkpointing/LinearSolverOptionsHFType.hpp>
+
 #include <language/utils/CheckpointResumeRepository.hpp>
 
 #include <map>
@@ -66,6 +69,21 @@ resume()
       ExecutionStatManager::getInstance().setPreviousCumulativeElapseTime(cumulative_elapse_time);
       ExecutionStatManager::getInstance().setPreviousCumulativeTotalCPUTime(cumulative_total_cpu_time);
     }
+    {
+      HighFive::Group linear_solver_options_default_group =
+        checkpoint.getGroup("singleton/linear_solver_options_default");
+
+      LinearSolverOptions& default_options = LinearSolverOptions::default_options;
+
+      default_options.epsilon() = linear_solver_options_default_group.getAttribute("epsilon").read<double>();
+      default_options.maximumIteration() =
+        linear_solver_options_default_group.getAttribute("maximum_iteration").read<size_t>();
+      default_options.verbose() = linear_solver_options_default_group.getAttribute("verbose").read<bool>();
+
+      default_options.library() = linear_solver_options_default_group.getAttribute("library").read<LSLibrary>();
+      default_options.method()  = linear_solver_options_default_group.getAttribute("method").read<LSMethod>();
+      default_options.precond() = linear_solver_options_default_group.getAttribute("precond").read<LSPrecond>();
+    }
     {
       std::cout << rang::fgB::magenta << "Resume DualConnectivityManager NIY" << rang::fg::reset << '\n';
       std::cout << rang::fgB::magenta << "Resume DualMeshManager NIY" << rang::fg::reset << '\n';