baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9ad72e6d21031f6239495419a7c4106d1672cc8f
FESADev/tests/unit/model/domain_test.cpp
T

367 lines
16 KiB
C++
Raw Blame History

#include "fesa/model/domain.h"
#include <gtest/gtest.h>
#include <filesystem>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include "fesa/elements/element_definition.h"
namespace {
fesa::ModelDefinition MakeOwnedDefinition() {
fesa::ModelDefinition definition{};
definition.source_path = "models/owned.inp";
definition.source_content_identity = "fnv1a64:fedcba9876543210";
definition.heading = "Stable declaration order";
definition.nodes = {
{{"Instance-A", 20, "0020"}, {2.0, 0.0, 0.0}, {"models/owned.inp", 12U}},
{{"Instance-A", 10, "0010"}, {1.0, 0.0, 0.0}, {"models/owned.inp", 11U}}};
definition.elements = {{{"Instance-A", 5, "0005"},
{fesa::EntityIndex{1}, fesa::EntityIndex{0}},
fesa::EntityIndex{0},
fesa::EntityIndex{0},
{"models/owned.inp", 20U}}};
definition.materials = {{"Steel", 210.0e9, 0.3, {"models/owned.inp", 30U}}};
definition.sections = {{"Section-1",
0.02,
1.0e-5,
0.0,
2.0e-5,
5.0e-6,
{0.0, 1.0, 0.0},
{{-0.1, 0.0}, {0.1, 0.0}},
{"models/owned.inp", 40U}}};
definition.node_sets = {
{"Tip", std::string{"Instance-A"}, {0U}, {"models/owned.inp", 45U}}};
definition.element_sets = {
{"Beam", std::string{"Instance-A"}, {0U}, {"models/owned.inp", 46U}}};
definition.parts = {
{"BeamPart", {20, 10}, {5}, {"Tip"}, {"Beam"}, {"models/owned.inp", 2U}}};
definition.instances = {{"Instance-A",
"BeamPart",
{{20, 0U}, {10, 1U}},
{{5, 0U}},
{"models/owned.inp", 50U}}};
definition.steps = {{"Step-1",
{{"Root", 1, 6, 0.0, {"models/owned.inp", 60U}}},
{{"Tip", 3, -1000.0, {"models/owned.inp", 61U}}},
0.1,
1.0,
1.0e-5,
1.0,
{"models/owned.inp", 55U}}};
definition.warnings = {{fesa::Severity::kWarning,
"ignored-output-request",
{"models/owned.inp", 70U},
"*OUTPUT",
"",
"Ignored output request."}};
return definition;
}
} // namespace
// C-MODEL-002
TEST(ElementDefinition, DomainOwnsMixedDefinitionsInStableBaseOrder) {
static_assert(std::has_virtual_destructor_v<fesa::ElementDefinition>);
static_assert(!std::is_copy_constructible_v<fesa::Domain>);
static_assert(!std::is_copy_assignable_v<fesa::Domain>);
static_assert(std::is_move_constructible_v<fesa::Domain>);
static_assert(std::is_move_assignable_v<fesa::Domain>);
fesa::ModelDefinition definition{};
definition.source_path = "models/mixed-owned.inp";
definition.source_content_identity = "fnv1a64:mixed";
definition.materials = {
{"Steel", 210.0e9, 0.3, {definition.source_path, 30U}}};
definition.sections = {{"BeamSection",
0.02,
1.0e-5,
0.0,
2.0e-5,
5.0e-6,
{0.0, 1.0, 0.0},
{},
{definition.source_path, 40U}}};
definition.shell_sections = {
{"ShellSection", 0.01, 0U, {definition.source_path, 41U}}};
definition.elements = {
{{"Beam-1", 7, "0007"}, {0U, 1U}, 0U, 0U, {definition.source_path, 20U}}};
definition.shell_elements = {{{"Shell-1", 9, "0009"},
fesa::ShellSourceElementType::kS4r,
{2U, 3U, 4U, 5U},
0U,
0U,
{definition.source_path, 21U}}};
auto result = fesa::Domain::Create(definition);
ASSERT_TRUE(result.HasValue());
fesa::Domain domain = std::move(result.Value());
static_assert(std::is_same_v<
decltype(std::declval<const fesa::Domain&>().Elements()[0U]),
const fesa::ElementDefinition&>);
static_assert(std::is_same_v<
decltype(std::declval<const fesa::Domain&>().Materials()[0U]),
const fesa::Material&>);
static_assert(std::is_same_v<
decltype(std::declval<const fesa::Domain&>().Properties()[0U]),
const fesa::ElementProperty&>);
ASSERT_EQ(domain.Elements().Size(), 2U);
const fesa::ElementDefinition& beam = domain.Elements()[0U];
EXPECT_EQ(beam.Kind(), fesa::ElementDefinitionKind::kEulerBeam3D);
EXPECT_EQ(beam.SourceId().source_label_text, "0007");
EXPECT_EQ(beam.SourceElementType(), "B33");
EXPECT_EQ(beam.NodeIndices(), (std::vector<fesa::EntityIndex>{0U, 1U}));
EXPECT_EQ(beam.MaterialIndex(), fesa::EntityIndex{0U});
EXPECT_EQ(beam.PropertyIndex(), fesa::EntityIndex{0U});
const fesa::ElementDefinition& shell = domain.Elements()[1U];
EXPECT_EQ(shell.Kind(), fesa::ElementDefinitionKind::kMitc4Shell);
EXPECT_EQ(shell.SourceId().source_label_text, "0009");
EXPECT_EQ(shell.SourceElementType(), "S4R");
EXPECT_EQ(shell.NodeIndices(),
(std::vector<fesa::EntityIndex>{2U, 3U, 4U, 5U}));
EXPECT_EQ(shell.MaterialIndex(), fesa::EntityIndex{0U});
EXPECT_EQ(shell.PropertyIndex(), fesa::EntityIndex{1U});
ASSERT_EQ(domain.BeamElements().Size(), 1U);
ASSERT_EQ(domain.ShellElements().Size(), 1U);
EXPECT_EQ(&domain.BeamElements()[0U], &beam);
EXPECT_EQ(&domain.ShellElements()[0U], &shell);
ASSERT_EQ(domain.Materials().Size(), 1U);
EXPECT_EQ(domain.Materials()[0U].Kind(),
fesa::MaterialKind::kIsotropicLinearElastic);
EXPECT_EQ(&domain.LinearElasticMaterials()[0U], &domain.Materials()[0U]);
ASSERT_EQ(domain.Properties().Size(), 2U);
EXPECT_EQ(domain.Properties()[0U].Kind(),
fesa::ElementPropertyKind::kGeneralBeamSection);
EXPECT_EQ(domain.Properties()[1U].Kind(),
fesa::ElementPropertyKind::kShellSection);
EXPECT_EQ(&domain.Sections()[0U], &domain.Properties()[0U]);
EXPECT_EQ(&domain.ShellSections()[0U], &domain.Properties()[1U]);
}
TEST(DomainModel, ImmutableOwnershipPreservesStableOrder) {
auto definition = MakeOwnedDefinition();
auto result = fesa::Domain::Create(definition);
ASSERT_TRUE(result.HasValue());
definition.source_path = "mutated.inp";
definition.source_content_identity = "mutated";
definition.nodes[0].source_id.source_label_text = "mutated";
definition.nodes[0].coordinates[0] = -99.0;
definition.sections[0].section_points[0][0] = -99.0;
definition.steps[0].loads[0].magnitude = 99.0;
definition.warnings[0].code = "mutated";
const fesa::Domain& domain = result.Value();
const fesa::Node* const first_node_address = domain.Nodes().data();
static_assert(
std::is_same_v<decltype(std::declval<const fesa::Domain&>().Nodes()),
const std::vector<fesa::Node>&>);
static_assert(std::is_same_v<
decltype(std::declval<const fesa::Domain&>().Elements()),
const fesa::DomainCollectionView<fesa::ElementDefinition>&>);
EXPECT_EQ(domain.SourcePath(), std::filesystem::path{"models/owned.inp"});
EXPECT_EQ(domain.SourceContentIdentity(), "fnv1a64:fedcba9876543210");
ASSERT_EQ(domain.Nodes().size(), 2U);
EXPECT_EQ(domain.Nodes()[0].source_id.source_label, 20);
EXPECT_EQ(domain.Nodes()[0].source_id.source_label_text, "0020");
EXPECT_DOUBLE_EQ(domain.Nodes()[0].coordinates[0], 2.0);
EXPECT_EQ(domain.Nodes()[1].source_id.source_label, 10);
EXPECT_EQ(domain.Nodes().data(), first_node_address);
ASSERT_EQ(domain.BeamElements().Size(), 1U);
EXPECT_EQ(domain.BeamElements()[0].node_indices[0], 1U);
EXPECT_EQ(domain.BeamElements()[0].node_indices[1], 0U);
ASSERT_EQ(domain.Materials().Size(), 1U);
ASSERT_EQ(domain.Sections().Size(), 1U);
EXPECT_DOUBLE_EQ(domain.Sections()[0].section_points[0][0], -0.1);
ASSERT_EQ(domain.NodeSets().size(), 1U);
EXPECT_EQ(domain.NodeSets()[0].node_indices[0], 0U);
ASSERT_EQ(domain.ElementSets().size(), 1U);
EXPECT_EQ(domain.ElementSets()[0].element_indices[0], 0U);
ASSERT_EQ(domain.Steps().Size(), 1U);
EXPECT_EQ(domain.Steps()[0].Name(), "Step-1");
EXPECT_DOUBLE_EQ(domain.Steps()[0].InitialIncrement(), 0.1);
EXPECT_DOUBLE_EQ(domain.Steps()[0].TimePeriod(), 1.0);
EXPECT_DOUBLE_EQ(domain.Steps()[0].MinimumIncrement(), 1.0e-5);
EXPECT_DOUBLE_EQ(domain.Steps()[0].MaximumIncrement(), 1.0);
ASSERT_EQ(domain.Steps()[0].Boundaries().size(), 1U);
ASSERT_EQ(domain.Steps()[0].Loads().size(), 1U);
ASSERT_EQ(domain.Steps()[0].ConcentratedLoads().Size(), 1U);
EXPECT_DOUBLE_EQ(
domain.Steps()[0].ConcentratedLoads()[0U].GlobalComponents()[2U],
-1000.0);
ASSERT_EQ(domain.Warnings().size(), 1U);
EXPECT_EQ(domain.Warnings()[0].code, "ignored-output-request");
}
TEST(DomainModel, MultipleIdentityInstancesDoNotMerge) {
fesa::ModelDefinition definition{};
definition.source_path = "models/two-instances.inp";
definition.source_content_identity = "fnv1a64:0011223344556677";
definition.nodes = {{{"Instance-A", 1, "1"},
{0.0, 0.0, 0.0},
{"models/two-instances.inp", 10U}},
{{"Instance-A", 2, "2"},
{1.0, 0.0, 0.0},
{"models/two-instances.inp", 11U}},
{{"Instance-B", 1, "1"},
{0.0, 0.0, 0.0},
{"models/two-instances.inp", 10U}},
{{"Instance-B", 2, "2"},
{1.0, 0.0, 0.0},
{"models/two-instances.inp", 11U}}};
definition.elements = {{{"Instance-A", 1, "1"},
{0U, 1U},
0U,
0U,
{"models/two-instances.inp", 20U}},
{{"Instance-B", 1, "1"},
{2U, 3U},
0U,
0U,
{"models/two-instances.inp", 20U}}};
definition.materials = {
{"Steel", 210.0e9, 0.3, {"models/two-instances.inp", 30U}}};
definition.sections = {{"Section-1",
0.02,
1.0e-5,
0.0,
2.0e-5,
5.0e-6,
{0.0, 1.0, 0.0},
{},
{"models/two-instances.inp", 40U}}};
definition.parts = {
{"BeamPart", {1, 2}, {1}, {}, {}, {"models/two-instances.inp", 2U}}};
definition.instances = {{"Instance-A",
"BeamPart",
{{1, 0U}, {2, 1U}},
{{1, 0U}},
{"models/two-instances.inp", 50U}},
{"Instance-B",
"BeamPart",
{{1, 2U}, {2, 3U}},
{{1, 1U}},
{"models/two-instances.inp", 51U}}};
definition.steps = {{"Step-1",
{},
{},
0.1,
1.0,
1.0e-5,
1.0,
{"models/two-instances.inp", 60U}}};
auto result = fesa::Domain::Create(std::move(definition));
ASSERT_TRUE(result.HasValue());
const fesa::Domain& domain = result.Value();
ASSERT_EQ(domain.Nodes().size(), 4U);
EXPECT_EQ(domain.Nodes()[0].source_id.source_label, 1);
EXPECT_EQ(domain.Nodes()[2].source_id.source_label, 1);
EXPECT_EQ(domain.Nodes()[0].source_id.source_label_text, "1");
EXPECT_EQ(domain.Nodes()[2].source_id.source_label_text, "1");
EXPECT_NE(domain.Nodes()[0].source_id.instance_name,
domain.Nodes()[2].source_id.instance_name);
ASSERT_EQ(domain.BeamElements().Size(), 2U);
EXPECT_EQ(domain.BeamElements()[0].source_id.source_label, 1);
EXPECT_EQ(domain.BeamElements()[1].source_id.source_label, 1);
EXPECT_EQ(domain.BeamElements()[0].source_id.instance_name, "Instance-A");
EXPECT_EQ(domain.BeamElements()[1].source_id.instance_name, "Instance-B");
EXPECT_EQ(domain.BeamElements()[0].node_indices[0], 0U);
EXPECT_EQ(domain.BeamElements()[1].node_indices[0], 2U);
}
// MITC4-MODEL-002
TEST(DomainModel, ShellOwnershipPreservesResolvedAssignmentsAndOptionalFrames) {
fesa::ModelDefinition definition{};
definition.source_path = "models/shell-owned.inp";
definition.source_content_identity = "fnv1a64:1234567890abcdef";
definition.materials = {
{"Material-B", 70.0e9, 0.33, {"models/shell-owned.inp", 31U}},
{"Material-A", 210.0e9, 0.3, {"models/shell-owned.inp", 30U}}};
definition.shell_sections = {
{"Section-B", 0.02, 0U, {"models/shell-owned.inp", 41U}},
{"Section-A", 0.01, 1U, {"models/shell-owned.inp", 40U}}};
definition.shell_elements = {{{"Shell-Instance", 20, "0020"},
fesa::ShellSourceElementType::kS4r,
{4U, 5U, 6U, 7U},
0U,
0U,
{"models/shell-owned.inp", 21U}},
{{"Shell-Instance", 10, "0010"},
fesa::ShellSourceElementType::kS4,
{0U, 1U, 2U, 3U},
1U,
1U,
{"models/shell-owned.inp", 20U}}};
definition.shell_node_initial_frames = {
{4U, {0.0, 0.0, 1.0}, {1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}},
{0U, {0.0, 1.0, 0.0}, {1.0, 0.0, 0.0}, {0.0, 0.0, -1.0}}};
auto result = fesa::Domain::Create(definition);
ASSERT_TRUE(result.HasValue());
definition.shell_sections[0].thickness = -1.0;
definition.shell_elements[0].source_id.source_label_text = "mutated";
definition.shell_node_initial_frames[0].director[2] = -1.0;
const fesa::Domain& domain = result.Value();
static_assert(std::is_same_v<
decltype(std::declval<const fesa::Domain&>().ShellElements()),
const fesa::DomainCollectionView<fesa::Mitc4ShellDefinition>&>);
static_assert(std::is_same_v<
decltype(std::declval<const fesa::Domain&>().ShellSections()),
const fesa::DomainCollectionView<fesa::ShellSection>&>);
static_assert(
std::is_same_v<decltype(std::declval<const fesa::Domain&>()
.ShellNodeInitialFrames()),
const std::vector<fesa::ShellNodeInitialFrame>&>);
ASSERT_EQ(domain.ShellElements().Size(), 2U);
EXPECT_EQ(domain.ShellElements()[0].source_id.source_label, 20);
EXPECT_EQ(domain.ShellElements()[0].source_id.source_label_text, "0020");
EXPECT_EQ(domain.ShellElements()[1].source_id.source_label, 10);
EXPECT_EQ(domain.ShellElements()[0].source_type,
fesa::ShellSourceElementType::kS4r);
EXPECT_EQ(domain.ShellElements()[1].source_type,
fesa::ShellSourceElementType::kS4);
EXPECT_EQ(domain.ShellElements()[0].node_indices[3], 7U);
EXPECT_EQ(domain.ShellElements()[0].material_index, 0U);
EXPECT_EQ(domain.ShellElements()[0].section_index, 0U);
ASSERT_EQ(domain.ShellSections().Size(), 2U);
EXPECT_EQ(domain.ShellSections()[0].name, "Section-B");
EXPECT_DOUBLE_EQ(domain.ShellSections()[0].thickness, 0.02);
EXPECT_EQ(domain.ShellSections()[0].material_index, 0U);
EXPECT_EQ(domain.ShellSections()[1].name, "Section-A");
ASSERT_EQ(domain.ShellNodeInitialFrames().size(), 2U);
EXPECT_EQ(domain.ShellNodeInitialFrames()[0].node_index, 4U);
EXPECT_EQ(domain.ShellNodeInitialFrames()[0].director,
(std::array<double, 3>{0.0, 0.0, 1.0}));
EXPECT_EQ(domain.ShellNodeInitialFrames()[0].tangent_a,
(std::array<double, 3>{1.0, 0.0, 0.0}));
EXPECT_EQ(domain.ShellNodeInitialFrames()[0].tangent_b,
(std::array<double, 3>{0.0, 1.0, 0.0}));
auto no_frames_result = fesa::Domain::Create(fesa::ModelDefinition{});
ASSERT_TRUE(no_frames_result.HasValue());
EXPECT_TRUE(no_frames_result.Value().ShellNodeInitialFrames().empty());
}
Reference in New Issue View Git Blame Copy Permalink