Integrate Refactor solver sources and dual MSVC CMake builds

src/fesa/analysis/dynamic_analysis_state.cpp

@@ -1,18 +1,24 @@
 #include "fesa/analysis/dynamic_analysis_state.h"
 
-#include <algorithm>
 #include <cmath>
 #include <limits>
 #include <stdexcept>
 #include <string>
 #include <utility>
 
+#include "fesa/core/source_identity.h"
 #include "fesa/elements/element_definition.h"
 #include "fesa/elements/finite_rotation.h"
+#include "math/finite_values.h"
+#include "results/shell_result_recovery.h"
+#include "analysis/shell_state_inventory.h"
 
 namespace fesa {
 namespace {
 
+using analysis_internal::ShellElementOrder;
+using math_internal::IsFinite;
+
 constexpr std::size_t kDofsPerNode = 6U;
 constexpr std::size_t kAngularDofsPerNode = 3U;
 constexpr std::size_t kShellLocationsPerElement = 4U;
@@ -28,59 +34,6 @@ Status Failure(const FailureCategory category, const std::string& message) {
                                      message}});
 }
 
-/// @brief Compares canonical and raw source identity exactly.
-bool SameId(const SourceEntityId& left, const SourceEntityId& right) {
-  return left.instance_name == right.instance_name &&
-         left.source_label == right.source_label &&
-         left.source_label_text == right.source_label_text;
-}
-
-/// @brief Checks all components of one fixed-size physical record.
-template <std::size_t Size>
-bool IsFinite(const std::array<double, Size>& values) {
-  return std::all_of(values.begin(), values.end(),
-                     [](double value) { return std::isfinite(value); });
-}
-
-/// @brief Checks every vector component before state acceptance.
-bool IsFinite(const Vector& values) {
-  for (std::size_t index = 0U; index < values.Size(); ++index) {
-    if (!std::isfinite(values[index])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/// @brief Checks all physical recovery quantities for finite values.
-bool IsFinite(const ShellResultRow& row) {
-  if (!IsFinite(row.natural_coordinates) || !IsFinite(row.generalized_strain) ||
-      !IsFinite(row.section_resultant)) {
-    return false;
-  }
-  for (const auto& axis : row.local_frame) {
-    if (!IsFinite(axis)) {
-      return false;
-    }
-  }
-  return std::all_of(row.stress.begin(), row.stress.end(),
-                     [](const ShellSectionStressRow& stress) {
-                       return std::isfinite(stress.zeta) &&
-                              IsFinite(stress.components);
-                     });
-}
-
-/// @brief Collects stable Domain indices for recovery identity.
-std::vector<EntityIndex> ShellElementOrder(const Domain& domain) {
-  std::vector<EntityIndex> order;
-  for (std::size_t index = 0U; index < domain.Elements().Size(); ++index) {
-    if (domain.Elements()[index].Kind() == ElementDefinitionKind::kMitc4Shell) {
-      order.push_back(static_cast<EntityIndex>(index));
-    }
-  }
-  return order;
-}
-
 /// @brief Requires complete ordered Gauss and section-position rows.
 Status ValidateShellRows(const DynamicAcceptedFrameState& frame,
                          const std::vector<EntityIndex>& shell_order) {
@@ -110,7 +63,7 @@ Status ValidateShellRows(const DynamicAcceptedFrameState& frame,
           frame.shell_results[element * kShellLocationsPerElement + point];
       if (row.element != shell_order[element] ||
           row.location != kLocations[point] ||
-          row.natural_coordinates != natural[point] || !IsFinite(row)) {
+          row.natural_coordinates != natural[point] || !results_internal::IsFiniteShellRow(row)) {
         return Failure(FailureCategory::kSolver,
                        "Shell recovery rows have invalid identity or values.");
       }
@@ -228,7 +181,7 @@ Status DynamicAnalysisState::CommitAcceptedFrame(
   }
   for (std::size_t node = 0U; node < node_count; ++node) {
     if (frame.nodal_internal_order[node] != node ||
-        !SameId(frame.nodal_source_ids[node], nodal_source_ids_[node]) ||
+        !SourceIdentityEquals(frame.nodal_source_ids[node], nodal_source_ids_[node]) ||
         !IsFinite(frame.nodal_triad[node][0U]) ||
         !IsFinite(frame.nodal_triad[node][1U]) ||
         !IsFinite(frame.nodal_triad[node][2U]) ||