Seastead Wave Simulation: Open Source Software Comparison

Design Context: 44ft Equilateral Triangle Deckhouse + 3x NACA 0035 Foil Legs (21.5ft x 8.5ft chord) + Heave Plates + Mooring.

Critical Physics: Non-linear hydrostatics (large waterplane area change), Viscous damping (heave plates/foils), Slamming/Green water on deck/legs, Mooring dynamics, 6-DOF motions.

Hardware: High-end GPU (NVIDIA RTX 3090/4090/A-series class assumed). OS: Linux preferred, Windows via WSL2 acceptable.

Executive Summary & Top Recommendation
Detailed Comparison Matrix
Deep Dives per Software
Time-to-First-Simulation Estimates (with AI Assist)
Design Iteration & Reusability
Recommended "Golden Path" Workflow

Executive Summary & Top Recommendation

Winner for Engineering Accuracy + Visualization + GPU Usage: DualSPHysics (v5.2+) running on Linux (native or WSL2).

Runner Up (Best Python Ecosystem / Frequency Domain + Non-linear Time Domain Hybrid): Capytaine (BEM) + MoorDyn + Custom Python Non-linear Froude-Krylov Solver.

Why DualSPHysics?

Physics Fidelity: Smoothed Particle Hydrodynamics (SPH) is a mesh-free Lagrangian method. It handles your specific "non-linear assumptions" breakpoints natively: large amplitude motion (legs going from 50% to 100% submerged), wave slamming on foil leading edges, green water on walkways, air entrapment in heave plates, and ventilated foil tips. No linearization required.
GPU Native: Written in CUDA. Your "good GPU" will be 100% utilized. Simulation speeds for ~1-2M particles (your scale) are ~10-50x real-time on modern RTX cards.
Visualization: Outputs VTK/CSV. ParaView (open source) creates publication-grade videos of pressure fields, free surface, and body motion.
Mooring: Native MoorDyn coupling (via Chrono::MoorDyn interface or direct DLL coupling in v5.2+) for helical screws.
Geometry: Imports STL/OBJ. Your CAD triangle + foil legs + heave plates map directly to boundary particles.

Why NOT the others?

Project Chrono (FSI-SPH): Chrono uses the same SPH kernel (Chrono::FSI is a wrapper around DualSPHysics kernel or a sibling implementation). However, DualSPHysics standalone has better wave generation (Active Wave Absorption), better pre-processing (GenCase), and a more active marine/hydro community. Chrono is better if you need multi-body dynamics (tracks, gears, complex joints) inside the hull. You don't.
Capytaine (BEM) + MoorDyn: Excellent Python API (Claude/Cursor will love it). Fast for linear/seakeeping. Fails your "linear assumption" test: Cannot capture viscous roll damping from heave plates, foil vortex shedding, slamming loads, or the exact non-linear buoyancy curve of your truncated foils without significant custom C/Python coding (Froude-Krylov + Cummins eq with non-linear hydrostatics). Good for preliminary sizing, bad for "how things go wrong".
OpenFOAM (interFoam/olaFlow): Gold standard for VOF (Volume of Fluid). Handles non-linear waves perfectly. But: Meshing moving foils with heave plates in 6-DOF is a nightmare (dynamic meshing / overset / morphing). CPU-bound (slow). GPU port (OpenFOAM-GPU) is immature. Setup time: Weeks.
WEC-Sim: Requires MATLAB/Simulink ($$$). Excluded.
Blender (Physics/FLIP Fluids): Not engineering accurate. FLIP Fluids addon is for VFX. No validation for hydrodynamic coefficients, no mooring coupling, single precision, no pressure loads output. Use only for marketing renders after DualSPHysics gives you the motion data.

Detailed Comparison Matrix

