Kinetic closure of turbulence

This paper introduces a kinetic closure for the filtered Boltzmann-BGK equation that naturally incorporates turbulent subfilter stresses and diffusion without requiring scale separation or explicit modeling, demonstrating improved stability and reduced dissipation in lattice Boltzmann simulations compared to the Smagorinsky model.

The Gist

Imagine you are trying to predict the weather. The atmosphere is a chaotic mess of swirling winds, tiny eddies, and massive storms. To simulate this on a computer, you have to divide the sky into a grid of boxes.

The Problem: The "Blurry" Picture
If your boxes are too big, you can't see the small swirls. You only see the big picture. In physics, this is called filtering. When you look at the big picture, the small swirls don't just disappear; they still affect the big picture. They act like invisible hands pushing and pulling the air.

In traditional weather models (based on the Navier-Stokes equations), scientists have to guess how these invisible hands work. They use a "crutch" called a turbulence model (like the Smagorinsky model). It's like saying, "I can't see the small swirls, so I'll just assume they act like thick honey to slow things down." This works okay, but it's a guess, and it often makes the simulation too "sticky" (too much dissipation), smoothing out the interesting details.

The New Idea: The Kinetic Closure
This paper introduces a new way to handle those invisible hands, using a different perspective called Kinetic Theory.

Instead of looking at the air as a continuous fluid (like water in a river), this method looks at the air as a crowd of billions of individual particles (like a massive dance floor of people).

• The Old Way (Fluid): You try to guess how the crowd moves as a whole.
• The New Way (Kinetic): You track the "dance moves" of the particles.

The Magic Trick: The "Collision" Rule
In this particle world, particles bump into each other. This is called a "collision."

• In a calm wind, particles bounce around and settle into a predictable pattern (like a calm dance).
• In a storm, the "dance" gets chaotic.

The authors realized that when you zoom out (filter) to see the big picture, the "dance" of the particles that you can't see (the subfilter scales) still needs to be accounted for.

In traditional models, they try to fix the big picture by adding extra rules. But here, the authors changed the rules of the dance floor itself.

They introduced a new "collision rule" for the particles. Think of it like this:

• Standard Rule: "If you bump into someone, bounce back to your average speed."
• New Rule: "If you bump into someone, bounce back to your average speed, PLUS a little extra nudge that represents the chaotic energy of the tiny swirls you can't see."

Why is this better?

1. No Crutches: You don't need to guess how "thick" the air is. The model naturally figures out how the invisible swirls transfer energy because it's built into the particle physics.
2. Less "Sticky": Because it doesn't rely on a guess that over-damps the system, the simulation stays lively. It keeps the swirls and eddies alive longer, which is more realistic.
3. Self-Correcting: The model uses the speed differences (gradients) in the wind to automatically figure out how much "extra nudge" is needed. If the wind is smooth, the nudge is zero. If the wind is chaotic, the nudge kicks in.

The Results: A Better Dance
The authors tested this new rule on two famous turbulent scenarios:

1. The Taylor-Green Vortex: A swirling vortex that breaks down into smaller and smaller swirls.
2. The Mixing Layer: Two streams of air sliding past each other, creating a chaotic boundary.

They compared their new "Kinetic Closure" against the old "Smagorinsky" method.

• The Old Method: Like trying to run through molasses. It slowed the simulation down too much and killed the interesting details.
• The New Method: Like running on a well-oiled track. It was more stable, didn't lose energy as quickly, and matched the "perfect" (but impossible to calculate) simulation much better.

The Takeaway
This paper is like upgrading the operating system of a video game. Instead of using a clumsy patch to fix the physics of the wind, they rewrote the core engine to understand the wind at a particle level. This allows computers to simulate turbulence more accurately, with less "fuzziness," and without needing to guess the rules of the game. It's a step toward simulating nature not just as a blurry picture, but as the complex, energetic dance it truly is.

Technical Summary

1. Problem Statement

Turbulent flows are characterized by chaotic, multiscale dynamics that are computationally prohibitive to resolve fully via Direct Numerical Simulation (DNS) for most engineering applications. Consequently, Large Eddy Simulation (LES) is widely used, where governing equations are filtered to resolve large scales while modeling the effects of unresolved (subfilter) scales.

• Limitations of Classical Approaches: In the filtered Navier–Stokes equations (NSE), the primary modeling challenge is the subfilter-scale (SFS) stress tensor (convective commutation error). This is typically modeled using eddy-viscosity assumptions (e.g., Smagorinsky model), which often introduce excessive numerical dissipation and require ad-hoc tuning. Furthermore, classical NSE closures assume a linear viscous stress tensor, explicitly neglecting diffusive commutation errors (subfilter diffusion), which are physically present but mathematically hidden by the linearity of Newton's constitutive laws.
• Limitations of Existing Kinetic Approaches: Previous attempts to model turbulence using the Boltzmann–BGK equation (BGK-BE) have relied on heuristic assumptions, such as renormalizing the collision operator via an effective relaxation time, relying on macroscopic eddy-viscosity concepts, or requiring strict scale separation between filter width and the Knudsen number. These approaches often fail to capture the intrinsic coupling between resolved and unresolved scales without external transport equations (like $k-\epsilon$).

The authors aim to develop a Kinetic Closure (KC) that naturally incorporates subfilter stresses and diffusion without explicit modeling ansatzes, scale separation requirements, or auxiliary transport equations.

