Title: Geometry-Informed Neural Operator for Large-Scale 3D PDEs
Venue: NeurIPS 2023
Accepted: yes
Keywords: partial differential equation

computational fluid dynamics

neural operator
Abstract: We propose the geometry-informed neural operator (GINO), a highly efficient approach for learning the solution operator of large-scale partial differential equations with varying geometries. GINO uses a signed distance function (SDF) representation 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. We provide an efficient implementation of GINO using an optimized hashing approach, which allows efficient learning  in a shared, compressed latent space with reduced computation and memory costs. GINO is discretization-invariant, meaning the trained model can be applied to arbitrary discretizations of the continuous domain and applies to any shape or resolution.  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,000x 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.

Geometry-Informed Neural Operator

Abstract

We propose the geometry-informed neural operator (GINO), a highly efficient approach for learning the solution operator of large-scale partial differential equations with varying geometries. GINO uses a signed distance function (SDF) 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 discretizationconvergent, meaning the trained model can be applied to arbitrary discretizations 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 × 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

Computational sciences aim to understand natural phenomena and develop computational models to study the physical world around us. Many natural phenomena follow the first principles of physics and are often described as evolution on function spaces, governed by partial differential equations (PDE). Various numerical methods, including finite difference and finite element methods, have been developed as computational approaches for solving PDEs. However, these methods need to be run at very high resolutions to capture detailed physics, which are time-consuming and expensive, and often beyond the available computation capacity. For instance, in computational fluid dynamics (CFD), given a shape design, the goal is to solve the Navier-Stokes equation and estimate physical properties such as pressure and velocity. Finding the optimal shape design often requires solving thousands of trial shapes, each of which can take more than ten hours even with GPUs [1].

To overcome these computational challenges, recent works propose deep learning-based methods, particularly neural operators [2], to speed up the simulation and inverse design. Neural operators

Input

Samples

GNO

FNO

GNO

Prediction

discretize

query

Operates on

input geometry

Operates on (latent)

regular geometry

Projects to

output geometry

-134.

-48.3

37.2

123.

FNO layers

generalize neural networks and learn operators, which are mappings between infinite-dimensional function spaces [2]. Neural operators are discretization convergent and can approximate general operators [3]. The input function to neural operators can be presented at any discretization, grid, resolution, or mesh, and the output function can be evaluated at any arbitrary point. Neural operators have shown promise in learning solution operators in partial differential equations (PDE) [3] with numerous applications in scientific computing, including weather forecasting [4], carbon dioxide storage and reservoir engineering [5], with a tremendous speedup over traditional methods. Prior works on neural operators developed a series of principled neural operator architectures to tackle a variety of scientific computing applications. Among the neural operators, graph neural operators (GNO) [2], and Fourier neural operators (FNO) [6] have been popular in various applications.

GNO implements kernel integration with graph structures and is applicable to complex geometries and irregular grids. The kernel integration in GNO shares similarities with the message-passing implementation of graph neural networks (GNN) [7], which is also used in scientific computing [810]. However, the main difference is that GNO defines the graph connection in a ball defined on the physical space, while GNN typically assumes a fixed set of neighbors, e.g., k-nearest neighbors, see Figure 5. Such nearest-neighbor connectivity in GNN violates discretization convergence, and it degenerates into a pointwise operator at high resolutions, leading to a poor approximation of the ground-truth operator using GNN. In contrast, GNO adapts the graph based on points within a physical space, allowing for universal approximation of operators. However, one limitation of graphbased methods is the computational complexity when applied to problems with long-range global interactions. To overcome this, prior works propose using multi-pole methods or multi-level graphs [11, 12] to help with global connectivity. However, they do not fully alleviate the problem since they require many such levels to capture global dependence, which still makes them expensive.

While GNO performs kernel integration in the physical space using graph operations, FNO leverages Fourier transform to represent the kernel integration in the spectral domain using Fourier modes. This architecture is applicable to general geometries and domains since the (continuous) Fourier transform can be defined on any domain. However, it becomes computationally efficient when applied to regular input grids since the continuous Fourier transform can then be efficiently approximated using discrete Fast Fourier transform (FFT) [13], giving FNO a significant quasi-linear computational complexity. However, FFT limits FNO to regular grids and cannot directly deal with complex geometries and irregular grids. A recent model, termed GeoFNO, learns a deformation from a given geometry to a latent regular grid [14] so that the FFT can be applied in the latent space. In order to transform the latent regular grid back to the irregular physical domain, discrete Fourier transform (DFT) on irregular grids is employed. However, DFT on irregular grids is more expensive than FFT, quadratic vs. quasi-linear, and does not approximate the Fourier transform in a discretization convergent manner. This is because, unlike in the regular setting, the points are not sampled at regular intervals, and therefore the integral does not take into account the underlying measure. Other attempts share a similar computational barrier as shown in Table 1, which we discussed in Section 5.

In this paper , we consider learning the solution operator for large-scale PDEs, in particular, 3D CFD simulations. We propose the geometry-informed neural operator (GINO), a neural operator

208.

architecture for arbitrary geometries and mesh discretizations. It uses a signed distance function (SDF) to represent the geometry and composes GNO and FNO architectures together in a principled manner to exploit the strengths of both frameworks.

The GNO by itself can handle irregular grids through graphs but is able to operate only locally under a limited computational budget, while the FNO can capture global interactions, but requires a regular grid. By using GNO to transform the irregular grid into a regular one for the FNO block, we can get the best of both worlds, i.e., computational efficiency and accuracy of the approximation. Thus, this architecture tackles the issue of expensive global integration operations that were unaddressed in prior works, while maintaining discretization convergence.

Specifically, GINO has three main components, ( i ) Geometry encoder : multiple local kernel integration layers through GNO with graph operations, ( ii ) Global model : a sequence of FNO layers for global kernel integration, and ( iii ) Geometry decoder : the final kernel integral layers, as shown in Figure 1. The input to the GINO is the input surface (as a point cloud) along with the SDF, representing the distance of each 3D point to the surface. GINO is trained end-to-end to predict output (e.g., car surface pressure in our experiments), a function defined on the geometry surfaces.

Geometry encoder: the first component in the GINO architecture uses the surface (i.e., point cloud) and SDF features as inputs. The irregular grid representation of the surface is encoded through local kernel integration layers implemented with GNOs, consisting of local graphs that can handle different geometries and irregular grids. The encoded function is evaluated on a regular grid, which is concatenated with the SDF input evaluated on the same grid. Global model: the output of the first component is encoded on a regular grid, enabling efficient learning with an FNO using FFT. Our second component consists of multiple FNO layers for efficient global integration. In practice, we find that this step can be performed at a lower resolution without significantly impacting accuracy, giving a further computational advantage. Geometry decoder: the final component is composed of local GNO-based layers with graph operations, that decode the output of the FNO and project it back onto the desired geometry, making it possible to efficiently query the output function on irregular meshes. The GNO layers in our framework are accelerated using our GPU-based hash-table implementation of neighborhood search for graph connectivity of meshes.

We validate our findings on two large-scale 3D CFD datasets. We generate our own large-scale industry-standard Ahmed's body geometries using GPU-based OpenFOAM [15], composed of 500+ car geometries with O (10 5 ) mesh points on the surface and O (10 7 ) mesh points in space. Each simulation takes 7-19 hours on 16 CPU cores and 2 Nvidia V100 GPUs. Further, we also study a lower resolution dataset with more realistic car shapes, viz., Shape-Net car geometries generated by [16]. GINO takes the point clouds and SDF features as the input and predicts the pressure fields on the surfaces of the vehicles. We perform a full cost-accuracy trade-off analysis. The result shows GINO is 26 , 000 × faster at computing the drag coefficients over the GPU-based OpenFOAM solver, while achieving 8.31% (Ahmed-body) and 7.29% (Shape-Net car) error rates on the full pressure field. Further, GINO is capable of zero-shot super-resolution, training with only one-eighth of the mesh points, and having a good accuracy when evaluated on the full mesh that is not seen during training.

