NE2001p is a fully Python implementation of the NE2001 Galactic electron density model. NE2001p 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.

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.

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

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.

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.

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

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.

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.

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.

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.

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.

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

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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