Vidyut3d: a GPU accelerated fluid solver for non-equilibrium plasmas on adaptive grids

This paper introduces Vidyut3d, a performance-portable, GPU-accelerated non-equilibrium plasma fluid solver built on the AMReX library that achieves 150–400x speed-ups on multi-architecture CPU+GPU systems while maintaining second-order accuracy through adaptive grids and advanced numerical schemes.

The Gist

Imagine you are trying to predict how a storm cloud moves, but instead of rain and wind, the "cloud" is made of super-charged particles (plasma) that can reach temperatures hotter than the surface of the sun, while the air around them stays cool. This is the world of non-equilibrium plasma, and it's used in everything from making computer chips to cleaning liquids.

The paper introduces a new digital tool called Vidyut3d (which roughly translates to "Electric 3D"). Think of this tool as a high-speed, super-accurate weather forecast simulator, but specifically designed for these tiny, chaotic electrical storms.

Here is a breakdown of what the paper says, using simple analogies:

1. The Problem: The "Traffic Jam" of Math

Simulating plasma is incredibly hard because it involves millions of tiny particles interacting at different speeds.

• The Old Way: Traditional computer programs (running on standard processors) are like a single cashier at a grocery store trying to scan millions of items one by one. It works, but it takes a long time.
• The New Way: The authors built Vidyut3d to run on GPUs (Graphics Processing Units). If a standard processor is a single cashier, a GPU is a massive warehouse with thousands of cashiers working in perfect sync. This allows the computer to do the math much, much faster.

2. The "Smart Zoom" Feature (Adaptive Grids)

One of the biggest challenges is that plasma storms have tiny, intense centers (like the tip of a lightning bolt) and huge, calm areas around them.

• The Analogy: Imagine trying to take a photo of a crowd. If you zoom out to see everyone, the faces are blurry. If you zoom in to see one face, you miss the rest of the crowd.
• The Solution: Vidyut3d uses Adaptive Mesh Refinement. It's like a camera that automatically zooms in super-close only where the action is happening (the "storm heads") and stays zoomed out for the calm areas. This saves massive amounts of computing power because it doesn't waste time calculating details where nothing is changing.

3. How They Tested It (The "Fake Reality" Check)

Before trusting a simulator, you have to prove it works. The authors used a few clever tests:

• The "Manufactured Solution" Test: They created a fake, made-up plasma storm where they already knew the exact answer. They ran their simulator and checked: "Did the computer get the answer we already knew?" It did, with high precision.
• The "Lightning Bolt" Test: They simulated a "streamer" (a tiny lightning bolt) moving through gas. They compared their results to other famous scientific papers and found their numbers matched almost perfectly.
• The "Glass Box" Test: They simulated a standard lab experiment (the GEC reference cell) that scientists use to test equipment. Their simulation matched real-world measurements and other computer models.

4. The Big Simulations (Putting It to Work)

Once they proved the tool worked, they ran two massive 3D simulations to show off its power:

• The "Lightning Show": They simulated 14 lightning bolts (streamers) moving through a mix of Argon and Hydrogen gas. They watched how these bolts interacted, merged, and moved. This took about 3 hours on a supercomputer with 200 powerful graphics cards.
• The "Thin Film Factory": They simulated a machine used to coat materials (like making solar panels). This involved a complex setup with three electrodes. They ran this for a long time to see how the plasma settled into a steady state.

5. The Speed Result (The "Rocket" Factor)

The most impressive finding is the speed.

• The authors compared running their simulation on a single standard computer processor (CPU) versus a single high-end graphics card (GPU).
• The Result: The GPU was 150 to 400 times faster than the single CPU.
• The Analogy: If the CPU took a month to finish a simulation, the GPU could do it in a few hours. This makes it possible to run complex, 3D simulations that were previously impossible or took too long to be useful.

Summary

The paper presents Vidyut3d, a new, open-source software that acts like a super-fast, smart-zooming camera for electrical storms (plasmas). By using modern graphics cards (GPUs) and a "smart zoom" technique, it can simulate complex plasma behaviors hundreds of times faster than older methods, helping scientists design better tools for manufacturing and energy.

Technical Summary

Technical Summary: Vidyut3d – A GPU-Accelerated Fluid Solver for Non-Equilibrium Plasmas

Problem Statement

Non-equilibrium (non-thermal) plasmas are critical to various engineering applications, including semiconductor manufacturing, materials synthesis, and surface modification. These discharges are characterized by high-energy electrons (10,000–100,000 K) coexisting with a much cooler gas background (300–1,000 K). Simulating these phenomena is computationally challenging due to the wide range of spatial and temporal scales and the tight coupling between physical processes such as electron-impact reactions, gas-phase chemistry, and species transport.

While Particle-in-Cell Monte Carlo Collision (PIC-MCC) methods are effective for low-pressure regimes, they become prohibitively expensive at higher pressures (e.g., atmospheric conditions) where fluid models are more appropriate. Existing fluid solvers for non-equilibrium plasmas (e.g., MOOSE, HPEM, COMSOL, PLASIMO, SOMAFOAM) often lack open-source availability or do not support hybrid CPU+GPU parallelization, limiting their ability to leverage modern High-Performance Computing (HPC) architectures. There is a specific gap in open-source, performance-portable fluid solvers capable of efficiently running on heterogeneous CPU+GPU systems for non-thermal plasma discharges.