2 Problem setting

We are interested in learning the map from the geometry of a PDE to its solution. We will first give a general framework and then discuss the Navier-Stokes equation in CFD as an example. Let D ⊂ R d be a Lipschitz domain and A a Banach space of real-valued functions on D . We consider the set of distance functions T ⊂ A so that, for each function T ∈ T , its zero set S T = { x ∈ D : T ( x ) = 0 } defines a ( d -1) -dimensional sub-manifold. We assume S T is simply connected, closed, smooth, and that there exists ϵ > 0 such that B ϵ ( x ) ∩ ∂D = ∅ for every x ∈ S T and T ∈ T . We denote by Q T ⊂ D , the open volume enclosed by the sub-manifold S T and assume that Q T is a Lipschitz domain with ∂Q T = S T . We define the Lipschitz domain Ω T := D \ ¯ Q T so that, ∂ Ω T = ∂D ∪ S T . Let L denote a partial differential operator and consider the problem

for some f ∈ F , g ∈ B where B , F denote Banach spaces of functions on R d with the assumption that the evaluation functional is continuous in B . We assume that L is such that, for any triplet ( T, f, g ) , the PDE (1) has a unique solution u ∈ U T where U T denotes a Banach space of functions on Ω T . Let U denote a Banach space of functions on D and let { E T : U T → U : T ∈ T } be a family of extension operators which are linear and bounded. We define the mapping from the distance function to the solution function

by ( T, f, g ) ↦→ E T ( u ) which is our operator of interest.

Navier-Stokes Equation. We illustrate the above abstract formulation with the following example. Let D = (0 , 1) d be the unit cube and let A = C ( ¯ D ) . We take T ⊂ A to be some subset such that the zero level set of every element defines a ( d -1) -dimensional closed surface which can be realized as the graph of a Lipschitz function and that there exists ϵ > 0 such that each surface is at least distance ϵ away from the boundary of D . We now consider the steady Naiver-Stokes equations,

where v : Ω T → R d is the velocity, p : Ω T → R is the pressure, ν is the viscosity, and f, q : R d → R d are the forcing and boundary functions. The condition that v = 0 in S T is commonly known as a 'no slip' boundary and is prevalent in many engineering applications. The function q , on the other hand, defines the inlet and outlet boundary conditions for the flow. We assume that f ∈ H -1 ( R d ; R d ) and q ∈ C ( R d ; R d ) . We can then define our boundary function g ∈ C ( R d ; R d ) such that g ( x ) = 0 for any x ∈ D with dist ( x, ∂D ) ≥ ϵ and g ( x ) = q ( x ) for any x ∈ D with, dist ( x, ∂D ) > ϵ/ 2 as well as any x ̸∈ D . Continuity of g can be ensured by an appropriate extension for any x ∈ D such that dist ( x, ∂D ) < ϵ and dist ( x, ∂D ) ≥ ϵ/ 2 [17]. We define u : Ω T → R d +1 by u = ( v, p ) as the unique weak solution of (3) with U T = H 1 (Ω T ; R d ) × L 2 (Ω T ) / R [18]. We define U = H 1 ( D ; R d ) × L 2 ( D ) / R and the family of extension operators { E T : U T → U} by E T ( u ) = ( E v T ( v ) , E p T ( p ) ) where E v T : H 1 (Ω T ; R d ) → H 1 ( D ; R d ) and E p T : L 2 (Ω T ) / R → L 2 ( D ) / R are defined as the restriction onto D of the extension operators defined in [19, Chapter VI, Theorem 5]. This establishes the existence of the operator Ψ : T × H -1 ( R d ; R d ) × C ( R d ; R d ) → H 1 ( D ; R d ) × L 2 ( D ) / R mapping the geometry, forcing, and boundary condition to the (extended) solution of the steady Navier-Stokes equation (3). Homomorphic extensions of deformation-based operators have been shown in [20]. We leave for future work studying the regularity properties of the presently defined operator.

3 Geometric-Informed Neural Operator

We propose a geometry-informed neural operator (GINO), a neural operator architecture for varying geometries and mesh regularities. GINO is a deep neural operator model consisting of three main components, ( i ) multiple local kernel integration layers, ( ii ) a sequence of FNO layers for global kernel integration which precedes ( iii ) the final kernel integral layers. Each layer of GINO follows the form of generic kernel integral of the form (5). Local integration is computed using graphs, while global integration is done in Fourier space.

3.1 Neural operator

A neural operator Ψ [3] maps the input functions a = ( T, f, g ) to the solution function u . The neural operator Ψ is composed of multiple layers of point-wise and integral operators,

The first layer P is a pointwise operator parameterized by a neural network. It transforms the input function a into a higher-dimensional latent space P : a ↦→ v 0 . Similarly, the last layer acts as a projection layer, which is a pointwise operator Q : v l ↦→ u , parameterized by a neural network Q . The model consists of L layers of integral operators K l : v l -1 ↦→ v l in between.

where κ l is a learnable kernel function. Non-linear activation functions are incorporated between each layer.

3.2 Graph operator block

To efficiently compute the integral in equation (5), we truncate the integral to a local ball at x with radius r > 0 , as done in [2],

We discretize the space and use a Riemann sum to compute the integral. This process involves uniformly sampling the input mesh points and connecting them with a graph for efficient parallel computation. Specifically, for each point x ∈ D , we randomly sample points { y 1 , . . . , y M } ⊂ B r ( x ) and approximate equation (6) as

where µ denotes the Riemannian sum weights corresponding to the ambient space of B r ( x ) . For a fixed input mesh of N points, the computational cost of equation (7) scales with the number of edges, denoted as O ( E ) = O ( MN ) . Here, the number of sampling points M is the degree of the graph. It can be either fixed to a constant sampling size, or scale with the area of the ball.

Encoder. Given an input point cloud { x in 1 , . . . , x in N } ⊂ S T , we employ a GNO-encoder to transform it to a function on a uniform latent grid { x grid 1 , . . . , x grid S } ⊂ D . The encoder is computed as discretization of an integral operator v 0 ( x grid ) ≈ ∑ M i =1 κ ( x grid , y in i ) µ ( y in i ) over ball B r in ( x grid ) . To inform the grid density, GINO computes Riemannian sum weights µ ( y in i ) . Further, we use Fourier features in the kernel [21]. For simple geometries, this encoder can be omitted, see Section 4.

Decoder. Similarly, given a function defined on the uniform latent grid { x grid 1 , . . . , x grid S } ⊂ D , we use a GNO-decoder to query arbitrary output points { x out 1 , . . . , x out N } ⊂ Ω T . The output is evaluated as u ( x out ) ≈ ∑ M i =1 κ ( x out , y grid i ) v l ( y grid i ) µ ( y grid i ) over ball B r out ( x out ) . Here, the Riemannian weight, µ ( y grid i ) = 1 /S since we choose the latent space to be regular grid. Since the queries are independent, we divide the output points into small batches and run them in parallel, which enables us to use much larger models by saving memory.

Efficient graph construction. The graph construction requires finding neighbors to each node that are within a certain radius. The simplest solution is to compute all possible distances between neighbors, which requires O ( N 2 ) computation and memory. However, as the N gets larger, e.g., 10 ∼ 100 million, computation and memory become prohibitive even on modern GPUs. Instead, we use a hash grid-based implementation to efficiently prune candidates that are outside of a ℓ ∞ -ball first and then compute the ℓ 2 distance between only the candidates that survive. This reduces the computational complexity to O ( Ndr 3 ) where d denotes unit density and r is the radius. This can be efficiently done using first creating a hash table of voxels with size r . Then, for each node, we go over all immediate neighbors to the current voxel that the current node falls into and compute the distance between all points in these neighboring voxels. Specifically, we use the CUDA implementation from Open3D [22]. Then, using the neighbors, we compute the kernel integration using gather-scatter operations from torch-scatter [23]. Further, if the degree of the graph gets larger, we can add Nyström approximation by sampling nodes [2].

