Pith. sign in

REVIEW 2 major objections 6 minor 42 references

Accelerating Numerical Relativity with Code Generation: CUDA-enabled Hyperbolic Relaxation

T0 review · 2 major / 6 minor · reviewed 2026-08-10 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read NRPyEllipticGPU is the first GPU-enabled elliptic solver in numerical relativity, solving binary black hole initial-data problems up to 16x faster in single precision and 2-4x in double precision while matching CPU results to roundoff.

desk verdict Solid engineering contribution: working CUDA codegen for NR elliptic solves that deserves peer review once the speedup claims are separated into kernel-level and end-to-end. read the letter →

arxiv 2501.14030 v2 pith:XU7DY7BF submitted 2025-01-23 gr-qc physics.comp-ph

Samuel D. Tootle , Leonardo R. Werneck , Thiago Assumpção , Terrence Pierre Jacques , Zachariah B. Etienne This is my paper · ORCID
classification gr-qcphysics.comp-ph
keywords numericalrelativitybinaryblackholeinitialdataellipticPDEsolverhyperbolicrelaxationGPUaccelerationCUDAcodegenerationNRPygravitationalwavecatalogs
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

To meet the accuracy and catalog demands of next-generation gravitational-wave detectors, numerical relativity needs to run much faster on modern hardware. This paper claims that the bottleneck of binary black hole initial data—solving the elliptic Hamiltonian constraint—can be moved to GPUs efficiently via code generation. The authors extend NRPy with CUDA output to build NRPyEllipticGPU, which they call the first GPU-enabled elliptic solver in numerical relativity. It solves the same puncture initial-data equations as the CPU code NRPyElliptic and reproduces its results at roundoff level, while running up to 16x faster in single precision and 2-4x faster in double precision on a high-end GPU. If correct, this lowers the cost of generating the large waveform catalogs that Cosmic Explorer, Einstein Telescope, and LISA will require.

What carries the argument

The hyperbolic relaxation method recasts the elliptic Hamiltonian constraint for puncture data as a first-order-in-time system: $\partial_t u = v - \eta u$ and $\partial_t v = c^2(\tilde{\nabla}^2 u + \frac{1}{8}\tilde{A}_{ij}\tilde{A}^{ij}(\psi_{\rm singular}+u)^{-7})$, integrated with Runge-Kutta steps. An adaptive relaxation wavespeed proportional to local grid spacing, combined with NRPy's SinhSymTP compactified coordinates, keeps the CFL condition satisfied while accelerating relaxation waves toward the outer boundary. On the GPU, NRPy-generated CUDA kernels compute the right-hand side, Hamiltonian residual, Runge-Kutta substeps, and boundary conditions, with common-subexpression elimination and fused-multiply-add intrinsics reducing total instructions by about 21%.

What would settle it

Run the same binary black hole initial-data solve with an independently written, optimized CPU elliptic solver on the same Ryzen 9 5950X and compare wall-clock time to NRPyEllipticGPU; if the double-precision speedup over that baseline falls well below the reported 2-4x, the speedup claim is tied to the authors' own CPU implementation rather than to the GPU approach.

Watch

Extended reading notes

Core claim

The central claim is that a CUDA port of the hyperbolic relaxation elliptic solver, generated automatically by NRPy, achieves roundoff-level agreement with the trusted CPU solver while shifting the four dominant kernels—right-hand-side evaluation, Hamiltonian residual, Runge-Kutta substeps, and boundary conditions—from memory-bound on CPU to compute-bound on GPU. The paper measures arithmetic intensity up to two orders of magnitude higher on the GPU, a double-precision speedup of roughly 4x on an RTX 3080 against a Ryzen 9 5950X, and up to 16x in single precision for the expensive kernels. On an L40 HPC GPU the gain over the consumer GPU is only about 15%, which the paper traces to both being limited to two double-precision operations per clock cycle; it concludes that further double-precision gains require GPUs with higher double-precision throughput, such as V100 or A100.

Load-bearing premise

The reported speedups assume the authors' own OpenMP-optimized NRPyElliptic on the Ryzen 9 5950X is a fair high-end CPU baseline; no independent CPU solver is benchmarked and single-kernel timings may not reflect full production runs.

Editorial extensions

If this is right

  • Binary black hole initial-data solves that previously ran on CPUs can run on GPU hardware with roundoff-level identical answers, lowering the cost of building the large waveform catalogs that third-generation detectors need.
  • The roofline shift from memory-bound to compute-bound means double-precision performance is limited by GPU hardware throughput, not by the solver's memory access; GPUs with more double-precision units per SM should improve the double-precision speedup beyond 2-4x.
  • Single precision yields about 16x rather than the theoretical 64x because the kernels become memory-bound, so single-precision production use is most attractive when memory bandwidth, not peak FLOPs, is the bottleneck.
  • Independent multipatch grids scale nearly linearly on a single GPU, making the approach suitable for the authors' planned volunteer-computing campaign to generate BBH waveforms.
  • Because the elliptic solver shares infrastructure with evolution codes, the same NRPy CUDA code-generation path can be extended to full spacetime evolution, not just initial data.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If an independent, highly optimized CPU elliptic solver were benchmarked, the reported double-precision speedup could be smaller; the paper compares only against its own OpenMP NRPyElliptic implementation.
  • The same code-generation strategy likely maps to HIP or SYCL to reach AMD GPUs, but the paper only implements CUDA, so portability remains untested.
  • The roundoff-level agreement means the GPU solver could be dropped into existing Einstein Toolkit workflows as a substitute initial-data thorn, but end-to-end evolution-plus-initial-data benchmarks are not yet shown.
  • The 64x single/double precision peak gap on consumer GPUs suggests mixed-precision strategies, such as single-precision relaxation with double-precision residual checks, could extend speedups without sacrificing the reported accuracy.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 6 minor

Summary. This paper extends the NRPy code-generation framework to emit CUDA kernels and presents NRPyEllipticGPU, a GPU-accelerated elliptic solver for binary black hole initial data based on hyperbolic relaxation. The authors report roundoff-level agreement with the CPU version (L2 norm ~9e-13, Fig. 1), roofline analysis showing GPU kernels are compute-bound (Fig. 2), kernel-level speedups up to ~4x in double precision and ~16x in single precision relative to the CPU code (Fig. 3), and multi-patch scaling results with end-to-end speedups of 1.65-3.79x (Fig. 6). The paper also describes CUDA-specific optimizations including constant memory, intrinsics, streams, and hybrid CPU-GPU work distribution.

Significance. If the kernel-level performance transfers to production workloads, the work provides a useful template for GPU-accelerating NR codes via code generation, with potential impact on BlackHoles@Home and similar projects. The paper's strengths include a reproducible Zenodo release, a careful roundoff-level consistency study, detailed roofline analysis with Nsight and Likwid, and a demonstration that generated CUDA intrinsics reduce instruction counts and improve numerical agreement. However, the central quantitative claims are based on single-kernel timings and an internal CPU baseline; the end-to-end multi-patch results in Fig. 6 are considerably more modest. The significance is therefore real but conditional on the speedup claims being robust to a more demanding benchmark methodology.

major comments (2)
  1. [Abstract; Sec. 5.3.2; Fig. 3] The headline speedup claims of up to 16x in single precision and 2-4x in double precision are based on single kernel call timings, not total program runtime, as the Fig. 3 caption states. The abstract and Sec. 6 translate these into "NRPyEllipticGPU running about 4x faster" and "roughly a 16x speedup" without clarifying that these are kernel-level, not end-to-end, performance claims. The end-to-end multi-patch results in Fig. 6 show speedups of only 1.65-3.79x (average 3.23x) for coarse grids, a large discrepancy that is never reconciled. The paper should either present the end-to-end numbers as the primary performance claim or provide a detailed breakdown of why kernel-level timings dominate overall runtime.
  2. [Sec. 5.1; Sec. 5.3] The only CPU baseline is the authors' own OpenMP-parallelized, SIMD-optimized NRPyElliptic code. No independent or state-of-the-art CPU elliptic solver (e.g., a tuned multigrid or preconditioned Krylov solver) is benchmarked, so the "high-end CPU" comparison in the abstract is entirely internal. The roundoff-level agreement established in Sec. 5.2 is valuable for consistency, but the speedup figures in Fig. 3 and the phrase "compared to a high-end CPU" are not validated against an external reference. The authors should either benchmark a competitive CPU solver or clearly restrict their claims to their own baseline.
