This document compares open-source software options for simulating a tensegrity seastead design comprising cylinders, pivots, and cables in ocean waves. The goal is to evaluate stability, motion response (heave/roll), and structural loads (cable snap loads) with high engineering accuracy.
CPU: AMD Threadripper (64 cores) | GPU: NVIDIA A6000 | RAM: 750 GB
This is an exceptional setup for simulation. It allows you to utilize SPH (Smoothed Particle Hydrodynamics) methods, which are computationally expensive but visually intuitive and capable of handling the complex "non-linear" water interactions you described (legs entering/leaving water). Most standard marine engineering software assumes small wave amplitudes relative to the structure size; your design challenges those assumptions, making your hardware a key asset.
Based on your requirements for accuracy (non-linear waves/floats), cable dynamics, and visualization, the best path is Project Chrono (PyChrono) with the FSI-SPH module.
It is the only open-source project that natively combines a high-fidelity multibody physics engine (for your cables and pivots) with a GPU-accelerated fluid solver that can utilize your A6000.
| Software | Methodology | Handles Non-Linear Waves? | Handles Cables/Pivots? | Setup Difficulty | Accuracy for Seastead |
|---|---|---|---|---|---|
| Project Chrono (FSI-SPH) | SPH (Particle) + Multibody | Excellent | Excellent | Medium | High |
| DualSPHysics | SPH (Particle) | Excellent | Limited/Complex | High | High (Fluid), Low (Structure) |
| WEC-Sim + MoorDyn | BEM (Potential Flow) | Poor (Linear Assumption) | Good | Medium | Medium (for small waves only) |
| Capytaine + MoorDyn | BEM (Potential Flow) | Poor (Linear Assumption) | Good | Low | Medium (for small waves only) |
| OpenFOAM | CFD (Mesh-based) | Excellent | Difficult | Very High | Very High |
| Blender | Game Engine Physics | N/A (Fake) | Good | Low | Not Engineering Grade |
Type: Multibody Dynamics with optional FSI (Fluid-Structure Interaction).
Why it fits: You tried Chrono, but likely the standard hydrodynamics module which uses simplified buoyancy or BEM-like assumptions. However, the Chrono::FSI module uses SPH (Smoothed Particle Hydrodynamics). This is perfect for you because:
Does it use BEM? No, if you use the FSI/SPH module, it does not use BEM. It solves the fluid equations particle-by-particle.
Visualization: It uses an Irrlicht 3D engine for real-time visualization or can export to POV-Ray/Blender for high-quality videos.
YouTube Example: Project Chrono FSI SPH Wave Tank Simulation
Setup Time: ~1-2 weeks with Claude Code. You will write a Python script defining the cylinders, the constraints (pivots), the cables, and the fluid box.
Reusability: High. Once you have a script for one seastead, changing the dimensions or adding a leg is just changing numbers in the Python script.
Type: SPH (Particle) Fluid Solver.
Why it fits: This is arguably the fastest open-source SPH code. It is excellent for visualizing waves crashing against cylinders. It creates beautiful, realistic videos.
The Catch: It is primarily a fluid solver. While it handles floating bodies, simulating complex mechanical systems (pivots, tensegrity cables that can go slack and snap tight) is difficult. You often have to couple it with another physics engine (like Project Chrono!) to get the mechanical behavior right.
YouTube Example: DualSPHysics Floating Structures
Setup Time: ~1 week for basic floating. ~1 month to integrate complex cable dynamics if not using the standard coupling.
Type: BEM (Boundary Element Method) + Mooring Dynamics.
Why it fits: This is the "standard" modern open-source stack for marine engineering. Capytaine calculates the hydrodynamic coefficients (added mass, radiation damping) for the hull. MoorDyn simulates the cables. They are both Python-friendly.
The Catch (Critical for you): Capytaine uses BEM. BEM assumes the water surface is flat and the body oscillates slightly around a mean position. It linearizes the problem.
Verdict: Not recommended for your specific non-linear submergence questions, despite being excellent tools for standard ships.
Type: MATLAB/Simulink based time-domain solver.
Why it fits: WEC-Sim is designed specifically for wave energy converters (which your seastead resembles). It handles moorings and body rotation well.
The Catch: It relies on BEM (usually from NEMOH or WAMIT) for hydrodynamic coefficients, carrying the same linearity limitations as Capytaine. Furthermore, it requires MATLAB.
Cost Estimate:
Verdict: Not Open Source and suffers from the same BEM linearity limitations.
Type: CFD (Computational Fluid Dynamics).
Why it fits: OpenFOAM is the industry standard for high-precision fluid simulation. It is strictly accurate. It can model the air/water interface (VoF method) perfectly.
The Catch: It is extremely difficult to set up. Simulating rigid body motion (6DOF) coupled with dynamic meshing is complex. Simulating a multibody system (legs pivoting relative to a platform) with cables is very advanced. It is often "overkill" for design iteration. One simulation might take days on a CPU (though your Threadripper helps). It is not well optimized for your A6000 compared to SPH codes.
YouTube Example: OpenFOAM Floating Body
Setup Time: ~1-2 months to master the configuration for this specific problem.
Type: 3D Animation Suite.
Verdict: Not Engineering Accurate. Blender uses the Bullet physics engine (via the rigid body simulator). It treats water as a generic "fluid" for visual effects or requires you to approximate buoyancy manually using force fields.
It will not calculate the correct hydrodynamic damping (drag) or the added mass effects of water moving around the legs. It will likely show the structure behaving much more stiffly or erratically than it would in real life.
Since your floats are cylinders, you have an option that sits between the "Simple BEM" and "Complex SPH" approaches.
You can use Project Chrono (Standard) or even write a custom script in Python (NumPy) that uses the Morison Equation.
Why this might be the "Engineering Sweet Spot": It is industry standard for offshore oil platforms (jacket structures). Since your seastead is "like a tiny oil platform" and your legs are "slender" relative to wave length, this method is likely accurate enough for structural sizing, much faster than SPH, and free.
If you use a scripted approach (Python + PyChrono), switching models is trivial. You define your seastead as a list of parameters:
platform_size = [40, 16]
leg_diameter = 4
leg_angle = 45
To simulate a different design, you just change these numbers and re-run the script. You do not need to "redraw" anything in a CAD tool if you write the script to generate the geometry procedurally.
If the SPH setup proves too difficult or slow to iterate on, pivot to using PyChrono with Morison Equation forces (custom force functor). This will give you the engineering accuracy for cable snap loads and damping without the computational weight of fluid particles.