GPU-native Embedding of Complex Geometries in Adaptive Octree Grids Applied to the Lattice Boltzmann Method

TL;DR

This work tackles embedding complex, non-aligned geometries into GPU-resident adaptive Cartesian grids for the lattice Boltzmann method. It introduces a GPU-native pipeline that voxelizes stationary geometries level-by-level within a block-based forest-of-octrees, using a hierarchical spatial-bin framework to accelerate solid-voxelization and near-wall refinement, and a flattened link-length lookup to enable interpolated boundary conditions. The approach yields a modest overhead while delivering accurate force predictions and stable near-wall resolution, demonstrated through 2D cylinder and 3D sphere flows and comparisons with sparse voxel methods and literature. The methodology is general and positions GPU-resident geometry embedding as a foundational technique for explicit solvers requiring high-performance, scalable AMR with complex geometries on GPUs.

Abstract

Adaptive mesh refinement (AMR) reduces computational costs in CFD by concentrating resolution where needed, but efficiently embedding complex, non-aligned geometries on GPUs remains challenging. We present a GPU-native algorithm for incorporating stationary triangle-mesh geometries into block-structured forest-of-octrees grids, performing both solid voxelization and automated near-wall refinement entirely on the device. The method employs local ray casting accelerated by a hierarchy of spatial bins, leveraging efficient grid-block traversal to eliminate the need for index orderings and hash tables commonly used in CPU pipelines, and enabling coalesced memory access without CPU-GPU synchronization. A flattened lookup table of cut-link distances between fluid and solid cells is constructed to support accurate interpolated bounce-back boundary conditions for the lattice Boltzmann method (LBM). We implement this approach as an extension of the AGAL framework for GPU-based AMR and benchmark the geometry module using the Stanford Bunny (112K triangles) and XYZ RGB Dragon (7.2M triangles) models from the Stanford 3D Scanning Repository. The extended solver is validated for external flows past a circular/square cylinder (2D, $Re = 100$), and a sphere (3D, $\text{Re}\in\{10, 15, 20\}$). Results demonstrate that geometry handling and interpolation impose modest overhead while delivering accurate force predictions and stable near-wall resolution on adaptive Cartesian grids. The approach is general and applicable to other explicit solvers requiring GPU-resident geometry embedding.

Figures (28)

• Figure 1: Embedding of a 2D circular cylinder () within an axis-aligned adaptive computational grid. Each square represents a $4\times 4$ block of cells. Cells are classified as fluid (), boundary (), and solid (). The links between the boundary and solid nodes are illustrated with arrows (). The staircase approximation of the cylinder imposed by voxelization is shown with the dashed line ().
• Figure 2: Stencil for the interpolated bounce-back condition along a link that intersects a tesselation of a 2D circular cylinder (shown in blue). The distance to the point of intersection between the link and a geometry edge is stored explicitly. A boundary node and one fluid node are required for the computation, and these may lie in different blocks as shown here.
• Figure 3: Left: Flow chart of proposed voxelization procedure. Right: Summary of our CUDA kernels for each subroutine.
• Figure 4: Labeling and orientation of the geometry elements. Left: Edge in 2D. Right: Triangle in 3D.
• Figure 5: Representations of the hierarchical grid: a) octree, b) flattened grid, c) hierarchical view of overlap.