Criteria	DualSPHysics (GPU SPH)	Capytaine + MoorDyn (Python BEM)	Project Chrono (FSI-SPH)	OpenFOAM (VOF - olaFlow)	REEF3D (CFD GPU)	SPlisHSPlasH (SPH)
Physics Model	Weakly Compressible SPH (WCSPH). Fully non-linear, viscous, compressible (acoustic), mesh-free.	Linear Potential Flow (BEM) + Non-linear FK (custom). Inviscid (mostly).	WCSPH (similar kernel to DualSPHysics) + Chrono Multibody.	VOF (Finite Volume). Incompressible. Turbulence models (k-omega SST).	Level Set / Ghost Fluid (High Order FDM). Incompressible. Turbulence.	WCSPH / DFSPH. Good for graphics, less marine validation.
Handles Your Non-Linearities	Excellent Native large motion, slamming, ventilation, heave plate separation.	Poor Requires manual non-linear FK + Morison strip theory hacks.	Excellent Same physics as DualSPHysics.	Good Mesh deformation limits large 6-DOF amplitude.	Good Cartesian grid + Immersed Boundary handles large motion well.	Fair Possible, less marine benchmarking.
GPU Utilization	Native CUDA (100% GPU). Fastest option.	CPU Only (BEM is dense matrix solve).	Native CUDA (via Chrono::FSI).	CPU (MPI) OpenFOAM-GPU experimental.	Native CUDA Very fast.	Native CUDA/OpenCL Fast.
Mooring (MoorDyn)	Native Coupling (v5.2+ DLL link).	Native Python (MoorDyn-Python wrapper).	Native (Chrono::MoorDyn).	External (FAST/OrcaFlex coupling, complex).	Limited Usually custom coupling.	None Custom only.
Python / AI Scripting	Moderate XML input files. `pysph` wrapper exists but unofficial. Best: Python writes XML/STL.	Excellent Pure Python OOP API. AI will write scripts fast.	Moderate Python bindings (PyChrono) exist but lag C++ API.	Moderate `PyFoam`, `oftools`. Case dicts are text.	Poor C++ input files. Limited Python.	Poor C++ / JSON config.
Pre/Post Processing	Good `GenCase` (STL->Particles), ParaView, `PostDualSPH`.	Excellent Matplotlib, NumPy, Pandas native.	Fair ParaView, custom C++ post-proc.	Excellent ParaView, `foamToVTK`, huge ecosystem.	Fair Tecplot/Paraview, custom tools.	Fair ParaView, built-in GUI.
Setup Complexity (Your Geometry)	Medium STL -> Particles -> XML. Wave tank setup standard.	Low Mesh panels (Gmsh) -> Python -> Run.	High Chrono::FSI setup is verbose C++/JSON.	Very High snappyHexMesh + dynamicMeshDict + waveGen.	High Cartesian grid + STL level-set. Complex config.	Medium Scene description files.
Validation / Marine Cred	High ISOPE, OMAE papers. Used for WEC, slamming, coastal.	High Standard for linear seakeeping/WEC.	Medium Growing, more robotics/granular focus.	Highest Industry standard for VOF.	Medium Strong academic (NTNU), less commercial.	Low Graphics/Engineering crossover.
Cost / License	GPL v3 (Free)	MIT / BSD (Free)	BSD-3 (Free)	GPL v3 (Free)	GPL v3 (Free)	MIT (Free)

Deep Dives per Software

1. DualSPHysics (The Recommended Choice)

Website: dual.sphysics.org | Repo: GitHub

Why it fits YOUR specific geometry:

The "Truncated Foil" Problem: Your legs are NACA 0035, 8.5ft chord, cut 0.5ft at trailing edge. In BEM, this changes added mass/damping coefficients non-linearly with submergence. In DualSPHysics, you just import the STL. The physics (pressure integration on wetted surface) handles the changing wetted area automatically.
Heave Plates: Viscous vortex shedding from sharp-edged plates is the primary damping mechanism. SPH captures this (with sufficient resolution/reynolds number scaling). BEM requires empirical Morison coefficients (guesswork).
Walkway Slamming / Green Water: 3ft walkway, 1ft above keel. In 6ft+ waves, this gets hit. SPH gives you pressure time-histories on every walkway panel for structural design.
Helical Mooring Screws: DualSPHysics v5.2+ loads MoorDyn.dll directly. You define the 3 screw pairs + fairlead positions in a .txt file. It solves mooring tension + body motion coupled implicitly.

The Workflow (AI Automatable):

CAD: Export 4 STLs: Hull_Triangle (walls+floor+ceiling as single watertight shell), Leg_Port, Leg_Starboard, Leg_Aft (or identical Leg x3 + transform XML). Heave plates can be separate STLs or merged.
GenCase (Pre-processor): Reads STLs. Generates particle positions for fluid (wave tank) and boundary (bodies). Defines initial waterline (50% leg submergence). Claude writes the GenCase.xml.
DualSPHysics (Solver): Runs on GPU. Inputs: GenCase output + DualSPHysics.xml (numerics, wave maker, mooring coupling, output freq). Claude writes the XML.
Post: PartVTK tool converts binary output to .vtk. Open in ParaView -> Animate -> Save Video.

Resolution Warning: Your legs are 8.5ft chord (~2.6m). For SPH, you need dp (particle spacing) <= Chord/40 ~ 6.5cm for pressure convergence on foils. Tank size: ~60m x 30m x 15m (deep water). Particle count ~ 8-12 Million. VRAM needed: ~12-16 GB (RTX 3090/4090 24GB is perfect. 12GB cards will struggle, need CPU fallback or smaller tank).

2. Capytaine + MoorDyn (The "Fast Physics" Baseline)

Best for: Quick RAOs, mean drift forces, mooring stiffness sizing, checking if the concept floats upright before spending GPU hours.

Python API Example (Claude writes this in seconds):

# pip install capytaine moordyn
import capytaine as cpt
import numpy as np

# 1. Define Bodies (Mesh from Gmsh/STL)
leg_mesh = cpt.mesh.meshes.mesh_from_stl('leg.stl')
# ... define 3 legs at triangle vertices, triangle deckhouse ...

# 2. Solve BEM (Frequency Domain)
solver = cpt.BEMSolver()
freqs = np.linspace(0.1, 2.0, 20) # rad/s
results = solver.solve_all(bodies, freqs, wave_directions=[0])

# 3. Extract Hydro Coeffs (Added Mass, Damping, Exciting Force)
# results[body].added_mass, .radiation_damping, .diffraction_force

# 4. Couple MoorDyn (Quasi-static or Time Domain via Cummins Eq)
# Requires writing Custom Time Domain solver in Python using 
# convolution integral (Cummins) + Non-linear Froude-Krylov (instant wetted hull)
# This is where it gets hard for your geometry.
        

Verdict: Do this FIRST (Week 1). It gives you natural periods, mooring pre-tension estimates, and a sanity check. Do not use for final "failure" analysis.

3. Project Chrono (Chrono::FSI-SPH)

Essentially the same SPH solver as DualSPHysics (developed in collaboration) but embedded in a Game-Engine style Multibody Dynamics kernel.

Use Chrono INSTEAD of DualSPHysics ONLY if: You need to simulate the internal mechanics simultaneously: e.g., the helical screw motor torque curves, the dinghy davit deployment kinematics, the walkway connection coupling between two seasteads (joint friction, slack), or tracked vehicle driving on deck.

For pure seakeeping: DualSPHysics has better wave absorption (active wave absorption - AWA), better wave generation (2nd order Stokes, focused waves), and simpler input files.

4. OpenFOAM (olaFlow / waves2Foam)

The "Heavy Iron" of CFD. VOF method captures air-water interface sharply (no particle noise).

Blocker for you: Dynamic Meshing for 6-DOF Trimaran. Your legs move 7ft+ vertically. The mesh around the foil/heave plates must deform or remesh every timestep. dynamicOversetFvMesh (overset/chimera) is the only robust way. Setting up 4 overlapping mesh zones (background + 3 leg zones) with heave plates sliding through background cells is a 2-3 month expert task. Not AI-friendly.

5. REEF3D (GPU CFD)

High-order finite difference on Cartesian grid + Level Set + Immersed Boundary (IB). Handles moving bodies extremely well (no meshing!). GPU native (CUDA). Used for breaking waves on fixed structures.

