ASPIRED reduces 2D spectral data from raw image to wavelength and flux calibrated 1D spectrum automatically without any user input (quicklook quality), and provides a set of easily configurable routines to build pipelines for long slit spectrographs on different telescopes (science quality). It delivers near real-time data reduction, which can facilitate automated or interactive decision making, allowing "on-the-fly" modification of observing strategies and rapid triggering of other facilities.

Popsynth provides an abstract way to generate survey populations from arbitrary luminosity functions and redshift distributions. Additionally, auxiliary quantities can be sampled and stored. Populations can be saved and restored via an HDF5 files for later use, and population synthesis routines can be created via classes or structured YAML files. Users can construct their own classes for spatial, luminosity, and other distributions, all of which can be connected to arbitrarily complex selection functions.

distance-omnibus computes posterior DPDFs for catalog sources using the Bayesian application of kinematic distance likelihoods derived from a Galactic rotation curve with prior Distance Probability Density Functions (DPDFs) derived from ancillary data. The methodology and code base are generalized for use with any (sub-)millimeter survey of the Galactic plane.

contaminante helps find the contaminant transiting source in NASA's Kepler, K2 or TESS data. When hunting for transiting planets, sometimes signals come from neighboring contaminants. This package helps users identify where the transiting signal comes from in their data. The code uses pixel level modeling of the TargetPixelFile data from NASA's astrophysics missions that are processed with the Kepler pipeline. The output of contaminante is a Python dictionary containing the source location and transit depth, and a contaminant location and depth. It can also output a figure showing where the main target is centered in all available TPFs, what the phase curve looks like for the main target, where the transiting source is centered in all available TPFs, if a transiting source is located outside the main target, or the transiting source phase curve, if a transiting source is located outside the main target.

Sculptor manipulates, models and analyzes spectroscopic data; the code facilitates reproducible scientific results and easy to inspect model fits. A built-in graphical user interface around LMFIT (ascl:1606.014) offers interactive control to set up and combine multiple spectral models to fully fit the spectrum of choice. Alternatively, all core functionality can be scripted to facilitate the design of spectral fitting and analysis pipelines.

GALLUMI (GALaxy LUMInosity) is a likelihood code that extracts cosmological and astrophysical parameters from the UV galaxy luminosity function. The code is implemented in the MCMC sampler MontePython (ascl:1307.002) and can be readily run in conjunction with other likelihood codes.

Find_Orb takes a set of observations of an asteroid, comet, or natural or artificial satellite given in the MPC (Minor Planet Center) format, the ADES astrometric format, and/or the NEODyS or AstDyS formats, and finds the corresponding orbit.

SPARTAN fits the spectroscopy and photometry of distant galaxies. The code implements multiple interfaces to help in the configuration of the fitting and the inspection of the results. SPARTAN relies on pre-computed input files (such as stellar population and IGM extinction), available for download, to save time in the fitting process.

Site with collection of codes and fundamental references on mean motion resonances.

Citlalicue allows you to create synthetic stellar light curves (transits, stellar variability and white noise) and detrend light curves using Gaussian Processes (GPs). Transits are implemented using PyTransit (ascl:1505.024). Python notebooks are provided to demonstrate using Citlalicue for both functions.

PSLS simulates solar-like oscillators representative of PLATO targets. It includes planetary transits, stochastically-excited oscillations, granulation and activity background components, as well as instrumental systematic errors and random noises representative for PLATO.

fiducial_flare generates a reasonable approximation of the UV emission of M dwarf stars over a single flare or a series of them. The simulated radiation is resolved in both wavelength and time. The intent is to provide consistent input for applications requiring time-dependent stellar UV radiation fields that balances simplicity with realism, namely for simulations of exoplanet atmospheres.

Residual Feature Extraction Pipeline carries out feature extraction of residual substructure within the residual images produced by popular galaxy structural-fitting routines such as GALFIT (ascl:1104.010) and GIM2D (ascl:1004.001). It extracts faint low surface brightness features by isolating flux-wise and area-wise significant contiguous pixels regions by rigorous masking routine. The code accepts the image cubes (original image, model image, residual image) and generates several data products, such as an image with extracted features, a source extraction based segmentation map, and the background sky mask and the residual extraction mask. It uses a Monte Carlo approach-based area threshold above which the extracted features are identified. The pipeline also creates a catalog entry indicating the surface brightness and its error.

The EDI (Exoplanet Detection Identifier) Vetter Unplugged software identifies false positive transit signals using Transit Least Squares (TLS) information and has been simplified from the full EDI-Vetter algorithm (ascl:2202.009) for easy implementation with the TLS output.

EDI (Exoplanet Detection Identifier) Vetter identifies false positive transit signal in the K2 data set. It combines the functionalities of Terra (ascl:2202.008) and RoboVetter (ascl:2012.006) and is optimized to test single transiting planet signals. An easily implemented suite of vetting metrics built to run alongside TLS of EDI Vetter, EDI-Vetter Unplugged (ascl:2202.010), is also available.

TERRA (Transiting Exoearth Robust Reduction Algorithm) identifies and removes instrumental noise in Kepler photometry. This transit detection code is optimized to detect small planets around photometrically quiet stars. TERRA calculates photometry in the time domain, combs the calibrated photometry for periodic, box-shaped signals, fits promising signals, and rejects signals inconsistent with exoplanet transits.

