Integrate Refactor solver sources and dual MSVC CMake builds

include/fesa/elements/element.h

@@ -1,13 +1,11 @@
 #ifndef FESA_ELEMENTS_ELEMENT_H_
 #define FESA_ELEMENTS_ELEMENT_H_
 
-#include <cstdint>
-#include <functional>
 #include <variant>
 #include <vector>
 
-#include "fesa/core/source_identity.h"
 #include "fesa/core/status.h"
+#include "fesa/elements/element_dof_layout.h"
 #include "fesa/math/matrix.h"
 #include "fesa/math/vector.h"
 #include "fesa/results/result_records.h"
@@ -15,23 +13,6 @@
 
 namespace fesa {
 
-/// @brief Identifies one component in the stable six-DOF node layout.
-enum class DofComponent : std::uint8_t {
-  kUx,
-  kUy,
-  kUz,
-  kUrx,
-  kUry,
-  kUrz,
-};
-
-/// @brief Describes one runtime element's stable node and component order.
-struct ElementDofLayout {
-  SourceEntityId source_id;
-  std::vector<EntityIndex> node_indices;
-  std::vector<DofComponent> components_per_node;
-};
-
 /// @brief Carries one element-local stiffness in its declared DOF order.
 struct ElementStiffnessContribution {
   ElementDofLayout layout;
@@ -78,10 +59,6 @@ class Element {
       const Vector& element_displacement) const = 0;
 };
 
-/// @brief Provides non-owning runtime elements in stable owner order.
-/// @note Every referenced element must outlive this view.
-using ElementView = std::vector<std::reference_wrapper<const Element>>;
-
 }  // namespace fesa
 
 #endif  // FESA_ELEMENTS_ELEMENT_H_

include/fesa/elements/element_capabilities.h