Issue: 6-DOF coupling for floating bodies is newer (2022+). MoorDyn coupling exists but less tested than DualSPHysics. Input is C++ structs / text files. Less Pythonic. Good alternative if DualSPHysics particle noise is unacceptable, but higher barrier to entry.

6. Blender (FLIP Fluids / Mantaflow)

Hard No for Engineering.

Single precision (pressure noise).
No hydrostatic pressure baseline (buoyancy is hacked via forces).
No validated turbulence/viscosity model for Re ~ 10^7.
No MoorDyn.
Time step limited by CFL for visual stability, not physics accuracy.

Use Blender FOR: Importing DualSPHysics .vtk or .csv motion data (6-DOF CSV) -> Drive Blender Rig -> Render Photorealistic Marketing Video.

Time-to-First-Simulation Estimates (With Claude Code / Cursor)

Assumes: You have STLs exported from CAD (Rhino/SolidWorks/FreeCAD). You run Linux (Ubuntu 22.04) natively or WSL2. GPU Drivers/CUDA Toolkit installed.

Phase	DualSPHysics	Capytaine + MoorDyn	Project Chrono (FSI)	OpenFOAM (olaFlow)
Environment Setup	1 Day (Docker: `docker pull dualsphysics/dualsphysics:gpu`)	2 Hours (pip install)	1 Day (Docker: `projectchrono/chrono:gpu` or compile)	2 Days (Docker: `opencfd/openfoam` + olaFlow compile)
Geometry Prep (STL -> Input)	2 Days (GenCase XML tuning: dp, tank dims, body transforms, ballast)	1 Day (Gmsh panel mesh + Python body setup)	3 Days (Chrono::FSI JSON format is verbose; STLs -> ChTriangleMeshConnected)	5-10 Days (snappyHexMesh + Overset zones + STL cleaning)
Physics Config (Waves, Mooring, Output)	2 Days (Wave maker type, AWA, MoorDyn.txt coupling, Output VTK freq)	2 Days (MoorDyn.py + Custom Time Domain Solver Script)	3 Days (Chrono::ChWaveGenerator, ChMoorDyn, Output callbacks)	5 Days (waveGen dict, dynamicMeshDict, MoorDyn coupling compile)
Debug / First Valid Run	3 Days (Particle instability, tensile instability, wall BCs, ballast check)	1 Day (Matrix singularities, irregular freqs, MoorDyn init)	5 Days (FSI coupling stability, time step, kernel params)	10+ Days (Courant number, mesh quality, pressure-velocity coupling)
TOTAL TO FIRST VIDEO	~8 Days	~6 Days (But wrong physics for final answer)	~12 Days	~22+ Days

Pro Tip: Run Capytaine (Week 1) and DualSPHysics (Week 2-3) in parallel. Capytaine gives you the target natural periods (Heave/Roll/Pitch) and mooring stiffness. You use those to validate the DualSPHysics model (run decay tests in DualSPHysics -> match periods).

Design Iteration: "How hard to run Design B?"

DualSPHysics (Parameterized XML + Python Wrapper)

Once you have a working GenCase.xml and DualSPHysics.xml template, changing the design is trivial for geometric scaling.

Leg Chord/Length/Draft: Change 3 numbers in Python script -> Regenerate STL (or use GenCase scaling) -> Re-run GenCase (2 mins) -> Re-run Solver.
Heave Plate Count/Size: Add STL to list in XML -> Re-run GenCase.
Triangle Size: Scale factor in Python -> Regenerate Hull STL -> Update Leg positions in XML.
Mooring Stiffness/Depth: Edit MoorDyn.txt (text file). No re-meshing.

Effort: Low (15 mins script edit + Compute time).

Capytaine

Effort: Very Low (Pure Python parametric script). But physics fidelity ceiling is hit immediately.

OpenFOAM / REEF3D

Effort: High. Changing leg length requires regenerating overset mesh zones / background mesh refinement boxes. Changing heave plates requires new immersed boundary STL + refinement zones. Manual intervention almost guaranteed.

Recommended "Golden Path" Workflow for Your Project

Phase 0: Environment (Day 1)

