feat(thermal): assemble heat operators and preserve typed frame history

2026-09-29 20:09:13 +09:00
parent 85b5daac89
commit 54154bee15
7 changed files with 1462 additions and 0 deletions
@@ -0,0 +1,229 @@
+#include "fesa/analysis/thermal_analysis_state.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace fesa {
+namespace {
+
+/// @brief Rejects a candidate without touching accepted state.
+Status Failure(const std::string& message) {
+  return Status::Failure(FailureCategory::kSolver, {{Severity::kError,
+                                                     "invalid-thermal-state",
+                                                     {},
+                                                     "HEAT TRANSFER",
+                                                     "",
+                                                     message}});
+}
+
+/// @brief Checks every stored scalar without imposing a temperature sign bound.
+bool Finite(const Vector& vector) {
+  for (std::size_t i = 0; i < vector.Size(); ++i)
+    if (!std::isfinite(vector[i])) return false;
+  return true;
+}
+
+/// @brief Compares prescribed row identities without conflating node and row
+/// IDs.
+bool SameReactionDofs(const std::vector<ThermalReactionDof>& left,
+                      const std::vector<ThermalReactionDof>& right) {
+  if (left.size() != right.size()) return false;
+  for (std::size_t i = 0; i < left.size(); ++i)
+    if (left[i].node != right[i].node ||
+        left[i].source_dof != right[i].source_dof)
+      return false;
+  return true;
+}
+
+}  // namespace
+
+Result<ThermalAnalysisState> ThermalAnalysisState::Create(
+    const AnalysisModel& model, const DofManager& dofs,
+    const ThermalAssembly& assembly) {
+  const Status validation = assembly.ValidateFor(model, dofs);
+  if (!validation.IsOk())
+    return Result<ThermalAnalysisState>::Failure(validation);
+  const auto& step = *model.ThermalStep();
+  const auto grid = ThermalTimeGrid::Create(
+      step.time_period, step.nominal_increment, step.maximum_increments);
+  if (!grid.HasValue())
+    return Result<ThermalAnalysisState>::Failure(grid.GetStatus());
+  ThermalAnalysisState state{grid.Value(), step.nominal_increment,
+                             step.time_period};
+  const auto& domain = model.GetDomain();
+  state.node_order_ = model.ActiveThermalNodes();
+  state.element_order_ = assembly.ElementOrder();
+  state.node_source_ids_.reserve(state.node_order_.size());
+  state.element_source_ids_.reserve(state.element_order_.size());
+  state.constraint_mask_.resize(state.node_order_.size());
+  for (const auto node : state.node_order_)
+    state.node_source_ids_.push_back(domain.Nodes()[node].source_id);
+  for (std::size_t index = 0; index < state.element_order_.size(); ++index) {
+    state.element_source_ids_.push_back(assembly.Kernels()[index].SourceId());
+    const auto frame = assembly.Kernels()[index].Recover({});
+    if (!frame.HasValue())
+      return Result<ThermalAnalysisState>::Failure(frame.GetStatus());
+    state.local_frames_.push_back(frame.Value().frames);
+  }
+  for (const auto full : dofs.ConstrainedDofs()) {
+    const auto row = full / 5;
+    const auto station = full % 5;
+    if (row >= state.node_order_.size() || (station != 0 && station != 4))
+      return Result<ThermalAnalysisState>::Failure(Failure(
+          "Only active source DOFs 11/15 may carry thermal reactions."));
+    state.constraint_mask_[row][station] = 1;
+    state.reaction_dofs_.push_back(
+        {state.node_order_[row], static_cast<int>(station) + 11});
+  }
+  ThermalAcceptedFrame initial;
+  initial.node_order = state.node_order_;
+  initial.temperature = Vector{dofs.FullDofCount()};
+  for (const auto& declaration : domain.ThermalInitialConditions()) {
+    for (int station = 11; station <= 15; ++station) {
+      const auto full = dofs.FullThermalDof(
+          declaration.node_index, static_cast<ThermalDofComponent>(station));
+      initial.temperature[full] =
+          declaration.station_values[static_cast<std::size_t>(station - 11)];
+    }
+  }
+  const Status valid_initial = state.ValidateFrame(initial);
+  if (!valid_initial.IsOk())
+    return Result<ThermalAnalysisState>::Failure(valid_initial);
+  // No reserve(count+1): INC may be UINT32_MAX; history grows only upon commit.
+  state.frames_.push_back(std::move(initial));
+  return Result<ThermalAnalysisState>::Success(std::move(state));
+}
+
+ThermalAnalysisState::ThermalAnalysisState(ThermalTimeGrid grid, double nominal,
+                                           double period)
+    : grid_{grid}, nominal_{nominal}, period_{period} {}
+
+Status ThermalAnalysisState::ValidateFrame(
+    const ThermalAcceptedFrame& frame) const {
+  if (frame.frame_index != frame.increment_index ||
+      frame.frame_index > grid_.Count() || frame.node_order != node_order_ ||
+      frame.temperature.Size() != node_order_.size() * 5 ||
+      !Finite(frame.temperature))
+    return Failure(
+        "Frame indices, temperature rows or finite values do not match the "
+        "inventory.");
+  if (frame.frame_index == 0) {
+    if (!frame.is_initial || frame.time != 0 || frame.time_increment != 0 ||
+        frame.completed)
+      return Failure(
+          "Initial frame must have time/delta zero and temperature only.");
+    return Status::Ok();
+  }
+  const auto scheduled =
+      grid_.Frame(static_cast<std::uint32_t>(frame.frame_index));
+  if (!scheduled.HasValue()) return scheduled.GetStatus();
+  if (frame.is_initial || !frame.completed ||
+      frame.time != scheduled.Value().time ||
+      frame.time_increment != scheduled.Value().delta)
+    return Failure(
+        "Completed frame must preserve its exact scheduled time, actual delta "
+        "and recovery payload.");
+  const auto& payload = *frame.completed;
+  if (!SameReactionDofs(payload.reaction_dofs, reaction_dofs_) ||
+      payload.reaction_heat_rate.Size() != reaction_dofs_.size() ||
+      !Finite(payload.reaction_heat_rate) ||
+      payload.element_order != element_order_ ||
+      payload.global_heat_flux.size() != element_order_.size())
+    return Failure(
+        "Completed recovery rows do not match the reaction/element inventory.");
+  for (const auto& element : payload.global_heat_flux)
+    for (const auto& flux : element)
+      if (!flux.IsFinite())
+        return Failure("Completed global heat flux is not finite.");
+  return Status::Ok();
+}
+
+Result<ThermalAcceptedFrame> ThermalAnalysisState::MakeCompletedFrame(
+    std::uint32_t index, Vector temperature, Vector reaction,
+    std::vector<ThermalElementFlux> flux) const {
+  const auto time = grid_.Frame(index);
+  if (!time.HasValue())
+    return Result<ThermalAcceptedFrame>::Failure(time.GetStatus());
+  ThermalAcceptedFrame frame;
+  frame.frame_index = index;
+  frame.increment_index = index;
+  frame.time = time.Value().time;
+  frame.time_increment = time.Value().delta;
+  frame.is_initial = false;
+  frame.node_order = node_order_;
+  frame.temperature = std::move(temperature);
+  frame.completed = ThermalCompletedPayload{reaction_dofs_, std::move(reaction),
+                                            element_order_, std::move(flux)};
+  const Status validation = ValidateFrame(frame);
+  if (!validation.IsOk())
+    return Result<ThermalAcceptedFrame>::Failure(validation);
+  return Result<ThermalAcceptedFrame>::Success(std::move(frame));
+}
+
+Status ThermalAnalysisState::CommitAcceptedFrame(
+    const ThermalAcceptedFrame& frame) {
+  if (frame.frame_index != static_cast<std::uint64_t>(frames_.size()) ||
+      IsComplete())
+    return Failure("Only the next scheduled completed frame can be committed.");
+  const Status validation = ValidateFrame(frame);
+  if (!validation.IsOk()) return validation;
+  // std::vector copy insertion provides the strong guarantee for this copyable
+  // value record: neither validation failure nor an allocation exception alters
+  // history.
+  frames_.push_back(frame);
+  return Status::Ok();
+}
+const std::vector<ThermalAcceptedFrame>& ThermalAnalysisState::AcceptedFrames()
+    const noexcept {
+  return frames_;
+}
+const ThermalAcceptedFrame& ThermalAnalysisState::CommittedState()
+    const noexcept {
+  return frames_.back();
+}
+bool ThermalAnalysisState::IsComplete() const noexcept {
+  return static_cast<std::uint64_t>(frames_.size()) ==
+         std::uint64_t{grid_.Count()} + 1;
+}
+const ThermalTimeGrid& ThermalAnalysisState::TimeGrid() const noexcept {
+  return grid_;
+}
+double ThermalAnalysisState::NominalTimeIncrement() const noexcept {
+  return nominal_;
+}
+double ThermalAnalysisState::TimePeriod() const noexcept { return period_; }
+const std::vector<EntityIndex>& ThermalAnalysisState::NodeOrder()
+    const noexcept {
+  return node_order_;
+}
+const std::vector<SourceEntityId>& ThermalAnalysisState::NodeSourceIds()
+    const noexcept {
+  return node_source_ids_;
+}
+const std::vector<EntityIndex>& ThermalAnalysisState::ElementOrder()
+    const noexcept {
+  return element_order_;
+}
+const std::vector<SourceEntityId>& ThermalAnalysisState::ElementSourceIds()
+    const noexcept {
+  return element_source_ids_;
+}
+const std::vector<std::array<std::uint8_t, 5>>&
+ThermalAnalysisState::ConstraintMask() const noexcept {
+  return constraint_mask_;
+}
+const std::vector<ThermalReactionDof>& ThermalAnalysisState::ReactionDofs()
+    const noexcept {
+  return reaction_dofs_;
+}
+const std::vector<ThermalElementFrames>& ThermalAnalysisState::FluxLocalFrames()
+    const noexcept {
+  return local_frames_;
+}
+
+}  // namespace fesa