Skip to content

CableDyn 0.2.0 - #32

Merged
SMI-Lab-Inha merged 31 commits into
mainfrom
release/0.2.0
Oct 20, 2026
Merged

SMI-Lab-Inha merged 31 commits into
mainfrom
release/0.2.0

Conversation

@SMI-Lab-Inha

Copy link
Copy Markdown
Owner

CableDyn 0.2.0

Merges dev into main for the 0.2.0 release (RELEASE.md). main is an ancestor of this branch, so main will be fast-forwarded to its head, as for 0.1.1.

Highlights

  • Active tensioning of finite-EI cables in OpenFAST. EI = 0 control ramps now follow MoorDyn-F: fairlead tensions within 0.13 %, where they were up to 6.3 % off.
  • Coupled torsion of finite-EI lines in OpenFAST and FAST.Farm, and Pinned/CoupledPinned/VesselPinned rods.
  • Tension-only lines:
    • a generalised-α force blend removes non-physical tension spikes when lines go slack;
    • adaptive sub-stepping through fast segment rotation and slack-to-taut snaps is on by default.
  • Static seabed friction toward the as-laid position (staticsFriction asLaid). Seabed contact for clump points and Point3 buoys.
  • Finite-EI node results recovered from nodal equilibrium. Local mesh refinement in the static solve: for example 10.0 s to 0.33 s on a 462-element lazy wave.
  • Diagnostics and default:
    • error messages are whole and name the cause and workaround;
    • new notes for folds, strain and coarse sections;
    • in OpenFAST a deck without dtM now solves every glue step.

The full list is in CHANGELOG.md under [0.2.0].

Release checks

validation/RELEASE_0_2_0.md records the builds and checks:

  • GNU suites: Release, Debug and NaN-initialised Debug, 293 of 293 each.
  • Python: 99.02 % branch coverage.
  • Docs: HTML and EPUB with -W -n.
  • Audits: metadata and tree, including the archive of this head.
  • OpenFAST: the build gate from a clean pinned checkout, and the linearisation check against MoorDyn.
  • Experiments: Holcombe and Bergdahl rerun.
  • Windows workflow (IFX 2025.3.2, static, reference LAPACK): all gates pass.
  • Clean-machine check of the assets: 26 checks, plus all 51 shipped examples with the release driver.

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)

File SHA-256
CableDyn_driver.exe 80c68e4f90749501cfed11a625358c28a2184c1db2bcb035874b152d61d9bdb7
openfast.exe dcead60b6bd95a462a9c0361edf17361230b84e1196d7556643e6144476ab608
cabledyn-0.2.0-py3-none-any.whl b72bb763862694974e8113203c8f6eb9a289067287718103b5b199dc4f9de41a
cabledyn-0.2.0.tar.gz fdb9985e31df83116f06e7dd3742b0d77e4a02f8fc15b3d5f30c8e171bacdca2

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>
@SMI-Lab-Inha

Copy link
Copy Markdown
Owner Author

@codex review

@chatgpt-codex-connector

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

Copy link
Copy Markdown

Codex Review Summary

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

Review Status Commit Review trigger
📝 Code Review ✅ Completed 2026-10-20T21:09:26.304066Z d3ddfeb Manual request
ℹ️ About Codex in GitHub

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

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

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

@read-the-docs-community

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

Copy link
Copy Markdown

Documentation build overview

📚 CableDyn | 🛠️ Build #35281303 | 📁 Comparing d3ddfeb against latest (f27c5e3)

  🔍 Preview build  

33 files changed · ± 33 modified

± Modified

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

Copy link
Copy Markdown

Choose a reason for hiding this comment

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

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 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".

Comment thread src/CableDyn_Bathymetry.f90 Resolved
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>
@SMI-Lab-Inha

Copy link
Copy Markdown
Owner Author

@codex review

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

Copy link
Copy Markdown

Choose a reason for hiding this comment

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

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 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".

Comment thread python/cabledyn/builder.py Resolved
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>
@SMI-Lab-Inha

Copy link
Copy Markdown
Owner Author

@codex review

@chatgpt-codex-connector

Copy link
Copy Markdown

Codex Review: Didn't find any major issues. What shall we delve into next?

Reviewed commit: abe441f5e9

ℹ️ 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 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>
@SMI-Lab-Inha

Copy link
Copy Markdown
Owner Author

@codex review

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

Copy link
Copy Markdown

Choose a reason for hiding this comment

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

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 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".

Comment thread src/CableDyn_RangeOutput.f90 Resolved
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>
@SMI-Lab-Inha

Copy link
Copy Markdown
Owner Author

@codex review

@chatgpt-codex-connector

Copy link
Copy Markdown

Codex Review: Didn't find any major issues. 🚀

Reviewed commit: 9e48281829

ℹ️ 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 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>
@SMI-Lab-Inha

Copy link
Copy Markdown
Owner Author

@codex review

@chatgpt-codex-connector

Copy link
Copy Markdown

Codex Review: Didn't find any major issues. Already looking forward to the next diff.

Reviewed commit: d3ddfebd5b

ℹ️ About Codex in GitHub

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

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

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

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

@SMI-Lab-Inha
SMI-Lab-Inha merged commit d3ddfeb into main Oct 20, 2026
15 checks passed
@SMI-Lab-Inha
SMI-Lab-Inha deleted the release/0.2.0 branch October 20, 2026 22:26
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant