GPU implementation of mixed quantum-classical Liouville molecular dynamics without momentum jump

arXiv:2608.14544 · physics.chem-ph, cond-mat.mtrl-sci, physics.comp-ph, quant-ph · Submitted 2026-08-14 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Physics. The day in general physics: instruments, methods and results across the field.

Kai: We're looking at the paper: "GPU implementation of mixed quantum-classical Liouville molecular dynamics without momentum jump".

Mira: Here's the gist of the paper. GPU implementation of mixed quantum-classical Liouville molecular dynamics without momentum jump is a study that introduces a momentum-jump-free theory of mixed quantum-classical Liouville molecular dynamics simulation on GPU architectures, achieving significant speedup by eliminating trajectory spawning The trajectory spawning that was previously implemented on CPU for sampling enhancement was eliminated to avoid the overhead of thread divergence and dynamic memory allocation on the GPU This achieved a speedup of an order of magnitude compared to the CPU computation with spawning, as well as a linear scaling with respect to the number of sampling trajectories Theoretical Framework The theoretical framework is based on a momentum-jump-free theory of mixed quantum-classical (QCL) Liouville molecular dynamics simulation This theory was derived from first principles under well-defined approximations, first taking the matrix element over the electronic basis and subsequently performing a partial Wigner transformation on the nuclear coordinates Because the resulting equations of motion do not contain the terms representing off-diagonal Hellmann-Feynman forces, which were interpreted as momentum-jump operations during nonadiabatic transitions, the numerical simulation is free from energy divergence near classical turning points associated with the momentum-jump The equation of motion for the density matrix element ραβ:W between states α and β after partial Wigner transformation on the nuclear degrees of freedom has been derived as

22, 23: GPU Implementation Details The GPU implementation avoids trajectory spawning by pre-allocating state variables for all walkers, including density matrix elements, coordinates, and momenta A GPU kernel is then launched at each time step to propagate the entire ensemble by one step The GPU code in Julia was implemented with the CUDA.jl library

29: The number of threads per block was set to 256, and the grid size (number of blocks) was determined via ceiling division to ensure that a sufficient number of blocks was allocated to cover all the walkers The reductions for ensemble average were performed with the mapreduce function rather than the @atomic addition, as the former ensures numerical reproducibility by maintaining a deterministic order of summation Simulation Models and Results The simulation models employed for numerical examination include the same models as in Refs.