# On Linux (Ubuntu 22.04/24.04) or WSL2
# 1. Install NVIDIA Container Toolkit
# 2. Pull DualSPHysics GPU Docker (easiest, reproducible)
docker pull dualsphysics/dualsphysics:v5.2-gpu

# 3. Pull ParaView (for viz)
# sudo apt install paraview  (or download binary for latest)

# 4. Python env for Capytaine/Pre-post
python3 -m venv venv_seastead
source venv_seastead/bin/activate
pip install capytaine moordyn numpy pandas matplotlib pyvista trimesh lxml

Phase 1: Hydrostatics & Linear Seakeeping (Week 1) - Capytaine

Script: Parametric geometry -> Gmsh surface mesh (panels) -> Capytaine BEM.
Outputs: Hydrostatic stiffness, COG/COB check, RAOs (Heave/Pitch/Roll), Natural Periods, Mean Drift Force.
MoorDyn: Quasi-static catenary -> Check pre-tension for 3ft pull-down.
Deliverable: "Target Numbers" for DualSPHysics validation.

Phase 2: Non-Linear Time Domain "Truth" (Week 2-4) - DualSPHysics

Decay Tests (No Waves): Displace 1m in Heave/Roll/Pitch. Match natural periods to Capytaine (linear zone) and see non-linear hardening/softening.
Regular Waves: H=1m to 6m, T=4s to 12s. Sweep. Record: 6-DOF motions, Leg pressures (slamming), Walkway pressures, Mooring tensions.
Irregular Waves (JONSWAP): Target Caribbean sea states (Hs=1.5m, Tp=6s) up to Survival (Hs=6m+). Run 30-60 min sim time (3-6 hrs GPU).
Two-Body Simulation: Import 2nd Seastead STL. Connect via MoorDyn "connector" (walkway) or Chrono joint if using Chrono. Simulate walkway loads.

Phase 3: Structural Loads & Visualization (Week 4+)

ParaView: Pressure heatmaps on foil leading edge (slamming), heave plate vortex shedding (Q-criterion), walkway green water.
Export 6-DOF CSV -> Blender (Geometry Nodes / Rig) -> Photorealistic video for investors/community.
Hot-spot pressure time series -> FEA (CalculiX / Code_Aster / Salome-Meca) for wall/leg laminate schedule.

AI Prompt Strategy for Claude Code

# Prompt Template for DualSPHysics XML Generation
"""
I am simulating a seastead in DualSPHysics v5.2.
Geometry:
- Equilateral Triangle Deckhouse: Side=13.4m (44ft), Height=2.13m (7ft), Draft=0.5m (est).
- 3x Legs: NACA 0035, Chord=2.59m (8.5ft), Span=6.55m (21.5ft), Truncated TE (0.15m flat).
- Legs attached at triangle vertices. 50% Submerged at rest (Draft=3.27m).
- Heave Plates: 3 per leg, 1.5m x 1.5m, sharp edges, at z=-1m, -2.5m, -4m relative to keel.
- Mass: 12,474 kg (27,500 lbs) displacement target. CG at waterline.
- Mooring: 3x Helical screws (MoorDyn), fairleads at triangle vertices, depth=15m, pretension for 0.9m (3ft) pull-down.

Task: Write a Python script using `lxml` to generate `GenCase.xml` and `DualSPHysics.xml`.
Requirements:
- dp = 0.05m (Chord/50). Estimate particle count.
- Tank: Length=4xWL, Width=3xWL, Depth=2xDraft.
- Wave Maker: Left piston, Active Wave Absorption (AWA) on right.
- Waves: Regular H=2m T=8s; then JONSWAP Hs=2.5m Tp=7s gamma=3.3.
- Output: VTK every 0.1s. Pressure on boundaries. 6-DOF CSV.
- MoorDyn Coupling: Enable DLL coupling. Write MoorDyn input file template.
- Ballast: Adjust leg internal ballast particles to hit target draft/CG.
"""
        

Generated for Seastead Design Project | DualSPHysics v5.2+ / Capytaine / MoorDyn Stack Recommended