PyQCAMS: Python Quasi-Classical Atom–Molecule Scattering

Abstract

We present Python Quasi-classical atom–molecule scattering (PyQCAMS v0.1.0), a new Python package for atom–diatom scattering within the quasi-classical trajectory approach. The input consists of the mass, collision energy, impact parameter, and pair-wise/three-body interactions. As the output, the code provides the vibrational quenching, dissociation, and reactive cross sections along with the rovibrational energy distribution of the reaction products. We benchmark the program for a reaction involving a molecular ion in a high-density ultracold gas, RbBa⁺ + Rb. Furthermore, we treat H₂ + Ca → CaH + H reactions as a prototypical example to illustrate the properties and performance of the software. Finally, we study the parallelization performance of the code by looking into the speedup of the program as a function of the number of CPUs used.

1. Introduction

For decades, one of the main approaches to studying molecular dynamics has been via the quasi-classical trajectory (QCT) method [1,2]. This technique treats collisions semi-classically. The nuclear dynamics in the underlying potential energy surface are treated classically. However, the initial and final states are chosen following the Bohr–Sommerfeld quantization rule, yielding accurate predictions at significantly less cost than quantum dynamics as long as they fall within given conditions—i.e., a high collision energy with a large number of contributing partial waves [3]. QCT has been used in a multitude of scenarios relevant to chemical physics [4,5,6,7,8,9,10] and cold and ultracold chemistry [11,12,13], ranging from the ultracold to the hyperthermal regimes. In particular, it has been used to study the relaxation and reaction dynamics of cold atom–ionic molecule [11,12] and atom–molecule collisions [14].

We present an open-source object-oriented program written in Python to perform QCT calculations on atom–diatom systems called Python Quasi-Classical Atom–Molecule Scattering (PyQCAMS). While chemical dynamics programs such as Gaussian [15] and VENUS [16] are capable of performing QCT calculations, we introduce a more accessible, user-friendly, and dedicated path to performing these simulations. Our program consists of completely open-source software and relies mainly on the NumPy [17] and SciPy [18] packages. We use matplotlib [19] for data visualization, pandas [20] for data storage and analysis, and multiprocess [21,22] for parallel implementation.

The outline of this paper is as follows: In Section 2.1 we discuss the theory behind the quasi-classical trajectories method, including the initial conditions, trajectory reactions, and analysis. In Section 2.2, we discuss the PyQCAMS program as separated into the inputs, main code, and outputs. We also discuss the implementation and performance of the program. In Section 3, we provide a benchmark study on the reaction RbBa⁺ + Rb as well as an example of a typical workflow to study the reaction H₂ + Ca, where we outline how a user can obtain reaction rates and product distributions using the program.

2. Materials and Methods

2.1. Theoretical Approach

In this section, we describe the basics of the QCT. The QCT method treats scattering processes semi-classically. The trajectories are calculated by solving Newton’s equations of motion of the colliding nuclei. In the case of atom–molecule scattering, at the start of each trajectory, the rovibrational spectrum is calculated following a discrete variable representation (DVR) method using particle-in-a-box eigenfunctions [23]. The internal degrees of freedom of the final molecule are treated within the Wentzel–Kramers–Brillouin (WKB) approximation, such that the final rovibrational state ($v^{\prime },j^{\prime }$) satisfies a quantum mechanically viable state. The classical Hamiltonian for a 3-particle atom–molecule system with masses $m_i$, $i=1,2,3$ takes the following form:

$$H=\sum _{i=1}^3\frac{{\overrightarrow{p}}_i^2}{2m_i}+V({\overrightarrow{r}}_1,{\overrightarrow{r}}_2,{\overrightarrow{r}}_3),$$

(1)

where ${\overrightarrow{p}}_i$ and ${\overrightarrow{r}}_i$ represent the momentum and position vectors of each atom with respect to the origin. This Hamiltonian is expressed in Jacobi coordinates as

$$H=\frac{{\overrightarrow{P}}_1^2}{2{\mu }_{12}}+\frac{{\overrightarrow{P}}_2^2}{2{\mu }_{3,12}}+V({\overrightarrow{\rho }}_1,{\overrightarrow{\rho }}_2),$$

(2)

