WIP: TOML Parameters

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "external/kokkos"]
 	path = external/Kokkos
 	url = https://github.com/kokkos/kokkos.git
+[submodule "external/tomlplusplus"]
+	path = external/tomlplusplus
+	url = https://github.com/marzer/tomlplusplus.git

CMakeLists.txt

@@ -263,6 +263,7 @@ if (NOT TARGET Kokkos::kokkos)
     endif()
   endif()
 endif()
+include_directories("external/tomlplusplus")
 
 # After we have imported Kokkos we can now report/check our config as Kokkos_ENABLE_XXX
 # is also availalbe when imported.
@@ -384,6 +385,7 @@ if (PARTHENON_ENABLE_UNIT_TESTS OR PARTHENON_ENABLE_INTEGRATION_TESTS OR PARTHEN
   add_subdirectory(tst)
 endif()
 
+
 if (PARTHENON_ENABLE_ASCENT)
   if (PARTHENON_USE_SYSTEM_PACKAGES)
     find_package(Ascent REQUIRED)

src/driver/driver.cpp

@@ -149,7 +149,7 @@ DriverStatus EvolutionDriver::Execute() {
       }
     } // END OF MAIN INTEGRATION LOOP
       // ======================================================
-  }   // Main t < tmax loop region
+  } // Main t < tmax loop region
 
   if (pmesh->UserWorkAfterLoop != nullptr) {
     pmesh->UserWorkAfterLoop(pmesh, pinput, tm);
@@ -270,12 +270,13 @@ void EvolutionDriver::SetGlobalTimeStep() {
 }
 
 void EvolutionDriver::DumpInputParameters() {
-  auto archive_settings =
-      pinput->GetOrAddString("parthenon/job", "archive_parameters", "false",
-                             std::vector<std::string>{"true", "false", "timestamp"});
-  if (archive_settings != "false" && Globals::my_rank == 0) {
+  auto archive_parameters =
+      pinput->GetOrAddBoolean("parthenon/job", "archive_parameters", false);
+  auto archive_timestamp =
+      pinput->GetOrAddBoolean("parthenon/job", "archive_timestamp", false);
+  if (archive_parameters && Globals::my_rank == 0) {
     std::ostringstream ss;
-    if (archive_settings == "timestamp") {
+    if (archive_timestamp) {
       auto itt_now =
           std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
       ss << "parthinput.archive." << std::put_time(std::gmtime(&itt_now), "%FT%TZ");

src/mesh/mesh.cpp

@@ -68,16 +68,12 @@ Mesh::Mesh(ParameterInput *pin, ApplicationInput *app_in, Packages_t &packages,
       adaptive(pin->GetOrAddString("parthenon/mesh", "refinement", "none") == "adaptive"
                    ? true
                    : false),
-      multilevel(
-          (adaptive ||
-           pin->GetOrAddString("parthenon/mesh", "refinement", "none") == "static" ||
-           pin->GetOrAddString("parthenon/mesh", "multigrid", "false") == "true")
-              ? true
-              : false),
-      multigrid(pin->GetOrAddString("parthenon/mesh", "multigrid", "false") == "true"
-                    ? true
-                    : false),
-      nbnew(), nbdel(), step_since_lb(), gflag(), packages(packages),
+      multilevel(adaptive ||
+                 pin->GetOrAddString("parthenon/mesh", "refinement", "none") ==
+                     "static" ||
+                 pin->GetOrAddBoolean("parthenon/mesh", "multigrid", false)),
+      multigrid(pin->GetOrAddBoolean("parthenon/mesh", "multigrid", false)), nbnew(),
+      nbdel(), step_since_lb(), gflag(), packages(packages),
       resolved_packages(ResolvePackages(packages)),
       default_pack_size_(pin->GetOrAddInteger("parthenon/mesh", "pack_size", -1)),
       // private members:
@@ -739,10 +735,6 @@ void Mesh::FillDerived() {
   }
 }
 
-//----------------------------------------------------------------------------------------
-// \!fn void Mesh::Initialize(bool init_problem, ParameterInput *pin)
-// \brief  initialization before the main loop
-
 void Mesh::Initialize(bool init_problem, ParameterInput *pin, ApplicationInput *app_in) {
   PARTHENON_INSTRUMENT
   bool init_done = true;
@@ -1095,27 +1087,28 @@ void Mesh::DoStaticRefinement(ParameterInput *pin) {
     return std::pair<int, int>{lxmin, lxmax};
   };
 
-  InputBlock *pib = pin->pfirst_block;
-  while (pib != nullptr) {
-    if (pib->block_name.compare(0, 27, "parthenon/static_refinement") == 0) {
+  for (auto pib : pin->Blocks("parthenon")) {
+    std::string block_name = std::string(pib.first);
+    if (block_name.compare(0, 17, "static_refinement") == 0) {
       RegionSize ref_size;
-      ref_size.xmin(X1DIR) = pin->GetReal(pib->block_name, "x1min");
-      ref_size.xmax(X1DIR) = pin->GetReal(pib->block_name, "x1max");
+      std::string block_path = "parthenon." + block_name;
+      ref_size.xmin(X1DIR) = pin->GetReal(block_path, "x1min");
+      ref_size.xmax(X1DIR) = pin->GetReal(block_path, "x1max");
       if (ndim >= 2) {
-        ref_size.xmin(X2DIR) = pin->GetReal(pib->block_name, "x2min");
-        ref_size.xmax(X2DIR) = pin->GetReal(pib->block_name, "x2max");
+        ref_size.xmin(X2DIR) = pin->GetReal(block_path, "x2min");
+        ref_size.xmax(X2DIR) = pin->GetReal(block_path, "x2max");
       } else {
         ref_size.xmin(X2DIR) = mesh_size.xmin(X2DIR);
         ref_size.xmax(X2DIR) = mesh_size.xmax(X2DIR);
       }
       if (ndim == 3) {
-        ref_size.xmin(X3DIR) = pin->GetReal(pib->block_name, "x3min");
-        ref_size.xmax(X3DIR) = pin->GetReal(pib->block_name, "x3max");
+        ref_size.xmin(X3DIR) = pin->GetReal(block_path, "x3min");
+        ref_size.xmax(X3DIR) = pin->GetReal(block_path, "x3max");
       } else {
         ref_size.xmin(X3DIR) = mesh_size.xmin(X3DIR);
         ref_size.xmax(X3DIR) = mesh_size.xmax(X3DIR);
       }
-      int ref_lev = pin->GetInteger(pib->block_name, "level");
+      int ref_lev = pin->GetInteger(block_path, "level");
       int lrlev = ref_lev + GetLegacyTreeRootLevel();
       // range check
       if (ref_lev < 1) {
@@ -1167,7 +1160,6 @@ void Mesh::DoStaticRefinement(ParameterInput *pin) {
         }
       }
     }
-    pib = pib->pnext;
   }
 }
 // Return list of locations and levels for the legacy tree

src/outputs/outputs_package.cpp

@@ -45,12 +45,12 @@ std::shared_ptr<StateDescriptor> Initialize(ParameterInput *pin) {
   std::vector<Real> last_times;
   std::vector<int> last_ns;
 
-  // loop over input block names.  Find those that start with "parthenon/output", read
+  // loop over input block names.  Find those in the parthenon.output blocks, read
   // parameters, and construct singly linked list of OutputTypes.
-  for (InputBlock *pib = pin->pfirst_block; pib != nullptr; pib = pib->pnext) {
-    if (pib->block_name.compare(0, 16, "parthenon/output") == 0) {
-      std::string outn = pib->block_name.substr(16); // 6 because counting starts at 0!
-      std::string block_name = pib->block_name;
+  for (auto pib : pin->Blocks("parthenon")) {
+    std::string block_name = std::string(pib.first);
+    if (block_name.compare(0, 6, "output") == 0) {
+      std::string outn = block_name.substr(6); // 6 because counting starts at 0!
 
       if (pin->DoesParameterExist(block_name, "next_time")) {
         std::stringstream msg;
@@ -68,7 +68,7 @@ std::shared_ptr<StateDescriptor> Initialize(ParameterInput *pin) {
       }
 
       // these are used for book-keeping
-      block_names.push_back(block_name);
+      block_names.push_back("parthenon." + block_name);
       block_numbers.push_back(atoi(outn.c_str()));
 
       // These will be updated later or restarted from