🔭 astrophysics

GPU-Accelerated Orbit Propagation with High-Fidelity Solar Radiation Pressure Modeling

This paper presents a Vulkan-based GPU-accelerated framework for high-fidelity Solar Radiation Pressure modeling that incorporates dynamic solar panel orientation, demonstrating significant computational speed-ups and improved long-term propagation accuracy while providing practical guidelines for balancing online computation against interpolation-based methods.

Original authors: Leandro Zardaín, Ariadna Farrés, Anna Puig, Kevin Muntal, Albert Mir

Published 2026-08-10

📖 3 min read☕ Coffee break read

CC BY 4.0

Original authors: Leandro Zardaín, Ariadna Farrés, Anna Puig, Kevin Muntal, Albert Mir

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 steer a paper airplane across a giant, invisible ocean. In space, that "paper airplane" is a satellite, and the "ocean" is filled with invisible wind made of light. This wind is called Solar Radiation Pressure (SRP). It's not made of air molecules, but of tiny particles of light (photons) shooting out from the Sun. When these light particles hit a satellite, they push it, just like a breeze pushes a sail. For satellites flying close to the Sun or those with huge, delicate solar panels, this light-wind is a major force that can knock them off course if you don't account for it.

To keep a satellite on the right path, scientists use math to predict where it will go. This is called "orbit propagation." It's like trying to guess where a ball will land after you throw it, but you have to consider gravity, the wind, and even the shape of the ball. For a long time, scientists used simple shapes to guess how the light-wind would push a satellite, like pretending the satellite is a perfect ball or a flat box. But real satellites are messy, with solar panels that fold, twist, and turn to face the Sun. These complex shapes catch the light-wind in tricky ways, and simple guesses often lead to big mistakes over time. The big question scientists face is: How do we calculate these tricky light-pushes accurately without spending so much computer time that we never finish the calculation?

This paper tackles that problem by building a super-fast, high-definition simulator for space travel. The researchers created a new way to use powerful computer graphics cards (GPUs) to calculate the light-wind forces with extreme precision, almost like a video game rendering a realistic scene. They also added a feature that lets the satellite's solar panels move and rotate just like they do in real life, rather than staying stiff and frozen. To make things even faster, they tested a "pre-computed" method: instead of calculating the light-push every single second, they pre-calculated a massive library of answers and just looked them up when needed.

The team found that their new graphics card system, built on a modern technology called Vulkan, is a speed demon. It can calculate the light-push for a complex satellite up to 9.4 times faster than their old system, and when running a full journey simulation, it's up to 15.2 times faster. This means they can use the super-accurate "video game" method for long trips without waiting days for the computer to finish. They also discovered that ignoring the movement of solar panels is a bad idea. For satellites with big, moving wings, pretending the panels are stuck in place can lead to errors that grow into massive mistakes—thousands of kilometers off course after a few weeks.

However, the "pre-computed" method (called SPAD) is also a winner for many situations. If the satellite's movement is predictable, looking up the pre-calculated answer is millions of times faster than doing the full calculation, and the error is so small it barely matters. The paper suggests a smart workflow: use the super-fast, high-accuracy graphics card to build the pre-computed library and to handle the most complex, moving parts, but use the pre-computed library for the daily driving of the satellite. This way, space agencies can get the best of both worlds: the precision of a high-definition simulation with the speed needed to plan real missions.

Technical Summary: GPU-Accelerated Orbit Propagation with High-Fidelity Solar Radiation Pressure Modeling

Problem Statement

Accurate orbit propagation is critical for mission design, maneuver planning, and propellant optimization, particularly as the complexity and number of space missions increase. A dominant non-gravitational perturbation affecting spacecraft trajectories, especially those operating close to the Sun, is Solar Radiation Pressure (SRP). While simplified analytical models (e.g., Cannonball, N-Plate) offer low computational costs, they fail to capture complex geometric effects such as self-occlusion, multiple reflections, and articulated solar panel motion. These simplifications lead to accumulated errors in long-term propagation.

Conversely, high-fidelity ray-tracing models provide accurate SRP estimation by simulating photon interactions with detailed spacecraft meshes. However, their computational cost becomes prohibitive when integrated into numerical orbit propagators, which require thousands to millions of SRP evaluations per trajectory. Furthermore, existing tools often lack the capability to dynamically update spacecraft geometry (e.g., moving solar panels) during propagation or to systematically compare interpolation-based approximations against online high-fidelity computations under identical conditions.

Methodology

The authors extend the existing HiFi-SoRaP framework to create a complete orbit propagation environment that addresses three complementary strategies for integrating high-fidelity SRP models:

