New geometric integration method could make long-duration spacecraft and binary-asteroid simulations more accurate, and potentially more computationally efficient
Every supercomputer simulation of an asteroid conceals a fundamental challenge. Although these systems can execute trillions of calculations per second, excessive computing power does not guarantee improved accuracy if the underlying numerical method gradually deviates from physical reality. In long-duration orbital simulations, minute numerical errors can accumulate, eventually causing a theoretically stable trajectory to deviate into an artifact of the simulation rather than a reflection of physics.
A recent study by researchers at Liaoning University and the Beijing Institute of Spacecraft Environment Engineering addresses this critical issue. The team has developed a numerical integration approach utilizing Hamel’s variational integrators to simulate the coupled orbital and rotational dynamics of binary asteroid systems. Their findings demonstrate that this method preserves essential geometric and physical properties more effectively than comparable Lie-group variational formulations, while requiring fewer computational operations. Furthermore, the approach exhibits significantly superior conservation of energy and rotational structure compared to conventional Runge–Kutta integration.
This development is particularly significant for high-performance computing (HPC). The research transcends the simple task of predicting asteroid positioning; it focuses on engineering numerically robust algorithms that maintain physical fidelity when modeling complex gravitational systems over extended timeframes. This pursuit represents the core objective of modern HPC applications.
When four asteroids become one difficult computing problem
The study, published in Space: Science & Technology (https://spj.science.org/doi/10.34133/space.0450), examines what the researchers call the full two-body problem involving two binary asteroids.
Each binary asteroid pair is approximated as a rigid “dumbbell”: two asteroids connected by a massless rod. The researchers assume the distance between the two members of each binary remains constant, allowing the pair to be treated as a rigid body.
That simplification still leaves a formidable computational problem.
Each dumbbell possesses both translational and rotational motion. The gravitational interaction therefore depends not only on where the bodies are located but also on how they are oriented.
The researchers formulate the system using SE(3), the special Euclidean group, which combines three-dimensional translation and rotation into a single mathematical framework. Rather than describing orientation with conventional Euler angles, the approach works directly with the geometry of rotations.
That matters computationally because the numerical representation itself becomes part of the physics.
Euler-angle formulations can encounter singularities, while the Lie-group formulation maintains the rotational configuration directly on the appropriate mathematical manifold. The researchers then formulate both continuous and discrete equations using Hamel’s formalism and derive a discrete integrator from Hamilton’s principle.
The resulting algorithm is a second-order variational integrator.
That phrase may sound like mathematical machinery for its own sake. It isn’t.
For an HPC engineer, it translates into a very practical question:
How many floating-point operations does it take to advance the simulation one step, and how much physical error accumulates while doing it?
The supercomputer problem is not just FLOPS
Traditional numerical integration methods such as Runge–Kutta are extremely useful because they are relatively straightforward and can provide high accuracy over individual integration steps.
But long-running orbital mechanics introduces another requirement: the numerical method must respect the underlying structure of the physical system.
The researchers compare Hamel’s method against both Lie-group variational integration and Runge–Kutta methods.
Their argument is that conventional integration can gradually violate quantities that should remain structurally constrained. In particular, the rotation matrix must remain orthogonal. If it drifts away from that condition, the computed orientation begins to contaminate the force and torque calculations.
That creates a feedback loop: numerical error → incorrect attitude → incorrect force/torque → additional numerical error.
The paper reports that this problem becomes particularly important for full-body dynamics because gravitational forces and torques depend simultaneously on position and attitude.
This is where a massively parallel computer can encounter an ironic limitation.
More processors can reduce wall-clock time, but they cannot repair a numerical algorithm that is systematically drifting away from the physics.
A better algorithm can.
Symplectic mathematics meets HPC efficiency
The researchers’ approach is based on preserving the symplectic structure of the underlying dynamical system.
Symplectic integrators are designed around the geometry of Hamiltonian mechanics rather than simply approximating derivatives. Their advantage becomes particularly important when simulations extend over many thousands, millions or potentially billions of integration steps.
In the study, both Hamel’s and Lie-group variational integrators preserve total energy and the Lie-group structure. The researchers report that Hamel’s formulation provides better structural preservation for comparable error magnitudes.
That is potentially important for future HPC workloads.
Consider a spacecraft mission simulation requiring a very long time horizon. If an integration method introduces a tiny error at every step, the computational cost can eventually become dominated by the need to reduce the timestep sufficiently to keep that error under control.
A structure-preserving method attacks the problem from a different direction.
Instead of simply calculating more steps, it attempts to make every step more physically meaningful.
That is a classic HPC optimization opportunity: reduce computational work by improving the algorithm rather than merely increasing the hardware.
The surprising result: the implicit method can be faster
Perhaps the most interesting performance result in the paper is that Hamel’s method is implicit, yet can require less computational work than the competing methods.
That sounds counterintuitive.
Implicit numerical schemes generally require equations to be solved during each timestep, while explicit schemes can advance the solution more directly.
But the details matter.
The researchers report that their Hamel formulation requires fewer operations than the Lie-group variational integrator because the implicit equations are expressed using Lie-algebra elements rather than Lie-group elements.
As a result, Hamel’s approach shows slightly higher computational efficiency in the comparison.
The comparison with Runge–Kutta is even more revealing.
The second-order explicit Runge–Kutta method requires two evaluations of the governing equations during each timestep. Each evaluation involves force and moment calculations, which are computationally expensive for this full-body problem.
Hamel’s method, although implicit, requires only one evaluation per step according to the study.
The authors note that this difference can become increasingly significant as the physical model or integrator order becomes more complex.
For HPC architects, this is a familiar lesson: The fastest algorithm is not necessarily the one with the fewest mathematical complications. It is the one that minimizes total computational work for the required accuracy.
Irregular asteroids make the problem more interesting
The researchers tested two configurations.
The first uses regular-shaped dumbbells consisting of identical rigid spheres connected by massless rods.
The second introduces irregularly shaped bodies and a more complicated gravitational potential.
That second case is particularly relevant to real asteroid dynamics.
Real asteroids are not spheres. Their irregular shapes affect both their gravitational fields and their rotational dynamics. The resulting forces can therefore alter spacecraft trajectories in ways that simplified point-mass models cannot capture.
The paper’s simulations show a noticeable trajectory deviation caused by the irregular geometry, particularly along the y direction. The researchers conclude that irregular planetary geometry can have a substantial influence on the resulting motion in full n-body dynamics.
For supercomputing, that creates a natural scaling path.
A simulation can move from: point masses → rigid bodies → irregular bodies → variable shapes → full n-body systems.
Every step increases the computational burden.
Every step also increases the value of numerical methods capable of preserving the underlying physics.
Where the HPC workload could explode
The current research should not be confused with a production-scale exascale asteroid simulation.
The paper reports CPU-time comparisons for the numerical methods; it does not claim that the experiments were executed on a TOP500-class supercomputer. That distinction is important.
But the algorithmic implications are much larger than the benchmark itself.
A future asteroid-dynamics workload could incorporate:
- multiple interacting asteroids;
- nonuniform mass distributions;
- high-resolution shape models;
- variable inter-asteroid distances;
- spacecraft proximity operations;
- solar radiation pressure;
- planetary perturbations;
- large ensembles of initial conditions;
- uncertainty quantification;
- trajectory optimization; and
- Monte Carlo searches across millions of possible orbital states.
At that point, the numerical integrator becomes part of the HPC architecture.
A simulation campaign might require thousands or millions of independent trajectories. A structure-preserving algorithm that reduces the computational cost of each trajectory can therefore have an outsized effect on total cluster utilization.
The paper’s authors themselves identify variable inter-asteroid distance as an important direction for future work.
That could make the problem considerably more computationally demanding because the rigid-dumbbell assumption would no longer remove an internal degree of freedom.
And then there is China’s rapidly changing supercomputing landscape
The research also arrives at an interesting moment for Chinese HPC.
China’s supercomputing capability has recently taken a dramatic step forward on the public TOP500 benchmark.
In June 2026, LineShine, installed at the National Supercomputing Centre in Shenzhen, debuted at No. 1 on the TOP500 with a measured 2.198 exaflops on HPL. According to TOP500, the system contains approximately 13.79 million CPU cores, uses China’s custom LingKun platform and LX2 processors, a proprietary LingQi interconnect and Kylin operating system.
The architectural detail is particularly notable.
LineShine is reported as a CPU-only exascale system, rather than relying on GPUs or other accelerators for its HPL result. TOP500 reports 2.198 exaflops of sustained HPL performance against a theoretical peak of 2.736 exaflops, approximately 80 percent of peak.
China’s improvement is not confined to the headline HPL number.
LineShine also took the top position on the HPCG benchmark, with 22.00 petaflops. HPCG is intended to represent computational patterns more closely associated with many real scientific applications than the highly optimized dense linear algebra used by HPL.
That is particularly relevant to the kind of computational science represented by the asteroid study.
HPC workloads are rarely just giant matrix multiplications.
Real scientific codes contain irregular memory accesses, synchronization, sparse calculations, nonlinear solvers and communication-heavy operations. An improvement in systems capable of handling those workloads matters just as much as an improvement in peak FLOPS.
From exaflops to better physics
There is therefore an interesting convergence taking place.
China is increasing the raw computational capability available for scientific computing while researchers are simultaneously improving the algorithms that determine how effectively that hardware can be used.
The asteroid paper represents the second half of that equation.
A supercomputer may have millions of cores, but the scientific result still depends on the numerical method running across those cores.
A poorly conditioned or physically drifting algorithm can turn enormous computational capacity into enormous computational waste.
A structure-preserving integrator can potentially allow the same hardware to simulate longer time horizons, larger ensembles or more complicated physical models without simply reducing the timestep until the computation becomes impractical.
The paper’s results show that Hamel’s variational integrators maintain low energy and orthogonality errors while also providing favorable CPU-time behavior. The researchers conclude that the approach offers a practical numerical method for full-body dynamics.
The bigger HPC question
The most compelling question prompted by this research is not merely the level of accuracy achievable in modeling binary asteroid systems, but whether future supercomputing efforts should prioritize the reduction of error-correction overhead in favor of deeper physical exploration.
Asteroid dynamics provide a rigorous test case, as the interplay between position, velocity, attitude, gravitational potential, angular momentum, and energy is unforgiving; even minute numerical deviations can lead to significant orbital inaccuracies over time. The researchers’ methodology compels the computational model to maintain fidelity to the underlying physical mathematics throughout the simulation.
This philosophy is increasingly vital as scientific computing scales to exascale levels and beyond. While China’s LineShine system exemplifies the vast potential of raw computational capacity, the research from Liaoning University highlights the essential, complementary challenge: ensuring that such power is translated into reliable scientific insight. Ultimately, the future of high-performance computing will depend not only on increasing floating-point operations but also on implementing the sophisticated mathematics necessary to ensure those operations remain physically meaningful.