Selected Projects

Schnek

Github repository: https://github.com/holgerschmitz/Schnek
Documentation: https://schnek.readthedocs.io/en/latest

Schnek is an open source C++ library that supports the rapid development of parallel simulation software on regular grids. It encapsulates parallelisation strategies together with much of the administration code required to implement flexible high-performance codes. This allows simulation code developers to focus on what matters for their specific problem: solving the model equations using the best numerical scheme.

Regular Grids are a core element for many numerical schemes. Schnek defined classes for n-dimensional grids. It also has support for fields that contain information about the mapping between physical coordinates and grid cells. The grids or fields can use a variety of different storage models. Some predefined models are C- or Fortran-ordered arrays and lazy-allocation schemes. The current development version also includes support for Kokkos Views. Different storage models are defined through a template parameter. This means, the same user code can compile with different models, just by changing a type definition.

Parallelisation Strategies determine how simulation codes make use of compute clusters and high-performanc computing hardware. Schnek supports parallelisation in two ways. Grids can be defined with ghost (or halo) cells. In addition, domain subdivisions allow allocating local ranges for each MPI process in arbitrary dimensions. They also manage the exchange of ghost cells between processes. The upcoming version of Schnek will extend this concept and allow more flexible domain decompositions, including support for multiple regions per process, flexible load balancing, distribution of particle-like data, and support for GPU and hybrid architectures.

Diagnostics encapsulate the output from a simulation run. Schnek defines classes that can save grids into HDF5 files and work seamlessly with the parallelisation strategies. Using a few simple lines of code, the developer can save an n-dimensional grid that is distributed over many MPI processes into a single data file.

Flexibility allows a simulation code to be used many times in different scenarios simulating vastly different physical systems. Schnek allows the development of large community codes by containing a parser for setup files that translates directly into an object hierarchy in the simulation code. Code developers can define modules that are configured through input parameters or even submodules using just a few lines of code. This allows the end user to configure the setup choosing which physical processes apply and how they interact.

Comparison of Relativistic Particle Pushers

Publication: https://arxiv.org/abs/2603.06509 
Github: https://github.com/holgerschmitz/particle-integrators

The integration of relativistic charged particle orbits in electromagnetic fields vital to understanding kinetic phenomena in in many areas of physics. In particular in the field of plasma physics, where particle-in-cell (PIC) codes are routinely used to investigate kinetic phenomena, the understanding of particle orbits is of vital importance. In the context of PIC codes, the integration schemes are often called particle pushers because the push the simulation particles each time step. Understanding the accuracy of these particle pushers is important for understanding the reliability of the outcome of PIC simulations.

The classic particle integration scheme that is used by most PIC codes is the Boris Scheme that divides the push into a position update, an acceleration by the electric field and a rotation of the velocity vector by the magnetic field. This scheme is second order and has good long-term stability. Some time ago, it was realised however that the Boris pusher did not perform as well in certain situations when the particle velocities reach near the speed of light. Since then, various alternative schemes have been proposed but no systematic study of these existed.

In a recent comparison, I evaluated a range of particle pushers and tested their convergence properties in a wide range of test scenarios. The study focused on explicit schemes in which the new position and velocity can be directly calculated from the previous position and velocity together with the electromagnetic fields. These are the schemes most suited for PIC simulation codes. The implementation of all schemes included in the study has also been published as a Github repository.

While there was no overall best scheme that performed better than the rest in all situations, the Boris scheme is still a good first choice. A scheme proposed by Higuera & Cary performed somewhat better in many cases at the expense of only a moderate increase in computational cost. Other schemes, based on the exact integration of particle orbits in a constant homogeneous electromagnetic field perform well in special cases, but are found to reduce to first order when used in time-dependent or inhomogeneous fields.

As part of the investigation is was found that a certain class of schemes could be extended to arbitrary high order accuracy. This may be important for developing high accuracy simulation codes that converge more quickly with the reduction of the time-step or grid spacing.

Dynamical Symmetries in Harmonic Generation with Structured Light

Publications: 
Nature Communications 15, 6878 (2024)
Phys. Rev. Research 8, 013241 (2026)
arXiv:2507.08635
arXiv:2604.08354

In a recent collaboration lead by R. Trines, we studied the dynamical symmetries in harmonic generation. A novel approach to describe the symmetries allows representing the nonlinear interactions on a grid in Fourier space. Each fundamental mode is represented by a single point and nonlinear interactions generate harmonics along the connecting lines at regular spaced intervals. This theory simplifies our understanding of existing experiments generating harmonics using beams with orbital angular momentum (OAM) and more general structured beams.

The theory developed in this collaboration can be applied to harmonic generation with high-intensity laser-solid interaction as well as to high-harmonic generation in gases and chiral media. It allows us to predict novel experimental setups, generating tunable frequency combs or harmonics with specified OAM.

Large scale particle-in-cell simulations were used to support the theoretical model. This involved designing new diagnostic tools and mathematical strategies for analysing the data based on the underlying theory. 

EPOCH

Github: https://github.com/epochpic/epoch
Documentation: https://epochpic.github.io
Publication: Plasma Phys. Control. Fusion 57, 113001 (2015)

EPOCH is a highly successful relativistic particle-in-cell code that is being developed by the University of Warwick. The code is is open source and is being used by many research groups around the world. It runs on local desktop Linux computers as well as on large high-performance computing clusters. It has been shown to scale well up to 10s of thousands of cores. The code is feature rich, implementing Coulomb collisions, ionisation, laser boundaries, perfectly matched absorbing layers, QED effects, moving window and more. This makes it a versatile code able to be used in many areas of plasma physics.

I have been involved with EPOCH as part of the core development team since 2010. Some of my early contributions include the implementation of Coulomb collisions as well as the perfectly matched boundary. More recently, I have contributed to the implementation of spin and polarisation effects. The inclusion of spin and polarisation dependent cross sections is ongoing. 

Code validation, convergence studies, definition of invariants, and regression tests are a fundamental part of a community code on this scale. The use of EPOCH in many research projects in plasma physics means that a large number of scientific results depend on the correctness of the code.