minor comments (6)
  1. [Abstract; Sec. 1; Sec. 6] The phrase "the first GPU-enabled elliptic solver in the NR community" is asserted without a systematic literature survey. I recommend softening to "to our knowledge" or citing a review that establishes novelty.
  2. [Fig. 3; Fig. 5; Fig. 6] No run-to-run variance or error bars are reported for any timing measurements. A few repeated runs would strengthen the claim that the observed speedups are statistically meaningful.
  3. [Sec. 2, Eq. (5)] The parameters eta (damping factor) and c (wave speed) are introduced but their specific values used in the benchmarks are not given. Listing them in Sec. 5 or an appendix would improve reproducibility.
  4. [Sec. 5.4, footnote 6] The energy-efficiency claim of a 1.3x improvement over NRPyElliptic is based on TDP-per-unit-speedup, a crude estimate that the authors acknowledge is not robust. This claim should be presented with stronger caveats or removed.
  5. [Sec. 3; Sec. 4] There are several missing spaces in compound words such as "theCUDA," "thehost," and "thedomain." These should be corrected in a final proofread.
  6. [Fig. 4; Sec. 5.4] The 21% reduction in total instructions is stated for the RHS kernel, but the surrounding text then discusses the H and RHS kernels together. Please clarify whether the instruction-count reduction is for RHS only or the combined set.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the GPU solver's performance and agreement figures are measured outputs, not consequences of how the inputs are defined.

full rationale

I walked the derivation chain and found no step in which a claimed prediction reduces to its own input by definition or by fitted construction. The elliptic equations come from the standard ADM/CTT puncture decomposition (Eqs. 1-5), with hyperbolic relaxation introduced independently in Ref. [33] and accelerated by methods from the authors' Paper I [32]; none of these antecedents define the GPU solver's target speedups. The consistency study (Fig. 1) checks that the CUDA port reproduces its CPU parent at roundoff level; this is an implementation-equivalence test, not a derivation in which the predicted quantity is also an input. The roofline and timing comparisons (Figs. 2, 3, 5) are direct profiler measurements, and Fig. 3 explicitly labels times as single kernel calls rather than total program runtime, so the 2-4x and 16x figures are reported as kernel-level empirical values rather than as end-to-end predictions. Fig. 6 separately reports end-to-end multipatch speedups of 1.65-3.79x. Using the same group's NRPyElliptic as the CPU baseline is a benchmarking-validity concern rather than circularity, because the speedup is measured against that code rather than derived from it. No fitted parameter is renamed as a prediction, no uniqueness theorem is imported from the authors' prior work, and no known result is repackaged under new coordinates. The 'first GPU-enabled elliptic solver' claim is an unsupported historical assertion, but it is not load-bearing for the technical performance results and is not a circular reduction.

Assumptions & free parameters 2 free parameters · 5 assumptions · 0 invented entities

The paper introduces no new physical entities and no fitted physics constants. The free parameters listed are inherited relaxation tuning inputs from Paper I. The key assumptions are standard puncture-formalism equations, the hyperbolic relaxation steady-state property, the algorithmic convergence strategy from Paper I, and the fairness of the internal CPU baseline.

free parameters (2)
  • damping factor eta = not specified in this paper (inherited from Paper I)
    Damping term in Eq. (5); chosen to stabilize hyperbolic relaxation and not fitted to GPU benchmark data.
  • relaxation wavespeed c = adaptive, set proportional to local grid spacing
    Wave speed in Eq. (5); tuned in Paper I with SinhSymTP coordinates to satisfy CFL and accelerate convergence; affects relaxation time but not the central GPU-vs-CPU comparison.
