spinsfast is a fast spin-s spherical harmonic transform algorithm, which is flexible and exact for band-limited functions. It permits the computation of several distinct spin transforms simultaneously. Specifically, only one set of special functions is computed for transforms of quantities with any spin, namely the Wigner d matrices evaluated at π/2, which may be computed with efficient recursions. For any spin, the computation scales as O(L^3), where L is the band limit of the function.

Scri manipulates time-dependent functions of spin-weighted spherical harmonics. It implements the BMS transformations of the most common gravitational waveforms, including the Newman-Penrose quantity ψ4, the Bondi news function, the shear spin coefficient σ, and the transverse-traceless metric perturbation h, as well as the remaining Newman-Penrose quantities ψ0 through ψ3.

EvoEMD evaluates cosmic evolution with or without an early matter dominated (EMD) era. The framework includes global parameter, particle, and process systems, and different methods for Hubble parameter calculation. EvoEMD automatically builds up the Boltzmann equation according to the user's definition of particle and process,solves the Boltzmann equation using 4th order Runge-Kutta method with adaptive steps tailored to cosmology application, and caches the collision rate calculation results for fast evaluation.

The FastJet package provides fast native implementations of many sequential recombination algorithms, including the longitudinally invariant kt longitudinally invariant inclusive Cambridge/Aachen and anti-kt jet finders. It also provides a uniform interface to external jet finders via a plugin mechanism. FastJet also includes tools for calculating jet areas and performing background (pileup/UE) subtraction and for jet substructure analyses.

Delphes simulates a fast multipurpose detector response. The simulation includes a tracking system, embedded into a magnetic field, calorimeters and a muon system. The Delphes framework is interfaced to standard file formats (e.g. Les Houches Event File or HepMC) and outputs observables such as isolated leptons, missing transverse energy and collection of jets that can be used for dedicated analyses. The simulation of the detector response takes into account the effect of magnetic field, the granularity of the calorimeters and sub-detector resolutions. Visualization of the final state particles is also built-in using the corresponding ROOT library.

The SIDM model combines the isothermal Jeans model and the model of adiabatic halo contraction into a simple semi-analytic procedure for computing the density profile of self-interacting dark-matter (SIDM) haloes with the gravitational influence from the inhabitant galaxies. It agrees well with cosmological SIDM simulations over the entire core-forming stage and up to the onset of gravothermal core-collapse. The fast speed of the method facilitates analyses that would be challenging for numerical simulations.

SatGen generates satellite-galaxy populations for host halos of desired mass and redshift. It combines halo merger trees, empirical relations for galaxy-halo connection, and analytic prescriptions for tidal effects, dynamical friction, and ram-pressure stripping. It emulates zoom-in cosmological hydrosimulations in certain ways and outperforms simulations regarding statistical power and numerical resolution.

bajes [baɪɛs] provides a user-friendly interface for setting up a Bayesian analysis for an arbitrary model, and is specialized for the analysis of gravitational-wave and multi-messenger transients. The code runs a parameter estimation job, inferring the properties of the input model. bajes is designed to be simple-to-use and light-weighted with minimal dependencies on external libraries. The user can set up a pipeline for parameters estimation of multi-messenger transients by writing a configuration file containing the information to be passed to the executables. The package also includes tools and methods for data analysis of multi-messenger signals. The pipeline incorporates an interface with reduced-order-quadratude (ROQ) interpolants. In particular, the ROQ pipeline relies on the output provided by PyROQ-refactored.

MORPHOFIT consists of a series of modules for estimating galaxy structural parameters. The package uses SEXTRACTOR (ascl:1010.064) in forced photometry mode to get an initial estimate of the galaxy structural parameters and create a multiband catalog. It also uses GALFIT (ascl:1010.064), running it on galaxy stamps and galaxy regions from the parent image and also on galaxies from the full image using SEXTRACTOR properties as input. MORPHOFIT has been optimized and tested in both low-density and crowded environments, and can recover the input structural parameters of galaxies with good accuracy.

pulsar_spectra provides a pulsar flux density catalog and automated spectral fitting software for finding spectral models. The package can also produce publication-quality plots and allows users to add new spectral measurements to the catalog. The spectral fitting software uses robust statistical methods to determine the best-fitting model for individual pulsar spectra.

HaloGraphNet predicts halo masses from simulations using Graph Neural Networks. Given a dark matter halo and its galaxies, this software creates a graph with information about the 3D position, stellar mass and other properties. It then trains a Graph Neural Network to predict the mass of the host halo. Data are taken from the CAMELS hydrodynamic simulations.

ASSIST integrates test particle trajectories in the field of the Sun, Moon, planets, and massive asteroids, with the positions of the masses obtained from the JPL DE441 ephemeris and its associated asteroid perturber file. Using REBOUND's (ascl:1110.016) IAS15 integrator, ASSIST incorporates the most significant gravitational harmonics and general relativistic corrections and accounts for position- and velocity-dependent non-gravitational effects. The first-order variational equations are included for all terms to support orbit fitting and covariance mapping.

Applefy calculates detection limits for exoplanet high contrast imaging (HCI) datasets. The package provides features and functionalities to improve the accuracy and robustness of contrast curve calculations. Applefy implements the classical approach based on the t-test, as well as the parametric boostrap test for non-Gaussian residual noise. Applefy enables the comparison of imaging results across instruments with different noise characteristics.

BatAnalysis processes and analyzes Swift Burst Alert Telescope (BAT) survey data in a comprehensive computational pipeline. The code downloads BAT survey data, batch processes the survey observations, and extracts light curves and spectra for each survey observation for a given source. BatAnalysis allows for the use of BAT survey data in advanced analyses of astrophysical sources including pulsars, pulsar wind nebula, active galactic nuclei, and other known/unknown transient events that may be detected in the hard X-ray band. BatAnalysis can also create mosaicked images at different time bins and extract light curves and spectra from the mosaicked images for a given source.

FALCO (Fast Linearized Coronagraph Optimizer) performs coronagraphic focal plane wavefront correction. It includes routines for pair-wise probing estimation of the complex electric field and Electric Field Conjugation (EFC) control. FALCO utilizes and builds upon PROPER (ascl:1405.006) and rapidly computes the linearized response matrix for each DM, which facilitates re-linearization after each control step for faster DM-integrated coronagraph design and wavefront correction experiments. A Python 3 implementation of FALCO (ascl:2304.005) is also available.

FALCO (Fast Linearized Coronagraph Optimizer) performs coronagraphic focal plane wavefront correction. It includes routines for pair-wise probing estimation of the complex electric field and Electric Field Conjugation (EFC) control. FALCO utilizes and builds upon PROPER (ascl:1405.006) and rapidly computes the linearized response matrix for each DM, which facilitates re-linearization after each control step for faster DM-integrated coronagraph design and wavefront correction experiments. A MATLAB implementation of FALCO (ascl:2304.004) is also available.

JET (JWST Exoplanet Targeting) optimizes lists of exoplanet targets for atmospheric characterization by the James Webb Space Telescope (JWST). The software uses catalogs of planet detections, either simulated, or actual and categorizes targets by radius and equilibrium temperature; it also estimates planet masses and generates model spectra and simulated instrument spectra. JET then performs a statistical analysis to determine if the instrument spectra can confirm an atmospheric detection and finally ranks the targets within each category by observation time required for detection.

FRIDDA forecasts the cosmological impact of measurements of the redshift drift and the fine-structure constant (alpha) as well as their combination. The code is based on Fisher Matrix Analysis techniques and works for various fiducial cosmological models. Though designed for the ArmazoNes high Dispersion Echelle Spectrograph (ANDES), it is easily adaptable to other fiducial cosmological models and to other instruments with similar scientific goals.

Virtual Telescope predicts the signal-to-noise and other parameters of imaging and/or spectroscopic observations as a function of telescope size, detector noise, and other factors for the Next-Generation Space Telescope.

extrapops simulates extra-galactic populations of gravitational waves sources and models their emission during the inspiral phase. The code approximately assesses the detectability of individual sources by LISA and computes the background due to unresolved sources in the LISA band using different methods. The simulated populations can be saved in a format compatible with LISA LDC. Simulations are well calibrated to produce accurate background calculations and fair random generation at the tails of the distributions, which is important for accurate probability of detectable events. extrapops uses a number of ad-hoc techniques for rapid simulation and allows room for further optimization up to almost 1 order of magnitude.

katdal interacts with the chunk stores and HDF5 files produced by the MeerKAT radio telescope and its predecessors (KAT-7 and Fringe Finder), which are collectively known as MeerKAT Visibility Format (MVF) data sets. The library uses memory carefully, allowing data sets to be inspected and partially loaded into memory. Data sets may be concatenated and split via a flexible selection mechanism. In addition, katdal provides a script to convert these data sets to CASA MeasurementSets.

killMS implements two very efficient algorithms for solving the Direction-Dependent calibration problem (also known as third generation calibration). This problem naturally arises in the Radio Interferometry Measurement Equation (RIME), but only became overwhelmingly problematic with the construction of the SKA precursors and pathfinders. Solving for the DDE calibration problem basically consists in inverting a number of non-linear equations, while the system is very large and often subject to ill conditioning. The two algorithms killMS uses are based on complex optimization techniques and exploit algorithmic shortcuts; killMS also runs an extended Kalman filter.

QuartiCal is the successor to CubiCal (ascl:1805.031). It implements a suite of fast radio interferometric calibration routines exploiting complex optimization. Unlike CubiCal, QuartiCal allows for any available Jones terms to be combined. It can also be deployed on a cluster.

stimela provides a system-agnostic scripting framework for simulating, processing, and imaging radio interferometric data. The framework executes radio interferometry related tasks such as imaging, calibration, and data synthesis in Docker containers using Python modules. stimela offers a simple interface to packages that perform these tasks rather than doing any data processing, synthesis or analysis itself. stimela only requires Docker and Python. Moreover, because of Docker, a stimela script runs the same way (in the same iso­lated environment) regardless of the host machine’s settings, thus providing a user-friendly and modular scripting environment that gives general users easy access to novel radio interferometry calibration, imaging, and synthesis packages.

This package is no longer under active development and has been superseded by Stimela2 (ascl:2412.002).

DDFacet provides a wideband wide-field spectral imaging and deconvolution framework that accounts for generic direction-dependent effects (DDEs). It implements a wide-field coplanar faceting scheme and uses nontrivial facet-dependent w-kernels to correct for noncoplanarity within the facets. In the imaging and deconvolution steps, DDFacet can handle generic, spatially discrete, time-frequency-baseline-direction-dependent full polarization Jones matrices, and computes a direction dependent PSF for use in the minor cycle of deconvolution for time-frequency-baseline dependent Mueller matrices. The code also allows for the effects of time and bandwidth averaging to be explicitly incorporated into deconvolution. DDFacet has been successfully tested with data diverse telescopes such as LOFAR, VLA, MeerKAT AR1, and ATCA.

Given a FITS image, breizorro creates a binary mask. The software allows the user control various parameters and functions, such as setting a sigma threshold for masking, merging in or subtracting one or more masks or region files, filling holes, applying dilation within a defined radius of pixels, and inverting the mask.

FLAGLET computes flaglet transforms with arbitrary spin direction, probing the angular features of this generic wavelet transform for rapid analysis of signals from wavelet coefficients. The code enables the decomposition of a band-limited signal into a set of flaglet maps that capture all information contained in the initial band-limited map, and it can reconstruct the individual flaglets at varying resolutions. FLAGLET relies upon the SSHT (ascl:2207.034), S2LET (ascl:1211.001), and SO3 codes to provide angular transforms and sampling theorems, as well as the FFTW (ascl:1201.015) code to compute Fourier transforms.

DarkMappy reconstructs maximum a posteriori (MAP) convergence maps by formulating an unconstrained Bayesian inference problem in order to implement hybrid Bayesian dark-matter reconstruction techniques on the plane and on the celestial sphere. These convergence maps support principled uncertainty quantification and provide hypothesis testing of structure, from which it is possible to distinguish between physical objects and artifacts of the reconstruction.

KERN contains most of the standard tools needed to work with radio telescope data. The suite saves time and reduces frustration in setting up of scientific pipelines, and also improves scientific reproducibility. It includes a wide variety of packages, including 21cmfast (ascl:1102.023), BRATS (ascl:1806.025), CARTA (ascl:2103.031), casacore (ascl:1912.002), CubiCal (ascl:1805.031), DDFacet (ascl:2305.008), PyBDSF (ascl:1502.007),TiRiFiC (ascl:1208.008), WSClean (ascl:1408.023), and many others. KERN can be run on a supported platform such as Ubuntu, with Docker and Singularity, or in a virtual machine.

aartfaac2ms converts raw Aartfaac correlator files to the casacore (ascl:1912.002) measurement set format. It phase rotates the data to a common phase center, and (optionally) flags, averages, and compresses the data. The code includes a tool, afedit, to splice a raw Aartfaac set based on LST.

DP3 (the Default Preprocessing Pipeline) is the LOFAR data pipeline processing program and is the successor to DPPP (ascl:1804.003). It performs many kinds of operations on the data in a pipelined way so the data are read and written only once. DP3 preprocesses the data of a LOFAR observation by executing steps such as flagging or averaging. Such steps can be used for the raw data as well as the calibrated data by defining the data column to use. One or more of the following steps can be defined as a pipeline. DP3 has an implicit input and output step. It is also possible to have intermediate output steps. DP3 comes with predefined steps, but also allows the user to plug in arbitrary steps implemented in either C++ or Python.

EIDOS models the primary beam of radio astronomy antennas. The code can be used to create MeerKAT L-band beams from both holographic (AH) observations and EM simulations within a maximum diameter of 10 degrees. The beam model is less accurate at higher frequencies, and performs much better below 1400 MHz. The diagonal terms of the model beam Jones matrix are much better known than the off-diagonal terms. The performance of EIDOS is dependent on the quality of the given AH and EM datasets; as more accurate AH models and EM simulations become available, this pipeline can be used to create more accurate sparse representation of primary beams using Zernike polynomials.

The gw_pta_emulator reads in gravitational wave (GW) characteristic strain spectra from black-hole population simulations, re-bins for the user's observing baseline, and constructs new spectra. The user can train a Gaussian process to emulate the spectral behavior at all frequencies across the astrophysical parameter space of supermassive black-hole binary environments.

Made-to-measure (M2M) is a standard technique for modeling the dynamics of astrophysical systems in which the system is modeled with a set of N particles with weights that are slowly optimized to fit a set of constraints while integrating these particles forward in the gravitational potential. Simple-m2m extends this standard technique to allow parameters of the system other than the particle weights to be fit as well, including nuisance parameters that describe the observer's relation to the dynamical system (e.g., the inclination) or parameters describing an external potential.

GWSurrogate provides an easy to use interface to gravitational wave surrogate models. Surrogates provide a fast and accurate evaluation mechanism for gravitational waveforms which would otherwise be found through solving differential equations. These equations must be solved in the “building” phase, which was performed using other codes.

The sterile neutrino production code sterile-dm incorporates new elements to the calculations of the neutrino opacity at temperatures 10 MeV ≤ T ≤ 10 GeV and folds the asymmetry redistribution and opacity calculations into the sterile neutrino production computation, providing updated PSDs for the range of parameters relevant to the X-ray excess. The code requires several data files, which are included. With each run, sterile-dm creates a new output sub-directory that contains a parameter file listing the mass, mixing angle, initial lepton asymmetry and other information, a state file, which includes, among other states, the temperature and FRW coordinate time, and a set of snapshot files, one for each line in the state file.

JEDI searches for and characterizes coronal dimming in light curves produced from the Solar Dynamics Observatory (SDO) Extreme Ultraviolet (EUV) Variability Experiment (EVE). The suite has a wrapper script that calls other functions, which can also be run independently assuming needed inputs from prior functions are provided. JEDI's functions fit light curves and return the best fit, compute precision for iron light curves, and find the biggest dimming depth and its time in a given light curve. JEDI also includes functions for finding the duration of the dimming, minimum, maximum, and mean slope of dimming of a light curve, and for identifying the biggest peak in two light curves, time shifting them so the peaks are concurrent, scaling them so the peaks are the same magnitude, and then subtracting them, among other useful functions.

COLIBRÌ (which roughly stands for “Cosmological Libraries”) computes cosmological quantities such as ages, distances, power spectra, and correlation functions. It supports Lambda-CDM cosmologies plus extensions including massive neutrinos, non-flat geometries, evolving dark energy (w0-wa) models, and numerical recipes for f(R) gravity. COLIBRÌ is built especially for large-scale structure purposes and can interact with the Boltzmann solvers CAMB (ascl:1102.026) and CLASS (ascl:1106.020).

GrGadget merges the Particle-Mesh (PM) relativistic GEVOLUTION code (ascl:1608.014) with the TreePM GADGET-4 code (ascl:2204.014) to create a TreePM simulation code that represents metric perturbations at the scales where they are relevant while resolving non-linear structures. The better resolution of the highly non-linear regime improves the representation of the relativistic fields sampled on the mesh with respect to PM-only simulations.

GLASS (Generator for Large Scale Structure) produces cosmological simulations on the sphere. The full, three-dimensional past light cone of the observer is discretized into a sequence of nested shells, which are further discretized in the angular dimensions into maps of the sphere. GLASS was originally designed to simulate cosmic matter, weak gravitational lensing, and galaxy positions, but its flexible design and open architecture allows it to be used for a wide range of cosmological and astrophysical simulations on the sphere.

Nextflow enables scalable and reproducible scientific workflows using software containers. It allows the adaptation of pipelines written in the most common scripting languages. Its fluent DSL simplifies the implementation and the deployment of complex parallel and reactive workflows on clouds and clusters. Nextflow supports deploying workflows on a variety of execution platforms including local, HPC schedulers, AWS Batch, Google Cloud Life Sciences, and Kubernetes. Additionally, it provides support for workflow dependencies through built-in support for, for example, Conda, Spack, Docker, Podman, Singularity, and Modules.

The Australian Square Kilometre Array Pathfinder (ASKAP) has been enabled by the Commensal Real-time ASKAP Fast Transients Collaboration (CRAFT) to detect Fast Radio Bursts (FRBs) in real-time and save raw antenna voltages containing FRB detections. CELEBI, the CRAFT Effortless Localization and Enhanced Burst Inspection pipeline, extends CRAFT’s existing software to process ASKAP voltages to produce sub-arcsecond precision localizations and polarimetric data at time resolutions as fine as 3 ns of FRB events. CELEBI uses Nextflow (ascl:2305.024) to link together Bash and Python code to perform software correlation, interferometric imaging, and beamforming, thereby making use of common astronomical software packages.

HAFFET (Hybrid Analytic Flux FittEr for Transients) analyzes supernovae photometric and spectroscopic data. It handles observational data for a set of targets, estimates their physical parameters, and visualizes the population of inferred parameters. HAFFET defines two classes, snobject for data and fittings for one specific object, and snelist to organize the overall running for a list of objects. The HAFFET package includes utilities for downloading SN data from online sources, intepolating multi band lightcurves, characterizing the first light and rising of SNe with power law fits, and matching epochs of different bands. It can also calculate colors, and/or construct the spectral energy distribution (SED), estimate bolometric LCs and host galaxy extinction, fit the constructed bolometric lightcurves to different models, and identify and fit the absorption minima of spectral lines, in addition to performing other tasks. In addition to utilizing the built-in models, users can add their own models or import models from other python packages.

Simulation-based inference is the process of finding parameters of a simulator from observations. The PyTorch package sbi performs simulation-based inference by taking a Bayesian approach to return a full posterior distribution over the parameters, conditional on the observations. This posterior can be amortized (i.e. useful for any observation) or focused (i.e.tailored to a particular observation), with different computational trade-offs. The code offers a simple interface for one-line posterior inference.

SAVED21cm extracts the 21cm signal from the simulated mock observation for the Radio Experiment for the Analysis of Cosmic Hydrogen (REACH). Though built for the REACH experiment, this 21cm signal extraction pipeline can in principle can be utilized for any global 21cm experiment. The toolkit is based on a pattern recognition framework using the Singular Value Decomposition (SVD) of the 21cm and foreground training set. SAVED21cm finds the patterns in the training sets and properly models the chromatic distortions with a better basis than the polynomials.

The N-body code TIDYMESS (TIdal DYnamics of Multi-body ExtraSolar Systems) can describe the mass distribution of each body its inertia tensor and directly and self-consistently integrates orbit, spin, and inertia tensors. It manages the deformation of a body follows the tidal Creep model and includes the centrifugal force and tidal force. Written in C++, TIDYMESS is available as a standalone package and also through the AMUSE framework (ascl:1107.007).

Delight infers photometric redshifts in deep galaxy and quasar surveys. It uses a data-driven model of latent spectral energy distributions (SEDs) and a physical model of photometric fluxes as a function of redshift, thus leveraging the advantages of both machine- learning and template-fitting methods by building template SEDs directly from the training data. Delight obtains accurate redshift point estimates and probability distributions and can also be used to predict missing photometric fluxes or to simulate populations of galaxies with realistic fluxes and redshifts.

β-SGP deconvolves an astronomical image with a known Point Spread Function, providing a means for restoration of telescopic images due to issues ranging from atmospheric turbulence to instrumental aberrations. The code supports improved astrometry, deblending of overlapping sources, faint source detection, and identification of point sources near bright extended objects, and other tasks. β-SGP generalizes the Scaled Gradient Projection (SGP) image deconvolution algorithm using β-divergence as a loss function to restore distorted stellar shapes.

PhotoParallax calculates photometric parallaxes for distant stars in the Gaia TGAS catalog without any use of physical stellar models or stellar density models of the Milky Way. It uses the geometric parallaxes to calibrate a photometric model that is purely statistical, which is a model of the data rather than a model of stars per se.

sstrax provides fast simulations of Milky Way stellar stream formation. Using JAX (ascl:2111.002) acceleration to support code compilation, sstrax forward models all aspects of stream formation, including evolution in gravitational potentials, tidal disruption and observational models, in a fully modular way. Although sstrax is a standalone python package, it was also developed to integrate directly with the Albatross (ascl:2306.009) inference pipeline, which performs inference on all relevant aspects of the stream model.

Albatross analyzes Milky Way stellar streams. This Simulation-Based Inference (SBI) library is built on top of swyft (ascl:2302.016), which implements neural ratio estimation to efficiently access marginal posteriors for all parameters of interest. Using swyft for its internal Truncated Marginal Neural Ratio Estimation (TMNRE) algorithm and sstrax (ascl:2306.008) for fast simulation and modeling, Albatross provides a modular inference pipeline to support parameter inference on all relevant parts of stellar stream models.

MOBSE investigates the demography of merging BHBs. A customized version of the binary stellar evolution code BSE (ascl:1303.014), MOBSE includes metallicity-dependent prescriptions for mass-loss of massive hot stars and upgrades for the evolution of single and binary massive stars.

Margarine computes marginal bayesian statistics given a set of samples from an MCMC or nested sampling run. Specifically, the code calculates marginal Kullback-Leibler divergences and Bayesian dimensionalities using Masked Autoregressive Flows and Kernel Density Estimators to learn and sample posterior distributions of signal subspaces in high dimensional data models, and determines the properties of cosmological subspaces, such as their log-probability densities and how well constrained they are, independent of nuisance parameters. Margarine thus allows for direct and specific comparison of the constraining ability of different experimental approaches, which can in turn lead to improvements in experimental design.

ZodiPy simulates the zodiacal emission in intensity that an arbitrary solar system observer is predicted to see given an interplanetary dust model, either in the form of timestreams or full-sky HEALPix maps. Written in Python, the code makes zodiacal emission simulations more accessible by providing a simple interface to existing models.

SCONCE-SCMS detects cosmic web structures, primarily cosmic filaments and the associated cosmic nodes, from a collection of discrete observations with the extended subspace constrained mean shift (SCMS) algorithms on the unit (hyper)sphere (in most cases, the 2D (RA,DEC) celestial sphere), and the directional-linear products space (most commonly, the 3D (RA,DEC,redshift) light cone).

The subspace constrained mean shift (SCMS) algorithm is a gradient ascent typed method dealing with the estimation of local principal curves, more widely known as density ridges. The one-dimensional density ridge traces over the curves where observational data are highly concentrated and thus serves as a natural model for cosmic filaments in our Universe. Modeling cosmic filaments as density ridges enables efficient estimation by the kernel density estimator (KDE) and the subsequent SCMS algorithm in a statistically consistent way. While the standard SCMS algorithm can identify the density ridges in any "flat" Euclidean space, it exhibits large bias in estimating the density ridges on the data space with a non-linear curvature. The extended SCMS algorithms used in SCONCE-SCMS are adaptive to the spherical and conic geometries and resolve the estimation bias of the standard SCMS algorithm on a 2D (RA,DEC) celestial sphere or 3D (RA,DEC,redshift) light cone.

AIOLOS solves differential equations for hydrodynamics, friction, (thermal) radiation transport and (photo)chemistry for simulating accretion onto, and hydrodynamic escape from, planetary atmospheres. The 1-D multispecies, multiphysics hydrodynamics code, written in C++, compiles in a flexible mode that runs problems with any number of input species, and can be sped up by setting the number of species at compile time, and allows the user to provide initial conditions or boundary conditions if desired. AIOLOS provides output and diagnostic files that give snapshots in time of the state of the simulation. Output files are specific to each species, and diagnostic files contain summary as well as detailed information for, for example, the radiation transport, opacities for all species, and optical cell depths per band, in addition to other information.

Mangrove uses Graph Neural Networks to regress baryonic properties directly from full dark matter merger trees to infer galaxy properties. The package includes code for preprocessing the merger tree, and training the model can be done either as single experiments or as a sweep. Mangrove provides loss functions, learning rate schedulers, models, and a script for doing the training on a GPU.

SuperRad models ultralight boson clouds that arise through black hole superradiance. It uses numerical results in the relativistic regime combined with analytic estimates to describe the dynamics and gravitational wave signals of ultralight scalar or vector clouds. Written in Python, SuperRad includes a set of testing routines that check the internal consistency of the package; these tests mainly serve the purpose of ensuring functionality of the waveform model but can also be utilized to check that SuperRad works as intended.

Zeus21 (Zippy Early-Universe Solver for 21-cm) captures the nonlocal and nonlinear physics of cosmic dawn to create an effective model for the 21-cm power spectrum and global signal. The code takes advantage of the approximate log-normality of the star-formation rate density (SFRD) during cosmic dawn to compute the 21-cm power spectrum analytically. It agrees with more expensive semi-numerical simulations to roughly 10% precision, but has comparably negligible computational cost (~ s) and memory requirements. Zeus21 pairs well with data from HERA, but can be used for any 21-cm inference or prediction. Its capabilities include finding the 21-cm power spectrum (at a broad range of k and z), the global signal, IGM temperatures (Tk, Ts, Tcolor), neutral fraction xHI, Lyman-alpha fluxes, and the evolution of the SFRD; all across cosmic dawn z=5-35. It can also predict UVLFs for HST and JWST. Zeus21 can use three different astrophysical models, one of which emulates 21cmFAST (ascl:1102.023), and can vary the cosmology through CLASS (ascl:1106.020).

FRB performs calculations, estimations, analysis, and Bayesian inferences for Fast Radio Bursts, including dispersion measure and emission measure calculations, derived properties and spectrums, and Galactic RM.

The transient search pipeline realfast integrates with the real-time environment at the Very Large Array (VLA) to look for fast radio bursts, pulsars, and other rare astrophysical transients. The software monitors multicast messages, catches visibility data, and defines a fast transient search pipeline with rfpipe (ascl:1710.002). It indexes candidate transients and other metadata for the search interface, and writes and archives new visibility files for candidate transients. realfast provides support for GPU algorithms, manages distributed futures, and performs blind injection and management of mock transients, among other tasks, and rapidly distributes data products and transient alerts to the public.

mockFRBhosts estimates the fraction of FRB hosts that can be cataloged with redshifts by existing and future optical surveys. The package uses frbpoppy (ascl:1911.009) to generate a population of FRBs for a given radio telescope. For each FRB, a host galaxy is drawn from a data base generated by GALFORM (ascl:1510.005). The galaxies' magnitudes in different photometric surveys are calculated as are the number of bands in which they are detected. mockFRBhosts also calculates the follow-up time in a 10-m optical telescope required to do photometry or spectroscopy and provides a simple interface to Bayesian inference methods via MCMC simulations provided in the FRB package (ascl:2306.018).

pipes_vis is an interactive graphical user interface for visualizing SPS spectra. Powered by Bagpipes (ascl:2104.017), it provides real-time manipulation of a model galaxy's star formation history, dust, and other relevant properties through sliders and text boxes.

apollinaire provides functions and a framework for helioseismic and asteroseismic instruments data managing and analysis, and includes all the tools necessary to analyze the acoustic oscillations of solar-like stars. The core of the package is the peakbagging library, which provides a full framework to extract oscillation modes parameters from solar and stellar power spectra.

RELAGN creates spectral models for the calculation of AGN SEDs, ranging from the Optical/UV (outer accretion disc) to the Hard X-ray (Innermost X-ray Corona). The code is available in two languages, Python and Fortran. The Fortran version is written to be used with the spectral fitting software XSPEC (ascl:9910.005), and is the preferred version for analyzing X-ray spectral data. The Python version provides more flexibility for modeling. Whereas the Fortran version produces only a spectrum, the Python implementation can extract the physical properties of the system (such as the physical mass accretion rate, disc size, and efficiency parameters) since these are all stored as attributes within the model. Both versions require a working installation of HEASOFT (ascl:1408.004).

COpops computes semi-analytically the CO flux of a disc (given initial conditions and age) under the assumption of LTE and optically thick emission. It then runs disc population synthesis using observationally-informed initial conditions. CO fluxes is one of the most easily accessible observables for studying disc evolution; COpops is a faster alternative to running computationally-expensive thermochemical models for hundreds of discs and is accurate, recovering agreement within a factor of three.

ALminer queries, analyzes, and visualizes the ALMA Science Archive. Users can programmatically query the archive for positions, target names, or other keywords in the archive metadata (such as proposal title, abstract, or scientific category). ALminer's plotting routines allow the query results to be visualized, and its analysis functions allow users to filter the results and check whether certain frequencies of interest are covered in the queried observations. The code also allows users to directly download ALMA data products in FITS format and/or the raw data that can be used for manual image processing. ALminer has been designed to make mining the ALMA archive as simple as possible, while being flexible to be customized according to the user's scientific interests. The code is released with a detailed tutorial Jupyter notebook, introducing ALminer's common functions as well as some of its more advanced options.

The Parthenon framework, derived from Athena++ (ascl:1912.005), handles massively-parallel, device-accelerated adaptive mesh refinement. It provides a device first/device resident approach, transparent packing of data across blocks (to reduce/hide kernel launch latency), and direct device-to-device communication via asynchronous, one-sided MPI communication to enable high performance. Parthenon uses an intermediate abstraction layer to hide complexity of device kernel launches, offers support for particles and abstract variable control via metadata tags, and has a flexible plug-in package system.

Planetary Ephemeris Program (PEP) computes numerical ephemerides and simultaneously analyzes a heterogeneous collection of astrometric data. Written in Fortran, it is a general-purpose astrometric data-analysis program and models orbital motion in the solar system, determines orbital initial conditions and planetary masses, and has been used to, for example, measure general relativistic effects and test physics theories beyond the standard model. PEP also models pulsar motions and distant radio sources, and can solve for sky coordinates for radio sources, plasma densities, and the second harmonic of the Sun's gravitational field.

