Using PennyLane

Release news

Development

API

Internals

  1. Docs
  2. qml.qchem
  3. qml.qchem.christiansen_integrals_dipole

qml.qchem.christiansen_integrals_dipole

christiansen_integrals_dipole(pes, n_states=16, num_workers=1, backend='serial')[source]

Computes Christiansen vibrational dipole integrals.

The Christiansen dipole operator is constructed similar to the vibrational Hamiltonian operator defined in Eqs. D4-D7 of arXiv:2504.10602. The dipole operator is defined as

\[\mu = \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( D_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) D_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 and \(D\) represents the dipole function obtained from the expansion

\[D({Q}) = \sum_i D_1(Q_i) + \sum_{i>j} D_2(Q_i,Q_j) + ....\]

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

Parameters:

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

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

  • 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 integrals for the Christiansen dipole operator

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, dipole_level = 3, cubic=True)
>>> integrals = qml.qchem.vibrational.christiansen_integrals_dipole(pes, n_states = 2)
>>> print(integrals[0][2])
[[[-0.00074107 -0.02287269]
[-0.02287269 -0.00216419]]]

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