🔢 mathematics

MultiWave: A computational lab for adaptive numerical methods approximating hyperbolic balance laws

This paper introduces MultiWave, a modular C++ framework designed as a computational laboratory for rapidly implementing and testing adaptive numerical methods, such as the adaptive perturbation discontinuous Galerkin method, for approximating hyperbolic balance laws.

Original authors: Adrian Kolb, Aleksey Sikstel

Published 2026-04-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Adrian Kolb, Aleksey Sikstel

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to simulate a massive, chaotic storm on a computer. The storm has calm, gentle breezes in some areas, but terrifying, violent tornadoes and shockwaves in others.

If you tried to map the entire storm with the same level of detail everywhere—using a grid so fine it could see individual raindrops—you would need a supercomputer the size of a city, and it would take forever to run. But if you use a coarse grid everywhere, you'd miss the dangerous tornadoes entirely, and your simulation would be useless.

MultiWave is a new, clever "computational laboratory" (a software toolkit written in C++) designed to solve exactly this problem. It allows scientists to simulate complex physical phenomena (like shockwaves, traffic jams, or fluid flow) by being smart about where they spend their computing power.

Here is how it works, explained through everyday analogies:

1. The "Smart Zoom" Camera (Adaptive Grids)

Think of the simulation grid like a digital photo.

The Old Way: You take a photo of a landscape. To see a tiny bug on a leaf in the distance, you have to zoom in on the entire photo, making the file size huge and the computer slow.
The MultiWave Way: It acts like a camera with intelligent auto-zoom. It keeps the background (the calm areas) in low resolution to save space. But the moment it detects a "tornado" (a shockwave or steep gradient), it instantly zooms in only on that specific spot to capture the details. When the storm passes, it zooms back out.

This is called Adaptivity. MultiWave doesn't just guess where to zoom; it uses a mathematical "detective" called Multiresolution Analysis (MRA).

2. The "Noise Detector" (Multiresolution Analysis)

How does the software know where to zoom? It uses a concept called Multiresolution Analysis.
Imagine you are listening to a symphony.

The coarse grid hears the general melody (the low notes).
The fine grid hears the specific, high-pitched squeaks of the violins.

MultiWave compares the "low notes" and the "high notes." If the difference between them is small (the music is smooth), it knows the area is calm and doesn't need high detail. If the difference is huge (a sudden, loud crash), it knows there is a "shock" happening and immediately adds more detail (refines the grid) in that specific spot.

3. The "Modular Lego Kit" (The Software Design)

One of the paper's biggest achievements is how the software is built. The authors didn't build a rigid, one-size-fits-all machine. Instead, they built a Lego kit.

The Base: They created a solid foundation (the Discontinuous Galerkin method) that handles the basic physics.
The Bricks: They designed the code so that different parts (like how to handle friction, how to handle water, or how to handle explosions) are separate "bricks."
The Magic: A scientist can snap a new "brick" onto the kit to simulate a new type of physics (like fluid-structure interaction or random weather patterns) without having to rebuild the whole engine.

The paper shows examples of this:

Adding Viscosity: Like adding a "friction" brick to simulate thick honey instead of water.
Shallow Water: Adding a "gravity" brick to simulate ocean waves hitting a beach.
Randomness: Adding a "dice roll" brick to simulate uncertain weather patterns.

4. The "Team of Workers" (Parallel Computing)

Simulating these storms requires massive power. MultiWave is designed to run on thousands of computer processors working together (like a team of workers).

The Problem: If you have 1,000 workers, but 900 of them are standing around waiting for the other 100 to finish a task, you are wasting money.
The MultiWave Solution: They use a clever sorting system (called a Space-Filling Curve) to hand out the work. They ensure that every worker gets a chunk of the map that is roughly the same size.
The "Ghost" Trick: When a worker needs information from a neighbor's territory (like a wind blowing from the next zone), they don't wait for a meeting. They send a "ghost" message ahead of time. While the neighbor is packing the data, the worker starts calculating the next step. This overlap makes the whole team incredibly fast.

Why Does This Matter?

This isn't just about math; it's about real-world safety and engineering.

Cavitation Erosion: The paper mentions simulating bubbles collapsing on ship propellers. This causes massive damage. MultiWave helps engineers design propellers that don't break.
Traffic & Logistics: It can model how a traffic jam forms and dissolves, helping city planners design better roads.
Medical Science: It can model blood flow through arteries, helping doctors understand aneurysms.

The Bottom Line

MultiWave is a high-tech, modular, and super-fast "computational laboratory." It allows scientists to simulate the most violent and complex physical events in the universe by only paying attention to the parts that matter, saving massive amounts of time and money while keeping the results incredibly accurate. It turns a supercomputer from a brute-force calculator into a smart, adaptive observer.

1. Problem Statement

The paper addresses the challenge of numerically solving systems of hyperbolic balance laws, which model diverse physical phenomena such as fluid dynamics, traffic flow, and biomedical processes. These systems are characterized by:

Complex Solution Structures: Solutions often contain smooth regions mixed with steep gradients, vortices, and discontinuities (shocks, contact waves).
Computational Cost: Achieving high precision on uniform grids is computationally prohibitive, especially in multiple spatial dimensions, as the number of degrees of freedom grows exponentially with refinement.
Need for Adaptivity: Accurate simulation requires adaptive numerical methods that dynamically refine the grid only where necessary (e.g., near shocks) while coarsening it in smooth regions.
Software Limitations: Existing frameworks often lack the flexibility to quickly prototype new mathematical concepts or the modularity to easily incorporate advanced features (e.g., non-conservative terms, specific limiters) without rewriting core infrastructure.

