MSG: Multidimensional Spectral Grids

• MSG is a software package that interpolates precomputed stellar spectra using C1-continuous cubic methods across multidimensional, Cartesian grids.
• It employs energy-conservative wavelength interpolation and limb-darkening laws to ensure physical fidelity in both flux and specific intensity outputs.
• The package features HDF5-backed storage with cache-based memory management, making it scalable for large spectral libraries and robust for stellar parameter inference.

MSG, short for Multidimensional Spectral Grids, is a software package for interpolating stellar spectra in pre-calculated grids of model atmospheres or photospheric parameters, rather than synthesizing each spectrum from scratch through direct radiative-transfer calculations in stellar atmospheres. Its purpose is to make the repeated use of expensive stellar atmosphere calculations computationally tractable: spectra are first precomputed on a grid, and spectra at intermediate parameter values are then obtained by interpolation. The package is designed for multidimensional stellar spectral grids, supports both fluxes and specific intensities, and is implemented as a modular library with multiple language bindings (Townsend et al., 2023).

1. Computational setting and motivation

The central problem addressed by MSG is the computational expense of direct stellar spectrum calculation. Computing a spectrum from first principles requires simulating radiation transport through the layers of a stellar atmosphere, and this is slow when many spectra are required for tasks such as spectral fitting, stellar parameter inference, forward modeling, or generating observables across a broad parameter space (Townsend et al., 2023).

The common alternative is to precompute spectra on a grid of stellar photospheric parameters and interpolate within that grid. MSG provides software infrastructure for this workflow. Its role is therefore not to replace model-atmosphere or spectrum-synthesis calculations, but to enable efficient and robust reuse of precomputed spectral libraries.

The package was motivated by the coexistence of many published stellar spectral grids and the absence of a focused interpolation package. The paper explicitly notes grids from Lanz & Hubeny (2003, 2007), Kirby (2011), de Laverny et al. (2012), Husser et al. (2013), Allende Prieto et al. (2018), Chiavassa et al. (2018), and Zsargó et al. (2020). The gap was therefore not the availability of grids, but the lack of software dedicated to flexible interpolation across them.

2. Grid model and interpolated variables

MSG operates on a precalculated grid of spectra and interpolates across an arbitrary number of photospheric parameters. The examples given in the paper are effective temperature $T_{\mathrm{eff}}$, surface gravity $g$, and metallicity $[\mathrm{Fe/H}]$, but the package does not restrict the number of physical interpolation variables so long as the underlying grid topology is Cartesian (Townsend et al., 2023).

The geometric requirement on the grid is important. Grid points must lie on a Cartesian topology, but the spacing in each dimension does not have to be uniform. In other words, the parameter space is rectilinear in topology rather than arbitrarily connected. This is the package’s main explicit structural constraint.

MSG also supports interpolation in additional variables beyond the photospheric parameter axes. It can interpolate in wavelength $\lambda$, and for limb-dependent specific intensity it also supports interpolation in direction cosine $\mu$, with

$\mu = \cos \theta .$

This places the package in the broader category of stellar-observable synthesis tools rather than a narrowly defined parameter-grid interpolator.

The grid data are stored in HDF5 container files using a flexible schema, and the package provides tools to convert grids from other formats into MSG’s format. This storage model is intended to accommodate large spectral libraries while keeping data organization sufficiently general for reuse in different applications.

3. Interpolation algorithms

The numerical core of MSG is implemented in a Fortran backend that is OpenMP-parallelized. The interpolation stack described in the paper has three components (Townsend et al., 2023):

1. Energy-conservative interpolation in wavelength $\lambda$
2. Parametric interpolation in direction cosine $\mu$ using limb-darkening laws
3. $C^{1}$-continuous cubic tensor-product interpolation across an arbitrary number of photospheric parameters

The multidimensional photospheric interpolation is characterized mathematically as

$C^{1}\text{-continuous},$

meaning that the interpolated function and its first derivatives are continuous across grid-cell boundaries. The paper explicitly links this smoothness to stable spectral modeling and fitting.

The package description does not provide an explicit polynomial basis or coefficient construction, but it does specify the tensor-product cubic character of the interpolation. Likewise, the wavelength treatment is described as energy-conservative interpolation in wavelength rather than simple pointwise interpolation, indicating that integrated energy or flux behavior is preserved by design. For angular interpolation in specific intensity, the dependence on $g$0 is handled through limb-darkening laws.

A further algorithmic feature is MSG’s handling of incomplete grids. The software can detect and gracefully handle interpolation attempts in regions with missing data, including ragged grid boundaries and holes in the grid. The response is interface-dependent: the Python interface raises exceptions, whereas the Fortran and C interfaces return status codes.

4. Software architecture and memory management

MSG is implemented as a software library rather than as a monolithic executable. The paper specifies three public interfaces: Python bindings, Fortran 2008 bindings, and C bindings (Townsend et al., 2023). Through these APIs, the package provides routines for interpolating both specific intensity spectra and flux spectra.

