RFIClean excises periodic RFI (broadband as well as narrow-band) in the Fourier domain, and then mitigates narrow-band spectral line RFI as well as broadband bursty time-domain RFI using robust statistics. Primarily designed to efficiently search and mitigate periodic RFI from GMRT time-domain data, RFIClean has evolved to mitigate any spiky (in time or frequency) RFI as well, and from any SIGPROC filterbank format data file. RFIClean uses several modules from SIGPROC (ascl:1107.016) to handle the filterbank format I/O.

PDQ predicts the positions on the sky of high-redshift quasars that should provide photons that are both acausal and uncorrelated. The predicted signal-to-noise ratios are calculated at framerate sufficient for random-number generation input to a loophole-free Bell test, and are calibrated against a public archival dataset of four pairs of highly-separated bright stars observed simultaneously (and serendipitously) at 17 Hz with that same instrumentation in 2019 to 2021.

AstroPT trains astronomical large observation models using imagery data. The code follows a similar saturating log-log scaling law to textual models and the models' performances on downstream tasks as measured by linear probing improves with model size up to the model parameter saturation point. Other modalities can be folded into the AstroPT model, and use of a causally trained autoregressive transformer model enables integration with the wider deep learning FOSS community.

MultiREx generates synthetic transmission spectra of exoplanets. This tool extends the functionalities of the TauREx (ascl:2209.015) framework, enabling the mass production of spectra and observations with added noise. Though the package was originally conceived to train machine learning models in the identification of biosignatures in noisy spectra, it can also be used for other purposes.

GalClass facilitates visual morphological classifications of large samples of galaxies taking advantage of multi-wavelength imaging and ancillary information. It offers a versatile Graphic User Interface (GUI), which adapts to the provided classification scheme. It displays a series of pre-prepared PDF files for classification, grouping by galaxy and filter, while also listing relevant metadata and displaying a color image of each source. GalClass enables easy navigation through the sample and continuously outputs classification results in a JSON file. Finally, it offers an analysis submodule which combines and processes output files of multiple classifications.

ChromaStarPy computes the vertical structure of a static, plane-parallel, one-dimensional stellar atmosphere in local thermodynamic equilibrium (LTE); it also computes the emergent spectrum incorporating opacity computed with a comprehensive atomic line list from the NIST Atomic Spectra Database. The code provides post-processed data products that are ready to visualize in a Python IDE such as spyder. ChromaStarPy is a port of ChromaStarServer (ascl:1701.009); the code enables users to experiment with and develop a stellar astrophysical modeling code in a graphical IDE, and to compare observational data to ad hoc model output.

ExoInt devolatilizes stellar abundances to produce rocky exoplanetary bulk composition to constrain the modeling of the exoplanet interiors; the code uses Monte Carlo simulations that assume that each element’s abundance (within its uncertainty) follows a Gaussian distribution. ExoInt also contains a module to provide the mineralogy based on the stoichemitric output of mantle and core compositions, core mass fraction, along with the given mass and radius information.

tpfplotter creates a TESS Target Pixel File of a source, overplotting the aperture mask used by the SPOC pipeline and the Gaia catalog to check for possible contaminations within the aperture. The software can create 1-column paper-ready figures, overplotting the Gaia DR2 catalog to the TESS Target Pixel Files, and can create plots for any target observed by TESS. tpfplotter can search by coordinates if the TIC number of the source is not known.

Pytmosph3R computes transmission and emission spectra based on 3D atmospheric simulations, for example, performed with the LMDZ generic global climate model. It produces transmittance maps of the atmospheric limb at all wavelengths that can then be spatially integrated to yield the transmission spectrum. Pytmosph3R can use 3D time-varying atmospheric structures from a GCM as well as simpler, parameterized 1D or 2D structures, and can be used in notebooks or on the command line.

