Skip to content

feat(torsion): torsion on the mixed deck, at one restrained end and on a Fixed rod end, the routes combined - #74

Merged
SMI-Lab-Inha merged 9 commits into
devfrom
feat/torsion-routes-b
Oct 31, 2026
Merged

SMI-Lab-Inha merged 9 commits into
devfrom
feat/torsion-routes-b

Conversation

@SMI-Lab-Inha

Copy link
Copy Markdown
Owner

Squash title: feat(torsion): torsion on the mixed deck, at one restrained end and on a Fixed rod end, the routes combined

What changed

Three more torsion route limits are lifted, then the torsion routes of 0.4.0 are combined. This
PR sits on the linearisation / control / modal PR; each of the first three features was built
and reviewed on its own branch from dev 66e3e83.

Prescribed motion and torsion on the standalone mixed deck

A standalone deck that mixes EI = 0 and finite-EI lines between Fixed/Coupled/Vessel
points runs on the coupled aggregate. It held its coupled ends and refused motionFile,
vesselMotion and every line restrained in torsion. The driver now marches the deck's
prescribed motion on the aggregate as the single-line cubic-Hermite route does (row 1 installed
before t = 0, a TMax = 0 run writes the static state); a vessel turns the end-connection and
torsion frames of the cables on its points, and the motionFile roll column imposes the twist.
vesselRAO stays refused with the deck waves; CableDyn_InitDeck/InitDeckAt keep their
refusal.

A line restrained in torsion at one end only

A finite-EI line whose END CONNECTIONS restrain its twist at one end only (the other end
TorsStiffness Free, or no row) was noted and solved as without the columns. Where its
LINE TYPES rows give GJ it is now solved in torsion: the free end carries no torque and
turns with the twist of the line, statically by Twist<L> = −Σ (K/GJ)(l − L) under GJ|K, and
in the dynamics with torsional waves that reflect at it. The Torq/Twist channels and range
columns work on such a line. A line that misses a rule (no GJ, two moving ends, the
configuration blend in a dynamic run, a restrained End A on a free, pinned or Coupled rod end or
a non-Rigid6 body) keeps the 6-column meaning, with a note naming the rule.

A torsional END CONNECTION on a Fixed rod end

A line restrained in torsion may hang from an end of a Fixed rod (an I-tube or J-tube), whose
frame holds the End A torsion frame, with Nx in the rod's deck axes; the ends of a rod fixed to
a Rigid6 body roll with the body. Rod<N>M of a rod fixed to a body now includes the connection
moment of a cable clamped at its end (it read 0). Free, pinned and Coupled/Vessel rods refuse
the torsion by name, and so does staggered bodyScheme on a body or rod. A finite-EI line
written anchor first onto a rod end is turned around like the other anchor-first lines; a line
between two rods is refused as ending on a rod end.

The routes combined

Each branch was built alone, so the one-end feature still left a line unsolved in torsion under
ATTACHMENTS, CONTROL, nModes and a rod End A. Those rules are lifted (natively and in the
Python validator):

  • the torsion stage after the attachment polish (feat(torsion): ATTACHMENTS on a line restrained in torsion #71) handles a free end: it takes the stage's
    final mesh, which after the polish is l0 (reading the pre-polish l0_am, which the polish
    has moved, crashed);
  • the modal twist Hessian skips a free end, which it took for an elastic end of compliance 0 (a
    non-finite stiffness);
  • a restrained End A may be on a Fixed rod end;
  • the staggered body scheme refuses a torsional End A only when End A is restrained.

OpenFAST linearisation already took a line free at one end; its gate is added.
ATTACHMENTS on a line restrained at both ends already ran on the mixed route and on a rod end
(both build the cable through the same builder as the single-line route); their gates are added.

Gates

Mixed deck (mixed_route_torsion, step_allocations_motion_*): vessel roll 20°, pitch 4°,
heave 1 m from rest on a sagging clamped line restrained in torsion, alone and beside a moving
chain: torque, twist and node positions agree to the printed digits (≤ 0.50 of a unit), end
tensions, inclination and End A bend moment within 6.6e-6 of their range; a 1 m surge with a 20°
roll column: ≤ 0.57 printed units, loads within 8.2e-6 (the Newton tolerance: with the
single-line controls every channel agrees to 0.36 printed units). A straight line rolled by 30°
gives Twist1 = Pretwist − roll to 5e-7° and Torq = GJ Φ/L to 4.7e-6 N·m. No heap allocation
per step.

One restrained end (torsion_one_end, step_allocations_torsion_one_end): a straight line held
rigidly at one end rings at the clamped–free frequencies (2n − 1)π/(2L) √(GJ/Irn) (3e-4, 3e-3);
a roll of the restrained end gives the continuum's free-end turn A/cos kL and reaction
GJ A k tan kL to 0.5 % below and above the first mode; deck statics with GJ|K give
Twist1 = −(K/GJ) dl to 8.5e-9 and the tension (EA − K²/GJ) ε to 4.6e-9; the same on the
coupled aggregate under a platform roll.

Rod end (rod_end_torsion): two turns on an inclined Fixed J-tube give GJ Φ/L to 1.1e-9, the
held Coupled point's torque to the printed digits, Rod1M = M_t a to 1.1e-8; on a rod fixed to a
rolling Rigid6 body the torque follows GJ (Φ − θ)/L to 4.1e-11 and Rod1M carries it to
2.0e-7.

Routes combined (VALIDATION T-17; each of the first five fails on the code before the last
commit):

Gate Oracle Measured
torsion_one_end T1: vertical GJ|K cable with two clumps and a buoy (net 14.6, −9.1, 5.8 kN), free at End A, then at End B Twist1 = −(K/GJ)(H − L0); tensions from the module weights; mid-line twist from the piecewise tension 8.5e-9; 2.9e-9; 3.9e-4 (first order in the mesh: 1.9e-4, 9.6e-5 at 80, 160 elements); no torque
T2: neutral modules on the rolled line (kL = π/8) the continuum's free-end twist and end torques 9e-4
control_torsion O: CONTROL deck on the aggregate, free at the fairlead, then at the anchor, paid out 0.2 m Twist1 = −(K/GJ)(H − L(t)); no torque; mean held tension (EA − K²/GJ) ε 3.7e-11; 8.2e-11 of K ε; 1.2e-4
modal_torsion_deck 3: the clamped line free at End B, then End A clamped–free chain 2 √(GJ/Irn)/l0 sin((2n − 1)π/(4N)); quarter-wave within 1 − sin x/x; first shape sin(π s/(2L)); other modes = TorsStiffness Free 8e-10; 6.4e-5 (first); 5e-10; exact
rod_end_torsion 4: J-tube line with GJ|K, free at End B, then at the rod end Twist1 = −(K/GJ) dl; the held Coupled point's 8.5e-9; identical
lin_torsion O (shell recipe) and openfast_lin_torsion.py 3 (OpenFAST): the straight line free at End B, then at End A clamped–free chain; quarter-wave within x²/6; roll stiffness 0 2e-14 (shell), 2.5e-13 (OpenFAST); 4.1e-5 (first); 0 (End B free: C A⁻¹ B cancels the feedthrough GJ/l_e)
rod_end_torsion 4: two turns, two clumps and a buoy on the J-tube line the held Coupled point's torque and twist identical
mixed_route_torsion 7: three buoyancy modules on the roll-column line the single-line route 1.15 printed units; loads 2.1e-5 of range

Ablations: lifting the rules without the mesh fix crashes T1 (SIGSEGV); without the Hessian fix
the modal deck stops ("the stiffness or mass matrix is not finite").

Changed results

  • Lines restrained at one end with a GJ row now carry the twist in their dynamics: on a swaying
    lazy-wave cable with GJ|K the tensions move by up to 1.5e-4 (7e-8 in a planar heave). A line
    restrained at End A on a Rigid6 body joins the static body balance; bending-pinned there its
    body's static moment now balances (on a buoy Body1My −103.9 N·m to 1e-6, FairTen1 126885 to
    126857 N, Body1Ry 0.3004 to 0.2984°; the march then differs by up to 2.6 % at dtM 0.05 s);
    clamped there, by about 1e-7. OpenFAST checkpoints of such decks written before do not reload.
  • Rod<N>M of a rod fixed to a body includes the connection moment of a cable clamped at its end.

