ShipNet: A Geometric Deep Learning Surrogate for Real-Time Ship Hydrodynamics

ShipNet is a geometric deep learning surrogate model that leverages hull point clouds and speed to predict near-field pressure distributions and far-field wave patterns in approximately 0.15 seconds, achieving a 550x speedup over traditional potential-flow solvers while maintaining high accuracy (R² ≥ 0.91) for rapid ship design exploration.

The Gist

Imagine you are an architect trying to design the perfect boat. To do this, you need to know how water will push against the hull and what kind of waves the boat will create as it moves. Traditionally, figuring this out is like trying to predict the weather: you have to run massive, super-complex computer simulations that take hours or even days to finish. It's accurate, but it's so slow and expensive that you can only test a handful of designs before you run out of time and money.

This paper introduces ShipNet, a new "AI shortcut" that solves this problem. Think of ShipNet not as a slow, detailed weather forecaster, but as a super-fast, highly trained expert who has studied thousands of boat designs and can instantly guess how the water will behave just by looking at a picture of the boat's shape.

Here is how it works, broken down into simple concepts:

1. The "Magic Eye" (Geometric Deep Learning)

Usually, computers struggle to understand 3D shapes because they are used to looking at grids (like a chessboard). But a boat hull is a smooth, curvy surface.

• The Analogy: Imagine trying to describe a sculpture to someone. You could try to describe it square by square (like a grid), but that's clumsy. Instead, ShipNet looks at the boat as a cloud of 1,024 tiny dots (a point cloud) floating in space.
• How it learns: It uses a special type of AI called a "Dynamic Graph Convolutional Network." Think of this as the AI playing a game of "connect the dots." It looks at each dot and asks, "Who are my neighbors?" It constantly redraws these connections as it digs deeper, learning not just the shape of the dots, but how the curves and bumps relate to each other.

2. The "Two-in-One" Prediction

ShipNet doesn't just guess one thing; it does two jobs at once using a single brain:

• Job A (The Skin): It predicts the pressure on the boat's skin. Imagine the water pushing against the hull; some spots get a hard shove (high pressure), and others get a gentle pull (low pressure). ShipNet maps this out dot-by-dot.
• Job B (The Wake): It predicts the waves left behind. This is like predicting the ripples in a pond after you throw a stone. It generates a 2D map showing exactly how high the waves will be behind the boat.

3. The Training Diet

To get this AI smart, the researchers didn't feed it real ocean data (which is messy and hard to get). Instead, they fed it 420 perfect, computer-generated simulations of two different types of yacht hulls (one with a straight nose, one with a bulbous nose).

• They created 70 variations of each yacht, changing things like the length of the nose or the width of the bulb.
• They tested these at three different speeds.
• The AI studied these simulations until it learned the "rules" of how shape changes affect water pressure and waves.

4. The "Super-Speed" Result

This is where the magic happens.

• The Old Way: Running one of those computer simulations takes about 3.8 minutes on a standard computer processor.
• The ShipNet Way: Once the AI is trained, it can look at a new boat design and give you the answer in 0.15 seconds on a graphics card.
• The Takeaway: That is a 1,500 times speedup. It turns a process that used to take hours into something that happens almost instantly. This means designers can now test hundreds of ideas in the time it used to take to test one.

5. How Good Is It?

The paper claims the AI is incredibly accurate:

• For the pressure on the boat's skin, it got it right 98% of the time compared to the slow, perfect simulations.
• For the wave patterns, it got it right 91% of the time.
• The Catch: The AI is only as good as the data it ate. It was trained on "inviscid" data, which means it assumes the water has no friction (like a perfect, slippery slide). It doesn't yet account for the "stickiness" of real water (viscosity) or complex parts like rudders and propellers. It also only knows about the specific types of yachts it was trained on.

Summary

ShipNet is a digital crystal ball for ship designers. By teaching a computer to "see" a boat as a cloud of dots and learn the physics of water from thousands of practice runs, the researchers created a tool that predicts how a boat will move through water almost instantly. While it's not perfect yet (it's missing some real-world friction details), it proves that we can replace slow, heavy calculations with fast, smart guesses, potentially revolutionizing how we design ships to be faster and more fuel-efficient.

Technical Summary

Technical Summary: ShipNet – A Geometric Deep Learning Surrogate for Real-Time Ship Hydrodynamics

Problem Statement
Accurate prediction of hydrodynamic performance is fundamental to ship design, yet high-fidelity Computational Fluid Dynamics (CFD), particularly Reynolds-Averaged Navier-Stokes (RANS) simulations, remains computationally prohibitive for large-scale parametric exploration. While CFD provides necessary detail for evaluating hull pressure and free-surface wave patterns, the substantial resource requirements and long turnaround times hinder its use as an interactive design tool. Existing data-driven surrogate models often rely on structured grids or fixed spatial discretizations, which struggle to accommodate the geometric variability inherent in hull-form design. There is a critical need for a surrogate model that can rapidly approximate hydrodynamic fields directly from unstructured geometric representations without sacrificing the ability to capture complex flow features.