SciCatalog handles catalogs of scientific data in a way that is easily extensible, including the ability to create nicely formatted AASTex deluxe tables for use in AAS Publishing manuscripts. It handles catalogs of values, their positive and negative uncertainties, and references for those values with methods for easily adding columns and changing values. The catalog is also backed up every time it is loaded under the assumption that it is about to be modified.

FIRE Studio is a Python interface for C libraries that project Smoothed Particle Hydrodynamic (SPH) datasets. These C libraries can, in principle, be applied to any SPH dataset; the Python interface is specialized to conveniently load and format Gadget-derivative datasets such as GIZMO (ascl:1410.003). FIRE Studio is fast, memory efficient, and parallelizable. In addition to producing "1-color" projection maps for SPH datasets, the interface can produce "2-color" maps, where the pixel saturation is set by one projected quantity and the hue is set by another, and "3-color" maps, where three quantities are projected simultaneously and remapped into an RGB colorspace. FIRE Studio can model stellar emission and dust extinction to produce mock Hubble images (by default) or to model surface brightness maps for thirteen of the most common bands (plus the bolometric luminosity). It produces publication quality static images of simulation datasets and provides interpolation scripts to create movies that smoothly evolve in time (provided multiple snapshots in time of the data exist), view the dataset from different perspectives (taking advantage of shared memory buffers to allow massive parallelization), or both.

Palettable is a library of color palettes for Python. The code is written in pure Python with no dependencies; it can be used to supply color maps for matplotlib plots, customize matplotlib plots, and to supply colors for a web application.

SUPPNet performs fully automated precise continuum normalization of merged echelle spectra and offers flexible manual fine-tuning, if necessary. The code uses a fully convolutional deep neural network (SUPP Network) trained to predict a pseudo-continuum. The post-processing step uses smoothing splines that give access to regressed knots, which are useful for optional manual corrections. The active learning technique controls possible biases that may arise from training with synthetic spectra and extends the applicability of the method to features absent in this kind of spectra.

Zwindstroom computes background quantities and scale-dependent growth factors for cosmological models with free-streaming species, such as massive neutrinos. Following the earlier REPS code (ascl:1612.022), the code uses a Newtonian fluid approximation with external neutrino sound speed to close the Boltzmann hierarchy. Zwindstroom supports multi-fluid models with distinct transfer functions and sound speeds. A flexible python interface facilitates interaction with CLASS (ascl:1106.020) through classy. There is also a Zwindstroom plugin for the cosmological initial conditions generator monofonIC (ascl:2008.024) that allows for higher-order LPT ICs for massive neutrino simulations in a single step.

NWelch uses Welch's method to estimate the power spectra, complex cross-spectrum, magnitude-squared coherence, and phase spectrum of bivariate time series with nonuniform observing cadence. For univariate time series, users can apply the Welch's power spectrum estimator or compute a nonuniform fast Fourier transform-based periodogram. Options include tapering in the time domain and computing bootstrap false alarm levels. Users may choose standard 50%-overlapping Welch's segments or apply a custom-made segmentation scheme. NWelch was designed for Doppler planet searches but may be applied to any type of time series.

CHIME/FRB instrument has recently published a catalog containing about half of thousand fast radio bursts (FRB) including their spectra and several reconstructed properties, like signal widths, amplitudes, etc. We have developed a model-independent approach for the classification of these bursts using cross-correlation and clustering algorithms applied to one-dimensional intensity profiles, i.e. to amplitudes as a function of time averaged over the frequency. This approach is implemented in frbmclust package, which is used for classification of bursts featuring different waveform morphology.

GA Galaxy fits models of interacting galaxies to synthetic data using a genetic algorithm and custom fitness function. The genetic algorithm is real-coded and uses a mixed Gaussian kernel for mutation. The fitness function incorporates 1.) a direct pixel-to-pixel comparison between the target and model images and 2.) a comparison of the degree of tidal distortion present in the target and model image such that target-model pairs which are similarly distorted will have a higher relative fitness. The genetic algorithm is written in Python 2.7 while the simulation code (SPAM: Stellar Particle Animation Module) is written in Fortran 90.

nProFit analyzes surface brightness profiles. It obtains the best-fit structural, scale, and shape parameters of star clusters in Hubble Space Telescope images of nearby galaxies. The code fits dynamical models and can derive physically-relevant parameters. Among these are central volume and luminosity densities, total masses and luminosities, central velocity dispersions, core radius, half-light radius, tidal radius, and binding energy.

disnht computes the absorption spectrum for a user-defined distribution of column densities. The input is a file including the array of column density values; a python routine is provided that can make logarithmic distribution of column density that can be used as an input. Other optional inputs are a cross-section file that includes the 2-d array [energy, cross-section]; a script is provided for computing cross sections for different abundance model for the interstellar medium (solar values). Other boolean flags can be used for input and output description, rebin, plot or save.

MAGRATHEA solves planet interiors and considers the case of fully differentiated interiors. The code integrates the hydrostatic equation in order to determine the correct planet radius given the mass in each layer. The code returns the pressure, temperature, density, phase, and radius at steps of enclosed mass. The code support four layers: core, mantle, hydrosphere, and atmosphere. Each layer has a phase diagram with equations of state chosen for each phase.

COWS (COsmic Web Skeleton) implements the cosmic filament finder COsmic Web Skeleton (COWS). Written in Python, the cosmic filament finder works on Hessian-based cosmic web identifiers (such as the V-web) and returns a catalogue of filament spines. The code identifies the medial axis, or skeleton, of cosmic web filaments and then separates this skeleton into individual filaments.

