SparseBLS uses the Box-fitting Least Squares (BLS) algorithm to detect transiting exoplanets in photometric data. SparseBLS does not bin data into phase bins and does not use a phase grid. Because its detection efficiency does not depend on the transit phase, it is significantly faster than BLS for sparse data and is well-suited for large photometric surveys producing unevenly-sampled sparse light curves, such as Gaia.

astrofix is an astronomical image correction algorithm based on Gaussian Process Regression. It trains itself to apply the optimal interpolation kernel for each image, performing multiple times better than median replacement and interpolation with a fixed kernel.

Gallenspy uses the gravitational lensing effect (GLE) to reconstruct mass profiles in disc-like galaxies. The algorithm inverts the lens equation for gravitational potentials with spherical symmetry, in addition to the estimation in the position of the source, given the positions of the images produced by the lens. Gallenspy also computes critical and caustic curves and the Einstein ring.

PyPion reads in Silo (ascl:2103.025) data files from PION (ascl:2103.024) simulations and plots the data. This library works for 1D, 2D, and 3D data files and for any amount of nested-grid levels. The scripts contained in PyPion save the options entered into the command line when the python script is run, open the silo file and save all of the important header variables, open the directory in the silo (or vtk, or fits) file and save the requested variable data (eg. density, temp, etc.), and set up the plotting function and the figure.

Silo reads and writes a wide variety of scientific data to binary disk files. The files Silo produces and the data within them can be easily shared and exchanged between wholly independently developed applications running on disparate computing platforms. Consequently, Silo facilitates the development of general purpose tools for processing scientific data. One of the more popular tools that process Silo data files is the VisIt visualization tool (ascl:1103.007).

Silo supports gridless (point) meshes, structured meshes, unstructured-zoo and unstructured-arbitrary-polyhedral meshes, block structured AMR meshes, constructive solid geometry (CSG) meshes, piecewise-constant (e.g., zone-centered) and piecewise-linear (e.g. node-centered) variables defined on the node, edge, face or volume elements of meshes as well as the decomposition of meshes into arbitrary subset hierarchies including materials and mixing materials. In addition, Silo supports a wide variety of other useful objects to address various scientific computing application needs. Although the Silo library is a serial library, it has features that enable it to be applied quite effectively and scalable in parallel.

PION (PhotoIonization of Nebulae) is a grid-based fluid dynamics code for hydrodynamics and magnetohydrodynamics, including a ray-tracing module for calculating the attenuation of radiation from point sources of ionizing photons. It also has a module for coupling fluid dynamics and the radiation field to microphysical processes such as heating/cooling and ionization/recombination. PION models the evolution of HII regions, photoionized bubbles that form around hot stars, and has been extended to include stellar wind sources so that both wind bubbles and photoionized bubbles can be simulated at the same time. It is versatile enough to be extended to other applications.

DRAKE (Dark matter Relic Abundance beyond Kinetic Equilibrium) predicts the dark matter relic abundance in situations where the standard assumption of kinetic equilibrium during the freeze-out process may not be satisfied. The code comes with a set of three dedicated Boltzmann equation solvers that implement, respectively, the traditionally adopted equation for the dark matter number density, fluid-like equations that couple the evolution of number density and velocity dispersion, and a full numerical evolution of the phase-space distribution.

nestle is a pure Python implementation of nested sampling algorithms for evaluating Bayesian evidence. Nested sampling integrates posterior probability in order to compare models in Bayesian statistics. It is similar to Markov Chain Monte Carlo (MCMC) in that it generates samples that can be used to estimate the posterior probability distribution. Unlike MCMC, the nature of the sampling also allows one to calculate the integral of the distribution. It is also a pretty good method for robustly finding global maxima.

Carsus manages atomic datasets. It requires Chianti (ascl:9911.004), and can read data from a variety of sources and output them to file formats readable by radiative transfer codes such as TARDIS (ascl:1402.018).

ARTIS is a 3D radiative transfer code for Type Ia supernovae using the Monte Carlo method with indivisible energy packets. It incorporates polarization and virtual packets and non-LTE physics appropriate for the nebular phase of Type Ia supernovae.

SuperNu simulates time-dependent radiation transport in local thermodynamic equilibrium with matter. It applies the methods of Implicit Monte Carlo (IMC) and Discrete Diffusion Monte Carlo (DDMC) for static or homologously expanding spatial grids. The radiation field affects material temperature but does not affect the motion of the fluid. SuperNu may be applied to simulate radiation transport for supernovae with ejecta velocities that are not affected by radiation momentum. The physical opacity calculation includes elements from Hydrogen up to Cobalt. SuperNu is motivated by the ongoing research into the effect of variation in the structure of progenitor star explosions on observables: the brightness and shape of light curves and the temporal evolution of the spectra. Consequently, the code may be used to post-process data from hydrodynamic simulations. SuperNu does not include any capabilities or methods that allow for non-trivial hydrodynamics.

GalacticDNSMass performs Bayesian inference on Galactic double neutron stars (DNS) to investigate their mass distribution. Each DNS is comprised of two neutron stars (NS), a recycled NS and a non-recycled (slow) NS. It compares two hypotheses: A - recycled NS and non-recycled NS follow an identical mass distribution, and B - they are drawn from two distinct populations. Within each hypothesis it also explore three possible functional models: Gaussian, two-Gaussian (mixture model), and uniform mass distributions.

