CableDyn

Getting started

  • Capabilities and route selection
    • Execution routes
    • Line and constitutive capability
    • Loads and environment
    • Topology and coupled objects
    • OpenFAST coverage
    • How to interpret this page
  • Key concepts
    • The model is a graph of line objects and boundary attachments
    • A line is one object built from sections
    • Line types are material + hydrodynamics
    • Two solver paths, selected by EI
    • Every run is static, then (optionally) dynamic
    • One core, many callers
    • Fail closed, never silent
    • Units, frames, and signs are frozen
    • Where to go next
  • Installation
    • Windows release
      • What is on the release page
      • Download and verify
      • Check that it runs
      • Run from any folder
      • Python package
      • Updating
    • Build from source
      • Windows (conda + GNU Fortran)
      • Windows (Intel IFX, static release)
      • Linux
      • macOS
      • Install the build
      • Update a source build
      • Build the documentation
    • Next steps
  • Quickstart: first result in five minutes
    • 1. Open a terminal in the release folder
    • 2. Solve a mooring line
    • 3. Check the exit code and the files
    • 4. Read the result
    • 5. The same result in Python
    • Next steps
  • Modelling workflow
    • 1. Choose the owner of motion and water kinematics
    • 2. Assemble the minimum engineering data
    • 3. Build topology in public End-A to End-B order
    • 4. Define line types and constitutive response
    • 5. Choose and converge the mesh
    • 6. Establish the static initial condition
    • 7. Configure dynamics and forcing
    • 8. Request auditable outputs
    • 9. Validate in layers
    • Use-case map
    • Study layout and reproducibility

Tutorials

  • Tutorials
    • Before you start
  • Tutorial 1 — A grounded catenary chain
    • The deck
    • Run it
    • Read the result
    • Check it by hand
    • Natural periods and mode shapes
    • Exercises
  • Tutorial 2 — A spread mooring and its output channels
    • The deck
    • Add channels and per-line files
    • Interpret the fairlead report
    • Exercises
  • Tutorial 3 — A lazy-wave power cable
    • Why a different element
    • The deck
    • Run it
    • Read the shape
    • Discrete buoyancy modules
    • Natural periods of the lazy wave
    • Exercises
  • Tutorial 4 — Prescribed fairlead motion
    • What changes from Tutorial 3
    • The motion file
    • Run it
    • Read the result
    • Vessel motion and a clamped hang-off
    • Exercises
  • Tutorial 5 — Current, waves, and convergence
    • The baseline
    • Environment records
    • Run the three cases for 60 s
    • Time-step convergence
    • Mesh convergence
    • Irregular and spread seas
    • MoorDyn-C kinematics files
    • Nonlinear regular waves
    • Anisotropic seabed friction
    • Exercises
  • Tutorial 6 — Synthetic ropes
    • Why a rope needs more than one EA
    • Statics: the slow stiffness decides
    • Dynamics: the dynamic stiffness decides
    • Syrope: working curve and load history
    • Exercises
  • Tutorial 7 — Buoys, bodies, and rods
    • Which object to use
    • A moored Rigid6 buoy
    • A rigid rod on four legs
    • A cable clamped to the buoy
    • A spar with pinned rods
    • The multibody march
    • A broken mooring line
    • Exercises
  • Tutorial 8 — Python studies and post-processing
    • Setup
    • A water-depth study
    • A dynamic record: statistics, fatigue, spectrum
    • The same from the command line
    • Range graphs and the touchdown point
    • Python API for GUIs and scripting
    • Exercises
  • Tutorial 9 — A floating wind turbine in OpenFAST
    • 1. Fetch the turbine model
    • 2. Assemble the case folder
    • 3. Make the model a single turbine at the origin
    • 4. How CableDyn is wired in
    • 5. Run it
    • 6. Result files
    • 7. Compare with MoorDyn
    • 8. Add a lazy-wave power cable
    • Exercises
  • Standalone driver tutorial
    • 1. Verify the executable and create the output folder
    • 2. Run a static catenary
    • 3. Read the input in object order
    • 4. Study every option
    • 5. Solve the three installed Lozon cables
    • 6. Prescribe fairlead motion
    • 7. Dynamic output and convergence
  • Examples
    • Start here
    • Mooring configurations
    • Synthetic ropes
    • Dynamic environment
    • Points, buoys, bodies, and rods
    • Line failure (accidental limit state)
    • Dynamic power cables
    • OpenFAST coupling
    • Auxiliary data

