Written in FORTRAN, Athena3D, based on Athena (ascl:1010.014), is an implementation of a flux-conservative Godunov-type algorithm for compressible magnetohydrodynamics. Features of the Athena3D code include compressible hydrodynamics and ideal MHD in one, two or three spatial dimensions in Cartesian coordinates; adiabatic and isothermal equations of state; 1st, 2nd or 3rd order reconstruction using the characteristic variables; and numerical fluxes computed using the Roe scheme. In addition, it offers the ability to add source terms to the equations and is parallelized based on MPI.

The ARoMe (Analytical Rossiter-McLaughlin Effects) library generates analytical Rossiter-McLaughlin (RM) effects. It models the Doppler-shift of a star during a transit measured by the fit of a cross-correlation function by a Gaussian function, fit of an observed spectrum by a modeled one, and the weighted mean.

KS Intergration solves for mutual photometric effects produced by planets and spots allowing for analysis of planetary occultations of spots and spots regions. It proceeds by identifying integrable and non integrable arcs on the objects profiles and analytically calculates the solution exploiting the power of Kelvin-Stokes theorem. It provides the solution up to the second degree of the limb darkening law.

caret (Classification And REgression Training) provides functions for training and plotting classification and regression models. It contains tools for data splitting, pre-processing, feature selection, model tuning using resampling, and variable importance estimation, as well as other functionality.

ASteCA (Automated Stellar Cluster Analysis), written in Python, fully automates standard tests applied on star clusters in order to determine their characteristics, including center, radius, and stars' membership probabilities. It also determines associated intrinsic/extrinsic parameters, including metallicity, age, reddening, distance, total mass, and binarity fraction, among others.

CALCEPH accesses binary planetary ephemeris files, including INPOPxx, JPL DExxx ,and SPICE ephemeris files. It provides a C Application Programming Interface (API) and, optionally, a Fortran 77 or 2003 interface to be called by the application. Two groups of functions enable the access to the ephemeris files, single file access functions, provided to make transition easier from the JPL functions, such as PLEPH, to this library, and many ephemeris file at the same time. Although computers have different endianess (order in which integers are stored as bytes in computer memory), CALCEPH can handles the binary ephemeris files with any endianess by automatically swaps the bytes when it performs read operations on the ephemeris file.

SOAP (Spot Oscillation And Planet) 2.0 simulates the effects of dark spots and bright plages on the surface of a rotating star, computing their expected radial velocity and photometric signatures. It includes the convective blueshift and its inhibition in active regions.

BGLS calculates the Bayesian Generalized Lomb-Scargle periodogram. It takes as input arrays with a time series, a dataset and errors on those data, and returns arrays with sampled periods and the periodogram values at those periods.

LineProf implements a series of line-profile analysis indicators and evaluates its correlation with RV data. It receives as input a list of Cross-Correlation Functions and an optional list of associated RV. It evaluates the line-profile according to the indicators and compares it with the computed RV if no associated RV is provided, or with the provided RV otherwise.

D3PO (Denoising, Deconvolving, and Decomposing Photon Observations) addresses the inference problem of denoising, deconvolving, and decomposing photon observations. Its primary goal is the simultaneous but individual reconstruction of the diffuse and point-like photon flux given a single photon count image, where the fluxes are superimposed. A hierarchical Bayesian parameter model is used to discriminate between morphologically different signal components, yielding a diffuse and a point-like signal estimate for the photon flux components.

JWFront visualizes wavefronts and light cones in general relativity. The interactive front-end allows users to enter the initial position values and choose the values for mass and angular momentum per unit mass. The wavefront animations are available in 2D and 3D; the light cones are visualized using the coordinate systems (t, x, y) or (t, z, x). JWFront can be easily modified to simulate wavefronts and light cones for other spacetime by providing the Christoffel symbols in the program.

MRrelation calculates the posterior predictive mass distribution for an individual planet. The probabilistic mass-radius relationship (M-R relation) is evaluated within a Bayesian framework, which both quantifies this intrinsic dispersion and the uncertainties on the M-R relation parameters.

IGMtransmission is a Java graphical user interface that implements Monte Carlo simulations to compute the corrections to colors of high-redshift galaxies due to intergalactic attenuation based on current models of the Intergalactic Medium. The effects of absorption due to neutral hydrogen are considered, with particular attention to the stochastic effects of Lyman Limit Systems. Attenuation curves are produced, as well as colors for a wide range of filter responses and model galaxy spectra. Photometric filters are included for the Hubble Space Telescope, the Keck telescope, the Mt. Palomar 200-inch, the SUBARU telescope and UKIRT; alternative filter response curves and spectra may be readily uploaded.

abcpmc is a Python Approximate Bayesian Computing (ABC) Population Monte Carlo (PMC) implementation based on Sequential Monte Carlo (SMC) with Particle Filtering techniques. It is extendable with k-nearest neighbour (KNN) or optimal local covariance matrix (OLCM) pertubation kernels and has built-in support for massively parallelized sampling on a cluster using MPI.

