Physics-Constrained Neural Closure for Lattice Boltzmann Large-Eddy Simulation

This paper presents a physics-constrained neural network closure for Lattice Boltzmann Large-Eddy Simulation that, by integrating data-driven learning with physical constraints like rotational equivariance and energy transfer matching, achieves superior statistical accuracy and production-ready performance compared to traditional Smagorinsky baselines.

The Gist

Imagine you are trying to predict the weather. You have a supercomputer, but it's too slow to simulate every single molecule of air in a storm. So, instead, you divide the sky into big, chunky blocks (like a giant 3D grid) and try to predict the weather for each block.

The problem is that inside each big block, there are tiny, chaotic swirls of wind (turbulence) that your computer can't see because the blocks are too big. In the old days, scientists used simple rules of thumb to guess what those tiny swirls were doing. They'd say, "Oh, the wind is moving fast, so it must be losing energy," kind of like assuming a car always slows down when you take your foot off the gas.

The Problem with the Old Rules:
These old rules were too simple. They missed the "backscatter" effect. Think of a river: usually, the big currents push the tiny ripples forward. But sometimes, a tiny whirlpool can actually kick energy back into the big current, speeding it up. The old rules couldn't do this; they only knew how to slow things down. This made their predictions a bit dull and inaccurate.

The New Solution: A "Smart Assistant" for Fluids
This paper introduces a new way to handle these invisible tiny swirls using Artificial Intelligence (AI). But instead of just letting the AI guess randomly, the authors built a "smart assistant" that follows the strict laws of physics.

Here is how they did it, using some simple analogies:

1. The Training: Teaching the AI to "Feel" the Flow

The researchers didn't just show the AI random pictures. They created a "perfect" simulation of a turbulent fluid (like a super-detailed video game of water) and then blurred it to look like the chunky blocks the computer can actually handle.

