majiayu000 Mooring Analysis SME Skill
Comprehensive mooring system design and analysis expertise for floating offshore platforms including catenary, taut, and semi-taut configurations.
When to Use This Skill
Use mooring analysis knowledge when:
- Station-keeping design - FPSO, semi-sub, SPAR mooring
- Catenary analysis - Static and dynamic behavior
- Tension calculations - Pretension, extreme loads
- Fatigue assessment - Mooring line fatigue life
- Anchor design - Holding capacity verification
- Installation planning - Pretension optimization
Core Knowledge Areas
1. Mooring Types
Catenary Mooring:
characteristics:
restoring_force: "Weight of suspended line"
typical_water_depth: "< 2000m"
materials: ["chain", "wire", "combination"]
advantages:
- Simple and reliable
- Well-proven technology
- Good energy absorption
disadvantages:
- Large footprint
- Heavy at great depths
Taut Mooring:
characteristics:
restoring_force: "Elastic elongation"
typical_water_depth: "Any depth"
materials: ["polyester", "steel wire"]
advantages:
- Small footprint
- Suitable for ultra-deep water
- Lower weight
disadvantages:
- Complex dynamics
- Requires higher pretension
- More sensitive to installation
2. Catenary Equations
Basic Catenary:
import numpy as np
def catenary_profile(
horizontal_tension: float, # kN
weight_per_length: float, # kN/m
length_on_seabed: float = 0 # m
) -> dict:
"""
Calculate catenary mooring line profile.
Catenary equations:
- x = a * sinh(s/a)
- z = a * (cosh(s/a) - 1)
Where a = H/w (catenary parameter)
Args:
horizontal_tension: Horizontal tension at touchdown
weight_per_length: Weight per unit length in water
length_on_seabed: Length of line on seabed
Returns:
Catenary parameters
"""
# Catenary parameter
a = horizontal_tension / weight_per_length
return {
'catenary_parameter_m': a,
'horizontal_tension_kN': horizontal_tension,
'weight_per_length_kN_m': weight_per_length
}
def catenary_suspended_length(
water_depth: float,
horizontal_distance: float,
horizontal_tension: float,
weight_per_length: float
) -> float:
"""
Calculate suspended length of catenary line.
Solve: z = a(cosh(x/a) - 1) for length s
Args:
water_depth: Water depth
horizontal_distance: Horizontal distance to anchor
horizontal_tension: Horizontal tension
weight_per_length: Weight per length
Returns:
Suspended line length
"""
from scipy.optimize import fsolve
a = horizontal_tension / weight_per_length
def equations(s):
# Horizontal: x = a*sinh(s/a)
# Vertical: z = a*(cosh(s/a) - 1)
eq1 = a * np.sinh(s/a) - horizontal_distance
eq2 = a * (np.cosh(s/a) - 1) - water_depth
return [eq1, eq2]
# Initial guess
s0 = np.sqrt(horizontal_distance**2 + water_depth**2)
# Solve
solution = fsolve(equations, s0)[0]
return solution
def catenary_top_tension(
water_depth: float,
horizontal_tension: float,
weight_per_length: float
) -> float:
"""
Calculate tension at top of catenary line.
T_top = sqrt(H² + (w*z)²)
Args:
water_depth: Water depth
horizontal_tension: Horizontal tension
weight_per_length: Weight per length
Returns:
Top tension in kN
"""
vertical_component = weight_per_length * water_depth
T_top = np.sqrt(horizontal_tension**2 + vertical_component**2)
return T_top
3. Mooring Line Components
Chain:
def chain_properties(
diameter: float, # mm
grade: str = "R4"
) -> dict:
"""
Get chain properties.
Args:
diameter: Nominal chain diameter
grade: Chain grade (R3, R4, R5)
Returns:
Chain properties
"""
# Minimum Breaking Load (MBL) for studless chain
# API RP 2SK Table 4-1
grade_factors = {
'R3': 0.0219, # tonnes/mm²
'R4': 0.0246,
'R5': 0.0273
}
k = grade_factors.get(grade, 0.0246)
MBL = k * diameter**2 # tonnes
# Weight in air (approximate)
weight_air = 0.0218 * diameter**2 # kg/m
# Weight in water (steel in seawater)
submerged_factor = (7.85 - 1.025) / 7.85 # Steel in seawater
weight_water = weight_air * submerged_factor # kg/m
return {
'diameter_mm': diameter,
'grade': grade,
'MBL_tonnes': MBL,
'MBL_kN': MBL * 9.81,
'weight_air_kg_m': weight_air,
'weight_water_kg_m': weight_water
}
Wire Rope:
def wire_rope_properties(
diameter: float, # mm
construction: str = "6x36"
) -> dict:
"""
Get wire rope properties.
Args:
diameter: Wire rope diameter
construction: Wire construction (6x36, 6x19, etc.)
Returns:
Wire properties
"""
# Approximate MBL (6x36 IWRC)
MBL = 0.0175 * diameter**2 # tonnes
# Weight in air
weight_air = 0.040 * diameter**2 # kg/m (steel core)
# Weight in water
submerged_factor = (7.85 - 1.025) / 7.85
weight_water = weight_air * submerged_factor
return {
'diameter_mm': diameter,
'construction': construction,
'MBL_tonnes': MBL,
'MBL_kN': MBL * 9.81,
'weight_air_kg_m': weight_air,
'weight_water_kg_m': weight_water
}
Polyester Rope:
def polyester_rope_properties(
diameter: float, # mm
linear_density: float = None # kg/m
) -> dict:
"""
Get polyester rope properties.
Args:
diameter: Rope diameter
linear_density: Mass per unit length (if known)
Returns:
Polyester properties
"""
# Approximate MBL
MBL = 0.0048 * diameter**2 # tonnes
# Weight in air (if not provided)
if linear_density is None:
linear_density = 0.0045 * diameter**2 # kg/m
# Weight in water (polyester is neutrally buoyant in seawater)
# Specific gravity ~1.38, seawater ~1.025
submerged_factor = (1.38 - 1.025) / 1.38
weight_water = linear_density * submerged_factor
# Axial stiffness (EA)
EA = 850 * MBL # kN (approximate)
return {
'diameter_mm': diameter,
'MBL_tonnes': MBL,
'MBL_kN': MBL * 9.81,
'weight_air_kg_m': linear_density,
'weight_water_kg_m': weight_water,
'EA_kN': EA
}
4. Design Standards and Criteria
Safety Factors (API RP 2SK):
safety_factors:
intact_condition:
ULS: # Ultimate Limit State
permanent_mooring: 1.67
temporary_mooring: 1.50
ALS: # Accidental Limit State
permanent: 1.25
temporary: 1.15
damaged_condition: # One line failed
ULS:
permanent: 1.40
temporary: 1.25
ALS:
permanent: 1.15
temporary: 1.05
fatigue:
design_factor: 10.0
Design Load Cases:
load_cases:
operating:
return_period: "1 year"
vessel_offset: "Normal operation"
mooring_check: "Fatigue dominant"
extreme:
return_period: "100 year"
vessel_offset: "Maximum excursion"
mooring_check: "ULS"
survival:
return_period: "10,000 year"
vessel_offset: "Survival condition"
mooring_check: "ALS"
damaged:
condition: "One line failed"
environment: "100 year"
mooring_check: "Damaged ULS"
5. Installation and Pretensioning
Pretension Optimization:
def calculate_pretension(
water_depth: float,
horizontal_distance: float,
target_touchdown_tension: float,
weight_per_length: float
) -> dict:
"""
Calculate required pretension for target touchdown tension.
Args:
water_depth: Water depth
horizontal_distance: Horizontal distance to anchor
target_touchdown_tension: Desired horizontal tension at seabed
weight_per_length: Line weight per length
Returns:
Required pretension
"""
# Calculate catenary profile
a = target_touchdown_tension / weight_per_length
# Suspended length
s = catenary_suspended_length(
water_depth,
horizontal_distance,
target_touchdown_tension,
weight_per_length
)
# Top tension
vertical_load = weight_per_length * water_depth
pretension = np.sqrt(target_touchdown_tension**2 + vertical_load**2)
return {
'pretension_kN': pretension,
'touchdown_tension_kN': target_touchdown_tension,
'suspended_length_m': s,
'catenary_parameter_m': a
}
6. Dynamic Analysis Considerations
Low Frequency Motion:
def estimate_low_frequency_offset(
mean_wave_drift: float, # kN
mooring_stiffness: float # kN/m
) -> float:
"""
Estimate vessel low-frequency offset.
Simple static approximation:
offset = Force / Stiffness
Args:
mean_wave_drift: Mean wave drift force
mooring_stiffness: Total horizontal stiffness
Returns:
Offset in meters
"""
return mean_wave_drift / mooring_stiffness
def calculate_mooring_stiffness(
num_lines: int,
pretension: float, # kN per line
fairlead_depth: float,
weight_per_length: float,
line_azimuth: list # degrees for each line
) -> float:
"""
Calculate total horizontal mooring stiffness.
Args:
num_lines: Number of mooring lines
pretension: Pretension per line
fairlead_depth: Depth of fairlead below waterline
weight_per_length: Weight per unit length
line_azimuth: Azimuth of each line
Returns:
Total horizontal stiffness in kN/m
"""
# Simplified: K = (T/a) for catenary
# where a = H/w
stiffness_per_line = weight_per_length * pretension / fairlead_depth
# Resolve in each direction
total_stiffness = 0
for azimuth in line_azimuth:
# Component in surge direction
component = stiffness_per_line * np.cos(np.radians(azimuth))
total_stiffness += component
return total_stiffness
Practical Applications
Application 1: FPSO 12-Line Mooring
mooring_configuration:
vessel: "FPSO"
water_depth: 1500 # m
number_of_lines: 12
configuration: "3x4 spread" # 3 bundles, 4 lines each
line_composition:
upper_chain:
length: 500 # m
diameter: 127 # mm
grade: "R4"
wire_rope:
length: 1000 # m
diameter: 120 # mm
construction: "6x36 IWRC"
lower_chain:
length: 500 # m
diameter: 127 # mm
grade: "R4"
pretension:
target: 2000 # kN per line
tolerance: "+/-10%"
anchor:
type: "drag_embedment"
capacity: 5000 # kN
safety_factor: 2.0
Application 2: Mooring Integrity Check
def mooring_integrity_check(
tension: float, # kN
MBL: float, # kN
safety_factor: float
) -> dict:
"""
Check mooring line integrity against criteria.
Args:
tension: Applied tension
MBL: Minimum Breaking Load
safety_factor: Required safety factor
Returns:
Check results
"""
utilization = tension / (MBL / safety_factor)
passed = utilization <= 1.0
return {
'tension_kN': tension,
'MBL_kN': MBL,
'allowable_tension_kN': MBL / safety_factor,
'utilization': utilization,
'passed': passed,
'margin': (1.0 - utilization) * 100 # Percent
}
Key Design Steps
Preliminary Sizing
- Water depth
- Vessel offset limits
- Environmental criteria
Configuration Selection
- Number of lines
- Line composition
- Anchor type
Static Analysis
- Catenary profile
- Pretension
- Touchdown loads
Dynamic Analysis
- Vessel motions
- Line tensions
- Fatigue damage
Integrity Assessment
- ULS/ALS checks
- Fatigue life
- Installation feasibility
Resources
- API RP 2SK: Stationkeeping Systems
- DNV-OS-E301: Position Mooring
- ISO 19901-7: Stationkeeping Systems
- OCIMF: Mooring Equipment Guidelines
Use this skill for all mooring system design and analysis in DigitalModel!