Integrate Refactor solver sources and dual MSVC CMake builds

2026-10-18 02:10:51 +09:00
parent 7ee32e5837
commit 12d51480de
218 changed files with 17842 additions and 9689 deletions
@@ -0,0 +1,83 @@
+#include "fesa/results/prepared_results_writer.h"
+
+#include "fesa/results/dynamic_results_writer.h"
+#include "fesa/results/eigen_results_writer.h"
+#include "fesa/results/nonlinear_results_writer.h"
+#include "fesa/results/results_writer.h"
+#include "fesa/results/solid_results_writer.h"
+#include "fesa/results/thermal_results_writer.h"
+
+namespace fesa {
+
+Status WritePreparedAnalysisResult(
+    const std::filesystem::path& results_path, const Domain& domain,
+    const PreparedAnalysisOutcome& outcome,
+    const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
+    NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
+    DynamicResultsWriter* dynamic_writer, ThermalResultsWriter* thermal_writer,
+    SolidResultsWriter* solid_writer) {
+  if (std::holds_alternative<SolidStaticExecutionResult>(outcome) ||
+      std::holds_alternative<SolidFrequencyState>(outcome) ||
+      std::holds_alternative<SolidDynamicExecutionResult>(outcome)) {
+    if (solid_writer == nullptr)
+      return Status::Failure(FailureCategory::kOutput,
+                             {{Severity::kError,
+                               "missing-solid-writer",
+                               {},
+                               "",
+                               {},
+                               "Solid result writer is required."}});
+    if (const auto* result = std::get_if<SolidStaticExecutionResult>(&outcome))
+      return solid_writer->Write(results_path, domain, result->state,
+                                 diagnostics);
+    if (const auto* result = std::get_if<SolidFrequencyState>(&outcome))
+      return solid_writer->Write(results_path, domain, *result,
+                                 diagnostics);
+    return solid_writer->Write(
+        results_path, domain,
+        std::get<SolidDynamicExecutionResult>(outcome).state, diagnostics);
+  }
+  if (std::holds_alternative<ThermalExecutionResult>(outcome)) {
+    if (thermal_writer == nullptr) {
+      return Status::Failure(FailureCategory::kOutput,
+                             {{Severity::kError,
+                               "missing-thermal-writer",
+                               {},
+                               "HEAT TRANSFER",
+                               {},
+                               "Thermal result writer is required."}});
+    }
+    return thermal_writer->Write(
+        results_path, domain,
+        std::get<ThermalExecutionResult>(outcome).state, diagnostics);
+  }
+  if (std::holds_alternative<DynamicExecutionResult>(outcome)) {
+    if (dynamic_writer == nullptr)
+      return Status::Failure(FailureCategory::kOutput,
+                             {{Severity::kError,
+                               "missing-dynamic-writer",
+                               {},
+                               "DYNAMIC",
+                               {},
+                               "Dynamic result writer is required."}});
+    return dynamic_writer->Write(
+        results_path, domain,
+        std::get<DynamicExecutionResult>(outcome).state, diagnostics);
+  }
+  if (std::holds_alternative<EigenAnalysisState>(outcome)) {
+    return eigen_writer.Write(results_path, domain,
+                              std::get<EigenAnalysisState>(outcome),
+                              diagnostics);
+  }
+  if (std::holds_alternative<LinearStaticExecutionResult>(outcome)) {
+    return linear_writer.Write(
+        results_path, domain,
+        std::get<LinearStaticExecutionResult>(outcome).state, diagnostics);
+  }
+
+  return nonlinear_writer.Write(
+      results_path, domain,
+      std::get<NonlinearStaticExecutionResult>(outcome).state, diagnostics);
+}
+
+}  // namespace fesa