We propose a methodology to identify and characterize different plasma environments observed by magnetospheric mission spacecraft instruments, creating a data-driven magnetosphere atlas. To enable an accurate analysis under highly non-uniform sampling, we design a 3D adaptive octree data structure that refines magnetospheric regions with high sampling counts. A variational autoencoder that leverages the octree structure allows us to automatically identify different regions of the Earth’s magnetosphere. The model also generates per-region feature distributions, improving interpretability by summarizing both typical conditions and variability. We apply this methodology to 10 years of plasma observations from NASA’s Magnetospheric Multiscale (MMS) mission, identify known magnetospheric regions, and create an atlas of plasma environments in space. The resulting atlas can be used to better understand magnetospheric plasma regions, detect anomalies, automatically generate labels for space applications, and study the magnetospheric response across geomagnetic activities.

We present a hybrid quantum-classical electrostatic Particle-in-Cell (PIC) method, where the electrostatic field Poisson solver is implemented on a quantum computer simulator using a hybrid classical-quantum Neural Network (HNN) using data-driven and physics-informed learning approaches. The HNN is trained on classical PIC simulation results and executed via a PennyLane quantum simulator. The remaining computational steps, including particle motion and field interpolation, are performed on a classical system. To evaluate the accuracy and computational cost of this hybrid approach, we test the hybrid quantum-classical electrostatic PIC against the two-stream instability, a standard benchmark in plasma physics. Our results show that the quantum Poisson solver achieves comparable accuracy to classical methods. It also provides insights into the feasibility of using quantum computing and HNNs for plasma simulations. We also discuss the computational overhead associated with current quantum computer simulators, showing the challenges and potential advantages of hybrid quantum-classical numerical methods.

The Disturbance Storm Time (Dst) index quantifies geomagnetic storm intensity by measuring global magnetic field variations. In this study, we apply interpretable machine-learning (ML) techniques to derive data-driven models describing the temporal evolution of the Dst index. We use historical data from the NASA OMNIWeb database, including solar wind density, bulk velocity, convective electric field, dynamic pressure, and magnetic pressure. We employ KAN networks and the symbolic regression framework PyOperon, based on an evolutionary algorithm, to identify closed-form expressions linking (Formula presented) to key solar wind parameters. The equations obtained via symbolic regression form a hierarchy of complexity levels and capture nonlinear dependencies and threshold effects in Dst evolution. In addition, we use a conventional MLP network as a reference black-box model. We benchmark all ML models against observed Dst data and compare their performance with empirical formulations such as the Burton-McPherron–Russell and O’Brien-McPherron models. The performance evaluation on historical storm events includes the 2003 Halloween storm, the 2015 St. Patrick’s Day storm, a moderate storm in 2017, and the extreme storm of May 2024. The data-driven models, particularly the MLP, demonstrate superior accuracy in most cases. While the symbolic regression expressions provide insight into the underlying physics, the results highlight an intrinsic trade-off between model interpretability and predictive accuracy. This is an extended version of a previous work presented in Markidis et al. (2025) [1].

Particle-in-Cell (PIC) Monte Carlo (MC) simulations are central to plasma physics but face increasing challenges on heterogeneous HPC systems due to excessive data movement, synchronization overheads, and inefficient utilization of multiple accelerators. In this work, we present a portable, multi-GPU hybrid MPI+OpenMP implementation of BIT1 that enables scalable execution on both Nvidia and AMD accelerators through OpenMP target tasks with explicit dependencies to overlap computation and communication across devices. Portability is achieved through persistent device-resident memory, an optimized contiguous one-dimensional data layout, and a transition from unified to pinned host memory to improve large data-transfer efficiency, together with GPU Direct Memory Access (DMA) and runtime interoperability for direct device-pointer access. Standardized and scalable I/O is provided using openPMD and ADIOS2, supporting high-performance file I/O, in-memory data streaming, and in-situ analysis and visualization. Performance results on pre-exascale and exascale systems, including Frontier (OLCF-5) for up to 16,000 GPUs, demonstrate significant improvements in run time, scalability, and resource utilization for large-scale PIC MC simulations.

We introduce QFT→FFT, a family of HPC FFT libraries that compute the discrete Fourier transform by executing a quantum Fourier transform (QFT) circuit on classical quantum computer simulators. Input arrays are mapped directly to state amplitudes with explicit normalization/indexing, making QFT a drop-in replacement for FFT primitives. A backend-agnostic planner builds a fused-gate schedule and memory layout adapters to increase arithmetic intensity and reduce memory data movement. We implement this design on top of Google’s C++ qsim and evaluate OpenMP, AVX, and CUDA backends. On an AMD EPYC Zen2 processor, our AVX performance is on par with that of multithreaded FFTW, utilizing 64 threads. On an NVIDIA A100, the CUDA backend achieves more than 4× lower time than both AVX and FFTW on AMD EPYC Zen2 at larger sizes. We also employ an approximate QFT (AQFT) that truncates small-angle controlled rotations beyond a cutoff k, reducing circuit depth and runtime while preserving accuracy.

