feat: adopt lumped mass and reduced-coordinate shell HHT

Integrate Hex8 mass verification and fixed-null-basis shell dynamics with numerical and physics handoff evidence. Preserve interrupted reference and full-validation status; full integration validation is deferred until after performance optimization.

include/fesa/analysis/dynamic_analysis_state.h

@@ -14,8 +14,16 @@
 
 namespace fesa {
 
+/// @brief Identifies the update and the meaning of a frame's full auxiliary A.
+enum class DynamicTimeIntegrationFormulation {
+  kFullCoordinateHht,
+  kReducedCoordinateHht
+};
+
 /// @brief Stores one accepted endpoint of an HHT dynamic step.
 struct DynamicAcceptedFrameState {
+  DynamicTimeIntegrationFormulation time_integration_formulation =
+      DynamicTimeIntegrationFormulation::kFullCoordinateHht;
   std::uint32_t frame_index = 0U;
   std::uint32_t increment_index = 0U;
   std::uint32_t iteration_count = 0U;
@@ -26,6 +34,8 @@ struct DynamicAcceptedFrameState {
   Vector generalized_coordinates{0U};
   Vector velocity{0U};
   Vector acceleration{0U};
+  /// Full-coordinate history stores the predictor driver. Reduced-coordinate
+  /// history stores (1+alpha)*a_n-alpha*a_previous; frame zero stores a0.
   Vector algorithmic_acceleration{0U};
   std::vector<std::array<std::array<double, 3>, 3>> nodal_triad;
   std::vector<std::array<double, 3>> nodal_director;

include/fesa/elements/hex8_element.h

@@ -64,7 +64,9 @@ class Hex8Element final : public Element {
   /// @note Failure preserves immutable reference data and all caller state.
   Result<Hex8HighLowResponse> EvaluateNonlinearHighLow(
       const Vector& high, const Vector& low) const;
-  /// @brief Returns the constant reference consistent mass; density required.
+  /// @brief Returns the constant reference row-sum lumped mass; density required.
+  /// @note Each diagonal entry is the row sum of the full 24-by-24 reference
+  /// consistent mass before any constraint reduction.
   Result<ElementStiffnessContribution> ComputeMass() const;
   /// @brief Returns immutable positive reference Gauss volume weights.
   /// @note Order is the kernel's fixed eight-point integration order.

include/fesa/elements/nonlinear_mitc4_inertia.h

@@ -38,7 +38,7 @@ struct DynamicRotationKinematics {
     const Vector3& phi, const Vector3& initial_director,
     const Vector3& velocity, const Vector3& acceleration);
 
-/// @brief Stores the consistent kinetic-inertia quantities at one trial.
+/// @brief Stores the nodal lumped kinetic-inertia quantities at one trial.
 struct NonlinearMitc4InertiaEvaluation {
   Matrix mass;
   Matrix position_tangent;
@@ -55,12 +55,12 @@ struct NonlinearMitc4InertiaEvaluation {
   double angular_momentum_rate_scale = 0.0;
 };
 
-/// @brief Evaluates finite-rotation consistent inertia for one MITC4 shell.
+/// @brief Evaluates finite-rotation nodal lumped inertia for one MITC4 shell.
 /// @note This object owns immutable reference geometry only, never analysis
 /// trial state.
 class NonlinearMitc4Inertia {
  public:
-  /// @brief Creates a checked consistent kinetic-mass evaluator.
+  /// @brief Creates a checked nodal lumped kinetic-mass evaluator.
   /// @param nodes Four non-owning nodes in source order.
   /// @param initial_frames Fixed proper node frames in source order.
   /// @param section Centered shell section with positive thickness.
@@ -74,7 +74,7 @@ class NonlinearMitc4Inertia {
       const ShellSection& section, const LinearElasticMaterial& material,
       double density);
 
-  /// @brief Evaluates physical consistent inertia at a complete trial.
+  /// @brief Evaluates physical nodal lumped inertia at a complete trial.
   /// @param trial Fixed-global translation and rotation coordinates.
   /// @param velocity24 Fixed-chart generalized physical velocity.
   /// @param physical_acceleration24 Fixed-chart generalized physical

include/fesa/elements/nonlinear_mitc4_shell.h

@@ -2,6 +2,7 @@
 #define FESA_ELEMENTS_NONLINEAR_MITC4_SHELL_H_
 
 #include <array>
+#include <cstddef>
 #include <string>
 
 #include "fesa/core/status.h"
@@ -53,6 +54,22 @@ struct NonlinearMitc4InternalEquilibrium {
   Matrix drilling_constraint_gradient{0U, 0U};
   std::array<Matrix, 4> drilling_constraint_hessian{
       Matrix{0U, 0U}, Matrix{0U, 0U}, Matrix{0U, 0U}, Matrix{0U, 0U}};
+  std::array<Vector, 4> drilling_constraint_third_directional_gradient{
+      Vector{0U}, Vector{0U}, Vector{0U}, Vector{0U}};
+};
+
+/// @brief Stores one nodal external drilling-null scalar and its variations.
+/// @note The scalar is `-n(phi)^T F`, where `n` is the normalized physical
+/// drill-null direction. Directional fields use `W=(phi_dot, 1)` and include
+/// the supplied force time derivatives.
+struct NonlinearMitc4ExternalDrillingConstraint {
+  double value = 0.0;
+  Vector gradient{0U};
+  Matrix hessian{0U, 0U};
+  double directional_first = 0.0;
+  double directional_second = 0.0;
+  Vector gradient_directional_first{0U};
+  Vector gradient_directional_second{0U};
 };
 
 class NonlinearMitc4Shell;
@@ -95,6 +112,22 @@ class NonlinearMitc4Shell {
   [[nodiscard]] Result<NonlinearMitc4Recovery> RecoverState(
       const NonlinearMitc4TrialDofs& trial) const;
 
+  /// @brief Evaluates the external nodal drill-null scalar through W.
+  /// @param node Source-local node index in `[0, 4)`.
+  /// @param phi Fixed-global principal-chart rotation in radians.
+  /// @param phi_dot Fixed-global chart rate in radians per time.
+  /// @param force Nodal external generalized moment.
+  /// @param force_rate First time derivative of force.
+  /// @param force_acceleration Second time derivative of force.
+  /// @return The scalar `-n(phi)^T force` and exact coordinate/time
+  /// derivatives, or a fail-closed diagnostic.
+  [[nodiscard]] 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;
+
  private:
   /// @brief Retains validated fixed-reference data without analysis ownership.
   NonlinearMitc4Shell(std::array<Vector3, 4> coordinates,

include/fesa/io/hdf5/dynamic_hdf5_results_writer.h

@@ -5,7 +5,8 @@
 
 namespace fesa {
 
-/// @brief Writes schema-v1 HHT dynamic HDF5 results with atomic finalization.
+/// @brief Writes HHT results with atomic finalization and formulation-specific
+/// schema: v1 for full-coordinate history, v2 for reduced-coordinate history.
 class DynamicHdf5ResultsWriter final : public DynamicResultsWriter {
  public:
   /// @brief Writes a validated dynamic result file and preserves a prior final