Last week, from Wednesday to Friday, I paid the Technical University of Munich (TUM)
a short visit for two great opportunities to present my work:
Once in the theoretical chemistry group of
Professor Wolfgang Domcke
and once at the annual meeting of the
modeling, analysis and simulation of molecular systems (MoAnSi) interest group,
a crowd consisting mostly of mathematicians and fellow modelling scientists.

## Talk at Domcke group

The first presentation
I gave last Wednesday in the Domcke group,
where
I talked about challenges and approaches to interdisciplinary software projects.
I also presented two projects of my own, namely
DFTK and adcc.
About these codes I already gave a few details
in previous
articles
and thus be rather brief with respect to details about them.

In the part of the talk on the plane-wave density-functional theory code DFTK
I mainly focused on the question why we decided to use Julia
as a programming language.
For this I summarised Julia's capabilities and performance
and gave a short teaser of Julia code in a
Jupyter notebook.
This notebook shows a Julia implementation of a Jacobi-Davidson
iterative eigensolver and discusses concrete instantiations of the code
in various situations.
This includes a mixed-precision algorithm, which transfers intermediate results
obtained in a lower precision (e.g. single precision) to higher
(i.e. double) precision and then continues the iterations at this level.
Other examples were diagonalisations using sparse matrices or GPU computations.
Most notably, for all these cases the actual Jacobi-Davidson code
was only written once and not explictly adapted
to fit the respective datastructures or computational backends.
Last, but not least the notebook teasered a small automatic
differentiation example as well.

The main focus of the talk, however, was the adcc code,
which implements the algebraic-diagrammatic construction scheme for
the polarisation propagator (ADC) and allows to drive this computation
from any SCF code using a python-based interface.
In the presentation I sketch content from our upcoming software paper
on adcc and present three examples for calculations, which we are able
to do with only few lines of python code.
This includes an analysis of the core-valence separation (CVS) error for water,
a sophisticated combination of freezing extra core and valence orbitals
alongside the CVS
and a case of an ADC(2) modelling of nile red (426 basis functions)
in an explicit solvent model (polarisable embedding).
The code for the second example, namely the combination of CVS with freezing
other orbitals, was also shown in an
example notebook.
Especially this part of the talk was well-received,
providing fruit for many ADC-related and adcc-related discussions afterwards.

## MoAnSi workshop

Directly after the day at the Domcke group I attended
the MoAnSi meeting,
which took place last Thursday and Friday,
bringing together a bunch of mathematicians interested in computational methods
for molecular science.
Similar to other interdisciplinary meetings overlapping chemistry and maths,
like the one in Oberwolfach,
the atmosphere was friendly and open.
Plenty of discussions were stimulating for thought about fundamental
aspects of quantum chemistry,
one usually does not think about as a chemist.

For this reason my second talk was tailored
a bit more to the mathematician crowd,
which meant that I focused more on DFTK
and how it could
be used in the context of mathematically-driven research
of density-functional theory.
Apart from the slides and the
Julia examples
I also presented some actual DFTK code,
emphasising how Julia leads to extremely concise and readable programs.
During the Q&A, I mentioned a blog article
about a Julia case study using the language for a petascale computation.
The respective project is
the Celeste code
and a summary of the hurdles and difficulties
can be found
in a post by Keno Fischer
on the Julia Computing Blog.

Slides and notebooks for both talks are linked in the main text above
or can be downloaded here: