Using PennyLane

Release news

Development

API

Internals

  1. Docs
  2. qml.qchem
  3. qml.qchem.christiansen_integrals

qml.qchem.christiansen_integrals

christiansen_integrals(pes, n_states=16, cubic=False, num_workers=1, backend='serial')[source]

Computes Christiansen vibrational Hamiltonian integrals.

The Christiansen vibrational Hamiltonian is defined based on Eqs. D4-D7 of arXiv:2504.10602 as:

\[H = \sum_{i}^M \sum_{k_i, l_i}^{N_i} C_{k_i, l_i}^{(i)} b_{k_i}^{\dagger} b_{l_i} + \sum_{i<j}^{M} \sum_{k_i,l_i}^{N_i} \sum_{k_j,l_j}^{N_j} C_{k_i k_j, l_i l_j}^{(i,j)} b_{k_i}^{\dagger} b_{k_j}^{\dagger} b_{l_i} b_{l_j},\]

where \(b^{\dagger}\) and \(b\) are the creation and annihilation operators, \(M\) represents the number of normal modes and \(N\) is the number of modals. The coefficients \(C\) represent the one-mode and two-mode integrals defined as

\[C_{k_i, l_i}^{(i)} = \int \phi_i^{k_i}(Q_i) \left( T(Q_i) + V_1^{(i)}(Q_i) \right) \phi_i^{h_i}(Q_i),\]

and

\[C_{k_i, k_j, l_i, l_j}^{(i,j)} = \int \int \phi_i^{k_i}(Q_i) \phi_j^{k_j}(Q_j) V_2^{(i,j)}(Q_i, Q_j) \phi_i^{l_i}(Q_i) \phi_j^{l_j}(Q_j) \; \text{d} Q_i \text{d} Q_j,\]

where \(\phi\) represents a modal, \(Q\) represents a normal coordinate, \(T\) represents the kinetic energy operator and \(V\) represents the potential energy operator obtained from the expansion

\[V({Q}) = \sum_i V_1(Q_i) + \sum_{i>j} V_2(Q_i,Q_j) + ....\]

Similarly, the three-mode integrals can be obtained following Eq. D7 of arXiv:2504.10602.

This function computes the coefficients \(C\) efficiently by using the Gauss-Hermite quadrature, which expresses the integral as

\[\sum_{p=1}^{P} w_p f(x_p),\]

where \(P\) is the degree of the quadrature with associated weights \(w\) and quadrature points \(x\) obtained from the potential energy data along the normal modes. The function \(f(x)\) represents the potential energy surface here.

Parameters:

  • pes (VibrationalPES) – object containing the vibrational potential energy surface data

  • n_states (int) – maximum number of bosonic states per mode

  • cubic (bool) – Whether to include three-mode integrals. Default is False.

  • num_workers (int) – the number of concurrent units used for the computation. Default value is set to 1.

  • backend (string) – the executor backend from the list of supported backends. Available options are mp_pool, cf_procpool, cf_threadpool, serial, mpi4py_pool, mpi4py_comm. Default value is set to serial. See Usage Details for more information.

Returns:

the one-mode and two-mode integrals for the Christiansen Hamiltonian

Return type:

List[TensorLike[float]]

Note

This function requires the h5py package to be installed. It can be installed with pip install h5py.

Example

>>> symbols  = ['H', 'F']
>>> geometry = np.array([[0.0, 0.0, -0.40277116], [0.0, 0.0, 1.40277116]])
>>> mol = qml.qchem.Molecule(symbols, geometry)
>>> pes = qml.qchem.vibrational_pes(mol, optimize=False)
>>> integrals = qml.qchem.vibrational.christiansen_integrals(pes,n_states=4)
>>> print(integrals[0])
[[[0.0103548  0.0019394  0.00046436 0.0016381 ]
  [0.0019394  0.03139978 0.00558    0.00137586]
  [0.00046436 0.00558    0.05314478 0.01047909]
  [0.0016381  0.00137586 0.01047909 0.07565063]]]

The backend options allow to run calculations using multiple threads or multiple processes.

  • serial: This executor wraps Python standard library calls without support for multithreaded or multiprocess execution. Any calls to external libraries that utilize threads, such as BLAS through numpy, can still use multithreaded calls at that layer.

  • mp_pool: This executor wraps Python standard library multiprocessing.Pool interface, and provides support for execution using multiple processes.

  • cf_procpool: This executor wraps Python standard library concurrent.futures.ProcessPoolExecutor interface, and provides support for execution using multiple processes.

  • cf_threadpool: This executor wraps Python standard library concurrent.futures.ThreadPoolExecutor interface, and provides support for execution using multiple threads. The threading executor may not provide execution speed-ups for tasks when using a GIL-enabled Python.

  • mpi4py_pool: This executor wraps the mpi4py.futures.MPIPoolExecutor class, and provides support for execution using multiple processes launched using MPI.

  • mpi4py_comm: This executor wraps the mpi4py.futures.MPICommExecutor class, and provides support for execution using multiple processes launched using MPI.

Previous
Next