assumptions (5)
  • domain assumption The Hamiltonian constraint for conformally flat Brandt-Bruegmann puncture data reduces to Eq. (4), with the momentum constraint solved analytically.
    Standard puncture initial data framework (Brandt-Bruegmann 1997; Cook 2000). The paper solves only Eq. (4), so correctness of the solution target relies on this reduction.
  • domain assumption The steady state of the hyperbolic relaxation system (5) coincides with the solution of the elliptic Hamiltonian constraint.
    This is the basis of the hyperbolic relaxation method (Rüter et al. 2018) and is inherited from Paper I; not re-derived in this paper.
  • domain assumption The adaptive relaxation wavespeed, with c proportional to local grid spacing, and the SinhSymTP coordinates satisfy the CFL condition and accelerate convergence.
    Algorithmic tuning from Paper I; the performance and agreement results depend on it, but the robustness of this choice is not separately analyzed here.
  • ad hoc to paper The OpenMP-parallelized, SIMD-optimized NRPyElliptic CPU code is a fair baseline for the reported speedups.
    Sec. 5.1 states comparisons use the authors' own optimized OpenMP version; no external CPU elliptic solver is benchmarked. Speedup numbers are therefore internal rather than state-of-the-art CPU comparisons.
  • domain assumption The measured GPU performance on RTX 3080 and L40 generalizes to other GPUs targeted by the paper (A100, V100, etc.).
    Sec. 5.5.1 extrapolates from two GPUs with compute capability 8.6 and 8.9 to data-center GPUs; this is an extrapolation, not a measurement.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Accelerating Numerical Relativity with Code Generation: CUDA-enabled Hyperbolic Relaxation." pith.science (2026). https://pith.science/paper/XU7DY7BF

@misc{pith2026250114030,
  author       = {Pith},
  title        = {Pith review of: Accelerating Numerical Relativity with Code Generation: CUDA-enabled Hyperbolic Relaxation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XU7DY7BF}},
  note         = {Machine review of arXiv:2501.14030}
}
read the original abstract

Next-generation gravitational wave detectors such as Cosmic Explorer, the Einstein Telescope, and LISA, demand highly accurate and extensive gravitational wave (GW) catalogs to faithfully extract physical parameters from observed signals. However, numerical relativity (NR) faces significant challenges in generating these catalogs at the required scale and accuracy on modern computers, as NR codes do not fully exploit modern GPU capabilities. In response, we extend NRPy, a Python-based NR code-generation framework, to develop NRPyEllipticGPU -- a CUDA-optimized elliptic solver tailored for the binary black hole (BBH) initial data problem. NRPyEllipticGPU is the first GPU-enabled elliptic solver in the NR community, supporting a variety of coordinate systems and demonstrating substantial performance improvements on both consumer-grade and HPC-grade GPUs. We show that, when compared to a high-end CPU, NRPyEllipticGPU achieves on a high-end GPU up to a sixteenfold speedup in single precision while increasing double-precision performance by a factor of 2--4. This performance boost leverages the GPU's superior parallelism and memory bandwidth to achieve a compute-bound application and enhancing the overall simulation efficiency. As NRPyEllipticGPU shares the core infrastructure common to NR codes, this work serves as a practical guide for developing full, CUDA-optimized NR codes.

Figures

Figures reproduced from arXiv: 2501.14030 by the authors.

