feat: add analysis state and base

tests/analysis/analysis_base_test.cpp

@@ -0,0 +1,78 @@
+#include "fesa/analysis/Analysis.hpp"
+
+#include "fesa/core/AnalysisState.hpp"
+#include "fesa/core/Domain.hpp"
+
+#include <memory>
+
+namespace {
+
+int require(bool condition) {
+    return condition ? 0 : 1;
+}
+
+class RecordingAnalysis final : public fesa::analysis::Analysis {
+public:
+    const char* name() const noexcept override {
+        return "recording";
+    }
+
+    bool received_domain = false;
+    bool ran = false;
+
+protected:
+    void doRun(const fesa::core::Domain& domain, fesa::core::AnalysisState& state) override {
+        received_domain = domain.nodeCount() == 1;
+        state.setCurrentTime(2.0);
+        ran = true;
+    }
+};
+
+int derived_analysis_runs_through_base_api() {
+    fesa::core::Domain domain;
+    domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
+    fesa::core::AnalysisState state;
+    RecordingAnalysis analysis;
+
+    fesa::analysis::Analysis& base = analysis;
+    base.run(domain, state);
+
+    if (const int result = require(analysis.ran); result != 0) {
+        return result;
+    }
+    if (const int result = require(analysis.received_domain); result != 0) {
+        return result;
+    }
+    if (const int result = require(domain.nodeCount() == 1); result != 0) {
+        return result;
+    }
+    return require(state.currentTime() == 2.0);
+}
+
+int analysis_exposes_name_through_base_api() {
+    RecordingAnalysis analysis;
+    const fesa::analysis::Analysis& base = analysis;
+
+    return require(base.name()[0] == 'r');
+}
+
+int analysis_can_be_deleted_through_base_pointer() {
+    std::unique_ptr<fesa::analysis::Analysis> analysis = std::make_unique<RecordingAnalysis>();
+
+    return require(analysis->name()[0] == 'r');
+}
+
+} // namespace
+
+int run_analysis_base_tests() {
+    if (const int result = derived_analysis_runs_through_base_api(); result != 0) {
+        return result;
+    }
+    if (const int result = analysis_exposes_name_through_base_api(); result != 0) {
+        return result;
+    }
+    if (const int result = analysis_can_be_deleted_through_base_pointer(); result != 0) {
+        return result;
+    }
+    return 0;
+}

tests/analysis/analysis_test_main.cpp

@@ -0,0 +1,12 @@
+int run_analysis_base_tests();
+int run_analysis_state_tests();
+
+int main() {
+    if (const int result = run_analysis_state_tests(); result != 0) {
+        return result;
+    }
+    if (const int result = run_analysis_base_tests(); result != 0) {
+        return result;
+    }
+    return 0;
+}

tests/core/analysis_state_test.cpp

