scripts/simulate_subsea_container.py

"""Structural screening simulator for subsea 40-foot datacenter concepts.

This is a first-pass engineering model meant to answer:
1. How badly does a flat-wall 40-foot box behave under subsea hydrostatic load?
2. Can a 40-foot transport envelope work if the actual pressure boundary is rounded?
3. Which components become the likely first failure mode as depth increases?

It is not a nonlinear FEA, CFD, or fatigue model. It uses conservative classical
screening formulas:
- Hydrostatic pressure: p = rho * g * h
- Flat panels / hatches: fixed-fixed beam strip approximation
- Cylindrical shell: membrane compression + elastic shell buckling with an
  imperfection knockdown factor
- Dished/spherical endcaps: membrane compression + elastic shell buckling

The main value is design ranking and failure-mode identification, not code sign-off.
"""

from __future__ import annotations

import argparse
import json
import math
from dataclasses import asdict, dataclass
from pathlib import Path

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd


RHO_SEAWATER = 1025.0
G = 9.81


@dataclass(frozen=True)
class Material:
    name: str
    youngs_modulus_pa: float
    poisson_ratio: float
    yield_strength_pa: float
    density_kg_m3: float


@dataclass(frozen=True)
class BoxContainerDesign:
    name: str
    outer_length_m: float
    outer_width_m: float
    outer_height_m: float
    wall_thickness_m: float
    roof_thickness_m: float
    door_thickness_m: float
    wall_bay_span_m: float
    roof_bay_span_m: float
    door_clear_span_m: float
    access_lid_span_m: float
    access_lid_thickness_m: float


@dataclass(frozen=True)
class InternalHullDesign:
    name: str
    envelope_length_m: float
    envelope_width_m: float
    envelope_height_m: float
    hull_outer_diameter_m: float
    hull_cyl_length_m: float
    shell_thickness_m: float
    endcap_thickness_m: float
    endcap_radius_m: float
    hatch_diameter_m: float
    hatch_thickness_m: float
    shell_buckling_knockdown: float
    head_buckling_knockdown: float


@dataclass
class ComponentCheck:
    component: str
    stress_pa: float
    yield_safety_factor: float
    buckling_safety_factor: float | None
    governing_safety_factor: float
    deflection_m: float | None
    pressure_pa: float
    note: str


def hydrostatic_pressure(depth_m: float, rho: float = RHO_SEAWATER, gravity: float = G) -> float:
    return rho * gravity * depth_m


def beam_strip_check(
    component: str,
    span_m: float,
    thickness_m: float,
    pressure_pa: float,
    material: Material,
    note: str,
) -> ComponentCheck:
    """Model a 1 m wide clamped strip under uniform pressure as a fixed-fixed beam."""
    line_load_n_per_m = pressure_pa * 1.0
    max_moment_nm = line_load_n_per_m * span_m**2 / 12.0
    stress_pa = 6.0 * max_moment_nm / max(thickness_m**2, 1e-12)
    inertia_m4 = thickness_m**3 / 12.0
    deflection_m = line_load_n_per_m * span_m**4 / (384.0 * material.youngs_modulus_pa * inertia_m4)
    yield_sf = material.yield_strength_pa / max(abs(stress_pa), 1.0)
    return ComponentCheck(
        component=component,
        stress_pa=stress_pa,
        yield_safety_factor=yield_sf,
        buckling_safety_factor=None,
        governing_safety_factor=yield_sf,
        deflection_m=deflection_m,
        pressure_pa=pressure_pa,
        note=note,
    )


def cylinder_shell_check(
    component: str,
    radius_m: float,
    thickness_m: float,
    pressure_pa: float,
    material: Material,
    knockdown: float,
    note: str,
) -> ComponentCheck:
    membrane_stress_pa = pressure_pa * radius_m / max(thickness_m, 1e-12)
    yield_sf = material.yield_strength_pa / max(abs(membrane_stress_pa), 1.0)
    buckling_pressure_pa = (
        knockdown
        * (2.0 * material.youngs_modulus_pa / math.sqrt(3.0 * (1.0 - material.poisson_ratio**2)))
        * (thickness_m / radius_m) ** 3
    )
    buckling_sf = buckling_pressure_pa / max(pressure_pa, 1.0)
    return ComponentCheck(
        component=component,
        stress_pa=membrane_stress_pa,
        yield_safety_factor=yield_sf,
        buckling_safety_factor=buckling_sf,
        governing_safety_factor=min(yield_sf, buckling_sf),
        deflection_m=None,
        pressure_pa=pressure_pa,
        note=note,
    )


