Field conserving adaptive mesh refinement (AMR) scheme on massively parallel adaptive octree meshes

This paper proposes a scalable, field-conserving coarsening operator for parallel octree-based adaptive mesh refinement that uses an $L^2$ projection to prevent systematic drift in conserved quantities during long-horizon simulations of partial differential equations.

The Gist

Imagine you are playing a high-stakes game of Minecraft, where you are building a massive, detailed castle. To make the castle look amazing, you use a lot of tiny, microscopic blocks for the intricate carvings on the towers. But for the giant, flat walls, you don't want to waste your computer's energy using tiny blocks; you’d rather use big, chunky blocks to save space.

This is exactly what scientists do when they simulate complex things like how oil and water mix or how cells grow. They use Adaptive Mesh Refinement (AMR). They use "tiny blocks" (a fine mesh) where things are changing rapidly, like a moving wave, and "big blocks" (a coarse mesh) where everything is calm.

The Problem: The "Leaky Bucket" Effect

The problem arises when the simulation decides a part of the world is now "calm" and wants to swap those tiny blocks for big ones. This is called coarsening.

In the old way (called "Injection"), the computer basically looks at the tiny blocks and says, "I'll just pick the values from the corners of these tiny blocks and use them for the big block."

The Metaphor: Imagine you have a bucket filled with 1,000 tiny droplets of water. You want to move that water into one large jug. If you just "inject" the water by picking up a few random droplets and ignoring the rest, you’re going to end up with a much lighter jug. You’ve "lost" the water that was in between the droplets you picked.

In a scientific simulation, this "lost water" is Mass. If you lose a little bit of mass every time you switch from tiny blocks to big blocks, after a thousand steps, your simulation might show that half your ocean has simply vanished into thin air!

The Solution: The "Perfect Pour"

The authors of this paper have invented a new way to switch from tiny blocks to big blocks without losing a single drop. Instead of just "picking" values, they use a two-step mathematical process:

1. The Local Redistribution: Instead of picking random points, they look at all the tiny blocks and mathematically "smear" their values across the new, big block so that the total amount stays exactly the same.
2. The Smooth Rebuild: They then use a specialized math tool (an $L^2$ projection) to make sure the new, big block looks as smooth and natural as possible, so the simulation doesn't "glitch" or look jagged.

The Metaphor: Instead of picking random droplets, imagine you take the 1,000 tiny droplets, put them in a blender to make a smooth liquid, and then pour that entire liquid into the big jug. You might not have the exact same "shape" of droplets, but you have exactly the same amount of water.

Why does this matter?

The researchers tested this on very difficult math problems, like the Cahn-Hilliard equation (which describes how substances separate, like oil separating from vinegar).

• The Old Way: The "oil" would slowly disappear or grow unnaturally because the math was "leaking" mass every time the mesh changed.
• The New Way: The mass stayed perfectly constant. The simulation was much more realistic and reliable over long periods of time.

In Short:

This paper provides a "leak-proof" way for supercomputers to simplify their math on the fly. It allows scientists to run massive, long-term simulations of nature without the "math" accidentally deleting the very matter they are trying to study.

Technical Summary

Technical Summary: Field-Conserving Adaptive Mesh Refinement (AMR) Scheme

1. Problem Statement

In long-horizon multiphysics simulations (such as phase-field modeling), maintaining the conservation of physical quantities (e.g., mass, charge) is critical. While many numerical schemes are designed to be conservative on a fixed mesh, the use of Adaptive Mesh Refinement (AMR) introduces a new source of error.

In Continuous Galerkin (CG) finite element discretizations on octree meshes:

• Refinement (Parent-to-Child): Is naturally conservative because interpolation uses the existing basis functions.
• Coarsening (Child-to-Parent): Standard "injection-based" methods—which simply discard fine-grid degrees of freedom (DOFs) that do not coincide with coarse nodes—are not conservative.

This lack of conservation during coarsening leads to systematic "mass drift" that accumulates over repeated AMR cycles, potentially invalidating the physical accuracy of long-term simulations.

2. Methodology

The authors propose a scalable, two-step field-conserving coarsening operator designed specifically for parallel octree-based AMR. Instead of simple injection, the method uses a projection-based approach:

1. Local $L^2$ Projection (Cell-Level Transfer):

   • The goal is to transfer the field from fine child elements to the quadrature points of the resulting coarse parent element.
   • The method computes coarse-element values at quadrature points such that the integral of the field over the parent element is preserved (discrete global conservation).
   • By choosing Lagrange basis functions that satisfy the property $N_j(x_k) = \delta_{jk}$ at the quadrature points, the authors derive a diagonal mass matrix, allowing for a direct, computationally efficient calculation of coarse quadrature values without solving a large system.
   • This step is highly parallelizable as it is performed locally within each coarsened parent element.

2. Global $L^2$ Projection (Nodal Recovery):

   • Once the values at the coarse quadrature points are determined, the actual coarse nodal DOFs are recovered by solving a local mass-matrix system ($M_G = b$).
   • This ensures that the reconstructed coarse field is the best $L^2$ approximation of the fine-mesh field, minimizing error while maintaining the integral constraint.

3. Key Contributions

• A New Coarsening Operator: A mathematically rigorous method to ensure discrete global conservation during the coarsening stage of CG-based AMR.
• Algorithmic Scalability: The method is designed for massively parallel environments (using the Dendrite-kt framework). The local nature of the first step and the small size of the local mass matrices in the second step ensure minimal overhead.
• Generality: While demonstrated with linear and quadratic elements, the framework is applicable to any CG formulation using Lagrange basis functions of arbitrary polynomial order.

4. Results and Validation

The authors validated the scheme using the Method of Manufactured Solutions (MMS) and complex multiphysics models:

• Convergence & Accuracy: MMS tests showed that the conservative scheme maintains optimal convergence rates (order 2 for linear, order 3 for quadratic) and achieves lower $L^2$ errors than injection.
• Cahn–Hilliard (CH) & Flory–Huggins Models:
  • Mass Conservation: The proposed scheme preserved mass to numerical precision, whereas injection-based coarsening showed significant, accumulating mass drift.
  • Energy Consistency: The conservative scheme resulted in a much smaller "energy mismatch" ($\Delta E$) during coarsening events (by nearly two orders of magnitude) compared to injection, meaning the physical dissipation behavior was better preserved.
• Cahn–Hilliard–Navier–Stokes (CHNS): In a 2D bubble-rise benchmark, the scheme successfully maintained mass conservation during complex fluid-interface interactions, where injection-based methods failed.
• Computational Overhead: The additional cost was found to be minimal—approximately 10% for CH and 7% for CHNS—and is expected to decrease as problem sizes grow.

5. Significance

This work addresses a fundamental gap in high-performance computing for multiphysics. By providing a way to perform AMR without sacrificing conservation laws, the authors enable more reliable, long-term simulations of phenomena like phase separation, interfacial fluid dynamics, and chemical reactions. The method is particularly significant for researchers using octree-based massively parallel frameworks, as it provides a robust way to balance computational efficiency (via AMR) with physical fidelity (via conservation).