rfast ingests tables of opacities and generates synthetic spectra of worlds and retrieves real or simulated spectral observations. It can add noise, perform inverse modeling, and plot results. The tool can be applied to simulated and real observations spanning reflected-light, thermal emission, and transit transmission. Retrieval parameters can be toggled and parameters can be retrieved in log or linear space and adopt a Gaussian or flat prior.

Mixclask combines Cloudy (ascl:9910.001) and SKIRT (ascl:1109.003) to predict spectra and gas properties in astrophysical contexts, such as galaxies and HII regions. The main output is the mean intensity of a region filled with stars, gas and dust at different positions, assuming axial symmetry. The inputs for Mixclask are the stellar and ISM data for each region and an file for the positions (x,y,z) that will be output.

Butterpy simulates star spot emergence, evolution, decay, and stellar rotational light curves. It tests the recovery of stellar rotation periods using different frequency analysis techniques. Butterpy can simulate light curves of stars with variable activity level, rotation period, spot lifetime, magnetic cycle duration and overlap, spot emergence latitudes, and latitudinal differential rotation shear.

ECLIPSE (Efficient Cmb poLarization and Intensity Power Spectra Estimator) implements an optimized version of the Quadratic Maximum Likelihood (QML) method for the estimation of the power spectra of the Cosmic Microwave Background (CMB) from masked skies. Written in Fortran, ECLIPSE can be used in a personal computer but also benefits from the capabilities of a supercomputer to tackle large scale problems; it is designed to run parallel on many MPI tasks. ECLIPSE analyzes masked CMB maps in which the signal can be affected by the beam and pixel window functions. The masks of intensity and polarization can be different and the noise can be isotropic or anisotropic. The program can estimate auto and cross-correlation power spectrum, that can be binned or unbinned.

CosmoGraphNet infers cosmological parameters or the galaxy power spectrum. It creates a graph from a galaxy catalog with information the 3D position and intrinsic galactic properties. A Graph Neural Network is then applied to predict the cosmological parameters or the galaxy power spectrum.

lasso_spectra fits Lasso regression models to data, specifically galaxy spectra. It contains two classes for performing the actual model fitting. GeneralizedLasso is a tensorflow implementation of Lasso regression, which includes the ability to use link functions. SKLasso is a wrapper around the scikit-learn Lasso implementation intended to give the same syntax as GeneralizedLasso. It is much faster and more reliable, but does not support generalized linear models.

COLT (Cosmic Lyman-alpha Transfer) is a Monte Carlo radiative transfer (MCRT) solver for post-processing hydrodynamical simulations on arbitrary grids. These include a plane parallel slabs, spherical geometry, 3D Cartesian grids, adaptive resolution octrees, unstructured Voronoi tessellations, and secondary outputs. COLT also includes several visualization and analysis tools that exploit the underlying ray-tracing algorithms or otherwise benefit from an efficient hybrid MPI + OpenMP parallelization strategy within a flexible C++ framework.

CONCEPT (COsmological N-body CodE in PyThon) simulates cosmological structure formation. It can simulate matter particles evolving under self-gravity in an expanding background. The code offers multiple gravitational solvers and has adaptive time integration built in. In addition to particles, CONCEPT also evolves fluids at various levels of non-linearity, providing the means for the inclusion of more exotic species such as massive neutrinos, as well as for simulations consistent with general relativistic perturbation theory. Various non-standard species, such as decaying cold dark matter, are fully supported. CONCEPT includes a sophisticated initial condition generator and can output snapshots, power spectra, bispectra ,and several kinds of renders.

Idefix solves non-relativistic HD and MHD equations on various grid geometries. Based on a Godunov finite-volume method, this astrophysical flows code includes a wide choice of solvers and several modules, including constrained transport, orbital advection, and non-ideal MHD, to address complex astrophysical and fluid dynamics applications. Written in C++, Idefix relies on the Kokkos meta-programming library to guarantee performance portability on a wide variety of architectures.

The machine learning pipeline CADET (CAvity DEtection Tool) finds and size-estimates arbitrary surface brightness depressions (X-ray cavities) on noisy Chandra images of galaxies. The pipeline is a self-standing Python script and inputs either raw Chandra images in units of counts (numbers of captured photons) or normalized background-subtracted and/or exposure-corrected images. CADET saves corresponding pixel-wise as well as decomposed cavity predictions in FITS format and also preserves the WCS coordinates; it also outputs a PNG file showing decomposed predictions for individual scales.

FacetClumps extracts and analyses clumpy structure in molecular clouds. Written in Python and based on the Gaussian Facet model, FacetClumps extracts signal regions using morphology, and segments the signal regions into local regions with a gradient-based method. It then applies a connectivity-based minimum distance clustering method to cluster the local regions to the clump centers. FacetClumps automatically adjusts its parameters to local situations to improve adaptability, and is optimized to detect faint and overlapping clumps.

GRChombo performs numerical relativity simulations. It uses Chombo (ascl:1202.008) for adaptive mesh refinement and can evolve standard spacetimes such as binary black hole mergers and scalar collapses into black holes. The code supports non-trivial many-boxes-in-many-boxes mesh hierarchies and massive parallelism and evolves the Einstein equation using the standard BSSN formalism. GRChombo is written in C++14 and uses hybrid MPI/OpenMP parallelism and vector intrinsics to achieve good performance.

PEPITA (Prediction of Exoplanet Precisions using Information in Transit Analysis) makes predictions for the precision of exoplanet parameters using transit light-curves. The code uses information analysis techniques to predict the best precision that can be obtained by fitting a light-curve without actually needing to perform the fit, thus allowing more efficient planning of observations or re-observations.

COFFE (COrrelation Function Full-sky Estimator) computes quantities in linear perturbation theory. It computes the full-sky and flat-sky 2-point correlation function (2PCF) of galaxy number counts, taking into account all of the effects, including density, RSD, and lensing. It also determines the full-sky, flat-sky, and redshift-averaged multipoles of the 2PCF, and the flat-sky Gaussian covariance matrix of the multipoles of the 2PCF.

CONDUCT calculates all components of kinetic tensors in fully ionized electron-ion plasmas at arbitrary magnetic field. It employs a thermal averaging with the Fermi distribution function and can be used when electrons are partially degenerate; it provides, along with the electrical and thermal conductivities, also thermopower (thermoelectric coefficient). CONDUCT takes into account collisions of the electrons with ions and (in solid phase) charged impurities as well as quantum effects on ionic motion in the solid phase. The code's outputs are the longitudinal, transverse, and off-diagonal (Hall) components of electrical and thermal conductivity tensors as well as the components of thermoelectric tensor.

The end-to-end SHERLOCK (Searching for Hints of Exoplanets fRom Lightcurves Of spaCe-based seeKers) pipeline allows users to explore data from space-based missions to search for planetary candidates. It can recover alerted candidates by the automatic pipelines such as SPOC and the QLP, Kepler objects of interest (KOIs) and TESS objects of interest (TOIs), and can search for candidates that remain unnoticed due to detection thresholds, lack of data exploration, or poor photometric quality. SHERLOCK has six different modules to perform its tasks; these modules can be executed by filling in an initial YAML file with some basic information and using a few lines of code sequentially to pass from one step to the next. Alternatively, the user may provide with the light curve in a csv file, where the time, normalized flux, and flux error are provided in columns in comma-separated format.

nuSpaceSim simulates upward-going extensive air showers caused by neutrino interactions with the atmosphere. It is an end-to-end, neutrino flux to space-based signal detection, modeling tool for the design of sub-orbital and space-based neutrino detection experiments. This comprehensive suite of modeling packages accepts an experimental design input and then models the experiment's sensitivity to both the diffuse, cosmogenic neutrino flux as well as astrophysical neutrino transient events, such as that postulated from binary neutron star (BNS) mergers. nuSpaceSim calculates the tau neutrino acceptance for the Optical Cherenkov technique; tau propagation is interpolated using included data tables from nupyprop (ascl:2306.044). The simulation is parameterized by an input XML configuration file, with settings for detector characteristics and global parameters; nuSpaceSim also provides a python API for programmatic access.

nuPyProp simulates tau neutrino and muon neutrino interactions in the Earth and predicts the spectrum of the τ-leptons and muons that emerge. The code produces tables of charged lepton exit probabilities and energies that can be used directly or as inputs to nuSpaceSim (ascl:2306.043), which is designed to simulate optical and radio signals from extensive air showers induced by the emerging charged leptons.

CHIPS (Complete History of Interaction-Powered Supernovae) simulates the circumstellar matter and light curves of interaction-powered transients. Coupled with MESA (ascl:1010.083), the combined codes can obtain the circumstellar matter profile and light curves of the interaction-powered supernovae. CHIPS generates a realistic CSM from a model-agnostic mass eruption calculation, which can serve as a reference for observers to compare with various observations of the CSM. The code can also generate bolometric light curves from CSM interaction, which can be compared with observed light curves. The calculation of mass eruption and light curve typically takes respectively half a day and half an hour on modern CPUs.

COLASolver creates Particle-Mesh (PM) N-body simulations; the code is fast and very flexible, and can compute a wide range of models. For models with complex dynamics (screened models), it provides several options from doing it exactly to approximate but fast to just simulating linear theory equations. Every time-consuming operation is parallelized over MPI and OpenMP. It uses a slab-based parallelization that works well for fast approximate (COLA) simulations but does not perform as well for high resolution simulations. COLASolver can also be used as an analysis code for results from other simulations.

MG-PICOLA is a modified version of L-PICOLA (ascl:1507.004) that extends the COLA approach for simulating cosmological structure formation to theories that exhibit scale-dependent growth. It can compute matter power-spectra (CDM and total), redshift-space multipole power-spectra P0,P2,P4 and do halofinding on the fly.

ARPACK-NG provides a common repository with maintained versions and a test suite for the ARPACK (ascl:1311.010) code, which is no longer updated; it is a collection of Fortran77 subroutines designed to solve large scale eigenvalue problems. ARPACK-NG offers routines for banded matrices, singular value decomposition, single and double precision real arithmetic versions for symmetric, non-symmetric standard or generalized problems, and a reverse communication interface (RCI). It also provides example driver routines that may be used as templates to implement numerous shift-invert strategies for all problem types, data types and precision, in addition to other tools. The ARPACK-NG project, started by Debian, Octave, and Scilab, is now a community project maintained by volunteers.

SubgridClumping derives the parameters for the global, in-homogeneous and stochastic clumping model and then computes the clumping factor for large low-resolution N-body simulations smoothed on a regular grid. Written for the CUBEP3M simulation, the package contains two main modules. The first derives the three clumping model parameters for a given small high-resolution simulation; the second computes a clumping factor cube (same mesh-size as input) for the three models for the given density field of a large low-resolution simulation.

Hitomi provides a comprehensive set of codes for cosmological analysis of anisotropic galaxy distributions using two- and three-point statistics: two-point correlation function (2PCF), power spectrum, three-point correlation function (3PCF), and bispectrum. The code can measure the Legendre-expanded 2PCF and power spectrum from an observed sample of galaxies, and can measure the 3PCF and bispectrum expanded using the Tripolar spherical harmonic (TripoSH) function. Hitomi is basically a serial code, but can also implement MPI parallelization. Hitomi uses MPI to read multiple different input parameters simultaneously.

kilopop produces binary neutron star kilonovae in the grey-body approximation. It can also create populations of these objects useful for forecasting detection and testing observing scenarios. Additionally, it uses an emulator for the grey-opacity of the material calibrated against a suite of numerical radiation transport simulations with the code SuperNu (ascl:2103.019).

TiDE (TIdal Disruption Event) computes the light curves or spectrum of tidal disruption events. Written in C++, it can compute the monochromatic light curve without diffusion, including the total luminosity, wind luminosity and disk luminosity, and the monochromatic light curve with diffusion. TiDE can also model the bolometric luminosity and calculate the spectrum at a given time, including the wind luminosity and disk luminosity. This code can be used to explore the possible parameter space and reveal potential biases caused by the model assumptions, and can be extended with new models, allowing one to compare and test different prescriptions and model assumptions under the same circumstances.

threepoint models the third-order aperture statistics, the natural components of the shear three-point correlation function and the covariance of third-order aperture statistics. Third-order weak lensing statistics extract cosmological information in the non-Gaussianity of the cosmic large-scale structure, making them a promising tool for cosmological analyses.

ESSENCE (Evaluating Statistical Significance undEr Noise CorrElation) evaluates the statistical significance of image analysis and signal detection under correlated noise in interferometric images (e.g., ALMA, NOEMA). It measures the noise autocorrelation function (ACF) to fully characterize the statistical properties of spatially correlated noise in the interferometric image, computes the noise in the spatially integrated quantities (e.g., flux, spectrum) with a given aperture, and simulates noise maps with the same correlation property. ESSENSE can also construct a covariance matrix from noise ACF, which can be used for a 2d image or 3d cube model fitting.

PSFMachine creates models of instrument effective Point Spread Functions (ePSFs), also called Pixel Response Functions (PRFs). These models are then used to fit a scene in a stack of astronomical images. PSFMachine is able to quickly derive photometry from stacks of Kepler and TESS images and separate crowded sources.

pybranch calculates experimental branching fractions and transition probabilities from measurements of atomic spectra. Though the program is usually used with spectral line lists from intensity-calibrated spectra from Fourier transform spectrometers, it can in principle be used with any calibrated spectra that meet the input requirements. pybranch takes a set of linelists, computes a weighted average branching fraction (Fki) for each line, combines these branching fractions with the level lifetime to obtain the transition probability, and then prints the calibrated intensities and S/N ratios for all the lines observed from a particular upper level in each spectrum. One line can be chosen to use as a reference to put all of the intensities on the same scale. pybranch can use calculated transition probabilities to calculate a residual from lines that have not been observed.

The Global Extinction Reduction IDL codes compare optical photometry from the twin Gemini North and South Multi-Object Spectrographs (GMOS-N and GMOS-S) against the expected worsening of atmospheric transparency due to global climate change. Data from the Gemini instruments are first reduced by DRAGONS (ascl:1811.002). GER then calibrates them against the Sloan Digital Sky Survey (SDSS) and Gaia G-band catalogs; image rotation and alignment is accomplished via identification of sufficiently-bright stars in Gaia. A simple model of Gemini and their site characteristics is generated, including meteorology, cloudy-fractions, number of reflections, dates of re-coatings modulated by rate of efficiency decay, together with response of detectors and associated zeropoints, and can be compared with the decline of transparency due to rising temperature and associated humidity increase.

BOXFIT calculates light curves and spectra for arbitrary observer times and frequencies and of performing (broadband) data fits using the downhill simplex method combined with simulated annealing. The flux value for a given observer time and frequency is a function of various variables that set the explosion physics (energy of the explosion, circumburst number density and jet collimation angle), the radiative process (magnetic field generation efficiency, electron shock-acceleration efficiency and synchrotron power slope for the electron energy distribution) and observer position (distance, redshift and angle). The code can be run both in parallel and on a single core. Because a data fit takes many iterations, this is best done in parallel. Single light curves and spectra can readily be done on a single core.

The fast N-body code SCF-FDPS (Self-Consistent Field-Framework for Developing Particle Simulators) simulates disk-halo systems. It combines a self-consistent field (SCF) code, which provides scalability, and a tree code that is parallelized using the Framework for Developing Particle Simulators (FDPS) (ascl:1604.011). SCF-FDPS handles a wide variety of halo profiles and can be used to study extensive dynamical problems of disk-halo systems.

Jdaviz provides data viewers and analysis plugins that can be flexibly combined as desired to create interactive applications. It offers Specviz (ascl:1902.011) for visualization and quick-look analysis of 1D astronomical spectra; Mosviz for visualization of astronomical spectra, including 1D and 2D spectra as well as contextual information, and Cubeviz for visualization of spectroscopic data cubes (such as those produced by JWST MIRI). Imviz, which provides visualization and quick-look analysis for 2D astronomical images, is also included. Jdaviz is designed with instrument modes from the James Webb Space Telescope (JWST) in mind, but the tool is flexible enough to read in data from many astronomical telescopes, and the documentation provides a complete table of all supported modes.

BE-HaPPY (Bias Emulator for Halo Power spectrum Python) facilitates future large scale surveys analysis by providing an accurate, easy to use and computationally inexpensive method to compute the halo bias in the presence of massive neutrinos. Provided with a linear power spectrum, the package will compute a new power spectrum according to the chosen configuration. BE-HaPPY handles linear, polynomial, and perturbation theory bias models. The code also handles Kaiser and Scoccimarro redshifts; other available options include real or redshift space, the total neutrino mass, and a choice of mass bin or scale array, among others.

RelicFast computes the scale-dependent bias induced by relics of different masses, spins, and temperatures, through spherical collapse and the peak-background split. The code determines halo bias in under a second, making it possible to include this effect for different cosmologies, and light relics, at little computational cost.

alf fits the absorption line optical—NIR spectrum. Initially written to constrain the stellar IMF in old massive galaxies, the code now also offers theoretical age and metallicity-dependent response functions covering 19 elements, nuisance parameters to capture uncertainties in stellar evolution, and parameters to capture uncertainties in the data, including modeling telluric absorption and sky line residuals. alf can fit stellar populations with metallicities from approximately -2.0 to +0.3 and performs well when fitting stellar populations ranging from metal-poor globular clusters to brightest cluster galaxies. The software works in continuum-normalized space and so does not make any use of the shape of the continuum (nor of corresponding photometry). Fitting is handled with emcee (ascl:1303.002); the code is MPI parallelized and runs efficiently on many processors, though fitting data with alf is time intensive.

axionHMcode computes the non-linear matter power spectrum in a mixed dark matter cosmology with ultra-light axion (ULA) component of the dark matter. This model uses some of the fitting parameters and is inspired by HMcode (ascl:1508.001). axionHMcode uses the full expanded power spectrum to calculate the non-linear power spectrum; it splits the axion overdensity into a clustered and linear component to take the non clustering of axions on small scales due to free-streaming into account.

pyPplusS calculates the light curves for ringed, oblate or spherical exoplanets in both the uniform and limb darkened cases. It can constrain the oblateness of planets using photometric data only. This code can be used to model light curves of more complicated configurations, including multiple planets, oblate planets, moons, rings, and combinations of these, while properly and efficiently taking into account overlapping areas and limb darkening.

AGNvar calculates the expected reverberation signal in any given energy band, for a given spectral energy distribution (SED), assuming variable X-ray emission. The code predicts the shape of the re-processed continuum by modeling the time-averaged SED according to input parameters, which include geometry, mass, and mass accretion rate; generally the input parameters are based off typical XSPEC (ascl:9910.005) models. It evaluates the SED response to an input driving light-curve (assumed to originate in the X-ray corona) and creates a set of time-dependent SEDs. It then takes the results from the set of time-dependent SEDs and extracts the light-curve in a given band pass.

21cmvFAST demonstrates that including dark matter (DM)-baryon relative velocities produces velocity-induced acoustic oscillations (VAOs) in the 21-cm power spectrum. Based on 21cmFAST (ascl:1102.023) and 21CMMC (ascl:1608.017), 21cmvFAST accounts for molecular-cooling haloes, which are expected to drive star formation during cosmic dawn, as both relative velocities and Lyman-Werner feedback suppress halo formation. This yields accurate 21-cm predictions all the way to reionization (z>~10).

The three-phase pnautilus chemical code finds the abundance of each species by solving rate equations for gas-phase and grain surface chemistries. It performs gas–grain simulations in which both the icy mantle and the surface are considered active, taking into account mantle photodissociation, diffusion, and reactions; the code also considers the competition among reaction, diffusion and evaporation.

baccoemu provides a collection of emulators for large-scale structure statistics over a wide range of cosmologies. The emulators provide fast predictions for the linear cold- and total-matter power spectrum, the nonlinear cold-matter power spectrum, and the modifications to the cold-matter power spectrum caused by baryonic physics in a wide cosmological parameter space, including dynamical dark energy and massive neutrinos.

Coniferest is a Python package designed for implementing anomaly detection algorithms and interactive active learning tools. The centerpiece of the package is an Isolation Forest algorithm, known for its superior scoring performance and multi-threading evaluation. This robust anomaly detection algorithm operates by constructing random decision trees.

In addition to the Isolation Forest algorithm, Coniferest also offers two modified versions for active learning: AAD Forest and Pineforest. The AAD Forest modifies the Isolation Forest by reweighting its leaves based on responses from human experts, providing a faster alternative to the ad_examples package.

On the other hand, Pineforest, developed by the SNAD team, employs a filtering algorithm that builds and dismantles trees with each new human-machine iteration step.

Coniferest provides a user-friendly interface for conducting interactive human-machine sessions, facilitating the use of these active anomaly detection algorithms. The SNAD team maintains and utilizes this package primarily for anomaly detection in the field of astronomy, with a particular focus on light-curve data from large time-domain surveys.

DiscVerSt calculates the vertical structure of accretion discs around neutron stars and black holes. Different classes represent the vertical structure for different types of EoS and opacity, temperature gradient and irradiation scheme; the code includes an interface for initializing the chosen structure type. DiscVerSt also contains functions to calculate S-curves and the vertical and radial profile of a stationary disc.

mnms (Map-based Noise ModelS) creates map-based models of Simons Observatory Atacama Cosmology Telescope (ACT) data. Each model supports drawing map-based simulations from data splits with independent realizations of the noise or equivalent, similar to an independent set of time-domain sims. In addition to the ability to create on-the-fly simulations, mnms also includes ready-made scripts for writing a large batch of products to disk in a dedicated SLURM job.

SIRENA (Software Ifca for Reconstruction of EveNts for Athena X-IFU) reconstructs the energy of incoming X-ray photons after their detection in the X-IFU TES detector. It is integrated in the SIXTE (ascl:1903.002) end-to-end simulations environment where it currently runs over SIXTE simulated data. This is done by means of a tool called tesreconstruction, which is mainly a wrapper to pass a data file to the SIRENA tasks.

Synthetic LISA simulates the LISA science process at the level of scientific and technical requirements. The code generates synthetic time series of the LISA fundamental noises, as filtered through all the TDI observables, and provides a streamlined module to compute the TDI responses to gravitational waves, according to a full model of TDI, including the motion of the LISA array, and the temporal and directional dependence of the armlengths.

BOWIE (Binary Observability With Illustrative Exploration) performs graphical analysis of binary signals from gravitational waves. It takes gridded data sets and produces different types of plots in customized arrangements for detailed analysis of gravitational wave sensitivity curves and/or binary signals. BOWIE offers three main tools: a gridded data generator, a plotting tool, and a waveform generator for general use. The waveform generator creates PhenomD waveforms for binary black hole inspiral, merger, and ringdown. Gridded data sets are created using the PhenomD generator for signal-to-noise (SNR) analysis. Using the gridded data sets, customized configurations of plots are created with the plotting package.

DataComb combines radio interferometric and single dish observations and obtains quantitative measures of how different techniques perform to obtain better fidelity images. The package relies on CASA (ascl:1107.013) for the combinations and on AstroPy (ascl:1304.002) for making quantitative
comparisons between different images produced by different methods. Model images and simulations are also used to assess the different combination methods.

Veusz produces a wide variety of publication-ready 2D and 3D plots. Plots are created by building up plotting widgets with a consistent object-based interface, and the package provides many options for customizing plots. Veusz can import data from text, CSV, HDF5 and FITS files; datasets can also be entered within the program and new datasets created via the manipulation of existing datasets using mathematical expressions and more. The program can also be extended, by adding plugins supporting importing new data formats, different types of data manipulation or for automating tasks, and it supports vector and bitmap output, including PDF, Postscript, SVG and EMF.

IMRIpy simulates an Intermediate Mass Ratio Inspiral (IMRI) by gravitational wave emission with a Dark Matter(DM) halo or a (baryonic) Accretion Disk around the central Intermediate Mass Black Hole(IMBH). It can use different density profiles (such as DM spikes), and different interactions, such as dynamical friction with and without HaloFeedback models or accretion, to produce the simulation.

The IMRPhenomD model generates gravitational wave signals for merging black hole binaries with non-precessing spins. The waveforms are produced in the frequency domain and include the inspiral, merger and ringdown parts for the dominant spherical harmonic mode of the signal. Part of LALSuite (ascl:2012.021) and also available as an independent code, IMRPhenomD is written in C and is calibrated against data from numerical relativity simulations. A re-implementation of IMRPhenomD in Python, PyIMRPhenomD (ascl:2307.023), is available.

PolyBin estimates the binned power spectrum, bispectrum, and trispectrum for full-sky HEALPix maps such as the CMB. This can include both spin-0 and spin-2 fields, such as the CMB temperature and polarization, or galaxy positions and galaxy shear. Alternatively, one can use only scalar maps. For each statistic, two estimators are available: the standard (ideal) estimators, which do not take into account the mask, and window-deconvolved estimators. For the second case, a Fisher matrix must be computed; this depends on binning and the mask, but does not need to be recomputed for each new simulation. PolyBin can compute both the parity-even and parity-odd components, accounting for any leakage between the two, for the bispectrum and trispectrum.

FGBuster (ForeGroundBuster) separates frequency maps into component maps and forecasts component separation both when the model is correct and when it is incorrect. FGBuster can be used for SED evaluation, intermediate component separation, multi-resolution separation, and forecasting, among other tasks.

The TOAST software framework simulates and processes timestream data collected by telescopes. The framework can distribute data among many processes and perform operations on the local pieces of the data, and has generic operators for common processing tasks such as filtering, pointing expansion, and map-making. In addition to offering I/O for a limited set of formats, it provides well-defined interfaces for adding custom I/O classes and processing operators. TOAST is written in C++ with a public Python interface, and contains utilities for controlling the runtime environment, logging, timing, streamed random number generation, quaternion operations, FFTs, and special function evaluation.

PyIMRPhenomD estimates the population of stellar origin black hole binaries for LISA observations using a Bayesian parameter estimation algorithm. The code reimplements IMRPhenomD (ascl:2307.019) in a pure Python code, compiled with the Numba just-in-time compiler. The module implements the analytic first and second derivatives necessary to compute t(f) and t'(f) rather than computing them numerically. Using the analytic derivatives increases the code complexity but produces faster and more numerically accurate results; the improvement in numerical accuracy is particularly significant for t'(f).

SHARK solves the hydrodynamic equations for gas and dust mixtures accounting for dust coagulation and fragmentation (among other things). The code is written in Fortran and is capable of handling both 1D and 2D Cartesian geometries; 1D simulations with spherical geometry are also possible. SHARK is versatile and can be used to model various astrophysical environments.

pyhalomodel computes halo-model power spectra for any desired tracer combination. The software requires only halo profiles for the tracers to be specified; these could be matter profiles, galaxy profiles, or something else, such as electron-pressure or HI profiles. pyhalomodel makes it easier to perform basic calculations using the halo model by reducing the changes of variables required to integrate halo profiles against halo mass functions, which can be confusing and tedious.

gyrointerp calculates gyrochronal ages by interpolating between open cluster rotation sequences. The framework, written in Python, can be used to find the gyrochronological age posterior of single or many stars. It can also produce a visual interpolation for a star’s age to determine where the star falls in the rotation-temperature plane in comparison to known reference clusters. gyrointerp models the ensemble evolution of rotation periods for main-sequence stars with temperatures of 3800-6200 K (masses of 0.5-1.2 solar) and is not applicable for subgiant or giant stars, and should be used cautiously with binary stars, as they can observationally bias temperature and rotation period measurements.

CosmicFish obtains expected bounds on cosmological parameters for a wide range of models and observables for cosmological forecasting. The package includes a Fortran library to produce Fisher matrices, a Python library that performs operations on the produced Fisher matrices, and a full set of plotting utilities. It works with many models, including CAMB (ascl:1102.026) and MGCAMB (ascl:1106.013), and can interface with any Boltzmann solver. The user can choose within a wide range of possible cosmological observables, including cosmic microwave background, weak lensing tomography, galaxy clustering, and redshift drift. CosmicFish is easy to customize; it provides a flexible package system and users can produce their own analyses and plotting pipelines following the default Python apps.

TidalPy performs semi-analytic calculations of tidal dissipation and subsequent orbit-spin evolution for rocky and icy worlds. It can be used as a black box, in which an Object-Oriented Programming (OOP) scheme performs many calculations with very little user input from the user, making it easy to get started with the package, or as a toolbox, as it contains many efficient functions to perform calculations relevant to tides and thermal-orbital coupling, which can be quickly imported and used in a custom scripts. In general, TidelPy's toolbox (functional) scheme provides much higher performance, flexibility, and extensibility than the OOP scheme. It also makes assumptions more visible to the user. The downside is the user may need to be more familiar with the underlying physics.

SIMPLE (Simple Intensity Map Producer for Line Emission) generates intensity maps that include observational effects such as noise, anisotropic smoothing, sky subtraction, and masking. Written in Python, it is based on a lognormal simulation of galaxies and random assignment of luminosities to these galaxies and generates mock intensity maps that can be used to study survey systematics and calculate covariance matrices of power spectra. The code is modular, allowing its components to be used independently.

SAMUS (Simulator of Asteroid Malformation Under Stress) simulates the deformation of minor bodies, assuming that they are homogenous incompressible fluid masses. They are initialized as ellipsoids and the Navier-Stokes equations are interatively solved to investigate the deformation of the body over time. The software is modular and allows for user-defined output functions, size, and trajectories. Structured as a single large class, SAMUS can store variables and handle arbitrary function calls, which eases debugging and investigation, especially for lengthy high-fidelity simulation runs.

HilalPy analyzes lunar crescent visibility criteria. Written in Python, the code uses more than 8000 lunar crescent visibility records extracted from literature and websites of lunar crescent observation, descriptive statistics, contradiction rate percentage, and regression analysis in its analysis to predict the visibility of a lunar crescent.

AmpF numerically calculates the amplification factor for solar lensing. The import parameters are the gravitational-wave frequency and the source angular position with respect to the solar center; the code outputs are the amplification factor and its geometrical-optics limit. AmpF accepts variables for several attributes and the overall amplitude of the lensing potential can be changed as needed. The method has been implemented in both C and Python.

Imber simulates spectroscopic and photometric observations with both a gridded numerical simulation and analytical model. Written in Python, it is specifically designed to predict Extremely Large Telescope instrument (such as ELT/METIS and TMT/MODHIS) Doppler imaging performance, and has also been applied to existing, archival observations of spectroscopy and photometry.

Guacho is a 3D hydrodynamical/magnetohydrodynamical code suited for astrophysical fluids. The hydrodynamic equations are evolved with a number of approximate Riemann solvers. Gaucho includes various modules to deal with different cooling regimes, and a radiation transfer module based on a Monte Carlo ray tracing method. The code can run sequentially or in parallel with MPI.

The binary_c software framework models the evolution of single, binary and multiple stars, including stellar evolution and nucleosynthesis. Stellar evolution includes wind mass loss, rotation, thermal pulses, magnetic braking, pre-main sequence evolution, supernovae and kicks, and neutron stars; binary-star evolution includes mass transfer, gravitational-wave losses, tides, novae, circumbinary discs, and merging stars. binary_c natively includes nucleosynthesis, and, as it is designed for stellar population calculations, it is lightweight and versatile. binary_c works in standalone, virtual and HPC environments, and its support software contains tools for development and data analysis. A version in Python, binary_c-python (ascl:2307.036), is also available.