def spherical_head_check(
    component: str,
    radius_m: float,
    thickness_m: float,
    pressure_pa: float,
    material: Material,
    knockdown: float,
    note: str,
) -> ComponentCheck:
    membrane_stress_pa = pressure_pa * radius_m / max(2.0 * thickness_m, 1e-12)
    yield_sf = material.yield_strength_pa / max(abs(membrane_stress_pa), 1.0)
    buckling_pressure_pa = (
        knockdown
        * (2.0 * material.youngs_modulus_pa / math.sqrt(3.0 * (1.0 - material.poisson_ratio**2)))
        * (thickness_m / radius_m) ** 2
    )
    buckling_sf = buckling_pressure_pa / max(pressure_pa, 1.0)
    return ComponentCheck(
        component=component,
        stress_pa=membrane_stress_pa,
        yield_safety_factor=yield_sf,
        buckling_safety_factor=buckling_sf,
        governing_safety_factor=min(yield_sf, buckling_sf),
        deflection_m=None,
        pressure_pa=pressure_pa,
        note=note,
    )


def evaluate_box(depth_m: float, material: Material, design: BoxContainerDesign) -> list[ComponentCheck]:
    pressure = hydrostatic_pressure(depth_m)
    return [
        beam_strip_check(
            component="side_wall_bay",
            span_m=design.wall_bay_span_m,
            thickness_m=design.wall_thickness_m,
            pressure_pa=pressure,
            material=material,
            note="1 m strip spanning between wall stiffeners; screens local bay yielding.",
        ),
        beam_strip_check(
            component="roof_bay",
            span_m=design.roof_bay_span_m,
            thickness_m=design.roof_thickness_m,
            pressure_pa=pressure,
            material=material,
            note="1 m strip spanning between roof stiffeners; ignores shell action and is conservative.",
        ),
        beam_strip_check(
            component="cargo_door",
            span_m=design.door_clear_span_m,
            thickness_m=design.door_thickness_m,
            pressure_pa=pressure,
            material=material,
            note="Represents the large flat door / end opening penalty.",
        ),
        beam_strip_check(
            component="service_lid",
            span_m=design.access_lid_span_m,
            thickness_m=design.access_lid_thickness_m,
            pressure_pa=pressure,
            material=material,
            note="Access lid behaves like a pressure hatch, not a normal container lid.",
        ),
    ]


def evaluate_internal_hull(depth_m: float, material: Material, design: InternalHullDesign) -> list[ComponentCheck]:
    pressure = hydrostatic_pressure(depth_m)
    radius_m = design.hull_outer_diameter_m / 2.0
    return [
        cylinder_shell_check(
            component="cylindrical_shell",
            radius_m=radius_m,
            thickness_m=design.shell_thickness_m,
            pressure_pa=pressure,
            material=material,
            knockdown=design.shell_buckling_knockdown,
            note="External-pressure shell buckling with imperfection knockdown; likely governing hull mode.",
        ),
        spherical_head_check(
            component="dished_endcap",
            radius_m=design.endcap_radius_m,
            thickness_m=design.endcap_thickness_m,
            pressure_pa=pressure,
            material=material,
            knockdown=design.head_buckling_knockdown,
            note="Approximated as rounded head; usually stronger than the cylindrical bay.",
        ),
        beam_strip_check(
            component="surface_service_hatch",
            span_m=design.hatch_diameter_m,
            thickness_m=design.hatch_thickness_m,
            pressure_pa=pressure,
            material=material,
            note="Circular hatch approximated as a clamped strip; conservative screening for hatch thickness.",
        ),
    ]


def required_box_thickness(span_m: float, pressure_pa: float, material: Material, target_sf: float) -> float:
    max_moment_nm = pressure_pa * span_m**2 / 12.0
    return math.sqrt(6.0 * max_moment_nm * target_sf / material.yield_strength_pa)


def required_cylinder_thickness(
    radius_m: float,
    pressure_pa: float,
    material: Material,
    target_sf: float,
    knockdown: float,
) -> float:
    t_yield = pressure_pa * radius_m * target_sf / material.yield_strength_pa
    coeff = knockdown * (2.0 * material.youngs_modulus_pa / math.sqrt(3.0 * (1.0 - material.poisson_ratio**2)))
    t_buckling = radius_m * ((pressure_pa * target_sf) / coeff) ** (1.0 / 3.0)
    return max(t_yield, t_buckling)


