Solving the (Navier-)Stokes equations with space and time adaptivity using deal.II

This paper demonstrates the flexibility and modularity of the deal.II library's multigrid infrastructure by solving stationary Stokes, transient Stokes, and incompressible Navier-Stokes equations using various adaptive strategies, including hp-adaptivity, space-time finite elements, and monolithic solvers.

The Gist

Imagine you are trying to predict how water flows through a complex network of pipes, around a sphere, or between spinning cylinders. This is the job of the Navier-Stokes equations, a set of mathematical rules that describe fluid motion. However, these equations are incredibly difficult to solve on a computer because the fluid behaves differently in different places: sometimes it moves smoothly, sometimes it swirls wildly, and sometimes it changes speed rapidly.

This paper is like a master blueprint for building a super-efficient computer simulation to solve these problems. The authors used a powerful software toolkit called deal.II to create a system that is smart, flexible, and fast.

Here is the breakdown of their work using simple analogies:

1. The Problem: The "One-Size-Fits-All" Trap

Imagine you are trying to paint a picture of a forest.

• The Old Way: You use the same size brush everywhere. To get the details of a tiny leaf, you have to use a tiny brush for the entire forest. This takes forever and wastes time on the empty sky where a big brush would do.
• The New Way (Adaptivity): You use a smart brush. When you are painting a tiny leaf, the brush shrinks to a fine point. When you are painting the sky, the brush expands to a wide stroke.
• The Paper's Innovation: The authors didn't just change the size of the brush (mesh size, or $h$-adaptivity); they also changed the complexity of the paint strokes (polynomial degree, or $p$-adaptivity). They call this $hp$-adaptivity. It's like having a brush that can instantly switch from a fine-point pen to a broad roller depending on exactly what part of the picture you are working on.

2. The Engine: The "Multigrid" Elevator

Solving these equations is like trying to find a lost key in a massive, multi-story building.

• The Slow Way: You check every single room on every floor, one by one. This is too slow.
• The Multigrid Way: Imagine you have a special elevator system.
  1. The Coarse View: First, you go to the roof and look at the building from a distance. You can't see the keys, but you can see which wing of the building is messy.
  2. The Descent: You take the elevator down to that specific wing. Now you look at the floor plan. You see which room is messy.
  3. The Fine View: You go down to the specific room and check every drawer.
  4. The Ascent: Once you find the key, you go back up, but this time you use the information to fix the "mess" on the floors above you, making the whole building cleaner.

This "elevator system" is called Multigrid. The paper shows how to build this elevator so it works perfectly even when the building has weird shapes (local refinement) and different types of rooms (different polynomial degrees).

3. The Three Challenges They Solved

The authors tested their "smart elevator" on three specific fluid problems:

• Challenge A: The Stationary Flow (The Y-Pipe)

  • The Scene: Water flowing through a pipe that splits into a "Y" shape.
  • The Trick: They used a hybrid elevator. First, they simplified the math (lowered the complexity of the paint strokes) until the problem was easy. Then, they simplified the geometry (made the rooms bigger). This combination ($hp$-multigrid) was incredibly fast and stable, solving the problem in a number of steps that didn't grow even as the simulation got more detailed.

• Challenge B: The Time-Traveling Flow (Space-Time Multigrid)

  • The Scene: Water flowing around a cylinder, but the flow changes over time (like a wave).
  • The Trick: Usually, computers solve time step-by-step (like watching a movie frame by frame). The authors treated Time as just another Space dimension. They built a 4D elevator that moves through space and time simultaneously. This allowed them to solve the whole movie at once rather than frame-by-frame, which is much more efficient.

• Challenge C: The Turbulent Flow (Navier-Stokes)

  • The Scene: Fast-moving water around a sphere or between spinning cylinders. This is messy and chaotic.
  • The Trick: To handle the chaos, they added "stabilizers" (like shock absorbers on a car) to the math. They then used a Monolithic Multigrid approach, which means they solved the speed of the water and the pressure of the water together in one giant system, rather than trying to solve them separately. This prevented the simulation from crashing or becoming unstable.

4. The Result: Speed and Flexibility

The authors compared two ways of running their elevator:

1. Global Coarsening (GC): The elevator stops at every floor for everyone to get off and on. It's very organized and balanced.
2. Local Smoothing (LS): The elevator only stops at the floors where people are actually working.

They found that Global Coarsening was generally better for parallel computers (many workers working together) because it kept everyone busy and waiting less. However, the real victory was that their system was modular.

The "Lego" Analogy:
The deal.II library is like a giant box of Lego bricks. The authors didn't have to build a new factory; they just snapped together different bricks (smoothers, transfer operators, coarse solvers) to build the perfect machine for each specific fluid problem. If a new problem comes up, they can just swap out one brick and the machine still works.

Summary

In short, this paper demonstrates a new, highly efficient way to simulate fluids. By combining smart mesh refinement (zooming in only where needed), variable complexity (using simple or complex math as needed), and a multigrid "elevator" that moves through space and time, they created a solver that is:

• Fast: It scales linearly (if you double the detail, it takes double the time, not quadruple).
• Robust: It doesn't crash when the math gets hard.
• Flexible: It can be easily adapted to new types of fluid problems.

This is a major step forward for engineers and scientists who need to simulate everything from blood flow in arteries to wind around skyscrapers.

Technical Summary

1. Problem Statement

The paper addresses the computational challenges associated with solving the Stokes and Navier–Stokes equations in the context of Computational Fluid Dynamics (CFD) and geosciences. Specifically, it focuses on:

• High-order accuracy and adaptivity: Solving these equations on meshes that are locally refined in both space ($h$-adaptivity) and polynomial degree ($p$-adaptivity), as well as in time.
• Scalability and Efficiency: Developing efficient linear and nonlinear iterative solvers capable of handling the resulting large, sparse, and often ill-conditioned systems of equations on parallel architectures.
• Diverse Regimes: Tackling stationary Stokes, transient Stokes (using space-time finite elements), and incompressible Navier–Stokes equations with stabilization techniques (SUPG/PSPG) on locally refined meshes.

2. Methodology

The authors utilize the deal.II finite-element library, leveraging its modular multigrid infrastructure to design solvers. The core methodology involves:

A. Multigrid Infrastructure in deal.II

The paper emphasizes the flexibility of deal.II's multigrid framework, which supports:

• Transfer Operators: Geometric, polynomial, and non-nested transfers. The implementation uses a unified base class where prolongation is performed cell-by-cell, handling constraints (e.g., hanging nodes) and weighting contributions.
• Coarsening Strategies:
  • Global Coarsening (GC): Coarsens the entire domain; efficient for parallel load balancing but requires resolving hanging-node constraints.
  • Local Smoothing (LS): Smoothes only the most refined parts of the domain; cheaper per iteration in serial but can suffer from load imbalance in parallel.
  • $hp$-Multigrid: A hybrid approach combining polynomial coarsening (reducing $p$) followed by geometric coarsening (reducing $h$).
• Matrix-Free Approach: All operators (smoothing, inter-grid transfer) are evaluated without assembling global matrices, which is crucial for high-order elements and memory efficiency.

B. Specific Solver Strategies

1. Stationary Stokes ($hp$-adaptive):

   • Uses a block factorization preconditioner (Silvester–Wathen type) with a block triangular structure.
   • The Schur complement is approximated by a scaled mass matrix.
   • The viscous block ($A$) is inverted using a single $hp$-multigrid V-cycle.
   • Smoothing: Chebyshev iterations combined with Additive Schwarz Methods (ASM) on specific patches (faces between $h$-refined and $p$-refined neighbors) to handle ill-conditioning caused by constraint elimination.

2. Transient Stokes (Space-Time FEM):

   • Discretizes time using variational methods (e.g., DG($k$) or Collocation IRK) on time slabs, creating a monolithic Kronecker-structured system.
   • Employs Space-Time Multigrid (hp-STMG) with tensor-product transfers ($P = P_\tau \otimes P_h$).
   • Custom temporal transfer operators are implemented by inheriting from deal.II's base class.
   • Uses a space-time ASM smoother that resolves velocity-pressure coupling locally on patches spanning one spatial cell and one time slab.

3. Navier–Stokes (Locally Refined):

   • Solves the nonlinear system using Newton–Krylov methods.
   • Stabilization is achieved via SUPG (Streamline-Upwind Petrov-Galerkin) and PSPG (Pressure-Stabilized Petrov-Galerkin), allowing equal-order elements ($Q_p/Q_p$).
   • The Jacobian is solved using a monolithic hybrid multigrid (geometric coarsening followed by polynomial coarsening).
   • PSPG stabilization results in a non-zero pressure diagonal block, enabling the use of simpler smoothers like point Jacobi.

3. Key Contributions

• Unified $hp$-Multigrid for Stokes: Demonstrated a robust $hp$-multigrid approach for continuous elements on $hp$-adaptive meshes, overcoming previous limitations regarding constraint handling and ill-conditioning.
• Space-Time Multigrid Implementation: Successfully implemented a space-time multigrid solver for transient Stokes equations using tensor-product transfers, integrating custom time-transfer operators into the deal.II framework.
• Stabilized Navier–Stokes on Local Meshes: Validated a monolithic multigrid solver for stabilized Navier–Stokes equations on locally refined meshes, comparing Global Coarsening (GC) vs. Local Smoothing (LS).
• Performance Analysis: Provided a comprehensive comparison of solver robustness, scalability, and efficiency metrics (parallel workload efficiency $\eta_w$ and vertical communication efficiency $\eta_v$) across different adaptivity strategies.

4. Results

The paper presents four experiments validating the methodology:

• Exp. 1 (Stationary Stokes, Y-pipe):

  • Robustness: $hp$-multigrid with ASM-enhanced smoothing achieved 28 $\pm$ 2 iterations, independent of refinement levels. In contrast, standard point Jacobi iteration counts increased with refinement.
  • Scalability: $hp$-multigrid showed $O(N)$ complexity (linear scaling with degrees of freedom), whereas AMG showed $O(N^2)$ behavior in this context.
  • Conclusion: $hp$-multigrid is superior to AMG for $hp$-adaptive Stokes problems.

• Exp. 2 (Transient Stokes, Flow past Cylinder):

  • Convergence: The number of GMRES iterations remained mesh-independent ($O(10)$) even as polynomial degree $k$ increased from 1 to 4.
  • Cost: Wall-clock time scaled primarily with the number of time steps and degrees of freedom, confirming the efficiency of the space-time multigrid preconditioner.

• Exp. 3 & 4 (Navier–Stokes, Taylor–Couette & Flow around Sphere):

  • GC vs. LS: Global Coarsening (GC) generally outperformed Local Smoothing (LS) in parallel execution.
  • Efficiency: In Exp. 4 (Flow around a sphere), GC was ~30% faster than LS. The primary bottleneck for LS was load imbalance ($\eta_w$ dropped to 53.8% for LS vs. 99.9% for GC in Exp. 4), causing processes to wait during synchronization.
  • Iteration Counts: Both methods required similar numbers of linear iterations, suggesting that the simplified boundary conditions in LS did not negatively impact convergence rates, likely due to stabilization.

5. Significance

• Modularity and Flexibility: The work highlights the power of the deal.II infrastructure, showing that complex solvers (space-time, $hp$-adaptive, stabilized) can be built by composing modular components (transfer operators, smoothers, coarse solvers).
• Parallel Efficiency: The study provides critical insights into the trade-offs between Global Coarsening and Local Smoothing in parallel environments, demonstrating that GC is often preferable for locally refined meshes due to better load balancing.
• Future-Proofing: The matrix-free approach and the active development of deal.II (including upcoming GPU porting) position these solvers as scalable solutions for exascale computing.
• Open Source: The code for the experiments is made available via GitHub repositories, promoting reproducibility and further development within the scientific community.

In summary, the paper establishes that deal.II's multigrid infrastructure is a highly effective, flexible, and scalable platform for solving complex fluid dynamics problems with advanced adaptivity strategies in both space and time.