@@ -0,0 +1,200 @@
+#ifndef FESA_ELEMENTS_ELEMENT_CAPABILITIES_H_
+#define FESA_ELEMENTS_ELEMENT_CAPABILITIES_H_
+
+#include <array>
+#include <cstddef>
+
+#include "fesa/elements/element.h"
+#include "fesa/elements/thermal_element_layout.h"
+#include "fesa/math/vector3.h"
+
+namespace fesa {
+
+class Hex8Element;
+class Mitc4Shell;
+class NonlinearMitc4Shell;
+class NonlinearMitc4Inertia;
+class ThermalShell;
+struct Hex8Response;
+struct Hex8HighLowResponse;
+struct Mitc4Stiffness;
+struct Mitc4Mass;
+struct NonlinearMitc4TrialDofs;
+struct NonlinearMitc4InternalEquilibrium;
+struct NonlinearMitc4ExternalDrillingConstraint;
+struct NonlinearMitc4InertiaEvaluation;
+struct ThermalShellRecovery;
+
+/// @brief Evaluates immutable shell trials; accepted history belongs to the procedure.
+class ShellTrialElement {
+ public:
+  virtual ~ShellTrialElement() = default;
+  /// @brief Returns stable source-local node/component order, never equations.
+  virtual const ElementDofLayout& DofLayout() const noexcept = 0;
+  /// @brief Returns the complete force/tangent/recovery at a fixed-global trial.
+  /// @param coordinate_direction Optional 24-vector for D2(f_int)[v,v].
+  /// @note Failure preserves the kernel, caller inputs and earlier responses.
+  virtual Result<NonlinearMitc4InternalEquilibrium> EvaluateTrial(
+      const NonlinearMitc4TrialDofs& trial,
+      const Vector* coordinate_direction = nullptr) const = 0;
+  /// @copydoc NonlinearMitc4Shell::EvaluateExternalDrillingConstraint
+  virtual Result<NonlinearMitc4ExternalDrillingConstraint>
+  EvaluateExternalDrillingConstraint(
+      std::size_t node, const Vector3& phi, const Vector3& phi_dot,
+      const Vector3& force, const Vector3& force_rate,
+      const Vector3& force_acceleration) const = 0;
+};
+
+/// @brief Borrows the same immutable shell kernel for every trial operation.
+/// @note The kernel must outlive this adapter and remain at its bound address.
+class Mitc4TrialAdapter final : public ShellTrialElement {
+ public:
+  Mitc4TrialAdapter(ElementDofLayout layout, const NonlinearMitc4Shell& kernel);
+  const ElementDofLayout& DofLayout() const noexcept override;
+  Result<NonlinearMitc4InternalEquilibrium> EvaluateTrial(
+      const NonlinearMitc4TrialDofs& trial,
+      const Vector* coordinate_direction = nullptr) const override;
+  Result<NonlinearMitc4ExternalDrillingConstraint>
+  EvaluateExternalDrillingConstraint(
+      std::size_t node, const Vector3& phi, const Vector3& phi_dot,
+      const Vector3& force, const Vector3& force_rate,
+      const Vector3& force_acceleration) const override;
+
+ private:
+  ElementDofLayout layout_;
+  const NonlinearMitc4Shell& kernel_;
+};
+
+/// @brief Keeps complete paired solid responses and reference mass typed.
+class SolidTrialElement : public Element {
+ public:
+  ~SolidTrialElement() override = default;
+  /// @copydoc Hex8Element::EvaluateLinear
+  virtual Result<Hex8Response> EvaluateLinear(const Vector& u) const = 0;
+  /// @copydoc Hex8Element::EvaluateNonlinear
+  virtual Result<Hex8Response> EvaluateNonlinear(const Vector& u) const = 0;
+  /// @copydoc Hex8Element::EvaluateLinearHighLow
+  virtual Result<Hex8HighLowResponse> EvaluateLinearHighLow(
+      const Vector& high, const Vector& low) const = 0;
+  /// @copydoc Hex8Element::EvaluateNonlinearHighLow
+  virtual Result<Hex8HighLowResponse> EvaluateNonlinearHighLow(
+      const Vector& high, const Vector& low) const = 0;
+  /// @copydoc Hex8Element::ComputeMass
+  virtual Result<ElementStiffnessContribution> ComputeMass() const = 0;
+  /// @brief Returns fixed Gauss weights used by the frequency mass bound.
+  virtual std::array<double, 8> ReferenceWeights() const noexcept = 0;
+};
+
+/// @brief Borrows one stable Hex8 kernel shared by all local operations.
+/// @note The kernel must outlive this adapter and remain at its bound address.
+class Hex8TrialAdapter final : public SolidTrialElement {
+ public:
+  explicit Hex8TrialAdapter(const Hex8Element& kernel);
+  const ElementDofLayout& DofLayout() const noexcept override;
+  Result<ElementStiffnessContribution> ComputeStiffness() const override;
+  Result<ElementResultBundle> Recover(const Vector& u) const override;
+  Result<Hex8Response> EvaluateLinear(const Vector& u) const override;
+  Result<Hex8Response> EvaluateNonlinear(const Vector& u) const override;
+  Result<Hex8HighLowResponse> EvaluateLinearHighLow(
+      const Vector& high, const Vector& low) const override;
+  Result<Hex8HighLowResponse> EvaluateNonlinearHighLow(
+      const Vector& high, const Vector& low) const override;
+  Result<ElementStiffnessContribution> ComputeMass() const override;
+  std::array<double, 8> ReferenceWeights() const noexcept override;
+
+ private:
+  const Hex8Element& kernel_;
+};
+
+/// @brief Returns the complete physical inertia response in fixed chart DOFs.
+class ShellInertiaElement {
+ public:
+  virtual ~ShellInertiaElement() = default;
+  virtual const ElementDofLayout& DofLayout() const noexcept = 0;
+  /// @copydoc NonlinearMitc4Inertia::Evaluate
+  virtual Result<NonlinearMitc4InertiaEvaluation> Evaluate(
+      const NonlinearMitc4TrialDofs& trial, const Vector& velocity24,
+      const Vector& physical_acceleration24) const = 0;
+};
+
+/// @brief Borrows immutable inertia geometry, never shared mutable scratch.
+/// @note The kernel must outlive this adapter and remain at its bound address.
+class Mitc4InertiaAdapter final : public ShellInertiaElement {
+ public:
+  Mitc4InertiaAdapter(ElementDofLayout layout,
+                      const NonlinearMitc4Inertia& kernel);
+  const ElementDofLayout& DofLayout() const noexcept override;
+  Result<NonlinearMitc4InertiaEvaluation> Evaluate(
+      const NonlinearMitc4TrialDofs& trial, const Vector& velocity24,
+      const Vector& physical_acceleration24) const override;
+
+ private:
+  ElementDofLayout layout_;
+  const NonlinearMitc4Inertia& kernel_;
+};
+
+/// @brief Keeps DS4 DOFs 11-15 and all four-by-six flux traces independent.
+class ThermalElement {
+ public:
+  virtual ~ThermalElement() = default;
+  /// @brief Returns node-major stations 11-15 and original source identity.
+  virtual const ThermalElementDofLayout& DofLayout() const noexcept = 0;
+  /// @copydoc ThermalShell::Conductivity
+  virtual const Matrix& Conductivity() const noexcept = 0;
+  /// @copydoc ThermalShell::Capacity
+  virtual const Matrix& Capacity() const noexcept = 0;
+  /// @copydoc ThermalShell::ConductivityError
+  virtual const Matrix& ConductivityError() const noexcept = 0;
+  /// @copydoc ThermalShell::CapacityError
+  virtual const Matrix& CapacityError() const noexcept = 0;
+  /// @copydoc ThermalShell::Recover
+  virtual Result<ThermalShellRecovery> Recover(
+      const std::array<double, 20>& temperature) const = 0;
+};
+
+/// @brief Borrows the same DS4 kernel for matrices, intervals and recovery.
+/// @note The kernel must outlive this adapter and remain at its bound address.
+class Ds4ThermalAdapter final : public ThermalElement {
+ public:
+  explicit Ds4ThermalAdapter(const ThermalShell& kernel);
+  const ThermalElementDofLayout& DofLayout() const noexcept override;
+  const Matrix& Conductivity() const noexcept override;
+  const Matrix& Capacity() const noexcept override;
+  const Matrix& ConductivityError() const noexcept override;
+  const Matrix& CapacityError() const noexcept override;
+  Result<ThermalShellRecovery> Recover(
+      const std::array<double, 20>& temperature) const override;
+
+ private:
+  ThermalElementDofLayout layout_;
+  const ThermalShell& kernel_;
+};
+
+/// @brief Supplies shell frequency operators with their distinct mass contract.
+class ShellReferenceElement : public Element {
+ public:
+  ~ShellReferenceElement() override = default;
+  /// @copydoc Mitc4Shell::Stiffness
+  virtual Result<Mitc4Stiffness> Stiffness() const = 0;
+  /// @copydoc Mitc4Shell::Mass
+  virtual Result<Mitc4Mass> Mass(double density) const = 0;
+};
+
+/// @brief Borrows the same linear MITC4 kernel for stiffness and recovery.
+/// @note The kernel must outlive this adapter and remain at its bound address.
+class Mitc4ReferenceAdapter final : public ShellReferenceElement {
+ public:
+  explicit Mitc4ReferenceAdapter(const Mitc4Shell& kernel);
+  const ElementDofLayout& DofLayout() const noexcept override;
+  Result<ElementStiffnessContribution> ComputeStiffness() const override;
+  Result<ElementResultBundle> Recover(const Vector& u) const override;
+  Result<Mitc4Stiffness> Stiffness() const override;
+  Result<Mitc4Mass> Mass(double density) const override;
+
+ private:
+  const Mitc4Shell& kernel_;
+};
+
+}  // namespace fesa
+
+#endif  // FESA_ELEMENTS_ELEMENT_CAPABILITIES_H_

