💻 computer science

BVH-Accelerated Ray Tracing for High-Frequency Electromagnetic Backscattering

This paper presents a GPU-accelerated, BVH-optimized shooting and bouncing rays (SBR) method that combines geometrical optics with physical optics to efficiently and accurately compute high-frequency electromagnetic backscattering from complex metallic objects.

Original authors: Marco Pasquale, Andong Hu, Luca Pennati, Ivy Peng, Stefano Markidis

Published 2026-04-13

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Marco Pasquale, Andong Hu, Luca Pennati, Ivy Peng, Stefano Markidis

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 predict how a radar gun "sees" a massive airplane. To do this accurately, you have to calculate how radio waves bounce off the plane's metal skin, travel through its engines, hit the tail, and bounce back to the radar.

If the airplane is huge compared to the tiny radio waves (which is true for modern jets), trying to simulate every single wave ripple using traditional math is like trying to count every grain of sand on a beach to measure the beach's size. It takes too long and requires too much computer memory.

This paper introduces a smarter, faster way to do this calculation using a method called Shooting and Bouncing Rays (SBR), supercharged with modern graphics card technology. Here is the breakdown in simple terms:

1. The Problem: Too Many Waves, Not Enough Time

In the world of high-frequency electronics (like 5G, 6G, and radar), the waves are so small that simulating them directly is impossible for big objects.

The Old Way: Try to solve the physics equations for the entire object at once. It's like trying to paint a mural by mixing every single drop of paint in the bucket before applying it to the wall. It's slow and messy.
The New Way: Instead of tracking the whole wave, we shoot thousands of invisible "lasers" (rays) at the object. We track where they hit, how they bounce, and where they end up. It's like throwing a handful of pebbles at a cave to see where they land, rather than mapping the entire cave wall.

2. The Solution: The "Flashlight" and the "Bouncer"

The authors' method works in two main phases:

Phase A: The Flashlight (Ray Tracing): Imagine shining a giant flashlight at the airplane. Instead of a solid beam of light, the flashlight shoots a grid of millions of tiny, invisible laser beams.
- When a beam hits the plane, it bounces off (specular reflection), just like a billiard ball hitting a cushion.
- It might bounce off the wing, hit the engine intake, bounce again, and finally fly back toward the radar.
- The computer records every bounce, the distance traveled, and the angle.
Phase B: The Bouncer (Physical Optics): Once the beams hit the plane, the computer calculates how much "energy" (signal strength) comes back. It treats the area around the hit point as a small mirror that reflects the signal. By adding up all these tiny reflections, it builds a complete picture of the radar signature.

3. The Secret Sauce: The "Smart Bouncer" (BVH)

The hardest part of this game is finding out which part of the plane the laser beam hit first. The airplane model is made of hundreds of thousands of tiny triangles (like a low-poly video game model).

The Naive Approach: If you have 1 million rays and 100,000 triangles, a dumb computer checks every ray against every triangle. That's 100 billion checks! It's like asking a bouncer at a club to check every person in the line against every face on a list of 100,000 VIPs. It would take forever.
The Smart Approach (BVH): The authors use a Bounding Volume Hierarchy (BVH). Think of this as a set of Russian nesting dolls or a library's card catalog.
- First, the computer puts the whole plane inside a big box.
- Then it puts the wings in a smaller box, the tail in another, and the engines in their own boxes.
- When a laser beam flies in, the computer checks the big box first. If the beam misses the big box, it instantly knows it missed the whole plane. If it hits the "Wing Box," it ignores the tail and engines entirely.
- This "culling" (cutting out the impossible) makes the search millions of times faster. It's like the bouncer checking the VIP list by first asking, "Are you in the VIP section?" before checking the specific name.

4. The Hardware: Supercharging with GPUs

The authors didn't just write a smart algorithm; they built it to run on GPUs (the powerful chips in gaming computers and supercomputers).

Parallel Processing: Instead of one ray at a time, they launch millions of rays simultaneously, like a swarm of bees.
The Pipeline: They organized the work so that one group of computer cores handles the "hitting" (finding the intersection), and another group handles the "calculating" (summing up the signal). This keeps the computer busy and efficient, like an assembly line where one team builds the car chassis and the next team paints it without waiting.

