feat: implement phase 1 solver baseline
This commit is contained in:
NINI
@@ -0,0 +1,302 @@
|
||||
#include "fesa/fesa.hpp"
|
||||
|
||||
#include <cmath>
|
||||
#include <functional>
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
|
||||
using TestFn = std::function<void()>;
|
||||
|
||||
struct TestCase {
|
||||
std::string name;
|
||||
TestFn fn;
|
||||
};
|
||||
|
||||
std::vector<TestCase>& registry() {
|
||||
static std::vector<TestCase> tests;
|
||||
return tests;
|
||||
}
|
||||
|
||||
struct RegisterTest {
|
||||
RegisterTest(std::string name, TestFn fn) {
|
||||
registry().push_back({std::move(name), std::move(fn)});
|
||||
}
|
||||
};
|
||||
|
||||
#define FESA_TEST(name) \
|
||||
void name(); \
|
||||
RegisterTest register_##name(#name, name); \
|
||||
void name()
|
||||
|
||||
#define FESA_CHECK(expr) \
|
||||
do { \
|
||||
if (!(expr)) { \
|
||||
throw std::runtime_error(std::string("check failed: ") + #expr); \
|
||||
} \
|
||||
} while (false)
|
||||
|
||||
#define FESA_CHECK_NEAR(actual, expected, tol) \
|
||||
do { \
|
||||
const auto actual_value = (actual); \
|
||||
const auto expected_value = (expected); \
|
||||
if (std::fabs(actual_value - expected_value) > (tol)) { \
|
||||
throw std::runtime_error(std::string("near check failed: ") + #actual); \
|
||||
} \
|
||||
} while (false)
|
||||
|
||||
std::string sourceRoot() {
|
||||
#ifdef FESA_SOURCE_DIR
|
||||
return FESA_SOURCE_DIR;
|
||||
#else
|
||||
return ".";
|
||||
#endif
|
||||
}
|
||||
|
||||
std::string phase1Input() {
|
||||
return R"inp(
|
||||
*Node
|
||||
1, 0, 0, 0
|
||||
2, 1, 0, 0
|
||||
3, 1, 1, 0
|
||||
4, 0, 1, 0
|
||||
*Element, type=S4, elset=EALL
|
||||
1, 1, 2, 3, 4
|
||||
*Nset, nset=LEFT
|
||||
1, 4
|
||||
*Nset, nset=RIGHT
|
||||
2, 3
|
||||
*Elset, elset=EALL
|
||||
1
|
||||
*Material, name=STEEL
|
||||
*Elastic
|
||||
1000.0, 0.3
|
||||
*Shell Section, elset=EALL, material=STEEL
|
||||
0.1
|
||||
*Boundary
|
||||
LEFT, 1, 6, 0
|
||||
RIGHT, 1, 2, 0
|
||||
RIGHT, 4, 6, 0
|
||||
*Cload
|
||||
2, 3, -1
|
||||
3, 3, -1
|
||||
*Step, name=Step-1
|
||||
*Static
|
||||
*End Step
|
||||
)inp";
|
||||
}
|
||||
|
||||
fesa::Domain parsedPhase1Domain() {
|
||||
fesa::AbaqusInputParser parser;
|
||||
auto parsed = parser.parseString(phase1Input());
|
||||
FESA_CHECK(parsed.ok());
|
||||
auto diagnostics = fesa::validateDomain(parsed.domain);
|
||||
FESA_CHECK(!fesa::hasError(diagnostics));
|
||||
return parsed.domain;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
FESA_TEST(core_types_and_dof_mapping_are_stable) {
|
||||
FESA_CHECK(sizeof(fesa::Real) == 8);
|
||||
FESA_CHECK(sizeof(fesa::GlobalId) == 8);
|
||||
FESA_CHECK(sizeof(fesa::EquationId) == 8);
|
||||
FESA_CHECK(fesa::abaqusDofNumber(fesa::Dof::UX) == 1);
|
||||
FESA_CHECK(fesa::abaqusDofNumber(fesa::Dof::RZ) == 6);
|
||||
FESA_CHECK(fesa::dofFromAbaqus(3).value() == fesa::Dof::UZ);
|
||||
FESA_CHECK(std::string(fesa::dofLabel(fesa::Dof::RY)) == "RY");
|
||||
}
|
||||
|
||||
FESA_TEST(parser_accepts_phase1_subset) {
|
||||
fesa::AbaqusInputParser parser;
|
||||
auto parsed = parser.parseString(phase1Input());
|
||||
FESA_CHECK(parsed.ok());
|
||||
FESA_CHECK(parsed.domain.nodes.size() == 4);
|
||||
FESA_CHECK(parsed.domain.elements.size() == 1);
|
||||
FESA_CHECK(parsed.domain.node_sets.at("left").node_ids.size() == 2);
|
||||
FESA_CHECK(parsed.domain.element_sets.at("eall").element_ids.size() == 1);
|
||||
FESA_CHECK(parsed.domain.materials.at("steel").elastic_modulus == 1000.0);
|
||||
FESA_CHECK(parsed.domain.shell_sections.front().thickness == 0.1);
|
||||
FESA_CHECK(parsed.domain.boundary_conditions.size() == 3);
|
||||
FESA_CHECK(parsed.domain.loads.size() == 2);
|
||||
}
|
||||
|
||||
FESA_TEST(parser_rejects_unsupported_features) {
|
||||
const std::string text = R"inp(
|
||||
*Part, name=P1
|
||||
*Node
|
||||
1, 0, 0, 0
|
||||
*Element, type=S4R
|
||||
1, 1, 2, 3, 4
|
||||
*Step, nlgeom=YES
|
||||
*End Step
|
||||
)inp";
|
||||
fesa::AbaqusInputParser parser;
|
||||
auto parsed = parser.parseString(text);
|
||||
FESA_CHECK(!parsed.ok());
|
||||
FESA_CHECK(fesa::containsDiagnostic(parsed.diagnostics, "FESA-PARSE-UNSUPPORTED-KEYWORD"));
|
||||
FESA_CHECK(fesa::containsDiagnostic(parsed.diagnostics, "FESA-PARSE-UNSUPPORTED-ELEMENT"));
|
||||
FESA_CHECK(fesa::containsDiagnostic(parsed.diagnostics, "FESA-PARSE-UNSUPPORTED-NLGEOM"));
|
||||
}
|
||||
|
||||
FESA_TEST(quad01_reference_input_remains_unsupported) {
|
||||
fesa::AbaqusInputParser parser;
|
||||
auto parsed = parser.parseFile(sourceRoot() + "/references/quad_01.inp");
|
||||
FESA_CHECK(!parsed.ok());
|
||||
FESA_CHECK(fesa::containsDiagnostic(parsed.diagnostics, "FESA-PARSE-UNSUPPORTED-KEYWORD") ||
|
||||
fesa::containsDiagnostic(parsed.diagnostics, "FESA-PARSE-UNSUPPORTED-ELEMENT"));
|
||||
}
|
||||
|
||||
FESA_TEST(domain_validation_reports_missing_property_and_targets) {
|
||||
fesa::Domain domain;
|
||||
domain.nodes[1] = {1, {0, 0, 0}};
|
||||
domain.nodes[2] = {2, {1, 0, 0}};
|
||||
domain.nodes[3] = {3, {1, 1, 0}};
|
||||
domain.nodes[4] = {4, {0, 1, 0}};
|
||||
domain.elements[1] = {1, fesa::ElementType::MITC4, {1, 2, 3, 4}, ""};
|
||||
domain.loads.push_back({"MISSING", 3, 1.0});
|
||||
auto diagnostics = fesa::validateDomain(domain);
|
||||
FESA_CHECK(fesa::containsDiagnostic(diagnostics, "FESA-VALIDATION-MISSING-PROPERTY"));
|
||||
FESA_CHECK(fesa::containsDiagnostic(diagnostics, "FESA-VALIDATION-MISSING-NSET"));
|
||||
}
|
||||
|
||||
FESA_TEST(dof_manager_owns_equation_numbering_and_reconstruction) {
|
||||
auto domain = parsedPhase1Domain();
|
||||
fesa::DofManager dofs(domain);
|
||||
FESA_CHECK(dofs.fullDofCount() == 24);
|
||||
FESA_CHECK(dofs.freeDofCount() == 2);
|
||||
FESA_CHECK(dofs.isConstrained(1, fesa::Dof::UX));
|
||||
FESA_CHECK(dofs.equation(2, fesa::Dof::UZ) == 0);
|
||||
FESA_CHECK(dofs.equation(3, fesa::Dof::UZ) == 1);
|
||||
auto full = dofs.reconstructFullVector({-0.1, -0.2});
|
||||
FESA_CHECK_NEAR(full[static_cast<std::size_t>(dofs.fullIndex(2, fesa::Dof::UZ))], -0.1, 1.0e-15);
|
||||
FESA_CHECK_NEAR(full[static_cast<std::size_t>(dofs.fullIndex(1, fesa::Dof::UX))], 0.0, 1.0e-15);
|
||||
}
|
||||
|
||||
FESA_TEST(gaussian_solver_solves_and_diagnoses_singular_systems) {
|
||||
fesa::DenseMatrix a(2, 2);
|
||||
a(0, 0) = 2.0;
|
||||
a(0, 1) = 1.0;
|
||||
a(1, 0) = 1.0;
|
||||
a(1, 1) = 3.0;
|
||||
fesa::GaussianEliminationSolver solver;
|
||||
auto solved = solver.solve(a, {1.0, 2.0});
|
||||
FESA_CHECK(solved.ok());
|
||||
FESA_CHECK_NEAR(solved.x[0], 0.2, 1.0e-12);
|
||||
FESA_CHECK_NEAR(solved.x[1], 0.6, 1.0e-12);
|
||||
|
||||
fesa::DenseMatrix singular(2, 2);
|
||||
singular(0, 0) = 1.0;
|
||||
singular(0, 1) = 2.0;
|
||||
singular(1, 0) = 2.0;
|
||||
singular(1, 1) = 4.0;
|
||||
auto failed = solver.solve(singular, {1.0, 2.0});
|
||||
FESA_CHECK(!failed.ok());
|
||||
FESA_CHECK(fesa::containsDiagnostic(failed.diagnostics, "FESA-SINGULAR-SOLVER"));
|
||||
}
|
||||
|
||||
FESA_TEST(results_writer_uses_step_frame_fields_for_u_and_rf) {
|
||||
auto domain = parsedPhase1Domain();
|
||||
fesa::DofManager dofs(domain);
|
||||
std::vector<fesa::Real> u(static_cast<std::size_t>(dofs.fullDofCount()), 0.0);
|
||||
std::vector<fesa::Real> rf(static_cast<std::size_t>(dofs.fullDofCount()), 0.0);
|
||||
u[static_cast<std::size_t>(dofs.fullIndex(2, fesa::Dof::UZ))] = -0.1;
|
||||
rf[static_cast<std::size_t>(dofs.fullIndex(1, fesa::Dof::UZ))] = 1.0;
|
||||
fesa::InMemoryResultsWriter writer;
|
||||
writer.writeLinearStatic(domain, dofs, u, rf);
|
||||
const auto& result = writer.result();
|
||||
FESA_CHECK(result.schema_name == "FESA_RESULTS");
|
||||
FESA_CHECK(result.steps.size() == 1);
|
||||
FESA_CHECK(result.steps[0].frames[0].field_outputs.count("U") == 1);
|
||||
FESA_CHECK(result.steps[0].frames[0].field_outputs.count("RF") == 1);
|
||||
FESA_CHECK(result.steps[0].frames[0].field_outputs.at("U").component_labels[2] == "UZ");
|
||||
FESA_CHECK(result.steps[0].frames[0].field_outputs.at("RF").component_labels[2] == "RFZ");
|
||||
}
|
||||
|
||||
FESA_TEST(displacement_csv_loader_accepts_quad01_format) {
|
||||
auto table = fesa::loadDisplacementCsv(sourceRoot() + "/references/quad_01_displacements.csv");
|
||||
FESA_CHECK(!fesa::hasError(table.diagnostics));
|
||||
FESA_CHECK(table.rows.size() == 121);
|
||||
FESA_CHECK(table.rows.count(1) == 1);
|
||||
}
|
||||
|
||||
FESA_TEST(displacement_comparator_matches_by_node_id_not_row_order) {
|
||||
fesa::FieldOutput actual;
|
||||
actual.name = "U";
|
||||
actual.entity_ids = {2, 1};
|
||||
actual.component_labels = fesa::displacementComponentLabels();
|
||||
actual.values = {{{2, 0, 0, 0, 0, 0}}, {{1, 0, 0, 0, 0, 0}}};
|
||||
fesa::CsvDisplacementTable expected;
|
||||
expected.rows[1] = {1, {1, 0, 0, 0, 0, 0}};
|
||||
expected.rows[2] = {2, {2, 0, 0, 0, 0, 0}};
|
||||
auto compared = fesa::compareDisplacements(actual, expected, {1.0e-12, 1.0e-12, 1.0});
|
||||
FESA_CHECK(compared.pass);
|
||||
}
|
||||
|
||||
FESA_TEST(mitc4_shape_functions_and_stiffness_baseline) {
|
||||
auto shape = fesa::shapeFunctions(0.25, -0.5);
|
||||
const fesa::Real sum = shape.n[0] + shape.n[1] + shape.n[2] + shape.n[3];
|
||||
FESA_CHECK_NEAR(sum, 1.0, 1.0e-15);
|
||||
|
||||
const std::array<fesa::Vec3, 4> coords = {{{0, 0, 0}, {1, 0, 0}, {1, 1, 0}, {0, 1, 0}}};
|
||||
fesa::MITC4ElementKernel kernel;
|
||||
auto k = kernel.stiffness(coords, 1000.0, 0.3, 0.1);
|
||||
FESA_CHECK(k.rows() == 24);
|
||||
FESA_CHECK(k.cols() == 24);
|
||||
for (fesa::LocalIndex i = 0; i < 24; ++i) {
|
||||
for (fesa::LocalIndex j = 0; j < 24; ++j) {
|
||||
FESA_CHECK_NEAR(k(i, j), k(j, i), 1.0e-8);
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<fesa::Real> uniform_translation(24, 0.0);
|
||||
for (int node = 0; node < 4; ++node) {
|
||||
uniform_translation[static_cast<std::size_t>(6 * node + 0)] = 1.0;
|
||||
}
|
||||
auto internal = k.multiply(uniform_translation);
|
||||
fesa::Real norm = 0.0;
|
||||
for (auto value : internal) {
|
||||
norm += std::fabs(value);
|
||||
}
|
||||
FESA_CHECK(norm < 1.0e-8);
|
||||
}
|
||||
|
||||
FESA_TEST(linear_static_analysis_solves_u_and_recovers_full_vector_rf) {
|
||||
auto domain = parsedPhase1Domain();
|
||||
fesa::LinearStaticAnalysis analysis;
|
||||
auto result = analysis.run(domain);
|
||||
FESA_CHECK(result.ok());
|
||||
FESA_CHECK(result.state.converged);
|
||||
FESA_CHECK(result.result_file.steps.size() == 1);
|
||||
const auto& frame = result.result_file.steps[0].frames[0];
|
||||
FESA_CHECK(frame.field_outputs.count("U") == 1);
|
||||
FESA_CHECK(frame.field_outputs.count("RF") == 1);
|
||||
fesa::Real total_rf_z = 0.0;
|
||||
fesa::DofManager dofs(domain);
|
||||
for (auto node_id : dofs.nodeIds()) {
|
||||
total_rf_z += result.state.reaction_full[static_cast<std::size_t>(dofs.fullIndex(node_id, fesa::Dof::UZ))];
|
||||
}
|
||||
FESA_CHECK_NEAR(total_rf_z, 2.0, 1.0e-8);
|
||||
}
|
||||
|
||||
int main() {
|
||||
int failed = 0;
|
||||
for (const auto& test : registry()) {
|
||||
try {
|
||||
test.fn();
|
||||
std::cout << "[PASS] " << test.name << '\n';
|
||||
} catch (const std::exception& error) {
|
||||
++failed;
|
||||
std::cerr << "[FAIL] " << test.name << ": " << error.what() << '\n';
|
||||
}
|
||||
}
|
||||
if (failed != 0) {
|
||||
std::cerr << failed << " test(s) failed\n";
|
||||
return 1;
|
||||
}
|
||||
std::cout << registry().size() << " test(s) passed\n";
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user