🔭 astrophysics

RotCurves: A PYTHON package for efficient modelling and fitting of galactic rotation curves at high-z

The paper introduces RotCurves, a publicly available Python package that offers a highly efficient (250x faster than dysmalpy) and flexible parametric forward-modeling tool for analyzing high-redshift galactic rotation curves by accurately correcting for beam smearing, making it ideal for rapid mass model testing and processing large IFU survey datasets.

Original authors: A. Nestor Shachar, A. Sternberg, S. H. Price, N. M. Förster Schreiber, R. Genzel, L. J. Tacconi, H. Übler, C. Barfety, A. Burkert, J. Chen, R. Davies, F. Eisenhauer, J. M. Espejo Salcedo, R. Herrera-C

Published 2026-02-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: A. Nestor Shachar, A. Sternberg, S. H. Price, N. M. Förster Schreiber, R. Genzel, L. J. Tacconi, H. Übler, C. Barfety, A. Burkert, J. Chen, R. Davies, F. Eisenhauer, J. M. Espejo Salcedo, R. Herrera-Camus, J. B. Jolly, L. L. Lee, T. Naab, S. Pastras, C. Pulsoni, T. T. Shimizu, G. Tozzi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine trying to understand how a giant, spinning pizza dough moves through space. In astronomy, these "pizzas" are galaxies, and the "spin" is called a rotation curve. By measuring how fast different parts of a galaxy spin, astronomers can figure out what it's made of—how much normal stuff (stars and gas) it has, and how much invisible "dark matter" is holding it together.

However, looking at these spinning galaxies from Earth is like trying to watch that pizza dough through a foggy, blurry window. The further away the galaxy is (which means looking back in time to the early universe), the blurrier it gets. This blur, caused by our telescopes and the atmosphere, is called "beam smearing." It smoothes out the sharp details of the motion, making the galaxy look like it's spinning slower or differently than it actually is.

The Problem: The Slow, Heavy Calculator

To fix this blur, astronomers use computer programs to "un-smear" the data. They build a fake model of a galaxy, run it through a simulation of the telescope's blur, and compare the result to the real data.

One popular tool for this is called dysmalpy. It's very accurate, but it's also incredibly slow. Think of it like trying to solve a massive jigsaw puzzle by making a 3D hologram of every single piece, rotating it, and then flattening it back down to see how it fits. It works, but it takes a long time—hours or even days for complex models. If you have thousands of galaxies to study (which is the case with modern telescopes), this method is too slow to be practical.

The Solution: RotCurves

The authors of this paper introduce a new tool called RotCurves. They describe it as a "fast-forward" version of the puzzle solver.

