[ascl:1604.006]
2-DUST: Dust radiative transfer code

2-DUST is a general-purpose dust radiative transfer code for an axisymmetric system that reveals the global energetics of dust grains in the shell and the 2-D projected morphologies of the shell that are strongly dependent on the mixed effects of the axisymmetric dust distribution and inclination angle. It can be used to model a variety of axisymmetric astronomical dust systems.

[ascl:1102.023]
21cmFAST: A Fast, Semi-Numerical Simulation of the High-Redshift 21-cm Signal

21cmFAST is a powerful semi-numeric modeling tool designed to efficiently simulate the cosmological 21-cm signal. The code generates 3D realizations of evolved density, ionization, peculiar velocity, and spin temperature fields, which it then combines to compute the 21-cm brightness temperature. Although the physical processes are treated with approximate methods, the results were compared to a state-of-the-art large-scale hydrodynamic simulation, and the findings indicate good agreement on scales pertinent to the upcoming observations (>~ 1 Mpc). The power spectra from 21cmFAST agree with those generated from the numerical simulation to within 10s of percent, down to the Nyquist frequency. Results were shown from a 1 Gpc simulation which tracks the cosmic 21-cm signal down from z=250, highlighting the various interesting epochs. Depending on the desired resolution, 21cmFAST can compute a redshift realization on a single processor in just a few minutes. The code is fast, efficient, customizable and publicly available, making it a useful tool for 21-cm parameter studies.

[ascl:1608.017]
21CMMC: Parallelized Monte Carlo Markov Chain analysis tool for the epoch of reionization (EoR)

21CMMC is an efficient Python sampler of the semi-numerical reionization simulation code 21cmFAST (ascl:1102.023). It can recover constraints on astrophysical parameters from current or future 21 cm EoR experiments, accommodating a variety of EoR models, as well as priors on individual model parameters and the reionization history. By studying the resulting impact on the EoR astrophysical constraints, 21CMMC can be used to optimize foreground cleaning algorithms; interferometer designs; observing strategies; alternate statistics characterizing the 21cm signal; and synergies with other observational programs.

[ascl:1609.013]
21cmSense: Calculating the sensitivity of 21cm experiments to the EoR power spectrum

21cmSense calculates the expected sensitivities of 21cm experiments to the Epoch of Reionization power spectrum. Written in Python, it requires NumPy, SciPy, and AIPY (ascl:1609.012).

[ascl:2006.004]
2D-FFTLog: Generalized FFTLog algorithm for non-Gaussian covariance matrices

2D-FFTLog takes the FFTLog algorithm for 1D Hankel transforms and generalizes it for 2D Hankel transforms. The algorithm is useful for efficiently computing non-Gaussian covariance matrices of cosmological 2-point statistics in configuration space from Fourier space covariances. Fast bin-averaging method is also developed for both the logarithmic binning and general binning choices. C and Python versions of the code are available.

[ascl:2005.012]
2DBAT: 2D Bayesian Automated Tilted-ring fitter

2DBAT implements Bayesian fits of 2D tilted-ring models to derive rotation curves of galaxies. It performs 2D tilted-ring analysis based on a Bayesian Markov Chain Monte Carlo (MCMC) technique, thus quantifying the kinematic geometry of galaxy discs, and deriving high-quality rotation curves that can be used for mass modeling of baryons and dark matter halos.

[ascl:1505.015]
2dfdr: Data reduction software

2dfdr is an automatic data reduction pipeline dedicated to reducing multi-fibre spectroscopy data, with current implementations for AAOmega (fed by the 2dF, KOALA-IFU, SAMI Multi-IFU or older SPIRAL front-ends), HERMES, 2dF (spectrograph), 6dF, and FMOS. A graphical user interface is provided to control data reduction and allow inspection of the reduced spectra.

[ascl:1608.015]
2DFFT: Measuring Galactic Spiral Arm Pitch Angle

Davis, Benjamin L.; Berrier, Joel C.; Shields, Douglas W.; Kennefick, Julia; Kennefick, Daniel; Seigar, Marc S.; Lacy, Claud H. S.; Puerari, Ivânio

2DFFT utilizes two-dimensional fast Fourier transformations of images of spiral galaxies to isolate and measure the pitch angles of their spiral arms; this provides a quantitative way to measure this morphological feature and allows comparison of spiral galaxy pitch angle to other galactic parameters and test spiral arm genesis theories. 2DFFT requires fourn.c from *Numerical Recipes in C* (Press et al. 1989).

P2DFFT (ascl:1806.011) is a parallelized version of 2DFFT.

[ascl:1808.007]
2DSF: Vectorized Structure Function Algorithm

The vectorized physical domain structure function (SF) algorithm calculates the velocity anisotropy within two-dimensional molecular line emission observations. The vectorized approach is significantly faster than brute force iterative algorithms and is very efficient for even relatively large images. Furthermore, unlike frequency domain algorithms which require the input data to be fully integrable, this algorithm, implemented in Python, has no such requirements, making it a robust tool for observations with irregularities such as asymmetric boundaries and missing data.

[ascl:1201.005]
2LPTIC: 2nd-order Lagrangian Perturbation Theory Initial Conditions

Setting initial conditions in numerical simulations using the standard procedure based on the Zel'dovich approximation (ZA) generates incorrect second and higher-order growth and therefore excites long-lived transients in the evolution of the statistical properties of density and velocity fields. Using more accurate initial conditions based on second-order Lagrangian perturbation theory (2LPT) reduces transients significantly; initial conditions based on 2LPT are thus much more appropriate for numerical simulations devoted to precision cosmology. The 2LPTIC code provides initial conditions for running cosmological simulations based on second-order Lagrangian Perturbation Theory (2LPT), rather than first-order (Zel'dovich approximation).

[ascl:1303.016]
2MASS Kit: 2MASS Catalog Server Kit

2MASS Kit is an open source software for use in easily constructing a high performance search server for important astronomical catalogs. It is tuned for optimal coordinate search performance (Radial Search, Box Search, Rectangular Search) of huge catalogs, thus increasing the speed by more than an order of magnitude when compared to simple indexing on a single table. Optimal conditions enable more than 3,000 searches per second for radial search of 2MASS PSC. The kit is best characterized by its flexible tuning. Each table index is registered in one of six table spaces (each resides in a separate directory), thus allowing only the essential parts to be easily moved onto fast devices. Given the terrific evolution that has taken place with recent SSDs in performance, a very cost-effective way of constructing high-performance servers is moving part of or all table indices to a fast SSD.

[submitted]
3D texturized model of MARS (MOLA) regions

The Matlab Tool generates a 3D model (WRL, texturized in height false color map) of a defined region of the Mars surface. It defines the region of interest of the Mars surface (by Lat Long), a resolution of the MOLA DTMs to be considered (with a minimum px onground of 468 m), a scale factor to be multiplied to the height of the surface to improve features visibility for bumping or shadowing effect.

[ascl:1507.001]
3D-Barolo: 3D fitting tool for the kinematics of galaxies

3D-Barolo (3D-Based Analysis of Rotating Object via Line Observations) or BBarolo is a tool for fitting 3D tilted-ring models to emission-line datacubes. BBarolo works with 3D FITS files, i.e. image arrays with two spatial and one spectral dimensions. BBarolo recovers the true rotation curve and estimates the intrinsic velocity dispersion even in barely resolved galaxies (about 2 resolution elements) if the signal to noise of the data is larger than 2-3. It has source-detection and first-estimate modules, making it suitable for analyzing large 3D datasets automatically, and is a useful tool for deriving reliable kinematics for both local and high-redshift galaxies.

[ascl:1803.010]
3D-PDR: Three-dimensional photodissociation region code

3D-PDR is a three-dimensional photodissociation region code written in Fortran. It uses the Sundials package (written in C) to solve the set of ordinary differential equations and it is the successor of the one-dimensional PDR code UCL_PDR (ascl:1303.004). Using the HEALpix ray-tracing scheme (ascl:1107.018), 3D-PDR solves a three-dimensional escape probability routine and evaluates the attenuation of the far-ultraviolet radiation in the PDR and the propagation of FIR/submm emission lines out of the PDR. The code is parallelized (OpenMP) and can be applied to 1D and 3D problems.

[ascl:1805.005]
3DCORE: Forward modeling of solar storm magnetic flux ropes for space weather prediction

Möstl, C.; Amerstorfer, T.; Palmerio, E.; Isavnin, A.; Farrugia, C. J.; Lowder, C.; Winslow, R. M.; Donnerer, J. M.; Kilpua, E. K. J.; Boakes, P. D.

3DCORE forward models solar storm magnetic flux ropes called 3-Dimensional Coronal Rope Ejection (3DCORE). The code is able to produce synthetic in situ observations of the magnetic cores of solar coronal mass ejections sweeping over planets and spacecraft. Near Earth, these data are taken currently by the Wind, ACE and DSCOVR spacecraft. Other suitable spacecraft making these kind of observations carrying magnetometers in the solar wind were MESSENGER, Venus Express, MAVEN, and even Helios.

[ascl:1111.011]
3DEX: Fast Fourier-Bessel Decomposition of Spherical 3D Surveys

High precision cosmology requires analysis of large scale surveys in 3D spherical coordinates, i.e. Fourier-Bessel decomposition. Current methods are insufficient for future data-sets from wide-field cosmology surveys. 3DEX (3D EXpansions) is a public code for fast Fourier-Bessel decomposition of 3D all-sky surveys which takes advantage of HEALPix for the calculation of tangential modes. For surveys with millions of galaxies, computation time is reduced by a factor 4-12 depending on the desired scales and accuracy. The formulation is also suitable for pre-calculations and external storage of the spherical harmonics, which allows for further speed improvements. The 3DEX code can accommodate data with masked regions of missing data. It can be applied not only to cosmological data, but also to 3D data in spherical coordinates in other scientific fields.

[ascl:1804.018]
3DView: Space physics data visualizer

Génot, V.; Beigbeder, L.; Popescu, D.; Dufourg, N.; Gangloff, M.; Bouchemit, M.; Caussarieu, S.; Toniutti, J.-P.; Durand, J.; Modolo, R.; André, N.; Cecconi, B.; Jacquey, C.; Pitout, F.; Rouillard, A.; Pinto, R.; Erard, S.; Jourdane, N.; Leclercq, L.; Hess, S.; Khodachenko, M.; Al-Ubaidi, T.; Scherf, M.; Budnik, E.

3DView creates visualizations of space physics data in their original 3D context. Time series, vectors, dynamic spectra, celestial body maps, magnetic field or flow lines, and 2D cuts in simulation cubes are among the variety of data representation enabled by 3DView. It offers direct connections to several large databases and uses VO standards; it also allows the user to upload data. 3DView's versatility covers a wide range of space physics contexts.

[submitted]
3LPT-init: Initial conditions with third-order Lagrangian perturbation for cosmological N-body simulations

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

[ascl:1708.020]
4DAO: DAOSPEC interface

4DAO launches DAOSPEC (ascl:1011.002) for a large sample of spectra. Written in Fortran, the software allows one to easily manage the input and output files of DAOSPEC, optimize the main DAOSPEC parameters, and mask specific spectral regions. It also provides suitable graphical tools to evaluate the quality of the solution and provides final, normalized, zero radial velocity spectra.

[ascl:1104.014]
A Correction to the Standard Galactic Reddening Map: Passive Galaxies as Standard Crayons

We present corrections to the Schlegel, Finkbeiner, Davis (SFD98) reddening maps over the Sloan Digital Sky Survey northern Galactic cap area. To find these corrections, we employ what we dub the "standard crayon" method, in which we use passively evolving galaxies as color standards by which to measure deviations from the reddening map. We select these passively evolving galaxies spectroscopically, using limits on the H alpha and O II equivalent widths to remove all star-forming galaxies from the SDSS main galaxy catalog. We find that by correcting for known reddening, redshift, color-magnitude relation, and variation of color with environmental density, we can reduce the scatter in color to below 3% in the bulk of the 151,637 galaxies we select. Using these galaxies we construct maps of the deviation from the SFD98 reddening map at 4.5 degree resolution, with 1-sigma error of ~ 1.5 millimagnitudes E(B-V). We find that the SFD98 maps are largely accurate with most of the map having deviations below 3 millimagnitudes E(B-V), though some regions do deviate from SFD98 by as much as 50%. The maximum deviation found is 45 millimagnitudes in E(B-V), and spatial structure of the deviation is strongly correlated with the observed dust temperature, such that SFD98 underpredicts reddening in regions of low dust temperature. The maps of these deviations, as well as their errors, are made available to the scientific community as supplemental correction to SFD98 at the URL below.

[submitted]
A Neural Network for the Identification of Dangerous Planetesimals (Including scripts for data generation)

Two neural networks were designed to identify hazardous planetesimals that were trained on object trajectories calculated in a cloud computing environment. The first neural network was fully-connected and was trained on the orbital elements (OEs) of real/simulated planetesimals, while the second was a 1-dimensional convolutional neural network that was trained on the position Cartesian coordinates of real/simulated planetesimals. Ultimately, the network trained on OEs had a better performance by identifying one-third of known potentially hazardous objects including the 3 asteroids with the highest chance of impact with Earth (2009 FD, 1999 RQ36, 1950 DA) as established by NASA's Monte Carlo based Sentry system.

[ascl:1312.011]
A_phot: Photon Asymmetry

Photon asymmetry is a novel robust substructure statistic for X-ray cluster observations with only a few thousand counts; it exhibits better stability than power ratios and centroid shifts and has a smaller statistical uncertainty than competing substructure parameters, allowing for low levels of substructure to be measured with confidence. A_phot computes the photon asymmetry (A_phot) parameter for morphological classification of clusters and allows quantifying substructure in samples of distant clusters covering a wide range of observational signal-to-noise ratios. The python scripts are completely automatic and can be used to rapidly classify galaxy cluster morphology for large numbers of clusters without human intervention.

[ascl:1704.010]
A-Track: Detecting Moving Objects in FITS images

A-Track is a fast, open-source, cross-platform pipeline for detecting moving objects (asteroids and comets) in sequential telescope images in FITS format. The moving objects are detected using a modified line detection algorithm.

[ascl:1910.003]
a3cosmos-gas-evolution: Galaxy cold molecular gas evolution functions

a3cosmos-gas-evolution calculates galaxies' cold molecular gas properties using gas scaling functions derived from the A3COSMOS project. By known galaxies' redshifts or cosmic age, stellar masses, and star formation enhancement to galaxies' star-forming main sequence (Delta MS), the gas scaling functions predict their stellar mass ratio (gas fraction) and gas depletion time.

[ascl:1110.009]
AAOGlimpse: Three-dimensional Data Viewer

AAOGlimpse is an experimental display program that uses OpenGL to display FITS data (and even JPEG images) as 3D surfaces that can be rotated and viewed from different angles, all in real-time. It is WCS-compliant and designed to handle three-dimensional data. Each plane in a data cube is surfaced in the same way, and the program allows the user to travel through a cube by 'peeling off' successive planes, or to look into a cube by suppressing the display of data below a given cutoff value. It can blink images and can superimpose images and contour maps from different sources using their world coordinate data. A limited socket interface allows communication with other programs.

[ascl:1504.014]
abcpmc: Approximate Bayesian Computation for Population Monte-Carlo code

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.

[ascl:1507.007]
abo-cross: Hydrogen broadening cross-section calculator

Line broadening cross sections for the broadening of spectral lines by collisions with neutral hydrogen atoms have been tabulated by Anstee & O’Mara (1995), Barklem & O’Mara (1997) and Barklem, O’Mara & Ross (1998) for s–p, p–s, p–d, d–p, d–f and f–d transitions. abo-cross, written in Fortran, interpolates in these tabulations to make these data more accessible to the end user. This code can be incorporated into existing spectrum synthesis programs or used it in a stand-alone mode to compute line broadening cross sections for specific transitions.

[ascl:1401.007]
abundance: High Redshift Cluster Abundance

abundance, written in Fortran, provides driver and fitting routines to compute the predicted number of clusters in a ΛCDM cosmology that agrees with CMB, SN, BAO, and H0 measurements (up to 2010) at some specified parameter confidence and the mass that would rule out that cosmology at some specified sample confidence. It also computes the expected number of such clusters in the light cone and the Eddington bias factor that must be applied to observed masses.

[ascl:1303.026]
ACORNS-ADI: Algorithms for Calibration, Optimized Registration and Nulling the Star in Angular Differential Imaging

ACORNS-ADI, written in python, is a parallelized software package which reduces high-contrast imaging data. Originally written for imaging data from Subaru/HiCIAO, it requires minimal modification to reduce data from other instruments. It is efficient, open-source, and includes several optional features which may improve performance.

[ascl:2003.003]
acorns: Agglomerative Clustering for ORganising Nested Structures

acorns generates a hierarchical system of clusters within discrete data by using an n-dimensional unsupervised machine-learning algorithm that clusters spectroscopic position-position-velocity data. The algorithm is based on a technique known as hierarchical agglomerative clustering. Although acorns was designed with the analysis of discrete spectroscopic position-position-velocity (PPV) data in mind (rather than uniformly spaced data cubes), clustering can be performed in n-dimensions and the algorithm can be readily applied to other data sets in addition to PPV measurements.

[ascl:1302.003]
ACS: ALMA Common Software

ALMA Common Software (ACS) provides a software infrastructure common to all ALMA partners and consists of a documented collection of common patterns and components which implement those patterns. The heart of ACS is based on a distributed Component-Container model, with ACS Components implemented as CORBA objects in any of the supported programming languages. ACS provides common CORBA-based services such as logging, error and alarm management, configuration database and lifecycle management. Although designed for ALMA, ACS can and is being used in other control systems and distributed software projects, since it implements proven design patterns using state of the art, reliable technology. It also allows, through the use of well-known standard constructs and components, that other team members whom are not authors of ACS easily understand the architecture of software modules, making maintenance affordable even on a very large project.

[ascl:2011.024]
ACStools: Python tools for Hubble Space Telescope Advanced Camera for Surveys data

Lim, Pey Lian; Davis, Matt; Hack, Warren; Grogin, Norman; Ogaz, Sara; Ubeda, Leonardo; Cara, Mihai; Borncamp, David; Miles, Nathan

The ACStools package contains Python tools to work with data from the Hubble Space Telescope (HST) Advanced Camera for Surveys (ACS). The package has several calibration utilities and a zeropoints calculator, can detect satellite trails, and offers destriping, polarization, and photometric tools.

[ascl:1908.003]
ActSNClass: Active learning for supernova photometric classification

ActSNClass uses a parametric feature extraction method, Random Forest classifier and two learning strategies (uncertainty sampling and random sampling) to performs active learning for supernova photometric classification.

[ascl:1502.004]
ADAM: All-Data Asteroid Modeling

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.

[ascl:2011.001]
AdaMet: Adaptive Metropolis for Bayesian analysis

AdaMet (Adaptive Metropolis) performs efficient Bayesian analysis. The user-friendly Python package is an implementation of the Adaptive Metropolis algorithm. In many real-world applications, it is more efficient and robust than emcee (ascl:1303.002), which warm-up phase scales linearly with the number of walkers. For this reason, and because of its didactic value, the AdaMet code is provided as an alternative.

[ascl:1305.004]
AdaptaHOP: Subclump finder

AdaptaHOP is a structure and substructure detector. It reads an input particle distribution file and can compute the mean square distance between each particle and its nearest neighbors or the SPH density associated to each particle + the list of its nearest neighbors. It can also read an input particle distribution and a neighbors file (output from a previous run) and output the tree of the structures in structures.

[ascl:1609.024]
AdaptiveBin: Adaptive Binning

AdaptiveBin takes one or more images and adaptively bins them. If one image is supplied, then the pixels are binned by fractional error on the intensity. If two or more images are supplied, then the pixels are fractional binned by error on the combined color.

[ascl:1010.024]
ADAPTSMOOTH: A Code for the Adaptive Smoothing of Astronomical Images

ADAPTSMOOTH serves to smooth astronomical images in an adaptive fashion in order to enhance the signal-to-noise ratio (S/N). The adaptive smoothing scheme allows taking full advantage of the spatially resolved photometric information contained in an image in that at any location the minimal smoothing is applied to reach the requested S/N. Support is given to match more images on the same smoothing length, such that proper estimates of local colors can be done, with a big potential impact on multi-wavelength studies of extended sources (galaxies, nebulae). Different modes to estimate local S/N are provided. In addition to classical arithmetic-mean averaging mode, the code can operate in median averaging mode, resulting in a significant enhancement of the final image quality and very accurate flux conservation.

[ascl:1109.002]
ADIPLS: Aarhus Adiabatic Oscillation Package (ADIPACK)

The goal of the development of the Aarhus Adiabatic Oscillation Package was to have a simple and efficient tool for the computation of adiabatic oscillation frequencies and eigenfunctions for general stellar models, emphasizing also the accuracy of the results. The Fortran code offers considerable flexibility in the choice of integration method as well as ability to determine all frequencies of a given model, in a given range of degree and frequency. Development of the Aarhus adiabatic pulsation code started around 1978. Although the main features have been stable for more than a decade, development of the code is continuing, concerning numerical properties and output. The code has been provided as a generally available package and has seen substantial use at a number of installations. Further development of the package, including bringing the documentation closer to being up to date, is planned as part of the HELAS Coordination Action.

[ascl:1203.001]
AE: ACIS Extract

ACIS Extract (AE), written in the IDL language, provides innovative and automated solutions to the varied challenges found in the analysis of X-ray data taken by the ACIS instrument on NASA's Chandra observatory. AE addresses complications found in many Chandra projects: large numbers of point sources (hundreds to several thousand), faint point sources, misaligned multiple observations of an astronomical field, point source crowding, and scientifically relevant diffuse emission. AE can perform virtually all the data processing and analysis tasks that lie between Level 2 ACIS data and publishable LaTeX tables of point-like and diffuse source properties and spectral models.

[ascl:1212.009]
Aegean: Compact source finding in radio images

Aegean, written in python, finds compact sources within radio images by seeking out islands of pixels above a given threshold and then using the curvature of the image to determine how many Gaussian components should be used to describe the island. The Gaussian fitting is initiated with parameters determined from the curvature and intensity maps, and makes use of mpfit to perform a constrained fit. Aegean has been optimized for compact radio sources in images that have no diffuse background emission, but by pre-processing the images with a spatial filter, or by convolving an optical image with an appropriately small PSF, Aegean is able to produce excellent results in a range of applications.

[ascl:1812.004]
aesop: ARC Echelle Spectroscopic Observation Pipeline

aesop (ARC Echelle Spectroscopic Observation Pipeline) analyzes echelle spectra for observations made by the Astrophysics Research Consortium (ARC) Echelle Spectrograph on the ARC 3.5 m Telescope at Apache Point Observatory. It is a high resolution spectroscopy software toolkit that picks up where the traditional IRAF reduction scripts leave off, and offers blaze function normalization by polynomial fits to observations of early-type stars, a robust least-squares normalization method, and radial velocity measurements (or offset removals) via cross-correlation with model spectra, including barycentric radial velocity calculations. It also concatenates multiple echelle orders into a simple 1D spectrum and provides approximate flux calibration.

[ascl:1509.003]
AFR (ASPFitsReader): A pulsar FITS file reader and analysis package

AFR, or ASPFitsReader, reduces, processes, and manipulates pulsar data, including calibration, template profile creation, and interactive excision of radio frequency interference from pulsar profile data. It also creates times-of-arrival compatible with Tempo (ascl:1509.002) and Tempo2 (ascl:1210.015) timing software.

[ascl:1805.008]
AGAMA: Action-based galaxy modeling framework

The AGAMA library is a collection of tools for constructing and analyzing models of galaxies. It computes gravitational potential and forces, performs orbit integration and analysis, and can convert between position/velocity and action/angle coordinates. It offers a framework for finding best-fit parameters of a model from data and self-consistent multi-component galaxy models, and contains useful auxiliary utilities such as various mathematical routines. The core of the library is written in C++, and there are Python and Fortran interfaces. AGAMA may be used as a plugin for the stellar-dynamical software packages galpy (ascl:1411.008), AMUSE (ascl:1107.007), and NEMO (ascl:1010.051).

[ascl:1804.020]
Agatha: Disentangling period signals from correlated noise in a periodogram framework

Agatha is a framework of periodograms to disentangle periodic signals from correlated noise and to solve the two-dimensional model selection problem: signal dimension and noise model dimension. These periodograms are calculated by applying likelihood maximization and marginalization and combined in a self-consistent way. Agatha can be used to select the optimal noise model and to test the consistency of signals in time and can be applied to time series analyses in other astronomical and scientific disciplines. An interactive web implementation of the software is also available at http://agatha.herts.ac.uk/.

[ascl:1607.001]
AGNfitter: SED-fitting code for AGN and galaxies from a MCMC approach

AGNfitter is a fully Bayesian MCMC method to fit the spectral energy distributions (SEDs) of active galactic nuclei (AGN) and galaxies from the sub-mm to the UV; it enables robust disentanglement of the physical processes responsible for the emission of sources. Written in Python, AGNfitter makes use of a large library of theoretical, empirical, and semi-empirical models to characterize both the nuclear and host galaxy emission simultaneously. The model consists of four physical emission components: an accretion disk, a torus of AGN heated dust, stellar populations, and cold dust in star forming regions. AGNfitter determines the posterior distributions of numerous parameters that govern the physics of AGN with a fully Bayesian treatment of errors and parameter degeneracies, allowing one to infer integrated luminosities, dust attenuation parameters, stellar masses, and star formation rates.

[ascl:1102.009]
AHF: Amiga's Halo Finder

Cosmological simulations are the key tool for investigating the different processes involved in the formation of the universe from small initial density perturbations to galaxies and clusters of galaxies observed today. The identification and analysis of bound objects, halos, is one of the most important steps in drawing useful physical information from simulations. In the advent of larger and larger simulations, a reliable and parallel halo finder, able to cope with the ever-increasing data files, is a must. In this work we present the freely available MPI parallel halo finder AHF. We provide a description of the algorithm and the strategy followed to handle large simulation data. We also describe the parameters a user may choose in order to influence the process of halo finding, as well as pointing out which parameters are crucial to ensure untainted results from the parallel approach. Furthermore, we demonstrate the ability of AHF to scale to high-resolution simulations.

[ascl:1310.003]
AIDA: Adaptive Image Deconvolution Algorithm

AIDA is an implementation and extension of the MISTRAL myopic deconvolution method developed by Mugnier et al. (2004) (see J. Opt. Soc. Am. A 21:1841-1854). The MISTRAL approach has been shown to yield object reconstructions with excellent edge preservation and photometric precision when used to process astronomical images. AIDA improves upon the original MISTRAL implementation. AIDA, written in Python, can deconvolve multiple frame data and three-dimensional image stacks encountered in adaptive optics and light microscopic imaging.

[ascl:1611.014]
AIMS: Asteroseismic Inference on a Massive Scale

AIMS (Asteroseismic Inference on a Massive Scale) estimates stellar parameters and credible intervals/error bars in a Bayesian manner from a set of seismic frequency data and so-called classic constraints. To achieve reliable parameter estimates and computational efficiency it searches through a grid of pre-computed models using an MCMC algorithm; interpolation within the grid of models is performed by first tessellating the grid using a Delaunay triangulation and then doing a linear barycentric interpolation on matching simplexes. Inputs for the modeling consists of individual frequencies from peak-bagging, which can be complemented with classic spectroscopic constraints.

[ascl:9911.003]
AIPS: Astronomical Image Processing System

AIPS ("Classic") is a software package for interactive and batch calibration and editing of astronomical data, typically radio interferometric data. AIPS can be used for the calibration, construction, enhancement, display, and analysis of astronomical images made from data using Fourier synthesis methods. Design and development of the package begin in 1978. AIPS presently consists of over 1,000,000 lines of code and 400,000 lines of documentation, representing over 65 person-years of effort.

[ascl:1310.006]
AIPSLite: ParselTongue extension for distributed AIPS processing

AIPSLite is an extension for ParselTongue (ascl:1208.020) that allows machines without an AIPS (ascl:9911.003) distribution to bootstrap themselves with a minimal AIPS environment. This allows deployment of AIPS routines on distributed systems, which is useful when data can be easily be split into smaller chunks and handled independently.

[ascl:1609.012]
AIPY: Astronomical Interferometry in PYthon

AIPY collects together tools for radio astronomical interferometry. In addition to pure-python phasing, calibration, imaging, and deconvolution code, this package includes interfaces to MIRIAD (ascl:1106.007) and HEALPix (ascl:1107.018), and math/fitting routines from SciPy.

[ascl:1107.006]
AIRES: AIRshower Extended Simulations

The objective of this work is to report on the influence of muon interactions on the development of air showers initiated by astroparticles. We make a comparative study of the different theoretical approaches to muon bremsstrahlung and muonic pair production interactions. A detailed algorithm that includes all the relevant characteristics of such processes has been implemented in the AIRES air shower simulation system. We have simulated ultra high energy showers in different conditions in order to measure the influence of these muonic electromagnetic interactions. We have found that during the late stages of the shower development (well beyond the shower maximum) many global observables are significantly modified in relative terms when the mentioned interactions are taken into account. This is most evident in the case of the electromagnetic component of very inclined showers. On the other hand, our simulations indicate that the studied processes do not induce significant changes either in the position of the shower maximum or the structure of the shower front surface.

[ascl:1310.004]
AIRY: Astronomical Image Restoration in interferometrY

Carbillet, Marcel; Fini, Luca; Anconelli, Barbara; Desiderà, Gabriele; La Camera, Andrea; Bertero, Mario; Boccacci, Patrizia

AIRY simulates optical and near-infrared interferometric observations; it can also perform subsequent image restoration or deconvolution. It is based on the CAOS (ascl:1106.017) Problem Solving Environment. Written in IDL, it consists of a set of specific modules, each handling a particular task.

[ascl:1402.005]
Aladin Lite: Lightweight sky atlas for browsers

Aladin Lite is a lightweight version of the Aladin tool, running in the browser and geared towards simple visualization of a sky region. It allows visualization of image surveys (JPEG multi-resolution HEALPix all-sky surveys) and permits superimposing tabular (VOTable) and footprints (STC-S) data. Aladin Lite is powered by HTML5 canvas technology and is easily embeddable on any web page and can also be controlled through a Javacript API.

[ascl:1112.019]
Aladin: Interactive Sky Atlas

Aladin is an interactive software sky atlas allowing the user to visualize digitized astronomical images, superimpose entries from astronomical catalogues or databases, and interactively access related data and information from the Simbad database, the VizieR service and other archives for all known sources in the field.

Created in 1999, Aladin has become a widely-used VO tool capable of addressing challenges such as locating data of interest, accessing and exploring distributed datasets, visualizing multi-wavelength data. Compliance with existing or emerging VO standards, interconnection with other visualisation or analysis tools, ability to easily compare heterogeneous data are key topics allowing Aladin to be a powerful data exploration and integration tool as well as a science enabler.

[ascl:1708.008]
ALCHEMIC: Advanced time-dependent chemical kinetics

ALCHEMIC solves chemical kinetics problems, including gas-grain interactions, surface reactions, deuterium fractionization, and transport phenomena and can model the time-dependent chemical evolution of molecular clouds, hot cores, corinos, and protoplanetary disks.

[ascl:1512.005]
ALFA: Automated Line Fitting Algorithm

ALFA fits emission line spectra of arbitrary wavelength coverage and resolution, fully automatically. It uses a catalog of lines which may be present to construct synthetic spectra, the parameters of which are then optimized by means of a genetic algorithm. Uncertainties are estimated using the noise structure of the residuals. An emission line spectrum containing several hundred lines can be fitted in a few seconds using a single processor of a typical contemporary desktop or laptop PC. Data cubes in FITS format can be analysed using multiple processors, and an analysis of tens of thousands of deep spectra obtained with instruments such as MUSE will take a few hours.

[ascl:1804.021]
allantools: Allan deviation calculation

allantools calculates Allan deviation and related time & frequency statistics. The library is written in Python and has a GPL v3+ license. It takes input data that is either evenly spaced observations of either fractional frequency, or phase in seconds. Deviations are calculated for given tau values in seconds. Several noise generators for creating synthetic datasets are also included.

[ascl:1903.003]
allesfitter: Flexible star and exoplanet inference from photometry and radial velocity

allesfitter provides flexible and robust inference of stars and exoplanets given photometric and radial velocity (RV) data. The software offers a rich selection of orbital and transit models, accommodating multiple exoplanets, multi-star systems, star spots, stellar flares, and various noise models. It features both parameter estimation and model selection. A graphical user interface is used to specify input parameters, and to easily run a nested sampling or Markov Chain Monte Carlo (MCMC) fit, producing publication-ready tables, LaTex code, and plots. allesfitter provides an inference framework that unites the versatile packages ellc (ascl:1603.016), aflare (flare model; Davenport et al. 2014), dynesty (ascl:1809.013), emcee (ascl:1303.002) and celerite (ascl:1709.008).

[ascl:1106.001]
AlterBBN: A program for calculating the BBN abundances of the elements in alternative cosmologies

AlterBBN evaluates the abundances of the elements generated by Big-Bang nucleosynthesis (BBN). This program computes the abundances of the elements in the standard model of cosmology and allows the user to alter the assumptions of the cosmological model to study their consequences on the abundances of the elements. In particular the baryon-to-photon ratio and the effective number of neutrinos, as well as the expansion rate and the entropy content of the Universe during BBN can be modified in AlterBBN. Such features allow the user to test the cosmological models by confronting them to BBN constraints.

[ascl:1503.006]
AMADA: Analysis of Multidimensional Astronomical DAtasets

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.

[submitted]
amber_meta