statmorph calculates non-parametric morphological diagnostics of galaxy images (e.g., Gini-M_{20} and CAS statistics), and fits 2D Sérsic profiles. Given a background-subtracted image and a corresponding segmentation map indicating the source(s) of interest, statmorph calculates the following morphological statistics for each source:
- Gini-M20 statistics;
- Concentration, Asymmetry and Smoothness (CAS) statistics;
- Multimode, Intensity and Deviation (MID) statistics;
- outer asymmetry and shape asymmetry;
- Sérsic index; and,
- several shape and size measurements associated to the above statistics, such as ellipticity, Petrosian radius, and half-light radius, among others.

AltaiPony de-trend light curves from Kepler, K2, and TESS missions, and searches them for flares. The code also injects and recovers synthetic flares to account for de-trending and noise loss in flare energy and determines energy-dependent recovery probability for every flare candidate. AltaiPony uses K2SC (ascl:1605.012), AstroPy (ascl:1304.002) and lightkurve (ascl:1812.013) in addition to other common codes, and extensive documentation and tutorials are provided for the software.

fermi-gce-flows uses a machine learning-based technique to characterize the contribution of modeled components, including unresolved point sources, to the GCE. It can perform posterior parameter estimation while accounting for pixel-to-pixel spatial correlations in the gamma-ray map. On application to Fermi data, the method generically attributes a smaller fraction of the GCE flux to unresolved point source-like emission when compared to traditional approaches.

tellrv measures absolute radial velocities for low-resolution NIR spectra. It uses telluric features to provide absolute wavelength calibration, and then cross-correlates with a standard star. Observations of a standard star are included for convenience; the code also requires both the telluric and non-telluric-corrected spectra.

dark-photons-perturbations determines constraints from Cosmic Microwave Background photons oscillating into dark photons, and from heating of the primordial plasma due to dark photon dark matter converting into low-energy photons in an inhomogeneous universe.

AllStarFit analyzes optical and infrared images and includes functions for:
- object detection and image segmentation using the ProFound package (ascl:1804.006);
- PSF determination using the ProFit package (ascl:1612.004) to fit multiple stars in the field simultaneously; and
- galaxy modelling with ProFit, using the previously determined PSF and user-specified models.

AllStarFit supports a variety of optimization methods (provided by external packages), including maximum-likelihood and Markov chain Monte Carlo (MCMC).

FitsMap visualizes astronomical image and catalog data. Implemented in Python, the software is a simple, lightweight tool, requires only a simple web server, and can scale to over gigapixel images with tens of millions of sources. Further, the web-based visualizations can be viewed performantly on mobile devices.

BLOSMapping determines the line-of-sight component of magnetic fields associated with molecular clouds. The code uses Faraday rotation measure catalogs along with an on-off approach based on relative measurements to estimate the rotation measure caused by molecular clouds. It then uses the outputs from a chemical evolution code along with extinction maps to determine the line-of-sight magnetic field strength and direction.

AstroToolBox identifies and classifies astronomical objects with a focus on low-mass stars and ultra-cool dwarfs. It can search numerous catalogs, including SIMBAD (measurements & references), AllWISE, Gaia, SDSS, among others, evaluates spectral type for main sequence stars including brown dwarfs, and provides SED fitting for ultra-cool and white dwarfs. AstroToolBox draws Gaia color-magnitude diagrams (CMD) with overplotted M0-M9 spectral types, and can draw Montreal Cooling Sequences on the white dwarf branch of the Gaia CMD. The tool can also blink images from different epochs in an image viewer, thus allowing visual identification of the motion or variability of objects. The software displays time series (static or animated) using infrared and optical images of various surveys and contains a photometric classifier. It also includes astrometric calculators and converters, an ADQL query interface (IRSA, VizieR, NOAO) and a batch spectral type lookup feature that uses a CSV file with object coordinates as input. The ToolBox also has a file browser linked to the image viewer, which makes it possible to check a large list of objects in a convenient way, and can save interesting finds in an object collection for later use.

EzTao models time series as a continuous-time autoregressive moving-average (CARMA) process. EzTao utilizes celerite (ascl:1709.008), a fast and scalable Gaussian Process Regression library, to evaluate the likelihood function. On average, EzTao is ten times faster than other tools relying on a Kalman filter for likelihood computation.

JexoSim 2.0 (JWST Exoplanet Observation Simulator) simulates exoplanet transit observations using all four instruments of the James Webb Space Telescope, and is designed for the planning and validation of science cases for JWST. The code generates synthetic spectra that capture the full impact of complex noise sources and systematic trends, allowing for assessment of both accuracy and precision in the final spectrum. JexoSim does not contain all known systematics for the various instruments, but is a good starting point to investigate the effects of systematics, and has the framework to incorporate more systematics in the future.

HoloSim-ML performs beam simulation and analysis of radio holography data from complex optical systems. The code uses machine learning to efficiently determine the position of hundreds of mirror adjusters on multiple mirrors with few micron accuracy.

The Fast Template Periodogram extends the Generalised Lomb Scargle periodogram (Zechmeister and Kurster 2009) for arbitrary (periodic) signal shapes. A template is first approximated by a truncated Fourier series of length H. The Nonequispaced Fast Fourier Transform NFFT is used to efficiently compute frequency-dependent sums. Template fitting can now be done in NlogN time, improving existing algorithms by an order of magnitude for even small datasets. The FTP can be used in conjunction with gradient descent to accelerate a non-linear model fit, or be used in place of the multi-harmonic periodogram for non-sinusoidal signals with a priori known shapes.