include/fesa/elements/element_dof_layout.h

@@ -0,0 +1,38 @@
+#ifndef FESA_ELEMENTS_ELEMENT_DOF_LAYOUT_H_
+#define FESA_ELEMENTS_ELEMENT_DOF_LAYOUT_H_
+
+#include <cstdint>
+#include <functional>
+#include <vector>
+
+#include "fesa/core/source_identity.h"
+
+namespace fesa {
+
+/// @brief Identifies one component in the stable six-DOF node layout.
+enum class DofComponent : std::uint8_t {
+  kUx,
+  kUy,
+  kUz,
+  kUrx,
+  kUry,
+  kUrz,
+};
+
+/// @brief Describes one runtime element's stable node and component order.
+struct ElementDofLayout {
+  SourceEntityId source_id;
+  std::vector<EntityIndex> node_indices;
+  std::vector<DofComponent> components_per_node;
+};
+
+class Element;
+
+/// @brief Provides non-owning runtime elements in stable owner order.
+/// @note Every referenced element must outlive this view.
+using ElementView = std::vector<std::reference_wrapper<const Element>>;
+
+
+}  // namespace fesa
+
+#endif  // FESA_ELEMENTS_ELEMENT_DOF_LAYOUT_H_

include/fesa/elements/element_factory.h