amber_meta integrates a few routines to launch AMBER (the “Apertif Monitor for Bursts Encountered in Real-time”, https://github.com/AA-ALERT/AMBER) in a systematic manner. To avoid typing a string in the command line manually with all parameters required to launch AMBER, amber_meta generates the command from configuration files, and can directly launch AMBER instances.

[ascl:1010.003]
AMBER: Data Reduction Software

Malbet, Fabien; Duvert, Gilles; Millour, Florentin; Le Bouquin, Jean-Baptiste; Mella, Guillaume; Halipré, Luc; Chelli, Alain; Lafrasse, Sylvain; Altariba, Evelyne; Zins, Gérard

AMBER data reduction software has an optional graphic interface in a high level language, allowing the user to control the data reduction step by step or in a completely automatic manner. The software has a robust calibration scheme that make use of the full calibration sets available during the night. The output products are standard OI-FITS files, which can be used directly in high level software like model fitting or image reconstruction tools.

[ascl:1404.007]
AMBIG: Automated Ambiguity-Resolution Code

AMBIG is a fast, automated algorithm for resolving the 180° ambiguity in vector magnetic field data, including those data from Hinode/Spectropolarimeter. The Fortran-based code is loosely based on the Minimum Energy Algorithm, and is distributed to provide ambiguity-resolved data for the general user community.

[ascl:1007.006]
AMIGA: Adaptive Mesh Investigations of Galaxy Assembly

AMIGA is a publicly available adaptive mesh refinement code for (dissipationless) cosmological simulations. It combines an N-body code with an Eulerian grid-based solver for the full set of magnetohydrodynamics (MHD) equations in order to conduct simulations of dark matter, baryons and magnetic fields in a self-consistent way in a fully cosmological setting. Our numerical scheme includes effective methods to ensure proper capturing of shocks and highly supersonic flows and a divergence-free magnetic field. The high accuracy of the code is demonstrated by a number of numerical tests.

[ascl:1502.017]
AMIsurvey: Calibration and imaging pipeline for radio data

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.

[ascl:2005.015]
AMPEL: Alert Management, Photometry, and Evaluation of Light curves

Nordin, J.; Brinnel, V.; van Santen, J.; Bulla, M.; Feindt, U.; Franckowiak, A.; Fremling, C.; Gal-Yam, A.; Giomi, M.; Kowalski, M.; Mahabal, A.; Miranda, N.; Rauch, L.; Reusch, S.; Rigault, M.; Schulze, S.; Sollerman, J.; Stein, R.; Yaron, O.; van Velzen, S.; Ward, C.

AMPEL provides an analysis framework for high-throughput surveys and is suited for streamed data. The package combines the functionality of an alert broker with a generic framework capable of hosting user-contributed code; it encourages provenance and keeps track of the varying information states that a transient displays. The latter concept includes information gathered over time and data policies such as access or calibration levels.

[ascl:1107.007]
AMUSE: Astrophysical Multipurpose Software Environment

AMUSE is an open source software framework for large-scale simulations in astrophysics, in which existing codes for gravitational dynamics, stellar evolution, hydrodynamics and radiative transport can be easily coupled and placed in the appropriate observational context.

[ascl:1708.028]
ANA: Astrophysical Neutrino Anisotropy

ANA calculates the likelihood function for a model comprised of two components to the astrophysical neutrino flux detected by IceCube. The first component is extragalactic. Since point sources have not been found and there is increasing evidence that one source catalog cannot describe the entire data set, ANA models the extragalactic flux as isotropic. The second component is galactic. A variety of catalogs of interest are also provided. ANA takes the galactic contribution to be proportional to the matter density of the universe. The likelihood function has one free parameter fgal that is the fraction of the astrophysical flux that is galactic. ANA finds the best fit value of fgal and scans over 0<f_{gal}<1.

[ascl:1402.019]
ANAigm: Analytic model for attenuation by the intergalactic medium

ANAigm offers an updated version of the Madau model for the attenuation by the intergalactic neutral hydrogen against the radiation from distant objects. This new model is written in Fortran90 and predicts, for some redshifts, more than 0.5--1 mag different attenuation magnitudes through usual broad-band filters relative to the original Madau model.

[ascl:1908.015]
Analysator: Quantitative analysis of Vlasiator files

Hannuksela, Otto Akseli; Battarbee, Markus; Pfau-Kempf, Yann; von Alfthan, Sebastian; Jarvinen, Riku; Ganse, Urs; Suni, Jonas

Analysator analyzes vlsv files produced by Vlasiator (ascl:1908.014). The code facilitates studies of particle paths, pitch angle distributions, velocity distributions, and more. It can read and write VLSV files and do calculations with the data, plot the real space from VLSV files with Mayavi (ascl:1205.008), and plot the velocity space (both blocks and iso surface) from VLSV files. It can also take cut-throughs, pitch angle distributions, gyrophase angle, and 3d slices, plot variables with sub plots in a clean format, and fit 1D polynomials to data.

[ascl:1110.001]
analytic_infall: A Molecular Line Infall Fitting Program

This code contains several simple radiative transfer models used for fitting the blue-asymmetric spectral line signature often found in infalling molecular cloud cores. It attempts to provide a direct measure of several physical parameters of the infalling core, including infall velocity, excitation temperature, and line of site optical depth. The code includes 6 radiative transfer models, however the conclusion of the associated paper is that the 5 parameter "hill" model (hill5) is most likely the best match to the physical excitation conditions of real infalling Bonnor-Ebert type clouds.

[ascl:1912.007]
anesthetic: Nested sampling visualization

anesthetic brings together tools for processing nested sampling chains, leveraging standard scientific python libraries. The code provides computation of Bayesian evidences, Kullback-Liebler divergences and Bayesian model dimensionalities, marginalized 1d and 2d plots, and dynamic replaying of nested sampling. anesthetic was designed primarily for use with nested sampling outputs, although it can be used for normal MCMC chains.

[ascl:1807.012]
AngPow: Fast computation of accurate tomographic power spectra

AngPow computes the auto (z1 = z2) and cross (z1 ≠ z2) angular power spectra between redshift bins (i.e. Cℓ(z1,z2)). The developed algorithm is based on developments on the Chebyshev polynomial basis and on the Clenshaw-Curtis quadrature method. AngPow is flexible and can handle any user-defined power spectra, transfer functions, bias functions, and redshift selection windows. The code is fast enough to be embedded inside programs exploring large cosmological parameter spaces through the Cℓ(z1,z2) comparison with data.

[ascl:9909.002]
ANGSIZ: A general and practical method for calculating cosmological distances

The calculation of distances is of fundamental importance in extragalactic astronomy and cosmology. However, no practical implementation for the general case has previously been available. We derive a second-order differential equation for the angular size distance valid not only in all homogeneous Friedmann-Lemaitre cosmological models, parametrised by $lambda_{0}$ and $Omega_{0}$, but also in inhomogeneous 'on-average' Friedmann-Lemaitre models, where the inhomogeneity is given by the (in the general case redshift-dependent) parameter $eta$. Since most other distances can be obtained trivially from the angular size distance, and since the differential equation can be efficiently solved numerically, this offers for the first time a practical method for calculating distances in a large class of cosmological models. We also briefly discuss our numerical implementation, which is publicly available.

[ascl:1411.019]
Anmap: Image and data analysis

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.

[ascl:1209.009]
ANNz: Artificial Neural Networks for estimating photometric redshifts

ANNz is a freely available software package for photometric redshift estimation using Artificial Neural Networks. ANNz learns the relation between photometry and redshift from an appropriate training set of galaxies for which the redshift is already known. Where a large and representative training set is available, ANNz is a highly competitive tool when compared with traditional template-fitting methods.

For a newer implementation of this package, please see ANNz2 (ascl:1910.014).

[ascl:1910.014]
ANNz2: Estimating photometric redshift and probability density functions using machine learning methods

ANNz2, a newer implementation of ANNz (ascl:1209.009), utilizes multiple machine learning methods such as artificial neural networks, boosted decision/regression trees and k-nearest neighbors to measure photo-zs based on limited spectral data. The code dynamically optimizes the performance of the photo-z estimation and properly derives the associated uncertainties. In addition to single-value solutions, ANNz2 also generates full probability density functions (PDFs) in two different ways. In addition, estimators are incorporated to mitigate possible problems of spectroscopic training samples which are not representative or are incomplete. ANNz2 is also adapted to provide optimized solutions to general classification problems, such as star/galaxy separation.

[ascl:1802.008]
AntiparticleDM: Discriminating between Majorana and Dirac Dark Matter

AntiparticleDM calculates the prospects of future direct detection experiments to discriminate between Majorana and Dirac Dark Matter (*i.e.*, to determine whether Dark Matter is its own antiparticle). Direct detection event rates and mock data generation are dealt with by a variation of the WIMpy code.

[ascl:1010.017]
AOFlagger: RFI Software

The radio frequency interference code AOFlagger automatically flags data and can be used to analyze the data in a measurement. The purpose of flagging is to mark samples that are affected by interfering sources such as radio stations, airplanes, electrical fences or other transmitting interferers.

The tools in the package are meant for offline use. The software package contains a graphical interface ("rfigui") that can be used to visualize a measurement set and analyze mitigation techniques. It also contains a console flagger ("rficonsole") that can execute a script of mitigation functions without the overhead of a graphical environment. All tools were written in C++.

The software has been tested extensively on low radio frequencies (150 MHz or lower) produced by the WSRT and LOFAR telescopes. LOFAR is the Low Frequency Array that is built in and around the Netherlands. Higher frequencies should work as well. Some of the methods implemented are the SumThreshold, the VarThreshold and the singular value decomposition (SVD) method. Included also are several surface fitting algorithms.

The software is published under the GNU General Public License version 3.

[ascl:1910.021]
AOtools: Adaptive optics modeling and analysis toolkit

The AOtools package offers generic adaptive optics processing tools in addition to astronomy-specific methods; among these are analyzing data in the pupil plane, images and point spread functions in the focal plane, wavefront sensors, modeling of atmospheric turbulence, physical optical propagation of wavefronts, and conversion functions to convert stellar brightness into photon flux for a given waveband. The software also calculates integrated atmospheric parameters, such as coherence time and isoplanatic angle from atmospheric turbulence and wind speed profile.

[ascl:1910.012]
AOTOOLS: Reduce IR images from Adaptive Optics

AOTOOLS reduces IR images from adaptive optics. It uses effective dithering, either sky subtraction or dark-subtration, and flat-fielding techniques to determine the effect of the instrument on an image of an object. It also performs bad pixel masking, degrades an AO on-axis PSF due to effects of anisoplanicity, and corrects an AO on-axis PSF due to effects of seeing.

[ascl:1103.011]
AP3M: Adaptive Particle-particle, Particle-mesh Code

AP^{3}M is an adaptive particle-particle, particle-mesh code. It is older than Hydra (ascl:1103.010) but faster and more memory-efficient for dark-matter only calculations. The Adaptive P^{3}M technique (AP^{3}M) is built around the standard P^{3}M algorithm. AP^{3}M produces fully equivalent forces to P^{3}M but represents a more efficient implementation of the force splitting idea of P^{3}M. The AP^{3}M program may be used in any of the three modes with an appropriate choice of input parameter.

[ascl:2002.010]
Apercal: Pipeline for the Westerbork Synthesis Radio Telescope Apertif upgrade

Apercal is a dedicated, automated data reduction and analysis pipeline written for the Apertif (APERture Tile In Focus) upgrade to the Westerbork Synthesis Radio Telescope. This upgrade dramatically increases the field of view and survey speed of the telescope and is being used for survey observations that can produce 5 terabytes of data for each observation. Apercal uses existing and new tools and parallelization to provide the performance needed for the large volume of data produced Apertif surveys. The software is written entirely in Python and uses third–party astronomical software, such as AOFlagger (ascl:1010.017), CASA (ascl:1107.013), and Miriad (ascl:1106.007), for certain tasks. Apercal is modular, making it possible to run specific modules manually instead of the full pipeline, and information can be exchanged between modules because status parameters are written and read from a python pickled dictionary file. The pipeline can also run fully automatically.

[ascl:1208.017]
APLpy: Astronomical Plotting Library in Python

APLpy (the Astronomical Plotting Library in Python) is a Python module for producing publication-quality plots of astronomical imaging data in FITS format. The module uses Matplotlib, a powerful and interactive plotting package. It is capable of creating output files in several graphical formats, including EPS, PDF, PS, PNG, and SVG. Plots can be made interactively or by using scripts, and can generate co-aligned FITS cubes to make three-color RGB images. It also offers different overlay capabilities, including contour sets, markers with customizable symbols, and coordinate grids, and a range of other useful features.

[ascl:1608.003]
appaloosa: Python-based flare finding code for Kepler light curves

The appaloosa suite automates flare-finding in every Kepler light curves. It builds quiescent light curve models that include long- and short-cadence data through iterative de-trending and includes completeness estimates via artificial flare injection and recovery tests.

[ascl:1804.017]
APPHi: Automated Photometry Pipeline for High Cadence Large Volume Data

Sánchez, E.; Castro, J.; Silva, J.; Hernández, J.; Reyes, M.; Hernández, B.; Alvarez, F.; García, T.

APPHi (Automated Photometry Pipeline) carries out aperture and differential photometry of TAOS-II project data. It is computationally efficient and can be used also with other astronomical wide-field image data. APPHi works with large volumes of data and handles both FITS and HDF5 formats. Due the large number of stars that the software has to handle in an enormous number of frames, it is optimized to automatically find the best value for parameters to carry out the photometry, such as mask size for aperture, size of window for extraction of a single star, and the number of counts for the threshold for detecting a faint star. Although intended to work with TAOS-II data, APPHi can analyze any set of astronomical images and is a robust and versatile tool to performing stellar aperture and differential photometry.

[ascl:1810.018]
APPLawD: Accurate Potentials in Power Law Disks

APPLawD (Accurate Disk Potentials for Power Law Surface densities) determines the gravitational potential in the equatorial plane of a flat axially symmetric disk (inside and outside) with finite size and power law surface density profile. Potential values are computed on the basis of the density splitting method, where the residual Poisson kernel is expanded over the modulus of the complete elliptic integral of the first kind. In contrast with classical multipole expansions of potential theory, the residual series converges linearly inside sources, leading to very accurate potential values for low order truncations of the series. The code is easy to use, works under variable precision, and is written in Fortran 90 with no external dependencies.

[ascl:1106.019]
Application of Compressive Sampling to Radio Astronomy I: Deconvolution

Compressive sampling is a new paradigm for sampling, based on sparseness of signals or signal representations. It is much less restrictive than Nyquist-Shannon sampling theory and thus explains and systematises the widespread experience that methods such as the Högbom CLEAN can violate the Nyquist-Shannon sampling requirements. In this paper, a CS-based deconvolution method for extended sources is introduced. This method can reconstruct both point sources and extended sources (using the isotropic undecimated wavelet transform as a basis function for the reconstruction step). We compare this CS-based deconvolution method with two CLEAN-based deconvolution methods: the Högbom CLEAN and the multiscale CLEAN. This new method shows the best performance in deconvolving extended sources for both uniform and natural weighting of the sampled visibilities. Both visual and numerical results of the comparison are provided.

[ascl:1308.005]
APPSPACK: Asynchronous Parallel Pattern Search

APPSPACK is serial or parallel, derivative-free optimization software for solving nonlinear unconstrained, bound-constrained, and linearly-constrained optimization problems, with possibly noisy and expensive objective functions.

[ascl:1408.021]
APS: Active Parameter Searching

APS finds Frequentist confidence limits on high-dimensional parameter spaces by using Gaussian Process interpolation to identify regions of parameter space for which chisquared is less than or equal to some specified limit. The code is written in C++, is robust against multi-modal chisquared functions and converges comparably fast to Monte Carlo methods. Code is also provided to draw Bayesian credible limits using the outputs of APS, though this code does not converge as well. APS requires the linear algebra libraries LAPACK, BLAS, and ARPACK (ascl:1311.010) to run.

[ascl:1208.003]
APT: Aperture Photometry Tool

Aperture Photometry Tool (APT) is software for astronomers and students interested in manually exploring the photometric qualities of astronomical images. It has a graphical user interface (GUI) which allows the image data associated with aperture photometry calculations for point and extended sources to be visualized and, therefore, more effectively analyzed. Mouse-clicking on a source in the displayed image draws a circular or elliptical aperture and sky annulus around the source and computes the source intensity and its uncertainty, along with several commonly used measures of the local sky background and its variability. The results are displayed and can be optionally saved to an aperture-photometry-table file and plotted on graphs in various ways using functions available in the software. APT is geared toward processing sources in a small number of images and is not suitable for bulk processing a large number of images, unlike other aperture photometry packages (e.g., SExtractor). However, APT does have a convenient source-list tool that enables calculations for a large number of detections in a given image. The source-list tool can be run either in automatic mode to generate an aperture photometry table quickly or in manual mode to permit inspection and adjustment of the calculation for each individual detection. APT displays a variety of useful graphs, including image histogram, and aperture slices, source scatter plot, sky scatter plot, sky histogram, radial profile, curve of growth, and aperture-photometry-table scatter plots and histograms. APT has functions for customizing calculations, including outlier rejection, pixel “picking” and “zapping,” and a selection of source and sky models. The radial-profile-interpolation source model, accessed via the radial-profile-plot panel, allows recovery of source intensity from pixels with missing data and can be especially beneficial in crowded fields.

[ascl:1007.005]
Arcetri Spectral Code for Thin Plasmas

The Arcetri spectral code allows to evaluate the spectrum of the radiation emitted by hot and optically thin plasmas in the spectral range 1 - 2000 Angstroms. The database has been updated including atomic data and radiative and collisional rates to calculate level population and line emissivities for a number of ions of the minor elements; a critical compilation of the electron collision excitation for these elements has been performed. The present version of the program includes the CHIANTI database for the most abundant elements, the minor elements data, and Fe III atomic model, radiative and collisional data.

[ascl:1107.011]
ARCHANGEL: Galaxy Photometry System

ARCHANGEL is a Unix-based package for the surface photometry of galaxies. While oriented for large angular size systems (i.e. many pixels), its tools can be applied to any imaging data of any size. The package core contains routines to perform the following critical galaxy photometry functions: sky determination; frame cleaning; ellipse fitting; profile fitting; and total and isophotal magnitudes.

The goal of the package is to provide an automated, assembly-line type of reduction system for galaxy photometry of space-based or ground-based imaging data. The procedures outlined in the documentation are flux independent, thus, these routines can be used for non-optical data as well as typical imaging datasets.

ARCHANGEL has been tested on several current OS's (RedHat Linux, Ubuntu Linux, Solaris, Mac OS X). A tarball for installation is available at the download page. The main routines are Python and FORTRAN based, therefore, a current installation of Python and a FORTRAN compiler are required. The ARCHANGEL package also contains Python hooks to the PGPLOT package, an XML processor and network tools which automatically link to data archives (i.e. NED, HST, 2MASS, etc) to download images in a non-interactive manner.

[ascl:2006.015]
ARCHI: Add-on pipeline module for background star analysis from CHEOPS data

Silva, André M.; Sousa, Sérgio G.; Santos, Nuno; Demangeon, Olivier D. S.; Silva, Pedro; Hoyer, S.; Guterman, P.; Deleuil, Magali; Ehrenreich, David

The CHaracterizing ExOPlanet Satellite (CHEOPS) mission pipeline provides photometry for the central star in its field; ARCHI takes in data from the CHEOPS mission pipeline, analyzes the background stars, and determines the photometry of these stars, thus creating the possibility of producing photometric time-series of several close-by targets at once, in addition to using different stars in the image to calibrate systematic errors.

[ascl:1805.012]
Arcmancer: Geodesics and polarized radiative transfer library

Arcmancer computes geodesics and performs polarized radiative transfer in user-specified spacetimes. The library supports Riemannian and semi-Riemannian spaces of any dimension and metric; it also supports multiple simultaneous coordinate charts, embedded geometric shapes, local coordinate systems, and automatic parallel propagation. Arcmancer can be used to solve various problems in numerical geometry, such as solving the curve equation of motion using adaptive integration with configurable tolerances and differential equations along precomputed curves. It also provides support for curves with an arbitrary acceleration term and generic tools for generating ray initial conditions and performing parallel computation over the image, among other tools.

[ascl:1909.010]
AREPO: Cosmological magnetohydrodynamical moving-mesh simulation code

AREPO is a massively parallel gravity and magnetohydrodynamics code for astrophysics, designed for problems of large dynamic range. It employs a finite-volume approach to discretize the equations of hydrodynamics on a moving Voronoi mesh, and a tree-particle-mesh method for gravitational interactions. AREPO is originally optimized for cosmological simulations of structure formation, but has also been used in many other applications in astrophysics.

[ascl:2011.010]
ARES: Accelerated Reionization Era Simulations

The Accelerated Reionization Era Simulations (ARES) code rapidly generates models for the global 21-cm signal. It can also be used as a 1-D radiative transfer code, stand-alone non-equilibrium chemistry solver, or global radiation background calculator.

[ascl:1205.009]
ARES: Automatic Routine for line Equivalent widths in stellar Spectra

ARES was developed for the measurement of Equivalent Width of absortion lines in stellar spectra; it can also be used to determine fundamental spectroscopic stellar parameters.The code reads a 1D FITS spectra and fits the requested lines in order to calculate the Equivalent width. The code is written in C++ based on the standard method of determining EWs. It automates the manual procedure that one normally carries out when using interactive routines such as the splot routine implemented in IRAF.

[ascl:1807.004]
ARKCoS: Radial kernel convolution on the sphere

ARKCoS (Accelerated radial kernel convolution on the sphere) efficiently convolves pixelated maps on the sphere with radially symmetric kernels with compact support. It performs the convolution along isolatitude rings in Fourier space and integrates in longitudinal direction in pixel space. The computational costs scale linearly with the kernel support, making the method most beneficial for convolution with compact kernels. Typical applications include CMB beam smoothing, symmetric wavelet analyses, and point-source filtering operations. The software is written in C++/CUDA and provides two independent code paths to do the necessary computation either on conventional hardware (CPUs), or on graphics processing units (GPUs).

[ascl:1505.005]
ARoME: Analytical Rossiter-McLaughlin Effects

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.

[ascl:1311.010]
ARPACK: Solving large scale eigenvalue problems

ARPACK is a collection of Fortran77 subroutines designed to solve large scale eigenvalue problems. The package is designed to compute a few eigenvalues and corresponding eigenvectors of a general n by n matrix A. It is most appropriate for large sparse or structured matrices A where structured means that a matrix-vector product w <- Av requires order n rather than the usual order n2 floating point operations. This software is based upon an algorithmic variant of the Arnoldi process called the Implicitly Restarted Arnoldi Method (IRAM). When the matrix A is symmetric it reduces to a variant of the Lanczos process called the Implicitly Restarted Lanczos Method (IRLM). These variants may be viewed as a synthesis of the Arnoldi/Lanczos process with the Implicitly Shifted QR technique that is suitable for large scale problems. For many standard problems, a matrix factorization is not required; only the action of the matrix on a vector is needed. ARPACK is capable of solving large scale symmetric, nonsymmetric, and generalized eigenproblems from significant application areas.

[ascl:1810.007]
ARTES: 3D Monte Carlo scattering radiative transfer in planetary atmospheres

The 3D Monte Carlo radiative transfer code ARTES calculates reflected light and thermal radiation in a spherical grid with a parameterized distribution of gas, clouds, hazes, and circumplanetary material. Designed specifically for (polarized) scattered light simulations of planetary atmospheres, it can compute both reflected stellar light and thermal emission from the planet for an arbitrary atmospheric structure and distribution of opacity sources. Multiple scattering, absorption, and polarization are fully treated and the output includes an image, spectrum, or phase curve. Several tools are included to create opacities and scattering matrices for molecules and clouds.

[ascl:1802.004]
ARTIP: Automated Radio Telescope Image Processing Pipeline

Sharma, Ravi; Gyanchandani, Dolly; Kulkarni, Sarang; Gupta, Neeraj; Pathak, Vineet; Pande, Arti; Joshi, Unmesh

The Automated Radio Telescope Image Processing Pipeline (ARTIP) automates the entire process of flagging, calibrating, and imaging for radio-interferometric data. ARTIP starts with raw data, i.e. a measurement set and goes through multiple stages, such as flux calibration, bandpass calibration, phase calibration, and imaging to generate continuum and spectral line images. Each stage can also be run independently. The pipeline provides continuous feedback to the user through various messages, charts and logs. It is written using standard python libraries and the CASA package. The pipeline can deal with datasets with multiple spectral windows and also multiple target sources which may have arbitrary combinations of flux/bandpass/phase calibrators.

[ascl:1402.014]
ARTIST: Adaptable Radiative Transfer Innovations for Submillimeter Telescopes

Jørgensen, Jes; Brinch, Christian; Girart, Josep Miquel; Padovani, Marco; Frau, Pau; Schaaf, Reinhold; Kuiper, Rolf; Bertoldi, Frank; Hogerheijde, Michiel; Juhasz, Attila; Vlemmings, Wouter

ARTIST is a suite of tools for comprehensive multi-dimensional radiative transfer calculations of dust and line emission, as well as their polarization, to help interpret observations from submillimeter telescopes. The ARTIST package consists of LIME, a radiative transfer code that uses adaptive gridding allowing simulations of sources with arbitrary multi-dimensional (1D, 2D, 3D) and time-dependent structures, thus ensuring rapid convergence; the DustPol and LinePol tools for modeling the polarization of the line and dust emission; and an interface run from Python scripts that manages the interaction between a general model library and LIME, and a graphical interface to simulate images.

[ascl:2004.012]
ArviZ: Exploratory analysis of Bayesian models

ArviZ provides backend-agnostic tools for diagnostics and visualizations of Bayesian inference by first converting inference data into xarray objects. It includes functions for posterior analysis, model checking, comparison and diagnostics. ArviZ’s functions work with NumPy arrays, dictionaries of arrays, xarray datasets, and have built-in support for PyMC3 (ascl:1610.016), PyStan, CmdStanPy, Pyro (ascl:1507.018), NumPyro, emcee (ascl:1303.002), and TensorFlow Probability objects. A Julia wrapper is also available.

[ascl:1204.016]
ASCfit: Automatic Stellar Coordinate Fitting Package

A modular software package for automatically fitting astrometric world coordinates (WCS) onto raw optical or infrared FITS images. Image stars are identified with stars in a reference catalog (USNO-A2 or 2MASS), and coordinates derived as a simple linear transformation from (X,Y) pixels to (RA,DEC) to the accuracy level of the reference catalog used. The package works with both optical and infrared images, at sidereal and non-sidereal tracking rates.

[ascl:1804.001]
ASERA: A Spectrum Eye Recognition Assistant

ASERA, ASpectrum Eye Recognition Assistant, aids in quasar spectral recognition and redshift measurement and can also be used to recognize various types of spectra of stars, galaxies and AGNs (Active Galactic Nucleus). This interactive software allows users to visualize observed spectra, superimpose template spectra from the Sloan Digital Sky Survey (SDSS), and interactively access related spectral line information. ASERA is an efficient and user-friendly semi-automated toolkit for the accurate classification of spectra observed by LAMOST (the Large Sky Area Multi-object Fiber Spectroscopic Telescope) and is available as a standalone Java application and as a Java applet. The software offers several functions, including wavelength and flux scale settings, zoom in and out, redshift estimation, and spectral line identification.

[ascl:1603.009]
Asfgrid: Asteroseismic parameters for a star

asfgrid computes asteroseismic parameters for a star with given stellar parameters and vice versa. Written in Python, it determines delta_nu, nu_max or masses via interpolation over a grid.

[ascl:1912.003]
ASKAPsoft: ASKAP science data processor software

Guzman, Juan; Whiting, Matthew; Voronkov, Max; Mitchell, Daniel; Ord, Stephen; Collins, Daniel; Marquarding, Malte; Lahur, Paulus; Maher, Tony; Van Diepen, Ger; Bannister, Keith; Wu, Xinyu; Lenc, Emil; Khoo, Jonathan; Bastholm, Eric

ASKAPsoft provides data processing functionality for Australian Square Kilometre Array Pathfinder, including calibration, spectral line imaging, continuum imaging, source detection and generation of source catalogs, and transient detection. The MPI-based package is the primary software for storing and processing raw data, and initiating the archiving of resulting science data products into the data archive (CASDA). The processing pipelines within ASKAPsoft are largely written in C++ built on top of casacore (ascl:1912.002) and other third party libraries.

[ascl:1609.020]
Askaryan Module: Askaryan electric fields predictor

The Askaryan Module is a C++ class that predicts the electric fields that Askaryan-based detectors detect; it is computationally efficient and accurate, performing fully analytic calculations requiring no *a priori* MC analysis to compute the entire field, for any frequencies, times, or viewing angles chosen by the user.

[ascl:1807.030]
ASP: Ames Stereo Pipeline

ASP (Ames Stereo Pipeline) provides fully automated geodesy and stereogrammetry tools for processing stereo imagery captured from satellites (around Earth and other planets), robotic rovers, aerial cameras, and historical imagery, with and without accurate camera pose information. It produces cartographic products, including digital elevation models (DEMs), ortho-projected imagery, 3D models, and bundle-adjusted networks of cameras. ASP's data products are suitable for science analysis, mission planning, and public outreach.

[ascl:1112.017]
ASpec: Astronomical Spectrum Analysis Package

ASpec is a spectrum and line analysis package developed at STScI. ASpec is designed as an add-on package for IRAF and incorporates a variety of analysis techniques for astronomical spectra. ASpec operates on spectra from a wide variety of ground-based and space-based instruments and allows simultaneous handling of spectra from different wavelength regimes. The package accommodates non-linear dispersion relations and provides a variety of functions, individually or in combination, with which to fit spectral features and the continuum. It also permits the masking of known bad data. ASpec provides a powerful, intuitive graphical user interface implemented using the IRAF Object Manager and customized to handle: data input/output (I/O); on-line help; selection of relevant features for analysis; plotting and graphical interaction; and data base management.

[ascl:1209.015]
Aspects: Probabilistic/positional association of catalogs of sources

Given two catalogs K and K' of n and n' astrophysical sources, respectively, Aspects (Association positionnelle/probabiliste de catalogues de sources) computes, for any objects M_{i} ∈ K and M'_{j} ∈ K', the probability that M'_{j} is a counterpart of M_{i}, i.e. that they are the same source. To determine this probability of association, the code takes into account the coordinates and the positional uncertainties of all the objects. Aspects also computes the probability P(A_{i, 0} | C ∩ C') that M_{i} has no counterpart.