Vulkan-Based GPU Acceleration: The original OpenGL-based ray-tracing implementation was ported to a Vulkan compute pipeline. This shift provides explicit control over memory management, synchronization, and compute scheduling. Key optimizations include:
- GPU-based Reduction: Accumulating SRP contributions directly on the GPU using subgroup operations to minimize data transfer overhead between the GPU and CPU.
- Numerical Consistency: Incorporating Kahan compensated summation to maintain numerical stability.
- Parallel Execution: Processing rays per pixel on the discretized image plane with independent compute shaders.
Movable Solar Panel Modeling: The spacecraft model was extended to support articulated structures using a rooted directed tree representation ( $G = (N, E, L)$ ). This allows the geometry to be updated dynamically before each SRP evaluation. The algorithm traverses the tree to identify movable joints, computes the necessary rotations to align panel normals with the Sun direction (clamped by angular limits), and applies rigid transformations to the relevant mesh subtrees.
Interpolation-Based Approximation (SPAD): To evaluate the trade-off between accuracy and cost, the framework utilizes a precomputed SRP dataset (SPAD). Instead of executing ray tracing at every integration step, SRP forces are retrieved via interpolation from an offline dataset generated by the high-fidelity GPU model.

Experimental Setup:
The framework was validated using two spacecraft models: a geometrically simple "BoxWing" satellite (212 triangles) and a high-fidelity Parker Solar Probe (PSP) model (39,257 triangles). Simulations were conducted on a heliocentric elliptical orbit (semi-major axis 0.557 AU, eccentricity 0.682) using an explicit Runge-Kutta 7/8 (RK78) integrator. The study compared:

Direct RayTrace GPU (OpenGL vs. Vulkan).
SPAD interpolation (with varying sampling grids).
Fixed vs. Movable solar panel configurations.

Key Contributions

The paper makes three primary contributions to the field of orbit propagation:

A Vulkan-Based High-Fidelity SRP Engine: A new implementation that accelerates direct ray-tracing SRP evaluation while preserving the numerical accuracy of the original OpenGL-based method.
Dynamic Geometry Integration: An extension of the SRP model to account for the continuous orientation changes of articulated solar panels during propagation, moving beyond static geometry assumptions.
Systematic Comparative Framework: A unified environment that allows for the direct comparison of analytical models, interpolation-based approaches (SPAD), and online high-fidelity ray tracing under identical propagation conditions.

Results

1. Numerical Accuracy and Vulkan Performance

Numerical Consistency: The Vulkan implementation preserves the accuracy of the original OpenGL method, with relative differences in computed SRP accelerations remaining below $5 \times 10^{-4}$ .
Speed-ups:
- For individual SRP computations, the Vulkan implementation with GPU-based reduction achieved speed-ups of 9.4x for the complex PSP model and 4.4x for the simpler BoxWing model compared to the original OpenGL implementation.
- For complete orbit propagation (20 revolutions), the total execution time was reduced by up to 15.2x for the PSP model (from ~5 hours 18 minutes to ~20 minutes 53 seconds).
- Performance gains were most significant for complex geometries where the ray-tracing computation dominates the execution time, minimizing the impact of fixed communication overhead.

2. Interpolation (SPAD) vs. Direct Evaluation

Accuracy: SPAD-based interpolation (using a 20x10 sampling grid) reproduced the trajectories of direct RayTrace GPU evaluations with high fidelity. In circular orbits, position differences were approximately 0.12 km, compared to 12.06 km for the N-Plate model.
Efficiency: Interpolation reduced the computational cost of orbit propagation from hours to milliseconds (orders of magnitude faster).
Limitations: Accuracy depends on the sampling grid. Shifted grids (SPAD 20x10S) requiring bilinear interpolation showed larger errors than grids aligned with the sampling points, though they remained more accurate than analytical models. Continuous attitude variations were identified as the most demanding scenario for interpolation.

3. Impact of Movable Solar Panels

Accuracy: Neglecting panel motion introduced significant errors, particularly for spacecraft with large area-to-mass ratios.
- For the PSP, the mean relative error in SRP force was ~7.5%, leading to a trajectory deviation of ~27,590 km after 20 revolutions.
- For the BoxWing model, the mean relative error was 2.75 (275%), resulting in a trajectory deviation of ~3.17 million km.
Computational Overhead: Incorporating movable panels increased the ray-tracing workload (number of ray-triangle intersections).
- For the PSP, the overhead was moderate (~8% increase in propagation time).
- For the BoxWing, the overhead was higher (~55% increase) due to the significant change in intersection counts caused by the large moving arrays.

Significance and Guidelines

The paper concludes that the choice of SRP modeling strategy must balance computational efficiency, numerical accuracy, and physical fidelity:

SPAD Interpolation is recommended for routine, long-term orbit propagation and mission analysis when the spacecraft attitude remains within the coverage of a precomputed dataset. It offers a highly favorable accuracy-to-performance ratio.
Direct High-Fidelity Ray Tracing (accelerated by Vulkan) is justified when maximum physical fidelity is required, when generating reference datasets, or when illumination conditions fall outside the validity of interpolation. The Vulkan implementation makes this feasible for complex spacecraft where it was previously too costly.
Movable Panel Modeling is essential for spacecraft with large articulated solar arrays. Neglecting panel motion can lead to significant long-term trajectory errors, and the associated computational cost is considered acceptable given the improvement in simulation realism.

The authors propose a practical workflow: generate high-fidelity reference data via direct GPU ray tracing (incorporating articulated structures where necessary) and utilize SPAD-based interpolation for routine propagation, switching to direct evaluation only when interpolation validity is compromised.