The l1 periodogram searches for periodicities in unevenly sampled time series. It can be used similarly as a Lomb-Scargle periodogram, and retrieves a figure which has a similar aspect but has fewer peaks due to aliasing. It is primarily designed for the search of exoplanets in radial velocity data, but can be also used for other purposes. The principle of the algorithm is to search for a representation of the input signal as a sum of a small number of sinusoidal components, that is a representation which is sparse in the frequency domain. Here, "small number" means small compared to the number of observations.

wpca, written in Python, offers several implementations of Weighted Principal Component Analysis and uses an interface similar to scikit-learn's sklearn.decomposition.PCA. Implementations include a direct decomposition of a weighted covariance matrix to compute principal vectors, and then a weighted least squares optimization to compute principal components, and an iterative expectation-maximization approach to solve simultaneously for the principal vectors and principal components of weighted data. It also includes a standard non-weighted PCA implemented using the singular value decomposition, primarily to be useful for testing.

hankl implements the FFTLog algorithm in lightweight Python code. The FFTLog algorithm can be thought of as the Fast Fourier Transform (FFT) of a logarithmically spaced periodic sequence (= Hankel Transform). hankl consists of two modules, the General FFTLog module and the Cosmology one. The latter is suited for modern cosmological application and relies heavily on the former to perform the Hankel transforms. The accuracy of the method usually improves as the range of integration is enlarged; FFTlog prefers an interval that spans many orders of magnitude. Resolution is important, as low resolution introduces sharp features which in turn causes ringing.

GRIT (Gravitational Rigid-body InTegrators) simulaties the coupled dynamics of both spin and orbit of N gravitationally interacting rigid bodies. The code supports tidal forces and general relativity correction are supported, and multiple schemes with different orders of convergences and splitting strategies are available. Multiscale splittings boost the simulation speed, and force evaluations can be parallelized. In addition, each body can be set to be a rigid body or just a point mass, and the floating-point format can be customized as float, double, or long double globally.

BayesicFitting fits models to data. Data in this context means a set of (measured) points x and y. The model provides some (mathematical) relation between the x and y. Fitting adapts the model such that certain criteria are optimized. The BayesicFitting toolbox also determines whether one model fits the data better than another, making the toolbox particularly powerful. The package consists of more than 100 Python classes, of which one third are model classes. Another third are fitters in one guise or another along with additional tools, and the remaining third is used for Nested Sampling.

The O'TRAIN package identifies transients in astronomical images based on a Convolutional Neural Network (CNN). It works on images from different telescopes and, through the use of Docker, can be deployed on different operating systems. O'TRAIN uses image cutouts containing real and false transients provided by the user to train a CNN algorithm implemented with Keras. Built-in diagnostics help to characterize the accuracy of the training, and a trained model is used to classify any new cutouts.

Optab, written in Fortran90, generates ideal-gas opacity tables. It computes opacity based on user-provided chemical equilibrium abundances, and outputs mean opacities as well as monochromatic opacities, thus providing opacity tables that are consistent with one's equation of state for radiation hydrodynamics simulations. For convenience, Optab also provides interfaces for FastChem (ascl:1804.025) or TEA (ascl:1505.031) for computing chemical abundances.

deeplenstronomy simulates large datasets for applying deep learning to strong gravitational lensing. It wraps the functionalities of lenstronomy (ascl:1804.012) in a convenient yaml-style interface to generate training datasets. The code can use built-in astronomical surveys, realistic galaxy colors, real images of galaxies, and physically motivated distributions of all parameters to train the neural network to create a simulated dataset.

TESSreduce builds on lightkurve (ascl:1812.013) to reduce TESS data while preserving transient signals. It takes a TPF as input (supplied or constructed with TESScut (https://mast.stsci.edu/tesscut/). The background subtraction accounts for the smooth background and detector straps. In addition to background subtraction, TESSreduce also aligns images, performs difference imaging, detects transient events, and by using PS1 data, can calibrate TESS counts to physical flux or AB magnitudes.

The SAPHIRES (Stellar Analysis in Python for HIgh REsolution Spectroscopy) suite contains functions for analyzing high-resolution stellar spectra. Though most of its functionality is aimed at deriving radial velocities (RVs), the suite also includes capabilities to measure projected rotational velocities (vsini) and determine spectroscopic flux ratios in double-lined binary systems (SB2s). These measurements are made primarily by computing spectral-line broadening functions. More traditional techniques such as Fourier cross-correlation, and two-dimensional cross-correlation (TODCOR) are also included.

Qwind3 models radiation-driven winds originating from accretion discs. An improvement over Qwind (ascl:2112.013), it derives the wind initial conditions and has significantly improved ray-tracing to calculate the wind absorption self consistently given the extended nature of the UV emission. It also corrects the radiation flux for relativistic effects, and assesses the impact of this on the wind velocity.

Qwind simulates the launching and acceleration phase of line-driven winds in the context of AGN accretion discs. The wind is modeled as a set of streamlines originating on the surface of the AGN accretion disc, and evolved following their equation of motion, given by the balance between radiative and gravitational force.

DiracVsMajorana determines the statistical significance with which a successful electron scattering experiment could reject the Majorana hypothesis -- that dark matter (DM) particles are their own anti-particles, a so-called Majorana fermion -- using the likelihood ratio test in favor of the hypothesis of Dirac DM. The code assumes that the DM interacts with the photon via higher-order electromagnetic moments. It requires tabulated atomic response functions, which can be computed with DarkARC (ascl:2112.011), to compute ionization spectra and predictions for signal event rates.

DarkARC computes and tabulates atomic response functions for direct sub-GeV dark matter (DM) searches. The tabulation of the atomic response functions is separated into two steps: 1.) the computation and tabulation of three radial integrals, and 2.) their combination into the response function tables. The computations are performed in parallel using the multiprocessing library.

