Over the part year or so a side project I have been working off and on
has been the adcc code.
This python module allows to perform excited states calculation
for simulating molecular spectra
based on algebraic-diagrammatic construction (ADC) methods.
The speciality of the adcc code is that
(a) multiple host programs are supported for supplying a Hartree-Fock reference,
right now pyscf, Psi4,
molsturm and veloxchem,
and (b) that its hybrid C++/python design allows to implement
a large part of the ADC procedure *including iterative solver schemes*
in python and still achieve the speed required for larger ADC calculations.
The code development has been a collaboration with multiple members
from the old group of my PhD times,
the Dreuw group from Heidelberg.
Finally, today, we are publicly releasing the code
following the submission of our paper on
adcc last week (download link).

I have already talked about adcc and ADC methods before (see also my research interests), so I'll be brief with my summary about these. The ADC scheme builds upon the fact that the poles of the polarisation propagator, i.e. the two-particle Green's function, contains the physical information for describing excited electronic states and their properties. Using a Møller-Plesset partitioning of the Schrödinger Hamiltonian one may construct a perturbative expansion for said polarisation propagator. In the ADC approach this is done using a particular representation basis for the many-body states of the Schrödinger Hamiltonian, the so-called intermediate state basis. The outcome are a perturbative series of matrices, the so-called ADC matrices corresponding to the ADC(n) series of methods. The ADC matrices contain exactly the spectral information of the polarisation propagator consistent to order n of a Møller-Plesset expansion of the correlated ground state. Diagonalising this matrix, thus allows to obtain excitation energies and excited-state properties. For more details, see for example the theory section in the adcc documentation.

As we discuss in our paper, in adcc the basic procedure of building and diagonalising
the ADC matrix is implemented in a hybrid C++/python code.
The aim was to keep everything,
including intermediate results, accessible from the python layer,
while implementing the computationally intensive parts in C++.
As a result,
the code is comparable to C++-only implementations in speed,
such that it can be used to e.g. treat biomolecular systems.
The iterative diagonalisation procedure
and other aspects of the numerics are implemented completely in python,
facilitating experimenting on the numerical level in the future.
Multiple variants of ADC are available up to and including ADC(3),
i.e. a treatment of the polarisation propagator consistent to third-order.
Originally adcc grew out of my desire to use another ADC code,
which is developed in the Dreuw group, namely the `adcman`

code,
interactively from python.
In its current state, however,
adcc has well grown beyond being a plain wrapper around `adcman`

.
The internal code structure and workflows of both packages have
very little in common, albeit the general methodology to solve ADC of both
packages is certainly related.
The design of adcc aims to simplify working with ADC methods
as a developer, but also facilitating the use and extension of existing workflows
by everyday users.
For more details and a couple of examples, see the paper,
or the Performing calculations with adcc
section of the adcc documentation.
Installing adcc is simple.
Given that a few requirements (such as openblas on Linux) are available,
it boils down to using pip:

pip install pybind11 pip install adcc

The full abstract reads

ADC-connect (

`adcc`

) is a hybrid python/C++ module for performing excited state calculations based on the algebraic-diagrammatic construction scheme for the polarisation propagator (ADC). Key design goal is to restrict adcc to this single purpose and facilitate connection to external packages, e.g., for obtaining the Hartree-Fock references, plotting spectra, or modelling solvents. Interfaces to four self-consistent field codes have already been implemented, namely`pyscf`

,`psi4`

,`molsturm`

, and`veloxchem`

. The computational workflow, including the numerical solvers, are implemented in python, whereas the working equations and other expensive expressions are done in C++. This equips`adcc`

with adequate speed, making it a flexible toolkit for both rapid development of ADC-based computational spectroscopy methods as well as unusual computational workflows. This is demonstrated by three examples. Presently, ADC methods up to third order in perturbation theory are available in adcc, including the respective core-valence separation and spin-flip variants. Both restricted or unrestricted Hartree-Fock references can be employed.