User reference

  • Deck format reference (.dat)
    • Principles
    • Records, comments, and tokens
      • Admissible input ranges
    • File names
    • Section structure
      • Section headers and aliases
      • LINE TYPES
      • BODIES (3D point buoy + 6D rigid body)
      • EXTERNAL LOADS
      • TURBINES (standalone farm decks)
      • ROD TYPES + RODS (rigid cylindrical rods)
      • POINTS
      • LINES + SECTIONS
      • SYROPE IC (optional, Syrope lines)
      • END CONNECTIONS (optional, finite-EI lines)
      • EQUIVALENT BUOYANCY (optional)
      • ATTACHMENTS (optional, finite-EI lines)
      • FAILURE (optional, EI = 0 decks)
      • CONTROL (optional, OpenFAST line control)
      • OPTIONS (value keyword order, case-insensitive keyword)
      • MoorDyn-C WaveKin and Currents modes
      • MoorDyn-F WaterKin file modes
      • Prescribed motion (motionFile)
      • Vessel motion (vesselMotion, vesselRAO)
      • OUTPUTS (one channel per line)
      • Static-configuration file <out_root>.static.out
    • Driver workflow
    • Design decisions
  • OPTIONS reference and defaults
    • Record syntax
    • Environment and seabed
    • Clock and initial condition
    • Nonlinear solver
    • Finite-EI cable controls
    • Ambient fluid and prescribed motion
    • MoorDyn compatibility-only keywords
    • Water-kinematics sources
    • Standalone versus OpenFAST checklist
  • Auxiliary input files
    • Common rules
      • Path resolution
      • Record rules
    • Prescribed motion file (motionFile)
      • Deck reference
      • Columns
      • Coverage and time grid
      • Example
    • Structured bathymetry file (bathymetryFile)
      • Deck reference
      • Columns
      • Validation
      • Example
    • WaterKin file
      • Deck reference
      • Layout
      • Modes
      • Current profile table
      • Wave-elevation history (WaveKinFile)
      • Example
    • Syrope settings file and OWC table
      • Deck reference
      • Settings file
      • OWC table
  • Output files and channels
    • Standalone driver files
      • Common layout
    • <out_root>.out — the main table
    • <out_root>.static.out — static range table
    • <out_root>.elements.out — Hermite element extrema
    • Per-line files (LINES Outputs flag)
      • <out_root>.Line<L>.range.out — range graphs
      • <out_root>.modes.out — natural frequencies and mode shapes
    • Per-rod files (RODS Outputs flag)
    • OUTPUTS channel vocabulary
      • Line-end channels
      • Line-node channels
      • Touchdown channels
      • Point channels
      • Body and rod channels
      • Validation of channel names
    • Console output
    • In OpenFAST
    • Reading and post-processing
  • Command-line reference
    • CableDyn_driver — the standalone solver
      • Synopsis
      • Arguments
      • Options
      • Checks before the solve
      • Standard streams
      • Exit codes
      • Examples
    • Python command-line tools
      • Locating the native driver
      • cabledyn-run
      • cabledyn-post
      • cabledyn-deck
      • cabledyn-study
  • Standalone Windows driver
    • Install and verify
    • Run a case
      • Command-line options
      • Long-run progress
      • Mixed mooring and power-cable decks
      • Initialisation report
      • Input-record style
      • Working-directory and path rules
    • Exit status and automation
      • When a run ends early
      • Output streams
    • Python automation
    • Choosing the standalone driver or OpenFAST
  • Conventions
    • Units
    • Global frame
    • Sign conventions
    • Line topology and arc length
    • Tension definitions
    • Angles at line ends
    • Torsion signs
    • Orientation angles
    • Seabed
    • Hydrodynamic reference quantities
    • Time integration parameter
    • Precision and finiteness
  • Migrating from MoorDyn or OrcaFlex
    • From MoorDyn
      • A stock MoorDyn deck runs almost unchanged
      • When to use SECTIONS instead
      • Keyword map
      • What differs on purpose
      • Inside OpenFAST
    • From OrcaFlex
    • Porting checklist
  • Troubleshooting
    • Exit codes at a glance
    • Reading an error message
    • A deck is rejected (exit 1)
      • Command line and files
      • Records, tokens, and sections
      • Clock, motion, and environment
      • Model data
      • Torsion
      • FAILURE and CONTROL sections
    • A solve does not converge
    • Warnings and notes that do not stop a run
    • An OpenFAST CompMooring = 5 run fails at init
    • The standalone binary will not launch (Windows)
  • Frequently asked questions
    • Modelling and inputs
    • Results
    • OpenFAST coupling
  • Glossary