WIMpy_NREFT (also known as WIMpy) calculates Dark Matter-Nucleus scattering rates in the framework of non-relativistic effective field theory (NREFT). It currently supports operators O1 to O11, as well as millicharged and magnetic dipole Dark Matter. It can be used to generate spectra for Xenon, Argon, Carbon, Germanium, Iodine and Fluorine targets. WIMpy_NREFT also includes functionality to calculate directional recoil spectra, as well as signals from coherent neutrino-nucleus scattering (including fluxes from the Sun, atmosphere and diffuse supernovae).

The Bayesian-based Gaussian Process model AsteroGaP (Asteroid Gaussian Processes) fits sparsely-sampled asteroid light curves. By utilizing a more flexible Gaussian Process framework for modeling asteroid light curves, it is able to represent light curves in a periodic but non-sinusoidal manner.

MISTTBORN can simultaneously fit multiple types of data within an MCMC framework. It handles photometric transit/eclipse, radial velocity, Doppler tomographic, or individual line profile data, for an arbitrary number of datasets in an arbitrary number of photometric bands for an arbitrary number of planets and allows the use of Gaussian process regression to handle correlated noise in photometric or Doppler tomographic data. The code can include dilution due to a nearby unresolved star in the transit fits, and an additional line component due to another star or scattered sun/moonlight in Doppler tomographic or line profile fits. It can also be used for eclipsing binary fits, including a secondary eclipse and radial velocities for both stars. MISTTBORN produces diagnostic plots showing the data and best-fit models and the associated code MISTTBORNPLOTTER produces publication-quality plots and tables.

NeutrinoFog calculates the neutrino floor based on the derivative of a hypothetical experimental discovery limit as a function of exposure, and leads to a neutrino floor that is only influenced by the systematic uncertainties on the neutrino flux normalizations.

STDPipe is a set of Python routines for astrometry, photometry and transient detection related tasks, intended for quick and easy implementation of custom pipelines, as well as for interactive data analysis. It is implemented as a library of routines covering most common tasks and operates on standard Python objects, including NumPy arrays for images and Astropy (ascl:1304.002) tables for catalogs and object lists. The pipeline does not re-implement code already implemented in other Python packages; instead, it transparently wraps external codes, such as SExtractor (ascl:1010.064), SCAMP (ascl:1010.063), PSFEx (ascl:1301.001), HOTPANTS (ascl:1504.004), and Astrometry.Net (ascl:1208.001), that do not have their own Python interfaces. STDPipe operates on temporary files, keeping nothing after the run unless something is explicitly requested.

Interferopy analyzes datacubes from radio-to-submm observations. It provides a homogenous interface to common tasks, making it easy to go from reduced datacubes to essential measurements and publication-quality plots. Its core functionalities are widely applicable and have been successfully tested on (but are not limited to) ALMA, NOEMA, VLA and JCMT data.

Defringe corrects fringe artifacts in near-infrared astronomical images taken with old generation CCD cameras. It essentially solves a robust PCA problem, masking out astrophysical sources, and models the contaminants as a linear superposition of (unknown) modes, with (unknown) projection coefficients. The problem uses nuclear norm regularization, which acts as a convex proxy for rank minimization. The code is written in python, using cupy for GPU acceleration, but will also work on CPUs.

The Python package SCORPIO retrieves images and associated data of galaxy pairs based on their position, facilitating visual analysis and data collation of multiple archetypal systems. The code ingests information from SDSS, 2MASS and WISE surveys based on the available bands and is designed for studies of galaxy pairs as natural laboratories of multiple astrophysical phenomena for, among other things, tidal force deformation of galaxies, pressure gradient induced star formation regions, and morphological transformation.

QUESTFIT fit the Spitzer mid-infrared spectra of the QUEST (Quasar ULIRG and Evolution STudy) sample. It uses two PAH templates atop an extincted and absorbed continuum model to fit the mid-IR spectra of galaxies that are heavily-absorbed. It also fits AGN with silicate models. The current version of QUESTFIT is optimized for processing spectra from the CASSIS (Combined Atlas of Sources with Spitzer IRS Spectra) portal to produce PAH fluxes for heavily absorbed sources.

pyCELP (aka "pi-KELP") calculates Coronal Emission Line Polarization. It forward synthesizes the polarized emission of ionized atoms formed in the solar corona and calculates the atomic density matrix elements for a single ion under coronal equilibrium conditions and excited by a prescribed radiation field and thermal collisions. pyCELP solves a set of statistical equilibrium equations in the spherical statistical tensor representation for a multi-level atom for the no-coherence case. This approximation is useful in the case of forbidden line emission by visible and infrared lines, such as Fe XIII 1074.7 nm and Si X 3934 nm.

