Spinifex is a pure Python tooling for ionospheric corrections in radio astronomy, e.g. getting total electron content and rotation measures.

StellarSpecModel is a Python package to interpolate the stellar spectral grid. Users provide stellar parameters (Teff, FeH, logg), the package will return the corresponding stellar spectrum.

This packagge also designed for generating and analyzing theoretical stellar spectral energy distributions (SEDs). The package includes functionality for both single and binary star systems, incorporating extinction models and the ability to handle photometric data in various filter bands.

Deep-Transit detects transits using a deep learning based 2D object detection algorithm. The code determines the light curve and outputs the transiting candidates' bounding boxes and confidence scores. It has been trained for Kepler and TESS data, and can be extended to other photometric surveys and even ground-based observations. Deep-Transit also provides an interface for training new datasets.

ROCKE-3D (Resolving Orbital and Climate Keys of Earth and Extraterrestrial Environments with Dynamics) models the atmospheres and oceans of solar system and exoplanetary terrestrial planets. Written in Fortran, it is a three-dimensional General Circulation Model (GCM). ROCKE-3D requires Panoply, the SOCRATES radiation code and spectral files, and has several additional dependencies.

The spectools_ir suite analyzes medium/high-resolution IR molecular astronomical spectra. It has three main sub-modules (flux_calculator, slabspec, and slab_fitter) and also offers a sub-module (utils) with a few additional functions. Written with infrared medium/high-resolution molecular spectroscopy in mind, spectools_ir generally assumes spectra are in units of Jy and microns and uses information from the HITRAN molecular database. Some routines are more general, but users interested in other applications should proceed with caution.

NbodyGradient computes gradients of N-body integrations for Newtonian gravity and arbitrary N-body hierarchies. Developed for transit-timing analyses and written in Julia, NbodyGradient gives derivatives of the transit times with respect to the initial conditions, either masses and Cartesian coordinates/velocities or orbital elements.

Hierarchical Semi-Sparse Cube (HiSS-Cube) framework provides highly parallel processing of combined multi-modal multi-dimensional big data. The package builds a database on top of the HDF5 framework which supports parallel queries. A database index on top of HDF5 can be easily constructed in parallel, and the code supports efficient multi-modal big data combinations. The performance of HiSS-Cube is bounded by the I/O bandwidth and I/O operations per second of the underlying parallel file system; it scales linearly with the number of I/O nodes and can be extended to any kind of multidimensional data combination and information retrieval.

Spectool is a toolkit designed for processing astronomical spectral data, offering a collection of common spectral analysis algorithms. The package includes functions for spectral resampling, spectral flattening, radial velocity measurements, spectral convolution broadening, and more. Each function in the package is implemented independently, allowing users to select and utilize the desired features as needed. The functions are designed with simple and intuitive interfaces, ensuring ease of use for various data sets and analysis tasks.

hmvec is a pure Python/numpy vectorized general halo model and HOD code. It includes support for 3d power spectra involving NFW, Battaglia electron density profiles and galaxy HODs. It also supports 2d power spectra including tSZ, cosmic shear, galaxy-galaxy lensing and CMB lensing. hmvec calculates a vectorized FFT for a given profile over all points in mass and redshift, using one double loop over mass and redshift to interpolate the profile Fourier transforms to the target wavenumbers; every other part of the code is vectorized.

SZiFi (pronounced "sci-fi") implements the iterative multi-frequency matched filter (iMMF) galaxy cluster finding method. It can be used to detect galaxy clusters with mm intensity maps through their thermal Sunyaev-Zeldovich (tSZ) signal. As a novel feature, SZiFi can perform foreground deprojection via a spectrally constrained MMF or sciMMF, and can also be used for point source detection.