Ground-truth pressure

Predicted pressure

Relative error

0.00

0.200

0.400

0.600

0.800

-197.

-96.7

3.54

104.

204.

-2.82e+03

-1.90e+03

-991.

-79.0

833.

0.00

0.370

0.739

1.11

1.48

3.3 Fourier operator block

The geometry encoding v 0 and the geometry specifying map T , both evaluated on a regular grid discretizing D are passed to a FNO block. We describe the basic FNO block as first outlined in [6]. We will first define global convolution in the Fourier space and use it to build the full FNO operator block. To that end, we will work on the d -dimensional unit torus T d . We define an integral operator with kernel κ ∈ L 2 ( T d ; R n × m ) as the mapping C : L 2 ( T d ; R m ) → L 2 ( T d ; R n ) given by

Here F , F -1 are the Fourier transform and its inverse respectively, defined for L 2 by the appropriate limiting procedure. The Fourier transform of the function κ will be parameterized directly by some fixed number of Fourier modes, denoted α ∈ N . In particular, we assume

for some index set I ⊂ Z d with | I | = α and coefficients c γ ∈ C n × m . Then we may view F : L 2 ( T d ; R n × m ) → ℓ 2 ( Z d ; C n × m ) so that F ( κ )( γ ) = c γ if γ ∈ I and F ( κ )( γ ) = 0 if γ ̸∈ I . We directly learn the coefficients c γ without ever having to evaluate κ in physical space. We then define the full operator block K : L 2 ( T d ; R m ) → L 2 ( T d ; R n ) by

where σ is a pointwise non-linearity and W ∈ R n × m is a learnable matrix. We further modify the layer by learning the kernel coefficients in tensorized form, adding skip connections, normalization layers, and learnable activations as outlined in [24]. We refer the reader to this work for further details.

Adaptive instance normalization. For many engineering problems of interest, the boundary information is a fixed, scalar, inlet velocity specified on some portion of ∂D . In order to efficiently incorporate this scalar information into our architecture, we use a learnable adaptive instance normalization [25] combined with a Fourier feature embedding [21]. In particular, the scalar velocity is embedded into a vector with Fourier features. This vector then goes through a learnable MLP, which outputs the scale and shift parameters of an instance normalization layer [26]. In problems where the velocity information is not fixed, we replace the normalization layers of the FNO blocks with this adaptive normalization. We find this technique improves performance, since the magnitude of the output fields usually strongly depends on the magnitude of the inlet velocity.

We do a benchmark study with several standard machine-learning methods on the Shape-Net and Ahmed body datasets. The training error is normalized L2 error; the test error is de-normalized L2.

4 Experiments

We explore a range of models on two CFD datasets. The large-scale Ahmed-Body dataset, which we generated, and also the Shape-Net Car dataset from [16]. Both datasets contain simulations of the Reynold-Averaged Navier-Stokes (RANS) equations for a chosen turbulence model. The goal is to estimate the full pressure field given the shape of the vehicle as input. We consider GNO [2], MeshGraphNet [9], GeoFNO [14], 3D UNet [27] with linear interpolation, FNO [6], and GINO. We train each model for 100 epochs with Adam optimizer and step learning rate scheduler. The implementation details can be found in the Appendix. All models run on a single Nvidia V100 GPU.

4.1 Ahmed-Body dataset

We generate the industry-level vehicle aerodynamics simulation based on the Ahmed-body shapes [28]. The shapes are parameterized with six design parameters: length, width, height, ground clearance, slant angle, and fillet radius. We also vary the inlet velocity from 10m/s to 70m/s, leading to Reynolds numbers ranging from 4 . 35 × 10 5 to 6 . 82 × 10 6 . Weuse the GPU-accelerated OpenFOAM solver for steady state simulation using the SST k -ω turbulence model [29] with 7.2 million mesh points in total with 100k mesh points on the surface. Each simulation takes 7-19 hours on 2 Nvidia v100 GPUs with 16 CPU cores. We generate 551 shapes in total and divide them into 500 for training and 51 for validation.

4.2 Shape-Net Car dataset

We also consider the Car dataset generated by [16]. The input shapes are from the ShapeNet Car category [30]. In [16], the shapes are manually modified to remove the side mirrors, spoilers, and tires. The RANS equations with the k -ϵ turbulence model and SUPG stabilization are simulated to obtain the time-averaged velocity and pressure fields using a finite element solver [31]. The inlet velocity is fixed at 20m/s (72km/h) and the estimated Reynolds number is 5 × 10 6 . Each simulation takes approximately 50 minutes. The car surfaces are stored with 3.7k mesh points. We take the 611 water-tight shapes out of the 889 instances, and divide the 611 instances into 500 for training and 111 for validation.

As shown in Table 2 3 and Figure 2, GINO achieves the best error rate with a large margin compared with previous methods. On the Ahmed-body dataset, GINO achieves 8.31% while the previous best method achieve 11.16%. On the Shape-Net Car, GINO achieves 7.12% error rate compared to 9.42% on FNO. It takes 0.1 seconds to evaluate, which is 100,000x faster than the GPU-parallel OpenFOAM solver that take 10 hours to generates the data. We further performance a full cost-accuracy analysis in the following section.

For ablations, we consider channel dimensions [32, 48, 64, 80], latent space [32, 48, 64, 80], and radius from 0.025 to 0.055 (with the domain size normalized to [-1, 1]). As depicted in Figure 4(a) and Table 4, larger latent spaces and radii yield superior performance.

4.3 Cost-accuracy analysis on drag coefficient

To compare the performance of our model against the industry-standard OpenFOAM solver, we perform a full cost-accuracy trade-off analysis on computing the drag coefficient, which is the standard design objective of vehicles and airfoils. The result shows GINO is 26,000x faster at computing the drag coefficients. Figure 3(b) below shows the cost-accuracy curve, measured in terms of inference

Previous works such as GNO and Geo-FNO cannot scale to large meshes with 100k points. We instead add the MeshGraphNet for graph comparison. Again, for UNet, FNO, and GINO, we fix the latent grid to 64 × 64 × 64 . The training error is normalized L2; the test error is de-normalized L2.

0.310

True drag

Filtered drag

0.305

Reference drag

3%relative error

Drag coefficient

0.300

0.295

0.290

10000

20000

30000

40000

50000

60000

Time (seconds)

(a) Example drag coefficient computed after every iteration of the OpenFOAM solver. The reference drag corresponds to the last point of the filtered signal. Triangle indicates the the time when the solver reaches a 3% relative error with respect to the reference drag.

0.065

OpenFOAM

6

0.060

GINO

0.055

GINO (drag loss)

Error

0.050

Relative

0.045

0.040

Average

0.035

0.030

0.025

100

101

102

103

104

Time(seconds)

(b) Cost-accuracy trade-off curve for OpenFOAM vs. GINO. Increasing cost of GINO is achieved by increasing the size of the latent space. Loss function for models on the red line includes only error in pressure and wall shear stress, while, for models on orange line, the loss also includes drag.

time needed for a relative error in the drag coefficient for GINO and OpenFOAM. The detailed setup is discussed in the appendix.

4.4 Discretization-convergence and ablation studies

We investigate discretization-convergence by varying different parts of GINO. Specifically, we vary the latent grid resolution and the sampling rates for input-output meshes. In these experiments, we fixed the training and test samples to be the same, i.e., same latent grid resolution or sampling rate, but varied the shape and input conditions.

Discretization-convergence wrt the latent grid. Here, each model is trained and tested on (the same) latent resolutions, specifically 32, 48, 64, 80, and 88, and the architecture is the same. As depicted in Figure 4(a), GINO demonstrates a comparable error rate across all resolutions. A minor improvement in errors is observed when employing a larger latent space. Conversely, the errors associated with the UNet model grow as the resolution is decreased due to the decreasing receptive field of its local convolution kernels.

