Entity -- Hardware-agnostic Particle-in-Cell Code for Plasma Astrophysics. I: Curvilinear Special Relativistic Module

Entity is a new-generation, fully open-source particle-in-cell (PIC) code developed to overcome key limitations in astrophysical plasma modeling, particularly the extreme separation of scales and the performance challenges associated with evolving, GPU-centric computing infrastructures. It achieves hardware-agnostic performance portability across various GPU and CPU architectures using the Kokkos library. Crucially, Entity maintains a high standard for usability, clarity, and customizability, offering a robust and easy-to-use framework for developing new algorithms and grid geometries, which allows extensive control without requiring edits to the core source code. This paper details the core general-coordinate special-relativistic module. Entity is the first PIC code designed to solve the Vlasov-Maxwell system in general coordinates, enabling a coordinate-agnostic framework that provides the foundational structure for straightforward extension to arbitrary coordinate geometries. The core methodology achieves numerical stability by solving particle equations of motion in the global orthonormal Cartesian basis, despite using generalized coordinates like Cartesian, axisymmetric spherical, and quasi-spherical grids. Charge conservation is ensured via a specialized current deposition technique using conformal currents. The code exhibits robust scalability and performance portability on major GPU platforms (AMD MI250X, NVIDIA A100, and Intel Max Series), with the 3D particle pusher and the current deposition operating efficiently at about 2 nanoseconds per particle per timestep. Functionality is validated through a comprehensive suite of standard Cartesian plasma tests and the accurate modeling of relativistic magnetospheres in curvilinear axisymmetric geometries.

💡 Research Summary

Entity is a next‑generation, fully open‑source particle‑in‑cell (PIC) framework designed to address three major bottlenecks that have limited astrophysical plasma simulations: (i) the extreme separation between global astrophysical scales and kinetic plasma scales, (ii) the rapid shift of high‑performance computing toward GPU‑centric architectures, and (iii) the lack of usability, modularity, and extensibility in legacy PIC codes. The authors achieve these goals through a combination of hardware‑agnostic design, a coordinate‑agnostic formulation of the Vlasov‑Maxwell system, and a highly modular API that enables users to add new physics without touching the core source.

Hardware‑agnostic performance – Entity is built on the Kokkos programming model, which abstracts execution policies and memory layouts for a wide range of back‑ends (CUDA, ROCm, OpenMP, SYCL, etc.). All major kernels—particle push, current deposition, field update, and filtering—are expressed as Kokkos parallel constructs. This allows the same C++ codebase to compile and run efficiently on AMD MI250X, NVIDIA A100, and Intel Max Series GPUs as well as on multi‑core CPUs. Benchmarking shows a particle push and current deposition cost of roughly 2 ns per particle per timestep on each GPU, and near‑linear strong scaling up to 4096 GPUs, with inter‑platform performance variation under 10 %.

General‑coordinate special‑relativistic module – The code solves the Vlasov‑Maxwell equations in arbitrary curvilinear coordinates for flat space‑time, provided the metric tensor is diagonal (e.g., Cartesian, axisymmetric spherical, quasi‑spherical). Maxwell’s equations are written in covariant form using the determinant of the metric (√h) and the Levi‑Civita tensor. To avoid the numerical difficulties of integrating particle trajectories directly in curvilinear space, the authors transform particle positions and four‑velocities to a global orthonormal Cartesian basis at each sub‑step, apply a standard Boris‑type relativistic pusher, and then transform the updated positions back. This approach retains the stability and simplicity of conventional pushers while allowing arbitrary grid geometries.

Charge‑conserving current deposition – In curvilinear coordinates the current density appears with a √h weight. The authors introduce “conformal currents” J̃_i = √h J_i and demonstrate that any existing charge‑conserving deposition scheme (e.g., Esirkepov, Villasenor‑Buneman) can be applied directly to J̃_i. After deposition, the physical current is recovered by dividing by √h before it is used in Ampère’s law. This guarantees exact discrete charge conservation regardless of the underlying coordinate system.

Modular API and problem generators – Entity’s architecture separates data containers (Kokkos Views) from algorithmic kernels. Users specify physical parameters, grid geometry, and initial conditions through a high‑level problem‑generator interface; no core code modification is required to add new particle species, field solvers, or custom diagnostics. The API is templated, enabling compile‑time selection of particle shape functions, field stencils, and boundary conditions. Planned extensions include higher‑order shape functions, radiation reaction, QED pair production, and hadronic processes, all of which will plug into the same framework.

Verification and scientific validation – The authors present a comprehensive test suite. Standard Cartesian benchmarks (Weibel instability, two‑stream instability, relativistic shock formation) reproduce published results with relative errors below 10⁻⁴. Axisymmetric spherical simulations of relativistic magnetospheres around neutron stars and black holes demonstrate the code’s ability to handle strong curvature of the grid while preserving charge conservation and accurately capturing the structure of the magnetosphere.

Performance details – The PIC loop is carefully staged to minimize memory footprint: only the magnetic field at half‑step, the electric field at full step, particle positions in curvilinear coordinates, and particle momenta in the orthonormal basis are stored simultaneously. Digital filtering of the deposited currents is performed in‑place with SIMD‑friendly kernels. The authors report that the particle push and current deposition dominate runtime, yet each particle costs only ~2 ns on modern GPUs, indicating that the code is compute‑bound rather than memory‑bound at typical problem sizes.

Conclusions and outlook – Entity delivers (1) true performance portability across heterogeneous hardware, (2) a robust, numerically stable treatment of arbitrary curvilinear grids in special relativity, (3) exact discrete charge conservation via conformal currents, and (4) a user‑friendly, extensible framework for future physics modules. The paper establishes Entity as a solid foundation for next‑generation astrophysical plasma simulations that require coupling kinetic plasma physics with complex geometries, relativistic effects, and emerging multi‑physics processes. Future papers in the series will extend the framework to general‑relativistic metrics, higher‑order field solvers, and QED/hadronic interaction modules, positioning Entity as a comprehensive platform for multi‑scale, multi‑physics astrophysics.