betaFeedback

WorksComputer Science

Learnable-Differentiable Finite Volume Solver for Accelerated Simulation of Flows

Abstract

Simulation of fluid flows is crucial for modeling physical phenomena like meteorology, aerodynamics, and biomedicine. Classical numerical solvers often require fine spatiotemporal grids to satisfy stability, consistency, and convergence conditions, leading to substantial computational costs. Although machine learning has demonstrated better efficiency, they typically suffer from issues of interpretability, generalizability, and data dependency. Hence, we propose a learnable and differentiable finite volume solver, called LDSolver, designed for efficient and accurate simulation of fluid flows on spatiotemporal coarse grids. LDSolver comprises two key components: (1) a differentiable finite volume solver, and (2) an learnable module providing equivalent approximation for fluxes (derivatives and interpolations), and temporal error correction on coarse grids. Even with limited training data (e.g., only a few trajectories), our model could accelerate the simulation while maintaining a high accuracy with superior generalizability. Experiments on different flow systems (e.g., Burgers, decaying, forced and shear flows) show that LDSolver achieves state-of-the-art performance, surpassing baseline models with notable margins.

Corresponding author.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].

KDD ’25, Toronto, ON, Canada

© 2025 Copyright held by the owner/author(s). Publication rights licensed to ACM.

ACM ISBN 979-8-4007-1454-2/2025/08

https://doi.org/10.1145/3711896.3737018

CCS Concepts

• Applied computing → Physics; • Computing methodologies → Modeling and simulation; Artificial intelligence.

Keywords

Accelerated Simulation of Fluid Flows, Differentiable Solver, Finite Volume Methods

ACM Reference Format:

Mengtao Yan, Qi Wang, Haining Wang, Ruizhi Chengze, Yi Zhang, Hongsheng Liu, Zidong Wang, Fan Yu, Qi Qi, and Hao Sun. 2025. Learnable-Differentiable Finite Volume Solver for Accelerated Simulation of Flows. In Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining V.2 (KDD ’25), August 3–7, 2025, Toronto, ON, Canada. ACM, New York, NY, USA, 19 pages. https://doi.org/10.1145/3711896.3737018

Introduction

Fluid flow simulation is crucial for various applications, including weather and climate forecasting [45] [4], aerospace engineering [47], automotive design [21], and biomedicine [3]. These flows are generally governed by nonlinear partial differential equations (PDEs), particularly the Navier-Stokes equations (NSE). However, the accuracy of traditional solvers heavily depends on spatiotemporal resolution [34, 61] [1, 20]. While fine grids are essential for ensuring convergence and solution validity, they result in extremely high computational costs. For instance, accurately simulating the flow field around an aircraft wing often requires tens to hundreds of millions of grid cells [46]. Such simulations typically take several days to a week to complete on high-performance computing clusters, utilizing hundreds of CPUs or multiple GPUs for parallel processing. Furthermore, any changes in initial or boundary conditions (IC/BCs) or design parameters require a full re-simulation. Additionally, a1: Corresponding author. significant limitation of existing solvers, such as OpenFOAM [19] and Fluent [33], is their inherent non-differentiability, which makes integration with neural networks challenging.

Recent advances in machine learning (ML) have demonstrated significant potential for accelerating the simulation of complex flows [6]. Existing ML-driven approaches can be broadly categorized into three groups. First, data-driven methods train models using supervised learning on pre-existing datasets. By bypassing the time-resolution limitations of traditional solvers, these methods often ignore underlying partial differential equation (PDE) constraints. As a result, they frequently suffer from poor interpretability, limited generalizability, and a strong reliance on large, labeled datasets [31] [26]. To address these issues, integrating physical information into the training process has been explored. Second, physics-informed neural networks (PINNs) incorporate PDEs and IC/BCs as regularization terms in the loss function, imposing soft constraints. However, PINNs face challenges related to training convergence, solution accuracy, and robust generalization [37, 38, 41, 50, 54, 59] [8]. Third, another category explicitly embeds physical information directly into the network architecture as hard constraints. For example, physics-encoded recurrent convolutional neural networks (PeRCNN) use neural networks within a finite difference (FD) framework to refine derivative approximations, improving generalization without extensive hyperparameter tuning. However, PeRCNN can still exhibit instability in long-term predictions [41]. Learning interpolation (LI) models [22] and TSM [48], operating within a finite volume framework, employ neural networks to learn the most resolution-sensitive components of traditional solvers. This enables faster simulations on coarser grids while maintaining accuracy. Nevertheless, due to the non-trainable nature of other numerical components, these models still require substantial labeled data for accurate predictions.

To address these challenges, we introduce LDSolver, a method designed for stable and high-fidelity long-term predictions, even with limited training data. Our approach begins by developing a differentiable numerical solver capable of generating high-fidelity solutions on fine grids. Training datasets are then created by downsampling these high-resolution solutions to the desired coarse grid resolutions. To correct accumulated errors on coarse grids, we employ neural networks to optimize derivatives and interpolations estimation mechanisms while strictly preserving the equation form. A temporal correction block further refines predictions over time, inspired by recent works [36] [5]. Motivated by advances in differentiable physics [52] [16], LDSolver is constructed on a fully differentiable solver backbone. As shown in Figure 1, our main contributions are summarized as follows:

Figure 1. Overview of LDSolver. It comprises a differentiable traditional solver integrated with finite volume methods and a learnable solver incorporating flux approximation (Appr.) and temporal correction (Corr.) blocks. Red arrows indicate simulations by the traditional solver on fine spatiotemporal (FST) grids, while blue arrows represent accelerated simulations by the learnable solver on coarse spatiotemporal (CST) grids. Green arrows highlight erroneous solutions produced by the traditional solver on CST grids.

  • We propose a novel learnable and differentiable finite volume solver (LDSolver) for accelerated flow simulations. This hybrid approach integrates traditional numerical solvers with machine learning, enabling high-fidelity simulations on fine grids and efficient learning and prediction on coarse grids, achieving strong generalization with limited data.

  • We introduce a flux block and a temporal correction block to estimate derivatives and interpolations on coarse grids, effectively reducing accumulated errors during long-time iterations on coarse grids.

  • LDSolver demonstrates significant improvements across various complex flows, including Burgers, decaying, forced, and shear flows. Compared to baseline models, it achieves at least a 50% reduction in mean absolute error (MAE) while maintaining high computational efficiency.

Related Work

Numerical Solvers: Traditionally, fluid dynamic systems are typically solved using numerical techniques, such as finite difference methods (FDM) [1], finite volume methods (FVM) [34], finite element methods (FEM) [61], and spectral methods [20]. Among these, FVM is a widely adopted numerical approach in computational fluid dynamics (CFD). By discretizing the integral form of the governing equations within control volumes, it ensures local conservation, robust stability, and the capability to handle complex geometries and boundary conditions. These methods generally require fine spatio-temporal discretizations to meet stability, consistency, and convergence criteria. However, the computational cost remains prohibitively high for large-scale simulations or inverse analyses.

Pure Data Driven Methods: Recently, deep learning has been increasingly applied to solving partial differential equations (PDEs). Common approaches include methods based on convolutional neural networks (CNNs) [57] [2], U-Nets [14], ResNets [32], graph neural networks (GNNs) [35, 44], and Transformer-based models [56] [18, 27]. Additionally, neural operator methods, such as DeepONet [31], multiwavelet-based models (MWTs) [13], Fourier Neural Operators (FNO) [24], and their variants [51] [12, 25], directly learn mappings between functions, making them particularly suitable for building surrogate models of PDE systems. These methods are typically purely data-driven, relying on extensive data, and they often suffer from limited interpretability and generalizability.

Physics-aware Learning Methods: Physics-aware learning methods have demonstrated significant potential in modeling spatiotemporal dynamics with limited data. These methods can be broadly categorized into two groups based on how they incorporate physics: (1) Physics-informed methods utilize partial differential equations (PDEs) and initial/boundary conditions (I/BCs) as soft constraints, often integrated into the loss function for regularization. Examples include PINNs [37, 38, 50, 54], PhyGeoNet [10], PhyCRNet [43], and PhySR [42]. (2) Physics-encoded methods treat PDE structures (such as equations, I/BCs) as hard constraints, directly embedding them into the neural network architecture. Examples include PeRCNN [39, 40], FluxGNN [17], TiGNN [15], EquNN [55], and PDE-Net models [29, 30], which design convolutional kernels to approximate differential operators and simulate system dynamics.

Hybrid Physics-ML Methods: Hybrid Physics-ML methods leverage neural networks to correct errors from classical numerical simulators, typically applied to low-resolution models. These methods can be integrated with various traditional numerical techniques, such as finite difference methods (e.g., PPNN [28], P2^{2}C2^{2}Net [53], learned numerical discretizations [60]), finite volume methods (e.g., LI [22], TSM [49]), and spectral methods (e.g., machine learning-enhanced spectral solvers [9]). By operating on coarse grids, they achieve significant simulation speedups while maintaining reasonable accuracy. However, due to the non-trainable nature of most numerical components, these models often require substantial labeled data to ensure accurate predictions.

Methodology

Problem Statement

Generally, the dynamics of fluid systems are governed by conservation-form partial differential equations (PDEs) of the following type:

∂u∂t+∇⋅F(u,μ)=S(u),(1)\frac{\partial\mathbf{u}}{\partial t} + \nabla\cdot\mathbf{F}(\mathbf{u},\mu) = \mathbf{S}(\mathbf{u}), \tag*{(1)}

where u\mathbf{u} denotes the flow field, F\mathbf{F} denotes the flux function, S\mathbf{S} represents source terms, and μ\mu is the PDE parameters (e.g., Reynolds number or diffusion coefficient). This formulation provides a unified framework for the governing equations of diverse flow systems, including Burgers, decaying, forced, and shear flows. For instance, the Burgers’ equation, with S=0\mathbf{S}=0, F=u2/2−ν∇u\mathbf{F}=\mathbf{u}^{2}/2-\nu\nabla\mathbf{u}, can be expressed within this framework.

Our goal is to develop a learnable solver trained on limited data to accelerate simulations of various flow systems on coarse grids. The proposed solver aims to retain the versatility of traditional solvers in simulating diverse flows while addressing their reliance on fine grids. By optimizing flux approximations and temporal corrections, the solver achieves significant computational efficiency and ensures generalizability across flow systems, including variations in initial conditions (ICs) and PDE parameters (μ\mu).

Main architecture of LDSover