Discretization-convergence in the input-output mesh. Here, GINO is trained and tested with sub-sampled input-output meshes at various sampling rates (2x, 4x, 6x, 8x). As illustrated in Figure 4(b), GINO exhibits a consistent error rate across all sampling rates. A slight increase in errors is observed on coarser meshes.

Zero-shot super-resolution. GINO possesses the ability to perform zero-shot super-resolution. The model is trained on a coarse dataset, sub-sampled by 2x, 4x, 6x, and 8x, and subsequently tested on the full mesh, that is not seen during training. The error remains consistent across all sampling rates 4(c). This characteristic enables the model to be trained at a coarse resolution when the mesh is dense, consequently reducing the computational requirements.

GINO(enc-dec)fixed degree

error

0.4

GINO(dec)fixeddegree

GINO (dec) fixed radius

relative12

0.3

UNet

0.2

0.1

0

32

48

64

8088

latent grid resolution

(a) Varying resolutions of the latent grid (same resolution for training and testing).

0.2

GINO(encoder-decoder)

0.15

0.1

0.05

0

2

4

6

8

meshsamplingrate

(b) Varying the sampling rates of the input-output mesh (same rate for training and testing).

0.2

GINO(encoder-decoder)

0.15

0.1

0.05

0

2

4

6

8

mesh sampling rate

(c) Train with a low sampling rate and test on full mesh (zero-shot superresolution).

5 Related Work

The study of neural operators and their extended applications in learning solution operators in PDE has been gaining momentum [3, 32-34]. A method that stands out is FNO, which uses Fourier transform [6]. The FNO and its variations have proven to highly accelerate the simulations for large-scale flow problems, including weather forecasting [4], seismology [35, 36] and multi-phase flow [5]. However, a challenge with the FNO is that its computation superiority is gained when applied on a regular grid, where the Fourier transform is approximated using FFT. Therefore, its reliance on FFT limits its use with irregular grids or complex geometries. There have been attempts to modify the FNO to work with these irregular structures, but scalability to large-scale 3D PDEs remains an issue. One such attempt is GeoFNO, which learns a coordinate transformation to map irregular inputs to a regular latent space [14]. This method, while innovative, requires a geometric discrete Fourier transform, which is computationally demanding and lacks discretization insurance. To circumvent this, GINO limits the Fourier transform to a local GNO to improve efficiency. The locality is defined assuming the metrics of the physical space.

Additionally, the Non-Equispaced Fourier neural solvers (NFS) merge the FNO with non-equispaced interpolation layers, a method similar to global GNO [37]. However, at the architecture level, their method replaces the integration of GNO with the summation of the nearest neighbor points on the graph. This step transitions this method to a neural network, failing to deliver a discretization convergent approach. The Domain-Agnostic Fourier Neural Operators (DAFNO) represents another attempt at improvement, applying an FNO to inputs where the geometry is represented as an indicator function [38]. However, this method lacks a strategy for handling irregular point clouds. Simultaneously, researchers are exploring the combination of FNO with the attention mechanisms [3] for irregular meshes. This includes the Operator Transformer (OFormer) [39], Mesh-Independent Neural Operator (MINO) [40], and the General Neural Operator Transformer (GNOT) [41]. Besides, the Clifford neural layers [42] use the Clifford algebra to compute multivectors, which provides Clifford-FNO implementations as an extension of FNO. The work [43] uses a physics-informed loss with U-Net for 3D channel flow simulation with several shapes. The work [44] innovatively proposes the use of multigrid training for neural networks that improves the convergence. Although these methods incorporate attention layers, which are special types of kernel integration [3] with quadratic complexity, they face challenges when scaling up for large-scale problems.

GNNs are incorporated in the prior attempts in physical simulations involving complex geometry, primarily due to the inherent flexibility of graph structures. Early research [7, 45-47] laid the foundation for GNNs, demonstrating that physical entities, when represented as graph nodes, and their interactions, as edges, could predict the dynamics of various systems. The introduction of graph element networks [48] marked a significant development, being the first to apply GNNs to PDEs by discretizing the domain into elements. The similar idea has been explored in term of continuous 3D point cloud convolution [49-51]. Another line of work, mesh graph networks [8-10], further explored PDEs in the context of fluid and solid mechanics. [52, 53] train a Graph convolutional neural works on the ShapeNet car dataset for inverse design. However, GNN architectures' limitations hinder their use in operator learning for PDEs. GNNs connect each node to its nearest neighbors according to the graph's metrics, not the metrics of the physical domain. As the input function's discretization becomes finer, each node's nearest neighbors eventually converge to the same node, contradicting the expectation of improved model performance with finer discretization. Furthermore, GNNs'

discretization

Coarser

discretization

…

Input geometries

Discretized geometries at various fine to coarse levels of discretizations

Finer

discretization

Target

Geometry

Finer

discretization

Target

Geometry

model behavior at the continuous function limit lacks a unique definition, failing the discretization convergence criterion. Consequently, as pointwise operators in function spaces at the continuous limit, GNNs struggle to approximate general operators between function spaces, Figure 5.

6 Conclusion

In this work, we propose the GINO model for 3D PDEs with complex geometries. The GINO model consists of the graph-kernel blocks for the encoder and decoder that go to a latent uniform space, where the Fourier blocks run on the latent space to capture the global interaction. We experiment on two CFD datasets: Shape-Net car geometries and large-scale Ahmed's body geometries, the latter encompassing over 600 car geometries featuring hundreds of thousands of mesh points. The evidence from these case studies illustrates that our method offers a substantial speed improvement, with a factor of 100,000 times acceleration in comparison to the GPU-based OpenFOAM solver. Concurrently, our approach has achieved one-fourth to one-half the error rates compared to prevailing neural networks such as 3D U-Net. This underscores the potential of our method to significantly enhance computational efficiency while maintaining a competitive level of accuracy within the realm of CFD applications. Limitation: The trained surrogate model is limited to a specific category of shapes. The quality of the model depends on the quality of the training dataset. For CFD with more complex shapes, it is not easy to obtain a large training dataset. We will explore physics-informed approaches [54] and generate time-dependent high-fidelity simulations in the future.

Acknowledgments and Disclosure of Funding

ZL is supported by the Nvidia fellowship. NBK is grateful to the NVIDIA Corporation for support through full-time employment.

References

Ashley M Korzun, Gabriel Nastac, Aaron Walden, Eric J Nielsen, William T Jones, and Patrick Moran. Application of a detached eddy simulation approach with finite-rate chemistry to mars-relevant retropropulsion operating environments. In AIAA SciTech 2022 Forum , page 2298, 2022.

Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Kaushik Bhattacharya, Andrew Stuart, and Anima Anandkumar. Neural operator: Graph kernel network for partial differential equations. arXiv preprint arXiv:2003.03485 , 2020.

Nikola Kovachki, Zongyi Li, Burigede Liu, Kamyar Azizzadenesheli, Kaushik Bhattacharya, Andrew Stuart, and Anima Anandkumar. Neural operator: Learning maps between function spaces. arXiv preprint arXiv:2108.08481 , 2021.

Jaideep Pathak, Shashank Subramanian, Peter Harrington, Sanjeev Raja, Ashesh Chattopadhyay, Morteza Mardani, Thorsten Kurth, David Hall, Zongyi Li, Kamyar Azizzadenesheli, et al. Fourcastnet: A global data-driven high-resolution weather model using adaptive fourier neural operators. arXiv preprint arXiv:2202.11214 , 2022.

Gege Wen, Zongyi Li, Qirui Long, Kamyar Azizzadenesheli, Anima Anandkumar, and Sally M Benson. Real-time high-resolution co 2 geological storage prediction using nested fourier neural operators. Energy & Environmental Science , 16(4):1732-1741, 2023.

Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Kaushik Bhattacharya, Andrew Stuart, and Anima Anandkumar. Fourier neural operator for parametric partial differential equations. arXiv preprint arXiv:2010.08895 , 2020.