where ${\overrightarrow{\rho }}_1$ is the Jacobi vector associated with the molecule, and ${\overrightarrow{P}}_1$ is its conjugate momentum. ${\overrightarrow{\rho }}_2$ is the Jacobi vector connecting the atom with the center of mass of the molecule, and ${\overrightarrow{P}}_2$ is its conjugate momentum, as shown in Figure 1. Note that this Hamiltonian uses the reduced masses of the corresponding atoms: ${\mu }_{12}={(\frac{1}{m_1}+\frac{1}{m_2})}^{-1}$ and ${\mu }_{3,12}={(\frac{1}{m_3}+\frac{1}{m_1+m_2})}^{-1}$. Defining the coordinates in this way separates the center-of-mass degree of freedom from the relative one. The momentum associated with the center-of-mass degrees of freedom is a constant of motion, since the interaction potentials do not depend on the center-of-mass position, and is neglected in the analysis of the dynamics.

We trace the atoms’ subsequent motion by solving Hamilton’s equations of motion:

$$\frac{d{\rho }_{i,\alpha }}{dt}=\frac{\partial H}{\partial P_{i,\alpha }}$$

(3)

$$\frac{d{P}_{i,\alpha }}{dt}=-\frac{\partial H}{\partial {\rho }_{i,\alpha }}$$

(4)

for $i=1,2$ for each associated vector, and $\alpha =1,2,3$ for each Cartesian component.

2.1.1. Initial Conditions

The initial orientation angles are randomly generated to initialize each trajectory. The momentum of the molecule, ${\overrightarrow{P}}_1$, is subsequently defined by the orientation angles. If we initialize the molecule at its classical outer turning point $|{\overrightarrow{\rho }}_1|=r_{+}$, the momentum has no radial component. Since the angular momentum $\overrightarrow{J}=\overrightarrow{r}\times \overrightarrow{p}$, and ${\overrightarrow{\rho }}_1\perp {\overrightarrow{P}}_1$, we find the magnitude of $P_1=\hslash \sqrt{j(j+1)}/r_{+}$, with the following components [3]:

$${\overrightarrow{P}}_1=P_1\left(\begin{array}{c}sin\varphi cos\eta -cos\theta cos\varphi sin\eta \\ -cos\varphi cos\eta -cos\theta sin\varphi sin\eta \\ sin\theta sin\eta \end{array}\right).$$

(5)

The angles $\varphi ,\theta ,\eta$ are defined in Figure 1. The relative momentum between the colliding atom and the molecule center for a given collision energy, $E_c$, is ${\overrightarrow{P}}_2=\sqrt{2{\mu }_{3,12}{E}_c}$. The initial vibrational phase is randomly sampled by choosing the initial distance between the atom and molecule as

$$R=R_0+\frac{\zeta P_2{\tau }_{v,j}}{{\mu }_{3,12}},$$

(6)

where $R_0$ is a fixed far-away distance, where the interaction potential strength is negligible. The second term probes the molecule’s vibrational phase since $\zeta \in [0,1]$ is randomly generated following a uniform distribution, and ${\tau }_{v,j}$ is the vibrational period of the molecule corresponding to the quantum mechanical state ($v,j$). This is calculated as

$${\tau }_{v,j}=\sqrt{2{\mu }_{12}}{\int }_{r_{-}}^{r_{+}}{\left[E_{int}-V\left(r_{12}\right)-\frac{{\hslash }^{2}j(j+1)}{2{\mu }_{12}{r}_{12}^2}\right]}^{-\frac{1}{2}}d{r}_{12},$$

(7)

where $V\left(r_{12}\right)$ is the molecular potential energy, and $r_{12}$ is the molecular separation. $E_{int}$ is the internal energy of the molecule, which is calculated via a DVR method. The bounds of the integral are given by the classical inner and outer turning points of the bound state, $r_{-}$ and $r_{+}$, respectively.

2.1.2. Final Products

For the atom–molecule reaction AB + C, we expect three possible final products (see Figure 2):

• Inelastic collision (quenching): AB($v,j$) + C → AB($v^{\prime },j^{\prime }$) + C;
• Molecular formation (reaction): AB + C → AC + B or BC + A;
• Dissociation: AB + C → A + B + C.