Theory manual

  • Theory
    • Kinematics and discretisation
      • The EI = 0 tension element
      • The cubic-Hermite bending element
      • Condensed torsion
    • Constitutive laws
      • Linear elasticity
      • Axial damping
      • Viscoelastic rope (MoorDyn ElasticMod 2 and 3)
      • Syrope polyester model
    • Hydrodynamic loads
      • Drag
      • Added mass and fluid inertia
      • Buoyancy and wetting
      • Waves
      • Currents
    • Seabed contact
    • Static equilibrium
      • EI = 0 path
      • Hermite path
    • Modal analysis
    • Time integration
    • Attached objects and line ends
    • Tension and coupled loads
    • Linear algebra
  • Solver paths
    • The EI = 0 cable path
    • The cubic-Hermite bending path
      • Static solve
      • Dynamics
    • Performance
    • Secondary path: Cosserat rod

Coupling & APIs

  • OpenFAST with CompMooring = 5
    • Required files
    • Configure the .fst
    • What OpenFAST owns and what the deck owns
      • Time step
      • Fluid source
    • Run and confirm
    • Output channels and files
    • Example files
    • Mixed moorings and power cables
    • Line-end bending connections
    • Lifecycle features
      • Two different Jacobians
    • Performance
    • Common mistakes
  • Coupling: OpenFAST and CFD
    • OpenFAST module (CompMooring = 5)
      • Standalone binaries
    • C binding (CableDyn_CAPI)
    • The coupling boundary
  • Coupling boundary
    • Exchanged quantities
    • Cadence
    • C ABI (CableDyn_CAPI.h)
      • Concurrency
    • OpenFAST module
    • Module map
  • C API reference
    • Overview
    • Building and linking
      • Build and install
      • CMake consumer
      • Command lines
    • ABI and versioning
    • Calling conventions
    • Status codes
      • Diagnostics
    • Coupled DOF layout
    • State, units, and load sign
    • Function reference
      • Version queries
      • CableDyn_Create
      • CableDyn_Close
      • CableDyn_InitDeck
      • CableDyn_InitLine
      • CableDyn_InitLines
      • CableDyn_UpdateStates
      • CableDyn_UpdatePointFluidFields
      • CableDyn_Step
      • CableDyn_CalcOutput
      • CableDyn_CalcOutputDerivatives
      • CableDyn_GetCoupledMotion
      • CableDyn_GetLastError
      • State and size queries
      • Object queries
    • Examples
      • One line from arrays
      • A mooring deck
  • Python package
    • Package status and installation
    • Standalone-driver quickstart
      • Executable discovery
      • Run semantics and safety
    • Typed result objects
      • Statistics, range graphs, and geometry
      • Rainflow cycles and damage-equivalent ranges
      • Power spectra, moments, and coherence
      • Dynamic line range graphs
      • DataFrame and pyDatView interoperability
    • Command-line wrapper
    • Programmatic deck construction
    • Build and edit decks as objects
    • Read, edit, and generate existing decks
    • Batch execution and study records
    • In-process coupling API
      • Objects and output channels
      • Snapshots and animation
    • API reference
  • Post-processing with other tools’ results
    • Reading OpenFAST, MoorDyn, and coupled runs
    • Comparing two runs
    • Resampling and filtering
    • Extreme values
    • Line geometry
    • Fatigue damage
      • Lifetime damage over sea states
    • Range graphs
    • Design checks
    • Touchdown time histories
    • Parameter grids
    • Results at a time
    • Clearance
    • Summary tables
  • Python API reference
    • Running the standalone driver
      • CableDynDriver
      • DriverResult
    • Batch studies
      • run_study()
      • StudyResult
      • StudyCaseResult
    • Parameter sweeps
      • parameter_grid()
    • Reading results
      • read_output()
      • OutputTable
      • TimeHistory
      • LineNodeHistory
      • LineSegmentHistory
      • StaticProfile
      • ChannelStatistics
      • StaticLineSummary
      • SpatialStatistics
    • Reading other codes’ outputs
      • read_table()
      • read_openfast_output()
      • read_moordyn_output()
      • read_moordyn_line()
      • MoorDynLineHistory
      • read_coupled_run()
      • CoupledRun
    • Comparing runs
      • compare_histories()
      • HistoryComparison
      • ChannelComparison
    • Signal processing
      • resample()
      • moving_average()
      • fft_filter()
    • Fatigue analysis
      • rainflow_cycles()
      • cycle_histogram()
      • damage_equivalent_range()
      • FatigueResult
      • RainflowCycle
      • RainflowHistogram
    • Fatigue damage
      • FatigueCurve
      • dnv_rp_c203_curve()
      • dnv_os_e301_curve()
      • api_rp_2sk_curve()
      • chain_nominal_area()
      • miner_damage()
      • channel_damage()
      • ChannelDamage
      • cable_stress()
      • damage_along_arc()
      • DamageProfile
      • study_sea_state_damage()
      • SeaStateDamage
      • lifetime_fatigue()
      • LifetimeFatigue
    • Range graphs
      • RangeGraph
      • read_range_graphs()
      • read_range_graph()
      • node_range_graph()
      • static_range_graph()
      • element_range_graph()
    • Design checks
      • bend_check()
      • BendLimits
      • BendCheck
      • mbr_utilisation()
      • tension_check()
      • DNV_OS_E301_STRENGTH_FACTOR
      • TensionCheck
      • API_RP_2SK_SAFETY_FACTORS
      • DNV_OS_E301_PARTIAL_FACTORS
    • Spectral analysis
      • power_spectrum()
      • magnitude_squared_coherence()
      • PowerSpectrum
      • SpectralPeak
      • CoherenceResult
    • Extreme values
      • block_maxima()
      • upcrossing_maxima()
      • fit_gumbel()
      • GumbelFit
      • fit_weibull()
      • WeibullFit
    • Line geometry
      • line_geometry()
      • LineGeometry
      • Touchdown
      • touchdown_history()
      • TouchdownHistory
    • Deck editing and case generation
      • DeckFile
      • DeckRecord
      • OptionRecord
      • generate_deck_cases()
      • GeneratedCase
      • DeckWriter
    • Deck object model
      • DeckModel
      • DeckReferenceError
      • SyropeEA
    • Snapshots and animation
      • Snapshots
      • Recorder
      • record()
      • animate()
      • Seabed
      • WaterSurface
    • Results at a time
      • line_positions()
      • LinePositions
      • line_field()
      • LineField
      • available_quantities()
      • profile_at()
      • profiles_at()
      • ArcProfile
      • line_range_graph()
    • Clearance
      • seabed_clearance()
      • SeabedClearance
      • line_clearance()
      • LineClearance
      • clearance_matrix()
      • ClearanceMatrix
      • segment_distance()
      • read_bathymetry()
      • Bathymetry
    • Summary tables
      • channel_summary()
      • line_summary()
      • ChannelSummary
      • LineSummary
      • SummaryTable
    • In-process coupling
      • CableDyn
      • Object views
    • Exceptions
      • DriverError
      • DriverNotFoundError
      • DriverExecutionError
      • OutputFormatError
      • DeckFormatError
      • StudyFormatError
      • StudyOutputError
      • CableDynError
      • ConvergenceError
  • Source module map
    • Foundation
    • Finite-EI cubic-Hermite path
    • EI = 0 cable path
    • Secondary Cosserat path
    • Hydrodynamics and contact
    • Coupled bodies and platform
    • Coupling shells
    • Drivers
    • C helper sources