Combining the branches

The six commits are cherry-picked in order (mixed route, one end, rod end; each with its review
fix), then one integration commit. Conflicts:

  • documentation, VALIDATION and the CHANGELOG: every entry kept; the scope paragraphs of
    doc/driver_format.md, doc/capabilities.rst, doc/openfast.rst and
    doc/troubleshooting.rst rewritten to the combined state (the C API rotating entry of feat(capi): host rotations, torsion through the C API #70,
    linearisation, control, modal, mixed deck, one end, rod end); the stale "torsion has no
    inertia" and "no torque–tension coupling" sentences are gone; the mixed deck's VALIDATION entry
    is T-16;
  • the torsion message TORSION_NEEDS_ORIENTATION and its Python mirror: the C API's
    InitDeck/InitDeckAt only (the mixed deck now turns the frames);
  • the deck driver's torsion stage: feat(torsion): ATTACHMENTS on a line restrained in torsion #71 split the notes into torsion_note, which now returns for
    a line free at one end (its note is the one-end state's, and no twist stage set the tolerance
    it reports); the shared roll-column check of the mixed route (check_motion_roll_lines) and
    its roll-column map take the one-end rule (line_torsion_at_a: a free End A takes no roll);
  • normalize_stock_endpoint_order takes the line types (rod end) and is followed by
    resolve_one_end_torsion (one end); test_step_allocations dispatches free,
    motion_roll and motion_vessel;
  • the Python validator's torsion check: the mixed-deck refusal removed, the one-end rules and the
    rod rules kept, the both-end ATTACHMENTS refusal of the rod branch's base dropped (feat(torsion): ATTACHMENTS on a line restrained in torsion #71 lifted
    it).

On #72 (rebase): the mixed route's CD_Init_Deck_Aggregate counts the host bodies with #72's
CoupledPinned ones, the aggregate takes both #72's start accelerations and the deck's
prescribed motion, the mixed deck still refuses MoorDyn-C Currents 1/2/5, and
test_step_allocations dispatches current_grid beside the torsion and motion gates. Every
current sample in the torsion code goes through deck_current_velocity(opts, position, time, ...). python/tests/test_native_model.py is dev's (the identity-based handle-release test of
#72); the gc.collect() variants of the mixed-route and rod-end fixes are dropped, so those
two commit messages still name a change they no longer make.

Checks

  • Full ctest suite (339) passes; pytest python/tests tests (2126 passed, 121 skipped; the
    native parity tests with CABLEDYN_TEST_DRIVER: 221 passed); ruff check/format clean;
    pre-commit clean; the docs build with -W clean.
  • All 53 example decks are bit-identical to the reference driver (dev 0f53412).

…deck

A standalone deck that mixes EI = 0 and finite-EI lines between
Fixed/Coupled/Vessel points runs on the coupled aggregate. The driver
held its coupled ends, refused a motionFile and vesselMotion, and
refused any line restrained in torsion (TORSION_NEEDS_ORIENTATION).

The driver now marches the deck's prescribed motion on the aggregate,
as the standalone cubic-Hermite route does:
- CD_Init_Deck_Aggregate / CD_AGG_Init_From_Deck take prescribed_motion:
  the motionFile or vesselMotion table is read into an opaque
  CD_MotionRuntimeType keyed to the aggregate moving-set order (the
  apply_coupled_positions enumeration); the aggregate checks the column
  map against its moving surface at the static state;
- CD_AGG_MotionKinematics returns one grid row: the point translations,
  the vessel's global-to-parent DCM and global angular rates (identity
  and zero for point rows) and the motionFile roll column of each cable
  restrained in torsion at its moving End A;
- CD_AGG_Step_Moving takes an optional roll (ncp_total): a cable
  restrained in torsion takes the imposed twist Phi_0 - roll,
  Phi_0 = Pretwist(B) - Pretwist(A), the single-cable route's u_twist;
- row 1 is installed (CD_AGG_UpdateStates_Moving) and the cables'
  free-node accelerations recomputed (CD_AGG_Refresh_Accelerations)
  before t = 0, as on the single-cable route; a TMax = 0 run writes the
  static state;
- the driver passes host_orientation: it holds the frames or turns them
  with the vessel, so torsion columns are accepted. A Rigid bending end
  connection on a vessel point turns with the vessel, as on the
  single-cable route and in OpenFAST; a motionFile holds it.
vesselRAO stays refused with the deck waves. The C API keeps the
refusal; TORSION_NEEDS_ORIENTATION drops the mixed-deck clause. The
roll-column check is shared (check_motion_roll_lines).