Instead of building a full 3D hologram of the galaxy, RotCurves uses a clever shortcut. Imagine looking at the spinning pizza dough from the side. Instead of simulating the entire 3D volume of the dough, RotCurves just looks at the flat surface of the dough and stretches the "blur" (the telescope's view) to match the angle of the pizza.

The Analogy: If you look at a round coin from the side, it looks like a thin ellipse. RotCurves realizes that instead of simulating the whole 3D coin, it can just stretch the "blur" into an ellipse and apply it to the flat surface. This saves a massive amount of computing power.

How Fast Is It?

The paper claims that RotCurves is about 250 times faster than the old method (dysmalpy).

dysmalpy: Takes about 3,600 milliseconds (3.6 seconds) to process one galaxy model.
RotCurves: Takes about 20 milliseconds (0.02 seconds).

It's the difference between waiting for a slow internet download and having the file instantly. This speed allows astronomers to test many different theories and models in the time it used to take to test just one.

Does It Work?

The authors tested RotCurves by comparing its results against the trusted, slower dysmalpy using "fake" galaxies (simulated data).

For Clear Views: When the galaxy is well-resolved (not too blurry), RotCurves agrees with the slow method almost perfectly (within 5%).
For Blurry Views: When the galaxy is very blurry (like looking at a distant, fuzzy smudge), the results start to drift apart, with differences up to 15%.
The "Bulge" Issue: The tool tends to slightly underestimate how much the galaxy is spinning in the very center (where the "bulge" of stars is) and slightly overestimate the size of the galaxy's disk. It's like guessing the size of a blurry circle; you might guess it's a bit bigger than it really is.

The Fitting Machine

RotCurves also includes a built-in "guessing machine" (called MCMC). Once you give it the blurry data, it tries thousands of different combinations of galaxy properties (mass, size, spin speed) to see which one matches the data best.

High Signal (Clear Data): It finds the right answer very accurately.
Low Signal (Noisy Data): If the data is very noisy (like trying to hear a whisper in a storm), the guesses become less accurate, especially for the galaxy's size and total mass.

Summary

RotCurves is a new, super-fast computer tool for astronomers. It allows them to quickly figure out how galaxies spin and what they are made of, even when the images are blurry. While it's not perfect for the very blurriest images, it is accurate enough for most cases and is so much faster than previous tools that it opens the door to studying thousands of galaxies at once, rather than just a handful.

The code is free and available for anyone to use, helping astronomers make sense of the vast amounts of data coming from powerful new telescopes like the James Webb Space Telescope.

Technical Summary: RotCurves – A Python Package for Efficient Modelling and Fitting of Galactic Rotation Curves at High-z

Problem Statement
Rotation curves are fundamental for understanding galaxy structure, dynamics, and dark matter halos. However, analyzing these curves at high redshift ( $z$ ) presents significant challenges due to surface brightness dimming and limited angular resolution. These limitations lead to "beam smearing," an artificial smoothing of velocity gradients caused by convolving light from large physical areas over the source. Correcting for this effect is critical but computationally expensive. Existing parametric forward-modelling tools, such as dysmalpy, construct full 3D or 4D data cubes (including spatial and spectral dimensions) to simulate observations. While accurate, these methods are computationally intensive, often requiring seconds to minutes per realization, which hinders rapid parameter exploration, testing of multiple mass model assumptions, and the processing of large samples from upcoming Integral Field Unit (IFU) surveys. There is a need for a tool that balances the accuracy of beam smearing correction with computational efficiency.

Methodology
The authors present RotCurves, a parametric forward-modelling tool designed to fit galactic rotation curves efficiently by approximating the beam smearing process in 2D rather than 3D.

Model Construction: The code constructs an idealized, axisymmetric galaxy model in centrifugal equilibrium. It calculates the intrinsic circular velocity in the galactic midplane by summing the contributions of various mass components:
- Baryons: Modeled as razor-thin or thick disks and bulges using Sérsic profiles (including exponential and de Vaucouleurs profiles).
- Dark Matter: Modeled as spherically symmetric halos using profiles such as NFW, $\alpha$ -NFW, Burkert, Einasto, and Dekel-Zhao. The code includes an option for adiabatic contraction of the halo due to baryonic accumulation.
- Pressure Support: The model corrects the observed rotation velocity for pressure gradients in the turbulent interstellar medium (ISM) using hydrostatic equilibrium assumptions, converting intrinsic circular velocity to observable rotational velocity based on velocity dispersion ( $\sigma_0$ ).
Beam Smearing Approximation: Unlike tools that rotate a 3D galaxy cube to match the sky and convolve with a Point Spread Function (PSF), RotCurves projects the beam onto the galactic midplane. For a given inclination angle $i$ , a circular Gaussian PSF is transformed into a bi-variate Gaussian with an axis ratio of $1/\cos(i)$ . The observed velocity and velocity dispersion at a given radius are calculated as weighted averages over this "effective beam," accounting for the emission profile (light weighting) and line-of-sight projection.
Fitting Procedure: The package includes a built-in Bayesian inference engine using the emcee MCMC sampler. It fits the model to observed rotation curves by minimizing a log-probability function comprising a least-squares likelihood and user-defined priors (uniform or Gaussian) on parameters such as baryonic mass, effective radius, bulge-to-total ratio, intrinsic velocity dispersion, and dark matter halo mass.

Key Contributions

Computational Efficiency: RotCurves achieves a runtime of $\sim 10-20$ ms per realization for a typical grid, which is approximately 250 times faster than dysmalpy (which takes $\sim 3-4$ seconds for the same task). This speedup is achieved by avoiding the construction of full 4D hypercubes.
2D Beam Projection: The paper introduces and validates a 2D projection method for beam smearing that accounts for inclination without requiring full 3D volume integration.
Benchmarking: The authors rigorously benchmark RotCurves against dysmalpy using synthetic observations of a fiducial $z=2$ galaxy model.

Results

Accuracy vs. dysmalpy: For well-resolved systems (PSF FWHM $< R_{\text{eff}}$ $< R_{eff}$ ), RotCurves reproduces the mock observed rotation and dispersion curves generated by dysmalpy to within 5% up to $3R_{\text{eff}}$ $3 R_{eff}$ . In marginally resolved systems (PSF FWHM $\gtrsim 1.5 R_{\text{eff}}$ $≳ 1.5 R_{eff}$ ), discrepancies increase to up to 15%.
- Systematic Differences: RotCurves tends to slightly underestimate velocity dispersion in the inner regions (by $\sim 10\%$ ) because it only considers midplane motions, whereas dysmalpy integrates off-midplane particles that broaden the line.
Parameter Recovery: Using MCMC fitting on synthetic data, RotCurves successfully recovers intrinsic model parameters (mass, radius, dispersion, dark matter fraction) across a wide range of galaxy properties.
- Biases: Systematic biases emerge for the effective radius ( $R_{\text{eff}}$ ), which is often overestimated by a factor of $\sim 1.5$ , and for low disk masses ( $M_{\text{disk}} \lesssim 3 \times 10^9 M_\odot$ ), where the disk mass is poorly constrained.
- Signal-to-Noise (S/N): Parameter recovery is excellent at high S/N ( $\gtrsim 25$ ). At lower S/N, deviations increase, particularly for disk mass and dark matter fractions. However, bulge mass and intrinsic velocity dispersion remain relatively robust even at lower S/N.
Inclination Limits: The tool is best suited for inclinations between $10^\circ$ and $80^\circ$ .

Significance and Claims
The paper positions RotCurves primarily as an exploratory tool for rapid testing of mass model assumptions and parameter studies, rather than a replacement for full 3D modeling in all contexts. Its significance lies in its ability to:

Efficiently process large samples of observational data from current and future large IFU surveys (e.g., VLT/MAVIS, JWST/NIRSpec, ELT/MOSAIC).
Facilitate the testing of different priors, profile shapes, and systematic effects without the computational overhead of full 3D simulations.
Provide quick, reasonable parameter estimates for high-redshift galaxies, serving as a starting point for more detailed analysis.

The authors emphasize that while RotCurves is highly efficient and accurate for well-resolved systems, users should exercise caution when interpreting results from poorly resolved, low S/N systems, where beam smearing effects are most severe and systematic biases (particularly in $R_{\text{eff}}$ ) are most pronounced. The code is publicly available on GitHub.