Methodology

The authors present Vidyut3d, a fluid solver designed to address these limitations. The solver is implemented in C++ using AMReX, a performance-portable adaptive Cartesian grid library, enabling execution on both NVIDIA and AMD GPU architectures.

Mathematical Model

The solver employs a two-temperature model for intermediate and high-pressure regimes, solving coupled conservation equations for:

• Species Transport: Conservation of number densities for electrons, ions, and neutrals using the drift-diffusion approximation.
• Electrostatics: A Poisson equation to determine self-consistent electric fields and potentials.
• Electron Energy: An electron energy equation to resolve electron temperature ($T_e$), which drives reaction rates and transport properties.
• Photoionization: A simplified three-term Helmholtz equation model is used to compute photoionization source terms, essential for streamer propagation simulations.
• Surface Charge: A boundary condition tracks surface charge density on dielectric surfaces.

The model assumes constant pressure and temperature for the background gas, with coupling to full gas fluid equations noted as future work.

Numerical Methods

• Discretization: A finite volume formulation on Cartesian grids.
• Advection: Discretized using a fifth-order Weighted Essentially Non-Oscillatory (WENO) scheme.
• Diffusion: Treated implicitly using a second-order central scheme.
• Time Integration: A global second-order implicit Runge-Kutta scheme (mid-point method) advances the system. The solver supports both fixed time-steps and adaptive time-stepping based on Courant numbers for advection, diffusion, and dielectric relaxation.
• Geometry: While primarily Cartesian, the solver supports axisymmetric configurations and cell masking to handle complex geometries (e.g., GEC reference cells) by disabling solves in specific regions.

Software Implementation

• Portability: The code utilizes AMReX's C++ lambda-based launch system for GPU execution and interfaces with HYPRE for stiff linear systems.
• Chemistry: A custom Python-based parser (adapted from CEPTR) converts CANTERA-formatted YAML files into C++ source code compatible with both host (CPU) and device (GPU) execution. This allows for the inclusion of complex plasma kinetics, including electron impact reactions, excited species quenching, and ion-ion recombination.

Key Contributions and Verification

The paper provides a comprehensive verification and validation suite:

1. Method of Manufactured Solutions (MMS):

   • Spatial Accuracy: Verification on a 1D domain demonstrated formal second-order accuracy in space for both species density and potential, despite the use of a fifth-order advection scheme (limited by the central diffusion scheme).
   • Temporal Accuracy: Verification confirmed that the time integration scheme achieves first-order accuracy with one corrector iteration and second-order accuracy with two or more iterations.

2. Benchmark Comparisons:

   • Capacitive Discharge (1 Torr He): Results matched established fluid models (Turner et al., SOMAFOAM, mps1d) and showed expected discrepancies with PIC models due to transport property parameterization.
   • Streamer Propagation: The solver successfully reproduced benchmark results from Bagheri et al. for positive streamer propagation in air, both with and without photoionization physics.
   • GEC Reference Cell: Simulations of a low-pressure argon RF discharge showed reasonable agreement with experimental data (Overzet and Hopkins) and previous fluid models, capturing peak electron densities and radial profiles.

Performance Assessment

The authors conducted performance studies on three distinct CPU+GPU architectures (NVIDIA H100, A100, and AMD MI250X) using a 3D streamer simulation with 4 million cells and 15 species.

• Speed-up: A single GPU demonstrated a 150x to 400x speed-up per time step compared to a single CPU core.
• Scaling:
  • Strong Scaling: Favorable scaling was observed up to 2048 CPU cores. GPU scaling was optimal up to ~40 GPUs, beyond which performance degraded due to CPU-GPU memory transfer and inter-GPU communication overheads.
  • Optimization: Recent code optimizations, including GPU-aware MPI and simultaneous multi-species solves, improved GPU computational efficiency by 26% and CPU efficiency by 7.5%.

Demonstration Simulations

The solver was applied to two complex 3D production cases:

1. Atmospheric Ar-H2 Streamer Discharge: A simulation of 14 interacting streamers in an Argon-Hydrogen mixture. The adaptive mesh refinement (AMR) dynamically refined the grid to a resolution of ~12 µm in high-gradient regions, utilizing 337 million cells at peak. The simulation ran on 200 NVIDIA H100 GPUs for 3 hours of wall-clock time.
2. RF Three-Electrode Reactor: A low-pressure (0.1 Torr) simulation of a thin-film deposition reactor with two powered targets and a grounded substrate. The solver captured plasma sheath formation and density distributions over 1,000 RF cycles.

Significance and Claims

The paper claims that Vidyut3d represents the first open-source, performance-portable non-thermal plasma fluid solver capable of running efficiently on modern CPU+GPU architectures. Its significance lies in:

• Accessibility: Providing an open-source tool (available on GitHub) for the plasma community.
• Scalability: Enabling high-fidelity 3D simulations of complex plasma phenomena (e.g., interacting streamers, reactor geometries) that were previously computationally prohibitive.
• Portability: Successfully abstracting hardware dependencies to run on both NVIDIA and AMD GPUs without code modification, facilitating the use of diverse HPC resources.

The authors conclude that while the current implementation focuses on fluid models, ongoing efforts aim to incorporate volume penalization for complex geometries, external circuit coupling, and further GPU performance optimizations.