2. Methodology

The authors present MultiWave, a C++ framework designed as a "computational laboratory" for developing and testing adaptive numerical methods. The methodology is built on three pillars:

A. Mathematical Foundation

Discontinuous Galerkin (DG) Method: The core spatial discretization uses the Runge-Kutta Discontinuous Galerkin (RKDG) method. This approach is chosen for its locality, high-order accuracy, and compatibility with unstructured or adaptive grids.
Multiresolution Analysis (MRA): Adaptivity is driven by MRA. The solution is decomposed into a coarse approximation and detail coefficients (wavelets) across a hierarchy of nested grids.
- Perturbation Adaptivity: The method treats the adaptive grid solution as a perturbation of a full reference grid.
- Thresholding: Cells are refined or coarsened based on the magnitude of detail coefficients. Significant details (indicating steep gradients or discontinuities) are retained, while insignificant ones are discarded.
- Prediction Strategy: To handle the time evolution of features, a prediction step (based on Harten's strategy) anticipates the movement of significant features into neighboring cells or higher refinement levels before the time step is taken.

B. Software Architecture & Design

MultiWave is implemented in modern C++ utilizing Object-Oriented Programming (OOP), Template Metaprogramming, and CRTP (Curiously Recurring Template Pattern).

Modularity: The framework is structured as a dependency graph of template classes (e.g., PDE, Divergence, Source, Limiter, MRA). This allows users to swap components (e.g., changing a flux function or adding a Laplace operator) without modifying the core solver logic.
Compile-Time Configuration: User-defined options (e.g., polynomial order, dimension, presence of source terms) are passed via template parameters. The compiler generates optimized code, eliminating runtime overhead for feature selection (e.g., if a source term is disabled, the code compiles out the source calculation entirely).
Data Structures:
- Level Multi-Index (LMI): Cells are identified by a 64-bit integer encoding the refinement level and spatial position, enabling efficient parent-child arithmetic without storing explicit geometry.
- Hash Maps: Adaptive solutions are stored in ankerl::unordered_dense hash maps keyed by LMI, balancing $O(1)$ lookup with cache-friendly iteration.
- Static Matrices: Local cell coefficients are stored as static matrices (using the Blaze library) to leverage SIMD vectorization and avoid heap allocations in inner loops.

C. Parallelization

Distributed Memory (MPI): The framework scales to large clusters using MPI.
Space-Filling Curves (SFC): A Morton-order SFC is used for domain decomposition, mapping the 2D/3D adaptive grid to a 1D linear order for load balancing.
Asynchronous Communication: Ghost cell exchange is overlapped with local volume integral computations to hide communication latency.
Load Rebalancing: The system dynamically redistributes cells when load imbalance exceeds a threshold, ensuring efficient resource usage during grid adaptation.

3. Key Contributions

A Modular, Extensible Framework: MultiWave provides a "plug-and-play" architecture where researchers can implement new numerical schemes (e.g., adding Laplace operators for viscous terms, path-conservative fluxes for non-conservative products, or well-balanced schemes for shallow water equations) by extending specific classes rather than rewriting the solver.
High-Performance Implementation: The use of compile-time polymorphism, SIMD instructions, and cache-optimized data layouts ensures that the adaptive solver achieves performance comparable to uniform grid solvers.
Robust Adaptivity Strategy: The integration of MRA-based perturbation adaptivity with RKDG provides a rigorous error control mechanism that maintains high-order accuracy in smooth regions while capturing discontinuities sharply.
Demonstrated Versatility: The paper showcases the framework's ability to handle:
- Standard Euler equations.
- Navier-Stokes equations (viscous terms).
- Non-conservative hyperbolic systems.
- Shallow water equations (with well-balancing and positivity preservation).
- Stochastic hyperbolic problems (weighted MRA).
- Fluid-structure interaction.

4. Results

The authors validate MultiWave through several numerical experiments:

Scaling Studies:
- Strong Scaling: On a uniform grid for 2D Euler equations, the framework achieves near-ideal scaling up to 288 MPI ranks. The SSPRK time-stepping and volume integrals scale efficiently; ghost exchange overhead is minimized via asynchronous communication.
- Weak Scaling: On adaptive grids, the framework maintains >80% efficiency up to 384 ranks. While adaptation overhead (refinement/coarsening) increases slightly with rank count, the core DG operations remain highly efficient.
Adaptivity Efficiency: In the Taylor-Green vortex test, MRA-based adaptivity achieved a compression rate of over 95% (reducing active cells significantly) while preserving error tolerance, leading to substantial reductions in computational time compared to uniform grids.
Complex Applications:
- Random Conservation Laws: Successfully applied weighted MRA to stochastic problems, refining grids based on probability density.
- Fluid-Structure Coupling: Demonstrated non-intrusive coupling of fluid (Euler) and solid (elastic) solvers, handling complex wave patterns and interface conditions efficiently.

5. Significance

MultiWave represents a significant advancement in computational fluid dynamics and numerical analysis software.

Research Acceleration: By abstracting low-level implementation details (mesh management, quadrature, parallel communication), it allows researchers to focus on mathematical innovation and rapid prototyping of new adaptive strategies.
Bridging Theory and Practice: It successfully translates complex theoretical concepts (MRA, perturbation adaptivity) into a high-performance, production-ready codebase.
Scalability: It proves that complex, dynamically adaptive methods can scale efficiently on modern supercomputers, making high-fidelity simulations of multi-scale phenomena feasible.
Community Impact: The framework is already in use by multiple research groups for uncertainty quantification, model adaptation, and error estimation, serving as a foundational tool for next-generation numerical methods.