feat(nonlinear-static-newton-raphson): step 10 - prepared-analysis-flow-and-full-procedure

src/fesa/analysis/prepared_analysis.cpp

@@ -0,0 +1,79 @@
+#include "fesa/analysis/prepared_analysis.h"
+
+#include <utility>
+
+#include "fesa/analysis/linear_static_procedure.h"
+#include "fesa/analysis/newton_iteration_log.h"
+#include "fesa/analysis/nonlinear_static_procedure.h"
+#include "fesa/app/output_paths.h"
+#include "fesa/io/abaqus/domain_mapper.h"
+#include "fesa/io/abaqus/input_reader.h"
+#include "fesa/results/nonlinear_results_writer.h"
+#include "fesa/results/results_writer.h"
+
+namespace fesa {
+
+Result<PreparedAnalysisInput> PrepareAnalysisInput(
+    const std::filesystem::path& input_path) {
+  const Result<ParsedInput> syntax = AbaqusInputReader{}.Read(input_path);
+  if (!syntax.HasValue()) {
+    return Result<PreparedAnalysisInput>::Failure(syntax.GetStatus());
+  }
+
+  Result<Domain> mapped = AbaqusDomainMapper{}.Map(syntax.Value());
+  if (!mapped.HasValue()) {
+    return Result<PreparedAnalysisInput>::Failure(mapped.GetStatus());
+  }
+
+  PreparedAnalysisInput prepared{std::move(mapped.Value()), {}};
+  prepared.diagnostics = prepared.domain.Warnings();
+  SortDiagnostics(prepared.diagnostics);
+  return Result<PreparedAnalysisInput>::Success(std::move(prepared));
+}
+
+Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
+    const Domain& domain, LinearStaticProcedureExecutor& linear_executor,
+    NonlinearStaticProcedureExecutor& nonlinear_executor,
+    NewtonIterationLogWriter& log) {
+  if (domain.Steps().Size() != 1U) {
+    return Result<PreparedAnalysisOutcome>::Failure(Status::Failure(
+        FailureCategory::kInput,
+        {{Severity::kError, "invalid-analysis-step-count", {}, "*STEP", {},
+          "Prepared analysis requires exactly one static step."}}));
+  }
+
+  if (domain.Steps()[0U].IsNonlinearStatic()) {
+    Result<NonlinearStaticExecutionResult> nonlinear =
+        nonlinear_executor.Execute(domain, log);
+    if (!nonlinear.HasValue()) {
+      return Result<PreparedAnalysisOutcome>::Failure(nonlinear.GetStatus());
+    }
+    return Result<PreparedAnalysisOutcome>::Success(
+        PreparedAnalysisOutcome{std::move(nonlinear.Value())});
+  }
+
+  Result<LinearStaticExecutionResult> linear = linear_executor.Execute(domain);
+  if (!linear.HasValue()) {
+    return Result<PreparedAnalysisOutcome>::Failure(linear.GetStatus());
+  }
+  return Result<PreparedAnalysisOutcome>::Success(
+      PreparedAnalysisOutcome{std::move(linear.Value())});
+}
+
+Status FinalizePreparedAnalysisResult(
+    const DerivedOutputPaths& paths, const Domain& domain,
+    const PreparedAnalysisOutcome& outcome,
+    const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
+    NonlinearResultsWriter& nonlinear_writer) {
+  if (std::holds_alternative<LinearStaticExecutionResult>(outcome)) {
+    return linear_writer.Write(
+        paths.results_path, domain,
+        std::get<LinearStaticExecutionResult>(outcome).state, diagnostics);
+  }
+
+  return nonlinear_writer.Write(
+      paths.results_path, domain,
+      std::get<NonlinearStaticExecutionResult>(outcome).state, diagnostics);
+}
+
+}  // namespace fesa