Validation

  • CableDyn verification and validation
    • Summary
    • Scope
    • L1 analytical
    • L2 MoorDyn comparisons
    • L3 OrcaFlex and physical experiments
      • Physical experiments
    • L4 coupled OpenFAST
    • L5 performance and robustness
      • Time-step stability
      • Wall-clock time
      • Numerical robustness
    • Reference systems: Lozon et al. (2025)
    • Static-initialisation robustness (static_init_sweep)
    • Dynamic robustness across the DLC motion envelope
    • OpenFAST feature coverage (CompMooring = 5)
      • WaterKin and SeaState modes
    • Torsion
    • Cross-code comparison method
    • Module tests
    • Python post-processing tests
    • Reproducing

Project

  • Changelog
    • [Unreleased]
      • Added
      • Fixed
    • 0.1.0 - 2026-10-01
      • Added
      • Fixed
  • How to cite
    • Journal article (preferred citation)
    • Software release
    • Relation to the journal article
    • Citing methods and reference data
  • References
    • Element formulation
    • Time integration and nonlinear solution
    • Hydrodynamics and ocean environment
    • Mooring-line models and synthetic ropes
    • Verification and validation references
    • Comparison codes
  • Contributing to CableDyn
    • Contributing upstream
    • Issues
    • Development setup
    • Pull requests
    • Standards
    • Repository contents
    • Licence and sign-off
  • Developing CableDyn
    • Environment
    • Build and test
    • Python package
    • Documentation
    • Formatting and checks
    • Coding standards
      • Fortran
      • SPDX headers
    • OpenFAST integration
    • Troubleshooting
CableDyn
  • Search

© Copyright 2026, Jae Hoon Seo, SMI Lab, Inha University. Last updated on 2026-10-05.

Built with Sphinx using a theme provided by Read the Docs.