def gross_cylinder_volume(design: InternalHullDesign) -> float:
    radius = design.hull_outer_diameter_m / 2.0
    cyl = math.pi * radius**2 * design.hull_cyl_length_m
    heads = 4.0 / 3.0 * math.pi * radius**3
    return cyl + heads


def gross_box_volume(design: BoxContainerDesign) -> float:
    return design.outer_length_m * design.outer_width_m * design.outer_height_m


def run_depth_sweep(
    depths_m: np.ndarray,
    material: Material,
    box_design: BoxContainerDesign,
    hull_design: InternalHullDesign,
) -> tuple[pd.DataFrame, pd.DataFrame]:
    box_rows: list[dict[str, float | str]] = []
    hull_rows: list[dict[str, float | str]] = []
    for depth in depths_m:
        for item in evaluate_box(float(depth), material, box_design):
            box_rows.append(
                {
                    "depth_m": float(depth),
                    "component": item.component,
                    "governing_sf": item.governing_safety_factor,
                    "yield_sf": item.yield_safety_factor,
                    "buckling_sf": item.buckling_safety_factor,
                    "stress_mpa": item.stress_pa / 1e6,
                    "deflection_mm": None if item.deflection_m is None else item.deflection_m * 1000.0,
                    "pressure_bar_g": item.pressure_pa / 1e5,
                }
            )
        for item in evaluate_internal_hull(float(depth), material, hull_design):
            hull_rows.append(
                {
                    "depth_m": float(depth),
                    "component": item.component,
                    "governing_sf": item.governing_safety_factor,
                    "yield_sf": item.yield_safety_factor,
                    "buckling_sf": item.buckling_safety_factor,
                    "stress_mpa": item.stress_pa / 1e6,
                    "deflection_mm": None if item.deflection_m is None else item.deflection_m * 1000.0,
                    "pressure_bar_g": item.pressure_pa / 1e5,
                }
            )
    return pd.DataFrame(box_rows), pd.DataFrame(hull_rows)


def plot_safety_factor_curves(
    box_df: pd.DataFrame,
    hull_df: pd.DataFrame,
    output_path: Path,
) -> None:
    fig, axes = plt.subplots(1, 2, figsize=(14, 5), sharey=True)
    for ax, df, title in [
        (axes[0], box_df, "Naive Flat-Wall Box"),
        (axes[1], hull_df, "ISO Frame + Internal Hull"),
    ]:
        for component, group in df.groupby("component"):
            ax.plot(group["depth_m"], group["governing_sf"], label=component, linewidth=2)
        ax.axhline(1.0, color="red", linestyle="--", linewidth=1.5, label="failure threshold")
        ax.axhline(1.5, color="orange", linestyle=":", linewidth=1.5, label="preferred min SF")
        ax.set_title(title)
        ax.set_xlabel("Depth (m)")
        ax.set_yscale("log")
        ax.grid(True, which="both", alpha=0.25)
    axes[0].set_ylabel("Governing safety factor (log scale)")
    axes[1].legend(loc="upper right", fontsize=8)
    fig.tight_layout()
    fig.savefig(output_path, dpi=180)
    plt.close(fig)


def plot_failure_heatmap(box_df: pd.DataFrame, hull_df: pd.DataFrame, output_path: Path) -> None:
    box_pivot = box_df.pivot(index="component", columns="depth_m", values="governing_sf")
    hull_pivot = hull_df.pivot(index="component", columns="depth_m", values="governing_sf")
    vmax = max(np.nanmax(box_pivot.values), np.nanmax(hull_pivot.values))
    vmin = min(np.nanmin(box_pivot.values), np.nanmin(hull_pivot.values))
    fig, axes = plt.subplots(2, 1, figsize=(14, 7), sharex=True)
    for ax, pivot, title in [
        (axes[0], box_pivot, "Naive Flat-Wall Box"),
        (axes[1], hull_pivot, "ISO Frame + Internal Hull"),
    ]:
        img = ax.imshow(pivot.values, aspect="auto", cmap="viridis", vmin=vmin, vmax=vmax)
        ax.set_yticks(range(len(pivot.index)))
        ax.set_yticklabels(pivot.index)
        ax.set_xticks(range(len(pivot.columns)))
        ax.set_xticklabels([f"{int(col)}" for col in pivot.columns], rotation=45)
        ax.set_title(title)
    axes[1].set_xlabel("Depth (m)")
    cbar = fig.colorbar(img, ax=axes.ravel().tolist(), shrink=0.9)
    cbar.set_label("Governing safety factor")
    fig.subplots_adjust(left=0.16, right=0.90, top=0.93, bottom=0.12, hspace=0.35)
    fig.savefig(output_path, dpi=180)
    plt.close(fig)