The kozai Python package evolves hierarchical triple systems in the secular approximation. As its name implies, the kozai package is useful for studying Kozai-Lidov oscillations. The kozai package can represent and evolve hierarchical triples using either the Delaunay orbital elements or the angular momentum and eccentricity vectors. kozai contains functions to calculate the period of Kozai-Lidov oscillations and the maximum eccentricity reached; it also contains a module to study octupole order effects by averaging over individual Kozai-Lidov oscillations.

DPI is a FORTRAN77 library that supplies the symplectic mapping method for binary star systems for the Mercury N-Body software package (ascl:1201.008). The binary symplectic mapping is implemented as a hybrid symplectic method that allows close encounters and collisions between massive bodies and is therefore suitable for planetary accretion simulations.

samiDB is an archive, database, and query engine to serve the spectra, spectral hypercubes, and high-level science products that make up the SAMI Galaxy Survey. Based on the versatile Hierarchical Data Format (HDF5), samiDB does not depend on relational database structures and hence lightens the setup and maintenance load imposed on science teams by metadata tables. The code, written in Python, covers the ingestion, querying, and exporting of data as well as the automatic setup of an HTML schema browser. samiDB serves as a maintenance-light data archive for Big Science and can be adopted and adapted by science teams that lack the means to hire professional archivists to set up the data back end for their projects.

CosmoTransitions analyzes early-Universe finite-temperature phase transitions with multiple scalar fields. The code enables analysis of the phase structure of an input theory, determines the amount of supercooling at each phase transition, and finds the bubble-wall profiles of the nucleated bubbles that drive the transitions.

The self-lensing binary code with Markov chain code was used to analyze the self-lensing binary system KOI-3278. It includes the MCMC modeling and the key figures.

Spearman’s rank correlation test is commonly used in astronomy to discern whether a set of two variables are correlated or not. Unlike most other quantities quoted in astronomical literature, the Spearman’s rank correlation coefficient is generally quoted with no attempt to estimate the errors on its value. This code implements a number of Monte Carlo based methods to estimate the uncertainty on the Spearman’s rank correlation coefficient.

WebbPSF provides a PSF simulation tool in a flexible and easy-to-use software package implemented in Python. Functionality includes support for spectroscopic modes of JWST NIRISS, MIRI, and NIRSpec, including modeling of slit losses and diffractive line spread functions.

drive-casa provides a Python interface for scripting of CASA (ascl:1107.013) subroutines from a separate Python process, allowing for utilization alongside other Python packages which may not easily be installed into the CASA environment. This is particularly useful for embedding use of CASA subroutines within a larger pipeline. drive-casa runs plain-text casapy scripts directly; alternatively, the package includes a set of convenience routines which try to adhere to a consistent style and make it easy to chain together successive CASA reduction commands to generate a command-script programmatically.

Chimenea implements an heuristic algorithm for automated imaging of multi-epoch radio-synthesis data. It generates a deep image via an iterative Clean subroutine performed on the concatenated visibility set and locates steady sources in the field of view. The code then uses this information to apply constrained and then unconstrained (i.e., masked/open-box) Cleans to the single-epoch observations. This obtains better results than if the single-epoch data had been processed independently without prior knowledge of the sky-model. The chimenea pipeline is built upon CASA (ascl:1107.013) subroutines, interacting with the CASA environment via the drive-casa (ascl:1504.006) interface layer.

HOTPANTS (High Order Transform of PSF ANd Template Subtraction) implements the Alard 1999 algorithm for image subtraction. It photometrically aligns one input image with another after they have been astrometrically aligned.

EsoRex (ESO Recipe Execution Tool) lists, configures, and executes Common Pipeline Library (CPL) (ascl:1402.010) recipes from the command line. Its features include automatically generating configuration files, recursive recipe-path searching, command line and configuration file parameters, and recipe product naming control, among many others.

The Solar Position Algorithm (SPA) calculates the solar zenith and azimuth angles in the period from the year -2000 to 6000, with uncertainties of +/- 0.0003 degrees based on the date, time, and location on Earth. SPA is implemented in C; in addition to being available for download, an online calculator using this code is available at https://www.nrel.gov/midc/solpos/spa.html.

UPMASK, written in R, performs membership assignment in stellar clusters. It uses photometry and spatial positions, but can take into account other types of data. UPMASK takes into account arbitrary error models; the code is unsupervised, data-driven, physical-model-free and relies on as few assumptions as possible. The approach followed for membership assessment is based on an iterative process, principal component analysis, a clustering algorithm and a kernel density estimation.

Validation of Exoplanet Signals using a Probabilistic Algorithm (VESPA) calculates false positive probabilities and statistically validates transiting exoplanets. Written in Python, it uses isochrones [ascl:1503.010] and the package simpledist.

Isochrones, written in Python, simplifies common tasks often done with stellar model grids, such as simulating synthetic stellar populations, plotting evolution tracks or isochrones, or estimating the physical properties of a star given photometric and/or spectroscopic observations.

