baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
624ea4872cd7f5bf704040ccc07838c6568c3004
FESADev/tests/reference/reference_comparison_test.cpp
T
KOKO\Mimi 624ea4872c modify tolerance policy
2026-08-18 02:29:26 +09:00

719 lines
30 KiB
C++
Raw Blame History

#include "reference_comparison.h"
#include <gtest/gtest.h>
#include <algorithm>
#include <array>
#include <atomic>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <limits>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#include "fesa/analysis/analysis_model.h"
#include "fesa/analysis/analysis_state.h"
#include "fesa/fem/dof_manager.h"
#include "fesa/io/abaqus/input_reader.h"
#include "fesa/io/hdf5/hdf5_results_writer.h"
#include "fesa/model/domain.h"
#ifndef FESA_TEST_SOURCE_DIR
#error FESA_TEST_SOURCE_DIR must identify the repository root.
#endif
#ifndef FESA_TEST_BINARY_DIR
#error FESA_TEST_BINARY_DIR must identify the CMake binary root.
#endif
namespace {
constexpr const char* kInputName = "cantilever beam.inp";
constexpr const char* kDisplacementName = "cantilever beam displacements.csv";
constexpr const char* kReactionName = "cantilever beam reactions.csv";
constexpr const char* kSectionName = "cantilever beam elemental forces.csv";
constexpr const char* kInstanceName = "PART-1_1-1";
constexpr std::size_t kNodeCount = 11U;
constexpr std::size_t kElementCount = 10U;
constexpr std::size_t kExpectedRowCount = 212U;
constexpr std::size_t kExpectedMetricCount = 6U;
using NodalValues = std::array<std::array<double, 6>, kNodeCount>;
using EndpointValues =
std::array<std::array<std::array<double, 4>, 2>, kElementCount>;
struct ComparisonValues {
NodalValues displacement{};
NodalValues reaction{};
EndpointValues section_resultants{};
};
const std::filesystem::path& SourceRoot() {
static const std::filesystem::path kRoot{FESA_TEST_SOURCE_DIR};
return kRoot;
}
const std::filesystem::path& BinaryRoot() {
static const std::filesystem::path kRoot{FESA_TEST_BINARY_DIR};
return kRoot;
}
std::string ReadBytes(const std::filesystem::path& path) {
std::ifstream stream{path, std::ios::binary};
if (!stream) {
throw std::runtime_error{"Unable to read fixture: " + path.string()};
}
return {std::istreambuf_iterator<char>{stream},
std::istreambuf_iterator<char>{}};
}
void WriteBytes(const std::filesystem::path& path,
const std::string& contents) {
std::ofstream stream{path, std::ios::binary | std::ios::trunc};
if (!stream) {
throw std::runtime_error{"Unable to write build-local fixture: " +
path.string()};
}
stream.write(contents.data(), static_cast<std::streamsize>(contents.size()));
if (!stream) {
throw std::runtime_error{"Unable to finish build-local fixture write."};
}
}
std::vector<std::string> ReadLines(const std::filesystem::path& path) {
std::ifstream stream{path};
if (!stream) {
throw std::runtime_error{"Unable to read fixture lines."};
}
std::vector<std::string> lines;
for (std::string line; std::getline(stream, line);) {
if (!line.empty() && line.back() == '\r') {
line.pop_back();
}
lines.push_back(std::move(line));
}
return lines;
}
void WriteLines(const std::filesystem::path& path,
const std::vector<std::string>& lines) {
std::ofstream stream{path, std::ios::trunc};
if (!stream) {
throw std::runtime_error{"Unable to write build-local fixture lines."};
}
for (const auto& line : lines) {
stream << line << '\n';
}
if (!stream) {
throw std::runtime_error{"Unable to finish build-local line write."};
}
}
void ReplaceFirst(std::string& contents, const std::string& from,
const std::string& to) {
const std::size_t position = contents.find(from);
if (position == std::string::npos) {
throw std::runtime_error{"Fixture token was not found: " + from};
}
contents.replace(position, from.size(), to);
}
ComparisonValues ReferenceValues() {
ComparisonValues values{};
const std::array<double, kNodeCount> uz = {
-1.0e-30, -2.761905780e-4, -1.066667140e-3, -2.314286540e-3,
-3.961906300e-3, -5.952383390e-3, -8.228574880e-3, -1.073333810e-2,
-1.340952890e-2, -1.620000600e-2, -1.904762720e-2};
const std::array<double, kNodeCount> ury = {
1.0e-29, 5.428573350e-4, 1.028571860e-3, 1.457143460e-3,
1.828572130e-3, 2.142857990e-3, 2.400001050e-3, 2.600000940e-3,
2.742858140e-3, 2.828572640e-3, 2.857143990e-3};
std::array<std::array<double, 4>, kNodeCount> stations{};
for (std::size_t node = 0U; node < kNodeCount; ++node) {
values.displacement[node][2U] = uz[node];
values.displacement[node][4U] = ury[node];
stations[node][2U] = node < kElementCount
? 1.0e7 - 1.0e6 * static_cast<double>(node)
: -1.56e-2;
}
values.reaction[0U][2U] = 1.0e6;
values.reaction[0U][4U] = -1.0e7;
for (std::size_t element = 0U; element < kElementCount; ++element) {
values.section_resultants[element][0U] = stations[element];
values.section_resultants[element][1U] = stations[element + 1U];
}
return values;
}
fesa::ModelDefinition MakeDefinition(const std::filesystem::path& input,
std::string source_content_identity) {
fesa::ModelDefinition definition{};
definition.source_path = input;
definition.source_content_identity = std::move(source_content_identity);
for (std::size_t node = 0U; node < kNodeCount; ++node) {
const auto label = static_cast<std::int64_t>(node + 1U);
definition.nodes.push_back({{kInstanceName, label, std::to_string(label)},
{static_cast<double>(node), 0.0, 0.0},
{input, node + 1U}});
}
definition.materials.push_back({"Material-1", 2.1e11, 0.3, {input, 20U}});
definition.sections.push_back({"Section-1",
1.0,
0.0833333,
0.0,
0.0833333,
0.140833,
{0.0, 1.0, 0.0},
{},
{input, 30U}});
for (std::size_t element = 0U; element < kElementCount; ++element) {
const auto label = static_cast<std::int64_t>(element + 1U);
definition.elements.push_back(
{{kInstanceName, label, std::to_string(label)},
{static_cast<fesa::EntityIndex>(element),
static_cast<fesa::EntityIndex>(element + 1U)},
0U,
0U,
{input, 40U + element}});
}
definition.steps.push_back(
{"Step-1", {}, {}, 1.0, 1.0, 1.0e-5, 1.0, {input, 60U}});
return definition;
}
void WriteResultsFixture(const std::filesystem::path& output,
const std::filesystem::path& input,
const ComparisonValues& values) {
auto parsed_input = fesa::AbaqusInputReader{}.Read(input);
if (!parsed_input.HasValue()) {
throw std::runtime_error{"Reference fixture input identity read failed."};
}
auto domain_result = fesa::Domain::Create(
MakeDefinition(input, parsed_input.Value().source_content_identity));
if (!domain_result.HasValue()) {
throw std::runtime_error{"Reference fixture Domain construction failed."};
}
fesa::Domain domain = std::move(domain_result.Value());
auto model_result = fesa::AnalysisModel::Create(domain);
if (!model_result.HasValue()) {
throw std::runtime_error{
"Reference fixture AnalysisModel construction failed."};
}
fesa::AnalysisModel model = std::move(model_result.Value());
auto dofs_result = fesa::DofManager::Create(model);
if (!dofs_result.HasValue()) {
throw std::runtime_error{
"Reference fixture DofManager construction failed."};
}
fesa::DofManager dofs = std::move(dofs_result.Value());
fesa::AnalysisState state = fesa::AnalysisState::Create(dofs, {"Step-1", 0U});
for (std::size_t node = 0U; node < kNodeCount; ++node) {
for (std::size_t component = 0U; component < 6U; ++component) {
const std::size_t index = node * 6U + component;
state.Displacement()[index] = values.displacement[node][component];
state.Reaction()[index] = values.reaction[node][component];
state.Residual()[index] = values.reaction[node][component];
}
}
for (std::size_t element = 0U; element < kElementCount; ++element) {
for (std::size_t endpoint = 0U; endpoint < 2U; ++endpoint) {
const std::size_t node = element + endpoint;
state.EndpointResults().push_back(
{static_cast<fesa::EntityIndex>(element),
static_cast<int>(endpoint),
domain.Nodes()[node].source_id,
{},
values.section_resultants[element][endpoint]});
}
state.GaussResults().push_back(
{static_cast<fesa::EntityIndex>(element), 1, {}, {}});
state.GaussResults().push_back(
{static_cast<fesa::EntityIndex>(element), 2, {}, {}});
state.StressResults().push_back({static_cast<fesa::EntityIndex>(element), 1,
0U, 0.0, 0.0, 0.0, "fesa-default"});
state.StressResults().push_back({static_cast<fesa::EntityIndex>(element), 2,
0U, 0.0, 0.0, 0.0, "fesa-default"});
}
fesa::Hdf5ResultsWriter writer;
const fesa::Status status = writer.Write(output, domain, state, {});
if (!status.IsOk()) {
throw std::runtime_error{"Reference fixture HDF5 write failed."};
}
}
class ContractFixture {
public:
ContractFixture(std::string label, const ComparisonValues& values) {
static std::atomic<std::uint64_t> sequence{0U};
root_ = BinaryRoot() / "reference" / "contract-fixtures" /
(std::move(label) + "-" + std::to_string(sequence.fetch_add(1U)));
legacy_ = root_ / "cantilever beam";
std::error_code error;
std::filesystem::remove_all(root_, error);
error.clear();
if (!std::filesystem::create_directories(legacy_, error) || error) {
throw std::runtime_error{"Unable to create contract fixture directory."};
}
const auto approved = SourceRoot() / "reference" / "cantilever beam";
for (const char* name :
{kInputName, kDisplacementName, kReactionName, kSectionName}) {
std::filesystem::copy_file(
approved / name, legacy_ / name,
std::filesystem::copy_options::overwrite_existing);
}
results_ = root_ / "results.h5";
WriteResultsFixture(results_, legacy_ / kInputName, values);
}
ContractFixture(const ContractFixture&) = delete;
ContractFixture& operator=(const ContractFixture&) = delete;
~ContractFixture() {
std::error_code ignored;
std::filesystem::remove_all(root_, ignored);
}
const std::filesystem::path& Root() const noexcept { return root_; }
const std::filesystem::path& Legacy() const noexcept { return legacy_; }
const std::filesystem::path& Results() const noexcept { return results_; }
private:
std::filesystem::path root_;
std::filesystem::path legacy_;
std::filesystem::path results_;
};
void ExpectFailureCode(const fesa::Result<fesa::test::ComparisonReport>& result,
const std::string& expected_code) {
ASSERT_FALSE(result.HasValue());
ASSERT_FALSE(result.GetStatus().IsOk());
ASSERT_FALSE(result.GetStatus().Diagnostics().empty());
EXPECT_EQ(result.GetStatus().Diagnostics().front().code, expected_code);
}
const fesa::test::RowDecision* FindRow(
const fesa::test::ComparisonReport& report,
const fesa::test::ComparisonQuantity quantity,
const std::int64_t source_node_label, const std::string& component) {
const auto found = std::find_if(report.rows.begin(), report.rows.end(),
[&](const fesa::test::RowDecision& row) {
return row.reference.quantity == quantity &&
row.reference.source_node_label ==
source_node_label &&
row.reference.component == component;
});
return found == report.rows.end() ? nullptr : &*found;
}
const fesa::test::ComponentMetrics* FindMetric(
const fesa::test::ComparisonReport& report,
const std::string& family_identity) {
const auto found =
std::find_if(report.metrics.begin(), report.metrics.end(),
[&](const fesa::test::ComponentMetrics& metric) {
return metric.family_identity == family_identity;
});
return found == report.metrics.end() ? nullptr : &*found;
}
const fesa::test::RowDecision* FindSectionRow(
const fesa::test::ComparisonReport& report,
const std::int64_t source_element_label, const int endpoint_index,
const std::string& component) {
const auto found = std::find_if(
report.rows.begin(), report.rows.end(),
[&](const fesa::test::RowDecision& row) {
return row.reference.quantity ==
fesa::test::ComparisonQuantity::kSectionResultant &&
row.reference.source_element_label == source_element_label &&
row.reference.endpoint_index == endpoint_index &&
row.reference.component == component;
});
return found == report.rows.end() ? nullptr : &*found;
}
void ExpectExactRowInventory(const fesa::test::ComparisonReport& report) {
ASSERT_EQ(report.rows.size(), kExpectedRowCount);
std::size_t row_index = 0U;
const auto expect_row = [&](const fesa::test::ComparisonQuantity quantity,
const std::size_t node,
const std::string& component,
const std::string& unit,
const std::string& coordinate_system,
const std::string& dataset_path) {
ASSERT_LT(row_index, report.rows.size());
const auto& row = report.rows[row_index++];
for (const auto* side : {&row.fesa, &row.reference}) {
EXPECT_EQ(side->model_id, "cantilever-beam-b33");
EXPECT_EQ(side->step_name, "Step-1");
EXPECT_EQ(side->frame_index, 0U);
EXPECT_EQ(side->instance_name, kInstanceName);
EXPECT_EQ(side->source_node_label, static_cast<std::int64_t>(node + 1U));
EXPECT_EQ(side->quantity, quantity);
EXPECT_EQ(side->component, component);
EXPECT_EQ(side->unit_dimension, unit);
EXPECT_EQ(side->coordinate_system, coordinate_system);
EXPECT_EQ(side->hdf5_dataset_path, dataset_path);
}
};
const std::array<std::string, 6> displacement_components = {
"UX", "UY", "UZ", "URX", "URY", "URZ"};
const std::array<std::string, 6> displacement_units = {
"length", "length", "length", "radian", "radian", "radian"};
for (std::size_t node = 0U; node < kNodeCount; ++node) {
for (std::size_t component = 0U; component < displacement_components.size();
++component) {
expect_row(fesa::test::ComparisonQuantity::kDisplacement, node,
displacement_components[component],
displacement_units[component], "global-cartesian",
"/steps/Step-1/frames/0/nodal/displacement");
}
}
const std::array<std::string, 6> reaction_components = {"RF1", "RF2", "RF3",
"RM1", "RM2", "RM3"};
const std::array<std::string, 6> reaction_units = {
"force", "force", "force",
"force*length", "force*length", "force*length"};
for (std::size_t node = 0U; node < kNodeCount; ++node) {
for (std::size_t component = 0U; component < reaction_components.size();
++component) {
expect_row(fesa::test::ComparisonQuantity::kReaction, node,
reaction_components[component], reaction_units[component],
"global-cartesian", "/steps/Step-1/frames/0/nodal/reaction");
}
}
const std::array<std::string, 4> section_components = {"N", "T", "My", "Mz"};
const std::array<std::string, 4> section_units = {
"force", "force*length", "force*length", "force*length"};
for (std::size_t element = 0U; element < kElementCount; ++element) {
for (std::size_t endpoint = 0U; endpoint < 2U; ++endpoint) {
for (std::size_t component = 0U; component < section_components.size();
++component) {
ASSERT_LT(row_index, report.rows.size());
const auto& row = report.rows[row_index++];
for (const auto* side : {&row.fesa, &row.reference}) {
EXPECT_EQ(side->source_element_label,
static_cast<std::int64_t>(element + 1U));
EXPECT_EQ(side->endpoint_index, static_cast<int>(endpoint));
EXPECT_EQ(side->source_node_label,
static_cast<std::int64_t>(element + endpoint + 1U));
EXPECT_EQ(side->component, section_components[component]);
EXPECT_EQ(side->unit_dimension, section_units[component]);
EXPECT_EQ(side->coordinate_system, "beam-local");
EXPECT_EQ(side->hdf5_dataset_path,
"/steps/Step-1/frames/0/element/section_resultant");
}
}
}
}
EXPECT_EQ(row_index, report.rows.size());
}
} // namespace
TEST(ReferenceComparisonContract,
PrecheckRejectsMissingSchemaDuplicateAndNonfiniteRows) {
auto mismatched_values = ReferenceValues();
mismatched_values.displacement[0U][0U] = 1.0;
{
ContractFixture fixture{"missing-file", mismatched_values};
ASSERT_TRUE(std::filesystem::remove(fixture.Legacy() / kDisplacementName));
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"needs-reference-artifacts");
}
{
ContractFixture fixture{"b31", mismatched_values};
auto input = ReadBytes(fixture.Legacy() / kInputName);
ReplaceFirst(input, "type=B33", "type=B31");
WriteBytes(fixture.Legacy() / kInputName, input);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"needs-reference-artifacts");
}
{
ContractFixture fixture{"header", mismatched_values};
auto csv = ReadBytes(fixture.Legacy() / kDisplacementName);
ReplaceFirst(csv, "U-U1", "U1");
WriteBytes(fixture.Legacy() / kDisplacementName, csv);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"schema-mismatch");
}
{
ContractFixture fixture{"missing-row", mismatched_values};
auto lines = ReadLines(fixture.Legacy() / kDisplacementName);
ASSERT_EQ(lines.size(), kNodeCount + 1U);
lines.pop_back();
WriteLines(fixture.Legacy() / kDisplacementName, lines);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"schema-mismatch");
}
{
ContractFixture fixture{"extra-row", mismatched_values};
auto lines = ReadLines(fixture.Legacy() / kDisplacementName);
ASSERT_EQ(lines.size(), kNodeCount + 1U);
std::string extra = lines.back();
ReplaceFirst(extra, ",PART-1_1-1,11,", ",PART-1_1-1,12,");
lines.push_back(std::move(extra));
WriteLines(fixture.Legacy() / kDisplacementName, lines);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"schema-mismatch");
}
{
ContractFixture fixture{"duplicate-row", mismatched_values};
auto lines = ReadLines(fixture.Legacy() / kReactionName);
ASSERT_EQ(lines.size(), kNodeCount + 1U);
lines.push_back(lines[1U]);
WriteLines(fixture.Legacy() / kReactionName, lines);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"schema-mismatch");
}
{
ContractFixture fixture{"nonfinite-row", mismatched_values};
auto csv = ReadBytes(fixture.Legacy() / kReactionName);
ReplaceFirst(csv, "0.000000000E+00", "NaN");
WriteBytes(fixture.Legacy() / kReactionName, csv);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"schema-mismatch");
}
{
ContractFixture fixture{"identity", mismatched_values};
auto csv = ReadBytes(fixture.Legacy() / kSectionName);
ReplaceFirst(csv, "PART-1_1-1", "WRONG-INSTANCE");
WriteBytes(fixture.Legacy() / kSectionName, csv);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"schema-mismatch");
}
{
ContractFixture fixture{"section-missing-endpoint", mismatched_values};
auto lines = ReadLines(fixture.Legacy() / kSectionName);
ASSERT_EQ(lines.size(), kElementCount * 2U + 1U);
lines.pop_back();
WriteLines(fixture.Legacy() / kSectionName, lines);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"schema-mismatch");
}
{
ContractFixture fixture{"section-duplicate-endpoint", mismatched_values};
auto lines = ReadLines(fixture.Legacy() / kSectionName);
ASSERT_EQ(lines.size(), kElementCount * 2U + 1U);
lines.push_back(lines[1U]);
WriteLines(fixture.Legacy() / kSectionName, lines);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"schema-mismatch");
}
{
ContractFixture fixture{"section-mismatched-endpoint", mismatched_values};
auto lines = ReadLines(fixture.Legacy() / kSectionName);
ASSERT_GT(lines.size(), 2U);
ReplaceFirst(lines[1U], ",1,1,", ",1,3,");
WriteLines(fixture.Legacy() / kSectionName, lines);
ExpectFailureCode(fesa::test::ReferenceComparison::Compare(
fixture.Results(), fixture.Legacy()),
"schema-mismatch");
}
}
TEST(ReferenceComparisonContract,
AppliesSharedFamilyScaleAndNearZeroBranchesWithoutAnAbsoluteGate) {
auto values = ReferenceValues();
const double translation_scale = 1.90476272e-2;
const double near_zero_band = 0.01 * translation_scale;
values.displacement[1U][0U] = 0.999 * near_zero_band;
values.displacement[2U][0U] = 1.001 * near_zero_band;
values.section_resultants[0U][0U][2U] = 1.0e7 + 4.999e5;
values.section_resultants[9U][1U][2U] = 0.0;
ContractFixture fixture{"tolerance", values};
auto result = fesa::test::ReferenceComparison::Compare(fixture.Results(),
fixture.Legacy());
ASSERT_TRUE(result.HasValue());
const auto& report = result.Value();
EXPECT_FALSE(report.passed);
EXPECT_EQ(report.rows.size(), kExpectedRowCount);
EXPECT_EQ(report.metrics.size(), kExpectedMetricCount);
const auto* zero =
FindRow(report, fesa::test::ComparisonQuantity::kDisplacement, 1, "UX");
const auto* near_zero =
FindRow(report, fesa::test::ComparisonQuantity::kDisplacement, 2, "UX");
const auto* deliberate_failure =
FindRow(report, fesa::test::ComparisonQuantity::kDisplacement, 3, "UX");
ASSERT_NE(zero, nullptr);
ASSERT_NE(near_zero, nullptr);
ASSERT_NE(deliberate_failure, nullptr);
EXPECT_DOUBLE_EQ(zero->reference.value, 0.0);
EXPECT_DOUBLE_EQ(zero->fesa.value, 0.0);
EXPECT_DOUBLE_EQ(zero->tolerance, near_zero_band);
EXPECT_TRUE(zero->passed);
EXPECT_TRUE(near_zero->passed);
EXPECT_FALSE(deliberate_failure->passed);
EXPECT_EQ(near_zero->tolerance_branch, "near-zero");
EXPECT_FALSE(near_zero->relative_error_applicable);
const auto* my_metric = FindMetric(report, "section-moment");
ASSERT_NE(my_metric, nullptr);
EXPECT_DOUBLE_EQ(my_metric->reference_scale, 1.0e7);
EXPECT_EQ(my_metric->components, (std::vector<std::string>{"T", "My", "Mz"}));
const auto* scaled = FindSectionRow(report, 1, 0, "My");
const auto* residue = FindSectionRow(report, 10, 1, "My");
ASSERT_NE(scaled, nullptr);
ASSERT_NE(residue, nullptr);
EXPECT_DOUBLE_EQ(scaled->tolerance, 5.0e5);
EXPECT_DOUBLE_EQ(scaled->absolute_error, 4.999e5);
EXPECT_TRUE(scaled->passed);
EXPECT_DOUBLE_EQ(residue->reference.value, -1.5625e-2);
EXPECT_DOUBLE_EQ(residue->fesa.value, 0.0);
EXPECT_DOUBLE_EQ(residue->absolute_error, 1.5625e-2);
EXPECT_DOUBLE_EQ(residue->tolerance, 1.0e5);
EXPECT_TRUE(residue->passed);
}
TEST(ReferenceComparisonContract,
ReportsEveryRowAndAggregateMetricDeterministically) {
auto values = ReferenceValues();
values.displacement[0U][0U] = 0.5e-9;
values.displacement[1U][0U] = -1.0e-9;
ContractFixture fixture{"metrics", values};
auto result = fesa::test::ReferenceComparison::Compare(fixture.Results(),
fixture.Legacy());
ASSERT_TRUE(result.HasValue());
const auto& report = result.Value();
ASSERT_TRUE(report.passed);
ExpectExactRowInventory(report);
ASSERT_EQ(report.metrics.size(), kExpectedMetricCount);
EXPECT_TRUE(std::all_of(
report.rows.begin(), report.rows.end(),
[](const fesa::test::RowDecision& row) { return row.passed; }));
const auto* metric = FindMetric(report, "displacement-translation");
const auto* worst =
FindRow(report, fesa::test::ComparisonQuantity::kDisplacement, 2, "UX");
ASSERT_NE(metric, nullptr);
ASSERT_NE(worst, nullptr);
EXPECT_EQ(metric->row_count, kNodeCount * 3U);
EXPECT_DOUBLE_EQ(metric->reference_scale, 1.90476272e-2);
EXPECT_DOUBLE_EQ(metric->maximum_absolute_error, 1.0e-9);
EXPECT_NEAR(metric->relative_rms,
std::sqrt(1.25 / static_cast<double>(kNodeCount * 3U)) * 1.0e-9 /
metric->reference_scale,
1.0e-21);
EXPECT_EQ(metric->worst_row,
static_cast<std::size_t>(worst - report.rows.data()));
EXPECT_FALSE(report.stress_comparison_applicable);
EXPECT_NE(report.stress_comparison_reason.find("N/A"), std::string::npos);
EXPECT_NE(report.stress_comparison_reason.find("HDF5"), std::string::npos);
EXPECT_DOUBLE_EQ(report.physics_evidence.free_residual_norm, 0.0);
EXPECT_EQ(report.physics_evidence.applied_force,
(std::array<double, 3>{0.0, 0.0, -1.0e6}));
EXPECT_EQ(report.physics_evidence.reaction_force,
(std::array<double, 3>{0.0, 0.0, 1.0e6}));
EXPECT_EQ(report.physics_evidence.applied_moment_about_origin,
(std::array<double, 3>{0.0, 1.0e7, 0.0}));
EXPECT_EQ(report.physics_evidence.reaction_moment_about_origin,
(std::array<double, 3>{0.0, -1.0e7, 0.0}));
EXPECT_TRUE(report.physics_evidence.endpoint_consistency_passed);
const auto json_a = fixture.Root() / "comparison-a.json";
const auto json_b = fixture.Root() / "comparison-b.json";
ASSERT_TRUE(
fesa::test::ReferenceComparison::WriteDeterministicJson(report, json_a)
.IsOk());
ASSERT_TRUE(
fesa::test::ReferenceComparison::WriteDeterministicJson(report, json_b)
.IsOk());
const std::string first = ReadBytes(json_a);
EXPECT_EQ(first, ReadBytes(json_b));
for (const char* required :
{"\"rows\"", "\"metrics\"", "\"family_identity\"", "\"components\"",
"\"near_zero_band\"", "\"relative_rms\"", "\"row_count\"",
"\"tolerance_branch\"", "\"relative_error_applicable\"",
"\"stress_comparison_applicable\":false",
"\"stress_comparison_reason\"", "\"physics_evidence\"",
"\"free_residual_norm\"", "\"applied_force\"", "\"reaction_force\"",
"\"applied_moment_about_origin\"", "\"reaction_moment_about_origin\"",
"\"endpoint_consistency_passed\""}) {
EXPECT_NE(first.find(required), std::string::npos) << required;
}
}
TEST(ReferenceComparisonContract,
PreservesSectionEndpointIdentityWithoutStationNormalization) {
auto values = ReferenceValues();
values.section_resultants[0U][1U][2U] = 9.0e6 - 5.0;
ContractFixture fixture{"stations", values};
auto result = fesa::test::ReferenceComparison::Compare(fixture.Results(),
fixture.Legacy());
ASSERT_TRUE(result.HasValue());
const auto& report = result.Value();
ASSERT_TRUE(report.passed);
EXPECT_TRUE(report.physics_evidence.endpoint_consistency_passed);
const auto* interior = FindSectionRow(report, 1, 1, "My");
ASSERT_NE(interior, nullptr);
EXPECT_DOUBLE_EQ(interior->fesa.value, 9.0e6 - 5.0);
EXPECT_DOUBLE_EQ(interior->reference.value, 9.0e6);
EXPECT_DOUBLE_EQ(interior->absolute_error, 5.0);
const auto* adjacent = FindSectionRow(report, 2, 0, "My");
ASSERT_NE(adjacent, nullptr);
EXPECT_DOUBLE_EQ(adjacent->fesa.value, 9.0e6);
EXPECT_DOUBLE_EQ(adjacent->reference.value, 9.0e6);
}
TEST(ReferenceComparisonContract,
MapsEachSectionCsvComponentToItsDirectEndpointResultant) {
auto values = ReferenceValues();
values.section_resultants[0U][0U] = {11.0, 22.0, 33.0, 44.0};
ContractFixture fixture{"section-component-mapping", values};
auto lines = ReadLines(fixture.Legacy() / kSectionName);
ASSERT_EQ(lines.size(), kElementCount * 2U + 1U);
lines[1U] = "Increment 1: Step Time = 1.000,PART-1_1-1,1,1,11,33,44,22";
WriteLines(fixture.Legacy() / kSectionName, lines);
auto result = fesa::test::ReferenceComparison::Compare(fixture.Results(),
fixture.Legacy());
ASSERT_TRUE(result.HasValue());
const auto& report = result.Value();
ASSERT_TRUE(report.passed);
const auto* n = FindSectionRow(report, 1, 0, "N");
const auto* t = FindSectionRow(report, 1, 0, "T");
const auto* my = FindSectionRow(report, 1, 0, "My");
const auto* mz = FindSectionRow(report, 1, 0, "Mz");
ASSERT_NE(n, nullptr);
ASSERT_NE(t, nullptr);
ASSERT_NE(my, nullptr);
ASSERT_NE(mz, nullptr);
EXPECT_DOUBLE_EQ(n->reference.value, 11.0);
EXPECT_DOUBLE_EQ(t->reference.value, 22.0);
EXPECT_DOUBLE_EQ(my->reference.value, 33.0);
EXPECT_DOUBLE_EQ(mz->reference.value, 44.0);
EXPECT_DOUBLE_EQ(n->fesa.value, 11.0);
EXPECT_DOUBLE_EQ(t->fesa.value, 22.0);
EXPECT_DOUBLE_EQ(my->fesa.value, 33.0);
EXPECT_DOUBLE_EQ(mz->fesa.value, 44.0);
}
Reference in New Issue View Git Blame Copy Permalink