Methodology
The authors propose ShipNet, a geometric deep learning surrogate designed to predict hull-surface pressure distributions and far-field free-surface wave patterns directly from hull geometry and operating speed.

• Data Generation: The training dataset comprises 420 inviscid free-surface simulations generated using the potential-flow panel method solver RAPID. The data covers two parent yacht hulls (one with a straight bow, one with a bulbous bow), each parameterized into 70 variants via a Latin hypercube design. Simulations were conducted at three speeds (12, 15, and 18 knots), resulting in a Froude number range of $Fn \in [0.197, 0.322]$.
• Data Preprocessing: Hull geometries were represented as point clouds ($N_p = 1024$ points sampled quasi-uniformly from the wetted surface) and aligned to a consistent global reference frame. Free-surface wave elevations were interpolated onto a fixed $256 \times 256$ Eulerian grid. Both pressure coefficients ($C_p$) and wave elevations ($\eta$) were standardized using training-set statistics.
• Architecture: ShipNet adapts the regression-based Dynamic Graph Convolutional Neural Network (regDGCNN).
  • Backbone: A shared backbone processes the input point cloud (augmented with the Froude number as a feature channel) through three successive EdgeConv layers. These layers dynamically construct $k$-nearest-neighbor graphs ($k=40$) to capture local geometric structures and aggregate them into a global latent embedding.
  • Multi-Head Output: The latent representation is decoded by two specialized heads:
    1. Pressure Head: Predicts the pressure coefficient at each sampled hull point using 1D convolutional layers, combining local geometric context with the global embedding.
    2. Wave Head: Predicts the 2D free-surface elevation map using a U-Net-like decoder with transposed convolutions to upsample the latent features to the target resolution.
• Loss Function: The model is trained with a composite loss function. The pressure loss is a standard Mean Squared Error (MSE). The wave loss utilizes a hybrid objective combining $L_1$ error, Structural Similarity Index Measure (SSIM), and a gradient penalty (Sobel filter) to enforce pixel-wise accuracy, structural similarity, and correct prediction of wave crests/troughs.

Key Contributions

1. Architecture Adaptation: Successfully adapted the regDGCNN architecture, previously demonstrated in automotive aerodynamics, to the two-phase ship hydrodynamics domain, handling the coupled air-water interface and vessel response.
2. Multi-Task Formulation: Developed a unified framework that jointly predicts near-body 3D manifold signals (hull pressure) and far-field 2D fields (wave elevation) from a shared latent representation, addressing both local and global flow behaviors simultaneously.
3. Validated Surrogate: Demonstrated a high-fidelity surrogate capable of predicting hydrodynamic fields with high accuracy ($R^2 \approx 0.98$ for pressure, $R^2 \approx 0.91$ for waves) while achieving a computational speedup of approximately 1500x compared to the potential-flow solver used for data generation.

Results

• Accuracy: On a geometry-held-out test set (63 cases), ShipNet achieved a mean $R^2$ of 0.981 for hull pressure and 0.912 for wave elevation. The model correctly identified primary flow features, such as stagnation points and Kelvin wake structures. Errors were localized to regions of high geometric complexity (e.g., bulbous bow leading edges) and high pressure gradients.
• Loss Function Sensitivity: Ablation studies revealed that the choice of loss function was critical. Training the wave head with standard MSE resulted in a negative $R^2$ (-0.360) and a trivial, over-smoothed solution. The hybrid loss ($L_1 + SSIM + Sobel$) was essential for capturing the sparse, high-amplitude features of the wave field.
• Efficiency: Inference time is approximately 0.15 seconds per case on an NVIDIA T4 GPU, compared to ~228 seconds for the RAPID solver on a single CPU core. This represents a 1500x speedup relative to the data-generation solver and a 550x speedup relative to CPU-based inference.
• Data Efficiency: Performance saturated at roughly 50% of the available dataset, indicating strong data efficiency.

Significance and Claims
The paper positions ShipNet as a proof-of-concept for using graph-based neural networks to create surrogate models for complex fluid-structure interaction problems. The authors claim that this approach fundamentally shifts the paradigm of early-stage ship design by reducing simulation latency from minutes to milliseconds. This enables:

• Interactive Design: Facilitating real-time, data-rich design spirals where vast parametric spaces can be explored systematically, a task infeasible with traditional simulation workflows.
• Early-Stage Screening: Providing rapid ranking and qualitative insights for hull candidates, prioritizing speed and geometric understanding over exact viscous detail in the initial design phases.
• Broader Applicability: Establishing a framework potentially applicable to other sectors involving fluid dynamics, such as aerospace and renewable energy, by operating directly on unstructured geometric representations.

Limitations
The authors explicitly acknowledge that the model is trained on inviscid potential flow data and is currently limited to a specific family of slender yacht hulls without appendages. Consequently, the model does not capture viscous effects (e.g., boundary layers) or complex stern flows (e.g., transom wakes). Future work is identified as necessary to extend the architecture to high-fidelity RANS datasets and more diverse vessel geometries.