The final product is determined by the relative energy between each atom. The condition for whether two atoms are bound is determined by the effective potential:

$$E_{ij}<\left\{\begin{array}{cc}{V}_{ij}\left(r_0\right)+\frac{j^{\prime }(j^{\prime }+1)}{2{\mu }_{ij}{r}_0^2}\hfill & j^{\prime }\ne 0\hfill \\ 0\hfill & j^{\prime }=0\hfill \end{array}\right.,$$

(8)

where $r_0$ is the local maximum of the effective potential. Here, $i,j\in [1,3]$, $i\ne j$ represent each of the atoms. Two atoms are considered bound only if this condition is satisfied for just one pair of atoms, so that the other two pairs can be deemed unbound.

The final states $(v^{\prime },j^{\prime })$ are calculated within the WKB approximation. The rotational quantum number is given by

$$j^{\prime }=-\frac{1}{2}+\frac{1}{2}\sqrt{1+4\frac{\overrightarrow{J^{\prime }}·\overrightarrow{J^{\prime }}}{{\hslash }^2}},$$

(9)

where $\overrightarrow{J}={\overrightarrow{\rho }}_i\times {\overrightarrow{P}}_i$ is the effective conjugate angular momentum of the Jacobi vector ${\overrightarrow{\rho }}_i$. This expression is equivalent to $\overrightarrow{J}·\overrightarrow{J}=j(j+1){\hslash }^2$. After rounding $j^{\prime }$ to the nearest integer number, the vibrational quantum number is given by [2]

$$v^{\prime }=-\frac{1}{2}+\frac{\sqrt{2{\mu }_{ab}}}{\pi \hslash }{\int }_{r_{-}}^{r_{+}}{\left[E_{int}^{\prime }-V\left(r_{ab}\right)-\frac{{\hslash }^2{j}^{\prime }(j^{\prime }+1)}{2{\mu }_{ab}{r}_{ab}^2}\right]}^{\frac{1}{2}}dr.$$

(10)

Although these equations lead to continuous numbers, they need to be interpreted as integers before assigning them as quantum numbers. One may choose to round to the nearest number via histogram binning (HB) or through the Gaussian binning (GB) process, where each rovibrational action ($x=v^{\prime },j^{\prime }$) is weighted against its nearest integer $x_t$ with a Gaussian  [24,25]:

$$W(x^{\prime },x_t)=\frac{1}{\sigma \sqrt{\pi }}{e}^{\frac{-|x^{\prime }-x_t{|}^2}{{\sigma }^2}}$$

(11)

with $\sigma =0.05$. The Gaussian weight of a trajectory ending in $(v^{\prime },j^{\prime })$ is

$$W(v^{\prime },j^{\prime })=W(v^{\prime },v_t)W(j^{\prime },j_t).$$

(12)

2.1.3. Analysis

The cross-section and reaction rate coefficients for an atom–molecule collision are calculated from the QCT simulations. The first step is to calculate the opacity function, which is formally defined as

$$P_{q,r,d}(E_c,b)=\int P_{q,r,d}(E_c,b,\theta ,\varphi ,\eta ,\chi )d\mathrm{\Omega },$$

(13)

where $d\mathrm{\Omega }=sin\theta d\theta d\varphi d\eta d\chi$, and $P_{q,r,d}$ represent the opacity function of a quenching, reaction, and dissociation product, respectively. This integral is evaluated via the Monte Carlo technique over the randomly generated variables $\theta ,\varphi ,\eta ,\mathrm{and}\chi$, with an error associated with one standard deviation:

$$P_{q,r,d}(E_c,b)=\frac{N_{q,r,d}(E_c,b)}{N}\pm \frac{\sqrt{N_{q,r,d}(E_c,b)}}{N}\sqrt{\frac{N-N_{q,r,d}(E_c,b)}{N}}.$$

(14)

The final state-specific opacity of a reaction initialized in state $(v_i,j_i)$ with collision energy $E_c$ and impact parameter b, and ending in state $(v^{\prime },j^{\prime })$ is calculated via the GB method [26]:

$$P_r(E_c,b;v^{\prime },j^{\prime })=\frac{{\sum }_{i=1}^{N_r}{W}_r^i(v^{\prime },j^{\prime })}{W}\pm \frac{\sqrt{{\sum }_{i=1}^{N_r}{W}_r^i(v^{\prime },j^{\prime })}}{W}\sqrt{\frac{W-{\sum }_{i=1}^{N_r}{W}_r^i(v^{\prime },j^{\prime })}{W}},$$

(15)

where $N_r$ is the number of reactive trajectories, and the total weight W is evaluated as

$$W=\sum ^{N}W(v^{\prime },j^{\prime })+N_d,$$

(16)

where N is the total number of trajectories, and $N_d$ is the number of dissociation trajectories. Each dissociation reaction has a weight $W_d=1$ since there is no rovibrational state associated with this product.

The opacity function yields the state-specific scattering cross section at different collision energies $E_c$:

$${\sigma }_{q,r,d}(E_c;v^{\prime },j^{\prime })=2\pi {\int }_0^{b_{\max }^{q,r,d}}{P}_{q,r,d}(E_c,b;v^{\prime },j^{\prime })bdb,$$

(17)

where $b_{\max }$ is defined such that $P(E_c,b_{max})=0$ for a given reaction channel. The rate coefficient is given by

$$k_{q,r,d}\left(E_c\right)={\sigma }_{q,r,d}\left(E_c\right)\sqrt{\frac{2E_c}{\mu }}.$$

(18)

2.2. The Program

PyQCAMS is written in an object-oriented manner, containing two main classes: Molecule and Trajectory. This treats molecules and trajectories as objects, tracing relevant attributes for each calculation, as outlined in Figure 3. The program takes an input, where the user specifies the details of the reaction of interest. The variables are passed into their respective classes, where the trajectory calculations are performed. The results of each trajectory are then output into a user specified file. The details of each step are outlined in this section.

2.2.1. Input

For a given system, a new Python script should be created with a dictionary containing the calculation input, as shown in Listing 1. The script contains the masses of all three atoms, where atoms 1 and 2 form the initial molecule, and atom 3 is the colliding atom. Each trajectory is defined by the collision energy (E0) in Kelvin, the impact parameter (b0) in Bohr, and the initial distance between the atom and molecule (R0) in Bohr.

Listing 1. Python script for a full QCT calculation of the reaction H + Ca. This example uses the Morse function from the potentials module, with appropriate parameters set. v12 always refers to the initial bound molecule. v123 is the three-body potential function, with associated derivatives. This example uses the Axilrod#–Teller model potential but with a coefficient of 0; so, it includes no three-body effects.

import numpy as np from pyqcams import qct, constants, potentials   # Atomic masses (amu converted to atomic units) m1 = 1.008∗constants.u2me # H m2 = 1.008∗constants.u2me # H m3 = 40.078∗constants.u2me # Ca   # Collision parameters E0 = 40000 # collision energy (K) b0 = 0 # Impact parameter (Bohr) R0 = 50 # Initial distance (Bohr)   # Potential parameters in atomic units v12, dv12 = potentials.morse(de = 0.16456603489, re = 1.40104284795, alpha = 1.059493476908482) v23, dv23 = potentials.morse(de = 0.06529228457, re = 3.79079033313, alpha = 0.6906412379896358) v31, dv31 = potentials.morse(de = 0.06529228457, re = 3.79079033313, alpha = 0.6906412379896358)   # Three-body interaction v123, dv123dr12, dv123dr23, dv123dr31 = potentials.axilrod(C=0)   # Initiate molecules mol12 = qct.Molecule(mi = m1, mj = m2, Vij = v12, dVij = dv12,                         xmin = .5, xmax = 30, vi = 1, ji = 0, npts=1000) mol23 = qct.Molecule(mi = m2, mj = m3, Vij = v23, dVij = dv23,                         xmin = 1, xmax = 40) mol31 = qct.Molecule(mi = m3, mj = m1, Vij = v31, dVij = dv31,                         xmin = 1, xmax = 40)   input_dict = {’m1’:m1, ’m2’:m2, ’m3’:m3,     ’E0’: E0, ’b0’: b0, ’R0’: R0, ’seed’: None,     ’mol_12’: mol12, ’mol_23’: mol23, ’mol_31’: mol31,     ’vt’: v123, ’dvtdr12’: dv123dr12,     ’dvtdr23’: dv123dr23, ’dvtdr31’: dv123dr31,     ’integ’:{ ’t_stop’: 2, ’r_stop’: 2, ’r_tol’: 1e-10,         ’a_tol’:1e-8, ’econs’:1e-5, ’lcons’:1e-5}}   if __name__ == ’__main__ ’:     bs = np.arange(0,5,0.25) # Range of impact parameters (Bohr)     nTraj = 10000 # Number of   trajectories     short_out = ’short.txt’ # Short output     long_output = ’long.txt’ # Long output       # Run over a range of impact parameters     for b in bs:         input_dict [’b0’] = b         qct.runN (nTraj, input_dict, short_out = ’short.txt’,                 long_out = ’long.txt’)       # Analysis     mu = m3∗m1∗m2/(m1 + m2 + m3)     analysis.opacity (’samplelong.txt’,GB = True, vib = True, rot = False, output = ’opacity.txt’)     analysis.crossSection (’samplelong.txt’, GB = True, vib = True, rot = False, output = ’sigma.txt’)     analysis.rate (’samplelong.txt’, mu = mu, GB = True, vib = True, rot = False, output = ’rate.txt’)

Next, the interaction potential between each atom and their derivatives is defined in atomic units. The user should define all two-body and three-body interactions (and their derivatives). These can be user-defined functions or chosen from the potentials module, which has a selection of analytical potentials and their derivatives for two-body and three-body interactions. One may fit ab initio potential curves and surfaces to a functional form for the trajectory calculation [27], which includes both two and three-body interactions. This functional form is provided in potentials as poly2 and poly3, inspired by [28]. The potentials offered in potentials are

• Two-Body Terms

  (a)

  Morse: $V\left(r\right)=D_e{\left(1-{exp}^{(-\alpha (r-r_e))}\right)}^2-D_e$

  User defines: $D_e,\alpha ,r_e$;

  (b)

  Generalized Lennard–Jones: $V\left(r\right)=C_m/r^m-C_n/r^n$

  User defines: $m,n,C_m,C_n$;

  (c)

  Buckingham: $V\left(r\right)=a{e}^{-br}-C_6/r^6$

  User defines: $a,b,C_6$;

  (d)

  poly2: $V\left(r\right)=\frac{C_0{e}^{-\alpha r}}{r}+{\displaystyle \sum _{i=1}^N}{c}_i{\rho }^i$, $\rho =r{e}^{-\beta r}$

  User defines: $C_0,\alpha ,\beta ,c_i$.

• Three-Body Terms

  (a)

  Axilrod–Teller [29]: $V(r_{12},r_{23},r_{31})=C\frac{3cos{\gamma }_{1}cos{\gamma }_{2}cos{\gamma }_3+1}{r_{12}^3{r}_{23}^3{r}_{31}^3}$

  User defines: C;

  (b)

  poly3: $V(r_{12},r_{23},r_{31})={\displaystyle \sum _{i,j,k}^M}{d}_{ijk}{\rho }_{12}^i{\rho }_{23}^j{\rho }_{31}^k$, ${\rho }_{\mu \nu }=r_{\mu \nu }{e}^{-{\beta }_{\mu \nu }{r}_{\mu \nu }}$

  User defines: $d_{ijk},{\beta }_{\mu \nu }.$

Three molecules representing the three possible reaction products should be initiated via the molecule class, with the following keyword arguments (‘mi’, ‘mj’, ‘Vij’, ‘dVij’, ‘xmin’, ‘xmax’). Here, ‘mi,mj’ are the masses of atoms ‘i’ and ‘j’, ‘Vij,dVij’ are the interaction potential and its derivative between those atoms, and ‘xmin,xmax’ represent the range of the interaction potential. Note that since molecule ‘12’ is initially bound, one should also define their initial vibrational and rotational quantum numbers, ‘vi,ji’. A DVR method is used to calculate the energy corresponding to this rovibrational state, so the user can control the number of DVR points with the keyword ‘npts’, which is set to 1000 by default. If the rovibrational spectrum is known, the DVR method can be skipped by setting the binding energy of the molecule using the keyword argument ’Ei’.

The main input requirement of PyQCAMS is a dictionary containing all of the previously defined parameters necessary for a QCT calculation. In addition, the dictionary should contain the three-body interaction term ‘Vt’ and its partial derivatives ‘dVtdr12, dVtdr23, dVtdr31’. To neglect the three-body interaction, just set these functions to 0. Finally, the parameters for integration should be entered in the nested dictionary ‘integ’. The user can choose when to stop a trajectory using ‘t_stop’, which is a multiplicative factor of the trajectory’s time scale. Another stopping condition is the maximum distance between any two atoms, ‘r_stop’, which is a multiplicative factor of the initial distance ‘R0’. Finally, the absolute and relative tolerances of the integrator can be controlled with ‘a_tol’ and ‘r_tol’, respectively. For reproducibility, the user can input a ‘seed’ for the random number generator or leave it as null to generate a new trajectory. The keywords for this dictionary are described in

Table 1. Keywords for the input dictionary required in the input file of PyQCAMS.

Keyword	Description (Unit)
m1, m2, m3	Atomic masses (a.u.)
E0	Collision energy (Kelvin)
b0	Impact parameter (Bohr)
R0	Initial distance (Bohr)
seed	Random number generator seed
mol_12	Molecule class object: of atoms one and two (initially bound)
mol_23	Molecule class object: of atoms two and three
mol_31	Molecule class object: of atoms three and one
Vt	Three-body interaction term $V_t$ (Hartree)
dVtdr12	Partial derivative $\partial V_t/\partial r_{12}$ (Hartree)
dVtdr23	Partial derivative $\partial V_t/\partial r_{23}$ (Hartree)
dVtdr31	Partial derivative $\partial V_t/\partial r_{31}$ (Hartree)
integ[t_stop]	Stopping condition: multiple of collision timescale
integ[r_stop]	Stopping condition: multiple of R0
integ[r_tol]	Relative error tolerance for equation of motion
integ[a_tol]	Absolute error tolerance for equation of motion
integ[econs]	Conserved energy requirement (Hartree)
integ[lcons]	Conserved momentum requirement (a.u.)

.

Note that atoms “1” and “2” should always represent those of the initial molecule, so that atom “3” represents the colliding atom. This convention should also be followed when specifying the masses. Additionally, all values entered in the input file should be in atomic units except for the collision energy.

2.2.2. Main Code

The main code consists of two classes, Molecule and Trajectory. After defining the input dictionary using Molecule objects and other keywords, it can be passed into the Trajectory class, which computes a quasi-classical trajectory.

The Molecule class contains methods relevant to molecules, such as the DVR method for finding the energy spectrum of a bound molecule and a method for calculating the classical turning points of a bound molecule. The spectrum and turning points for different ${\mathrm{E}}_{(v,j)}$ in different potentials can be stored separately for future use. The attributes of Molecule objects can be found in

Table 2. Attributes of a PyQCAMS Molecule object other than those provided in their input. All values are in atomic units.

Keyword	Description
Ei	Initial binding energy (for molecule 12)
E	Final relative energy
Veff	Effective potential
re	Equilibrium distance
rp	Classical outer turning point
rm	Classical inner turning point
tau	Vibrational period
bdry	Local maximum of effective potential
bdx	Interparticle distance of effective potential local maximum
vPrime	Final vibrational number (not binned)
vt	Final vibrational number (rounded)
vw	Gaussian weight associated with vPrime
jPrime	Final rotational number (rounded)
jw	Gaussian weight associated with jPrime

.

The Trajectory class performs the main QCT calculation and is outlined in Figure 4. First, a random set of initial conditions is generated by the method iCond, following Section 2.1.1, yielding ($\overrightarrow{{\rho }_1},\overrightarrow{{\rho }_2},\overrightarrow{P_1},\overrightarrow{P_2}$). Next, the Hamilton’s equations of motion are solved using a SciPy [18] integrator utilizing the adaptive Runge–Kutta 5(4) integration method [30]. After one of the stop conditions is met, the energy and momentum are checked for conservation. Finally, the product count ${\overrightarrow{n}}_f$ is created following Section 2.1.2. We first check each effective potential as to whether it can support bound states, then we check the final relative energies based on Equation (8). If more than one bound molecule is found, we denote it as an intermediate complex in the final output. If the trajectory results in a bound molecule, the final state $\overrightarrow{s_f}$ is calculated using the Molecule class method turningPts.

2.2.3. Output

The Trajectory object has attributes (see

Table 3. Useful attributes of the Trajectory class other than those provided in the input dictionary. While only some of these are obtained by the program by default, the user can choose to save any of these attributes when using qct.runN. All position, energy, momentum, and time attributes are in atomic units.

Attribute	Description
count	count vector of reaction products
fstate	state vector of reaction products
R	initial atom–diatom distance
ang	initial configuration of angles
w0	initial Jacobi vectors
wn	set of Jacobi vectors ${\overrightarrow{\rho }}_1$, ${\overrightarrow{\rho }}_2$, ${\overrightarrow{P}}_1$, ${\overrightarrow{P}}_2$ throughout the trajectory
t	trajectory time steps
delta_e	energy conservation
delta_l	momentum conservation

) relevant to a trajectory that can be tracked to an output file.

For a single trajectory, the default outputs are

• Initial state (vi, ji, $E_c$, b).
• Product count $\overrightarrow{n_f}$ = ($n_{12},n_{23},n_{31},n_d,n_c$), where n is either 0 or 1. $n_{ij}$ represents a bound molecule between atoms i and j, $n_d$ represents dissociation, and $n_c$ represents a three-atom intermediate complex at the end of the calculation.
• Final state $\overrightarrow{s_f}$ = ($v,vw(v^{\prime },v),j,jw(j^{\prime },j)$), where $xw(x^{\prime },x)$ is the Gaussian weight given in Equation (11). For trajectories yielding $n_d=1$ or $n_c=1$, the final state outputs $\overrightarrow{s_f}$ = (0, 0, 0, 0).

A full QCT study requires many trajectories run over a range of impact parameters. The qct.runN method provides a way to run N trajectories for a given input, from which there are two modes of output:

• Long output: Prints a single line per trajectory containing the default outputs. If any of the attributes provided in Table 3 are desired, place them as a list of strings in the ‘attrs’ argument of qct.runN method. This file is required as an input to the analysis functions provided by PyQCAMS.
• Short output: Sums over the product count $n_i$ of all trajectories for a given initial state ($v_i,j_i,E_c,b$). This can be useful for studies that do not involve state-specific results or GB.

A sample of the output files is shown in Figure 5.

2.2.4. Analysis Functions

PyQCAMS is equipped with an analysis module that contains functions to analyze the output file. These functions are opacity to compute the opacity function, crossSection to compute the cross section in units of ${\mathrm{cm}}^2$, and rate to compute the reaction rate in units of ${\mathrm{cm}}^3/\mathrm{s}$. These functions take the output of PyQCAMS as an input. The user has a choice of using HB or GB and can also choose to calculate state-specific results or neglect them.

2.2.5. Parallel Implementation and Performance

The code is best used in a parallel implementation, which dramatically speeds up the time per trajectory as the number of CPUs is increased (Figure 6). The qct.runN method automatically runs the trajectory in parallel using multiprocessing with all CPUS. The number of CPUs is controllable and reverts to serial computation when the number of CPUs is set to 1.

Figure 6 shows the speedup of the program as the number of CPUs varies, averaged over 1000 trajectories, calculated as $S\left(N\right)=t\left(1\right)/t\left(N\right)$ for N CPUs. It is clear that parallel processing yields a speedup of up to 20 times, thus a significant decrease in the total calculation time.

The majority of the calculation time is spent during the solution of the Hamilton’s equations of motion. Scipy’s solve_ivp API allows the user to control the absolute and relative tolerances to control local error estimates. These can be controlled in the input dictionary and will have a large influence on the energy and momentum conservation and the time per trajectory. It is highly recommended to study the effect that these tolerances have on a system before running large calculations by tracking those attributes of the Trajectory object.

2.2.6. Visualization

The file plotters.py contains several methods for visualizing the results of a trajectory. Figure 2 was obtained using the traj_plt function, which requires a trajectory object as input. There is also a 3D plot generator traj_3d, which provides a trace of the event. The usage of these plotters is shown in the example Jupyter notebook.

3. Results

3.1. RbBa⁺ + Rb

As a benchmark, we study a system of cold molecular ions embedded in an ultracold gas, namely the reaction RbBa⁺ + Ba as studied in [12]. We use the same pairwise interaction potential between Rb and Ba⁺, where it is assumed that the charge is localized in the Ba atom, with the Lennard–Jones potential: $V\left(r\right)=C_8/r^8-C_4/r^4$. For Rb-Rb, we use the triplet ground state potential parameters obtained from [31] in the Lennard–Jones potential: $V\left(r\right)=C_{12}/r^{12}-C_6/r^6$, whereas [12] uses the full potential provided in [31]. We calculate the quenching cross section (RbBa⁺($v_i$) + Rb → RbBa⁺($v\ne v_i$) + Rb) for states initialized at various high-lying vibrational states (with j = 0) near the dissociation of RbBa⁺. In Figure 7, we compare the quenching cross sections calculated by PyQCAMS to those presented in [12], where the cross sections were also found through the QCT method.

The calculated quenching cross sections are plotted alongside the Langevin cross section ${\sigma }_L=\pi {\left(4C_4\right)}^{1/2}{E}_c^{-1/2}$. We see good agreement with both the Langevin prediction and the previous results at the lower vibrational states. For the higher vibrational states, we notice that, at $E_c=100$ mK, the PyQCAMS results lie closer to the Langevin prediction than previously reported. These elongated states seem to pose a challenge for convergence, as shown in the 20 mK data for both sets of results. However, PyQCAMS seems to have performed better at 100 mK than previous calculations regarding the Langevin prediction, demonstrating the strength of the program.

3.2. H₂ + Ca

As an example, we demonstrate the calculation of the CaH formation rate as a result of the reaction H₂ + Ca → CaH + H. The first part of the code contains the inputs as described in Section 2.2.1. The potential ranges and parameters for H₂ and CaH were obtained from [32,33] and [34,35], respectively. Here, we chose the Morse potential to describe the interaction of both H₂ and CaH. We ran ${10}^4$ trajectories in parallel, looped over 20 impact parameters. The script for this calculation is shown in Listing 1.

We repeated the code in Listing 1 over a range of collision energies $E_c$ and three different initial vibrational levels of H₂. The rates for CaH formation are shown in Figure 8, where it is noticed that higher collision energies give rise to larger reaction rates, as expected in endothermic reactions. Additionally, as the initial vibrational level of H₂ is increased, the rates of reaction increase for a given collision energy. However, at very high collision energies such a trend changes due to the dominance of molecular dissociation processes. A more detailed study of this reaction will be published elsewhere.

We can also calculate the distribution of states of CaH and H₂, using the final state vector $\overrightarrow{s}$. Figure 9 shows these distributions at four different collision energies. We can see that the higher vibrational states fill up for both CaH and H₂ as the collision energy is increased, as is typical in endothermic reactions. All details of these calculations can be found in a Jupyter notebook example file.

4. Discussion

We have presented a Python quasi-classical atom–molecule scattering program, PyQCAMS. The PyQCAMS program aims to provide an easy-to-use platform for calculating quasi-classical trajectories for atom–diatomic molecule systems, including the three most relevant potentials for diatomic molecules: Morse, Buckingham, and the generalized Lennard–Jones, as well as any user-defined analytic potentials supplied by the user. We discussed the underlying theory behind the program and the methods of the program as they pertain to the theory. As output, the user obtains the reaction probability per energy and impact parameter. Then, with this information, it is possible to calculate the cross section and energy-dependent rate constant using the provided analysis functions. Its object-oriented approach allows the user to study different properties of a given trajectory. The plotter tools make it easy to visualize the results of a trajectory, making it ideal for a new researcher studying trajectories or for presenting the topic in a classroom setting. Finally, we would like to emphasize that there are already codes available for the calculation of reaction dynamics based in QCT methods, e.g., VENUS [36], Newton-X [37], or SHARC [38]. However, these programs are dedicated to more complex scenarios and are less versatile than the present code for atom–diatom collisions. Our code is fully written in Python, making it fully transparent and user-friendly. Furthermore, we offer direct plotting tools to rapidly diagnose any complication during the computation of a new system.