CRIME (Cosmological Realizations for Intensity Mapping Experiments) generates mock realizations of intensity mapping observations of the neutral hydrogen distribution. It contains three separate tools, GetHI, ForGet, and JoinT. GetHI generates realizations of the temperature fluctuations due to the 21cm emission of neutral hydrogen. Optionally it can also generate a realization of the point-source continuum emission (for a given population) by sampling the same density distribution, though using this feature greatly affects performance. ForGet generates realizations of the different galactic and extra-galactic foregrounds relevant for intensity mapping experiments using some external datasets (e.g. the Haslam 408 MHz map) stored in the "data"folder. JoinT is provided for convenience; it joins the temperature maps generated by GetHI and ForGet and includes several instrument-dependent effects (in an overly simplistic way).

The RAiSERed (Radio AGN in Semi-analytic Environments: Redshifts) code implements the RAiSE analytic model for Fanaroff-Riley type II sources, using a Bayesian prior for their host cosmological environments, to measure the redshift of active galactic nuclei lobes based on radio-frequency observations. The Python code provides a class for the user to store measured attributes for each radio source, and to which model derived redshift probability density functions are returned. Systematic uncertainties in the analytic model can be calibrated by specifying a subset of radio sources with spectroscopic redshifts. Functions are additionally provided to plot the redshift probability density functions and assess the success of the model calibration.

LPF (Live Pulse Finder) provides real-time automated analysis of the radio image data stream at multiple frequencies. The fully automated GPU-based machine-learning backed pipeline performs source detection, association, flux measurement and physical parameter inference. At the end of the pipeline, an alert of a significant detection of a transient event can be sent out and the data saved for further investigation.

QuickCBC is a robust end-to-end low-latency Bayesian parameter estimation algorithm for binary mergers. It reads in calibrated strain data, performs robust on-source spectral estimation, executes a rapid search for compact binary coalescence (CBC) signals, uses wavelet de-noising to subtract any glitches from the search residuals, produces low-latency sky maps and initial parameter estimates, followed by full Bayesian parameter estimation.

schNell computes basic map-level noise properties for generic networks of gravitational wave interferometers, primarily the noise power spectrum "N_ell", but this lightweight python module that can also be used for, for example, antenna patterns, overlap functions, and inverse variance maps, among other tasks. The code has three main classes; detectors contain information about each individual detector of the network, such as their positions, noise properties, and orientation. NoiseCorrelations describes the noise-level correlation between pairs of detectors, and the MapCalculators class combines a list of Detectors into a network (potentially together with a NoiseCorrelation object) and computes the corresponding map-level noise properties arising from their correlations.

AstroNet-Triage contains TensorFlow models and data processing code for identifying exoplanets in astrophysical light curves; this is the triage version of two TESS neural networks. For the vetting version, see AstroNet-Vetting (ascl:2103.011). The TensorFlow code downloads and pre-processes TESS data, builds different types of neural network classification models, trains and evaluates new models, and generates new predictions using a trained model. Utilities that operate on light curves are provided; these reading TESS data from .h5 files, and perform phase folding, splitting, binning, and other tasks. C++ implementations of some light curve utilities are also included.

AstroNet-Vetting identifies exoplanets in astrophysical light curves. This is the vetting version of two TESS neural networks; for the triage version, see AstroNet-Triage (ascl:2103.012). The package contains TensorFlow code that downloads and pre-processes TESS data, builds different types of neural network classification models, trains and evaluates a new model, and uses a trained model to generate new predictions. It includes utilities for operating on light curves, such as for reading TESS data from .h5 files, phase folding, splitting, and binning. In addition, C++ implementations of light curve utilities are also provided.

TransitFit fits exoplanetary transit light-curves for transmission spectroscopy studies. The code uses nested sampling for efficient and robust multi-epoch, multi-wavelength fitting of transit data obtained from one or more telescopes. TransitFit allows per-telescope detrending to be performed simultaneously with parameter fitting, including the use of user-supplied detrending alogorithms. Host limb darkening can be fitted either independently ("uncoupled") for each filter or combined ("coupled") using prior conditioning from the PHOENIX stellar atmosphere models. For this, TransitFit uses the Limb Darkening Toolkit (ascl:1510.003) together with filter profiles, including user-supplied filter profiles.

The cosmology code DarkEmulator calculates summary statistics of large scale structure constructed as a part of Dark Quest Project. The “dark_emulator” python package enables fast and accurate computations of halo clustering quantities. The code supports the halo mass function, halo-matter cross-correlation, and halo auto-correlation as a function of halo masses, redshift, separations and cosmological models.

The MRS (The MOS Reduction Software) suite reduces the spectra taken with the multi-object spectrograph spectra used as the focal plane instrument of RTT150 telescope in the TÜBİTAK National Observatory.

Simple program for planning and managing astronomical observations as observational diary or logs.

Pyedra performs asteroid phase curve fitting. From a simple table containing the asteroid MPC number, phase angle and reduced magnitude, Pyedra estimates the parameters of the phase function using the least squares method. The user can choose from three different models for the phase curve fit: H-G model, H-G1-G2 model and the Shevchenko model. The output in all cases is a table containing the adjusted parameters and their corresponding errors. This package allows carrying out phase function analysis for a few asteroids as well as to process large volumes of data such as those released by current large surveys.