@@ -5,6 +5,7 @@
 
 #include "fesa/core/status.h"
 #include "fesa/elements/element.h"
+#include "fesa/elements/element_capabilities.h"
 
 namespace fesa {
 
@@ -21,6 +22,14 @@ class ElementFactory {
   Result<std::unique_ptr<Element>> Create(const ElementDefinition& definition,
                                           const Domain& domain) const;
 
+  /// @brief Binds a typed view of an existing stable runtime kernel.
+  /// @note Returns null for a different family. The kernel must outlive the
+  /// returned adapter and remain at its address; no second kernel is created.
+  std::unique_ptr<SolidTrialElement> BindSolidTrial(const Element& kernel) const;
+  /// @copydoc BindSolidTrial
+  std::unique_ptr<ShellReferenceElement> BindShellReference(
+      const Element& kernel) const;
+
  private:
   /// @brief Creates one checked B33 runtime candidate.
   Result<std::unique_ptr<Element>> CreateBeam(

include/fesa/elements/euler_beam_3d.h

@@ -4,12 +4,11 @@
 #include <array>
 #include <cstddef>
 #include <string>
-#include <string_view>
 #include <vector>
 
 #include "fesa/core/status.h"
 #include "fesa/elements/element.h"
-#include "fesa/elements/element_definition.h"
+#include "fesa/elements/euler_beam_3d_definition.h"
 #include "fesa/materials/isotropic_linear_elastic_material.h"
 #include "fesa/math/matrix.h"
 #include "fesa/math/vector.h"
@@ -17,40 +16,8 @@
 
 namespace fesa {
 
-class Domain;
 struct Node;
 
-/// @brief Defines one two-node B33 semantic element.
-class EulerBeam3DDefinition final : public ElementDefinition {
- public:
-  /// @brief Constructs a parser-validated semantic definition.
-  EulerBeam3DDefinition(SourceEntityId source_id,
-                        std::array<EntityIndex, 2> node_indices,
-                        EntityIndex material_index, EntityIndex section_index,
-                        SourceLocation location);
-
-  ElementDefinitionKind Kind() const noexcept override;
-  const SourceEntityId& SourceId() const noexcept override;
-  std::string_view SourceElementType() const noexcept override;
-  const std::vector<EntityIndex>& NodeIndices() const noexcept override;
-  EntityIndex MaterialIndex() const noexcept override;
-  EntityIndex PropertyIndex() const noexcept override;
-
-  SourceEntityId source_id;
-  std::array<EntityIndex, 2> node_indices;
-  EntityIndex material_index;
-  EntityIndex section_index;
-  SourceLocation location;
-
- private:
-  friend class Domain;
-
-  /// @brief Synchronizes the base view after parser-candidate construction.
-  void SynchronizeNodeIndices();
-
-  std::vector<EntityIndex> node_indices_view_;
-};
-
 /// @brief Stores constant line-load components in the beam local frame.
 struct ConstantLocalLineLoad {
   double px;

include/fesa/elements/euler_beam_3d_definition.h

@@ -0,0 +1,48 @@
+#ifndef FESA_ELEMENTS_EULER_BEAM_3D_DEFINITION_H_
+#define FESA_ELEMENTS_EULER_BEAM_3D_DEFINITION_H_
+
+#include <array>
+#include <string_view>
+#include <vector>
+
+#include "fesa/elements/element_definition.h"
+
+namespace fesa {
+
+class Domain;
+
+/// @brief Defines one two-node B33 semantic element.
+class EulerBeam3DDefinition final : public ElementDefinition {
+ public:
+  /// @brief Constructs a parser-validated semantic definition.
+  EulerBeam3DDefinition(SourceEntityId source_id,
+                        std::array<EntityIndex, 2> node_indices,
+                        EntityIndex material_index, EntityIndex section_index,
+                        SourceLocation location);
+
+  ElementDefinitionKind Kind() const noexcept override;
+  const SourceEntityId& SourceId() const noexcept override;
+  std::string_view SourceElementType() const noexcept override;
+  const std::vector<EntityIndex>& NodeIndices() const noexcept override;
+  EntityIndex MaterialIndex() const noexcept override;
+  EntityIndex PropertyIndex() const noexcept override;
+
+  SourceEntityId source_id;
+  std::array<EntityIndex, 2> node_indices;
+  EntityIndex material_index;
+  EntityIndex section_index;
+  SourceLocation location;
+
+ private:
+  friend class Domain;
+
+  /// @brief Synchronizes the base view after parser-candidate construction.
+  void SynchronizeNodeIndices();
+
+  std::vector<EntityIndex> node_indices_view_;
+};
+
+
+}  // namespace fesa
+
+#endif  // FESA_ELEMENTS_EULER_BEAM_3D_DEFINITION_H_

include/fesa/elements/finite_rotation.h

@@ -33,11 +33,13 @@ Matrix ExpSkew(const Vector3& phi);
 /// @pre phi is finite and lies inside the approved principal chart.
 Matrix LeftJacobianSO3(const Vector3& phi);
 
-/// @brief Computes the inverse transpose of the SO(3) left Jacobian.
-/// @param phi Fixed-global rotation coordinate in radians.
-/// @return The 3-by-3 inverse-transpose left Jacobian.
+/// @brief Solves J(phi)^T * moment = generalized for a spatial moment.
+/// @param phi Fixed-global principal-chart rotation coordinate in radians.
+/// @param generalized Work-conjugate moment in fixed-global chart coordinates.
+/// @return A finite spatial moment in the same force-length units, or failure.
 /// @pre phi is finite and lies inside the approved principal chart.
-Matrix InverseTransposeLeftJacobianSO3(const Vector3& phi);
+/// @note Inputs remain unchanged; no inverse Jacobian is constructed.
+Result<Vector3> SpatialMomentSO3(const Vector3& phi, const Vector3& generalized);
 
 /// @brief Builds a checked finite-rotation state from its reference frame.
 /// @param phi Fixed-global principal-chart rotation coordinate in radians.

include/fesa/elements/mitc4_shell.h

@@ -3,12 +3,11 @@
 
 #include <array>
 #include <string>
-#include <string_view>
 #include <vector>
 
 #include "fesa/core/status.h"
 #include "fesa/elements/element.h"
-#include "fesa/elements/element_definition.h"
+#include "fesa/elements/mitc4_shell_definition.h"
 #include "fesa/materials/isotropic_linear_elastic_material.h"
 #include "fesa/math/matrix.h"
 #include "fesa/math/vector.h"
@@ -17,52 +16,8 @@
 
 namespace fesa {
 
-class Domain;
 struct Node;
 
-/// @brief Preserves the source shell type independently of formulation.
-enum class ShellSourceElementType { kS4, kS4r };
-
-/// @brief Names the internal shell formulation selected by S4 and S4R.
-inline constexpr std::string_view kMitc4InternalFormulation{"FESA-MITC4"};
-
-/// @brief Defines one four-node S4/S4R semantic element.
-class Mitc4ShellDefinition final : public ElementDefinition {
- public:
-  /// @brief Constructs a parser-validated semantic definition.
-  Mitc4ShellDefinition(SourceEntityId source_id,
-                       ShellSourceElementType source_type,
-                       std::array<EntityIndex, 4> node_indices,
-                       EntityIndex material_index, EntityIndex section_index,
-                       SourceLocation location);
-
-  ElementDefinitionKind Kind() const noexcept override;
-  const SourceEntityId& SourceId() const noexcept override;
-  std::string_view SourceElementType() const noexcept override;
-  const std::vector<EntityIndex>& NodeIndices() const noexcept override;
-  EntityIndex MaterialIndex() const noexcept override;
-  EntityIndex PropertyIndex() const noexcept override;
-
-  SourceEntityId source_id;
-  ShellSourceElementType source_type;
-  std::array<EntityIndex, 4> node_indices;
-  EntityIndex material_index;
-  EntityIndex section_index;
-  SourceLocation location;
-
- private:
-  friend class Domain;
-
-  /// @brief Rebinds a shell-local section index to the unified property view.
-  void SetPropertyIndex(EntityIndex property_index) noexcept;
-
-  /// @brief Synchronizes the base view after parser-candidate construction.
-  void SynchronizeNodeIndices();
-
-  EntityIndex property_index_;
-  std::vector<EntityIndex> node_indices_view_;
-};
-
 /// @brief Stores bilinear shape values and natural-coordinate derivatives.
 struct Mitc4ShapeFunctions {
   std::array<double, 4> values;
@@ -213,11 +168,10 @@ class Mitc4Shell final : public Element {
   void BindRuntime(ElementDofLayout layout, EntityIndex element_index,
                    SourceLocation location);
 
-  /// @brief Stores covariant, reciprocal, frame, and Jacobian data at one
+  /// @brief Stores covariant, frame, and Jacobian data at one
   /// point.
   struct GeometryData {
     std::array<Vector3, 3> covariant;
-    std::array<Vector3, 3> reciprocal;
     Mitc4LocalFrame frame;
     double jacobian;
   };

include/fesa/elements/mitc4_shell_definition.h

@@ -0,0 +1,60 @@
+#ifndef FESA_ELEMENTS_MITC4_SHELL_DEFINITION_H_
+#define FESA_ELEMENTS_MITC4_SHELL_DEFINITION_H_
+
+#include <array>
+#include <string_view>
+#include <vector>
+
+#include "fesa/elements/element_definition.h"
+
+namespace fesa {
+
+class Domain;
+
+/// @brief Preserves the source shell type independently of formulation.
+enum class ShellSourceElementType { kS4, kS4r };
+
+/// @brief Names the internal shell formulation selected by S4 and S4R.
+inline constexpr std::string_view kMitc4InternalFormulation{"FESA-MITC4"};
+
+/// @brief Defines one four-node S4/S4R semantic element.
+class Mitc4ShellDefinition final : public ElementDefinition {
+ public:
+  /// @brief Constructs a parser-validated semantic definition.
+  Mitc4ShellDefinition(SourceEntityId source_id,
+                       ShellSourceElementType source_type,
+                       std::array<EntityIndex, 4> node_indices,
+                       EntityIndex material_index, EntityIndex section_index,
+                       SourceLocation location);
+
+  ElementDefinitionKind Kind() const noexcept override;
+  const SourceEntityId& SourceId() const noexcept override;
+  std::string_view SourceElementType() const noexcept override;
+  const std::vector<EntityIndex>& NodeIndices() const noexcept override;
+  EntityIndex MaterialIndex() const noexcept override;
+  EntityIndex PropertyIndex() const noexcept override;
+
+  SourceEntityId source_id;
+  ShellSourceElementType source_type;
+  std::array<EntityIndex, 4> node_indices;
+  EntityIndex material_index;
+  EntityIndex section_index;
+  SourceLocation location;
+
+ private:
+  friend class Domain;
+
+  /// @brief Rebinds a shell-local section index to the unified property view.
+  void SetPropertyIndex(EntityIndex property_index) noexcept;
+
+  /// @brief Synchronizes the base view after parser-candidate construction.
+  void SynchronizeNodeIndices();
+
+  EntityIndex property_index_;
+  std::vector<EntityIndex> node_indices_view_;
+};
+
+
+}  // namespace fesa
+
+#endif  // FESA_ELEMENTS_MITC4_SHELL_DEFINITION_H_

include/fesa/elements/thermal_dof_component.h

@@ -0,0 +1,20 @@
+#ifndef FESA_ELEMENTS_THERMAL_DOF_COMPONENT_H_
+#define FESA_ELEMENTS_THERMAL_DOF_COMPONENT_H_
+
+
+namespace fesa {
+
+/// @brief Identifies the fixed bottom-to-top thermal station source DOFs.
+/// @note This is separate from the six-component structural DofComponent.
+enum class ThermalDofComponent : int {
+  kBottom = 11,
+  kLower = 12,
+  kMiddle = 13,
+  kUpper = 14,
+  kTop = 15
+};
+
+
+}  // namespace fesa
+
+#endif  // FESA_ELEMENTS_THERMAL_DOF_COMPONENT_H_

include/fesa/elements/thermal_element_layout.h

@@ -3,7 +3,8 @@
 
 #include <array>
 
-#include "fesa/model/model_types.h"
+#include "fesa/core/source_identity.h"
+#include "fesa/elements/thermal_dof_component.h"
 
 namespace fesa {