• The Input: They taught the AI to look at two things: Stretching (how the fluid is being pulled apart) and Spinning (how it's swirling).
• The Output: The AI learned to predict exactly what those invisible tiny swirls are doing to the big blocks.

2. The "Physics-Constraint" Rulebook

Usually, AI can be a bit wild and make up things that look real but break the laws of physics. The authors added a special "rulebook" to the training:

• Rotational Symmetry: If you rotate the fluid 90 degrees, the AI's answer should rotate with it, not stay the same.
• Energy Balance: The AI must respect how energy moves. It can't invent energy out of thin air.
• The "Backscatter" Bonus: Crucially, the AI was allowed to say, "Hey, sometimes the tiny swirls push the big flow faster." This is the backscatter effect the old rules missed.

3. The Hybrid Engine: The "Engine and the Steering Wheel"

This is the cleverest part. The AI predicts a complex force, but the computer simulation (called Lattice Boltzmann) is built to handle simple "friction" (viscosity) very well, but struggles with complex forces.

So, the authors split the AI's prediction into two parts:

• The Engine (Dissipative Part): If the AI says the flow is losing energy (friction), they feed that directly into the computer's "friction engine." This is easy for the computer to handle.
• The Steering Wheel (Residual Part): If the AI says there's a weird, complex push or a "kick" (backscatter) that isn't just friction, they apply it as a gentle "nudge" or force. This allows the simulation to keep the complex, chaotic behavior without breaking the computer.

4. The Results: Faster and Smarter

They tested this new "Smart Assistant" against the old rules.

• Accuracy: It predicted the chaotic swirls much better, capturing those tricky "kicks" (backscatter) that the old rules ignored.
• Speed: They managed to run this AI on a super-fast graphics card (GPU) using a standard format (ONNX). It was almost as fast as the old, simple rules!
• Transferability: They trained it on a simple, swirling fluid (like a mixer), and then tried it on a completely different flow (air moving over a wall in a pipe). Without retraining, it worked surprisingly well, suggesting the AI learned the essence of turbulence, not just the specific test case.

The Bottom Line

Think of this paper as upgrading a car's navigation system.

• Old System: "Turn left because the map says so." (Simple, reliable, but misses shortcuts).
• New System: "Turn left, but also accelerate because I see a tailwind coming from a side street, and I know the physics of the road allows it."

They built a navigation system for fluids that is smart enough to see the invisible details, disciplined enough to follow physics, and fast enough to run in real-time. This could help engineers design better airplanes, predict weather more accurately, and understand how blood flows through our veins, all without needing a supercomputer the size of a city.

Technical Summary

1. Problem Statement

Large-Eddy Simulation (LES) is essential for studying turbulent flows at high Reynolds numbers where Direct Numerical Simulation (DNS) is computationally prohibitive. However, LES requires a Subgrid-Scale (SGS) model to represent the effects of unresolved scales.

• Limitations of Classical Models: Traditional models like the Smagorinsky model rely on an eddy-viscosity assumption. While robust, they often suppress backscatter (energy transfer from small to large scales) and struggle to capture complex stress anisotropy.
• Limitations of Existing ML Models: While data-driven ML closures have shown promise in continuum Navier-Stokes solvers, their application to the Lattice Boltzmann Method (LBM) is limited. LBM has a unique kinetic formulation where stress and pressure are locally available, but coupling explicit stress tensors into the LBM evolution equation without destabilizing the solver remains a challenge.
• Core Question: Can a compact, physics-constrained Machine Learning (ML) model accurately predict the full SGS stress tensor and be coupled stably and efficiently into an LBM solver to improve accuracy over classical viscosity-only baselines?

2. Methodology

A. Data Generation and Features

• Training Data: Generated from LBM DNS of Forced Homogeneous Isotropic Turbulence (FHIT) on grids ranging from $192^3$ to $256^3$.
• Filtered-Downsampled (FD) Approach: DNS data is filtered and downsampled to create paired datasets of resolved fields and exact SGS stresses at multiple filter widths ($\Delta$).
• Input Features: The model uses 9 macroscopic derivative features:
  • 6 components of the symmetric strain-rate tensor ($S_{ij}$).
  • 3 components of the vorticity vector ($\omega$).
• Normalization: To ensure generalization across different filter widths, a $\Delta$-normalization is applied to the derivative inputs ($S^* = \Delta S$), making them scale-invariant.

B. Neural Network Architecture

• Structure: A compact, fully connected feedforward network with a 9 $\to$ 64 $\to$ 64 $\to$ 6 topology.
• Output: Predicts the 6 independent components of the SGS stress tensor ($\tau_{ij}^{ML}$).
• Activation: Uses GELU (Gaussian Error Linear Unit) activation functions.
• Parameters: Approximately 5,190 trainable parameters, ensuring low computational overhead.

C. Physics-Constrained Training

The loss function combines data fidelity with physical constraints to ensure the model respects turbulence physics:
$$\mathcal{L} = \mathcal{L}_{MSE} + \lambda_\pi \mathcal{L}_\pi + \lambda_{eq} \mathcal{L}_{eq} + \lambda_{divF} \mathcal{L}_{divF}$$

1. $\mathcal{L}_{MSE}$: Mean Squared Error between predicted and true SGS stress.
2. $\mathcal{L}_\pi$ (Energy Transfer): Matches the SGS energy transfer rate ($\Pi = -\tau_{ij}S_{ij}$). Crucially, this allows negative $\Pi$ (backscatter) without enforcing non-negativity constraints.
3. $\mathcal{L}_{eq}$ (Rotational Equivariance): Enforces that the stress tensor transforms correctly under discrete cube rotations, ensuring frame invariance.
4. $\mathcal{L}_{divF}$ (Divergence-Free Forcing): Penalizes the divergence of the implied SGS forcing term to ensure compatibility with the solver's forcing formulation.

D. Hybrid Coupling Strategy (The Core Innovation)

To integrate the predicted stress into the LBM solver without destabilizing it, the authors propose a split strategy:

1. Dissipative Part: The component of the stress aligned with the strain rate is converted into an effective viscosity ($\nu_{eff}$). This modifies the relaxation rate ($s_\nu$) in the MRT-LBM collision operator, naturally handling dissipation and backscatter (via negative viscosity values).
2. Residual Part: The remaining anisotropic, non-dissipative stress component is applied as an explicit body force using the Guo forcing scheme.
3. Deviatoric Projection: A traceless projection is applied post-inference to ensure the stress tensor is physically consistent with incompressible flow.

E. Deployment

• The model is exported to ONNX Runtime.
• Integrated into a production Fortran/OpenACC LBM solver.
• Inference is performed on NVIDIA A100 GPUs with batched processing to maximize throughput.

3. Key Contributions

1. First Explicit-Stress ML Closure for LBM: Demonstrates that a full SGS stress tensor can be predicted from local derivatives and coupled to LBM, moving beyond simple relaxation-time modifications.
2. Hy dissipative/Residual Split: Introduces a novel coupling mechanism that separates the stress into a viscosity-like part (for stability and backscatter) and a forcing part (for anisotropy), enabling stable long-time LES.
3. Physics-Constrained Training: Successfully integrates rotational equivariance and energy-transfer matching directly into the training loop, improving physical consistency.
4. Production-Ready Performance: Achieves throughput comparable to dynamic Smagorinsky models (within ~0.6% overhead) via ONNX Runtime, proving feasibility for practical applications.
5. Transferability: Demonstrates that a model trained only on homogeneous isotropic turbulence (FHIT) can successfully simulate turbulent channel flow without retraining.

4. Results

A Priori Validation (Static)

• Accuracy: The model achieves high correlation ($\rho \approx 0.90-0.95$) and $R^2 \approx 0.70-0.84$ across various filter widths and viscosities.
• Backscatter: The Probability Density Function (PDF) of energy transfer ($\Pi$) closely matches DNS, capturing both the forward transfer peak and the negative tail (backscatter). In contrast, the Smagorinsky model fails to predict backscatter entirely (zero probability for $\Pi < 0$).

A Posteriori Validation (Dynamic LES)

• Statistical Fidelity: In FHIT rollouts, the ML-LES model reproduces stress distributions and energy transfer statistics significantly better than both static and dynamic Smagorinsky baselines.
• Energy Balance: The ML-coupled LES maintains a much tighter energy balance (closer to DNS) compared to viscosity-only models, which exhibit larger imbalances.
• Robustness: The model performs consistently when coupled with both MRT and BGK collision operators, despite being trained on MRT data.
• Channel Flow Transfer: When applied to turbulent channel flow ($Re_\tau \approx 160$) without retraining, the model accurately predicts mean velocity profiles, RMS fluctuations, and Reynolds shear stress, matching DNS benchmarks closely.

Performance

• Throughput: The ONNX-coupled ML-LES achieves 71.155 MLUP/s (Million Lattice Updates Per Second), compared to 71.592 MLUP/s for the dynamic Smagorinsky baseline. The overhead is negligible (~0.6%).

5. Significance

This work bridges a critical gap between advanced data-driven turbulence modeling and the Lattice Boltzmann Method.

• Scientific Impact: It proves that explicit stress prediction is viable in LBM, overcoming the historical reliance on viscosity-only closures. The ability to capture backscatter and anisotropy without sacrificing stability is a major advancement.
• Practical Impact: By demonstrating that a model trained on simple isotropic turbulence can transfer to complex wall-bounded flows (channel flow), the paper suggests that ML closures can be more generalizable than previously thought, provided the feature representation and normalization are handled correctly.
• Engineering Impact: The successful deployment via ONNX Runtime with near-zero performance penalty indicates that such ML-enhanced solvers are ready for industrial-scale simulations, offering a path to higher-fidelity LES without the prohibitive cost of DNS.