TFF derives the Fourier decomposition of period-folded RR Lyrae light curves with gaps. The method can be used for the same purpose on any other types of variables, assuming that the the template database is changed to the proper type of variables.

Ggm contains useful utilities for Gaussian gradient filtering of astronomical FITS images. It applies the Gaussian gradient magnitude filter to an input fits image, using a particular scale, sigma, in pixels. ggm cosmetically hides point sources in fits images by filling point sources with random values from the surrounding pixel region. It also provides an interactive tool to combine FITS images filtered on different scales.

satcand applies theoretical constraints of orbital stability and tidal migration to KOI exomoon candidates. The package can evaluate the tidal migration within a Sun-Earth-Moon system, plot angular velocity over time, and calculate the migration time scale (T1) and the total migration time scale, among other things. In addition to the theoretical constraints, observational constraints can be applied.

Characterize and understandOpen Clusters(OCs) allow us to understand better properties and mechanisms about the Universe such as stellar formation and the regions where these events occur. They also provide information about stellar processes and the evolution of the galactic disk.

In this paper, we present a novel method to characterize OCs. Our method employs a model built on Artificial Neural Networks(ANNs). More specifically, we adapted a state of the art model, the Deep Embedded Clustering(DEC) model for our purpose. The developed method aims to improve classical state of the arts techniques. We improved not only in terms of computational efficiency (with lower computational requirements), but inusability (reducing the number of hyperparameters to get a good characterization of the analyzed clusters). For our experiments, we used the Gaia DR2 database as the data source, and compared our model with the clustering technique K-Means. Our method achieves good results, becoming even better (in some of the cases) than current techniques.

redshifts collects all unique spectroscopic redshifts from online databases such as VizieR and NED. It can perform a flexible search within a radius of a given set of (RA, DEC) coordinates and uses column names and descriptions (including UCD keywords) to identify columns containing spectroscopic redshifts or velocities. It weeds out photometric redshifts and duplicates and returns a unique list of best spectroscopic redshift measurements. redshifts can be used standalone from the terminal, and can take a number of optional command line arguments, or from Python.

spalipy performs detection-based astronomical image registration in Python. A source image is transformed to the pixel-coordinate system of a template image using their respective detections as tie-points by finding matching quads of detections. spalipy also includes an optional additional warping of the initial affine transformation via splines to achieve accurate registration in the case of non-homogeneous coordinate transforms. This is particularly useful in the case of optically distorted or wide field-of-view images.

hfs_fit performs parameter optimization in the analysis of emission line hyperfine structure (HFS). The code uses a simulated annealing algorithm to optimize the magnetic dipole interaction constants, electric quadrupole interaction constants, Voigt profile widths and the center of gravity wavenumber for a given emission line profile. The fit can be changed visually with sliders for parameters, which is useful when HFS constants are unknown.

21cmDeepLearning extracts the underlying matter density map from a 21 cm intensity field by making use of a convolutional neural network (CNN) with the U-Net architecture; the software is implemented in Pytorch. The astrophysical parameters of the simulations can be predicted with a secondary CNN. The simulations of matter density and 21 cm maps are performed with the code 21cmFAST (ascl:1102.023).

The synchrofit (synchrotron fitter) package implements a reduced dimensionality parameterisation of standard synchrotron spectrum models, and provides fitting routines applicable for active galactic nuclei and supernova remnants. The Python code includes the Jaffe-Parola model (JP), Kardashev-Pacholczyk model (KP), and continuous injection models (CI/KGJP) for both constant or Maxwell-Boltzmann magnetic field distributions. An adaptive maximum likelihood algorithm is invoked to fit these models to multi-frequency radio observations; the adaptive mesh is customisable for either optimal precision or computational efficiency. Functions are additionally provided to plot the fitted spectral model with its confidence interval, and to derive the spectral age of the synchrotron emitting particles.

USNO/AE98 contains ephemerides for fifteen of the largest asteroids that The Astronomical Almanac has used since its 2000 edition. These ephemerides are based on the Jet Propulsion Laboratory (JPL) planetary ephemeris DE405 and, thus, aligned to the International Celestial Reference System (ICRS). The data cover the period from 1799 November 16 (JD 2378450.5) through 2100 February 1 (JD 2488100.5). The internal uncertainty in the mean longitude at epoch, 1997 December 18, ranges from 0.05 arcseconds for 7 Iris through 0.22 arcseconds for 65 Cybele, and the uncertainty in the mean motion varies from 0.02 arcseconds per century for 4 Vesta to 0.14 arcseconds per century for 511 Davida.

The Astronomical Almanac has published ephemerides for 1 Ceres, 2 Pallas, 3 Juno, and 4 Vesta since its 1953 edition. Historically, these four asteroids have been observed more than any of the others. Ceres, Pallas, and Vesta deserve such attention because as they are the three most massive asteroids, the source of significant perturbations of the planets, the largest in linear size, and among the brightest main belt asteroids. Studying asteroids may provide clues to the origin and primordial composition of the solar system, data for modeling the chaotic dynamics of small solar system bodies, and assessments of potential collisions. Therefore, USNO/AE98 includes more than the traditional four asteroids.

The following criteria were used to select main belt asteroids for USNO/AE98:

Diameter greater than 300 km, presumably among the most massive asteroids
Excellent observing history and discovered before 1850
Largest in their taxonomic class
The massive asteroids included may be studied for their perturbing effects on the planets while those with detailed observing histories may be used to evaluate the accuracy limits of asteroid ephemerides. The fifteen asteroids that met at least one of these criteria are

