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.

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.

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.

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.

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.

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.

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

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

The deep learning model Starduster emulates dust radiative transfer simulations, which significantly accelerates the computation of dust attenuation and emission. Starduster contains two specific generative models, which explicitly take into account the features of the dust attenuation curves and dust emission spectra. Both generative models should be trained by a set of characteristic outputs of a radiative transfer simulation. The obtained neural networks can produce realistic galaxy spectral energy distributions that satisfy the energy balance condition of dust attenuation and emission. Applications of Starduster include SED-fitting and SED-modeling from semi-analytic models.

SunnyNet learns the mapping the between LTE and NLTE populations of a model atom and predicts the NLTE populations based on LTE populations for an arbitrary 3D atmosphere. To use SunnyNet, one must already have a set of LTE and NLTE populations computed in 3D, to train the network. These must come from another code, as SunnyNet is unable to solve the formal problem. Once SunnyNet is trained, one can feed it LTE populations from a different 3D atmosphere, and obtain predicted NLTE populations. The NLTE populations can then be used to synthesize any spectral line that is included in the model atom. SunnyNet's output is a file with predicted NLTE populations. SunnyNet itself does not calculate synthetic spectra, but a sample script written in the Julia language that quickly computes Hα spectra is included.

INSANE (INflationary potential Simulator and ANalysis Engine) takes either a numeric inflationary potential or a symbolic one, calculates the background evolution and then, using the Mukhanov-Sasaki equations, calculates the primordial power spectrum it yields. The package can analyze the results to extract the spectral index n_s, the index running alpha, the running of running and possibly higher moments. The package contains two main modules: BackgroundSolver solves the background equations, and the MsSolver module solves and analyses the MS equations.