test_mixed_route_torsion (driver executable):
- vessel roll 20 deg, pitch 4 deg, heave 1 m from rest on a sagging
  clamped line restrained in torsion, alone (cubic-Hermite route) and
  beside a moving chain (mixed route): torque, twist and node positions
  to the printed digits (<= 0.50 of a unit), end tensions, inclination
  and End A bend moment within 6.6e-6 of their range; a motionFile of
  the same translations holds the frames (bend moment 11 %, twist 19 deg
  apart);
- a 1 m surge with a 20 deg roll column: <= 0.57 printed units, loads
  within 8.2e-6 of range;
- the remaining difference is the Newton tolerance (coupled cables 5e-3
  with a fresh factor, the single line the deck's 1e-8 with a carried
  factor): given the single-line controls, the library march reproduces
  every channel to 0.36 printed units;
- a straight line held or rolled by 30 deg (vessel, roll column):
  Twist1 = Pretwist - roll to 5e-7 deg, Torq = GJ Phi/L to 4.7e-6 N m;
- a roll column at the chain point stops by name.
On dev every mixed run stops ("mixed-deck motionFile is not supported").
test_step_allocations motion_roll / motion_vessel: the march makes no
heap allocation after warm-up.

The Python deck reader accepts a mixed deck with motionFile/vesselMotion
and torsion columns. All example decks are bit-identical.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
…fore the install

Review fixes for the prescribed motion and torsion on the standalone mixed
deck:
- a static mixed run (TMax = 0) of a line restrained in torsion takes
  False alpha_force_blend, as the single-line route and the Python reader
  do: CD_Init_Deck_Aggregate / CD_AGG_Init_From_Deck take static_run (the
  driver passes nstep == 0); a dynamic run still stops with the
  "torsion in a dynamic run" message;
- with TMax = 0 the mixed route installs motion row 1 as the single-line
  routes do (the t = 0 row is that state);
- both finite-EI routes write .static.out before the row-1 install, so the
  file holds the static solve. A single-line deck whose row 1 is off the
  deck fairlead changes .static.out only (2 cm offset: fairlead x 0.02 ->
  0 m, tension 3.5 MN -> 29 kN); all 53 example decks are bit-identical;
- docs: the EI = 0 lines of a mixed deck re-derive their interior
  accelerations on the row-1 transfer, which the EI = 0-only route does
  not (documented, that route unchanged); index and openfast wording; the
  agreement figures hold for motions from rest (a start with a jump in
  velocity differs by several percent of the range).

test_mixed_route_torsion gates 5 and 6:
- TMax = 0, row 1 2 cm off the fairlead: both routes write the same t = 0
  row (difference 0 at the printed digits; FairTen 3.5 MN, the installed
  row) and a .static.out with the fairlead at x = 0;
- a static mixed deck with torsion and False alpha_force_blend runs
  (torque error 3.4e-6 N m against GJ Phi/L); the same deck with
  TMax = 1 stops by name.
On the previous commit gate 5 fails (the mixed t = 0 row is the static
state, the single-line .static.out shows x = 0.02) and gate 6 fails (the
static deck is refused). The Python parity test accepts the static deck.