Peter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, et al. Interaction networks for learning about objects, relations and physics. Advances in neural information processing systems , 29, 2016.

Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter Battaglia. Learning to simulate complex physics with graph networks. In International conference on machine learning , pages 8459-8468. PMLR, 2020.

Tobias Pfaff, Meire Fortunato, Alvaro Sanchez-Gonzalez, and Peter W Battaglia. Learning mesh-based simulation with graph networks. arXiv preprint arXiv:2010.03409 , 2020.

Kelsey R Allen, Tatiana Lopez-Guevara, Kimberly Stachenfeld, Alvaro Sanchez-Gonzalez, Peter Battaglia, Jessica Hamrick, and Tobias Pfaff. Physical design using differentiable learned simulators. arXiv preprint arXiv:2202.00728 , 2022.

Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Andrew Stuart, Kaushik Bhattacharya, and Anima Anandkumar. Multipole graph neural operator for parametric partial differential equations. Advances in Neural Information Processing Systems , 33, 2020.

Remi Lam, Alvaro Sanchez-Gonzalez, Matthew Willson, Peter Wirnsberger, Meire Fortunato, Alexander Pritzel, Suman Ravuri, Timo Ewalds, Ferran Alet, Zach Eaton-Rosen, et al. Graphcast: Learning skillful medium-range global weather forecasting. arXiv preprint arXiv:2212.12794 , 2022.

James W Cooley and John W Tukey. An algorithm for the machine calculation of complex fourier series. Mathematics of computation , 19(90):297-301, 1965.

Zongyi Li, Daniel Zhengyu Huang, Burigede Liu, and Anima Anandkumar. Fourier neural operator with learned deformations for pdes on general geometries. arXiv preprint arXiv:2207.05209 , 2022.

Hrvoje Jasak, Aleksandar Jemcov, Zeljko Tukovic, et al. Openfoam: A c++ library for complex physics simulations. In International workshop on coupled methods in numerical dynamics , volume 1000, pages 1-20, 2007.

Nobuyuki Umetani and Bernd Bickel. Learning three-dimensional flow for interactive aerodynamic design. ACM Transactions on Graphics (TOG) , 37(4):1-10, 2018.

Hassler Whitney. Analytic extensions of differentiable functions defined in closed sets. Transactions of the American Mathematical Society , 36(1):63-89, 1934.

R. Temam. Navier-Stokes Equations: Theory and Numerical Analysis . Studies in mathematics and its applications. North-Holland, 1984.

Elias M. Stein. Singular Integrals and Differentiability Properties of Functions . Princeton University Press, 1970.

Albert Cohen, Christoph Schwab, and Jakob Zech. Shape holomorphy of the stationary navierstokes equations. SIAM Journal on Mathematical Analysis , 50(2):1720-1752, 2018.

Vincent Sitzmann, Julien Martel, Alexander Bergman, David Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. Advances in Neural Information Processing Systems , 33:7462-7473, 2020.

Qian-Yi Zhou, Jaesik Park, and Vladlen Koltun. Open3D: A modern library for 3D data processing. arXiv:1801.09847 , 2018.

Matthias Fey et al. Pytorch extension library of optimized scatter operations, 2023. URL https://github.com/rusty1s/pytorch_scatter .

Jean Kossaifi, Nikola Kovachki, Kamyar Azizzadenesheli, and Anima Anandkumar. Multi-grid tensorized fourier neural operator for high-resolution pdes, 2023.

Xun Huang and Serge J. Belongie. Arbitrary style transfer in real-time with adaptive instance normalization. CoRR , abs/1703.06868, 2017.

Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Instance normalization: The missing ingredient for fast stylization. arXiv preprint arXiv:1607.08022 , 2016.

Adrian Wolny, Lorenzo Cerrone, Athul Vijayan, Rachele Tofanelli, Amaya Vilches Barro, Marion Louveaux, Christian Wenzl, Sören Strauss, David Wilson-Sánchez, Rena Lymbouridou, Susanne S Steigleder, Constantin Pape, Alberto Bailoni, Salva Duran-Nebreda, George W Bassel, Jan U Lohmann, Miltos Tsiantis, Fred A Hamprecht, Kay Schneitz, Alexis Maizel, and Anna Kreshuk. Accurate and versatile 3d segmentation of plant tissues at cellular resolution. eLife , 9:e57613, jul 2020. ISSN 2050-084X. doi: 10.7554/eLife.57613. URL https://doi. org/10.7554/eLife.57613 .

Syed R Ahmed, G Ramm, and Gunter Faltin. Some salient features of the time-averaged ground vehicle wake. SAE transactions , pages 473-503, 1984.

Florianr Menter. Zonal two equation kw turbulence models for aerodynamic flows. In 23rd fluid dynamics, plasmadynamics, and lasers conference , page 2906, 1993.

Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012 , 2015.

Olek C Zienkiewicz, Robert Leroy Taylor, and Perumal Nithiarasu. The finite element method for fluid dynamics . Butterworth-Heinemann, 2013.

Kaushik Bhattacharya, Bamdad Hosseini, Nikola B Kovachki, and Andrew M Stuart. Model reduction and neural networks for parametric pdes. The SMAI journal of computational mathematics , 7:121-157, 2021.

Georgios Kissas, Jacob H Seidman, Leonardo Ferreira Guilhoto, Victor M Preciado, George J Pappas, and Paris Perdikaris. Learning operators with coupled attention. Journal of Machine Learning Research , 23(215):1-63, 2022.

Md Ashiqur Rahman, Zachary E Ross, and Kamyar Azizzadenesheli. U-no: U-shaped neural operators. arXiv preprint arXiv:2204.11127 , 2022.

Yan Yang, Angela F Gao, Jorge C Castellanos, Zachary E Ross, Kamyar Azizzadenesheli, and Robert W Clayton. Seismic wave propagation and inversion with neural operators. The Seismic Record , 1(3):126-134, 2021.

Hongyu Sun, Yan Yang, Kamyar Azizzadenesheli, Robert W Clayton, and Zachary E Ross. Accelerating time-reversal imaging with neural operators for real-time earthquake locations. arXiv preprint arXiv:2210.06636 , 2022.

Haitao Lin, Lirong Wu, Yongjie Xu, Yufei Huang, Siyuan Li, Guojiang Zhao, Li Cari, et al. Non-equispaced fourier neural solvers for pdes. arXiv preprint arXiv:2212.04689 , 2022.

Ning Liu, Siavash Jafarzadeh, and Yue Yu. Domain agnostic fourier neural operators. arXiv preprint arXiv:2305.00478 , 2023.

Zijie Li, Kazem Meidani, and Amir Barati Farimani. Transformer for partial differential equations' operator learning. arXiv preprint arXiv:2205.13671 , 2022.

Seungjun Lee. Mesh-independent operator learning for partial differential equations. In ICML 2022 2nd AI for Science Workshop .

Zhongkai Hao, Chengyang Ying, Zhengyi Wang, Hang Su, Yinpeng Dong, Songming Liu, Ze Cheng, Jun Zhu, and Jian Song. Gnot: A general neural operator transformer for operator learning. arXiv preprint arXiv:2302.14376 , 2023.

Johannes Brandstetter, Rianne van den Berg, Max Welling, and Jayesh K Gupta. Clifford neural layers for pde modeling. arXiv preprint arXiv:2209.04934 , 2022.

Nils Wandel, Michael Weinmann, and Reinhard Klein. Teaching the incompressible navierstokes equations to fast neural surrogate models in three dimensions. Physics of Fluids , 33(4), 2021.

Aditya Balu, Sergio Botelho, Biswajit Khara, Vinay Rao, Soumik Sarkar, Chinmay Hegde, Adarsh Krishnamurthy, Santi Adavani, and Baskar Ganapathysubramanian. Distributed multigrid neural solvers on megavoxel domains. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis , pages 1-14, 2021.

Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907 , 2016.

Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. Advances in neural information processing systems , 30, 2017.

Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261 , 2018.

