(Fully)-Compiled Inputs

src/outputs/output_parameters.hpp

@@ -40,6 +40,7 @@ struct OutputParameters {
 
   int block_number = 0;
   std::string block_name;
+  std::string state_key;
   std::string file_basename;
   int file_number_width;
   bool file_label_final;

src/outputs/outputs.cpp

@@ -84,6 +84,21 @@
 
 namespace parthenon {
 
+namespace {
+int IsLegacyOutputBlock(const std::string &block_name) {
+  constexpr const char *prefix = "parthenon/output";
+  if (block_name.rfind(prefix, 0) != 0) return false;
+  const std::string suffix = block_name.substr(std::char_traits<char>::length(prefix));
+  const bool is_legacy =  !suffix.empty() &&
+         std::all_of(suffix.begin(), suffix.end(),
+                     [](unsigned char c) { return std::isdigit(c) != 0; });
+  if (is_legacy) {
+    return  std::atoi(suffix.c_str());
+  } 
+  return -1;
+}
+} // namespace
+
 //----------------------------------------------------------------------------------------
 // OutputType constructor
 
@@ -111,14 +126,21 @@ Outputs::Outputs(Mesh *pm, ParameterInput *pin, SimTime *tm) {
   // `pinput` again here as we're actually processing (potentially even modifying)
   // `pinput`.
   auto output_blocks = pin->GetBlockNamesWithPrefix("parthenon/output");
+  int named_output_ordinal = 0;
   for (const auto &block_name : output_blocks) {
     std::shared_ptr<OutputType> pnew_type; // the new output we will create
     bool restart = false;                  // we track restart outputs separately so we
                                            // need this temp variable to check
     OutputParameters op;                   // define temporary OutputParameters struct
     op.block_name = block_name;
-    const auto outn_str = block_name.substr(16); // 16 because counting starts at 0!
-    op.block_number = atoi(outn_str.c_str());
+    const auto slash = block_name.find_last_of('/');
+    const auto outn_str =
+        (slash == std::string::npos) ? block_name : block_name.substr(slash + 1);
+    op.state_key = outn_str;
+    const int legacy_number = IsLegacyOutputBlock(block_name);
+    const bool legacy_output = (legacy_number >= 0);
+    op.block_number =
+        legacy_output ? legacy_number : named_output_ordinal++;
     auto *pfile_number = pkg->MutableParam<int>(outn_str + "/file_number");
     auto *plast_time = pkg->MutableParam<Real>(outn_str + "/last_time");
     auto *plast_n = pkg->MutableParam<int>(outn_str + "/last_n");
@@ -215,10 +237,9 @@ Outputs::Outputs(Mesh *pm, ParameterInput *pin, SimTime *tm) {
     op.include_in_final =
         pin->GetOrAddBoolean(op.block_name, "include_in_final", true,
                              "include output when triggered on final signal");
-    char define_id[10];
-    std::snprintf(define_id, sizeof(define_id), "out%d",
-                  op.block_number); // default id="outN"
-    op.file_id = pin->GetOrAddString(op.block_name, "id", define_id);
+    const std::string default_id =
+        legacy_output ? "out" + std::to_string(op.block_number) : op.state_key;
+    op.file_id = pin->GetOrAddString(op.block_name, "id", default_id);
     op.file_type = pin->GetString(op.block_name, "file_type", "output type");
 
     // read ghost cell option
@@ -547,10 +568,9 @@ void Outputs::MakeOutputs(Mesh *pm, ParameterInput *pin, SimTime *tm,
 void OutputType::UpdateNextOutput_(Mesh *pm, SimTime *tm) {
   output_params.file_number++;
   auto pkg = pm->packages.Get("Outputs");
-  const auto outn_str = std::to_string(output_params.block_number);
-  auto *pfile_number = pkg->MutableParam<int>(outn_str + "/file_number");
-  auto *plast_time = pkg->MutableParam<Real>(outn_str + "/last_time");
-  auto *plast_n = pkg->MutableParam<int>(outn_str + "/last_n");
+  auto *pfile_number = pkg->MutableParam<int>(output_params.state_key + "/file_number");
+  auto *plast_time = pkg->MutableParam<Real>(output_params.state_key + "/last_time");
+  auto *plast_n = pkg->MutableParam<int>(output_params.state_key + "/last_n");
   *pfile_number = output_params.file_number;
   if (tm != nullptr) {
     // JMM: Do NOT use the current time to update these, as that can

src/outputs/outputs_package.cpp

@@ -42,7 +42,9 @@ std::shared_ptr<StateDescriptor> Initialize(ParameterInput *pin) {
   // from restart files or are cleanly initialized).
   auto output_blocks = pin->GetBlockNamesWithPrefix("parthenon/output");
   for (const auto &block_name : output_blocks) {
-    std::string outn = block_name.substr(16); // 16 because counting starts at 0!
+    const auto slash = block_name.find_last_of('/');
+    const std::string outn =
+        (slash == std::string::npos) ? block_name : block_name.substr(slash + 1);
 
     // These will be updated later or restarted from
     int file_number = 0;

src/outputs/parthenon_hdf5.cpp

@@ -45,6 +45,7 @@
 #include "outputs/parthenon_xdmf.hpp"
 #include "outputs/restart.hpp"
 #include "pack/default_names.hpp"
+#include "parameter_parsers/rummy_parser.hpp"
 #include "provenance.hpp"
 #include "utils/string_utils.hpp"
 
@@ -137,14 +138,19 @@ void PHDF5Output::WriteOutputFileImpl(Mesh *pm, ParameterInput *pin, SimTime *tm
   Kokkos::Profiling::pushRegion("write Attributes");
   {
     Kokkos::Profiling::pushRegion("write input");
-    // write input key-value pairs
-    std::ostringstream oss;
-    pin->ParameterDump(oss);
-
-    // Mesh information
     const H5G input_group = MakeGroup(file, "/Input");
-
-    HDF5WriteAttribute("File", oss.str().c_str(), input_group);
+    if (const auto *deck = pin->GetRummyDeck(); deck != nullptr) {
+      const auto state = MakeRummyRestartState(*pin, *deck);
+      HDF5WriteAttribute("File", state.source, input_group);
+      HDF5WriteAttribute("InputParser", "rummy", input_group);
+      HDF5WriteAttribute("RummyMode", state.mode, input_group);
+      HDF5WriteAttribute("RummyStateVersion", state.version, input_group);
+      HDF5WriteAttribute("RummyState", state.source, input_group);
+    } else {
+      std::ostringstream oss;
+      pin->ParameterDump(oss);
+      HDF5WriteAttribute("File", oss.str(), input_group);
+    }
     Kokkos::Profiling::popRegion(); // write input
   } // Input section
 

src/outputs/parthenon_opmd.cpp

@@ -56,6 +56,7 @@
 #include "outputs/outputs.hpp"
 #include "outputs/parthenon_opmd.hpp"
 #include "pack/default_names.hpp"
+#include "parameter_parsers/rummy_parser.hpp"
 #include "parthenon_array_generic.hpp"
 #include "provenance.hpp"
 #include "utils/error_checking.hpp"
@@ -507,10 +508,18 @@ void OpenPMDOutput::WriteOutputFileImpl(Mesh *pm, ParameterInput *pin, SimTime *
   // Then our own
   if (!is_slice) {
     PARTHENON_INSTRUMENT_REGION("write input");
-    // write input key-value pairs
-    std::ostringstream oss;
-    pin->ParameterDump(oss);
-    it.setAttribute("InputFile", oss.str());
+    if (const auto *deck = pin->GetRummyDeck(); deck != nullptr) {
+      const auto state = MakeRummyRestartState(*pin, *deck);
+      it.setAttribute("InputFile", state.source);
+      it.setAttribute("InputParser", std::string("rummy"));
+      it.setAttribute("RummyMode", state.mode);
+      it.setAttribute("RummyStateVersion", state.version);
+      it.setAttribute("RummyState", state.source);
+    } else {
+      std::ostringstream oss;
+      pin->ParameterDump(oss);
+      it.setAttribute("InputFile", oss.str());
+    }
   }
 
   if (!is_slice) {

src/outputs/restart.hpp

@@ -98,6 +98,14 @@ class RestartReader {
 
   [[nodiscard]] virtual std::string GetInputString() const = 0;
 
+  struct RummyInputState {
+    bool present = false;
+    int version = 0;
+    std::string mode;
+    std::string source;
+  };
+  [[nodiscard]] virtual RummyInputState GetRummyInputState() const = 0;
+
   // Return output format version number. Return -1 if not existent.
   [[nodiscard]] virtual int GetOutputFormatVersion() const = 0;
 

src/outputs/restart_hdf5.cpp

@@ -84,6 +84,23 @@ int RestartReaderHDF5::GetOutputFormatVersion() const {
 #endif // ENABLE_HDF5
 }
 
+RestartReader::RummyInputState RestartReaderHDF5::GetRummyInputState() const {
+#ifndef ENABLE_HDF5
+  PARTHENON_FAIL("Restart functionality is not available because HDF5 is disabled");
+#else
+  RummyInputState state;
+  const H5O input = H5O::FromHIDCheck(H5Oopen(fh_, "Input", H5P_DEFAULT));
+  auto status = PARTHENON_HDF5_CHECK(H5Aexists(input, "InputParser"));
+  if (status <= 0 || GetAttr<std::string>("Input", "InputParser") != "rummy")
+    return state;
+  state.present = true;
+  state.version = GetAttr<int>("Input", "RummyStateVersion");
+  state.mode = GetAttr<std::string>("Input", "RummyMode");
+  state.source = GetAttr<std::string>("Input", "RummyState");
+  return state;
+#endif
+}
+
 RestartReaderHDF5::SparseInfo RestartReaderHDF5::GetSparseInfo() const {
 #ifndef ENABLE_HDF5
   PARTHENON_FAIL("Restart functionality is not available because HDF5 is disabled");

src/outputs/restart_hdf5.hpp

@@ -55,6 +55,7 @@ class RestartReaderHDF5 : public RestartReader {
   [[nodiscard]] std::string GetInputString() const override {
     return GetAttr<std::string>("Input", "File");
   };
+  [[nodiscard]] RummyInputState GetRummyInputState() const override;
 
   // Return output format version number. Return -1 if not existent.
   [[nodiscard]] int GetOutputFormatVersion() const override;

src/outputs/restart_opmd.hpp

@@ -41,6 +41,17 @@ class RestartReaderOPMD : public RestartReader {
   [[nodiscard]] std::string GetInputString() const override {
     return it->getAttribute("InputFile").get<std::string>();
   };
+  [[nodiscard]] RummyInputState GetRummyInputState() const override {
+    RummyInputState state;
+    if (!it->containsAttribute("InputParser") ||
+        it->getAttribute("InputParser").get<std::string>() != "rummy")
+      return state;
+    state.present = true;
+    state.version = it->getAttribute("RummyStateVersion").get<int>();
+    state.mode = it->getAttribute("RummyMode").get<std::string>();
+    state.source = it->getAttribute("RummyState").get<std::string>();
+    return state;
+  }
 
   // Return output format version number. Return -1 if not existent.
   [[nodiscard]] int GetOutputFormatVersion() const override;