feat: implement consistent-mass HHT shell dynamics

src/fesa/analysis/prepared_analysis.cpp

@@ -2,6 +2,7 @@
 
 #include <utility>
 
+#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"
@@ -9,6 +10,7 @@
 #include "fesa/app/output_paths.h"
 #include "fesa/io/abaqus/domain_mapper.h"
 #include "fesa/io/abaqus/input_reader.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"
@@ -37,7 +39,8 @@ Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
     const Domain& domain, LinearStaticProcedureExecutor& linear_executor,
     NonlinearStaticProcedureExecutor& nonlinear_executor,
     const LinearFrequencyProcedureExecutor& frequency_executor,
-    NewtonIterationLogWriter& log) {
+    NewtonIterationLogWriter& log,
+    const HhtDynamicProcedureExecutor* dynamic_executor) {
   if (domain.Steps().Size() != 1U) {
     return Result<PreparedAnalysisOutcome>::Failure(Status::Failure(
         FailureCategory::kInput,
@@ -49,6 +52,22 @@ Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
           "Prepared analysis requires exactly one analysis step."}}));
   }
 
+  if (domain.Dynamic() != nullptr) {
+    if (dynamic_executor == nullptr)
+      return Result<PreparedAnalysisOutcome>::Failure(
+          Status::Failure(FailureCategory::kSolver,
+                          {{Severity::kError,
+                            "missing-dynamic-executor",
+                            {},
+                            "DYNAMIC",
+                            {},
+                            "Dynamic execution adapter is required."}}));
+    auto dynamic = dynamic_executor->Execute(domain, log);
+    if (!dynamic.HasValue())
+      return Result<PreparedAnalysisOutcome>::Failure(dynamic.GetStatus());
+    return Result<PreparedAnalysisOutcome>::Success(
+        PreparedAnalysisOutcome{std::move(dynamic.Value())});
+  }
   if (domain.Steps()[0U].IsFrequency()) {
     auto eigen = frequency_executor.Execute(domain);
     if (!eigen.HasValue()) {
@@ -80,8 +99,21 @@ Status FinalizePreparedAnalysisResult(
     const DerivedOutputPaths& paths, const Domain& domain,
     const PreparedAnalysisOutcome& outcome,
     const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
-    NonlinearResultsWriter& nonlinear_writer,
-    EigenResultsWriter& eigen_writer) {
+    NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
+    DynamicResultsWriter* dynamic_writer) {
+  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(
+        paths.results_path, domain,
+        std::get<DynamicExecutionResult>(outcome).state, diagnostics);
+  }
   if (std::holds_alternative<EigenAnalysisState>(outcome)) {
     return eigen_writer.Write(paths.results_path, domain,
                               std::get<EigenAnalysisState>(outcome),