Figure 1
Figure 1. Solution comparison between NRPyElliptic and NRPyEllipticGPU halfway through relaxation (red) and at the end of relaxation (blue). Triangle (square) markers denote generating NRPyEllipticGPU with (without) CUDA intrinsics. a sufficiently complex calculation can outweigh the memory access latency if there is enough work to be performed. 5.3.2. Performance Metrics and Observations [PITH_FULL_IMAGE:figures/full_fig_p0… view at source ↗
Figure 2
Figure 2. Roofline comparison of the vectorized (SIMD) CPU version of NRPyElliptic and the accelerated NRPyEllipticGPU (GPU) codes. Here we plot the data for the RHS (Right-Hand Side), H (Hamiltonian Constraint), RK (Runge-Kutta substeps), and BC (Boundary Conditions) kernels. CPU metrics were obtained using Likwid 5.3, while GPU metrics were obtained using NVIDIA Nsight Compute 2022.3.0.0. considerably more active threads ex… view at source ↗
Figure 3
Figure 3. For each bar, we show the execution time for a single call to each kernel, not the entire program runtime, for increasing grid sizes. We compare the NRPyElliptic CPU code (no hatch marks) against NRPyEllipticGPU without CUDA intrinsics (GPU), NRPyEllipticGPU with CUDA intrinsics (GPU-I), and NRPyEllipticGPU using single precision (GPU×32). Dashed lines denote approximate ideal weak scaling. are not able to achieve t… view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: Instruction distribution for the NRPyEllipticGPU RHS kernel, comparing the code port without intrinsics (No intrinsics) to one using CUDA intrinsics (Intrinsics). The “Total Instructions” bar shows the overall reduction in instruction count. ∼2x higher than the reporte…
Figure 5
Figure 5. Figure 5: Same as [PITH_FULL_IMAGE:figures/full_fig_p020_5.png]
Figure 6
Figure 6. Figure 6: Left: Total execution time (tN ) for N grids, normalized by the single￾grid runtime (t1). NRPyElliptic results (blue) increase faster than the nearly linear NRPyEllipticGPU results using 1 CUDA stream (orange) or N CUDA streams (green). Right: Overall GPU speedup compa…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

42 extracted references · 15 canonical work pages

  1. [1]

    GWTC-2.1: Deep extended catalog of compact binary coalescences observed by LIGO and Virgo during the first half of the third observing run

    R. Abbott et al. “GWTC-2.1: Deep extended catalog of compact binary coalescences observed by LIGO and Virgo during the first half of the third observing run”. In: Phys. Rev. D 109.2 (2024), p. 022001. doi: 10 . 1103 / PhysRevD.109.022001 . Preprint available at https://arxiv.org/abs/2108. 01045

    work page 2024

  2. [2]

    GWTC-3: Compact Binary Coalescences Observed by LIGO and Virgo during the Second Part of the Third Observing Run

    R. Abbott et al. “GWTC-3: Compact Binary Coalescences Observed by LIGO and Virgo during the Second Part of the Third Observing Run”. In: Phys. Rev. X 13.4 (2023), p. 041039. doi: 10.1103/PhysRevX.13.041039. Preprint available at https://arxiv.org/abs/2111.03606

    arXiv 2023

  3. [3]

    Eccentricity estimate for black hole mergers with numerical relativity simulations

    V. Gayathri et al. “Eccentricity estimate for black hole mergers with numerical relativity simulations”. In: Nature Astron. 6.3 (2022), pp. 344–349. doi: 10.1038/ s41550- 021- 01568- w. Preprint available at https://arxiv.org/abs/2009. 05461

    work page 2022

  4. [4]

    Parameter estimation method that directly compares gravitational wave observations to numerical relativity

    J. Lange et al. “Parameter estimation method that directly compares gravitational wave observations to numerical relativity”. In: Phys. Rev. D 96.10 (2017), p. 104041. doi: 10 . 1103 / PhysRevD . 96 . 104041. Preprint available at https : //arxiv.org/abs/1705.09833

    arXiv 2017

  5. [5]

    Directly comparing GW150914 with numerical solutions of Einstein’s equations for binary black hole coalescence

    B. P. Abbott et al. “Directly comparing GW150914 with numerical solutions of Einstein’s equations for binary black hole coalescence”. In: Phys. Rev. D 94.6 (2016), p. 064035. doi: 10 . 1103 / PhysRevD . 94 . 064035. Preprint available at https://arxiv.org/abs/1606.01262

    arXiv 2016

  6. [6]

    Accessed: 2024-09-07, Available at: https: //xdmod.access-ci.org/

    ACCESS Resource Metrics (XMOD) . Accessed: 2024-09-07, Available at: https: //xdmod.access-ci.org/

    work page 2024

  7. [7]

    Gravitational waveform accuracy requirements for future ground-based detectors

    Michael P¨ urrer and Carl-Johan Haster. “Gravitational waveform accuracy requirements for future ground-based detectors”. In: Phys. Rev. Res. 2.2 (2020), p. 023151. doi: 10 . 1103 / PhysRevResearch . 2 . 023151. Preprint available at https://arxiv.org/abs/1912.10055

    arXiv 2020

  8. [8]

    Assessing the readiness of numerical relativity for LISA and 3G detectors

    Deborah Ferguson et al. “Assessing the readiness of numerical relativity for LISA and 3G detectors”. In: Phys. Rev. D 104.4 (2021), p. 044037. doi: 10 . 1103 / PhysRevD.104.044037 . Preprint available at https://arxiv.org/abs/2006. 04272

    work page 2021

Show all 42 references
  1. [9]

    SENR/NRPy+: Numerical Relativity in Singular Curvilinear Coordinate Systems

    Ian Ruchlin, Zachariah B. Etienne, and Thomas W. Baumgarte. “SENR/NRPy+: Numerical Relativity in Singular Curvilinear Coordinate Systems”. In: Phys. Rev. D 97.6 (2018), p. 064036. doi: 10.1103/PhysRevD.97.064036. Preprint available at https://arxiv.org/abs/1712.07658

    2018 arXiv

  2. [10]

    Improved moving-puncture techniques for compact binary simulations

    Zachariah B. Etienne. “Improved moving-puncture techniques for compact binary simulations”. In: Phys. Rev. D 110.6 (2024), p. 064045. doi: 10.1103/PhysRevD. 110.064045. Preprint available at https://arxiv.org/abs/2404.01137. REFERENCES 27

    2024 arXiv

  3. [11]

    Baumgarte and Stuart L

    Thomas W. Baumgarte and Stuart L. Shapiro. Numerical Relativity: Solving Einstein ’s Equations on the Computer. Cambridge, U.K., 2010

    2010

  4. [12]

    3+1 formalism and bases of numerical relativity

    Eric Gourgoulhon. “3+1 formalism and bases of numerical relativity”. In: (Mar. 2007). Preprint available at https://arxiv.org/abs/gr-qc/0703035

    2007 arXiv

  5. [13]

    Taking GPU Programming Models to Task for Performance Portability

    Joshua H. Davis et al. “Taking GPU Programming Models to Task for Performance Portability”. In: arXiv e-prints , arXiv:2402.08950 (Feb. 2024), arXiv:2402.08950. doi: 10.48550/arXiv.2402.08950 . Preprint available at https://arxiv.org/ abs/2402.08950

    2024 doi arXiv

  6. [14]

    OpenMP Application Program Interface Version 5.0

    OpenMP Architecture Review Board. OpenMP Application Program Interface Version 5.0 . 2018. url: https : / / www . openmp . org / wp - content / uploads / OpenMP-API-Specification-5.0.pdf

    2018

  7. [15]

    Achieving Portability and Performance through OpenACC

    J. A. Herdman et al. “Achieving Portability and Performance through OpenACC”. In: 2014 First Workshop on Accelerator Programming using Directives . 2014, pp. 19–26. doi: 10.1109/WACCPD.2014.10

    2014 doi

  8. [16]

    Evaluating the performance portability of SYCL across CPUs and GPUs on bandwidth-bound applications

    Istvan Z. Reguly. “Evaluating the performance portability of SYCL across CPUs and GPUs on bandwidth-bound applications”. In: Proceedings of the SC ’23 Workshops of The International Conference on High Performance Computing, Network, Storage, and Analysis . SC-W ’23. Denver, CO...

    2023

  9. [17]

    RAJA: Portable Performance for Large-Scale Scientific Applications

    David A. Beckingsale et al. “RAJA: Portable Performance for Large-Scale Scientific Applications”. In: 2019 IEEE/ACM International Workshop on Performance, Portability and Productivity in HPC (P3HPC) . 2019, pp. 71–81. doi: 10.1109/P3HPC49587.2019.00012

    2019

  10. [18]

    Kokkos 3: Programming Model Extensions for the Exascale Era

    Christian R. Trott et al. “Kokkos 3: Programming Model Extensions for the Exascale Era”. In: IEEE Transactions on Parallel and Distributed Systems 33.4 (2022), pp. 805–817. doi: 10.1109/TPDS.2021.3097283

    2022

  11. [19]

    AsterX: a new open-source GPU-accelerated GRMHD code for dynamical spacetimes

    Jay V. Kalinani et al. “AsterX: a new open-source GPU-accelerated GRMHD code for dynamical spacetimes”. In: arxiv (June 2024). Preprint available at https: //arxiv.org/abs/2406.11669

    2024 arXiv

  12. [20]

    GRaM-X: a new GPU-accelerated dynamical spacetime GRMHD code for Exascale computing with the Einstein Toolkit

    Swapnil Shankar et al. “GRaM-X: a new GPU-accelerated dynamical spacetime GRMHD code for Exascale computing with the Einstein Toolkit”. In: Class. Quant. Grav. 40.20 (2023), p. 205009. doi: 10.1088/1361-6382/acf2d9. Preprint available at https://arxiv.org/abs/2210.17509

    2023

  13. [21]

    http:einsteintoolkit.org

    Einstein Toolkit home page . http:einsteintoolkit.org

  14. [22]

    AMReX: A Framework for Block-Structured Adaptive Mesh Refinement

    Weiqun Zhang et al. “AMReX: A Framework for Block-Structured Adaptive Mesh Refinement”. In: Journal of Open Source Software 4.37 (2019), p. 1370. doi: 10.21105/joss.01370. REFERENCES 28

    2019 doi

  15. [23]

    K-athena: a performance portable structured grid finite volume magnetohydrodynamics code

    Philipp Grete, Forrest W Glines, and Brian W O’Shea. “K-athena: a performance portable structured grid finite volume magnetohydrodynamics code”. In: IEEE Transactions on Parallel and Distributed Systems 32.1 (2020), pp. 85–97

    2020

  16. [24]

    Parthenon – a performance portable block-structured adaptive mesh refinement framework

    Philipp Grete et al. “Parthenon – a performance portable block-structured adaptive mesh refinement framework”. In: arXiv e-prints, arXiv:2202.12309 (Feb. 2022), arXiv:2202.12309. doi: 10.48550/arXiv.2202.12309 . Preprint available at https://arxiv.org/abs/2202.12309

    2022 doi arXiv

  17. [25]

    Performance-Portable Numerical Relativity with AthenaK

    Hengrui Zhu et al. “Performance-Portable Numerical Relativity with AthenaK”. In: arxiv (Sept. 2024). Preprint available at https : / / arxiv . org / abs / 2409 . 10383

    2024

  18. [26]

    Performance-Portable Binary Neutron Star Mergers with AthenaK

    Jacob Fields et al. “Performance-Portable Binary Neutron Star Mergers with AthenaK”. In: arxiv (Sept. 2024). Preprint available at https : / / arxiv . org / abs/2409.10384

    2024 arXiv

  19. [27]

    GPU-accelerated simulations of isolated black holes

    Adam G. M. Lewis and Harald P. Pfeiffer. “GPU-accelerated simulations of isolated black holes”. In: Class. Quant. Grav. 35.9 (2018), p. 095017. doi: 10. 1088/1361-6382/aab256 . Preprint available at https://arxiv.org/abs/1804. 09101

    2018

  20. [28]

    A GPU-accelerated AMR solver for gravitational wave propagation

    Milinda Fernando et al. “A GPU-accelerated AMR solver for gravitational wave propagation”. In: International Conference for High Performance Computing, Networking, Storage and Analysis . Nov. 2022. doi: 10.5555/3571885.3571984

    2022

  21. [29]

    A Simflowny-based finite-difference code for high- performance computing in numerical relativity

    Carlos Palenzuela et al. “A Simflowny-based finite-difference code for high- performance computing in numerical relativity”. In: Class. Quant. Grav. 35.18 (2018), p. 185007. doi: 10.1088/1361-6382/aad7f6. Preprint available athttps: //arxiv.org/abs/1806.04182

    2018 arXiv

  22. [30]

    Code generation for AMReX with applications to numerical relativity

    Adam J. Peterson et al. “Code generation for AMReX with applications to numerical relativity”. In: Class. Quant. Grav. 40.24 (2023), p. 245013. doi: 10. 1088/1361-6382/ad0b37 . Preprint available at https://arxiv.org/abs/2301. 08354

    2023

  23. [31]

    http://nrpyplus.net/

    NRPy+’s webpage. http://nrpyplus.net/

  24. [32]

    Fast hyperbolic relaxation elliptic solver for numerical relativity: Conformally flat, binary puncture initial data

    Thiago Assumpcao et al. “Fast hyperbolic relaxation elliptic solver for numerical relativity: Conformally flat, binary puncture initial data”. In: Phys. Rev. D 105.10 (2022), p. 104037. doi: 10.1103/PhysRevD.105.104037 . Preprint available at https://arxiv.org/abs/2111.02424

    2022 arXiv

  25. [33]

    Hyperbolic Relaxation Method for Elliptic Equations

    Hannes R. R¨ uter et al. “Hyperbolic Relaxation Method for Elliptic Equations”. In: Phys. Rev. D 98.8 (2018), p. 084044. doi: 10.1103/PhysRevD.98.084044 . Preprint available at https://arxiv.org/abs/1708.07358

    2018 arXiv

  26. [34]

    Dynamical Structure and Definition of Energy in General Relativity

    Richard L. Arnowitt, Stanley Deser, and Charles W. Misner. “Dynamical Structure and Definition of Energy in General Relativity”. In: Phys. Rev. 116 (1959), pp. 1322–1330. doi: 10.1103/PhysRev.116.1322. REFERENCES 29

    1959 doi

  27. [35]

    The Dynamics of general relativity

    Richard L. Arnowitt, Stanley Deser, and Charles W. Misner. “The Dynamics of general relativity”. In: Gen. Rel. Grav. 40 (2008), pp. 1997–2027. doi: 10.1007/ s10714 - 008 - 0661 - 1. Preprint available at https : / / arxiv . org / abs / gr - qc/0405109

    2008

  28. [36]

    Initial data for numerical relativity

    Gregory B. Cook. “Initial data for numerical relativity”. In: Living Rev. Rel. 3 (2000), p. 5. doi: 10.12942/lrr-2000-5 . Preprint available at https://arxiv. org/abs/gr-qc/0007085

    2000 arXiv

  29. [37]

    A Simple construction of initial data for multiple black holes

    Steven Brandt and Bernd Bruegmann. “A Simple construction of initial data for multiple black holes”. In: Phys. Rev. Lett. 78 (1997), pp. 3606–3609. doi: 10 . 1103 / PhysRevLett . 78 . 3606. Preprint available at https : / / arxiv . org / abs/gr-qc/9703066

    1997 arXiv

  30. [38]

    https://docs.nvidia.com/ cuda/cuda-c-programming-guide/

    NVIDIA: CUDA C Programming Guide webpage . https://docs.nvidia.com/ cuda/cuda-c-programming-guide/

  31. [39]

    Array programming with NumPy

    Charles R. Harris et al. “Array programming with NumPy”. In: Nature 585.7825 (Sept. 2020), pp. 357–362. doi: 10.1038/s41586-020-2649-2

    2020 doi

  32. [40]

    SciPy 1.0: Fundamental Algorithms for Scientific Computing in Python

    Pauli Virtanen et al. “SciPy 1.0: Fundamental Algorithms for Scientific Computing in Python”. In: Nature Methods 17 (2020), pp. 261–272. doi: 10.1038/s41592- 019-0686-2

    2020 doi

  33. [41]

    SymPy: symbolic computing in Python

    Aaron Meurer et al. “SymPy: symbolic computing in Python”. In: PeerJ Computer Science 3 (Jan. 2017), e103. issn: 2376-5992. doi: 10.7717/peerj-cs.103

    2017 doi

  34. [42]

    Matplotlib: A 2D graphics environment

    J. D. Hunter. “Matplotlib: A 2D graphics environment”. In: Computing in Science & Engineering 9.3 (2007), pp. 90–95. doi: 10.1109/MCSE.2007.55

    2007 doi

Pith tools

Reviewed August 10, 2026 · model on record in the stance chip above.