@@ -0,0 +1,203 @@
+#include "fesa/core/AnalysisState.hpp"
+
+#include <stdexcept>
+#include <vector>
+
+namespace {
+
+int require(bool condition) {
+    return condition ? 0 : 1;
+}
+
+template <typename Exception, typename Function>
+int require_throws(Function&& function) {
+    try {
+        function();
+    } catch (const Exception&) {
+        return 0;
+    } catch (...) {
+        return 1;
+    }
+    return 1;
+}
+
+int default_state_has_no_dofs() {
+    const fesa::core::AnalysisState state;
+
+    if (const int result = require(state.dofCount() == 0); result != 0) {
+        return result;
+    }
+    if (const int result = require(state.displacement().empty()); result != 0) {
+        return result;
+    }
+    if (const int result = require(state.externalForce().empty()); result != 0) {
+        return result;
+    }
+    if (const int result = require(state.internalForce().empty()); result != 0) {
+        return result;
+    }
+    if (const int result = require(state.residual().empty()); result != 0) {
+        return result;
+    }
+    return require(state.reaction().empty());
+}
+
+int sized_state_initializes_zero_vectors() {
+    const fesa::core::AnalysisState state{3};
+
+    if (const int result = require(state.dofCount() == 3); result != 0) {
+        return result;
+    }
+    for (const auto* vector : {
+             &state.displacement(),
+             &state.externalForce(),
+             &state.internalForce(),
+             &state.residual(),
+             &state.reaction(),
+         }) {
+        if (const int result = require(vector->size() == state.dofCount()); result != 0) {
+            return result;
+        }
+        for (const double value : *vector) {
+            if (const int result = require(value == 0.0); result != 0) {
+                return result;
+            }
+        }
+    }
+    return 0;
+}
+
+int setters_replace_matching_size_vectors() {
+    fesa::core::AnalysisState state{2};
+
+    state.setDisplacement({1.0, 2.0});
+    state.setExternalForce({3.0, 4.0});
+    state.setInternalForce({5.0, 6.0});
+    state.setResidual({7.0, 8.0});
+    state.setReaction({9.0, 10.0});
+
+    if (const int result = require(state.displacement()[0] == 1.0 && state.displacement()[1] == 2.0); result != 0) {
+        return result;
+    }
+    if (const int result = require(state.externalForce()[0] == 3.0 && state.externalForce()[1] == 4.0); result != 0) {
+        return result;
+    }
+    if (const int result = require(state.internalForce()[0] == 5.0 && state.internalForce()[1] == 6.0); result != 0) {
+        return result;
+    }
+    if (const int result = require(state.residual()[0] == 7.0 && state.residual()[1] == 8.0); result != 0) {
+        return result;
+    }
+    return require(state.reaction()[0] == 9.0 && state.reaction()[1] == 10.0);
+}
+
+int mismatched_setter_preserves_existing_vector() {
+    fesa::core::AnalysisState state{2};
+    state.setDisplacement({1.0, 2.0});
+
+    if (const int result = require_throws<std::invalid_argument>([&state]() {
+            state.setDisplacement({3.0});
+        });
+        result != 0) {
+        return result;
+    }
+
+    return require(state.displacement()[0] == 1.0 && state.displacement()[1] == 2.0);
+}
+
+int resize_resets_all_vectors_to_zero() {
+    fesa::core::AnalysisState state{2};
+    state.setDisplacement({1.0, 2.0});
+    state.setExternalForce({3.0, 4.0});
+
+    state.resize(3);
+
+    if (const int result = require(state.dofCount() == 3); result != 0) {
+        return result;
+    }
+    for (const auto* vector : {
+             &state.displacement(),
+             &state.externalForce(),
+             &state.internalForce(),
+             &state.residual(),
+             &state.reaction(),
+         }) {
+        for (const double value : *vector) {
+            if (const int result = require(value == 0.0); result != 0) {
+                return result;
+            }
+        }
+    }
+    return 0;
+}
+
+int clear_forces_preserves_displacement() {
+    fesa::core::AnalysisState state{2};
+    state.setDisplacement({1.0, 2.0});
+    state.setExternalForce({3.0, 4.0});
+    state.setInternalForce({5.0, 6.0});
+    state.setResidual({7.0, 8.0});
+    state.setReaction({9.0, 10.0});
+
+    state.clearForces();
+
+    if (const int result = require(state.displacement()[0] == 1.0 && state.displacement()[1] == 2.0); result != 0) {
+        return result;
+    }
+    for (const auto* vector : {
+             &state.externalForce(),
+             &state.internalForce(),
+             &state.residual(),
+             &state.reaction(),
+         }) {
+        for (const double value : *vector) {
+            if (const int result = require(value == 0.0); result != 0) {
+                return result;
+            }
+        }
+    }
+    return 0;
+}
+
+int counters_can_be_updated() {
+    fesa::core::AnalysisState state;
+
+    state.setCurrentTime(1.25);
+    state.setIncrementIndex(3);
+    state.setIterationIndex(5);
+
+    if (const int result = require(state.currentTime() == 1.25); result != 0) {
+        return result;
+    }
+    if (const int result = require(state.incrementIndex() == 3); result != 0) {
+        return result;
+    }
+    return require(state.iterationIndex() == 5);
+}
+
+} // namespace
+
+int run_analysis_state_tests() {
+    if (const int result = default_state_has_no_dofs(); result != 0) {
+        return result;
+    }
+    if (const int result = sized_state_initializes_zero_vectors(); result != 0) {
+        return result;
+    }
+    if (const int result = setters_replace_matching_size_vectors(); result != 0) {
+        return result;
+    }
+    if (const int result = mismatched_setter_preserves_existing_vector(); result != 0) {
+        return result;
+    }
+    if (const int result = resize_resets_all_vectors_to_zero(); result != 0) {
+        return result;
+    }
+    if (const int result = clear_forces_preserves_displacement(); result != 0) {
+        return result;
+    }
+    if (const int result = counters_can_be_updated(); result != 0) {
+        return result;
+    }
+    return 0;
+}