5. The Results: From Theory to Real Planes

The Test: They tested their method on a perfect metal sphere. They compared their results to the "gold standard" math (Mie theory).
- Result: It matched perfectly for large objects, proving the math works.
- Warning: They found that if the "lasers" are too far apart (too few rays), the image gets blurry and glitchy (aliasing), like a low-resolution video game. They created a rule: you need at least 5 rays for every wavelength to get a clear picture.
The Big Test: They simulated an Airbus A380 (a massive double-decker jet).
- They calculated the radar signature from every possible angle (360 degrees around the plane).
- Speed: Using a supercomputer (LUMI) with hundreds of graphics cards, they did this in about 27 minutes. Doing this with old methods would have taken days or weeks.

Summary

This paper is about building a high-speed, smart radar simulator.

Stop counting every wave: Use rays instead.
Don't check everything: Use a "Russian Doll" box system (BVH) to ignore empty space.
Use the swarm: Run millions of calculations at once on powerful graphics cards.
Keep it sharp: Make sure you have enough rays so the image doesn't get pixelated.

This technology is crucial for designing better stealth aircraft, improving 6G wireless networks, and creating more accurate weather and radar systems without needing a supercomputer the size of a city.

1. Problem Statement

As electromagnetic frequencies increase (moving toward sub-terahertz and 6G scenarios), the characteristic size of objects ( $D$ ) becomes much larger than the wavelength ( $\lambda$ ). In this high-frequency regime ( $D/\lambda \gg 1$ ):

Full-wave solvers (e.g., FDTD, FEM) become computationally infeasible because they require resolving the geometry with meshes fine enough to capture the wavelength, leading to massive memory and runtime requirements.
Asymptotic methods are required. Specifically, Shooting and Bouncing Rays (SBR) is a preferred approach for predicting Radar Cross Section (RCS) of complex metallic objects.
The Bottleneck: The dominant computational cost in SBR is the repeated ray-surface intersection query. As ray density increases to satisfy physical optics (PO) accuracy requirements and bounce depth increases to capture multi-reflection effects, a naive "all-vs-all" ray-triangle test becomes prohibitively expensive.

2. Methodology

The authors propose a high-performance SBR framework implemented in SagittaSBR, which couples Geometrical Optics (GO) transport with Physical Optics (PO) integration, accelerated by hierarchical spatial data structures and heterogeneous computing.

A. Mathematical Formulation

GO/PO Hybrid: The method approximates electromagnetic propagation using ray trajectories (GO) and calculates the scattered field by integrating induced surface currents over the illuminated area (PO).
Ray-Tube Discretization: Instead of tracking ray divergence factors, the method discretizes the PO surface integral using a grid of incident rays. Each ray represents a "ray tube" with an area weight $\Delta A = \Delta s^2$ .
Sampling Rule: To prevent spatial aliasing (non-physical oscillations in the RCS pattern), the incident ray spacing $\Delta s$ is constrained by $\Delta s \leq \lambda/5$ . This ensures at least five samples per wavelength, converting accuracy requirements directly into ray grid resolution.
Monostatic RCS: The scattered field amplitude $A$ is computed via a coherent sum of contributions from valid ray paths:
$A = \sum_{i=1}^{N} \frac{jk\Delta A}{4\pi} 2(\hat{n}_i \cdot -\hat{k}_{inc}) \Gamma^{N_i} e^{-j2kR_i}$
Where $R_i$ is the accumulated optical path length, $N_i$ is the number of bounces, and $\Gamma$ is the reflection coefficient.

B. Algorithmic Pipeline

The workflow is organized into a Trace–Integrate pipeline:

Sampling: An orthographic grid of rays is launched from a virtual aperture covering the target's projected extent.
BVH-Accelerated Traversal (Trace):
- A Bounding Volume Hierarchy (BVH) is constructed over the target's triangular mesh.
- Splitting Strategies: The BVH uses either a Median split (fast, balanced trees) or a Binned Surface Area Heuristic (SAH) (optimized for complex geometries to minimize traversal cost).
- Multi-bounce Transport: Rays are iteratively traced through the BVH. Upon hitting a triangle, the ray direction is updated via specular reflection, and the path length is accumulated.
- Hit Recording: The traversal stage outputs a compact record for each ray: validity flag, first-hit normal, total path length, and bounce count.
PO Accumulation (Integrate):
- Only "valid" rays (those that hit the target and return to the receiver plane) are processed.
- The coherent sum (Eq. 7) is evaluated in a separate kernel. This separation allows the intersection-heavy phase and the arithmetic-heavy phase to be optimized independently.