Ferran Alet, Adarsh Keshav Jeewajee, Maria Bauza Villalonga, Alberto Rodriguez, Tomas Lozano-Perez, and Leslie Kaelbling. Graph element networks: adaptive, structured computation and memory. In International Conference on Machine Learning , pages 212-222. PMLR, 2019.

Yangyan Li, Rui Bu, Mingchao Sun, Wei Wu, Xinhan Di, and Baoquan Chen. Pointcnn: Convolution on x-transformed points. Advances in neural information processing systems , 31, 2018.

Pedro Hermosilla, Tobias Ritschel, Pere-Pau Vázquez, Àlvar Vinacua, and Timo Ropinski. Monte carlo convolution for learning on non-uniformly sampled point clouds. ACMTransactions on Graphics (TOG) , 37(6):1-12, 2018.

Wenxuan Wu, Zhongang Qi, and Li Fuxin. Pointconv: Deep convolutional networks on 3d point clouds. In Proceedings of the IEEE/CVF Conference on computer vision and pattern recognition , pages 9621-9630, 2019.

Edoardo Remelli, Artem Lukoianov, Stephan Richter, Benoit Guillard, Timur Bagautdinov, Pierre Baque, and Pascal Fua. Meshsdf: Differentiable iso-surface extraction. Advances in Neural Information Processing Systems , 33:22468-22478, 2020.

Nikita Durasov, Artem Lukoyanov, Jonathan Donier, and Pascal Fua. Debosh: Deep bayesian shape optimization. arXiv preprint arXiv:2109.13337 , 2021.

Zongyi Li, Hongkai Zheng, Nikola Kovachki, David Jin, Haoxuan Chen, Burigede Liu, Kamyar Azizzadenesheli, and Anima Anandkumar. Physics-informed neural operator for learning partial differential equations. arXiv preprint arXiv:2111.03794 , 2021.

Matthias Fey and Jan Eric Lenssen. Fast graph representation learning with pytorch geometric. arXiv preprint arXiv:1903.02428 , 2019.

7 Appendix

7.1 Experiments and Ablations

When fixing the radius, larger latent resolutions lead to better performance. The gaps become smaller when fixing the number of edges and scaling the radius correspondingly.

Benchmarks. This study analyzes several existing models, including GNO, GeoFNO, 3D UNet, and MeshGraphNet. All models are trained using the Adam optimizer for 100 epochs, with the learning rate halved at the 50th epoch. We consider starting learning rates such as [0.002, 0.001, 0.0005, 0.00025, 0.0001], with the most favorable results attained at the rates 0.00025 and 0.0001. For GeoFNO, a 2D spherical latent space is employed due to instability with 3D deformation, leading to a faster runtime than other 3D-based models. In the 3D UNet model, we evaluate channel dimensions ranging from [64, 128, 256] and depths from [4, 5, 6]. Utilizing a larger model can reduce UNet's error rate to 11.1%.

We added an experiment comparing GINO's performance with GNN. We used the MeshGraphNet [9], which is a common GNN method for physical simulations. The MeshGraphNet has three main parts: an encoder, a decoder, and a processor. Both the encoder and decoder use the same setup, with a channel size of 256. The processor has 15 layers of information passing, using edge and node blocks. It also has a size of 256. In total, the GNN model has about 10M parameters. The total number of edges is around 280k, which saturates a single NVIDIA V100 GPU with 32GB of memory. We set the learning rate to be 1e-4 with an exponential decay with a rate of 0.99985, similar to the original setup in [9].

For the GINO model, we consider channel dimensions [32, 48, 64, 80], latent space [32, 48, 64, 80], and radius from 0.025 to 0.055 (with the domain size normalized to [-1, 1]). As depicted in Figure 4(a) and Table 4, larger latent spaces and radii yield superior results.

The choice of radius is significant. A larger radius leads to better performance for all models.

Encoder and Decoder. For the GINO model, we contemplate two configurations: an encoderdecoder design utilizing GNO layers for both input and output, and a decoder-only design which takes the fixed SDF input directly from the latent space and employs the GNO layer solely for output. When the input mesh significantly exceeds the latent grid in size, the encoder proves beneficial in information extraction. However, when the size of the latent grid matches or surpasses the input mesh, an encoder becomes redundant. As depicted in Table 5, both the encoder-decoder and decoder-only designs exhibit comparable performance.

Parallelism. Data parallelism is incorporated in the GNO decoder. In each batch, the model sub-samples 5,000 mesh points to calculate the pressure field. As query points are independent, they can be effortlessly batched. This parallel strategy allows for a larger radius in the decoder GNO. Without a parallel implementation, a radius of 0.025 leads to 300,000 edges, rapidly depleting GPU memory. Yet, with parallelism, the algorithm can handle a radius of 0.055. Implementing parallelism in the encoder is left for future exploration.

Weights in the Riemann Sum. As mentioned in the GNO section, the integral is approximated as a Riemann sum. In the decoder, the weight µ ( y ) is constant, reflecting the uniformity of the latent space. Conversely, in the encoder, weights are determined as the area of the triangle. For increased expressiveness, the weight is also integrated into the kernel, resulting in a kernel of the form κ ( x, y, µ ( y )) . However, it's worth noting that the encoder's significance diminishes when a large latent space is in use.

Sub-sampling and Super-resolution. The computational cost of the models increases rapidly with the number of mesh points. Training models with sub-sampled meshes saves significant computational resources. Discretization-convergent models can achieve such super-resolution; they can be trained on coarse mesh points and generalized to a fine evaluation mesh. We investigate the super-resolution capabilities of UNet (interp), FNO (interp), and GINO. As demonstrated in Table 6, GINO maintains consistency across all resolutions. UNet (interp) and FNO (interp) can also adapt to denser test meshes, albeit with a marginally higher error rate, based on linear interpolation. The results corroborate GINO's discretization-convergent nature.

Hash-table-based Graph Construction. For graph construction and kernel integration computation in this work, we utilize the CUDA implementation from Open3D [22] and torch-scatter [23], respectively. This approach is 40% faster compared to a previous GNO implementation that constructed the graphs with pairwise distance and used the PyTorch Geometric library[55]. These implementations are Incorporated into the GNO encoder and decoder in GINO.

In addition, the CUDA hash based implementation requires less memory footprint O ( Ndr 3 ) compare to the standard pairwise distance which requires O ( N 2 ) memory and computation complexity. For 10k points, hash-based implementation requires 6GB of GPU memory while the pairwise method requires 24GB of GPU memory; making the hash-based method more scalable for larger graphs.

7.2 Drag Coefficient Comparison

For many engineering tasks, the goal is often to determine a single quantity of interest from a simulation which can then be used within an overall design process. In the design of automobiles, a sought after quantity is the drag coefficient of the vehicle. Intuitively, it is a number inversely proportional to the efficiency with which a vehicle passes through a fluid. Engineers are therefore often interested in designing geometries with minimal drag coefficients. For a fluid with unit density, the drag coefficient is defined as

where ∂ Ω ⊂ R 3 is the surface of the car, p : R 3 → R is the pressure, ˆ n : ∂ Ω → S 2 is the outward unit normal vector of the car surface, ˆ i : R 3 → S 2 is the unit direction of the inlet flow, T w : ∂ Ω → R 3 is the wall shear stress on the surface of the car, v ∈ R is the speed of the inlet flow, and A ∈ R is the area of the smallest rectangle enclosing the front of the car.

For our Ahmed-body dataset, we train several GINO models (decoder) to predict the pressure on the surface of the car as well as the wall shear stress. Since the inlet flow is always parallel to the x -axis

i.e. ˆ i ( x ) = ( -1 , 0 , 0) , we predict only the first component of the wall shear stress. Since our results from Table 4 indicate that varying the size of the latent space has a significant effect on predictive performance, we make this the only hyper-parameter of the model and fix all others. We choose latent resolutions varying from 24 to 86 . Furthermore, we consider two different loss functions. The first is simply the average of the relative L 2 errors for pressure and wall shear stress. The second includes in this average the relative error in the drag coefficient computed using equation (8). The drag is always computed from our full-field predictions and is never given as part of the output from the model.