DIPol-UF provides tools for remote control and operation of DIPol-UF, an optical (BVR) imaging CCD polarimeter. The project contains libraries that handle low-level interoperation with ANDOR SDK (provided by the CCD manufacturer), communication with stepper motors (which perform plate rotations), FITS file serialization/deserialization, over-network communication between different system components (each CCD is connected to a standalone PC), as well as provide GUI (built with WPF).

An internally overhauled but fundamentally similar version of Forecaster by Jingjing Chen and David Kipping, originally presented in arXiv:1603.08614 and hosted at https://github.com/chenjj2/forecaster.

The model itself has not changed- no new data was included and the hyperparameter file was not regenerated. All functions were rewritten to take advantage of Numpy vectorization and some additional user features were added. Now able to be installed via pip.

The caustic technique is a powerful method to infer cluster mass profiles to clustrocentric distances well beyond the virial radius. It relies in the measure of the escape velocity of the sistem using only galaxy redshift information. This method was introduced by Diaferio & Geller (1997) and Diaferio (1999). This code allows the caustic mass estimation for galaxy clusters, as well as outlier identification as a side effect. However, a pre-cleaning of interlopers is recommended, using e.g., the shifting-gapper technique.

GWToolbox simulates gravitational wave observations for various detectors. The package is composed of three modules, namely the ground-based detectors (and their targets), the space-borne detectors (and their targets) and pulsar timing arrays (PTA). These three modules work independently and have different dependencies on other packages and libraries; failed dependencies met in one module will not influence the usage of another module. GWToolbox can accessed with a web interface (gw-universe.org) or as a python package (https://bitbucket.org/radboudradiolab/gwtoolbox).

pySYD detects solar-like oscillations and measures global asteroseismic parameters. The code is a python-based implementation of the IDL-based SYD pipeline by Huber et al. (2009), which was extensively used to measure asteroseismic parameters for Kepler stars, and adapts the well-tested methodology from SYD and also improves these existing analyses. It also provides additional capabilities, including an automated best-fit background model selection, parallel processing, the ability to samples for further analyses, and an accessible and command-line friendly interface. PySYD provides best-fit values and uncertainties for the granulation background, frequency of maximum power, large frequency separation, and mean oscillation amplitudes.

SteParSyn infers stellar atmospheric parameters (Teff, log g, [Fe/H], and Vbroad) of FGKM-type stars using the spectral synthesis method. The code uses the MCMC sampler emcee (ascl:1303.002) in conjunction with an spectral emulator that can interpolate spectra down to a precision < 1%. A grid of synthetic spectra that allow the user to characterize the spectra of FGKM-type stars with parameters in the range of 3500 to 7000 K in Teff, 0.0 to 5.5 dex in log g, and −2.0 to 1.0 dex in [Fe/H] is also provided.

gCMCRT globally processes 3D atmospheric data, and as a fully 3D model, it avoids the biases and assumptions present when using 1D models to process 3D structures. It is well suited to performing the post-processing of large parameter GCM model grids, and provides simple pipelines that convert the 3D GCM structures from many well used GCMs in the community to the gCMCRT format, interpolating chemical abundances (if needed) and performing the required spectra calculation. The high-resolution spectra modes of gCMCRT provide an additional highly useful capability for 3D modellers to directly compare output to high-resolution spectral data.

The data analysis UniMAP (Unicorn Multi-window Anomaly Detection Pipeline) leverages the Temporal Outlier Factor (TOF) method to find anomalies in LVC data. The pipeline requires a target detector and a start and stop GPS time describing a time interval to analyze, and has three outputs: 1.) an array of GPS times corresponding to TOF detections; 2.) a long q-transform of the entire data interval with visualizations of the TOF detections in the time series; and 3.) q-transforms of the data windows that triggered TOF detections.

Astrosat calculates which satellites can be seen by a given observer in a given field of view at a given observation time and observation duration. This includes the geometry of the satellite and observer but also estimates the expected apparent brightness of the satellite to aid astronomers in assessing the impact on their observations.

flatstar is an open-source Python tool for drawing stellar disks as numpy.ndarray objects with scientifically-rigorous limb darkening. Each pixel has an accurate fractional intensity in relation to the total stellar intensity of 1.0. It is ideal for ray-tracing simulations of stars and planetary transits. The code is fast, has the most well-known limb-darkening laws, including linear, quadratic, square-root, logarithmic, and exponential, and allows the user to implement custom limb-darkening laws. flatstar also offers supersampling for situations where both coarse arrays and precision in stellar disk intensity (i.e., no hard pixel boundaries) is desired, and upscaling to save on computation time when high-resolution intensity maps are needed, though there is some precision loss in intensities.

p-winds produces simplified, 1-D models of the upper atmosphere of a planet and performs radiative transfer to calculate observable spectral signatures. The scalable implementation of 1D models allows for atmospheric retrievals to calculate atmospheric escape rates and temperatures. In addition, the modular implementation allows for a smooth plugging-in of more complex descriptions to forward model their corresponding spectral signatures (e.g., self-consistent or 3D models).

Nii implements an automatic parallel tempering Markov chain Monte Carlo (APT-MCMC) framework for sampling multidimensional posterior distributions and provides an observation simulation platform for the differential astrometric measurement of exoplanets. Although this code specifically focuses on the orbital parameter retrieval problem of differential astrometry, Nii can be applied to other scientific problems with different posterior distributions and offers many control parameters in the APT part to facilitate the adjustment of the MCMC sampling strategy; these include the number of parallel chains, the β values of different chains, the dynamic range of the sampling step sizes, and frequency of adjusting the step sizes.