1 Ceres (new mass determination)
2 Pallas (new mass determination)
3 Juno
4 Vesta (new mass determination)
6 Hebe
7 Iris
8 Flora
9 Metis
10 Hygiea
15 Eunomia
16 Psyche
52 Europa
65 Cybele
511 Davida
704 Interamnia
The refereed paper by Hilton (1999, Astron. J. 117, 1077) describes the USNO/AE98 asteroid ephemerides in detail. The associated USNO/AA Tech Note 1998-12 includes residual plots for all fifteen asteroids and a comparison between these ephemerides and those used in The Astronomical Almanac through 1999.

Software to compact, read, and interpolate the USNO/AE98 asteroid ephemerides is also available. It is written in C and designed to work with the C edition of the Naval Observatory Vector Astrometry Software (NOVAS). The programs could be used with tabular ephemerides of other asteroids as well. The associated README file provides the details of this system.

FLARE, a parallel code written in Python, generates 100,000 Fast Radio Bursts (FRB) using the Monte Carlo method. The FRB population is diverse and includes sporadic FRBs, repeaters, and periodic repeaters. However, less than 200 FRBs have been detected to date, which makes understanding the FRB population difficult. To tackle this problem, FLARE uses a Monte Carlo method to generate 100,000 realistic FRBs, which can be analyzed later on for further research. It has the capability to simulate FRB distances (based on the observed FRB distance range), energies (based on the "flaring magnetar model" of FRBs), fluences, multi-wavelength counterparts (based on x-ray to radio fluence ratio of FRB 200428), and other properties. It analyzes the resulting synthetic FRB catalog and displays the distribution of their properties. It is fast (as a result of parallel code) and requires minimal human interaction. FLARE is, therefore, able to give a broad picture of the FRB population.

GLEAM (Galaxy Line Emission and Absorption Modeling) fits Gaussian models to emission and absorption lines in large samples of 1D galaxy spectra. The code is tailored to work well without much human interaction on optical and infrared spectra in a wide range of instrument setups and signal-to-noise regimes. gleam will create a fits table with Gaussian line measurements, including central wavelength, width, height and amplitude, as well as estimates for the continuum under the line and the line flux, luminosity, equivalent width and velocity width. gleam will also, optionally, make plots of the spectrum with fitted lines overlaid.

BALRoGO (Bayesian Astrometric Likelihood Recovery of Galactic Objects) handles data from the Gaia space mission. It extracts galactic objects such as globular clusters and dwarf galaxies from data contaminated by interlopers using a combination of Bayesian and non-Bayesian approaches. It fits proper motion space, surface density, and the object center. It also provides confidence regions for the color-magnitude diagram and parallaxes.

PyAutoFit supports advanced statistical methods such as massively parallel non-linear search grid-searches, chaining together model-fits and sensitivity mapping. It is a Python-based probabilistic programming language which composes and fits models using a range of Bayesian inference libraries, such as emcee (ascl:1303.002) and dynesty (ascl:1809.013). It performs model composition and customization, outputting results, model-specific visualization and posterior analysis. Built for big-data analysis, results are output as a database which can be loaded after model-fitting is complete.

PyFstat performs F-statistic-based continuous gravitational wave (CW) searches and other CW data analysis tasks. It is built on top of the LALSuite library (ascl:2012.021), making that library's functionality more accessible through a Python interface; it also provides MCMC-based followup of promising candidates from wide-parameter-space searches.

extinction is an implementation of fast interstellar dust extinction laws in Python. It contains Cython-optimized implementations of empirical dust extinction laws found in the literature. Flux values can be reddened or dereddened using included functions, and all extinction laws accept a unit keyword to change the interpretation of the wavelength array from Angstroms to inverse microns. Part of this code originated in the specutils package (ascl:1902.012).

binaryoffset identifies the binary offset effect in images from any detector. The easiest input to work with is a dark or bias image that is spatially flat. The code can also be run on images that are not spatially flat, assuming that there is some model of the signal on the CCD that can be used to produce a residual image.

Piff models the point-spread function (PSF) across multiple detectors in the full field of view (FOV). Models can be built in chip coordinates or in sky coordinates if needed to account for the effects of astrometric distortion. The software can fit in either real or Fourier space, and can identify and excise outlier stars that are poor exemplars of the PSF according to some metric.

Multi_CLASS modifies the Boltzmann code CLASS (ascl:1106.020) to compute of the cross-tracer angular power spectra of the number count fluctuations for two different tracers of the underlying dark matter density field. In other words, it generalizes the standard nCl output option of CLASS to the case of two different tracers, for example, two different galaxy populations with their own redshift distribution, and galaxy and magnification bias parameters, among others.

Multi_CLASS also includes an implementation of the effect of primordial non-Gaussianities of the local type, parametrized by the parameter f_NL (following the large-scale structure convention), on the effective bias of the tracers. There is also the possibility of having a tilted non-Gaussian correction, parametrized by n_NG, with a pivot scale determined by k_pivot_NG. The package includes galaxy redshift distributions for forthcoming galaxy surveys, with the ease of choosing between them (or an input file) from the parameters input file (e.g., multi_explanatory.ini). In addition, Multi_CLASS includes the possibility of using resolved gravitational wave events as a tracer.

