PhD topics & MSc projects

PhD topics

I’m always looking for potential PhD candidates. Funding is notoriously difficult to find, but the search for a PhD should always start with a topic that is fascinating, before we dive into funding opportunities. The examples below are PhD topic “prototypes”. I prefer to tailor projects to the knowledge and interest of candidates, as long as they align with my own research interest. Typically, I also aim for PhD topics that align with major research projects, as it makes it easier to embed students into existing teams such that they acquire professional skills around team work and collaboration “on the fly”.

As kind of a summary, the descriptions below are just kind of an inspiration or a starting point before we flesh out an individual PhD project that aligns with the candidate’s interest and projects that are currently running.

Higher-dimensional PDE solver meshes

Almost all mainstream PDE solvers in my work are 2d or 3d (with a few exceptions). However, a lot of the problems of people using my code are somehow higher-dimensional. The prime example is solvers where we don’t know some parameters precisely. In this case, the thing most people do is to repeatedly run simulations with varying parameters to match the outcomes they are after or to understand how the solution reacts to changes of some parameters. Within optimisation cycles, this is the forward cycle. Within a Bayesian framework, they would probably run multiple forward solves for different parameters in parallel. All codes in the field to some degree follow this approach.

I think that this is a poor idea: We could solve a d+n-dimensional problem right from the start (n being different parameters), i.e. evolve multiple PDE “shots” on a higher-dimensional grid and get a feeling for the solution’s behaviour in one go.

Read more

Time stepping

The solvers in my group typically use fixed time stepping (where all parts of the mesh advance in time with the same speed) or they use something like bucketed time stepping. Here, finer mesh parts advance with smaller time step sizes, but this “smaller” is dictated by the mesh resolution difference. We have some examples where mesh parts can advance in time totally anarchically anticipating the information propagation speed of the physic. All of these schemes have at least two massive issues:

• The load balancing is hard;
• the gains in efficiency as we only advance cells where “things happen” is eaten up by administration overhead and the fact that GPUs are particularly good in handling large, regular workload.

For these reasons, adaptive time stepping is still rare for very large simulations.

The other big challenge around time stepping is that we mostly use explicit time stepping, as implicit approaches are seen as too costly. Unfortunately, the explicit schemes really struggle with stiff PDEs and mos of the things I am interested in can become (very) stiff. Therefore, it is an interesting question to consider implicit-explicit schemes.

Read more

Task graph tracking and performance prediction

Over the past few years, we have proposed several C++ language extensions using attributes to reduce a solver’s memory footprint and optimise its data layouts. These extensions also allow programmers to specify where compute kernels should run. Our core idea is that a programmer can annotate code to inform the compiler that a floating-point variable holds, for example, only 10 significant digits, and that the subsequent code would benefit from data organised as Structure of Arrays (SoA) rather than Array of Structs (AoS). However, programmers can continue to work with native IEEE formats and AoS. Our Clang compiler extensions then process this information:

Hierarchical, variable precision via compiler extensions

Over the past few years, we have proposed several C++ language extensions using attributes to reduce a solver’s memory footprint and optimise its data layouts. These extensions also allow programmers to specify where compute kernels should run. Our core idea is that a programmer can annotate code to inform the compiler that a floating-point variable holds, for example, only 10 significant digits, and that the subsequent code would benefit from data organised as Structure of Arrays (SoA) rather than Array of Structs (AoS). However, programmers can continue to work with native IEEE formats and AoS. Our Clang compiler extensions then process this information: they store the data using only the 10 valid digits, convert it into native C++ types ahead of the any actual computation, and reorganise the data into SoA behind the scenes. Furthermore, they rewrite the compute kernels to exploit this altered layout, particularly if these kernels are executed on the GPU.

There are several logical follow-up steps that frame a new PhD thesis: How can we apply these concepts to higher-dimensional arrays? At present, we mainly study 1D data, such as a series of particles. Can the annotation mechanism be extended to support dynamic changes in precision during computation? Can we completely hide all arising conversion overhead – in particular on accelerated compute systems?

Read more

Multigrid and ADER-DG

Multigrid solvers are among the fastest known solvers for elliptic PDEs. My group has published several pieces of work on algebraic-geometric multigrid, additive schemes mirroring multiplicative robustness, and parallelisation using inexact, iterative assembly. One of the key things we haven’t completed yet is however multigrid in combination with higher-order methods. Notably the ADER-DG scheme, i.e. how to couple it with a multigrid solver, is of particular interest to me. In classical Runge-Kutta methods, we have to solve one multigrid problem per shot if multigrid tackles and elliptic operator within the time stepping equation. Otherwise, the convergence order deteriorates. It is an open question how to design a multigrid solver that fits to ADER-DG’s local implicit solves and higher-order prediction – we might need some local space-time multigrid – and there are plenty of HPC tricks that will have to be employed to make the arising schemes fast..

Read more

Numerical Relativity in the Realm of New Physics

Collaborative project with Baojiu Li (ICC)
Preferred funding stream: CSC or DDS

Numerical Relativity is the holy grail of computational physics. Yet, it took nearly a century after Einstein published General Relativity (GR) that long-term stable simulations of black holes became possible due to the highly nonlinear nature of the gravitational field equations. Since then, there have been huge progresses in this field, and interest has grown much stronger after the first gravitational wave (GW) detection less than a decade ago. Already, such detections have been used to shed light on the mysterious accelerated expansion of our Universe, ruling classes of gravity theories beyond GR.

With the advent of a new generation of GW detectors, in the coming decades GW cosmology will evolve into a mature subject in astronomy. The data collected will allow people to test new theories of fundamental physics with unprecedented exquisiteness. However, even today, simulating the evolution of compact object systems such as black holes and neutron stars in various theories of gravity is still a big challenge.

In this project, the candidate will work on the scientific developments and applications of our numerical relativity simulation code, ExaGRyPE, developed by a collaboration between the Physics and Computer Science departments at Durham University. There are a range of potential directions this project can lead to. Some of these directions sit more in Physics, others have a stronger computer science touch. From a numerics/computer science touch, I’m particularly interested in

• the coupling of the code base with a multigrid solver. We have a prototype of a solver already, and we have ExaGRyPE up and running (obviously), but the actual coupling between the two of them is something largely unexplored. If we manage to couple the two types of solvers, we can do things that are currently out of reach for many competitor codes in the field. Notably, we can address something like the holy grail of this domain (from an HPC point of view): We can start to look into implicit time stepping schemes and hence allow for way bigger time step sizes even though we increase the resolution further. The time step constraints currently are a major showstopper for many calculations. The other interesting option offered by a multigrid solver is that we can treat the Einstein constraints explicitly: Each solution has to fulfil certain conditions. At the moment, we do not enforce these conditions, but evaluate them after each time step and add them as penalty again for the next one, pushing the solution into a direction that is phyiscally valid (penalty approach). With a multigrid solver, we could finally solve the constraints exactly, which should improve the solver’s stability.
• the reformulation of the underlying Physics in a higher-dimensional sense. There is this theory that we live and observe phenomena on a brane world, i.e. something like a shower curtain embedded into a higher-dimensional space. The formulae for this idea do exist, but there are no larger codes that can simulate it, as they would have to evolve the PDE in 6,7,….-dimensional spaces, only to then construct a submanifold through this space. ExaGRyPE is built on top of Peano which can handle such “high-dimensional” meshes, and there is, at the moment, no other bigger code that could do this, which makes this project potentially ground breaking.

MSc projects

Every year, I propose a couple of MSc/BSc topics at the department. These topics are tailored to the projects that I current drive, i.e. I always aim for projects that can, in theory, make a direct contribution towards a larger research theme. That does not mean that I only supervise such topics. If you are interested in a particular area of my research which is not covered by current proposals, please come to see me to discuss if we can tailor a bespoke project around your particular interests.