CoLoRe (Cosmological Lofty Realization) generates fast mock realizations of a given galaxy sample using a lognormal model or LPT for the matter density. Tt can simulate a variety of cosmological tracers, including photometric and spectroscopic galaxies, weak lensing, and intensity mapping. CoLoRe is a parallel C code, and its behavior is controlled primarily by the input param file.

The COCOPLOT (COlor COllapsed PLOTting) quick-look and context image code conveys spectral profile information from all of the spatial pixels in a 3D datacube as a single image using color. It can also identify and expose temporal behavior and display and highlight solar features. COCOPLOT thus aids in identifying regions of interest quickly. The software is available in Python and IDL, and can be used as a standalone package or integrated into other software.

LEGWORK (LISA Evolution and Gravitational Wave ORbit Kit) is a simple package for gravitational wave calculations. It evolves binaries and computes signal-to-noise ratios for binary systems potentially observable with LISA; it also visualizes the results. LEGWORK can also compare different detector sensitivity curves, compute the horizon distance for a collection of sources, and tracks signal-to-noise evolution over time.

prose provides pipelines for performing common tasks, such as automated calibration, reduction and photometry, and makes building custom pipelines easy. The prose framework is instrument-agnostic and makes constructing pipelines easy. It offers a wide range of implemented building blocks and also allows users to define their own.

CEvNS calculates Coherent Elastic Neutrino-Nucleus Scattering (CEvNS) cross sections and recoil spectra. It includes (among other things) the Standard Model contribution to the CEvNS cross section, along with the contribution from Simplified Models with new vector or scalar mediators. It also covers neutrino magnetic moments and non-standard contact neutrino interactions (NSI).

The library NLopt performs nonlinear local and global optimization for functions with and without gradient information. It provides a simple, unified interface and wraps many algorithms for global and local, constrained or unconstrained, optimization, and provides interfaces for many other languages, including C++, Fortran, Python, Matlab or GNU Octave, OCaml, GNU Guile, GNU R, Lua, Rust, and Julia.

PSwarm is a global optimization solver for bound and linear constrained problems (for which the derivatives of the objective function are unavailable, inaccurate or expensive). The algorithm combines pattern search and particle swarm. Basically, it applies a directional direct search in the poll step (coordinate search in the pure simple bounds case) and particle swarm in the search step. PSwarm makes no use of derivative information of the objective function. It has been shown to be efficient and robust for smooth and nonsmooth problems, both in serial and in parallel.

JAX brings Autograd and XLA together for high-performance machine learning research. It can automatically differentiate native Python and NumPy functions. The code can differentiate through loops, branches, recursion, and closures, and it can take derivatives of derivatives of derivatives. JAX supports reverse-mode differentiation (a.k.a. backpropagation) via grad as well as forward-mode differentiation, and the two can be composed arbitrarily to any order.

astroDDPM uses a denoising diffusion probabilistic model (DDPM) to synthesize galaxies that are qualitatively and physically indistinguishable from the real thing. The similarity of the synthesized images to real galaxies from the Photometry and Rotation curve OBservations from Extragalactic Surveys (PROBES) sample and from the Sloan Digital Sky Survey is quantified using the Fréchet Inception Distance to test for subjective and morphological similarity. The emergent physical properties (such as total magnitude, color, and half light radius) of a ground truth parent and synthesized child dataset are also compared to generate a Synthetic Galaxy Distance metric. The DDPM approach produces sharper and more realistic images than other generative methods such as Adversarial Networks (with the downside of more costly inference), and could be used to produce large samples of synthetic observations tailored to a specific imaging survey. Potential uses of the DDPM include accurate in-painting of occluded data, such as satellite trails, and domain transfer, where new input images can be processed to mimic the properties of the DDPM training set.

As a new generation of large-scale telescopes are expected to produce single data products in the range of hundreds of GBs to multiple TBs, different approaches to I/O efficient data interaction and extraction need to be investigated and made available to researchers. This will become increasingly important as the downloading and distribution of TB scale data products will become unsustainable, and researchers will have to take their processing analysis to the data. We present a methodology to extract 3 dimensional spatial-spectral data from dimensionally modelled tables in Parquet format on a Hadoop system. The data is loaded into the Parquet tables from FITS cube files using a dedicated process. We compare the performance of extracting data using the Apache Spark parallel compute framework on top of the Parquet-Hadoop ecosystem with data extraction from the original source files on a shared file system. We have found that the Spark-Parquet-Hadoop solution provides significant performance benefits, particularly in a multi user environment. We present a detailed analysis of the single and multi-user experiments conducted and also discuss the benefits and limitations of the platform used for this study.

XookSuut models circular and noncircular flows on resolved velocity maps. The code performs nonparametric fits to derive kinematic models without assuming analytical functions on the different velocity components of the models. It recovers the circular and radial motions in galaxies in dynamical equilibrium and can derive the noncircular motions induced by oval distortions, such as that produced by stellar bars. XookSuut explores the full space of parameters on a N-dimensional space to derive their mean values; this combined method efficiently recovers the constant parameters and the different kinematic components.

