Repository navigation
CableDyn 0.2.0 - #32
Conversation
The modal and stack_modal tests stopped with an access violation inside openblas.dll on some hosted CI runners, and on every run on an AMD Zen 4 workstation. The fault is in OpenBLAS 0.3.34, not in CableDyn: a plain DGEMM with an inner dimension above 128 reproduces it with no CableDyn code loaded, and 0.3.33 runs the same calls cleanly. OpenBLAS 0.3.34 enlarges the GEMM blocking on AMD Zen 4/5 CPUs that expose AVX-512, and its Zen and Haswell DGEMM kernels then overrun their stack buffer. It is reached in builds without the AVX-512 kernels, such as the conda-forge Windows package, and with a forced OPENBLAS_CORETYPE (OpenMathLib/OpenBLAS#6013, #6021, fixed upstream after 0.3.34). The dense DSYGV reference of test_modal reached it; the solver's banded LAPACK calls never pass DGEMM an inner dimension above 128, and the release executables use reference LAPACK, so results are unchanged. The CI failures were intermittent because only some runners expose AVX-512. Exclude 0.3.34 in environment.yml, which CI also uses, so that the next OpenBLAS release is admitted, and record the cause in the changelog and the troubleshooting table of DEVELOPMENT.md. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Profiling the release build showed the directional-sea kinematics(CD_Sea_Kinematics, the deck's wavetrain rows and spectral seas) taking80 % of a chain run in a two-train sea. For every node, step andcomponent it computed the phase cosine twice (for the elevation andagain for the kinematics) and two exponentials for the depth profile.The cosines of the elevation pass are now kept for the kinematics pass(up to 4096 components; any further ones are recomputed), and thedepth profile uses EXP(-k (z + 2h)) = e2kd / EXP(k z) with the table'se2kd = EXP(-2 k h), as the JONSWAP component path does. A componentwhose EXP(k z) or e2kd underflows, or a call at another depth than thesynthesis, takes the second exponential instead; the sea now recordsthe depth of its synthesis for that test. With the release build thetwo-train chain example runs in 1.57 s instead of 1.89 s (-17 %).The formulas are unchanged. With gfortran the outputs of the twodirectional-sea examples are bit-identical; with IFX the reuse removesa fused sin/cos evaluation of the second pass, and one channel ofchain_torsethaugen_spread.dat differs by one unit in its eighth printeddigit at isolated rows. A new unit test checks the kinematics against adirect per-component sum, with all cosines kept, with cosines past thekept length, with underflowing exponentials, and at another depth.Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Speed work on CableDyn needs to know where a run spends its time, on any build and any deck. Until now the only breakdown was the profile of the OpenFAST module and the finite-EI step counters, which no standalone run could switch on. With CABLEDYN_PROFILE set (the variable the OpenFAST module already reads), the driver prints, before the success line, the wall time of input parsing, initialisation and statics, and the dynamic march, split into the fluid sampled by the driver, the line, cable and object steps, the checks, the outputs and the progress report, with the time per step. It also prints the EI = 0 line steps and their Newton iterations, and the finite-EI cable step counters and times on the routes that step their cables in turn. The profile tracks the running phase: CD_Profile_Enter charges the time since the previous mark to it and starts the next one, so the phases add up to the total, and a run that stops with an error keeps its time in the phase it stopped in. Every march marks where its fluid update, step, checks, outputs and progress report begin, and counts a step once it has passed its checks. The EI = 0 counts are taken in CD_Step_Model with atomic updates, because lines step in parallel. Unarmed, each mark is one test of a flag. The profile only reads the clock: every output file of the eight example decks tried, one per route, is byte-identical with and without it, with one OpenMP thread and with the default. A unit test checks the partition, a failed run's phase and the OpenMP counts; driver tests check the report on the EI = 0, finite-EI and failing routes. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Profiling a buoy with a clamped power cable showed 77 % of the run in cable steps: 4849 of them for 600 march steps. Each monolithic step took one outer iteration, then rebuilt the junction Jacobian, whose clamped- cable part is six finite-difference columns, each re-stepping the whole cable from the step entry, and converged at the second iteration: eight cable steps per step. The cable columns are now kept per cable and reused across steps, with the refresh rules of the mooring lines' condensed tangent: rebuilt on a step's first Jacobian when they are 20 steps old, when the previous step needed more than two outer iterations, or when the step size changed (step halving), and on every Jacobian from the third outer iteration on; a failed step discards them. A fresh build adds the same values as before. The cache spans the largest junction group, a body's six coordinates plus three for each rod pinned to it. examples/buoy_clamped_cable.dat runs in 2.25 s instead of 6.60 s with the release build, with the same mean outer iterations (2.01). The junction still converges to its tolerance, so results change within it: tensions by about 2e-6 relative, the body position by under 1 um, the body pitch moment by 2 N m on a 11 kN m channel. Against a run converged to 1e-10, the previous code already differed by 1.7 N m on that channel; at that tolerance both versions agree to 7e-8. Decks without a clamped cable are unchanged. A new test deck runs a clamped cable on a body that also holds a pinned rod. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Torsion of finite-EI lines was the main feature of 0.1.1 but ran in the standalone driver only: the coupled entries refused any torsion column. Most of what the coupled route needs was already in place. The cable module turns a parent-attached End A frame with the host orientation, returns the torque moment with the connection moment, substeps a large turn within a step, and carries the unwrapped twist in its snapshot and checkpoint mirror. The OpenFAST and FAST.Farm shells pass the platform orientation every update. The aggregate and the single-cable entry now take a host_orientation flag, which the shells set: with it a deck with torsion columns builds, without it (the C API, the standalone mixed route, which move line ends by translation only) the deck is refused by name instead of running with a frozen fairlead frame. A coupled run is always dynamic, so the configuration blend is refused at initialisation as on the standalone route. Three shell changes complete it. The checkpoint rebuild moved the fairlead to the restart pose before it reloaded the cable mirror, so the preflight bounded the twist change against the static twist and a restart after more than 90 deg of turn failed; the rebuild now restores the torsion cables' mirror first. Linearisation now refuses a line restrained in torsion also at a bending-pinned end, whose torque stiffness the translation-only reduction would drop. The state registration subtracted the friction and force-blend slots but not the 14 torsion slots, so the velocity and position blocks were mislabelled. A new test, coupled_torsion, drives the aggregate: a rolled fairlead gives Twist1 = -roll and GJ(-roll)/L, a 60 deg/s roll the quasi-static torque at every step (bit-identical to the single coupled cable), 1.5 turns no 2 pi slip; rewind, refusal of a 100 deg non-stepping turn, PtfmInit, a FAST.Farm turbine yaw, and the checkpoint recipe after 150 deg (the previous order is refused) are checked. In an OpenFAST build, the IEA-15 MW mixed deck with its power cable restrained in torsion runs 60 s in waves and restarts from a checkpoint bit-identically. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Two items of the coupled-route validation backlog, and a build note. Linearisation. The release check gated only invariants of CableDyn's stiffness block and reported MoorDyn's zero-frequency reduction D - C A^-1 B as unusable. OpenFAST writes the .lin matrices in the .fst OutFmt, and with the usual 4-digit format D (about 1e8 N/m) cancels to a 1e4 N/m result; the same case reproduces the asymmetric block that way. openfast_lin_ab.py now writes both twins at full precision (ES24.15E3), lets MoorDyn settle, linearises at t = 0, refuses a reference with fewer than 10 digits or asymmetric above 1e-3, and gates CableDyn against it to 0.5 %. On the IEA-15 MW UMaine twin the fairlead stiffness agrees to 0.07-0.10 % (0.29 % for the transverse H/X term), the platform 6 x 6 diagonals to 0.10 %, and standalone static solves reproduce the block by finite differences to 1.5e-5. FAST.Farm. fastfarm_shared_ab.py prepares the r-test MD_Shared farm for both shared-mooring modules (identical inputs, every anchor-leg anchor tension added to the outputs) and compares complete runs only. Over 600 s, from 100 s on, tension means agree to 0.02 %, extremes to 0.25 %, platform motions to millimetres; the shared lines' tension std is 2.2-2.7 % lower with CableDyn and 1.0 % lower at half the mooring step (implicit 0.05 s step against MoorDyn's 1e-4 s explicit one). On a line with no Fixed end FairTen and AnchTen name the opposite ends from MoorDyn's; the migration guide now says so. Build. OpenFAST's CMake raises the Windows stack to 16 MB only for Cygwin and Visual Studio; a MinGW FAST.Farm.exe kept 2 MB and overflowed in ElastoDyn. DEVELOPMENT.md adds the linker flag. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
The PtfmInit and FAST.Farm checks of coupled_torsion hang a neutrally buoyant 100 m line under the fairlead with its anchor exactly 100 m below, so the static solve starts from zero tension, where it has no catenary seed and its result depends on round-off. With OPENBLAS_CORETYPE=Prescott (the workaround for the OpenBLAS 0.3.34 modal crash) the FAST.Farm check failed deterministically: the mesh-sequenced fallback stopped on a kinked state. The anchor now sits 0.5 m lower, so the line hangs taut at 0.5 % strain; the twist and torque checks are unchanged (the torsion compliance uses the unstretched length) and pass with the default, Prescott, Haswell and SkylakeX kernels. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
) A one-hour coupled OpenFAST run of the IEA-15 MW mixed deck showed the power cable's anchor tension jump from 1.22 kN to 3.1 kN about 25 s in and stay there while the platform drifted toward the anchor; without seabed friction it declined to 0.6 kN. The friction law is not at fault. The seabed contact acts at the nodes, which carry no moment, so at a held anchor end resting on the floor the consistent end moment of the end element's weight (w L^2 / 12) had nothing to react it: the free end tangent turned 1.9 deg into the floor, the element dipped 27 mm below the seabed between its nodes, and membrane locking put -47 kN to +127 kN of axial force in it about a 1.2 kN line tension. The compressed part buckles sideways once the hang-off sways, and friction locks the drawn-in nodes. The seabed now carries that end moment at a held line end resting on the floor, along the floor normal on a slope, in the statics and the dynamics, scaled by a C1 smoothstep of the inner node's elastic normal force over its half share of the element weight: a laid element keeps the full support, an element rising from an anchor on the floor gets none (its line is bit-identical to the same line without a seabed). Each energy line search holds the share of its starting point, so the potential stays a potential of the residual. The laid cable's static tension is uniform (1218.204 N); in the coupled run the anchor tension stays at a median of 1.39 kN with sub-second stick-slip peaks. Lines whose held end is off the floor are byte-identical; the shipped finite-EI examples with a grounded anchor change by at most 0.34 N. Two decks of the statics matrix change outcome, with the evidence in the matrix: LW_1015__cur_fr fails closed (its old hairpin is reachable only through compression, which its tension-only deck rules out), and CUR_1013 now finds the equilibrium with the grounded run turned sideways, because a refinement stopped on compression in a current now names the current limit and the driver retries out of the plane. The slope-polish test moves its fairlead to x = 200 m, out of a knife-edge layout that failed on Linux. VALIDATION.md records the full-turbine touchdown run. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
A finite-EI line whose static solve fails its stability test on a deck mesh longer than half the bending length (EI/|w|)^(1/3) is now solved again on the mesh that resolves that length, and accepted when stable there. A lazy-wave power cable restrained in torsion, with 10 m elements along its grounded run, stopped with "unstable equilibrium": its free-DOF tangent had one negative eigenvalue because the pointwise axial force of the stiff-EA elements oscillated into compression at touchdown (-14.5 kN to +21 kN against a 1.2-1.5 kN tension). Refinement removes it, and the positions converge as h^2. The catenary-continuation route, the mesh-sequenced route and the symmetry-broken in-current route each retry on the refined mesh (with the routes' tolerance ladder), and a planar state in an in-plane current is refined before it is classified as a physical saddle. Decks that solved before are byte-identical. A finite-EI line solved in its vertical plane starts dynamics with its out-of-plane DOFs released; the hand-off now runs one stability test with the dynamic end constraints (also on the discrete state of an attachment polish, planar or 3D) and prints a note naming the line, its coarsest element against its half bending length and the refinement that meets it. No result changes. The IEA-15 MW mixed example's power cable is meshed to the rule (248 elements instead of 87); its static tensions now match a 1 m mesh, and the one-hour full-turbine record is rerun: hang-off tension unchanged, touchdown curvature 0.109 1/m, and the anchor tension flat at its static 1.23 kN where the coarse mesh showed stick-slip peaks to 4.1 kN. The statics-matrix hang guard now scales with the configured CPU bound, so slow but healthy Debug runs are not stopped as hung. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Static equilibria over real (non-planar) bathymetry, the two failures a statics robustness campaign found that any survey grid can trigger. Finite-EI lines over a non-planar bathymetry failed even with 2 cm roughness (39 of 192 sweep runs): the catenary seed, laid on the plane fitted along the chord, was rejected as soon as a node sat about 1e-6 (L + |z|) below the real bed, the anchor walk was not allowed and the mesh-sequenced fallback ended on a kinked branch. Seed nodes deeper than their static penalty penetration are now draped onto the bed, the anchor walk runs with the walked anchor following the bed at its own height above it, and a failed walk there no longer marks the deck inadmissible. Planar beds keep the old checks; the final state is audited, stability-tested and kink-checked as before. Rough sweep 153/192 -> 192/192. EI = 0 lines resting in a crease of the bilinear bed (a trench bottom, a valley of a 2D grid) had no discrete equilibrium, because the contact normal jumps across a grid line. Each interior grid line is now rounded within a band of 5 % of the smaller adjacent spacing by the C2 fillet J (delta - |u|)^3 / (6 delta^2) of the slope jump, as a tensor product; the surface moves by at most |J| delta / 6 along one line, exactly planar grids stay bilinear bit for bit, and in a band the contact force is the gradient of the penalty potential with its Hessian as tangent, in statics and dynamics, while the friction capacity stays the scalar normal law on every route. A Fixed point at the tabulated depth of a creased node is placed on the rounded surface; one between the surfaces but near neither is judged against the rounded seabed. Trench depths 2-30 m: 5/11 -> 11/11; EI = 0 rough sweep 192/192. Rough-bed decks that solved before change by at most 0.04 % in FairTen (0.40 % for one deck settling in another valley) and up to 8.5 % in AnchTen, from removing the spurious horizontal reactions of one-sided normals; all examples and driver test decks are byte-identical. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Seabed friction in the static solve, following OrcaFlex's "As laid" policy, as the opt-in option staticsFriction asLaid. The default, staticsFriction none, keeps the previous behaviour (and MoorDyn's), which is conservative for anchor loads; every example and test deck is byte-identical under it. Seabed friction had no effect on the static solve: its springs were anchored to the frictionless still-water layout, so a grounded run on a slope with tan(theta) < mu, or laid with surplus length, still slid or folded (an EI = 0 line on a 5 deg slope with mu = 1 folded 24 m past its anchor, as with mu = 0). With asLaid, the line is assumed laid from its lower end along a lay azimuth (layAzimuth / layAzimuth<ID>, default from that end toward the other) at an as-laid tension (asLaidTension / asLaidTension<ID>, default 0, at most EA), and friction resists displacement from those positions with the regularised law of the dynamics, isotropic or anisotropic. On a bathymetry each reference node carries the normal sink of its nodal load (weight, discrete attachment loads, the turning load of the laid tension, with the surface metric), so the normal sink adds no friction deflection. The reference is laid on every mesh a static solve uses and on the final mesh for the dynamics, whose friction anchors continue the static springs (no jump at t = 0). A lay off the chord plane, or a seabed sloping across it, puts a finite-EI line in 3D. The EI = 0 and finite-EI routes, the coupled aggregate, the C API and the Python deck reader/writer/builder share it; routes that cannot apply it refuse it by name. Results with asLaid: the 5 deg line holds where laid (FairTen 714.2 -> 622.9 kN, friction within mu N at every grounded node), a 650 m finite-EI cable on a 10 deg slope solves and holds, a refined line equals its fine-mesh twin to 1e-12 m, and on a flat seabed laid at its run tension the result equals the frictionless one. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
C ABI 1, minor extension 2: calls for hosts that drive the Coupled points of a deck, CFD solvers in particular. Every existing function is unchanged. - CableDyn_InitDeckAt solves the statics with every line-bound Coupled/Vessel point at its entry of q0 (the host blocks alone, like MoorDyn's X, or the full coupled vector), on the point and the aggregate route, and checks that every host block starts at q0. A body starting away from its deck position no longer starts the lines with a transient: for foamMooring's EsfLOWC box, line 4's fairlead load moved by up to 0.38 N of 0.52 N under InitDeck; under InitDeckAt it equals the deck moved to the host positions bit for bit. - CableDyn_SaveState / CableDyn_RestoreState keep one in-memory deep copy of the model (and the aggregate's committed time) for the outer correctors of a host step; restore then step is bit-identical to stepping from the saved state on both routes, including viscoelastic, Syrope, seabed friction, point fluid fields, bodies and rods. - CableDyn_GetCoupledLayout returns the deck point id and type of every block of the coupled vector. Python: init_deck_at, save_state, restore_state, coupled_layout, host_dofs. doc/capi.rst gains "Coupling a host (CFD) solver", which compares the call sequence with MoorDyn's C API step by step. Tests: c_api_host_coupling (C, shared library), save/restore in test_c_api and test_c_api_stack (1 MiB stack), and python/tests/test_host_coupling.py. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
…fter an unfactored exit (#19) Tension-only (EI = 0) line steps drop work that repeated itself every Newton evaluation, about 10 % of a step: element kernels re-validating section data the line model validates when it is set, repeated scalar checks and message blanking in the Froude-Krylov and added-mass kernels, zero velocity Jacobians added into the band, a consistent-mass band re-assembled although its inputs had not changed, and rescans of a band and factor just checked finite. The kernels take an optional inputs_validated that the line model passes after its own check; public callers keep the full validation and every input error is reported as before. The mass band is reused while its inputs are unchanged, compared exactly, and every other writer clears the reuse. With the release build chain_range_tdp runs 16 % faster, als_volturnus_line_break_time and spar_pinned_rods 13 %, and rod_moored_spar 12 %. With gfortran every output of the 52 example decks is byte-identical; with the release build three output files differ by at most 8.6e-7 of their column maximum. The monolithic body and point coupling back-solved a line step's end tangent with its last factorization, but a fresh tangent evaluation overwrote the band before it was factored while the factored flags stayed set: a step that ended right there (accepted within the near-tolerance allowance, or converged on the fresh tangent) used an unfactored matrix. The flags are now cleared at the evaluation; in a unit test reaching that exit the end tangent was off by 2.3e5 (relative) and now agrees with an ordinary exit to 1.8e-11. No example deck takes this path. Tests: the trusted kernels bit for bit against the validating ones, the reused mass band against a fresh assembly with the expected hits and misses, and the junction tangent after an allowance exit. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Tension-only (EI = 0) lines produced silent tension spikes of 5x to
360x when parts of a line went slack, at the default rhoInf = 0.4 and
every dtM from 0.002 to 0.2 s: a light, axially stiff cable in 3 m
heave reported 4.2 MN at the fairlead against about 0.1 MN, the same
cable in an Hs 8 m sea 0.41 MN at the anchor against 0.043 MN, and a
semi-taut chain-polyester leg 9.5 MN against 4.6 MN.
Two mechanisms: the axial force was evaluated at the blended
configuration q_alpha, so a segment slack at the start of a step ended
it over-stretched; and a segment released from taut to slack within a
step returned more work than its strain energy.
- The step now blends forces, (1 - af) r(q_{n+1}, v_{n+1}) +
af r(q_n, v_n), as the finite-EI path does, for the axial force and
every dynamic load (added mass stays at q_alpha). The step-start
force is recomputed at the committed state, so no state is added and
restarts stay exact. False alpha_force_blend selects the former
scheme.
- A segment that releases within a step keeps at most the step-start
force that its stored energy W_n = T_n e_n / 2 can do over the
projected chord shortening l_n - t_n . d_{n+1}, crediting the end
share, with a consistent tangent; the bound covers rotating releases,
the kept axial-damping share and the viscoelastic and Syrope law
tensions (their end tension estimated with the law stiffness). Taut
lines that do not turn are never capped.
- modified_newton rebuilds the tangent when an iterate reduces the
residual by less than a factor four, as the manual states.
- The standalone driver audits EI = 0 lines from t = 0: a warning at
the first non-physical tension spike of a line, and notes for taut
segments turning more than 1 deg per step, for snaps whose axial
wave crosses a segment more than once per step, and for rhoInf above
0.95.
At the default rhoInf the reproducers now match their fine-step
references. Taut lines keep their accuracy: every MoorDyn-C, OrcaFlex,
analytic and experimental comparison that runs locally still passes
(the snap-load peak at 20 ms improves from 2.76 % to 1.5 %; the
Bergdahl record is rerun, RMSE 1.58 N); the OpenFAST and FAST.Farm
records using EI = 0 dynamics are unchanged within their recorded
figures. Every EI = 0 dynamic output changes; over the shipped
examples tension statistics move by at most 0.23 % (mean) and 0.9 %
(maximum), except the two line-break decks. Static runs and finite-EI
lines are unchanged; EI = 0 dynamic decks cost up to 6 % more time.
Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
…chor uplift channels (#21) Finite-EI node tension, curvature and bend moment are recovered from nodal equilibrium. They had used the element-mean axial force EA(|r'| - 1), which oscillates between elements wherever the line bends over an element and exceeds the tension by EI kappa^2 on any mesh: on the 87-element lazy wave of the IEA-15 mixed example the interior node tension dropped to -173 N against a true 1.2 kN. Each element's end forces, with its own distributed loads, seabed contact (bathymetry crease rounding included) and inertia, now give the effective tension (the axial component of the section force), the bend moment and the curvature as that moment over EI. The largest interior tension error against the converged equilibrium falls from 1552 N to 60 N on that mesh and from 516 N to 0.3 N on a 1 m mesh. A held end laid on the seabed carries the floor reaction of its half element (a laid anchor reported a spurious 903 N m); a section of very low EI reports the exact geometric curvature. Line-end values, positions and the material-strain checks are unchanged. OutputRecovery element restores the previous definitions, and CD_HermiteCable_Dyn_Curvature_Exact / CD_HFMF_Curvature_Exact keep the geometric curvature. The recovery is cached per element, keyed on the element's own DOFs, time and load configuration, so the channels of an output row share one evaluation and per-node loops stay O(n). The touchdown point is located inside the element by the parabola through the last grounded node and the next two, so it moves continuously (largest step between output rows under a surge: 4.64 m -> 0.08 m with 5 m elements); Fortran and Python agree. New channels for drag-anchor checks: AnchFz<L> and AnchFH<L>, the vertical and horizontal components of the AnchTen<L> end force (equal to Point<P>Fz/FH for an anchor holding one line), and TDP<L>Grd, the grounded length, on every route; the manual names TDP<L>Grd or AnchIncl as the no-uplift check. The Python validator refuses a coupled finite-EI cable without a Fixed End B, as the native aggregate does. Range graphs and .t.out files written every step cost about 4 % more run time. The T-6 static-profile curvature record moves from 0.056 % to 0.049 %; the one-hour coupled full-turbine curvatures are marked as the geometric definition. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
The coupled aggregate (CompMooring = 5) refused Pinned rods, and every deck refused MoorDyn-F's CoupledPinned/VesselPinned rods. Both now run on the coupled route. - A pinned rod's step advances its rotation about the pin, with the pin acceleration in the rotation equation (as MoorDyn-F) and the force the rod puts on its pin. A CoupledPinned rod takes its pin's position, velocity and acceleration from the host and returns a force and no moment; an output probe re-solves its angular acceleration at the probed pin acceleration, with the coupled-end mass of the frozen line interior. The pin moves linearly within a sub-step from the committed start values, so restarts are bit-identical; PtfmInit and the static initial condition carry CoupledPinned rods. A bare end of a Pinned or CoupledPinned rod needs no Rod<N>A/B point; CoupledPinned is refused standalone and in the C API, rods in FAST.Farm and in linearisation. - The explicit sub-step estimate for rods and bodies now bounds every stiffness acting within a step: a pinned rod's swing about its pin (weight, buoyancy, pin acceleration, both pin poses of a host pin), seabed contact (reach from the full station motion, the highest floor on its path), the waterplane of surface-piercing rods, finite-EI cables in the staggered multibody march, and the pin acceleration of a rod pinned to a body. Line-free decks and the staggered march are sub-stepped too, and a step that needs more than the 256 cap warns. - Seabed friction on rods and bodies is applied implicitly through its secant damping coefficient; it was an explicit stiff damper that made a resting rod chatter (a rod held in a cross current now creeps at 1.3e-4 m/s, against 5.3e-3 m/s before). Every shipped example output is byte-identical. Tests: the compound pendulum against the elliptic period, a held CoupledPinned node against the Pinned rod and the analytic pin reaction, pin acceleration and base excitation, sub-cycling, the probe force, snapshot/probe/restart bit identity, PtfmInit, and one test per sub-step source (pendulum without a line, surface crossing, stiff seabed, bathymetry ramp, floating rod, friction hold, cable on a rod) that fails without its term. In OpenFAST (IEA-15 MW, line 1 on a 4 m CoupledPinned rod, JONSWAP Hs 6 m), a checkpoint restart and NumCrctn = 1 are bit-identical. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
On a finite-EI line whose mesh was refined automatically, the node-indexed OUTPUT channels (Ten/Curv/BendMom<L>N<J>, L<L>N<J>p/v/a, Dec, Azi, Torq, Twist) read node J of the refined mesh instead of deck node J, silently: on a lazy wave refined from 71 to 1136 elements, Ten4N34 (the touchdown, 220 m) read 5488 N from 41 m against a true 1544 N, and BendMom4N54 (on the seabed) 1214 N m against 0. Refinement bisects elements, so every deck node is a node of the final mesh. The cable builder now maps each deck node to its final-mesh node by unstretched arc length from End A (also for non-uniform refinement; a deck node not on the mesh fails closed), and node channels name deck nodes on every route: standalone static and dynamic, mixed aggregate, multibody, OpenFAST/FAST.Farm and the C API EvalChannel. Whole-mesh outputs keep the refined mesh and say where the deck nodes are: a DeckNode column in .static.out and a # DeckNode line in .Line<L>.p.out (only on refined lines), the C API GetLineValues quantity CD_C_LINE_DECK_NODE, and Python Line.deck_nodes; the Python placement helpers use the map and raise rather than guess without one. Unrefined lines and EI = 0 lines are unchanged; every example output is byte-identical. validation/PAPER_REPRODUCTION.md is brought up to date with a re-run of the article's table: paper mode (now also element OutputRecovery) reproduces v0.1.0 in every printed digit except the two-point axial-rule row, moved by the seabed anchor-end weight moment fix; the defaults columns carry the force-blended EI = 0 step. Tests: node_channels_refined_line (deck nodes against the static profile and .elements.out, dynamic positions against .p.out, the mixed route, the C API, Python placement), Python unit tests, and seabed_friction_aniso's gate moved to the deck nodes it meant. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
…id (#24) SeaState evaluates its wave kinematics on a grid (X_HalfWidth, Y_HalfWidth, Z_Depth) and clamps a point outside it to the boundary. The r-test MD_Shared SeaState inputs, reused by the OpenFAST tutorial and examples/openfast, span 100 m and 40 m depth, so the moorings (840 m out, 200 m deep) took boundary kinematics without a message. The CableDyn shell now checks the positions it samples, at the static equilibrium and every mooring step until it has warned once, and prints one warning with the number of submerged nodes outside the grid, the farthest node per direction and the SeaState inputs to enlarge. Waves are checked in x, y and depth, a SeaState current in depth only; under Wheeler stretching the depth checked is the one SeaState interpolates at (also for a current-only host mode). A run with host waves or current refuses a nonzero MSL2SWL, since the mooring samples SeaState at positions relative to the mean sea level. FAST.Farm and still water check nothing, and after the warning the check costs nothing. The tutorial and examples/openfast now enlarge the grid (half-widths 900 m, Z_Depth to the seabed) and quote their results for it: with the MD_Shared grid the line-1 fairlead tension standard deviation was 18 % too high (0.136 against 0.115 MN). Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
At coarse steps the snap peaks of tension-only (EI = 0) lines were set by the time step rather than the physics: segments rotating several degrees per step left all-chain snap peaks 10-20 % low and semitaut peaks high, under any scheme. After a line step converges, it is now re-solved from the same committed state in sub-steps along the quintic end-motion boundary when a taut segment turned more than ei0_substep_angle (1 deg; at least 4 sub-steps, at most ei0_substep_max = 16) or a segment snapped from slack to taut above a quarter of the largest start tension at an axial Courant number above 1. ei0_substeps off restores the previous results bit for bit; paper mode (False alpha_force_blend) turns it off. Lines with an active junction DOF of the monolithic body scheme (the default for decks with bodies, rods or Free/Connect points) are not sub-stepped. At dtM = 0.1 s the Lozon all-chain heave peaks move from -14.7 / -17.2 % to -3.8 / -7.7 % of the converged values and the semitaut anchor peaks from +16 / +26 % to within about 4 %; Bergdahl, the snap-load study, the one-hour VolturnUS-S and the L2/L3 parity records are unchanged. The kept dashpot share of a segment slack at the step start is bounded by its own one-step dissipation plus the end share's credit, continuously, with a consistent tangent. The documentation now states that the undamped light-cable reproducer has no converged snap peak (converged finite-EI runs give 0.093 / 0.057 MN) and recommends physical axial damping or finite EI for converged snap peaks. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
…under the force blend (#26) Active line tensioning (CONTROL, driven by a ServoDyn cable-control channel) now works for finite-EI cables in OpenFAST runs: the fairlead-side segment changes length and rate as in MoorDyn-F, the committed force is kept across the update, and restarts and correction steps are bit-identical. For EI = 0 lines a length update entered the committed side of the generalised-alpha blend, so ramps lagged MoorDyn-F by up to 4.1 % (pay- out) and 6.3 % (haul-in) at the fairleads. The line now keeps the lengths and rates its committed state was reached with: under the force-blended step every step-start quantity uses them, end-of-step quantities the new ones, inertia the blended ones, and with ei0_substeps auto a pending change is spread over the sub-steps. A command outside MoorDyn-F's bounds stops the run by name. Coupled A/B against stock MoorDyn: ramp differences 0.13 % (fairlead) / 0.39 % (anchor) for EI = 0 lines and 0.21 % / 0.86 % for a finite-EI cable; a constant-rate pay-out matches its closed form to 1.8e-3 N. Runs without CONTROL are bit-identical. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Failure messages were cut off by fixed-size buffers along the solver chain: the tensile qualification failure of a dynamic step ended mid-advice. Every buffer now holds the longest diagnostic it can receive (the C API handle 4096 characters), lists that can outgrow their buffer end with an omission marker, and hot-path kernel buffers keep their short lengths so the step time is unchanged. Messages also name the actual cause and the workaround: weightless and neutrally buoyant lines, Coupled-to-Coupled lines, finite-EI cables on Connect/Free/Coupled points, the still-water rejection by route, and an anchor below the seabed. The initialisation report notes static fairlead strain above maxStrain (10 % if unset) and warns on any section coarser than 1/8 of its line. No acceptance rule or result changes. The controlled-cable snapshot test now marches the restored model and its reference with tangent reuse off from an uncached committed force: Restore clears both caches, so bit-identity with a copy that kept them held only by chance and failed on the Linux Debug runner. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Free and Connect points and Point3 buoys had no seabed contact of their own, so a heavy clump sank into the seabed (a 50 t clump 2.8 m). A point with Mass or Vol now rests on a footprint A = V^(2/3) with the line contact law, in the point static equilibrium and in the monolithic, staggered, OpenFAST and C API point steps; the contact is frictionless. Only clump_weight_free_point.dat among the examples changes. OpenFAST linearisation of a deck with a Point3 buoy fails closed by name. A tension-only line whose grounded run a current or a falling seabed carries past its anchor, where it folds back with zero tension, now gets a note naming the fold, its cause and the remedy that fits the deck's static friction; the finite-EI run-past-anchor note follows the same rule. The notes number segments and nodes from End A as the output channels do. No result changes apart from the point contact. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
A finite-EI mesh too coarse for its static curvature was refined as a whole, every element split by the factor the worst one needed: a 462-element lazy wave was solved on 7392 elements in 10.0 s. The static solve now splits only the elements that need it (curvature, half the bending length, the end boundary layer, an isolated contact change) and grades the mesh around them; the deck above solves on 492 elements in 0.33 s with end tensions within 4e-7. Every deck node stays a node, so node channels still name deck nodes, and decks that do not refine give identical output. The discrete-attachment polish of a lazy wave with 25 modules in a 0.3 m/s cross current on a frictional seabed diverged at load fraction 0.125. A step that does not converge is now repeated with pseudo-transient continuation, then a residual-merit line search, and halved; the state reached must pass the smeared state's checks or the solve fails closed. The deck solves within 0.2 % of its smeared twin, and polishes that converged before take the same solves. CD_HermiteCable_Static_Solve_AutoMesh takes an optional max_elements (a lower element limit than 8192; callers are unchanged), so the test of the element-limit priorities runs on a small, well-conditioned line. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
Set the version to 0.2.0 (released 2026-10-20) in every file the release metadata check names, and replace the unreleased notes with a short [0.2.0] section, one entry per user-visible change. The README links to the manual and to GitHub instead of to Markdown files, and the README and the manual state that CableDyn is not affiliated with the EPSRC-funded University of Edinburgh project of the same name. In OpenFAST a deck without dtM now solves every glue step instead of about every 0.1 s: held loads reach the platform about dtM/2 late, a negative damping that matters for stiff moorings and for tension statistics. A coarser deck dtM still trades accuracy for speed, as the console, the OpenFAST page and the known issues say. The solver builds without compiler warnings (no result changes), and the Holcombe and Bergdahl validation records are rerun with the 0.2.0 build: Holcombe is byte-identical, and the Bergdahl waveform RMSEs move from 5.95 % to 5.93 % and from 2.54 % to 2.56 %. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
The deck driver stores the seabed recompute inputs of every finite-EI cable with seabed contact (kBot, the contact diameters and cBot/kBot), so that active line control can rebuild the nodal contact coefficients after a length change, and CD_HermiteCable_Dyn_Set_Control_Seabed checked that the inputs reproduce the installed coefficients bit for bit. The deck computes the damping as kn*(cBot/kBot) and the check computes the same product, but the optimised Intel build of the release evaluates the two with different rounding: the release driver stopped examples/buoy_clamped_cable.dat with "the inputs do not reproduce the installed nodal contact damping". The gfortran builds of the test suite round both the same way and did not show it. The check now accepts coefficients within 8 units in the last place, which still rejects inputs that do not belong to the installed coefficients. Built with the release flags (Intel Fortran 2025.3.2, /Qipo, reference LAPACK), the driver of dev stops on that deck and the fixed driver runs it and every other shipped example (51 decks). Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
validation/RELEASE_0_2_0.md lists what was built and tested for the release: the source, toolchains and pins; the GNU Release, Debug and NaN-initialised Debug suites (293 of 293 each), Python coverage, the documentation, the metadata and tree audits, the OpenFAST build gate and linearisation check, and the rerun experimental comparisons; the Windows gates of the release workflow; the clean-machine check of the assets (26 checks, every shipped example included); and the asset hashes. The validation README lists it. 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: e5389b6a79
ℹ️ 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_Bathymetry_Max_Floor bounds the seabed under a horizontal box by the highest node of the cells the box overlaps, raised by a fraction of their node range for the crease rounding. The rounding band of a grid line reaches into the cells on both sides, and its slope jump depends on the nodes one beyond them, so a box inside a flat cell next to a crease got no allowance: with x = 0, 1, 2 and depths 100, 100, 90 the floor at x = 0.99 is -99.957 m, while the bound of a box around it was -100 m. The explicit sub-step estimate of rods and Rigid6 bodies could then miss a contact already under way and leave its stiffness out. The crease allowance now takes the node range of the cells widened by one node on every side (clamped to the grid); the highest-node part stays on the box's own cells. A test checks that example and a box swept across both cells; it fails without the change. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
|
@codex review |
There was a problem hiding this comment.
💡 Codex Review
Here are some automated review suggestions for this pull request.
Reviewed commit: 1a56ccddbc
ℹ️ 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 per-line OPTIONS layAzimuth<L> and asLaidTension<L> carry the LINE
id in the keyword, but DeckModel treated them as opaque scalar options:
renaming the line left the keyword naming the old id, so to_text()
failed with "OPTION layAzimuth1 names no LINE", and removing the line
with cascade=True left the rows behind.
DeckModel.references(line) now lists these rows, so remove() refuses a
line they name unless cascade is true, removes them with it, and names
them in the error ("OPTION layAzimuth2"); rename() rewrites their
keywords to the new id. A test covers rename, the error, the cascade
and a global layAzimuth row that stays; it fails without the change.
Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
|
@codex review |
|
Codex Review: Didn't find any major issues. What shall we delve into next? 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". |
The release review found two more defects, fixed on this branch (the crease bound of CD_Bathymetry_Max_Floor and the per-line friction options of the Python DeckModel), so the assets were rebuilt from the final tree (release workflow run 39457117645). The record gives their hashes and Windows gates, the Python suite of the final head (2104 passed, 99.02% branch coverage), and the clean-machine check of these assets: 26 checks and all 51 shipped examples pass. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
|
@codex review |
There was a problem hiding this comment.
💡 Codex Review
Here are some automated review suggestions for this pull request.
Reviewed commit: fff7d864e6
ℹ️ 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 touchdown point lies where the parabola through the last grounded node and the next two crosses the contact-onset height. Where the line rises sharply beyond the element, the parabola dips below that height inside the element, and its crossing lay near the suspended node: with clearances -0.001, h, 0.01, 1, 2 on unit spacing the TDP approached x = 1 as h fell to zero but jumped to about 1.97 once node 2 grounded, an artificial jump in the touchdown excursion and grounded-length histories that contradicted the documented continuity. The parabola's curvature is now limited to |qa| <= d1/l1, the bound at which it rises monotonically over the element, so it crosses once, and the crossing reaches a node exactly when the node reaches the onset height from either side. Stencils that already rise monotonically give the same result as before. The driver (TDP<L> channels, range graphs) and cabledyn.touchdown_history change together. On a convex stencil the TDP now lies at the monotone crossing (0.58 of the chord for -0.005, 0.01, 1 instead of 0.97); tests sweep a node through the grounding in both languages and fail without the change. The manual no longer quotes the surge figures measured with the unlimited parabola. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
|
@codex review |
|
Codex Review: Didn't find any major issues. 🚀 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". |
The release review found a third defect, the touchdown jump on steep stencils, fixed on this branch, so the assets were rebuilt from the final tree (release workflow run 39484701335). The record gives their hashes, the Python suite of the final head (2105 passed, 99.01% branch coverage), and the clean-machine check of these assets: 26 checks and all 51 shipped examples pass. Signed-off-by: Jae Hoon Seo <jaehoon.seo@inha.ac.kr>
|
@codex review |
|
Codex Review: Didn't find any major issues. Already looking forward to the next diff. 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". |
CableDyn 0.2.0
Merges
devintomainfor the 0.2.0 release (RELEASE.md).mainis an ancestor of this branch, somainwill be fast-forwarded to its head, as for 0.1.1.Highlights
EI = 0control ramps now follow MoorDyn-F: fairlead tensions within 0.13 %, where they were up to 6.3 % off.Pinned/CoupledPinned/VesselPinnedrods.staticsFriction asLaid). Seabed contact for clump points andPoint3buoys.dtMnow solves every glue step.The full list is in
CHANGELOG.mdunder[0.2.0].Release checks
validation/RELEASE_0_2_0.mdrecords the builds and checks:-W -n.The clean-machine check found an Intel-only rejection of
buoy_clamped_cable.dat, fixed in #31 before these assets were built.Assets (release workflow run 39424978495)
CableDyn_driver.exe80c68e4f90749501cfed11a625358c28a2184c1db2bcb035874b152d61d9bdb7openfast.exedcead60b6bd95a462a9c0361edf17361230b84e1196d7556643e6144476ab608cabledyn-0.2.0-py3-none-any.whlb72bb763862694974e8113203c8f6eb9a289067287718103b5b199dc4f9de41acabledyn-0.2.0.tar.gzfdb9985e31df83116f06e7dd3742b0d77e4a02f8fc15b3d5f30c8e171bacdca2