The architecture of LDSolver is depicted in Figure 2. Additionally, commonly used symbols are provided in Appendix Table 3. Taking the NSE as an example, the solver comprises two main modules:

Architecture of the learnable differentiable solver

Figure 2. Architecture of the learnable differentiable solver (LDSolver), illustrated using forced flow as an example. LDSolver consists of a finite volume (FV) module with a flux block and a temporal correction block. (a) Overall architecture; (b) Finite volume module (FV module); (c) Flux block.

(1) an upper pathway for the temporal correction block, and (2) a lower pathway for the finite volume (FV) module. The solver is designed to be flexibly adaptable for handling various equations.

The upper path (Temporal Correction Block) illustrates the process of updating the flow field from the initial field u0\mathbf{u}_0 to the kck_c-th field ukc\mathbf{u}_{k_c}, where kck_c is the temporal correction interval. The updates for the first kc−1k_c-1 steps are performed through time integration in the FV module, with the updated field u\mathbf{u} stored in the temporal buffer after each step. At the kck_c-th step, the velocities u[0:kc−1]\mathbf{u}_{[0:k_c-1]} from the previous kc−1k_c-1 steps are fed into the temporal correction block to compute the accumulated temporal error. The update of ukc\mathbf{u}_{k_c} is then obtained by combining the output of the FV module with this error compensation. This process repeats until the final time step NN is reached, effectively correcting the temporal error every kck_c steps.

The lower pathway (FV module) updates the solution across adjacent time steps using finite volume spatial discretization and a fourth-order Runge-Kutta (RK4) time integrator. Starting from the initial field u0\mathbf{u}_0, the flux block computes ∇u0\nabla\mathbf{u}_0, representing the derivative values at the interfaces, and uˉ0\bar{\mathbf{u}}_0, the average value. An intermediate velocity field u0∗\mathbf{u}_0^{*} is then obtained by incorporating the external force term f\mathbf{f}. Next, the divergence ∇⋅u0∗\nabla\cdot\mathbf{u}_0^{*} is computed by the flux block, and a Poisson solver determines the intermediate pressure field p0∗\mathbf{p}_0^{*}. Finally, a projection step updates the velocity to u1∗\mathbf{u}_1^{*}, completing one RK4 sub-step. This process is repeated for the subsequent 4 time steps to obtain the next field u1\mathbf{u}_1.

In summary, given the initial field u0\mathbf{u}_0, the computation of uk\mathbf{u}_k for k∈[1,N]k\in[1,N] can be defined as follows:

uk={FV(uk−1)+TC(u0,…,uk−1),if k=Mkc,FV(uk−1),otherwise,(2)\mathbf{u}_k = \begin{cases} \mathcal{F}\mathcal{V}(\mathbf{u}_{k-1})+\mathcal{T}\mathcal{C}(\mathbf{u}_0,\ldots,\mathbf{u}_{k-1}), & \text{if } k=Mk_c,\\ \mathcal{F}\mathcal{V}(\mathbf{u}_{k-1}), & \text{otherwise,} \end{cases} \tag*{(2)}

where FV(uk−1)\mathcal{F}\mathcal{V}(\mathbf{u}_{k-1}) represents the update by the Finite Volume (FV) module, TC(uk−1)\mathcal{T}\mathcal{C}(\mathbf{u}_{k-1}) denotes the temporal correction (TC) block, and MM is a positive integer. The whole solution u[0,N]\mathbf{u}_{[0,N]} is obtained by combining the outputs of both modules at every kck_c step. For other time steps, the solution is updated exclusively by the FV module.

Learnable Finite Volume Solver

As previously mentioned in Section 2, FVM offers inherent advantages in computational fluid dynamics [34]. Therefore, we adopt it as the foundational framework. For a control volume Vij→R2V_{ij}\to\mathbb{R}^{2} at the i,ji,j-th grid coordinate, integrating Eq. (1) and applying the divergence theorem yields (for simplicity, i,ji,j is omitted below):

∂∂t∫Vu dV=∮∂VF(u)⋅n dA+∫VS dV,(3)\frac{\partial}{\partial t}\int_{V}\mathbf{u}\,\mathrm{d}V=\oint_{\partial V}\mathbf{F}(\mathbf{u})\cdot\mathbf{n}\,\mathrm{d}A+\int_{V}\mathbf{S}\,\mathrm{d}V, \tag*{(3)}

where ∂V\partial V and n:∂V→R2\mathbf{n}:\partial V\to\mathbb{R}^{2} represent the boundary of the cell VV and the unit normal vector field pointing outward, respectively. Taking the governing equation of flow, i.e. the NSE (Appendix Eq. S26), as an example, Eq. (3) can be discretized using linear interpolation as:

∂∂t(∇V)=−∑f∈∂VAf(Fd+Fa+Fp)⋅nf+SV,(4)\frac{\partial}{\partial t}(\nabla V)=-\sum_{f\in\partial V}A_f(\mathbf{F}_d+\mathbf{F}_a+\mathbf{F}_p)\cdot\mathbf{n}_f+S V, \tag*{(4)}

where AfA_f denotes the surface area of the control volume VV, Fd\mathbf{F}_d is the dissipation flux, Fa\mathbf{F}_a represents the advection flux, and Fp\mathbf{F}_p corresponds to the pressure flux.

On coarse spatial grids, numerical flux computations suffer from reduced accuracy. As detailed in Appendix Section B, accurate discretization of dissipation fluxes (FdF_d) requires precise estimation of interfacial derivatives, while advection fluxes (FaF_a) depend on accurate interpolation of interfacial velocities. Pressure flux (FpF_p) computation, typically involving the solution of a Poisson equation, also necessitates accurate evaluation of the velocity field divergence (a derivative operation). On coarse temporal grids, large time intervals can also lead to significant error accumulation. To mitigate these errors, we introduce a flux block and a temporal correction block within a finite volume framework.

Flux Block

The flux block is designed to compute derivatives and interpolations, combining three complementary components through an integrated operator (Figure 2c):

O(m)(u)=OP(m)⏟Physics+OL(m)⏟Learnable+OF(m)⏟Frequency,(5)O^{(m)}(\mathbf{u}) = \underbrace{O_P^{(m)}}_{\text{Physics}} + \underbrace{O_L^{(m)}}_{\text{Learnable}} + \underbrace{O_F^{(m)}}_{\text{Frequency}}, \tag*{(5)}

where m∈{d,i}m \in\{d,i\} distinguishes derivative (dd) and interpolation (ii) operations. Each component maintains dimension-specific parameters without weight sharing.

Physics-based Conv. The physics-based convolution is designed to rigorously preserve physical consistency through non-trainable 2D convolutions rooted in numerical analysis foundations:

OP(m)(u)=WP(m)∗u,WP(m)∈R5×4,(6)O_P^{(m)}(\mathbf{u}) = W_P^{(m)} * \mathbf{u}, \quad W_P^{(m)} \in\mathbb{R}^{5 \times4}, \tag*{(6)}

where OP(m)O_P^{(m)} denotes the physics-based operator, WP(m)W_P^{(m)} represents the unlearnable convolution kernel and u\mathbf{u} indicates the input flow field. The 5×45 \times4 kernels implement finite difference operators [30] - central differencing for derivatives (m=dm=d) and linear interpolation for flux reconstruction (m=im=i), ensuring strict adherence to numerical conservation laws. This physics-based design guarantees solution boundedness and discrete conservation (complete kernel configurations in Appendix Eq. S6).

Learnable Conv. The learnable convolution enhances local discretization accuracy through parameterized convolutions to address coarse-resolution limitations:

OL(m)(u)=WL(m)∗u,WL(m)∈R5×4,(7)O_L^{(m)}(\mathbf{u}) = W_L^{(m)} * \mathbf{u}, \quad W_L^{(m)} \in\mathbb{R}^{5 \times4}, \tag*{(7)}

where OL(m)O_L^{(m)} represents the learnable operator, WL(m)W_L^{(m)} denotes the trainable convolution kernel, and u\mathbf{u} indicates the input flow field. The 5×45 \times4 kernels, initialized with minor random values, are optimized during training to adjust stencil weights. This adaptive mechanism preserves structured connectivity of finite volume discretizations while compensating for truncation errors.

Frequency Domain Operator. The frequency domain operator captures global features of the flow field. We employ a Fourier neural operator (FNO) [24] to implement this component:

OF(m)(u)=Q(F−1(RL⋅F(u))),(8)O_F^{(m)}(\mathbf{u}) = Q\left(\mathcal{F}^{-1}\left(R_L \cdot\mathcal{F}(\mathbf{u})\right)\right), \tag*{(8)}

where OF(m)O_F^{(m)} denotes the frequency domain operator, F\mathcal{F} and F−1\mathcal{F}^{-1} represent the forward and inverse Fourier transforms, respectively, RLR_L denotes the frequency-space correction layers, and QQ is a learnable projection mapping spectral features back to physical space. The architecture first decomposes the whole field into spectral components via F\mathcal{F}, applies LL-layer frequency-space corrections, and then reconstructs the enhanced features through F−1\mathcal{F}^{-1}. The projection $Q ensures dimensional consistency, effectively addressing multiscale resolution challenges (implementation details in Appendix D.2). Network hyperparameters are documented in Appendix Table S3.

Temporal Correction Block

Given a solution uk\mathbf{u}_k at time step kk, the model predicts the solution uk+1\mathbf{u}_{k+1} at the next time step through:

uk+1=uk+∫tktk+1H(uk,τ) dτ,(9)\mathbf{u}_{k+1} = \mathbf{u}_k + \int_{t_k}^{t_{k+1}} H(\mathbf{u}_k,\tau)\,d\tau, \tag*{(9)}

where H(uk,τ)H(\mathbf{u}_k,\tau) represents the FV Module, a learnable operator approximating the residual of the governing equation. Temporal integration is performed using the fourth-order Runge-Kutta (RK4) method, achieving O(Δt4)O(\Delta t^4) accuracy with Δt=tk+1−tk\Delta t=t_{k+1}-t_k (implementation details are provided in Appendix B.5). Large Δt\Delta t values on coarse grids exacerbate temporal error accumulation, motivating our analysis and the development of the temporal correction block. The temporal error is defined as:

ek=uk−uk∗,(10)e_k = \mathbf{u}_k - \mathbf{u}_k^*, \tag*{(10)}

where uk\mathbf{u}_k denotes the coarse-grid solution and uk∗\mathbf{u}_k^* the exact solution. Appendix B.6 derives the propagation relation:

ek=g(k−1)(u0,…,uk−1,Δt,e0),(11)e_k = g^{(k-1)}(\mathbf{u}_0,\ldots,\mathbf{u}_{k-1},\Delta t,e_0), \tag*{(11)}

with g(k−1)g^{(k-1)} representing the error propagation function after k−1k-1 iterations. This formulation establishes eke_k’s dependence on prior numerical solutions u0,…,uk−1\mathbf{u}_0,\ldots,\mathbf{u}_{k-1} and their cumulative errors. Our neural correction mechanism processes these solutions through a FNO model, chosen for its ability to efficiently capture global features and handle multiscale resolution challenges:

ek=Q(F−1(RL⋅F(u0,…,uk−1))).(12)e_k = Q\left(\mathcal{F}^{-1}\left(R_L \cdot\mathcal{F}(\mathbf{u}_0,\ldots,\mathbf{u}_{k-1})\right)\right). \tag*{(12)}

Considering the complexity of subsequent experiments, this module is exclusively implemented in the forced flow. The hyperparameters are provided in Appendix Table S3.

Poisson Solver and Projection process

In solving the NSE for incompressible flows, the pressure field is derived by solving a Poisson equation via a projection method (see Appendix Section B.3). The Poisson equation is given by Δp=∇⋅uk∗\Delta p = \nabla\cdot\mathbf{u}_k^*, where uk∗\mathbf{u}_k^* is the intermediate velocity field. To estimate the pressure field, we employ a spectral method, with details provided in Appendix Section B.3. Based on ∇⋅uk∗\nabla\cdot\mathbf{u}_k^*, we update the pressure pkp^k (see Figure 2(b)). Then, we obtain the next step of divergence-free uk+1\mathbf{u}_{k+1} based on the projection step, uk+1=uk∗−Δt⋅∇p\mathbf{u}_{k+1}=\mathbf{u}_k^*-\Delta t\cdot\nabla p.

Experiments

We evaluated the performance of LDSolver on several benchmark flow problems, including Burgers, decaying, forced, and shear flow. The results show that our model achieves higher accuracy and better generalizability, thanks to its unique design that fully integrates with a traditional solver. We have released the source code and data at https://github.com/intell-sci-comput/LDsolver.git.

Experimental Setup

Simulation Datasets. We consider four types of two-dimensional flows: Burgers’ equation, decaying flow, forced flow, and shear flow. These distinct flow types present diverse challenges for LDSolver. By activating only the physics-based convolution, our model reduces to a traditional numerical solver. Simulations on fine spatio-temporal grids yield high-fidelity flows, denoted as u~∈RT~×ny×nx\tilde{\mathbf{u}}\in\mathbb{R}^{\tilde{T}\times n_y\times n_x}. Coarse-grid flows, represented as u∈RT×ny×nx\mathbf{u}\in\mathbb{R}^{T\times n_y\times n_x}, are obtained by downsampling the fine-grid fields in space and time. These coarse-grid flows serve as training labels. For each flow type, we generate 5–10 trajectories for training and evaluate performance on 10 trajectories. Dataset parameters are detailed in Table 1, with additional specifications in Appendix Table S2.

DatasetSpatial GridTime Steps# Training Traj.# Testing Traj.Sample LengthSimulation Duration (s)
Burgers’ Equation1002→252100^2 \to25^21800→4501800 \to450510204.5
Decaying Flow20482→6422048^2 \to64^276800→240076800 \to240010103216.8
Forced Flow20482→6422048^2 \to64^238400→120038400 \to12001010328.4
Shear Flow2048×1024→128×642048 \times1024 \to128 \times6444800→140044800 \to14005102014.0

Table 1. Summary of datasets and training configurations. The arrow (→\to) indicates downsampling from fine (simulation) to coarse (training) grids.

Model Training. We partition the data along the temporal dimension to make samples. Each sample has a length of ksk_s, resulting in nsample=N/ksn_{\mathrm{sample}}=N/k_s samples. The model roll out in an autoregressive manner to get predictions. The loss is computed at the predicted flow field u\mathbf{u} with the corresponding labels u~\tilde{\mathbf{u}}. The loss function is:

L(θ)=1MB∑i=1M∑j=1BMSE⁡(uij,u~ij),(13)\mathcal{L}(\theta)=\frac{1}{MB}\sum_{i=1}^{M}\sum_{j=1}^{B}\operatorname{MSE}(\mathbf{u}_{ij},\tilde{\mathbf{u}}_{ij}), \tag*{(13)}

where uij\mathbf{u}_{ij} represents the predicted flows of the jj-th sample in the ii-th batch, u~ij\tilde{\mathbf{u}}_{ij} is the corresponding label, MM denotes the number of batches, BB is the batch size, and θ\theta represents the trainable parameters. Detailed network parameters and training configurations are provided in Appendix Section D.4.

Evaluation Metrics. The model’s performance is evaluated using four key metrics: Root Mean Squared Error (RMSE) and Mean Absolute Error (MAE) quantify the average magnitude of errors; Mean Normalized Absolute Difference (MNAD) assesses the relative error; and High Correlation Time (HCT) measures the time required for the model to achieve high-fidelity accuracy. Formal definitions of these metrics can be found in Appendix Section D.1.

Baseline Models. To demonstrate the superiority of the proposed LDSolver, we conduct comparisons with several benchmark models, including FNO [?], PeRCNN [40], DeepONet [32], TSM [48] and P2^2C2^2Net [53]. Detailed descriptions and training configurations of these benchmark models are provided in Appendix Section D.2. Note that we ignored to select Learned Interpolation (LI) [?] as the baseline because it has the instability issue that leads to NaN values in prediction, particularly when the training data is limited and sparse [53]. We compared LDSolver with these baseline models across various metrics in Appendix D.3, demonstrating that LDSolver exhibits highly general capabilities.

Main Results

Figure 3 and Figure 4 show the results comparison between LDSolver and baseline models, including error distributions, correlation coefficient time series, and snapshots at the final time step. The quantitative performance results are shown in Table 2.

Comparison between LDSolver and baseline models, showing error distributions, correlation coefficient time series, and predicted solutions at final time steps

Figure 3. Comparison between LDSolver and baseline models, showing error distributions (left), correlation coefficient time series (middle), and predicted solutions at final time steps (right). (a) Burgers’ Equation (25×2525 \times25); (b) Decaying Flow (64×6464 \times64); (c) Forced Flow (64×6464 \times64). Snapshots on the right represent the final simulation states at 4.5 s, 16.8 s, and 8.4 s, respectively.

Comparison of predicted solutions of shear flow

Figure 4. Comparison between LDSolver and baseline models for predicted solutions of shear flow. The models are trained on a grid size of 64×12864 \times128. (a) The first column shows the initial conditions (ICs), with the remaining columns displaying snapshots at the final simulation state t=14t = 14 s for different models. The sampling point is marked by a star (⋆\star) at coordinates (48, 64). (b) Correlation time series of different baseline models. (c) Error distribution. (d) Time series of the variable ss in shear flow at the star (⋆\star) sampling point for the ground truth, LDSolver, and P²C²Net.

CaseModelRMSEMAEMNADHCT (s)
Burgers’ EquationDeepONet4228.29107.86443.10.1000
Burgers’ EquationFNO0.23700.19510.16270.2000
Burgers’ EquationPeRCNN0.07570.05430.04224.5000
Burgers’ EquationP2C2NetP^{2}C^{2}\mathrm{Net}0.13570.09070.07813.0000
Burgers’ EquationLDSolver0.02200.01450.01114.5000
Burgers’ EquationProm. (↑)70.91%73.26%73.70%0%
Decaying FlowFNO1.16690.90550.12822.5749
Decaying FlowTSM1.64781.29010.18510.2103
Decaying FlowPeRCNNNANNANNAN3.4704
Decaying FlowP2C2NetP^{2}C^{2}\mathrm{Net}0.21840.09310.013012.6200
Decaying FlowLDSolver0.07320.04070.005616.8262
Decaying FlowProm. (↑)66.48%56.28%56.92%33.33%
Forced FlowFNO1.16840.91800.11660.4908
Forced FlowTSM1.12350.87290.11060.5609
Forced FlowPeRCNNNANNANNAN2.6291
Forced FlowP2C2NetP^{2}C^{2}\mathrm{Net}0.42980.26900.03225.2582
Forced FlowLDSolver0.23770.12530.01598.4131
Forced FlowProm. (↑)44.70%53.42%50.62%60.00%
Shear FlowFNO0.18470.09960.09978.6000
Shear FlowTSM0.43370.34240.34271.5000
Shear FlowPeRCNN0.24700.19850.19877.0000
Shear FlowP2C2NetP^{2}C^{2}\mathrm{Net}0.18340.09810.09828.7000
Shear FlowLDSolver0.02310.01290.012914.0000
Shear FlowProm. (↑)87.40%86.85%86.86%60.92%

Table 2. Benchmark comparisons of LDSolver against baseline methods. Performance promotion (PROM) indicates the relative metric change ratio between LDSolver and the top-performing baseline.

Burgers’ Equation. The Burgers’ equation involves advection-diffusion processes. LDSolver, PeRCNN, and FNO successfully capture the dynamics, while P2C2Net suffers from poor physical stability due to lack of local conservation. However, our method demonstrates a significant advantage in error levels, as evidenced by the error distributions in Figure 3(a) (left). Table 2 further supports this observation, showing substantial performance gains of our model over the baselines, with improvements exceeding 70% in spatial metrics during long-term predictions.

Decaying Flow. We evaluated LDSolver on a decaying flow at a Reynolds number of Re=1000Re = 1000 with no external force. As shown in Figure 3(b) (right), all baseline models except TSM struggled to accurately predict the trajectory. In contrast, LDSolver demonstrated superior stability and effectively learned the underlying dynamics. This is further supported by the error analysis in Figure 3(b) (left),

where LDSolver achieved the lowest error compared to the baselines. Table 2 provides a comprehensive summary of performance metrics, showing improvements exceeding 55% error reduction for LDSolver across all evaluations in the decaying flow scenario.

Forced Flow. We further evaluated LDSolver on a forced flow with external forcing at Re=1000Re = 1000, a benchmark dataset known for its significant challenges [49] [22]. As shown in Figure 3(c), snapshots generated by baseline models at t=8.4t = 8.4 seconds exhibited incorrect dynamic patterns. Our model achieved the lowest average test error compared to the baselines. Additionally, LDSolver consistently outperformed the baselines in terms of correlation coefficient evolution. Table 2 further confirms the superior performance of our model, demonstrating improvements of at least 44% across all metrics. We also analyzed the learned physical properties of the fluid dynamics, such as the energy spectrum. As illustrated in Figure 5, the energy spectrum of LDSolver shows excellent agreement with the ground truth, highlighting its capability to capture high-frequency features. Furthermore, we validated the results of forced flow by comparing snapshots and correlations between DNS at different resolutions and LDSolver. As shown in Appendix Figure S2 and Appendix Figure S3, LDSolver’s accuracy surpasses that of the 512×512512 \times512-resolution DNS and approaches that of the 1024×10241024 \times1024-resolution DNS. This enables significant simulation acceleration.

Figure 5. Energy spectra of different baseline models for the forced flow.

Shear Flow. We further evaluated LDSolver on the NSE with mixture transport [7]. This flow requires solving a coupled advection-diffusion equation alongside the NSE, which increases the learning complexity of the model. As illustrated in the predicted snapshots in Figure 4(a), few baseline models captured the global patterns but exhibited limitations in resolving local details. In contrast, LDSolver demonstrated a significant advantage in learning scalar transport dynamics. Moreover, the error analysis in Figure 4(c) revealed that LDSolver achieved errors nearly 1 to 2 orders of magnitude lower than the baselines. Table 2 highlights performance improvements ranging from 60% to 87% compared to the best-performing baseline.

Additionally, the time series at the sampling point in Figure 4(d) also shows that LDSolver closely aligns with the ground truth.

Generation Tests

Using the forced flow and shear flow case, we evaluated the generalization capability of LDSolver across different PDE parameters.

The model was trained at Re=1000Re = 1000 and tested at four Reynolds numbers: Re={200,500,1500,2000}Re = \{200, 500, 1500, 2000\}. As shown in Figure 6(b), the error distributions demonstrated stable performance, consistently remaining below a threshold across all tested Reynolds numbers. Figure 6(c) further confirms robust and satisfactory error levels, with smaller errors observed when the Reynolds number is closer to the training value, as validated by the correlation curves in Figure 6(b). We observed a notable poor performance at Re=200Re = 200, which we hypothesize is due to the exponential dependence of the ratio between the nonlinear convective term and the linear viscous term in the NSE on the Reynolds number (ReRe). As ReRe decreases from 1000 to 200, the dominant term shifts from the convection term (u⋅∇)u(u \cdot\nabla)u to the linear dissipation term ν∇2u\nu\nabla^{2}u. However, the model parameters remain fixed based on the high-ReRe feature extraction mode, lacking the ability to adaptively adjust the feature weight distribution. Extended generalization tests on shear flow with varying ReRe and diffusion coefficients (DD) are provided in Appendix § 12.

LDSolver generalization over various Reynolds numbers

Figure 6. LDSolver generalization over various Reynolds numbers (ReRe). (a) Vorticity evolution snapshots for forced flow. (b) Error distribution. (c) Correlation time series.

Ablation Study

To assess the contributions of individual components to model performance, we performed an ablation study on the forced flow dataset using six configurations: (1) Model 1 (physics-based convolution only, equivalent to DNS solver); (2) Model 2 (without physics-based convolution); (3) Model 3 (without frequency domain operator); (4) Model 4 (frequency domain operator exclusively); (5)

Model 5 (without Temporal Correction block); and (6) the complete LDSolver architecture. All experiments maintained identical dataset and hyperparameter settings as specified in previous sections.

Table 3 demonstrates the significant impact of each component. The findings are presented as follows. (1) With only the physics-based convolution, the model becomes untrainable, effectively reducing LDSolver to a traditional solver. Consequently, direct solutions on coarse grids using this configuration result in substantial numerical errors, exhibiting error levels four times higher than the complete model. This highlights the critical role of the learnable modules on coarse grids. (2) Removing the physics-based convolution, which provides the baseline solution derived from fixed kernels, leads to degraded performance. (3) The absence of the frequency domain operator introduces convergence issues during inference. (4) Eliminating the temporal correction block significantly increases cumulative errors. In summary, the physics-based convolution provides a basic solution on coarse grids, the learnable convolutions capture local information, frequency domain operator supplies global information and enhance inference stability, and the temporal correction block ensures accurate predictions over long time horizons. These components are therefore essential.

ModelRMSEMAEMNADHCT (s)
DNS Solver0.83330.65720.13133.5475
w/o PhyConv0.28740.21550.03866.9478
w/o FreqOpNANNANNAN1.5914
FreqOp onlyNANNANNAN1.8158
w/o TempCorr0.33610.25420.04566.5622
LDSolver (Full)0.23770.12530.01598.4131

Table 3. Ablation study results for LDSolver.

Conclusion

We introduce a learnable and differentiable finite volume solver (LDSolver) for efficient and accurate simulation of fluid flows on coarse spatiotemporal grids. LDSolver consists of two core components: (1) a differentiable finite volume solver as the computational framework, and (2) learnable modules designed to correct derivative, interpolation, and temporal errors on coarse grids. Within the spatial module, a physics-based convolution provides a baseline solution, learnable convolutions extract local features, and a frequency domain operator captures global features. In the temporal module, a temporal correction block mitigates accumulated errors in long-term simulations. Experiments on four flow systems demonstrate that LDSolver significantly accelerates simulations (as shown in Table 4) while maintaining high accuracy and robust generalization, even with limited training data. While LDSolver shows great potential, two key areas require further exploration: (1) its reliance on regular grids limits its applicability to complex geometries. This limitation can be addressed by incorporating geometry-aware models (e.g., Geo-FNO [23]), coordinate transformations (e.g., PhyGeoNet [11]), or graph-based extensions (e.g., PhyMPGN [58]) to handle irregular domains and boundary conditions, and (2) extending the current framework to support three-dimensional flows remains a critical direction for future research.

CaseBurgersDecayingForcedShear
DNS2.306729.240232.806129.1428
LDSolver0.98002.37733.80362.7857
Speed up ×\times (↑\uparrow)2.353712.30008.625010.4615

Table 4. Computation Speed Comparison. Values represent GPU simulation time required per physical second. The DNS resolutions for the four flow systems are 100×100100 \times100, 1024×10241024 \times1024, 1024×10241024 \times1024, and 1024×5121024 \times512, respectively. The corresponding LDSolver resolutions are 25×2525 \times25, 64×6464 \times64, 64×6464 \times64, and 128×64128 \times64.

Acknowledgments

This work is supported by the National Natural Science Foundation of China (No. 62276269, No. 92270118) and the Beijing Natural Science Foundation (No. 1232009).

Appendix

This supplementary material file provides the appendix section to the main article.

Notation

The commonly used symbols and variables throughout the article are listed in Table S1.

VariableMeaning
ukiju^{ij}_{k}Velocity at 2D grid coordinate (i,j)(i,j) at time step kk on coarse grids
uˉkij\bar{u}^{ij}_{k}Velocity at 2D grid coordinate (i,j)(i,j) at time step kk on fine grids
uˉ\bar{u}Average value of uu
u∗u^{*}The intermediate velocity field
pkijp^{ij}_{k}Pressure at 2D grid coordinate (i,j)(i,j) at time step kk
ffExternal force
ReReReynolds number
VijV^{ij}Control volume at 2D grid coordinate (i,j)(i,j)
AijA^{ij}Area of the face (i,j)(i,j)
kck_{c}Temporal buffer correction steps
NNTotal simulation time steps
TTTotal simulation time
x\mathbf{x}The coarse-grid coordinates
δt\delta tThe fine time step
Δt\Delta tThe coarse time step
δx\delta xThe fine grids distance
Δx\Delta xThe coarse grids distance
ksk_{s}Sample length

Table S1. Commonly used symbols and variables and their meaning.

Basics of the Finite Volume Method

Staggered Grid and BC Encoding

The staggered grid is an efficient discretization strategy in finite-volume methods, where velocity components and pressure (or other scalar fields) are stored at distinct spatial positions within grid cells, as illustrated in Figure S1. For a control volume VijV^{ij}, velocity components are typically located at cell face centers, while pressure resides at cell centroids. This staggered arrangement inherently avoids non-physical oscillations (e.g., checkerboard artifacts) caused by pressure-velocity decoupling in traditional collocated grids, leveraging natural interpolation of physical variables. Within the finite-volume framework, staggered grids enable precise flux integration of mass and momentum across cell boundaries by directly utilizing velocity values at face locations, ensuring strict local conservation. Furthermore, pressure gradient terms are naturally computed through finite differences of adjacent pressure values, eliminating interpolation errors and enhancing numerical stability.

Figure S1. Staggered grid and boundary condition encoding.

To rigorously enforce prescribed periodic boundary conditions and maintain feature map consistency during differentiation, our architecture integrates periodic boundary condition (BC) padding (Figure S1). This deterministic padding approach ensures precise boundary periodicity while enhancing numerical accuracy in derivative-based computations.

Spatial Discretization

Taking the xx-direction as an example, we consider the discretization of the momentum equation (Eq. (39)) using the finite volume method (FVM). We denote each term in the NSE below, where all the discretizations are performed within a control volume VV (with the indices ii, jj omitted for simplicity). Using the divergence theorem, we transform the volume integrals into surface integrals, leading to eq. (14):

∂∂t∫Vu dV−∮Suu⋅n dS−∮Spn dS+1Re∮S∇u⋅n dS+∮Sfx dS(14)\frac{\partial}{\partial t}\int_V u\,\mathrm{d}V -\oint_S \mathbf{u}\mathbf{u}\cdot\mathbf{n}\,\mathrm{d}S -\oint_S p\mathbf{n}\,\mathrm{d}S +\frac{1}{Re}\oint_S \nabla\mathbf{u}\cdot\mathbf{n}\,\mathrm{d}S +\oint_S f_x\,\mathrm{d}S \tag*{(14)}

This equation represents the transient term in its integral form.

Advection Term: The second term involves the advection of the velocity field, expressed as (u⋅∇)u(\mathbf{u}\cdot\nabla)\mathbf{u}. By applying the divergence theorem, the volume integral is converted to a surface integral:

∮Suu⋅n dS≈(uu)eΔy−(uu)wΔy+(uu)nΔx−(uu)sΔx.(15)\oint_S \mathbf{u}\mathbf{u}\cdot\mathbf{n}\,\mathrm{d}S \approx(\mathbf{u}\mathbf{u})_e\Delta y-(\mathbf{u}\mathbf{u})_w\Delta y+(\mathbf{u}\mathbf{u})_n\Delta x-(\mathbf{u}\mathbf{u})_s\Delta x. \tag*{(15)}

Here, ee, ww, nn, ss denote the east, west, north, and south faces of the control volume, respectively.

Dissipation Term: The dissipation term represents the viscous forces in the fluid and is given by 1Re∇2u\frac{1}{Re}\nabla^2\mathbf{u}. Using the divergence theorem again, we transform the volume integral into surface integrals:

∮S∇u⋅n dS=∂u∂x∣eΔy−∂u∂x∣wΔy+∂u∂y∣nΔx−∂u∂y∣sΔx.(16)\oint_S \nabla\mathbf{u}\cdot\mathbf{n}\,\mathrm{d}S = \left.\frac{\partial u}{\partial x}\right|_e\Delta y- \left.\frac{\partial u}{\partial x}\right|_w\Delta y+ \left.\frac{\partial u}{\partial y}\right|_n\Delta x- \left.\frac{\partial u}{\partial y}\right|_s\Delta x. \tag*{(16)}

Pressure Term: The pressure term is discretized by applying the Gauss theorem:

∮Spn dS≈(peΔy−pwΔy)=(pe−pw)Δy(17)\oint_S p\mathbf{n}\,\mathrm{d}S \approx(p_e\Delta y-p_w\Delta y)=(p_e-p_w)\Delta y \tag*{(17)}

External Forcing Term: Finally, the external forcing term ff is assumed to be constant within each control volume, and its integral is approximated as:

∮Sfx dS≈fx⋅V.(18)\oint_S f_x\,\mathrm{d}S \approx f_x\cdot V. \tag*{(18)}

In this process, evaluating the convective and diffusive fluxes requires estimating velocity interpolations and spatial derivatives at the faces of control volumes within VV. Using Taylor expansion and linear interpolation, these quantities at the cell faces can be approximated as:

WP(d)=[000000001−2727−100000000]×124(Δx)(19)W_P^{(d)}= \begin{bmatrix} 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0\\ 1 & -27 & 27 & -1\\ 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 \end{bmatrix} \times\frac{1}{24(\Delta x)} \tag*{(19)}
WP(i)=[000000000−11000000000]×12(Δx)(20)W_P^{(i)}= \begin{bmatrix} 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0\\ 0 & -1 & 1 & 0\\ 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 \end{bmatrix} \times\frac{1}{2(\Delta x)} \tag*{(20)}

where WP(d)W_P^{(d)} represents the kernel for derivative estimation, which employs a fourth-order accurate finite difference scheme, and WP(i)W_P^{(i)} denotes the kernel for interpolation, utilizing a second-order accurate central difference scheme. These kernels are applied to approximate the required quantities at the control volume faces, ensuring accurate numerical solutions.

The pressure term is typically addressed using projection methods, as detailed in Appendix Section B.3. For time integration, various schemes can be employed; in this study, we utilize the fourth-order Runge-Kutta (RK4) method, the specifics of which are provided in the Appendix Section B.5.

Projection Method

The projection method is a widely used finite volume approach for solving the NSE, primarily addressing the pressure-velocity coupling problem. Its core concept lies in the time-splitting technique: first, the convection and dissipation terms are solved using the velocity field from the previous time step; then, the pressure term is obtained by solving the Poisson equation to satisfy the divergence-free condition; finally, the velocity field at the next time step is computed through time integration. This method ensures fluid incompressibility by projecting the velocity field and, when combined with appropriate numerical techniques, guarantees both computational efficiency and accuracy. The details are as follows: Initially, the momentum equation is solved by neglecting the pressure gradient term using the RK4 method (see Appendix Section B.5). Specifically, an intermediate velocity field uk∗u_k^{*} is computed using the following equation:

∂uk∗∂t=−(uk⋅∇)uk∗+1Re∇2uk∗+f,(21)\frac{\partial u_k^{*}}{\partial t}=-(u_k\cdot\nabla)u_k^{*}+\frac{1}{Re}\nabla^{2}u_k^{*}+f, \tag*{(21)}

where uk∗u_k^{*} is an intermediate velocity that generally does not satisfy ∇⋅uk∗=0\nabla\cdot u_k^{*}=0. Next, enforce incompressibility by solving for the pressure increment pp. Applying ∇⋅uk+1=0\nabla\cdot u_{k+1}=0 to the corrector uk+1=uk∗−δt∇pu_{k+1}=u_k^{*}-\delta t\nabla p yields

∇2p=1δt∇⋅uk∗,(22)\nabla^{2}p=\frac{1}{\delta t}\nabla\cdot u_k^{*}, \tag*{(22)}

where pp is the physical pressure, obtained by solving the2 equation with a Poisson solver as detailed in Appendix B.4. Update the velocity to divergence-free form:

uk+1=uk∗−δt∇p,(23)u_{k+1}=u_k^{*}-\delta t\nabla p, \tag*{(23)}

where δt\delta t is the time step size. This step corrects the velocity field to ensure adherence to the divergence-free condition. The update of the velocity field is now complete. This procedure guarantees ∇⋅uk+1=0\nabla\cdot u_{k+1}=0 at each step, while treating advection and diffusion explicitly for computational efficiency and accuracy.

Poisson Solver

The goal of the Poisson solver is to determine the state quantities of a system in a two-dimensional spatial domain using the spectral method for a given Laplacian term. The Laplace equation in two dimensions is:

Δp=ψ(u∗).(24)\Delta p=\psi(u^{*}). \tag*{(24)}

Applying Fast Fourier Transform (FFT) on Eq. (24), we get:

−(ηx2+ηy2)p^=ψ^(u∗),(25)-(\eta_x^2+\eta_y^2)\hat{p}=\hat{\psi}(u^{*}), \tag*{(25)}

where ηx\eta_x and ηy\eta_y are the wavenumbers along the xx and yy axes, respectively, assuming ηx2+ηy2≠0\eta_x^2+\eta_y^2 \ne0 to avoid division by zero. In the frequency domain, we obtain:

p^=−ψ^(u∗)(ηx2+ηy2).(26)\hat{p}=-\frac{\hat{\psi}(\mathbf{u}^{\ast})}{\left(\eta_x^2+\eta_y^2\right)}. \tag*{(26)}

Next, we transform the field from the frequency domain to the spatial domain using inverse Fast Fourier Transform (iFFT):

p=iFFT⁡[ψ^(u∗)−(ηx2+ηy2)].(27)p=\operatorname{iFFT}\left[\frac{\hat{\psi}(\mathbf{u}^{\ast})}{-\left(\eta_x^2+\eta_y^2\right)}\right]. \tag*{(27)}

By applying this process to ψ(u∗)\psi(\mathbf{u}^{\ast}), we can efficiently decouple the pressure field without any labeled data.

RK4 scheme

The RK4 (Runge-Kutta 4th order) method is a widely used numerical integration technique for solving ordinary differential equations (ODEs) and partial differential equations (PDEs). It is commonly employed as a time-stepping solver due to its balance between computational efficiency and accuracy. This method approximates the solution by calculating intermediate slopes at several points within each time step.

The general form of the time-stepping integration for advancing from time step kk to k+1k+1 can be written as:

uk+1=uk+∫kk+1H(uk(x,τ))dτ.(28)\mathbf{u}_{k+1}=\mathbf{u}_k+\int_k^{k+1}\mathcal{H}\left(\mathbf{u}_k(x,\tau)\right)\mathrm{d}\tau. \tag*{(28)}

where uk+1\mathbf{u}_{k+1} and uk\mathbf{u}_k represent the solutions at times k+1k+1 and kk, respectively.

RK4 is a high-order integration scheme. It divides the time interval into several small, equally spaced steps to approximate the integral. The update process for the state at each time step can be described as follows:

r1=H(uk,k),(29)r_1=\mathcal{H}(\mathbf{u}_k,k), \tag*{(29)}
r2=H(uk+Δt2×r1,k+Δt2),(30)r_2=\mathcal{H}\left(\mathbf{u}_k+\frac{\Delta t}{2}\times r_1,k+\frac{\Delta t}{2}\right), \tag*{(30)}
r3=H(uk+Δt2×r2,k+Δt2),(31)r_3=\mathcal{H}\left(\mathbf{u}_k+\frac{\Delta t}{2}\times r_2,k+\frac{\Delta t}{2}\right), \tag*{(31)}
r4=H(uk+Δt×r3,k+Δt),(32)r_4=\mathcal{H}\left(\mathbf{u}_k+\Delta t\times r_3,k+\Delta t\right), \tag*{(32)}
uk+1=uk+16Δt(r1+2r2+2r3+r4).(33)\mathbf{u}_{k+1}=\mathbf{u}_k+\frac{1}{6}\Delta t\left(r_1+2r_2+2r_3+r_4\right). \tag*{(33)}

This approach ensures that the solution is advanced accurately while maintaining a reasonable computational cost. The weighted sum of the intermediate slopes r1r_1, r2r_2, r3r_3, and r4r_4 provides a high-order approximation to the integral.

Temporal Error Analysis

Consider a numerical time-stepping scheme where uk\mathbf{u}_k denotes the computed solution at step kk, uk†\mathbf{u}^{\dagger}_k the exact solution, and δt\delta t the time step size. The global error is defined as ek=uk−uk†e_k=\mathbf{u}_k-\mathbf{u}^{\dagger}_k. Assume the numerical method follows the recurrence relation uk=F(uk−1,δt)\mathbf{u}_k=\mathcal{F}(\mathbf{u}_{k-1},\delta t), while the exact solution satisfies uk†=F(uk−1†,δt)+τ(uk−1†,δt)\mathbf{u}^{\dagger}_k=\mathcal{F}(\mathbf{u}^{\dagger}_{k-1},\delta t)+\tau(\mathbf{u}^{\dagger}_{k-1},\delta t), where τ\tau is the local truncation error.

The error propagation is derived by subtracting these relationships:

ek=F(uk−1,δt)−F(uk−1†,δt)−τ(uk−1†,δt).(34)e_k=\mathcal{F}(\mathbf{u}_{k-1},\delta t)-\mathcal{F}(\mathbf{u}^{\dagger}_{k-1},\delta t)-\tau(\mathbf{u}^{\dagger}_{k-1},\delta t). \tag*{(34)}

Linearizing F\mathcal{F} about uk−1†\mathbf{u}^{\dagger}_{k-1} via Taylor expansion yields:

F(uk−1,δt)≈F(uk−1†,δt)+∂F∂u∣uk−1†ek−1+O(∥ek−1∥2).(35)\mathcal{F}(\mathbf{u}_{k-1},\delta t)\approx\mathcal{F}(\mathbf{u}^{\dagger}_{k-1},\delta t)+\left.\frac{\partial\mathcal{F}}{\partial\mathbf{u}}\right|_{\mathbf{u}^{\dagger}_{k-1}}e_{k-1}+O\left(\lVert e_{k-1}\rVert^2\right). \tag*{(35)}

Substituting this into the error equation reveals the recursive structure:

ek≈∂F∂u∣uk−1†ek−1−τ(uk−1†,δt)+O(∥ek−1∥2),(36)e_k\approx\left.\frac{\partial\mathcal{F}}{\partial\mathbf{u}}\right|_{\mathbf{u}^{\dagger}_{k-1}}e_{k-1}-\tau(\mathbf{u}^{\dagger}_{k-1},\delta t)+O\left(\lVert e_{k-1}\rVert^2\right), \tag*{(36)}

showing that errors propagate through both linear amplification of prior discrepancies and accumulation of truncation errors.

Unrolling the recursion through kk steps gives:

ek=∏i=1k∂F∂u∣ui−1†e0−∑j=1k∏i=j+1k∂F∂u∣ui−1†τ(uj−1†,δt)+O(∑m=1k∥em−1∥2).(37)e_k=\prod_{i=1}^{k}\left.\frac{\partial\mathcal{F}}{\partial\mathbf{u}}\right|_{\mathbf{u}^{\dagger}_{i-1}}e_0-\sum_{j=1}^{k}\prod_{i=j+1}^{k}\left.\frac{\partial\mathcal{F}}{\partial\mathbf{u}}\right|_{\mathbf{u}^{\dagger}_{i-1}}\tau(\mathbf{u}^{\dagger}_{j-1},\delta t)+O\left(\sum_{m=1}^{k}\lVert e_{m-1}\rVert^2\right). \tag*{(37)}

This decomposition highlights three key dependencies: (1) Amplification factors tied to the method’s Jacobian matrices, which depend on historical solutions through ui†=ui−ei\mathbf{u}^{\dagger}_i=\mathbf{u}_i-e_i; (2) Cumulative truncation errors modulated by preceding Jacobians; (3) Nonlinear coupling effects when F\mathcal{F} is nonlinear.

This proves ek=g(k−1)(u0,…,uk−1,δt,e0)e_k=g^{(k-1)}(\mathbf{u}_0,\ldots,\mathbf{u}_{k-1},\delta t,e_0) under the conditions that F\mathcal{F} is continuously differentiable and errors remain small (∥ek∥≪1\lVert e_k\rVert\ll1). The function g(k−1)g^{(k-1)} encapsulates both linear error propagation and nonlinear state dependencies arising from solution-history-dependent Jacobians. This motivates the design of temporal correction block that leverage historical solution buffers to counteract error accumulation.

Numerical Solver

Datasets Description

To evaluate the generalizability of LDSolver, we constructed diverse datasets encompassing various complex flow systems, including the Burgers’ equation, decaying flow, forced flow, and shear flow. To ensure fairness in testing, we randomly selected 10 seeds with Gaussian random field, providing a diverse set of random initial conditions. Additionally, we introduced a warm-up phase to allow the system to reach a steady state before data collection, thereby mitigating the influence of initial transient effects. Further details can be found in Table S2.

Parameters / CaseBurgers’ EquationDecaying FlowForced FlowShear Flow
Spatial Domain[0,1]2[0,1]^2[0,2π]2[0,2\pi]^2[0,2π]2[0,2\pi]^2[0,8]×[0,4][0,8]\times[0,4]
Grid1002100^2204822048^2204822048^22048×10242048\times1024
Training Grid25225^264264^264264^2128×64128\times64
Simulation dt (s)1.00×10−31.00\times10^{-3}2.19×10−42.19\times10^{-4}2.19×10−42.19\times10^{-4}3.125×10−43.125\times10^{-4}
Warmup (s)0.5404012
Training data group510105
Testing data group10101010
Spatial downsample16×16\times1024×1024\times1024×1024\times512×512\times
Temporal downsample10×10\times32×32\times32×32\times32×32\times

Table S2. Settings for generating datasets.

Burgers’ Equation. The Burgers’ Equation is a fundamental equation in fluid dynamics, capturing the interplay between convection and diffusion process. It finds applications across various disciplines, including materials science, applied mathematics, and engineering:

∂u∂t=ν∇2u−u⋅∇u,t∈[0,T].(38)\frac{\partial\mathbf{u}}{\partial t}=\nu\nabla^2\mathbf{u}-\mathbf{u}\cdot\nabla\mathbf{u},\quad t\in[0,T]. \tag*{(38)}

where u={u,v}∈R2\mathbf{u}=\{u,v\}\in\mathbb{R}^2 represents the fluid velocity, ν\nu denotes the viscosity coefficient (set to 0.002), and ∇\nabla signifies the gradient operator. We generate the dataset using our numerical finite volume solver (LDSolver). Periodic boundary conditions are imposed on the spatial domain x∈[0,1]x \in[0,1]. The data is initially generated on a 1002100^2 grid and downsampled to a 25225^2 grid for our training experiments. The simulation uses a time step of δt=1×10−3\delta t = 1\times10^{-3} seconds, with a total simulation time of T=4.5T = 4.5 seconds. In the training phase, we use 5 distinct trajectories, each comprising 450 snapshots with a temporal interval of Δt=10δt\Delta t = 10\delta t. For the testing phase, we generate 10 additional trajectories, each also containing 450 snapshots.

Decaying & Forced Flow. The decaying and forced flow is governed by the NSE:

∂u∂t+(u⋅∇)u=1Re∇2u−∇p+f,t∈[0,T].(39)\frac{\partial\mathbf{u}}{\partial t}+(\mathbf{u}\cdot\nabla)\mathbf{u}=\frac{1}{Re}\nabla^2\mathbf{u}-\nabla p+\mathbf{f},\qquad t\in[0,T]. \tag*{(39)}
∇⋅u=0,(40)\nabla\cdot\mathbf{u}=0, \tag*{(40)}

where u={u,v}∈R2\mathbf{u}=\{u,v\}\in\mathbb{R}^2 is the fluid velocity vector, p∈Rp\in\mathbb{R} is the pressure, and ReRe is the Reynolds number, a dimensionless parameter that characterizes flow regimes such as laminar, turbulent, or transitional. Here, TT denotes the total simulation time. The decaying and forced flow is governed by the NSE (see Eq. (39)). To generate the dataset, high-resolution (e.g., 2048×20482048\times2048 grid cells) simulations were performed using numerical LDSover on fine grids with a small time step δt\delta t. The resulting data were downsampled to coarser grids (e.g., 64×6464\times64 grid cells) with a significantly larger time step Δt=32δt\Delta t=32\delta t to establish the ground truth. Initial conditions (ICs) were generated by Gaussian random field. For training, we used only 10 sets of labeled data, each containing 2400 snapshots. For testing, 10 different trajectories were generated. The model’s performance was evaluated across 5 Reynolds numbers: Re={200,500,1000,1500,2000}Re=\{200,500,1000,1500,2000\}. For decaying flow, f=0\mathbf{f}=0, while for forced flow, we set fk=[sin⁡4y−0.1uk,−0.1vk]T\mathbf{f}_k=[\sin4y-0.1u_k,-0.1v_k]^\mathsf{T}.

Shear Flow. Consider a more complex scenario where the NSE are coupled with a Burgers’ equation to model the spatiotemporal evolution of a substance (e.g., heat, pollutants, solutes) within a flow. This coupled system finds broad applicability in processes such as atmospheric pollutant diffusion, heat transfer, and solute transport. Here, we take a classic shear flow system as an example and use LDSolver to attempt solving such problems.

∂u∂t+∇p−1Re∇2u=−u⋅∇u,t∈[0,T].(41)\frac{\partial\mathbf{u}}{\partial t}+\nabla p-\frac{1}{Re}\nabla^2\mathbf{u}=-\mathbf{u}\cdot\nabla\mathbf{u},\qquad t\in[0,T]. \tag*{(41)}

This equation describes the fluid motion, where u=(u,v)∈R2\mathbf{u}=(u,v)\in\mathbb{R}^2 is the velocity field, and p∈Rp\in\mathbb{R} is the pressure, subject to the constraint ∫p=0\int p=0 (i.e., the total pressure is zero). The velocity field also satisfies the mass conservation equation ∇⋅u=0\nabla\cdot\mathbf{u}=0.

∂s∂t−D∇2s=−u⋅∇s,t∈[0,T].(42)\frac{\partial s}{\partial t}-D\nabla^2s=-\mathbf{u}\cdot\nabla s,\qquad t\in[0,T]. \tag*{(42)}

This equation governs the transport of a substance, where s∈Rs\in\mathbb{R} is a passive scalar representing the concentration or temperature of the substance, and DD is the diffusion coefficient. In this case, the Reynolds number is set to Re∈{1000,2000}Re\in\{1000,2000\}, and the diffusion coefficient is set to D∈{0.001,0.002}D\in\{0.001,0.002\}.

The shear flow dynamics are governed by the Reynolds number ReRe and the diffusion coefficient DD. A high Reynolds number results in inertia-dominated shear instabilities, whereas the diffusion coefficient regulates the relative diffusion rates of the momentum and scalar fields.

The initial velocity field is composed of vertically displaced shear layers, characterized by a hyperbolic tangent profile of width ww, and horizontally modulated vortices, represented by sine waves with exponentially decaying modes:

ux=∑k=1nsheartanh⁡(5(y−yk)w)+ϵx,(43)u_x=\sum_{k=1}^{n_{\mathrm{shear}}}\tanh\left(\frac{5(y-y_k)}{w}\right)+\epsilon_x, \tag*{(43)}
uy=∑k=1nshearsin⁡(nblobsπx)e−25w2∣y−yk∣2+ϵy(44)u_y=\sum_{k=1}^{n_{\mathrm{shear}}}\sin(n_{\mathrm{blobs}}\pi x)e^{-25w^2|y-y_k|^2}+\epsilon_y \tag*{(44)}

where nshear=2n_{\mathrm{shear}}=2, nblobs=2n_{\mathrm{blobs}}=2, and w=0.5w=0.5. The scalar field ss is initially aligned with the shear layer at t=0t=0. ϵx\epsilon_x and ϵy\epsilon_y denote random noise components to generate different ICs.

Solver Property Analysis

We analyzed the forced flow at various resolutions. Figure S2 demonstrates that as the resolution decreases, the flow field snapshot gradually degrades. When the resolution is reduced to 64264^2, the solver’s accuracy significantly declines, a trend also reflected in the spatial correlation time series shown in Figure S3. This systematic analysis underscores the robustness and limitations of our solver across different resolutions. We also observed that LDSolver at a resolution of 64264^2 achieves higher simulation accuracy than DNS at 5122512^2, approaching the performance of DNS at 102421024^2.

Comparison of vorticity snapshot evolution between DNS solutions at different resolutions and LDSolver at a resolution of $64 \times 64$

Figure S2. A comparison of vorticity snapshot evolution between DNS solutions at different resolutions and LDSolver at a resolution of 64×6464 \times64.

Comparison of vorticity correlation time series between DNS solutions at different resolutions and LDSolver at a resolution of 64×64

Figure S3. A comparison of vorticity correlation time series between DNS solutions at different resolutions and LDSolver at a resolution of 64×64.

Training Parameters and Results

Evaluation Metrics

We adopt multiple metrics to assess the performance of the tested models, including Root Mean Square Error (RMSE), Mean Absolute Error (MAE), Mean Normalized Absolute Difference (MNAD), and High-Correlation Time (HCT) [49]. Below, we define these metrics and explain their roles in evaluating prediction accuracy and reliability.

RMSE=1n∑i=1n∥Bi−B~i∥2(45)\mathrm{RMSE} = \sqrt{\frac{1}{n}\sum_{i=1}^{n}\left\lVert\mathbf{B}_{i} - \tilde{\mathbf{B}}_{i}\right\rVert^{2}} \tag*{(45)}
MAE=1n∑i=1n∣Bi−B~i∣(46)\mathrm{MAE} = \frac{1}{n}\sum_{i=1}^{n}\left\lvert\mathbf{B}_{i} - \tilde{\mathbf{B}}_{i}\right\rvert \tag*{(46)}
MNAD=1n∑i=1n∥Bi−B~i∥∥Bi∥max⁡−∥Bi∥min⁡(47)\mathrm{MNAD} = \frac{1}{n}\sum_{i=1}^{n}\frac{\left\lVert\mathbf{B}_{i} - \tilde{\mathbf{B}}_{i}\right\rVert}{\left\lVert\mathbf{B}_{i}\right\rVert_{\max} - \left\lVert\mathbf{B}_{i}\right\rVert_{\min}} \tag*{(47)}
HCT=∑i=1NΔt⋅1[PCC(Bi,B~i)>0.8](48)\mathrm{HCT} = \sum_{i=1}^{N}\Delta t \cdot\mathbf{1}\left[\mathrm{PCC}(\mathbf{B}_{i},\tilde{\mathbf{B}}_{i}) > 0.8\right] \tag*{(48)}
PCC(Bi,B~i)=cov⁡(Bi,B~i)σBiσB~i(49)\mathrm{PCC}(\mathbf{B}_{i},\tilde{\mathbf{B}}_{i}) = \frac{\operatorname{cov}(\mathbf{B}_{i},\tilde{\mathbf{B}}_{i})}{\sigma_{\mathbf{B}_{i}}\sigma_{\tilde{\mathbf{B}}_{i}}} \tag*{(49)}

where nn is the number of trajectories, B~i\mathbf{\tilde{B}}_i denotes the ground truth of the ii-th trajectory, and Bi\mathbf{B}_i represents the predicted spatiotemporal sequence. ∥⋅∥\lVert\cdot\rVert is defined as the Euclidean (or ℓ2\ell_2) norm of a given vector, while ∥⋅∥max⁡\lVert\cdot\rVert_{\max} and ∥⋅∥min⁡\lVert\cdot\rVert_{\min} denote its maximum and minimum values, respectively. NN is the total number of time steps, Δt\Delta t is the time interval, and 1[⋅]\mathbf{1}[\cdot] is an indicator function returning 1 if the condition holds and 0 otherwise. cov⁡(⋅)\operatorname{cov}(\cdot) is the covariance, and σBi\sigma_{\mathbf{B}_i}, σB~i\sigma_{\mathbf{\tilde{B}}_i} are the standard deviations of Bi\mathbf{B}_i and B~i\mathbf{\tilde{B}}_i, respectively.

Root Mean Square Error (RMSE) quantifies the average magnitude of error between predicted and true values, providing insights into model precision. Mean Absolute Error (MAE) measures the average absolute deviation between predictions and observations, reflecting the scale of errors. Mean Normalized Absolute Difference (MNAD) evaluates prediction consistency by normalizing errors against the range of observed values. HCT quantifies the model’s capability to maintain reliable long-term predictions. It accumulates the time intervals where the Pearson Correlation Coefficient (PCC) between predictions and ground truth exceeds 0.8.

Baseline models

Fourier Neural Operator (FNO). FNO [24] integrates neural networks with Fourier transforms to effectively capture both global and local features of system dynamics. As shown in Figure S4, the network structure mainly consists of three components: PP (lift operation), QQ (projection operation), and Fourier layers. Both PP and QQ are convolutional operations for channel transformation. Each Fourier layer uses the Fast Fourier Transform (FFT) and the inverse Fast Fourier Transform (iFFT) for frequency domain transformations. Additionally, RϕR_\phi represents spectral filtering and convolution in the frequency domain, and WlW_l denotes the local linear transformation for the ll-th layer. σ\sigma is the GeLU activation function.

Architecture of the Fourier Neural Operator (FNO) model

Figure S4. Architecture of the Fourier Neural Operator (FNO) model.

PeRCNN. PeRCNN [40] embeds physical principles directly into the learning framework by incorporating governing equations

within the neural network structure. This architecture features multiple parallel convolutional neural networks (CNNs), which model polynomial relationships through feature map multiplications. The inclusion of physical laws enhances the model’s generalization and extrapolation capabilities, enabling accurate predictions in dynamic systems governed by complex equations.

DeepONet. DeepONet [32] is designed to approximate operators and directly map inputs to outputs using neural networks. The architecture consists of two main components: the trunk net, which processes domain-specific information, and the branch net, which handles input functions. This dual-structure approach enables the efficient learning of complex functional relationships and enhances the model’s ability to capture detailed operator mappings in various applications.

Temporal Stencil Modeling (TSM). TSM [49] addresses time-dependent partial differential equations (PDEs) in conservation form by integrating time-series modeling with learnable stencil techniques. This method effectively recovers information lost during downsampling, improving predictive accuracy. TSM is particularly beneficial for machine learning models working with coarse-resolution datasets.

P2^2C2^2Net. P2^2C2^2Net [53] adopts a physics-encoded variable correction learning approach that embeds PDE structures into coarse grids to solve nonlinear dynamic systems. The model introduces a convolutional filter with symmetry constraints, to adaptively compute derivatives of system state variables. It improves the model’s ability to capture the characteristics of nonlinear dynamics with limited data, enhancing both generalization and computational efficiency.

Descriptive Analysis of Models

We analyze the characteristics of LDSolver and existing baselines, focusing on their performance on the NSE example. Table S4 summarizes these methods, highlighting key aspects such as learnability, differentiability, strict physical consistency, handling limited data, stability of rollout predictions, independence from historical data, and temporal error correction. Notably, our proposed model, LDSolver, excels across all evaluated criteria.

ModelLearnable & DifferentiablePhysics ConsistencyPreserves ConservationHandles Limited DataRollout Prediction StabilityIndependent of Historical DataTemporal Error Correction
FNO✓✗✗✗✓✓✗
LI✓✓✓✗✗✓✗
TSM✓✓✓✗✗✗✓
PeRCNN✓✓✗✗✗✓✗
P2C2P^{2}C^{2}Net✓✓✗✓✓✓✓
LDSolver✓✓✓✓✓✓✓

Table S4. Summary analysis of LDSolver and baselines for the NSE example. Each model is assessed based on the listed criteria, with ✓ indicating support and ✗ indicating lack of support.

Training Details

All experiments, including training and inference, were conducted on a single Nvidia A100 GPU (80GB memory), running on a server with an Intel(R) Xeon(R) Platinum 8380 CPU (2.30 GHz, 64 cores). Model training was performed on coarse grids (see Table S2).

LDSolver: The LDSover architecture employs the Adam optimizer with a learning rate of 1×10−41 \times10^{-4}. The model is trained for 5000 epochs with a batch size of 20. Detailed hyperparameters are listed in Table S3.

CaseBlockHyperparametersValues
BurgersPhysics-based Conv.NetworkCNN
H×W5×4
Input/Output channel[1,1]
Learnable Conv.NetworkCNN
H×W5×4
Input/Output channel[1,1]
Decaying FlowPhysics-based Conv.NetworkCNN
H×W5×4
Input/Output channel[1,1]
Learnable Conv.NetworkCNN
H×W5×4
Input/Output channel[1,1]
Frequency Domain OperatorNetworkFNO [24]
Layers4
Modes16
Width8
σ\sigmaGELU
Forced FlowPhysics-based Conv.NetworkCNN
H×W5×4
Input/Output channel[1,1]
Learnable Conv.NetworkCNN
H×W5×4
Input/Output channel[1,1]
Frequency Domain OperatorNetworkFNO [24]
Layers6
Modes32
Width16
σ\sigmaGELU
Temporal Correction BlockNetworkFNO [24]
Layers4
Modes32
Width8
σ\sigmaGELU
Shear FlowPhysics-based Conv.NetworkCNN
H×W5×4
Input/Output channel[1,1]
Learnable Conv.NetworkCNN
H×W5×4
Input/Output channel[1,1]
Frequency Domain OperatorNetworkFNO [24]
Layers4
Modes32
Width8
σ\sigmaGELU

Table S3. Overview of hyperparameters of LDSolver for Burgers, decaying, forced, and shear flow.

P2^2C2^2Net: The P2^2C2^2Net architecture [53] also uses the Adam optimizer with a learning rate of 5×10−35 \times10^{-3}. Training is performed over 5000 epochs, with a batch size of 16. The hyperparameter configurations adhere to the default settings specified in the original paper [53].

FNO: The architecture of the FNO network follows the original study [24], with the main adjustment being the adaptation of the training method to an autoregressive framework. Adam optimizer is used with a learning rate of 1×10−31 \times10^{-3} and a batch size of 20.

Training spans 5000 epochs, with the rollout timestep matching that of LDSolver.

DeepONet: The DeepONet model uses its default configuration [32] and the Adam optimizer. The learning rate is set to 5×10−45 \times10^{-4}, with a decay factor of 0.9 applied every 5000 steps. The model is trained for 5000 epochs with a batch size of 20.

PeRCNN: The PeRCNN model [40] is used with the standard settings. The optimization is performed using the Adam optimizer with a StepLR scheduler, which reduces the learning rate by a factor of 0.96 every 100 steps. The initial learning rate is set to 0.02, and the model is trained for 1000 epochs with a batch size of 32.

TSM: The TSM architecture [48] is used with default settings. The initial learning rate is 1×10−41 \times10^{-4}, and weight decay is set to 1×10−41 \times10^{-4}. The gradient clipping norm is 1×10−21 \times10^{-2}. Adam optimizer is used with β2=0.98\beta_{2} = 0.98, and the batch size is set to 8.

Additional Results

We evaluate LDSolver’s generalization capability across both forced and shear flow configurations under varying initial conditions (ICs), Reynolds numbers (ReRe), and diffusion coefficients (DD). Figure S5 demonstrates consistent performance preservation across these parameter variations for the shear flow.

Generalization performance of shear flow

Figure S5. Generalization performance of shear flow. Time steps kk are shown horizontally: (a) Trained on Re=1000\mathrm{Re} = 1000, D=0.001D = 0.001 and tested on Re=2000\mathrm{Re} = 2000, D=0.001D = 0.001; (b) Trained on Re=1000\mathrm{Re} = 1000, D=0.001D = 0.001 and tested on Re=1000\mathrm{Re} = 1000, D=0.002D = 0.002. The ground truth is obtained from DNS at a resolution of 2048×10242048 \times1024, while the predictions are from LDSolver at a resolution of 128×64128 \times64.

References

  1. [28]Xin-Yang Liu, Min Zhu, Lu Lu, Hao Sun, and Jian-Xun Wang. 2024. Multi-resolution partial differential equations preserved learning framework for spatiotemporal dynamics. Communications Physics 7, 1 (2024), 31.DOI
  2. [29]Zichao Long, Yiping Lu, and Bin Dong. 2019. PDE-Net 2.0: Learning PDEs from data with a nonsymbolic hybrid deep network. J. Comput. Phys. 399 (2019), 108925.DOI
  3. [30]Zichao Long, Yiping Lu, Xianzhong Ma, and Bin Dong. 2018. PDE-Net: Learning PDEs from data. In International Conference on Machine Learning. 3208–3216.arxiv.org/abs/1710.09668
  4. [31]Lu Lu, Pengzhan Jin, Guofei Pang, Zhongqiang Zhang, and George Em Karniadakis. 2021. Learning Nonlinear Operators via DeepONet Based on the Universal Approximation Theorem of Operators. Nature Machine Intelligence 3, 3 (2021), 218–229.
  5. [32]Yiping Lu, Aoxiao Zhong, Quanzheng Li, and Bin Dong. 2018. Beyond finite layer neural networks: Bridging deep architectures and numerical differential equations. In International Conference on Machine Learning. 3276–3285.arxiv.org/abs/1710.10121
  6. [33]John E Mattsson. 2023. An introduction to ansys fluent 2023. SdC Publications.
  7. [34]Fadl Moukalled, Luca Mangani, and Marwan Darwish. 2016. The Finite Volume Method. Springer.DOI
  8. [35]Tobias Pfaff, Meire Fortunato, Alvaro Sanchez-Gonzalez, and Peter Battaglia. 2021. Learning meshbased simulation with graph networks. In International Conference on Learning Representations.arxiv.org/abs/2010.03409
  9. [36]Michael Poli, Stefano Massaroli, Atsushi Yamashita, Hajime Asama, and Jinkyoo Park. 2020. Hypersolvers: Toward fast continuous-depth models. Advances in Neural Information Processing Systems 33 (2020), 21105–21117.arxiv.org/abs/2007.09601
  10. [37]Maziar Raissi, Paris Perdikaris, and George E Karniadakis. 2019. Physics-Informed Neural Networks: A Deep Learning Framework for Solving Forward and Inverse Problems Involving Nonlinear Partial Differential Equations. J. Comput. Phys. 378 (2019), 686–707.DOI
  11. [38]Maziar Raissi, Alireza Yazdani, and George Em Karniadakis. 2020. Hidden Fluid Mechanics: Learning Velocity and Pressure Fields from Flow Visualizations. Science 367, 6481 (2020), 1026–1030.DOI
  12. [39]Chengping Rao, Pu Ren, Yang Liu, and Hao Sun. 2022. Discovering Nonlinear PDEs from Scarce Data with Physics-Encoded Learning. In International Conference on Learning Representations.arxiv.org/abs/2201.12354
  13. [40]Chengping Rao, Pu Ren, Qi Wang, Oral Buyukozturk, Hao Sun, and Yang Liu. 2023. Encoding physics to learn reaction–diffusion processes. Nature Machine Intelligence 5, 7 (2023), 765–779.arxiv.org/abs/2106.04781
  14. [41]Chengping Rao, Hao Sun, and Yang Liu. 2021. Physics-Informed Deep Learning for Computational Elastodynamics Without Labeled Data. Journal of Engineering Mechanics 147, 8 (2021), 04021043.arxiv.org/abs/2006.08472
  15. [42]Pu Ren, Chengping Rao, Yang Liu, Zihan Ma, Qi Wang, Jian-Xun Wang, and Hao Sun. 2023. Physics-informed deep super-resolution for spatiotemporal data. J. Comput. Phys. 492 (2023), 112438.arxiv.org/abs/2208.01462
  16. [43]Pu Ren, Chengping Rao, Yang Liu, Jian-Xun Wang, and Hao Sun. 2022. PhyCRNet: Physics-informed convolutional-recurrent network for solving spatiotemporal PDEs. Computer Methods in Applied Mechanics and Engineering 389 (2022), 114399.DOI
  17. [44]Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter Battaglia. 2020. Learning to simulate complex physics with graph networks. In International Conference on Machine Learning. 8459–8468.
  18. [45]Tapio Schneider, João Teixeira, Christopher S Bretherton, Florent Brient, Kyle G Pressel, Christoph Schär, and A Pier Siebesma. 2017. Climate goals and computing the future of clouds. Nature Climate Change 7, 1 (2017), 3–5.DOI
  19. [46]J S Shang. 2009. Computational fluid dynamics application to aerospace science. The Aeronautical Journal 113, 1148 (2009), 619–632.DOI
  20. [47]Jeffrey P Slotnick, Abdollah Khodadoust, Juan Alonso, David Darmofal, William Gropp, Elizabeth Lurie, and Dimitri J Mavriplis. 2014. CFD vision 2030 study: a path to revolutionary computational aerosciences. Technical Report.
  21. [48]Zhiqing Sun, Yiming Yang, and Shinjae Yoo. 2023. A neural pde solver with temporal stencil modeling. In International Conference on Machine Learning. PMLR, 33135–33155.arxiv.org/abs/2302.08105
  22. [49]Zhiqing Sun, Yiming Yang, and Shinjae Yoo. 2023. A neural PDE solver with temporal stencil modeling. In International Conference on Machine Learning. 33135–33155.arxiv.org/abs/2302.08105
  23. [50]Kejun Tang, Jiayu Zhai, Xiaoliang Wan, and Chao Yang. 2024. Adversarial Adaptive Sampling: Unify PINN and Optimal Transport for the Approximation of PDEs. In International Conference on Learning Representations.arxiv.org/abs/2305.18702
  24. [51]Alasdair Tran, Alexander Mathews, Lexing Xie, and Cheng Soon Ong. 2022. Factorized Fourier neural operators. In International Conference on Learning Representations.arxiv.org/abs/2111.13802
  25. [52]Kiwon Um, Robert Brand, Yun Raymond Fei, Philipp Holl, and Nils Thuerey. 2020. Solver-in-the-loop: Learning from differentiable physics to interact with iterative pde-solvers. Advances in Neural Information Processing Systems 33 (2020), 6111–6122.arxiv.org/abs/2007.00016
  26. [53]Qi Wang, Pu Ren, Hao Zhou, Xin-Yang Liu, Zhiwen Deng, Yi Zhang, Ruizhi Chengze, Hongsheng Liu, Zidong Wang, Jian-Xun Wang, et al. 2024. P²C² Net: PDE-Preserved Coarse Correction Network for Efficient Prediction of Spatiotemporal Dynamics. Advances in Neural Information Processing Systems (2024).arxiv.org/abs/2411.00040
  27. [54]Rui Wang, Karthik Kashinatham, Mustafa Mustafa, Adrian Albert, and Rose Yu. 2020. Towards Physics-Informed Deep Learning for Turbulent Flow Prediction. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. 1457–1466.
  28. [55]Rui Wang, Robin Walters, and Rose Yu. 2021. Incorporating symmetry into deep dynamics models for improved generalization. In International Conference on Learning Representations.arxiv.org/abs/2002.03061
  29. [56]Haixu Wu, Huakun Luo, Haowen Wang, Jianmin Wang, and Mingsheng Long. 2024. Transolver: A fast transformer solver for PDEs on general geometries. International Conference on Machine Learning (2024).arxiv.org/abs/2402.02366
  30. [57]Mengtao Yan, Zhiming Zhang, Shangce Gao, and Shuyang Cao. 2022. Predicting aerodynamic pressure on a square cylinder from wake velocity field by masked gated recurrent unit model. Physics of Fluids 34, 11 (2022).DOI
  31. [58]Bocheng Zeng, Qi Wang, Mengtao Yan, Yang Liu, Ruizhi Chengze, Yi Zhang, Hongsheng Liu, Zidong Wang, and Hao Sun. 2025. PhyMPGN: Physics-encoded Message Passing Graph Network for spatiotemporal PDE systems. International Conference on Learning Representations (2025).arxiv.org/abs/2410.01337
  32. [59]Ruiyang Zhang, Yang Liu, and Hao Sun. 2020. Physics-Informed Multi-LSTM Networks for Metamodeling of Nonlinear Structures. Computer Methods in Applied Mechanics and Engineering 369 (2020), 113226.DOI
  33. [60]Jiawei Zhuang, Dmitrii Kochkov, Yohai Bar-Sinai, Michael P Brenner, and Stephan Hoyer. 2021. Learned discretizations for passive scalar advection in a two-dimensional turbulent flow. Physical Review Fluids 6, 6 (2021), 064605.DOI
  34. [61]Olek C Zienkiewicz, Robert L Taylor, and Jian Z Zhu. 2005. The Finite Element Method: Its Basis and Fundamentals. Elsevier.

Paper details

vlnc:W_6mxtbph6
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents