MARUT: An Exascale-Ready, GPU-Accelerated High-Order CFD Framework with AMR for High-Speed Flows and Finite-Rate Chemistry

This paper introduces MARUT, a scalable, GPU-accelerated high-order CFD framework featuring adaptive mesh refinement and finite-rate chemistry capabilities, designed to deliver high-fidelity simulations of compressible and reacting flows across subsonic to hypersonic regimes on exascale supercomputing architectures.

The Gist

Imagine you are trying to simulate a hurricane, a supersonic jet breaking the sound barrier, or a rocket re-entering the atmosphere. These are incredibly complex events where air moves at different speeds, heats up, cools down, and even changes its chemical makeup (like oxygen turning into nitrogen oxides). To predict these events accurately, scientists use "Computational Fluid Dynamics" (CFD), which is essentially a giant digital sandbox where they solve math equations to see how fluids behave.

The problem is that these simulations are like trying to count every single grain of sand on a beach while the tide is coming in. It requires so much computing power that traditional computers (CPUs) often get overwhelmed, especially when you need high detail (high fidelity) and speed.

Enter MARUT.

The paper introduces MARUT, a new, super-fast simulation engine built specifically for modern, powerful computer chips called GPUs (the same kind of chips that power high-end video games and AI). Think of MARUT not as a single worker, but as an army of thousands of tiny, fast workers all doing their part simultaneously.

Here is how MARUT works, broken down into simple concepts:

1. The "Smart Zoom" Camera (Adaptive Mesh Refinement)

Imagine you are taking a photo of a race car. If you zoom out too far, you can't see the details of the engine. If you zoom in too close, you miss the whole car.

• Old way: You take a photo with the same level of detail everywhere. To see the engine, you have to make the entire photo incredibly high-resolution, which takes forever to process.
• MARUT's way: It uses Adaptive Mesh Refinement (AMR). It acts like a smart camera that automatically zooms in only where things are happening fast or changing wildly (like a shockwave or a fire). In calm areas, it zooms out to save time. This "smart zoom" happens entirely inside the GPU's memory, so it doesn't waste time sending data back and forth to the main computer.

2. The "High-Resolution Lens" (High-Order Methods)

Most simulations use a grid that is a bit like a low-resolution pixelated image. To get a smooth curve, you need millions of pixels.

• MARUT's way: It uses High-Order Spectral Discontinuous Galerkin (DG) methods. Think of this as using a high-quality, smooth lens instead of pixels. It can represent curves and waves with far fewer "blocks" of data while still being incredibly accurate. This means it can capture the sharp edges of a shockwave without blurring them out.

3. The "Super-Fast Factory" (GPU Acceleration)

A traditional computer (CPU) is like a brilliant professor who can solve very hard problems one by one, but slowly. A GPU is like a factory floor with thousands of assembly line workers.

• The Paper's Claim: MARUT is built from the ground up to run on these "assembly line" workers. It keeps all the data on the GPU so the workers never have to stop to ask the "professor" (the CPU) for instructions. This allows it to run simulations up to 20 times faster than traditional methods on the same problem size.

4. Handling the "Chemical Kitchen" (Finite-Rate Chemistry)

When air gets super hot (like in a hypersonic jet), the molecules start breaking apart and reacting. It's like a chemical kitchen where ingredients are constantly swapping partners.

• The Paper's Claim: MARUT doesn't just simulate the wind; it simulates the chemistry. It tracks how different gases react, how heat is stored in vibrating molecules, and how energy is exchanged. It uses a clever "splitting" technique to handle these fast chemical reactions without slowing down the whole simulation.

5. The "Teamwork" (Multi-GPU Scaling)

Sometimes a problem is too big for even one super-fast GPU. You need to connect many GPUs together.

• The Paper's Claim: MARUT is designed to let these GPUs talk to each other efficiently. It uses a strategy where the GPUs do their math work while simultaneously passing notes (data) to their neighbors. This ensures that even when using four or more GPUs, the system doesn't get stuck waiting for data. The paper shows it maintains high efficiency, meaning adding more GPUs actually makes the job faster, not slower.

What Did They Test It On?

The authors didn't just build it; they tested it against real-world scenarios to prove it works:

• Supersonic Cylinder: Simulating air rushing past a cylinder at 3 times the speed of sound. MARUT correctly captured the shockwaves and the swirling wake behind it.
• Taylor-Green Vortex: A classic test for turbulence. MARUT showed it could handle the chaotic swirling of air without losing energy or accuracy, even when the mesh (the grid) was changing size dynamically.
• Wing Flight: Simulating air flowing over a real airplane wing (the ONERA M6) at transonic speeds. It matched real wind-tunnel data perfectly, capturing the complex shockwaves that form on the wing.
• Explosive Blast: Simulating a chemical explosion where air heats up and reacts. MARUT correctly predicted how the shockwave moved and how the chemical composition of the air changed.

The "Secret Sauce" (Julia Language)

Finally, the paper mentions that MARUT is written in a programming language called Julia. Think of Julia as a language that is as easy to read as English but as fast as C++. Because of this, the authors say MARUT is ready to be connected to Artificial Intelligence (AI) and machine learning tools in the future, potentially allowing for "self-driving" simulations that can learn and adapt on their own.

In Summary:
MARUT is a next-generation simulation tool that combines a "smart zoom" camera, a high-quality lens, and a massive army of GPU workers to simulate complex, high-speed airflows and chemical reactions. It is faster, more accurate, and more efficient than previous methods, making it a powerful tool for designing future aerospace vehicles.

Technical Summary

Technical Summary: MARUT – An Exascale-Ready, GPU-Accelerated High-Order CFD Framework

Problem Statement
High-fidelity simulation of compressible flows, particularly those involving strong discontinuities (shocks), thin viscous layers, and chemically reacting nonequilibrium phenomena, remains a central challenge in computational fluid dynamics (CFD). Traditional CPU-based architectures struggle to resolve these multiscale physics within practical turnaround times due to the prohibitive computational costs associated with high-resolution grids and high-order discretizations. Furthermore, emerging aerospace applications—ranging from hypersonic vehicle design to atmospheric entry—require methods capable of handling finite-rate chemistry, thermochemical non-equilibrium, and adaptive mesh refinement (AMR) on heterogeneous supercomputing architectures. The combination of high-order accuracy, dynamic adaptivity, and realistic three-dimensional geometries creates workloads that exceed the capabilities of single-node or single-GPU execution, necessitating scalable multi-GPU solvers that minimize communication overhead while maintaining solution fidelity.

Methodology
The paper presents MARUT, a scalable, multi-GPU computational fluid dynamics framework implemented natively in the Julia programming language. The solver is designed to exploit modern heterogeneous architectures through a fully GPU-resident workflow, eliminating host-device data transfer bottlenecks during time-stepping loops.

• Numerical Discretization: MARUT employs a high-order spectral Discontinuous Galerkin (DG) method for spatial discretization. It utilizes a nodal formulation on Gauss–Lobatto–Legendre (GLL) nodes with tensor-product bases. To ensure stability and entropy conservation, the inviscid fluxes are evaluated using an entropy-stable split-form (Ranocha flux) or a convex blend with a first-order finite-volume (FV) sub-cell scheme for shock capturing (Hennemann–Gassner indicator). Temporal integration is performed using strong-stability-preserving Runge–Kutta (SSP-RK) schemes (specifically SSPRK54).
• Viscous and Source Terms: Viscous terms are handled via the Bassi–Rebay 1 (BR1) mixed formulation, which introduces an auxiliary gradient variable computed via a central-difference DG operator. For chemically reacting flows, the framework incorporates finite-rate chemistry (Arrhenius laws) and thermochemical non-equilibrium (two-temperature Landau–Teller relaxation). These stiff source terms are integrated implicitly using a Strang splitting strategy with Newton iteration, while the transport steps remain explicit.
• Adaptive Mesh Refinement (AMR): A defining feature of MARUT is its GPU-resident conservative AMR strategy. Built upon the P4est library, the framework manages a forest-of-octrees data structure entirely on the device. The AMR cycle includes indicator-based flagging, 2:1 balance enforcement, conservative $L^2$ projection for solution transfer, and dynamic reconstruction of connectivity and mortar interfaces. This approach avoids the latency of CPU-GPU synchronization during mesh adaptation.
• Parallelization: The solver utilizes MPI for distributed-memory parallelism across multiple GPUs. It employs a face-only communication strategy to minimize data exchange volume and overlaps communication with computation to hide latency.

Key Contributions

1. Unified High-Order GPU Platform: Development of a fully GPU-accelerated spectral DG solver with SSP-RK time integration, capable of low-dissipation, high-fidelity simulations of shock-dominated and reactive flows.
2. GPU-Resident Conservative AMR: Introduction of a dynamic AMR strategy that operates entirely on the GPU, resolving multiscale structures (shocks, shear layers, reaction fronts) while overcoming the primary computational bottleneck of data movement between CPU and GPU.
3. Broad Regime Validation: Demonstration of robustness across subsonic, transonic, supersonic, and hypersonic regimes, including flows with finite-rate chemistry and stiff reactive source terms.
4. Exascale Readiness: Establishment of efficient multi-GPU scalability with strong and weak scaling performance on NVIDIA GPUs, achieving high parallel efficiency for large-scale simulations.

Results
The framework was validated against a suite of canonical benchmark problems:

• 2D Supersonic Cylinder: Simulated transient inviscid flow ($M=3$) with AMR, capturing detached bow shocks and unsteady wake vortex shedding. The solver achieved near-linear strong scaling and demonstrated the ability of the GPU-resident AMR to track evolving flow features.
• 3D Taylor–Green Vortex (TGV): Validated the solver's dissipation and dispersion properties at $Re=1600$ for both subsonic ($M=0.1$) and supersonic ($M=1.25$) regimes. The AMR configuration (Case 3) reproduced the kinetic energy decay and dissipation rates of fully resolved uniform meshes (Case 2) with significantly fewer elements, confirming the accuracy of the conservative projection and the entropy-stable operators.
• Transonic ONERA M6 Wing: Simulated viscous flow at $M=0.84$ on a curvilinear hexahedral mesh. The results showed close agreement with experimental surface pressure coefficients and captured complex features like $\lambda$-shock structures and tip-vortex roll-up.
• Non-Equilibrium Blast Reaction: Modeled a 2D chemically reacting blast wave with a 5-species air model and two-temperature relaxation. The solver successfully captured shock dynamics, species production (N, O, NO), and vibrational relaxation without violating positivity constraints.
• Performance: In single-GPU benchmarks, MARUT demonstrated speed-ups ranging from 8x to 25x over multi-threaded CPU baselines (32–64 threads) for 2D Euler and 3D Navier–Stokes problems, with efficiency increasing as problem size grew. Multi-GPU scaling studies on up to four L40S GPUs showed strong scaling efficiencies of 78.8% to 91.5% and weak scaling efficiencies of 86.3% to 88.3% for large problem sizes, with communication overheads kept below 10% in optimal configurations.

Significance
The paper positions MARUT as a flexible platform for next-generation exascale-ready simulations. By combining high-order accuracy, adaptive resolution, and native GPU acceleration, it addresses the challenge of simulating complex compressible-flow phenomena across high-speed reactive-flow applications. The framework's implementation in Julia is highlighted as a strategic advantage, enabling natural integration with differentiable programming and machine-learning libraries. This facilitates future developments in autonomous flow control, inverse modeling, and data-driven scientific discovery, reflecting a broader transition in computational science toward modular, AI-compatible simulation ecosystems. The work establishes that high-fidelity, production-scale CFD is feasible on modern heterogeneous platforms when algorithms are designed to minimize data movement and maximize parallel throughput.