PT-REX (Point-to-point TRend EXtractor) performs ptp analysis on every kind of extended radio source. The code exploits a set of different fitting methods to allow study of the spatial correlation, and is structured in a series of tasks to handle the individual steps of a ptp analysis independently, from defining a grid to sample the radio emission to accurately analyzing the data using several statistical methods. A major feature of PT-REX is the use of an automatic, randomly-generated sampling routine to combine several SMptp analysis into a Monte Carlo ptp (MCptp) analysis. By repeating several cycles of SMptp analysis with randomly-generated grids, PT-REX produces a distribution of values of k that describe its parameter space, thus allowing a reliably estimate of the trend (and its uncertainties).

BCES performs robust linear regression on (X,Y) data points where both X and Y have measurement errors. The fitting method is the bivariate correlated errors and intrinsic scatter (BCES). Some of the advantages of BCES regression compared to ordinary least squares fitting are that it allows for measurement errors on both variables and permits the measurement errors for the two variables to be dependent. Further it permits the magnitudes of the measurement errors to depend on the measurements and other lines such as the bisector and the orthogonal regression can be constructed.

SELCIE (Screening Equations Linearly Constructed and Iteratively Evaluated) investigates the chameleon model that arises from screening a scalar field introduced in some modified gravity models that is coupled to matter. The code provides tools to construct user defined meshes by utilizing the GMSH mesh generation software. These tools include constructing shapes whose boundaries are defined by some function or by constructing it out of basis shapes such as circles, cones and cylinders. The mesh can also be separated into subdomains, each of which having its own refinement parameters. These meshes can then be converted into a format that is compatible with the finite element software FEniCS. SELCIE uses FEniCS (ascl:2110.018) with a nonlinear solving method (Picard or Newton method) to solve the chameleon equation of motion for some parameters and density distribution. These density distributions are constructed by having the density profile of each subdomain being set by a user defined function, allowing for extremely customizable setups that are easy to implement.

FEniCS solves partial differential equations (PDEs) and enables users to quickly translate scientific models into efficient finite element code. With the high-level Python and C++ interfaces to FEniCS, it is easy to get started, but FEniCS offers also powerful capabilities for more experienced programmers. FEniCS runs on a multitude of platforms ranging from laptops to high-performance clusters, and each component of the FEniCS platform has been fundamentally designed for parallel processing. This framework allows for rapid prototyping of finite element formulations and solvers on laptops and workstations, and the same code may then be deployed on large high-performance computers.

ThERESA retrieves three-dimensional maps of exoplanets. The code constructs 2-dimensional maps for each light given light curve, places those maps vertically in an atmosphere, and runs radiative transfer to calculate emission from the planet over a latitude/longitude grid. ThERESA then integrates over the grid (combined with the visibility function) to generate light curves. These light curves are compared against the input light curves behind MCMC to explore parameter space.

Pyro is a flexible, scalable deep probabilistic programming library built on PyTorch. It can represent any computable probability distribution and scales to large data sets with little overhead compared to hand-written code. The library is implemented with a small core of powerful, composable abstractions. Its high-level abstractions express generative and inference models, but also allows experts to customize inference.

Flux provides an elegant approach to machine learning. Written in Julia, it provides lightweight abstractions on top of Julia's native GPU and AD support. It has many useful tools built in, but also lets you use the full power of the Julia language where you need it. Flux has relatively few explicit APIs for features like regularization or embeddings; instead, writing down the mathematical form works and is fast. The package works well with Julia libraries from data frames and images to differential equation solvers, so building complex data processing pipelines that integrate Flux models is straightforward.

Swordfish studies the information yield of counting experiments. It implements at its core a rather general version of a Poisson point process with background uncertainties described by a Gaussian random field, and provides easy access to its information geometrical properties. Based on this information, a number of common and less common tasks can be performed. Swordfish allows quick and accurate forecasts of experimental sensitivities without time-intensive Monte Carlos, mock data generation and likelihood maximization. It can:

- calculate the expected upper limit or discovery reach of an instrument;
- derive expected confidence contours for parameter reconstruction;
- visualize confidence contours as well as the underlying information metric field;
- calculate the information flux, an effective signal-to-noise ratio that accounts for background systematics and component degeneracies; and
- calculate the Euclideanized signal which approximately maps the signal to a new vector which can be used to calculate the Euclidean distance between points.

Nauyaca infers planetary masses and orbits from mid-transit times fitting. The code requires transit ephemeris per planet and stellar mass and radius, and uses minimization routines and a Markov chain Monte Carlo method to find planet parameters that best reproduce the transit times based on numerical simulations. The code package provides customized plotting tools for analyzing the results.

GGCHEMPY is efficient for building 1-D, 2-D and 3-D simulations of physical parameters of Planck galactic cold clumps; it provides a graphical user interface and can also be invoked by a Python script. The code initializes the reaction network using input parameters, and then computes the reaction rate coefficients for all reactions. It uses the backward-differentiation formulas method to solve the ordinary differential equations for the integration. The modeled results are saved and can be directly passed to a Python dictionary for analysis and plotting.

The Julia library GRASS produces realistic stellar spectra with time-variable granulation signatures. It is based on real observations of the Sun, and does not rely on magnetohydrodynamic simulations to produce its spectra. GRASS can also compute bisectors for absorption lines or CCF profiles, and provides two methods for calculating bisectors.

BASTA determines properties of stars using a pre-computed grid of stellar models. It calculates the probability density function of a given stellar property based on a set of observational constraints defined by the user. BASTA is very versatile and has been used in a large variety of studies requiring robust determination of fundamental stellar properties.