KOKO\Mimi
573 lines
19 KiB
C++
573 lines
19 KiB
C++
#include <fesa/model/domain_builder.hpp>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <limits>
|
|
#include <string_view>
|
|
#include <utility>
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
namespace {
|
|
|
|
fesa::Node first_node() {
|
|
return {
|
|
fesa::NodeId{0},
|
|
fesa::EntityOrigin{"BeamPart", "Beam-1", 1},
|
|
fesa::Vec3{0.0, 0.0, 0.0},
|
|
};
|
|
}
|
|
|
|
fesa::Node second_node() {
|
|
return {
|
|
fesa::NodeId{1},
|
|
fesa::EntityOrigin{"BeamPart", "Beam-1", 2},
|
|
fesa::Vec3{2.0, 0.0, 0.0},
|
|
};
|
|
}
|
|
|
|
fesa::IsotropicElastic valid_material() {
|
|
return {
|
|
fesa::MaterialId{0},
|
|
"Steel",
|
|
210.0e9,
|
|
0.3,
|
|
};
|
|
}
|
|
|
|
fesa::BeamSection valid_section() {
|
|
return {
|
|
fesa::SectionId{0},
|
|
"General",
|
|
0.04,
|
|
1.2e-4,
|
|
1.4e-4,
|
|
2.0e-4,
|
|
0.03,
|
|
0.031,
|
|
fesa::ShearPropertySource::input,
|
|
fesa::Vec3{0.0, 1.0, 0.0},
|
|
{{-0.1, 0.0}, {0.1, 0.0}},
|
|
};
|
|
}
|
|
|
|
fesa::BeamElement valid_element() {
|
|
return {
|
|
fesa::ElementId{0},
|
|
fesa::EntityOrigin{"BeamPart", "Beam-1", 1},
|
|
{fesa::NodeId{0}, fesa::NodeId{1}},
|
|
fesa::MaterialId{0},
|
|
fesa::SectionId{0},
|
|
};
|
|
}
|
|
|
|
fesa::StepDefinition valid_step() {
|
|
return {
|
|
"Load",
|
|
{{fesa::NodeId{0}, 1, 0.0}},
|
|
{{fesa::NodeId{1}, {0.0, -100.0, 0.0, 0.0, 0.0, 0.0}}},
|
|
};
|
|
}
|
|
|
|
fesa::DomainBuilder make_builder(
|
|
fesa::IsotropicElastic material,
|
|
fesa::BeamSection section,
|
|
fesa::BeamElement element,
|
|
fesa::StepDefinition step) {
|
|
fesa::DomainBuilder builder;
|
|
builder.add_node(first_node());
|
|
builder.add_node(second_node());
|
|
builder.add_material(std::move(material));
|
|
builder.add_section(std::move(section));
|
|
builder.add_beam_element(std::move(element));
|
|
builder.add_node_set({"Fixed", {fesa::NodeId{0}}});
|
|
builder.add_element_set({"Beam", {fesa::ElementId{0}}});
|
|
builder.set_step(std::move(step));
|
|
return builder;
|
|
}
|
|
|
|
fesa::DomainBuilder make_valid_builder() {
|
|
return make_builder(
|
|
valid_material(), valid_section(), valid_element(), valid_step());
|
|
}
|
|
|
|
bool has_diagnostic(
|
|
const fesa::DomainBuildResult& result,
|
|
const std::string_view code) {
|
|
return std::ranges::any_of(
|
|
result.diagnostics,
|
|
[code](const fesa::Diagnostic& diagnostic) {
|
|
return diagnostic.code == code;
|
|
});
|
|
}
|
|
|
|
std::size_t diagnostic_count(
|
|
const fesa::DomainBuildResult& result,
|
|
const std::string_view code) {
|
|
return static_cast<std::size_t>(std::ranges::count_if(
|
|
result.diagnostics,
|
|
[code](const fesa::Diagnostic& diagnostic) {
|
|
return diagnostic.code == code;
|
|
}));
|
|
}
|
|
|
|
TEST(DomainBuilder, BuildsImmutableDomainAndDenseNodeLookups) {
|
|
auto result = std::move(make_valid_builder()).build();
|
|
|
|
ASSERT_TRUE(result.domain.has_value());
|
|
EXPECT_TRUE(result.diagnostics.empty());
|
|
|
|
const fesa::Domain& domain = *result.domain;
|
|
ASSERT_EQ(domain.nodes().size(), 2);
|
|
ASSERT_EQ(domain.beam_elements().size(), 1);
|
|
ASSERT_EQ(domain.materials().size(), 1);
|
|
ASSERT_EQ(domain.sections().size(), 1);
|
|
ASSERT_EQ(domain.node_sets().size(), 1);
|
|
ASSERT_EQ(domain.element_sets().size(), 1);
|
|
EXPECT_EQ(domain.step().name, "Load");
|
|
EXPECT_EQ(&domain.node(fesa::NodeId{1}), &domain.nodes()[1]);
|
|
EXPECT_EQ(
|
|
&domain.node(fesa::EntityOrigin{"BeamPart", "Beam-1", 2}),
|
|
&domain.nodes()[1]);
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsDuplicateInternalId) {
|
|
auto builder = make_valid_builder();
|
|
builder.add_node({
|
|
fesa::NodeId{1},
|
|
fesa::EntityOrigin{"BeamPart", "Beam-1", 3},
|
|
fesa::Vec3{3.0, 0.0, 0.0},
|
|
});
|
|
|
|
const auto result = std::move(builder).build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.duplicate_node_id"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsDuplicateMaterialId) {
|
|
auto builder = make_valid_builder();
|
|
auto material = valid_material();
|
|
material.name = "Duplicate";
|
|
builder.add_material(std::move(material));
|
|
|
|
const auto result = std::move(builder).build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.duplicate_material_id"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsDuplicateSectionId) {
|
|
auto builder = make_valid_builder();
|
|
auto section = valid_section();
|
|
section.name = "Duplicate";
|
|
builder.add_section(std::move(section));
|
|
|
|
const auto result = std::move(builder).build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.duplicate_section_id"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsDuplicateElementId) {
|
|
auto builder = make_valid_builder();
|
|
auto element = valid_element();
|
|
element.origin.local_label = 2;
|
|
builder.add_beam_element(std::move(element));
|
|
|
|
const auto result = std::move(builder).build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.duplicate_element_id"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsDuplicateOriginWithinEntityKind) {
|
|
auto builder = make_valid_builder();
|
|
builder.add_node({
|
|
fesa::NodeId{2},
|
|
fesa::EntityOrigin{"OtherPart", "Beam-1", 2},
|
|
fesa::Vec3{3.0, 0.0, 0.0},
|
|
});
|
|
|
|
const auto result = std::move(builder).build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.duplicate_node_origin"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsDuplicateElementOriginWithinEntityKind) {
|
|
auto builder = make_valid_builder();
|
|
auto element = valid_element();
|
|
element.id = fesa::ElementId{1};
|
|
element.origin.part_name = "OtherPart";
|
|
builder.add_beam_element(std::move(element));
|
|
|
|
const auto result = std::move(builder).build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.duplicate_element_origin"));
|
|
}
|
|
|
|
TEST(DomainValidation, CollectsMissingReferencesAcrossSemanticEntities) {
|
|
auto builder = make_valid_builder();
|
|
builder.add_beam_element({
|
|
fesa::ElementId{1},
|
|
fesa::EntityOrigin{"BeamPart", "Beam-1", 2},
|
|
{fesa::NodeId{90}, fesa::NodeId{91}},
|
|
fesa::MaterialId{92},
|
|
fesa::SectionId{93},
|
|
});
|
|
builder.add_node_set({"MissingNodes", {fesa::NodeId{94}}});
|
|
builder.add_element_set({"MissingElements", {fesa::ElementId{95}}});
|
|
builder.set_step({
|
|
"Load",
|
|
{{fesa::NodeId{96}, 1, 0.0}},
|
|
{{fesa::NodeId{97}, {1.0, 0.0, 0.0, 0.0, 0.0, 0.0}}},
|
|
});
|
|
|
|
const auto result = std::move(builder).build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.missing_node_reference"));
|
|
EXPECT_TRUE(has_diagnostic(result, "model.missing_material_reference"));
|
|
EXPECT_TRUE(has_diagnostic(result, "model.missing_section_reference"));
|
|
EXPECT_TRUE(has_diagnostic(result, "model.missing_element_reference"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsNonpositiveYoungsModulus) {
|
|
auto material = valid_material();
|
|
material.young = 0.0;
|
|
|
|
const auto result = std::move(make_builder(
|
|
material,
|
|
valid_section(),
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.invalid_material"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsPoissonRatioOutsideOpenPhysicalRange) {
|
|
for (const double poisson : {-1.0, 0.5}) {
|
|
auto material = valid_material();
|
|
material.poisson = poisson;
|
|
|
|
const auto result = std::move(make_builder(
|
|
material,
|
|
valid_section(),
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value()) << "poisson=" << poisson;
|
|
EXPECT_TRUE(has_diagnostic(result, "model.invalid_material"))
|
|
<< "poisson=" << poisson;
|
|
}
|
|
}
|
|
|
|
struct InvalidSectionProperty final {
|
|
const char* name;
|
|
double fesa::BeamSection::*member;
|
|
};
|
|
|
|
class DomainValidationInvalidSection
|
|
: public testing::TestWithParam<InvalidSectionProperty> {};
|
|
|
|
TEST_P(DomainValidationInvalidSection, RejectsNonpositiveProperty) {
|
|
auto section = valid_section();
|
|
section.*(GetParam().member) = 0.0;
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
section,
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.invalid_section"));
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
SectionProperties,
|
|
DomainValidationInvalidSection,
|
|
testing::Values(
|
|
InvalidSectionProperty{"Area", &fesa::BeamSection::area},
|
|
InvalidSectionProperty{"Iy", &fesa::BeamSection::iy},
|
|
InvalidSectionProperty{"Iz", &fesa::BeamSection::iz},
|
|
InvalidSectionProperty{"TorsionJ", &fesa::BeamSection::torsion_j},
|
|
InvalidSectionProperty{
|
|
"ShearAreaY", &fesa::BeamSection::shear_area_y},
|
|
InvalidSectionProperty{
|
|
"ShearAreaZ", &fesa::BeamSection::shear_area_z}),
|
|
[](const testing::TestParamInfo<InvalidSectionProperty>& info) {
|
|
return info.param.name;
|
|
});
|
|
|
|
TEST(DomainValidation, RejectsNonfiniteNodeCoordinate) {
|
|
const double nan = std::numeric_limits<double>::quiet_NaN();
|
|
auto builder = make_valid_builder();
|
|
builder.add_node({
|
|
fesa::NodeId{2},
|
|
fesa::EntityOrigin{"BeamPart", "Beam-1", 3},
|
|
fesa::Vec3{nan, 0.0, 0.0},
|
|
});
|
|
|
|
const auto result = std::move(builder).build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsNonfiniteMaterialConstant) {
|
|
auto material = valid_material();
|
|
material.young = std::numeric_limits<double>::infinity();
|
|
|
|
const auto result = std::move(make_builder(
|
|
material,
|
|
valid_section(),
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsNonfinitePoissonRatio) {
|
|
auto material = valid_material();
|
|
material.poisson = std::numeric_limits<double>::quiet_NaN();
|
|
|
|
const auto result = std::move(make_builder(
|
|
material,
|
|
valid_section(),
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsNonfiniteSectionProperty) {
|
|
auto section = valid_section();
|
|
section.area = std::numeric_limits<double>::infinity();
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
section,
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsNonfiniteSectionOrientation) {
|
|
auto section = valid_section();
|
|
section.orientation.y = std::numeric_limits<double>::quiet_NaN();
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
section,
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsNonfiniteRecoveryPoint) {
|
|
auto section = valid_section();
|
|
const double nan = std::numeric_limits<double>::quiet_NaN();
|
|
section.recovery_points = {{nan, 0.0}};
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
section,
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsNonfinitePrescribedValue) {
|
|
auto step = valid_step();
|
|
step.prescribed_dofs[0].value =
|
|
std::numeric_limits<double>::infinity();
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
valid_section(),
|
|
valid_element(),
|
|
step))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsNonfiniteLoadComponent) {
|
|
auto step = valid_step();
|
|
step.nodal_loads[0].values[0] =
|
|
std::numeric_limits<double>::quiet_NaN();
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
valid_section(),
|
|
valid_element(),
|
|
step))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
}
|
|
|
|
TEST(DomainValidation, CollectsIndependentMaterialPropertyDiagnostics) {
|
|
auto material = valid_material();
|
|
material.young = std::numeric_limits<double>::quiet_NaN();
|
|
material.poisson = 0.5;
|
|
|
|
const auto result = std::move(make_builder(
|
|
material,
|
|
valid_section(),
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
EXPECT_TRUE(has_diagnostic(result, "model.invalid_material"));
|
|
}
|
|
|
|
TEST(DomainValidation, CollectsIndependentSectionPropertyDiagnostics) {
|
|
auto section = valid_section();
|
|
section.area = -1.0;
|
|
section.iy = std::numeric_limits<double>::quiet_NaN();
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
section,
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.nonfinite_value"));
|
|
EXPECT_TRUE(has_diagnostic(result, "model.invalid_section"));
|
|
}
|
|
|
|
TEST(DomainValidation, CollectsNonfiniteStepValuesIndependently) {
|
|
const double nan = std::numeric_limits<double>::quiet_NaN();
|
|
const double infinity = std::numeric_limits<double>::infinity();
|
|
auto step = fesa::StepDefinition{
|
|
"Load",
|
|
{{fesa::NodeId{0}, 1, infinity}},
|
|
{{fesa::NodeId{1}, {nan, 0.0, 0.0, 0.0, 0.0, 0.0}}},
|
|
};
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
valid_section(),
|
|
valid_element(),
|
|
step))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_EQ(diagnostic_count(result, "model.nonfinite_value"), 2);
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsZeroLengthElement) {
|
|
auto element = valid_element();
|
|
element.nodes[1] = fesa::NodeId{0};
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
valid_section(),
|
|
element,
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.zero_length_element"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsZeroAndElementParallelOrientation) {
|
|
for (const fesa::Vec3 orientation :
|
|
{fesa::Vec3{0.0, 0.0, 0.0}, fesa::Vec3{1.0, 0.0, 0.0}}) {
|
|
auto section = valid_section();
|
|
section.orientation = orientation;
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
section,
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.invalid_orientation"));
|
|
}
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsElementWithoutMaterialAndSectionAssignments) {
|
|
auto element = valid_element();
|
|
element.material = fesa::MaterialId{8};
|
|
element.section = fesa::SectionId{9};
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
valid_section(),
|
|
element,
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.missing_material_reference"));
|
|
EXPECT_TRUE(has_diagnostic(result, "model.missing_section_reference"));
|
|
}
|
|
|
|
TEST(DomainValidation, RejectsConflictingBoundaryConditions) {
|
|
auto step = valid_step();
|
|
step.prescribed_dofs.push_back({fesa::NodeId{0}, 1, 0.25});
|
|
|
|
const auto result = std::move(make_builder(
|
|
valid_material(),
|
|
valid_section(),
|
|
valid_element(),
|
|
step))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(
|
|
has_diagnostic(result, "model.conflicting_boundary_condition"));
|
|
}
|
|
|
|
TEST(DomainValidation, CollectsIndependentDiagnosticsWithoutEarlyExit) {
|
|
auto material = valid_material();
|
|
material.young = -1.0;
|
|
auto section = valid_section();
|
|
section.area = -1.0;
|
|
section.orientation = fesa::Vec3{1.0, 0.0, 0.0};
|
|
|
|
const auto result = std::move(make_builder(
|
|
material,
|
|
section,
|
|
valid_element(),
|
|
valid_step()))
|
|
.build();
|
|
|
|
EXPECT_FALSE(result.domain.has_value());
|
|
EXPECT_TRUE(has_diagnostic(result, "model.invalid_material"));
|
|
EXPECT_TRUE(has_diagnostic(result, "model.invalid_section"));
|
|
EXPECT_TRUE(has_diagnostic(result, "model.invalid_orientation"));
|
|
}
|
|
|
|
} // namespace
|