C. Implementation & Parallelization

Hardware: The code is written in C++/CUDA and supports NVIDIA and AMD GPUs via the HIP runtime API.
MPI Parallelization: The angular sweep (varying incident angles $\theta, \phi$ ) is distributed across MPI ranks. Each rank holds a copy of the mesh and BVH, processing a subset of angles independently.
Memory Management: Uses a global node pool with atomic counters for BVH construction and explicit fixed-size stacks for traversal to avoid recursion depth issues and register spilling.

3. Key Contributions

BVH-Accelerated SBR: Successfully integrates BVH spatial partitioning into high-frequency electromagnetic scattering to drastically reduce the complexity of ray-triangle intersection searches.
Trace–Integrate Decomposition: Separates the geometric traversal (hit detection) from the field evaluation (PO integration). This improves cache locality and allows for distinct optimization of the two computational phases.
Heterogeneous GPU Support: Demonstrates a unified implementation that runs efficiently on both NVIDIA (A100) and AMD (MI250X) architectures, revealing distinct performance characteristics regarding floating-point precision.
Robust Sampling Criterion: Establishes a clear rule ( $\Delta s \leq \lambda/5$ ) to control numerical aliasing, ensuring physical fidelity across frequency sweeps.

4. Results & Validation

A. Validation (PEC Sphere)

Mie Theory Comparison: The solver was validated against analytical Mie scattering solutions for a Perfectly Electrically Conducting (PEC) sphere.
Accuracy: Excellent agreement was found in the optical region ( $k_r \gtrsim 30$ ), with a standard deviation of $\sim 2.5\%$ .
Aliasing Instability: At very high frequencies ( $k_r \approx 8000$ ), aliasing occurred when the ray grid density was held constant while the wavelength decreased. This confirmed the necessity of the $\lambda/5$ sampling rule.

B. Large-Scale Application (A380 Aircraft)

Scenario: A full-spherical monostatic RCS scan of an A380 aircraft (approx. 80m $\times$ 73m) at 10 GHz.
Scale: Used a $30,000 \times 30,000$ ray grid ( $9 \times 10^8$ rays per angle) with up to 100 bounces per ray.
Performance:
- Runtime: Average computation time of 616 ms per angular position on 8 LUMI nodes (32 AMD MI250X GPUs).
- Total Rays: The simulation processed approximately $1.125 \times 10^{14}$ rays.
- Scalability: Strong scaling efficiency reached 88% at 256 devices; weak scaling efficiency reached 96%.

C. Architecture-Specific Insights

Precision Trade-offs:
- NVIDIA A100: Single precision (FP32) is significantly faster (+53% speedup) than double precision (FP64).
- AMD MI250X: Double precision (FP64) is actually 20% faster than FP32 for the ray-launch kernel, likely due to hardware optimization for 64-bit operations.
- Recommendation: Use FP32 for NVIDIA to maximize throughput; use FP64 for AMD to minimize runtime and avoid phase accumulation errors.

5. Significance

This work demonstrates that asymptotic ray-based methods, when combined with modern BVH acceleration and exascale GPU computing, can effectively solve electromagnetic scattering problems for electrically large, complex geometries (like aircraft) that are currently intractable for full-wave solvers.

6G Relevance: The ability to simulate scattering at sub-terahertz frequencies is critical for the design of future 6G communication systems and radar.
Scalability: The method scales efficiently to thousands of GPU cores, enabling rapid parameter sweeps for design optimization.
Future Directions: The framework is extensible to include diffraction effects (GTD/UTD), dielectric materials, and fully polarimetric scattering, which are necessary for even higher fidelity simulations.

Software Availability: The source code is open-source at https://github.com/marco-pas/SagittaSBR.