The GSD library reads data written in the James Clerk Maxwell Telescope GSD format. This format uses the General Single-Dish Data model and was used at the JCMT until 2005. The library provides an API to open GSD files and read their contents. The content of the data files is self-describing and the library can return the type and name of any component. The library is used by SPECX (ascl:1310.008), JCMTDR (ascl:1406.019) and COADD (ascl:1411.020). The SMURF (ascl:1310.007) package can convert GSD heterodyne data files to ACSIS format using this library.

The pYSOVAR code calculates properties for a stack of lightcurves, including simple descriptive statistics (mean, max, min, ...), timing (e.g. Lomb-Scargle periodograms), variability indixes (e.g. Stetson), and color properties (e.g. slope in the color-magnitude diagram). The code is written in python and is closely integrated with astropy tables. Initially, pYSOVAR was written specifically for the analysis of two clusters in the YSOVAR project, using the (not publicly released) YSOVAR database as an input. Additional functionality has been added and the code has become more general; it is now useful for other clusters in the YSOVAR dataset or for other projects that have similar data (lightcurves in one or more bands with a few hundred points for a few thousand objects), though may not work out-of-the-box for different datasets.

UniPOPS, a suite of programs and utilities developed at the National Radio Astronomy Observatory (NRAO), reduced data from the observatory's single-dish telescopes: the Tucson 12-m, the Green Bank 140-ft, and archived data from the Green Bank 300-ft. The primary reduction programs, 'line' (for spectral-line reduction) and 'condar' (for continuum reduction), used the People-Oriented Parsing Service (POPS) as the command line interpreter. UniPOPS unified previous analysis packages and provided new capabilities; development of UniPOPS continued within the NRAO until 2004 when the 12-m was turned over to the Arizona Radio Observatory (ARO). The submitted code is version 3.5 from 2004, the last supported by the NRAO.

AMADA allows an iterative exploration and information retrieval of high-dimensional data sets. This is done by performing a hierarchical clustering analysis for different choices of correlation matrices and by doing a principal components analysis in the original data. Additionally, AMADA provides a set of modern visualization data-mining diagnostics. The user can switch between them using the different tabs.

Written in Python, dust calculates X-ray dust scattering and extinction in the intergalactic and local interstellar media.

HELIOS-K is an opacity calculator for exoplanetary atmospheres. It takes a line list as an input and computes the line shapes of an arbitrary number of spectral lines (~millions to billions). HELIOS-K is capable of computing 100,000 spectral lines in 1 second; it is written in CUDA, is optimized for graphics processing units (GPUs), and can be used with the HELIOS radiative transfer code (ascl:1807.009).

TAME measures the equivalent width (EWs) in high-resolution spectra. Written by IDL, TAME provides the EWs of spectral lines by profile fitting in an automatic or interactive mode and is reliable for measuring EWs in a spectrum with a spectral resolution of R ≳ 20000. It offers an interactive mode for more flexible measurement of the EW and a fully automatic mode that can simultaneously measure the EWs for a large set of lines.

Galax2d computes the 2D stationary solution of the isothermal Euler equations of gas dynamics in a rotating galaxy with a weak bar. The gravitational potential represents a weak bar and controls the flow. A damped Newton method solves the second-order upwind discretization of the equations for a steady-state solution, using a consistent linearization and a direct solver. The code can be applied as a tool for generating flow models if used on not too fine meshes, up to 256 by 256 cells for half a disk in polar coordinates.

K2flix makes it easy to inspect the CCD pixel data obtained by NASA's Kepler space telescope. The two-wheeled extended Kepler mission, K2, is affected by new sources of systematics, including pointing jitter and foreground asteroids, that are easier to spot by eye than by algorithm. The code takes Kepler's Target Pixel Files (TPF) as input and turns them into contrast-stretched animated gifs or MPEG-4 movies. K2flix can be used both as a command-line tool or using its Python API.

ROBOSPECT, written in C, automatically measures and deblends line equivalent widths for absorption and emission spectra. ROBOSPECT should not be used for stars with spectra in which there is no discernible continuum over large wavelength regions, nor for the most carbon-enhanced stars for which spectral synthesis would be favored. Although ROBOSPECT was designed for metal-poor stars, it is capable of fitting absorption and emission features in a variety of astronomical sources.

AstroLines adjusts spectral line parameters (gf and damping constant) starting from an initial line list. Written in IDL and tailored to the APO Galactic Evolution Experiment (APOGEE), it runs a slightly modified version of MOOG (ascl:1202.009) to compare synthetic spectra with FTS spectra of the Sun and Arcturus.

