feat(cpp-object-oriented-modular-refactoring): step 5 - solver-workflow-google-style

include/fesa/analysis/linear_static_analysis.h

@@ -0,0 +1,104 @@
+#ifndef FESA_ANALYSIS_LINEAR_STATIC_ANALYSIS_H_
+#define FESA_ANALYSIS_LINEAR_STATIC_ANALYSIS_H_
+
+#include <filesystem>
+#include <memory>
+#include <vector>
+
+#include "fesa/analysis/analysis_model.h"
+#include "fesa/analysis/analysis_state.h"
+#include "fesa/constraints/essential_constraints.h"
+#include "fesa/core/status.h"
+#include "fesa/fem/dof_manager.h"
+#include "fesa/math/sparse_matrix.h"
+#include "fesa/math/vector.h"
+#include "fesa/model/domain.h"
+
+namespace fesa {
+
+class LinearSolver;
+class ParallelFor;
+class ResultsWriter;
+
+/// @brief Carries input and authoritative output paths for one analysis run.
+struct AnalysisRequest {
+  std::filesystem::path input_path;
+  std::filesystem::path output_path;
+};
+
+/// @brief Executes the current approved V0 analysis lifecycle.
+class Analysis {
+ public:
+  virtual ~Analysis() = default;
+
+  /// @brief Runs the eight current lifecycle stages in their approved order.
+  /// @param request Input and output paths for this run.
+  /// @return The first stage failure or successful result finalization.
+  Status Run(const AnalysisRequest& request);
+
+ protected:
+  /// @brief Initializes owned input and Domain state for a run.
+  virtual Status Initialize(const AnalysisRequest& request) = 0;
+  /// @brief Builds the non-owning active-model view.
+  virtual Status BuildAnalysisModel() = 0;
+  /// @brief Builds stable DOF numbering and the sparse structural pattern.
+  virtual Status BuildDofMapAndSparsePattern() = 0;
+  /// @brief Assembles full stiffness and stable constraint partitions.
+  virtual Status AssembleAndPartitionStiffness() = 0;
+  /// @brief Factorizes Kff before any load assembly.
+  virtual Status Factorize() = 0;
+  /// @brief Assembles loads and forms Ff-Kfc*dc without solving.
+  virtual Status AssembleLoadsAndEffectiveRhs() = 0;
+  /// @brief Substitutes the retained factorization and reconstructs full d.
+  virtual Status SubstituteAndReconstruct() = 0;
+  /// @brief Recovers a complete candidate and writes authoritative results.
+  virtual Status RecoverAndWriteResults() = 0;
+};
+
+/// @brief Orchestrates the single-step linear-static procedure.
+/// @note Factorization, substitution, recovery, and writing remain separately
+/// observable through injected backend boundaries.
+class LinearStaticAnalysis final : public Analysis {
+ public:
+  /// @brief Creates a procedure using non-owned backend adapters.
+  /// @note All three adapters must outlive this analysis object.
+  LinearStaticAnalysis(const ParallelFor& parallel_for,
+                       LinearSolver& linear_solver,
+                       ResultsWriter& results_writer);
+
+ protected:
+  /// @copydoc Analysis::Initialize
+  Status Initialize(const AnalysisRequest& request) override;
+  /// @copydoc Analysis::BuildAnalysisModel
+  Status BuildAnalysisModel() override;
+  /// @copydoc Analysis::BuildDofMapAndSparsePattern
+  Status BuildDofMapAndSparsePattern() override;
+  /// @copydoc Analysis::AssembleAndPartitionStiffness
+  Status AssembleAndPartitionStiffness() override;
+  /// @copydoc Analysis::Factorize
+  Status Factorize() override;
+  /// @copydoc Analysis::AssembleLoadsAndEffectiveRhs
+  Status AssembleLoadsAndEffectiveRhs() override;
+  /// @copydoc Analysis::SubstituteAndReconstruct
+  Status SubstituteAndReconstruct() override;
+  /// @copydoc Analysis::RecoverAndWriteResults
+  Status RecoverAndWriteResults() override;
+
+ private:
+  const ParallelFor& parallel_for_;
+  LinearSolver& linear_solver_;
+  ResultsWriter& results_writer_;
+  AnalysisRequest request_;
+  std::unique_ptr<Domain> domain_;
+  std::unique_ptr<AnalysisModel> model_;
+  std::unique_ptr<DofManager> dofs_;
+  std::unique_ptr<AnalysisState> state_;
+  std::unique_ptr<SparseMatrix> full_stiffness_;
+  std::unique_ptr<PartitionedStiffness> partitioned_stiffness_;
+  std::unique_ptr<Vector> effective_rhs_;
+  std::vector<Diagnostic> diagnostics_;
+};
+
+}  // namespace fesa
+
+#endif  // FESA_ANALYSIS_LINEAR_STATIC_ANALYSIS_H_