Source-linked AI summary
Geometry-Informed Neural Operator for Large-Scale 3D PDEs
Zongyi Li, Nikola Borislavov Kovachki, Chris Choy, Boyi Li, Jean Kossaifi, Shourya Prakash Otta, Mohammad Amin Nabian, Maximilian Stadler, Christian Hundt, Kamyar Azizzadenesheli, Anima Anandkumar
TL;DR
Large-scale 3D PDE simulations with complex geometries are expensive because detailed physics requires high-resolution numerical methods. GINO combines graph and Fourier neural operators through a regular latent space to learn solution operators, achieving substantial speedups while maintaining competitive accuracy in CFD case studies.
Problem
High-resolution numerical methods for large-scale PDEs, including CFD, are time-consuming and expensive when capturing detailed physics.
Method
GINO uses signed-distance-function geometry features and graph neural operators to map irregular inputs to regular latent spaces where Fourier neural operators capture global interactions.
Results
GINO achieved substantial CFD speedups, with reported acceleration ranging from 26,000× over GPU-based OpenFOAM for drag coefficients to 100,000 times in conclusion case studies, while attaining one-fourth to one-half the error rates of prevailing neural networks.
Takeaways & Limitations
The case studies support GINO as a discretization-convergent approach that combines computational efficiency with competitive accuracy for CFD involving varying geometries.
Takeaways & Limitations
The paper identifies studying the regularity properties of the presently defined operator as future work.
Abstract
from arXiv · showhide
We propose the geometry-informed neural operator (GINO), a highly efficient approach to learning the solution operator of large-scale partial differential equations with varying geometries. GINO uses a signed distance function and point-cloud representations of the input shape and neural operators based on graph and Fourier architectures to learn the solution operator. The graph neural operator handles irregular grids and transforms them into and from regular latent grids on which Fourier neural operator can be efficiently applied. GINO is discretization-convergent, meaning the trained model can be applied to arbitrary discretization of the continuous domain and it converges to the continuum operator as the discretization is refined. To empirically validate the performance of our method on large-scale simulation, we generate the industry-standard aerodynamics dataset of 3D vehicle geometries with Reynolds numbers as high as five million. For this large-scale 3D fluid simulation, numerical methods are expensive to compute surface pressure. We successfully trained GINO to predict the pressure on car surfaces using only five hundred data points. The cost-accuracy experiments show a $26,000 \times$ speed-up compared to optimized GPU-based computational fluid dynamics (CFD) simulators on computing the drag coefficient. When tested on new combinations of geometries and boundary conditions (inlet velocities), GINO obtains a one-fourth reduction in error rate compared to deep neural network approaches.
1 Introduction
Large-scale 3D PDE simulation is expensive on varying geometries, motivating GINO, which combines graph and Fourier neural operators through a regular latent grid. Experiments on car aerodynamics show substantial speed and accuracy gains.
- Motivation: High-resolution CFD simulations can require more than ten hours per trial shape, making repeated evaluation for design optimization expensive.The motivation is especially acute when thousands of candidate shapes must be solved.
- Related work: Prior graph and Fourier approaches face complementary limitations: graph methods struggle with long-range interactions, while FFT-based methods require regular grids.GINO addresses this combination by transforming between irregular physical geometry and a regular latent representation.
- Method: GINO learns solution operators for large-scale PDEs on arbitrary geometries and mesh discretizations using SDF and point-cloud representations.Its architecture combines geometry-aware graph operators with Fourier operators.
- Method: GINO maps irregular geometry data to a regular latent grid with GNO layers, applies FNO layers for global interactions, then projects predictions back to the input domain.This division uses graph operations for irregular grids and FFT-efficient Fourier processing on regular grids.
- Experiments: 26,000× faster drag-coefficient computation was achieved than with GPU-based OpenFOAM, with 8.31% and 7.29% full-pressure-field error rates on Ahmed-body and Shape-Net car datasets.The datasets include 500+ Ahmed’s body geometries and large spatial meshes.
- Experiments: GINO supports zero-shot super-resolution by training with one-eighth of the mesh points and evaluating accurately on the unseen full mesh.The reported result concerns pressure prediction on vehicle surfaces.
2 Problem setting
The paper formulates learning a PDE solution operator whose inputs include geometry, forcing, and boundary conditions, with geometry represented through distance functions. The formulation assumes well-posed PDE solutions and bounded extensions, while leaving operator regularity for future work.
- The problem is to learn the map from a PDE geometry to its solution.
- Distance functions define closed surfaces and enclosed Lipschitz domains that determine the computational domain.For each T, the zero set S_T defines the surface, while Ω_T is the exterior domain bounded by the cube boundary and S_T.
- The formulation assumes each PDE instance has a unique solution in a Banach space of functions on Ω_T.
- The operator maps geometry, forcing, and boundary conditions to an extended solution function through bounded linear extension operators.The mapping is (T, f, g) ↦ E_T(u).
- For steady Navier–Stokes equations, velocity, pressure, viscosity, forcing, and boundary functions define the PDE example.The surface condition v = 0 is a no-slip boundary, while q specifies inlet and outlet flow conditions.
- The regularity properties of the defined solution operator are left for future work.
3 Geometric-Informed Neural Operator
GINO combines graph-based local integration with Fourier-based global integration to learn operators on varying geometries and mesh discretizations. Its encoder maps irregular point-cloud data to a regular latent grid, while its decoder evaluates outputs at arbitrary points.
- Architecture: GINO is a neural operator architecture for varying geometries and mesh regularities, using local graph integration and global Fourier integration.The architecture includes local kernel integration layers, FNO layers, and final kernel integral layers.
- Graph operator block: GINO discretizes local kernel integrals using sampled graph neighbors and Riemannian weights, with computational cost scaling as O(E) = O(MN).M is the graph degree, and the implementation uses hash grids to avoid the O(N^2) cost of exhaustive neighbor searches.
- Encoder and global model: The GNO encoder transforms irregular surface point clouds into functions on a uniform latent grid, where FNO layers can efficiently perform global integration with FFT.The grid also receives the geometry-specifying SDF evaluated at the same locations.
- Decoder: The decoder queries arbitrary output points from the regular latent grid and evaluates the output function on those points.Independent query batches can be run in parallel to reduce memory use.
- Boundary conditioning: Adaptive instance normalization embeds scalar inlet velocity with Fourier features and uses an MLP to produce normalization scale and shift parameters.The method is used when boundary information varies and is reported to improve performance because output magnitude depends strongly on inlet velocity.
4 Experiments
The experiments benchmark GINO on Shape-Net Car and large-scale Ahmed-body CFD datasets, evaluating predictive accuracy, computational cost, and discretization convergence. GINO achieves the lowest reported errors, substantial speedups, and stable performance across resolutions and mesh sampling rates.
- Benchmark setup: GINO is benchmarked against GNO, MeshGraphNet, GeoFNO, 3D UNet, and FNO on Shape-Net Car and Ahmed-body CFD datasets.All models use the same single NVIDIA V100 GPU setting.
- Datasets: The Ahmed-body dataset contains 551 parameterized vehicle shapes, with 500 used for training and 51 for validation, and simulations spanning Reynolds numbers from 4.35×10^5 to 6.82×10^6.The simulations use approximately 7.2 million mesh points, including 100,000 surface points, and require 7–19 hours each.
- Predictive accuracy: GINO achieves 8.31% error on Ahmed-body and 7.12% on Shape-Net Car, outperforming the previous best results of 11.16% and 9.42% respectively.The Shape-Net Car comparison is against FNO.
- Computational cost: 0.1 seconds is GINO’s reported evaluation time, compared with 10 hours for GPU-parallel OpenFOAM data generation, corresponding to a 100,000x speedup.The comparison concerns evaluating the predicted vehicle pressure-related output against the solver workflow.
- Cost-accuracy analysis: 26,000x faster is GINO’s reported drag-coefficient computation speed compared with OpenFOAM in the cost-accuracy analysis.The curve measures inference time required to reach a specified relative drag-coefficient error.
- Discretization convergence: GINO maintains a consistent error rate across latent-grid resolutions and input-output mesh sampling rates, with only slight degradation on coarser meshes.It also retains consistent error when trained on coarsened meshes and tested on the unseen full mesh.
5 Related Work
Related work combines graph-based methods for irregular geometries with Fourier-based operators for global interactions. The paper positions GINO as addressing computational and discretization-convergence limitations in prior combinations of these ideas.
- Fourier neural operators: FNO efficiently captures global interactions on regular grids through FFT, but FFT limits its direct use on irregular grids and complex geometries.GeoFNO addresses this by learning a deformation to a latent regular grid, but requires a computationally demanding geometric discrete Fourier transform.
- Fourier neural operators: GINO limits Fourier processing to a local GNO-based transformation, using physical-space metrics to improve efficiency while retaining discretization convergence.This contrasts with GeoFNO’s geometric discrete Fourier transform.
- Prior hybrid approaches: NFS replaces GNO integration with summation over nearest-neighbor graph points, which the paper describes as failing to provide a discretization-convergent approach.The paper distinguishes this architecture from neural-operator integration.
- Graph neural methods: GNN-based PDE methods represent physical entities as graph nodes and interactions as edges, while GNO defines graph connections using physical-space balls rather than fixed neighbor sets.The paper associates fixed nearest-neighbor connectivity in GNNs with discretization-dependence.
6 Conclusion
GINO combines graph-kernel encoders and decoders with Fourier blocks on a latent uniform space for 3D PDEs with complex geometries. Case studies report major acceleration and lower error rates, while the method remains limited by training-data and shape-category scope.
- Conclusion: GINO uses graph-kernel blocks to map complex-geometry inputs to a latent uniform space, where Fourier blocks capture global interactions.The architecture includes graph-kernel encoders and decoders around the latent Fourier representation.
- Conclusion: The case studies cover Shape-Net Car and an Ahmed-body dataset with over 600 car geometries and hundreds of thousands of mesh points.These datasets provide the paper’s 3D CFD evaluation setting.
- Conclusion: 100,000 times acceleration is reported for GINO relative to the GPU-based OpenFOAM solver.The conclusion also reports one-fourth to one-half the error rates of neural-network baselines such as 3D U-Net.
- Limitations: The trained surrogate model is limited to a specific category of shapes, and its quality depends on the training dataset.The paper notes that obtaining large training datasets for more complex CFD shapes is difficult.
7 Appendix
The appendix evaluates GINO through architecture ablations, benchmark comparisons, implementation choices, super-resolution, and drag-coefficient cost-accuracy analysis. Results show that latent-space and radius choices affect performance, while GINO maintains resolution robustness and achieves substantial computational savings.
- Experiments and Ablations: Larger latent spaces and radii yield superior GINO performance in the Ahmed-body ablations.The evaluated latent spaces range from 32 to 80, and radii from 0.025 to 0.055.
- Experiments and Ablations: When the latent grid matches or exceeds the input mesh, encoder-decoder and decoder-only designs show comparable performance.The encoder is more useful when the input mesh significantly exceeds the latent grid.
- Super-resolution and Data: The study trains GINO on sub-sampled meshes to test super-resolution and evaluates pressure-field prediction across Ahmed-body and Shape-Net Car CFD datasets.The Ahmed-body experiments also predict wall shear stress for drag-coefficient evaluation.
- Implementation: Hash-based graph construction uses 6GB of GPU memory for 10k points, compared with 24GB for the pairwise method.The hash-based implementation is reported as 40% faster and uses O(Ndr^3) memory versus O(N^2) for pairwise construction.
- Drag Coefficient Comparison: 26,000× speed-up is achieved by GINO at a 3% relative drag-coefficient error compared with OpenFOAM.The cost comparison includes preprocessing, model runtime, and drag calculation for GINO; OpenFOAM runs on two GPUs.