NeuralFVM: Neural-physics-based Finite Volume Method for Turbulent Flows Using the $k$-$\omega$ Model

This paper presents NeuralFVM, a GPU-accelerated neural-physics solver that reformulates the finite volume method with the $k$-$\omega$ turbulence model using local tensor operations and operator-splitting to achieve significant speedups while maintaining accuracy comparable to commercial CFD software.

The Gist

Imagine you are trying to predict how smoke will drift through a crowded room, or how hot air will swirl around a computer server. This is the job of Computational Fluid Dynamics (CFD). Traditionally, solving these problems is like trying to count every single grain of sand on a beach while the tide is coming in—it takes massive computers, huge amounts of time, and a lot of patience.

This paper introduces a new tool called NeuralFVM. Think of it as a "smart, super-fast translator" that teaches a computer to understand fluid physics using the same language that modern Artificial Intelligence (AI) speaks.

Here is a breakdown of how it works, using simple analogies:

1. The Old Way vs. The New Way

• The Old Way (Traditional CFD): Imagine trying to solve a giant jigsaw puzzle where every piece is connected to every other piece. To move one piece, you have to recalculate the position of the whole board. This requires building a massive, complex "global map" (a matrix) that is slow to update, especially on standard computer processors (CPUs).
• The New Way (NeuralFVM): Instead of looking at the whole puzzle at once, NeuralFVM looks at the puzzle neighbor by neighbor. It uses a technique called Finite Volume Method (FVM), but it translates the math into "local operations."
  • The Analogy: Imagine a game of "telephone" in a crowded stadium. Instead of one person shouting to the whole stadium, everyone only whispers to the person standing right next to them. If everyone does this simultaneously, the message spreads incredibly fast. NeuralFVM does this with fluid physics, allowing the computer to process millions of "neighbors" at the exact same time.

2. Speaking the Language of AI (The "Neural" Part)

Usually, AI (like the neural networks that power image recognition) is great at spotting patterns in data but bad at following strict physical laws. Conversely, traditional physics solvers follow the laws perfectly but are rigid and hard to combine with AI.

NeuralFVM bridges this gap by rewriting the laws of physics (like how air moves and heat spreads) as convolutions.

• The Analogy: Think of a convolution as a "stencil" or a "cookie cutter." In this system, the computer uses a specific cookie cutter to slice through the data, calculating how a value changes based only on its immediate neighbors.
• Because these "cookie cutters" are the same tools AI uses to recognize faces in photos, the physics solver can now run on GPUs (Graphics Processing Units). GPUs are like having 10,000 tiny workers instead of one big boss, making the calculation 19 to 46 times faster than before.

3. Taming the "Stiff" Problem

Turbulence is chaotic. In the math behind it, there are "destruction terms" (parts of the equation that try to cancel out energy). These are "stiff," meaning they are very sensitive. If you try to calculate them too quickly, the numbers go wild and the simulation crashes (like a car spinning out of control).

• The Analogy: Imagine trying to balance a broom on your hand. If you just react to the broom falling (explicit method), you might be too slow and drop it. If you try to predict exactly where it will fall and move your hand instantly (implicit method), it's mathematically hard to do without a complex global map.
• The Solution: The authors used a strategy called Operator Splitting. They split the problem into two parts:
  1. The Easy Part: The smooth, predictable flow (handled quickly).
  2. The Tricky Part: The stiff, sensitive destruction terms. They handle this part "semi-implicitly," which is like gently guiding the broom back to balance without needing to calculate the entire room's physics at once. This keeps the simulation stable without slowing it down.

4. What Did They Prove?

The team tested their new "NeuralFVM" solver against the industry standard, ANSYS Fluent (a very expensive, commercial software used by engineers worldwide).

• The Test: They simulated air flowing through channels, around blocks, and even inside a room (a benchmark test called Annex 20).
• The Result: The NeuralFVM results were almost identical to the commercial software. It got the speed, temperature, and turbulence patterns right.
• The Bonus: Because it's built on AI tools, it's fully differentiable.
  • The Analogy: Traditional solvers are like a black box: you put air in, and you get a picture out. If you want to know how to change the shape of a wall to make the air flow better, you have to guess and check thousands of times. NeuralFVM is like a transparent box where you can ask, "If I move this wall 1 inch left, how does the air change?" and it tells you instantly. This opens the door for AI to design better engines, buildings, and cars automatically.

Summary

NeuralFVM is a new way to simulate fluid flow that:

1. Runs 20-40x faster by using graphics cards (GPUs) instead of standard processors.
2. Talks the same language as AI, making it easy to combine physics with machine learning.
3. Solves the "stiff" math problems of turbulence without crashing.
4. Is accurate, matching the results of the world's best commercial software.

It's a step toward a future where we can design complex systems (like cooling data centers or optimizing car aerodynamics) in minutes rather than days, using AI to do the heavy lifting.

Technical Summary

1. Problem Statement

Computational Fluid Dynamics (CFD) is essential for analyzing fluid flow and heat transfer but remains computationally expensive, particularly for turbulent flows. While hardware acceleration via Graphics Processing Units (GPUs) has improved speed, traditional CFD solvers often lack versatility and are difficult to integrate with modern Machine Learning (ML) workflows.
Specific challenges include:

• Turbulence Modeling: Reynolds-Averaged Navier-Stokes (RANS) models, such as the standard $k-\omega$ model, involve stiff destruction terms in transport equations. These terms can cause numerical instability (negative turbulence values) if not handled implicitly.
• Implicit vs. Local Operations: Traditional implicit methods require global matrix assembly and inversion, which breaks the "locality" required for efficient GPU parallelism and differentiable programming frameworks (like PyTorch).
• Integration Gap: Existing neural-physics solvers often focus on Direct Numerical Simulation (DNS) or Large Eddy Simulation (LES), which are too costly for industrial applications, or rely on data-driven approaches that lack physical consistency.

2. Methodology

The authors propose NeuralFVM, a neural-physics solver based on the Finite Volume Method (FVM) implemented entirely using local tensor operations compatible with deep learning libraries (PyTorch).

Core Formulation

• Tensor Reformulation: The governing equations (Continuity, Momentum, Energy, and $k-\omega$ turbulence transport) are reformulated as sequences of local tensor operations. Instead of global matrix assembly, spatial derivatives and interpolations are performed using convolutional kernels (stencil operators).
• Convolution vs. Shift: To optimize performance, the authors implement these convolutional operations using tensor slicing and shifting rather than standard convolution layers. This reduces computational overhead while maintaining numerical equivalence.
• Boundary Conditions: Implemented via "ghost cells" using padding operations. Both external boundaries and internal solid interfaces (embedded blocks) are handled by extracting, shifting, and aggregating neighboring fluid values.

Handling Stiffness in Turbulence Models

A critical innovation is the treatment of the stiff destruction terms ($Y_k$ and $Y_\omega$) in the $k-\omega$ equations:

• Operator Splitting: The transport equations are split into "destruction" terms and "rest" terms.
• Semi-Implicit Treatment: The stiff destruction terms are advanced using a semi-implicit Euler scheme. This allows for an unconditionally stable update that guarantees positive turbulence values without requiring global matrix inversion.
  • Update formula: $k^{n+1} = k^n / (1 + \Delta t \cdot \beta^* f_{\beta^*} \omega^n)$.
• Explicit Treatment: The remaining terms (convection, diffusion, generation) are advanced using explicit Runge-Kutta schemes.
• Time Integration: A Strang splitting strategy is employed, alternating between half-steps of the semi-implicit destruction solver and full steps of the explicit solver.

Pressure-Velocity Coupling

• Geometric Multigrid (GMG): The pressure Poisson equation is solved using a geometric multigrid algorithm reformulated as a neural network architecture (similar to U-Net).
• Fixed Weights: Unlike typical neural networks, the convolutional kernels for smoothing and inter-grid transfer (restriction/prolongation) are derived analytically from the governing equations, not learned from data.
• Algorithm: The solver uses a V-cycle approach where residuals are restricted to coarser grids, smoothed via Jacobi iterations, and prolonged back to the fine grid.

3. Key Contributions

1. GPU-Native RANS Solver: Development of a fully differentiable, GPU-accelerated RANS solver specifically for the standard $k-\omega$ model, achieving significant speedups over CPU counterparts.
2. Local Tensor Operations: Elimination of global matrix assembly. The entire solver, including the stiff turbulence terms and multigrid pressure solver, operates via local tensor operations, enabling seamless integration with ML workflows.
3. Stiffness Handling Strategy: Introduction of an operator-splitting strategy that treats stiff destruction terms semi-implicitly, ensuring numerical stability and positivity of turbulence variables without sacrificing the locality required for GPU efficiency.
4. Differentiability: The framework is fully differentiable, allowing for automatic computation of gradients with respect to model parameters or boundary conditions, facilitating gradient-based optimization and inverse design.
5. Hardware Flexibility: The code can run on both CPU and GPU architectures with minimal modification (single configuration variable change).

4. Results and Validation

The NeuralFVM solver was validated against the commercial CFD software ANSYS Fluent 2025 R2 and experimental data across several scenarios:

• Channel Flow Verification:
  • Open Channel & Blocked Channel: Simulations of flow over a cube and in a channel with blocks showed close agreement with Fluent in velocity ($V$), temperature ($T$), turbulent kinetic energy ($k$), and specific dissipation rate ($\omega$).
  • Accuracy: The solver accurately captured sharp gradients near walls and wake recovery, with minor discrepancies attributed to differences in near-wall treatment and time integration methods.
• Complex Geometries:
  • Multiple Aligned & Staggered Blocks: Successfully reproduced complex flow interactions, wake formations, and thermal transport for arrays of blocks of varying sizes and arrangements.
  • Indoor Airflow (Annex 20): Validated against the IEA Annex 20 benchmark. The solver reproduced experimental streamlines and vertical velocity profiles ($x=3m, 6m$) with high fidelity, matching results from standard $k-\omega$ implementations in CFX and Star-CCM+.
• Performance (Speedup):
  • GPU vs. CPU: The GPU implementation achieved a 19x to 46x speedup compared to the CPU version across different mesh sizes (up to ~33 million cells).
  • Shift vs. Convolution: Replacing standard convolution operations with tensor shift operations reduced runtime by approximately 50%.

5. Significance and Future Outlook

• Bridging CFD and ML: NeuralFVM provides a robust foundation for data-driven turbulence modeling, inverse design, and gradient-based optimization by offering a differentiable, physics-consistent solver.
• Efficiency: The ability to run complex RANS simulations with near-commercial accuracy on GPUs at a fraction of the computational cost opens new possibilities for real-time simulation and high-throughput design exploration.
• Limitations & Future Work: The current study is limited to uniform structured grids. Future work aims to extend the framework to unstructured grids, higher Reynolds number flows, and more advanced turbulence models, as well as integrating learning-based closure strategies.

In summary, NeuralFVM represents a significant step forward in "neural-physics" computing, successfully combining the physical rigor of the Finite Volume Method with the computational efficiency and differentiability of deep learning frameworks for turbulent flow simulation.