baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(cpp-object-oriented-modular-refactoring): step 20 - analysis-hierarchy

Browse Source
This commit is contained in:
KOKO\Mimi
2026-08-16 11:33:08 +09:00
parent 95c186b812
commit be35d00f49
8 changed files with 214 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/integration/analysis/linear_static_analysis_test.cpp
+49 -67
View File
@@ -14,6 +14,7 @@
#include <utility>
#include <vector>
#include "fesa/analysis/analysis.h"
#include "fesa/assembly/parallel_for.h"
#include "fesa/results/results_writer.h"
#include "fesa/solvers/linear/mkl_pardiso_solver.h"
@@ -152,45 +153,6 @@ N4, 1, 6
)inp");
}
// The pure Template Method spy makes the eight public lifecycle hooks
// observable without coupling the ordering assertion to any solver backend.
class SpyAnalysis final : public fesa::Analysis {
public:
const std::vector<std::string>& Events() const noexcept { return events_; }
protected:
fesa::Status Initialize(const fesa::AnalysisRequest&) override {
return Record("initialize");
}
fesa::Status BuildAnalysisModel() override {
return Record("build-analysis-model");
}
fesa::Status BuildDofMapAndSparsePattern() override {
return Record("build-dof-map-and-sparse-pattern");
}
fesa::Status AssembleAndPartitionStiffness() override {
return Record("assemble-and-partition-stiffness");
}
fesa::Status Factorize() override { return Record("factorize"); }
fesa::Status AssembleLoadsAndEffectiveRhs() override {
return Record("assemble-loads-and-effective-rhs");
}
fesa::Status SubstituteAndReconstruct() override {
return Record("substitute-and-reconstruct");
}
fesa::Status RecoverAndWriteResults() override {
return Record("recover-and-write-results");
}
private:
fesa::Status Record(const char* event) {
events_.emplace_back(event);
return fesa::Status::Ok();
}
std::vector<std::string> events_;
};
// The solver spy records only the adapter-boundary operations. In particular,
// solve() cannot conceal a second factorization call.
class SpyLinearSolver final : public fesa::LinearSolver {
@@ -342,17 +304,6 @@ class CapturingResultsWriter final : public fesa::ResultsWriter {
} // namespace
TEST(LinearStaticCli, FactorizesBeforeLoadAndSolvesWithoutRefactorization) {
SpyAnalysis lifecycle;
const fesa::AnalysisRequest empty_request{};
ASSERT_TRUE(lifecycle.Run(empty_request).IsOk());
EXPECT_EQ(lifecycle.Events(),
(std::vector<std::string>{
"initialize", "build-analysis-model",
"build-dof-map-and-sparse-pattern",
"assemble-and-partition-stiffness", "factorize",
"assemble-loads-and-effective-rhs",
"substitute-and-reconstruct", "recover-and-write-results"}));
TempDirectory directory{"order"};
const auto input = directory.Path() / "order.inp";
const auto output = directory.Path() / "results.h5";
@@ -362,9 +313,10 @@ TEST(LinearStaticCli, FactorizesBeforeLoadAndSolvesWithoutRefactorization) {
fesa::SerialParallelFor serial;
SpyLinearSolver solver{adapter_events};
SpyResultsWriter writer{adapter_events};
fesa::LinearStaticAnalysis analysis{serial, solver, writer};
std::unique_ptr<fesa::Analysis> analysis =
std::make_unique<fesa::LinearStaticAnalysis>(serial, solver, writer);
ASSERT_TRUE(analysis.Run({input, output}).IsOk());
ASSERT_TRUE(analysis->Run({input, output}).IsOk());
EXPECT_EQ(solver.FactorizeCalls(), 1);
EXPECT_EQ(solver.SolveCalls(), 1);
EXPECT_EQ(writer.WriteCalls(), 1);
@@ -373,6 +325,30 @@ TEST(LinearStaticCli, FactorizesBeforeLoadAndSolvesWithoutRefactorization) {
"writer-write"}));
}
TEST(LinearStaticCli, FactorizesBeforeRejectingAnInvalidLoad) {
TempDirectory directory{"factorize-before-load"};
const auto input = directory.Path() / "invalid-load-shell.inp";
const auto output = directory.Path() / "must-not-exist.h5";
WriteText(input, ShellDeck("*Boundary\nAll, 1, 6\n", "*Cload\nN1, 6, 1.0\n"));
std::vector<std::string> adapter_events;
fesa::SerialParallelFor serial;
SpyLinearSolver solver{adapter_events};
SpyResultsWriter writer{adapter_events};
std::unique_ptr<fesa::Analysis> analysis =
std::make_unique<fesa::LinearStaticAnalysis>(serial, solver, writer);
const fesa::Status status = analysis->Run({input, output});
ASSERT_FALSE(status.IsOk());
EXPECT_EQ(status.Category(), fesa::FailureCategory::kModel);
ASSERT_EQ(status.Diagnostics().size(), 1U);
EXPECT_EQ(status.Diagnostics()[0U].code, "unsupported-drilling-load");
EXPECT_EQ(solver.FactorizeCalls(), 1);
EXPECT_EQ(solver.SolveCalls(), 0);
EXPECT_EQ(writer.WriteCalls(), 0);
EXPECT_EQ(adapter_events, (std::vector<std::string>{"solver-factorize"}));
}
TEST(LinearStaticCli, RealPipelineHandlesAnalyticalAndNonzeroPrescription) {
TempDirectory directory{"analytical"};
const auto input = directory.Path() / "prescribed-axial.inp";
@@ -382,9 +358,10 @@ TEST(LinearStaticCli, RealPipelineHandlesAnalyticalAndNonzeroPrescription) {
fesa::SerialParallelFor serial;
fesa::MklPardisoSolver solver;
CapturingResultsWriter writer;
fesa::LinearStaticAnalysis analysis{serial, solver, writer};
std::unique_ptr<fesa::Analysis> analysis =
std::make_unique<fesa::LinearStaticAnalysis>(serial, solver, writer);
const auto status = analysis.Run({input, output});
const auto status = analysis->Run({input, output});
ASSERT_TRUE(status.IsOk());
EXPECT_EQ(writer.OutputPath(), output);
EXPECT_EQ(writer.NodeCount(), 2U);
@@ -419,9 +396,10 @@ TEST(Mitc4ShellCli, UsesExistingLifecycleAndExactlyOneFactorization) {
fesa::SerialParallelFor serial;
SpyLinearSolver solver{adapter_events};
SpyResultsWriter writer{adapter_events};
fesa::LinearStaticAnalysis analysis{serial, solver, writer};
std::unique_ptr<fesa::Analysis> analysis =
std::make_unique<fesa::LinearStaticAnalysis>(serial, solver, writer);
ASSERT_TRUE(analysis.Run({input, output}).IsOk());
ASSERT_TRUE(analysis->Run({input, output}).IsOk());
EXPECT_EQ(solver.FactorizeCalls(), 1);
EXPECT_EQ(solver.SolveCalls(), 1);
EXPECT_EQ(writer.WriteCalls(), 1);
@@ -440,9 +418,10 @@ TEST(Mitc4ShellCli, AppliesKfcForNonzeroPrescribedDisplacement) {
fesa::SerialParallelFor serial;
RecordingMklSolver solver;
CapturingResultsWriter writer;
fesa::LinearStaticAnalysis analysis{serial, solver, writer};
std::unique_ptr<fesa::Analysis> analysis =
std::make_unique<fesa::LinearStaticAnalysis>(serial, solver, writer);
const auto status = analysis.Run({input, output});
const auto status = analysis->Run({input, output});
for (const auto& diagnostic : status.Diagnostics()) {
EXPECT_TRUE(status.IsOk()) << diagnostic.code << ": " << diagnostic.message;
}
@@ -479,19 +458,21 @@ TEST(Mitc4ShellCli, RejectsSingularAndAcceptsZeroByZeroFreeSystem) {
fesa::MklPardisoSolver singular_solver;
std::vector<std::string> singular_events;
SpyResultsWriter singular_writer{singular_events};
fesa::LinearStaticAnalysis singular_analysis{serial, singular_solver,
singular_writer};
const auto singular =
singular_analysis.Run({singular_input, directory.Path() / "singular.h5"});
std::unique_ptr<fesa::Analysis> singular_analysis =
std::make_unique<fesa::LinearStaticAnalysis>(serial, singular_solver,
singular_writer);
const auto singular = singular_analysis->Run(
{singular_input, directory.Path() / "singular.h5"});
ASSERT_FALSE(singular.IsOk());
EXPECT_EQ(singular.Category(), fesa::FailureCategory::kSolver);
EXPECT_EQ(singular_writer.WriteCalls(), 0);
RecordingMklSolver constrained_solver;
CapturingResultsWriter constrained_writer;
fesa::LinearStaticAnalysis constrained_analysis{serial, constrained_solver,
constrained_writer};
const auto constrained = constrained_analysis.Run(
std::unique_ptr<fesa::Analysis> constrained_analysis =
std::make_unique<fesa::LinearStaticAnalysis>(serial, constrained_solver,
constrained_writer);
const auto constrained = constrained_analysis->Run(
{constrained_input, directory.Path() / "constrained.h5"});
ASSERT_TRUE(constrained.IsOk());
EXPECT_EQ(constrained_solver.FactorizeCalls(), 1);
@@ -511,9 +492,10 @@ TEST(Mitc4ShellCli, DoesNotWriteAnInvalidRecoveryCandidate) {
NonfiniteLinearSolver solver;
std::vector<std::string> adapter_events;
SpyResultsWriter writer{adapter_events};
fesa::LinearStaticAnalysis analysis{serial, solver, writer};
std::unique_ptr<fesa::Analysis> analysis =
std::make_unique<fesa::LinearStaticAnalysis>(serial, solver, writer);
const auto status =
analysis.Run({input, directory.Path() / "must-not-exist.h5"});
analysis->Run({input, directory.Path() / "must-not-exist.h5"});
ASSERT_FALSE(status.IsOk());
EXPECT_EQ(status.Category(), fesa::FailureCategory::kModel);