To compare the performance of our model against the industry-standard OpenFOAM solver, we perform a full cost-accuracy trade-off analysis. During data generation, we keep track of the drag coefficient predicted by OpenFOAM after every iteration. While the coefficient converges with more iterations, this convergence is not monotone and can often appear quite noisy. This makes computing the error from the raw data not possible. We therefore apply a box filter to the raw signal to compute a filtered version of the drag which acts as smoother. We take as the reference drag, the drag at the last iteration of the filtered signal. To compute the number of iterations it takes for the solver to predict a drag coefficient at a given relative error, we trace back the predictions from the filtered signal and return the first time at which this prediction incurs the given error with respect to the reference drag. An example of this methodology is shown in Figure 3(a). The errors for our GINO model are computed with respect to the true drag coefficient from the last iteration of the solver. This is because we take as ground truth the pressure and wall shear stress from this last iteration and train our model to predict them.

Figure 3(b) shows the cost-accuracy curve, measured in terms of inference time needed for a relative error in the drag coefficient for GINO and OpenFOAM. The cost of GINO is computed as the time, averaged over the test set, needed to predict the drag coefficient by running the model. This time includes both data pre-processing (computing the SDF) as well as the model run-time and the drag calculation given the predicted fields. All models are ran on a single NVIDIA V100 GPU. The cost for OpenFOAM is computed as described in the previous paragraph and is averaged over the test set. The solver is ran on two NVIDIA V100 GPUs in parallel. We observe a four to five order of magnitude speed-up when using GINO. At a 3% relative error, we find the speed-up from our model which includes drag in the loss to be 26 , 000 × . As we increase the size of the latent space, the cost of GINO grows, however, we observe a plateau in the drag error. This is common in machine learning models as the error from using finite data starts to dominate the approximation error. Furthermore, we use only the size of the latent space as a hyper-parameter, keeping the number of learnable parameters fixed. It is interesting to explore further how parametrically scaling the model impacts predictive power.

7.3 Data Generation

Industry-standard vehicle aerodynamics simulations are generated in this study, utilizing the Ahmedbody shapes as a foundation [28]. Examples are illustrated in Figure 6. These shapes are characterized by six design parameters: length, width, height, ground clearance, slant angle, and fillet radius, as outlined in Table 7. In addition to these design parameters, we include the inlet velocity to address a wide variation in Reynolds number. The inlet velocity varies from 10m/s to 70m/s, consequently resulting in Reynolds numbers ranging from 4 . 35 × 10 5 to 6 . 82 × 10 6 . This varying input adds complexity to the problem. We identify the design points using the Latin hypercube sampling scheme for space filling design of experiments .

The simulations employ the GPU-accelerated OpenFOAM solver for steady-state analyses, applying the SST k -ω turbulence model. Consisting of 7.2 million mesh points in total, including 100k surface mesh points, each simulation is run on 2 NVIDIA V100 GPUs and 16 CPU cores, taking between 7 to 19 hours to complete.

For this study, the focus is solely on the prediction of the pressure field. It is our hope that this dataset can be utilized in future research, potentially aiding in full-field simulation of the velocity field, as well as the inverse design.

Velocity Magnitude

Pressure

0.0e+0010

20

30

40

50

70

809.0e+01

-4.7e+03 -4000

-3000

-2000

-1000

1.4e+03

Velocity Magnitude

Pressure

0.0e+0010

60

70

809.0e+01

-4.7e+03 -4000

-3000

-2000

-1000

1.4e+03

Velocity Magnitude

Pressure

0.0e+0010

20

70

809.0e+01

4.7e+03 -4000

-3000

-2000

-1000

