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

src/fesa/app/fesa_application.cpp

@@ -2,17 +2,20 @@
 
 #include <filesystem>
 #include <iostream>
-#include <memory>
 #include <string>
 #include <vector>
 
-#include "fesa/analysis/analysis.h"
-#include "fesa/analysis/linear_static_analysis.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/prepared_analysis.h"
 #include "fesa/app/output_paths.h"
 #include "fesa/assembly/parallel_for.h"
 #include "fesa/core/diagnostic.h"
 #include "fesa/io/hdf5/hdf5_results_writer.h"
+#include "fesa/io/hdf5/nonlinear_hdf5_results_writer.h"
 #include "fesa/solvers/linear/mkl_pardiso_solver.h"
+#include "fesa/solvers/linear/mkl_pardiso_tangent_solver.h"
 
 namespace fesa {
 namespace {
@@ -73,17 +76,53 @@ int FesaApplication::Run(const std::vector<std::string>& arguments) {
     return kOutputExitCode;
   }
 
-  AnalysisRequest request;
-  request.input_path = paths.Value().input_path;
-  request.output_path = paths.Value().results_path;
-  request.log_path = paths.Value().log_path;
-
   TbbParallelFor parallel_for;
   MklPardisoSolver linear_solver;
-  Hdf5ResultsWriter results_writer;
-  std::unique_ptr<Analysis> analysis = std::make_unique<LinearStaticAnalysis>(
-      parallel_for, linear_solver, results_writer);
-  const Status status = analysis->Run(request);
+  MklPardisoTangentSolver tangent_solver;
+  Hdf5ResultsWriter linear_writer;
+  NonlinearHdf5ResultsWriter nonlinear_writer;
+  NewtonIterationLogWriter log;
+
+  Status status = log.Open(paths.Value().log_path);
+  if (!status.IsOk()) {
+    WriteDiagnostics(status.Diagnostics());
+    return ExitCodeFor(status);
+  }
+
+  Result<PreparedAnalysisInput> prepared =
+      PrepareAnalysisInput(paths.Value().input_path);
+  if (!prepared.HasValue()) {
+    status = prepared.GetStatus();
+  } else {
+    LinearStaticProcedureExecutor linear_executor(parallel_for, linear_solver);
+    NonlinearStaticProcedureExecutor nonlinear_executor(parallel_for,
+                                                         tangent_solver);
+    Result<PreparedAnalysisOutcome> outcome = ExecutePreparedAnalysis(
+        prepared.Value().domain, linear_executor, nonlinear_executor, log);
+    if (!outcome.HasValue()) {
+      status = outcome.GetStatus();
+    } else {
+      const Status close_status = log.Close();
+      if (!close_status.IsOk()) {
+        WriteDiagnostics(close_status.Diagnostics());
+        return ExitCodeFor(close_status);
+      }
+      status = FinalizePreparedAnalysisResult(
+          paths.Value(), prepared.Value().domain, outcome.Value(),
+          prepared.Value().diagnostics, linear_writer, nonlinear_writer);
+      if (status.IsOk()) {
+        return kSuccessExitCode;
+      }
+      WriteDiagnostics(status.Diagnostics());
+      return ExitCodeFor(status);
+    }
+  }
+
+  const Status close_status = log.Close();
+  if (!close_status.IsOk()) {
+    WriteDiagnostics(close_status.Diagnostics());
+    return ExitCodeFor(close_status);
+  }
   if (status.IsOk()) {
     return kSuccessExitCode;
   }