cosmocnc evaluates the number count likelihood of galaxy cluster catalogs. Fast Fourier Transform (FFT) convolutions are used to evaluate some of the likelihood integrals. The code supports three types of likelihoods (unbinned, binned, and an extreme value likelihood); it also supports the addition of stacked cluster data (e.g., stacked lensing profiles), which is modeled in a consistent way with the cluster catalog. The package produce mass estimates for each cluster in the sample, which are derived assuming the hierarchical model that is used to model the mass observables, and generates synthetic cluster catalogs for a given observational set-up. cosmocnc interfaces with the Markov chain Monte Carlo (MCMC) code Cobaya (ascl:1910.019), allowing for easy-to-run MCMC parameter estimation.

Sledgehamr (ScaLar fiEld Dynamics Getting solvEd witH Adaptive Mesh Refinement) simulates the dynamics of coupled scalar fields on a 3-dimensional mesh. Adaptive mesh refinement (AMR) can boost performance if spatially localized regions of the scalar field require high resolution. sledgehamr is compatible with both GPU and CPU clusters, and, because it is AMReX-based (ascl:2409.012), offers a flexible and customizable framework. This framework enables various applications, such as the generation of gravitational wave spectra.

Based on oxkat (ascl:2009.003), polkat focuses on automating full polarization calibration and snapshot (i.e., second-scale) imaging of polarimetric radio data taken with the MeerKAT telescope. Accepting raw visibilities in Measurement Set format, polkat performs the necessary data editing, calibration (reference and self-calibration), and imaging to extract the complete polarization properties for user-defined target sources. Required software packages, including, but not limited to, CASA (ascl:1107.013), WSClean (ascl:1408.023), and QuartiCal (ascl:2305.006) are containerized with Apptainer/Singularity. polkat can be run locally or on high-performance computing that uses a slurm job scheduler; for the latter option, polkat will generate the necessary job submission files.

The Python code smhr (Spectroscopy Made Harder) wraps the MOOG spectral synthesis code (ascl:1202.009) to analyze high-resolution stellar spectra. It offers numerous analysis tools, including normalization of apertures, inverse variance-weighted stitching of overlapping apertures and/or sequential exposures. The code also provides Doppler measurement and correction, automatic measurement of EWs, and multiple methods for inferring stellar parameters; further, it measures elemental abundances from EWs or spectral synthesis and performs a rigorous uncertainty analysis. smhr can be run automatically (in batch mode) or interactively through a graphical user interface. Analyses can be saved to a single file for, for example, distribution to other spectroscopists or release with a publication.

legacypipe produces DESI Legacy Imaging Surveys (aka the Legacy Surveys). It can process individual exposures from many cameras, including the Dark Energy Camera on the Blanco telescope, the 90Prime camera on the Bok telescope, and the Mosaic3 camera on the Mayall telescope. The code can also process exposures from the Hyper-SuprimeCam on Subaru, the old SuprimeCam on Subaru, MegaCam on the Canada-France-Hawaii Telescope, and image products from the GALEX and WISE satellites. Legacypipe performs source detection, and then measurement via forward-modeling using The Tractor (ascl:1604.008). It generates coadded output images as well as catalogs, plus a variety of metrics useful for understanding the properties of the imaging.

Pigi (Parallel Interferometric GPU Imager) implements the image domain gridding algorithm and is compatible with both NVIDIA and AMD graphics cards. It provides a high-performance implementation capable of gridding hundreds of mega visibilities per second on modest hardware. The code can correct for baseline-, time-, and direction-dependent effects such as the primary beam or ionosphere as part of the (de)gridding process. Pigi provides end-to-end deconvolution capabilities with a basic iterative cleaning implementation.

THAI analyzes and visualizes climate model output for the TRAPPIST-1 Habitable Atmosphere Intercomparison (THAI) project, which examines TRAPPIST-1e under several different atmosphere scenarios. The package includes functions to preprocess and clean the data and common and model-specific variables for convenience. THAI processes and plots the data, allowing for examination and intercomparison of results from the different models.