RASSINE normalizes merged 1D spectra using the concept of convex hulls. The code uses six parameters that can be fine-tuned, and provides an interactive interface, including graphical feedback, for easily choosing the parameters. RASSINE can also provide a first guess for the parameters that are derived directly from the merged 1D spectrum based on previously performed calibrations.

lensingGW simulates lensed gravitational waves in ground-based interferometers from arbitrary compact binaries and lens models. Its algorithm resolves strongly lensed images and microimages simultaneously, such as the images resulting from hundreds of microlenses embedded in galaxies and galaxy clusters. It is based on Lenstronomy (ascl:1804.012),

MOSAIC (Multipole Operators in Symbols, Automatically Improved and Condensed) automatically produces, verifies, and optimizes computer code for Fast Multipole Method (FMM) operators. It is based on a symbolic algebra library, and can produce code for any expansion order and be extended to use any basis or kernel function. The code applies algebraic modifications to reduce the number of floating-point operations and can symbolically verify correctness.

HUAYNO implements integrators derived from second order Hamiltonian splitting for N-body dynamics. This integration scheme conserves energy and momentum with little or no systematic drift. The code uses an explicit but approximate formula for the time symmetrization that is compatible with the use of individual time steps, making an iterative scheme unnecessary. HUAYNO is available as part of the AMUSE package (ascl:1107.007).

DaMaSCUS-SUN is a Monte Carlo tool simulating the process of solar reflection of dark matter (DM) particles. It provides precise estimates of the DM particle flux reflected by the Sun and passing through a direct detection experiment on Earth. One application is to compute exclusion limits for low DM masses based on nuclear and electron recoil experiments.

mirkwood uses supervised machine learning to model non-linearly mapping galaxy fluxes to their properties. Multiple models are stacked to mitigate poor performance by any individual model in a given region of the parameter space. The code accounts for uncertainties arising both from intrinsic noise in observations and from finite training data and incorrect modeling assumptions, and provides highly accurate physical properties from observations of galaxies as compared to traditional SED fitting.

OPUS (Observatoire de Paris UWS System) provides interoperable access to analysis and simulation codes on local machines or work clusters. This job control system was developed using the micro-framework bottle.py, and executes jobs asynchronously to better manage jobs with a long execution duration. The software follows the proposed IVOA Provenance Data Model to capture and expose the provenance information of jobs and results.

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

nway is a source cross-matching tool for arbitrarily many astronomical catalogs. It features Bayesian match probabilities based on astronomical sky coordinates (RA, DEC), works with arbitrarily many catalogs, and can handle varying errors. nway can also incorporate additional prior information, such as the magnitude or color distributions of the sources to match, and works accurately and fast in small areas and all-sky catalogs.

GalRotpy models the dynamical mass of disk-like galaxies and makes a parametric fit of the rotation curve by means of the composed gravitational potential of the galaxy. It can be used to check the presence of an assumed mass type component in a observed rotation curve, to determine quantitatively the main mass contribution in a galaxy by means of the mass ratios of a given set of five potentials, and to bound the contribution of each mass component given its gravitational potential parameters.

MUSE-PSFR reconstructs a PSF for the MUSE WFM-AO mode using telemetry data from SPARTA. The algorithm conducts a Fourier analysis of the laser-assisted ground layer adaptive optics (GLAO) residual phase statistics and has been test in end-to-end simulations. A sensitivity analysis was conducted to determine the required accuracy in terms of input parameters. MUSE-PSFR is capable of reconstructing the critical parameters of a PSF and can be used with MUSE 3D data by all MUSE users.

polgraw-allsky searches for almost monochromatic gravitational wave signals. This pipeline searches for continuous gravitational wave signals in time-domain data using the F-statistic on data from a network of detectors. The software generates a parameter space grid, conducts a coherent search for candidate signals in narrowband time segments, and searches for coincidences among different time segments. The pipeline also estimates the false alarm probability of coincidences and follows up on interesting outliers.

hardCORE calculates the minimum, maximum, and marginal core radius fractions (CRFmin, CRFmax, CRFmarg) for a solid exoplanet using only its mass and radius. Written in Python, the code is an efficient tool that is extremely fast to execute and perform inversions.

EqTide calculates the evolution of 2 bodies experiencing tidal evolution according to the "equilibrium tide" framework's "constant-phase-lag" and "constant-time-lag" models. The input file contains a list of options that can be set, as well as output parameters that print to a file during an integration. The example input files provide a guide for the syntax and grammar of EqTide.

CMasher provides a curated collection of scientific colormaps that are perceptually uniform sequential using the viscm package (ascl:2102.007). Most of them are color-vision deficiency friendly; they cover a wide range of different color combinations to accommodate for most applications. The package provides several alternatives to commonly used colormaps, such as chroma and rainforest for jet, sunburst for hot, neutral for binary, and fusion and redshift for coolwarm.

viscm is a Python tool for visualizing and designing colormaps using colorspacious and matplotlib.

Lightbeam simulates the 3D propagation of light through waveguides of arbitrary geometries. This code package is based off of the finite-differences beam propagation method, and employs a transverse adaptive mesh for extra computational efficiency. Also included are tools to simulate adaptive optics systems for use in conjunction with waveguides, useful in astronomical contexts for simulating coupling devices which transfer telescope light to the science instrument.