TROPF (Tidal Response Of Planetary Fluids) enables efficient terrestrial fluid tidal studies across a wide range of parameter space. The software includes several different solutions to the governing equations in classical tidal theory, and can calculate millions of such solutions on several-minute-long timescales. Written in MATLAB/Octave, TROPF can be ported to Python and other languages, as the instructions for building the operator matrices are described in detail and the coding of core TROPF routines adheres to generic sparse matrix operations and avoids functions specific to MATLAB.

DYNAMITE (DYNAmical Multi-planet Injection TEster) predicts the presence of unseen planets in multi-planet systems via population statistics. The code uses the specific (yet often incomplete) data on the orbital and physical parameters for the planets in any given system's architecture and combines it with detailed statistical population models and a dynamical stability criterion to predict the likelihood for the parameters of one additional planet in the system. DYNAMITE's predictions are given in the form of observable values (transit depth measurements, RV semi-amplitudes, or direct imaging separation and contrast), which can be tested by follow-up observations.

CHIMERA (CaltecH Inverse ModEling and Retrieval Algorithms) retrieves exoplanet atmospheres, and can be used for both transmission and emission geometries with options for both the "free" and "chemically consistent" abundance retrievals. The code uses correlated-K opacities (R=100) with the random-overlap resort-rebin procedure and includes full multiple scattering in emission (both planetary and stellar reflected light) using a two stream approximation variant. CHIMERA includes multiple Bayesian samplers, including PyMultiNest (ascl:1606.005) and dynesty (ascl:1809.013).

VSPEC (Variable Star PhasE Curve) simulates exoplanet observations. It combines NASA’s Planetary Spectrum Generator (PSG) with a custom variable star model. Originally built to simulate the infrared excess of non-transiting planets, VSPEC supports transit, eclipse, phase curve geometries as well as spots, faculae, flares, granulation, and the transit light source effect.

Turbospectrum_NLTE updates the spectral synthesis code Turbospectrum (ascl:1205.004) with NLTE capabilities. The code takes a 1D model atmosphere, one or several line lists, and computes the emergent spectrum (flux and/or intensities at various angles), with a prescribed chemical composition. Various parameters can be adjusted, such as microturbulence (vmicro), individual abundances, and isotopic ratios. Turbospectrum_NLTE can also handle the computation for a single chunk of spectrum with a constant wavelength step, or for a number of smaller windows, e.g., around lines of interest. Calculations can also be done for plane-parallel or spherically symmetric models.

TriArc (reTRIeval ARCturus) uses Bayesian statistics to determine the minimum abundance of an atmospheric species in a given model atmosphere (excluding the species of interest) and spectral noise profile. The code is configured for transmission spectroscopy and is built using the forward modeling capabilities of petitRADTRANS (ascl:2207.014); it also uses PandExo (ascl:1906.016). TriArc has been used to calculate prebiosignature detection thresholds for various potential JWST targets.

tglc (TESS-Gaia Light Curve) produces PSF-based TESS full-frame image (FFI) light curves for any sector and any star with custom options. Using Gaia DR3 as priors, the code has forward modeled FFIs with the effective point spread function to remove contamination from nearby stars. The resulting light curves show a photometric precision closely tracking the pre-launch prediction of the noise level: TGLC's photometric precision consistently reaches <2% at 16th TESS magnitude even in crowded fields, demonstrating excellent decontamination and deblending power.

SWAMPE models the dynamics of exoplanetary atmospheres; it is an intermediate-complexity, two-dimensional shallow-water general circulation model. Benchmarked for synchronously rotating hot Jupiters and sub-Neptunes, the code is modular and can be modified to model dissimilar space objects, from Brown Dwarfs to terrestrial, potentially habitable exoplanets. SWAMPE can be easily run on a personal laptop.

Spright predicts planetary masses, densities, and radial velocity semi-amplitudes given a small planet's radius or planetary radii given the small planet's mass. The package contains two relations: one for small planets orbiting M dwarfs and another for planets orbiting FGK stars. The radial velocity semi-amplitude can be predicted given the planet's radius, orbital period, orbital eccentricity (optional), and the host star mass. Spright offers both a command line script and a set of Python classes. The command line script can directly create publication-quality plots, and the classes offer a full access to the predicted numerical distributions.

RTModel models and interprets microlensing events. It uses photometric time series collected from ground and/or space telescopes to propose one or more of the following possible models:

- single-lens-single-source microlensing;
- single-lens-binary-source microlensing, with or without xallarap; and/or
- binary-lens-single-source microlensing, including planetary microlensing, parallax and orbital motion.

All models include the finite-size of the source(s). The modeling strategy is based on a grid search in the parameter space for single-lens models, whereas a template library for binary-lens models is used including all possible geometries of the source trajectory with respect to the caustics. In addition to this global search, planets are searched where maximal deviations from a Paczynski model occurs. The RTModel package also including subpackages for creating an immediate visualization of models and the possibility to review each individual fitting process as an animated GIF.

pycdata imports datasets from various telescopes/instruments in pycheops (ascl:2312.034), thus providing the facility pycheops lacks to model transits, eclipses, phase curves from other telescopes/instruments and the PSF photometry produced by PIPE (ascl:2404.002). pycdata automatically puts resultant data products into the pycheops cache directory so that it can be directly readable from the pycheops command line.

plaNETic uses a Bayesian neural network-based to model small (masses between 0.5 and 15 M_earth) exoplanets. The code efficiently computes posteriors of a planet's internal structure based on its observed planetary and stellar parameters. It uses a full grid accept-reject sampling algorithm. plaNETic also allows for different choices in priors concerning the expected abundance of water (formation inside vs. outside of iceline) and the planetary Si/Mg/Fe ratios (stellar vs. iron-enriched vs. free).

photoevolver simulates the atmospheric escape of extrasolar planets and their evolution. The code evolves the gaseous atmosphere of a planet backwards and forwards in time, taking into account its internal structure and cooling rate, atmospheric mass loss processes, and the stellar emission history. photoevolver determines whether a palent's atmosphere survives or ise completely stripped by radiation from its host star.

The 1D radiative-convective code PCM_LBL simulates the climates of diverse planetary atmospheres. The code is written in modular modern Fortran and uses a 'brute-force' spectral approach where absorption coefficients are computed on a fixed spectral grid directly from line data. This allows climate calculations to be performed more simply and at higher accuracy than in a correlated-k approach. PCM_LBL allows the user to iterate rapidly between fast, lower accuracy calculations and slow high accuracy calculations. By default, the model is set up to run fairly fast at moderate resolution; the accuracy of the code can be adjusted with a few (documented) changes.

PBjam analyzes the oscillation spectra of solar-like oscillators. The code performs two main tasks: identifying a set of modes of interest in a spectrum of oscillations, and accurately modeling those modes to measure their frequencies. Mode identification relies on a large set of previous observations of the model parameters, which are then used to construct a prior distribution to inform the sampling. PJjam models the modes using a nested sampling or MCMC algorithm, where Lorentzian profiles are fit to each of the identified modes.

nuance uses linear models and Gaussian processes to simultaneously search for planetary transits while modeling correlated noises (e.g., stellar variability). The code computes the likelihood of a transit being present in some correlated noise without disentangling the two; it searches the transit signal while simultaneously modeling correlated noise, assuming that the light curve can be modeled as a Gaussian process. nuance detects single or periodic transits and can find transits in light curves from multiple instruments, whether space-based or ground-based; it can also run in parallel on CPUs or GPUs.

A Python package for helping with detecting exoplanet transit dips in TESS light curves.

Features:
Load and clean .fits light curve or target pixel files
Visualize light curves and transit candidates
Designed for students, researchers, and citizen scientists
Easily download and process raw data in bulk
Easily shortlist potential exoplanet candidates

LeR calculates detectable rates of gravitational waves events (both lensed and un-lensed events). Written in Python, it performs statistical simulation and forecasting of gravitational wave (GW) events and their rates. The code samples gravitational wave source properties and lens galaxies attributes and source redshifts, and can generate image properties such as source position, magnification, and time delay. The package also calculates detectable merger rates per year. Key features of LeR include efficient sampling, optimized SNR calculations, and systematic archiving of results. LeR is tailored to support both GW population study groups and GW lensing research groups by providing a comprehensive suite of tools for GW event analysis.

R2D2 (Residual-to-Residual DNN series for high-Dynamic range imaging) performs synthesis imaging for radio interferometry. The R2D2 algorithm takes a hybrid structure between a Plug-and-Play (PnP) algorithm and a learned version of the well-known Matching Pursuit algorithm. Its reconstruction is formed as a series of residual images, iteratively estimated as outputs of iteration-specific Deep Neural Networks (DNNs), each taking the previous iteration’s image estimate and associated back-projected data residual as inputs. The primary application of the R2D2 algorithm is to solve large-scale high-resolution high-dynamic range inverse problems in radio astronomy, more specifically 2D planar monochromatic intensity imaging.

SCONE (Supernova Classification with a Convolutional Neural Network) classifies supernovae (SNe) by type using multi-band photometry data (lightcurves) using a convolutional neural networks. SCONE takes in supernova (SN) photometry data in the format output by SNANA simulations, separated into two types of files: metadata and observation data. Photometric data is pre-processed via 2D Gaussian process regression, which smooths over irregular sampling rates between filters and also allows SCONE to be independent of the filter set on which it was trained.

NRPyElliptic sets up initial data (ID) for numerical relativity (NR) using the same numerical methods employed for solving hyperbolic evolution equations. The code implements a hyperbolic relaxation method to solve complex nonlinear elliptic PDEs for NR ID. The hyperbolic PDEs are evolved forward in (pseudo)time, resulting in an exponential relaxation of the arbitrary initial guess to a steady state that coincides with the solution of the elliptic system. The package solves these equations on highly efficient numerical grids exploiting underlying symmetries in the physical scenario. NRPyElliptic is built in the NRPy+ (ascl:1807.025) framework, which facilitates the solution of hyperbolic PDEs on Cartesian-like, spherical-like, cylindrical-like, or bispherical-like numerical grids.

Gradus.jl traces geodesics and calculates observational signatures of accreting compact objects. The code requires only a specification of the non-zero metric components of a chosen spacetime in order to solve the geodesic equation and compute a wide variety of trajectories and orbits. Gradus includes algorithms for calculating physical quantities are implemented generically, so they may be used with different classes of spacetime with minimal effort.

Colume (COLUMn to vOLUME) uses the statistical and spatial distribution of a column density map to infer a likely volume density distribution along each line of sight. The Python package incorporates all pre-processing (in particular re-sampling) functions needed to efficiently work on the column density maps. Colume's outputs are saved in Numpy format.

XGPaint, written in Julia, generates maps of extragalactic foregrounds, using astrophysical models designed to replicate the statistics of the millimeter sky. The code computes simulated galaxies from the Cosmic Infrared Background (CIB), radio galaxies, and contributions and distortions from the Sunyaev-Zeldovich (SZ) effect. XGPaint is multithreaded, and supports both HEALPix and Plate Carrée pixelizations.

The Blooming Tree (BT) algorithm identifies clusters, groups, and substructures from galaxy redshift surveys. Based on the hierarchical clustering method, it takes the projected binding energy as the linking length and provides three main analysis approaches to trim the hierarchical tree; 1.) the direct trimming (binding energy, velocity disperion, or eta); 2.) the sigma plateau, when no trimming threshold is appointed; and 3.) the blooming tree. The Blooming Tree algorithm tool works only in the terminal.

ExoSim 2 (Exoplanet Observation Simulator 2) makes spectro-photometric observations of transiting exoplanets from space, ground, and sub-orbital platforms. It is a complete rewrite of ExoSim (ascl:2002.008); it is implemented in Python 3 and uses object-oriented design principles. The package follows a three-step workflow: the creation of focal planes, the production of Sub-Exposure blocks, and the generation of non-destructive reads (NDRs). ExoSim 2 has demonstrated consistency in estimating photon conversion efficiency, saturation time, and signal generation. The simulator has also been validated independently for instantaneous read-out and jitter simulation, and for astronomical signal representation.

FELINE (Find Emission LINEs) combines a fully parallelized galaxy line template matching with the matched filter approach for individual emission features of LSDcat (ascl:1612.002). For the 3D matched filtering, the complete data cube is first median filtered to remove all continuum sources, and then cross-correlated with a template of an isolated emission feature in two spatial and one spectral dimension. FELINE then evaluates the likelihood in each spectrum of the cube for emission lines at the positions provided by a given redshift and a certain combination of typical emission features.

Superbubble Finding Algorithm identifies superbubbles in HI column density maps of both observed and simulated galaxies that has only two adjustable parameters. The algorithm takes an input column density galaxy image and returns the labels and basic measurements of the detected bubbles so plotting and further analysis can be done. The algorithm includes an automated galaxy-background separation step to focus the analysis on the galactic disk. Functions to solve for the superbubble radii, superbubble galactic radii location, and an external function to plot the detected bubbles are also packaged in Superbubble Finding Algorithm.

GaMorNet classifies galaxies morphologically using a Convolutional Neural Network. The code does not need a large amount of training data, as it is trained on simulations and then transfer-learned on a small portion of real data, and can be applied on multiple datasets. The software has a misclassification rate of less than 5%. GaMorNet is written in Python and uses the Keras and TFLearn deep learning libraries to perform all of the machine learning operations. Both these aforementioned libraries in turn use TensorFlow for their underlying tensor operations.

GaMPEN (Galaxy Morphology Posterior Estimation Network) estimates robust posteriors (i.e., values + uncertainties) for structural parameters of galaxies using a Bayesian machine learning framework. The code also automatically crops input images to an optimal size before structural parameter estimation. The package produces extremely well-calibrated (less than 5% deviation) predicted posteriors; these have been shown to be up to 60% more accurate compared to the uncertainties predicted by many light-profile fitting algorithms. Once trained, it takes GaMPEN less than a millisecond to perform a single model evaluation on a CPU. Thus, GaMPEN’s posterior prediction capabilities are ready for large galaxy samples expected from upcoming large imaging surveys, such as Rubin-LSST, Euclid, and NGRST.

StellarSpecModel interpolates the stellar spectral grid; provided with stellar parameters (Teff, FeH, logg), the package will return the corresponding stellar spectrum. It also generates and analyzes theoretical stellar spectral energy distributions (SEDs). StellarSpecModel includes functionality for both single and binary star systems, incorporating extinction models and the ability to handle photometric data in various filter bands.

LESSPayne performs semi-automatic analysis for echelle spectra of stars. It uses a neural network emulator to do a full spectrum fit to estimate stellar parameters and performs automatic continuum and equivalent width fits normalization with theoretical masks. The code uses MOOG (ascl:1202.009) for spectrum synthesis fitting, ATLAS model atmosphere interpolation, and equivalent width abundance determination. LESSPayne can also perform automatic abundance uncertainty analysis with error propagation and summary tables, and should be viewed as providing a high-quality initialization for an smhr file that reduces the time for a standard analysis.