AccretR calculates mass, radius, and bulk composition along a specified growth track for orderly/hierarchical, runaway, and random particle accretion models. Elements in the model include concentrations of H, C, N, O, Na, Mg, Al, Si, S, Cl, K, Ca, and Fe. Maximal water is also computed, assuming all H goes into forming water. Accretional heat is also calculated. AccretR is optimized to build Jupiter's moon Europa, and Saturn's moons Titan and Enceladus, from CI, CM, CR, CK, CO and CV carbonaceous chondrite meteorites, cometary material (using comet 67P/Churyumov-Gerasimenko), and pure water ice.

Semi-automatic analysis for echelle spectra of stars.

The major parts are:
(1) full spectrum fit with a neural network emulator to estimate stellar parameters
(2) automatic continuum normalization with theoretical masks
(3) automatic equivalent width fits with theoretical masks
(4) ATLAS model atmosphere interpolation and equivalent width abundance determination using MOOG
(5) spectrum synthesis fitting using MOOG
(6) automatic abundance uncertainty analysis with error propagation and summary tables

LESSPayne can be run in a completely automatic mode, which is best used as a quick check of outputs during observing or an initial inspection. However, science-quality results still require a classic line-by-line analysis, where the quality of all fits is inspected by the user using the Spectroscopy Made Harder (smhr) graphical user interface or other automatic output plots. LESSPayne should be viewed as providing a high-quality initialization for an smhr file that reduces the time for a standard analysis.