A practical design decision concerns memory usage. MSG does not load an entire large grid into memory at startup. Instead, it uses a cache in which data are loaded only when needed. Once the cache reaches a user-specified limit, older data are removed using a least-recently-used (LRU) policy. The paper emphasizes the relevance of this choice because some spectral grids can be hundreds of gigabytes in size.

This memory-management strategy is closely tied to the HDF5 storage format. The combination of HDF5-backed storage, lazy loading, and LRU eviction makes the package usable for very large libraries without requiring that the full grid reside in memory. A plausible implication is that the software is meant to be embedded in larger analysis workflows where grid access patterns are sparse and demand-driven, but the paper itself states the software-engineering facts rather than framing them as a broader systems claim.

5. Derived observables and operational workflow

Beyond interpolated spectra themselves, MSG can evaluate several derived outputs (Townsend et al., 2023). These include:

• moments of the radiation field
• spectra convolved with filter/instrument response functions
• resulting photometric colors

Accordingly, MSG is positioned not only as a spectral interpolator but also as a tool for synthesizing observables from stellar models. This is particularly relevant when precomputed model atmospheres are used as inputs to survey simulation, parameter estimation, or forward modeling pipelines.

The workflow described in the paper is straightforward. One starts with a precomputed stellar spectral grid, converts or stores it in MSG’s HDF5 format if necessary, loads the grid through the Python, Fortran, or C API, and requests a spectrum at a target set of photospheric parameters. MSG then interpolates in the relevant parameter dimensions, and, where needed, in $g$1 and $g$2. Additional synthesis steps can then be applied to compute radiation-field moments or convolve the spectrum with response functions to obtain colors.

This workflow is especially well matched to applications in which many nearby evaluations in parameter space are required. The software is therefore well suited to repeated-query regimes rather than one-off spectrum synthesis.

6. Relation to other interpolation tools

The paper situates MSG relative to several existing tools and emphasizes differences in interpolation order, API design, and grid restrictions (Townsend et al., 2023).

Tool	Interpolation / interface	Constraint or limitation noted
FERRE	piecewise-cubic interpolation; arbitrary number of photospheric parameters	only for grids with rectilinear boundaries; monolithic executable
Starfish	Python API; piecewise-linear interpolation; arbitrary number of parameters	linear interpolation has known limitations
stsynphot	Python API; piecewise-linear interpolation	limited to three photospheric parameters; hard-coded selection of grids
MSG	modular library; Python, Fortran 2008, and C bindings; cubic $g$3-continuous interpolation	grid topology must remain Cartesian

The comparison is not presented as a general benchmark of interpolation accuracy, but as a delineation of software scope and design. FERRE supports an arbitrary number of photospheric parameters and piecewise-cubic interpolation, but is described as being limited to grids with rectilinear boundaries and as a monolithic executable, making it less suitable for modular embedding. Starfish provides a Python API and arbitrary-parameter interpolation, but uses piecewise-linear interpolation. stsynphot also uses piecewise-linear interpolation, is limited to three photospheric parameters, and uses a hard-coded grid selection.

Within this comparison, MSG is defined by four distinguishing properties: it is focused specifically on spectral interpolation, it is modular, it provides higher-order cubic interpolation with $g$4 continuity, and it is engineered for large HDF5-backed grids.

7. Scope, advantages, and limitations

The practical significance of MSG lies in its ability to generate synthetic spectra, fluxes, specific intensities, radiation-field moments, and photometric colors from precomputed stellar atmosphere or spectral grids (Townsend et al., 2023). The paper explicitly identifies applications in spectral fitting, stellar parameter inference, forward modeling, generating observables for large samples of stars, and embedding interpolation into larger analysis pipelines.

The package’s stated advantages are: efficient use of precomputed grids; support for arbitrary-dimensional interpolation; cubic $g$5-continuous interpolation; support for both specific intensity and flux; angular interpolation with limb-darkening laws; HDF5-based storage and conversion tools; cache-based memory management for huge grids; modular interfaces in Python, Fortran, and C; graceful handling of missing-data regions; and the ability to compute additional observables such as colors.

Its principal explicit limitation is structural: the grid topology must remain Cartesian. Although spacing may be nonuniform along each axis, the package does not support arbitrary grid topology. A second limitation is methodological rather than a deficiency: when interpolation is requested in regions with missing data, MSG signals the issue rather than extrapolating through the missing region.

Taken together, these properties define MSG as a multilingual, modular interpolation library for stellar spectral grids whose primary contribution is to make expensive precomputed stellar atmosphere calculations reusable at scale. Its emphasis on smooth high-order interpolation, large-grid handling, and observables synthesis places it at the interface between numerical stellar atmosphere modeling and practical spectroscopic analysis.