test_native_model: collect garbage before counting the constructor's
close calls, so a model of an earlier test finalised by the collector is
not counted (the suite's allocation pattern made it fail in a full run).

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
… end free to twist

A finite-EI line whose END CONNECTIONS restrain its twist at one end only
(the other end TorsStiffness Free, or no row) was noted and solved as without
the columns. It is now solved in torsion wherever a line restrained at both
ends is and its LINE TYPES rows give GJ: the free end carries no torque and
turns with the twist of the line.

- CD_HermiteTorsionType gains end_free: an infinite end compliance, so the
  condensed compliance is +Inf and the condensed torque and stiffness are
  zero. Validate refuses two free ends, a free end with a compliance, and a
  free end without irn; the static solve refuses a free end (no static
  torque).
- Nodal twist: a free end is neither rigid nor elastic (tw_spring): no spring
  and no held angle, so the torque vanishes there and torsional waves reflect.
  tw_init shifts the angles as one to meet the restrained end. The end moment
  of a free end has no torque, the energy no spring term, and the
  Torsion_State derivative queries skip the pi/2 Theta check (the torque is
  zero on every branch).
- Deck: resolve_one_end_torsion (after the anchor-first swap) sets
  tors_free_end when the line meets the rules (GJ on every section, Fixed End
  B, no ATTACHMENTS or CONTROL, no nModes, a force-blended march, a restrained
  End A on no rod end and on a Rigid6 body only) and zeroes the free end's
  Pretwist; otherwise tors_note names the rule, in the note and in the refusal
  of a Torq/Twist channel. torsion_stage of such a line keeps the untwisted
  static state, sets the free end's gauge frame and Theta there, and notes the
  free end's static turn -sum (K/GJ)(l - L). A free End A takes no parent
  torsion frame; the multibody clamp, body passes and turn limit, and the
  motionFile roll, act only on a restrained End A. The Python deck validator
  mirrors the rules.

Decision: such a line runs the torsion model whenever it gives GJ (its
14-column row then gives Irn > 0, so a dynamic run always has inertia to
carry). Its static state is unchanged bit for bit; its dynamics, CurvX/CurvY
axes and range columns change. On the GoM lazy-wave cable restrained at one
end the tensions move by up to 7e-8 in a planar heave and 1.5e-4 in a sway
with GJ|K; a 10-column row keeps the 6-column results exactly.

test_torsion_one_end:
- clamped-free modes of a straight line (GJ 80, Irn 0.5), free at End A and
  at End B: ring-down peaks 3e-4 and 3e-3 from (2n - 1) pi/(2L) sqrt(GJ/Irn);
  a roll of the restrained end at kL = pi/4 and 3 pi/4 gives the free end's
  A/cos kL (1.2e-4, 1.6e-3, in antiphase above the first mode) and the
  reaction GJ A k tan kL (1.1e-4, 4.7e-3); no torque at the free end;
  snapshot/restore bit-identical;
- deck statics with GJ|K, free End A, free End B and End A without a row:
  Twist1 = -(K/GJ) dl = -458.37 deg to 8.5e-9, no torque, the tension
  (EA - K^2/GJ) eps to 4.6e-9; a stretching march: the free end turns with the
  stretch at every step to 1.1e-8;
- the motionFile roll of a restrained End A of a line free at End B (Irn 1,
  kL = pi/8): Twist1, Torq1N1 and the free end's Torq1N41 within 9e-4 of the
  continuum; the same through the coupled aggregate's platform roll; a line
  free at End A keeps its static twist under the platform roll, with no torque
  and no axial moment;
- a 10-column row keeps the line unsolved and its twist channels refused with
  the reason.
On dev the deck gates stop at the twist channel ("not torsionally restrained
at both ends"). step_allocations_torsion_one_end: no heap allocation per step.
The full suite and the Python tests pass; all 53 example decks are
bit-identical to dev.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
- Python deck validator: the torsion columns of a line written anchor first
  are keyed by the native End A/B (the anchor-first swap, which also negates
  a pretwist), as the held ends are; a line restrained at the deck's End B on
  a Point3 body, which the swap makes End A, is now refused its twist
  channels as natively. Parity tests with that deck (and its Rigid6 twin)
  against the native driver.
- A line solved in torsion at one end holds its restrained end's Pretwist
  (its imposed twist) within 1000 turns, natively and in the validator, as a
  line restrained at both ends holds Pretwist(B) - Pretwist(A).
- The one-end static note gives Twist<L> with its axis (End B relative to
  End A, right-handed about the End A -> End B tangent); the docs state that
  a free End B turns by +Twist<L> and a free End A by -Twist<L>.
- driver_format: the CurvX/CurvY axes of a line free at one end start from
  End A's Nx (not rolled by its Pretwist) when End A is restrained and from
  End B's Nx rolled by End B's Pretwist when End B is; file_formats: the
  roll column is read on a deck with a line solved in torsion.
- CHANGELOG names the result changes: a line restrained at End A on a Rigid6
  body joins the static balance of the body's clamped ends, also when
  bending-Pinned there (on a buoy the static Body1My goes from -103.9 N m to
  1e-6, FairTen1 from 126885 to 126857 N, Body1Ry from 0.3004 to 0.2984 deg;
  the march differs by up to 2.6 % at dtM 0.05 s, 0.5 % at 0.0125 s; about
  1e-7 when clamped), and OpenFAST checkpoints of decks with one restrained
  end and a GJ row written before the change do not reload (the cable
  mirror grew by the nodal twist; the rebuild stops at a mirror-extent
  check).

The one-end static note, like the both-end one, is printed on every static
body pass (the shared note path is left as it is). All 53 example decks are
bit-identical to dev.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
A line restrained in torsion stopped at any rod end ("a rod has no
spin angle in this build"). Of the rod types that reach a finite-EI
line (the multibody march), a Fixed rod and a rod fixed to a Rigid6
body carry a whole orientation; a Free or Pinned rod (also
Body<N>Pinned, CoupledPinned) is axisymmetric: no load acts about its
axis, its static solve has no roll angle and its roll is never loaded,
so it cannot hold a torque. Coupled/Vessel rods carry no finite-EI line
on any route (the multibody march takes no motionFile, the coupled
aggregate no rod beside a finite-EI cable).

- check_torsion_line accepts an end of a Fixed rod. Free, pinned and
  Coupled/Vessel rods keep named refusals that give the reason.
- The ends of a Body<N> rod are already body points, whose torsion
  frame rolls with the body; that route is now gated.
- clamp_object_frame returns the End A reference normal in the object
  frame: on a rod end the deck's Nx (in the rod's deck axes, like Ez)
  is carried into the rod frame, nx0 = R^T Nx, before the cable is
  built in the march and in the static passes. Taken in the rod frame
  instead it would twist the line by the roll of that frame (90 deg on
  the gate's J-tube).
- Rod<N>M of a rod fixed to a body now includes the connection moment
  of a cable clamped at its end, as on a rod of the march (it read 0).
- staggered bodyScheme refuses a torsional End A on a body or rod,
  bending-pinned included: it drove the cable end by translation, so
  the torsion frame stayed frozen while the body rolled.

test_rod_end_torsion: on an inclined Fixed J-tube with normals in
global axes, two turns give Torq = GJ Phi/L to 1.1e-9, the same torque
as from a Fixed point to the printed digits, equal normals and
pretwists 8e-13 of GJ Phi/L (0.125 without the frame conversion),
Rod1M = M_t a to 1.1e-8, a 1 s march and a bending-pinned End A the
same; on a rod fixed to a body rolled 10/-20/35 deg and released, the
torque follows GJ (Phi - theta)/L to 4.1e-11, the returned moment lies
along the turned line axis to 2.9e-7, Rod1M carries it to 2.0e-7 (old
code: 0, an error of 1.0), the roll follows the torsional pendulum to
1.0e-4 of Phi; Pinned, Free, Body<N>Pinned and Coupled rods and the
staggered scheme stop by name. The multibody march has no restart
path. Full suite passes; all 53 example decks are bit-identical. The
Python deck validator mirrors the refusals.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
…vice

- normalize_stock_endpoint_order turns a finite-EI line written anchor
  first onto a rod end (NodeA a Fixed point, NodeB R<N>A/B) around, with
  its END CONNECTIONS ends, reference directions, normals and pretwists
  swapped as the other swaps do: such a line runs only from the rod
  (End A) to a Fixed End B, and the stock row stopped with "two moving
  ends". An EI = 0 line to a rod end keeps its written order, so no
  existing deck changes. The finite-EI test reads the SECTIONS line
  types by name (they are resolved later).
- A finite-EI line whose End B is a rod end (a line between two rods, a
  J-tube to a J-tube) stops with a message that says so and gives the
  remedy (a Fixed point at the rod end), for the torsion and the
  bending END CONNECTIONS checks, instead of "two moving ends". The
  cable holds End B at a Fixed point only, and its End B reaction does
  not reach the rod's loads, so this is not lifted here.
- The rod refusal advises a Fixed rod, a Body<N> rod, a Rigid6 body
  point or a Fixed point: a deck with a rod runs on the multibody march,
  which takes no Coupled End A for a finite-EI line.
- clamp_object_frame carries Nx into the rod frame only on a Fixed rod;
  a free or pinned rod's march frame differs by a roll (torsion is
  refused there), as its docstring now says.
- The reference route of test_rod_end_torsion is a held Coupled point
  (the standalone finite-EI march takes no Fixed End A): test text and
  CHANGELOG say so.
- test_native_model collects leftover models before it tracks close():
  a model of an earlier test collected inside it made the test depend
  on the garbage collector's timing.

The anchor-first J-tube deck runs bit for bit as the rod-first one; an
anchor-first line onto a Pinned rod meets the Pinned rod's refusal; a
line between two Fixed rods stops by name. The Python deck validator
mirrors the swap and the messages. Full suite passes; all 53 example
decks are bit-identical.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
The torsion routes were built one at a time, so a line restrained in
torsion at one end only (its other end free to twist) still fell back to
no torsion, with a note, under ATTACHMENTS, CONTROL, nModes and a rod
End A. Now that the routes coexist those rules are lifted.

- resolve_one_end_torsion (and its Python mirror) no longer notes
  ATTACHMENTS, CONTROL or the modal analysis; a restrained End A may be
  on a Fixed rod end, as on a line restrained at both ends (free, pinned
  and Coupled/Vessel rods keep a named note).
- The torsion stage after the attachment polish handles a free end:
  one_end_state takes the stage's final mesh (l0 after the polish, which
  has taken over l0_am; reading l0_am there crashed).
- CD_HermiteCable_Dyn_Twist_Hessian skips a free end (no spring): it took
  it for an elastic end of compliance 0, so the modal stiffness was not
  finite.
- The staggered body scheme refuses a torsional End A only when End A is
  restrained (line_torsion_at_a), not for a line free there.

Gates (each fails on the code before this commit; the lin and route
gates confirm combinations that already ran):
- torsion_one_end T1: a vertical GJ|K cable (99 m over 100 m) with two
  clumps and a buoy (net 14.6, -9.1, 5.8 kN), free at End A and at End B:
  Twist1 = -(K/GJ)(H - L0) to 8.5e-9, end tensions to 2.9e-9, no torque,
  the mid-line twist from the module tensions to 3.9e-4 (first order in
  the mesh: 1.9e-4, 9.6e-5 at 80, 160 elements); T2: neutral modules on
  the rolled line keep the continuum response to 9e-4. Before: the twist
  channels stopped ("not combined with ATTACHMENTS"); with the rule
  lifted but l0_am read, a crash.
- control_torsion O: a CONTROL deck on the aggregate, free at the
  controlled fairlead or at the anchor, paid out 0.2 m: Twist1 =
  -(K/GJ)(H - L(t)) to 3.7e-11, no torque (8.2e-11 of K eps), mean held
  tension (EA - K^2/GJ) eps to 1.2e-4. Before: refused at init.
- modal_torsion_deck 3: the clamped line free at End B / End A: the
  torsional modes are the clamped-free chain's to 8e-10, the quarter-wave
  within 1 - sin x/x (6.4e-5 on the first), the first shape
  sin(pi s/(2L)) to 5e-10, the other modes those of TorsStiffness Free.
  Before: no twist columns; without the Hessian fix: a non-finite matrix.
- lin_torsion O: the free end's angle is a state, the twist modes of A
  the clamped-free chain's to 2e-14, the reduced roll stiffness 0 (End B
  free: C A^-1 B cancels the feedthrough GJ/l_e; End A free: no column);
  openfast_lin_torsion.py gains the straight line free at End B, run in
  OpenFAST: 100 twist states, the clamped-free chain's modes to 2.5e-13,
  4.1e-5 below the quarter-wave on the first, roll stiffness 0 (the other
  two decks unchanged: 5e-14, GJ/L to 7e-15, lazy wave 4.9e-4).