Aspects is written in Fortran 95; the required Fortran 90 Numerical Recipes routines used in version 1.0 have been replaced with free equivalents in version 2.0.

[ascl:1806.031]
ASPIC: Accurate Slow-roll Predictions for Inflationary Cosmology

Aspic, written in modern Fortran, computes various observable quantities used in cosmology from definite single field inflationary models. It provides an efficient, extendable, and accurate way of comparing theoretical inflationary predictions with cosmological data and supports many (~70) models of inflation. The Hubble flow functions, observable quantities up to second order in the slow-roll approximation, are in direct correspondence with the spectral index, the tensor-to-scalar ratio and the running of the primordial power spectrum. The ASPIC library also provides the field potential, its first and second derivatives, the energy density at the end of inflation, the energy density at the end of reheating, and the field value (or e-fold value) at which the pivot scale crossed the Hubble radius during inflation. All these quantities are computed in a way which is consistent with the existence of a reheating phase.

[ascl:1510.006]
ASPIC: STARLINK image processing package

Davenhall, A. C.; Hartley, Ken F.; Penny, Alan J.; Kelly, B. D.; King, Dave J.; Lupton, W. F.; Tudhope, D.; Pike, C. D.; Cooke, J. A.; Pence, W. D.; Wallace, Patrick T.; Brownrigg, D. R. K.; Baines, Dave W. T.; Warren-Smith, Rodney F.; McNally, B. V.; Bell, L. L.; Jones, T. A.; Terrett, Dave L.; Pearce, D. J.; Carey, J. V.; Currie, Malcolm J.; Benn, Chris; Beard, S. M.; Giddings, Jack R.; Balona, Luis A.; Harrison, B.; Wood, Roger; Sparkes, Bill; Allan, Peter M.; Berry, David S.; Shirt, J. V.

ASPIC handled basic astronomical image processing. Early releases concentrated on image arithmetic, standard filters, expansion/contraction/selection/combination of images, and displaying and manipulating images on the ARGS and other devices. Later releases added new astronomy-specific applications to this sound framework. The ASPIC collection of about 400 image-processing programs was written using the Starlink "interim" environment in the 1980; the software is now obsolete.

[ascl:1310.005]
ASPRO 2: Astronomical Software to PRepare Observations

ASPRO 2 (Astronomical Software to PRepare Observations) is an observation preparation tool for interferometric observations with the VLTI or other interferometers such as CHARA and SUSI. It is a Java standalone program that provides a dynamic graphical interface to simulate the projected baseline evolution during observations (super-synthesis) and derive visibilities for targets (i.e., single star, binaries, user defined FITS image). It offers other useful functions such as the ability to load and save your observation settings and generate Observing Blocks.

[ascl:1903.011]
AsPy: Aspherical fluctuations on the spherical collapse background