binary_c-python provides a manager for and interface to the binary_c framework (ascl:2307.035), and rapidly evolves individual systems and populations of stars. It provides functions such as data processing tools and initial distribution functions for stellar properties. binary_c-python also includes tools to run large grids of (binary) stellar systems on servers or distributed systems.

WDMWaveletTransforms implements the fast forward and inverse WDM wavelet transforms in Python from both the time and frequency domains. The frequency domain transforms are inherently faster and more accurate. The wavelet domain->frequency domain and frequency domain->wavelet domain transforms are nearly exact numerical inverses of each other for a variety of inputs tested, including Gaussian random noise. WDMWaveletTransforms has both command line and Python interfaces.

WarpX is an advanced electromagnetic & electrostatic Particle-In-Cell code. It supports many features including Perfectly-Matched Layers (PML), mesh refinement, and the boosted-frame technique. A highly-parallel and highly-optimized code, WarpX can run on GPUs and multi-core CPUs, includes load balancing capabilities, and scales to the largest supercomputers.

adiabatic-tides evaluates the tidal stripping of dark matter (sub)haloes in the adiabatic limit. It exactly reproduces the remnant of an NFW halo that is exposed to a slowly increasing isotropic tidal field and approximately reproduces the remnant for an anisotropic tidal field. adiabatic-tides also predicts the asymptotic mass loss limit for orbiting subhaloes and differently concentrated host-haloes with and without baryonic components, and can be used to improve predictions of dark matter annihilation.

pycrires runs the CRIRES+ recipes of EsoRex. The pipeline organizes the raw data, creates SOF and configuration files, runs the calibration and science recipes, and creates plots of the images and extracted spectra. Additionally, it corrects remaining inaccuracies in the wavelength solution and the spectrum curvature. pycrires also provides dedicated routines for the extraction, calibration, and detection of spatially-resolved objects such as directly imaged planets.

EFTCAMB patches the public Einstein-Boltzmann solver CAMB (ascl:1102.026) to implement the Effective Field Theory approach to cosmic acceleration. It can be used to investigate the effect of different EFT operators on linear perturbations and to study perturbations in any specific DE/MG model that can be cast into EFT framework. To interface EFTCAMB with cosmological data sets, it is equipped with a modified version of CosmoMC (ascl:1106.025), EFTCosmoMC, to create a bridge between the EFT parametrization of the dynamics of perturbations and observations.

LIMpy models and analyzes multi-line intensity maps of CII (158 µ), OIII (88 µ), and CO (1-0) to CO (13-12) transitions. It can be used as an analytic model for star formation rate, to simulate line intensity maps based on halo catalogs, and to calculate the power spectrum from simulated maps and the cross-correlated signal between two separate lines. Among other things, LIMpy can also create multi-line luminosity models and determine the multi-line intensity power spectrum.

EAGLES (Estimating AGes from Lithium Equivalent widthS) implements an empirical model that predicts the lithium equivalent width (EW) of a star as a function of its age and effective temperature. The code computes the age probability distribution for a star with a given EW and Teff, subject to an age probability prior that may be flat in age or flat in log age. Data for more than one star can be entered; EAGLES then treats these as a cluster and determines the age probability distribution for the ensemble. The code produces estimates of the most probable age, uncertainties and the median age; output files consisting of probability plots, best-fit isochrone plots, and tables of the posterior age probability distribution(s).

The centrifugal deformation program RUBIS (Rotation code Using Barotropy conservation over Isopotential Surfaces) takes an input 1D model (with spherical symmetry) and returns its deformed version by applying a conservative rotation profile specified by the user. The code needs only the density as a function of radial distance from the reference model in addition to the surface pressure to be imposed to perform the deformation; preserving the relation between density and pressure when going from the 1D to the 2D structure makes this lightness possible. By solving Poisson's equation in spheroidal rather than spherical coordinates whenever a discontinuity is present, RUBIS can deform both stellar and planetary models, thereby dealing with potential discontinuities in the density profile.

NAVanalysis studies the non-baryonic, or non-Newtonian, contribution to galaxy rotation curves straight from a given data sample. Conclusions on the radial profile of a given model can be drawn without individual galaxy fits to provide an efficient sample comparison. The method can be used to eliminate model parameter regions, find the most probable parameter regions, and uncover trends not easy to find from standard fits. Further, NAVanalysis can compare different approaches and models.

HAYASHI (Halo-level AnalYsis of the Absorption Signal in HI) computes the number of absorption features of the 21cm forest using a semianalytic formalism. It includes the enhancement of the signal due to the presence of substructures within minihalos and supports non-standard cosmologies with impact in the large scale structure, such as warm dark matter and primordial black holes. HAYASHI is written in Python3 and uses the cosmological computations package Colossus (ascl:1501.016).

GWDALI focuses on parameter estimations of gravitational waves generated by compact object coalescence (CBC). This software employs both Gaussian (Fisher Matrix) and Beyond-Gaussian methods to approximate the likelihood of gravitational wave events. GWDALI also addresses the challenges posed by Fisher Matrices with zero determinants. Additionally, the Beyond-Gaussian approach incorporates the Derivative Approximation for Likelihoods (DALI) algorithm, enabling a more reliable estimation process.

NaMaster computes full-sky angular cross-power spectra of masked, spin-0 and spin-2 fields with an arbitrary number of known contaminants using a pseudo-Cl (aka MASTER) approach. The code also implements E/B-mode purification and offers both full-sky and flat-sky modes. NaMaster is available as a C library, Python module, and standalone program.

reMASTERed reconstructs ensemble-averaged pseudo-$C_\ell$ to effectively exact precision, with significant improvements over traditional estimators for cases where the map and mask are correlated. The code can compute the results given an arbitrary map and mask; it can also compute the results in the ensemble average for certain types of threshold masks.

νHawkHunter explores the prospects of detecting neutrinos produced by the evaporation of primordial black holes in ground-based experiments. It makes use of neutrino fluxes from Hawking radiation computed with BlackHawk (ascl:2012.020). νHawkHunter is also be used for Diffuse Supernova Neutrino Background or similar studies by replacing the signal fluxes by the proper ones.

WeakLensingQML implements the Quadratic Maximum Likelihood (QML) estimator and applies it to simulated cosmic shear data and compares the results to a Pseudo-Cl implementation. The package computes and saves relevant data files for later processes, such as the fiduciary cosmic shear power spectrum used in the analysis, the sky mask, and computing an analytic version of the QML's covariance matrix. The core of the package implements a conjugate-gradient approach for the quadratic estimator, and is parallelized for maximum performance. The code relies on the Eigen linear algebra package and the HealPix spherical harmonic transform library. A post-processing script analyzes the results and compares the QML's estimates with those from the Pseudo-Cl estimator; it then produces an array of plots highlighting the results.

EVo calculates the speciation and volume of a volcanic gas phase erupting in equilibrium with its parent magma. Models can be run to calculate the gas phase in equilibrium with a melt at a single pressure, or the melt can be decompressed from depth rising to the surface as a closed-system case. Single pressure and decompression can be run for OH, COH, SOH, COHS and COHSN systems. EVo can calculate gas phase weight and volume fraction within the system, gas phase speciation as mole fraction or weight fraction across numerous compounds, and the volatile content of the melt at each pressure. It also calculates melt density, f02 of the system, and more. EVo can be set up using either melt volatile contents, or for a set amount of atomic volatile which is preferable for conducting experiments over a wide range of fO2 values.

EVolve calculates the chemical composition and surface pressure of a ID atmosphere on a rocky planet that is being produced by volcanic activity, as it grows over time. Once the initial volatile content of the planet's mantle and the composition and resultant surface pressure of any pre-existing atmosphere is set, the volcanic degassing model EVo (ascl:2307.052) calculates the amount and speciation of any volcanic gases released into the atmosphere over each time step. Atmospheric processing is calculated using FastChem (ascl:1804.025); thermochemical equilibrium is assumed so the final chemical composition of the atmosphere is calculated according to the pre-set surface temperature.

Directly imaged planet candidates (high contrast point sources near bright stars) are often validated, among other supporting lines of evidence, by comparing their observed motion against the projected motion of a background source due to the proper motion of the bright star and the parallax motion due to the Earth's orbit. Often, the "background track" is constructed assuming an interloping point source is at infinity and has no proper motion itself, but this assumption can fail, producing false positive results, for crowded fields or insufficient observing time-baselines (e.g. Nielsen et al. 2017). `backtrack` is a tool for constructing background proper motion and parallax tracks for validation of high contrast candidates. It can produce classical infinite distance, stationary background tracks, but was constructed in order to fit finite distance, non-stationary tracks using nested sampling (and can be used on clusters). The code sets priors on parallax based on the relations in Bailer-Jones et al. 2021 that are fit to Gaia eDR3 data, and are therefore representative of the galactic stellar density. The public example currently reproduces the results of Nielsen et al. 2017 and Wagner et al. 2022, demonstrating that the motion of HD 131399A "b" is fit by a finite distance, non-stationary background star, but the code has been tested and validated on proprietary datasets. The code is open source, available on github, and additional contributions are welcome.

LEFTfield forward models cosmological matter density fields and biased tracers of large-scale structure. The model, written in C++ code, is centered around classes encapsulating scalar, vector, and tensor grids. It includes the complete bias expansion at any order in perturbations and captures general expansion histories without relying on the EdS approximation; however, the latter is also implemented and results in substantially smaller computational demands. LEFTfield includes a subset of the nonlinear higher-derivative terms in the bias expansion of general tracers.

plan-net uses machine learning with an ensemble of Bayesian neural networks for atmospheric retrieval; this approach yields greater accuracy and more robust uncertainties than a single model. A new loss function for BNNs learns correlations between the model outputs. Performance is improved by incorporating domain-specific knowledge into the machine learning models and provides additional insight by inferring the covariance of the retrieved atmospheric parameters.

HELA performs atmospheric retrieval on exoplanet atmospheres using a Random Forest algorithm. The code has two stages: training (which includes testing), and predicting. It requires a training set that matches the format of the data to be analyzed, with the same number of points and a sample spectrum for each parameter. The number of trees used and the number of jobs are editable. The HELA package includes a training set and data as examples.

species (spectral characterization and inference for exoplanet science) provides a coherent framework for spectral and photometric analysis of directly imaged exoplanets and brown dwarfs which builds on publicly-available data and models from various resources. species contains tools for grid and free retrievals using Bayesian inference, synthetic photometry, interpolating a variety atmospheric and evolutionary model grids (including the possibility to add a custom grid), color-magnitude and color-color diagrams, empirical spectral analysis, spectral and photometric calibration, and analysis of emission lines.

APOLLO forward models the radiative transfer of light through a planetary (or brown dwarf) atmosphere; it also forward models transit and emission spectra and retrieves atmospheric properties of extrasolar planets. The code has two operational modes: one to compute a planetary spectrum given a set of parameters, and one to retrieve those parameters based on an observed spectrum. The package uses emcee (ascl:1303.002) to find the best fit to a spectrum for a given parameter set. APOLLO is modular and offers many options that may be turned on and off, including the type of observations, a flexible molecular composition, multiple cloud prescriptions, multiple temperature-pressure profile prescriptions, multiple priors, and continuum normalization.

orbitN generates accurate and reproducible long-term orbital solutions for near-Keplerian planetary systems with a dominant mass M0. The code focuses on hierarchical systems without close encounters but can be extended to include additional features. Among other features, the package includes M0's quadrupole moment, a lunar contribution, and post-Newtonian corrections (1PN) due to M0 (fast symplectic implementation). To reduce numerical roundoff errors, orbitN features Kahan compensated summation.

MBASC (Multi-Band AGN-SFG Classifier) classifies sources as Active Galactic Nuclei (AGNs) and Star Forming Galaxies (SFGs). The algorithm is based on the light gradient-boosting machine ML technique. MBASC can use a wide range of multi-wavelength data and redshifts to predict a classification for sources.

connect (COsmological Neural Network Emulator of CLASS using TensorFlow) emulates cosmological parameters using neural networks. This includes both sampling of training data and training of the actual networks using the TensorFlow library. connect aids in cosmological parameter inference by immensely speeding up the process, which is achieved by substituting the cosmological Einstein-Boltzmann solver codes, needed for every evaluation of the likelihood, with a neural network with a 10² to 10³ times faster evaluation time. The code requires CLASS (ascl:1106.020) and Monte Python (ascl:1307.002) if iterative sampling is used.

FABADA (Fully Adaptive Bayesian Algorithm for Data Analysis) performs non-parametric noise reduction using Bayesian inference. It iteratively evaluates possible smoothed models of the data to estimate the underlying signal that is statistically compatible with the noisy measurements. Iterations stop based on the evidence E and the χ² statistic of the last smooth model, and the expected value of the signal is computed as a weighted average of the smooth models. Though FABADA was written for astronomical data, such as spectra (1D) or images (2D), it can be used as a general noise reduction algorithm for any one- or two-dimensional data; the only requisite of the input data is an estimation of its associated variance.

MOOG_SCAT, a redevelopment of the LTE radiative transfer code MOOG (ascl:1202.009), contains modifications that allow for the treatment of isotropic, coherent scattering in stars. MOOG_SCAT employs a modified form of the source function and solves radiative transfer with a short charactersitics approach and an acclerated lambda iteration scheme.

FLATW'RM (FLAre deTection With Ransac Method) detects stellar flares in light curves using a classical machine-learning method. The code tries to find a rotation period in the light curve and splits the data to detection windows. The light curve sections are fit with the robust fitting algorithm RANSAC (Random sample consensus); outlier points (flare candidates) above the pre-set detection level are marked for each section. For the given detection window, only those flare candidates that have at least a given number of consecutive points (three by default) are kept and marked as flares. When using FLATW’RM, the code's output should be checked to determine whether changes to the default settings are needed to account for light curve noise, data sampling frequency, and scientific needs.

SIMBI simulates heterogeneous relativistic gas dynamics up to 3d for special relativistic hydrodynamics and up to 2D Newtonian hydrodynamics. It supports user-defined mesh expansion and contraction, density, momentum, and energy density terms outside of grid; the code also supports source terms in the Euler equations and source terms at the boundaries. Boundary conditions, which include periodic, reflecting, outflow, and inflow boundaries, are given as an array of strings. If an inflow boundary condition is set but no inflow boundary source terms are given, SIMBI switches to outflow boundary conditions to prevent crashes. The code can track a single passive scalar, insert an immersed boundary, and is impermeable by default. SIMBI USES the Cython framework to blend together C++, CUDA, HIP, and Python.

AstroPhot quickly extracts detailed information from complex astronomical data for individual images or large survey programs. It fits models for sky, stars, galaxies, PSFs, and more in a principled chi^2 forward optimization, recovering Bayesian posterior information and covariance of all parameters. The code optimizes forward models on CPU or GPU, across images that are large, multi-band, multi-epoch, rotated, dithered, and more. Models are optimized together, thus handling overlapping objects and including the covariance between parameters (including PSF and galaxy parameters). AstroPhot includes several optimization algorithms, including Levenberg-Marquardt, Gradient descent, and No-U-Turn MCMC sampling.

FastSpecFit models the observed-frame optical spectroscopy and broadband photometry of extragalactic targets using physically grounded stellar continuum and emission-line templates. The code handles data from the Dark Energy Spectroscopic Instrument (DESI) Survey, which is amassing spectrophotometry for an unprecedented 40 million extragalactic targets, although the algorithms are general enough to accommodate other upcoming, massively multiplexed spectroscopic surveys. FastSpecFit extracts nearly 800 observed- and rest-frame quantities from each target, including light-weighted ages and stellar velocity dispersions based on the underlying stellar continuum; line-widths, velocity shifts, integrated fluxes, and equivalent widths for nearly 40 rest-frame ultraviolet, optical, and near-infrared emission lines arising from both star formation and active galactic nuclear activity; and K-corrections and rest-frame absolute magnitudes and colors. Moreover, FastSpecFit is designed with speed and parallelism in mind, enabling it to deliver robust model fits to tens of millions of targets.

Nemo detects millimeter-wave Sunyaev-Zel'dovich galaxy clusters and compact sources. Originally developed for the Atacama Cosmology Telescope project, the code is capable of analyzing the next generation of deep, wide multifrequency millimeter-wave maps that will be produced by experiments such as the Simons Observatory. Nemo provides several modules for analyzing ACT/SO data in addition to the command-line programs provided in the package.

DiskMINT (Disk Model for INdividual Targets) models individual disks and derives robust disk mass estimates. Built on RADMC-3D (ascl:1202.015) for continuum (and gas line) radiative transfer, the code includes a reduced chemical network to determine the C18O emission. DiskMINT has a Python3 module that generates a self-consistent 2D disk structure to satisfy VHSE (Vertical Hydrostatic Equilibrium). It also contains a Fortran code of the reduced chemical network that contains the main chemical processes necessary for C18O modeling: the isotopologue-selective photodissociation, and the grain-surface chemistry where the CO converting to CO2 ice is the main reaction.

Rapster (RAPid cluSTER evolution) models binary black hole population synthesis and the evolution of star clusters based on simple, yet realistic prescriptions. The code can generate large populations of dynamically formed binary black holes. Rapster uses SEVN (ascl:2206.019) to model the initial black hole mass spectrum and PRECESSION (ascl:1611.004) to model the mass, spin, and gravitational recoil of merger remnants.

Caput (Cluster Astronomical Python Utilities) contains utilities for handling large datasets on computer clusters. Written with radio astronomy in mind, the package provides an infrastructure for building, managing and configuring pipelines for data processing. It includes modules for dynamically importing and utilizing mpi4py, in-memory mock-ups of h5py objects, and infrastructure for running data analysis pipelines on computer clusters. Caput features a generic container for holding self-documenting datasets in memory with straightforward syncing to h5py files, and offers specialization for holding time stream data. Caput also includes tools for MPI-parallel analysis and routines for converting between different time representations, dealing with leap seconds, and calculating celestial times.

BCMemu provides emulators to model the suppression in the power spectrum due to baryonic feedback processes. These emulators are based on the baryonification model, where gravity-only N-body simulation results are manipulated to include the impact of baryonic feedback processes. The package also has a three parameter barynification model; the first assumes all the three parameters to be independent of redshift while the second assumes the parameters to be redshift dependent.

glmnet efficiently fits the entire lasso or elastic-net regularization path for linear regression (gaussian), multi-task gaussian, logistic and multinomial regression models (grouped or not), Poisson regression and the Cox model. The algorithm uses cyclical coordinate descent in a path-wise fashion.

KeplerFit fits a Keplerian velocity distribution model to position-velocity (PV) data to obtain an estimate of the enclosed mass. The code extracts the scales of the pixels in both directions, spatial and spectral, then extracts the most extreme velocity at each position; this returns two arrays of positions and velocities. KeplerFit then models the extracted PV data and returns a set of the best-fit parameters, the standard deviations in each of the parameters, and the total residual of the fit.

Driftscan simulates and analyzes transit radio interferometers, with a particular focus on 21cm cosmology. Given a design of a telescope, it generates a set of products used to analyze data from it and simulate timestreams. Driftscan also constructs a filter to extract cosmological 21 cm emission from astrophysical foregrounds, such as our galaxy and radio point sources, and estimates the 21cm power spectrum using an optimal quadratic estimator.

velocileptors computes the real- and redshift-space power spectra and correlation functions of biased tracers using 1-loop perturbation theory (with effective field theory counter terms and up to cubic biasing) as well as the real-space pairwise velocity moments. It provides simple computation of the power spectrum wedges or multipoles, and uses a reduced set of parameters for computing the most common case of the redshift-space power spectrum. In addition, velocileptors offers two "direct expansion" modules available in LPT and EPT.

FishLSS computes the Fisher information matrix for a set of observables and model parameters. It can model the redshift-space power spectrum of any biased tracer of the CDM+baryon field and the post-reconstruction galaxy power spectrum. The code also models the projected cross-correlation of galaxies with the CMB lensing convergence, the projected galaxy power spectrum, and the CMB lensing convergence power spectrum. FishLSS requires pyFFTW (ascl:2109.009), velocileptors (ascl:2308.014), and CLASS (ascl:1106.020).

TRES simulates hierarchical triple systems with stellar and planetary components, including stellar evolution, stellar winds, tides, general relativistic effects, mass transfer, and three-body dynamics. It combines stellar evolution and interactions with three-body dynamics in a self-consistent way. The code includes the effects of common-envelope evolution, circularized stable mass transfer, tides, gravitational wave emission and up-to-date stellar evolution through SeBa (ascl:1201.003). Other stellar evolution codes, such as SSE (ascl:1303.015), can also be used. TRES is written in the AMUSE (ascl:1107.007) software framework.

Uncertain_blackholemass predicts virial black hole masses using a neural network model and quantifies their uncertainties. The scripts retrieve data and run feature extraction and uncertainty quantification for regression. They can be used separately or deployed to existing machine learning methods to generate prediction intervals for the black hole mass predictions.

Swiftbat retrieves, analyzes, and displays data from NASA's Swift spacecraft, especially data from the Swift Burst Alert Telescope (BAT). All BAT data are available from the Swift data archive; however, a few routines in this library use data access methods not available to the general public and thus are useful only to Swift team members. The package also installs a command-line program 'swinfo' that provides Swift Information such as what the MET (onboard-clock) time is, where Swift was pointing, and whether a specific source was above the horizon and/or in the field of view.

GWSim generates mock gravitational waves (GW) events corresponding to different binary black holes (BBHs) population models. It can incorporate scenarios of GW mass models, GW spin distributions, the merger rate, and the cosmological parameters. GWSim generates samples of binary compact objects for a fixed amount of observation time, duty cycle, and configurations of the detector network; the universe created by the code is uniform in comobile volume.

The feed-forward neural network DeepGlow emulates BOXFIT (ascl:2306.059) simulation data of gamma-ray burst (GRB) afterglows. The package provides an easy interface to generate GRB afterglow spectra and light curves mimicking those generated through BOXFIT with high accuracy. The code used to generate the training data and to train the neural networks is also included.

CoLFI (Cosmological Likelihood-Free Inference) estimates parameters directly from the observational data sets using neural density estimators (NDEs); it is a fully ANN-based framework that differs from the Bayesian inference. The package contains three NDEs that are used to estimate parameters: an artificial neural network (ANN), a mixture density network (MDN), and a mixture neural network (MNN). CoLFI can learn the conditional probability density using samples generated by models, and the posterior distribution can be obtained for given observational data.

The injection-recovery MATRIX (Multi-phAse Transits Recovery from Injected eXoplanets) Toolkit creates grids of scenarios with a set of periods, radii, and epochs of synthetic transiting exoplanet signals in a provided light curve. Typical injection-recovery executions consist of 2-dimensional scenarios, where only one epoch (random or hardcoded) was used for each period and radius, which may reduce accuracy. MATRIX performs multi-phase analyses needing only a few parameters in a configuration file and running one line of code.

Plages Identification identifies solar plages from Ca II K photographic observations irrespective of noise level, brightness, and other image properties. The code provides an efficient, reliable method for identifying solar plages. The output of the algorithm is an image highlighting the plages and the calculated plage index. Plages Identification is also deployed as a webapp, allowing users to experiment with different hyperparameters and visualize their impact on the output image in real time.

Calibration solutions for the LOFAR radio telescope are stored in a 5-dimensional (time, frequency, station, polarisation and direction in the sky) HDF5 table. H5plot is a GUI application focussing on interactive visual inspection of these calibration solutions.

Matching stars in astronomical images is an essential step in data reduction. This work includes some matching programs implemented by Python: simple matching, fast matching, and triangle matching. For two catalogs with m and n objects, the simple method has a time and space complexity of O(m*n) but is fast for fewer n or m. The time complexity of the fast method is O(mlogm+nlogn). The triangle method will work between rotated and scaled images. All methods are applied in pipelines and work well. This package is published to the PyPI with the name 'qmatch'.

Working with a GUI, or adding interaction in plotting, will help a lot in data analysis. However, the common GUI of Python is OS-dependent, while manually adding interactive codes is too complex. A pseudo-GUI tool is introduced in this work. It will help to add buttons/checkers in the graph and assign callback functions to them. The remaining problem is that the documents in this package are in Chinese and will be in English in the next version. This program is published to the PyPI, and can be installed by 'pip install pltgui'.

INSPECTA (formerly sdhdfProc) is a software package to read, manipulate and process radio astronomy data in Spectral-Domain Hierarchical Data Format (SDHDF). It is available as part of the 'sdhdf_tools' repository.

pymcspearman is a python implementation of MCSpearman (ascl:1504.008) and calculates Spearman's rank correlation coefficient for data, using bootstrapping and/or perturbation to estimate the uncertainties on the correlation coefficient. This software project has migrated (and expanded) to pymccorrelation (ascl:2309.010).

pymccorrelation calculates correlation coefficients for data, using bootstrapping and/or perturbation to estimate the uncertainties on the correlation coefficient and p-value. The code supports Pearson's r, Spearman's rho, and Kendall's tau. Calculations of Kendall's tau additionally support censored data. This code supercedes and expands the deprecated code pymcspearman (ascl:2309.009).

The Periodogram Comparison for Optimizing Small Transiting Planet Detection R code compares two periodogram algorithms for detecting transiting exoplanets: the Box-fitting Least Squares (BLS) and the Transit Comb Filter (TCF). It calculates the False Alarm Probability (FAP) based on extreme value theory and signal-to-noise ratio (SNR) metrics to quantify periodogram peak significance. The comparison approach is aimed at optimizing the detection of small transiting planets in future transiting exoplanet surveys. The code can be extended for comparing any set of periodograms.

The python photometry suite StarbugII provides accurate photometry on point-like sources embedded in complex diffuse emissions. The tool has a simple modular interface with a wide range of photometric routines including embedded source detection, aperture and PSF photometry, diffuse background emission estimation, catalog matching and artificial star testing. The core is built around Photutils (ascl:1609.011).

maszcal calibrates the observable-mass relation for galaxy clusters, with a focus on the thermal Sunyaev-Zeldovich signal's relation to mass. maszcal explicitly models baryonic matter density profiles, differing from most previous approaches that treat galaxy clusters as purely dark matter. To do this, it uses a generalized Nararro-Frenk-White (GNFW) density to represent the baryons, while using the more typical NFW profile to represent dark matter.

fitScalingRelation fits galaxy cluster scaling relations using orthogonal or bisector regression and MCMC. It takes into account errors on both variables and intrinsic scatter. Although it geared for fitting galaxy cluster scaling relations of all kinds, it can be used for any kind of regression problem with errors on both variables and intrinsic scatter.

bskit, built upon the nbodykit (ascl:1904.027) simulation analysis package, measures density bispectra from snapshots of cosmological N-body or hydrodynamical simulations. It can measure auto or cross bispectra in a user-specified set of triangle bins (that is, triplets of 3-vector wavenumbers). Several common sets of bins are also implemented, including all triangle bins for specified k_min and k_max, equilateral triangles between specified k_min and k_max, isosceles triangles, and squeezed isosceles triangles.

PEREGRINE performs full parameter estimation on gravitational wave signals. Using an internal Truncated Marginal Neural Ratio Estimation (TMNRE) algorithm and building upon the swyft (ascl:2302.016) code to efficiently access marginal posteriors, PEREGRINE conducts a sequential simulation-based inference approach to support the analysis of both transient and continuous gravitational wave sources. The code can fully reconstruct the posterior distributions for all parameters of spinning, precessing compact binary mergers using waveform approximants.

ChEAP (Chemical Evolution Analytic Package) implements an analytic solution for the chemical evolution model of the Galaxy that extends the instantaneous recycling approximation with the contribution of Type Ia SNe. The code works for different prescriptions of the delay time distributions (DTDs), including the single and double degenerate scenarios, and allows the inclusion of an arbitrary number of pristine gas infalls. The required functions are contained in the CheapTools.py file, which is imported as a Python library. ChEAP also includes code to illustrate, with a random-parameter chemical evolution model, the accuracy of this analytic solution compared to one using numerical integration.

The finite volume hydro code Sprout uses a simple expanding Cartesian grid to track outflows for several orders of magnitudes in expansion. It captures shocks whether they are aligned or misaligned with the grid, and provides second-order convergence for smooth flows. The code's expanding mesh capability reduces numerical diffusion drastically for outflows, especially when the analytic nature of the bulk flow is known beforehand. Sprout can be used to study fluid instabilities in expanding flows, such as in SN explosions and jets; it resolves fine fluid structures at small length scales and expand the mesh gradually as the structures grow.