- rod_end_torsion 4: on the Fixed J-tube, free at End B or at the rod
  end, Twist1 = -(K/GJ) dl to 8.5e-9, the held Coupled point's to the
  printed digits (before: noted, "a rod has no spin angle"); a rod-end
  line with two clumps and a buoy equals the held point's torque and
  twist.
- mixed_route_torsion 7: three buoyancy modules on the gate-2 line: the
  single-line and mixed routes agree within the gate-2 tolerances (1.15
  printed units, end loads 2.1e-5 of their range).
- Python parity: the one-end verdicts with nModes, ATTACHMENTS and Fixed
  and pinned rods against the native driver.

Also: the doc and comment sentences on the one-end rules, the deck
driver's torsion note and VALIDATION T-17.

Full suite and Python tests pass; all 53 example decks are
bit-identical to the reference.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
@SMI-Lab-Inha

Copy link
Copy Markdown
Owner Author

@codex review

@chatgpt-codex-connector

chatgpt-codex-connector Bot commented Oct 30, 2026 •

Copy link
Copy Markdown

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review Status Commit Review trigger
📝 Code Review ✅ Completed 2026-10-31T00:00:17.585184Z a463acb Manual request
ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

@read-the-docs-community

read-the-docs-community Bot commented Oct 30, 2026 •

Copy link
Copy Markdown

Documentation build overview

📚 CableDyn | 🛠️ Build #35536988 | 📁 Comparing a463acb against latest (fd1936d)

  🔍 Preview build  

31 files changed · ± 31 modified

± Modified

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: e25f2a6cb4

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment thread src/CableDyn_DeckDriver.f90 Resolved
The endpoint-order check bound finite_ei to a bool where _validate had
already bound it to the list of a line type's EI values; strict mypy
rejects the reassignment. The flag is now line_is_finite_ei.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
@SMI-Lab-Inha

Copy link
Copy Markdown
Owner Author

@codex review

@chatgpt-codex-connector

Copy link
Copy Markdown

Codex Review: Didn't find any major issues. Breezy!

Reviewed commit: edcc286ff8

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

CD_Init_Deck_Aggregate parses the deck caller-driven, so
resolve_one_end_torsion took a standalone TMax = 0 mixed deck for a
dynamic run: without alpha_force_blend a line restrained in torsion at
one end was left unsolved in torsion, and asking for its Twist or Torq
channels refused an otherwise supported static deck. parse_deck now
takes the static_run flag the aggregate already has and resolves such
lines as in a static run.

Gate 6 of mixed_route_torsion: the static one-end deck with Torq1N1 and
Twist1 runs (torque at the free end 0 N m; refused before), and the
dynamic one still stops with the named force-blend message.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
@SMI-Lab-Inha

Copy link
Copy Markdown
Owner Author

@codex review

@chatgpt-codex-connector

Copy link
Copy Markdown

Codex Review: Didn't find any major issues. Can't wait for the next one!

Reviewed commit: a463acb0e0

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