2. Methodology

The authors propose a novel closure for the filtered Boltzmann–BGK equation (FBGK-BE) by exploiting the fundamental differences between kinetic and hydrodynamic descriptions of turbulence.

Theoretical Framework

1. Filtered Kinetic Equation: The authors start with the nondimensional BGK-BE and apply a spatial filter. Unlike the NSE, the linear transport terms in the BGK-BE do not generate convective commutation errors. Instead, the commutation error arises entirely within the collision operator, which is diffusive in nature.
2. Generalized Collision Operator:
   • Standard BGK models assume the distribution function $f$ relaxes to a local equilibrium $f^{(0)}$ based on conserved moments.
   • In the filtered case, the equilibrium $f^{(0)}$ cannot be computed directly from filtered moments because it hides subfilter fluctuations ($f_{sgs}$).
   • The authors introduce a generalized collision operator that explicitly accounts for the relaxation of the subfilter distribution $f_{sgs}$ toward zero with a distinct frequency $\omega_t$:
     $$\Omega^* \equiv -\omega^*(f - f^{(0)}) - \omega_t f_{sgs}$$
   • This formulation treats the subfilter stress and diffusion as intrinsic parts of the kinetic relaxation process, rather than external source terms.

Chapman–Enskog (CE) Expansion

To derive the macroscopic behavior and close the system:

• The authors perform a CE expansion on the FBGK-BE. Crucially, they do not separate turbulent fluctuations from the mean flow (a common assumption in RANS/LES). Instead, they separate diffusive and convective processes, consistent with standard kinetic theory.
• Derivation of $f^{(1)}$ and $f_{sgs}$:
  • The first-order non-equilibrium distribution $f^{(1)}$ is derived in terms of velocity gradients.
  • The subfilter distribution $f_{sgs}$ is defined as the residual: $f_{sgs} \approx f - f^{(0)} - \epsilon f^{(1)}$.
  • This derivation shows that the SFS stress tensor ($\tau_{sgs}$) is naturally captured by the moments of $f_{sgs}$ and depends directly on velocity gradients, eliminating the need for a Smagorinsky-type structural assumption.
• Modeling $\omega_t$: The subfilter relaxation frequency $\omega_t$ is modeled using dimensional analysis similar to the $k-\epsilon$ model, relating it to the magnitude of the subfilter stress tensor and its time evolution.

Numerical Implementation

• The model is implemented within the Lattice Boltzmann Method (LBM) framework (specifically the D3Q27 lattice).
• The collision step is modified to include the subfilter relaxation term:
  $$f_i^{post} = f_i - \omega f_i^{(1)} - \omega_t f_{sgs,i}$$
• Stability is ensured by imposing a condition $\nu_t \geq \nu$ (turbulent viscosity $\geq$ molecular viscosity), preventing the subfilter term from becoming negative or vanishingly small at coarse resolutions.

3. Key Contributions

1. Intrinsic Subfilter Modeling: The paper demonstrates that the kinetic framework naturally accounts for subfilter turbulent diffusion (the diffusive commutation error $E_D$), which is absent in classical filtered NSE closures.
2. No Scale Separation Required: Unlike previous kinetic turbulence models, this approach does not require the filter width to be separated from the Knudsen number, making it valid for a broader range of flow regimes.
3. Elimination of Ad-Hoc Assumptions: The model derives the subfilter stress contribution directly from velocity gradients via the CE expansion, removing the need for empirical structural assumptions (like the Smagorinsky ansatz) or auxiliary transport equations (like $k-\epsilon$).
4. Generalized BGK Operator: The introduction of a distinct relaxation frequency ($\omega_t$) for the subfilter distribution provides a physically consistent mechanism to model subgrid dissipation within the kinetic hierarchy.

4. Results

The model was validated against the Smagorinsky model and DNS data using two canonical test cases:

• Taylor–Green Vortex (TGV):
  • Simulated at $Re=1600$ on a $32^3$ grid.
  • Metric: Time evolution of integral enstrophy.
  • Outcome: The Kinetic Closure (KC) model was significantly less dissipative than the Smagorinsky model. It converged toward the unfiltered BGK solution at higher resolutions, whereas the Smagorinsky model remained overly dissipative.
• Turbulent Mixing Layer (ML):
  • Simulated with $Re=800$.
  • Metric: Velocity self-similarity profiles.
  • Outcome: The KC model successfully captured the self-similarity of the velocity profile, demonstrating improved stability and reduced numerical diffusion compared to the Smagorinsky baseline.

5. Significance

This work represents a paradigm shift in turbulence modeling by bridging the gap between kinetic theory and Large Eddy Simulation.

• Reduced Dissipation: By avoiding the excessive dissipation typical of eddy-viscosity models, the KC approach allows for more accurate resolution of turbulent structures, potentially enabling coarser grids to achieve DNS-quality results.
• Theoretical Rigor: The derivation provides a self-consistent kinetic theory for turbulence that recovers the filtered Navier–Stokes equations in the hydrodynamic limit while retaining information about subfilter scales.
• Future Potential: The framework is general and can be extended to thermal flows, compressible turbulence, and more advanced collision operators (e.g., Multi-Relaxation Time). It offers a promising alternative to classical LES for complex engineering flows where minimizing numerical dissipation is critical.