Goal: type in “this foil shape, this triangle spacing” and get a real aluminum member schedule, connection list, and piece-by-piece weights — for a 44′ triangle / 3-leg seastead that packs into one 45′ high-cube container.
Companion notes for the seastead design study · Marine aluminum · Target displacement 27,500 lb
Short version: there is no single open-source program today that goes from “shape + spacing” to a sized truss with weights. The good news: your structure is simple enough (triangular box-girder walls, bolted floor/ceiling panels, three foil-section legs) that a small custom Python toolchain gets you 90% of the way:
build123d or CadQuery (scripted parametric solids, STEP export)PyNite (pure-Python 3D frame FEA — iterate member sizes automatically)pandas BOM rollupIf you prefer a GUI over code: FreeCAD (spreadsheet-driven parametric models + built-in CalculiX FEM + mass properties) is the strongest single open-source package.
| Layer | Tool |
|---|---|
| Parameters | One params.py / JSON file (all dimensions in SI internally) |
| Solid geometry | build123d or CadQuery (Python, OCCT kernel) |
| Global frame sizing | PyNite — auto-loop member catalogs until utilization ≤ target |
| Plating/stiffeners | Custom ISO 12215-5 / DNV scantling functions |
| Local FEA checks | CalculiX + Gmsh (brackets, thruster mounts, heave plates, corner joints) |
| BOM / weights / CG | pandas → CSV + Markdown/HTML report |
| Packing check | Same script: bin-pack parts into 44.6×7.7×8.9 ft, ≤62,000 lb |
Effort: roughly a weekend to first numbers, a few weeks to trustworthy. Every design variant becomes a one-line parameter change.
| Layer | Tool |
|---|---|
| CAD & assemblies | FreeCAD (Spreadsheet workbench drives dimensions; Assembly workbench; Fasteners addon) |
| Mass properties | FreeCAD volume × density, or its Material system |
| FEA | FreeCAD FEM workbench (ships with CalculiX solver) |
| Heavy FEA | Salome-Meca (Salome + Code_Aster) or Gmsh + PrePoMax + CalculiX |
| BOM | FreeCAD spreadsheet / export to CSV |
Best for exploring the container pack-out visually and producing drawings. Member auto-sizing still wants Stack A’s loop.
| Task | First choice (OSS) | Alternatives | Notes |
|---|---|---|---|
| Parametric geometry, part families, STEP export | build123d / CadQuery OSS | FreeCAD, OpenVSP, Blender+Sverchok | Foil lofts, panel arrays, extrusion cuts — all scriptable. |
| Truss / frame member sizing (auto-iterate) | PyNite OSS | Frame3DD, Anastruct (2D), OpenSees | Loop over RHS/extrusion catalogs until utilization target met. |
| Hull/wall plating & stiffener scantlings | Your own scripts (ISO 12215-5 / DNV formulas) OSS | Spreadsheets | No turnkey OSS scantling tool exists; the formulas are simple to code (~200 lines). |
| Full FEA verification (shells, welds, brackets) | CalculiX OSS | Code_Aster/Salome-Meca, Elmer, FreeCAD FEM | Abaqus-style input; nonlinear, contact, buckling. |
| Meshing | Gmsh OSS | Salome, snappyHexMesh (OpenFOAM) | Python-scriptable; reads STEP. |
| Optimization (optional) | scipy.optimize / NLopt OSS | Dakota | Drive PyNite sizing; minimize weight s.t. utilization & deflection limits. |
| Hydrostatics, displacement, draft curves | Direct from your geometry (Python) OSS | DELFTship Free, FreeShip | Your shapes are prisms + foils — closed-form integration is easy and exact. |
| Wave loads / motions (seakeeping RAOs) | Capytaine (Nemoh successor) OSS | Nemoh | Linear potential-flow BEM; wave loads on the 3-leg arrangement. |
| Coupled dynamics + tension-leg mooring | OpenFAST (HydroDyn + MoorDyn) OSS | MoorDyn standalone; custom Python | Built for floating wind; adaptable to taut taut-leg pretension studies. |
| Slamming / green water / walkway wave pass-through | OpenFOAM (interFoam), REEF3D OSS | DualSPHysics free-academic | Only needed later, for detail design. |
| Foil section drag (NACA 0035 legs) | XFLR5 OSS | OpenVSP parasite-drag buildup | 2D section CL/CD at your Reynolds numbers. |
| Thruster / propulsor first-cut sizing | OpenProp OSS | Vendor data for rim drives | Rim drives are niche; actuator-disk math is fine at concept stage. |
| BOM, weights, CG, container load plan | pandas + openpyxl OSS | FreeCAD spreadsheet | Single source of truth; diff-able in git. |
| Visualization / renders for the website | Blender (+Sverchok) OSS | FreeCAD TechDraw for drawings | Import STEP from build123d/CadQuery. |
| Commercial benchmarks (what the pros use, for reference): Rhino+Grasshopper+Karamba3D (interactive truss sizing), DNV Sesam/GeniE (semi-submersible structures), Maxsurf + Maxsurf Structure, OrcaFlex (moorings), ShipWeight (weight databases), Onshape free tier (cloud parametric CAD with configurations & BOM — not OSS, but zero-cost and excellent). | |||
Python libraries for parametric solid modeling on the OpenCascade kernel. You write code like “loft a NACA 0035 section, cut the trailing edge, array bolt holes,” and get exact solids with exact volumes. Exports STEP/STL for FreeCAD, Gmsh, Blender, and machine shops.
Full parametric CAD. Key features for this project:
Watch out: big assemblies get slow; it sizes nothing for you — pair with PyNite or hand scantlings.
NASA’s parametric geometry tool. Component-based (lofts, ducts, pods), with a mass-properties tool (set material densities per component) and parasite-drag buildup. Great for rapid “what if the legs were longer / triangle bigger” layout studies and decent CG/inertia guesses. Not a structural sizer.
Node-based parametric meshing inside Blender. Excellent for marketing renders and exploded assembly animations of the pack-out sequence; mass via mesh volume × density. Not engineering-grade solids — use downstream of build123d/CadQuery, not instead of.
Pure-Python 3D frame/truss FEA: pip install PyNite. Nodes, beam elements, releases, springs, load combinations, P-Δ, plate elements, reactions and member force envelopes.
Industrial-grade FEA solver with Abaqus-compatible input. Nonlinear, contact, buckling, heat. Pair with Gmsh (scripted mesher, reads STEP) and either FreeCAD’s FEM workbench or PrePoMax (free Windows GUI) as pre/post.
EDF’s industrial FEA bundled with the Salome CAD/mesh platform. More capable (and steeper) than CalculiX; enormous verification-example library. Choose this when you outgrow CalculiX or want fatigue/eigenvalue workflows with strong documentation.
Frame3DD (GPL, C): mature 3D frame statics + dynamics; callable, dated UX.
Anastruct: very quick 2D frame checks (e.g., a wall panel as a 2D ring beam).
OpenSees: research-grade, civil-oriented; overkill here but capable.
Linear potential-flow boundary-element solver (radiation/diffraction). Mesh the three legs + triangle, get added mass, damping, RAOs, and first-order wave loads per sea state — the loads that feed your structural sizing. Python API, actively maintained.
NREL’s coupled floating-system simulator. HydroDyn (wave kinematics + body forcing) + MoorDyn (dynamic mooring lines, including taut lines) + a controller slot. Built for floating wind turbines but the physics is generic: use it to check the tension-leg concept (pretension, slack risk, snap loads) and the two-seastead-connected-in-waves problem qualitatively.
Hull surface modelers with hydrostatics/stability. Honestly optional for you — your displaced shapes (3 foil prisms + triangle) are simple enough to integrate exactly in Python, and you’ll want that inside the generator anyway.
2D foil section analysis. Run NACA 0035 at your chord/Reynolds range to get profile drag and lift-curve slope for transit-power estimates and for the “leading edge forward” drag argument.
Later-stage CFD: green-water on the walkway grating, slamming on heave plates, dinghy wake shielding. REEF3D is purpose-built for wave–structure interaction; OpenFOAM interFoam is the generalist; DualSPHysics (SPH) is free for academic use, license-checked for commercial.
| Alloy / form | Density | Base yield (typ.) | As-welded yield (typ. design) | Typical use |
|---|---|---|---|---|
| 5083-H116 / H321 plate | 2,660 kg/m³ (166 lb/ft³) | ≈ 230 MPa | ≈ 125–145 MPa | Shell/wall plating, tanks — the marine temper (exfoliation-resistant) |
| 6082-T6 extrusions (EU) | 2,700 kg/m³ | ≈ 260 MPa | ≈ 150–160 MPa | Frames, beams, walkway structure |
| 6061-T6 extrusions (US) | 2,700 kg/m³ | ≈ 275 MPa | ≈ 150–165 MPa | Same, US supply chain |
The workflow that produces “shape in → sized structure + weights out.” Everything below is illustrative skeleton code, not a finished program.
# seastead_gen.py — illustrative skeleton (SI internally, imperial display)
@dataclass
class Params:
tri_side_m: float = 44.0 * 0.3048 # equilateral triangle, wall centerline
wall_h_m: float = 7.0 * 0.3048 # floor-to-ceiling
leg_len_m: float = 21.5 * 0.3048 # span of each foil leg
leg_chord_m: float = 8.5 * 0.3048 # NACA 0035 chord
leg_t_over_c: float = 0.35
te_cut_m: float = 0.5 * 0.3048 # blunt trailing edge
walkway_w_m: float = 3.0 * 0.3048
disp_target_kg: float = 27_500 * 0.4536
util_limit: float = 0.80 # max member utilization
...
# ---------- 1. Buoyancy & draft ----------
def naca0035_area(t, c): # symmetric 4-digit section area
return 0.685 * t * c # (closed-TE variant ≈ same)
def leg_volume(p): # × (1 - te_cut correction)
...
def draft_vs_displacement(p): # integrate immersed foil volume
return interpolator # → check 27,500 lb point & waterplane
# ---------- 2. Environmental loads ----------
def design_pressures(p, h_s, T_p): # ISO 12215-5-style slam/static heads
return pressure_map # per panel zone (bow/beam/stern factors)
# ---------- 3. Scantlings ----------
def plate_thickness(pressure, spacing, allowable): ...
def stiffener_SM(pressure, spacing, span, allowable): ...
# ---------- 4. Global frame: auto-size with PyNite ----------
from Pynite import FEModel3D
def build_frame(profile_set): # nodes/elements for triangle box girder,
m = FEModel3D() # floor beams, ceiling beams, leg attachments
... # loads: gravity + inverted pressures + leg reactions
return m
def autosize(catalog): # catalog sorted by lb/ft, ascending
for candidate in catalog:
m = build_frame(candidate)
m.analyze()
if max_utilization(m) <= Params.util_limit \
and max_deflection(m) <= span/240:
return candidate # lightest member that passes
raise RuntimeError("no member passes")
# ---------- 5. Local FEA hooks (CalculiX via .inp files) ----------
def write_ccx_inp(joint_id, loads): ... # corner joints, thruster mounts, heave plates
# ---------- 6. Outputs ----------
def bom(parts) -> pd.DataFrame:
# id, group, description, alloy, profile, length_m, unit_kg, qty, kg, notes
...
def container_pack_check(bom): # 44.6 × 7.7 × 8.9 ft, ≤ 62,000 lb, CG box
...
def report(): # markdown/HTML: BOM, group rollups, CG, margins
...
Why this beats a monolithic program: every assumption (wave pressure, utilization limit, weld knockdown, contingency) lives in one auditable file. When someone asks “what if the walkway is 4 ft?” you change one number and re-run — new truss sizes, new weights, new pack-out, in seconds.
| ID | Group | Description | Alloy/form | Profile / thickness | Length | Unit wt | Qty | Total | Joints / notes |
|---|---|---|---|---|---|---|---|---|---|
| WP-A1 | Walls | Wall panel, side A | 5083-H116 plate | 5 mm | 22′-0″ × 7′-0″ | 419 lb | 3 | 1,257 lb | field-bolted to chords, sealed |
| CB-W1 | Walls | Bottom chord, wall 1 | 6082-T6 | RHS 150×75×5 | 22′-0″ | 3.9 lb/ft | 3 | 258 lb | corner gussets CC-01 |
| FJ-01 | Floor | Floor joist | 6082-T6 | RHS 100×50×4 | 21′-4″ | 2.1 lb/ft | 17 | 748 lb | @16″ o.c., clip FCL-1 |
| Values above are illustrative placeholders showing the schema — the generator computes real ones. | |||||||||
These are rough, first-pass calculations from your stated dimensions — worth resolving before building the parametric model, because two of them affect the fundamental geometry.