Plasma simulations are among the most computationally demanding scientific workloads, combining high-dimensional kinetic evolution, particle-mesh coupling, field solves, and data-intensive communication. As general-purpose processor scaling slows, post-Moore technologies are being explored to address bottlenecks in data movement, memory access, and power consumption. This paper provides a community perspective on the role of these technologies in plasma simulation, assessing three major classes: reconfigurable and data-path accelerators, non-von Neumann architectures, and quantum computing. Each is evaluated, in a co-design approach, against representative plasma workloads spanning particle-in-cell, continuum Vlasov, gyrokinetic, fluid/MHD, hybrid, and warm dense matter methods. We find that no single technology can replace existing HPC platforms. Instead, three tiers of opportunity emerge: FPGA-class and data-path accelerators offer near-term kernel offload and workflow-level data services, non-von Neumann architectures represent medium-term directions for operator-level acceleration, and quantum computing, although the least mature, is potentially the most disruptive for warm dense matter and inertial confinement fusion microphysics. We outline best practices for selective adoption and identify focused demonstrators, benchmarking, and modular software ecosystems as immediate community priorities. 

We introduce QPU micro-kernels: shallow quantum circuits that perform a stencil node update and return a Monte Carlo estimate from repeated measurements. We show how to use them to solve Partial Differential Equations (PDEs) explicitly discretized on a computational stencil. From this point of view, the QPU serves as a sampling accelerator. Each micro-kernel consumes only stencil inputs (neighbor values and coefficients), runs a shallow parameterized circuit, and reports the sample mean of a readout rule. The resource footprint in qubits and depth is fixed and independent of the global grid. This makes micro-kernels easy to orchestrate from a classical host and to parallelize across grid points. We present two realizations. The Bernoulli micro-kernel targets convex-sum stencils by encoding values as single-qubit probabilities with shot allocation proportional to stencil weights. The branching micro-kernel prepares a selector over stencil branches and applies addressed rotations to a single readout qubit. In contrast to monolithic quantum PDE solvers that encode the full space-time problem in one deep circuit, our approach keeps the classical time loop and offloads only local updates. Batching and in-circuit fusion amortize submission and readout overheads. We test and validate the QPU micro-kernel method on two PDEs commonly arising in scientific computing: the Heat and viscous Burgers' equations. On noiseless quantum circuit simulators, accuracy improves as the number of samples increases. On the IBM Brisbane quantum computer, single-step diffusion tests show lower errors for the Bernoulli realization than for branching at equal shot budgets, with QPU micro-kernel execution dominating the wall time.

We present a blueprint for a quantum middle layer that supports applications across various quantum technologies. Inspired by concepts and abstractions from HPC libraries and middleware, our design is backend-neutral and context-aware. A program only needs to specify its intent once as typed data and operator descriptors. It declares what the quantum registers mean and which logical transformations are required, without committing to gates, pulses, continuous-variable routines, or anneal backend. Such execution details are carried separately in a context descriptor and can change per backend without modifying the intent artifacts. We develop a proof of concept implementation that uses JSON files for the descriptors and two backends: a gate-model path realized with IBM Qiskit Aer simulator and an annealing path realized with D-Wave Ocean’s simulated annealer. On a Max-Cut problem instance, the same typed problem runs on both backends by varying only the operator formulation (Quantum Approximated Optimization Algorithm formulation vs. Ising Hamiltonian formulation) and the context. The proposed middle layer concepts are characterized by portability, composability, and its minimal core can evolve with hardware capabilities.

Exascale computing revolutionizes scientific research by facilitating large-scale simulations and data analysis. As applications generate massive, heterogeneous data streams, the I/O subsystem increasingly dominates runtime, limiting scalability and time-to-solution. Emerging storage accelerators such as the Rabbit system offer a promising path forward. Rabbit provides dynamically configurable hybrid storage, combining high-bandwidth, node-local NVMe (e.g., XFS) with shared, distributed file systems (e.g., Lustre), to match diverse I/O patterns more efficiently. In this work, we evaluate Rabbit's capability to mitigate I/O bottlenecks using iPIC3D, a representative implicit Particle-in-Cell (PIC) code for exascale scientific workloads. We perform a detailed characterization of the key phases of I/O (restart, field, and moment) and identify the dominant access patterns in these phases. We then benchmark these patterns using IOR in Rabbit hybrid storage configurations, identifying the ideal performance achievable for each access pattern under node-local and distributed storage modes. We use phase-aware mapping of these patterns to Rabbit storage systems, achieving a 4.85 times improvement in I/O throughput, reducing the I/O share of runtime from 38% to 11% and delivering an end-to-end speedup of 1.45 times. These results outline the importance of hardware-software co-design and highlight Rabbit as a scalable, data-intensive storage solution.

We present performance scaling and optimization of iPIC3D - an exascale-class, GPU-enabled implicit particle-in-cell code for planetary-scale magnetosphere modeling and plasma simulation - on El Capitan. Our strong and weak scaling studies demonstrate near-linear scaling up to 8,000 nodes (32,000 APUs) with a parallel efficiency of nearly 100%. We optimize iPIC3D to leverage AMD’s MI300A APUs, the Merced Lustre filesystem, and Rabbit nodes for high-bandwidth I/O. Optimizations reduce memory usage by 97% and runtime by 74%, enabling simulations that are 1.8 times larger than before. Rabbit further improve checkpointing bandwidth by 2 times, ensuring scalable fault- tolerant simulations on exascale architectures.