feat(linear-static-mitc4-shell): step 2 - shell-director-geometry

2026-08-12 19:28:54 +09:00
parent 7002febe2e
commit c0a68ee964
7 changed files with 842 additions and 0 deletions
@@ -517,6 +517,18 @@ TEST(InpDomainMapping, MapsS4AndS4rThroughOneMitc4Identity) {
    EXPECT_DOUBLE_EQ(domain.shellSections()[1].thickness, 0.2);
    EXPECT_EQ(domain.shellSections()[1].materialIndex, 1U);

+    ASSERT_EQ(domain.shellNodeInitialFrames().size(), domain.nodes().size());
+    EXPECT_EQ(domain.shellNodeInitialFrames()[0].nodeIndex, 0U);
+    EXPECT_EQ(
+        domain.shellNodeInitialFrames()[0].director,
+        (std::array<double, 3>{0.0, 0.0, 1.0}));
+    EXPECT_EQ(
+        domain.shellNodeInitialFrames()[0].tangentA,
+        (std::array<double, 3>{1.0, 0.0, 0.0}));
+    EXPECT_EQ(
+        domain.shellNodeInitialFrames()[0].tangentB,
+        (std::array<double, 3>{0.0, 1.0, 0.0}));
+
    ASSERT_EQ(domain.steps().size(), 1U);
    ASSERT_EQ(domain.steps()[0].boundaries.size(), 1U);
    EXPECT_EQ(domain.steps()[0].boundaries[0].lastDof, 6);
@@ -0,0 +1,276 @@
+#include "fesa/model/shell_geometry.hpp"
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <string>
+#include <vector>
+
+namespace {
+
+using Vector3 = std::array<double, 3>;
+
+fesa::Node node(fesa::EntityIndex label, Vector3 coordinates) {
+    return {
+        {"Shell-Instance", static_cast<std::int64_t>(label),
+         std::to_string(label)},
+        coordinates,
+        {"shell-geometry.inp", static_cast<std::size_t>(label + 1U)}};
+}
+
+fesa::Mitc4ShellDefinition element(
+    fesa::EntityIndex label,
+    std::array<fesa::EntityIndex, 4> nodeIndices) {
+    return {
+        {"Shell-Instance", static_cast<std::int64_t>(label),
+         std::to_string(label)},
+        fesa::ShellSourceElementType::s4,
+        nodeIndices,
+        0U,
+        0U,
+        {"shell-geometry.inp", static_cast<std::size_t>(100U + label)}};
+}
+
+std::vector<fesa::ShellSection> sections(double thickness = 0.2) {
+    return {{"Section", thickness, 0U, {"shell-geometry.inp", 90U}}};
+}
+
+double dot(const Vector3& left, const Vector3& right) {
+    return left[0] * right[0] + left[1] * right[1] + left[2] * right[2];
+}
+
+Vector3 cross(const Vector3& left, const Vector3& right) {
+    return {
+        left[1] * right[2] - left[2] * right[1],
+        left[2] * right[0] - left[0] * right[2],
+        left[0] * right[1] - left[1] * right[0]};
+}
+
+double norm(const Vector3& value) {
+    return std::sqrt(dot(value, value));
+}
+
+void expectVectorNear(
+    const Vector3& actual,
+    const Vector3& expected,
+    double tolerance = 1.0e-12) {
+    for (std::size_t component = 0U; component < actual.size(); ++component) {
+        EXPECT_NEAR(actual[component], expected[component], tolerance);
+    }
+}
+
+void expectRightHandedFrame(const fesa::ShellNodeInitialFrame& frame) {
+    EXPECT_NEAR(norm(frame.director), 1.0, 1.0e-12);
+    EXPECT_NEAR(norm(frame.tangentA), 1.0, 1.0e-12);
+    EXPECT_NEAR(norm(frame.tangentB), 1.0, 1.0e-12);
+    EXPECT_NEAR(dot(frame.director, frame.tangentA), 0.0, 1.0e-12);
+    EXPECT_NEAR(dot(frame.director, frame.tangentB), 0.0, 1.0e-12);
+    EXPECT_NEAR(dot(frame.tangentA, frame.tangentB), 0.0, 1.0e-12);
+    expectVectorNear(cross(frame.tangentA, frame.tangentB), frame.director);
+}
+
+const fesa::ShellNodeInitialFrame& frameFor(
+    const fesa::ShellGeometry& geometry,
+    fesa::EntityIndex nodeIndex) {
+    const auto found = std::find_if(
+        geometry.nodalFrames.begin(),
+        geometry.nodalFrames.end(),
+        [nodeIndex](const fesa::ShellNodeInitialFrame& frame) {
+            return frame.nodeIndex == nodeIndex;
+        });
+    EXPECT_NE(found, geometry.nodalFrames.end());
+    return *found;
+}
+
+void expectFailureCode(
+    const fesa::Result<fesa::ShellGeometry>& result,
+    const std::string& code) {
+    ASSERT_FALSE(result.hasValue());
+    EXPECT_EQ(result.status().failureCategory(), fesa::FailureCategory::model);
+    ASSERT_EQ(result.status().diagnostics().size(), 1U);
+    EXPECT_EQ(result.status().diagnostics()[0].code, code);
+}
+
+} // namespace
+
+// MITC4-GEO-001
+TEST(Mitc4Geometry, BuildsDeterministicFramesForPlanarRotatedAndWarpedElements) {
+    const std::vector<fesa::Node> planarNodes{
+        node(0U, {0.0, 0.0, 0.0}),
+        node(1U, {1.0, 0.0, 0.0}),
+        node(2U, {1.0, 1.0, 0.0}),
+        node(3U, {0.0, 1.0, 0.0})};
+    auto planar = fesa::preprocessShellGeometry(
+        planarNodes, {element(10U, {0U, 1U, 2U, 3U})}, sections());
+
+    ASSERT_TRUE(planar.hasValue());
+    ASSERT_EQ(planar.value().elementData.size(), 1U);
+    expectVectorNear(planar.value().elementData[0].normalCandidate, {0.0, 0.0, 1.0});
+    EXPECT_NEAR(planar.value().elementData[0].surfaceAreaWeight, 1.0, 1.0e-12);
+    ASSERT_EQ(planar.value().nodalFrames.size(), 4U);
+    for (const auto& frame : planar.value().nodalFrames) {
+        expectVectorNear(frame.director, {0.0, 0.0, 1.0});
+        expectVectorNear(frame.tangentA, {1.0, 0.0, 0.0});
+        expectVectorNear(frame.tangentB, {0.0, 1.0, 0.0});
+        expectRightHandedFrame(frame);
+    }
+
+    const std::vector<fesa::Node> rotatedNodes{
+        node(0U, {0.0, 0.0, 0.0}),
+        node(1U, {0.0, 1.0, 0.0}),
+        node(2U, {0.0, 1.0, 1.0}),
+        node(3U, {0.0, 0.0, 1.0})};
+    auto rotated = fesa::preprocessShellGeometry(
+        rotatedNodes, {element(11U, {0U, 1U, 2U, 3U})}, sections());
+
+    ASSERT_TRUE(rotated.hasValue());
+    const auto& rotatedFrame = frameFor(rotated.value(), 0U);
+    expectVectorNear(rotatedFrame.director, {1.0, 0.0, 0.0});
+    expectVectorNear(rotatedFrame.tangentA, {0.0, 1.0, 0.0});
+    expectVectorNear(rotatedFrame.tangentB, {0.0, 0.0, 1.0});
+    expectRightHandedFrame(rotatedFrame);
+
+    const std::vector<fesa::Node> warpedNodes{
+        node(0U, {0.0, 0.0, 0.0}),
+        node(1U, {2.0, 0.0, 0.0}),
+        node(2U, {2.0, 1.0, 0.2}),
+        node(3U, {0.0, 1.0, 0.0})};
+    auto warped = fesa::preprocessShellGeometry(
+        warpedNodes, {element(12U, {0U, 1U, 2U, 3U})}, sections());
+
+    ASSERT_TRUE(warped.hasValue());
+    EXPECT_GT(warped.value().elementData[0].surfaceAreaWeight, 2.0);
+    for (const auto& frame : warped.value().nodalFrames) {
+        expectRightHandedFrame(frame);
+    }
+}
+
+// MITC4-GEO-002
+TEST(Mitc4Geometry, AreaWeightsSharedDirectorsInStableSourceIdentityOrder) {
+    const std::vector<fesa::Node> nodes{
+        node(0U, {0.0, 0.0, 0.0}),
+        node(1U, {1.0, 0.0, 0.0}),
+        node(2U, {1.0, 1.0, 0.0}),
+        node(3U, {0.0, 1.0, 0.0}),
+        node(4U, {2.0, 0.0, 1.0}),
+        node(5U, {2.0, 1.0, 1.0})};
+    const auto flat = element(10U, {0U, 1U, 2U, 3U});
+    const auto tilted = element(20U, {1U, 4U, 5U, 2U});
+
+    auto first = fesa::preprocessShellGeometry(
+        nodes, {tilted, flat}, sections());
+    auto second = fesa::preprocessShellGeometry(
+        nodes, {flat, tilted}, sections());
+
+    ASSERT_TRUE(first.hasValue());
+    ASSERT_TRUE(second.hasValue());
+    const Vector3 expectedSharedDirector{
+        -1.0 / std::sqrt(5.0), 0.0, 2.0 / std::sqrt(5.0)};
+    for (const auto sharedNode : {1U, 2U}) {
+        const auto& firstFrame = frameFor(first.value(), sharedNode);
+        const auto& secondFrame = frameFor(second.value(), sharedNode);
+        expectVectorNear(firstFrame.director, expectedSharedDirector);
+        expectVectorNear(firstFrame.director, secondFrame.director, 0.0);
+        expectVectorNear(firstFrame.tangentA, {0.0, 1.0, 0.0});
+        expectRightHandedFrame(firstFrame);
+    }
+}
+
+// MITC4-GEO-003
+TEST(Mitc4Geometry, RejectsInvalidSurfaceJacobianAndIncidentOrientationCases) {
+    const auto validElement = element(10U, {0U, 1U, 2U, 3U});
+
+    expectFailureCode(
+        fesa::preprocessShellGeometry(
+            {node(0U, {0.0, 0.0, 0.0}), node(1U, {0.0, 0.0, 0.0}),
+             node(2U, {1.0, 1.0, 0.0}), node(3U, {0.0, 1.0, 0.0})},
+            {validElement}, sections()),
+        "invalid-shell-geometry");
+
+    expectFailureCode(
+        fesa::preprocessShellGeometry(
+            {node(0U, {0.0, 0.0, 0.0}), node(1U, {1.0, 1.0, 0.0}),
+             node(2U, {0.0, 1.0, 0.0}), node(3U, {1.0, 0.0, 0.0})},
+            {validElement}, sections()),
+        "invalid-shell-geometry");
+
+    expectFailureCode(
+        fesa::preprocessShellGeometry(
+            {node(0U, {0.0, 0.0, 0.0}), node(1U, {1.0, 0.0, 0.0}),
+             node(2U, {2.0, 0.0, 0.0}), node(3U, {3.0, 0.0, 0.0})},
+            {validElement}, sections()),
+        "invalid-shell-geometry");
+
+    expectFailureCode(
+        fesa::preprocessShellGeometry(
+            {node(0U, {0.0, 0.0, 0.0}), node(1U, {1.0, 0.0, 0.0}),
+             node(2U, {0.05, 0.05, 0.0}), node(3U, {0.0, 1.0, 0.0})},
+            {validElement}, sections()),
+        "invalid-shell-geometry");
+
+    expectFailureCode(
+        fesa::preprocessShellGeometry(
+            {node(0U, {0.0, 0.0, 0.0}),
+             node(1U, {1.0, 0.0, 0.0}),
+             node(2U, {1.0, std::numeric_limits<double>::quiet_NaN(), 0.0}),
+             node(3U, {0.0, 1.0, 0.0})},
+            {validElement}, sections()),
+        "invalid-shell-geometry");
+
+    expectFailureCode(
+        fesa::preprocessShellGeometry(
+            {node(0U, {0.0, 0.0, 0.0}), node(1U, {1.0, 0.0, 0.0}),
+             node(2U, {1.0, 1.0, 0.0}), node(3U, {0.0, 1.0, 0.0})},
+            {validElement}, sections(0.0)),
+        "invalid-shell-jacobian");
+
+    const std::vector<fesa::Node> opposedNodes{
+        node(0U, {0.0, 0.0, 0.0}), node(1U, {1.0, 0.0, 0.0}),
+        node(2U, {1.0, 1.0, 0.0}), node(3U, {0.0, 1.0, 0.0})};
+    expectFailureCode(
+        fesa::preprocessShellGeometry(
+            opposedNodes,
+            {element(10U, {0U, 1U, 2U, 3U}),
+             element(20U, {0U, 3U, 2U, 1U})},
+            sections()),
+        "opposed-incident-normal");
+}
+
+// MITC4-GEO-004
+TEST(Mitc4Geometry, ExposesTheCompleteRequiredValidationPointInventory) {
+    const auto& points = fesa::shellGeometryValidationPoints();
+    ASSERT_EQ(points.size(), 17U);
+    EXPECT_EQ(
+        std::count_if(points.begin(), points.end(), [](const auto& point) {
+            return point.kind == fesa::ShellGeometryPointKind::center;
+        }),
+        1);
+    EXPECT_EQ(
+        std::count_if(points.begin(), points.end(), [](const auto& point) {
+            return point.kind == fesa::ShellGeometryPointKind::stiffness;
+        }),
+        8);
+    EXPECT_EQ(
+        std::count_if(points.begin(), points.end(), [](const auto& point) {
+            return point.kind == fesa::ShellGeometryPointKind::tying;
+        }),
+        4);
+    EXPECT_EQ(
+        std::count_if(points.begin(), points.end(), [](const auto& point) {
+            return point.kind == fesa::ShellGeometryPointKind::recovery;
+        }),
+        4);
+
+    EXPECT_EQ(points.front().naturalCoordinates, (Vector3{0.0, 0.0, 0.0}));
+    const double gauss = 1.0 / std::sqrt(3.0);
+    EXPECT_EQ(points[1].naturalCoordinates, (Vector3{-gauss, -gauss, -gauss}));
+    EXPECT_EQ(points[8].naturalCoordinates, (Vector3{-gauss, gauss, gauss}));
+    EXPECT_EQ(points[9].naturalCoordinates, (Vector3{0.0, -1.0, 0.0}));
+    EXPECT_EQ(points[12].naturalCoordinates, (Vector3{1.0, 0.0, 0.0}));
+    EXPECT_EQ(points[13].naturalCoordinates, (Vector3{-gauss, -gauss, 0.0}));
+    EXPECT_EQ(points[16].naturalCoordinates, (Vector3{-gauss, gauss, 0.0}));
+}