feat(hex8): connect Solid CLI and atomic HDF5 output

src/fesa/analysis/prepared_analysis.cpp

@@ -2,11 +2,13 @@
 
 #include <utility>
 
+#include "fesa/analysis/analysis_model.h"
 #include "fesa/analysis/hht_dynamic_procedure.h"
 #include "fesa/analysis/linear_frequency_procedure.h"
 #include "fesa/analysis/linear_static_procedure.h"
 #include "fesa/analysis/newton_iteration_log.h"
 #include "fesa/analysis/nonlinear_static_procedure.h"
+#include "fesa/analysis/solid_frequency_procedure.h"
 #include "fesa/app/output_paths.h"
 #include "fesa/io/abaqus/domain_mapper.h"
 #include "fesa/io/abaqus/input_reader.h"
@@ -14,6 +16,7 @@
 #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 {
@@ -42,7 +45,10 @@ Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
     const LinearFrequencyProcedureExecutor& frequency_executor,
     NewtonIterationLogWriter& log,
     const HhtDynamicProcedureExecutor* dynamic_executor,
-    const TransientHeatProcedureExecutor* thermal_executor) {
+    const TransientHeatProcedureExecutor* thermal_executor,
+    const SolidStaticProcedureExecutor* solid_static_executor,
+    const SolidFrequencyProcedureExecutor* solid_frequency_executor,
+    const SolidHhtDynamicProcedureExecutor* solid_dynamic_executor) {
   if (domain.ThermalStep() != nullptr) {
     if (thermal_executor == nullptr) {
       return Result<PreparedAnalysisOutcome>::Failure(
@@ -72,6 +78,63 @@ Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
           "Prepared analysis requires exactly one analysis step."}}));
   }
 
+  if (domain.IsSolid()) {
+    const auto missing = []() {
+      return Result<PreparedAnalysisOutcome>::Failure(Status::Failure(
+          FailureCategory::kSolver,
+          {{Severity::kError,
+            "missing-solid-executor",
+            {},
+            "",
+            {},
+            "The selected Solid execution adapter is required."}}));
+    };
+    if (domain.Dynamic() != nullptr) {
+      if (solid_dynamic_executor == nullptr) return missing();
+      auto model = AnalysisModel::Create(domain);
+      if (!model.HasValue())
+        return Result<PreparedAnalysisOutcome>::Failure(model.GetStatus());
+      auto dofs = DofManager::Create(model.Value());
+      if (!dofs.HasValue())
+        return Result<PreparedAnalysisOutcome>::Failure(dofs.GetStatus());
+      auto state = SolidDynamicAnalysisState::Create(domain, dofs.Value());
+      if (!state.HasValue())
+        return Result<PreparedAnalysisOutcome>::Failure(state.GetStatus());
+      const Status execution =
+          solid_dynamic_executor->ExecuteInto(domain, state.Value());
+      for (const auto& record : state.Value().IterationRecords()) {
+        const Status written = log.Write(record);
+        if (!written.IsOk())
+          return Result<PreparedAnalysisOutcome>::Failure(written);
+      }
+      if (!execution.IsOk())
+        return Result<PreparedAnalysisOutcome>::Failure(execution);
+      return Result<PreparedAnalysisOutcome>::Success(
+          PreparedAnalysisOutcome{SolidDynamicExecutionResult{
+              std::move(dofs.Value()), std::move(state.Value())}});
+    }
+    if (domain.Steps()[0U].IsFrequency()) {
+      if (solid_frequency_executor == nullptr) return missing();
+      auto result = solid_frequency_executor->Execute(domain);
+      if (!result.HasValue())
+        return Result<PreparedAnalysisOutcome>::Failure(result.GetStatus());
+      return Result<PreparedAnalysisOutcome>::Success(
+          PreparedAnalysisOutcome{std::move(result.Value())});
+    }
+    if (solid_static_executor == nullptr) return missing();
+    SolidStaticState state;
+    const Status execution = solid_static_executor->ExecuteInto(domain, state);
+    for (const auto& record : state.IterationRecords()) {
+      const Status written = log.Write(record, domain.Steps()[0U].Name());
+      if (!written.IsOk())
+        return Result<PreparedAnalysisOutcome>::Failure(written);
+    }
+    if (!execution.IsOk())
+      return Result<PreparedAnalysisOutcome>::Failure(execution);
+    return Result<PreparedAnalysisOutcome>::Success(PreparedAnalysisOutcome{
+        SolidStaticExecutionResult{std::move(state), domain.Warnings()}});
+  }
+
   if (domain.Dynamic() != nullptr) {
     if (dynamic_executor == nullptr)
       return Result<PreparedAnalysisOutcome>::Failure(
@@ -120,8 +183,29 @@ Status FinalizePreparedAnalysisResult(
     const PreparedAnalysisOutcome& outcome,
     const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
     NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
-    DynamicResultsWriter* dynamic_writer,
-    ThermalResultsWriter* thermal_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(paths.results_path, domain, result->state,
+                                 diagnostics);
+    if (const auto* result = std::get_if<SolidFrequencyState>(&outcome))
+      return solid_writer->Write(paths.results_path, domain, *result,
+                                 diagnostics);
+    return solid_writer->Write(
+        paths.results_path, domain,
+        std::get<SolidDynamicExecutionResult>(outcome).state, diagnostics);
+  }
   if (std::holds_alternative<ThermalExecutionResult>(outcome)) {
     if (thermal_writer == nullptr) {
       return Status::Failure(FailureCategory::kOutput,