The Exoplanet Modeling and Analysis Center (EMAC) is a website which serves as a catalog, repository and integration platform for modeling and analysis resources focused on the study of exoplanet characteristics and environments. EMAC hosts user-submitted software ranging in category from planetary interior models to data visualization tools. Other features of EMAC include integrated web tools developed by the EMAC team in collaboration with the tools' original authors and video demonstrations of a growing number of hosted tools. EMAC aims to be a comprehensive repository for researchers to access a variety of exoplanet resources that can assist them in their work, and currently hosts a growing number of code bases, models, and tools. EMAC is a key project of the NASA GSFC Sellers Exoplanet Environments Collaboration (SEEC).

X-PSI simulates rotationally-modified (pulsed) surface X-ray emission from neutron stars, taking into account relativistic effects on the emitted radiation. This can then be used to perform Bayesian statistical inference on real or simulated astronomical data sets. Model parameters of interest may include neutron star mass and radius (useful to constrain the properties of ultradense nuclear matter) or the system geometry and properties of the hot emitting surface-regions. To achieve this, X-PSI couples code for likelihood functionality (simulation) with existing open-source software for posterior sampling (inference).

ThumbStack produces stacked maps and profiles, given catalogs of object positions and maps. It is designed for thermal and kinematic Sunyaev-Zel'dovich measurements. Based on Pixell (ascl:2102.003), it outputs 2D stacked maps and radial profiles for different filters (e.g., aperture photometry filters), as well as their covariances, estimated through several methods including bootstrap.

Pixell loads, manipulates, and analyzes maps stored in rectangular pixelization. It is mainly targeted for use with maps of the sky (e.g., CMB intensity and polarization maps, stacks of 21 cm intensity maps, binned galaxy positions or shear) in cylindrical projection, but its core functionality is more general. It extends numpy's ndarray to an ndmap class that associates a World Coordinate System (WCS) with a numpy array. It includes tools for Fourier transforms (through numpy or pyfft) and spherical harmonic transforms (through libsharp2 (ascl:1402.033)) of such maps and tools for visualization (through the Python Image Library).

MST (Minimum Spanning Tree) identifies velocity coherent large-scale filaments through ATLASGAL clumps. It can also isolate filaments embedded in a crowded position–position–velocity (PPV) space. One strength of this method is its repeatability compared to manual approaches.

spinOS calculates binary orbital elements. Given a set of radial velocity measurements of a spectroscopic binary and/or relative position measurement of an astrometric binary, spinOS fits an orbital model by minimizing a chi squared metric. These routines are neatly packaged in a graphical user interface, developed using tkinter, facilitating use. Minimization is achieved by default using a Levenberg-Marquardt algorithm from lmfit [ascl:1606.014]. A Markov Chain Monte Carlo option is available to sample the posterior probability distribution in order to estimate errors on the orbital elements.

Stratsi calculates stratified and vertically-shearing streaming instabilities. It solves one- and two-fluid linearized equations, and, for two-fluid models, also provides the parameters and analytic vertical structure and solves for equilibrium horizontal velocity profiles. It offers utilities and various plotting options, including plots to compare one- and two-fluid results, viscous results to inviscid results, and results from two different stokes numbers or two different metallicities. stratsi requires Dedalus (ascl:1603.015) and Eigentools (ascl:2101.017).

Eigentools is a set of tools for studying linear eigenvalue problems. The underlying eigenproblems are solved using Dedalus (ascl:1603.015), which provides a domain-specific language for partial differential equations. Eigentools extends Dedalus's EigenvalueProblem object and provides automatic rejection of unresolved eigenvalues, simple plotting of specified eigenmodes and of spectra, and computation of $\epsilon$-pseudospectra for any Differential-Algebraic Equations with user-specifiable norms. It includes tools to find critical parameters for linear stability analysis and is able to project eigenmode onto 2- or 3-D domain for visualization. It can also output projected eigenmodes as Dedalus-formatted HDF5 file to be used as initial conditions for Initial Value Problems, and provides simple plotting of drift ratios (both ordinal and nearest) to evaluate tolerance for eigenvalue rejection.

pyUPMASK is an unsupervised clustering method for stellar clusters that builds upon the original UPMASK (ascl:1504.001) package. Its general approach makes it applicable to analyses that deal with binary classes of any kind, as long as the fundamental hypotheses are met. The core of the algorithm follows the method developed in UPMASK but introducing several key enhancements that make it not only more general, they also improve its performance.

DarpanX computes reflectivity and other specular optical functions of a multilayer or single layer mirror for different energy and angles as well as to fit the XRR measurements of the mirrors. It can be used as a standalone package. It has also been implemented as a local module for XSPEC (ascl:9910.005), which is accessible through and requires PyXspec (ascl:2101.014), and can accurately fit experimentally measured X-ray reflectivity data. DarpanX is implemented as a Python 3 module and an API is provided to access the underlying algorithms.

PyXspec is an object oriented Python interface to the XSPEC (ascl:9910.005) spectral-fitting program. It provides an alternative to Tcl, the sole scripting language for standard Xspec usage. With PyXspec loaded, a user can run Xspec with Python language scripts or interactively at a Python shell prompt; everything in PyXspec is accessible by importing the package xspec into your Python script. PyXspec can be utilized in a Python script or from the command line of the plain interactive Python interpreter. PyXspec does not implement its own command handler, so it is not intended to be run as the Python equivalent of a traditional interactive XSPEC session (which is really an enhanced interactive Tcl interpreter).