def build_summary(
    material: Material,
    box_design: BoxContainerDesign,
    hull_design: InternalHullDesign,
    box_df: pd.DataFrame,
    hull_df: pd.DataFrame,
    target_depth_m: float,
) -> str:
    target_pressure = hydrostatic_pressure(target_depth_m)
    box_min = box_df.groupby("depth_m")["governing_sf"].min()
    hull_min = hull_df.groupby("depth_m")["governing_sf"].min()
    box_target = box_df[box_df["depth_m"] == target_depth_m].sort_values("governing_sf").iloc[0]
    hull_target = hull_df[hull_df["depth_m"] == target_depth_m].sort_values("governing_sf").iloc[0]
    req_box_wall = required_box_thickness(
        span_m=box_design.wall_bay_span_m,
        pressure_pa=target_pressure,
        material=material,
        target_sf=1.5,
    )
    req_box_door = required_box_thickness(
        span_m=box_design.door_clear_span_m,
        pressure_pa=target_pressure,
        material=material,
        target_sf=1.5,
    )
    req_hull_shell = required_cylinder_thickness(
        radius_m=hull_design.hull_outer_diameter_m / 2.0,
        pressure_pa=target_pressure,
        material=material,
        target_sf=1.5,
        knockdown=hull_design.shell_buckling_knockdown,
    )
    box_volume = gross_box_volume(box_design)
    hull_volume = gross_cylinder_volume(hull_design)
    box_fail_depth = float(box_min[box_min < 1.0].index.min()) if (box_min < 1.0).any() else math.inf
    hull_fail_depth = float(hull_min[hull_min < 1.0].index.min()) if (hull_min < 1.0).any() else math.inf

    return f"""# Subsea 40-Foot Structural Screening Summary

## Model intent

This report screens two concepts under hydrostatic external pressure:

- `{box_design.name}`: a flat-wall sealed 40-foot box with stiffened panels and a top access lid
- `{hull_design.name}`: a 40-foot transport envelope carrying an internal rounded pressure hull

The analysis is a structural screening model, not code-certifiable FEA. It is intended to show design ranking and likely first failure modes.

## Assumptions

- Material: `{material.name}`
- Young's modulus: `{material.youngs_modulus_pa / 1e9:.0f} GPa`
- Yield strength: `{material.yield_strength_pa / 1e6:.0f} MPa`
- Seawater density: `{RHO_SEAWATER:.0f} kg/m^3`
- Gravity: `{G:.2f} m/s^2`
- Target comparison depth: `{target_depth_m:.0f} m` (`{target_pressure / 1e5:.2f} bar(g)`)

## Result at target depth

### Flat-wall box

- Governing component: `{box_target['component']}`
- Governing safety factor: `{box_target['governing_sf']:.2f}`
- Governing stress: `{box_target['stress_mpa']:.1f} MPa`

### Internal rounded hull

- Governing component: `{hull_target['component']}`
- Governing safety factor: `{hull_target['governing_sf']:.2f}`
- Governing stress: `{hull_target['stress_mpa']:.1f} MPa`

## Thickness required for SF = 1.5 at target depth

- Flat wall bay (`{box_design.wall_bay_span_m:.2f} m` stiffener spacing): `{req_box_wall * 1000:.1f} mm`
- Flat cargo door / opening (`{box_design.door_clear_span_m:.2f} m` clear span): `{req_box_door * 1000:.1f} mm`
- Rounded cylindrical shell (`{hull_design.hull_outer_diameter_m / 2.0:.2f} m` radius): `{req_hull_shell * 1000:.1f} mm`

## Gross packaging volume

- 40-foot box envelope: `{box_volume:.1f} m^3`
- Internal rounded hull gross volume: `{hull_volume:.1f} m^3`
- Rounded hull / box gross volume ratio: `{hull_volume / box_volume:.2f}`

## Depth where governing SF first drops below 1.0

- Flat-wall box: `{box_fail_depth if math.isfinite(box_fail_depth) else 'not reached in sweep'}`
- Internal rounded hull: `{hull_fail_depth if math.isfinite(hull_fail_depth) else 'not reached in sweep'}`

## Interpretation

The flat-wall box fails for the expected reason: the large flat panels and especially the large door / lid spans become pressure-loaded plates. The structure very quickly turns into a heavy pressure vessel, and once reinforced enough to survive depth it is no longer behaving like a cheap shipping container.

The internal rounded hull works materially better because shell buckling scales more favorably than flat-plate bending for this geometry. The transport frame can still be ISO-like for handling, but the actual pressure boundary should stay rounded.

## What this model proves

- A normal box-shaped pressure boundary is structurally unattractive underwater.
- A 40-foot transport envelope can still be useful if the actual pressure hull inside it is cylindrical / rounded.
- The likely first failure modes are the large flat opening panels on the box concept and shell buckling / hatch thickness on the rounded concept.

## What this model does not prove

- Final certifiable wall thickness
- Weld detail adequacy
- Local stress concentrations at penetrators, supports, or hatch rings
- Fatigue, corrosion allowance, or collapse after dent / ovality defects
- Thermal, fluid, and electrical integration

The next step after this model would be a proper shell / plate FEA and then a welded-detail design review.
"""