FRISBHEE (FRIedmann Solver for Black Hole Evaporation in the Early-universe solves the Friedmann - Boltzmann equations for Primordial Black Holes + SM radiation + BSM Models. Considering the collapse of density fluctuations as the PBH formation mechanism, the code handles monochromatic and extended mass and spin distributions. FRISBHEE can return the full evolution of the PBH, SM and Dark Radiation comoving energy densities, together with the evolution of the PBH mass and spin as a function of the log₁₀ at scale factor, and can determine the relic abundance in the case of Dark Matter produced from BH evaporation for monochromatic and extended distributions.

PlanetSlicer fits brightness maps to phase curves using the "orange-slice" method and works both for self-luminous objects and those that diffuse reflected light assuming Lambertian reflectance. In both cases, the model supposes that a spherical object can be divided into slices of constant brightness (or albedo) which may be integrated to yield the total flux observed, given the angles of observation. The package contains two key functions: toPhaseCurve and fromPhaseCurve; the former integrates the brightness for each slice to calculate the observed total flux from the object, given the longitude of observation. The latter does the opposite, estimating the brightness of the slices from a set of observed total flux (the phase curve).

celerite2 is a re-write of celerite (ascl:1709.008), an algorithm for fast and scalable Gaussian Process (GP) Regression in one dimension. celerite2 improves numerical stability and integration with various machine learning frameworks. The implementation includes interfaces in Python and C++, with full support for PyMC (ascl:1610.016) and JAX (ascl:2111.002).

lcsim creates artificial light curves using two algorithms. The first simulates Gaussian distributed light curves following a specific power spectral density (PSD) freely selectable by the user. The second algorithm simulates light curves following a specific PSD and matching a specific probability density function (PDF). The package provides methods to resample the simulated light curves and add "observational" noise. Furthermore, the package provides an interface to a SQLite3-based database to store and access the simulations.

wwz provides a python3 implementation of the Foster weighted wavelet z-transform, a wavelet-based method for periodicity analysis of unevenly sampled data.

q3dfit performs PSF decomposition and spectral analysis for high dynamic range JWST IFU observations, allowing the user to create science-ready maps of relevant spectral features. The software takes advantage of the spectral differences between quasars and their host galaxies for maximal-contrast subtraction of the quasar point-spread function (PSF) to reveal and characterize the faint extended emission of the host galaxy. Host galaxy emission is carefully fit with a combination of stellar continuum, emission and absorption of dust and ices, and ionic and molecular emission lines.

The DustPyLib library contains auxiliary modules for the dust evolution software DustPy (ascl:2207.016), which simulates the evolution of dust and gas in protoplanetary disks. DustPyLib includes interfaces to radiative transfer codes and modules with extensions to the DustPy defaults.

MAGPy-RV (Modelling stellar Activity with Gaussian Processes in Radial Velocity) models data with Gaussian Process regression and affine invariant Monte Carlo Markov Chain parameter searching. Developed to model intrinsic, quasi-periodic variations induced by the host star in radial velocity (RV) surveys for the detection of exoplanets and the accurate measurements of their orbital parameters and masses, it now includes a variety of kernels and models and can be applied to any timeseries analysis. MAGPy-RV includes publication level plotting, efficient posterior extraction, and export-ready LaTeX results tables. It also handles multiple datasets at once and can model offsets and systematics from multiple instruments. MAGPy-RV requires no external dependencies besides basic python libraries and corner (ascl:1702.002).

zCluster measures galaxy cluster photometric redshifts using data from broadband photometry in large public surveys, given a priori knowledge of the cluster position. The code retrieves and uses redshift probability distributions in order to create a projected two-dimensional density map of a targeted galaxy cluster, which is later convolved with a Gaussian kernel to smooth the map. zCluster also produces photometric redshift estimates and galaxy density maps for any point in the sky using the included zField tool.

clfd (clean folded data) implements GPU-accelerated smart interference removal algorithms to be used on folded pulsar search and pulsar timing data. The code converts each source profile to a small set of representative features, flagging outliers in the resulting feature space. clfd further visualizes the outlier flagging process, as well as the resulting two-dimensional time-frequency mask that is applied to the clean archive. The code provides access to cleaning algorithms that were initially developed for the High Time Resolution Universe (HTRU) survey which found several pulsars.

IQRM-APOLLO cleans narrow-band radio frequency interference (RFI) using the Inter-Quartile Range Mitigation (IQRM) algorithm. By masking this interference, the code reduces the number of false positive pulsar candidates and increases sensitivity for pulsar detection. The IQRM algorithm is an outlier detection algorithm that is both non-parametric and robust to the presences of trends in time series data. Using short-duration data blocks, IQRM-APOLLO computes a spectral statistic that correlates with the presence of RFI, removing high outliers from the input signal.

riptide implements the Fast Folding Algorithm (FFA) to identify periodic signals from time series data. In order to identify faint pulsars, the code provides access to a library of functions and classes for processing dedispersed radio signals. The FFA approaches the theoretical optimum for sensitivity to periodic signals regardless of pulse period and duty cycle.

AI-Feynman fits analytical expressions to data sets via symbolic regression, mapping the target variable to different features supplied in the data array. Using a neural network with constraints in the number of parameters utilized, the code provides the ability to obtain analytical expressions for normalized features that are used to predict a Pareto-optimal target. AI-Feynman is robust in handling noisy data, recursively generating multidimensional symbolic expressions that match data from an unknown functions.

GRIZZLY simulates reionization using a 1D radiative transfer scheme. The code enables the efficient exploration of the parameter space for evaluating 21cm brightness temperature fluctuations near the cosmic dawn. GRIZZLY builds upon the BEARS algorithm for generating simulated reionization maps with density and velocity fields, which are useful for profiling dark matter halos and cosmological density fields.

The graphical user interface Wavelength Calibrator facilitates wavelength calibration. Although developed for astronomical data reduction, it can also be used in any place where wavelength calibration is needed.

VCAL-SPHERE, for VIP-based Calibration of VLT/SPHERE data, is a versatile pipeline for high-contrast imaging of exoplanets and circumstellar disks. The pipeline covers all steps of data reduction, including raw calibration, pre-processing and post-processing (i.e., modeling and subtraction of the stellar halo), for the IFS, IRDIS-DBI and IRDIS-CI modes (and combinations thereof) of the VLT instrument SPHERE. The three main steps of the reduction correspond to different modules, where the first follows the recommended EsoRex (ascl:1504.003) workflow and associated recipes with occasional inclusion of VIP (ascl:1603.003) routines (e.g., for PCA-based sky subtraction), while the other two stages fully rely on the VIP toolbox. Although the default parameters of the pipeline should yield a good reduction in most cases, these can be tuned using JSON parameter files for each stage of the pipeline for optimal reduction of specific datasets.

The IDL code Special-Blurring compares models of quantum-foam-induced blurring with the full dataset of gamma-ray burst localizations available from the NASA High Energy Astrophysics Science Research Archive (as of 1 November 2022). This includes GRB221009A, which was especially bright and detected in extremely high energy TeV gamma-rays. An upper limit of the parameter alpha (giving the maximal strength of quantum blurring) can be entered, which is scaled in the model of blurring (called "Phi") operating much like "seeing" from the ground in the optical, and those calculations are plotted against the observations.

The landscape of high- and ultra-high-energy astrophysics has changed in the last decade, largely due to the inflow of data collected by large-scale cosmic-ray, gamma-ray, and neutrino observatories. At the dawn of the multimessenger era, the interpretation of these observations within a consistent framework is important to elucidate the open questions in this field. CRPropa 3.2 is a Monte Carlo code for simulating the propagation of high-energy particles in the Universe. This version represents a major leap forward, significantly expanding the simulation framework and opening up the possibility for many more astrophysical applications. This includes, among others: efficient simulation of high-energy particles in diffusion-dominated domains, self-consistent and fast modelling of electromagnetic cascades with an extended set of channels for photon production, and studies of cosmic-ray diffusion tensors based on updated coherent and turbulent magnetic-field models. Furthermore, several technical updates and improvements are introduced with the new version, such as: enhanced interpolation, targeted emission of sources, and a new propagation algorithm (Boris push). The detailed description of all novel features is accompanied by a discussion and a selected number of example applications.

The KvW code applies the Kwee Van Woerden (KvW) method for eclipse or transit minimum timing, with an improved error calculation that avoids underestimated errors in minimum times that may appear in the original method. This is particularly the case for low-noise eclipse or transit lightcurves from space or from modern ground instrumentation. The code requires an input light curve of near-equidistant points that contains only the eclipse, without any off-eclipse points, and is available in python and IDL. Both implementaitons return an eclipse minimum time with its error and provide optional text output and plots, as well as several levels of debug information.

The NEOexchange web portal and Target and Observation Manager ingests solar system objects, including Near-Earth Object (NEO) candidates from the Minor Planet Center, schedules observations on the Las Cumbres Observatory global telescope network and reduces, displays, and analyzes the resulting data. NEOexchange produces calibrated photometry from the imaging data and uses Source Extractor (ascl:1010.064) and SCAMP (ascl:1010.063) to perform object detection and astrometric fitting and calviacat (ascl:2207.015) to perform photometric calibration against photometric catalogs. It also has the ability to perform image registration and subtraction using SWARP (ascl:1010.068) and HOTPANTS (ascl:1504.004) and image stacking, alignment, and faint feature detection using gnuastro (ascl:1801.009).

MONDPMesh provides a particle-mesh method to calculate the time evolution of an system of point masses under modified gravity, namely the AQUAL formalism. This is done by transforming the Poisson equation for the potential into a system of four linear PDEs, and solving these using fast Fourier transforms. The accelerations on the point masses are calculated from this potential, and the system is propagated using Leapfrog integration. The time complexity of the code is O(N⋅p⋅log(p)) for p pixels and N particles, which is the same as for a Newtonian particle-mesh code.

Tensiometer provides non-Gaussian tension estimators that extend GetDist (ascl:1910.018) capabilities to test the level of agreement or disagreement between different posterior distributions by using kernel density estimates. The code has been used to study the level of internal agreement between different measurements of the clustering of cosmological structures from the Dark Energy Survey and the Planck satellite.

IQRM implements the Inter-Quartile Range Mitigation (IQRM) interference flagging algorithm for radio pulsar and transient searches. This module provides only the algorithm that infers a channel mask from some spectral statistic that measures the level of RFI contamination in a time-frequency data block. It should be useful as a reference implementation to developers who wish to integrate IQRM into an existing pipeline or search code.

Hi-COLA runs fast approximate N-body simulations of non-linear structure formation in reduced Horndeski gravity (Horndeski theories with luminal gravitational waves). It is generic with respect to the reduced Horndeski class. Given an input Lagrangian, Hi-COLA's front-end dynamically constructs the appropriate field equations and consistently solves for the cosmological background, linear growth, and screened fifth force of that theory. This is passed to the back-end, which runs a hybrid N-body simulation at significantly reduced computational and temporal cost compared to traditional N-body codes. By analyzing the particle snapshots, one can study the formation of structure through statistics such as the matter power spectrum.

FPFS (Fourier Power Function Shaplets) is a fast, accurate shear estimator for the shear responses of galaxy shape, flux, and detection. Utilizing leading-order perturbations of shear (a vector perturbation) and image noise (a tensor perturbation), the code determines shear and noise responses for both measurements and detections. Unlike methods that distort each observed galaxy repeatedly, the software employs analytical shear responses of select basis functions, including Shapelets basis and peak basis. FPFS is efficient and can process approximately 1,000 galaxies within a single CPU second, and maintains a multiplicative shear estimation bias below 0.5% even amidst blending challenges.

PIPPIN (PDI pipeline for NACO data) reduces the polarimetric observations made with the VLT/NACO instrument. It applies the Polarimetric Differential Imaging (PDI) technique to distinguish the polarized, scattered light from the (largely) un-polarized, stellar light. As a result, circumstellar dust can be uncovered. PIPPIN appropriately handles various instrument configurations, including half-wave plate and de-rotator usage, Wollaston beam-splitter, and wiregrid observations. As part of the PDI reduction, PIPPIN performs various levels of corrections for instrumental polarization and crosstalk.

CosmoLattice performs lattice simulations of field dynamics in an expanding universe. The code can simulate the dynamics of interacting scalar field theories, Abelian U(1) gauge theories, and non-Abelian SU(2) gauge theories, either in flat spacetime or an expanding FLRW background, including the case of self-consistent expansion sourced by the fields themselves. It can also compute gravitational waves sourced by U(1) Abelian Gauge fields. The CosmoLattice platform can implement any system of dynamical equations suitable for discretization on a lattice, as it introduces its own language describing fields and operations between them, and hence can implement new libraries to solve arbitrary field problems (related or not to cosmology).

pygwb analyzes laser interferometer data and designs a gravitational wave background (GWB) search pipeline. Its modular and flexible codebase is tailored to current ground-based interferometers such as LIGO Hanford, LIGO Livingston, and Virgo, but can be generalized to other configurations. It is based on GWpy (ascl:1912.016) and bilby (ascl:1901.011) for optimal integration with widely-used gravitational wave data analysis tools. pygwb also includes a set of scripts to analyze data and perform large-scale searches on a high-performance computing cluster efficiently.

FASMA delivers the atmospheric stellar parameters (effective temperature, surface gravity, metallicity, microturbulence, macroturbulence, and rotational velocity) based on the spectral synthesis technique. This technique relies on the comparison of synthetic spectra with observations to yield the best-fit parameters under a χ2 minimization process. FASMA also delivers chemical abundances of 13 elements. Written in Python, the code is wrapped around MOOG (ascl:1202.009) which calculates the synthetic spectra. FASMA includes two grids of models in MOOG readable format, Kurucz and marcs, that cover the parameter space for both dwarf and giant stars with metallicity limit of -5.0 dex.

nemiss calculates neutrino emission from an astrophysical jet. nemiss works as part of the PLUTO-nemiss-rlos pipeline. PLUTO (ascl:1010.045) produces a hydrodynamical jet. Then, nemiss calculates beamed neutrino emission at each eligible cell along a given direction in space. Finally, rlos (ascl:1811.009) produces a synthetic neutrino image of the jet along the given direction, taking into consideration the finite nature of the speed of light.

The numerical code RoSSBi3D (Rotating Systems Simulation Code for Bi-fluids) is designed for protoplanetary discs study at 2D and 3D. It is a finite volume code which is second order in time, features self-gravity (2D), and uses an exact Riemann solver to account for discontinuities. This FORTRAN 90 code solves the fully compressible inviscid Euler, continuity and energy conservation equations in polar coordinates for an ideal gas orbiting a central object. Solid particles are treated as a pressureless fluid and interact with the gas through aerodynamic forces. The code works on high performance computers thanks to the MPI standard (CPU).

prodimopy is an open-source Python package to read, analyze and plot modelling results of the radiation thermo-chemical disk code ProDiMo (PROtoplanetary DIsk MOdel, https://prodimo.iwf.oeaw.ac.at). It also includes tools to run ProDiMo in 1D slap model mode, to run simple ProDimo model grids and to interface ProDiMo with 1D and 2D disk codes (i.e. use input structure from hydrodynamic models).

prodimopy can also be used independently of ProDiMo (no ProDiMo installation is required) and hence is also useful to extract information from already available ProDiMo models (e.g. as input for other codes) or for model comparison.

smops interpolates input sub-band model FITS images, such as those produced by WSClean (ascl:1408.023), into more finely channelized sub-band model FITS images, thus generating model images at a higher frequency resolution. It is a Python-based command line tool. For example, given input model FITS images initially created from sub-dividing a given bandwidth into four, smops can subdivide that bandwidth further, resulting in more finely channelized model images, to a specified frequency resolution. This smooths out the stepwise behavior of models across frequency, which can improve the results of self-calibration with such models.

PROSPECT infers cosmological parameters using profile likelihoods. It constructs an approximate profile likelihood from an MCMC and optimizes it using simulated annealing, a gradient-free stochastic optimization algorithm. It employs an automatic tuning of the step size parameter and binned covariance matrices from the MCMC to achieve efficient optimizations of the profile likelihood.

BUQO solves large-scale imaging inverse problems. It leverages probability concentration phenomena and the underlying convex geometry to formulate the Bayesian hypothesis test as a convex problem that is then efficiently solved by using scalable optimization algorithms. This allows scaling to high-resolution and high-sensitivity imaging problems that are computationally unaffordable for other Bayesian computation approaches.

DENSe enables Bayesian non-parametric inferences of densities of Poisson data counts. Its framework of stateless methods is written in Python, although it relies on NIFTy (ascl:1302.013, ascl:1903.008) for the heavy lifting. DENSe utilizes all available information in the data by modeling the inherent correlation structure using a Matérn kernel. The inference of the density from count data can be written in a single line of python code. The fitting method takes a multidimensional numpy array as input and returns multidimensional arrays of the same dimensions encoding the density field.

LyaCoLoRe uses CoLoRe (ascl:2111.009) simulations to generate simulated Lyman alpha forest spectra. The code takes the output files from CoLoRe as an input, carries out several stages of processing, and produces realistic skewers of transmitted flux fraction as an output. The repository includes tools to tune the parameters within LyaCoLoRe's transformation, and to measure the 1D power spectrum of output skewers quickly.

SolarAxionFlux quantifies systematic differences and statistical uncertainties in the calculation of the solar axion flux from axion-photon and axion-electron interactions. Determining the limitations of these calculations can be used to identify potential improvements and help determine axion model parameters more accurately.

CosmoLED computes Hawking evaporation from black holes and set constraints on the fraction of black holes in dark matter. Based on ExoCLASS (ascl:1106.020), the code provides a DarkAges_LED module and C codes in class_LED to compute the evolution and energy deposition functions from LED black holes. Though CosmoLED is designed for large extra dimension black holes, it can also be used to study 4D black holes.

The CompressedFisher library tests whether Fisher forecasts using simulated components are converged. The library contains tools to compute standard Fisher estimates, estimate the level of bias due to the finite number of simulations, and compute the compressed Fisher information. Typical usage of CompressedFisher requires two ensembles of simulations: one set of simulations is given at the fiducial parameters (𝜃) to estimate the covariance matrix. The second is a set of simulated derivatives; these can either be in the form of realizations of the derivatives themselves or simulations evaluate at a set of point in the neighborhood of the fiducial point that the code can use to estimate the derivatives.

The non-parametric Jeans code GravSphere models discrete data and can be used to model dark matter distributions in galaxies. It can also recover the density ρ(r) and velocity anisotropy β(r) of spherical stellar systems, assuming only that they are in a steady state. Real or mock data are prepared by using the included binulator.py code; the repository also includes many examples for exploring the GravSphere's capabilities.

FORECAST generates realistic astronomical images and galaxy surveys by forward modeling the output snapshot of any hydrodynamical cosmological simulation. It exploits the snapshot by constructing a lightcone centered on the observer's position; the code computes the observed fluxes of each simulated stellar element, modeled as a Single Stellar Population (SSP), in any chosen set of pass-band filters, including k-correction, IGM absorption, and dust attenuation. These fluxes are then used to create an image on a grid of pixels, to which observational features such as background noise and PSF blurring can be added. FORECAST provides customizable options for filters, size of the field of view, and survey parameters, thus allowing the synthetic images to be tailored for specific research requirements.

PhotochemPy finds the steady-state chemical composition of an atmosphere or evolves atmospheres through time. Given inputs such as the stellar UV flux and atmospheric temperature structure, the code creates a photochemical model of a planet's atmosphere. PhotochemPy is a distant fork of Atmos (ascl:2106.039). It provides a Python wrapper to Fortran source code but can also be used exclusively in Fortran.

The folding pipeline PulsarX searches for pulsars. The code includes radio frequency interference mitigation, de-dispersion, folding, and parameter optimization, and supports both psrfits and filterbank data formats. The toolset has two implementations of the folding pipelines; one uses a brute-force de-dispersion algorithm, and the other an algorithm that becomes more efficient than the brute-force de-dispersion algorithm as the number of candidates increases. PulsarX is appropriate for large-scale pulsar surveys.

21cmEMU emulates 21cmFAST (ascl:1102.023) summary statistics, among them the 21-cm power spectrum, 21-cm global brightness temperature, IGM spin temperature, and neutral fraction. It also emulates the Thomson scattering optical depth and UV luminosity functions. With 21cmFAST installed, parameters can be supplied direction to 21cmEMU, and 21cmEMU can be used for, for example, analytic calculations of tau_e and UV luminosity functions. The code is included as an alternative simulator in 21cmMC (ascl:1608.017).

GRFolres performs simulations in modified theories of gravity. It is based on GRChombo (ascl:2306.039) and inherits all of the capabilities of the main GRChombo code, which makes use of the Chombo library (ascl:1202.008) for adaptive mesh refinement. The code implements the 4∂ST theory of modified gravity and the cubic Horndeski theory in (3+1)-dimensional numerical relativity. GRFolres can be used for stable gauge evolution, solving the modified energy and momentum constraints for initial conditions, and monitoring the constraint violation and calculating the energy densities associated with the different scalar terms in the action. It can also extract data for the tensor and scalar gravitational waveforms.

SUNBIRD trains neural-network-based models for galaxy clustering. It also incorporates pre-trained emulators for different summary statistics, including galaxy two-point correlation function, density-split clustering statistics, and old-galaxy cross-correlation function. These models have been trained on mock galaxy catalogs, and were calibrated to work for specific samples of galaxies. SUNBIRD implements routines with PyTorch to train new neural-network emulators.

The Farmer contains photometry routines geared towards deep, multi-wavelength galaxy surveys. It fits simple parametric surface brightness profiles provided by The Tractor (ascl:1604.008) to measure precision photometry even in deeply crowded fields when provided with a suitable high resolution detection image. The Farmer has been used to build a number of galaxy survey catalogs including COSMOS202, SHELA, and H20.

LimberJack.jl performs cosmological analyses of 2 point auto- and cross-correlation measurements from galaxy clustering, CMB lensing and weak lensing data. Written in Julia, it obtains gradients for its outputs faster than traditional finite difference methods, making the code greatly synergistic with gradient-based sampling methods such as Hamiltonian Monte Carlo. LimberJack.jl can efficiently exploring parameter spaces with hundreds of dimensions.

PyMsOfa accesses the International Astronomical Union’s SOFA library (ascl:1403.026) from Python. It offers a wrapper package based on a foreign function library for Python (ctypes), a wrapper with the foreign function interface for Python calling C code (cffi), and a package directly written in pure Python codes from SOFA subroutines. PyMsOfa is suitable for the astrometric detection of habitable planets of the Closeby Habitable Exoplanet Survey (CHES) mission and for the frontier themes of black holes and dark matter related to astrometric calculations and other fields.

Rainbow is a black-body parametric model for transient light curves. It uses Bazin function as a model for bolometric flux evolution and a logistic function for the temperature evolution; it provides seven fit parameters and goodness of fit (reduced χ²) and is well-suited for transient objects. Also included is RainbowRisingFit, suitable for rising transient objects, which offers six fit parameters. It is based on a rising sigmoid bolometric flux and a sigmoid temperature evolution. These implementations are implemented in the light-curve processing toolbox (ascl:2107.001) for Python.

The ProPane package comes with key utilities for warping between different WCS systems: propaneWarp (for warping individual frames once). ProPane also contains the various functions for creating large stacks of many warped frames (which is of class ProPane, which is roughly meant to suggest the idea of many panes of glass being stacked together). It uses the wcslib C library (ascl:1108.003) for projections (all legal ones are supported) via the Rwcs package, and uses the threaded Cimg C++ library via the imager library to do image warping. ProPane also contains functions converted from older (deprecated) Rwcs and ProFound (ascl:1804.006) related functions.

PyRaTE (Python Radiative Transfer Emission) post-processes astrochemical simulations. This multilevel radiative transfer code uses the escape probablity method to calculate the population densities of the species under consideration. The code can handle all projection angles and geometries and can also be used to produce mock observations of the Goldreich-Kylafis effect. PyRaTE is written in Python; it uses a parallel strategy and relies on the YT analysis toolkit (ascl:1011.022), mpi4py and numba.

C²-Ray calculates spherical symmetric time-dependent photo-ionization in 1D with the source at the origin for hydrogen only. The code is explicitly photon-conserving and uses an analytical relaxation solution for the ionization rate equations for each time step, thus enabling integration of the equation of transfer along a ray with fewer cells and time steps than previous methods. It is suitable for coupling radiative transfer to gas and N-body dynamics methods on fixed or adaptive grids. C²-Ray is not parallelized but contains an MPI module for compatibility with the 3D version (C²-Ray3Dm).

C²-Ray3Dm performs time-dependent photo-ionization calculations for 3D multiple sources, and for hydrogen only. Based on C²-Ray (ascl:2312.022), it runs under both MPI and OpenMP. The length of subroutines has been reduced to make the code more manageable and easier to read.

C2-Ray3Dm1D_Helium is the hydrogen + helium version of the radiative transfer photo-ionization code C²-Ray. It combines the 1D and 3D versions of the code.

pyC²Ray updates C²-Ray (ascl:2312.022), an astrophysical radiative transfer code used to simulate the Epoch of Reionization (EoR). pyC²Ray includes a new raytracing method, ASORA, developed for GPUs, and provides a Python interface for customizable use of the code. The core features of C²-Ray, written in Fortran90, are wrapped using f2py as a Python extension module, while the raytracing library ASORA is implemented in C++ using CUDA. Both are native Python C-extensions and can be directly accessed from any Python script.

CloudFlex models observational signatures associated with the small-scale structure of the circumgalactic medium. It populates cool gas structures in the CGM as a complex of cloudlets using a Monte Carlo method. Various parameters can be set to describe the structure of the cloudlet complexes, including cloudlet mass, density, velocity, and size. Functionality exists for generating the observational signatures of sightlines piercing these cloudlet complexes, borrowing heavily from the Trident code (ascl:1612.019).

galclaim identifies association between astrophysical transient sources and host galaxy. This association is made by estimating the chance alignment between a given transient sky localization and nearby galaxies. The code can be used with various catalogs, including Pan-STARRS, HSC, AllWISE and GLADE. galclaim also pre-checks for nearby bright galaxy using the RC3 catalog (https://heasarc.gsfc.nasa.gov/w3browse/all/rc3.html). When a nearby galaxy is found, a warning is raised and the properties of the galaxy are saved in a dedicated output file. The package can create plots displaying the computed pval for the found objects for each transient and each catalog; plots are stored in the result/plots directory.

SAGE corrects the time-dependent impact of stellar activity on transmission spectra. It uses a pixelation approach to model the stellar surface with spots and faculae, while accounting for limb-darkening and rotational line-broadening. The code can be used to evaluate stellar contamination for F to M-type hosts, test various spot sizes and locations, and quantify the impact of limb-darkening. SAGE can also retrieve the properties and distribution of active regions on the stellar surface from photometric monitoring, and connect the photometric variability to the stellar contamination of transmission spectra.

RRLFE generates and applies calibrations for retrieving [Fe/H] from low-res spectra of RR Lyrae variable stars. The code can generate a metallicity calibration anew, from real or synthetic spectra; it can also apply a metallicity calibration to low-resolution (R ~2000) RR Lyrae spectra spanning 3911 to 4950 angstroms.

matvis simulates radio interferometric visibilities at the necessary scale with both CPU and GPU implementations. It is matrix-based and applicable to wide field-of-view instruments such as the Hydrogen Epoch of Reionization Array (HERA) and the Square Kilometre Array (SKA), as it does not make any approximations of the visibility integral (such as the flat-sky approximation). The only approximation made is that the sky is a collection of point sources, which is valid for sky models that intrinsically consist of point-sources, but is an approximation for diffuse sky models. The matvix matrix-based algorithm is fast and scales well to large numbers of antennas. The code supports both CPU and GPU implementations as drop-in replacements for each other and also supports both dense and sparse sky models.

AM³ simulates lepto-hadronic interactions in astrophysical environments. It solves the time-dependent partial differential equations for the energy spectra of electrons, positrons, protons, neutrons, photons, neutrinos as well as charged secondaries (pions and muons), immersed in an isotropic magnetic field. The code accounts for the emission of photons and charged secondaries in electromagnetic and hadronic interactions feed back into the interaction rates in a time-dependent manner, therefore grasping non-linear effects including electromagnetic cascades. AM³ is computationally efficient, making it possible to scan vast source parameter scans and fit the observational data, and has been deployed to explain multi-wavelength observations from blazars, gamma-ray bursts and tidal disruption events.

gaia_tools contains codes for working with the ESA/Gaia data and related data sets (APOGEE, GALAH, LAMOST DR2, and RAVE). Written in Python, it includes tools to read catalogs, perform cross-matching, read RVS or XP spectra, and query the Gaia archive. gaia_tools also contains various matching recipes, such as matching APOGEE or APOGEE-RC to Gaia DR2, and RAVE to TGAS (taking into account the epoch difference).

RADIS resolves spectra with millions of lines within seconds on a single-CPU and can be GPU-accelerated. It supports HITRAN, HITEMP and ExoMol out-of-the-box (auto-download), and therefore is particularly suitable to compute cross-sections or transmission spectra at high-temperature. RADIS includes equilibrium calculations for all species, and non-LTE for CO2 and CO.

pycheops analyzes CHEOPS light curve data. The models in the package can also be applied to other types of data. pycheops includes a "cook book" and examples; in addition, it provides a command-line tool that aids in the preparation of observing requests for CHEOPS observers.

SubGen generates Monte-Carlo samples of dark matter subhaloes. It fully describes the joint distribution of subhaloes in final mass, infall mass, and radius; it can be used to predict derived distributions involving combinations of these quantities, including the universal subhalo mass function, the subhalo spatial distribution, the gravitational lensing profile, the dark matter annihilation radiation profile and boost factor. SubGen works only for CDM subhaloes; for an extension of the code to also work with WDM subhaloes, see SubGen2 (ascl:2312.036).

The SubGen2 subhalo population generator works for both CDM and WDM of arbitrary DM particle mass. It can be used to generate a population of subhaloes according to the joint distribution of subhalo bound mass, infall mass and halo-centric distance in a halo of a given mass. SubGen2 is an extension to SubGen (ascl:2312.035), which works only for CDM subhaloes.

tomso loads and saves input and output files for and from stellar evolution and oscillation codes. The functions are bundled together in modules that correspond with a specific stellar evolution code, stellar oscillation code, or file format. tomso supports the FGONG format and various input/output files for ADIPLS (ascl:1109.002), GYRE (ascl:1308.010), MESA (ascl:1010.083), and STARS (ascl:1107.008). tomso's main purpose is to provide a compact interface for manipulating input and output data in these formats and simplify research that uses them.

The 3-D convection code Rayleigh enables study of dynamo behavior in spherical geometry. It evolves the incompressible and anelastic MHD equations in spherical geometry using a pseudo-spectral approach. Rayleigh employs spherical harmonics in the horizontal direction and Chebyshev polynomials in the radial direction and has undergone extensive accuracy testing.

LUNA generates dynamically accurate lightcurves from a planet-moon pair, analytically accounting for shadow overlaps, stellar limb darkening, and planet-moon dynamical motion. The code takes transit timing/duration variations and ingress/egress asymmetries into consideration not only for the planet, but also the moon. LUNA was designed to be analytical and dynamical and to incorporate limb darkening (including non-linear laws) and account for all orbital elements, including eccentricity and longitude of the ascending node. Because the software is precise and analytic, LUNA is a highly potent tool for exomoon detection.

pyPETAL produces cross-correlation functions, discrete correlation functions, and mean time lags from multi-band AGN time-series data, combining multiple different codes (including pyCCF (ascl:1805.032), pyZDCF, PyROA (ascl:2107.012), and JAVELIN (ascl:1010.007)) used for active galactic nuclei (AGN) reverberation mapping (RM) analysis into a unified pipeline. This pipeline also implements outlier rejection using Damped Random Walk Gaussian process fitting, and detrending through the LinMix algorithm. pyPETAL implements a weighting scheme for all lag-producing modules, mitigating aliasing in peaks of time lag distributions between light curves. pyPETAL scales to any combination of internal code modules, supporting a variety of computational workflows.

CosmosCanvas creates perception-based color maps for different astrophysical properties such as spectral index and velocity fields. Three tutorials demonstrate how to use python code to exploit and adjust the boundaries in these divergent colour schemes. Intended to work with human physiology, each tutorial offers at least one default scheme that is monotonic in value both as a redundancy for supporting data information and an aid for colour blind viewers. This library relies on Gilles Ferrand's colourspace library.

LoSoTo (LOFAR Solution Tool) performs a variety of operations on H5parm data, which is based on the HDF5 format; it isolates direction independent systematic effects and can therefore be transferred to the target field. Subsets of data can be selected for each operation using lists of axes values, regular expressions, or intervals. The LoSoTo package stores solutions in arrays organized in a hierarchical fashion; this provides flexibility and preserves performance. The code can, for example, extract Faraday rotation from RR/LL phase solutions or a rotation matrix, clip solutions around the median, and calculate the ionospheric structure function. LoSoTo includes an outlier flagging procedure, normalizes solutions to a given value, and offers an advanced plotting routine, and many other operations.

deal.II computes solutions to partial differential equations (PDEs) using adaptive finite elements. The code provides an interface for processing PDEs accessible to both laptops and supercomputers, and has been used to investigate the local and global waveform effects of gravitational waves by numerical simulation. deal.II supports massively parallel computing of very large linear systems of equations and provides access to triangulation of various geometries of the simulation domain.

DARC (Dirac Atomic R-matrix Codes) enables the study of continuum processes for a general atomic system. The suite of programs calculate electron-atom or electron-ion collision cross-sections. In addition, the programs include code for bound-state and photoionization calculations.

harmonic learns an approximate harmonic mean estimator (referred to as a "learnt harmonic mean estimator") from posterior distribution samples to compute the marginal likelihood required for Bayesian model selection. Using a large number of independent Markov chain Monte Carlo (MCMC) chains from another package such as emcee (ascl:1303.002), harmonic uses importance sampling to learn a new target distribution in order to optimize an approximate harmonic estimator while minimizing its variance.

The Feed Forward Neural Network SYSNet models the relationship between the imaging maps, such as stellar density and the observed galaxy density field, in order to mitigate the systematic effects and to make a robust galaxy clustering measurements. The cost function is Mean Squared Error and a L2 regularization term, and the optimization algorithm is Adaptive Moment (ADAM).

Ostrich emulates surrogate models for complex and expensive functions using Principal Component Analysis (PCA) to decompose a signal, then interpolate the PCA weights over the parameters θ using a Gaussian Process interpolator. The code is trained on samples from the expensive functions, recreating and interpolating between those training samples with reduced computational cost, and recalculating for each use.

baryon-sweep produces a robust outlier rejection while simultaneously preserving the signal of the science target. The code works as a standalone solution or as a supplement to the current pipeline software. baryon-sweep creates the 2D pixel mask and mask layers, processes the sky (non-science target) spaxels, and creates a post-processed cube ready for use.

SolarKAT mitigates solar interference in MeerKAT data and recovers the visibilities rather than discarding them; this solar imaging pipeline takes 1GC calibrated data in Measurement Set format as input. Written in Python, the pipeline employs solar tracking, subtraction, and peeling techniques to enhance data quality by significantly reducing solar radio interference. This is achieved while preserving the flux measurements in the main field. SolarKAT is versatile and can be applied to general radio astronomy observations and solar radio astronomy; additionally, generated solar images can be used for weather forecasting. SolarKAT is deployed in Stimela (ascl:2305.007). It is based on existing radio astronomy software, including CASA (ascl:1107.013), breizorro (ascl:2305.009), WSclean (ascl:1408.023), Quartical (ascl:2305.006), and Astropy (ascl:1304.002).

LoRD (Locate Reconnection Distribution) identifies the locations and structures of 3D magnetic reconnection within discrete magnetic field data. The toolkit contains three main functions; the first, ARD (Analyze Reconnection Distribution) locates the grids undergoing reconnection without null points and also recognizes the local configurations of reconnection sites. ANP (Analyze Null Points) locates and classifies the 3D null points, and APNP (Analyze Projected Null Points) analyzes the 2D neutral points projected on a plane near a cell. LoRD is written in Matlab and the toolkit contains demo scripts.

maskfill inward extrapolates edge pixels just outside masked regions, using iterative median filtering and the full information contained in the edge pixels. This provides seamless transitions between masked pixels and good pixels, and allows high fidelity reconstruction of gaps in continuous narrow features. An image and a mask the only required inputs.

CRR (Convex Ridge Regularizer) takes the gradient of regularizers that are the sum of convex-ridge functions and parameterizes them using a neural network that has a single hidden layer with increasing and learnable activation functions. The neural network is trained within a few minutes as a multistep Gaussian denoiser, and offers improvements for denoising and image reconstruction over other methods with similar reliability.

QuantifAI reconstructs radio interferometric images using scalable Bayesian uncertainty quantification relying on data-driven (learned) priors. It relies on the convex accelerated optimization algorithms in CRR (ascl:2401.016) and is built on top of PyTorch. QuantifAI also includes MCMC algorithms for posterior sampling.

tidalspin uses a Bayesian approach to infer posterior distributions of a black hole's parameters (mass and spin) in an observed tidal disruption event, given a prior estimate of the black hole’s mass (e.g., from a galactic scaling relationship, or the tidal disruption event’s observed properties). These posterior distributions will only utilize the properties of tidal forces in their inference. tidalspin can be applied to the population of tidal disruption events already discovered.

StructureFunction determines the X-ray Structure Function of a population of Active Galactic Nuclei (AGN) for which two epoch X-ray observations are available and are separated by rest frame time interval. The calculation of the X-ray structure function is Bayesian. The sampling of the likelihood uses Stan (ascl:1801.003) for statistical modeling and high-performance statistical computation.

escatter.py performs Monte Carlo simulations of electron scattering events. The code was developed to better understand the emission lines from the interacting supernova SN 2021adxl, specifically the blue excess seen in the Hα 6563A emission line. escatter follows a photon that was formed in a thin interface between the supernova ejecta and surrounding material as it travels radially outwards through the dense material, scattering electrons outwards until it reaches an optically thin region, and plots a histogram of the emergent photons.

NMMA probes nuclear physics and cosmology with multimessenger analysis. This fully featured, Bayesian multi-messenger pipeline targets joint analyses of gravitational-wave and electromagnetic data (focusing on the optical). Using bilby (ascl:1901.011) as the back-end, the software uses a variety of samplers to sampling these data sets. NMMA uses chiral effective field theory based neutron star equation of states when performing inference, and is also capable of estimating the Hubble Constant.

Rfits reads and writes FITS images, tables, and headers. Written in R, Rfits works with all types of compressed images, and both ASCII and binary tables. It uses CFITSIO (ascl:1010.001) for all low level FITS IO, so in general should be as fast as other CFITSIO-based software. For images, Rfits offers fully featured memory mapping and on-the-fly subsetting (by pixel and coordinate) and sparse pixel sampling, allowing for efficient inspection of very large (larger than memory) images.

Rwcs offers access to all the projection and distortion systems of WCSLIB (ascl:1108.003) in R. This can be used directly for, for example, pixel lookups, or for higher level general distortion and projection.

CCBH-Numerics (previously called CCBH-PLPP) computes the probability of the existence of a single cosmologically coupled black hole (BH) with a formation mass below a specified threshold for given observational data of binary black holes (BBHs) from gravitational waves. The code uses the unbiased population of BBHs, as given by the power-law-plus-peak (PLPP) profile, as the observational input, and assumes that the detected BBHs are formed from stellar evolution, not primordial BHs. CCBH-Numerics also works with individual data from BBHs and for NSBH pairs as well.

MGPT (Modified Gravity Perturbation Theory) computes 2-point statistics for LCDM model, DGP and Hu-Sawicky f(R) gravity. Written in C, the code can be easily modified to include other models. Specifically, it computes the SPT matter power spectrum, SPT Lagrangian-biased tracers power spectrum, and the CLPT matter correlation function. MGPT also computes the CLPT Lagrangian-biased tracers correlation function and a set of Q and R functionsfrom which other statistics, as leading order bispectrum, can be constructed.

polarizationtools converts, analyzes, and simulates polarization data. The different python scripts (1) convert Stokes parameters into linear polarization parameters with proper treatment of the uncertainties and vice versa; (2) shift electric vector position angle (EVPA) data points in time series to account for the 180 degrees ambiguity; (3) identify rotations of the EVPA e.g. in blazar polarization monitoring data according to various rotation definitions; and (4) simulate polarization time series as a random walk in the Stokes Q-U plane.

ECLIPSR fully and automatically analyzes space based light curves to find eclipsing binaries and provide some first order measurements, such as the binary star period and eclipse depths. It provides a recipe to find individual eclipses using the time derivatives of the light curves, including eclipses in light curves of stars where the dominating variability is, for example, pulsations. Since the algorithm detects each eclipse individually, even light curves containing only one eclipse can (in principle) be successfully analyzed and classified. ECLIPSR can find eclipsing binaries among both pulsating and non-pulsating stars in a homogeneous and quick manner and process large amounts of light curves in reasonable amounts of time. The output includes, among other things, the individual eclipse markers, the period and time of first (primary) eclipse, and a score between 0 and 1 indicating the likelihood that the analyzed light curve is that of an eclipsing binary.

star_shadow automatically analyzes space based light curves of eclipsing binaries and provide a measurement of eccentricity, among other parameters. It measures the timings of eclipses using the time derivatives of the light curves, using a model of orbital harmonics obtained from an initial iterative prewhitening of sinusoids. Since the algorithm extracts the harmonics from the rest of the sinusoidal variability eclipse timings can be measured even in the presence of other (astrophysical) signals, thus determining the orbital eccentricity automatically from the light curve along with information about the other variability present in the light curve. The output includes, but is not limited to, a sinusoid plus linear model of the light curve, the orbital period, the eccentricity, argument of periastron, and inclination.

SkyLine generates mock line-intensity maps (both in 3D and 2D) in a lightcone from a halo catalog, accounting for the evolution of clustering and astrophysical properties, and observational effects such as spectral and angular resolutions, line-interlopers, and galactic foregrounds. Using a given astrophysical model for the luminosity of each line, the code paints the signal for each emitter and generates the map, adding coherently all contributions of interest. In addition, SkyLine can generate maps with the distribution of Luminous Red Galaxies and Emitting Line Galaxies.

2cosmos is a modification of Monte Python (ascl:1307.002) and allows the user to write likelihood modules that can request two independent instances of CLASS (ascl:1106.020) and separate dictionaries and structures for all cosmological and nuisance parameters. The intention is to be able to evaluate two independent cosmological calculations and their respective parameters within the same likelihood. This is useful for evaluating a likelihood using correlated datasets (e.g. mutually exclusive subsets of the same dataset for which one wants to take into account all correlations between the subsets).

Pynkowski computes Minkowski Functionals and other higher order statistics of input fields, as well as their expected values for different kinds of fields. This package supports Minkowski functionals, and maxima and minima distributions. Supported input formats include scalar HEALPix maps such as those used by healpy (ascl:2008.022) and polarization HEALPix maps in the SO(3) formalism. Pynkowski also supports various theoretical fields, including Gaussian (e.g., CMB Temperature or the initial density field), Chi squared (e.g., CMB polarization intensity), and spin 2 maps in the SO(3) formalism.

DistClassiPy uses different distance metrics to classify objects such as light curves. It provides state-of-the-art performance for time-domain astronomy, and offers lower computational requirements and improved interpretability over traditional methods such as Random Forests, making it suitable for large datasets. DistClassiPy allows fine-tuning based on scientific objectives by selecting appropriate distance metrics and features, which enhances its performance and improves classification interpretability.

kinematic_scaleheight uses MCMC methods to kinematically estimate the vertical distribution of clouds in the Galactic plane, including the least squares analysis of Crovisier (1978), an updated least squares analysis using a modern Galactic rotation model, and a Bayesian model sampled via MCMC as described in Wenger et al. (2024).

BTSbot automates real-time identification of bright extragalactic transients in Zwicky Transient Facility (ZTF) data. A multi-modal convolutional neural network, BTSbot provides a bright transient score to individual ZTF detections using their image data and 25 extracted features. The package eliminates the need for daily visual inspection of new transients by automatically identifying and requesting spectroscopic follow-up observations of new bright transient candidates. BTSbot recovers all bright transients in our test split and performs on par with human experts in terms of identification speed (on average, ∼1 hour quicker than scanners).

Poke (pronounced /poʊˈkeɪ/ or po-kay) uses commercial ray tracing APIs and open-source physical optics engines to simultaneously model scalar wavefront error, diffraction, and polarization to bridge the gap between ray trace models and diffraction models. It operates by storing ray data from a commercial ray tracing engine into a Python object, from which physical optics calculations can be made. Poke provides two propagation physics modules, Gaussian Beamlet Decomposition and Polarization Ray Tracing, that add to the utility of existing scalar diffraction models. Gaussian Beamlet Decomposition is a ray-based approach to diffraction modeling that integrates physical optics models with ray trace models to directly capture the influence of ray aberrations in diffraction simulations. Polarization Ray Tracing is a ray-based method of vector field propagation that can diagnose the polarization aberrations in optical systems.

fkpt computes the 1-loop redshift space power spectrum for tracers using perturbation theory for LCDM and Modified Gravity theories using "fk"-Kernels. Though implemented for the Hu-Sawicky f(R) modified gravity model, it is straightforward to use it for other models.

The MINDS hybrid pipeline is based on the JWST pipeline and routines from the VIP package (ascl:1603.003) for the reduction of JWST MIRI-MRS data. The pipeline compensates for some of the known weaknesses of the official JWST pipeline to improve the quality of spectrum extracted from MIRI-MRS data. This is done by leveraging the capabilities of VIP, another large data reduction package used in the field of high-contrast imaging.

The front end of the pipeline is a highly automated Jupyter notebook. Parameters are typically set in one cell at the beginning of the notebook, and the rest of the notebook can be run without any further modification. The Jupyter notebook format provides flexibility, enhanced visibility of intermediate and final results, more straightforward troubleshooting, and the possibility to easily incorporate additional codes by the user to further analyze or exploit their results.

s4cmb (Systematics For Cosmic Microwave Background) studies the impact of instrumental systematic effects on measurements of CMB experiments based on bolometric detector technology. s4cmb provides a unified framework to simulate raw data streams in the time domain (TODs) acquired by CMB experiments scanning the sky, and to inject in these realistic instrumental systematics effect.

pycorr wraps two-point counter engines such as Corrfunc (ascl:1703.003) to estimate the correlation function. It supports theta (angular), s, s-mu, rp-pi binning schemes, analytical two-point counts with periodic boundary conditions, and inverse bitwise weights (in any integer format) and (angular) upweighting. It also provides MPI parallelization and jackknife estimate of the correlation function covariance matrix.

FitCov estimates the covariance of two-point correlation functions in a way that requires fewer mocks than the standard mock-based covariance. Rather than using an analytically fixed correction to some terms that enter the jackknife covariance matrix, the code fits the correction to a mock-based covariance obtained from a small number of mocks. The fitted jackknife covariance remains unbiased, an improvement over other methods, performs well both in terms of precision (unbiased constraints) and accuracy (similar uncertainties), and requires significant less computational power. In addition, FitCov can be easily implemented on top of the standard jackknife covariance computation.

LtU-ILI (Learning the Universe Implicit Likelihood Inference) performs machine learning parameter inference. Given labeled training data or a stochastic simulator, the LtU-ILI piepline automatically trains state-of-the-art neural networks to learn the data-parameter relationship and produces robust, well-calibrated posterior inference. The package comes with a wide range of customizable complexity, including posterior-, likelihood-, and ratio-estimation methods for ILI, including sequential learning analogs, and various neural density estimators, including mixture density networks, conditional normalizing flows, and ResNet-like ratio classifiers. It offers fully-customizable, exotic embedding networks, including CNNs and Graph Neural Networks, and a unified interface for multiple ILI backends such as sbi, pydelfi, and lampe. LtU-ILI also handles multiple marginal and multivariate posterior coverage metrics, and offers Jupyter and command-line interfaces and a parallelizable configuration framework for efficient hyperparameter tuning and production runs.

Pylians3 (Python3 libraries for the analysis of numerical simulations) provides a Python 3 version of Pylians (ascl:1811.008), which analyzes numerical simulations (both N-body and hydrodynamic); parts of the codebase are also written in cython and C. It computes density fields, power spectra, bispectra, and correlation functions, identifies voids, and populates halos with galaxies using an HOD. Pylians3 also applies HI+H2 corrections to the output of hydrodynamic simulations, make 21cm maps, computes DLAs column density distribution functions, and can plot density fields and make movies.

URecon reconstructs the initial conditions of N-body simulations from late time (e.g., z=0) density fields. This simple UNET architecture is implemented in TensorFlow and requires Pylians3 (ascl:2403.012) for measuring power spectrum of density fields. The package includes weights trained on Quijote fiducial cosmology simulations.

OneLoopBispectrum computes the one-loop bispectrum of galaxies in redshift space. It computes and simplifies the bispectrum kernels using Mathematica; this is cosmology-independent. The code also computes the full and flattened bispectrum templates, given the pre-computed integration kernels. OneLoopBispectrum uses Mathematica to read in and combine the bispectrum templates, and Python to interpolate and extract the one-loop bispectrum.

CLASS-PT modifies the CLASS (ascl:1106.020) code to compute the non-linear power spectra of dark matter and biased tracers in one-loop cosmological perturbation theory, for both Gaussian and non-Gaussian initial conditions. CLASS-PT can be interfaced with the MCMC sampler MontePython (ascl:1805.027) using the (new and improved) custom-built likelihoods found here.

The DensityFieldTools toolset manipulates density fields and measures power spectra and bispectra using a very simple interface. After loading a density field, it computes the power spectrum and the bispectrum for a desired binning. The bispectrum estimator also automatically computes the power spectrum for the chosen binning, to facilitate, for example, shot-noise subtraction. DensityFieldTools also provides a quick way to measure (cross-)power spectra directly from density fields.

Obsplanning is a suite of tools to help plan astronomical observations from ground-based observatories, for traditional single-site as well as multi-station (VLBI) observing. Conveniently determine observability of objects in the sky from your observatory, and produce plots to help you prepare for your observations over the course of a session. Celestial source coordinates (including solar system objects) can be queried or created, and transformed. Calibrator or reference sources can be selected by proximity, and slew order can be optimized to save valuable telescope time. Plots and visualizations can be easily made to chart source elevation and transits, source proximity to the Sun and Moon, concurrent 'up time' of sources at multiple sites (for VLBI or tandem observations), 'dark time' at a telescope site for a given year, finder plots made from real images (with options to query online databases), and more.

cbeam models the propagation of guided light through slowly-varying few-mode waveguides using the coupled-mode theory (CMT). When compared with more general numerical methods for waveguide simulation, such as the finite-differences beam propagation method (FD-BPM), numerical implementations of the CMT can be much more computationally efficient. Written in Python and Julia, the package provides a Pythonic class structure to define waveguides, with simple classes for directional couplers and photonic lanterns already provided. cbeam also doubles as a finite-element eigenmode solver.

PIPE (PSF Imagette Photometric Extraction) extracts PSF (point-spread function) photometry from data acquired by the space telescope CHEOPS (CHaracterisation of ExOPlanetS). Advantages of PSF photometry over standard aperture photometry include reduced sensitivity to contaminants such as background stars, cosmic ray hits, and hot/bad pixels. For CHEOPS, an additional advantage is that photometry can be extracted from an imagette, a small window around the target that is downlinked at a shorter cadence than the larger-sized subarray used for aperture photometry. These advantages make PIPE particularly well suited for targets brighter or fainter than the nominal G = 7-11 mag range of CHEOPS, i.e., where short-cadence imagettes are available (bright end) or when contamination becomes a problem (faint end). Within the nominal range, PIPE usually offers no advantage over the standard aperture photometry.

KCWIKit extends the official KCWI DRP (ascl:2301.019) with a variety of stacking tools and DRP improvements. The software offers masking and median filtering scripts to be used while running the KCWI DRP, and a step-by-step KCWI_DRP implementation for finer control over the reduction process. Once the DRP has finished, KCWIKit can be used to stack the output cubes via the Montage package. Various functions cross-correlate and mosaic the constituent cubes and the final stacked cubes are WCS corrected. Helper functions can then be used to deproject the stacked cube into lower-dimensional representations should the user desire.

TAT-pulsar (Timing Analysis Toolkit for Pulsars) analyzes, processes, and visualizes pulsar data, thus handling the scientific intricacies of pulsar timing. By leveraging observational data from pulsars, along with the associated physical processes and statistical characteristics, the package integrates a suite of Python-based tools and data analysis scripts specifically developed for both isolated pulsars and binary systems. This enables swift analysis and the detailed presentation of timing properties in the high-energy pulsar field. Developed and implemented completely independently from other pulsar timing software such as Stingray (ascl:1608.001) and PINT (ascl:1902.007), TAT-pulsar serves as a valuable cross-checking and supplementary tool for data analysis.

GalMOSS performs two-dimensional fitting of galaxy profiles. This Python-based, Torch-powered tool seamlessly enables GPU parallelization and meets the high computational demands of large-scale galaxy surveys. It incorporates widely used profiles such as the Sérsic, Exponential disk, Ferrer, King, Gaussian, and Moffat profiles, and allows for the easy integration of more complex models. Tested on over 8,000 galaxies from the Sloan Digital Sky Survey (SDSS) g-band with a single NVIDIA A100 GPU, GalMOSS completed classical Sérsic profile fitting in about 10 minutes. Benchmark tests show that GalMOSS achieves computational speeds that are significantly faster than those of default implementations.

PolyBin3D estimates the binned power spectrum and bispectrum for 3D fields such as the distributions of matter and galaxies. For each statistic, two estimators are available: the standard (ideal) estimators, which do not take into account the mask, and window-deconvolved estimators. In the second case, the computation of a Fisher matrix is required; this depends on binning and the mask, but does not need to be recomputed for each new simulation. PolyBin3D supports GPU acceleration using JAX. It is a sister code to PolyBin (ascl:2307.020), which computes the polyspectra of data on the two-sphere, and is a modern reimplementation of the former Spectra-Without-Windows (ascl:2108.011) code.

WignerFamilies generates families of Wigner 3j and 6j symbols by recurrence relation. These exact methods are orders of magnitude more efficient than strategies such as prime factorization for problems which require every non-trivial symbol in a family, and are very useful for large quantum numbers. WignerFamilies is thread-safe and very fast, beating the standard Fortran routine DRC3JJ from SLATEC by a factor of 2-4.

LensIt enables CMB lensing and CMB delensing using the flat-sky approximation. The package can find the maximum posterior estimation of CMB lensing deflection maps from temperature and/or polarization maps and perform Wiener filtering of masked CMB data and allow for inhomogenous noise, including lensing deflections, using a multigrid preconditioner. It contains fast and accurate simulation libraries for lensed CMB skies, and standard quadratic estimator lensing reconstruction tools. LensIt also includes CMB internal delensing tools, including internal delensing biases calculation for temperature and/or polarization maps.

The superABC sampling method obtains cosmological constraints from supernova light curves using Approximate Bayesian Computation (ABC) without any likelihood assumptions. It provides an interface to two forward model simulations, SNCosmo (ascl:1611.017) and SNANA (ascl:1010.027), for supernova cosmology.

Panphasia computes a very large realization of a Gaussian white noise field. The field has a hierarchical structure based on an octree geometry with 50 octree levels fully populated. The code sets up Gaussian initial conditions for cosmological simulations and resimulations of structure formation. Panphasia provides an easy way to publish the linear phases used to set up cosmological simulation initial conditions; publishing phases enriches the literature and makes it easier to reproduce and extend published simulation work.

BayeSN performs hierarchical Bayesian SED modeling of type Ia supernova light curves. This probabilistic optical-NIR SED model analyzes the population distribution of physical properties as well as cosmology-independent distance estimation for individual SNe. BayeSN is built with NumPyro and Jax (ascl:2111.002) and provides support for GPU acceleration.

EffectiveHalos provides models of the real-space matter power spectrum, based on a combination of the Halo Model and Effective Field Theory, which are 1% accurate up to k = 1 h/Mpc, across a range of cosmologies, including those with massive neutrinos. It can additionally compute accurate halo count covariances (including a model of halo exclusion), both alone and in combination with the matter power spectrum.

Meanoffset performs astronomical image alignment. The code uses the means of the rows and columns of an original image for alignment and finds the optimal offset corresponding to the maximum similarity by comparing different offsets between images. The similarity is evaluated by the standard deviation of the quotient divided by the means. The code is fast and robust.

astroNN creates neural networks for deep learning using Keras for model and training prototyping while taking advantage of Tensorflow's flexibility. It contains tools for use with APOGEE, Gaia and LAMOST data, though is primarily designed to apply neural nets on APOGEE spectra analysis and predict luminosity from spectra using data from Gaia parallax with reasonable uncertainty from Bayesian Neural Net. astroNN can handle 2D and 2D colored images, and the package contains custom loss functions and layers compatible with Tensorflow or Keras with Tensorflow backend to deal with incomplete labels. The code contains demo for implementing Bayesian Neural Net with Dropout Variational Inference for reasonable uncertainty estimation and other neural nets.

EBWeyl computes the electric and magnetic parts of the Weyl tensor, Eαβ and Bαβ, using a 3+1 slicing formulation. The module provides a Finite Differencing class with 4th (default) and 6th order backward, centered, and forward schemes. Periodic boundary conditions are used by default; otherwise, a combination of the 3 schemes is available. It also includes a Weyl class that computes for a given metric the variables of the 3+1 formalism, the spatial Christoffel symbols, spatial Ricci tensor, electric and magnetic parts of the Weyl tensor projected along the normal to the hypersurface and fluid flow, the Weyl scalars and invariant scalars. EBWeyl can also compute the determinant and inverse of a 3x3 or 4x4 matrice in every position of a data box.

The Machine Learning Telescope Pointing Correction code trains and tests machine learning models for correcting telescope pointing. Using historical APEX data from 2022, including pointing corrections, and other data such as weather conditions, position and rotation of the secondary mirror, pointing offsets observed during pointing scans, and the position of the sun, among other data, the code treats the data in two different ways to test which factors are the most likely to account for pointing errors.

pyilc implements the needlet internal linear combination (NILC) algorithm for CMB component separation in pure Python; it also implements harmonic-space ILC. The code can also perform Cross-ILC, where the covariance matrices are computed only from independent splits of the maps. In addition, pyilc includes an inpainting code, diffusive_inpaint, that diffusively inpaints a masked region with the mean of the unmasked neighboring pixels.

GPUniverse models quantum fields in finite dimensional Hilbert spaces with Generalised Pauli Operators (GPOs) and overlapping degrees of freedom. In addition, the package can simulate sets of qubits that are only quasi independent (i.e., the Pauli algebras of different qubits have small, but non-zero anti-commutator), which is useful for validating analytical results for holographic versions of the Weyl field.

PySSED (Python Stellar Spectral Energy Distributions) downloads and extracts data on multi-wavelength catalogs of astronomical objects and regions of interest and automatically proceses photometry into one or more stellar SEDs. It then fits those SEDs with stellar parameters. PySSED can be run directly from the command line or as a module within a Python environment. The package offers a wide variety plots, including Hertzsprung–Russell diagrams of analyzed objects, angular separation between sources in specific catalogs, and two-dimensional offset between cross-matches.

NbodyIMRI uses N-body simulations to study Dark Matter-dressed intermediate-mass ratio inspirals (IMRI) and extreme mass ratio inspiral (EMRI) systems. The code calculates all BH-BH forces and BH-DM forces directly while neglecting DM-DM pairwise interactions. This allows the code to scale up to very large numbers of DM particles in order to study stochastic processes like dynamical friction.

cuDisc simulates the evolution of protoplanetary discs in both the radial and vertical dimensions, assuming axisymmetry. The code performs 2D dust advection-diffusion, dust coagulation/fragmentation, and radiative transfer. A 1D evolution model is also included, with the 2D gas structure calculated via vertical hydrostatic equilibrium. cuDisc requires a NVIDIA GPU.

jetsimpy creates hydrodynamic simulations of relativistic blastwaves with tabulated angular energy and Lorentz factor profiles and efficiently models Gamma-Ray Burst afterglows. It supports tabulated angular energy and tabulated angular Lorentz factor profiles. jetsimpy also supports ISM, wind, and mixed external density profile, including synthetic afterglow light curves, apparent superluminal motion, and sky map and Gaussian equivalent image sizes. Additionally, you can add your own emissivity model by defining a lambda function in a c++ source file, allowing the package to be used for more complicated models such as Synchrotron self-absorption.

mhealpy extends the functionalities of the HEALPix (ascl:1107.018) wrapper healpy (ascl:2008.022) to handle single and multi-resolution maps (a.k.a. multi-order coverage maps or MOC maps). In addition to creating and analyzes MOC maps, it supports arithmetic operations, adaptive grids, resampling of existing multi-resolution maps, and plotting, among other functions, and reads and writes to FITS, which enables sharing spatial information for multiwavelength and multimessenger analyses.

Written in Python, pAGN solves AGN disk model equations. The code is highly customizable and, with the correct inputs, provides a fully evolved AGN disk model through parametric 1D curves for key disk parameters such as temperature and density. pAGN can be used to study migration torques in AGN disks, simulations of compact object formation inside gas disks, and comparisons with new, more complex models of AGN disks.

stringgen creates emulations of cosmic string maps with statistics similar to those of a single (or small ensemble) of reference simulations. It uses wavelet phase harmonics to calculate a compressed representation of these reference simulations, which may then be used to synthesize new realizations with accurate statistical properties, e.g., 2 and 3 point correlations, skewness, kurtosis, and Minkowski functionals.

LEO-vetter automatically vets transit signals found in light curve data. Inspired by the Kepler Robovetter (ascl:2012.006), LEO-vetter computes vetting metrics to be compared to a series of pass-fail thresholds. If a signal passes all tests, it is considered a planet candidate (PC). If a signal fails at least one test, it may be either an astrophysical false positive (FP; e.g., eclipsing binary, nearby eclipsing signal) or false alarm (FA; e.g., systematic, stellar variability). Pass-fail thresholds can be changed to suit individual research purposes, and LEO-vetter produces vetting reports for manual inspection of signals. Flux-level vetting can be applied to any light curve dataset (such as Kepler, K2, and TESS), including light curves with mixes of cadences, while pixel-level vetting has been implemented for TESS.

S2FFT computes Fourier transforms on the sphere and rotation group using JAX (ascl:2111.002) or PyTorch. It leverages autodiff to provide differentiable transforms, which are also deployable on hardware accelerators (e.g., GPUs and TPUs). More specifically, S2FFT provides support for spin spherical harmonic and Wigner transforms (for both real and complex signals), with support for adjoint transformations where needed, and comes with different optimisations (precompute or not) that one may select depending on available resources and desired angular resolution L.

binary_precursor models light curves of supernova (SN) precursors powered by a pre-SN outburst accompanying accretion onto a compact object companion. Though it is only one of the possible models, it is useful for interpretations of (bright) SN precursors highly exceeding the Eddington limit of massive stars, which are observed in a fraction of SNe with dense circumstellar matter (CSM) around the progenitor. It offers a number of editable parameters, including compact object mass, progenitor mass, progenitor radii, and opacity. Initial CSM velocity can be normalized by the progenitor escape velocity (xi parameter), and the CSM mass, ionization temperature, and binary separation can also be specified.

ExoPlex is a thermodynamically self-consistent mass-radius-composition calculator. Users input a bulk molar composition and a mass or radius, and ExoPlex will calculate the resulting radius or mass. Additionally, it will produce the planet's core mass fraction, interior mineralogy and the pressure, adiabatic temperature, gravity and density profiles as a function of depth.

RhoPop identifies compositionally distinct populations of small planets (R≲2R_⊕). It employs mixture models in a hierarchical framework and the dynesty (ascl:1809.013) nested sampler for parameter and evidence estimates. RhoPop includes a density-mass grid of water-rich compositions from water mass fraction (WMF) 0-1.0 and a grid of volatile-free rocky compositions over a core mass fraction (CMF) range of 0.006-0.95. Both grids were calculated using the ExoPlex mass-radius-composition calculator (ascl:2404.029).

A fast GPU-based bispectrum estimator implemented using JAX.

We present a module built into the PypeIt Python package to reduce high resolution Y, J, H, K, and L band spectra from the W. M. Keck Observatory NIRSPEC spectrograph. This data reduction pipeline is capable of spectral extraction, wavelength calibration, and telluric correction of data taken before and after the 2018 detector upgrade, all in a single package. The procedure for reducing data is thoroughly documented in an expansive tutorial.

Swiftest is a software package designed to model the long-term dynamics of system of bodies in orbit around a dominant central body, such a planetary system around a star, or a satellite system around a planet. The main body of the program is written in Modern Fortran, taking advantage of the object-oriented capabilities included with Fortran 2003 and the parallel capabilities included with Fortran 2008 and Fortran 2018. Swiftest also includes a Python package that allows the user to quickly generate input, run simulations, and process output from the simulations. Swiftest uses a NetCDF output file format which makes data analysis with the Swiftest Python package a streamlined and flexible process for the user. Building off a strong legacy, including its predecessors Swifter and Swift, Swiftest takes the next step in modeling the dynamics of planetary systems by improving the performance and ease of use of software, and by introducing a new collisional fragmentation model. Currently, Swiftest includes the four main symplectic integrators included in its predecessors: WHM, RMVS, HELIO, and SyMBA. In addition, Swiftest also contains the Fraggle model for generating products of collisional fragmentation.

The SPEDAS (Space Physics Environment Data Analysis Software) framework supports multi-mission data ingestion, analysis and visualization for the Space Physics community. It standardizes the retrieval of data from distributed repositories, the scientific processing with a powerful set of legacy routines, the quick visualization with full output control and the graph creation for use in papers and presentations. SPEDAS includes a GUI for ease of use by novice users, works on multiple platforms, and though based on IDL, can be used with or without an IDL license. The framework supports plugin modules for multiple projects such as THEMIS, MMS, and WIND, and provides interfaces for software modules developed by the individual teams of those missions. A Python implementation of the framework, PySPEDAS (ascl:2405.005), is also available.

nessai performs nested sampling for Bayesian Inference and incorporates normalizing flows. It is designed for applications where the Bayesian likelihood is computationally expensive. nessai uses PyTorch and also supports the use of bilby (ascl:1901.011).

raynest, written in Python, computes Bayesian evidences and probability distributions using parallel chains.

pyADfit models accretion discs around astrophysical objects. The code provides functions to calculate physical quantities related to accretion disks and perform parameter estimation using observational data. The accretion disc model is the alpha-disc model while the parameter estimation can be performed with Nessai (ascl:2405.002), Raynest (ascl:2405.003), or CPnest (ascl:2205.021).

pySPEDAS (Python-based Space Physics Environment Data Analysis Software) supports multi-mission, multi-instrument retrieval, analysis, and visualization of heliophysics time series data. A Python implementation of SPEDAS (ascl:2405.001), it supports most of the capabilities of SPEDAS; it can load heliophysics data sets from more than 30 space-based and ground-based missions, coordinate transforms, interpolation routines, and unit conversions, and provide interactive access to numerous data sets. pySPEDAS also creates multi-mission, multi-instrument figures, includes field and wave analysis tools, and performs magnetic field modeling, among other functions.

ICPertFLRW, a Cactus code (ascl:1102.013) thorn, provides as initial conditions an FLRW metric perturbed with the comoving curvature perturbation Rc in the synchronous comoving gauge. Rc is defined as a sum of sinusoidals (20 in each x, y, and z direction) whose amplitude, wavelength, and phase shift are all parameters in param.ccl. While the metric and extrinsic curvature only have first order scalar perturbations, the energy density is computed exactly in full from the Hamiltonian constraint, hence vector and tensor perturbations are initially present at higher order. These are then passed to the CT_Dust thorn to be evolved.

GauPro fits a Gaussian process regression model to a dataset. A Gaussian process (GP) is a commonly used model in computer simulation. It assumes that the distribution of any set of points is multivariate normal. A major benefit of GP models is that they provide uncertainty estimates along with their predictions.

i-SPin simulates 3-component Schrodinger systems with and without gravity and with and without self-interactions while obeying SO(3) symmetry. The code allows the user to input desired parameters, along with initial conditions for the Schrodinger fields. Its three function modules then perform the main (drift-kick-drift) steps of the algorithm, track the fractional changes in total mass and spin in the system, and then plot results. The default plots are mass and spin density projections along with total mass and spin fractional changes.

morphen performs image analysis, multi-Sersic image fitting decomposition, and radio interferometric self-calibration, thus measuring basic image morphology and photometry. The code provides a state-of-the-art Python-based image fitting implementation based on the Sersic function. Geared, though not exclusively, toward radio astronomy, morphen's tools involve pure python, but also are integrated with CASA (ascl:1107.013) in order to work with common casatasks as well as WSClean (ascl:1408.023).

riddler automates fitting of type Ia supernovae spectral time series. The code is comprised of a series of neural networks trained to emulate radiative transfer simulations from TARDIS (ascl:1402.018). Emulated spectra are then fit to observations using nested sampling implemented in UltraNest (ascl:1611.001) to estimate the posterior distributions of model parameters and evidences.

DirectSHT performs direct spherical harmonic transforms for point sets on the sphere. Given a set of points, defined by arrays of theta and phi (in radians) and weights, it provides the spherical harmonic transform coefficients alm. JAX (ascl:2111.002) can be used to speed up the computation; the code will automatically fall back to numpy if JAX is not present. The code is much faster when run on GPUs. When they are available and JAX is installed, the code automatically distributes computation and memory across them.

fitramp fits a ramp to a series of nondestructive reads and detects and rejects jumps. The software performs likelihood-based jump detection for detectors read out up-the-ramp; it uses the entire set of reads to compute likelihoods. The code compares the χ² value of a fit with and without a jump for every possible jump location. fitramp can fit ramps with and without fitting the reset value (the pedestal), and fit and mask jumps within or between groups of reads. It can also compute the bias of ramp fitting.

LTdwarfIndices studies spectral indices to determine whether one or more brown dwarfs are photometric variable candidates. For a single brown dwarf, it analyzes a given set of indices and outputs the number of graphs the object appears in in the variable area, whether it is a variable or non-variable candidate, and, optionally, an index-index or histogram plot. Using another code module, LTdwarftIndices can also analyze a set of sample indices for many brown dwarfs.

EF-TIGRE (Effective Field Theory of Interacting dark energy with Gravitational REdshift) constrains interacting Dark Energy/Dark Matter models in the Effective Field Theory framework through Large Scale Structures observables. In particular, the observables include the effect of gravitational redshift, a distortion of time from galaxy clustering. This generates a dipole in the correlation function which is detectable with two distinct populations of galaxies, thus making it possible to break degeneracies among parameters of the EFT description.

sunbather simulates the upper atmospheres of exoplanets and their observational signatures. The code constructs 1D Parker wind profiles using p-winds (ascl:2111.011) to simulate these with Cloudy (ascl:9910.001), and postprocesses the output with a custom radiative transfer module to predict the transmission spectra of exoplanets.

autoregressive-bbh-inference, written in Python, models the distributions of binary black hole masses, spins, and redshifts to identify physical features appearing in these distributions without the need for strongly-parametrized population models. This allows not only agnostic study of the “known unknowns” of the black hole population but also reveals the “unknown unknowns," the unexpected and impactful features that may otherwise be missed by the standard building-block method.

AFINO (Automated Flare Inference of Oscillations) finds oscillations in time series data using a Fourier-based model comparison approach. The code analyzes the date and generates a results file in either JSON or Pickle format, which contains numerous properties of the data and analysis, and a summary plot.

coronagraph_noise simulates coronagraph noise. Written in IDL, the code includes a generalized coronagraph routine and simulators for the WFIRST Shaped Pupil Coronagraph in both spectroscopy and imaging modes. Functions available include stellar and planetary flux functions, planet photon and zodiacal light count rates, planet-star flux ratio, and clock induced charge count rate, among others. coronagraph_noise also includes routines to smooth a plot by convolving with a Gaussian profile to convolve a spectrum with a given instrument resolution and to take a spectrum that is specified at high spectral resolution and degrade it to a lower resolution. A Python implementation of coronagraph_noise, coronagraph (ascl:2405.019), is also available.

coronagraph provides a Python noise model for directly imaging exoplanets with a coronagraph-equipped telescope. Based on the original IDL code for this coronagraph model, coronograph_noise (ascl:2405.018), the Python version has been expanded in a few key ways. Most notably, the Telescope, Planet, and Star objects used for reflected light coronagraph noise modeling can now be used for transmission and emission spectroscopy noise modeling, making this model a general purpose exoplanet noise model for many different types of observations.

tapify implements a suite of multitaper spectral estimation techniques for analyzing time series data. It supports analysis of both evenly and unevenly sampled time series data. The multitaper statistic tackles the problems of bias and consistency, which makes it an improvement over the classical periodogram for evenly sampled data and the Lomb-Scargle periodogram for uneven sampling. In basic statistical terms, this estimator provides a confident look at the properties of a time series in the frequency or Fourier domain.

PALpy provides a Python interface to PAL, the positional Astronomy Library (ascl:1606.002), which is written in C. All arguments modified by the C API are returned and none are modified. The one routine that is different is palObs, which returns a simple dict that can be searched using standard Python. The keys to the dict are the short names and the values are another dict with keys name, long, lat and height.

blackthorn generates spectra of dark matter annihilations into right-handed (RH) neutrinos or into particles that result from their decay. These spectra include photons, positrons, and neutrinos. The code provides support for varied RH-neutrino masses ranging from MeV to TeV by incorporating hazma, PPPC4DMID, and HDMSpectra models to compute dark matter annihilation cross sections and mediator decay widths. blackthorn also computes decay branching fractions and partial decay widths.

raccoon implements the cross-correlation function (CCF) method. It builds weighted binary masks from a stellar spectrum template, computes the CCF of stellar spectra with a mask, and derives radial velocities (RVs) and activity indicators from the CCF. raccoon is mainly implemented in Python 3; it also uses some Fortran subroutines that are called from Python.

ndcube manipulates, inspects, and visualizes multi-dimensional contiguous and non-contiguous coordinate-aware data arrays. A sunpy (ascl:1401.010) affiliated package, it combines data, uncertainties, units, metadata, masking, and coordinate transformations into classes with unified slicing and generic coordinate transformations and plotting and animation capabilities. ndcube handles data of any number of dimensions and axis types (e.g., spatial, temporal, and spectral) whose relationship between the array elements and the real world can be described by World Coordinate System (WCS) translations.

CosmoPower develops Bayesian inference pipelines that leverage machine learning to solve inverse problems in science. While the emphasis is on building algorithms to accelerate Bayesian inference in cosmology, the implemented methods allow for their application across a wide range of scientific fields. CosmoPower provides neural network emulators of matter and Cosmic Microwave Background power spectra, which can replace Boltzmann codes such as CAMB (ascl:1102.026) or CLASS (ascl:1106.020) in cosmological inference pipelines, to source the power spectra needed for two-point statistics analyses. This provides orders-of-magnitude acceleration to the inference pipeline and integrates naturally with efficient techniques for sampling very high-dimensional parameter spaces.

GAStimator implements a Python MCMC Gibbs-sampler with adaptive stepping. The code is simple, robust, and stable and well suited to high dimensional problems with many degrees of freedom and very sharp likelihood features. It has been used extensively for kinematic modeling of molecular gas in galaxies, but is fully general and may be used for any problem MCMC methods can tackle.

Scaling Relations Finder finds the scaling relations between magnetic field properties and observables for a model of galactic magnetic fields. It uses observable quantities as input: the galaxy rotation curve, the surface densities of the gas, stars and star formation rate, and the gas temperature to create galactic dynamo models. These models can be used to estimate parameters of the random and mean components of the magnetic field, as well as the gas scale height, root-mean-square velocity and the correlation length and time of the interstellar turbulence, in terms of the observables.

SMART (Spectral energy distributions Markov chain Analysis with Radiative Transfer models) implements a Bayesian Markov chain Monte Carlo (MCMC) method to fit the ultraviolet to millimeter spectral energy distributions (SEDs) of galaxies exclusively with radiative transfer models. The models constitute four types of pre-computed libraries, which describe the starburst, active galactic nucleus (AGN) torus, host galaxy and polar dust components.

candl (CMB Analysis With A Differentiable Likelihood) analyzes CMB power spectrum measurements using a differentiable likelihood framework. It is compatible with JAX (ascl:2111.002), though JAX is optional, allowing for fast and easy computation of gradients and Hessians of the likelihoods, and candl provides interface tools for working with other cosmology software packages, including Cobaya (ascl:1910.019) and MontePython (ascl:1805.027). The package also provides auxiliary tools for common analysis tasks, such as generating mock data, and supports the analysis of primary CMB and lensing power spectrum data.

Lenser estimates weak gravitational lensing signals, particularly flexion, from real survey data or realistically simulated images. Lenser employs a hybrid of image moment analysis and an Analytic Image Modeling (AIM) analysis. In addition to extracting flexion measurements by fitting a (modified Sérsic) model to a single image of a galaxy, Lenser can do multi-band, multi-epoch fitting. In multi-band mode, Lenser fits a single model to multiple postage stamps, each representing an exposure of a single galaxy in a particular band.

The anzu package offers two independent codes for hybrid Lagrangian bias models in large-scale structure. The first code measures the hybrid "basis functions"; the second takes measurements of these basis functions and constructs an emulator to obtain predictions from them at any cosmology (within the bounds of the training set). anzu is self-contained; given a set of N-body simulations used to build emulators, it measures the basis functions. Alternatively, given measurements of the basis functions, anzu should in principle be useful for constructing a custom emulator.

CARDiAC (Code for Anisotropic Redshift Distributions in Angular Clustering) computes the impact of anisotropic redshift distributions on a wide class of angular clustering observables. It supports auto- and cross-correlations of galaxy samples and cosmic shear maps, including galaxy-galaxy lensing. The anisotropy can be present in the mean redshift and/or width of Gaussian distributions, as well as in the fraction of galaxies in each component of multi-modal distributions. Templates of these variations can be provided by the user or simulated internally within the code.

sphereint calculates the numerical volume in a sphere. It provides a weight for each grid position based on whether or not it is in (weight = 1), out (weight = 0), or partially in (weight in between 0 and 1) a sphere of a given radius. A cubic cell is placed around each grid position and the volume of the cell in the sphere (assuming a flat surface in the cell) is calculated and normalized by the cell volume to obtain the weight.

CBiRd (Code for Bias tracers In Redshift space) provides correlators in the Effective Field Theory of Large-Scale Structure (EFTofLSS) in a ready-to-use pipeline for cosmological analysis of galaxy-redshift surveys data. It provides a core calculation package (C++BiRd), a Python implementation of a Taylor expansion of the power spectrum around a reference cosmology for efficient evaluation (TBiRd), and libraries to correct for observational systematics. CBiRd also provides MCMC samplers (MCBiRd) for a power spectrum and bispectrum analysis of galaxy-redshift surveys data based on emcee (ascl:1303.002), and can provide an earlybird pass to explore the cosmos with LSS surveys.

PRyMordial offers fast and precise evaluation of both the Big Bang Nucleosynthesis (BBN) light-element abundances and the effective number of relativistic degrees of freedom. It can be used within and beyond the Standard Model. The package calculates N_eff and helium-4, deuterium, helium-3 and lithium-7 abundances. PRyMordial corrects for QED plasma effects, neutron lifetime, and incomplete neutrino decoupling, and includes an optional module that re-elaborates all the ODE systems of the code in Julia.

Color transformations calculator determines the magnitude of a galaxy in a needed photometric band, given its color and magnitude in the original band. It supports various optical and near intrared surveys, including SDSS, DECaLS, DELVE, UKIDSS, VHS, and VIKING, and provides conversions for both total and aperture magnitudes with apertures of 1.5", 2" or 3" diameters. The source code, useful for performing bulk calculations, is available in Python and IDL; the calculator is also offered as a web service.

Quadratic Monte Carlo generates ensembles of models and confines fitness landscapes without relying on linear stretch moves; it works very efficiently for ring potential and Rosenbrock density. The method is general and can be implemented into any existing MC software, requiring only a few lines of code.

The ALeRCE anomaly detector cross-validates six anomaly detection algorithms for three classes (transient, periodic, and stochastic) of anomalous sources within the Zwicky Transient Facility (ZTF) data stream using the ALeRCE light curve features. A machine and deep learning-based framework is used for anomaly detection. For each class, a distinct anomaly detection model is constructed using only information about the known objects (i.e., inliers) for training. An anomaly score is computed using the probabilities to determine whether the light curve corresponds to a transient, stochastic, or periodic nature.

EVA (Excess Variability-based Age) computes the VarX values and VarX90 ages for a given list of stars. The package retrieves information from Gaia, performs basic var90 calculations, then calculates the age of the group in a given band or overall (by combining all three bands). EVA then analyzes and plots the results.

FLORAH generates the assembly history of halos using a recurrent neural network and normalizing flow model. The machine-learning framework can be used to combine multiple generated networks that are trained on a suite of simulations with different redshift ranges and mass resolutions. Depending on the training, the code recovers key properties, including the time evolution of mass and concentration, and galaxy stellar mass versus halo mass relation and its residuals. FLORAH also reproduces the dependence of clustering on properties other than mass, and is a step towards a machine learning-based framework for planting full merger trees.

BiaPy provides deep-learning workflows for a large variety of image analysis tasks, including 2D and 3D semantic segmentation, instance segmentation, object detection, image denoising, single image super-resolution, self-supervised learning and image classification. Though developed specifically for bioimages, it can be used for watershed-based instance segmentation for friends-of-friends proto-haloes.

ytree reads and works with merger tree data from multiple formats. An extension of yt (ascl:1011.022), which can analyze snapshots from cosmological simulations, ytree can be thought of as the yt of merger trees. ytree's online documentation lists supported formats; support for additional formats can be added, as in principle, any type of tree-like data where an object has one or more ancestors and a single descendant can be supported.

SuperLite produces synthetic spectra for astrophysical transient phenomena affected by circumstellar interaction. It uses Monte Carlo methods and multigroup structured opacity calculations for semi-implicit, semirelativistic radiation transport in high-velocity shocked outflows, and can reproduce spectra of typical Type Ia, Type IIP, and Type IIn supernovae. SuperLite also generates high-quality spectra that can be compared with observations of transient events, including superluminous supernovae, pulsational pair-instability supernovae, and other peculiar transients.

Magnification bias estimation estimates magnification bias for a galaxy sample with a complex photometric selection for the example of SDSS BOSS. The code works for CMASS and the LOWZ, z1 and z3 samples. A template for applying the approach to other surveys is included; requirements include a galaxy catalog that provides magnitudes (used for photometric selection) and the exact conditions used for the photometric selection.

LeHaMoC simulates high-energy astrophysical sources. It simulates the behavior of relativistic pairs, protons interacting with magnetic fields, and photons in a spherical region. The package contains numerous physical processes, including synchrotron emission and self-absorption, inverse Compton scattering, photon-photon pair production, and adiabatic losses. It also includes proton-photon pion production, proton-photon (Bethe-Heitler) pair production, and proton-proton collisions. LeHaMoC can model expanding spherical sources with a variable magnetic field strength. In addition, three types of external radiation fields can be defined: grey body or black body, power-law, and tabulated.

Photochem models the photochemical and climate composition of a planet's atmosphere. It takes inputs such as the stellar UV flux and atmospheric temperature structure to find the steady-state chemical composition of an atmosphere, or evolve atmospheres through time. Photochem also contains 1-D climate models and a chemical equilibrium solver.

Phazap post-processes gravitational-wave (GW) parameter estimation data to obtain the phases and polarization state of the signal at a given detector and frequency. It is used for low-latency identification of strongly lensed gravitational waves via their phase consistency by measuring their distance in the detector phase space. Phazap builds on top of the IGWN conda enviroment which includes the standard GW packages LALSuite (ascl:2012.021) and bilby (ascl:1901.011), and can be applied beyond lensing to test possible deviations in the phase evolution from modified theories of gravity and constrain GW birefringence.

This python code automatically detects solar active regions (AR). Based on morphological operation and region growing, it uses synoptic magnetograms from SOHO/MDI and SDO/HMI and calculates the parameters that characterize each AR, including the latitude and longitude of the flux-weighted centroid of two polarities and the whole AR, the area, and the flux of each polarity, and the initial and final dipole moments.

GRINN (Gravity Informed Neural Network) solves the coupled set of time-dependent partial differential equations describing the evolution of self-gravitating flows in one, two, and three spatial dimensions. It is based on physics informed neural networks (PINNs), which are mesh-free and offer a fundamentally different approach to solving such partial differential equations. GRINN has solved for the evolution of self-gravitating, small-amplitude perturbations and long-wavelength perturbations and, when modeling 3D astrophysical flows, provides accuracy on par with finite difference (FD) codes with an improvement in computational speed.

PowerSpecCovFFT computes the non-Gaussian (regular trispectrum and its shot noise) part of the analytic covariance matrix of the redshift-space galaxy power spectrum multipoles using an FFTLog-based method. The galaxy trispectrum is based on a tree-level standard perturbation theory but with a slightly different galaxy bias expansion. The code computes the non-Gaussian covariance of the power spectrum monopole, quadrupole, hexadecapole, and their cross-covariance up to kmax ~ 0.4 h/Mpc.

Faceted-HyperSARA images radio-interferometric wideband intensity data. Written in MATLAB, the library offers a collection of utility functions and scripts from data extraction from an RI measurement set MS Table to the reconstruction of a wideband intensity image over the field of view and frequency range of interest. The code achieves high precision imaging from large data volumes and supports data dimensionality reduction via visibility gridding and estimation of the effective noise level when reliable noise estimates are not available. Faceted-HyperSASA also corrects the w-term via w-projection and incorporates available compact Fourier models of the direction dependent effects (DDEs) in the measurement operator.

The phi-GPU (Parallel Hermite Integration on GPU) high-order N-body parallel dynamic code uses the fourth-order Hermite integration scheme with hierarchical individual block time-steps and incorporates external gravity. The software works directly with GPU, using only NVIDIA GPU and CUDA code. It creates numerical simulations and can be used to study galaxy and star cluster evolution.

Redback provides end-to-end interpretation and parameter estimation of electromagnetic transients. Using data downloaded by the code or provided by the user, the code processes the data into a homogeneous transient object. Redback implements several different types of electromagnetic transients models, ranging from simple analytical models to numerical surrogates, fits models implemented in the package or provided by the user, and plots lightcurves. The code can also be used as a tool to simulate realistic populations without having to fit anything, as models are implemented as functions and can be used to simulate populations. Redback uses Bilby (ascl:1901.011) for sampling and can easily switch samplers and likelihoods.

AutoPhOT (AUTOmated Photometry Of Transients) produces publication-quality photometry of transients quickly. Written in Python 3, this automated pipeline's capabilities include aperture and PSF-fitting photometry, template subtraction, and calculation of limiting magnitudes through artificial source injection. AutoPhOT is also capable of calibrating photometry against either survey catalogs (e.g., SDSS, PanSTARRS) or using a custom set of local photometric standards.

Exovetter is an open-source, pip-installable python package which calculates metrics on high cadence time series photometry to distinguish between exoplanet transit signals and false positives. The package standardizes the implementation of metrics developed for the TESS, Kepler, and K2 missions such as Odd-Even, Multiple Event Statistic, and Centroid Offset (see “Planetary Candidates Observed by Kepler. VIII.”, Thompson et al. 2018.). Metrics can be run individually or together as part of a pipeline. Exovetter also includes several visualizations to further evaluate the transits and metrics.

WinNet, a single zone nuclear reaction network, calculates many different nucleosynthesis processes, including r-process, nup-process, and explosive nucleosynthesis, and many more). It reads in a user-defined file with runtime parameters, then chooses the evolution mode, which is dependent on temperature. The temperature, density, and neutrino quantities are updated, after which the reaction network equations are solved numerically. If convergence is not achieved, the step size is halved and the iteration is repeated. Once convergence is reached, the output is generated and the time is evolved; the final output such as the final abundances and mass fractions are written.

MAKEE (MAuna Kea Echelle Extraction) reduces data from the HIRES and ESI instruments at Keck Observatory. It is optimized for the spectral extraction of single, unresolved point sources and is designed to run non-interactively using a set of default parameters. Taking the raw HIRES FITS files as input, the code determines the position (or trace) of each echelle order, defines the object and background extraction boundaries, optimally extracts a spectrum for each order, and computes wavelength calibrations. MAKEE produces FITS format "spectral images" (each row is a separate echelle order spectrum) and the data values are in arbitrary (relative) flux units. MAKEE will reduce data from all HIRES formats, including the single CCD format, the single CCD with Red and UV cross dispersers, and the current 3 CCD system. It can handle a variety of pixel binnings, including 1x1, 1x2, 1x4 (column x row).

Python Fully Automated TiRiFiC (pyFAT) wraps around the tilted ring fitting code (TiRiFiC, ascl:1208.008) to fully automate the process of fitting simple tilted ring models to line emission cubes. pyFAT is the successor to the IDL/GDL FAT (ascl:1507.011) code and offers improved handling and fitting as well as several new features. PyFAT fits simple rotationally symmetric discs with asymmetric warps and surface brightness distributions, providing a base model that can can be used in TiRiFiC to explore large scale motions. pyFAT delivers much more control over the fitting procedure, which is made possible by the new modular setup and the use of omegaconf for the input and default settings.

pycosie is analysis code used for Technicolor Dawn (TD), a Gadget-3 derived cosmological radiative SPH simulation suite. The target analyses are to complement what is done with TD and other analysis software in its suite. pycosie creates power spectrum from generated Lyman-alpha forests spectra, links absorbers to potential host galaxies, grids gas information for each galaxy, and reads specific output files from software such as Rockstar (ascl:1210.008) and SKID (ascl:1102.020).

Forklens measures weak gravitational lensing signal using a deep-learning methoe. It measures galaxy shapes (shear) and corrects the smearing of the point spread function (PSF, an effect from either/both the atmosphere and optical instrument). It contains a custom CNN architecture with two input branches, fed with the observed galaxy image and PSF image, and predicts several features of the galaxy, including shape, magnitude, and size. Simulation in the code is built directly upon GalSim (ascl:1402.009).

BaCoN (BAyesian COsmological Network) trains and tests Bayesian Convolutional Neural Networks in order to classify dark matter power spectra as being representative of different cosmologies, as well as to compute the classification confidence. It supports the following theories: LCDM, wCDM, f(R), DGP, and a randomly generated class. Additional cosmologies can be easily added.

provabgs infers full posterior distributions of galaxy properties for galaxies in the DESI Bright Galaxy Survey using state-of-the-art Bayesian spectral energy distribution (SED) modeling of DESI spectroscopy and photometry. provabgs includes a state-of-the-art stellar population synthesis (SPS) model based on non-parametric prescription for star formation history, a metallicity history that varies over the age of the galaxy, and a flexible dust prescription. It has a neural network emulator for the SPS model that enables accelerated inference. Full posteriors of the 12 SPS parameters can be derived in ~10 minutes. The emulator is currently designed for galaxies from 0 < z < 0.6. provabgs also includes a Bayesian inference pipeline that is based on zeus (ascl:2008.010).

GRDzhadzha evolves matter on curved spacetimes with an analytic time and space dependence. Written in C++14, it uses hybrid MPI/OpenMP parallelism to achieve good performance. The code is based on publicly available 3+1D numerical relativity code GRChombo (ascl:2306.039) and inherits all of the capabilities of the main GRChombo code, which uses the Chombo library for adaptive mesh refinement.

RealSim generates survey-realistic synthetic images of galaxies from hydrodynamical simulations of galaxy formation and evolution. The main functionality of this code inserts "idealized" simulated galaxies into Sloan Digital Sky Survey (SDSS) images in such a way that the statistics of sky brightness, resolution, and crowding are matched between simulated galaxies and observed galaxies in the SDSS. The suite accepts idealized synthetic images in calibrated AB surface brightnesses and rebins them to the desired redshift and CCD angular scale; RealSim can add Poisson noise, if desired, by adopting generic values of photometric calibrations in survey fields. Images produced by the suite can be inserted into real image fields to incorporate real skies, PSF degradation, and contamination by neighboring sources in the field of view. The RealSim methodology can be applied to any existing galaxy imaging survey.

ATM (Asteroid Thermal Modeling) models asteroid flux measurements to estimate an asteroid's size, surface temperature distribution, and emissivity, and creates model spectral energy distributions for the different thermal models. After downloading lookup tables for relevant models, it can also fit observations of asteroids.

UFalcon rapidly post-processes N-body code output into signal maps for many different cosmological probes. The package is able to produce maps of weak-lensing convergence, linear-bias galaxy over-density, cosmic microwave background (CMB) lensing convergence and the integrated Sachs-Wolfe temperature perturbation given a set of N-body lightcones. It offers high flexibility for lightcone construction, such as user-specific survey-redshift ranges, redshift distributions and single-source redshifts. UFalcon also computes the galaxy intrinsic alignment signal, which can be treated as an additive component to the cosmological signal.

bigfile stores data from cosmology simulations from HPC systems and beyond. It provides a hierarchical structure of data columns via File, Dataset and Column. A Column stores a two dimensional table. Numerical typed columns are supported; attributes can be attached to a Column and both numerical attributes and string attributes are supported. Type casting is performed on-the-fly if read/write operations request a different data type than the file has stored.

Fof uses the friends-of-friends method to find groups. A particle belongs to a friends-of-friends group if it is within some linking length of any other particle in the group. After all such groups are found, those with less than a specified minimum number of group members are rejected. The program takes input files in the TIPSY (ascl:1111.015) binary format and produces a single ASCII output file called fof.grp. This output file is in the TIPSY array format and contains the group number to which each particle belongs. A group number of zero means that the particle does not belong to a group. The fof.grp file can be read in by TIPSY and used to color each particle by group number to visualize the groups. Simulations with periodic boundary conditions can also be handled by fof by specifying the period in each dimension on the command line.

cola_halo generates hundreds of realizations on the fly. This parallel cosmological N-body simulation code generates random Gaussian initial condition using 2LPTIC (ascl:1201.005), time evolves N-body particles with colacode (ascl:1602.021), and finds dark-matter halos with the Friends-of-Friends code (ascl:2407.012).

PFFT computes massively parallel, fast Fourier transformations on distributed memory architectures. PFFT can be understood as a generalization of FFTW-MPI (ascl:1201.015) to multidimensional data decomposition; in fact, using PFFT is very similar to FFTW. The library is written in C and MPI; a Fortran interface is also available.

AstroCLIP performs contrastive pre-training between two different kinds of astronomical data modalities (multi-band imaging and optical spectra) to yield a meaningful embedding space which captures physical information about galaxies and is shared between both modalities. The embeddings can be used as the basis for competitive zero- and few-shot learning on a variety of downstream tasks, including similarity search, redshift estimation, galaxy property prediction, and morphology classification.

Flash-X simulates physical phenomena in several scientific domains, primarily those involving compressible or incompressible reactive flows, using Eulerian adaptive mesh and particle techniques. It derives some of its solvers from and is a descendant of FLASH (ascl:1010.082). Flash-X has a new framework that relies on abstractions and asynchronous communications for performance portability across a range of heterogeneous hardware platforms, including exascale machines. It also includes new physics capabilities, such as the Spark general relativistic magnetohydrodynamics (GRMHD) solver, and supports interoperation with the AMReX mesh framework, the HYPRE linear solver package, and the Thornado neutrino radiation hydrodynamics package, among others.

Heimdall uses direct, tree, and sub-band dedispersion algorithms on massively parallel computing architectures (GPUs) to speed up real-time detection of radio pulsar and other transient events.

ELISA is a Python library designed for efficient spectral modeling and robust statistical inference. With user-friendly interface, ELISA streamlines the spectral analysis workflow.

The modeling framework of ELISA is flexible, allowing users to construct complex models by combining models of ELISA and XSPEC, as well as custom models. Parameters across different model components can also be linked. The models can be fitted to the spectral datasets using either Bayesian or maximum likelihood approaches. For Bayesian fitting, ELISA incorporates advanced Markov Chain Monte Carlo (MCMC) algorithms, including the No-U-Turn Sampler (NUTS), nested sampling, and affine-invariant ensemble sampling, to tackle the posterior sampling problem. For maximum likelihood estimation (MLE), ELISA includes two robust algorithms: the Levenberg-Marquardt algorithm and the Migrad algorithm from Minuit. The computation backend is based on Google's JAX, a high-performance numerical computing library, which can reduce the runtime for fitting procedures like MCMC, thereby enhancing the efficiency of analysis.

After fitting, goodness-of-fit assessment can be done with a single function call, which automatically conducts posterior predictive checks and leave-one-out cross-validation for Bayesian models, or parametric bootstrap for MLE. These methods offer greater accuracy and reliability than traditional fit-statistic/dof measures, and thus better model discovery capability. For comparing multiple candidate models, ELISA provides robust Bayesian tools such as the Widely Applicable Information Criterion (WAIC) and the Leave-One-Out Information Criterion (LOOIC), which are more reliable than AIC or BIC. Thanks to the object-oriented design, collecting the analysis results should be simple. ELISA also provide visualization tools to generate ready-for-publication figures.

ELISA is an open-source project and community contributions are welcome and greatly appreciated.

The photGalIMF code calculates the evolution of stellar mass and luminosity for a galaxy model, based on the PARSEC stellar evolution model (ascl:1502.005). It requires input lists specifying the age, mass, metallicity, and initial mass function (IMF) of single stellar populations. These input parameters can be provided by the companion galaxy chemical simulation code GalIMF (ascl:1903.010), which generates realistic sets of inputs.

pony3d statistically identifies islands of contiguous emission inside a three-dimensional volume. The primary functionality is the rapid and reliable creation of masks for the deconvolution of radio interferometric radio spectral line emission. It has been designed to run on the output of the wsclean imager (ascl:1408.023) whereby the individual FITS image per frequency plane enables a high degree of parallelism, but can work on any image set providing this criterion is met. Single channel island rejection is offered, along with 3D mask dilation and boxcar averaging. pony3d is also a prototype source-finding and extraction tool.

The High-Resolution Imaging and Spectroscopy of Exoplanets (HiRISE) instrument at the Very Large Telescope (VLT) combines the exoplanet imager SPHERE with the high-resolution spectrograph CRIRES using single-mode fibers. HiRISE has been designed to enable the characterization of known, directly-imaged planetary companions in the H band at a spectral resolution on the order of R = λ/∆λ = 140 000. The hipipe package is a custom python pipeline used to reduce the HiRISE data and produce high-level science products that can be used for astrophysical interpretation.

Package‑X instantly solves one loop Feynman integrals in full generality. Written in Mathematica and extensively tested and adopted, the package computes dimensionally regulated one-loop integrals with up to four distinct propagators of arbitrarily high rank, calculates traces of Dirac matrices in d dimensions for closed fermion loops, or carries out Dirac algebra for open fermion lines. Package‑X also generates analytic results for any kinematic configuration (e.g., at zero external momentum or physical threshold) for real masses and external invariants, provides analytic expressions for UV-divergent, IR-divergent and finite parts either separately or all together, and computes discontinuities across cuts of one-loop integrals, among other tasks.

Sharpened dimensionality reduction (SDR) sharpens original data before dimensionality reduction to create visually segregrated sample clusters. user-guided labeling. Each distinct cluster can then be labeled and used to further analyze an otherwise unlabeled data set. Written in C++, SDR scales well with large high-dimensional data.

pySDR performs local gradient clustering-based sharpened dimensionality reduction (SDR). The library uses the C++ LGCDR_v1 code as its backend.

SHARC (SHArpened Dimensionality Reduction and Classification) performs local gradient clustering-based sharpened dimensionality reduction (SDR) using neural network projections and uses these projections to make classifications. The library also contains functions for finding the optimal SDR parameters and for consolidating classification results obtained through multiple classifiers. It requires pySDR (ascl:2408.002). SHARC provides accurate and physically insightful classification of astronomical objects based on their broadband colors.

Global mm-VLBI Array (GMVA) observations are accompanied by a lot of metadata (i.e., the so-called 'ANTAB' files) that contain the system temperature (Tsys) and the gain values of the individual GMVA antennas. These data are required for the amplitude calibration of GMVA data which is an essential part in the data reduction. Unfortunately, Tsys measurements in the ANTAB files are not perfect and there are almost always erroneous values in some of the ANTAB files (particularly in the VLBA data). This could lead to incorrect results in the amplitude calibration and thus need to be corrected with proper data inspection/treatment. However, every GMVA station provides the ANTAB file in their own data format which makes the examination tricky. AntabGMVA was designed to resolve these issues and allows GMVA users to manage the GMVA ANTAB files easily and efficiently. Using AntabGMVA, one can perform extraction/inspection/visualization/correction of the Tsys data from the ANTAB files and finally generate one single ANTAB file which includes all the final products.

Sailfish simulates accreting binary systems, including binary protostars, post-AGN stellar binaries, mass-transferring X-ray binaries, and double black hole systems. The binary components are "on the grid" rather than excised, and are evolved according to the Kepler two-body problem, modified to account for gravitational wave losses or self-consistent forcing from the orbiting gas. The solvers are shock-capturing and are second order accurate in space and time. Gravity is fully Newtonian. Thermodynamics can be treated using a gamma-law equation of state with a blackbody cooling term, or in the locally isothermal approximation, in which the gas temperature is set to a constant times the local free-fall speed. Sailfish is fully Cartesian and has extensive diagnostic capabilities to facilitate accurate calculations of gas-driven orbital evolution or the extraction of electromagnetic disk signatures. The code is extremely efficient, reaching more than one billion zone updates per second on an NVIDIA A100 GPU, enabling extremely high resolution of complex flows around the binary components.

Astronify contains tools for sonifying astronomical data, specifically data series. Data series sonification takes a data table and maps one column to time, and one column to pitch. This technique is commonly used to sonify light curves, where observation time is scaled to listening time and flux is mapped to pitch. While Astronify’s sonification uses the columns “time” and “flux” by default, any two columns can be supplied and a sonification created.

Sonification extends the Astronify software (ascl:2408.005) to sonify a spatially distributed dataset. The package contains scripts to convert images into scatterplots and sonifications. The reproduce_image.py script takes an image file and reproduces it as a scatterplot by converting the input image to grayscale, extracting pixel values and generating scatter data based on these values, and then plotting the scatter data to create a visual representation of the image. The sonifications script converts the scatterplot data into an audio series and adjusts the note spacing and sonification range to customize an auditory representation. Sonification accepts images in PNG and JPG formats.

LADDER (Learning Algorithm for Deep Distance Estimation and Reconstruction) reconstructs the “cosmic distance ladder” by analyzing sequential cosmological data; it can also be applied to other sequential datasets with associated covariance information. It uses the apparent magnitude data from the Pantheon Type Ia supernovae compilation, fully incorporating covariance information to accurately predict mean values and uncertainties. It offers model-independent consistency checks for datasets such as Baryon Acoustic Oscillations (BAO) and can calibrate high-redshift datasets such as Gamma Ray Bursts (GRBs) without assuming any underlying cosmological model. Additionally, LADDER serves as a model-independent mock catalog generator for forecast-based cosmological studies.

HaloFlow uses a machine learning approach to infer Mh and stellar mass, M∗, using grizy band magnitudes, morphological properties quantifying characteristic size, concentration, and asymmetry, total measured satellite luminosity, and number of satellites.

Cue interprets nebular emission across a wide range of ionizing conditions of galaxies. The software, based on Cloudy (ascl:9910.001), emulates a neural net. It does not require a specific ionizing spectrum as a source, instead approximating the ionizing spectrum with a 4-part piece-wise power-law. Along with the flexible ionizing spectra, Cue allows freedom in [O/H], [N/O], [C/O], gas density, and total ionizing photon budget.

BELTCROSS2 calculates the closest approaches of asteroid to the mean orbits of meteoroid streams. It is especially useful to check if an asteroid, which was observed to become active, passed through a meteoroid stream, and through which stream, a short time before the beginning of the activity. The basic characteristics of the closest encounter of the asteroid with the stream are provided by BELTCROSS2.

M_SMiLe computes an approximation of the probability of magnification for a lens system consisting of microlensing by compact objects within a galaxy cluster. It specifically focuses on the scenario where the galaxy cluster is strongly lensing a background galaxy and the compact objects, such as stars, are sensitive to this microlensing effect. The microlenses responsible for this effect are stars and stellar remnants, though exotic objects such as compact dark matter candidates (including PBHs and axion mini-halos) can contribute to this effect.

RadioSED uses nested sampling to perform a Bayesian analysis of radio SEDs constructed from radio flux density measurements obtained as part of large area surveys (or in some limited cases, as part of targeted followup campaigns). It is a pure Python implementation, and is essentially a wrapper around Bilby (ascl:1901.011), the Bayesian inference library. RadioSED uses dynesty (ascl:1809.013) to perform the sampling steps, though other samplers could also be used. Users can make use of a pre-defined set of models and surveys from which to draw flux density measurements, or they can define their own models and provide their own input flux density measurements. All flux density measurements are referenced against the RACS-LOW survey, and source names and IDs from the survey catalogue are used as identifiers.

GRBoondi simulates generalized Proca fields on arbitrary analytic fixed backgrounds; it is based on the publicly available 3+1D numerical relativity code GRChombo (ascl:2306.039). GRBoondi reduces the prerequisite knowledge of numerical relativity and GRChombo in the numerical studies of generalized Proca theories. The main steps to perform a study are inputting the additions to the equations of motion beyond the base Proca theory; GRBoondi can then automatically incorporate the higher-order terms in the simulation. The code is written entirely in C++14 and uses hybrid MPI/OpenMP parallelism. GRBoondi inherits all of the capabilities of the main GRChombo code, which makes use of the Chombo library (ascl:1202.008) for adaptive mesh refinement.

21cmFirstCLASS extends 21cmFAST (ascl:1102.023) and interfaces with CLASS (ascl:1106.020) to generate initial conditions at recombination that are consistent with the input cosmological model. These initial conditions can be set during the time of recombination, allowing one to compute the 21cm signal (and its spatial fluctuations) throughout the dark ages, as well as in the proceeding cosmic dawn and reionization epochs, just as in the standard 21cmFAST. 21cmFirstCLASS tracks both the CDM density field δ_c as well as the baryons density field δ_b. In addition, the user interface in 21cmFirstCLASS has been improved and allows one to easily plot the 21cm power spectrum while including noise from the output of 21cmSense (ascl:1609.013).

SAQQARA analyzes stochastic gravitational wave background signals. This Simulation-based Inference (SBI) library is built on top of the swyft code (ascl:2302.016), which implements neural ratio estimation to efficiently access marginal posteriors for all parameters of interest. Simulation-based inference combined with implicit marginalization (over nuisance parameters) has been shown to be well suited for SGWB data analysis.

Written in Python, DarsakX is used to design and analyze the imaging performance of a multi-shell X-ray telescope with an optical configuration similar to Wolter-1 optics for astronomical purposes. It can also assess the impact of figure error on the telescope's imaging performance and optimize the optical design to improve angular resolution for wide-field telescopes. By default, DarsakX uses DarpanX (ascl:2101.015) to calculate the mirror's reflectivity.

UltraDark.jl simulates cosmological scalar fields. Written in Julia, it is inspired by PyUltraLight (ascl:1810.009) and designed to be simple to use and extend. It solves a non-interacting scalar field Gross-Pitaevskii equation coupled to Poisson's equation for gravitational potential. The scalar field describes scalar dark matter in models including ultralight dark matter, fuzzy dark matter, axion-like particles and the like. It also describes an inflaton field in the reheating epoch of the early universe.

SUSHI (Semi-blind Unmixing with Sparsity for hyperspectral images) performs non-stationary unmixing of hyperspectral images. The typical use case is to map the physical parameters such as temperature and redshift from a model with multiple components using data from hyperspectral images. Applying a spatial regularization provides more robust results on voxels with low signal to noise ratio. The code has been used on X-ray astronomy but the method can be applied to any integral field unit (IFU) data cubes.

FGCluster runs spectral clustering onto Healpix maps for parametric foreground removal, using a map encoding the feature to cluster as inputs. Pixel similarity is given by the geometrical affinity of each pixel in the sphere. FGCluster can also take an uncertainty map as an input, in which case the adjacency is modified in such a way that the pixel similarity accounts also for the statistical significance given by the pixel values in a map and the uncertainties.

MCMole3D (Monte-Carlo MOlecular Line Emission) simulates the 3D molecular cloud emission in the Milky Way. In particular, it can simulate both the unpolarized and polarized emission coming from the first rotational line of Carbon Monoxide (CO, J=1-0). MCMole3D seeks to compare the simulated emission with that observed by full sky surveys from the Planck satellite.

PICASSO (Python Inpainter for Cosmological and AStrophysical SOurces) provides a suite of inpainting methodologies to reconstruct holes on images (128x128 pixels) extracted from a HEALPIX map. Three inpainting techniques are included; these are divided into two main groups: diffusive-based methods (Nearest-Neighbors), and learning-based methods that rely on training DCNNs to fill the missing pixels with the predictions learned from a training data-set (Deep-Prior and Generative Adversarial Networks). PICASSO also provides scripts for projecting from full sky HEALPIX maps to flat thumbnails images, performing inpainting on GPUs and parallel inpainting on multiple processes, and for projecting from flat images to HEALPIX. Pretrained models are also included.

Stardust extracts galaxy properties by fitting their multiwavelength data to a set of linearly combined templates. This Python package brings three different families of templates together: 1.) UV+Optical emission from dust unobscured stellar light; 2.) AGN heated dust in the MIR; and 3.) IR dust reprocessed stellar light in the NIR-FIR. Stardust's template fitting does not rely on energy balance. As a result, the total luminosity of dust obscured and dust unobscured stellar light do not rely on each other, and it is possible to fit objects such as SMGs where the energy balance approach might not be applicable.

cloudyfsps is a Python interface between FSPS (ascl:1010.043) and Cloudy (ascl:9910.001). It compiles FSPS models for use as ionizing sources (Stellar SED grids) within Cloudy and generates Cloudy input files, single-parameter or grids of parameters. It runs Cloudy models in parallel and formats the output, which is nebular continuum and nebular line emission, for FSPS input and for explorative manipulation and plotting within Python. cloudyfsps includes pre-packaged plots for BPT diagrams (NII, SII, OI, OII) with observed data from HII regions and SDSS galaxies, and also provides comparisons with MAPPINGS III (ascl:1306.008) models.

resonances identifies mean-motion resonances of small bodies. It uses the REBOUND integrator (ascl:1110.016) and automatically identifies two-body and three-body mean-motion resonance in the Solar system. The package can be used for other possible planetary systems, including exoplanets. resonances accurately differentiates different types of resonances (pure, transient, uncertain) and provides an interface for mass tasks, such as finding resonant areas in a planetary system. The software can also plot time series and periodograms.

BeyonCE (Beyond Common Eclipsers) explores the large parameter space of eclipsing disc systems. The fitting code reduces the parameter space encompassed by the transit of circumsecondary disc (CSD) systems with azimuthally symmetric, non-uniform optical-depth profiles to constrain the size and orientation of discs with a complex sub-structure. BeyonCE does this by rejecting disc geometries that do not reproduce the measured gradients within their light curves.

ClassiPyGRB downloads, processes, visualizes, and classifies GRBs in the Swift/BAT database. Users can query light curves for any GRB and use tools to preprocess the data, including noise/duration reduction and interpolation. The package provides a set of facilities and tutorials for classifying GRBs based on their light curves using a method based on a dimensionality reduction of the data using t-Distributed Stochastic Neighbour Embedding (TSNE); results are visualized using a Graphical User Interface (GUI). ClassiPyGRB also plots and animates the results of the TSNE analysis for a deeper hyperparameter grid search.

The software framework AMReX is designed for building massively parallel block-structured adaptive mesh refinement (AMR) applications. Key features of AMReX include C++ and Fortran interfaces; 1-, 2- and 3-D support; and support for cell-centered, face-centered, edge-centered, and nodal data. The framework also supports hyperbolic, parabolic, and elliptic solves on hierarchical adaptive grid structure, optional subcycling in time for time-dependent PDEs, and parallelization via flat MPI, OpenMP, hybrid MPI/OpenMP, or MPI/MPI, and parallel I/O. AMReX supports the plotfile format with AmrVis, VisIt (ascl:1103.007), ParaView (ascl:1103.014), and yt (ascl:1011.022).

planetMagFields accesses and analyzes information about magnetic fields of planets in our solar system and visualizes them in both 2D and 3D. The code provides access to properties of a planet, such as dipole tilt, Gauss coefficients, and computed radial magnetic field at surface, and has methods to plot the field and write a vts file for 3D visualization. planetMagFields can be used to produce both 2D and 3D visualizations of a planetary field; it also provides the option of potential extrapolation.

symbolic_pofk provides simple Python functions and a Fortran90 routine for precise symbolic emulations of the linear and non-linear matter power spectra and for the conversion σ 8 ↔ A s as a function of cosmology. These can be easily copied, pasted, and modified to other languages. Outside of a tested k range, the fit includes baryons by default; however, this can be switched off.

GASTLI (GAS gianT modeL for Interiors) calculates the interior structure models for gas giants exoplanets. The code computes mass-radius curves, thermal evolution curves, and interior composition retrievals to fit a interior structure model to your mass, radius, age, and if available, atmospheric metallicity data. GASTLI can also plot the results, including internal and atmospheric profiles, a pressure-temperature diagram, mass-radius relations, and thermal evolution curves.

PyExoCross, a Python adaptation of ExoCross (ascl:1803.014), post-processes molecular line lists generated by ExoMol, HITRAN, and HITEMP and other similar initiatives. It generates absorption and emission spectra and other properties, including partition functions, specific heats, and cooling functions, based on molecular line lists. The code also calculates cross sections with four line profiles: Doppler, Gaussian, Lorentzian, and Voigt. PyExoCross can convert data format between ExoMol and HITRAN, and supports importing and exporting line lists in the ExoMol and HITRAN/HITEMP formats.

WISE2MBH uses infrared cataloged data from the Wide-field Infrared Survey Explorer (WISE) to estimate the mass of supermassive black holes (SMBH). It implements a Monte Carlo approach for error propagation, considering mean photometric errors from WISE magnitudes, errors in fits of scaling relations used and scatter of those relations, if available.

PySR performs Symbolic Regression; it uses machine learning to find an interpretable symbolic expression that optimizes some objective. Over a period of several years, PySR has been engineered from the ground up to be (1) as high-performance as possible, (2) as configurable as possible, and (3) easy to use. PySR is developed alongside the Julia library SymbolicRegression.jl, which forms the powerful search engine of PySR. Symbolic regression works best on low-dimensional datasets, but one can also extend these approaches to higher-dimensional spaces by using "Symbolic Distillation" of Neural Networks. Here, one essentially uses symbolic regression to convert a neural net to an analytic equation. Thus, these tools simultaneously present an explicit and powerful way to interpret deep neural networks.

Padé simulates protoplanetary disk hydrodynamics in cylindrical coordinates. Written in Fortran90, it is a finite-difference code and the compact 4th-order standard Padé scheme is used for spatial differencing. Padé differentiation is known to have spectral-like resolving power. The z direction can be periodic or non-periodic. The 4th order Runge-Kutta is used for time advancement. Padé implements a version of the FARGO technique to eliminate the time-step restriction imposed by Keplerian advection, and capturing of shocks that are not too strong can be done by using artificial bulk viscosity.

pyRRG measures the 2nd and 4th order moments using a TinyTim model to correct for PSF distortions. The code is invariant to the number exposures and orientation of the drizzle images. pyRRG uses a machine learning algorithm to automatically classify stars and galaxies; this can also be done manually if greater accuracy is needed.

GalCraft creates mock integral-field spectroscopic (IFS) observations of the Milky Way and other hydrodynamical/N-body simulations. It conducts all the procedures from inputting data and spectral templates to the output of IFS data cubes in FITS format. The produced mock data cubes can be analyzed in the same way as real IFS observations by many methods, particularly codes like Voronoi binning (ascl:1211.006), pPXF (ascl:1210.002), line-strength indices, or a combination of them (e.g., the GIST pipeline, ascl:1907.025). The code is implemented using Python-native parallelization. GalCraft will be particularly useful for directly comparing the Milky Way with other MW-like galaxies in terms of kinematics and stellar population parameters and ultimately linking the Galactic and extragalactic to study galaxy evolution.

The kete tools are intended to enable the simulation of all-sky surveys of solar system objects. This includes multi-body physics orbital dynamics, thermal and optical modeling of the objects, as well as field of view and light delay corrections. These tools in conjunction with the Minor Planet Centers (MPC) database of known asteroids can be used to not only plan surveys but can also be used to predict what objects are visible for existing or past surveys.

The primary goal for kete is to enable a set of tools that can operate on the entire MPC catalog at once, without having to do queries on specific objects. It has been used to simulate over 10 years of survey time for the NEO Surveyor mission using 10 million main-belt and near-Earth asteroids.

ysoisochrone is a Python3 package that handles the isochrones for young stellar objects (YSOs), and utilize isochrones to derive the stellar mass and ages. Our primary method is a Bayesian inference approach, and the Python code builds on the IDL version developed in Pascucci et al. (2016). The code estimates the stellar masses, ages, and associated uncertainties by comparing their stellar effective temperature, bolometric luminosity, and their uncertainties with different stellar evolutionary models, including those specifically developed for YSOs. User-developed evolutionary tracks can also be utilized when provided in the specific format described in the code documentation.

This paper introduces RadioSunPy, an open-source Python package developed for accessing, visualizing, and analyzing multi-band radio observations of the Sun from the RATAN-600 solar complex. The advancement of observational technologies and software for processing and visualizing spectro-polarimetric microwave data obtained with the RATAN-600 radio telescope opens new opportunities for studying the physical characteristics of solar plasma at the levels of the chromosphere and corona. These levels remain some difficult to detect in the ultraviolet and X-ray ranges. The development of these methods allows for more precise investigation of the fine structure and dynamics of the solar atmosphere, thereby deepening our understanding of the processes occurring in these layers. The obtained data also can be utilized for diagnosing solar plasma and forecasting solar activity. However, using RATAN-600 data requires extensive data processing and familiarity with the RATAN-600. The package offers comprehensive data processing functionalities, including direct access to raw data, essential processing steps such as calibration and quiet Sun normalization, and tools for analyzing solar activity. This includes automatic detection of local sources, identifying them with NOAA (National Oceanic and Atmospheric Administration) active regions, and further determining parameters for local sources and active regions. By streamlining data processing workflows, RadioSunPy enables researchers to investigate the fine structure and dynamics of the solar atmosphere more efficiently, contributing to advancements in solar physics and space weather forecasting.

pysymlog provides utilities for binning, normalizing colors, wrangling tick marks, and other tasks, in symmetric logarithm space. For numbers spanning positive and negative values, the code works in log scale with a transition through zero, down to some threshold. This is useful for representing data that span many scales such as standard log-space that include values of zero or even negative values. pysymlog provides convenient functions for creating 1D and 2D histograms and symmetric log bins, generating logspace-like arrays through zero and managing matplotlib major and minor ticks in symlog space, as well as bringing symmetric log scaling functionality to plotly.

vortex-p analyzes the velocity fields of astrophysical simulations of different natures (for example, SPH, moving-mesh, and meshless) usually spanning many orders of magnitude in scales involved. The code performs Helmholtz-Hodge decomposition (HHD); that is, it can decompose the velocity field into a solenoidal and an irrotational/compressive part Helmholtz-Hodge decomposition. vortex-p internally uses an AMR representation of the velocity field and can, in principle, capture the full dynamical range of the simulation. The package can also perform Reynolds decomposition (i.e., the decomposition of the velocity field into a bulk and a turbulent part). This is achieved by means of a multi-scale filtering of the velocity field, where the filtering scale around each point is determined by the local flow properties. vortex-p expands the vortex (ascl:2206.001) code, which had been coupled to the outputs of the MASCLET code, to a fully stand-alone tool capable of working with the outcomes of a broad range of simulation methods.

iPIC3D performs kinetic plasma simulations at magnetohydrodynamics time scales. This three-dimensional parallel code uses the implicit Particle-in-Cell method; implicit integration in time of the Vlasov–Maxwell system removes the numerical stability constraints. Written in C++, iPIC3D can be run with CUDA acceleration and supports MPI, OpenMP, and multi-node multi-GPU simulations.

BayeSED implements full Bayesian interpretation of spectral energy distributions (SEDs) of galaxies and AGNs. It performs Bayesian parameter estimation using posteriori probability distributions (PDFs) and Bayesian SED model comparison using Bayesian evidence. Its latest version BayeSED3 supports various built-in SED models and can emulate other SED models using machine learning techniques.

Forcepho infers the fluxes and shapes of galaxies from astronomical images. It models the appearance of multiple sources in multiple bands simultaneously and compares to observed data via a likelihood function. Gradients of this likelihood allow for efficient maximization of the posterior probability or sampling of the posterior probability distribution via Hamiltonian Monte Carlo. The model intrinsic galaxy shapes and positions are shared across the different bands, but the fluxes are fit separately for each band. Forcepho does not perform detection; initial locations and (very rough) parameter estimates must be supplied by the user.

measure_extinction measures extinction due to dust absorbing photons or scattering photons out of the line-of-sight. Extinction applies to the case for a star seen behind a foreground screen of dust. This package provides the tools to measure dust extinction curves using observations of two effectively identical stars, differing only in that one is seen through more dust than the other.

solar-vSI performs Monte Carlo integration of multi-body phase space efficiently. The calculation of solar antineutrino spectra from 8B decay requires the integration of five-body phase space. Though there is no simple analytical approach to this problem, recursive relations can be used to facilitate numerical evaluations.

DIRTY (DustI Radiative Transfer, Yeah!) computes the radiative transfer and dust emission from arbitrary distributions of dust illuminated by arbitrary distributions of sources (usually stars). It uses Monte Carlo methods to solve the radiative transfer problem in full 3D including non-equilibrium and equilibrium thermal dust emission. As are other similar models, DUSTY is computationally intensive; as a result, it is written in C++.

lensitbiases is an rFFT-based N1 lensing bias calculation and tests. It is tuned for TT, P-only or MV (GMV) like quadratic estimators. It performs rFFT-based N1 and N1 matrix calculations in ~ O(ms) time per lensing multipole for Planck-like config, which allows on-the-fly evaluation of the bias. It also calculates 5 rFFT's of moderate size per L for N1 TT, 20 for PP, and 45 for MV or GMV. lensitbiases is not particularly efficient for low lensing L's, since in this case one must use large boxes.

DGEM compares different computation methods for three-dimensional dust continuum radiative transfer. This simple code is based on mcpolar, translated to C++, and refactored to realize and compare radiative transfer techniques, namely Monte Carlo, Quasi-Monte-Carlo, and the Directions Grid Enumeration Method (DGEM). DGEM uses precalculated directions of the photons propagation instead of the random ones to speed up the calculations process. The code also offers a gnuplot script for plotting the resulting images.

The 1D radiative-equilibrium model Exo-REM simulates young gas giants far from their star and brown dwarfs. Fluxes are calculated using the two-stream approximation assuming hemispheric closure. The radiative-convective equilibrium is solved assuming that the net flux (radiative + convective) is conservative. The conservation of flux over the pressure grid is solved iteratively using a constrained linear inversion method. Rayleigh scattering from H2, He, and H2O, as well as absorption and scattering by clouds (calculated from extinction coefficient, single scattering albedo, and asymmetry factor interpolated from precomputed tables for a set of wavelengths and particle radii), are also taken into account.

ARK implements Computational Fluid Dynamics applications, such as Euler and all-Mach regime, on a Cartesian grid with MPI+Kokkos. It provides a performance-portable Kokkos implementation for compressible hydrodynamics and performs simulations of convection without any approximation of Boussinesq nor anelastic type. It adapts an all-Mach number scheme into a well-balanced scheme for gravity, which preserves arbitrary discrete equilibrium states up to the machine precision. The low-Mach correction in the numerical flux allows ARK to be more precise in the low-Mach regime; the code is well suited for studying highly stratified and high-Mach convective flows.

CloudCovErr.jl debiases fluxes and improves error bar estimates for photometry on top of structured filamentary backgrounds. It first estimates the covariance matrix of the residuals from a previous photometric model and then computes corrections to the estimated flux and flux uncertainties. Using an infilling technique to estimate the background and its uncertainty dramatically improves flux and flux uncertainty estimates for stars in images of fields with significant nebulosity.

Kamodo provides access to, interpolation of, and visualization of space weather models and data. The code allows model developers to represent simulation results as mathematical functions which may be manipulated directly. As the software does not generate model outputs, users must acquire the desired model outputs before these outputs can be functionalized by the software. Kamodo handles unit conversion transparently and supports interactive science discovery through Jupyter notebooks with minimal coding.

Gaspery uses the Fisher Information Matrix (FIM) to evaluate different radial velocity (RV) observing strategies; this assists observational exoplanet astronomers in constructing the observing strategy that maximizes information (or minimizes uncertainty) on the RV semi-amplitude K. The code is flexible and generalizable, however, and can maximize information on any free parameter from any model, given a time series support (x-axis).

StellarSpectraObservationFitting (SSOF) measures radial velocities and creates data-driven models (with fast, physically-motivated Gaussian Process regularization) for the time-variable spectral features for both the telluric transmission and stellar spectrum measured by Extremely Precise Radial Velocity (EPRV) spectrographs (while accounting for the wavelength-dependent instrumental line-spread function). Written in Julia, SSOF provides two methods for estimating the uncertainties on the RVs and model scores based on the photon uncertainties in the original data. For quick estimates of the uncertainties, the code looks at the local curvature of the likelihood space; the second method for estimating errors is via bootstrap resampling.

fastPTA forecasts the sensitivity of future Pulsar Timing Array (PTA) configurations and assesses constraints on Stochastic Gravitational Wave Background (SGWB) parameters. The code can generate mock PTA catalogs with noise levels compatible with current and future PTA experiments. These catalogs can then be used to perform Fisher forecasts of MCMC simulations.

Heracles manages harmonic-space statistics on the sphere. It takes catalogs of positions and function values on the sphere and turns them into angular power spectra and mixing matrices. Heracles is both a Python library, to be used in notebooks or data processing pipelines, and a tool for running measurements from the command line using a configuration file.

Falcon-DM simulates intermediate mass ratio inspirals in DM spikes. This lightweight N-body code is written in C++ and is specifically tuned for simulating IMRIs embedded in dark matter (DM) spikes. It features a 2nd order Drift-Kick-Drift integrator using the symplectic HOLD scheme and symmetrized, individual, time-steps for accurate time-integration. Falcon-DM also offers post-Newtonian (PN) effects up to PN2.5 using the auxiliary velocity algorithm.

**Finalflash** is a Python package designed for primary beam corrections of uGMRT radio interferometric images. The software uses frequency-dependent beam models and FITS file handling to improve the accuracy of radio astronomical data. It is open source and available under the MIT License. The code is hosted at https://github.com/arpan-52/Finalflash.

Mosaic characterizes the beam shape and generate efficient tilings for efficient multi-beam observations. It consists of an interferometric pattern simulator and characterizer, an optimized tiling generator, and a beamforming weights calculator. It is being used in the filter-banking beamformer in the MeerKAT telescope; more than 200 pulsars have been discovered from the multiple beam observations supported by Mosaic.

flashcurve estimates the necessary time windows for adaptive binning light curves in Fermi-LAT data using raw photon data. Fluxes coming from Gamma rays measured by the Fermi-LAT satellite are extremely variable. Gamma-ray light curves produced by flashcurve, which uses deep learning, optimally use adaptive bin sizes to retrieve information about the source dynamics and to combine gamma-ray observations in a multi-messenger perspective.

PyMerger detects binary black hole mergers from the Einstein Telescope based on a Deep Residual Neural Network (ResNet) model; the model was trained on combined data from all three proposed sub-detectors of ET (TSDCD). The model achieved high BBH detection rates. Though not trained on BNS and BHNS mergers, PyMerger successfully detected 11,477 BNS and 323 BHNS mergers in ET-MDC, indicating its potential for broader applicability.

DarkRayNet uses recurrent neural networks (RNNs) to quickly simulate antiprotons, antideuterons, protons and Helium cosmic ray (CR) spectra at Earth for an extensive range of parameters. The corresponding neural networks are trained on GALPROP (ascl:1010.028) simulations. DarkRayNet can also simulate the cosmic ray fluxes for antideuterons; the spectra can be predicted for a signal from dark matter annihilation DM Antideuterons and for secondary emission Secondary Antideuterons.

GAz calculates photometric redshifts for low redshift galaxies. It finds optimal polynomial forms to fit to data. It explores the very large space of high order polynomials while only requiring optimization of a small number of terms. Tested with the 2SLAQ LRG data set, GAz generalizes well to various data sets and redshift ranges.

HBSGSep (Hierarchical Bayesian Star-Galaxy Separations) classifies stars and galaxies photometrically by fitting templates and hierarchically learning their prior weights. The hierarchical Bayesian algorithms are unsupervised and do not use a training set nor are priors set in advance of running the algorithms; the priors for the templates are inferred from the data themselves.

EFTofPNG (Effective Field Theory of Post-Newtonian Gravity) performs high precision computations in the effective field theory of post-Newtonian (PN) Gravity, including spins. Written in Mathematica, it provides computer-algebra tools to derive analytical input for gravitational-wave source modelling relevant to current observatories. EFTofPNG has been used to derive of all currently known spin-dependent conservative interaction potentials in the post-Newtonian (PN) approximation to General Relativity (GR).

Astrocats enables astronomers to construct their own curated catalogs of astronomical data with the intention of producing shareable catalogs of that data in human-readable formats. Astrocats is used by several existing open astronomy catalogs, including the Open Supernova Catalog, Open TDE Catalog, Open Nova Catalog, and the Open Black Hole Catalog.

Pycosmicstar studies the star formation history for different cosmological models. The package contains two abstract classes, cosmology and structureabstract. The class cosmology is passed as a parameter for the classes that implement structureabstract. This approach takes polymorphism into account. The modeling of structures and star formation are not strongly dependent on the cosmology. Pycosmicstar generates a new cosmological class that implements the methods of abstract class cosmology that is useful to study, for example, the role of dark energy in the cosmic star formation rate evolution.

ReverseDiff implements methods to take gradients, Jacobians, Hessians, and higher-order derivatives of native Julia functions (or any callable object) using reverse mode automatic differentiation (AD). While performance can vary depending on the functions you evaluate, the algorithms implemented by ReverseDiff generally outperform non-AD algorithms in both speed and accuracy.

MMLPhoto-z estimates the photo-z of quasars using a cross-modal contrastive learning approach. This method employs adversarial training and contrastive loss functions to promote the mutual conversion between multi-band photometric data features (magnitude, color) and photometric image features, while extracting modality-invariant features. MMLPhoto-z can also be applied to tasks like photo-z estimation for galaxies with missing magnitudes. Overall, this method proves effective in enhancing the photo-z estimation across diverse datasets and conditions.

BSAVI (Bayesian Sample Visualizer) aids likelihood analysis of model parameters where samples from a distribution in the parameter space are used as inputs to calculate a given observable. For example, selecting a range of samples will allow you to easily see how the observables change as you traverse the sample distribution. At the core of BSAVI is the Observable object, which contains the data for a given observable and instructions for plotting it. It is modular, so you can write your own function that takes the parameter values as inputs, and BSAVI will use it to compute observables on the fly. It also accepts tabular data, so if you have pre-computed observables, simply import them alongside the dataset containing the sample distribution to start visualizing. Though BSAVI was developed for use in theoretical cosmology, it can be customized to fit a wide range of visualization needs.

NE2001p is a fully Python implementation of the NE2001 Galactic electron density model. The code forward models the dispersion and scattering of compact radio sources, including pulsars, fast radio bursts, AGNs, and masers, and the model predicts the distances of radio sources that lack independent distance measures.

Spectroflat flat fields spectro-polarimetric data. It can be plugged into existing Python-based data reduction pipelines or used as a standalone calibration and performance analysis tool. The code includes smile distortion correction and flat field extraction. The library expects the spatial domain on the vertical-axis and the spectral domain on the horizontal axis. Spectroflat does not include any file reading/writing routines and expects numpy arrays as input.

atlas-fit amends the results of spectroflat (ascl:2411.014) with calibration against a solar atlas. Data for wavelength calibration and continuum-correction is generated from flat field information and selected solar atlantes. The atlas-fit package provides two tools: one to generate a list of lines from the atlas and data to use for finding a wavelength solution (dispersion), and another to amend the calibration results from the spectroflat library.

fits_warp smoothly removes the distorting effect of the ionosphere and restores sources to their reference positions in both the catalog and image domain. Image warping uses pixel offsets derived from a catalog of cross-matched sources. Though initially written for low-frequency radio astronomy, fits_warp can be used to de-distort any image distorted by some vector field which is sampled by some sparse pierce-points.

CLASS LVDM modifies the CLASS code (ascl:1106.020) to incorporate the cosmological model of Lorentz invariance violation (LV) in gravity and dark matter. Compared to the usual CLASS code, it contains four new parameters: alpha, beta, and lambda characterize LV in the gravity sector
, and Y characterizes LV in the dark matter sector.

threedhst reduces WFC3 grism exposures. It is essentially a wrapper around aXe (ascl:1109.016) and produces a catalog and other useful files; extracted 1D spectra are placed in a single file, and 2D spectra are in individual files. The code produces an HTML table with thumbnails of the direct images, 1D, and 2D spectra and supports the pipeline Unicorn (ascl:2411.019), which produces data products from the 3D-HST grism survey of four CANDELS fields. threedhst has been superceded by Grizli (ascl:1905.001).

The Unicorn pipeline produces data products from the 3D-HST grism survey of four CANDELS fields. It extracts interlaced 2D and 1D spectra for all objects in the Skelton et al. (2014) photometric catalogs. It then fits the 2D spectra and multi-band photometry to determine redshifts and emission line strengths. Unicorn is built on threedhst (ascl:2411.018) and has been superseded by grizli (ascl:1905.001).

The spectral classification code Diagnose assigns one of four classifications (star, galaxy, quasar, or unknown) to each source and returns a redshift estimate for the galaxies and quasars and a velocity estimate for the stars. The code uses a chi-squared minimization for linear combinations of principal component templates to determine a best-fit spectral classification and redshift estimate. It computes three best-fit chi-squared values: one for stellar type and velocity, one for galaxy type and redshift, and one for a quasar and redshift. Diagnose then compares the best fit of these three reduced chi-squared values to the second best fit and evaluates the difference against a statistical threshold.

McFine performs complex, multi-component hyperfine spectra fitting in astronomical data. It turns line intensities into gas conditions using a fully automated Bayesian method. Written in Python, the code uses Markov chain Monte Carlo (MCMC) to characterize model denegeracies. It handles local thermodynamic equilibrium (LTE) and radiative-transfer (RT) models and can fit individual spectra and data cubes; given a data cube, it can also use the neighboring information to attempt a better fit. McFine also fits the minimum number of distinct components to avoid overfitting.

HIILines analytically models lines emitted by the ionized interstellar medium (ISM). It covers [OIII], [OII], H_α, and H_β lines. The strength of HIILines is its high computational efficiency. It can be used for galaxy spectroscopic survey measurement interpolations assuming a one-zone picture and galaxy line emission measurement design and forecasts. HIILines also performs post-processing of hydrodynamical galaxy formation simulations for ISM emission lines.

mochi_class extends the hi_class code (ascl:1808.010), itself a patch to the Einstein-Boltzmann solver CLASS (ascl:1106.020). It replaces α-functions by stable basis to ensure stability and takes general functions of time as input, including the dark energy equation of state or its normalized background energy-density. mochi_class provides stability test checking for mathematical (classical) instabilities in the scalar field fluctuations, and also includes a GR approximation scheme, among other new capabilities.

jaxspec performs statistical inference on X-ray spectra. It loads an X-ray spectrum (in the OGIP standard), defines a spectral model from the implemented components, and calculates the best parameters using state-of-the-art Bayesian approaches. The code is built on top of JAX (ascl:2111.002) to provide just-in-time compilation and automatic differentiation of the spectral models, enabling the use of sampling algorithms. jaxspec is written in pure Python and is not dependent on HEASoft (ascl:1408.004).

DArk Matter SPIkes (DAMSPI) analyzes dark matter spikes around Intermediate Mass Black Holes (IMBHs) in the Milky Way. It extracts an IMBH catalog with the corresponding dark matter spike parameters from EAGLE simulations to probe a potential gamma-ray signal from dark matter self-annihilation. The catalog includes, among others, the coordinates, mass, formation redshift, and spike parameters for each individual IMBH.

The numerical modeling code DustPOL-py calculates the multi-wavelength polarization degree of absorption and thermal dust emission based on Radiative Torque alignment (RAT-A), Magnetically enhanced RAT (MRAT) and Radiative Torque Disruption (RAT-D). The code saves the output files (wavelength and degree of polarization) for further analysis and is idealization for diffuse ISM, molecular clouds and star-forming regions; it also predicts the polarization spectrum for one- or two-dust layers. A web-interface GUI for DustPOL-py is also available.

DarkMatters calculates multi-frequency and multi-messenger emissions from WIMP annihilation and decay. This can be done both for standard channels and custom models, with the ability to produce surface brightnesses and integrated fluxes as well as maps in FITS format to compare to actual data. DarkMatters uses an accelerated ADI solver such as GALPROP (ascl:1010.028) for electron diffusion with an innovative sparse matrix approach. Additionally, there is the option to use a Green's function approximate solution (implemented in both C++ and Python).

SMINT (Structure Model INTerpolator) obtains posterior distributions on the H/He or H2O mass fraction of a planet; its interface is user-friendly. The parameters of the planet of interest are input with specifications on the priors that should be used. SMINT returns publication-ready plots presenting the joint parameters constraints obtained from interpolating the interior models grid of interest as well as confidence intervals for each parameter.

IcyDwarf calculates the coupled physical-chemical evolution of an icy dwarf planet or moon. The code calculates the thermal evolution of an icy planetary body (moon or dwarf planet), with no chemistry, but with rock hydration, dehydration, hydrothermal circulation, core cracking, tidal heating, and porosity; the depth of cracking and a bulk water:rock ratio by mass in the rocky core are also computed. It also calculates whether cryovolcanism is possible by the exsolution of volatiles from cryolavas. IcyDwarf also determines the equilibrium fluid and rock chemistries resulting from water-rock interaction in subsurface oceans in contact with a rocky core, up to 200ºC and 1000 bar.

NEMESISPY infers the atmospheric properties of exoplanets, such as chemical composition, using spectroscopic data. The package calculates radiative transfer using the correlated-k approximation and for parametric atmospheric modelling. NEMESISPY is a Python implementation of the well-established Fortran NEMESIS library (ascl:2210.009), which has been applied to the atmospheric retrievals of both solar system planets and exoplanets employing numerous different observing geometries.

This notebook provides a comprehensive approach for analyzing and visualizing astronomical data from FITS (Flexible Image Transport System) files, focusing on moment maps derived from molecular line emissions within the galaxy NGC 0628. The analysis involves applying various image processing techniques to handle corrupted pixels, reconstruct images, and enhance the quality of moment maps. The notebook also demonstrates how to simulate super-resolution to improve the spatial resolution of the data. By utilizing Gaussian filtering, median filtering, and contrast enhancement, the approach improves the clarity and precision of the data, making it suitable for detailed astrophysical studies. This tool serves as an efficient method for processing and visualizing large-scale astronomical datasets for further analysis and scientific interpretation.

This project presents a comprehensive spectroscopic analysis of O and B-type stars, neutron stars, and white dwarfs, with a focus on the detection of helium (He) and oxygen (O) in stellar atmospheres. By leveraging data from the Sloan Digital Sky Survey (SDSS) and utilizing tools such as Astropy, Astroquery, and Specutils, the project aims to identify key spectral lines of helium and oxygen, as well as the formation of heliox (OHe) molecules. The methodology involves querying SDSS for relevant spectral data, filtering and analyzing it based on stellar classification, and visualizing the results using advanced techniques. The findings contribute to the understanding of stellar evolution, chemical processes, and the role of these elements in various stellar classes. Additionally, the project incorporates interactive data exploration with Aladin Lite and Simbad, offering a robust framework for future astrophysical research.

Twinkle calculates and plots the stellar spectral energy distribution (SED) using empirical photometric data and stellar model grids. The code was originally created to help calculate the excess infrared (IR) flux from a star; the presence of an IR excess indicates dust orbiting the star. This dust likely results from the grinding and collisions of asteroids, influenced by a larger planetary object—pointing to the potential for finding planets. Twinkle quickly calculates the temperature and location of the dust to first order by fitting the assumed blackbody or modified blackbody function to the broadband excess emission.

Stimela2 develops data reduction workflows and is a significant update of Stimela (ascl:2305.007). Though designed for radio astronomy data, it can be adapted for other data processing applications. Stimela2 represents workflows by linear, concise and intuitive YAML-format "recipes". Atomic data reduction tasks (binary executables, Python functions and code, and CASA tasks) are described by YAML-format "cab definitions" detailing each task's "schema" (inputs and outputs). Stimela2 provides a rich syntax for chaining tasks together, and encourages a high degree of modularity: recipes may be nested into other recipes, and configuration is cleanly separated from recipe logic. Tasks can be executed natively or in isolated environments using containerization technologies such as Apptainer. Stimela2 facilitates the deployment of scalable, distributed workflows by interfacing with the Slurm scheduler and the Kubernetes API, the latter allowing workflows to be readily deployed in the cloud.

dask-ms constructs xarray datasets from CASA tables, thus providing a data access layer for Measurement Set v2.0 data. It supports the CASA Data Table System, Zarr and Apache Arrow formats, but abstracts them away from the developer at the xarray dataset level. It therefore serves as a basis for writing distributed PyData Radio Astronomy applications and supports writing variables back to the respective column in the Table. The intention behind dask-ms is to support the Measurement Set as a data source and sink for the purposes of writing parallel, distributed radio astronomy algorithms.

BADASS (Bayesian AGN Decomposition Analysis for SDSS Spectra) decomposes Sloan Digital Sky Survey (SDSS) spectra and fits Type 1 ("broad line") Active Galactic Nuclei (AGN) in the optical. The fitting process uses the Bayesian affine-invariant Markov-Chain Monte Carlo sampler emcee (ascl:1303.002) for robust parameter and uncertainty estimation, as well as autocorrelation analysis to access parameter chain convergence. Out of the box, BADASS fits SDSS spectra, and MANGA IFU cube data; the code can be modified to fit user-input spectra of any instrument.

pmwd simulates and models cosmological evolutionary history. The code includes reverse time integration in addition to traditional forward simulation, enabling symmetrical dynamics analysis using the adjoint method. The pmwd particle-mesh model supports fully-differentiable analytic, semi-analytics, and deep learning components in parallel. Based on JAX (ascl:2111.002), pmwd is optimized for PU computation.

Coport computes covariant polarized radiation transfer in any spacetime. It is particularly useful for imaging black hole accretion systems. Written in Julia, it contains functions for handling the computation of all rays and a single ray, and deriving initial ray directions. Coport also has functions for interpolating GRMHD data, obtaining covariant emission, absorption, and Faraday rotation coefficients, and projecting the polarization tensor at the observer's screen, among other tasks.

FINUFFT (Flatiron Institute Nonuniform Fast Fourier Transform) computes the three standard types of nonuniform FFT to a specified precision, in one, two, or three dimensions. It can be run on a multi-core shared-memory machine or on a GPU. It is extremely fast and has very simple interfaces to most major numerical languages (such as C/C++, Fortran, MATLAB, octave, Python, and Julia). FINUFFT also provides more advanced (vectorized and “guru”) interfaces that allow multiple strength vectors and the reuse of FFT plans.

nifty-ls evaluates the Lomb-Scargle periodogram very quickly and accurately. The Lomb-Scargle periodogram, used for identifying periodicity in irregularly-spaced observations, is useful but computationally expensive. However, when it is phrased mathematically as a pair of non-uniform FFTs (NUFFTs), FINUFFT (ascl:2412.007), which is really fast, can be leveraged to improve performance. It also enables GPU (CUDA) support and is several orders of magnitude more accurate than Astropy's (ascl:1304.002) Lomb Scargle with default settings.

Codex Africanus presents radio astronomy algorithms to the user as modular functions accepting NumPy inputs and producing NumPy outputs. Internally, it uses Numba to accelerate these codes and Dask to parallelize and distribute them. The library contains functions for plotting convolution filters and tapers associated with convolution filters and can compute the discretised direct Fourier transform (DFT) for an ideal interferometer. Codex Africanus has routines for gridding or degridding complex visibilities onto or from an image, includes deconvolution algorithms and coordinate transforms, and many other functions.

exoTEDRF (Exoplanet Transit and Eclipse Data Reduction Framework) reduces and analyzes JWST exoplanet time series observations. The code is modular and tunable, which makes it easy to run multiple reductions of a given dataset, and therefore ascertain whether the spectral features driving atmosphere inferences are robust or are sensitive to the peculiarities of a given reduction. exoTEDRF has full support for TSOs with NIRISS/SOSS and can run the ATOCA extraction algorithm (ascl:2502.016) to explicitly model the SOSS order overlap.

DIES calculates equilibrium dust temperatures and the resulting dust emission spectra. It handles spherical models (cells are spherical shells), computes dust temperatures (equilibrium temperatures only), and returns spectra for different impact parameters. The code uses the immediate re-emission method; it is not suitable for problems where the stochastic heating of the grains is important. DIES can assume constant dust properties throughout the model, and also offers an alternative script that allows dust properties to be set cell by cell. The program uses OpenCL libraries and is recommended to be run on GPUs.

CosmoFlow automatically computes cosmological correlators. The Cosmological Flow approach is based on computing cosmological correlators by solving differential equations in time governing their time evolution through the entirety of the spacetime during inflation, from their origin as quantum fluctuations in the deep past to the end of inflation. This method takes into account all physical effects at tree-level without approximation. Specifically, CosmoFlow computes the two- and three-point correlators of fields and/or conjugate momenta X a in Fourier space that includes an arbitrary number of degrees of freedom with any propagation speeds, couplings, and time-dependencies.

Spectuner identifies spectral lines of interstellar molecules automatically. The code uses XCLASS (ascl:1810.016) for the spectral line model and SciPy for the peak finder. Spectral fitting is performed using article swarm optimization and the peak matching loss function. From frequency in a unit of MHz and temperature in a unit of K, Spectuner returns the combined spectrum, identification of the combined spectrum, and the identification of all candidates.

Siril reduces reduction and improves the signal/noise ratio of an image from multiple captures. It can can align automatically or manually, and stack and enhance pictures from various file formats, even image sequence files (films and SER files). Its Graphical User Interface (GUI) allows manual processing of images in addition to scripts or typing commands. Siril provides astrometry and photometry options and performs geometric transformations in addition to many other tools.

The Payne precisely and simultaneously determines numerous stellar labels from observed spectra based on fitting physical spectral models. It fits all all labels (stellar parameters and element abundances) simultaneously, and uses spectral models where the atmosphere structure and the radiative transport are consistently calculated to reflect the stellar labels. The Payne leads to both precise and accurate estimates of stellar labels, based on physical models and without re-calibration.

WD_models transforms white dwarf (WD) photometry to physical parameters (i.e., mass, cooling age, and Teff) and vice versa, based on interpolation of existing WD atmosphere grid and cooling models. The code converts the coordinates of Gaia (and other passbands) H--R diagram into WD parameters and plots contours of WD parameters on the Gaia (and other passbands) H--R diagram. WD_models also provides tools to transform any desired WD parameters and compare the results of different WD models. In addition, the user may customize many parameters, such as the choice of cooling models and setting details of plotting.

Particle_spray models the position and velocity distributions of newly-escaped stream particles that emerge from globular clusters (GCs). Rather than computing the detailed internal cluster dynamics, which is computationally expensive, the code directly draws tracer particles from these distributions. This algorithm is fast and accurate, and is implemented in a series of notebooks for several galactic dynamics codes, including AGAMA (ascl:1805.008) and galpy (ascl:1411.008).

gwforge generates mock gravitational wave detector data using user-defined population and arbitrary detector sensitivity. The code can, for example, simulate a wide range of binary source populations by specifying parameters such as the local merger rate, distribution functions, and additional keyword arguments, and simulate coloured Gaussian or zero noise using a provided or default power spectrum to represent the detector noise. gwforge can also inject gravitational wave signal(s) into the generated detector data using the previously generated population and a chosen waveform model.

FitTeD solves time-dependent general relativistic disc equations to fit multi-band light curves and spectra. It includes relativistic optics effects such as Doppler and gravitational energy shifting, and gravitational lensing, and can include non-disc light curve and spectral components to, for example, model the early time rise and decay of tidal disruption event light curves in optical-to-UV bands. FitTeD also provides Monte Carlo Markov Chain fitting procedures that return posterior distributions of black hole and disc parameters.

Combustion Toolbox (CT) models thermodynamic properties of the gaseous species with the ideal gas equation of state (EoS). Written in MATLAB, this thermochemical code is modular and has three main modules: CT-EQUIL, CT-SD, and CT-ROCKET. CT-EQUIL computes the composition at the equilibrium of multi-component gas mixtures that undergo canonical thermochemical transformations from an initial state (reactants). CT-SD solves steady-state shock and detonation waves in either normal or oblique incidence, and CT-ROCKET computes the theoretical performance of rocket engines under highly idealized conditions. Modules can be accessed through user-friendly GUI or from MATLAB’s command line in plain code mode.

BlendingToolKit (BTK) generates images of blended objects and evaluate performance metrics on various detection, deblending and measurement algorithms. The toolkit is a convenient way to produce multi-band postage stamp images of blend scenes and evaluate the performance of deblending algorithms, as well as train samples for machine learning algorithms.

ForestFlow emulates the linear biases and small-scale deviation parameters of the 3D flux power spectrum of the Lyman-alpha forest. The parameters are modeled as a function of cosmology – the small-scale amplitude and slope of the linear power spectrum – and the physics of the intergalactic medium.

cogsworth merges rapid population synthesis and galactic dynamics together; the code can evolve a population of stars using population synthesis while self-consistently integrating their orbits with a chosen galactic potential. This enables exploration of the full evolutionary history (both stellar and orbital) of a population of stars and the ability to make predictions for present day kinematics and other distributions. cogsworth also provides tools for transforming the intrinsic populations into observables and for classifying the nature of each system.

CLOWN (CLOud Watcher at Night) detects and monitors clouds in real time. The software can be used with any type of all-sky camera even without knowing its parameters; parameters are stored instead in a configuration file. CLOWN correctly traces cloud positions in the sky and provides accurate pointing information to the observation planning of the optical telescope to avoid cloudy areas.

squishyplanet produces realistic lightcurves and phase curves of non-spherical exoplanets. The code generates models of triaxial planets; fitting for the triaxial shape can provide additional constraints on the planet’s interior properties and evolution. squishyplanet also handles complex limb darkening profiles while also accounting for the planet’s non-circular, potentially time-varying, projected shape.

The euclidlib python package is an unofficial tool designed to read products from the Euclid Consortium Science Ground Segment. Euclidlib offers user-friendly reading and writing routines, and effectively enables to work overall with Large-Scale Structure cosmological products.

The visualization tool MARDIGRAS (Mass-Radius DIaGRAm with Sliders) enables simple and intuitive manipulation of mass-radius relationships (also known as iso-composition curves) using interactive sliders. It infers composition based on mass and radius (and other parameters). As a result, it requires use of actual measurements of mass and radius; values that are upper/lower limits, derived from empirical mass-radius relations, or are somewhat controversial should not be used. MARDIGRAS screen captures can be used for general scientific communication but are not of suitable quality for article publication.

Mister plotter (mr-plotter) creates paper-quality mass-radius diagrams based on a wide range of state-of-the-art models of planetary interiors and atmospheres. It can be used to contextualize planets and infer their possible internal structures. It can also be used to search for correlations at a population level with its color-coding option based on any property collected in the NASA Exoplanet Archive, PlanetS, and Exoplanet.eu catalogs. mr-plotter can also produce article-ready two-column plots.

POSEIDON models and retrieves 1D, 2D, and 3D exoplanet transmission spectra. Given a set of observed exoplanet spectra from space-based or ground-based telescopes, the code uses Bayesian techniques to infer the atmospheric properties of the planet. POSEIDON also includes disk-integrated thermal emission and reflection spectra modeling and retrievals for both secondary eclipses and directly-imaged substellar objects.

lintsampler performs linear interpolant sampling to create a set of sample points from a density function. The code uses the evaluation of the density at the two endpoints of 1D interval, or the four corners of a 2D rectangle, or generally the 2^k vertices of a dimensional hyperbox (or a series of such hyperboxes, e.g., the cells of a k-dimensional grid) to draw random samples within the hyperbox. lintsampler works by evaluating a given PDF on the nodes of a grid (or grid-like structure, such as a tree); the number of evaluations (and memory occupancy) grows exponentially with the number of dimensions.

γ-Cascade (also called GCascade) uses a semi-analytic approach to model gamma-ray propagation through cosmological distances accounting for attenuation, the formation of electromagnetic cascades,and cosmological redshifting. V4 implements an assortment of the most widely used EBL models, significantly improves computational precision, and provides new core functionality. Additionally, GCascadeV4 uses a new method to estimate the uncertainty due to the EBL model.

easyspec is a tool designed to streamline long-slit spectroscopy, offering an intuitive framework for reducing, extracting, and analyzing astrophysical spectra.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

This repository implements an optimized XGBoost-based framework for photometric classification of Type Ia supernovae, addressing class imbalance through PR-AUC and F1-score prioritization. The approach is designed for scalability in large-scale astronomical surveys such as LSST and ensures improved classification robustness compared to traditional metrics like ROC-AUC.

exoscene simulates direct images of exoplanetary systems. Written in Python, the package has three modules. These modules can determine a planet's relative astrometry ephemeris, its phase function, and flux ratio, compute the band-integrated irradiance of a star, and accurately resample an image model array to a detector array. exoscene also offers modeling and mapping functions and has additional capabilities.

AESTRA (Auto-Encoding STellar Radial-velocity and Activity) uses deep learning for precise radial velocity measurements in the presence of stellar activity noise. The architecture combines a convolutional radial-velocity estimator and a spectrum auto-encoder. The input consists of a collection of hundreds or more of spectra of a single star, which span a variety of activity states and orbital motion phases of any potential planets. AESTRA does not require any prior knowledge about the star.

APPLESOSS (A Producer of ProfiLEs for SOSS) builds 2D spatial profiles for the first, second, and third diffraction orders for a NIRISS/SOSS GR700XD/CLEAR observation. The profiles are entirely data driven, retain a high level of fidelity to the original observations, and can be used as the specprofile reference file for ATOCA (ascl:2502.016). They can also be used as a PSF weighting for optimal extractions.

ATMOSPHERIX reads t.fits files from the Canada-France-Hawaii Telescope's near-infrared spectropolarimeter SPIRou, processes the data to remove telluric/stella contributions, and performs the correlation analysis for a given planet atmosphere template. The correlation function computes the correlation between the data and model for a grid of planet velocimetric semi-amplitude and systemic velocity. ATMOSPHERIX takes transmission spectroscopy into account and allows the user to inject a synthetic planet if desired.

Bioverse assesses the diagnostic power of a statistical exoplanet survey of the properties of nearby terrestrial exoplanets via direct imaging or transit spectroscopy. It combines Gaia-based stellar samples with Kepler-derived exoplanet demographics and a mission simulator that enables exploration of a variety of observing, follow-up, and characterization strategies. The code contains a versatile module for population-level hypothesis testing supporting trade studies and survey optimization. Bioverse supports direct imaging or transit missions, and its modularity makes it adaptable to any mission concept that makes measurements on a sample of exoplanets.

CROCODILE (CROss-COrrelation retrievals of Directly-Imaged self-Luminous Exoplanets) runs atmospheric retrievals of directly observed gas giant exoplanets by adopting adequate likelihood functions. The code makes use of petitRADTRANS (ascl:2207.014) and PyMultiNest (ascl:1606.005) and provides a statistical framework to interpret the photometry, low-resolution spectroscopy, and medium (and higher) resolution cross-correlation spectroscopy.

DIA (Delta function Difference Imaging Code) provides a difference image analysis pipeline that employs a delta-function kernel; this is useful for reducing TESS Full Frame Images. DIA's scripts are available in both Python and IDL and are nearly identical in their outputs. Together, the scripts make a pipeline that cleans and aligns images, generates a master frame by combining all available images, performs image subtraction, generates light curves, and does a basic detrending to the light curves based on magnitude. DIA can also apply bias subtraction, flat fielding, background subtraction and align images to the first image in the list.

Given mass, radius, and equilibrium temperature, ExoMDN can deliver a full posterior distribution of mass fractions and thicknesses of each planetary layer. A machine-learning model for the interior characterization of exoplanets based on Mixture Density Networks (MDN), ExoMDN is trained on a large dataset of more than 5.6 million synthetic planets below 25 Earth masses. These synthetic planets consist of an iron core, a silicate mantle, a water and high-pressure ice layer, and a H/He atmosphere. ExoMDN uses log-ratio transformations to convert the interior structure data into a form that the MDN can easily handle.

GEOCLIM.jl, written in Julia, replicates some features of the original GEOCLIM model written in Fortran. It also extends the original weathering equations WHAK and MAC, which ignore direct dependence on pCO2 and include direct pCO2 dependence respectively. The code estimates global silicate weathering rates from gridded climatology. GEOCLIM.jl estimates weathering during periods of Earth history when the continental configuration was radically different, typically more than 100 million years ago, and includes functions to compute, for example, land/ocean fraction, area-weighted average, area-weighted sum, and land mass perimeter, among other values.

Gollum performs spectral visualization and analysis. It offers both a programmatic interface and a visual interface that help users analyze stellar and substellar spectra, with support included for a set of precomputed synthetic spectral model grids.

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.

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.

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.

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.

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).

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.

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.

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.

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.