AsPy computes the determinants of aspherical fluctuations on the spherical collapse background. Written in Python, this procedure includes analytic factorization and cancellation of the so-called `IR-divergences'—spurious enhanced contributions that appear in the dipole sector and are associated with large bulk flows.

[ascl:1404.016]
AST: World Coordinate Systems in Astronomy

The AST library provides a comprehensive range of facilities for attaching world coordinate systems to astronomical data, for retrieving and interpreting that information in a variety of formats, including FITS-WCS, and for generating graphical output based on it. Core projection algorithms are provided by WCSLIB (ascl:1108.003) and astrometry is provided by the PAL (ascl:1606.002) and SOFA (ascl:1403.026) libraries. AST bindings are available in Python (pyast), Java (JNIAST) and Perl (Starlink::AST). AST is used as the plotting and astrometry library in DS9 and GAIA, and is distributed separately and as part of the Starlink software collection.

[ascl:1505.002]
ASteCA: Automated Stellar Cluster Analysis

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.

[ascl:1403.023]
ASTERIX: X-ray Data Processing System

Peden, Jim; Allan, David J.; Ponman, Trevor; Saxton, Richard; Andrews, Phillip; Beard, Richard; Vallance, Bob

ASTERIX is a general purpose X-ray data reduction package optimized for ROSAT data reduction. ASTERIX uses the Starlink software environment (ascl:1110.012).

[ascl:1607.016]
astLib: Tools for research astronomers

astLib is a set of Python modules for performing astronomical plots, some statistics, common calculations, coordinate conversions, and manipulating FITS images with World Coordinate System (WCS) information through PyWCSTools, a simple wrapping of WCSTools (ascl:1109.015).

[ascl:2004.006]
ASTRAEUS: Semi-analytical semi-numerical galaxy evolution and reionization code

ASTRAEUS (semi-numerical rAdiative tranSfer coupling of galaxy formaTion and Reionization in n-body dArk mattEr simUlationS) self-consistently derives the evolution of galaxies and the reionization of the IGM based on the merger trees and density fields of a DM-only N-body simulation. It models gas accretion, star formation, SN feedback, the time and spatial evolution of the ionized regions, accounting for recombinations, HI fractions and photoionization rates within ionized regions, and radiative feedback. ASTRAEUS is for studying the galaxy-reionization interplay in the first billion years. The underlying code is written in C and is MPI-parallelized; its modular design allows new physical processes and galaxy properties to be added easily. ASTRAEUS can be run on a tree-branch-by-tree-branch basis (*i.e.,* fully vertical) or on a redshift-by-redshift basis (*i.e.,* fully horizontal) when evolving the galaxies by using local horizontal merger trees.

[ascl:1605.009]
ASTRiDE: Automated Streak Detection for Astronomical Images

ASTRiDE detects streaks in astronomical images using a "border" of each object (i.e. "boundary-tracing" or "contour-tracing") and their morphological parameters. Fast moving objects such as meteors, satellites, near-Earth objects (NEOs), or even cosmic rays can leave streak-like traces in the images; ASTRiDE can detect not only long streaks but also relatively short or curved streaks.

[ascl:1907.032]
Astro-SCRAPPY: Speedy Cosmic Ray Annihilation Package in Python

Astro-SCRAPPY detects cosmic rays in images (numpy arrays), based on Pieter van Dokkum's L.A.Cosmic algorithm and originally adapted from cosmics.py written by Malte Tewes. This implementation is optimized for speed, resulting in slight difference from the original code, such as automatic recognition of saturated stars (rather than treating such stars as large cosmic rays, and use of a separable median filter instead of the true median filter. Astro-SCRAPPY is an AstroPy (ascl:1304.002) affiliated package.

[ascl:1705.016]
astroABC: Approximate Bayesian Computation Sequential Monte Carlo sampler

astroABC is a Python implementation of an Approximate Bayesian Computation Sequential Monte Carlo (ABC SMC) sampler for parameter estimation. astroABC allows for massive parallelization using MPI, a framework that handles spawning of processes across multiple nodes. It has the ability to create MPI groups with different communicators, one for the sampler and several others for the forward model simulation, which speeds up sampling time considerably. For smaller jobs the Python multiprocessing option is also available.

[ascl:1912.010]
AstroAccelerate: Accelerated software package for processing time-domain radio astronomy data

AstroAccelerate processes time-domain radio astronomy data. It offers a standalone code that can be used to process filterbank data and a library that performs GPU-accelerated single pulse processing (SPS), Fourier Domain Acceleration Searching (FDAS) and dedispersion in real-time on very large data-sets comparable to those that will be produced by next-generation radio telescopes such as the SKA. AstroAccelerate uses NVIDIAR GPUs, and is configurable, stable, and easily maintained.

[ascl:1906.001]
Astroalign: Asterism-matching alignment of astronomical images

Astroalign tries to register (align) two stellar astronomical images, especially when there is no WCS information available. It does so by finding similar 3-point asterisms (triangles) in both images and deducing the affine transformation between them. Generic registration routines try to match feature points, using corner detection routines to make the point correspondence. These generally fail for stellar astronomical images since stars have very little stable structure so are, in general, indistinguishable from each other. Asterism matching is more robust and closer to the human way of matching stellar images. Astroalign can match images of very different field of view, point-spread function, seeing and atmospheric conditions. It may require special care or may not work on images of extended objects with few point-like sources or in crowded fields.

[ascl:1311.003]
AstroAsciiData: ASCII table Python module

ASCII tables continue to be one of the most popular and widely used data exchange formats in astronomy. AstroAsciiData, written in Python, imports all reasonably well-formed ASCII tables. It retains formatting of data values, allows column-first access, supports SExtractor style headings, performs column sorting, and exports data to other formats, including FITS, Numpy/Numarray, and LaTeX table format. It also offers interchangeable comment character, column delimiter and null value.

[ascl:1104.002]
AstroBEAR: Adaptive Mesh Refinement Code for Ideal Hydrodynamics & Magnetohydrodynamics

AstroBEAR is a modular hydrodynamic & magnetohydrodynamic code environment designed for a variety of astrophysical applications. It uses the BEARCLAW package, a multidimensional, Eulerian computational code used to solve hyperbolic systems of equations. AstroBEAR allows adaptive-mesh-refinment (AMR) simulations in 2, 2.5 (i.e., cylindrical), and 3 dimensions, in either cartesian or curvilinear coordinates. Parallel applications are supported through the MPI architecture. AstroBEAR is written in Fortran 90/95 using standard libraries.

AstroBEAR supports hydrodynamic (HD) and magnetohydrodynamic (MHD) applications using a variety of spatial and temporal methods. MHD simulations are kept divergence-free via the constrained transport (CT) methods of Balsara & Spicer. Three different equation of state environments are available: ideal gas, gas with differing isentropic γ, and the analytic Thomas-Fermi formulation of A.R. Bell.

[ascl:1512.007]
AstroBlend: Visualization package for use with Blender

AstroBlend is a visualization package for use in the three dimensional animation and modeling software, Blender. It reads data in via a text file or can use pre-fab isosurface files stored as OBJ or Wavefront files. AstroBlend supports a variety of codes such as FLASH (ascl:1010.082), Enzo (ascl:1010.072), and Athena (ascl:1010.014), and combines artistic 3D models with computational astrophysics datasets to create models and animations.

[ascl:2006.017]
AstroCatR: Time series reconstruction of large-scale astronomical catalogs

AstroCatR reconstructs celestial objects' time series data for astronomical catalogs. It is a command-line program running on the Linux platform and is implemented in C and Python; AstroCatR's capabilities are based on specialized sky partitioning and MPI parallel programming. The package contains three parts: ETL (extract-transform-load) pre-processing, TS-matching calculation, and time series data retrieval. Once the user obtains the original catalogs, running ETL pre-processing generates a sky zoning file. The TS-matching module marks celestial objects, and finally, running the Query program searches celestial objects from the time series datasets which matched with the target.

[ascl:1507.010]
Astrochem: Abundances of chemical species in the interstellar medium

Astrochem computes the abundances of chemical species in the interstellar medium, as function of time. It studies the chemistry in a variety of astronomical objects, including diffuse clouds, dense clouds, photodissociation regions, prestellar cores, protostars, and protostellar disks. Astrochem reads a network of chemical reactions from a text file, builds up a system of kinetic rates equations, and solves it using a state-of-the-art stiff ordinary differential equation (ODE) solver. The Jacobian matrix of the system is computed implicitly, so the resolution of the system is extremely fast: large networks containing several thousands of reactions are usually solved in a few seconds. A variety of gas phase process are considered, as well as simple gas-grain interactions, such as the freeze-out and the desorption via several mechanisms (thermal desorption, cosmic-ray desorption and photo-desorption). The computed abundances are written in a HDF5 file, and can be plotted in different ways with the tools provided with Astrochem. Chemical reactions and their rates are written in a format which is meant to be easy to read and to edit. A tool to convert the chemical networks from the OSU and KIDA databases into this format is also provided. Astrochem is written in C, and its source code is distributed under the terms of the GNU General Public License (GPL).

[ascl:1905.007]
Astrocut: Tools for creating cutouts of TESS images

The Transiting Exoplanet Survey Satellite (TESS) produces Full Frame Images (FFIs) at a half hour cadence and keeps the same pointing for ~27 days at a time. Astrocut performs the same cutout across all FFIs that share a common pointing to create a time series of images on a small portion of the sky.

The Astrocut package has two parts: the CubeFactory and the CutoutFactory. The CubeFactory class creates a large image cube from a list of FFI files, which allows the cutout operation to be performed efficiently. The CutoutFactory class performs the actual cutout and builds a target pixel file (TPF) that is compatible with TESS pipeline TPFs. Because this software operates on TESS mission-produced FFIs, the resulting TPFs are not background-subtracted. In addition to the Astrocut software itself, the Mikulski Archive for Space Telescopes (MAST) provides a cutout service, TESScut, which runs Astrocut on MAST servers, and allows users to simply request cutouts through a web form or direct HTTP API query.

[ascl:1804.004]
AstroCV: Astronomy computer vision library

AstroCV processes and analyzes big astronomical datasets, and is intended to provide a community repository of high performance Python and C++ algorithms used for image processing and computer vision. The library offers methods for object recognition, segmentation and classification, with emphasis in the automatic detection and classification of galaxies.

[ascl:1907.016]
astrodendro: Astronomical data dendrogram creator

Astrodendro, written in Python, creates dendrograms for exploring and displaying hierarchical structures in observed or simulated astronomical data. It handles noisy data by allowing specification of the minimum height of a structure and the minimum number of pixels needed for an independent structure. Astrodendro allows interactive viewing of computed dendrograms and can also produce publication-quality plots with the non-interactive plotting interface.

[ascl:1010.013]
AstroGK: Astrophysical Gyrokinetics Code

The gyrokinetic simulation code AstroGK is developed to study fundamental aspects of kinetic plasmas and for applications mainly to astrophysical problems. AstroGK is an Eulerian slab code that solves the electromagnetic Gyrokinetic-Maxwell equations in five-dimensional phase space, and is derived from the existing gyrokinetics code GS2 by removing magnetic geometry effects. Algorithms used in the code are described. The code is benchmarked using linear and nonlinear problems. Serial and parallel performance scalings are also presented.

[ascl:2003.013]
AstroHOG: Analysis correlations using the Histograms of Oriented Gradients

AstroHOG compares extended spectral-line observations (PPV cubes); the histogram of oriented gradients (HOG) technique takes as input two PPV cubes and provides an estimate of their spatial correlation across velocity channels to study spatial correlation between different tracers of the ISM.

[ascl:1309.001]
AstroImageJ: ImageJ for Astronomy

AstroImageJ is generic ImageJ (ascl:1206.013) with customizations to the base code and a packaged set of astronomy specific plugins. It reads and writes FITS images with standard headers, displays astronomical coordinates for images with WCS, supports photometry for developing color-magnitude data, offers flat field, scaled dark, and non-linearity processing, and includes tools for precision photometry that can be used during real-time data acquisition.

[ascl:1502.022]
AstroLines: Astrophysical line list generator in the H-band

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.

[ascl:1406.008]
ASTROM: Basic astrometry program

ASTROM performs "plate reductions" by taking user-provided star positions and the (x,y) coordinates of the corresponding star images and establishes the relationship between (x,y) and (ra,dec), thus enabling the coordinates of unknown stars to be determined. ASTROM is distributed with the Starlink software (ascl:1110.012) and uses SLALIB (ascl:1403.025).

[ascl:1010.078]
AstroMD: A Multi Dimensional Visualization and Analysis Toolkit for Astrophysics

Over the past few years, the role of visualization for scientific purpose has grown up enormously. Astronomy makes an extended use of visualization techniques to analyze data, and scientific visualization has became a fundamental part of modern researches in Astronomy. With the evolution of high performance computers, numerical simulations have assumed a great role in the scientific investigation, allowing the user to run simulation with higher and higher resolution. Data produced in these simulations are often multi-dimensional arrays with several physical quantities. These data are very hard to manage and to analyze efficiently. Consequently the data analysis and visualization tools must follow the new requirements of the research. AstroMD is a tool for data analysis and visualization of astrophysical data and can manage different physical quantities and multi-dimensional data sets. The tool uses virtual reality techniques by which the user has the impression of travelling through a computer-based multi-dimensional model.

[ascl:1203.012]
Astrometrica: Astrometric data reduction of CCD images

Astrometrica is an interactive software tool for scientific grade astrometric data reduction of CCD images. The current version of the software is for the Windows 32bit operating system family. Astrometrica reads FITS (8, 16 and 32 bit integer files) and SBIG image files. The size of the images is limited only by available memory. It also offers automatic image calibration (Dark Frame and Flat Field correction), automatic reference star identification, automatic moving object detection and identification, and access to new-generation star catalogs (PPMXL, UCAC 3 and CMC-14), in addition to online help and other features. Astrometrica is shareware, available for use for a limited period of time (100 days) for free; special arrangements can be made for educational projects.

[ascl:1208.001]
Astrometry.net: Astrometric calibration of images

Astrometry.net is a reliable and robust system that takes as input an astronomical image and returns as output the pointing, scale, and orientation of that image (the astrometric calibration or World Coordinate System information). The system requires no first guess, and works with the information in the image pixels alone; that is, the problem is a generalization of the "lost in space" problem in which nothing—not even the image scale—is known. After robust source detection is performed in the input image, asterisms (sets of four or five stars) are geometrically hashed and compared to pre-indexed hashes to generate hypotheses about the astrometric calibration. A hypothesis is only accepted as true if it passes a Bayesian decision theory test against a null hypothesis. With indices built from the USNO-B catalog and designed for uniformity of coverage and redundancy, the success rate is >99.9% for contemporary near-ultraviolet and visual imaging survey data, with no false positives. The failure rate is consistent with the incompleteness of the USNO-B catalog; augmentation with indices built from the Two Micron All Sky Survey catalog brings the completeness to 100% with no false positives. We are using this system to generate consistent and standards-compliant meta-data for digital and digitized imaging from plate repositories, automated observatories, individual scientific investigators, and hobbyists.

[ascl:1407.018]
AstroML: Machine learning and data mining in astronomy

Written in Python, AstroML is a library of statistical and machine learning routines for analyzing astronomical data in python, loaders for several open astronomical datasets, and a large suite of examples of analyzing and visualizing astronomical datasets. An optional companion library, astroML_addons, is available; it requires a C compiler and contains faster and more efficient implementations of certain algorithms in compiled code.

[ascl:2010.012]
Astronomaly: Flexible framework for anomaly detection in astronomy

Astronomaly actively detects anomalies in astronomical data. A python back-end runs anomaly detection based on machine learning; a JavaScript front-end provides data viewing and labeling. The package works on many common astronomy data types, including one-dimensional data and images, and offering extendable techniques for preprocessing, feature extraction, and machine learning.

[ascl:1802.009]
astroplan: Observation planning package for astronomers

Morris, Brett M.; Tollerud, Erik; Sipocz, Brigitta; Deil, Christoph; Douglas, Stephanie T.; Berlanga Medina, Jazmin; Vyhmeister, Karl; Price-Whelan, Adrian M.; Jeschke, Eric

astroplan is a flexible toolbox for observation planning and scheduling. It is powered by Astropy (ascl:1304.002); it works for Python beginners and new observers, and is powerful enough for observatories preparing nightly and long-term schedules as well. It calculates rise/set/meridian transit times, alt/az positions for targets at observatories anywhere on Earth, and offers built-in plotting convenience functions for standard observation planning plots (airmass, parallactic angle, sky maps). It can also determine the observability of sets of targets given an arbitrary set of constraints (i.e., altitude, airmass, moon separation/illumination, etc.).

[ascl:1402.003]
astroplotlib: Astronomical library of plots

Ubeda, Leonardo; Davis, Matt; Diaz, Rosa; Hammer, Derek; Philippe-Lajoie, Charles; Le Blanc, Tommy; Lim, Pey-Lian; Viana, Alex

Astropoltlib is a multi-language astronomical library of plots, a collection of templates useful for creating paper-quality figures. Most of the codes for producing the plots are written in IDL and/or Python; a very few are written in Mathematica. Any plot can be downloaded and customized to one's own needs.

[ascl:1805.024]
ASTROPOP: ASTROnomical Polarimetry and Photometry pipeline

AstroPoP reduces almost any CCD photometry and image polarimetry data. For photometry reduction, the code performs source finding, aperture and PSF photometry, astrometry calibration using different automated and non-automated methods and automated source identification and magnitude calibration based on online and local catalogs. For polarimetry, the code resolves linear and circular Stokes parameters produced by image beam splitter or polarizer polarimeters. In addition to the modular functions, ready-to-use pipelines based in configuration files and header keys are also provided with the code. AstroPOP was initially developed to reduce the IAGPOL polarimeter data installed at Observatório Pico dos Dias (Brazil).

[ascl:1304.002]
Astropy: Community Python library for astronomy

Greenfield, Perry; Robitaille, Thomas; Tollerud, Erik; Aldcroft, Tom; Barbary, Kyle; Barrett, Paul; Bray, Erik; Crighton, Neil; Conley, Alex; Conseil, Simon; Davis, Matt; Deil, Christoph; Dencheva, Nadia; Droettboom, Michael; Ferguson, Henry; Ginsburg, Adam; Grollier, Frédéric; Moritz Günther, Hans; Hanley, Chris; Hsu, J. C.; Kerzendorf, Wolfgang; Kramer, Roban; Lian Lim, Pey; Muna, Demitri; Nair, Prasanth; Price-Whelan, Adrian; Shiga, David; Singer, Leo; Taylor, James; Turner, James; Woillez, Julien; Zabalza, Victor

Astropy provides a common framework, core package of code, and affiliated packages for astronomy in Python. Development is actively ongoing, with major packages such as PyFITS, PyWCS, vo, and asciitable already merged in. Astropy is intended to contain much of the core functionality and some common tools needed for performing astronomy and astrophysics with Python.

[ascl:1207.007]
Astropysics: Astrophysics utilities for python

Astropysics is a library containing a variety of utilities and algorithms for reducing, analyzing, and visualizing astronomical data. Best of all, it encourages the user to leverage the existing capabilities of Python to make this quick, easy, and as painless as cutting-edge science can even actually be. There do exist other Python packages with some of the capabilities of this project, but the goal of this project is to integrate all these tools together and make them interact in the most straightforward ways possible.

[ascl:1708.004]
Astroquery: Access to online data resources

Ginsburg, Adam; Parikh, Madhura; Woillez, Julien; Groener, Austen; Liedtke, Simon; Sipocz, Brigitta; Robitaille, Thomas; Deil, Christoph; Svoboda, Brian; Tollerud, Erik; Persson, Magnus Vilhelm; Séguin-Charbonneau, Loïc; Armstrong, Caden; Mirocha, Jordan; Droettboom, Michael; Allen, James; Moolekamp, Fred; Egeland, Ricky; Singer, Leo; Barbary, Kyle; Grollier, Frédéric; Shiga, David; Moritz Günther, Hans; Parejko, John; Booker, Joseph; Rol, Evert; Edward; Miller, Adam; Willett, Kyle

Astroquery allows users to access online astronomical data from a wide range of sources; it is an Astropy-affiliated package. Each web service has its own sub-package for interfacing with a particular data source.

[ascl:1407.007]
ASTRORAY: General relativistic polarized radiative transfer code

ASTRORAY employs a method of ray tracing and performs polarized radiative transfer of (cyclo-)synchrotron radiation. The radiative transfer is conducted in curved space-time near rotating black holes described by Kerr-Schild metric. Three-dimensional general relativistic magneto hydrodynamic (3D GRMHD) simulations, in particular performed with variations of the HARM code, serve as an input to ASTRORAY. The code has been applied to reproduce the sub-mm synchrotron bump in the spectrum of Sgr A*, and to test the detectability of quasi-periodic oscillations in its light curve. ASTRORAY can be readily applied to model radio/sub-mm polarized spectra of jets and cores of other low-luminosity active galactic nuclei. For example, ASTRORAY is uniquely suitable to self-consistently model Faraday rotation measure and circular polarization fraction in jets.

[ascl:1010.023]
AstroSim: Collaborative Visualization of an Astrophysics Simulation in Second Life

AstroSim is a Second Life based prototype application for synchronous collaborative visualization targeted at astronomers.

[ascl:1507.019]
AstroStat: Statistical analysis tool

AstroStat performs statistical analysis on data and is compatible with Virtual Observatory (VO) standards. It accepts data in a variety of formats and performs various statistical tests using a menu driven interface. Analyses, performed in R, include exploratory tests, visualizations, distribution fitting, correlation and causation, hypothesis testing, multivariate analysis and clustering. AstroStat is available in two versions with an identical interface and features: as a web service that can be run using any standard browser and as an offline application.

[ascl:1307.007]
AstroTaverna: Tool for Scientific Workflows in Astronomy

AstroTaverna is a plugin for Taverna Workbench that provides the means to build astronomy workflows using Virtual Observatory services discovery and efficient manipulation of VOTables (based on STIL tool set). It integrates SAMP-enabled software, allowing data exchange and communication among local VO tools, as well as the ability to execute Aladin scripts and macros.

[ascl:2009.013]
AstroVaDEr: Unsupervised clustering and synthetic image generation

AstroVaDEr (Astronomical Variational Deep Embedder) performs unsupervised clustering and synthetic image generation using astronomical imaging catalogs to classify their morphologies. This variational autoencoder leverages improvements to the variational deep clustering (VDC) paradigm; its variational inference properties allow the network to be employed as a generative network. AstroVaDEr can be adapted to various surveys and image classification problems.

[ascl:1608.005]
AstroVis: Visualizing astronomical data cubes

AstroVis enables rapid visualization of large data files on platforms supporting the OpenGL rendering library. Radio astronomical observations are typically three dimensional and stored as data cubes. AstroVis implements a scalable approach to accessing these files using three components: a File Access Component (FAC) that reduces the impact of reading time, which speeds up access to the data; the Image Processing Component (IPC), which breaks up the data cube into smaller pieces that can be processed locally and gives a representation of the whole file; and Data Visualization, which implements an approach of Overview + Detail to reduces the dimensions of the data being worked with and the amount of memory required to store it. The result is a 3D display paired with a 2D detail display that contains a small subsection of the original file in full resolution without reducing the data in any way.

[ascl:1406.001]
ASURV: Astronomical SURVival Statistics

ASURV (Astronomical SURVival Statistics) provides astronomy survival analysis for right- and left-censored data including the maximum-likelihood Kaplan-Meier estimator and several univariate two-sample tests, bivariate correlation measures, and linear regressions. ASURV is written in FORTRAN 77, and is stand-alone and does not call any specialized libraries.

[ascl:1010.014]
Athena: Grid-based code for astrophysical magnetohydrodynamics (MHD)

Athena is a grid-based code for astrophysical magnetohydrodynamics (MHD). It was developed primarily for studies of the interstellar medium, star formation, and accretion flows. The code has been designed to be easily extensible for use with static and adaptive mesh refinement. It combines higher-order Godunov methods with the constrained transport (CT) technique to enforce the divergence-free constraint on the magnetic field. Discretization is based on cell-centered volume-averages for mass, momentum, and energy, and face-centered area-averages for the magnetic field. Novel features of the algorithm include (1) a consistent framework for computing the time- and edge-averaged electric fields used by CT to evolve the magnetic field from the time- and area-averaged Godunov fluxes, (2) the extension to MHD of spatial reconstruction schemes that involve a dimensionally-split time advance, and (3) the extension to MHD of two different dimensionally-unsplit integration methods. Implementation of the algorithm in both C and Fortran95 is detailed, including strategies for parallelization using domain decomposition. Results from a test suite which includes problems in one-, two-, and three-dimensions for both hydrodynamics and MHD are given, not only to demonstrate the fidelity of the algorithms, but also to enable comparisons to other methods. The source code is freely available for download on the web.

[ascl:1402.026]
athena: Tree code for second-order correlation functions

athena is a 2d-tree code that estimates second-order correlation functions from input galaxy catalogues. These include shear-shear correlations (cosmic shear), position-shear (galaxy-galaxy lensing) and position-position (spatial angular correlation). Written in C, it includes a power-spectrum estimator implemented in Python; this script also calculates the aperture-mass dispersion. A test data set is available.

[ascl:1912.005]
Athena++: Radiation GR magnetohydrodynamics code

Athena++ is a complete re-write of the Athena astrophysical magnetohydrodynamics (MHD) code (ascl:1010.014) in C++. Compared to earlier versions, the Athena++ code has much more flexible coordinate and grid options and supports new physics. It also offers significantly improved performance and scalability, and improved source code clarity and modularity. Athena++ supports compressible hydrodynamics and MHD in 1D, 2D, and 3D, and special and general relativistic hydrodynamics and MHD. In addition, it supports Cartesian, cylindrical, or spherical polar coordinates; static or adaptive mesh refinement in any coordinate system; mixed parallelization with both OpenMP and MPI; and a task-based execution model for improved load balancing, scalability and modularity.

[ascl:1505.006]
Athena3D: Flux-conservative Godunov-type algorithm for compressible magnetohydrodynamics

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.

[ascl:1911.006]
ATHOS: A Tool for HOmogenizing Stellar parameters

ATHOS provides on-the-fly stellar parameter determination of FGK stars based on flux ratios from optical spectra. Once configured properly, it will measure flux ratios in the input spectra and deduce the stellar parameters effective temperature, iron abundance (a.k.a [Fe/H]), and surface gravity by employing pre-defined analytical relations. ATHOS can be configured to run in parallel in an arbitrary number of threads, thus enabling the fast and efficient analysis of huge datasets.

[ascl:1110.015]
atlant: Advanced Three Level Approximation for Numerical Treatment of Cosmological Recombination

atlant is a public numerical code for fast calculations of cosmological recombination of primordial hydrogen-helium plasma is presented. This code is based on the three-level approximation (TLA) model of recombination and allows us to take into account some "fine'' physical effects of cosmological recombination simultaneously with using fudge factors.

[ascl:1911.013]
ATLAS: Turning Dopplergram images into frequency shift measurements

ATLAS performs the tracking, projecting, power-spectrum-making, and ring-fitting needed to turn a set of Dopplergram images into a set of frequency shift measurements. This code is essentially a combination of three codes, FRACK (FORTRAN Tracking), PSPEC (Power SPECtrum), and MRF (Multi-Ridge Fitting), included in the ATLAS package. ATLAS reads in a list of longitude/latitude coordinates corresponding to the desired tile centers and a set of full-disk Dopplergram images and outputs frequency shift measurements from each wave mode of each tile. The code relies on both distributed-memory (MPI) and shared-memory (OpenMP) parallelism to scale up to around 1000 processes. Due to the immense volume of data produced by the tracking and projecting steps, the intermediate data products (tiles, power spectra) are never written out.

[ascl:1303.024]
ATLAS12: Opacity sampling model atmosphere program

ATLAS12 is an opacity sampling model atmosphere program to allow computation of models with individual abundances using line data. ATLAS12 is able to compute the same models as ATLAS9 which uses pretabulated opacities, plus models with arbitrary abundances. ATLAS12 sampled fluxes are quite accurate for predicting the total flux except in the intermediate or narrow bandpass intervals because the sample size is too small.

[ascl:1607.003]
Atlas2bgeneral: Two-body resonance calculator

For a massless test particle and given a planetary system, Atlas2bgeneral calculates all resonances in a given range of semimajor axes with all the planets taken one by one. Planets are assumed in fixed circular and coplanar orbits and the test particle with arbitrary orbit. A sample input data file to calculate the two-body resonances is available for use with the Fortran77 source code.

[ascl:1607.004]
Atlas3bgeneral: Three-body resonance calculator

For a massless test particle and given a planetary system, atlas3bgeneral calculates all three body resonances in a given range of semimajor axes with all the planets taken by pairs. Planets are assumed in fixed circular and coplanar orbits and the test particle with arbitrary orbit. A sample input data file to calculate the three-body resonances is available for use with the Fortran77 source code.

[ascl:1710.017]
ATLAS9: Model atmosphere program with opacity distribution functions

ATLAS9 computes model atmospheres using a fixed set of pretabulated opacities, allowing one to work on huge numbers of stars and interpolate in large grids of models to determine parameters quickly. The code works with two different sets of opacity distribution functions (ODFs), one with “big” wavelength intervals covering the whole spectrum and the other with 1221 “little” wavelength intervals covering the whole spectrum. The ODFs use a 12-step representation; the radiation field is computed starting with the highest step and working down. If a lower step does not matter because the line opacity is small relative to the continuum at all depths, all the lower steps are lumped together and not computed to save time.

[ascl:1703.013]
Atmospheric Athena: 3D Atmospheric escape model with ionizing radiative transfer

Atmospheric Athena simulates hydrodynamic escape from close-in giant planets in 3D. It uses the Athena hydrodynamics code (ascl:1010.014) with a new ionizing radiative transfer implementation to self-consistently model photoionization driven winds from the planet. The code is fully compatible with static mesh refinement and MPI parallelization and can handle arbitrary planet potentials and stellar initial conditions.

[ascl:1708.001]
ATOOLS: A command line interface to the AST library

The ATOOLS package of applications provides an interface to the AST library (ascl:1404.016), allowing quick experiments to be performed from the shell. It manipulates descriptions of coordinate frames and mappings in the form of AST objects and performs other functions, with each application within the package corresponding closely to one of the functions in the AST library.

[ascl:1405.009]
ATV: Image display tool

Barth, Aaron J.; Schlegel, David; Finkbeiner, Doug; Colley, Wesley; Liu, Mike; Brauher, Jim; Cunningham, Nathaniel; Perrin, Marshall; Roe, Henry; Weaver, Hal

ATV displays and analyses astronomical images using the IDL image-processing language. It allows interactive control of the image scaling, color table, color stretch, and zoom, with support for world coordinate systems. It also does point-and-click aperture photometry, simple spectral extractions, and can produce publication-quality postscript output images.

[ascl:1909.001]
Auto-multithresh: Automated masking for clean

Auto-multithresh implements an automated masking algorithm for clean. It operates on the residual image within the minor cycle of clean to identify and mask regions of significant emission. It then cascades these significant regions down to lower signal to noise. It includes features to pad the mask to avoid sharp edges and to remove small regions that are unlikely to be significant emission. The algorithm described by this code was incorporated into the tclean task within CASA as auto-multithresh.

[ascl:1406.004]
Autoastrom: Autoastrometry for Mosaics

Autoastrom performs automated astrometric corrections on an astronomical image by automatically detecting objects in the frame, retrieving a reference catalogue, cross correlating the catalog with CCDPACK (ascl:1403.021) or MATCH, and using the ASTROM (ascl:1406.008) application to calculate a correction. It is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1904.007]
AutoBayes: Automatic design of customized analysis algorithms and programs

AutoBayes automatically generates customized algorithms from compact, declarative specifications in the data analysis domain, taking a statistical model as input and creating documented and optimized C/C++ code. The synthesis process uses Bayesian networks to enable problem decompositions and guide the algorithm derivation. Program schemas encapsulate advanced algorithms and data structures, and a symbolic-algebraic system finds closed-form solutions for problems and emerging subproblems. AutoBayes has been used to analyze planetary nebulae images taken by the Hubble Space Telescope, and can be applied to other scientific data analysis tasks.

[ascl:1602.001]
Automark: Automatic marking of marked Poisson process in astronomical high-dimensional datasets

Automark models photon counts collected form observation of variable-intensity astronomical sources. It aims to mark the abrupt changes in the corresponding wavelength distribution of the emission automatically. In the underlying methodology, change points are embedded into a marked Poisson process, where photon wavelengths are regarded as marks and both the Poisson intensity parameter and the distribution of the marks are allowed to change.

[ascl:1812.015]
AUTOSPEC: Automated Spectral Extraction Software for integral field unit data cubes

AUTOSPEC provides fast, automated extraction of high quality 1D spectra from astronomical datacubes with minimal user effort. AutoSpec takes an integral field unit (IFU) datacube and a simple parameter file in order to extract a 1D spectra for each object in a supplied catalogue. A custom designed cross-correlation algorithm improves signal to noise as well as isolates sources from neighboring contaminants.

[ascl:1612.014]
AUTOSTRUCTURE: General program for calculation of atomic and ionic properties

AUTOSTRUCTURE calculates atomic and ionic energy levels, radiative rates, autoionization rates, photoionization cross sections, plane-wave Born and distorted-wave excitation cross sections in LS- and intermediate-coupling using non- or (kappa-averaged) relativistic wavefunctions. These can then be further processed to form Auger yields, fluorescence yields, partial and total dielectronic and radiative recombination cross sections and rate coefficients, photoabsorption cross sections, and monochromatic opacities, among other properties.

[ascl:1109.016]
aXe: Spectral Extraction and Visualization Software

aXe is a spectroscopic data extraction software package that was designed to handle large format spectroscopic slitless images such as those from the Wide Field Camera 3 (WFC3) and the Advanced Camera for Surveys (ACS) on HST. aXe is a PyRAF/IRAF package that consists of several tasks and is distributed as part of the Space Telescope Data Analysis System (STSDAS). The various aXe tasks perform specific parts of the extraction and calibration process and are successively used to produce extracted spectra.

[ascl:2006.009]
AxionNS: Ray-tracing in neutron stars

AxionNS computes radio light curves resulting from the resonant conversion of Axion dark matter into photons within the magnetosphere of a neutron star. Photon trajectories are traced from the observer to the magnetosphere where a root finding algorithm identifies the regions of resonant conversion. Given the modeling of the axion dark matter distribution and conversion probability, one can compute the photon flux emitted from these regions. The individual contributions from all the trajectories is then summed to obtain the radiated photon power per unit solid angle.

[ascl:1605.004]
BACCHUS: Brussels Automatic Code for Characterizing High accUracy Spectra

BACCHUS (Brussels Automatic Code for Characterizing High accUracy Spectra) derives stellar parameters (T_{eff}, log *g*, metallicity, microturbulence velocity and rotational velocity), equivalent widths, and abundances. The code includes on the fly spectrum synthesis, local continuum normalization, estimation of local S/N, automatic line masking, four methods for abundance determinations, and a flagging system aiding line selection. BACCHUS relies on the grid of MARCS model atmospheres, Masseron's model atmosphere thermodynamic structure interpolator, and the radiative transfer code Turbospectrum (ascl:1205.004).

[ascl:1708.010]
BAGEMASS: Bayesian age and mass estimates for transiting planet host stars

BAGEMASS calculates the posterior probability distribution for the mass and age of a star from its observed mean density and other observable quantities using a grid of stellar models that densely samples the relevant parameter space. It is written in Fortran and requires FITSIO (ascl:1010.001).

[ascl:1312.008]
BAMBI: Blind Accelerated Multimodal Bayesian Inference

BAMBI (Blind Accelerated Multimodal Bayesian Inference) is a Bayesian inference engine that combines the benefits of SkyNet (ascl:1312.007) with MultiNest (ascl:1109.006). It operated by simultaneously performing Bayesian inference using MultiNest and learning the likelihood function using SkyNet. Once SkyNet has learnt the likelihood to sufficient accuracy, inference finishes almost instantaneously.

[ascl:1408.020]
bamr: Bayesian analysis of mass and radius observations

bamr is an MPI implementation of a Bayesian analysis of neutron star mass and radius data that determines the mass versus radius curve and the equation of state of dense matter. Written in C++, bamr provides some EOS models. This code requires O_{2}scl (ascl:1408.019) be installed before compilation.

[ascl:1905.014]
Bandmerge: Merge data from different wavebands

Bandmerge takes in ASCII tables of positions and fluxes of detected astronomical sources in 2-7 different wavebands, and write out a single table of the merged data. The tool was designed to work with source lists generated by the Spitzer Science Center's MOPEX (ascl:1111.006) software, although it can be "fooled" into running on other data as well.

[ascl:1801.001]
BANYAN_Sigma: Bayesian classifier for members of young stellar associations

Gagné, Jonathan; Mamajek, Eric E.; Malo, Lison; Riedel, Adric; Rodriguez, David; Lafrenière, David; Faherty, Jacqueline K.; Roy-Loubier, Olivier; Pueyo, Laurent; Robin, Annie C.; Doyon, René

BANYAN_Sigma calculates the membership probability that a given astrophysical object belongs to one of the currently known 27 young associations within 150 pc of the Sun, using Bayesian inference. This tool uses the sky position and proper motion measurements of an object, with optional radial velocity (RV) and distance (D) measurements, to derive a Bayesian membership probability. By default, the priors are adjusted such that a probability threshold of 90% will recover 50%, 68%, 82% or 90% of true association members depending on what observables are input (only sky position and proper motion, with RV, with D, with both RV and D, respectively). The algorithm is implemented in a Python package, in IDL, and is also implemented as an interactive web page.

[ascl:1402.025]
BAOlab: Baryon Acoustic Oscillations software

Using the 2-point correlation function, BAOlab aids the study of Baryon Acoustic Oscillations (BAO). The code generates a model-dependent covariance matrix which can change the results both for BAO detection and for parameter constraints.

[ascl:1403.013]
BAOlab: Image processing program

BAOlab is an image processing package written in C that should run on nearly any UNIX system with just the standard C libraries. It reads and writes images in standard FITS format; 16- and 32-bit integer as well as 32-bit floating-point formats are supported. Multi-extension FITS files are currently not supported. Among its tools are ishape for size measurements of compact sources, mksynth for generating synthetic images consisting of a background signal including Poisson noise and a number of pointlike sources, imconvol for convolving two images (a “source” and a “kernel”) with each other using fast fourier transforms (FFTs) and storing the output as a new image, and kfit2d for fitting a two-dimensional King model to an image.

[ascl:1810.002]
Barcode: Bayesian reconstruction of cosmic density fields

Barcode (BAyesian Reconstruction of COsmic DEnsity fields) samples the primordial density fields compatible with a set of dark matter density tracers after cosmic evolution observed in redshift space. It uses a redshift space model based on the analytic solution of coherent flows within a Hamiltonian Monte Carlo posterior sampling of the primordial density field; this method is applicable to analytically derivable structure formation models, such as the Zel'dovich approximation, but also higher order schemes such as augmented Lagrangian perturbation theory or even particle mesh models. The algorithm is well-suited for analysis of the dark matter cosmic web implied by the observed spatial distribution of galaxy clusters, such as obtained from X-ray, SZ or weak lensing surveys, as well as that of the intergalactic medium sampled by the Lyman alpha forest. In these cases, virialized motions are negligible and the tracers cannot be modeled as point-like objects. Barcode can be used in all of these contexts as a baryon acoustic oscillation reconstruction algorithm.

[ascl:2008.008]
Barry: Modular BAO fitting code

Barry compares different BAO models. It removes as many barriers and complications to BAO model fitting as possible and allows each component of the process to remain independent, allowing for detailed comparisons of individual parts. It contains datasets, model fitting tools, and model implementations incorporating different descriptions of non-linear physics and algorithms for isolating the BAO (Baryon Acoustic Oscillation) feature.

[ascl:1608.004]
BART: Bayesian Atmospheric Radiative Transfer fitting code

Cubillos, Patricio; Blecic, Jasmina; Harrington, Joseph; Rojo, Patricio; Lust, Nate; Bowman, Oliver; Stemm, Madison; Foster, Andrew; Loredo, Thomas J.; Fortney, Jonathan; Madhusudhan, Nikku

BART implements a Bayesian, Monte Carlo-driven, radiative-transfer scheme for extracting parameters from spectra of planetary atmospheres. BART combines a thermochemical-equilibrium code, a one-dimensional line-by-line radiative-transfer code, and the Multi-core Markov-chain Monte Carlo statistical module to constrain the atmospheric temperature and chemical-abundance profiles of exoplanets.

[ascl:1807.018]
BARYCORR: Python interface for barycentric RV correction

BARYCORR is a Python interface for ZBARYCORR (ascl:1807.017); it requires the measured redshift and returns the corrected barycentric velocity and time correction.

[ascl:1808.001]
Barycorrpy: Barycentric velocity calculation and leap second management

barycorrpy (BCPy) is a Python implementation of Wright and Eastman's 2014 code (ascl:1807.017) that calculates precise barycentric corrections well below the 1 cm/s level. This level of precision is required in the search for 1 Earth mass planets in the Habitable Zones of Sun-like stars by the Radial Velocity (RV) method, where the maximum semi-amplitude is about 9 cm/s. BCPy was developed for the pipeline for the next generation Doppler Spectrometers - Habitable-zone Planet Finder (HPF) and NEID. An automated leap second management routine improves upon the one available in Astropy. It checks for and downloads a new leap second file before converting from the UT time scale to TDB. The code also includes a converter for JDUTC to BJDTDB.

[ascl:1601.017]
BASCS: Bayesian Separation of Close Sources

BASCS models spatial and spectral information from overlapping sources and the background, and jointly estimates all individual source parameters. The use of spectral information improves the detection of both faint and closely overlapping sources and increases the accuracy with which source parameters are inferred.

[ascl:1608.007]
BASE-9: Bayesian Analysis for Stellar Evolution with nine variables

Robinson, Elliot; von Hippel, Ted; Stein, Nathan; Stenning, David; Wagner-Kaiser, Rachel; Si, Shijing; van Dyk, David

The BASE-9 (Bayesian Analysis for Stellar Evolution with nine variables) software suite recovers star cluster and stellar parameters from photometry and is useful for analyzing single-age, single-metallicity star clusters, binaries, or single stars, and for simulating such systems. BASE-9 uses a Markov chain Monte Carlo (MCMC) technique along with brute force numerical integration to estimate the posterior probability distribution for the age, metallicity, helium abundance, distance modulus, line-of-sight absorption, and parameters of the initial-final mass relation (IFMR) for a cluster, and for the primary mass, secondary mass (if a binary), and cluster probability for every potential cluster member. The MCMC technique is used for the cluster quantities (the first six items listed above) and numerical integration is used for the stellar quantities (the last three items in the above list).

[ascl:1208.010]
BASE: Bayesian Astrometric and Spectroscopic Exoplanet Detection and Characterization Tool

BASE is a novel program for the combined or separate Bayesian analysis of astrometric and radial-velocity measurements of potential exoplanet hosts and binary stars. The tool fulfills two major tasks of exoplanet science, namely the detection of exoplanets and the characterization of their orbits. BASE was developed to provide the possibility of an integrated Bayesian analysis of stellar astrometric and Doppler-spectroscopic measurements with respect to their binary or planetary companions’ signals, correctly treating the astrometric measurement uncertainties and allowing to explore the whole parameter space without the need for informative prior constraints. The tool automatically diagnoses convergence of its Markov chain Monte Carlo (MCMC[2]) sampler to the posterior and regularly outputs status information. For orbit characterization, BASE delivers important results such as the probability densities and correlations of model parameters and derived quantities. BASE is a highly configurable command-line tool developed in Fortran 2008 and compiled with GFortran. Options can be used to control the program’s behaviour and supply information such as the stellar mass or prior information. Any option can be supplied in a configuration file and/or on the command line.

[ascl:1308.006]
BASIN: Beowulf Analysis Symbolic INterface

BASIN (Beowulf Analysis Symbolic INterface) is a flexible, integrated suite of tools for multiuser parallel data analysis and visualization that allows researchers to harness the power of Beowulf PC clusters and multi-processor machines without necessarily being experts in parallel programming. It also includes general tools for data distribution and parallel operations on distributed data for developing libraries for specific tasks.

[ascl:1510.002]
batman: BAsic Transit Model cAlculatioN in Python

batman provides fast calculation of exoplanet transit light curves and supports calculation of light curves for any radially symmetric stellar limb darkening law. It uses an integration algorithm for models that cannot be quickly calculated analytically, and in typical use, the batman Python package can calculate a million model light curves in well under ten minutes for any limb darkening profile.

[ascl:1612.021]
BaTMAn: Bayesian Technique for Multi-image Analysis

Casado, J.; Ascasibar, Y.; García-Benito, R.; Guidi, G.; Choudhury, O. S.; Bellocchi, E.; Sánchez, S. F.; Díaz, A. I.

Bayesian Technique for Multi-image Analysis (BaTMAn) characterizes any astronomical dataset containing spatial information and performs a tessellation based on the measurements and errors provided as input. The algorithm iteratively merges spatial elements as long as they are statistically consistent with carrying the same information (i.e. identical signal within the errors). The output segmentations successfully adapt to the underlying spatial structure, regardless of its morphology and/or the statistical properties of the noise. BaTMAn identifies (and keeps) all the statistically-significant information contained in the input multi-image (e.g. an IFS datacube). The main aim of the algorithm is to characterize spatially-resolved data prior to their analysis.

[submitted]
BAYES-LOSVD: a bayesian framework for non-parametric extraction of the LOSVD

BAYES-LOSVD is a python framework for the non-parametric extraction of the Line-Of-Sight Velocity Distributions in galaxies. It makes use of Stan (https://mc-stan.org/) to perform all the computations and provide reliable uncertainties for all the parameters of the model chosen for the fit. The code comes with a large number of features, including read-in routines for some of the most popular IFU spectrographs and surveys: ATLAS3D, CALIFA, MaNGA, MUSE-WFM, SAMI, SAURON.

[ascl:1505.027]
BAYES-X: Bayesian inference tool for the analysis of X-ray observations of galaxy clusters

The great majority of X-ray measurements of cluster masses in the literature assume parametrized functional forms for the radial distribution of two independent cluster thermodynamic properties, such as electron density and temperature, to model the X-ray surface brightness. These radial profiles (e.g. β-model) have an amplitude normalization parameter and two or more shape parameters. BAYES-X uses a cluster model to parametrize the radial X-ray surface brightness profile and explore the constraints on both model parameters and physical parameters. Bayes-X is programmed in Fortran and uses MultiNest (ascl:1109.006) as the Bayesian inference engine.

[ascl:2002.018]
Bayesfit: Command-line program for combining Tempo2 and MultiNest components

Bayesfit pulls together Tempo2 (ascl:1210.015) and MultiNest (ascl:1109.006) components to provide additional functionality such as the specification of priors; Nelder–Mead optimization of the maximum-posterior point; and the capability of computing the partially marginalized likelihood for a given subset of timing-model parameters. Bayesfit is a single python command-line application.

[ascl:1407.015]
BayesFlare: Bayesian method for detecting stellar flares

BayesFlare identifies flaring events in light curves released by the Kepler mission; it identifies even weak events by making use of the flare signal shape. The package contains functions to perform Bayesian hypothesis testing comparing the probability of light curves containing flares to that of them containing noise (or non-flare-like) artifacts. BayesFlare includes functions in its amplitude-marginalizer suite to account for underlying sinusoidal variations in light curve data; it includes such variations in the signal model, and then analytically marginalizes over them.

[ascl:1209.001]
Bayesian Blocks: Detecting and characterizing local variability in time series

Bayesian Blocks is a time-domain algorithm for detecting localized structures (bursts), revealing pulse shapes within bursts, and generally characterizing intensity variations. The input is raw time series data, in almost any form. Three data modes are elaborated: (1) time-tagged events, (2) binned counts, and (3) measurements at arbitrary times with normal errors. The output is the most probable segmentation of the observation interval into sub-intervals during which the signal is perceptibly constant, i.e. has no statistically significant variations. The idea is not that the source is deemed to actually have this discontinuous, piecewise constant form, rather that such an approximate and generic model is often useful. Treatment of data gaps, variable exposure, extension to piecewise linear and piecewise exponential representations, multi-variate time series data, analysis of variance, data on the circle, other data modes, and dispersed data are included.

This implementation is exact and replaces the greedy, approximate, and outdated algorithm implemented in BLOCK.

[ascl:1711.004]
BayesVP: Full Bayesian Voigt profile fitting

BayesVP offers a Bayesian approach for modeling Voigt profiles in absorption spectroscopy. The code fits the absorption line profiles within specified wavelength ranges and generates posterior distributions for the column density, Doppler parameter, and redshifts of the corresponding absorbers. The code uses publicly available efficient parallel sampling packages to sample posterior and thus can be run on parallel platforms. BayesVP supports simultaneous fitting for multiple absorption components in high-dimensional parameter space. The package includes additional utilities such as explicit specification of priors of model parameters, continuum model, Bayesian model comparison criteria, and posterior sampling convergence check.

[ascl:1805.022]
BCcodes: Bolometric Corrections and Synthetic Stellar Photometry

BCcodes computes bolometric corrections and synthetic colors in up to 5 filters for input values of the stellar parameters Teff, log(g), [Fe/H], E(B-V) and [alpha/Fe].

[ascl:1907.011]
beamconv: Cosmic microwave background detector data simulator

beamconv simulates the scanning of the CMB sky while incorporating realistic beams and scan strategies. It uses (spin-)spherical harmonic representations of the (polarized) beam response and sky to generate simulated CMB detector signal timelines. Beams can be arbitrarily shaped. Pointing timelines can be read in or calculated on the fly; optionally, the results can be binned on the sphere.

[ascl:1905.006]
beamModelTester: Model evaluation for fixed antenna phased array radio telescopes

beamModelTester enables evaluation of models of the variation in sensitivity and apparent polarization of fixed antenna phased array radio telescopes. The sensitivity of such instruments varies with respect to the orientation of the source to the antenna, resulting in variation in sensitivity over altitude and azimuth that is not consistent with respect to frequency due to other geometric effects. In addition, the different relative orientation of orthogonal pairs of linear antennae produces a difference in sensitivity between the antennae, leading to an artificial apparent polarization. Comparing the model with observations made using the given telescope makes it possible evaluate the model's performance; the results of this evaluation can provide a figure of merit for the model and guide improvements to it. This system also enables plotting of results from a single station observation on a variety of parameters.

[ascl:1104.013]
BEARCLAW: Boundary Embedded Adaptive Refinement Conservation LAW package

The BEARCLAW package is a multidimensional, Eulerian AMR-capable computational code written in Fortran to solve hyperbolic systems for astrophysical applications. It is part of AstroBEAR, a hydrodynamic & magnetohydrodynamic code environment designed for a variety of astrophysical applications which allows simulations in 2, 2.5 (i.e., cylindrical), and 3 dimensions, in either cartesian or curvilinear coordinates.

[ascl:1908.013]
BEAST: Bayesian Extinction And Stellar Tool

Gordon, Karl D.; Fouesneau, Morgan; Arab, Heddy; Tchernyshyov, Kirill; Weisz, Daniel R.; Dalcanton, Julianne J.; Williams, Benjamin F.; Bell, Eric F.; Bianchi, Luciana; Boyer, Martha; Choi, Yumi; Dolphin, Andrew; Girardi, Léo; Hogg, David W.; Kalirai, Jason S.; Kapala, Maria; Lewis, Alexia R.; Rix, Hans-Walter; Sandstrom, Karin; Skillman, Evan D.

BEAST (Bayesian Extinction and Stellar Tool) fits the ultraviolet to near-infrared photometric SEDs of stars to extract stellar and dust extinction parameters. The stellar parameters are age (t), mass (M), metallicity (M), and distance (d). The dust extinction parameters are dust column (Av), average grain size (Rv), and mixing between type A and B extinction curves (fA).

[ascl:1306.006]
BEHR: Bayesian Estimation of Hardness Ratios

BEHR is a standalone command-line C program designed to quickly estimate the hardness ratios and their uncertainties for astrophysical sources. It is especially useful in the Poisson regime of low counts, and computes the proper uncertainty regardless of whether the source is detected in both passbands or not.

[submitted]
BELLAMY: A cross-matching package for the cynical astronomer

BELLAMY is a cross-matching algorithm designed primarily for radio images, that aims to match all sources in the supplied target catalogue to sources in a reference catalogue by calculating the probability of a match. BELLAMY utilises not only the position of a source on the sky, but also the flux data to calculate this probability, determining the most probable match in the reference catalog to the target source. Additionally, BELLAMY attempts to undo any spatial distortion that may be affecting the target catalogue, by creating a model of the offsets of matched sources which is then applied to unmatched sources. This combines to produce an iterative cross-matching algorithm that provides the user with an obvious measure of how confident they should be with the results of a cross-match.

[ascl:1306.013]
Bessel: Fast Bessel Function Jn(z) Routine for Large n,z

Bessel, written in the C programming language, uses an accurate scheme for evaluating Bessel functions of high order. It has been extensively tested against a number of other routines, demonstrating its accuracy and efficiency.

[ascl:1901.009]
bettermoments: Line-of-sight velocity calculation

bettermoments measures precise line-of-sight velocities from Doppler shifted lines to determine small scale deviations indicative of, for example, embedded planets.

[ascl:1402.015]
BF_dist: Busy Function fitting

Westmeier, Tobias; Jurek, Russell; Obreschkow, Danail; Koribalski, Bärbel S.; Staveley-Smith, Lister

The "busy function" accurately describes the characteristic double-horn HI profile of many galaxies. Implemented in a C/C++ library and Python module called BF_dist, it is a continuous, differentiable function that consists of only two basic functions, the error function, erf(x), and a polynomial, |x|^n, of degree n >= 2. BF_dist offers great flexibility in fitting a wide range of HI profiles from the Gaussian profiles of dwarf galaxies to the broad, asymmetric double-horn profiles of spiral galaxies, and can be used to parametrize observed HI spectra of galaxies and the construction of spectral templates for simulations and matched filtering algorithms accurately and efficiently.

[ascl:1504.020]
BGLS: A Bayesian formalism for the generalised Lomb-Scargle periodogram

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.

[ascl:1806.002]
BHDD: Primordial black hole binaries code

BHDD (BlackHolesDarkDress) simulates primordial black hole (PBH) binaries that are clothed in dark matter (DM) halos. The software uses N-body simulations and analytical estimates to follow the evolution of PBH binaries formed in the early Universe.

[ascl:1206.005]
bhint: High-precision integrator for stellar systems

bhint is a post-Newtonian, high-precision integrator for stellar systems surrounding a super-massive black hole. The algorithm makes use of the fact that the Keplerian orbits in such a potential can be calculated directly and are only weakly perturbed. For a given average number of steps per orbit, bhint is almost a factor of 100 more accurate than the standard Hermite method.

[ascl:1802.013]
BHMcalc: Binary Habitability Mechanism Calculator

BHMcalc provides renditions of the instantaneous circumbinary habital zone (CHZ) and also calculates BHM properties of the system including those related to the rotational evolution of the stellar components and the combined XUV and SW fluxes as measured at different distances from the binary. Moreover, it provides numerical results that can be further manipulated and used to calculate other properties.

[ascl:9910.006]
BHSKY: Visual distortions near a black hole

BHSKY (copyright 1999 by Robert J. Nemiroff) computes the visual distortion effects visible to an observer traveling around and descending near a non-rotating black hole. The codes are general relativistically accurate and incorporate concepts such as large-angle deflections, image magnifications, multiple imaging, blue-shifting, and the location of the photon sphere. Once star.dat is edited to define the position and orientation of the observer relative to the black hole, bhsky_table should be run to create a table of photon deflection angles. Next bhsky_image reads this table and recomputes the perceived positions of stars in star.num, the Yale Bright Star Catalog. Lastly, bhsky_camera plots these results. The code currently tracks only the two brightest images of each star, and hence becomes noticeably incomplete within 1.1 times the Schwarzschild radius.

[ascl:1501.009]
BIANCHI: Bianchi VIIh Simulations

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.

[ascl:1908.021]
bias_emulator: Halo bias emulator

bias_emulator models the clustering of halos on large scales. It incorporates the cosmological dependence of the bias beyond the mapping of halo mass to peak height. Precise measurements of the halo bias in the simulations are interpolated across cosmological parameter space to obtain the halo bias at any point in parameter space within the simulation cloud. A tool to produce realizations of correlated noise for propagating the modeling uncertainty into error budgets that use the emulator is also provided.

[ascl:1312.004]
BIE: Bayesian Inference Engine

The Bayesian Inference Engine (BIE) is an object-oriented library of tools written in C++ designed explicitly to enable Bayesian update and model comparison for astronomical problems. To facilitate "what if" exploration, BIE provides a command line interface (written with Bison and Flex) to run input scripts. The output of the code is a simulation of the Bayesian posterior distribution from which summary statistics e.g. by taking moments, or determine confidence intervals and so forth, can be determined. All of these quantities are fundamentally integrals and the Markov Chain approach produces variates $ heta$ distributed according to $P( heta|D)$ so moments are trivially obtained by summing of the ensemble of variates.

[ascl:1711.021]
Bifrost: Stream processing framework for high-throughput applications

Bifrost is a stream processing framework that eases the development of high-throughput processing CPU/GPU pipelines. It is designed for digital signal processing (DSP) applications within radio astronomy. Bifrost uses a flexible ring buffer implementation that allows different signal processing blocks to be connected to form a pipeline. Each block may be assigned to a CPU core, and the ring buffers are used to transport data to and from blocks. Processing blocks may be run on either the CPU or GPU, and the ring buffer will take care of memory copies between the CPU and GPU spaces.

[ascl:1208.007]
Big MACS: Accurate photometric calibration

Kelly, P. L.; von der Linden, A.; Applegate, D.; Allen, M.; Allen, S. W.; Burchat, P. R.; Burke, D. L.; Ebeling, H.; Capak, P.; Czoske, O.; Donovan, D.; Mantz, A.; Morris, R. G.

Big MACS is a Python program that estimates an accurate photometric calibration from only an input catalog of stellar magnitudes and filter transmission functions. The user does not have to measure color terms which can be difficult to characterize. Supplied with filter transmission functions, Big MACS synthesizes an expected stellar locus for your data and then simultaneously solves for all unknown zeropoints when fitting to the instrumental locus. The code uses a spectroscopic model for the SDSS stellar locus in color-color space and filter functions to compute expected locus. The stellar locus model is corrected for Milky Way reddening. If SDSS or 2MASS photometry is available for stars in field, Big MACS can yield a highly accurate absolute calibration.

[ascl:1901.011]
Bilby: Bayesian inference library

Ashton, Gregory; Hübner, Moritz; Lasky, Paul D.; Talbot, Colm; Ackley, Kendall; Biscoveanu, Sylvia; Chu, Qi; Divarkala, Atul; Easter, Paul J.; Goncharov, Boris; Hernandez Vivanco, Francisco; Harms, Jan; Lower, Marcus E.; Meadors, Grant D.; Melchor, Denyz; Payne, Ethan; Pitkin, Matthew D.; Powell, Jade,; Sarin, Nikhil; Smith, Rory J. E.; Thrane, Eric

Bilby provides a user-friendly interface to perform parameter estimation. It is primarily designed and built for inference of compact binary coalescence events in interferometric data, such as analysis of compact binary mergers and other types of signal model including supernovae and the remnants of binary neutron star mergers, but it can also be used for more general problems. The software is flexible, allowing the user to change the signal model, implement new likelihood functions, and add new detectors. Bilby can also be used to do population studies using hierarchical Bayesian modelling.

[ascl:2009.025]
Binary-Speckle: Binary or triple star parameters

Binary-Speckle reduces Speckle or AO data from the raw data to deconvolved images (in Fourier space), to determine the parameters of a binary or triple, and to find limits for undetected companion stars.

[ascl:1710.008]
Binary: Accretion disk evolution

Binary computes the evolution of an accretion disc interacting with a binary system. It has been developed and used to study the coupled evolution of supermassive BH binaries and gaseous accretion discs.

[ascl:1811.003]
binaryBHexp: On-the-fly visualizations of precessing binary black holes

binaryBHexp (binary black hole explorer) uses surrogate models of numerical simulations to generate on-the-fly interactive visualizations of precessing binary black holes. These visualizations can be generated in a few seconds and at any point in the 7-dimensional parameter space of the underlying surrogate models. These visualizations provide a valuable means to understand and gain insights about binary black hole systems and gravitational physics such as those detected by the LIGO gravitational wave detector.

[ascl:2012.004]
BinaryStarSolver: Orbital elements of binary stars solver

Given a series of radial velocities as a function of time for a star in a binary system, BinaryStarSolver solves for various orbital parameters. Namely, it solves for eccentricity (e), argument of periastron (ω), velocity amplitude (K), long term average radial velocity (γ), and orbital period (P). If the orbital parameters of a primary star are already known, it can also find the orbital parameters of a companion star, with only a few radial velocity data points.

[ascl:1312.012]
BINGO: BI-spectra and Non-Gaussianity Operator

The BI-spectra and Non-Gaussianity Operator (BINGO) code, written in Fortran, computes the scalar bi-spectrum and the non-Gaussianity parameter fNL in single field inflationary models involving the canonical scalar field. BINGO can calculate all the different contributions to the bi-spectrum and the parameter fNL for an arbitrary triangular configuration of the wavevectors.

[ascl:1805.015]
BinMag: Widget for comparing stellar observed with theoretical spectra

BinMag examines theoretical stellar spectra computed with Synth/SynthMag/Synmast/Synth3/SME spectrum synthesis codes and compare them to observations. An IDL widget program, BinMag applies radial velocity shift and broadening to the theoretical spectra to account for the effects of stellar rotation, radial-tangential macroturbulence, and instrumental smearing. The code can also simulate spectra of spectroscopic binary stars by appropriate coaddition of two synthetic spectra. Additionally, BinMag can be used to measure equivalent width, fit line profile shapes with analytical functions, and to automatically determine radial velocity and broadening parameters. BinMag interfaces with the Synth3 (ascl:1212.010) and SME (ascl:1202.013) codes, allowing the user to determine chemical abundances and stellar atmospheric parameters from the observed spectra.

[ascl:1905.004]
Binospec: Data reduction pipeline for the Binospec imaging spectrograph

Kansky, Jan; Chilingarian, Igor; Fabricant, Daniel; Matthews, Anne; Moran, Sean; Paegert, Martin; Duane Gibson, J.; Porter, Dallan; Roll, John

Binospec reduces data for the Binospec imaging spectrograph. The software is also used for observation planning and instrument control, and is automated to decrease the number of tasks the user has to perform. Binospec uses a database-driven approach for instrument configuration and sequencing of observations to maximize efficiency, and a web-based interface is available for defining observations, monitoring status, and retrieving data products.

[ascl:1011.008]
Binsim: Visualising Interacting Binaries in 3D

Binsim produces images of interacting binaries for any system parameters. Though not suitable for modeling light curves or spectra, the resulting images are helpful in visualizing the geometry of a given system and are also helpful in talks and educational work. The code uses the OpenGL API to do the 3D rendering. The software can produce images of cataclysmic variables and X-ray binaries, and can render the mass donor star, an axisymmetric disc (without superhumps, warps or spirals), the accretion stream and hotspot, and a "corona."

[ascl:1208.002]
BINSYN: Simulating Spectra and Light Curves of Binary Systems with or without Accretion Disks

The BINSYN program suite is a collection of programs for analysis of binary star systems with or without an optically thick accretion disk. BINSYN produces synthetic spectra of individual binary star components plus a synthetic spectrum of the system. If the system includes an accretion disk, BINSYN also produces a separate synthetic spectrum of the disk face and rim. A system routine convolves the synthetic spectra with filter profiles of several photometric standards to produce absolute synthetic photometry output. The package generates synthetic light curves and determines an optimized solution for system parameters.

[ascl:1512.008]
Bisous model: Detecting filamentary pattern in point processes

The Bisous model is a marked point process that models multi-dimensional patterns. The Bisous filament finder works directly with galaxy distribution data and the model intrinsically takes into account the connectivity of the filamentary network. The Bisous model generates the visit map (the probability to find a filament at a given point) together with the filament orientation field; these two fields are used to extract filament spines from the data.

[ascl:1712.004]
Bitshuffle: Filter for improving compression of typed binary data

Bitshuffle rearranges typed, binary data for improving compression; the algorithm is implemented in a python/C package within the Numpy framework. The library can be used alongside HDF5 to compress and decompress datasets and is integrated through the dynamically loaded filters framework. Algorithmically, Bitshuffle is closely related to HDF5's Shuffle filter except it operates at the bit level instead of the byte level. Arranging a typed data array in to a matrix with the elements as the rows and the bits within the elements as the columns, Bitshuffle "transposes" the matrix, such that all the least-significant-bits are in a row, etc. This transposition is performed within blocks of data roughly 8kB long; this does not in itself compress data, but rearranges it for more efficient compression. A compression library is necessary to perform the actual compression. This scheme has been used for compression of radio data in high performance computing.

[ascl:1411.027]
BKGE: Fermi-LAT Background Estimator

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.

[ascl:2012.020]
BlackHawk: Black hole evaporation calculator

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

[ascl:1906.002]
Blimpy: Breakthrough Listen I/O Methods for Python

Blimpy (Breakthrough Listen I/O Methods for Python) provides utilities for viewing and interacting with the data formats used within the Breakthrough Listen program, including Sigproc filterbank (.fil) and HDF5 (.h5) files that contain dynamic spectra (aka 'waterfalls'), and guppi raw (.raw) files that contain voltage-level data. Blimpy can also extract, calibrate, and visualize data and a suite of command-line utilities are also available.

[ascl:1208.009]
BLOBCAT: Software to Catalog Blobs

BLOBCAT is a source extraction software that utilizes the flood fill algorithm to detect and catalog blobs, or islands of pixels representing sources, in 2D astronomical images. The software is designed to process radio-wavelength images of both Stokes I intensity and linear polarization, the latter formed through the quadrature sum of Stokes Q and U intensities or as a by-product of rotation measure synthesis. BLOBCAT corrects for two systematic biases to enable the flood fill algorithm to accurately measure flux densities for Gaussian sources. BLOBCAT exhibits accurate measurement performance in total intensity and, in particular, linear polarization, and is particularly suited to the analysis of large survey data.

[ascl:9909.005]
BLOCK: A Bayesian block method to analyze structure in photon counting data

Bayesian Blocks is a time-domain algorithm for detecting localized structures (bursts), revealing pulse shapes, and generally characterizing intensity variations. The input is raw counting data, in any of three forms: time-tagged photon events, binned counts, or time-to-spill data. The output is the most probable segmentation of the observation into time intervals during which the photon arrival rate is perceptibly constant, i.e. has no statistically significant variations. The idea is not that the source is deemed to have this discontinuous, piecewise constant form, rather that such an approximate and generic model is often useful. The analysis is based on Bayesian statistics.

This code is obsolete and yields approximate results; see Bayesian Blocks instead for an algorithm guaranteeing exact global optimization.

[ascl:1607.008]
BLS: Box-fitting Least Squares

BLS (Box-fitting Least Squares) is a box-fitting algorithm that analyzes stellar photometric time series to search for periodic transits of extrasolar planets. It searches for signals characterized by a periodic alternation between two discrete levels, with much less time spent at the lower level.

[ascl:1709.009]
bmcmc: MCMC package for Bayesian data analysis

bmcmc is a general purpose Markov Chain Monte Carlo package for Bayesian data analysis. It uses an adaptive scheme for automatic tuning of proposal distributions. It can also handle Bayesian hierarchical models by making use of the Metropolis-Within-Gibbs scheme.

[ascl:1801.008]
BOND: Bayesian Oxygen and Nitrogen abundance Determinations

BOND determines oxygen and nitrogen abundances in giant H II regions by comparison with a large grid of photoionization models. The grid spans a wide range in O/H, N/O and ionization parameter U, and covers different starburst ages and nebular geometries. Unlike other statistical methods, BOND relies on the [Ar III]/[Ne III] emission line ratio to break the oxygen abundance bimodality. By doing so, it can measure oxygen and nitrogen abundances without assuming any a priori relation between N/O and O/H. BOND takes into account changes in the hardness of the ionizing radiation field, which can come about due to the ageing of H II regions or the stochastically sampling of the IMF. The emission line ratio He I/Hβ, in addition to commonly used strong lines, constrains the hardness of the ionizing radiation field. BOND relies on the emission line ratios [O III]/Hβ, [O II]/Hβ and [N II]/Hβ, [Ar III]/Hβ, [Ne III]/Hβ, He I/Hβ as its input parameters, while its output values are the measurements and uncertainties for O/H and N/O.

[ascl:1212.001]
Bonsai: N-body GPU tree-code

Bonsai is a gravitational N-body tree-code that runs completely on the GPU. This reduces the amount of time spent on communication with the CPU. The code runs on NVIDIA GPUs and on a GTX480 it is able to integrate ~2.8M particles per second. The tree construction and traverse algorithms are portable to many-core devices which have support for CUDA or OpenCL programming languages.

[ascl:1210.030]
BOOTTRAN: Error Bars for Keplerian Orbital Parameters

BOOTTRAN calculates error bars for Keplerian orbital parameters for both single- and multiple-planet systems. It takes the best-fit parameters and radial velocity data (BJD, velocity, errors) and calculates the error bars from sampling distribution estimated via bootstrapping. It is recommended to be used together with the RVLIN (ascl:1210.031) package, which find best-fit Keplerian orbital parameters. Both RVLIN and BOOTTRAN are compatible with multiple-telescope data. BOOTTRAN also calculates the transit time and secondary eclipse time and their associated error bars. The algorithm is described in the appendix of the associated article.

[ascl:1108.019]
BOREAS: Mass Loss Rate of a Cool, Late-type Star

The basic mechanisms responsible for producing winds from cool, late-type stars are still largely unknown. We take inspiration from recent progress in understanding solar wind acceleration to develop a physically motivated model of the time-steady mass loss rates of cool main-sequence stars and evolved giants. This model follows the energy flux of magnetohydrodynamic turbulence from a subsurface convection zone to its eventual dissipation and escape through open magnetic flux tubes. We show how Alfven waves and turbulence can produce winds in either a hot corona or a cool extended chromosphere, and we specify the conditions that determine whether or not coronal heating occurs. These models do not utilize arbitrary normalization factors, but instead predict the mass loss rate directly from a star's fundamental properties. We take account of stellar magnetic activity by extending standard age-activity-rotation indicators to include the evolution of the filling factor of strong photospheric magnetic fields. We compared the predicted mass loss rates with observed values for 47 stars and found significantly better agreement than was obtained from the popular scaling laws of Reimers, Schroeder, and Cuntz. The algorithm used to compute cool-star mass loss rates is provided as a self-contained and efficient IDL computer code. We anticipate that the results from this kind of model can be incorporated straightforwardly into stellar evolution calculations and population synthesis techniques.

Would you like to view a random code?