1.4e+03

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper presents geometry-informed neural operator (GINO), solving computational fluid dynamics (CFD)  problems. It combines graph neural operations (GNO) and Fourier neural operators (FNO) to adapt to irregular discretized grids. The authors have tested the model on two large-scale datasets.\n\nSTRENGTHS:\n1. The authors propose combining GNO and FNO to leverage the advantages of both methods, such as analyzing local and global information and efficiently processing irregular grids. They also conduct experiments demonstrating that GINO exhibits discretization invariance over the latent grid and the input-output mesh.\n\n2. The authors have generated two CFD datasets using various vehicle datasets. It would greatly benefit the learning physical simulation community if these datasets were made publicly available upon the paper's acceptance.\n\nWEAKNESSES:\n1. The definition of the $\\kappa$ operator in the graph operator block is unclear. It is not specified whether it measures the distance between two points or the similarity of their features. Additionally, it would be helpful to know if the $\\kappa$ operator has any learnable parameters. Providing more details in the paper would make it self-contained and enable readers to understand the methodology.\n\n2. The paper mentions the input of SDF features and surface points. It would be beneficial to clarify if these two types of data are fed in a uniform manner. For instance, are the point locations associated with their corresponding SDF values, while the surface points are assigned a value of 0?\n\n3. The authors claim efficient graph construction in the paper. However, it appears that once the graph operator block finishes processing the input, it results in a regular grid. It would be important to address whether the implementation takes this into consideration and ensures the efficiency of the graph construction process.\n\nQUESTIONS:\nSee weakness.\n\nLIMITATIONS:\nSee weakness.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-04"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper introduces a novel approach for applying Fourier or other Neural operators to complex geometries by prepending a “learnable projection step” via Graph Neural Operator (GNO). Unlike previous methods that morphe complex geometries into regular domains, this approach projects (learnable) sampled nodes onto nearby regular grids, providing advantages such as discretization invariance and reduced computational overhead by sub-sampling.\n\nHowever, the method is limited to simple geometries and fails to account for variations in geometry and subtle geometry features. **The paper also lacks sufficient datasets and comparisons with relevant methods, such as the GNN family.**\n\nWhile the ideas are somewhat novel, though not groundbreaking, **the paper requires further evaluation to demonstrate its strengths and limitations.**\n\n**A borderline rejection is assigned, with reconsideration if the issues are addressed during the revision period.**\n\n## After rebuttal\n- The authors improved their references, presentation, and empirical evaluation; Hence I increased my score to 5\n\nSTRENGTHS:\n- Discretization invariant\n- Improved efficiency and scalability by sub-sampling\n- Improved empirical performance\n\nWEAKNESSES:\n- Insufficient number of datasets and comparisons:\n  - More datasets should have been included, such as cylinders and airfoils from [1].\n  - Comparisons with representative methods from the GNN family, such as MeshGraphNet[1], MSGNN-Grid[2], and BSMSGNN[3], should have been discussed or ideally conducted.\n  - Among the mentioned papers [1] to [3], a crucial comparison would be with [2], which also utilizes a background grid as a helper but differs in the backbone as it did not use FNO. This would have provided a valuable benchmark for evaluation.\n\n- The overly ambitious illustrations: such as the claim in the abstract that \"...(the method) can be applied to any geometry\", which is not the case. A more objective approach in illustrating both the strengths and limitations would be appreciated by readers.\n\n- Lack of clarity in dataset presentation and results:\n  - Fig.2 suggests that the shapes are overly simplistic and the pressure distributions appear uniformly smooth, indicating ease of learning. It is essential for the author to provide a more comprehensive and clear explanation, including typical examples of datasets and variations in geometry among examples.\n\n[1] Pfaff, Tobias, Meire Fortunato, Alvaro Sanchez-Gonzalez, and Peter W. Battaglia. \"Learning Mesh-Based Simulation with Graph Networks.\" Link: https://openreview.net/forum?id=roNqYL0_XP\n\n[2] Lino, Mario, Chris Cantwell, Anil A Bharath, and Stathi Fotiadis. \"Simulating continuum mechanics with multi-scale graph neural networks.\". Link: https://arxiv.org/abs/2106.04900\n\n[3] Cao, Yadi, Menglei Chai, Minchen Li, and Chenfanfu Jiang. \"Efficient learning of mesh-based physical simulation with bi-stride multi-scale graph neural network.\". Link: https://openreview.net/forum?id=2Mbo7IEtZW\n\nQUESTIONS:\nSee the last point in **Weaknesses**\n\nLIMITATIONS:\nThe method is limited to very simple geometries due to 2 facts:\n1. Only relies on the point cloud. A counter-example is porous material where the point cloud can be the same but the tunnel is very different.\n   - In other words, although this method is discretization invariant, it is also geometry-ignorant, which is not desired.\n2. Sub-sampling, if the key flow feature is determined by some subtle geometries, which is very common, this method fails again. The limitation also is reflected in the dataset, as the pressure seems to look really smooth for all cases, and all geometries are very simple.\n\nI recommend the authors objectively illustrate these facts, even at the beginning (you do not have to emphasize them; mentioning them is enough). More experiments objectively showing the limitation (maybe in the appendix) are also appreciated.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 5, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-05"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe authors address the task of learning to solve large-scale PDEs based on a geometry-informed neural operator. The combination of graph neural operators (GNO) and Fourier neural operators (FNO) allows the exploration of the benefits of being able to handle irregular grids and locality of operations to allow efficiency (due to GNO) as well as capturing global interactions (due to FNO), thereby overcoming the limitations of the individual approaches. In more detail, the surface (e.g. point cloud) is input to a geometry encoder that encodes the irregular grid information on a regular grid structure based on local kernel integration layers through GNO with graph operations. Then the result is concatenated with signed distance features. Then, a sequence of FNO layers is used (i.e. on latent space) for global kernel integration. The respective intermediate result is projected back to the domain of the input geometry.\n\nTo show the potential of their approach, the authors carry out experiments on a novel own dataset as well as a ShapeNet car dataset, where they report quantitative results regarding training and test errors.\n\nSTRENGTHS:\nTechnical soundness and novelty:\nThe method seems novel and performs beneficial over some potential alternatives in terms of speed and accuracy, since it allows a significant speed-up in comparison to the OpenFOAM solver and offers more accuracy than GNO, GeoFNO and U-Net.\n\nEvaluation:\nThe authors provide quantitative and qualitative results including comparisons to baselines regarding training/test errors.\n\nExposition:\nThe paper is well-structured and mostly readable. Figure/tables and their captions are informative.\n\nWEAKNESSES:\nTechnical soundness and novelty\n- The discussion of limitations provided by the authors is rather short. Blending out the benefits of physics-informed approaches, that led to extreme speed-ups over OpenFOAM particularly for fluid simulation as well as offer generalization to novel scenes without being limited to object categories, limits the conclusions drawn from the presented work. The relation to these should be better emphasized to clarify what the presented method adds and whether it can be combined with these.  \n- The datasets are described in a very short manner. Especially for the new dataset, it would be relevant to see more details such as a systematic overview on the key aspects. In addition, clarifications on whether the trainings of different approaches converged within the used 100 iterations would be relevant. In Figure 2, the rightmost part is also difficult to interpret given the used color scale.\n\nEvaluation:\n- Reporting training and test errors only gives limited insights on where the errors are better/worse in comparison to previous approaches. E.g., it is not demonstrated that physical phenomena (such as the Magnus effect or Karman vortex streets) are accurately represented.\n- What are limitations/failure cases that cannot be handled that well with the presented operator?\n\nReferences:\nDiscussing other developments such as\n\nBrandstetter et al., CLIFFORD NEURAL LAYERS FOR PDE MODELING\n-> usage of multivector representations together with Clifford convolutions. The authors show the benefit of Clifford neural layers by replacing convolution and Fourier operations in common neural PDE surrogates by their Clifford counterparts on 2D Navier-Stokes tasks\n\nor physics-informed upgrades of U-Net such as e.g.\n\nWandel et al., Teaching the incompressible Navier–Stokes equations to fast neural surrogate models in three dimensions\n-> an example of physics-informed fluid simulation based on physics-informed U-Net\n\nor the splitting of the solver into region-wise optimization such as\n\nBalu et al., Distributed Multigrid Neural Solvers on Megavoxel Domain\n\nwould improve the discussion of the presented approach and its potential in the context of related work, especially since the presented approach involves quite strong assumptions (dependence on training data/shape category) and not leveraging physics-informed models therefore should be discussed.\n\nQUESTIONS:\nPlease discuss the comments mentioned under 'Weaknesses'.\n\nLIMITATIONS:\nLimitations are shortly discussed, but seem to be severely limiting (category-specific approach, lacking generalization capabilities, unclear relation to speed-ups achieved based on physics-informed approaches).", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-06"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper proposes a framework to learn a neural operator for large-scale 3D PDEs. The framework uses a well-implemented Graph Neural Operator (GNO) to transform the irregular grid into a regular grid, so that it enables the powerful Fourier Neural Operator (FNO) to work on irregular input data, such as point clouds, in a discretization invariant way. \n\nThe main contribution of the paper is to use GNO to transform large-scale irregular grids (point clouds and SDF) into regular grids, to make the FNO suitable. Based on this, GINO realized 100,000x speed-up compared to GPU-based simulators on large-scale stable CFD problems. The model is proven to be working on datasets with a high level of complexity and realism. The paper also generates two large-scale CDF datasets, which require a large amount of time to simulate and generate, which is valuable.\n\nSTRENGTHS:\n1. Clear written about the problem setting and equations and symbols. \n\n2. The main idea is useful but not too complicated to understand. An efficient combination of existing methods. \n\n3. The method has a general potential for various kinds of PDEs. \n\n4. The method has shown great performance in engineering-level experiments, fulfilling its great potential for applications.\n\nWEAKNESSES:\nAlthough the experiments have demonstrated the main ability of the model, the experiments are not complete enough to support all claims and novelties. \n\n1. Since the model is a new combination of two existing methods GNO and FNO, the main contribution is the new usage of GNO. Then the main thing required to be demonstrated should be “GNO is more proper and has great encoding and decoding ability between irregular and regular grids”. Regarding this, some different encoding methods should be compared, such as GNN, kNN.\n\n2. Discretization invariance is said to be important, but no direct experiments could support this. Although Table 5 is relevant to this, but the variables are not kept so it’s not a direct support. In other words, a GNN+FNO baseline should be added.\n\nQUESTIONS:\n1. What is the difference between your proposed GNO and Continuous Convolution (CtsConv) from “Lagrangian Fluid Simulation with Continuous Convolutions”? It seems there is no obvious difference based on equations. And one of the claimed contributions is a well-implemented GNO, which makes it much more efficient, but CtsConv is also well-implemented based on Open3D and hashing table. \n\n2. What is the performance for much finer latent resolutions such as 128^3 and 256^3? Can we keep increasing the test error by increasing the latent resolution?\n\nLIMITATIONS:\n1. As the paper stated, the trained model is limited to a specific observed category of shapes. The training for the operator requires a training dataset of high quality. \n\n2. The proposed framework should be general for various kinds of PDEs, but only stable NS equations are tested. \n\n3. The framework is for 3D PDEs, which could be modified for time-dependent ones.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-06"}

comments: SUMMARY:
This paper proposes a geometry-informed neural operator for arbitrary geometry, to facilitate the learning on the solution operator for large-scale 3D CFD simulation.

STRENGTHS:
The proposed GINO model applies graph-kernel blocks for the encoder and decoder, for processing features in the latent uniform space, with the Fourier blocks running on the latent space to capture the global interaction. The proposed method provides significant runtime speedup.

WEAKNESSES:
For the experiment, the authors only perform the evaluation on the car category of ShapeNet dataset. It’ll be more persuasive to have the proposed model evaluate the other categories rather than only a single category.

QUESTIONS:
As the authors claim the significant speedup provided by the proposed method. Could the authors report the scale of the parameters of the proposed method, and the comparison to the other related methods?

LIMITATIONS:
As pointed out by the authors, this work is constrained to a specific category and limited to CFD with more complex shapes. It'll be with practical significance if the proposed work could tackle these limitations.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2023-07-08