Curvit produces light curves from UVIT (Ultraviolet Imaging Telescope) data. It uses the events list from the official UVIT L2 pipeline (version 6.3 onwards) as input. The makecurves function of curvit automatically detects sources from events list and creates light curves. Curvit provides source coordinates only in the instrument coordinate system. If you already have the source coordinates, the curve function of curvit can be used to create light curves. The package has several parameters that can be set by the user; some of these parameters have default values. Curvit is available on PyPI.

Octo-Tiger models mass transfer in binary systems using a Cartesian adaptive mesh refinement grid. It simulates the evolution of star systems based on a modified fast multipole method (FMM) on adaptive octrees. The code takes shock heating into account and uses the dual energy formalism with an ideal gas equation of state; it also conserves linear and angular momenta to machine precision. Octo-Tiger is implemented in C++ and is parallelized using the High Performance ParalleX (HPX) runtime system.

Nigraha identifies and evaluates planet candidates from TESS light curves. Using a combination of high signal to noise ratio (SNR) shallow transits, supervised machine learning, and detailed vetting, the neural network-based pipeline identifies planet candidates missed by prior searches. The pipeline runs in four stages. It first performs period finding using the Transit Least Squares (TLS) package and runs sector by sector to build a per-sector catalog. It then transforms the flux values in .fits lightcurve files to global/local views and write out the output in .tfRecords files, builds a model on training data, and saves a checkpoint. Finally, it loads a previously saved model to generate predictions for new sectors. Nigraha provides helper scripts to generate candidates in new sectors, thus allowing others to perform their own analyses.

The apogee package works with SDSS-III APOGEE and SDSS-IV APOGEE-2 data. It reads various data products and applies cuts, works with APOGEE bitmasks, and plots APOGEE spectra. It can generate model spectra for APOGEE spectra, and APOGEE model grids can be used to fit spectra. apogee includes some simple stacking functions and implements the effective selection function for APOGEE.

cFS is a platform and project independent reusable software framework and set of reusable applications developed by NASA Goddard Space Flight Center. There are three key aspects to the cFS architecture: a dynamic run-time environment, layered software, and a component based design, making it suitable for reuse on NASA flight projects and/or embedded software systems. This framework is used as the basis for the flight software for satellite data systems and instruments, but can also be used on other embedded systems. Modules of this package are used in NICER (Neutron star Interior Composition Explorer). The modules are available as separate downloads from SourceForge through the NASA cFS website.

