Repository navigation
feat(torsion): torsion on the mixed deck, at one restrained end and on a Fixed rod end, the routes combined - #74
Conversation
…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>
|
@codex review |
Codex Review SummaryThis comment shows the latest Codex review activity on this pull request.
ℹ️ About Codex in GitHubYour team has set up Codex to review pull requests in this repo. Reviews are triggered when you
Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings. |
There was a problem hiding this comment.
💡 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".
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>
|
@codex review |
|
Codex Review: Didn't find any major issues. Breezy! Reviewed commit: ℹ️ About Codex in GitHubYour team has set up Codex to review pull requests in this repo. Reviews are triggered when you
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>
|
@codex review |
|
Codex Review: Didn't find any major issues. Can't wait for the next one! Reviewed commit: ℹ️ About Codex in GitHubYour team has set up Codex to review pull requests in this repo. Reviews are triggered when you
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". |
…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>
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>
…, 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>
Squash title:
feat(torsion): torsion on the mixed deck, at one restrained end and on a Fixed rod end, the routes combinedWhat 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 = 0and finite-EI lines betweenFixed/Coupled/Vesselpoints runs on the coupled aggregate. It held its coupled ends and refused
motionFile,vesselMotionand every line restrained in torsion. The driver now marches the deck'sprescribed motion on the aggregate as the single-line cubic-Hermite route does (row 1 installed
before
t = 0, aTMax = 0run writes the static state); a vessel turns the end-connection andtorsion frames of the cables on its points, and the
motionFileroll column imposes the twist.vesselRAOstays refused with the deck waves;CableDyn_InitDeck/InitDeckAtkeep theirrefusal.
A line restrained in torsion at one end only
A finite-EI line whose
END CONNECTIONSrestrain its twist at one end only (the other endTorsStiffness Free, or no row) was noted and solved as without the columns. Where itsLINE TYPESrows giveGJit is now solved in torsion: the free end carries no torque andturns with the twist of the line, statically by
Twist<L> = −Σ (K/GJ)(l − L)underGJ|K, andin the dynamics with torsional waves that reflect at it. The
Torq/Twistchannels and rangecolumns work on such a line. A line that misses a rule (no
GJ, two moving ends, theconfiguration 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
Fixedrod (an I-tube or J-tube), whoseframe holds the End A torsion frame, with
Nxin the rod's deck axes; the ends of a rod fixed toa Rigid6 body roll with the body.
Rod<N>Mof a rod fixed to a body now includes the connectionmoment 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 bodySchemeon a body or rod. A finite-EI linewritten 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,nModesand a rod End A. Those rules are lifted (natively and in thePython validator):
final mesh, which after the polish is
l0(reading the pre-polishl0_am, which the polishhas moved, crashed);
non-finite stiffness);
Fixedrod end;OpenFAST linearisation already took a line free at one end; its gate is added.
ATTACHMENTSon 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 − rollto 5e-7° andTorq = GJ Φ/Lto 4.7e-6 N·m. No heap allocationper step.
One restrained end (
torsion_one_end,step_allocations_torsion_one_end): a straight line heldrigidly 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 kLand reactionGJ A k tan kLto 0.5 % below and above the first mode; deck statics withGJ|KgiveTwist1 = −(K/GJ) dlto 8.5e-9 and the tension(EA − K²/GJ) εto 4.6e-9; the same on thecoupled aggregate under a platform roll.
Rod end (
rod_end_torsion): two turns on an inclined Fixed J-tube giveGJ Φ/Lto 1.1e-9, theheld Coupled point's torque to the printed digits,
Rod1M = M_t ato 1.1e-8; on a rod fixed to arolling Rigid6 body the torque follows
GJ (Φ − θ)/Lto 4.1e-11 andRod1Mcarries it to2.0e-7.
Routes combined (VALIDATION T-17; each of the first five fails on the code before the last
commit):
torsion_one_endT1: verticalGJ|Kcable with two clumps and a buoy (net 14.6, −9.1, 5.8 kN), free at End A, then at End BTwist1 = −(K/GJ)(H − L0); tensions from the module weights; mid-line twist from the piecewise tensionkL = π/8)control_torsionO:CONTROLdeck on the aggregate, free at the fairlead, then at the anchor, paid out 0.2 mTwist1 = −(K/GJ)(H − L(t)); no torque; mean held tension(EA − K²/GJ) εK ε; 1.2e-4modal_torsion_deck3: the clamped line free at End B, then End A2 √(GJ/Irn)/l0 sin((2n − 1)π/(4N)); quarter-wave within1 − sin x/x; first shapesin(π s/(2L)); other modes =TorsStiffness Freerod_end_torsion4: J-tube line withGJ|K, free at End B, then at the rod endTwist1 = −(K/GJ) dl; the held Coupled point'slin_torsionO (shell recipe) andopenfast_lin_torsion.py3 (OpenFAST): the straight line free at End B, then at End Ax²/6; roll stiffness 0C A⁻¹ Bcancels the feedthroughGJ/l_e)rod_end_torsion4: two turns, two clumps and a buoy on the J-tube linemixed_route_torsion7: three buoyancy modules on the roll-column lineAblations: 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
GJrow now carry the twist in their dynamics: on a swayinglazy-wave cable with
GJ|Kthe tensions move by up to 1.5e-4 (7e-8 in a planar heave). A linerestrained 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,FairTen1126885 to126857 N,
Body1Ry0.3004 to 0.2984°; the march then differs by up to 2.6 % atdtM0.05 s);clamped there, by about 1e-7. OpenFAST checkpoints of such decks written before do not reload.
Rod<N>Mof 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:
doc/driver_format.md,doc/capabilities.rst,doc/openfast.rstanddoc/troubleshooting.rstrewritten 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;
TORSION_NEEDS_ORIENTATIONand its Python mirror: the C API'sInitDeck/InitDeckAtonly (the mixed deck now turns the frames);torsion_note, which now returns fora 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) andits roll-column map take the one-end rule (
line_torsion_at_a: a free End A takes no roll);normalize_stock_endpoint_ordertakes the line types (rod end) and is followed byresolve_one_end_torsion(one end);test_step_allocationsdispatchesfree,motion_rollandmotion_vessel;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_Aggregatecounts the host bodies with #72'sCoupledPinnedones, the aggregate takes both #72's start accelerations and the deck'sprescribed motion, the mixed deck still refuses MoorDyn-C
Currents 1/2/5, andtest_step_allocationsdispatchescurrent_gridbeside the torsion and motion gates. Everycurrent sample in the torsion code goes through
deck_current_velocity(opts, position, time, ...).python/tests/test_native_model.pyis 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 thosetwo commit messages still name a change they no longer make.
Checks
pytest python/tests tests(2126 passed, 121 skipped; thenative parity tests with
CABLEDYN_TEST_DRIVER: 221 passed); ruff check/format clean;pre-commit clean; the docs build with
-Wclean.