If using LESSPayne, please cite Casey (2014) (https://ui.adsabs.harvard.edu/abs/2014PhDT.......394C/abstract), Ting et al. (2019) (https://ui.adsabs.harvard.edu/abs/2019ApJ...879...69T/abstract), and Ji et al. (2020) (https://ui.adsabs.harvard.edu/abs/2020AJ....160..181/abstract) in addition to this ASCL entry.

Additionally as always, please cite the model atmospheres used (default is ATLAS, https://ui.adsabs.harvard.edu/abs/2003IAUS..210P.A20C/abstract), radiative transfer code (default is MOOG including scattering, https://ui.adsabs.harvard.edu/abs/1973PhDT.......180S/abstract, https://ui.adsabs.harvard.edu/abs/2011AJ....141..175S/abstract, https://ui.adsabs.harvard.edu/abs/2012ascl.soft02009S/abstract), and atomic data (if using any built into this package, see references in https://ascl.net/2104.027 and https://ui.adsabs.harvard.edu/abs/2021RNAAS...5...92P/abstract).

IGRINS RV extracts radial velocities (RVs) from spectra taken with the Immersion GRating INfrared Spectrometer (IGRINS). It uses a modified forward modeling technique that leverages telluric absorption lines as a common-path wavelength calibrator. IGRINS RV achieves an RV precision in the H and K bands of around 25-30 m/s for narrow-line stars.

The IGRINS (Immersion Grating Infrared Spectrometer) PipeLine Package (PLP) processes all IGRINS observing data, such as that from the McDonald 2.7m, LDT/DCT, or Gemini-South telescopes, without (or with a minimum of) human interaction. It was also designed to be adaptable for a real time processing during the observing run. The IGRINS PLP uses a "recipe" to process a certain data group and requires an input file describing which recipe should be used with which data sets.

TESS-SIP creates a Systematics-insensitive Periodogram (SIP) using lightkurve (ascl:1812.013) to detect long period rotation in NASA's TESS mission data. The SIP method detrends telescope systematics (the TESS scattered light) simultaneously with calculating a Lomb-Scargle periodogram, thus allowing estimation of the rotation rate of variables with a period of >30 days when there are multiple sectors.

blasé performs whole-spectrum fitting by cloning 10,000+ spectral lines from a pre-computed synthetic spectral model template and then learning the perturbations to those lines through comparison to real data. Each spectral line has four parameters, yielding possibly 40,000+ parameters. The technique uses autodiff to tune the parameters precisely and quickly. Built in PyTorch with native GPU support, blasé can be extended to, for example, Doppler imaging, Precision RVs, and abundances.

ATOCA (Algorithm to Treat Order Contamination) extracts and decontaminates spectroscopic images with multiple sources or diffraction orders. For all orders and sources, the package takes the wavelength solutions, the trace profiles, the throughputs, and the spectral resolution kernels as input. From these, ATOCA simultaneously models the detector and extracts the spectra.

Optimal BLS explicitly includes Keplerian dynamics in transit searches, which enhances transit detectability while reducing the resources and time usually required for such searches. The (standard) BLS is either fairly insensitive to long-period planets or less sensitive to short-period planets and computationally slower by a significant factor of ~330 (for a 3 yr long dataset). Physical system parameters, such as the host star's size and mass, directly affect transit search. Optimal BLS leverages this understanding to optimize the search for every star individually.

spaceKLIP reduces and analyzes JWST NIRCam and MIRI coronagraphy data. The package runs the official JWST stage 1 and 2 data reduction pipelines with several modifications that improve the quality of high-contrast imaging reductions. spaceKLIP then performs PSF subtraction based on the KLIP algorithm as implemented in pyKLIP (ascl:1506.001), outputs contrast curves, and enables forward model PSF fitting for any detected companions in order to extract their properties (offset and flux).

SpecMatch-Emp extracts the fundamental properties of a star (effective temperature, radius, and metallicity) by comparing a target star's spectrum to a library of spectra from stars with known properties. The spectral library comprises high-resolution, high signal-to-noise observed spectra from Keck/HIRES for 404 touchstone stars with well-determined stellar parameters derived from interferometry, asteroseismology, and spectrophotometry. The code achieves accuracies of 100K, 15%, and 0.09 dex in Teff, Rstar, and [Fe/H] respectively for FGKM dwarfs.

The PACMAN pipeline reduces and analyzes Hubble/Wide Field Camera 3 (WFC3) observations of transiting exoplanets. The pipeline runs end-to-end, beginning with a time series of 2D images and ending with a spectrum for the planet, and includes both spectral extraction and light curve fitting. PACMAN can easily fit multiple observations simultaneously.

PyMieScatt (Python Mie Scattering) calculates relevant parameters including absorption, scattering, extinction, asymmetry, and backscatter. The package also contains single-line functions to calculate optical coefficients (in Mm-1) of ensembles of particles in lognormal (with single or multiple modes) or custom size distributions. The inverse calculations retrieve the complex refractive index from laboratory measurements of scattering and absorption (or backscatter), useful for studying atmospheric organic aerosol of unknown composition.

Crimson Light is a tool to visualize and slice metadata on the available archival observations of samples of astrophysical objects. This visualization enables the user to view available multi-wavelength datasets for a range of objects, optionally filtering the displayed observations on the basis of (angular) resolution, wavelength/frequency coverage, and other properties.

WATSON (Visual Vetting and Analysis of Transits from Space ObservatioNs) enables a comfortable visual vetting of transiting signal candidates from Kepler, K2, and TESS missions. The code looks for transit-like signals that could be generated by other sources or instrument artifacts and runs simplified tests on scenarios including transit shape model fit, odd-even transits checks, and centroids shifts. It also considers optical ghost effects, transit source offsets, and several other scenarios. WATSON then computes metrics and flags problematic signals.

The Tiberius pipeline, written in Python, extracts and reduces time-series spectra and fits exoplanet transit light curves. Written in Python, the code can extract spectra from all four JWST instruments, ground-based long-slit spectrographs, and Keck/NIRSPEC echelle spectra. The light curve fitting routines in Tiberius can be used as standalone code to fit, for example, HST light curves extracted with other methods.

SPCA (Spitzer Phase Curve Analysis) analyzes Spitzer/IRAC observations of exoplanets. It implements 2D polynomial, Pixel Level Decorrelation, BiLinearly-Interpolated Sub-pixel Sensitivity mapping, and Gaussian Process decorrelation methods, allowing the user to change techniques by setting a single variable. The code's modular structure enables integration of custom astrophysical models and decorrelation methods. SPCA can reduce and decorrelate multiple datasets with a single command.

TLCM (Transit and Light Curve Modeler) analyzes the light curves of transiting exoplanets. Written in IDL and runnable under GDL, the code fits the light curves with quadratic limb darkening law; the limb darkening coefficients can be different for the two objects considered. The package carries out the fit of the transit + occultation + out-of-transit variation + radial velocity (RV) model to the observed light curve to find the best agreement between model and observations. TLCM also estimates the uncertainties of the fitted parameters.

The Giants pipeline accesses TESS data, produces noise-corrected light curves, and searches for planets transiting evolved stars. Built with Lightkurve (ascl:1812.013) and written in Python, its emphasis is on finding giant planets around subgiant and RGB stars in TESS Full Frame Images (FFIs). Giants produces a one-page PDF summary for each target.

polyrot computes the structure of rotating polytropic bodies. The code computes the equilibrium structure of rotating planets and stars modeled as "polytropes" with pressure and density, and can also compute models including rotation specified as a function of cylindrical radius. polyrot includes a basic plotting function that can show a cross-section along the rotation axis with the colormap indicating density, and a line plotting the surface radius of the star; these and other quantities are attached as attributes to the model.

MOLPOP-CEP calculates the exact solution of radiative transfer problems in multi-level atomic systems. The radiative transfer equations are analytically integrated to reduce the final problem to the solution of a non-linear algebraic system of equations in the level populations. The code uses Coupled Escape Probability formalism to analytically solve the radiative transfer. Written in Fortran 90, MOLPOP-CEP is limited to plane-parallel slabs that can present arbitrary spatial variations of the physical conditions.

chemcomp models and enables the study of the formation of planets in 1D protoplanetary disks. It includes disk physics for viscous disk evolution, pebble growth and evolution applying the two populations model, evaporation and condensation at evaporation lines, and chemical compositions. Written in Python, chemcomp also includes planet physics for type-I and type-II migration, thermal and dynamical torques, and pebble and gas accretion.

speedyfit fits the photometric spectral energy distribution of stars using a Markov chain Monte Carlo approach to determine the errors on the derived parameters. This command line tool searches the most common online databases for photometric observations of a target and automatically pulls archive photometry from the main surveys. The code fits theoretical atmosphere models to the obtained photometry. Speedyfit handles both single and binary stars and allows for the inclusion of constraints from other sources, such as atmosphere parameters derived from spectroscopy, distances, or reddening.

RadioBEAR (Radio BErkeley Atmospheric Radiative-transfer) calculates the brightness temperature of planetary atmospheres in the meter-to-millimeter wavelength range. The code assumes the atmosphere is in local thermodynamic equilibrium; it can calculate the RT-derived brightness temperatures of a planet on each location on the planet and create 2D model maps of the planet's disk.

SpectralRadex runs RADEX (ascl:1010.075) directly from Python and creates model spectra from RADEX outputs. The package uses F2PY (Fortran to Python interface generator) to compile a version of RADEX written in modern Fortran, most importantly dropping the use of common blocks. As a result, running a RADEX model creates no subprocesses and can be parallelized. SpectralRadex uses the RADEX calculated line opacities and excitation temperatures to calculate the brightness temperature as a function of frequency. This allows observed spectra to be modeled in Python in a non-LTE fashion.

breads (Broad Repository for Exoplanet Analysis, Discovery, and Spectroscopy) provides a toolkit for data analyses in astronomical spectroscopy of exoplanets, in particular frameworks for rigorous forward modeling of observational data to achieve physical inferences with reduced systematic biases. Users choose a data class, a forward model function, and a fitting strategy. Data classes normalize the data format, simplifying reduction across different spectrographs while allowing for specific behaviors of each instrument to also be coded into their own specific class. breads provides specific functionality for modeling data from JWST NIRSpec, Keck OSIRIS, and Keck KPIC, but the underlying mathematical framework is more general.

ECCOplanets simulates the formation of rocky planets in chemical equilibrium (based on a Gibbs free energy minimisation). The package includes tools for analyzing the simulated planet and two databases, one of thermochemical data and the other of stellar abundance patterns. ECCOplanets provides a simplified starting point for getting an approximate idea of the variety of planetary compositions based on the variety of stellar compositions.

NEXO (Nonsingular Estimator for EXoplanet Orbits) fits exoplanet orbits to direct astrometric measurements using nonlinear batch estimation and nonsingular orbital elements. The estimation technique is based on the unscented transform, which approximates probability distributions using finite, deterministic sets of weighted sample points. Furthermore, NEXO uses Gaussian mixtures to account for the strong nonlinearities in the measurement model. As a fitting basis, it uses a set of orbital elements developed specifically for directly observed exoplanets, combining features of the Thiele–Innes constants and the Cohen–Hubbard nonsingular elements.

ExoTR (Exoplanetary Transmission Retrieval) interprets exoplanetary transmission spectra using a Bayesian inverse retrieval algorithm. The code can be used in two ways; the first is by leveraging the physics forward model only to generate synthetic planetary atmospheric transmission spectra (including the addition of errorbars). The second way is by using a retrieval routine based on nested sampling (i.e., MultiNest (ascl:1109.006)) to extract physical and chemical information from the input transmission spectra.

The CIANNA framework creates and trains deep-learning models for astronomical data analysis. Functionalities and optimizations are added based on relevance to astrophysical problem-solving. CIANNA builds and trains a wide variety of neural network architectures for various tasks through a high-level Python interface. It supports both computing on CPU and GPU acceleration through low-level CUDA programming, taking advantage of AI-dedicated hardware substructures. CIANNA distinguishes itself by its low latency, allowing tight integration with other codes.

tshirt (Time Series Helper and Integration Reduction Tool) processes raw data on exoplanet systems for time series science. It reduces raw data to produce flat fields, subtracts bias, and corrects gain. tshirt also performs photometric and optimal spectral extraction of light curves.

Haystacks creates high-fidelity spatial and spectral models of complete planetary systems including star, planets, interplanetary dust, and astrophysical background sources. These models are intended for use in simulations of direct imaging and spectroscopy with high-contrast instruments on exoplanet missions to prepare future exoEarth observations.

pympc performs checks for the presence of minor and major Solar System bodies at specified coordinates. Orbital elements from the Minor Planet Center are used to propagate orbits to determine the position of asteroids, comets, NEOS, planets and major moons at the request epoch. Topocentric corrections are included to allow for observatory-specific positions. The requested position can also be checked for being within the Hill Sphere (in projection) of any Solar System planet.

CAFE (Continuum And Feature Extraction) fits JWST IFU data; the code is a Python version of the original CAFE IDL software for fitting Spitzer/IRS spectra. The code contains two main tools: (1) the CAFE Region Extraction Tool Automaton (CRETA) and (2) the CAFE spectral fitting tool, or fitter. CRETA performs single-position and full-grid extractions from JWST IFU datasets; that is, from pipeline-processed cubes obtained with the NIRSpec IFU and MIRI MRS instruments. The CAFE fitter uses the spectra extracted by CRETA (or spectra provided by the user) and performs a spectral decomposition of the continuum emission (stellar and/or dust), as well as of a variety of common spectral features (in emission and absorption) present in the near- and mid-IR spectra of galaxies, including prominent, broad emission from small grains and molecules such as Polycyclic Aromatic Hydrocarbons (PAHs). The full dust treatment (size and composition) performed by CAFE allows the dust continuum model components to fit not only spectra from typical star-forming galaxies, but also those from more extreme, heavily dust-obscured starburst galaxies, such as luminous infrared galaxies (LIRGs and ULIRGs), active galactic nuclei (AGN), or very luminous quasars.