S³Fit fits spectrum and multi-band photometric Spectral Energy Distribution (SED) simultaneously for analyzing observational data of galaxies. It improves the moderate constraints on properties of continuum models in a pure spectral fitting due to the limited wavelength coverage. The code supports multiple models with multiple components, and can handle complex systems with a mixed contribution of Active Galactic Nucleus (AGN) and its host galaxy in both of continua and emission lines (e.g., narrow lines and broad outflow lines). The fitting strategy is optimized to enable an efficient solution of the best-fit results for several tens of parameters and model components. S³Fit is also extensible for adding functions and components by users such as new band filters, star formation history functions, emission lines, and also types of models.

This library of synthetic X-ray spectra provides a tabulated version of the slim disk model for fitting tidal disruption events (TDEs). The library is created by ray-tracing stationary, general relativistic slim disks and consistently incorporating gravitational redshift, Doppler, and lensing effects.

NcorpiON integrates collisional and fragmenting systems of planetesimals or moonlets orbiting a central mass. It features a fragmentation model, based on crater scaling and ejecta models, that realistically simulates a violent impact. Written in C, the code detects collisions, computes mutual gravity, and can resolve a collision by fragmentation. The fast multipole expansions are implemented up to order six to allow for a high precision in mutual gravity computation.

Mini-chem solves chemical kinetics for gas giant atmospheric modeling. It is pared down from large chemical networks to make use of "net forward reaction tables"; this significantly reduces the number of reactions and species required to be evolved in the ODE solvers. The code's NCHO network consists of only 12 species with 10 reactions, making it a lightweight and easy to couple network to large scale 3D GCM models, or other models of interest (such as 1D or 2D kinetic modelling efforts). Mini-chem is written in Fortran and has three main parts: the input routine, the chemistry routines, and the still ODE solver.

luas builds Gaussian processes (GPs) primarily for two-dimensional data sets. It uses different optimizations to make the application of GPs to 2D data sets possible within a reasonable timeframe. The code is implemented using Jax (ascl:2111.002), which helps calculate derivatives of the log-likelihood as well as permitting the code to be easily run on either CPU or GPU. luas can be used with popular inference frameworks such as NumPyro and PyMC. The package makes it easier to account for systematics correlated across two dimensions in data sets, in addition to being helpful for any other applications (e.g., interpolation).

kpic_pipeline reduces data taken with the Keck Planet Imager and Characterizer (KPIC). Written in Python, the code processes high resolution spectroscopy data taken with KPIC to study exoplanet atmospheres; it processes and calibrate the data to enable spectroscopic model fitting. kpic_pipeline can reduce the observed data into 1D spectra for one given science target or can be used to reduce the full nightly data.

IsoFATE (Isotopic Fractionation via ATmospheric Escape) models mass fractionation resulting from diffusive separation in escaping planetary atmospheres and numerically computes atmospheric species abundance over time. The model is tuned to sub-Neptune sized planets with rocky cores of Earth-like bulk composition and primordial H/He atmospheres. F, G, K, and M type stellar fluxes are readily implemented. IsoFATE has two versions, the first of which simulates a ternary mixture of H, He, and D (deuterium); the second version is coupled to the magma ocean-atmosphere equilibrium chemistry model Atmodeller.

The IGRINS_transit data reduction pipeline takes high-resolution observations of transiting exoplanets with Gemini-S/IGRINS and produces cross-correlation detections of molecules in the exoplanet's atmosphere. IGRINS_transit removes low signal-to-noise orders, performs a secondary wavelength calibration, and uses a singular value decomposition (SVD) to separate out the signature of the transiting planet from the host star and telluric contamination.

GPS (Genesis Population Synthesis) develops population synthesis models. The code suite uses the Genesis database of planet formation models for small exoplanets (super-Earths and Mini-Neptunes). Although the codebase focuses on the Genesis models, aother models can easily be integrated with GPS. It computes the bulk compositions of the planets and simulates atmospheric loss and evolution to find the final states of the planets that can be observationally verified. GPS also offers tools to process and analyze the data from recent observations of small exoplanets in order to compare them with the models.