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

Integrate Refactor solver sources and dual MSVC CMake builds

Browse Source
This commit is contained in:
KOKO\Mimi
2026-10-18 02:10:51 +09:00
parent 7ee32e5837
commit 12d51480de
218 changed files with 17842 additions and 9689 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit/solvers/linear/linear_solver_test.cpp
+283
View File
@@ -2,13 +2,22 @@
#include <gtest/gtest.h>
#include <limits>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <vector>
#include "fesa/analysis/linear_frequency_procedure.h"
#include "fesa/analysis/solid_frequency_procedure.h"
#include "fesa/solvers/eigen/eigen_solver.h"
#include "fesa/solvers/eigen/mkl_feast_eigen_solver.h"
#include "fesa/fem/dof_manager.h"
#include "fesa/math/sparse_matrix.h"
#include "fesa/solvers/linear/mkl_pardiso_solver.h"
#include "fesa/solvers/linear/mkl_pardiso_tangent_solver.h"
#include "solvers/linear/pardiso_session_test_seam.h"
namespace {
@@ -125,3 +134,277 @@ TEST(MklPardisoSolver, RejectsInvalidCsrStateAndDimensions) {
EXPECT_EQ(no_diagonal_status.Diagnostics().front().code,
"solver-missing-diagonal");
}
namespace {
class RecordingEigenSolver final : public fesa::EigenSolver {
public:
explicit RecordingEigenSolver(bool& destroyed) : destroyed_(destroyed) {}
~RecordingEigenSolver() override { destroyed_ = true; }
fesa::Result<fesa::FeastEigenResult> Solve(
const fesa::SparseMatrix& matrix, std::size_t modes,
double scale) const override {
EXPECT_EQ(matrix.Rows(), 0U);
EXPECT_EQ(modes, 3U);
EXPECT_DOUBLE_EQ(scale, 7.0);
++standard_calls;
return fesa::Result<fesa::FeastEigenResult>::Failure(
fesa::Status::Failure(fesa::FailureCategory::kSolver, {}));
}
fesa::Result<fesa::FeastEigenResult> SolveGeneralized(
const fesa::SparseMatrix& stiffness, const fesa::SparseMatrix& mass,
std::size_t modes, double lower_bound,
double scale) const override {
EXPECT_EQ(stiffness.Rows(), 0U);
EXPECT_EQ(mass.Rows(), 0U);
EXPECT_EQ(modes, 4U);
EXPECT_DOUBLE_EQ(lower_bound, 2.0);
EXPECT_DOUBLE_EQ(scale, 11.0);
++generalized_calls;
return fesa::Result<fesa::FeastEigenResult>::Failure(
fesa::Status::Failure(fesa::FailureCategory::kSolver, {}));
}
mutable int standard_calls{0};
mutable int generalized_calls{0};
private:
bool& destroyed_;
};
} // namespace
TEST(EigenSolverContract, DispatchesBothPencilsAndDestroysThroughBase) {
static_assert(std::is_abstract_v<fesa::EigenSolver>);
static_assert(std::has_virtual_destructor_v<fesa::EigenSolver>);
static_assert(std::is_base_of_v<fesa::EigenSolver,
fesa::MklFeastEigenSolver>);
static_assert(std::is_constructible_v<fesa::LinearFrequencyProcedureExecutor,
const fesa::EigenSolver&>);
static_assert(std::is_constructible_v<fesa::SolidFrequencyProcedureExecutor,
const fesa::EigenSolver&>);
bool destroyed = false;
{
auto recording = std::make_unique<RecordingEigenSolver>(destroyed);
const auto* observations = recording.get();
std::unique_ptr<fesa::EigenSolver> solver = std::move(recording);
const fesa::EigenSolver& contract = *solver;
const auto empty = MakeDenseCsr(0U, 0U, {});
EXPECT_FALSE(contract.Solve(empty, 3U, 7.0).HasValue());
EXPECT_FALSE(contract.SolveGeneralized(empty, empty, 4U, 2.0, 11.0)
.HasValue());
EXPECT_EQ(observations->standard_calls, 1);
EXPECT_EQ(observations->generalized_calls, 1);
EXPECT_FALSE(destroyed);
}
EXPECT_TRUE(destroyed);
}
TEST(PardisoSession, RetainsDistinctStoragePoliciesAndFreshPhaseOrder) {
std::vector<int> phases;
fesa::internal::ScopedPardisoBackendTestHook hook{
[&](const fesa::internal::PardisoBackendTestCall& call,
MKL_INT&, MKL_INT&) {
phases.push_back(static_cast<int>(call.phase));
if (call.phase == 11) {
EXPECT_EQ(call.equation_count, 2);
if (call.matrix_type == 2) {
EXPECT_EQ(call.row_offsets[2], 3);
EXPECT_EQ(call.column_indices[0], 0);
EXPECT_EQ(call.column_indices[1], 1);
EXPECT_EQ(call.column_indices[2], 1);
} else {
EXPECT_EQ(call.matrix_type, 11);
EXPECT_EQ(call.row_offsets[2], 4);
EXPECT_DOUBLE_EQ(call.values[2], 0.0);
}
}
}};
{
fesa::MklPardisoSolver solver;
const auto matrix = MakeDenseCsr(2U, 2U, {4.0, 1.0, 1.0, 3.0});
ASSERT_TRUE(solver.Factorize(matrix).IsOk());
fesa::Vector solution{2U};
ASSERT_TRUE(solver.Solve(fesa::Vector{2U, 1.0}, solution).IsOk());
EXPECT_NEAR(solution[0], 2.0 / 11.0, 1e-14);
ASSERT_TRUE(solver.Solve(fesa::Vector{2U, 2.0}, solution).IsOk());
EXPECT_NEAR(solution[1], 6.0 / 11.0, 1e-14);
ASSERT_TRUE(solver.Factorize(matrix).IsOk());
}
EXPECT_EQ(phases, (std::vector<int>{11, 22, 33, 33, -1, 11, 22, -1}));
phases.clear();
{
fesa::MklPardisoTangentSolver solver;
const auto matrix = MakeDenseCsr(2U, 2U, {2.0, 1.0, 0.0, 3.0});
ASSERT_TRUE(solver.FactorizeFresh(matrix).IsOk());
fesa::Vector correction{2U};
ASSERT_TRUE(solver.SolveCorrection(fesa::Vector{2U, 6.0}, correction).IsOk());
EXPECT_NEAR(correction[0], 2.0, 1e-14);
EXPECT_NEAR(correction[1], 2.0, 1e-14);
ASSERT_TRUE(solver.FactorizeFresh(matrix).IsOk());
}
EXPECT_EQ(phases, (std::vector<int>{11, 22, 33, -1, 11, 22, -1}));
}
TEST(PardisoSession, FailedSolvePreservesOutputAndRetainedFactorization) {
int solve_calls = 0;
fesa::internal::ScopedPardisoBackendTestHook hook{
[&](const fesa::internal::PardisoBackendTestCall& call,
MKL_INT& error, MKL_INT&) {
if (call.phase != 33) return;
++solve_calls;
if (solve_calls == 1) error = -3;
if (solve_calls == 2)
call.solution[0] = (std::numeric_limits<double>::infinity)();
}};
fesa::MklPardisoSolver solver;
ASSERT_TRUE(solver.Factorize(MakeDenseCsr(1U, 1U, {2.0})).IsOk());
fesa::Vector solution{1U, 17.0};
const auto failed = solver.Solve(fesa::Vector{1U, 6.0}, solution);
ASSERT_FALSE(failed.IsOk());
EXPECT_EQ(failed.Diagnostics().front().code, "pardiso-solve-failed");
EXPECT_DOUBLE_EQ(solution[0], 17.0);
const auto nonfinite = solver.Solve(fesa::Vector{1U, 6.0}, solution);
ASSERT_FALSE(nonfinite.IsOk());
EXPECT_EQ(nonfinite.Diagnostics().front().code, "nonfinite-solver-solution");
EXPECT_DOUBLE_EQ(solution[0], 17.0);
ASSERT_TRUE(solver.Solve(fesa::Vector{1U, 6.0}, solution).IsOk());
EXPECT_DOUBLE_EQ(solution[0], 3.0);
}
TEST(PardisoSession, ReleaseFailurePrecedesNewValidationAndInvalidatesState) {
int releases = 0;
fesa::internal::ScopedPardisoBackendTestHook hook{
[&](const fesa::internal::PardisoBackendTestCall& call,
MKL_INT& error, MKL_INT&) {
if (call.phase == -1) { ++releases; error = -3; }
}};
fesa::MklPardisoSolver solver;
ASSERT_TRUE(solver.Factorize(MakeDenseCsr(1U, 1U, {2.0})).IsOk());
const auto status = solver.Factorize(MakeDenseCsr(1U, 2U, {1.0, 2.0}));
ASSERT_FALSE(status.IsOk());
EXPECT_EQ(status.Diagnostics().front().code, "pardiso-release-failed");
fesa::Vector output{1U, 19.0};
const auto unavailable = solver.Solve(fesa::Vector{1U, 1.0}, output);
ASSERT_FALSE(unavailable.IsOk());
EXPECT_EQ(unavailable.Diagnostics().front().code, "solver-not-factorized");
EXPECT_DOUBLE_EQ(output[0], 19.0);
EXPECT_EQ(releases, 1);
}
TEST(PardisoSession, FactorizationFailuresAndExceptionsReleaseExactlyOnce) {
const auto matrix = MakeDenseCsr(1U, 1U, {2.0});
for (const int failing_phase : {11, 22}) {
std::vector<int> phases;
fesa::internal::ScopedPardisoBackendTestHook hook{
[&](const fesa::internal::PardisoBackendTestCall& call,
MKL_INT& error, MKL_INT&) {
phases.push_back(static_cast<int>(call.phase));
if (call.phase == failing_phase) error = -8;
}};
{
fesa::MklPardisoSolver solver;
const auto status = solver.Factorize(matrix);
ASSERT_FALSE(status.IsOk());
EXPECT_EQ(status.Diagnostics().front().code, "pardiso-integer-overflow");
fesa::Vector output{1U, 29.0};
EXPECT_FALSE(solver.Solve(fesa::Vector{1U, 1.0}, output).IsOk());
EXPECT_DOUBLE_EQ(output[0], 29.0);
}
EXPECT_EQ(phases, failing_phase == 11 ? (std::vector<int>{11, -1})
: (std::vector<int>{11, 22, -1}));
}
std::vector<int> phases;
fesa::internal::ScopedPardisoBackendTestHook hook{
[&](const fesa::internal::PardisoBackendTestCall& call,
MKL_INT&, MKL_INT&) {
phases.push_back(static_cast<int>(call.phase));
if (call.phase == 11) throw std::runtime_error("injected unwind");
}};
{
fesa::MklPardisoTangentSolver solver;
EXPECT_THROW(solver.FactorizeFresh(matrix), std::runtime_error);
EXPECT_EQ(phases, (std::vector<int>{11, -1}));
}
EXPECT_EQ(phases, (std::vector<int>{11, -1}));
}
TEST(PardisoSession, FailedTangentSolveRetainsStateButFailedFreshInvalidatesIt) {
bool fail_solve = true;
fesa::internal::ScopedPardisoBackendTestHook hook{
[&](const fesa::internal::PardisoBackendTestCall& call,
MKL_INT& error, MKL_INT&) {
if (call.phase == 33 && fail_solve) error = -3;
}};
fesa::MklPardisoTangentSolver solver;
ASSERT_TRUE(solver.FactorizeFresh(
MakeDenseCsr(2U, 2U, {2.0, 1.0, 0.0, 3.0})).IsOk());
fesa::Vector correction{2U, 31.0};
auto status = solver.SolveCorrection(fesa::Vector{2U, 6.0}, correction);
ASSERT_FALSE(status.IsOk());
EXPECT_EQ(status.Diagnostics().front().code, "pardiso-solve-failed");
EXPECT_DOUBLE_EQ(correction[0], 31.0);
EXPECT_DOUBLE_EQ(correction[1], 31.0);
fail_solve = false;
ASSERT_TRUE(solver.SolveCorrection(fesa::Vector{2U, 6.0}, correction).IsOk());
EXPECT_NEAR(correction[0], 2.0, 1e-14);
EXPECT_NEAR(correction[1], 2.0, 1e-14);
status = solver.FactorizeFresh(MakeDenseCsr(1U, 2U, {1.0, 2.0}));
ASSERT_FALSE(status.IsOk());
EXPECT_EQ(status.Diagnostics().front().code, "solver-matrix-not-square");
status = solver.SolveCorrection(fesa::Vector{2U, 6.0}, correction);
ASSERT_FALSE(status.IsOk());
EXPECT_EQ(status.Diagnostics().front().code, "solver-not-factorized");
EXPECT_NEAR(correction[0], 2.0, 1e-14);
EXPECT_NEAR(correction[1], 2.0, 1e-14);
}
TEST(PardisoSession, EmptyLifecycleNeverInvokesBackend) {
int calls = 0;
fesa::internal::ScopedPardisoBackendTestHook hook{
[&](const fesa::internal::PardisoBackendTestCall&, MKL_INT&, MKL_INT&) {
++calls;
}};
{
fesa::MklPardisoSolver solver;
fesa::MklPardisoTangentSolver tangent;
const auto empty = MakeDenseCsr(0U, 0U, {});
fesa::Vector solution{0U};
ASSERT_TRUE(solver.Factorize(empty).IsOk());
ASSERT_TRUE(solver.Solve(fesa::Vector{0U}, solution).IsOk());
ASSERT_TRUE(solver.Factorize(empty).IsOk());
ASSERT_TRUE(tangent.FactorizeFresh(empty).IsOk());
ASSERT_TRUE(tangent.SolveCorrection(fesa::Vector{0U}, solution).IsOk());
ASSERT_TRUE(tangent.FactorizeFresh(empty).IsOk());
}
EXPECT_EQ(calls, 0);
}
TEST(PardisoSession, RestoresDefaultThreadPolicyAndPreservesCallerOverride) {
const int previous = mkl_set_num_threads_local(0);
struct RestoreThreads {
int previous;
~RestoreThreads() { mkl_set_num_threads_local(previous); }
} restore{previous};
const auto matrix = MakeDenseCsr(1U, 1U, {2.0});
for (const int caller_threads : {0, 2}) {
mkl_set_num_threads_local(caller_threads);
int release_calls = 0;
fesa::internal::ScopedPardisoBackendTestHook hook{
[&](const fesa::internal::PardisoBackendTestCall& call,
MKL_INT& error, MKL_INT&) {
EXPECT_EQ(mkl_get_max_threads(), caller_threads == 0 ? 1 : 2);
if (call.phase == 22) error = -8;
if (call.phase == -1) ++release_calls;
}};
{
fesa::MklPardisoSolver solver;
EXPECT_FALSE(solver.Factorize(matrix).IsOk());
EXPECT_EQ(mkl_set_num_threads_local(caller_threads), caller_threads);
}
EXPECT_EQ(release_calls, 1);
EXPECT_EQ(mkl_set_num_threads_local(caller_threads), caller_threads);
}
}