topoaccel calculates topological acceleration for several of the S^3 quotient spaces considered 'regular', in that they have a Platonic solid as one of their fundamental domain shapes, and are globally homogeneous. The topoaccel scripts can be run using the free-licensed software package Maxima (https://maxima.sourceforge.io/documentation.html).

The Roman Coronagraph Exposure Time Calculator (Roman_Coronagraph_ETC for short) is the public version of the exposure time calculator of the Coronagraph Instrument aboard the Nancy Grace Roman Space Telescope funded by NASA. The methods used to estimate the integration times are based upon peer reviewed research articles (see Bibliography) and a collection of instrumental and modeling parameters of both the Coronagraph Instrument and the Nancy Grace Roman Space Telescope. The code is written in python. Visit https://github.com/hsergi/Roman_Coronagraph_ETC for more information.

SISTER (Starshade Imaging Simulations Toolkit for Exoplanet Reconnaissance) predicts how an exoplanet system would look in an instrument that utilizes an Starshade to block the light from the host star. The tool allows for controlling a set of parameters of the whole instrument for: (1) the Starshade design, (2) the exoplanetary system, (3) the telescope and (4) the camera. SISTER includes plotting software, and can also store simulations on disk for plotting with other software.

exoVista generates a "universe" of planetary systems, creating thousands of models of quasi-self-consistent planetary systems around known nearby stars at scattered light wavelengths. It efficiently records the position, velocity, spectrum, and physical parameters of all bodies as functions of time. exoVista models can be used for simulating surveys using the direct imaging, transit, astrometric, and radial velocity techniques.

NIMBLE (Non-parametrIc jeans Modeling with B-spLinEs) inferrs the cumulative mass distribution of a gravitating system from full 6D phase space coordinates of its tracers via spherical Jeans modeling. It models the Milky Way's dark matter halo using Gaia and Dark Energy Spectroscopic Instrument Milky Way Survey (DESI MWS) data. NIMBLE includes a basic inverse modeling Jeans routine that assumes perfect and complete data is available and a more complex forward modeling Jeans routine that deconvolves observational effects (uncertainties and limited survey volume) characteristic of Gaia and the DESI-MWS. It also includes tools for generating simple equilibrium model galaxies using Agama (ascl:1805.008) and imposing mock Gaia+DESI errors on 6D phase space input data.

imexam performs simple image examination and plotting, with similar functionality to IRAF's (ascl:9911.002) imexamine. It is a lightweight library that enables users to explore data from a command line interface, through a Jupyter notebook, or through a Jupyter console. imexam can be used with multiple viewers, such as DS9 (scl:0003.002) or Ginga (ascl:1303.020), or without a viewer as a simple library to make plots and grab quick photometry information. It has been designed so that other viewers may be easily attached in the future.

pygacs manipulates Gaia catalog tables hosted at ESA's Gaia Archive Core Systems (GACS). It provides python modules for the access and manipulation of tables in GACS, such as a basic query on a single table or crossmatch between two tables. It employs the TAP command line access tools described in the Help section of the GACS web pages. Both public and authenticated access have been implemented.

starry_process implements an interpretable Gaussian process (GP) for modeling stellar light curves. The code's hyperparameters are physically interpretable, and include the radius of the spots, the mean and variance of the latitude distribution, the spot contrast, and the number of spots, among others. The rotational period of the star, the limb darkening parameters, and the inclination (or marginalize over the inclination if it is not known) can also be specified.

GAMERA handles spectral modeling of non-thermally emitting astrophysical sources in a simple and modular way. It allows the user to devise time-dependent models of leptonic and hadronic particle populations in a general astrophysical context (including SNRs, PWNs and AGNs) and to compute their subsequent photon emission. GAMERA can calculate the spectral evolution of a particle population in the presence of time-dependent or constant injection, energy losses and particle escape; it also calculates the radiation spectrum from a parent particle population.

MIRaGe creates simulated exposures for NIRCam’s imaging and wide field slitless spectroscopy (WFSS) modes, NIRISS’s imaging, WFSS, and aperture masking interferometery (AMI) modes, and FGS’s imaging mode. It supports sidereal as well as non-sidereal tracking; for example, sources can be made to move across the field of view within an observation.

fleck simulates rotational modulation of stars due to starspots and is used to overcome the degeneracies and determine starspot coverages accurately for a sample of young stars. The code simulates starspots as circular dark regions on the surfaces of rotating stars, accounting for foreshortening towards the limb, and limb darkening. Supplied with the latitudes, longitudes, and radii of spots and the stellar inclinations from which each star is viewed, fleck takes advantage of efficient array broadcasting with numpy to return approximate light curves. For example, the code can compute rotational modulation curves sampled at ten points throughout the rotation of each star for one million stars, with two unique spots each, all viewed at unique inclinations, in about 10 seconds on a 2.5 GHz Intel Core i7 processor. This rapid computation of light curves en masse makes it possible to measure starspot distributions with techniques such as Approximate Bayesian Computation.

D2O acts as a layer of abstraction between algorithm code and data-distribution logic to manage cluster-distributed multi-dimensional numerical arrays; this provides usability without losing numerical performance and scalability. D2O's global interface makes the cluster node's local data directly accessible for use in customized high-performance modules. D2O is written in Python; the code is portable and easy to use and modify. Expensive operations are carried out by dedicated external libraries like numpy and mpi4py and performance scales well when moving to an MPI cluster. In combination with NIFTy, D2O enables supercomputer based astronomical imaging via RESOLVE (ascl:1505.028) and D3PO (ascl:1504.018).

SATCHEL (Search Algorithm for Transits in the Citizen science Hunt for Exoplanets in Lightcurves) searches for individual signals of interest in time-series data classified through crowdsourcing. The pipeline was built for the purpose of finding long-period exoplanet transit signals in Kepler photometric time-series data, but may be adapted for searches for any kind of one-dimensional signals in crowdsourced classifications.

pyobs enables remote and fully autonomous observation control of astronomical telescopes. It provides an abstraction layer over existing drivers and a means of communication between different devices (called modules in pyobs). The code can also act as a hardware driver for all the devices used at an observatory. In addition, pyobs offers non-hardware-related modules for automating focusing, acquisition, guiding, and other routine tasks.

PetroFit calculates Petrosian properties, such as radii and concentration indices; it also fits galaxy light profiles. The package, built on Photutils (ascl:1609.011), includes tools for performing accurate photometry, segmentations, Petrosian properties, and fitting.

AutoSourceID-Light (ASID-L) analyzes optical imaging data using computer vision techniques that can naturally deal with large amounts of data. The framework rapidly and reliably localizes sources in optical images.

easyFermi provides a user-friendly graphical interface for basic to intermediate analysis of Fermi-LAT data in the framework of Fermipy (ascl:1812.006). The code can measure the gamma-ray flux and photon index, build spectral energy distributions, light curves, test statistic maps, test for extended emission, and relocalize the coordinates of gamma-ray sources. Tutorials for easyFermi are available on YouTube and GitHub.

The MaNGA Data Reduction Pipeline (DRP) processes the raw data to produce flux calibrated, sky subtracted, coadded data cubes from each of the individual exposures for a given galaxy. The DRP consists of two primary parts: the 2d stage that produces flux calibrated fiber spectra from raw individual exposures, and the 3d stage that combines multiple flux calibrated exposures with astrometric information to produce stacked data cubes. These science-grade data cubes are then processed by the MaNGA Data Analysis Pipeline (ascl:2203.017), which measures the shape and location of various spectral features, fits stellar population models, and performs a variety of other analyses necessary to derive astrophysically meaningful quantities from the calibrated data cubes.

The MaNGA data analysis pipeline (MaNGA DAP) analyzes the data produced by the MaNGA data-reduction pipeline (ascl:2203.016) to produced physical properties derived from the MaNGA spectroscopy. All survey-provided properties are currently derived from the log-linear binned datacubes (i.e., the LOGCUBE files).

The Python package sympy2c allows creation and compilation of fast C/C++ based extension modules from symbolic representations. It can create fast code for the solution of high dimensional ODEs, or numerical evaluation of integrals where sympy fails to compute an anti-​derivative. Based on the symbolic formulation of a stiff ODE, sympy2c analyzes sparsity patterns in the Jacobian matrix of the ODE, and generates loop-​less fast code by unrolling loops in the internally used LU factorization algorithm and by avoiding unnecessary computations involving known zeros.

agnpy focuses on the numerical computation of the photon spectra produced by leptonic radiative processes in jetted Active Galactic Nuclei (AGN). It includes classes describing the galaxy components responsible for line and thermal emission and calculates the absorption due to gamma-gamma pair production on soft (IR-UV) photon fields.

MAMPOSSt (Modeling Anisotropy and Mass Profiles of Observed Spherical Systems) is a Bayesian code to perform mass/orbit modeling of spherical systems. It determines marginal parameter distributions and parameter covariances of parametrized radial distributions of dark or total matter, as well as the mass of a possible central black hole, and the radial profiles of density and velocity anisotropy of one or several tracer components, all of which are jointly fit to the discrete data in projected phase space. It is based upon the MAMPOSSt likelihood function for the distribution of individual tracers in projected phase space (projected radius and line-of-sight velocity) and the CosmoMC Markov Chain Monte Carlo code (ascl:1106.025), run in generic mode. MAMPOSSt is not based on the 6D distribution function (which would require triple integrals), but on the assumption that the local 3D velocity distribution is an (anisotropic) Gaussian (requiring only a single integral).