MaLTPyNT (Matteo's Libraries and Tools in Python for NuSTAR Timing) provides a quick-look timing analysis of NuSTAR data, properly treating orbital gaps and exploiting the presence of two independent detectors by using the cospectrum as a proxy for the power density spectrum. The output of the analysis is a cospectrum, or a power density spectrum, that can be fitted with XSPEC (ascl:9910.005) or ISIS (ascl:1302.002). The software also calculates time lags. Though written for NuSTAR data, MaLTPyNT can also perform standard spectral analysis on X-ray data from other satellite such as XMM-Newton and RXTE.

ketu, written in Python, searches K2 light curves for evidence of exoplanets; the code simultaneously fits for systematic effects caused by small (few-pixel) drifts in the telescope pointing and other spacecraft issues and the transit signals of interest. Though more computationally expensive than standard search algorithms, it can be efficiently implemented and used to discover transit signals.

XPCell simulates convective plasma cells. The program is implemented in two versions, one using GNUPLOT and the second OpenGL. XPCell offers a GUI to introduce the parameter required by the program.

XFGL visualizes gravitational lenses. It has an XFORM GUI and is completely interactive with the mouse. It uses OpenGL for the simulations.

AMIsurvey is a fully automated calibration and imaging pipeline for data from the AMI-LA radio observatory; it has two key dependencies. The first is drive-ami, included in this entry. Drive-ami is a Python interface to the specialized AMI-REDUCE calibration pipeline, which applies path delay corrections, automatic flags for interference, pointing errors, shadowing and hardware faults, applies phase and amplitude calibrations, Fourier transforms the data into the frequency domain, and writes out the resulting data in uvFITS format. The second is chimenea, which implements an automated imaging algorithm to convert the calibrated uvFITS into science-ready image maps. AMIsurvey links the calibration and imaging stages implemented within these packages together, configures the chimenea algorithm with parameters appropriate to data from AMI-LA, and provides a command-line interface.

libnova is a general purpose, double precision, celestial mechanics, astrometry and astrodynamics library. Among many other calculations, it can calculate aberration, apparent position, proper motion, planetary positions, orbit velocities and lengths, angular separation of bodies, and hyperbolic motion of bodies.

Camelus provides a prediction on weak lensing peak counts from input cosmological parameters. Written in C, it samples halos from a mass function and assigns a profile, carries out ray-tracing simulations, and then counts peaks from ray-tracing maps. The creation of the ray-tracing simulations requires less computing time than N-body runs and the results is in good agreement with full N-body simulations.

Magnetron, written in Python, decomposes magnetar bursts into a superposition of small spike-like features with a simple functional form, where the number of model components is itself part of the inference problem. Markov Chain Monte Carlo (MCMC) sampling and reversible jumps between models with different numbers of parameters are used to characterize the posterior distributions of the model parameters and the number of components per burst.

Rabacus performs analytic radiative transfer calculations in simple geometries relevant to cosmology and astrophysics; it also contains tools to calculate cosmological quantities such as the power spectrum and mass function. With core routines written in Fortran 90 and then wrapped in Python, the execution speed is thousands of times faster than equivalent routines written in pure Python.

SPHGR (Smoothed-Particle Hydrodynamics Galaxy Reduction) is a python based open-source framework for analyzing smoothed-particle hydrodynamic simulations. Its basic form can run a baryonic group finder to identify galaxies and a halo finder to identify dark matter halos; it can also assign said galaxies to their respective halos, calculate halo & galaxy global properties, and iterate through previous time steps to identify the most-massive progenitors of each halo and galaxy. Data about each individual halo and galaxy is collated and easy to access.

SPHGR supports a wide range of simulations types including N-body, full cosmological volumes, and zoom-in runs. Support for multiple SPH code outputs is provided by pyGadgetReader (ascl:1411.001), mainly Gadget (ascl:0003.001) and TIPSY (ascl:1111.015).

PolyChord is a Bayesian inference tool for the simultaneous calculation of evidences and sampling of posterior distributions. It is a variation on John Skilling's Nested Sampling, utilizing Slice Sampling to generate new live points. It performs well on moderately high dimensional (~100s D) posterior distributions, and can cope with arbitrary degeneracies and multimodality.

nbody6tt, based on Aarseth's nbody6 (ascl:1102.006) code, includes the treatment of complex galactic tides in a direct N-body simulation of a star cluster through the use of tidal tensors (tt) and offers two complementary methods. The first allows consideration of any kind of galaxy and orbit, thus offering versatility; this method cannot be used to study tidal debris, as it relies on the tidal approximation (linearization of the tidal force). The second method is not limited by this and does not require a galaxy simulation; the user defines a numerical function which takes position and time as arguments, and the galactic potential is returned. The space and time derivatives of the potential are used to (i) integrate the motion of the cluster on its orbit in the galaxy (starting from user-defined initial position and velocity vector), and (ii) compute the tidal acceleration on the stars.

The Hierarchical Data System (HDS) is a file-based hierarchical data system designed for the storage of a wide variety of information. It is particularly suited to the storage of large multi-dimensional arrays (with their ancillary data) where efficient access is needed. It is a key component of the Starlink software collection (ascl:1110.012) and is used by the Starlink N-Dimensional Data Format (NDF) library (ascl:1411.023).

HDS organizes data into hierarchies, broadly similar to the directory structure of a hierarchical filing system, but contained within a single HDS container file. The structures stored in these files are self-describing and flexible; HDS supports modification and extension of structures previously created, as well as functions such as deletion, copying, and renaming. All information stored in HDS files is portable between the machines on which HDS is implemented. Thus, there are no format conversion problems when moving between machines. HDS can write files in a private binary format (version 4), or be layered on top of HDF5 (version 5).

Based on the freely available CHIANTI (ascl:9911.004) database and software, KAPPA synthesizes line and continuum spectra from the optically thin spectra that arise from collisionally dominated astrophysical plasmas that are the result of non-Maxwellian κ-distributions detected in the solar transition region and flares. Ionization and recombination rates together with the ionization equilibria are provided for a range of κ values. Distribution-averaged collision strengths for excitation are obtained by an approximate method for all transitions in all ions available within CHIANTI; KAPPA also offers tools for calculating synthetic line and continuum intensities.

PyBDSF (Python Blob Detector and Source Finder, formerly PyBDSM) decomposes radio interferometry images into sources and makes their properties available for further use. PyBDSF can decompose an image into a set of Gaussians, shapelets, or wavelets as well as calculate spectral indices and polarization properties of sources and measure the psf variation across an image. PyBDSF uses an interactive environment based on CASA (ascl:1107.013); PyBDSF may also be used in Python scripts.

Montblanc, written in Python, is a GPU implementation of the Radio interferometer measurement equation (RIME) in support of the Bayesian inference for radio observations (BIRO) technique. The parameter space that BIRO explores results in tens of thousands of computationally expensive RIME evaluations before reduction to a single X² value. The RIME is calculated over four dimensions, time, baseline, channel and source and the values in this 4D space can be independently calculated; therefore, the RIME is particularly amenable to a parallel implementation accelerated by Graphics Programming Units (GPUs). Montblanc is implemented for NVIDIA's CUDA architecture and outperforms MeqTrees (ascl:1209.010) and OSKAR.

PARSEC (PARametrized Simulation Engine for Cosmic rays) is a simulation engine for fast generation of ultra-high energy cosmic ray data based on parameterizations of common assumptions of UHECR origin and propagation. Implemented are deflections in unstructured turbulent extragalactic fields, energy losses for protons due to photo-pion production and electron-pair production, as well as effects from the expansion of the universe. Additionally, a simple model to estimate propagation effects from iron nuclei is included. Deflections in the Galactic magnetic field are included using a matrix approach with precalculated lenses generated from backtracked cosmic rays. The PARSEC program is based on object oriented programming paradigms enabling users to extend the implemented models and is steerable with a graphical user interface.

ADAM (All-Data Asteroid Modeling) models asteroid shape reconstruction from observations. Developed in MATLAB with core routines in C, its features include general nonconvex and non-starlike parametric 3D shape supports and reconstruction of asteroid shape from any combination of lightcurves, adaptive optics images, HST/FGS data, disk-resolved thermal images, interferometry, and range-Doppler radar images. ADAM does not require boundary contour extraction for reconstruction and can be run in parallel.

N-GenIC is an initial conditions code for cosmological structure formation that can be used to set-up random N-body realizations of Gaussian random fields with a prescribed power spectrum in a homogeneously sampled periodic box. The code creates cosmological initial conditions based on the Zeldovich approximation, in a format directly compatible with GADGET (ascl:0003.001) or AREPO (ascl:1909.010).

OpenOrb (OOrb) contains tools for rigorously estimating the uncertainties resulting from the inverse problem of computing orbital elements using scarce astrometry. It uses the least-squares method and also contains both Monte-Carlo (MC) and Markov-Chain MC versions of the statistical ranging method. Ranging obtains sampled, non-Gaussian orbital-element probability-density functions and is optimized for cases where the amount of astrometry is scarce or spans a relatively short time interval.

RH 1.5D performs Zeeman multi-level non-local thermodynamical equilibrium calculations with partial frequency redistribution for an arbitrary amount of chemical species. Derived from the RH code and written in C, it calculates spectra from 3D, 2D or 1D atmospheric models on a column-by-column basis (or 1.5D). It includes optimization features to speed up or improve convergence, which are particularly useful in dynamic models of chromospheres. While one should be aware of its limitations, the calculation of spectra using the 1.5D or column-by-column is a good approximation in many cases, and generally allows for faster convergence and more flexible methods of improving convergence. RH 1.5D scales well to at least tens of thousands of CPU cores.

Colossus is a collection of Python modules for cosmology and dark matter halos calculations. It performs cosmological calculations with an emphasis on structure formation applications, implements general and specific density profiles, and provides a large range of models for the concentration-mass relation, including a conversion to arbitrary mass definitions.

Exoplanet determines the posterior distribution of exoplanets by use of a trans-dimensional Markov Chain Monte Carlo method within Nested Sampling. This method finds the posterior distribution in a single run rather than requiring multiple runs with trial values.

GalPaK 3D extracts the intrinsic (i.e. deconvolved) galaxy parameters and kinematics from any 3-dimensional data. The algorithm uses a disk parametric model with 10 free parameters (which can also be fixed independently) and a MCMC approach with non-traditional sampling laws in order to efficiently probe the parameter space. More importantly, it uses the knowledge of the 3-dimensional spread-function to return the intrinsic galaxy properties and the intrinsic data-cube. The 3D spread-function class is flexible enough to handle any instrument.

GalPaK 3D can simultaneously constrain the kinematics and morphological parameters of (non-merging, i.e. regular) galaxies observed in non-optimal seeing conditions and can also be used on AO data or on high-quality, high-SNR data to look for non-axisymmetric structures in the residuals.

Molecfit corrects astronomical observations for atmospheric absorption features based on fitting synthetic transmission spectra to the astronomical data, which saves a significant amount of valuable telescope time and increases the instrumental efficiency. Molecfit can also estimate molecular abundances, especially the water vapor content of the Earth’s atmosphere. The tool can be run from a command-line or more conveniently through a GUI.

Exorings, written in Python, contains tools for displaying and fitting giant extrasolar planet ring systems; it uses FITS formatted data for input.

The Sloan Digital Sky Survey (SDSS) produces large amounts of data daily. transfer, written in Python, provides the effective automation needed for daily data transfer operations and management and operates essentially free of human intervention. This package has been tested and used successfully for several years.

PythonPhot is a simple Python translation of DAOPHOT-type (ascl:1104.011) photometry procedures from the IDL AstroLib (Landsman 1993), including aperture and PSF-fitting algorithms, with a few modest additions to increase functionality and ease of use. These codes allow fast, easy, and reliable photometric measurements and are currently used in the Pan-STARRS supernova pipeline and the HST CLASH/CANDELS supernova analysis.

BIANCHI provides functionality to support the simulation of Bianchi Type VIIh induced temperature fluctuations in CMB maps of a universe with shear and rotation. The implementation is based on the solutions to the Bianchi models derived by Barrow et al. (1985), which do not incorporate any dark energy component. Functionality is provided to compute the induced fluctuations on the sphere directly in either real or harmonic space.

Enrico analyzes Fermi data. It produces spectra (model fit and flux points), maps and lightcurves for a target by editing a config file and running a python script which executes the Fermi science tool chain.

LP-VIcode computes variational chaos indicators (CIs) quickly and easily. The following CIs are included:

• Lyapunov Indicators, also known as Lyapunov Characteristic Exponents, Lyapunov Characteristic Numbers or Finite Time Lyapunov Characteristic Numbers (LIs)
  
• Mean Exponential Growth factor of Nearby Orbits (MEGNO)
  
• Slope Estimation of the largest Lyapunov Characteristic Exponent (SElLCE)
  
• Smaller ALignment Index (SALI)
  
• Generalized ALignment Index (GALI)
  
• Fast Lyapunov Indicator (FLI)
  
• Orthogonal Fast Lyapunov Indicator (OFLI)
  
• Spectral Distance (SD)
  
• dynamical Spectra of Stretching Numbers (SSNs)
  
• Relative Lyapunov Indicator (RLI)
  

PsrPopPy is a Python implementation of the Galactic population and evolution of radio pulsars modelling code PSRPOP (ascl:1107.019).

DECA performs photometric analysis of images of disk and elliptical galaxies having a regular structure. It is written in Python and combines the capabilities of several widely used packages for astronomical data processing such as IRAF (ascl:9911.002), SExtractor (ascl:1010.064), and the GALFIT (ascl:1104.010) code to perform two-dimensional decomposition of galaxy images into several photometric components (bulge+disk). DECA can be applied to large samples of galaxies with different orientations with respect to the line of sight (including edge-on galaxies) and requires minimum human intervention.

Dst is a fully parallel Python destriping code for polarimeter data; destriping is a well-established technique for removing low-frequency correlated noise from Cosmic Microwave Background (CMB) survey data. The software destripes correctly formatted HDF5 datasets and outputs hitmaps, binned maps, destriped maps and baseline arrays.

Characterization of the frequency response of coherent radiometric receivers is a key element in estimating the flux of astrophysical emissions, since the measured signal depends on the convolution of the source spectral emission with the instrument band shape. Python-qucs automates the process of preparing input data, running simulations and exporting results of QUCS (Quasi Universal Circuit Simulator) simulations.

NIGO (Numerical Integrator of Galactic Orbits) predicts the orbital evolution of test particles moving within a fully-analytical gravitational potential generated by a multi-component galaxy. The code can simulate the orbits of stars in elliptical and disc galaxies, including non-axisymmetric components represented by a spiral pattern and/or rotating bar(s).

PynPoint uses principal component analysis to detect and estimate the flux of exoplanets in two-dimensional imaging data. It processes many, typically several thousands, of frames to remove the light from the star so as to reveal the companion planet.

The code has been significantly rewritten and expanded; please see ascl:1812.010.

SOPHIA (Simulations Of Photo Hadronic Interactions in Astrophysics) solves problems connected to photohadronic processes in astrophysical environments and can also be used for radiation and background studies at high energy colliders such as LEP2 and HERA, as well as for simulations of photon induced air showers. SOPHIA implements well established phenomenological models, symmetries of hadronic interactions in a way that describes correctly the available exclusive and inclusive photohadronic cross section data obtained at fixed target and collider experiments.

CRPropa computes the observable properties of UHECRs and their secondaries in a variety of models for the sources and propagation of these particles. CRPropa takes into account interactions and deflections of primary UHECRs as well as propagation of secondary electromagnetic cascades and neutrinos. CRPropa makes use of the public code SOPHIA (ascl:1412.014), and the TinyXML, CFITSIO (ascl:1010.001), and CLHEP libraries. A major advantage of CRPropa is its modularity, which allows users to implement their own modules adapted to specific UHECR propagation models. An updated version, CRPropa3 (ascl:2208.016), is available.

GeoTOA computes the pulse times of arrival (TOAs) at an observatory (or spacecraft) from unbinned Fermi LAT data. Written in Python, the software requires NumPy, matplotlib, SciPy, Fermitools (ascl:1905.011), and Tempo2 (ascl:1210.015).

The TraP is a pipeline for detecting and responding to transient and variable sources in a stream of astronomical images. Images are initially processed using a pure-Python source-extraction package, PySE (ascl:1805.026), which is bundled with the TraP. Source positions and fluxes are then loaded into a SQL database for association and variability detection. The database structure allows for estimation of past upper limits on newly detected sources, and for forced fitting of previously detected sources which have since dropped below the blind-extraction threshold. Developed with LOFAR data in mind, the TraP has been used with data from other radio observatories.

Make Me A Star (MMAS) quickly generates stellar collision remnants and can be used in combination with realistic dynamical simulations of star clusters that include stellar collisions. The code approximates the merger process (including shock heating, hydrodynamic mixing, mass ejection, and angular momentum transfer) with simple algorithms based on conservation laws and a basic qualitative understanding of the hydrodynamics. These simple models agree very well with those from SPH (smoothed particle hydrodynamics) calculations of stellar collisions, and the subsequent stellar evolution of these models also matches closely that of the more accurate hydrodynamic models.

URCHIN is a Smoothed Particle Hydrodynamics (SPH) reverse ray tracer (i.e. from particles to sources). It calculates the amount of shielding from a uniform background that each particle experiences. Preservation of the adaptive density field resolution present in many gas dynamics codes and uniform sampling of gas resolution elements with rays are two of the benefits of URCHIN; it also offers preservation of Galilean invariance, high spectral resolution, and preservation of the standard uniform UV background in optically thin gas.

Hrothgar is a parallel minimizer and Markov Chain Monte Carlo generator. It has been used to solve optimization problems in astrophysics (galaxy cluster mass profiles) as well as in experimental particle physics (hadronic tau decays).

PIAO is an efficient memory-controlled Python code that uses the standard spherical overdensity (SO) algorithm to identify halos. PIAO employs two additional parameters besides the overdensity Δc. The first is the mesh-box size, which splits the whole simulation box into smaller ones then analyzes them one-by-one, thereby overcoming a possible memory limitation problem that can occur when dealing with high-resolution, large-volume simulations. The second is the smoothed particle hydrodynamics (SPH) neighbors number, which is used for the SPH density calculation.

HMF calculates the Halo Mass Function (HMF) given any set of cosmological parameters and fitting function and serves as the backend for the web application HMFcalc. Written in Python, it allows for dynamic accurate calculation of the transfer function with CAMB (ascl:1102.026) and efficient and self-consistent parameter updates. HMF offers exploration of the effects of cosmological parameters, redshift and fitting function on the predicted HMF.

BRUCE and KYLIE, written in Fortran 77, synthesize the spectra of pulsating stars. BRUCE constructs a point-sampled model for the surface of a rotating, gravity-darkened star, and then subjects this model to perturbations arising from one or more non-radial pulsation modes. Departures from adiabaticity can be taken into account, as can the Coriolis force through adoption of the so-called traditional approximation. BRUCE writes out a time-sequence of perturbed surface models. This sequence is read in by KYLIE, which synthesizes disk-integrated spectra for the models by co-adding the specific intensity emanating from each visible point toward the observer. The specific intensity is calculated by interpolation in a large temperature-gravity-wavelength-angle grid of pre-calculated intensity spectra.

DAMIT (Database of Asteroid Models from Inversion Techniques) is a database of three-dimensional models of asteroids computed using inversion techniques; it provides access to reliable and up-to-date physical models of asteroids, i.e., their shapes, rotation periods, and spin axis directions. Models from DAMIT can be used for further detailed studies of individual objects as well as for statistical studies of the whole set. The source codes for lightcurve inversion routines together with brief manuals, sample lightcurves, and the code for the direct problem are available for download.

The Universal Transit Modeller (UTM) is a light-curve simulator for all kinds of transiting or eclipsing configurations between arbitrary numbers of several types of objects, which may be stars, planets, planetary moons, and planetary rings. A separate fitting program, UFIT (Universal Fitter) is part of the UTM distribution and may be used to derive best fits to light-curves for any set of continuously variable parameters. UTM/UFIT is written in IDL code and its source is released in the public domain under the GNU General Public License.

Cheetah models starspots in photometric data (lightcurves) by calculating the modulation of a light curve due to starspots. The main parameters of the program are the linear and quadratic limb darkening coefficients, stellar inclination, spot locations and sizes, and the intensity ratio of the spots to the stellar photosphere. Cheetah uses uniform spot contrast and the minimum number of spots needed to produce a good fit and ignores bright regions for the sake of simplicity.

SoFiA is a flexible source finding pipeline designed to detect and parameterize sources in 3D spectral-line data cubes. SoFiA combines several powerful source finding and parameterization algorithms, including wavelet denoising, spatial and spectral smoothing, source mask optimization, spectral profile fitting, and calculation of the reliability of detections. In addition to source catalogues in different formats, SoFiA can also generate a range of output data cubes and images, including source masks, moment maps, sub-cubes, position-velocity diagrams, and integrated spectra. The pipeline is controlled by simple parameter files and can either be invoked on the command line or interactively through a modern graphical user interface.

A reimplementation of this pipeline using OpenMPI, SoFiA 2 (ascl:2109.005), is available.

The Fermi-LAT Background Estimator (BKGE) is a publicly available open-source tool that can estimate the expected background of the Fermi-LAT for any observational conguration and duration. It produces results in the form of text files, ROOT files, gtlike source-model files (for LAT maximum likelihood analyses), and PHA I/II FITS files (for RMFit/XSpec spectral fitting analyses). Its core is written in C++ and its user interface in Python.

sic (Sparse Inpainting Code) generates Gaussian, isotropic CMB realizations, masks them, and recovers the large-scale masked data using sparse inpainting; it is written in Fortran90.

The SPT lensing likelihood code, written in Fortran90, performs a Gaussian likelihood based upon the lensing potential power spectrum using a file from CAMB (ascl:1102.026) which contains the normalization required to get the power spectrum that the likelihood call is expecting.

CGS3DR is data reduction software for the UKIRT CGS3 mid-infrared grating spectrometer instrument. It includes a command-line interface and a GUI. The software, originally on VMS, was ported to Unix. It uses Starlink (ascl:1110.012) infrastructure libraries.

The Extensible N-Dimensional Data Format (NDF) stores bulk data in the form of N-dimensional arrays of numbers. It is typically used for storing spectra, images and similar datasets with higher dimensionality. The NDF format is based on the Hierarchical Data System (HDS) and is extensible; not only does it provide a comprehensive set of standard ancillary items to describe the data, it can also be extended indefinitely to handle additional user-defined information of any type. The NDF library is used to read and write files in the NDF format. It is distributed with the Starlink software (ascl:1110.012).

Starlink Figaro is an independently-maintained fork of Figaro (ascl:1203.013) that runs in the Starlink software environment (ascl:1110.012). It is a general-purpose data reduction package targeted mainly at optical/IR spectroscopy. It uses the NDF data format and the ADAM libraries for parameters and messaging.

POSTMORTEM is the visibility data reduction and map making package from MRAO (Mullard Radio Astronomy Observatory) and is used with the Ryle and CLFST telescopes at Cambridge. It contains sub-systems for nonitoring telescope performance, displaying and editing the visibility data, performing calibrations, removing flux from interfering bright sources, and map-making. It requires PGPLOT (ascl:1103.002), SLALIB (ascl:1403.025), and NAG numerical routines, all of which are distributed with the STARLINK software collection (ascl:1110.012) or available separately.

COADD was used to reduce photometry and continuum data from the UKT14 instrument on the James Clerk Maxwell Telescope in the 1990s. The software can co-add multiple observations and perform sigma clipping and Kolmogorov-Smirnov statistical analysis. Additional information on the software is available in the JCMT Spring 1993 newsletter (large PDF).

Anmap analyses and processes images and spectral data. Originally written for use in radio astronomy, much of its functionality is applicable to other disciplines; additional algorithms and analysis procedures allow direct use in, for example, NMR imaging and spectroscopy. Anmap emphasizes the analysis of data to extract quantitative results for comparison with theoretical models and/or other experimental data. To achieve this, Anmap provides a wide range of tools for analysis, fitting and modelling (including standard image and data processing algorithms). It also provides a powerful environment for users to develop their own analysis/processing tools either by combining existing algorithms and facilities with the very powerful command (scripting) language or by writing new routines in FORTRAN that integrate seamlessly with the rest of Anmap.