feat(linear-static-3d-euler-beam): step 15 - analysis-state

2026-08-09 17:32:06 +09:00
parent 25bbfd5ac2
commit 90a2f64ba4
8 changed files with 514 additions and 0 deletions
@@ -0,0 +1,173 @@
+#include "fesa/analysis/analysis_state.hpp"
+
+#include <gtest/gtest.h>
+
+#include <filesystem>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+namespace {
+
+template<class T, class = void>
+struct HasVelocity : std::false_type {};
+
+template<class T>
+struct HasVelocity<T, std::void_t<decltype(std::declval<T&>().velocity())>>
+    : std::true_type {};
+
+template<class T, class = void>
+struct HasAcceleration : std::false_type {};
+
+template<class T>
+struct HasAcceleration<
+    T, std::void_t<decltype(std::declval<T&>().acceleration())>>
+    : std::true_type {};
+
+template<class T, class = void>
+struct HasTemperature : std::false_type {};
+
+template<class T>
+struct HasTemperature<T, std::void_t<decltype(std::declval<T&>().temperature())>>
+    : std::true_type {};
+
+template<class T, class = void>
+struct HasIterationHistory : std::false_type {};
+
+template<class T>
+struct HasIterationHistory<
+    T, std::void_t<decltype(std::declval<T&>().iterationHistory())>>
+    : std::true_type {};
+
+template<class T, class = void>
+struct HasNonlinearState : std::false_type {};
+
+template<class T>
+struct HasNonlinearState<
+    T, std::void_t<decltype(std::declval<T&>().nonlinearState())>>
+    : std::true_type {};
+
+fesa::DofManager makeDofs() {
+    fesa::ModelDefinition definition{};
+    definition.sourcePath = "models/analysis-state.inp";
+    definition.sourceContentIdentity = "fnv1a64:0123456789abcdef";
+    definition.nodes = {
+        {{"Beam-1", 1, "1"}, {0.0, 0.0, 0.0}, {definition.sourcePath, 10U}},
+        {{"Beam-1", 2, "2"}, {1.0, 0.0, 0.0}, {definition.sourcePath, 11U}}};
+    definition.steps = {{
+        "Step-1",
+        {{"1", 1, 6, 0.0, {definition.sourcePath, 20U}}},
+        {},
+        0.1,
+        1.0,
+        0.01,
+        1.0,
+        {definition.sourcePath, 19U}}};
+
+    auto domain = fesa::Domain::create(std::move(definition));
+    EXPECT_TRUE(domain.hasValue());
+    auto model = fesa::AnalysisModel::create(domain.value());
+    EXPECT_TRUE(model.hasValue());
+    auto dofs = fesa::DofManager::create(model.value());
+    EXPECT_TRUE(dofs.hasValue());
+    return std::move(dofs.value());
+}
+
+void expectAllZero(const fesa::Vector& vector) {
+    for (std::size_t index = 0U; index < vector.size(); ++index) {
+        EXPECT_DOUBLE_EQ(vector[index], 0.0);
+    }
+}
+
+} // namespace
+
+TEST(AnalysisState, AllocatesOnlyV0FullVectors) {
+    const auto dofs = makeDofs();
+    ASSERT_EQ(dofs.fullDofCount(), 12U);
+    ASSERT_EQ(dofs.constrainedDofCount(), 6U);
+
+    auto state = fesa::AnalysisState::create(dofs, {"Step-1", 0U});
+    const fesa::AnalysisState& constState = state;
+    const fesa::Vector* const vectors[] = {
+        &constState.displacement(),
+        &constState.externalForce(),
+        &constState.internalForce(),
+        &constState.residual(),
+        &constState.reaction()};
+
+    for (const auto* vector : vectors) {
+        EXPECT_EQ(vector->size(), dofs.fullDofCount());
+        expectAllZero(*vector);
+    }
+    for (std::size_t left = 0U; left < std::size(vectors); ++left) {
+        for (std::size_t right = left + 1U; right < std::size(vectors); ++right) {
+            EXPECT_NE(vectors[left]->data(), vectors[right]->data());
+        }
+    }
+
+    state.displacement()[0] = 4.0;
+    state.reaction()[11] = -9.0;
+    EXPECT_DOUBLE_EQ(state.displacement()[0], 4.0);
+    EXPECT_DOUBLE_EQ(state.reaction()[11], -9.0);
+    EXPECT_DOUBLE_EQ(state.externalForce()[0], 0.0);
+    EXPECT_DOUBLE_EQ(state.internalForce()[0], 0.0);
+    EXPECT_DOUBLE_EQ(state.residual()[0], 0.0);
+
+    EXPECT_FALSE(HasVelocity<fesa::AnalysisState>::value);
+    EXPECT_FALSE(HasAcceleration<fesa::AnalysisState>::value);
+    EXPECT_FALSE(HasTemperature<fesa::AnalysisState>::value);
+    EXPECT_FALSE(HasIterationHistory<fesa::AnalysisState>::value);
+    EXPECT_FALSE(HasNonlinearState<fesa::AnalysisState>::value);
+}
+
+TEST(AnalysisState, CopiesOrMovesWithoutAliasing) {
+    static_assert(std::is_copy_constructible_v<fesa::AnalysisState>);
+    static_assert(std::is_copy_assignable_v<fesa::AnalysisState>);
+    static_assert(std::is_move_constructible_v<fesa::AnalysisState>);
+    static_assert(std::is_move_assignable_v<fesa::AnalysisState>);
+
+    const auto dofs = makeDofs();
+    auto original = fesa::AnalysisState::create(dofs, {"Step-1", 0U});
+    original.displacement()[0] = 3.0;
+    original.reaction()[11] = -2.0;
+    original.endpointResults().push_back({
+        0U,
+        -1,
+        {"Beam-1", 1, "1"},
+        {1.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+        {2.0, 0.0, 0.0, 0.0}});
+    original.gaussResults().push_back(
+        {0U, 1, {0.1, 0.0, 0.0, 0.0}, {10.0, 0.0, 0.0, 0.0}});
+    original.stressResults().push_back(
+        {0U, 1, 0U, 0.0, 0.0, 10.0, "fesa-default"});
+
+    auto copied = original;
+    EXPECT_NE(copied.displacement().data(), original.displacement().data());
+    EXPECT_NE(copied.reaction().data(), original.reaction().data());
+    EXPECT_NE(copied.endpointResults().data(), original.endpointResults().data());
+    EXPECT_NE(copied.gaussResults().data(), original.gaussResults().data());
+    EXPECT_NE(copied.stressResults().data(), original.stressResults().data());
+    copied.displacement()[0] = 30.0;
+    copied.endpointResults()[0].endAction[0] = 20.0;
+    EXPECT_DOUBLE_EQ(original.displacement()[0], 3.0);
+    EXPECT_DOUBLE_EQ(original.endpointResults()[0].endAction[0], 1.0);
+
+    auto moved = std::move(copied);
+    EXPECT_EQ(moved.identity().stepName, "Step-1");
+    EXPECT_DOUBLE_EQ(moved.displacement()[0], 30.0);
+    EXPECT_DOUBLE_EQ(moved.endpointResults()[0].endAction[0], 20.0);
+    EXPECT_NE(moved.displacement().data(), original.displacement().data());
+    EXPECT_NE(moved.endpointResults().data(), original.endpointResults().data());
+
+    auto copyAssigned = fesa::AnalysisState::create(dofs, {"Other", 3U});
+    copyAssigned = original;
+    copyAssigned.reaction()[11] = -20.0;
+    EXPECT_DOUBLE_EQ(original.reaction()[11], -2.0);
+    EXPECT_EQ(copyAssigned.identity().stepName, "Step-1");
+
+    auto moveAssigned = fesa::AnalysisState::create(dofs, {"Other", 4U});
+    moveAssigned = std::move(copyAssigned);
+    EXPECT_EQ(moveAssigned.identity().stepName, "Step-1");
+    EXPECT_DOUBLE_EQ(moveAssigned.reaction()[11], -20.0);
+    EXPECT_NE(moveAssigned.reaction().data(), original.reaction().data());
+}