def default_material() -> Material:
    return Material(
        name="S355 structural steel",
        youngs_modulus_pa=210e9,
        poisson_ratio=0.30,
        yield_strength_pa=355e6,
        density_kg_m3=7850.0,
    )


def default_box_design() -> BoxContainerDesign:
    return BoxContainerDesign(
        name="naive_sealed_flat_box",
        outer_length_m=12.192,
        outer_width_m=2.438,
        outer_height_m=2.591,
        wall_thickness_m=0.016,
        roof_thickness_m=0.018,
        door_thickness_m=0.020,
        wall_bay_span_m=0.60,
        roof_bay_span_m=0.60,
        door_clear_span_m=2.34,
        access_lid_span_m=1.20,
        access_lid_thickness_m=0.025,
    )


def default_hull_design() -> InternalHullDesign:
    return InternalHullDesign(
        name="iso_frame_internal_pressure_hull",
        envelope_length_m=12.192,
        envelope_width_m=2.438,
        envelope_height_m=2.591,
        hull_outer_diameter_m=2.20,
        hull_cyl_length_m=9.40,
        shell_thickness_m=0.030,
        endcap_thickness_m=0.035,
        endcap_radius_m=1.10,
        hatch_diameter_m=0.80,
        hatch_thickness_m=0.060,
        shell_buckling_knockdown=0.20,
        head_buckling_knockdown=0.50,
    )


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Run subsea 40-foot container structural screening.")
    parser.add_argument("--max-depth-m", type=float, default=150.0)
    parser.add_argument("--depth-step-m", type=float, default=5.0)
    parser.add_argument("--target-depth-m", type=float, default=100.0)
    parser.add_argument("--wall-thickness-mm", type=float, default=None)
    parser.add_argument("--roof-thickness-mm", type=float, default=None)
    parser.add_argument("--door-thickness-mm", type=float, default=None)
    parser.add_argument("--lid-thickness-mm", type=float, default=None)
    parser.add_argument("--wall-bay-span-m", type=float, default=None)
    parser.add_argument("--roof-bay-span-m", type=float, default=None)
    parser.add_argument("--door-clear-span-m", type=float, default=None)
    parser.add_argument("--lid-span-m", type=float, default=None)
    parser.add_argument("--shell-thickness-mm", type=float, default=None)
    parser.add_argument("--endcap-thickness-mm", type=float, default=None)
    parser.add_argument("--hatch-thickness-mm", type=float, default=None)
    parser.add_argument("--hull-diameter-m", type=float, default=None)
    parser.add_argument("--hull-length-m", type=float, default=None)
    parser.add_argument("--hatch-diameter-m", type=float, default=None)
    parser.add_argument("--shell-knockdown", type=float, default=None)
    parser.add_argument("--head-knockdown", type=float, default=None)
    parser.add_argument(
        "--output-dir",
        type=Path,
        default=Path("underwater_datacenter_project") / "simulation_outputs",
    )
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    output_dir = args.output_dir
    output_dir.mkdir(parents=True, exist_ok=True)

    material = default_material()
    box_design = default_box_design()
    hull_design = default_hull_design()

    if args.wall_thickness_mm is not None:
        box_design = BoxContainerDesign(**{**asdict(box_design), "wall_thickness_m": args.wall_thickness_mm / 1000.0})
    if args.roof_thickness_mm is not None:
        box_design = BoxContainerDesign(**{**asdict(box_design), "roof_thickness_m": args.roof_thickness_mm / 1000.0})
    if args.door_thickness_mm is not None:
        box_design = BoxContainerDesign(**{**asdict(box_design), "door_thickness_m": args.door_thickness_mm / 1000.0})
    if args.lid_thickness_mm is not None:
        box_design = BoxContainerDesign(**{**asdict(box_design), "access_lid_thickness_m": args.lid_thickness_mm / 1000.0})
    if args.wall_bay_span_m is not None:
        box_design = BoxContainerDesign(**{**asdict(box_design), "wall_bay_span_m": args.wall_bay_span_m})
    if args.roof_bay_span_m is not None:
        box_design = BoxContainerDesign(**{**asdict(box_design), "roof_bay_span_m": args.roof_bay_span_m})
    if args.door_clear_span_m is not None:
        box_design = BoxContainerDesign(**{**asdict(box_design), "door_clear_span_m": args.door_clear_span_m})
    if args.lid_span_m is not None:
        box_design = BoxContainerDesign(**{**asdict(box_design), "access_lid_span_m": args.lid_span_m})

    if args.shell_thickness_mm is not None:
        hull_design = InternalHullDesign(**{**asdict(hull_design), "shell_thickness_m": args.shell_thickness_mm / 1000.0})
    if args.endcap_thickness_mm is not None:
        hull_design = InternalHullDesign(**{**asdict(hull_design), "endcap_thickness_m": args.endcap_thickness_mm / 1000.0})
    if args.hatch_thickness_mm is not None:
        hull_design = InternalHullDesign(**{**asdict(hull_design), "hatch_thickness_m": args.hatch_thickness_mm / 1000.0})
    if args.hull_diameter_m is not None:
        hull_design = InternalHullDesign(
            **{
                **asdict(hull_design),
                "hull_outer_diameter_m": args.hull_diameter_m,
                "endcap_radius_m": args.hull_diameter_m / 2.0,
            }
        )
    if args.hull_length_m is not None:
        hull_design = InternalHullDesign(**{**asdict(hull_design), "hull_cyl_length_m": args.hull_length_m})
    if args.hatch_diameter_m is not None:
        hull_design = InternalHullDesign(**{**asdict(hull_design), "hatch_diameter_m": args.hatch_diameter_m})
    if args.shell_knockdown is not None:
        hull_design = InternalHullDesign(**{**asdict(hull_design), "shell_buckling_knockdown": args.shell_knockdown})
    if args.head_knockdown is not None:
        hull_design = InternalHullDesign(**{**asdict(hull_design), "head_buckling_knockdown": args.head_knockdown})

    depths = np.arange(5.0, args.max_depth_m + 0.1, args.depth_step_m)
    box_df, hull_df = run_depth_sweep(depths, material, box_design, hull_design)

    box_csv = output_dir / "box_depth_sweep.csv"
    hull_csv = output_dir / "internal_hull_depth_sweep.csv"
    box_df.to_csv(box_csv, index=False)
    hull_df.to_csv(hull_csv, index=False)

    sf_plot = output_dir / "safety_factor_vs_depth.png"
    heatmap_plot = output_dir / "failure_heatmap.png"
    plot_safety_factor_curves(box_df, hull_df, sf_plot)
    plot_failure_heatmap(box_df, hull_df, heatmap_plot)

    summary_text = build_summary(material, box_design, hull_design, box_df, hull_df, args.target_depth_m)
    summary_path = output_dir / "simulation_summary.md"
    summary_path.write_text(summary_text, encoding="utf-8")

    metadata = {
        "material": asdict(material),
        "box_design": asdict(box_design),
        "internal_hull_design": asdict(hull_design),
        "target_depth_m": args.target_depth_m,
        "max_depth_m": args.max_depth_m,
        "depth_step_m": args.depth_step_m,
    }
    (output_dir / "simulation_metadata.json").write_text(json.dumps(metadata, indent=2), encoding="utf-8")

    print(f"Wrote outputs to {output_dir.resolve()}")
    print(f"Summary: {summary_path.resolve()}")
    print(f"Curves: {sf_plot.resolve()}")
    print(f"Heatmap: {heatmap_plot.resolve()}")


if __name__ == "__main__":
    main()