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.