Towards a GPU-Native Adaptive Mesh Refinement Scheme for the Lattice Boltzmann Method in Complex Geometries

TL;DR

The paper presents a GPU-native AMR pipeline for the Lattice Boltzmann Method that supports complex, triangle-mesh boundaries within a forest-of-octrees grid on a single GPU. It introduces geometry representation and GPU-oriented routines to import, discretize, and transfer mesh data, and implements three boundary-relationship algorithms: near-wall refinement, face detection, and a spatial binning scheme to efficiently identify boundary-adjacent cells. Results demonstrate substantial GPU speedups over CPU for near-wall detection on both 2D and 3D geometries, with insights into bin-density trade-offs and guidance for integrating the geometry module with a GPU-based LBM solver. This work lays the groundwork for accurate boundary treatment in LBM on complex geometries while maintaining full GPU residency for mesh adaptation and simulation timing.

Abstract

We present a GPU-native mesh adaptation procedure that incorporates a complex geometry represented with a triangle mesh within a primary Cartesian computational grid organized as a forest of octrees. A C++/CUDA program implements the procedure for execution on a single GPU as part of a new module with the AGAL framework, which was originally developed for GPU-native adaptive mesh refinement (AMR) and fluid flow simulation with the Lattice Boltzmann Method (LBM). Traditional LBM is limited to grids with regular prismatic cells with domain boundaries aligned with the cell faces. This work is a first step towards an implementation of the LBM that can simulate flow over irregular surfaces while retaining both adaptation of the mesh and the temporal integration routines entirely on the GPU. Geometries can be inputted as a text file (which generates primitive objects such as circles and spheres) or as an STL file (which can be generated by most 3D modeling software). The procedure is divided into three steps: 1) an import step where the geometry is loaded into either an index list arrangement or directly as a face-vertex coordinates list, 2) a spatial binning step where the faces are distributed to a set of bins with user-defined density, and 3) a near-wall refinement step where the cells of the computational grid detect adjacency to the faces stored in the appropriate bin to form the links between the geometry and the boundary nodes. We validate the implementation and assess its performance in terms of total execution time and speedup relative to a serial CPU implementation using a 2D circle and a 3D Stanford bunny.

Figures (13)

• Figure 1: Left: Nodes in the tree correspond to blocks in the grid and identify locations in the data arrays. Right: scope of the current work. The Geometry module replaces the old near-wall refinement routine and enables grid cells to identify the proper domain boundary.
• Figure 2: Half-way bounce-back boundary conditions are second-order accurate for geometries aligned with the cell edges/faces, but interpolation or ghost methods are needed to maintain accuracy for more general surfaces.
• Figure 3: Visualization of the current edge and triangle orientations.
• Figure 4: Index ($\texttt{geom\_f\_node\_X}$, $\texttt{geom\_ID\_face}$) and coordinate list ($\texttt{geom\_f\_face\_X}$) representations of a sample triangle mesh. Yellow cells indicate the indices of the elements.
• Figure 5: Visualization of the near-wall region around a single triangle oriented in 3D.