EphemMatch reads in the period, epoch, positional, and other information of all the Kepler DR25 TCEs, as well as the cumulative KOI list, and lists of EBs from the Kepler Eclipsing Binary Working Group (http://keplerebs.villanova.edu) as well as several catalogs of EBs known from ground-based surveys. The code then performs matching to identify two different objects that have a statistically identical period and epoch (within some tolerance) and perform logic to identify which is the real source (the parent) and which is a false positive due to contamination from the parent (a child).

Mask galaxy is an automatic machine learning pipeline for detection, segmentation and morphological classification of galaxies. The model is based on the Mask R-CNN Deep Learning architecture. This model of instance segmentation also performs image segmentation at the pixel level, and has shown a Mean Average Precision (mAP) of 0.93 in morphological classification of spiral or elliptical galaxies.

ptemcee, pronounced "tem-cee", is fork of Daniel Foreman-Mackey's emcee (ascl:1303.002) to implement parallel tempering more robustly. As far as possible, it is designed as a drop-in replacement for emcee. It is helpful for characterizing awkward, multi-modal probability distributions.

Avocado produces classifications of arbitrary astronomical transients and variable objects. It addresses the problem of biased spectroscopic samples by generating many lightcurves from each object in the original spectroscopic sample at a variety of redshifts and with many different observing conditions. The "augmented" samples of lightcurves that are generated are much more representative of the full datasets than the original spectroscopic samples.

radiowinds calculates the radio emission produced by the winds around stars. The code calculates thermal bremsstrahlung that is emitted from the wind, which depends directly on the density and temperature of the stellar wind plasma. The program takes input data in the form of an interpolated 3d grid of points (of the stellar wind) containing position, temperature and density data. From this it calculates the thermal free-free emission expected from the wind at a range of user-defined frequencies.

whereistheplanet predicts the locations of directly imaged companions (mainly exoplanets and brown dwarfs) based on past orbital fits to the data. This tool helps coordinate follow-up observations to characterize their properties, as precise pointing of the instrument is often needed. It uses orbitize! (ascl:1910.009) as a backend. whereistheplanet is available as a Python API, a command line tool, and a web form at whereistheplanet.com.

BAYES-LOSVD performs non-parametric extraction of the Line-Of-Sight Velocity Distributions in galaxies. Written in Python, it uses Stan (ascl:1801.003) to perform all the computations and provides reliable uncertainties for all the parameters of the model chosen for the fit. The code comes with a large number of features, including read-in routines for some of the most popular IFU spectrographs and surveys, such as ATLAS3D, CALIFA, MaNGA, MUSE-WFM, SAMI, and SAURON.

In cosmological N-body simulations, higher-order Lagrangian perturbation on the initial condition affects the formation of nonlinear structure. Using this code, the initial condition generated by Zel'dovich approximation (Lagrangian linear perturbation) for Gadget-2 code to initial condition with second- or third-order Lagrangian perturbation (2LPT, 3LPT).

EinsteinPy performs General Relativity and gravitational physics tasks, including geodesics plotting for Schwarzschild, Kerr and Kerr Newman space-time models, calculation of Schwarzschild radius, and calculation of event horizon and ergosphere for Kerr space-time. It can perform symbolic manipulations of various tensors such as Metric, Riemann, Ricci and Christoffel symbols. EinsteinPy also features hypersurface embedding of Schwarzschild space-time, and includes other utilities and functions. It is a community-developed package and is written in Python.

Magritte performs 3D radiative transfer modeling; though focused on astrophysics and cosmology, the techniques can also be applied more generally. The code uses a deterministic ray-tracer with a formal solver that currently focuses on line radiative transfer. Magritte can either be used as a C++ library or as a Python package.

DRAGraces (Data Reduction and Analysis for GRACES) reduces GRACES spectra taken with the Gemini North high-resolution spectrograph. It finds GRACES frames in a given directory, determines the list of bias, flat, arc and science frames, and performs the reduction and extraction. Written in IDL, DRAGraces is straightforward and easy to use.

HCGrid maps non-uniform radio astronomy data onto a uniformly distributed grid using a convolution-based algorithm on CPU-GPU heterogeneous platforms. The package has three modules; the initialization module initializes parameters needed for the calculation process, such as setting the size of the sampling space and output resolution. The gridding module uses a parallel ordering algorithm to pre-order the sampling points based on HEALPix on the CPU platform and uses an efficient two-level lookup table to speed up the acquisition of sampling points; it then accelerates convolution by using the high parallelism of GPU and through related performance optimization strategies based on CUDA architecture to further improve the gridding performance. The third module processes the results; it visualizes the gridding and exports the final products as FITS files.

SWIGLAL, a wrapper for and component of the LALSuite (ascl:2012.021) gravitational wave detection and analysis libraries, which are primarily written in C, makes LALSuite routines directly accessible to Python and Octave scripts.

LALSuite contains numerous gravitational wave analysis libraries. Written primarily in C, the libraries include math and signal analysis packages such as for vector manipulation, FFT, statistics, time-domain filtering, and numerical and signal injection routines. The libraries also include date and time and datatype factory routines, in addition to general and support tools and a variety of Python packages. Also included are packages for gravitational waveform and noise generation, burst gravitational wave data analysis, inspiral and ringdown CBC gravitational wave data analysis, pulsar and continuous wave gravitational wave data analysis, and Bayesian inference data analysis. Various wrappers and other tools are also included.

BlackHawk calculates the Hawking evaporation spectra of any black hole distribution. Written in C, the program enables users to compute the primary and secondary spectra of stable or long-lived particles generated by Hawking radiation of the distribution of black holes, and to study their evolution in time.

PyXel models astronomical X-ray imaging data; it provides a common set of image analysis tools for astronomers working with extended X-ray sources. PyXel can model surface brightness profiles from X-ray satellites using a variety of models and statistics. PyXel can, for example, fit a broken power-law model to a surface brightness profile, and fit a constant to the sky background level in the direction of the merging galaxy cluster.

SimCADO simulates observations with any NIR/Vis imaging system. Though the package was originally designed to simulate images for the European Extremely Large Telescope (ELT) and MICADO, with the proper input, it is capable of simulating observations from many different telescope and instrument configurations.

SLIT (Sparse Lens Inversion Technique) provides a method for inversion of lensed images in the frame of strong gravitational lensing. The code requires the input image along with lens mass profile and a PSF. The user then has to chose a maximum number of iterations after which the algorithm will stop if not converged and a image size ratio to the input image to set the resolution of the reconstructed source. Results are displayed in pyplot windows.

Pomegranate builds probabilistic models in Python that is implemented in Cython for speed. The code merges the easy-to-use API of scikit-learn with the modularity of probabilistic modeling, including general mixture and hidden Markov models and Bayesian networks, to allow users to specify complicated models without the need to be concerned about implementation details. The models are built from the ground up and natively support features such as multi-threaded parallelism and out-of-core processing.

Seaborn provides a high-level interface for drawing attractive statistical graphics. Written in Python, it builds on matplotlib and integrates closely with pandas data structures. Its plotting functions operate on dataframes and arrays containing whole datasets and internally perform the necessary semantic mapping and statistical aggregation to produce informative plots. Its dataset-oriented, declarative API allows the user to focus on what the different elements of the plots mean, rather than on the details of how to draw them.

Dolphin uniformly models large lens samples. It is a wrapper for Lenstronomy (ascl:1804.012), and features semi-automated modeling of a large sample of quasar and galaxy-galaxy lenses. Dolphin, written in Python, provides easy portability between local and MPI environments.

sedop is a Monte-Carlo minimization code designed to optimally construct spectral energy distributions (SEDs) for sources of ultraviolet and X-ray radiation employed in numerical simulations of reionization and radiative feedback.

TRAN_K2 searches for periodic transits in the photometric time series of the Kepler K2 mission. The search is made by considering stellar variability and instrumental systematics. TRAN_K2 is written in Fortran 77 and has a single input parameter file that can be edited by the user depending on the type of run and parameter ranges to be used.

Skye detects a statistically significant excess clustering of transit times, indicating that there are likely systematics at specific times that cause many false positive detections, for the Kepler DR25 planet candidate catalog. The technique could be used for any survey looking to statistically cull false alarms.