```html Seastead Simulation: Open Source Tool Comparison

Open-Source Seastead Wave Simulation Tool Guide

This guide compares free/open-source simulation packages for your 3-leg triangular seastead. The analysis prioritizes non-linear hydrodynamic accuracy (due to large heave variation and changing wetted area), GPU compatibility, engineering output quality, and setup feasibility with AI assistance.

Key Physics Warning: Standard Boundary Element Method (BEM) solvers linearize wave forces around a static wetted surface. Your design experiences 0–100% leg submersion changes in large waves. This breaks linear restoring, radiation, and excitation assumptions. You need non-linear time-domain hydrodynamics (SPH, VOF/CFD, or strongly non-linear Morison/BEM hybrids).

1. Quick Comparison Matrix

Yes (Excellent)NativeYes (High)Partial/ExperimentalYesNative (via DualSPHysics)No (Violates linear assumptions)CPU onlyMarginal (limited non-linear extensions)CPU onlyNoNative

Tool	Accuracy Type	Handles Extreme Heave?	GPU Ready?	AI-Setup Time
DualSPHysics	SPH (Particles)	2–3 weeks	Open Source	Slamming, variable wetted area, GPU speed
OpenFOAM (with olaFlow/waves2Foam)	CFD (VOF)	4–6 weeks	Open Source	Industry-grade flow/turbulence, flexible boundaries
Project Chrono + DualSPHysics	SPH + RBD Coupling	3–4 weeks	Open Source	Fluid-Structure coupling, mooring/actuator integration later
Capytaine + MoorDyn	Linear BEM (Potential Flow)	1–2 weeks	Open Source	Preliminary sizing, fast parameter sweeps (small waves only)
WEC-Sim + MoorDyn	Linear/Weakly Non-linear BEM	2–3 weeks	~$3,000–$5,000 (MATLAB required)	Academic marine energy platforms, not optimal here
Blender (Native Physics)	Game/Rigid-Body	1 week	Free / Open Source	Visualization only. Zero engineering accuracy.

2. Detailed Tool Analysis

DualSPHysics (Recommended)

Why it fits: Smoothed Particle Hydrodynamics natively handles large free-surface deformation, dynamic wetted surface changes, wave slamming, and air-water mixing. Perfect for legs transitioning from 50% submerged to nearly dry.
GPU: Highly optimized for CUDA/OpenCL. Scales linearly with GPU memory. Your high-end GPU will drastically cut solver time vs CPU clusters.
Setup with AI: Claude Code can generate .xml case files, automate boundary setup, write Python post-processing for VTK export, and script ParaView/Blender rendering. Main learning curve: SPH particle resolution, smoothing length, and damping coefficients.
Outputs: Time history of positions, accelerations, forces at any node. VTK/CSV export. Directly compatible with ParaView and Blender (for cinematic rendering).

OpenFOAM (with olaFlow or IH-Waves)

Why it fits: RANS/VOF CFD gives the highest fidelity for turbulence, pressure distribution, and flow separation around foil-shaped legs. Handles non-linear waves exactly.
Limitations: Primarily CPU-bound (GPU offloading is still experimental). Mesh generation (snappyHexMesh/Gmsh) around thin NACA sections at multiple orientations is tricky. Requires careful wave boundary implementation to avoid reflections.
Setup with AI: 4–6 weeks even with heavy AI scripting due to CFD stability tuning (Courant number, time-step, mesh quality, VOF interface compression).

Project Chrono + DualSPHysics Coupled

Clarification: Chrono does not have a mature standalone "FSI-SPH" solver for free-surface waves out-of-the-box. The recommended path is Chrono::Engine (rigid body dynamics) coupled to DualSPHysics for hydrodynamics.
Pros: Full multibody dynamics, future-proof for thrusters, mooring, and your stabilizer actuators. Open source, C++/Python APIs.
Setup: 3–4 weeks. Requires compiling Chrono from source, building coupling libraries, and configuring MPI/GPU handshakes. AI can scaffold CMake builds and coupling scripts.

Capytaine + MoorDyn

Reality Check: Pure linear potential flow. Extremely fast and Python-native, but assumes small motions and constant wetted surface. Your design explicitly violates this in waves above ~1.5 ft.
Use Case: Excellent for early-stage mass/stiffness validation and mooring tension estimates in calm-to-moderate seas. Not suitable for failure prediction or large-heave acceleration analysis.

WEC-Sim + MoorDyn

Cost/Licensing: WEC-Sim itself is free, but requires MATLAB. MATLAB base ~$2,100 + Simulink ~$1,000 + Simscape Multibody ~$2,000. Total ~$5,100 for commercial/non-student licenses in most regions (including Anguilla).
Technical: Built on linear BEM. Adds weakly non-linear restoring, Morrison drag, and non-linear mooring via MoorDyn. Still cannot model legs fully emerging/submerging accurately.
Visualization: Exports to Simulink 3D or VTK. Good for plots, mediocre for cinematic videos without export workflows.

Blender (Native Physics)

Engineering Accuracy: None. Blender’s fluid and rigid body solvers are for visual effects, not hydrodynamic load prediction. No wave-structure coupling based on Navier-Stokes or potential flow.
Recommendation: Use Blender only for post-processing visualization after extracting VTK/CSV data from DualSPHysics or OpenFOAM. AI can script camera paths, lighting, and keyframe export.

3. Addressing Your Specific Questions

"Does Chrono::FSI-SPH use BEM?"
No. If you use Chrono coupled with DualSPHysics, it uses particle-based SPH, not BEM. BEM is entirely bypassed. The coupling passes hydrodynamic forces to Chrono's rigid-body solver, which integrates 6-DOF motion. This is explicitly non-linear.

"Can Blender simulate this accurately now?"
No. While Mantaflow and rigid body physics have improved, they do not solve hydrodynamic wave-structure interaction with physical wave spectra, radiation damping, or dynamic Froude/Krylov forces. Use it strictly for rendering results from engineering solvers.

"Will DualSPHysics handle the damping question?"
Yes. SPH naturally captures added mass, viscous drag, wave radiation damping, and impact slamming without linear assumptions. You will see exactly how leg submersion changes affect heave/roll decay and peak loads.

4. Workflow & Design Reusability

Once you establish a baseline pipeline, adapting to new seastead layouts is highly streamlined:

Parametric Geometry: Generate STL/PLY from FreeCAD, OpenSCAD, or Blender. Keep origin/mass properties consistent.
Case Templating: AI can generate .xml (DualSPHysics) or blockMeshDict (OpenFOAM) from a JSON config (leg spacing, chord, mass, inertia).
Automated Pre/Post: Python scripts auto-run mesh particle conversion, launch GPU solver, extract CSV forces/accelerations, and render VTK → Blender video.
Time per new design: ~1–3 days (mostly for geometry export validation and mass property checks, not solver setup).

5. Final Recommendation

Primary Engine: DualSPHysics + ParaView/Blender for engineering-accurate, GPU-accelerated, non-linear wave simulation.
Project Chrono + DualSPHysics if/when you integrate mooring, thruster control, or active stabilizers.
Avoid: BEM-only tools (Capytaine, WEC-Sim) for failure prediction in large waves. Avoid Blender for physics calculation.
First Simulation Roadmap:
1. Week 1: Install DualSPHysics + CUDA toolchain. Export simple 3-leg STL from CAD.
2. Week 2: Write automated XML case generator (AI-assisted). Set JONSWAP spectrum, calm-to-moderate waves.
3. Week 3: Validate mass/inertia, tune particle spacing (~150k–500k particles), run solver.
4. Week 4: Extract acceleration/position CSVs. Script VTK export. Animate in Blender.
5. Week 5: Scale to extreme waves (Hs=3–5m). Analyze heave limits, peak deck accelerations, leg pressure spikes.

```