21, 23: , specifically the three-dimensional spin-boson model and a two-state three-mode model of the S2 → S1 internal conversion of pyrazine For the three-mode spin-boson model, accuracy is comparable between the CPU and GPU simulations For the pyrazine S2 → S1 internal conversion, the simulation appears to have reasonably converged with 107 walkers, but 106 walkers would be sufficient to determine the decay rate The simulations with 108 walkers, which indicated more than sufficient convergence, were 67 times faster than those with CPU for both systems Scaling Performance The computation time was found to scale linearly with respect to the total number of simulated trajectories The GPU simulation achieved an order of magnitude speedup, although the exact factor would depend on the hardware specification This high parallel scalability is expected to benefit directly from ongoing developments in both hardware architectures (e.g., modern GPUs and unified memory) and software frameworks The present scheme is expected to benefit directly from ongoing developments in both hardware architectures (e.g.

Title and authors: Kai: Let's talk about who wrote this and what the title actually says. The paper "GPU implementation of mixed quantum-classical Liouville molecular dynamics without momentum jump" comes from Koji Ando at Tokyo Woman’s Christian University.

Mira: It’s interesting that the title immediately flags two major things: it's a GPU implementation, meaning hardware acceleration, and it's momentum-jump-free, which is the theoretical foundation they are using.

Lev: So what does this mean for us on real hardware? It means we aren't just running slow CPU code; we’re looking at how to map this specific quantum dynamics onto parallel processing units.

Kai: Right. The key part for me is that they specifically eliminated the trajectory spawning technique that was previously used on the CPU just to boost sampling, which is a huge simplification for the GPU version.

Mira: It simplifies things by making the number of walkers predetermined and avoiding non-deterministic behavior because you don't rely on random transition probabilities to decide when to spawn new trajectories.

Lev: That deterministic approach is exactly what we need when we move toward real hardware; you want predictable performance, not unpredictable thread divergence.

The paper's summary: Kai: So the paper summarizes how they did this GPU implementation without trajectory spawning, emphasizing that they pre-allocate state variables for all walkers at the beginning.

Mira: They detail the mathematical derivation of the equation of motion for each density matrix element, showing how it's derived from first principles by taking a matrix element over the electronic basis and then performing a partial Wigner transformation on the nuclear coordinates.

Lev: That equation they derive, which is shown on page two twenty-two through twenty-three, it’s complex; I need to know if this new GPU setup keeps that same theoretical foundation intact <ref:2608.14544#pg2>.

Kai: It does. The framework for the equation of motion for the density matrix element between states alpha and beta after partial Wigner transformation on the nuclear degrees of freedom is derived as shown in those references, twenty-two twenty-three <ref:2608.14544#pg2>.

Mira: And because their resulting equations of motion don't contain terms representing off-diagonal Hellmann-Feynman forces—which they interpret as momentum-jump operations during nonadiabatic transitions—the simulation stays free from energy divergence near classical turning points.

Lev: So they’re saying that by sticking to this specific theory, you get a cleaner numerical result, which is good because those divergences are usually where things break down on the CPU side.

The paper's improvements: Kai: The main improvement they highlight is the speedup achieved by eliminating trajectory spawning on the GPU compared to the CPU computation with spawning. They report an order of magnitude speedup for that comparison.

Mira: On top of that, they show linear scaling with respect to the number of sampling trajectories, which is a very strong performance claim for this type of simulation.

Lev: Linear scaling is what we’re aiming for when we talk about efficient large-scale ensembles; it means if you double the walkers, you roughly double the time needed on the GPU.

Kai: And they also mention that this entire setup allows them to test different models, like the three-dimensional spin-boson model and a two-state three-mode model for pyrazine internal conversion.

Mira: For those models, they show that accuracy is comparable between their CPU and GPU simulations for the spin-boson model. However, for the pyrazine S2 to S1 internal conversion, they note that convergence is reached with one hundred seven walkers, but one hundred six would actually be enough to determine the decay rate <ref:2608.14544#pg3,with 107 walkers, but 106>.

Lev: So it’s not just about speed; it’s about getting a reliable result efficiently. That distinction between one hundred six and one hundred seven walkers for the pyrazine case is important because it tells us where we can stop wasting compute time <ref:2608.14544#pg3>.

Conclusion: Kai: To wrap up, this GPU implementation of mixed quantum-classical Liouville molecular dynamics without momentum jump shows a significant speedup by removing the trajectory spawning overhead on the GPU. They demonstrated that this setup achieves linear scaling with respect to the number of sampling trajectories and performs well for models like the spin-boson and pyrazine internal conversion simulations.

Mira: The implication is that we can run these complex quantum dynamics ensembles much faster on modern hardware because they've streamlined the process by using a momentum-jump-free theory that avoids those problematic terms.

Lev: For running this on real hardware, the linear scaling is what matters most; it means we don't have to worry about sudden spikes in computation time when we increase the ensemble size. It’s predictable.

Kai: So, overall, this paper gives us a concrete way to run these simulations faster and more efficiently using GPU architecture by focusing on a deterministic method instead of relying on random spawning for every walker.

Mira: It moves the discussion toward how we can integrate these kinds of methods into broader quantum-classical simulations without getting bogged down in those trajectory spawning issues.

Lev: Yeah, it gives us a clear path forward for making these types of calculations practical on systems where memory and thread management are tight constraints.

Department of Information and Sciences, Tokyo Woman’s Christian University

physics.chem-ph, cond-mat.mtrl-sci, physics.comp-ph, quant-ph

Submitted: 2026-08-14

Updated: 2026-11-05

Comments: 5 pages, 5 figures

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 77/100

The gist: GPU implementation of mixed quantum-classical Liouville molecular dynamics without momentum jump is a study that introduces a momentum-jump-free theory of mixed quantum-classical Liouville molecular…

Key concepts

Mixed Quantum-Classical (QCL) Liouville Molecular Dynamics
This is a simulation method that combines quantum mechanics (for electronic states) and classical mechanics (for nuclear motion). It tracks how the system evolves by considering both the quantum state changes and the classical movement of atoms over time.
Momentum-Jump-Free Theory
The theoretical foundation avoids terms in the equations of motion that represent 'momentum jumps,' which are typically associated with nonadiabatic transitions. This mathematical approach ensures numerical stability near classical turning points, preventing energy divergence during simulation.
Trajectory Spawning Elimination
Previously, sampling enhancement required creating new trajectories on the CPU at each step. This GPU implementation avoids this overhead by pre-allocating memory for all necessary walkers upfront and running a single kernel to propagate the entire ensemble simultaneously.

Terminology

Summary

GPU implementation of mixed quantum-classical Liouville molecular dynamics without momentum jump is a study that introduces a momentum-jump-free theory of mixed quantum-classical Liouville molecular dynamics simulation on GPU architectures, achieving significant speedup by eliminating trajectory spawning The trajectory spawning that was previously implemented on CPU for sampling enhancement was eliminated to avoid the overhead of thread divergence and dynamic memory allocation on the GPU This achieved a speedup of an order of magnitude compared to the CPU computation with spawning, as well as a linear scaling with respect to the number of sampling trajectories

Theoretical Framework

The theoretical framework is based on a momentum-jump-free theory of mixed quantum-classical (QCL) Liouville molecular dynamics simulation This theory was derived from first principles under well-defined approximations, first taking the matrix element over the electronic basis and subsequently performing a partial Wigner transformation on the nuclear coordinates Because the resulting equations of motion do not contain the terms representing off-diagonal Hellmann-Feynman forces, which were interpreted as momentum-jump operations during nonadiabatic transitions, the numerical simulation is free from energy divergence near classical turning points associated with the momentum-jump The equation of motion for the density matrix element ραβ:W between states α and β after partial Wigner transformation on the nuclear degrees of freedom has been derived as [22, 23]

GPU Implementation Details

The GPU implementation avoids trajectory spawning by pre-allocating state variables for all walkers, including density matrix elements, coordinates, and momenta A GPU kernel is then launched at each time step to propagate the entire ensemble by one step The GPU code in Julia was implemented with the CUDA.jl library [29] The number of threads per block was set to 256, and the grid size (number of blocks) was determined via ceiling division to ensure that a sufficient number of blocks was allocated to cover all the walkers The reductions for ensemble average were performed with the mapreduce function rather than the @atomic addition, as the former ensures numerical reproducibility by maintaining a deterministic order of summation

Simulation Models and Results

The simulation models employed for numerical examination include the same models as in Refs. [21, 23], specifically the three-dimensional spin-boson model and a two-state three-mode model of the S2 → S1 internal conversion of pyrazine For the three-mode spin-boson model, accuracy is comparable between the CPU and GPU simulations For the pyrazine S2 → S1 internal conversion, the simulation appears to have reasonably converged with 107 walkers, but 106 walkers would be sufficient to determine the decay rate The simulations with 108 walkers, which indicated more than sufficient convergence, were 67 times faster than those with CPU for both systems

Scaling Performance

The computation time was found to scale linearly with respect to the total number of simulated trajectories The GPU simulation achieved an order of magnitude speedup, although the exact factor would depend on the hardware specification This high parallel scalability is expected to benefit directly from ongoing developments in both hardware architectures (e.g., modern GPUs and unified memory) and software frameworks The present scheme is expected to benefit directly from ongoing developments in both hardware architectures (e. p. 3

Where the paper says it

Thanks to its high parallel scalability, the present scheme is expected to benefit directly from ongoing developments in both hardware architectures (e. , modern GPUs and unified memory) and software frameworks (such as QM/MM, fragment-based methods, multiple time-scale schemes).

g.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Enhanced simulation speed for mixed quantum-classical Liouville molecular dynamics by implementing a GPU implementation without trajectory spawning, achieving an order of magnitude speedup compared to CPU computation with spawning.

  2. The improved AI system can perform massively parallel computation over 107 to 108 trajectories efficiently on modern graphics processing unit architectures using the Julia language and CUDA.

  3. The system can scale linearly with respect to the number of simulated trajectories, allowing for efficient handling of large ensembles without incurring thread divergence or dynamic memory allocation overheads on GPUs.

  4. For chemical processes like S2 → S1 internal conversion, the system can accurately determine decay rates using a total of 107 walkers, demonstrating convergence within 20 femtoseconds for certain models.

  5. The framework can be seamlessly integrated into standard classical MD simulations because nuclear motion is governed by classical mechanics, enabling its use in systems ranging from gas and condensed phases to biological macromolecules.

Abstract

We implemented on GPU a mixed quantum-classical Liouville molecular dynamics simulation based on a momentum-jump-free theory. The trajectory spawning that was previously implemented on CPU for sampling enhancement was eliminated to avoid the overhead of thread divergence and dynamic memory allocation on the GPU. The method was applied to a three-dimensional spin-boson model and a three-mode model of S 2 to S 1 internal conversion in pyrazine involving a conical intersection. A speedup of an order of magnitude compared to the CPU computation with spawning was achieved, as well as a linear scaling with respect to the number of sampling trajectories.

Related papers