feat(nonlinear-static-newton-raphson): step 0 - cli-output-lease-and-derived-names

tests/reference/b33_reference_comparison_test.cpp

@@ -153,7 +153,8 @@ TEST(B33ReferenceComparison, GeneratesAuthoritativeHdf5AndComparisonEvidence) {
   const auto input = reference_directory / "cantilever beam.inp";
   const auto output_directory =
       binary_root / "reference" / "cantilever-beam-b33";
-  const auto results = output_directory / "results.h5";
+  const auto execution_input = output_directory / input.filename();
+  const auto results = output_directory / "cantilever beam_results.h5";
   const auto comparison = output_directory / "comparison.json";
 
   // Only the exact build-local evidence directory is reset; the approved
@@ -173,16 +174,18 @@ TEST(B33ReferenceComparison, GeneratesAuthoritativeHdf5AndComparisonEvidence) {
             std::filesystem::path{"cantilever beam reactions.csv"});
   EXPECT_EQ(reference_before[3U].relative_path,
             std::filesystem::path{"cantilever beam.inp"});
+  ASSERT_TRUE(std::filesystem::copy_file(input, execution_input, error));
+  ASSERT_FALSE(error);
 
   fesa::FesaApplication application;
-  // FesaApplication receives application operands/options; main strips argv[0].
-  ASSERT_EQ(application.Run({input.string(), "--output", results.string()}), 0);
+  ASSERT_EQ(application.Run({execution_input.string()}), 0);
   ASSERT_TRUE(std::filesystem::is_regular_file(results));
   ASSERT_GT(H5Fis_hdf5(results.string().c_str()), 0);
   EXPECT_GT(StressRowCount(results), 0U);
 
   auto comparison_result =
-      fesa::test::ReferenceComparison::Compare(results, reference_directory);
+      fesa::test::ReferenceComparison::Compare(results, reference_directory,
+                                                execution_input);
   ASSERT_TRUE(comparison_result.HasValue());
   const auto& report = comparison_result.Value();
   ASSERT_TRUE(report.passed);
@@ -248,7 +251,9 @@ TEST(B33ReferenceComparison, GeneratesAuthoritativeHdf5AndComparisonEvidence) {
   }
   std::sort(generated_names.begin(), generated_names.end());
   EXPECT_EQ(generated_names,
-            (std::vector<std::string>{"comparison.json", "results.h5"}));
+            (std::vector<std::string>{"cantilever beam.inp",
+                                      "cantilever beam_results.h5",
+                                      "comparison.json"}));
 
   ExpectTreeUnchanged(reference_before, SnapshotTree(reference_directory));
 }

tests/reference/mitc4_reference_cases_test.cpp

@@ -75,14 +75,19 @@ CaseEvidence RunCase(const std::string& case_id,
   if (!std::filesystem::create_directories(output_directory, error) || error) {
     throw std::runtime_error{"Unable to create MITC4 evidence directory."};
   }
-  const auto results = output_directory / "results.h5";
+  const auto execution_input = output_directory / input.filename();
+  if (!std::filesystem::copy_file(input, execution_input, error) || error) {
+    throw std::runtime_error{"Unable to copy MITC4 input for execution."};
+  }
+  const auto results = output_directory /
+                       (execution_input.stem().string() + "_results.h5");
   const auto comparison = output_directory / "comparison.json";
 
   fesa::FesaApplication application;
-  EXPECT_EQ(application.Run({input.string(), "--output", results.string()}), 0);
+  EXPECT_EQ(application.Run({execution_input.string()}), 0);
   EXPECT_TRUE(std::filesystem::is_regular_file(results));
   auto comparison_result = fesa::test::Mitc4ReferenceComparison::Compare(
-      {case_id, source_element_type, input, csv, results});
+      {case_id, source_element_type, execution_input, csv, results});
   if (!comparison_result.HasValue()) {
     std::string diagnostics;
     for (const auto& diagnostic : comparison_result.GetStatus().Diagnostics()) {
@@ -104,7 +109,9 @@ CaseEvidence RunCase(const std::string& case_id,
   }
   std::sort(generated.begin(), generated.end());
   EXPECT_EQ(generated,
-            (std::vector<std::string>{"comparison.json", "results.h5"}));
+            (std::vector<std::string>{"comparison.json",
+                                      input.filename().string(),
+                                      results.filename().string()}));
   EXPECT_TRUE(std::filesystem::is_directory(reference_directory));
   ExpectUnchanged(input, input_before);
   ExpectUnchanged(csv, csv_before);

tests/reference/reference_comparison.cpp

@@ -1345,10 +1345,18 @@ bool FiniteReport(const ComparisonReport& report) {
 Result<ComparisonReport> ReferenceComparison::Compare(
     const std::filesystem::path& results_hdf5,
     const std::filesystem::path& legacy_reference_directory) {
+  return Compare(results_hdf5, legacy_reference_directory,
+                 legacy_reference_directory / kInputName);
+}
+
+Result<ComparisonReport> ReferenceComparison::Compare(
+    const std::filesystem::path& results_hdf5,
+    const std::filesystem::path& legacy_reference_directory,
+    const std::filesystem::path& execution_input_path) {
   try {
     RequireExactArtifactInventory(legacy_reference_directory);
-    const auto input = legacy_reference_directory / kInputName;
-    Domain domain = ReadApprovedDomain(input);
+    const auto reference_input = legacy_reference_directory / kInputName;
+    Domain domain = ReadApprovedDomain(reference_input);
     const ReferenceTable displacement =
         ReadReferenceCsv(legacy_reference_directory / kDisplacementName,
                          {"Frame", "Part Instance Name", "Node Label", "U-U1",
@@ -1359,7 +1367,8 @@ Result<ComparisonReport> ReferenceComparison::Compare(
                           "RF-RF2", "RF-RF3", "RM-RM1", "RM-RM2", "RM-RM3"});
     const SectionReferenceTable section =
         ReadSectionReferenceCsv(legacy_reference_directory / kSectionName);
-    HdfProjection hdf = ReadHdfProjection(results_hdf5, input, domain);
+    HdfProjection hdf =
+        ReadHdfProjection(results_hdf5, execution_input_path, domain);
     const auto displacement_rows = OrderedRows(displacement, hdf.nodes);
     const auto reaction_rows = OrderedRows(reaction, hdf.nodes);
     const auto section_rows = OrderedSectionRows(section, hdf);

tests/reference/reference_comparison.h

@@ -84,6 +84,15 @@ class ReferenceComparison {
   static Result<ComparisonReport> Compare(
       const std::filesystem::path& results_hdf5,
       const std::filesystem::path& legacy_reference_directory);
+
+  /// @brief Compares results using a separately copied execution input path.
+  /// @param execution_input_path Input path recorded by the solver in HDF5.
+  /// @note Reference inputs and CSV files remain in legacy_reference_directory.
+  static Result<ComparisonReport> Compare(
+      const std::filesystem::path& results_hdf5,
+      const std::filesystem::path& legacy_reference_directory,
+      const std::filesystem::path& execution_input_path);
+
   static Status WriteDeterministicJson(
       const ComparisonReport& report, const std::filesystem::path& output_json);
 };