File size: 7,117 Bytes
aa6138d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | """Optimize deep-water container-format subsea concepts.
The concept space here is intentionally limited to designs that preserve an ISO-like
external handling frame while using multiple internal rounded pressure tubes.
This is a screening optimizer, not certifiable FEA.
"""
from __future__ import annotations
import argparse
import json
import math
from pathlib import Path
import pandas as pd
from simulate_subsea_container import (
G,
RHO_SEAWATER,
default_material,
hydrostatic_pressure,
required_cylinder_thickness,
)
ISO_LENGTH = 12.192
ISO_WIDTH = 2.438
ISO_HEIGHT = 2.591
def tube_volume(radius_m: float, cyl_length_m: float) -> float:
return math.pi * radius_m**2 * cyl_length_m + 4.0 / 3.0 * math.pi * radius_m**3
def tube_area(radius_m: float, cyl_length_m: float) -> float:
return 2.0 * math.pi * radius_m * cyl_length_m + 4.0 * math.pi * radius_m**2
def shell_mass_kg(count: int, radius_m: float, cyl_length_m: float, shell_thickness_m: float, density_kg_m3: float) -> float:
return count * tube_area(radius_m, cyl_length_m) * shell_thickness_m * density_kg_m3
def bundle_fits(layout: str, diameter_m: float, clearance_m: float) -> bool:
if layout == "single":
return diameter_m + 2 * clearance_m <= min(ISO_WIDTH, ISO_HEIGHT)
if layout == "twin":
return 2 * diameter_m + 3 * clearance_m <= ISO_WIDTH and diameter_m + 2 * clearance_m <= ISO_HEIGHT
if layout == "quad":
return 2 * diameter_m + 3 * clearance_m <= ISO_WIDTH and 2 * diameter_m + 3 * clearance_m <= ISO_HEIGHT
raise ValueError(layout)
def tube_count(layout: str) -> int:
return {"single": 1, "twin": 2, "quad": 4}[layout]
def current_drag_kn(current_speed_m_s: float, cd: float = 1.05) -> float:
projected_area = ISO_LENGTH * ISO_HEIGHT
drag = 0.5 * RHO_SEAWATER * cd * projected_area * current_speed_m_s**2
return drag / 1000.0
def optimize(target_depth_m: float, min_sf: float, current_speed_m_s: float) -> pd.DataFrame:
material = default_material()
p = hydrostatic_pressure(target_depth_m)
rows: list[dict] = []
clearance = 0.08
for layout in ["single", "twin", "quad"]:
count = tube_count(layout)
for radius_m in [0.40, 0.45, 0.50, 0.52, 0.55, 0.58, 0.60, 0.70, 0.80, 1.00]:
diameter_m = 2.0 * radius_m
if not bundle_fits(layout, diameter_m, clearance):
continue
# Keep room for endcaps, supports, and cable terminations.
for cyl_length_m in [8.8, 9.2, 9.6, 10.0, 10.4]:
if cyl_length_m + diameter_m + 0.6 > ISO_LENGTH:
continue
shell_thickness_m = required_cylinder_thickness(radius_m, p, material, min_sf, 0.2)
total_volume = count * tube_volume(radius_m, cyl_length_m)
total_shell_mass = shell_mass_kg(
count=count,
radius_m=radius_m,
cyl_length_m=cyl_length_m,
shell_thickness_m=shell_thickness_m,
density_kg_m3=material.density_kg_m3,
)
displaced_mass = total_volume * RHO_SEAWATER
score = total_volume / max(total_shell_mass / 1000.0, 1e-6)
rows.append(
{
"layout": layout,
"tube_count": count,
"tube_od_m": diameter_m,
"tube_radius_m": radius_m,
"tube_cyl_length_m": cyl_length_m,
"shell_thickness_mm": shell_thickness_m * 1000.0,
"gross_internal_volume_m3": total_volume,
"shell_mass_tonnes": total_shell_mass / 1000.0,
"displaced_mass_tonnes": displaced_mass / 1000.0,
"net_buoyancy_shell_only_tonnes": (displaced_mass - total_shell_mass) / 1000.0,
"current_drag_kn": current_drag_kn(current_speed_m_s),
"depth_m": target_depth_m,
"min_sf": min_sf,
"score": score,
}
)
df = pd.DataFrame(rows)
if df.empty:
return df
# Prefer higher payload volume, then better volume-per-mass.
return df.sort_values(
["gross_internal_volume_m3", "score", "shell_mass_tonnes"],
ascending=[False, False, True],
)
def build_markdown(best: pd.Series) -> str:
pressure_bar = hydrostatic_pressure(float(best["depth_m"])) / 1e5
return f"""# Deep-Water Container-Format Design
## Recommended concept
The best deep-water container-format concept from the screening sweep is:
- layout: `{best['layout']}`
- tube count: `{int(best['tube_count'])}`
- each tube OD: `{best['tube_od_m']:.2f} m`
- each cylindrical body length: `{best['tube_cyl_length_m']:.2f} m`
- shell thickness: `{best['shell_thickness_mm']:.1f} mm`
## Why this wins
This design keeps the ISO external handling logic while replacing one large pressure boundary with multiple smaller rounded ones. That reduces shell thickness demand at depth and avoids the flat-wall penalty.
## Screened design point
- design depth: `{best['depth_m']:.0f} m`
- hydrostatic pressure: `{pressure_bar:.2f} bar(g)`
- minimum screening safety factor baked into sizing: `{best['min_sf']:.2f}`
- gross internal pressure volume: `{best['gross_internal_volume_m3']:.1f} m^3`
- shell-only mass: `{best['shell_mass_tonnes']:.1f} t`
- shell-only net buoyancy: `{best['net_buoyancy_shell_only_tonnes']:.1f} t`
- broadside current drag at reference current: `{best['current_drag_kn']:.1f} kN`
## Interpretation
For deeper water, the most plausible container-like architecture is not a single container pressure box. It is an ISO frame carrying multiple smaller pressure tubes.
"""
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Optimize deep-water container-format bundle.")
parser.add_argument("--target-depth-m", type=float, default=300.0)
parser.add_argument("--min-sf", type=float, default=1.5)
parser.add_argument("--current-speed-m-s", type=float, default=1.5)
parser.add_argument(
"--output-dir",
type=Path,
default=Path("underwater_datacenter_project") / "optimized_deepwater_container_bundle",
)
return parser.parse_args()
def main() -> None:
args = parse_args()
out = args.output_dir
out.mkdir(parents=True, exist_ok=True)
df = optimize(args.target_depth_m, args.min_sf, args.current_speed_m_s)
if df.empty:
raise SystemExit("No feasible design found.")
best = df.iloc[0]
df.to_csv(out / "candidate_bundle_designs.csv", index=False)
(out / "best_bundle_design.json").write_text(best.to_json(indent=2), encoding="utf-8")
(out / "final_design.md").write_text(build_markdown(best), encoding="utf-8")
print(f"Wrote outputs to {out.resolve()}")
print(f"Best design file: {(out / 'final_design.md').resolve()}")
if __name__ == "__main__":
main()
|