@SMI-Lab-Inha
SMI-Lab-Inha merged commit e992e9f into dev Oct 31, 2026
20 of 21 checks passed
@SMI-Lab-Inha
SMI-Lab-Inha deleted the feat/torsion-routes-b branch October 31, 2026 01:40
SMI-Lab-Inha added a commit that referenced this pull request Oct 31, 2026
…rs or two objects, TURBINES rows turning both end frames (#75)

A finite-EI (cubic-Hermite) line may now have two moving ends: End B on a
Coupled/Vessel point (a cable shared by two floaters, a FAST.Farm shared
line), standalone, in OpenFAST, FAST.Farm and the C API, and End B on a
Rigid6 body point or a rod end on the standalone multibody march (a cable
between two objects). Both ends are driven, carry END CONNECTIONS and torsion,
and return their loads to their hosts or objects.

Base: dev e992e9f (#74); the series is rebased onto it from 6195432 (#71),
past #72, #73 and #74.

- HFMF boundary: a second driven end at internal node 1 (moving_b), with its
  own parent frame, end connection and torsion frame (the frames of both ends
  turn with their parents), its mirror block in the restart state, and a held
  End B (at rest, target equal to the committed position in either frame) that
  steps exactly as a Fixed End B.
- Standalone: motionFile, vesselMotion/vesselRAO, TURBINES rows and the roll
  column drive End B as End A; Phi = Pretwist(B) - Pretwist(A) - roll(A) -
  roll(B), the roll of an end free in torsion twisting nothing. TURBINES
  decks start each end's Ez/Nx in its turbine's PtfmInit axes and turn both
  frames with the rows' rotations, as FAST.Farm does.
- Aggregate, OpenFAST, FAST.Farm, C API: End B on a moving column of its own
  (cable_col_b), the turbine map, host orientations at both ends,
  CableDyn_GetCoupledLayout with the End B blocks; OpenFAST linearisation of
  such a cable fails closed (the linearisation of torsion from #73 stays for
  every other line). On the standalone mixed deck the roll columns of both
  ends twist the line.
- Multibody march: End B's attachment, frames and loads (cab_*_b); the
  monolithic step re-steps a cable between two objects at every outer
  iteration and couples both objects' junction coordinates through its
  finite-difference end-to-end stiffness in the one Newton matrix; the
  static passes balance both objects on the cubic-Hermite end loads,
  accelerated by Anderson mixing (a stiff EI 1e6 clamped cable between two
  unequal moored bodies, out of their plane: 8 passes either direction, where
  the plain passes diverged); the staggered scheme takes pinned ends. A
  pinned cable with one moving end is coupled at the predictor whichever end
  that is, and an end on a fixed rod's end is the Fixed end there, so the
  result does not depend on the line's direction. A partitioned coupling was
  measured and not taken: on a stiff taut cable (EA 1e8 N) between 200 kg
  bodies at dtM 0.05 s it needed 9.2 mean outer iterations and 300 step
  halvings over 100 steps, the joint form 3.9 and none. An End B on a
  Free/Connect point, a Point3 buoy or a Coupled/Vessel point stays refused
  there by name.
- Validation (native and the Python mirror): END CONNECTIONS and torsion
  admit those End B points; staticsFriction asLaid is refused on a moving
  End B.

Where it meets the torsion routes of #73/#74 (one restrained end, torsion on
Fixed and `Body<N>` rod ends, prescribed motion on the mixed deck):
- check_torsion_line is the union of both scopes. Two cases neither solves are
  refused by name, natively and in deck_file.py: torsion at an End B on a rod
  end, and a rod End A restrained in torsion with a moving End B. A bending
  END CONNECTION takes any End B that holds a frame (ROD_END_B_NOTE is gone).
- The restrained end decides, not any torsion on the line
  (line_torsion_at_a/line_torsion_at_b): connected_end, cab_clamp_b, the End B
  staggered refusal, the static pass tolerance and pinned-end skip, the roll
  columns, and the torsion turn limit of both bodies (an end free in torsion
  is not limited). clamp_object_frame takes the Fixed-rod normal of the end it
  frames; `Rod<N>` connection moments include End B.
- Mixed deck: build_aggregate_motion now follows the two-ends moving-set order
  (End A columns, then End B columns) and cable_two_ends imposes
  Phi_0 - roll(A) - roll(B). Before, a deck whose End B point came first was
  refused and otherwise the roll did not twist the line (gate 8 below).
- test_cable_between_bodies D: a Fixed-to-rod-end line and its reversal now
  write one output, since #74 turns a Fixed-to-rod line around as dev turns a
  Fixed-to-body line.

Result changes:
- The finite-EI compatibility (Cosserat) deck route is retired. Only three
  test decks reached it, all refusals or a run-only smoke; on four
  shared-line decks it failed to converge (three) or reached a static
  FairTen of -6.1e8 N (one), and the Hermite route runs all four. Decks with
  a line between two moving points now run on the Hermite route.
- A torsion frame at a bending-pinned body or rod End A is refused on
  bodyScheme staggered (it ran with the frame held still and could spin the
  body through +-180 deg); the monolithic scheme turns it with the body.
- Standalone TURBINES decks: an end on a `Turbine<J>` point takes Ez and Nx in
  the turbine's axes (turned by PtfmInit) and its frames turn with the
  TURBINES rows. Decks whose turbines start rotated or whose rows rotate,
  with end connections or torsion, change: on a clamped line twisted 90 deg
  between turbines rolling 10 deg in opposite senses the end torque at 1 s is
  613.6 N m (788.1 N m before), tensions within 5e-7. No example uses
  TURBINES rows.

Gates:
- tests/test_two_moving_ends: a held Coupled End B writes the Fixed End B's
  files byte for byte (also at a 37 deg chord heading and in the modes); a
  symmetric cable whose ends move apart stays mirror-symmetric (4e-11 m); a
  rigid translation keeps the end loads (4e-5 N of 1.6e4 N); End B driven
  equals the reversed line driven at End A (1e-3 N; turning clamped End B
  2e-5 N, 4e-7 N m); equal rolls keep the torque (3e-6 N m), opposite rolls
  change it by GJ (2 phi)/L (5e-6 N m); restarts bit-identical; FAST.Farm
  aggregate vs standalone: shared line 7e-3 N of 1.9e4 N, yawed turbines with
  torsion 7.6e-9, rolling turbines 3.4e-8 in every channel.
- tests/test_cable_between_bodies: two mirrored bodies stay mirror images
  (monolithic clamped and staggered pinned, to the output precision); a body
  joined to a 1e15 kg body equals the body-to-Fixed line of the established
  route to 8e-9 (clamped, and twisted 90 deg); two free bodies with no
  external load keep the total linear momentum to 3e-5 and the energy to
  0.2 %; a 90 deg twist returns equal and opposite torques GJ Phi/L (sum
  below 2e-10 N m); a moored pair starts balanced and stays at rest, its
  connection moments turning it from the pinned pitch; the stiff unequal pair
  converges forward and reversed to one equilibrium the still dynamics hold,
  and with its passes limited fails closed naming the line; either direction
  of a Fixed-point-to-rod-end cable gives the same output, and an End B on a
  fixed rod's end is the Fixed End B; a body-to-rod-end cable runs; refusals
  name their cause (the staggered torsion End A included).
- tests/test_mixed_route_torsion gate 8: a line twisted 90 deg between two
  Coupled points beside a chain, both ends rolled by the roll column: rolled
  oppositely the twist stays 90 deg exactly (torque GJ Phi/L to 3.4e-6 N m);
  rolled equally 15 deg it is 90 - 2 roll to 5.0e-7 deg (4.7e-6 N m; the old
  code 30 deg and 262 N m); End B's point listed first gives the same figures
  (the old code refused the deck).
- tests/test_rod_end_torsion, python/tests/test_deck_native_parity: the End B
  rod-end refusal and the shared staggered message.
- Python validator: mirrors the march's End B refusals, the staggered refusal
  of a connected or torsional end at either end, and the two new torsion
  refusals.
- C API and Python: host rotations at both end frames, the coupled layout
  driven through the documented host recipe, the asLaid mirror.

Commits: the two-moving-ends commits rebased one by one, the three multibody
commits (a finite-EI line between two objects, its review fixes, the Python
mirror) as one with the torsion-route integration, then the Intel ifx #5151
continuation fix and the mixed-deck roll fix with gate 8.

Two fixes from the checked Debug CI job:
- `end_b_at_rest` no longer indexes `pdof_b` when End B is not driven
  (Fortran does not short-circuit `moving_b .AND. .NOT. end_b_at_rest(...)`;
  Release read a stray value it then discarded, Debug stopped on it).
- A rod numbered as a body is no longer one of the body's attachment points
  (also in 0.3.0): a `Rod<N>A/B` end point keeps its rod's id where a
  `Body<N>` point keeps its body's, and the body's point list took both. New
  gate `body_rod_numbering`: the same deck with the arm rod numbered 1 and 3
  now writes identical outputs; before, 200 of 203 rows differed (arm pitch
  172 deg, body pitch 1.06 deg, a leg tension 3.0 kN in 1 s).
The 25 tests the Debug job failed and the new gate pass on a local checked
Debug build.

Full ctest (341/341) and pytest (python/tests and tests with the native
driver: 2179 passed, 75 skipped) pass; ruff check/format and mypy clean (the
three numpy-stub notes dev already has aside), pre-commit clean, docs build
with warnings as errors, no symbol both in a PUBLIC list and declared PUBLIC.
A/B against the reference driver: 53 of 53 examples byte-identical.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
SMI-Lab-Inha added a commit that referenced this pull request Oct 31, 2026
GitHub retires the `macos-14` runner image on 2 November 2026, and its scheduled brownouts
already cancel the `wheels / macos` job (#73, #74, #75: "Cancelled after 1s", annotated as a
macOS 14 brownout, actions/runner-images#13518).

- `.github/workflows/wheels.yml`: the macOS wheel builds on `macos-15` with
  `MACOSX_DEPLOYMENT_TARGET=15.0`, the oldest macOS its Homebrew gfortran and OpenBLAS bottles
  support there, so delocate accepts the bundled libraries. The wheel tag becomes
  `macosx_15_0_arm64` (0.3.0: `macosx_14_0_arm64`).
- The installation page, the README and the CHANGELOG (`Changed`) say the macOS wheel needs
  macOS 15 or newer on Apple silicon; on macOS 14, build from source.

No code change. Docs build with warnings as errors locally; the `wheels / macos` job of this PR
is the build and smoke test of the new wheel.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
SMI-Lab-Inha added a commit that referenced this pull request Oct 31, 2026
…, on lines as long as their span and on bodies with pinned cables (#77)

## What changed

Six accuracy items from the open list, rebased onto dev (#73 torsion linearisation, control and modal analysis, #74 torsion on the mixed deck, at one end and on a rod end, #75 lines with two moving ends, #76), one commit that closes where they meet dev's newer routes, and four fixes from an independent review.

- **Dry weight of an `EI = 0` line above the surface.** With a seabed the march gives the part of a line above the still-water level its dry weight; the static start kept its buoyancy. `CD_Static_Line_Equilibrium` now carries the dry part as a fixed point on the wetted lengths. A chain hung from 5 m above the surface starts in the march's equilibrium (holds to 1e-10; before 1e-3 of its fairlead load in the first step), and the coupled and standalone starts agree to 1.4e-8 (before 2.4e-4).
- **The same dry weight in the force balance of `Connect`/`Free` points, bodies and rods** (`solve_body_equilibrium_core`, its warm and cold line solves, the new `CD_Static_Line_Dry_Load`). A 50 t `Connect` point hung by two chains from 10 m above the surface holds its position over 2 s (before it sank 1.1e-2 m). An `EI = 0` chain between two moving objects across the surface, a body point 5 m above it and a `Connect` clump, holds both (before 5.5e-3 m). In that balance a finite-EI line, carried without its bending stiffness, now takes its dry weight with or without a seabed, as its cubic-Hermite cable does: a body with a light pinned cable 5 m above the surface on a deck without a seabed holds its heave to 7e-6 m (before 2.8e-3 m).
- **`ATTACHMENTS` above the surface.** The march loads an attachment above the free surface with its weight alone, while the attachment polish and the torsion stage after it kept its buoyancy. Each solve now takes every attachment's load for the side of the surface its node is on, and the final solve is repeated until no attachment changes side. A 500 kg, 0.2 m³ module 3 m above the surface held the fairlead load over 1 s to the output's 8 digits, restrained in torsion as well (before it moved by up to 6.1e-2). An attachment carried above and below the surface on alternate solves (a net-buoyant module that would float, which a point attachment cannot represent) fails closed, and the message leads with that attachment's index, Mass and Volume.
- **A pinned cable with `ATTACHMENTS` in the body static balance.** The object solve left a bending-pinned End A free in torsion to its cable without bending stiffness, which carries no attachments. Such a line now takes the static passes of a connected end. On a moored body with a 2 t clump on a pinned cable the body holds its pose (before it drifted by up to 2.9e-2 m and 0.20 deg in 5 s).
- **Current gradient in the finite-EI static tangent.** A depth profile is sampled at the node elevations and a current grid at the node positions, so the drag moves with the nodes. The Newton tangent now carries that: the drag tangent matches central differences to 4e-10 to 1.7e-9 (before 5e-2 to 0.2), also at the twisted equilibrium of a line restrained in torsion with `GJ|K` (4.3e-10, before 5.4e-2). The equilibria do not change beyond the solver tolerance; Newton converges faster in strong shear (16 instead of 23 iterations).
- **Force-scale floor for a finite-EI line as long as its span.** The static start of a neutral line whose length equals its span failed with neutral or drag-area `ATTACHMENTS`: the polish stalled at the round-off of the axial forces. For a line whose chord is at least its length, the convergence scale now includes that floor over the tolerance, as on the `EI = 0` path. Such lines now start straight and unloaded, also between two moving ends, restrained in torsion at both ends or at End A only, and with a chord 1e-8 longer than the line (0.1 N to 2.2e-7 N). All of these failed on dev.
- Docs: the linearisation at an accelerating coupled point (`doc/openfast.rst`, `VALIDATION.md`), and the carry spin of a held end section, measured and left out (`doc/theory.rst`; the modal analysis and the OpenFAST linearisation of #73 leave it out as well).

## Review fixes

- **The attachment with no static side is named** (`attachment_static_polish`, `torsion_after_attachments`): a 200 kg, 2 m³ module 50 m along a slack cable stopped with only "the homotopy stopped at load fraction 0.625000"; every later failure now leads with the attachment that crossed the surface (`static_dry_weight` 9). On dev the same deck ran with the module 4.5 m above the surface and its buoyancy kept.
- **A pinned cable with `ATTACHMENTS` on a `Point3` buoy** is refused by the existing `Point3` message instead of an END CONNECTIONS message for a deck without that row (`line_attachments` 10).
- **The body passes of a pinned cable with `ATTACHMENTS` are Anderson-mixed**, as the passes of a line between two objects are: on a spar rod with a 1500 kg clump on a pinned cable the plain passes diverged (end-load change 2.9 of the force scale after 60) and the deck stopped; they now converge in 26 and the rod holds to 8 digits over 3 s (`line_attachments` 11).
- **Every bending-pinned finite-EI line on a Rigid6 body or a rod end takes the (mixed) passes**, with or without attachments: the stand-in without bending stiffness put a spar rod's start 5.7e-2 m off equilibrium (7e-2 m drift and a 2.3 % leg tension change in 3 s); it now holds to 8 digits after 4 passes (`line_attachments` 12; before 1.8e-4 m in 0.1 s). This changes the static start of user decks with a pinned finite-EI cable on a free body or rod by the bending share of the end force; no example deck has one.
- **Body passes that do not hinge on round-off** (after the Linux Release job failed `line_attachments` 11 with no convergence in 60 passes, where Windows took 26): the core solve's stand-in cable now carries the line's `ATTACHMENTS` smeared as net weight, as the Hermite statics smear them, so the passes correct only the lumped, surface-side, drag and bending differences (the whole 15 kN clump load before); a failed pass set is repeated once on the stand-in without attachments; and the Anderson column-drop bound is 1e-6 instead of 1e-10 (a pinned end's residual spans fewer directions than the history, so later columns were round-off with coefficients near 1e12). Gate 11 converges in 6 passes, geometrically. New gate 13: the same deck with a leg anchor moved 1 ulp either way gives the same rod pose to 1e-9 m in 6 passes each (before 26, no convergence after 60, 26). Across a 45-deck sweep of rod and body decks (clump mass, cable length, rod mass, start offsets, 1-ulp and 1e-14 m moves) 42 converge, 34 before; the two-object decks are unchanged. Gates 11 and 12 march at `dtM` 0.002 s, because the explicit coupling of a cable to a free rod on this branch is unstable at 0.01 s (fixed separately in the next PR).
- Known and left: the as-laid friction reference still takes an attachment's net in-water weight, which matters only where the seabed rises above `z = 0`.

## Rebase notes

- Conflicts were only in `CHANGELOG.md` (entries kept side by side), `doc/openfast.rst` (the torsion linearisation paragraph of #73 kept, and the zero-frequency paragraph replaced by this branch's operating-point version) and `doc/theory.rst` (the carry-spin paragraph placed before #74's free-end section). The source files merged cleanly. `cached_line_solve`, `prepare_line` and `warm_line_solve` sit on #75's two-ends object solve unchanged: the line cache already treats both ends alike.
- The carry-spin commit message no longer says the modal analysis refuses torsion.

## Gates

- `static_dry_weight` 1-8: gates 1-5 as before. Gate 6: a module above the surface, plain and restrained in torsion (0; before 6.1e-2), and a submerged module as guard. Gate 7: a pinned cable above the surface on a body without a seabed (7e-6 m; before 2.8e-3 m). Gate 8: an `EI = 0` chain between a body above the surface and a `Connect` point (0; before 5.5e-3 m).
- `line_attachments` 8 (continued) and 9: two moving ends, torsion at one or both ends, and a chord above the length, each of which failed on dev; the pinned cable with a clump on a moored body (1e-9 m; before 2.9e-2 m).
- `hermite_static_current_gradient` 1-5, `nodal_twist_dynamic` (carry spin).

## Checks

- Full ctest (Release): 344 of 344 pass (also after the review fixes; base now dev 1a8a606, #76 touched only CI and docs). On the checked Debug build (`-fcheck=all`) the added and touched tests and their neighbours pass, 12 of 12: `static_dry_weight`, `line_attachments`, `hermite_static_current_gradient`, `nodal_twist_dynamic`, `hermite_cable_static`, `hermite_torsion_static`, `torsion_attachments`, `torsion_one_end`, `rod_end_torsion`, `clamped_cable_ends`, `cable_between_bodies`, `bodies_rods`.
- pytest `python/tests` and `tests`, with the native parity tests on (`CABLEDYN_TEST_DRIVER`): 2179 passed, 75 skipped.
- ruff check and format are clean. Strict mypy shows only dev's 3 numpy-stub notes. pre-commit and Sphinx `-W` are clean, and no symbol is both in a `PUBLIC` list and declared `PUBLIC`.
- Example A/B against dev 357f9eb: 53 of 53 identical. No example has a line or attachment above the water, a finite-EI line in a profile or grid current, a line as long as its span, or a pinned cable with `ATTACHMENTS` on a body.

Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant