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

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

[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: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: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: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: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: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.

[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: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: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: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.

[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 RFI software presented here can automatically flag 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: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: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

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: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: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: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: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 and requires a number of Numerical Recipes routines in Fortran 90.

[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: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: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: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: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: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: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: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: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: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: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: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: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: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: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: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: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: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: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.

[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: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: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: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.

[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: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: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: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: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, 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: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: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 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.

[ascl:1607.017]
BoxRemap: Volume and local structure preserving mapping of periodic boxes

BoxRemap remaps the cubical domain of a cosmological simulation into simple non-cubical shapes. It can be used for on-the-fly remappings of the simulation geometry and is volume-preserving; remapped geometry has the same volume V = L3 as the original simulation box. The remappings are structure-preserving (local neighboring structures are mapped to neighboring places) and one-to-one, with every particle/halo/galaxy/etc. appearing once and only once in the remapped volume.

[ascl:1108.011]
BPZ: Bayesian Photometric Redshift Code

Photometric redshift estimation is becoming an increasingly important technique, although the currently existing methods present several shortcomings which hinder their application. Most of those drawbacks are efficiently eliminated when Bayesian probability is consistently applied to this problem. The use of prior probabilities and Bayesian marginalization allows the inclusion of valuable information, e.g. the redshift distributions or the galaxy type mix, which is often ignored by other methods. In those cases when the a priori information is insufficient, it is shown how to `calibrate' the prior distributions, using even the data under consideration. There is an excellent agreement between the 108 HDF spectroscopic redshifts and the predictions of the method, with a rms error Delta z/(1+z_spec) = 0.08 up to z<6 and no systematic biases nor outliers. The results obtained are more reliable than those of standard techniques even when the latter include near-IR colors. The Bayesian formalism developed here can be generalized to deal with a wide range of problems which make use of photometric redshifts, e.g. the estimation of individual galaxy characteristics as the metallicity, dust content, etc., or the study of galaxy evolution and the cosmological parameters from large multicolor surveys. Finally, using Bayesian probability it is possible to develop an integrated statistical method for cluster mass reconstruction which simultaneously considers the information provided by gravitational lensing and photometric redshifts.

[ascl:1806.025]
BRATS: Broadband Radio Astronomy ToolS

BRATS (Broadband Radio Astronomy ToolS) provides tools for the spectral analysis of broad-bandwidth radio data and legacy support for narrowband telescopes. It can fit models of spectral ageing on small spatial scales, offers automatic selection of regions based on user parameters (e.g. signal to noise), and automatic determination of the best-fitting injection index. It includes statistical testing, including Chi-squared, error maps, confidence levels and binning of model fits, and can map spectral index as a function of position. It also provides the ability to reconstruct sources at any frequency for a given model and parameter set, subtract any two FITS images and output residual maps, easily combine and scale FITS images in the image plane, and resize radio maps.

[ascl:1412.005]
BRUCE/KYLIE: Pulsating star spectra synthesizer

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

[ascl:1407.016]
Brut: Automatic bubble classifier

Brut, written in Python, identifies bubbles in infrared images of the Galactic midplane; it uses a database of known bubbles from the Milky Way Project and Spitzer images to build an automatic bubble classifier. The classifier is based on the Random Forest algorithm, and uses the WiseRF implementation of this algorithm.

[ascl:1303.014]
BSE: Binary Star Evolution

BSE is a rapid binary star evolution code. It can model circularization of eccentric orbits and synchronization of stellar rotation with the orbital motion owing to tidal interaction in detail. Angular momentum loss mechanisms, such as gravitational radiation and magnetic braking, are also modelled. Wind accretion, where the secondary may accrete some of the material lost from the primary in a wind, is allowed with the necessary adjustments made to the orbital parameters in the event of any mass variations. Mass transfer occurs if either star fills its Roche lobe and may proceed on a nuclear, thermal or dynamical time-scale. In the latter regime, the radius of the primary increases in response to mass-loss at a faster rate than the Roche-lobe of the star. Prescriptions to determine the type and rate of mass transfer, the response of the secondary to accretion and the outcome of any merger events are in place in BSE.

[ascl:9904.001]
BSGMODEL: The Bahcall-Soneira Galaxy Model

BSGMODEL is used to construct the disk and spheroid components of the Galaxy from which the distribution of visible stars and mass in the Galaxy is calculated. The computer files accessible here are available for export use. The modifications are described in comment lines in the software. The Galaxy model software has been installed and used by different people for a large variety of purposes (see, e. g., the the review "Star Counts and Galactic Structure'', Ann. Rev. Astron. Ap. 24, 577, 1986 ).

[ascl:1204.003]
BUDDA: BUlge/Disk Decomposition Analysis

Budda is a Fortran code developed to perform a detailed structural analysis on galaxy images. It is simple to use and gives reliable estimates of the galaxy structural parameters, which can be used, for instance, in Fundamental Plane studies. Moreover, it has a powerful ability to reveal hidden sub-structures, like inner disks, secondary bars and nuclear rings.

[ascl:1610.010]
BurnMan: Lower mantle mineral physics toolkit

BurnMan determines seismic velocities for the lower mantle. Written in Python, BurnMan calculates the isotropic thermoelastic moduli by solving the equations-of-state for a mixture of minerals defined by the user. The user may select from a list of minerals applicable to the lower mantle included or can define one. BurnMan provides choices in methodology, both for the EoS and for the multiphase averaging scheme and the results can be visually or quantitatively compared to observed seismic models.

[ascl:1806.026]
BWED: Brane-world extra dimensions

Braneworld-extra-dimensions places constraints on the size of the AdS5 radius of curvature within the Randall-Sundrum brane-world model in light of the near-simultaneous detection of the gravitational wave event GW170817 and its optical counterpart, the short γ-ray burst event GRB170817A. The code requires a (supplied) patch to the Montepython cosmological MCMC sampler (ascl:1805.027) to sample the posterior distribution of the 4-dimensional parameter space in VBV17 and obtain constraints on the parameters.

[ascl:1610.011]
BXA: Bayesian X-ray Analysis

BXA connects the nested sampling algorithm MultiNest (ascl:1109.006) to the X-ray spectral analysis environments Xspec/Sherpa for Bayesian parameter estimation and model comparison. It provides parameter estimation in arbitrary dimensions and plotting of spectral model vs. the data for best fit, posterior samples, or each component. BXA allows for model selection; it computes the evidence for the considered model, ready for use in computing Bayes factors and is not limited to nested models. It also visualizes deviations between model and data with Quantile-Quantile (QQ) plots, which do not require binning and are more comprehensive than residuals.

[ascl:1211.005]
C-m Emu: Concentration-mass relation emulator

The concentration-mass relation for dark matter-dominated halos is one of the essential results expected from a theory of structure formation. C-m Emu is a simple numerical code for the c-M relation as a function of cosmological parameters for wCDM models generates the best-fit power-law model for each redshift separately and then interpolate between the redshifts. This produces a more accurate answer at each redshift at the minimal cost of running a fast code for every c -M prediction instead of using one fitting formula. The emulator is constructed from 37 individual models, with three nested N-body gravity-only simulations carried out for each model. The mass range covered by the emulator is 2 x 10^{12} M_sun < M <10^{15} M_sun with a corresponding redshift range of z=0 -1. Over this range of mass and redshift, as well as the variation of cosmological parameters studied, the mean halo concentration varies from c ~ 2 to c ~ 8. The distribution of the concentration at fixed mass is Gaussian with a standard deviation of one-third of the mean value, almost independent of cosmology, mass, and redshift over the ranges probed by the simulations.

[ascl:1610.006]
C^{3}: Command-line Catalogue Crossmatch for modern astronomical surveys

The Command-line Catalogue Cross-matching (C^{3}) software efficiently performs the positional cross-match between massive catalogues from modern astronomical surveys, whose size have rapidly increased in the current data-driven science era. Based on a multi-core parallel processing paradigm, it is executed as a stand-alone command-line process or integrated within any generic data reduction/analysis pipeline. C^{3} provides its users with flexibility in portability, parameter configuration, catalogue formats, angular resolution, region shapes, coordinate units and cross-matching types.

[ascl:1102.013]
Cactus: HPC infrastructure and programming tools

Cactus provides computational scientists and engineers with a collaborative, modular and portable programming environment for parallel high performance computing. Cactus can make use of many other technologies for HPC, such as Samrai, HDF5, PETSc and PAPI, and several application domains such as numerical relativity, computational fluid dynamics and quantum gravity are developing open community toolkits for Cactus.

[ascl:1303.017]
CADRE: CArma Data REduction pipeline

CADRE, the Combined Array for Millimeter-wave Astronomy (CARMA) data reduction pipeline, gives investigators a first look at a fully reduced set of their data. It runs automatically on all data produced by the telescope as they arrive in the data archive. The pipeline is written in python and uses python wrappers for MIRIAD subroutines for direct access to the data. It applies passband, gain and flux calibration to the data sets and produces a set of continuum and spectral line maps in both MIRIAD and FITS format.

[ascl:1807.015]
CAESAR: Compact And Extended Source Automated Recognition

CAESAR extracts and parameterizes both compact and extended sources from astronomical radio interferometric maps. The processing pipeline is a series of stages that can run on multiple cores and processors. After local background and rms map computation, compact sources are extracted with flood-fill and blob finder algorithms, processed (selection + deblending), and fitted using a 2D gaussian mixture model. Extended source search is based on a pre-filtering stage, allowing image denoising, compact source removal and enhancement of diffuse emission, followed by a final segmentation. Different algorithms are available for image filtering and segmentation. The outputs delivered to the user include source fitted and shape parameters, regions and contours. Written in C++, CAESAR is designed to handle the large-scale surveys planned with the Square Kilometer Array (SKA) and its precursors.

[ascl:1505.001]
CALCEPH: Planetary ephemeris files access code

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

[ascl:1210.010]
CALCLENS: Curved-sky grAvitational Lensing for Cosmological Light conE simulatioNS

CALCLENS, written in C and employing widely available software libraries, efficiently computes weak gravitational lensing shear signals from large N-body light cone simulations over a curved sky. The algorithm properly accounts for the sky curvature and boundary conditions, is able to produce redshift-dependent shear signals including corrections to the Born approximation by using multiple-plane ray tracing, and properly computes the lensed images of source galaxies in the light cone. The key feature of this algorithm is a new, computationally efficient Poisson solver for the sphere that combines spherical harmonic transform and multgrid methods. As a result, large areas of sky (~10,000 square degrees) can be ray traced efficiently at high-resolution using only a few hundred cores on widely available machines. Coupled with realistic galaxy populations placed in large N-body light cone simulations, CALCLENS is ideally suited for the construction of synthetic weak lensing shear catalogs to be used to test for systematic effects in data analysis procedures for upcoming large-area sky surveys.

[ascl:1105.013]
CAMB Sources: Number Counts, Lensing & Dark-age 21cm Power Spectra

We relate the observable number of sources per solid angle and redshift to the underlying proper source density and velocity, background evolution and line-of-sight potentials. We give an exact result in the case of linearized perturbations assuming general relativity. This consistently includes contributions of the source density perturbations and redshift distortions, magnification, radial displacement, and various additional linear terms that are small on sub-horizon scales. In addition we calculate the effect on observed luminosities, and hence the result for sources observed as a function of flux, including magnification bias and radial-displacement effects. We give the corresponding linear result for a magnitude-limited survey at low redshift, and discuss the angular power spectrum of the total count distribution. We also calculate the cross-correlation with the CMB polarization and temperature including Doppler source terms, magnification, redshift distortions and other velocity effects for the sources, and discuss why the contribution of redshift distortions is generally small. Finally we relate the result for source number counts to that for the brightness of line radiation, for example 21-cm radiation, from the sources.

[ascl:1102.026]
CAMB: Code for Anisotropies in the Microwave Background

We present a fully covariant and gauge-invariant calculation of the evolution of anisotropies in the cosmic microwave background (CMB) radiation. We use the physically appealing covariant approach to cosmological perturbations, which ensures that all variables are gauge-invariant and have a clear physical interpretation. We derive the complete set of frame-independent, linearised equations describing the (Boltzmann) evolution of anisotropy and inhomogeneity in an almost Friedmann-Robertson-Walker (FRW) cold dark matter (CDM) universe. These equations include the contributions of scalar, vector and tensor modes in a unified manner. Frame-independent equations for scalar and tensor perturbations, which are valid for any value of the background curvature, are obtained straightforwardly from the complete set of equations. We discuss the scalar equations in detail, including the integral solution and relation with the line of sight approach, analytic solutions in the early radiation dominated era, and the numerical solution in the standard CDM model. Our results confirm those obtained by other groups, who have worked carefully with non-covariant methods in specific gauges, but are derived here in a completely transparent fashion.

[ascl:1801.007]
cambmag: Magnetic Fields in CAMB

cambmag is a modification to CAMB (ascl:1102.026) that calculates the compensated magnetic mode in the scalar, vector and tensor case. Previously CAMB included code only for the vectors. It also corrects for tight-coupling issues and adds in the ability to include massive neutrinos when calculating vector modes.

[ascl:1605.006]
CAMELOT: Cloud Archive for MEtadata, Library and Online Toolkit

Ginsburg, Adam; Kruijssen, J. M. Diederik; Longmore, Steven N.; Koch, Eric; Glover, Simon C. O.; Dale, James E.; Commerçon, Benoît; Giannetti, Andrea; McLeod, Anna F.; Testi, Leonardo; Zahorecz, Sarolta; Rathborne, Jill M.; Zhang, Qizhou; Fontani, Francesco; Beltrán, Maite T.; Rivilla, Victor M.

CAMELOT facilitates the comparison of observational data and simulations of molecular clouds and/or star-forming regions. The central component of CAMELOT is a database summarizing the properties of observational data and simulations in the literature through pertinent metadata. The core functionality allows users to upload metadata, search and visualize the contents of the database to find and match observations/simulations over any range of parameter space.

To bridge the fundamental disconnect between inherently 2D observational data and 3D simulations, the code uses key physical properties that, in principle, are straightforward for both observers and simulators to measure — the surface density (Sigma), velocity dispersion (sigma) and radius (R). By determining these in a self-consistent way for all entries in the database, it should be possible to make robust comparisons.

[ascl:1502.015]
Camelus: Counts of Amplified Mass Elevations from Lensing with Ultrafast Simulations

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

[ascl:1505.030]
CANDID: Companion Analysis and Non-Detection in Interferometric Data

Gallenne, A.; Mérand, A.; Kervella, P.; Monnier, J. D.; Schaefer, G. H.; Baron, F.; Breitfelder, J.; Le Bouquin, J. B.; Roettenbacher, R. M.; Gieren, W.; Pietrzynski, G.; McAlister, H.; ten Brummelaar, T.; Sturmann, J.; Sturmann, L.; Turner, N.; Ridgway, S.; Kraus, S.

CANDID finds faint companion around star in interferometric data in the OIFITS format. It allows systematically searching for faint companions in OIFITS data, and if not found, estimates the detection limit. The tool is based on model fitting and Chi2 minimization, with a grid for the starting points of the companion position. It ensures all positions are explored by estimating a-posteriori if the grid is dense enough, and provides an estimate of the optimum grid density.

[ascl:1106.017]
CAOS: Code for Adaptive Optics Systems

The CAOS "system" (where CAOS stands for Code for Adaptive Optics Systems) is properly said a Problem Solving Environment (PSE). It is essentially composed of a graphical programming interface (the CAOS Application Builder) which can load different packages (set of modules). Current publicly distributed packages are the Software Package CAOS (the original adaptive optics package), the Software Package AIRY (an image-reconstruction-oriented package - AIRY stands for Astronomical Image Restoration with interferometrY), the Software Package PAOLAC (a simple CAOS interface for the analytic IDL code PAOLA developed by Laurent Jolissaint - PAOLAC stands for PAOLA within Caos), and a couple of private packages (not publicly distributed but restricted to the corresponding consortia): SPHERE (especially developed for the VLT planet finder SPHERE), and AIRY-LN (a specialized version of AIRY for the LBT instrument LINC-NIRVANA). Another package is also being developed: MAOS (that stands for Multiconjugate Adaptive Optics Simulations), developed for multi-reference multiconjugate AO studies purpose but still in a beta-version form.

[ascl:1404.011]
CAP_LOESS_1D & CAP_LOESS_2D: Recover mean trends from noisy data

CAP_LOESS_1D and CAP_LOESS_2D provide improved implementations of the one-dimensional (Clevelend 1979) and two-dimensional (Cleveland & Devlin 1988) Locally Weighted Regression (LOESS) methods to recover the mean trends of the population from noisy data in one or two dimensions. They include a robust approach to deal with outliers (bad data). The software is available in both IDL and Python versions.

[ascl:1505.003]
caret: Classification and Regression Training

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

[ascl:1404.009]
carma_pack: MCMC sampler for Bayesian inference

carma_pack is an MCMC sampler for performing Bayesian inference on continuous time autoregressive moving average models. These models may be used to model time series with irregular sampling. The MCMC sampler utilizes an adaptive Metropolis algorithm combined with parallel tempering.

[ascl:1611.016]
Carpet: Adaptive Mesh Refinement for the Cactus Framework

Carpet is an adaptive mesh refinement and multi-patch driver for the Cactus Framework (ascl:1102.013). Cactus is a software framework for solving time-dependent partial differential equations on block-structured grids, and Carpet acts as driver layer providing adaptive mesh refinement, multi-patch capability, as well as parallelization and efficient I/O.

[ascl:1107.013]
CASA: Common Astronomy Software Applications

CASA, the Common Astronomy Software Applications package, is being developed with the primary goal of supporting the data post-processing needs of the next generation of radio astronomical telescopes such as ALMA and EVLA. The package can process both interferometric and single dish data. The CASA infrastructure consists of a set of C++ tools bundled together under an iPython interface as a set of data reduction tasks. This structure provides flexibility to process the data via task interface or as a python script. In addition to the data reduction tasks, many post-processing tools are available for even more flexibility and special purpose reduction needs.

[ascl:1402.013]
CASSIS: Interactive spectrum analysis

CASSIS (Centre d'Analyse Scientifique de Spectres Infrarouges et Submillimetriques), written in Java, is suited for broad-band spectral surveys to speed up the scientific analysis of high spectral resolution observations. It uses a local spectroscopic database made of the two molecular spectroscopic databases JPL and CDMS, as well as the atomic spectroscopic database NIST. Its tools include a LTE model and the RADEX model connected to the LAMDA molecular collisional database. CASSIS can build a line list fitting the various transitions of a given species and to directly produce rotational diagrams from these lists. CASSIS is fully integrated into HIPE, the Herschel Interactive Processing Environment, as a plug-in.

[ascl:1105.010]
CASTRO: Multi-dimensional Eulerian AMR Radiation-hydrodynamics Code

Almgren, A. S.; Beckner, V. E.; Bell, J. B.; Day, M. S.; Howell, L. H.; Katz, M; Lijewski, M. J.; Malone, C.; Nonaka, A.; Singer, M.; Zhang, W; Zingale, M.

CASTRO is a multi-dimensional Eulerian AMR radiation-hydrodynamics code that includes stellar equations of state, nuclear reaction networks, and self-gravity. Initial target applications for CASTRO include Type Ia and Type II supernovae. CASTRO supports calculations in 1-d, 2-d and 3-d Cartesian coordinates, as well as 1-d spherical and 2-d cylindrical (r-z) coordinate systems. Time integration of the hydrodynamics equations is based on an unsplit version of the the piecewise parabolic method (PPM) with new limiters that avoid reducing the accuracy of the scheme at smooth extrema. CASTRO can follow an arbitrary number of isotopes or elements. The atomic weights and amounts of these elements are used to calculate the mean molecular weight of the gas required by the equation of state. CASTRO supports several different approaches to solving for self-gravity. The most general is a full Poisson solve for the gravitational potential. CASTRO also supports a monopole approximation for gravity, and a constant gravity option is also available. The CASTRO software is written in C++ and Fortran, and is based on the BoxLib software framework developed by CCSE.

[ascl:1804.013]
CAT-PUMA: CME Arrival Time Prediction Using Machine learning Algorithms

CAT-PUMA (CME Arrival Time Prediction Using Machine learning Algorithms) quickly and accurately predicts the arrival of Coronal Mass Ejections (CMEs) of CME arrival time. The software was trained via detailed analysis of CME features and solar wind parameters using 182 previously observed geo-effective partial-/full-halo CMEs and uses algorithms of the Support Vector Machine (SVM) to make its predictions, which can be made within minutes of providing the necessary input parameters of a CME.

[ascl:1206.008]
Catena: Ensemble of stars orbit integration

Catena integrates the orbits of an ensemble of stars using the chain-regularization method (Mikkola & Aarseth) with an embedded Runge-Kutta integration method of 9(8)th order (Prince & Dormand).

[ascl:1810.013]
catsHTM: Catalog cross-matching tool

The catsHTM package quickly accesses and cross-matches large astronomical catalogs that have been reformatted into the HDF5-based file format. It performs efficient cone searches at resolutions from a few arc-seconds to degrees within a few milliseconds time, cross-match numerous catalogs, and can do general searches.

[ascl:1403.021]
CCDPACK: CCD Data Reduction Package

CCDPACK contains programs to debias, remove dark current, flatfield, register, resample and normalize data from single- or multiple-CCD instruments. The basic reduction stages can be set up using an X based GUI that controls an automated reduction system so one can to start working without any detailed knowledge of the package (or indeed of CCD reduction). Registration is performed using graphical, script based or automated techniques that keep the amount of work to a minimum. CCDPACK uses the Starlink environment (ascl:1110.012).

[ascl:1510.007]
ccdproc: CCD data reduction software

Craig, M. W.; Crawford, S. M.; Deil, Christoph; Gomez, Carlos; Günther, Hans Moritz; Heidt, Nathan; Horton, Anthony; Karr, Jennifer; Nelson, Stefan; Ninan, Joe Phillip; Pattnaik, Punyaslok; Rol, Evert; Schoenell, William; Seifert, Michael; Singh, Sourav; Sipocz, Brigitta; Stotts, Connor; Streicher, Ole; Tollerud, Erik; Walker, Nathan; ccdproc contributors

Ccdproc is an affiliated package for the AstroPy package for basic data reductions of CCD images. The ccdproc package provides many of the necessary tools for processing of ccd images built on a framework to provide error propagation and bad pixel tracking throughout the reduction process.

[ascl:1511.013]
CCDtoRGB: RGB image production from three-band astronomical images

Lupton, Robert; Blanton, Michael R.; Fekete, George; Hogg, David W.; O'Mullane, Wil; Szalay, Alex; Wherry, Nicholas

CCDtoRGB produces red‐green‐blue (RGB) composites from three‐band astronomical images, ensuring an object with a specified astronomical color has a unique color in the RGB image rather than burnt‐out white stars. Use of an arcsinh stretch shows faint objects while simultaneously preserving the structure of brighter objects in the field, such as the spiral arms of large galaxies.

[ascl:1707.004]
CCFpams: Atmospheric stellar parameters from cross-correlation functions

CCFpams allows the measurement of stellar temperature, metallicity and gravity within a few seconds and in a completely automated fashion. Rather than performing comparisons with spectral libraries, the technique is based on the determination of several cross-correlation functions (CCFs) obtained by including spectral features with different sensitivity to the photospheric parameters. Literature stellar parameters of high signal-to-noise (SNR) and high-resolution HARPS spectra of FGK Main Sequence stars are used to calibrate the stellar parameters as a function of CCF areas.

[ascl:1208.006]
ccogs: Cosmological Calculations on the GPU

This suite contains two packages for computing cosmological quantities on the GPU: aperture_mass, which calculates the aperture mass map for a given dataset using the filter proposed by Schirmer et al (2007) (an NFW profile with exponential cut-offs at zero and large radii), and angular_correlation, which calculates the 2-pt angular correlation function using data and a flat distribution of randomly generated galaxies. A particular estimator is chosen, but the user has the flexibility to explore other estimators.

[ascl:1604.009]
CCSNMultivar: Core-Collapse Supernova Gravitational Waves

CCSNMultivar aids the analysis of core-collapse supernova gravitational waves. It includes multivariate regression of Fourier transformed or time domain waveforms, hypothesis testing for measuring the influence of physical parameters, and the Abdikamalov et. al. catalog for example use. CCSNMultivar can optionally incorporate additional uncertainty due to detector noise and approximate waveforms from anywhere within the parameter space.

[ascl:1709.008]
celerite: Scalable 1D Gaussian Processes in C++, Python, and Julia

celerite provides fast and scalable Gaussian Process (GP) Regression in one dimension and is implemented in C++, Python, and Julia. The celerite API is designed to be familiar to users of george and, like george, celerite is designed to efficiently evaluate the marginalized likelihood of a dataset under a GP model. This is then be used alongside a non-linear optimization or posterior inference library for the best results.

[ascl:1602.011]
Celestial: Common astronomical conversion routines and functions

The R package Celestial contains common astronomy conversion routines, particularly the HMS and degrees schemes, and a large range of functions for calculating properties of different cosmologies (as used by the cosmocalc website). This includes distances, ages, growth rate/factor and densities (e.g., Omega evolution and critical energy density). It also includes functions for calculating thermal properties of the CMB and Planck's equations and virial properties of halos in different cosmologies, and standard NFW and weak-lensing formulas and low level orbital routines for calculating Roche properties, Vis-Viva and free-fall times.

[ascl:1612.016]
CELib: Software library for simulations of chemical evolution

CELib (Chemical Evolution Library) simulates chemical evolution of galaxy formation under the simple stellar population (SSP) approximation and can be used by any simulation code that uses the SSP approximation, such as particle-base and mesh codes as well as semi-analytical models. Initial mass functions, stellar lifetimes, yields from type II and Ia supernovae, asymptotic giant branch stars, and neutron star mergers components are included and a variety of models are available for use. The library allows comparisons of the impact of individual models on the chemical evolution of galaxies by changing control flags and parameters of the library.

[submitted]
centerRadon: Center Determination Code in Stellar Images

centerRadon finds the center of stars based on Radon Transform (Pueyo et al., 2015) to sub-pixel precision. For a coronagraphic image of a star, it starts from a given location, then for each sub-pixel position, it interpolates the image and sums the pixels along different angles, creating a cost function. The center of the star is expected to correspond with where the cost function maximizes. The default values are set for the STIS coronagraphic images of the Hubble Space Telescope by summing over the diagonals (i.e., 45° and 135°), but it can be generally applied to other high-contrast imaging instruments with or without Adaptive Optics systems such as HST-NICMOS, P1640, or GPI.

[ascl:1308.015]
Ceph_code: Cepheid light-curves fitting

Ceph_code fits multi-band Cepheid light-curves using templates derived from OGLE observations. The templates include short period stars (<10 day) and overtone stars.

[ascl:1610.002]
CERES: Collection of Extraction Routines for Echelle Spectra

The Collection of Extraction Routines for Echelle Spectra (CERES) constructs automated pipelines for the reduction, extraction, and analysis of echelle spectrograph data. This modular code includes tools for handling the different steps of the processing: CCD reductions, tracing of the echelle orders, optimal and simple extraction, computation of the wave-length solution, estimation of radial velocities, and rough and fast estimation of the atmospheric parameters. The standard output of pipelines constructed with CERES is a FITS cube with the optimally extracted, wavelength calibrated and instrumental drift-corrected spectrum for each of the science images. Additionally, CERES includes routines for the computation of precise radial velocities and bisector spans via the cross-correlation method, and an automated algorithm to obtain an estimate of the atmospheric parameters of the observed star.

[ascl:1010.059]
CESAM: A Free Code for Stellar Evolution Calculations

The Cesam code is a consistent set of programs and routines which perform calculations of 1D quasi-hydrostatic stellar evolution including microscopic diffusion of chemical species and diffusion of angular momentum. The solution of the quasi-static equilibrium is performed by a collocation method based on piecewise polynomials approximations projected on a B-spline basis; that allows stable and robust calculations, and the exact restitution of the solution, not only at grid points, even for the discontinuous variables. Other advantages are the monitoring by only one parameter of the accuracy and its improvement by super-convergence. An automatic mesh refinement has been designed for adjusting the localisations of grid points according to the changes of unknowns. For standard models, the evolution of the chemical composition is solved by stiffly stable schemes of orders up to four; in the convection zones mixing and evolution of chemical are simultaneous. The solution of the diffusion equation employs the Galerkin finite elements scheme; the mixing of chemicals is then performed by a strong turbulent diffusion. A precise restoration of the atmosphere is allowed for.

[ascl:1010.001]
CFITSIO: A FITS File Subroutine Library

CFITSIO is a library of C and Fortran subroutines for reading and writing data files in FITS (Flexible Image Transport System) data format. CFITSIO provides simple high-level routines for reading and writing FITS files that insulate the programmer from the internal complexities of the FITS format. CFITSIO also provides many advanced features for manipulating and filtering the information in FITS files.

[ascl:1411.024]
CGS3DR: UKIRT CGS3 data reduction software

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

[ascl:1406.013]
CGS4DR: Automated reduction of data from CGS4

CGS4DR is data reduction software for the CGS4 instrument at UKIRT. The software can be used offline to reprocess CGS4 data. CGS4DR allows a wide variety of data reduction configurations, and can interlace oversampled data frames; reduce known bias, dark, flat, arc, object and sky frames; remove the sky, residual sky OH-lines (λ < 2.3 μm) and thermal emission (λ ≥ 2.3 μm) from data; and add data into groups for improved signal-to-noise. It can also extract and de-ripple a spectrum and offers a variety of ways to plot data, in addition to other useful features. CGS4DR is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1105.005]
ChaNGa: Charm N-body GrAvity solver

ChaNGa (Charm N-body GrAvity solver) performs collisionless N-body simulations. It can perform cosmological simulations with periodic boundary conditions in comoving coordinates or simulations of isolated stellar systems. It also can include hydrodynamics using the Smooth Particle Hydrodynamics (SPH) technique. It uses a Barnes-Hut tree to calculate gravity, with hexadecapole expansion of nodes and Ewald summation for periodic forces. Timestepping is done with a leapfrog integrator with individual timesteps for each particle.

[ascl:1703.015]
Charm: Cosmic history agnostic reconstruction method

Charm (cosmic history agnostic reconstruction method) reconstructs the cosmic expansion history in the framework of Information Field Theory. The reconstruction is performed via the iterative Wiener filter from an agnostic or from an informative prior. The charm code allows one to test the compatibility of several different data sets with the LambdaCDM model in a non-parametric way.

[ascl:1412.002]
Cheetah: Starspot modeling code

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

[ascl:1702.011]
Chempy: A flexible chemical evolution model for abundance fitting

Chempy models Galactic chemical evolution (GCE); it is a parametrized open one-zone model within a Bayesian framework. A Chempy model is specified by a set of 5-10 parameters that describe the effective galaxy evolution along with the stellar and star-formation physics: e.g. the star-formation history (SFH), the feedback efficiency, the stellar initial mass function (IMF) and the incidence of supernova of type Ia (SN Ia). Chempy can sample the posterior probability distribution in the full model parameter space and test data-model matches for different nucleosynthetic yield sets, performing essentially as a chemical evolution fitting tool. Chempy can be used to confront predictions from stellar nucleosynthesis with complex abundance data sets and to refine the physical processes governing the chemical evolution of stellar systems.

[ascl:9911.004]
CHIANTI: A database for astrophysical emission line spectroscopy

CHIANTI consists of a critically evaluated set of atomic data necessary to calculate the emission line spectrum of astrophysical plasmas. The data consists of atomic energy levels, atomic radiative data such as wavelengths, weighted oscillator strengths and A values, and electron collisional excitation rates. A set of programs that use these data to calculate the spectrum in a desired wavelength range as a function of temperature and density are also provided. These programs have been written in Interactive Data Language (IDL) and descriptions of these various programs are provided on the website.

[ascl:1308.017]
ChiantiPy: Python package for the CHIANTI atomic database

ChiantiPy is an object-orient Python package for calculating astrophysical spectra using the CHIANTI atomic database for astrophysical spectroscopy. It provides access to the database and the ability to calculate various physical quantities for the interpretation of astrophysical spectra.

[ascl:1504.005]
chimenea: Multi-epoch radio-synthesis data imaging

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

[ascl:1403.006]
CHIMERA: Core-collapse supernovae simulation code

Mezzacappa, Anthony; Hix, Raph; Messor, Bronson; Lentz, Eric; Chertkow, Merek Austin; Parete-Koon, Suzanne; Lingerfelt, Eric

CHIMERA simulates core collapse supernovas; it is three-dimensional and accounts for the differing energies of neutrinos. This massively parallel multiphysics code conserves total energy (gravitational, internal, kinetic, and neutrino) to within 0.5 B, given a conservative gravitational potential. CHIMERA has three main components: a hydro component, a neutrino transport component, and a nuclear reaction network component. It also includes a Poisson solver for the gravitational potential and a sophisticated equation of state.

[ascl:1602.017]
CHIP: Caltech High-res IRS Pipeline

CHIP (Caltech High-res IRS Pipeline) reduces high signal-to-noise short-high and long-high Spitzer-IRS spectra, especially that taken with dedicated background exposures. Written in IDL, it is independent of other Spitzer reduction tools except IRSFRINGE (ascl:1602.016).

[ascl:1104.012]
CHIWEI: A Code of Goodness of Fit Tests for Weighted and Unweighed Histograms

A self-contained Fortran-77 program for goodness of fit tests for histograms with weighted entries as well as with unweighted entries is presented. The code calculates test statistic for case of histogram with normalized weights of events and for case of unnormalized weights of events.

[ascl:1409.008]
CHLOE: A tool for automatic detection of peculiar galaxies

CHLOE is an image analysis unsupervised learning algorithm that detects peculiar galaxies in datasets of galaxy images. The algorithm first computes a large set of numerical descriptors reflecting different aspects of the visual content, and then weighs them based on the standard deviation of the values computed from the galaxy images. The weighted Euclidean distance of each galaxy image from the median is measured, and the peculiarity of each galaxy is determined based on that distance.

[ascl:1607.006]
Cholla: 3D GPU-based hydrodynamics code for astrophysical simulation

Cholla (Computational Hydrodynamics On ParaLLel Architectures) models the Euler equations on a static mesh and evolves the fluid properties of thousands of cells simultaneously using GPUs. It can update over ten million cells per GPU-second while using an exact Riemann solver and PPM reconstruction, allowing computation of astrophysical simulations with physically interesting grid resolutions (>256^3) on a single device; calculations can be extended onto multiple devices with nearly ideal scaling beyond 64 GPUs.

[ascl:1202.008]
Chombo: Adaptive Solutions of Partial Differential Equations

Chombo provides a set of tools for implementing finite difference methods for the solution of partial differential equations on block-structured adaptively refined rectangular grids. Both elliptic and time-dependent modules are included. Chombo supports calculations in complex geometries with both embedded boundaries and mapped grids, and also supports particle methods. Most parallel platforms are supported, and cross-platform self-describing file formats are included.

The Chombo package is a product of the community of Collaborators working with the Applied Numerical Algorithms Group (ANAG), part of the Computational Research Division at LBNL.

[ascl:1209.004]
CHORIZOS: CHi-square cOde for parameterRized modeling and characterIZation of phOtometry and Spectrophotmetry

CHORIZOS is a multi-purpose Bayesian code developed in IDL to compare photometric data with model spectral energy distributions (SEDs). The user can select the SED family (e.g. Kurucz) and choose the behavior of each parameter (e.g. Teff) to be fixed, constrained to a given range, or unconstrained. The code calculates the likelihood for the full specified parameter ranges, thus allowing for the identification of multiple solutions and the evaluation of the full correlation matrix for the derived parameters of a single solution.

[ascl:1804.007]
chroma: Chromatic effects for LSST weak lensing

Chroma investigates biases originating from two chromatic effects in the atmosphere: differential chromatic refraction (DCR), and wavelength dependence of seeing. These biases arise when using the point spread function (PSF) measured with stars to estimate the shapes of galaxies with different spectral energy distributions (SEDs) than the stars.

[ascl:1311.006]
CIAO: Chandra Interactive Analysis of Observations

CIAO is a data analysis system written for the needs of users of the Chandra X-ray Observatory. Because Chandra data is 4-dimensional (2 spatial, time, energy) and each dimension has many independent elements, CIAO was built to handle N-dimensional data without concern about which particular axes were being analyzed. Apart from a few Chandra instrument tools, CIAO is mission independent. CIAO tools read and write several formats, including FITS images and tables (which includes event files) and IRAF imh files. CIAO is a powerful system for the analysis of many types of data.

[ascl:1803.002]
CIFOG: Cosmological Ionization Fields frOm Galaxies

CIFOG is a versatile MPI-parallelised semi-numerical tool to perform simulations of the Epoch of Reionization. From a set of evolving cosmological gas density and ionizing emissivity fields, it computes the time and spatially dependent ionization of neutral hydrogen (HI), neutral (HeI) and singly ionized helium (HeII) in the intergalactic medium (IGM). The code accounts for HII, HeII, HeIII recombinations, and provides different descriptions for the photoionization rate that are used to calculate the residual HI fraction in ionized regions. This tool has been designed to be coupled to semi-analytic galaxy formation models or hydrodynamical simulations. The modular fashion of the code allows the user to easily introduce new descriptions for recombinations and the photoionization rate.

[ascl:1111.004]
CIGALE: Code Investigating GALaxy Emission

The CIGALE code has been developed to study the evolution of galaxies by comparing modelled galaxy spectral energy distributions (SEDs) to observed ones from the far ultraviolet to the far infrared. It extends the SED fitting algorithm written by Burgarella et al. (2005, MNRAS 360, 1411). While the previous code was designed to fit SEDs in the optical and near infrared, CIGALE is able to fit SEDs up to the far infrared using Dale & Helou (2002, ApJ 576, 159). CIGALE Bayesian and CIGALE Monte Carlo Markov Chain are available.

[ascl:1708.002]
CINE: Comet INfrared Excitation

CINE calculates infrared pumping efficiencies that can be applied to the most common molecules found in cometary comae such as water, hydrogen cyanide or methanol. One of the main mechanisms for molecular excitation in comets is the fluorescence by the solar radiation followed by radiative decay to the ground vibrational state. This command-line tool calculates the effective pumping rates for rotational levels in the ground vibrational state scaled by the heliocentric distance of the comet. Fluorescence coefficients are useful for modeling rotational emission lines observed in cometary spectra at sub-millimeter wavelengths. Combined with computational methods to solve the radiative transfer equations based, e.g., on the Monte Carlo algorithm, this model can retrieve production rates and rotational temperatures from the observed emission spectrum.

[ascl:1202.001]
CISM_DX: Visualization and analysis tool

CISM_DX is a community-developed suite of integrated data, models, and data and model explorers, for research and education. The data and model explorers are based on code written for OpenDX and Octave; OpenDX provides the visualization infrastructures as well as the process for creating user interfaces to the model and data, and Octave allows for extensive data manipulation and reduction operations. The CISM-DX package extends the capabilities of the core software programs to meet the needs of space physics researchers.

[ascl:1312.013]
CJAM: First and second velocity moments calculations

CJAM calculates first and second velocity moments using the Jeans Anisotropic MGE (JAM) models of Cappellari (2008) and Cappellari (2012). These models have been extended to calculate all three (x, y, z) first moments and all six (xx, yy, zz, xy, xz, yz) second moments. CJAM, written in C, is based on the IDL implementation of the line-of-sight calculations by Michele Cappellari.

[ascl:1106.020]
CLASS: Cosmic Linear Anisotropy Solving System

Boltzmann codes are used extensively by several groups for constraining cosmological parameters with Cosmic Microwave Background and Large Scale Structure data. This activity is computationally expensive, since a typical project requires from 10'000 to 100'000 Boltzmann code executions. The code CLASS (Cosmic Linear Anisotropy Solving System) incorporates improved approximation schemes leading to a simultaneous gain in speed and precision. We describe here the three approximations used by CLASS for basic LambdaCDM models, namely: a baryon-photon tight-coupling approximation which can be set to first order, second order or to a compromise between the two; an ultra-relativistic fluid approximation which had not been implemented in public distributions before; and finally a radiation streaming approximation taking reionisation into account.

[ascl:1807.013]
CLASSgal: Relativistic cosmological large scale structure code

CLASSgal computes large scale structure observables; it includes all relativistic corrections and computes both the power spectrum *C _{l}*(

[ascl:1407.010]
CLE: Coronal line synthesis

CLE, written in Fortran 77, synthesizes Stokes profiles of forbidden lines such as Fe XIII 1074.7nm, formed in magnetic dipole transitions under coronal conditions. The lines are assumed to be optically thin, excited by (anisotropic) photospheric radiation and thermal particle collisions.

[ascl:1602.019]
CLOC: Cluster Luminosity Order-Statistic Code

CLOC computes cluster order statistics, *i.e.* the luminosity distribution of the Nth most luminous cluster in a population. It is flexible and requires few assumptions, allowing for parametrized variations in the initial cluster mass function and its upper and lower cutoffs, variations in the cluster age distribution, stellar evolution and dust extinction, as well as observational uncertainties in both the properties of star clusters and their underlying host galaxies. It uses Markov chain Monte Carlo methods to search parameter space to find best-fitting values for the parameters describing cluster formation and disruption, and to obtain rigorous confidence intervals on the inferred values.

[ascl:1103.015]
Cloudy_3D: Quick Pseudo-3D Photoionization Code

We developed a new quick pseudo-3D photoionization code based on Cloudy (G. Ferland) and IDL (RSI) tools. The code is running the 1D photoionization code Cloudy various times, changing at each run the input parameters (e.g. inner radius, density law) according to an angular law describing the morphology of the object. Then a cube is generated by interpolating the outputs of Cloudy. In each cell of the cube, the physical conditions (electron temperature and density, ionic fractions) and the emissivities of lines are determined. Associated tools (VISNEB and VELNEB_3D) are used to rotate the nebula and to compute surface brightness maps and emission line profiles, given a velocity law and taking into account the effect of the thermal broadening and eventually the turbulence. Integrated emission line profiles are computed, given aperture shapes and positions (seeing and instrumental width effects are included). The main advantage of this tool is the short time needed to compute a model (a few tens minutes).

[ascl:9910.001]
Cloudy: Numerical simulation of plasmas and their spectra

Ferland, Gary; van Hoof, Peter; Verner, Dima; Verner, Katya; Ferguson, Jason; Hamann, Fred; Kingdon, Jim; Korista, Kirk; Shields, Joe

Cloudy is a large-scale spectral synthesis code designed to simulate fully physical conditions within an astronomical plasma and then predict the emitted spectrum. The code is freely available and is widely used in the analysis and interpretation of emission-line spectra.

[ascl:1107.014]
Clumpfind: Determining Structure in Molecular Clouds

We describe an automatic, objective routine for analyzing the clumpy structure in a spectral line position-position-velocity data cube. The algorithm works by first contouring the data at a multiple of the rms noise of the observations, then searches for peaks of emission which locate the clumps, and then follows them down to lower intensities. No a proiri clump profile is assumed. By creating simulated data, we test the performance of the algorithm and show that a contour map most accurately depicts internal structure at a contouring interval equal to twice the rms noise of the map. Blending of clump emission leads to small errors in mass and size determinations and in severe cases can result in a number of clumps being misidentified as a single unit, flattening the measured clump mass spectrum. The algorithm is applied to two real data sets as an example of its use. The Rosette molecular cloud is a 'typical' star-forming cloud, but in the Maddalena molecular cloud high-mass star formation is completely absent. Comparison of the two clump lists generated by the algorithm show that on a one-to-one basis the clumps in the star-forming cloud have higher peak temperatures, higher average densities, and are more gravitationally bound than in the non-star-forming cloud. Collective properties of the clumps, such as temperature-size-line-width-mass relations appear very similar, however. Contrary to the initial results reported in a previous paper (Williams & Blitz 1993), we find that the current, more thoroughly tested analysis finds no significant difference in the clump mass spectrum of the two clouds.

[ascl:1201.012]
CLUMPY: A code for gamma-ray signals from dark matter structures

CLUMPY is a public code for semi-analytical calculation of the gamma-ray flux astrophysical J-factor from dark matter annihilation/decay in the Galaxy, including dark matter substructures. The core of the code is the calculation of the line of sight integral of the dark matter density squared (for annihilations) or density (for decaying dark matter). The code can be used in three modes: i) to draw skymaps from the Galactic smooth component and/or the substructure contributions, ii) to calculate the flux from a specific halo (that is not the Galactic halo, e.g. dwarf spheroidal galaxies) or iii) to perform simple statistical operations from a list of allowed DM profiles for a given object. Extragalactic contributions and other tracers of DM annihilation (e.g. positrons, antiprotons) will be included in a second release.

[ascl:1711.008]
clustep: Initial conditions for galaxy cluster halo simulations

clustep generates a snapshot in GADGET-2 (ascl:0003.001) format containing a galaxy cluster halo in equilibrium; this snapshot can also be read in RAMSES (ascl:1011.007) using the DICE patch. The halo is made of a dark matter component and a gas component, with the latter representing the ICM. Each of these components follows a Dehnen density profile, with gamma=0 or gamma=1. If gamma=1, then the profile corresponds to a Hernquist profile.

[ascl:1610.008]
cluster-in-a-box: Statistical model of sub-millimeter emission from embedded protostellar clusters

Cluster-in-a-box provides a statistical model of sub-millimeter emission from embedded protostellar clusters and consists of three modules grouped in two scripts. The first (cluster_distribution) generates the cluster based on the number of stars, input initial mass function, spatial distribution and age distribution. The second (cluster_emission) takes an input file of observations, determines the mass-intensity correlation and generates outflow emission for all low-mass Class 0 and I sources. The output is stored as a FITS image where the flux density is determined by the desired resolution, pixel scale and cluster distance.

[ascl:1605.002]
cluster-lensing: Tools for calculating properties and weak lensing profiles of galaxy clusters

The cluster-lensing package calculates properties and weak lensing profiles of galaxy clusters. Implemented in Python, it includes cluster mass-richness and mass-concentration scaling relations, and NFW halo profiles for weak lensing shear, the differential surface mass density ΔΣ(r), and for magnification, Σ(r). Optionally the calculation will include the effects of cluster miscentering offsets.

[ascl:1802.003]
CMacIonize: Monte Carlo photoionisation and moving-mesh radiation hydrodynamics

CMacIonize simulates the self-consistent evolution of HII regions surrounding young O and B stars, or other sources of ionizing radiation. The code combines a Monte Carlo photoionization algorithm that uses a complex mix of hydrogen, helium and several coolants in order to self-consistently solve for the ionization and temperature balance at any given time, with a standard first order hydrodynamics scheme. The code can be run as a post-processing tool to get the line emission from an existing simulation snapshot, but can also be used to run full radiation hydrodynamical simulations. Both the radiation transfer and the hydrodynamics are implemented in a general way that is independent of the grid structure that is used to discretize the system, allowing it to be run both as a standard fixed grid code and also as a moving-mesh code.

[ascl:1106.018]
CMB B-modes from Faraday Rotation

This code is a quick and exact calculator of B-mode angular spectrum due to Faraday rotation by stochastic magnetic fields. Faraday rotation induced B-modes can provide a distinctive signature of primordial magnetic fields because of their characteristic frequency dependence and because they are only weakly damped on small scales, allowing them to dominate B-modes from other sources. By numerically solving the full CMB radiative transport equations, we study the B-mode power spectrum induced by stochastic magnetic fields that have significant power on scales smaller than the thickness of the last scattering surface. Constraints on the magnetic field energy density and inertial scale are derived from WMAP 7-year data, and are stronger than the big bang nucleosynthesis (BBN) bound for a range of parameters. Observations of the CMB polarization at smaller angular scales are crucial to provide tighter constraints or a detection.

[ascl:1106.023]
CMBACT: CMB from ACTive sources

This code is based on the cosmic string model described in this paper by Pogosian and Vachaspati, as well as on the CMBFAST code created by Uros Seljak and Matias Zaldarriaga. It contains an integrator for the vector contribution to the CMB temperature and polarization. The code is reconfigured to make it easier to use with or without active sources. To produce inflationary CMB spectra one simply sets the string tension to zero (gmu=0.0d0). For a non-zero value of tension only the string contribution is calculated.

An option is added to randomize the directions of velocities of consolidated segments as they evolve in time. In the original segment model, which is still the default version (irandomv=0), each segment is given a random velocity initially, but then continues to move in a straight line for the rest of its life. The new option (irandomv=1) allows to additionally randomize velocities of each segment at roughly each Hubble time. However, the merits of this new option are still under investigation. The default version (irandomv=0) is strongly recommended, since it actually gives reasonable unequal time correlators. For each Fourier mode, k, the string stress-energy components are now evaluated on a time grid sufficiently fine for that k.

[ascl:1007.004]
CMBEASY: An object-oriented code for the cosmic microwave background

CMBEASY is a software package for calculating the evolution of density fluctuations in the universe. Most notably, the Cosmic Microwave Background temperature anisotropies. It features a Markov Chain Monte Carlo driver and many routines to compute likelihoods of any given model. It is based on the CMBFAST package by Uros Seljak and Matias Zaldarriaga.

[ascl:9909.004]
CMBFAST: A microwave anisotropy code

CMBFAST is the most extensively used code for computing cosmic microwave background anisotropy, polarization and matter power spectra. This package contains cosmological linear perturbation theory code to compute the evolution of various cosmological matter and radiation components, both today and at high redshift. The code has been tested over a wide range of cosmological parameters.

This code is no longer supported; please investigate using CAMB (ascl:1102.026) instead.

[ascl:1109.009]
CMBquick: Spectrum and Bispectrum of Cosmic Microwave Background (CMB)

CMBquick is a package for Mathematica in which tools are provided to compute the spectrum and bispectrum of Cosmic Microwave Background (CMB). It is unavoidably slow, but the main goal is not to design a tool which can be used for systematic exploration of parameters in cosmology, but rather a toy CMB code which is transparent and easily modified. Considering this, the name chosen is nothing but a joke which refers to the widely spread and used softwares CMBFAST, CAMB or CMBeasy (ascl:1007.004), which should be used for serious and heavy first order CMB computations, and which are indeed very fast.

The package CMBquick is unavoidably slow when it comes to compute the multipoles Cls, and most of it is due to the access time for variables which in Mathematica is approximately ten times slower than in C or Fortran. CMBquick is thus approximately 10 times slower than CAMB and cannot be used for the same reasons. It uses the same method as CAMB for computing the CMB spectrum, which is based on the line of sight approach. However the integration is performed in a different gauge with different time steps and k-spacing. It benefits from the power of Mathematica on numerical resolution of stiff differential systems, and the transfer functions can be obtained with exquisite accuracy.

The purpose of CMBquick is thus twofold. First, CMBquick is a slow but precise and pedagogical, tool which can be used to explore and modify the physical content of the linear and non-linear dynamics. Second, it is a tool which can help developing templates for nonlinear computations, which could then be hard coded once their correctness is checked. The number of equations for non-linear dynamics is quite sizable and CMBquick makes it easy (but slow) to manipulate the non-linear equations, to solve them precisely, and to plot them.

[ascl:1112.011]
CMBview: A Mac OS X program for viewing HEALPix-format sky map data on a sphere

CMBview is a viewer for FITS files containing HEALPix sky maps. Sky maps are projected onto a 3d sphere which can be rotated and zoomed interactively with the mouse. Features include:

- rendering of the field of Stokes vectors

- ray-tracing mode in which each screen pixel is projected onto the sphere for high quality rendering

- control over sphere lighting

- export an arbitrarily large rendered texture

- variety of preset colormaps

[ascl:1611.020]
CMCIRSED: Far-infrared spectral energy distribution fitting for galaxies near and far

The Caitlin M. Casey Infra Red Spectral Energy Distribution model (CMCIRSED) provides a simple SED fitting technique suitable for a wide range of IR data, from sources which have only three IR photometric points to sources with >10 photometric points. These SED fits produce accurate estimates to a source's integrated IR luminosity, dust temperature and dust mass. CMCIRSED is based on a single dust temperature greybody fit linked to a MIR power law, fitted simultaneously to data across ∼5–2000 μm.

[ascl:1109.020]
CMFGEN: Probing the Universe through Spectroscopy

A radiative transfer code designed to solve the radiative transfer and statistical equilibrium equations in spherical geometry. It has been designed for application to W-R stars, O stars, and Luminous Blue-Variables. CMFGEN allows fundamental parameters such as effective temperatures, stellar radii and stellar luminosities to be determined. It can provide constraints on mass-loss rates, and allow abundance determinations for a wide range of atomic species. Further it can provide accurate energy distributions, and hence ionizing fluxes, which can be used as input for codes which model the spectra of HII regions and ring nebular.

[ascl:1101.005]
CMHOG: Code for Ideal Compressible Hydrodynamics

CMHOG (Connection Machine Higher Order Godunov) is a code for ideal compressible hydrodynamics based on the Lagrange-plus-remap version of the piecewise parabolic method (PPM) of Colella & Woodward (1984, J. Comp. Phys., 74, 1). It works in one-, two- or three-dimensional Cartesian coordinates with either an adiabatic or isothermal equation of state. A limited amount of extra physics has been added using operator splitting, including optically-thin radiative cooling, and chemistry for combustion simulations.

[ascl:1011.014]
CO5BOLD: COnservative COde for the COmputation of COmpressible COnvection in a BOx of L Dimensions with l=2,3

The code was supplemented with an (optional) MHD version [Schaffenberger et al. (2005)] that can treat magnetic fields. There are also modules for the formation and advection of dust available. The current version now contains the treatment of chemical reaction networks, mostly used for the formation of molecules [Wedemeyer-Böhm et al. (2005)], and hydrogen ionization [Leenaarts & Wedemeyer-Böhm (2005)], too.

Freytag, Bernd; Steffen, Matthias; Wedemeyer-Böhm, Sven; Ludwig, Hans-Günter; Leenaarts, Jorrit; Schaffenberger, Werner; Allard, France; Chiavassa, Andrea; Höfner, Susanne; Kamp, Inga; Steiner, Oskar

CO5BOLD - nickname COBOLD - is the short form of "COnservative COde for the COmputation of COmpressible COnvection in a BOx of L Dimensions with l=2,3''.

It is used to model solar and stellar surface convection. For solar-type stars only a small fraction of the stellar surface layers are included in the computational domain. In the case of red supergiants the computational box contains the entire star. Recently, the model range has been extended to sub-stellar objects (brown dwarfs).

CO5BOLD solves the coupled non-linear equations of compressible hydrodynamics in an external gravity field together with non-local frequency-dependent radiation transport. Operator splitting is applied to solve the equations of hydrodynamics (including gravity), the radiative energy transfer (with a long-characteristics or a short-characteristics ray scheme), and possibly additional 3D (turbulent) diffusion in individual sub steps. The 3D hydrodynamics step is further simplified with directional splitting (usually). The 1D sub steps are performed with a Roe solver, accounting for an external gravity field and an arbitrary equation of state from a table.

The radiation transport is computed with either one of three modules:

- MSrad module: It uses long characteristics. The lateral boundaries have to be periodic. Top and bottom can be closed or open ("solar module'').

- LHDrad module: It uses long characteristics and is restricted to an equidistant grid and open boundaries at all surfaces (old "supergiant module'').

- SHORTrad module: It uses short characteristics and is restricted to an equidistant grid and open boundaries at all surfaces (new "supergiant module'').

The code was supplemented with an (optional) MHD version [Schaffenberger et al. (2005)] that can treat magnetic fields. There are also modules for the formation and advection of dust available. The current version now contains the treatment of chemical reaction networks, mostly used for the formation of molecules [Wedemeyer-Böhm et al. (2005)], and hydrogen ionization [Leenaarts & Wedemeyer-Böhm (2005)], too.

CO5BOLD is written in Fortran90. The parallelization is done with OpenMP directives.

[ascl:1505.010]
COBS: COnstrained B-Splines

COBS (COnstrained B-Splines), written in R, creates constrained regression smoothing splines via linear programming and sparse matrices. The method has two important features: the number and location of knots for the spline fit are established using the likelihood-based Akaike Information Criterion (rather than a heuristic procedure); and fits can be made for quantiles (e.g. 25% and 75% as well as the usual 50%) in the response variable, which is valuable when the scatter is asymmetrical or non-Gaussian. This code is useful for, for example, estimating cluster ages when there is a wide spread in stellar ages at a chosen absorption, as a standard regression line does not give an effective measure of this relationship.

[ascl:1406.017]
COCO: Conversion of Celestial Coordinates

The COCO program converts star coordinates from one system to another. Both the improved IAU system, post-1976, and the old pre-1976 system are supported. COCO can perform accurate transformations between multiple coordinate systems. COCO’s user-interface is spartan but efficient and the program offers control over report resolution. All input is free-format, and defaults are provided where this is meaningful. COCO uses SLALIB (ascl:1403.025) and is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1703.002]
COCOA: Simulating Observations of Star Cluster Simulations

COCOA (Cluster simulatiOn Comparison with ObservAtions) creates idealized mock photometric observations using results from numerical simulations of star cluster evolution. COCOA is able to present the output of realistic numerical simulations of star clusters carried out using Monte Carlo or N-body codes in a way that is useful for direct comparison with photometric observations. The code can simulate optical observations from simulation snapshots in which positions and magnitudes of objects are known. The parameters for simulating the observations can be adjusted to mimic telescopes of various sizes. COCOA also has a photometry pipeline that can use standalone versions of DAOPHOT (ascl:1104.011) and ALLSTAR to produce photometric catalogs for all observed stars.

[ascl:1202.012]
CoCoNuT: General relativistic hydrodynamics code with dynamical space-time evolution

CoCoNuT is a general relativistic hydrodynamics code with dynamical space-time evolution. The main aim of this numerical code is the study of several astrophysical scenarios in which general relativity can play an important role, namely the collapse of rapidly rotating stellar cores and the evolution of isolated neutron stars. The code has two flavors: CoCoA, the axisymmetric (2D) magnetized version, and CoCoNuT, the 3D non-magnetized version.

[ascl:1602.021]
COLAcode: COmoving Lagrangian Acceleration code

COLAcode is a serial particle mesh-based N-body code illustrating the COLA (COmoving Lagrangian Acceleration) method; it solves for Large Scale Structure (LSS) in a frame that is comoving with observers following trajectories calculated in Lagrangian Perturbation Theory (LPT). It differs from standard N-body code by trading accuracy at small-scales to gain computational speed without sacrificing accuracy at large scales. This is useful for generating large ensembles of accurate mock halo catalogs required to study galaxy clustering and weak lensing; such catalogs are needed to perform detailed error analysis for ongoing and future surveys of LSS.

[ascl:1802.014]
collapse: Spherical-collapse model code

collapse calculates the spherical−collapse for standard cosmological models as well as for dark energy models when the dark energy can be taken to be spatially homogeneous. The calculation is valid on sub−horizon scales and takes a top−hat perturbation to exist in an otherwise featureless cosmos and follows its evolution into the non−linear regime where it reaches a maximum size and then recollapses. collapse provides the user with the linear−collapse threshold (delta_c) and the virial overdensity (Delta_v) for the collapsed halo over a range of cosmic scale factors.

[ascl:1508.005]
ColorPro: PSF-corrected aperture-matched photometry

ColorPro automatically obtains robust colors across images of varied PSF. To correct for the flux lost in images with poorer PSF, the "detection image" is blurred to match the PSF of these other images, allowing observation of how much flux is lost. All photometry is performed in the highest resolution frame (images being aligned given WCS information in the FITS headers), and identical apertures are used in every image. Usually isophotal apertures are used, as determined by SExtractor (ascl:1010.064). Using SExSeg (ascl:1508.006), object aperture definitions can be pre-defined and object detections from different image filters can be combined automatically into a single comprehensive "segmentation map." After producing the final photometric catalog, ColorPro can automatically run BPZ (ascl:1108.011) to obtain Bayesian Photometric Redshifts.

[ascl:1501.016]
Colossus: COsmology, haLO, and large-Scale StrUcture toolS

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

[ascl:1606.007]
COMB: Compact embedded object simulations

COMB supports the simulation on the sphere of compact objects embedded in a stochastic background process of specified power spectrum. Support is provided to add additional white noise and convolve with beam functions. Functionality to support functions defined on the sphere is provided by the S2 code (ascl:1606.008); HEALPix (ascl:1107.018) and CFITSIO (ascl:1010.001) are also required.

[ascl:1708.024]
ComEst: Completeness Estimator

ComEst calculates the completeness of CCD images conducted in astronomical observations saved in the FITS format. It estimates the completeness of the source finder SExtractor (ascl:1010.064) on the optical and near-infrared (NIR) imaging of point sources or galaxies as a function of flux (or magnitude) directly from the image itself. It uses PyFITS (ascl:1207.009) and GalSim (ascl:1402.009) to perform the end-to-end estimation of the completeness and can also estimate the purity of the source detection.

[ascl:1404.008]
Comet: Multifunction VOEvent broker

Comet is a Python implementation of the VOEvent Transport Protocol (VTP). VOEvent is the IVOA system for describing transient celestial events. Details of transients detected by many projects, including Fermi, Swift, and the Catalina Sky Survey, are currently made available as VOEvents, which is also the standard alert format by future facilities such as LSST and SKA. The core of Comet is a multifunction VOEvent broker, capable of receiving events either by subscribing to one or more remote brokers or by direct connection from authors; it can then both process those events locally and forward them to its own subscribers. In addition, Comet provides a tool for publishing VOEvents to the global VOEvent backbone.

[ascl:1402.028]
Commander 2: Bayesian CMB component separation and analysis

Bull, Phil; Eriksen, Hans Kristian; Gjerløw, Eirik; Gorski, Krzysztof; Jewell, Jeff; Seljebotn, Dag Sverre; Wehus, Ingunn

Commander 2 is a Gibbs sampling code for joint CMB estimation and component separation. The Commander framework uses a parametrized physical model of the sky to perform statistically-rigorous analyses of multi-frequency, multi-resolution CMB data on the full and partial (flat) sky, as well as cross-correlation analyses with large-scale structure datasets.

[ascl:1606.009]
Companion-Finder: Planets and binary companions in time series spectra

Companion-Finder looks for planets and binary companions in time series spectra by searching for the spectral lines of stellar companions to other stars observed with high-precision radial-velocity surveys.

[ascl:1403.015]
computePk: Power spectrum computation

ComputePk computes the power spectrum in cosmological simulations. It is MPI parallel and has been tested up to a 4096^3 mesh. It uses the FFTW library. It can read Gadget-3 and GOTPM outputs, and computes the dark matter component. The user may choose between NGP, CIC, and TSC for the mass assignment scheme.

[ascl:1210.011]
Consistent Trees: Gravitationally Consistent Halo Catalogs and Merger Trees for Precision Cosmology

Behroozi, Peter S.; Wechsler, Risa H.; Wu, Hao-Yi; Busha, Michael T.; Klypin, Anatoly A.; Primack, Joel R.

Consistent Trees generates merger trees and halo catalogs which explicitly ensure consistency of halo properties (mass, position, velocity, radius) across timesteps. It has demonstrated the ability to improve both the completeness (through detecting and inserting otherwise missing halos) and purity (through detecting and removing spurious objects) of both merger trees and halo catalogs. Consistent Trees is able to robustly measure the self-consistency of halo finders and to directly measure the uncertainties in halo positions, halo velocities, and the halo mass function for a given halo finder based on consistency between snapshots in cosmological simulations.

[ascl:9905.001]
CONSKY: A Sky CCD Integration Simulation

This program addresses the question of what resources are needed to produce a continuous data record of the entire sky down to a given limiting visual magnitude. Toward this end, the program simulates a small camera/telescope or group of small camera/telescopes collecting light from a large portion of the sky. From a given stellar density derived from a Bahcall - Soneira Galaxy model, the program first converts star densities at visual magnitudes between 5 and 20 to number of sky pixels needed to monitor each star simultaneously. From pixels, the program converts input CCD parameters to needed telescope attributes, needed data storage space, and the length of time needed to accumulate data of photometric quality for stars of each limiting visual magnitude over the whole sky. The program steps though photometric integrations one second at a time and includes the contribution from a bright background, read noise, dark current, and atmospheric absorption.

[ascl:1609.023]
contbin: Contour binning and accumulative smoothing

Contbin bins X-ray data using contours on an adaptively smoothed map. The generated bins closely follow the surface brightness, and are ideal where the surface brightness distribution is not smooth, or the spectral properties are expected to follow surface brightness. Color maps can be used instead of surface brightness maps.

[ascl:1401.006]
convolve_image.pro: Common-Resolution Convolution Kernels for Space- and Ground-Based Telescopes

The IDL package convolve_image.pro transforms images between different instrumental point spread functions (PSFs). It can load an image file and corresponding kernel and return the convolved image, thus preserving the colors of the astronomical sources. Convolution kernels are available for images from Spitzer (IRAC MIPS), Herschel (PACS SPIRE), GALEX (FUV NUV), WISE (W1 - W4), Optical PSFs (multi- Gaussian and Moffat functions), and Gaussian PSFs; they allow the study of the Spectral Energy Distribution (SED) of extended objects and preserve the characteristic SED in each pixel.

[ascl:1210.013]
ConvPhot: A profile-matching algorithm for precision photometry

ConvPhot measures colors between two images having different resolutions. ConvPhot is designed to work especially for faint galaxies, accurately measuring colors in relatively crowded fields. It makes full use of the spatial and morphological information contained in the highest quality images to analyze multiwavelength data with inhomogeneous image quality.

[ascl:1304.022]
Copter: Cosmological perturbation theory

Copter is a software package for doing calculations in cosmological perturbation theory. Specifically, Copter includes code for computing statistical observables in the large-scale structure of matter using various forms of perturbation theory, including linear theory, standard perturbation theory, renormalized perturbation theory, and many others. Copter is written in C++ and makes use of the Boost C++ library headers.

[ascl:1112.012]
CORA: Emission Line Fitting with Maximum Likelihood

CORA analyzes emission line spectra with low count numbers and fits them to a line using the maximum likelihood technique. CORA uses a rigorous application of Poisson statistics. From the assumption of Poissonian noise, the software derives the probability for a model of the emission line spectrum to represent the measured spectrum. The likelihood function is used as a criterion for optimizing the parameters of the theoretical spectrum and a fixed point equation is derived allowing an efficient way to obtain line fluxes. CORA has been applied to an X-ray spectrum with the Low Energy Transmission Grating Spectrometer (LETGS) on board the Chandra observatory.

[ascl:1603.002]
CORBITS: Efficient Geometric Probabilities of Multi-Transiting Exoplanetary Systems

CORBITS (Computed Occurrence of Revolving Bodies for the Investigation of Transiting Systems) computes the probability that any particular group of exoplanets can be observed to transit from a collection of conjectured exoplanets orbiting a star. The efficient, semi-analytical code computes the areas bounded by circular curves on the surface of a sphere by applying elementary differential geometry. CORBITS is faster than previous algorithms, based on comparisons with Monte Carlo simulations, and tests show that it is extremely accurate even for highly eccentric planets.

[submitted]
Core Cosmology Library

Chisari, Nora Elisa; Alonso, David; Krause, Elisabeth; Leonard, C. Daniellle; Bull, Philip; Neveu, Jérémy; Villarreal, Antonio; Singh, Sukhdeep; McClintock, Thomas; Ellison, John; Du, Zilong; Zuntz, Joe; Mead, Alexander; Joudaki, Shahab; Lorenz, Christiane S.; Troester, Tilman; Sanchez, Javier; Lanusse, Francois; Ishak, Mustapha; Hlozek, Renée; Blazek, Jonathan; Campagne, Jean-Eric; Almoubayyed, Husni; Eifler, Tim; Kirby, Matthew; Kirkby, David; Plaszczynski, Stéphane; Slosar, Anze; Vrastil, Michal; Wagoner, Erika L. (The LSST Dark Energy Science Collaboration)

The Core Cosmology Library (CCL) provides routines to compute basic cosmological observables to a high degree of accuracy, which have been verified with an extensive suite of validation tests. Predictions are provided for many cosmological quantities, including distances, angular power spectra, correlation functions, halo bias and the halo mass function through state-of-the-art modeling prescriptions available in the literature. Fiducial specifications for the expected galaxy distributions for the Large Synoptic Survey Telescope (LSST) are also included, together with the capability of computing redshift distributions for a user-defined photometric redshift model. A rigorous validation procedure, based on comparisons between CCL and independent software packages, allows us to establish a well-defined numerical accuracy for each predicted quantity. As a result, predictions for correlation functions of galaxy clustering, galaxy-galaxy lensing and cosmic shear are demonstrated to be within a fraction of the expected statistical uncertainty of the observables for the models and in the range of scales of interest to LSST. CCL is an open source software package written in C, with a python interface and publicly available at https://github.com/LSSTDESC/CCL.

[ascl:1406.003]
CoREAS: CORSIKA-based Radio Emission from Air Showers simulator

CoREAS is a Monte Carlo code for the simulation of radio emission from extensive air showers; it is an update of and successor code to REAS3 (ascl:1107.009). It implements the endpoint formalism for the calculation of electromagnetic radiation directly in CORSIKA (ascl:1202.006). As such, it is parameter-free, makes no assumptions on the emission mechanism for the radio signals, and takes into account the complete complexity of the electron and positron distributions as simulated by CORSIKA.

[ascl:1702.002]
corner.py: Corner plots

*corner.py* uses matplotlib to visualize multidimensional samples using a scatterplot matrix. In these visualizations, each one- and two-dimensional projection of the sample is plotted to reveal covariances. *corner.py* was originally conceived to display the results of Markov Chain Monte Carlo simulations and the defaults are chosen with this application in mind but it can be used for displaying many qualitatively different samples. An earlier version of *corner.py* was known as triangle.py.

[ascl:1711.005]
correlcalc: Two-point correlation function from redshift surveys

correlcalc calculates two-point correlation function (2pCF) of galaxies/quasars using redshift surveys. It can be used for any assumed geometry or Cosmology model. Using BallTree algorithms to reduce the computational effort for large datasets, it is a parallelised code suitable for running on clusters as well as personal computers. It takes redshift (z), Right Ascension (RA) and Declination (DEC) data of galaxies and random catalogs as inputs in form of ascii or fits files. If random catalog is not provided, it generates one of desired size based on the input redshift distribution and mangle polygon file (in .ply format) describing the survey geometry. It also calculates different realisations of (3D) anisotropic 2pCF. Optionally it makes healpix maps of the survey providing visualization.

[ascl:1211.004]
CORRFIT: Cross-Correlation Routines

CORRFIT is a set of routines that use the cross-correlation method to extract parameters of the line-of-sight velocity distribution from galactic spectra and stellar templates observed on the same system. It works best when the broadening function is well sampled at the spectral resolution used (e.g. 200 km/s dispersion at 2 Angstrom resolution). Results become increasingly sensitive to the spectral match between galaxy and template if the broadening function is not well sampled. CORRFIT does not work well for dispersions less than the velocity sampling interval ('delta' in the code) unless the template is perfect.

[ascl:1703.003]
Corrfunc: Blazing fast correlation functions on the CPU

Corrfunc is a suite of high-performance clustering routines. The code can compute a variety of spatial correlation functions on Cartesian geometry as well Landy-Szalay calculations for spatial and angular correlation functions on a spherical geometry and is useful for, for example, exploring the galaxy-halo connection. The code is written in C and can be used on the command-line, through the supplied python extensions, or the C API.

[ascl:1202.006]
CORSIKA: An Air Shower Simulation Program

CORSIKA (COsmic Ray Simulations for KAscade) is a program for detailed simulation of extensive air showers initiated by high energy cosmic ray particles. Protons, light nuclei up to iron, photons, and many other particles may be treated as primaries. The particles are tracked through the atmosphere until they undergo reactions with the air nuclei or, in the case of unstable secondaries, decay. The hadronic interactions at high energies may be described by several reaction models. Hadronic interactions at lower energies are described, and in particle decays all decay branches down to the 1% level are taken into account. Options for the generation of Cherenkov radiation and neutrinos exist. CORSIKA may be used up to and beyond the highest energies of 100 EeV.

[ascl:1712.008]
CosApps: Simulate gravitational lensing through ray tracing and shear calculation

Cosmology Applications (CosApps) provides tools to simulate gravitational lensing using two different techniques, ray tracing and shear calculation. The tool ray_trace_ellipse calculates deflection angles on a grid for light passing a deflecting mass distribution. Using MPI, ray_trace_ellipse may calculate deflection in parallel across network connected computers, such as cluster. The program physcalc calculates the gravitational lensing shear using the relationship of convergence and shear, described by a set of coupled partial differential equations.

[ascl:1010.040]
Cosmic String Simulations

Complicated cosmic string loops will fragment until they reach simple, non-intersecting ("stable") configurations. Through extensive numerical study, these attractor loop shapes are characterized including their length, velocity, kink, and cusp distributions. An initial loop containing $M$ harmonic modes will, on average, split into 3M stable loops. These stable loops are approximately described by the degenerate kinky loop, which is planar and rectangular, independently of the number of modes on the initial loop. This is confirmed by an analytic construction of a stable family of perturbed degenerate kinky loops. The average stable loop is also found to have a 40% chance of containing a cusp. This new analytic scheme explicitly solves the string constraint equations.

[ascl:1010.030]
CosmicEmu: Cosmic Emulator for the Dark Matter Power Spectrum

Lawrence, Earl; Heitmann, Katrin; White, Martin; Higdon, David; Wagner, Christian; Habib, Salman; Williams, Brian

Many of the most exciting questions in astrophysics and cosmology, including the majority of observational probes of dark energy, rely on an understanding of the nonlinear regime of structure formation. In order to fully exploit the information available from this regime and to extract cosmological constraints, accurate theoretical predictions are needed. Currently such predictions can only be obtained from costly, precision numerical simulations. The "Coyote Universe'' simulation suite comprises nearly 1,000 N-body simulations at different force and mass resolutions, spanning 38 wCDM cosmologies. This large simulation suite enabled construct of a prediction scheme, or emulator, for the nonlinear matter power spectrum accurate at the percent level out to k~1 h/Mpc. This is the first cosmic emulator for the dark matter power spectrum.

[ascl:1304.006]
CosmicEmuLog: Cosmological Power Spectra Emulator

CosmicEmuLog is a simple Python emulator for cosmological power spectra. In addition to the power spectrum of the conventional overdensity field, it emulates the power spectra of the log-density as well as the Gaussianized density. It models fluctuations in the power spectrum at each k as a linear combination of contributions from fluctuations in each cosmological parameter. The data it uses for emulation consist of ASCII files of the mean power spectrum, together with derivatives of the power spectrum with respect to the five cosmological parameters in the space spanned by the Coyote Universe suite. This data can also be used for Fisher matrix analysis. At present, CosmicEmuLog is restricted to redshift 0.

[ascl:1601.008]
CosmicPy: Interactive cosmology computations

CosmicPy performs simple and interactive cosmology computations for forecasting cosmological parameters constraints; it computes tomographic and 3D Spherical Fourier-Bessel power spectra as well as Fisher matrices for galaxy clustering. Written in Python, it relies on a fast C++ implementation of Fourier-Bessel related computations, and requires NumPy, SciPy, and Matplotlib.

[ascl:9910.004]
COSMICS: Cosmological initial conditions and microwave anisotropy codes

COSMICS is a package of Fortran programs useful for computing transfer functions and microwave background anisotropy for cosmological models, and for generating gaussian random initial conditions for nonlinear structure formation simulations of such models. Four programs are provided: linger_con and linger_syn integrate the linearized equations of general relativity, matter, and radiation in conformal Newtonian and synchronous gauge, respectively; deltat integrates the photon transfer functions computed by the linger codes to produce photon anisotropy power spectra; and grafic tabulates normalized matter power spectra and produces constrained or unconstrained samples of the matter density field.

[ascl:1505.013]
cosmoabc: Likelihood-free inference for cosmology

Ishida, Emille E. O.; Vitenti, Sandro D. P.; Penna-Lima, Mariana; Trindade, Arlindo M.; Cisewski, Jessi; M.; de Souza, Rafael; Cameron, Ewan; Busti, Vinicius C.

Approximate Bayesian Computation (ABC) enables parameter inference for complex physical systems in cases where the true likelihood function is unknown, unavailable, or computationally too expensive. It relies on the forward simulation of mock data and comparison between observed and synthetic catalogs. cosmoabc is a Python Approximate Bayesian Computation (ABC) sampler featuring a Population Monte Carlo variation of the original ABC algorithm, which uses an adaptive importance sampling scheme. The code can be coupled to an external simulator to allow incorporation of arbitrary distance and prior functions. When coupled with the numcosmo library, it has been used to estimate posterior probability distributions over cosmological parameters based on measurements of galaxy clusters number counts without computing the likelihood function.

[ascl:1511.019]
CosmoBolognaLib: Open source C++ libraries for cosmological calculations

CosmoBolognaLib contains numerical libraries for cosmological calculations; written in C++, it is intended to define a common numerical environment for cosmological investigations of the large-scale structure of the Universe. The software aids in handling real and simulated astronomical catalogs by measuring one-point, two-point and three-point statistics in configuration space and performing cosmological analyses. These open source libraries can be included in either C++ or Python codes.

[ascl:1303.003]
CosmoHammer: Cosmological parameter estimation with the MCMC Hammer

CosmoHammer is a Python framework for the estimation of cosmological parameters. The software embeds the Python package emcee by Foreman-Mackey et al. (2012) and gives the user the possibility to plug in modules for the computation of any desired likelihood. The major goal of the software is to reduce the complexity when one wants to extend or replace the existing computation by modules which fit the user's needs as well as to provide the possibility to easily use large scale computing environments. CosmoHammer can efficiently distribute the MCMC sampling over thousands of cores on modern cloud computing infrastructure.

[ascl:1110.024]
CosmoMC SNLS: CosmoMC Plug-in to Analyze SNLS3 SN Data

This module is a plug-in for CosmoMC and requires that software. Though programmed to analyze SNLS3 SN data, it can also be used for other SN data provided the inputs are put in the right form. In fact, this is probably a good idea, since the default treatment that comes with CosmoMC is flawed. Note that this requires fitting two additional SN nuisance parameters (alpha and beta), but this is significantly faster than attempting to marginalize over them internally.

[ascl:1106.025]
CosmoMC: Cosmological MonteCarlo

We present a fast Markov Chain Monte-Carlo exploration of cosmological parameter space. We perform a joint analysis of results from recent CMB experiments and provide parameter constraints, including sigma_8, from the CMB independent of other data. We next combine data from the CMB, HST Key Project, 2dF galaxy redshift survey, supernovae Ia and big-bang nucleosynthesis. The Monte Carlo method allows the rapid investigation of a large number of parameters, and we present results from 6 and 9 parameter analyses of flat models, and an 11 parameter analysis of non-flat models. Our results include constraints on the neutrino mass (m_nu < 0.3eV), equation of state of the dark energy, and the tensor amplitude, as well as demonstrating the effect of additional parameters on the base parameter constraints. In a series of appendices we describe the many uses of importance sampling, including computing results from new data and accuracy correction of results generated from an approximate method. We also discuss the different ways of converting parameter samples to parameter constraints, the effect of the prior, assess the goodness of fit and consistency, and describe the use of analytic marginalization over normalization parameters.

[ascl:1110.019]
CosmoNest: Cosmological Nested Sampling

CosmoNest is an algorithm for cosmological model selection. Given a model, defined by a set of parameters to be varied and their prior ranges, and data, the algorithm computes the evidence (the marginalized likelihood of the model in light of the data). The Bayes factor, which is proportional to the relative evidence of two models, can then be used for model comparison, i.e. to decide whether a model is an adequate description of data, or whether the data require a more complex model.

For convenience, CosmoNest, programmed in Fortran, is presented here as an optional add-on to CosmoMC, which is widely used by the cosmological community to perform parameter fitting within a model using a Markov-Chain Monte-Carlo (MCMC) engine. For this reason it can be run very easily by anyone who is able to compile and run CosmoMC. CosmoNest implements a different sampling strategy, geared for computing the evidence very accurately and efficiently. It also provides posteriors for parameter fitting as a by-product.

[ascl:1408.018]
CosmoPhotoz: Photometric redshift estimation using generalized linear models

de Souza, Rafael S.; Elliott, Jonathan; Krone-Martins, Alberto; Ishida, Emille E. O.; Hilbe, Joseph; Cameron, Ewan

CosmoPhotoz determines photometric redshifts from galaxies utilizing their magnitudes. The method uses generalized linear models which reproduce the physical aspects of the output distribution. The code can adopt gamma or inverse gaussian families, either from a frequentist or a Bayesian perspective. A set of publicly available libraries and a web application are available. This software allows users to apply a set of GLMs to their own photometric catalogs and generates publication quality plots with no involvement from the user. The code additionally provides a Shiny application providing a simple user interface.

[ascl:1212.006]
CosmoPMC: Cosmology sampling with Population Monte Carlo

Kilbinger, Martin; Benabed, Karim; Cappé, Olivier; Coupon, Jean; Cardoso, Jean-François; Fort, Gersende; McCracken, Henry Joy; Prunet, Simon; Robert, Christian P.; Wraith, Darren

CosmoPMC is a Monte-Carlo sampling method to explore the likelihood of various cosmological probes. The sampling engine is implemented with the package pmclib. It is called Population MonteCarlo (PMC), which is a novel technique to sample from the posterior. PMC is an adaptive importance sampling method which iteratively improves the proposal to approximate the posterior. This code has been introduced, tested and applied to various cosmology data sets.

[ascl:1304.017]
CosmoRec: Cosmological Recombination code

CosmoRec solves the recombination problem including recombinations to highly excited states, corrections to the 2s-1s two-photon channel, HI Lyn-feedback, n>2 two-photon profile corrections, and n≥2 Raman-processes. The code can solve the radiative transfer equation of the Lyman-series photon field to obtain the required modifications to the rate equations of the resolved levels, and handles electron scattering, the effect of HeI intercombination transitions, and absorption of helium photons by hydrogen. It also allows accounting for dark matter annihilation and optionally includes detailed helium radiative transfer effects.

[ascl:1705.001]
COSMOS: Carnegie Observatories System for MultiObject Spectroscopy

COSMOS (Carnegie Observatories System for MultiObject Spectroscopy) reduces multislit spectra obtained with the IMACS and LDSS3 spectrographs on the Magellan Telescopes. It can be used for the quick-look analysis of data at the telescope as well as for pipeline reduction of large data sets. COSMOS is based on a precise optical model of the spectrographs, which allows (after alignment and calibration) an accurate prediction of the location of spectra features. This eliminates the line search procedure which is fundamental to many spectral reduction programs, and allows a robust data pipeline to be run in an almost fully automatic mode, allowing large amounts of data to be reduced with minimal intervention.

[ascl:1409.012]
CosmoSIS: Cosmological parameter estimation

Zuntz, Joe; Paterno, Marc; Jennings, Elise; Rudd, Douglas; Manzotti, Alessandro; Dodelson, Scott; Bridle, Sarah; Sehrish, Saba; Kowalkowski, James

CosmoSIS is a cosmological parameter estimation code. It structures cosmological parameter estimation to ease re-usability, debugging, verifiability, and code sharing in the form of calculation modules. Witten in python, CosmoSIS consolidates and connects existing code for predicting cosmic observables and maps out experimental likelihoods with a range of different techniques.

[ascl:1701.004]
CosmoSlik: Cosmology sampler of likelihoods

CosmoSlik quickly puts together, runs, and analyzes an MCMC chain for analysis of cosmological data. It is highly modular and comes with plugins for CAMB (ascl:1102.026), CLASS (ascl:1106.020), the Planck likelihood, the South Pole Telescope likelihood, other cosmological likelihoods, emcee (ascl:1303.002), and more. It offers ease-of-use, flexibility, and modularity.

[ascl:1311.009]
CosmoTherm: Thermalization code

CosmoTherm allows precise computation of CMB spectral distortions caused by energy release in the early Universe. Different energy-release scenarios (e.g., decaying or annihilating particles) are implemented using the Green's function of the cosmological thermalization problem, allowing fast computation of the distortion signal. The full thermalization problem can be solved on a case-by-case basis for a wide range of energy-release scenarios using the full PDE solver of CosmoTherm. A simple Monte-Carlo toolkit is included for parameter estimation and forecasts using the Green's function method.

[ascl:1504.010]
CosmoTransitions: Cosmological Phase Transitions

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

[ascl:1307.010]
cosmoxi2d: Two-point galaxy correlation function calculation

Cosmoxi2d is written in C and computes the theoretical two-point galaxy correlation function as a function of cosmological and galaxy nuisance parameters. It numerically evaluates the model described in detail in Reid and White 2011 (arxiv:1105.4165) and Reid et al. 2012 (arxiv:1203.6641) for the multipole moments (up to ell = 4) for the observed redshift space correlation function of biased tracers as a function of cosmological (though an input linear matter power spectrum, growth rate f, and Alcock-Paczynski geometric factors alphaperp and alphapar) as well as nuisance parameters describing the tracers (bias and small scale additive velocity dispersion, isotropicdisp1d).

This model works best for highly biased tracers where the 2nd order bias term is small. On scales larger than 100 Mpc, the code relies on 2nd order Lagrangian Perturbation theory as detailed in Matsubara 2008 (PRD 78, 083519), and uses the analytic version of Reid and White 2011 on smaller scales.

[ascl:1512.013]
CounterPoint: Zeeman-split absorption lines

CounterPoint works in concert with MoogStokes (ascl:1308.018). It applies the Zeeman effect to the atomic lines in the region of study, splitting them into the correct number of Zeeman components and adjusting their relative intensities according to the predictions of Quantum Mechanics, and finally creates a Moog-readable line list for use with MoogStokes. CounterPoint has the ability to use VALD and HITRAN line databases for both atomic and molecular lines.

[ascl:1808.003]
CPF: Corral Pipeline Framework

Cabral, Juan; Sanchez, Bruno; Beroiz, Martin; Dominguez, Mariano; Lares, Marcelo; Gurovich, Sebastian; Granitto, Pablo

Corral generates astronomical pipelines. Data processing pipelines represent an important slice of the astronomical software library that include chains of processes that transform raw data into valuable information via data reduction and analysis. Written in Python, Corral features a Model-View-Controller design pattern on top of an SQL Relational Database capable of handling custom data models, processing stages, and communication alerts. It also provides automatic quality and structural metrics based on unit testing. The Model-View-Controller provides concept separation between the user logic and the data models, delivering at the same time multi-processing and distributed computing capabilities.

[ascl:1402.010]
CPL: Common Pipeline Library

The Common Pipeline Library (CPL) is a set of ISO-C libraries that provide a comprehensive, efficient and robust software toolkit to create automated astronomical data reduction pipelines. Though initially developed as a standardized way to build VLT instrument pipelines, the CPL may be more generally applied to any similar application. The code also provides a variety of general purpose image- and signal-processing functions, making it an excellent framework for the creation of more generic data handling packages. The CPL handles low-level data types (images, tables, matrices, strings, property lists, etc.) and medium-level data access methods (a simple data abstraction layer for FITS files). It also provides table organization and manipulation, keyword/value handling and management, and support for dynamic loading of recipe modules using programs such as EsoRex (ascl:1504.003).

[ascl:1710.009]
CppTransport: Two- and three-point function transport framework for inflationary cosmology

CppTransport solves the 2- and 3-point functions of the perturbations produced during an inflationary epoch in the very early universe. It is implemented for models with canonical kinetic terms, although the underlying method is quite general and could be scaled to handle models with a non-trivial field-space metric or an even more general non-canonical Lagrangian.

[ascl:1102.012]
CPROPS: Bias-free Measurement of Giant Molecular Cloud Properties

CPROPS, written in IDL, processes FITS data cubes containing molecular line emission and returns the properties of molecular clouds contained within it. Without corrections for the effects of beam convolution and sensitivity to GMC properties, the resulting properties may be severely biased. This is particularly true for extragalactic observations, where resolution and sensitivity effects often bias measured values by 40% or more. We correct for finite spatial and spectral resolutions with a simple deconvolution and we correct for sensitivity biases by extrapolating properties of a GMC to those we would expect to measure with perfect sensitivity. The resulting method recovers the properties of a GMC to within 10% over a large range of resolutions and sensitivities, provided the clouds are marginally resolved with a peak signal-to-noise ratio greater than 10. We note that interferometers systematically underestimate cloud properties, particularly the flux from a cloud. The degree of bias depends on the sensitivity of the observations and the (u,v) coverage of the observations. In the Appendix to the paper we present a conservative, new decomposition algorithm for identifying GMCs in molecular-line observations. This algorithm treats the data in physical rather than observational units, does not produce spurious clouds in the presence of noise, and is sensitive to a range of morphologies. As a result, the output of this decomposition should be directly comparable among disparate data sets.

The CPROPS package contains within it a distribution of the CLUMPFIND code written by Jonathan Williams and described in Williams, de Geus, and Blitz(1994). The package is available as a stand alone package. If you make use of the CLUMPFIND functionality in the CPROPS package for a publication, please cite Jonathan's original article.

[ascl:1101.008]
CRASH: A Block-Adaptive-Mesh Code for Radiative Shock Hydrodynamics

van der Holst, B.; Toth, G.; Sokolov, I. V.; Powell, K. G.; Holloway, J. P.; Myra, E. S.; Stout, Q.; Adams, M. L.; Morel, J. E.; Drake, R. P.

We describe the CRASH (Center for Radiative Shock Hydrodynamics) code, a block adaptive mesh code for multi-material radiation hydrodynamics. The implementation solves the radiation diffusion model with the gray or multigroup method and uses a flux limited diffusion approximation to recover the free-streaming limit. The electrons and ions are allowed to have different temperatures and we include a flux limited electron heat conduction. The radiation hydrodynamic equations are solved in the Eulerian frame by means of a conservative finite volume discretization in either one, two, or three-dimensional slab geometry or in two-dimensional cylindrical symmetry. An operator split method is used to solve these equations in three substeps: (1) solve the hydrodynamic equations with shock-capturing schemes, (2) a linear advection of the radiation in frequency-logarithm space, and (3) an implicit solve of the stiff radiation diffusion, heat conduction, and energy exchange. We present a suite of verification test problems to demonstrate the accuracy and performance of the algorithms. The CRASH code is an extension of the Block-Adaptive Tree Solarwind Roe Upwind Scheme (BATS-R-US) code with this new radiation transfer and heat conduction library and equation-of-state and multigroup opacity solvers. Both CRASH and BATS-R-US are part of the publicly available Space Weather Modeling Framework (SWMF).

[ascl:1111.002]
CRBLASTER: A Parallel-Processing Computational Framework for Embarrassingly-Parallel Image-Analysis Algorithms

The development of parallel-processing image-analysis codes is generally a challenging task that requires complicated choreography of interprocessor communications. If, however, the image-analysis algorithm is embarrassingly parallel, then the development of a parallel-processing implementation of that algorithm can be a much easier task to accomplish because, by definition, there is little need for communication between the compute processes. I describe the design, implementation, and performance of a parallel-processing image-analysis application, called CRBLASTER, which does cosmic-ray rejection of CCD (charge-coupled device) images using the embarrassingly-parallel L.A.COSMIC algorithm. CRBLASTER is written in C using the high-performance computing industry standard Message Passing Interface (MPI) library. The code has been designed to be used by research scientists who are familiar with C as a parallel-processing computational framework that enables the easy development of parallel-processing image-analysis programs based on embarrassingly-parallel algorithms. The CRBLASTER source code is freely available at the official application website at the National Optical Astronomy Observatory. Removing cosmic rays from a single 800x800 pixel Hubble Space Telescope WFPC2 image takes 44 seconds with the IRAF script lacos_im.cl running on a single core of an Apple Mac Pro computer with two 2.8-GHz quad-core Intel Xeon processors. CRBLASTER is 7.4 times faster processing the same image on a single core on the same machine. Processing the same image with CRBLASTER simultaneously on all 8 cores of the same machine takes 0.875 seconds -- which is a speedup factor of 50.3 times faster than the IRAF script. A detailed analysis is presented of the performance of CRBLASTER using between 1 and 57 processors on a low-power Tilera 700-MHz 64-core TILE64 processor.

[ascl:1308.009]
CReSyPS: Stellar population synthesis code

CReSyPS (Code Rennais de Synthèse de Populations Stellaires) is a stellar population synthesis code that determines core overshooting amount for Magellanic clouds main sequence stars.

[ascl:1612.009]
CRETE: Comet RadiativE Transfer and Excitation

CRETE (Comet RadiativE Transfer and Excitation) is a one-dimensional water excitation and radiation transfer code for sub-millimeter wavelengths based on the RATRAN code (ascl:0008.002). The code considers rotational transitions of water molecules given a Haser spherically symmetric distribution for the cometary coma and produces FITS image cubes that can be analyzed with tools like MIRIAD (ascl:1106.007). In addition to collisional processes to excite water molecules, the effect of infrared radiation from the Sun is approximated by effective pumping rates for the rotational levels in the ground vibrational state.

[ascl:1708.003]
CRISPRED: CRISP imaging spectropolarimeter data reduction pipeline

CRISPRED reduces data from the CRISP imaging spectropolarimeter at the Swedish 1 m Solar Telescope (SST). It performs fitting routines, corrects optical aberrations from atmospheric turbulence as well as from the optics, and compensates for inter-camera misalignments, field-dependent and time-varying instrumental polarization, and spatial variation in the detector gain and in the zero level offset (bias). It has an object-oriented IDL structure with computationally demanding routines performed in C subprograms called as dynamically loadable

modules (DLMs).

[ascl:1110.020]
CROSS_CMBFAST: ISW-correlation Code

This code is an extension of CMBFAST4.5.1 to compute the ISW-correlation power spectrum and the 2-point angular ISW-correlation function for a given galaxy window function. It includes dark energy models specified by a constant equation of state (w) or a linear parameterization in the scale factor (w0,wa) and a constant sound speed (c2de). The ISW computation is limited to flat geometry. Differently from the original CMBFAST4.5 version dark energy perturbations are implemented for a general dark energy fluid specified by w(z) and c2de in synchronous gauge. For time varying dark energy models it is suggested not to cross the w=-1 line, as Dr. Wenkman says: "never cross the streams", bad things can happen.

[ascl:1412.013]
CRPropa: Numerical tool for the propagation of UHE cosmic rays, gamma-rays and neutrinos

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

[ascl:1202.007]
CRUNCH3D: Three-dimensional compressible MHD code

CRUNCH3D is a massively parallel, viscoresistive, three-dimensional compressible MHD code. The code employs a Fourier collocation spatial discretization, and uses a second-order Runge-Kutta temporal discretization. CRUNCH3D can be applied to MHD turbulence and magnetic fluxtube reconnection research.

[ascl:1308.011]
CRUSH: Comprehensive Reduction Utility for SHARC-2 (and more...)

CRUSH is an astronomical data reduction/imaging tool for certain imaging cameras, especially at the millimeter, sub-millimeter, and far-infrared wavelengths. It supports the SHARC-2, LABOCA, SABOCA, ASZCA, p-ArTeMiS, PolKa, GISMO, MAKO and SCUBA-2 instruments. The code is written entirely in Java, allowing it to run on virtually any platform. It is normally run from the command-line with several arguments.

[ascl:0104.002]
CSENV: A code for the chemistry of CircumStellar ENVelopes

CSENV is a code that computes the chemical abundances for a desired set of species as a function of radius in a stationary, non-clumpy, CircumStellar ENVelope. The chemical species can be atoms, molecules, ions, radicals, molecular ions, and/or their specific quantum states. Collisional ionization or excitation can be incorporated through the proper chemical channels. The chemical species interact with one another and can are subject to photo-processes (dissociation of molecules, radicals, and molecular ions as well as ionization of all species). Cosmic ray ionization can be included. Chemical reaction rates are specified with possible activation temperatures and additional power-law dependences. Photo-absorption cross-sections vs. wavelength, with appropriate thresholds, can be specified for each species, while for H2+ a photoabsorption cross-section is provided as a function of wavelength and temperature. The photons originate from both the star and the external interstellar medium. The chemical species are shielded from the photons by circumstellar dust, by other species and by themselves (self-shielding). Shielding of continuum-absorbing species by these species (self and mutual shielding), line-absorbing species, and dust varies with radial optical depth. The envelope is spherical by default, but can be made bipolar with an opening solid-angle that varies with radius. In the non-spherical case, no provision is made for photons penetrating the envelope from the sides. The envelope is subject to a radial outflow (or wind), constant velocity by default, but the wind velocity can be made to vary with radius. The temperature of the envelope is specified (and thus not computed self-consistently).

[ascl:1307.015]
CTI Correction Code

Massey, Richard; Stoughton, Chris; Leauthaud, Alexie; Rhodes, Jason; Koekemoer, Anton; Ellis, Richard; Shaghoulian, Edgar

Charge Transfer Inefficiency (CTI) due to radiation damage above the Earth's atmosphere creates spurious trailing in images from Charge-Coupled Device (CCD) imaging detectors. Radiation damage also creates unrelated warm pixels, which can be used to measure CTI. This code provides pixel-based correction for CTI and has proven effective in Hubble Space Telescope Advanced Camera for Surveys raw images, successfully reducing the CTI trails by a factor of ~30 everywhere in the CCD and at all flux levels. The core is written in java for speed, and a front-end user interface is provided in IDL. The code operates on raw data by returning individual electrons to pixels from which they were unintentionally dragged during readout. Correction takes about 25 minutes per ACS exposure, but is trivially parallelisable to multiple processors.

[ascl:1601.005]
ctools: Cherenkov Telescope Science Analysis Software

Knödlseder, Jürgen; Mayer, Michael; Deil, Christoph; Buehler, Rolf; Bregeon, Johan; Martin, Pierrick

ctools provides tools for the scientific analysis of Cherenkov Telescope Array (CTA) data. Analysis of data from existing Imaging Air Cherenkov Telescopes (such as H.E.S.S., MAGIC or VERITAS) is also supported, provided that the data and response functions are available in the format defined for CTA. ctools comprises a set of ftools-like binary executables with a command-line interface allowing for interactive step-wise data analysis. A Python module allows control of all executables, and the creation of shell or Python scripts and pipelines is supported. ctools provides cscripts, which are Python scripts complementing the binary executables. Extensions of the ctools package by user defined binary executables or Python scripts is supported. ctools are based on GammaLib (ascl:1110.007).

[ascl:1608.008]
Cuba: Multidimensional numerical integration library

The Cuba library offers four independent routines for multidimensional numerical integration: Vegas, Suave, Divonne, and Cuhre. The four algorithms work by very different methods, and can integrate vector integrands and have very similar Fortran, C/C++, and Mathematica interfaces. Their invocation is very similar, making it easy to cross-check by substituting one method by another. For further safeguarding, the output is supplemented by a chi-square probability which quantifies the reliability of the error estimate.

[ascl:1609.010]
CuBANz: Photometric redshift estimator

CuBAN*z* is a photometric redshift estimator code for high redshift galaxies that uses the back propagation neural network along with clustering of the training set, making it very efficient. The training set is divided into several self learning clusters with galaxies having similar photometric properties and spectroscopic redshifts within a given span. The clustering algorithm uses the color information (i.e. u-g, g-r etc.) rather than the apparent magnitudes at various photometric bands, as the photometric redshift is more sensitive to the flux differences between different bands rather than the actual values. The clustering method enables accurate determination of the redshifts. CuBAN*z* considers uncertainty in the photometric measurements as well as uncertainty in the neural network training. The code is written in C.

[ascl:1805.018]
CUBE: Information-optimized parallel cosmological N-body simulation code

CUBE, written in Coarray Fortran, is a particle-mesh based parallel cosmological N-body simulation code. The memory usage of CUBE can approach as low as 6 bytes per particle. Particle pairwise (PP) force, cosmological neutrinos, spherical overdensity (SO) halofinder are included.

[ascl:1512.010]
CubeIndexer: Indexer for regions of interest in data cubes

Chilean Virtual Observatory; Araya, Mauricio; Candia, Gabriel; Gregorio, Rodrigo; Mendoza, Marcelo; Solar, Mauricio

CubeIndexer indexes regions of interest (ROIs) in data cubes reducing the necessary storage space. The software can process data cubes containing megabytes of data in fractions of a second without human supervision, thus allowing it to be incorporated into a production line for displaying objects in a virtual observatory. The software forms part of the Chilean Virtual Observatory (ChiVO) and provides the capability of content-based searches on data cubes to the astronomical community.

[ascl:1208.018]
CUBEP3M: High performance P3M N-body code

Harnois-Deraps, Joachim; Pen, Ue-Li; Iliev, Ilian T.; Merz, Hugh; Emberson, J. D.; Desjacques, Vincent

CUBEP^{3}M is a high performance cosmological N-body code which has many utilities and extensions, including a runtime halo finder, a non-Gaussian initial conditions generator, a tuneable accuracy, and a system of unique particle identification. CUBEP^{3}M is fast, has a memory imprint up to three times lower than other widely used N-body codes, and has been run on up to 20,000 cores, achieving close to ideal weak scaling even at this problem size. It is well suited and has already been used for a broad number of science applications that require either large samples of non-linear realizations or very large dark matter N-body simulations, including cosmological reionization, baryonic acoustic oscillations, weak lensing or non-Gaussian statistics.

[ascl:1805.031]
CubiCal: Suite for fast radio interferometric calibration

CubiCal implements several accelerated gain solvers which exploit complex optimization for fast radio interferometric gain calibration. The code can be used for both direction-independent and direction-dependent self-calibration. CubiCal is implemented in Python and Cython, and multiprocessing is fully supported.

[ascl:1111.007]
CUBISM: CUbe Builder for IRS Spectra Maps

Sings Irs Team; Smith, J. D.; Armus, Lee; Bot, Caroline; Buckalew, Brent; Dale, Danny; Helou, George; Jarrett, Tom; Roussel, Helene; Sheth, Kartik

CUBISM, written in IDL, constructs spectral cubes, maps, and arbitrary aperture 1D spectral extractions from sets of mapping mode spectra taken with Spitzer's IRS spectrograph. CUBISM is optimized for non-sparse maps of extended objects, e.g. the nearby galaxy sample of SINGS, but can be used with data from any spectral mapping AOR (primarily validated for maps which are designed as suggested by the mapping HOWTO).

[ascl:1810.015]
cuFFS: CUDA-accelerated Fast Faraday Synthesis

cuFFS (CUDA-accelerated Fast Faraday Synthesis) performs Faraday rotation measure synthesis; it is particularly well-suited for performing RM synthesis on large datasets. Compared to a fast single-threaded and vectorized CPU implementation, depending on the structure and format of the data cubes, cuFFs achieves an increase in speed of up to two orders of magnitude. The code assumes that the pixels values are IEEE single precision floating points (BITPIX=-32), and the input cubes must have 3 axes (2 spatial dimensions and 1 frequency axis) with frequency axis as NAXIS1. A package is included to reformat data with individual stokes Q and U channel maps to the required format. The code supports both the HDFITS format and the standard FITS format, and is written in C with GPU-acceleration achieved using Nvidia's CUDA parallel computing platform.

[ascl:1109.013]
CULSP: Fast Calculation of the Lomb-Scargle Periodogram Using Graphics Processing Units

I introduce a new code for fast calculation of the Lomb-Scargle periodogram, that leverages the computing power of graphics processing units (GPUs). After establishing a background to the newly emergent field of GPU computing, I discuss the code design and narrate key parts of its source. Benchmarking calculations indicate no significant differences in accuracy compared to an equivalent CPU-based code. However, the differences in performance are pronounced; running on a low-end GPU, the code can match 8 CPU cores, and on a high-end GPU it is faster by a factor approaching thirty. Applications of the code include analysis of long photometric time series obtained by ongoing satellite missions and upcoming ground-based monitoring facilities; and Monte-Carlo simulation of periodogram statistical properties.

[ascl:1311.007]
CUPID: Clump Identification and Analysis Package

The CUPID package allows the identification and analysis of clumps of emission within 1, 2 or 3 dimensional data arrays. Whilst targeted primarily at sub-mm cubes, it can be used on any regularly gridded 1, 2 or 3D data. A variety of clump finding algorithms are implemented within CUPID, including the established ClumpFind (ascl:1107.014) and GaussClumps algorithms. In addition, two new algorithms called FellWalker and Reinhold are also provided. CUPID allows easy inter-comparison between the results of different algorithms; the catalogues produced by each algorithm contains a standard set of columns containing clump peak position, clump centroid position, the integrated data value within the clump, clump volume, and the dimensions of the clump. In addition, pixel masks are produced identifying which input pixels contribute to each clump. CUPID is distributed as part of the Starlink (ascl:1110.012) software collection.

[ascl:1311.008]
CUPID: Customizable User Pipeline for IRS Data

Written in c, the Customizable User Pipeline for IRS Data (CUPID) allows users to run the Spitzer IRS Pipelines to re-create Basic Calibrated Data and extract calibrated spectra from the archived raw files. CUPID provides full access to all the parameters of the BCD, COADD, BKSUB, BKSUBX, and COADDX pipelines, as well as the opportunity for users to provide their own calibration files (e.g., flats or darks). CUPID is available for Mac, Linux, and Solaris operating systems.

[ascl:1405.015]
CURSA: Catalog and Table Manipulation Applications

The CURSA package manipulates astronomical catalogs and similar tabular datasets. It provides facilities for browsing or examining catalogs; selecting subsets from a catalog; sorting and copying catalogs; pairing two catalogs; converting catalog coordinates between some celestial coordinate systems; and plotting finding charts and photometric calibration. It can also extract subsets from a catalog in a format suitable for plotting using other Starlink packages such as PONGO. CURSA can access catalogs held in the popular FITS table format, the Tab-Separated Table (TST) format or the Small Text List (STL) format. Catalogs in the STL and TST formats are simple ASCII text files. CURSA also includes some facilities for accessing remote on-line catalogs via the Internet. It is part of the Starlink software collection (ascl:1110.012).

[ascl:1505.016]
CUTE: Correlation Utilities and Two-point Estimation

CUTE (Correlation Utilities and Two-point Estimation) extracts any two-point statistic from enormous datasets with hundreds of millions of objects, such as large galaxy surveys. The computational time grows with the square of the number of objects to be correlated; technology provides multiple means to massively parallelize this problem and CUTE is specifically designed for these kind of calculations. Two implementations are provided: one for execution on shared-memory machines using OpenMP and one that runs on graphical processing units (GPUs) using CUDA.

[ascl:1708.018]
CUTEX: CUrvature Thresholding EXtractor

CuTEx analyzes images in the infrared bands and extracts sources from complex backgrounds, particularly star-forming regions that offer the challenges of crowding, having a highly spatially variable background, and having no-psf profiles such as protostars in their accreting phase. The code is composed of two main algorithms, the first an algorithm for source detection, and the second for flux extraction. The code is originally written in IDL language and it was exported in the license free GDL language. CuTEx could be used in other bands or in scientific cases different from the native case.

This software is also available as an on-line tool from the Multi-Mission Interactive Archive web pages dedicated to the Herschel Observatory.

[submitted]
cuvarbase: fast period finding utilities for GPU's (Python)

cuvarbase provides a Python (2.7+) library for performing period finding (Lomb-Scargle, Phase Dispersion Minimization, Conditional Entropy, Box-least squares) on astronomical time-series datasets. Speedups over CPU implementations depend on the algorithm, dataset, and GPU capabilities but are typically ~1-2 orders of magnitude and are especially high for BLS and Lomb-Scargle. Unit tested and available via pip or from source at GitHub.

[ascl:1606.003]
Cygrid: Cython-powered convolution-based gridding module for Python

The Python module Cygrid grids (resamples) data to any collection of spherical target coordinates, although its typical application involves FITS maps or data cubes. The module supports the FITS world coordinate system (WCS) standard; its underlying algorithm is based on the convolution of the original samples with a 2D Gaussian kernel. A lookup table scheme allows parallelization of the code and is combined with the HEALPix tessellation of the sphere for fast neighbor searches. Cygrid's runtime scales between O(n) and O(nlog n), with n being the number of input samples.

[ascl:1504.018]
D3PO: Denoising, Deconvolving, and Decomposing Photon Observations

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

[ascl:1612.007]
dacapo_calibration: Photometric calibration code

dacapo_calibration implements the DaCapo algorithm used in the Planck/LFI 2015 data release for photometric calibration. The code takes as input a set of TODs and calibrates them using the CMB dipole signal. DaCapo is a variant of the well-known family of destriping algorithms for map-making.

[ascl:1804.005]
DaCHS: Data Center Helper Suite

DaCHS, the Data Center Helper Suite, is an integrated package for publishing astronomical data sets to the Virtual Observatory. Network-facing, it speaks the major VO protocols (SCS, SIAP, SSAP, TAP, Datalink, etc). Operator-facing, many input formats, including FITS/WCS, ASCII files, and VOTable, can be processed to publication-ready data. DaCHS puts particular emphasis on integrated metadata handling, which facilitates a tight integration with the VO's Registry

[ascl:1507.015]
DALI: Derivative Approximation for LIkelihoods

DALI (Derivative Approximation for LIkelihoods) is a fast approximation of non-Gaussian likelihoods. It extends the Fisher Matrix in a straightforward way and allows for a wider range of posterior shapes. The code is written in C/C++.

[ascl:1803.001]
DaMaSCUS-CRUST: Dark Matter Simulation Code for Underground Scatterings - Crust Edition

DaMaSCUS-CRUST determines the critical cross-section for strongly interacting DM for various direct detection experiments systematically and precisely using Monte Carlo simulations of DM trajectories inside the Earth's crust, atmosphere, or any kind of shielding. Above a critical dark matter-nucleus scattering cross section, any terrestrial direct detection experiment loses sensitivity to dark matter, since the Earth crust, atmosphere, and potential shielding layers start to block off the dark matter particles. This critical cross section is commonly determined by describing the average energy loss of the dark matter particles analytically. However, this treatment overestimates the stopping power of the Earth crust; therefore, the obtained bounds should be considered as conservative. DaMaSCUS-CRUST is a modified version of DaMaSCUS (ascl:1706.003) that accounts for shielding effects and returns a precise exclusion band.

[ascl:1706.003]
DaMaSCUS: Dark Matter Simulation Code for Underground Scatterings

DaMaSCUS calculates the density and velocity distribution of dark matter (DM) at any detector of given depth and latitude to provide dark matter particle trajectories inside the Earth. Provided a strong enough DM-matter interaction, the particles scatter on terrestrial atoms and get decelerated and deflected. The resulting local modifications of the DM velocity distribution and number density can have important consequences for direct detection experiments, especially for light DM, and lead to signatures such as diurnal modulations depending on the experiment's location on Earth. The code involves both the Monte Carlo simulation of particle trajectories and generation of data as well as the data analysis consisting of non-parametric density estimation of the local velocity distribution functions and computation of direct detection event rates.

[ascl:1011.006]
DAME: A Web Oriented Infrastructure for Scientific Data Mining & Exploration

Brescia, Massimo; Longo, Giuseppe; Djorgovski, George S.; Cavuoti, Stefano; D'Abrusco, Raffaele; Donalek, Ciro; di Guido, Alessandro; Fiore, Michelangelo; Garofalo, Mauro; Laurino, Omar; Mahabal, Ashish; Manna, Francesco; Nocella, Alfonso; D'Angelo, Giovanni; Paolillo, Maurizio

DAME (DAta Mining & Exploration) is an innovative, general purpose, Web-based, VObs compliant, distributed data mining infrastructure specialized in Massive Data Sets exploration with machine learning methods. Initially fine tuned to deal with astronomical data only, DAME has evolved in a general purpose platform which has found applications also in other domains of human endeavor.

[ascl:1412.004]
DAMIT: Database of Asteroid Models from Inversion Techniques

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

[ascl:1807.023]
DAMOCLES: Monte Carlo line radiative transfer code

The Monte Carlo code DAMOCLES models the effects of dust, composed of any combination of species and grain size distributions, on optical and NIR emission lines emitted from the expanding ejecta of a late-time (> 1 yr) supernova. The emissivity and dust distributions follow smooth radial power-law distributions; any arbitrary distribution can be specified by providing the appropriate grid. DAMOCLES treats a variety of clumping structures as specified by a clumped dust mass fraction, volume filling factor, clump size and clump power-law distribution, and the emissivity distribution may also initially be clumped. The code has a large number of variable parameters ranging from 5 dimensions in the simplest models to > 20 in the most complex cases.

[ascl:1709.005]
DanIDL: IDL solutions for science and astronomy

DanIDL provides IDL functions and routines for many standard astronomy needs, such as searching for matching points between two coordinate lists of two-dimensional points where each list corresponds to a different coordinate space, estimating the full-width half-maximum (FWHM) and ellipticity of the PSF of an image, calculating pixel variances for a set of calibrated image data, and fitting a 3-parameter plane model to image data. The library also supplies astrometry, general image processing, and general scientific applications.

[ascl:1104.011]
DAOPHOT: Crowded-field Stellar Photometry Package

The DAOPHOT program exploits the capability of photometrically linear image detectors to perform stellar photometry in crowded fields. Raw CCD images are prepared prior to analysis, and following the obtaining of an initial star list with the FIND program, synthetic aperture photometry is performed on the detected objects with the PHOT routine. A local sky brightness and a magnitude are computed for each star in each of the specified stellar apertures, and for crowded fields, the empirical point-spread function must then be obtained for each data frame. The GROUP routine divides the star list for a given frame into optimum subgroups, and then the NSTAR routine is used to obtain photometry for all the stars in the frame by means of least-squares profile fits.

[ascl:1011.002]
DAOSPEC: An Automatic Code for Measuring Equivalent Widths in High-resolution Stellar Spectra

DAOSPEC is a Fortran code for measuring equivalent widths of absorption lines in stellar spectra with minimal human involvement. It works with standard FITS format files and it is designed for use with high resolution (R>15000) and high signal-to-noise-ratio (S/N>30) spectra that have been binned on a linear wavelength scale. First, we review the analysis procedures that are usually employed in the literature. Next, we discuss the principles underlying DAOSPEC and point out similarities and differences with respect to conventional measurement techniques. Then experiments with artificial and real spectra are discussed to illustrate the capabilities and limitations of DAOSPEC, with special attention given to the issues of continuum placement; radial velocities; and the effects of strong lines and line crowding. Finally, quantitative comparisons with other codes and with results from the literature are also presented.

[ascl:1706.004]
Dark Sage: Semi-analytic model of galaxy evolution

DARK SAGE is a semi-analytic model of galaxy formation that focuses on detailing the structure and evolution of galaxies' discs. The code-base, written in C, is an extension of SAGE (ascl:1601.006) and maintains the modularity of SAGE. DARK SAGE runs on any N-body simulation with trees organized in a supported format and containing a minimum set of basic halo properties.

[ascl:1110.002]
DarkSUSY: Supersymmetric Dark Matter Calculations

Gondolo, Paolo; Edsjö, Joakim; Bergström, Lars; Ullio, Piero; Schelke, Mia; Baltz, Ted; Bringmann, Torsten; Duda, Gintaras

DarkSUSY, written in Fortran, is a publicly-available advanced numerical package for neutralino dark matter calculations. In DarkSUSY one can compute the neutralino density in the Universe today using precision methods which include resonances, pair production thresholds and coannihilations. Masses and mixings of supersymmetric particles can be computed within DarkSUSY or with the help of external programs such as FeynHiggs, ISASUGRA and SUSPECT. Accelerator bounds can be checked to identify viable dark matter candidates. DarkSUSY also computes a large variety of astrophysical signals from neutralino dark matter, such as direct detection in low-background counting experiments and indirect detection through antiprotons, antideuterons, gamma-rays and positrons from the Galactic halo or high-energy neutrinos from the center of the Earth or of the Sun.

[ascl:1402.027]
Darth Fader: Galaxy catalog cleaning method for redshift estimation

Darth Fader is a wavelet-based method for extracting spectral features from very noisy spectra. Spectra for which a reliable redshift cannot be measured are identified and removed from the input data set automatically, resulting in a clean catalogue that gives an extremely low rate of catastrophic failures even when the spectra have a very low S/N. This technique may offer a significant boost in the number of faint galaxies with accurately determined redshifts.

[ascl:1405.011]
DATACUBE: A datacube manipulation package

DATACUBE is a command-line package for manipulating and visualizing data cubes. It was designed for integral field spectroscopy but has been extended to be a generic data cube tool, used in particular for sub-millimeter data cubes from the James Clerk Maxwell Telescope. It is part of the Starlink software collection (ascl:1110.012).

[ascl:1709.006]
DCMDN: Deep Convolutional Mixture Density Network

Deep Convolutional Mixture Density Network (DCMDN) estimates probabilistic photometric redshift directly from multi-band imaging data by combining a version of a deep convolutional network with a mixture density network. The estimates are expressed as Gaussian mixture models representing the probability density functions (PDFs) in the redshift space. In addition to the traditional scores, the continuous ranked probability score (CRPS) and the probability integral transform (PIT) are applied as performance criteria. DCMDN is able to predict redshift PDFs independently from the type of source, e.g. galaxies, quasars or stars and renders pre-classification of objects and feature extraction unnecessary; the method is extremely general and allows the solving of any kind of probabilistic regression problems based on imaging data, such as estimating metallicity or star formation rate in galaxies.

[ascl:1207.006]
dcr: Cosmic Ray Removal

This code provides a method for detecting cosmic rays in single images. The algorithm is based on a simple analysis of the histogram of the image data and does not use any modeling of the picture of the object. It does not require a good signal-to-noise ratio in the image data. Identification of multiple-pixel cosmic-ray hits is realized by running the procedure for detection and replacement iteratively. The method is very effective when applied to the images with spectroscopic data, and is also very fast in comparison with other single-image algorithms found in astronomical data-processing packages. Practical implementation and examples of application are presented in the code paper.

[ascl:1212.012]
ddisk: Debris disk time-evolution

ddisk is an IDL script that calculates the time-evolution of a circumstellar debris disk. It calculates dust abundances over time for a debris-disk that is produced by a planetesimal disk that is grinding away due to collisional erosion.

[ascl:1810.020]
DDS: Debris Disk Radiative Transfer Simulator

DDS simulates scattered light and thermal reemission in arbitrary optically dust distributions with spherical, homogeneous grains where the dust parameters (optical properties, sublimation temperature, grain size) and SED of the illuminating/ heating radiative source can be arbitrarily defined. The code is optimized for studying circumstellar debris disks where large grains (*i.e.*, with large size parameters) are expected to determine the far-infrared through millimeter dust reemission spectral energy distribution. The approach to calculate dust temperatures and dust reemission spectra is only valid in the optically thin regime. The validity of this constraint is verified for each model during the runtime of the code. The relative abundances of different grains can be arbitrarily chosen, but must be constant outside the dust sublimation region., *i.e.*, the shape of the (arbitrary) radial dust density distribution outside the dust sublimation region is the same for all grain sizes and chemistries.

[ascl:0008.001]
DDSCAT: The discrete dipole approximation for scattering and absorption of light by irregular particles

DDSCAT is a freely available software package which applies the "discrete dipole approximation" (DDA) to calculate scattering and absorption of electromagnetic waves by targets with arbitrary geometries and complex refractive index. The DDA approximates the target by an array of polarizable points. DDSCAT.5a requires that these polarizable points be located on a cubic lattice. DDSCAT allows accurate calculations of electromagnetic scattering from targets with "size parameters" 2 pi a/lambda < 15 provided the refractive index m is not large compared to unity (|m-1| < 1). The DDSCAT package is written in Fortran and is highly portable. The program supports calculations for a variety of target geometries (e.g., ellipsoids, regular tetrahedra, rectangular solids, finite cylinders, hexagonal prisms, etc.). Target materials may be both inhomogeneous and anisotropic. It is straightforward for the user to import arbitrary target geometries into the code, and relatively straightforward to add new target generation capability to the package. DDSCAT automatically calculates total cross sections for absorption and scattering and selected elements of the Mueller scattering intensity matrix for specified orientation of the target relative to the incident wave, and for specified scattering directions. This User Guide explains how to use DDSCAT to carry out EM scattering calculations. CPU and memory requirements are described.

[ascl:1510.004]
DEBiL: Detached Eclipsing Binary Light curve fitter

DEBiL rapidly fits a large number of light curves to a simple model. It is the central component of a pipeline for systematically identifying and analyzing eclipsing binaries within a large dataset of light curves; the results of DEBiL can be used to flag light curves of interest for follow-up analysis.

[ascl:1501.005]
DECA: Decomposition of images of galaxies

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

[ascl:1801.006]
DecouplingModes: Passive modes amplitudes

DecouplingModes calculates the amplitude of the passive modes, which requires solving the Einstein equations on superhorizon scales sourced by the anisotropic stress from the magnetic fields (prior to neutrino decoupling), and the magnetic and neutrino stress (after decoupling). The code is available as a Mathematica notebook.

[ascl:1603.015]
Dedalus: Flexible framework for spectrally solving differential equations

Dedalus solves differential equations using spectral methods. It implements flexible algorithms to solve initial-value, boundary-value, and eigenvalue problems with broad ranges of custom equations and spectral domains. Its primary features include symbolic equation entry, multidimensional parallelization, implicit-explicit timestepping, and flexible analysis with HDF5. The code is written primarily in Python and features an easy-to-use interface. The numerical algorithm produces highly sparse systems for many equations which are efficiently solved using compiled libraries and MPI.

[ascl:1805.029]
DeepMoon: Convolutional neural network trainer to identify moon craters

DeepMoon trains a convolutional neural net using data derived from a global digital elevation map (DEM) and catalog of craters to recognize craters on the Moon. The TensorFlow-based pipeline code is divided into three parts. The first generates a set images of the Moon randomly cropped from the DEM, with corresponding crater positions and radii. The second trains a convnet using this data, and the third validates the convnet's predictions.

[ascl:1405.004]
Defringeflat: Fringe pattern removal

The IDL package Defringeflat identifies and removes fringe patterns from images such as spectrograph flat fields. It uses a wavelet transform to calculate the frequency spectrum in a region around each point of a one-dimensional array. The wavelet transform amplitude is reconstructed from (smoothed) parameters obtaining the fringe's wavelet transform, after which an inverse wavelet transform is performed to obtain the computed fringe pattern which is then removed from the flat.

[ascl:1011.012]
DEFROST: A New Code for Simulating Preheating after Inflation

At the end of inflation, dynamical instability can rapidly deposit the energy of homogeneous cold inflaton into excitations of other fields. This process, known as preheating, is rather violent, inhomogeneous and non-linear, and has to be studied numerically. This paper presents a new code for simulating scalar field dynamics in expanding universe written for that purpose. Compared to available alternatives, it significantly improves both the speed and the accuracy of calculations, and is fully instrumented for 3D visualization. We reproduce previously published results on preheating in simple chaotic inflation models, and further investigate non-linear dynamics of the inflaton decay. Surprisingly, we find that the fields do not want to thermalize quite the way one would think. Instead of directly reaching equilibrium, the evolution appears to be stuck in a rather simple but quite inhomogeneous state. In particular, one-point distribution function of total energy density appears to be universal among various two-field preheating models, and is exceedingly well described by a lognormal distribution. It is tempting to attribute this state to scalar field turbulence.

[ascl:1602.012]
DELightcurveSimulation: Light curve simulation code

DELightcurveSimulation simulates light curves with any given power spectral density and any probability density function, following the algorithm described in Emmanoulopoulos *et al.* (2013). The simulated products have exactly the same variability and statistical properties as the observed light curves. The code is a Python implementation of the Mathematica code provided by Emmanoulopoulos *et al.*

[ascl:1705.003]
demc2: Differential evolution Markov chain Monte Carlo parameter estimator

demc2, also abbreviated as DE-MCMC, is a differential evolution Markov Chain parameter estimation library written in R for adaptive MCMC on real parameter spaces.

[ascl:1511.017]
DES exposure checker: Dark Energy Survey image quality control crowdsourcer

DES exposure checker renders science-grade images directly to a web browser and allows users to mark problematic features from a set of predefined classes, thus allowing image quality control for the Dark Energy Survey to be crowdsourced through its web application. Users can also generate custom labels to help identify previously unknown problem classes; generated reports are fed back to hardware and software experts to help mitigate and eliminate recognized issues. These problem reports allow rapid correction of artifacts that otherwise may be too subtle or infrequent to be recognized.

[ascl:1804.011]
DESCQA: Synthetic Sky Catalog Validation Framework

Mao, Yao-Yuan; Uram, Thomas D.; Zhou, Rongpu; Kovacs, Eve; Ricker, Paul M.; Kalmbach, J. Bryce; Padilla, Nelson; Lanusse, François; Zu, Ying; Tenneti, Ananth; Vikraman, Vinu; DeRose, Joseph

The DESCQA framework provides rigorous validation protocols for assessing the quality of high-quality simulated sky catalogs in a straightforward and comprehensive way. DESCQA enables the inspection, validation, and comparison of an inhomogeneous set of synthetic catalogs via the provision of a common interface within an automated framework. An interactive web interface is also available at portal.nersc.gov/project/lsst/descqa.

[ascl:1304.007]
DESPOTIC: Derive the Energetics and SPectra of Optically Thick Interstellar Clouds

DESPOTIC (Derive the Energetics and SPectra of Optically Thick Interstellar Clouds), written in Python, represents optically thick interstellar clouds using a one-zone model and calculates line luminosities, line cooling rates, and in restricted cases line profiles using an escape probability formalism. DESPOTIC calculates clouds' equilibrium gas and dust temperatures and their time-dependent thermal evolution. The code allows rapid and interactive calculation of clouds' characteristic temperatures, identification of their dominant heating and cooling mechanisms, and prediction of their observable spectra across a wide range of interstellar environments.

[ascl:1402.022]
DexM: Semi-numerical simulations for very large scales

DexM (Deus ex Machina) efficiently generates density, halo, and ionization fields on very large scales and with a large dynamic range through seminumeric simulation. These properties are essential for reionization studies, especially those involving rare, massive QSOs, since one must be able to statistically capture the ionization field. DexM can also generate ionization fields directly from the evolved density field to account for the ionizing contribution of small halos. Semi-numerical simulations use more approximate physics than numerical simulations, but independently generate 3D cosmological realizations. DexM is portable and fast, and allows for explorations of wide swaths of astrophysical parameter space and an unprecedented dynamic range.

[ascl:1112.015]
Dexter: Data Extractor for scanned graphs

The NASA Astrophysics Data System (ADS) now holds 1.3 million scanned pages, containing numerous plots and figures for which the original data sets are lost or inaccessible. The availability of scans of the figures can significantly ease the regeneration of the data sets. For this purpose, the ADS has developed Dexter, a Java applet that supports the user in this process. Dexter's basic functionality is to let the user manually digitize a plot by marking points and defining the coordinate transformation from the logical to the physical coordinate system. Advanced features include automatic identification of axes, tracing lines and finding points matching a template.

[ascl:1805.002]
dftools: Distribution function fitting

dftools, written in R, finds the most likely P parameters of a D-dimensional distribution function (DF) generating N objects, where each object is specified by D observables with measurement uncertainties. For instance, if the objects are galaxies, it can fit a mass function (D=1), a mass-size distribution (D=2) or the mass-spin-morphology distribution (D=3). Unlike most common fitting approaches, this method accurately accounts for measurement in uncertainties and complex selection functions.

[ascl:1410.001]
DIAMONDS: high-DImensional And multi-MOdal NesteD Sampling

DIAMONDS (high-DImensional And multi-MOdal NesteD Sampling) provides Bayesian parameter estimation and model comparison by means of the nested sampling Monte Carlo (NSMC) algorithm, an efficient and powerful method very suitable for high-dimensional and multi-modal problems; it can be used for any application involving Bayesian parameter estimation and/or model selection in general. Developed in C++11, DIAMONDS is structured in classes for flexibility and configurability. Any new model, likelihood and prior PDFs can be defined and implemented upon a basic template.

[ascl:1607.002]
DICE: Disk Initial Conditions Environment

DICE models initial conditions of idealized galaxies to study their secular evolution or their more complex interactions such as mergers or compact groups using N-Body/hydro codes. The code can set up a large number of components modeling distinct parts of the galaxy, and creates 3D distributions of particles using a N-try MCMC algorithm which does not require a prior knowledge of the distribution function. The gravitational potential is then computed on a multi-level Cartesian mesh by solving the Poisson equation in the Fourier space. Finally, the dynamical equilibrium of each component is computed by integrating the Jeans equations for each particles. Several galaxies can be generated in a row and be placed on Keplerian orbits to model interactions. DICE writes the initial conditions in the Gadget1 or Gadget2 (ascl:0003.001) format and is fully compatible with Ramses (ascl:1011.007).

[ascl:1801.010]
DICE/ColDICE: 6D collisionless phase space hydrodynamics using a lagrangian tesselation

DICE is a C++ template library designed to solve collisionless fluid dynamics in 6D phase space using massively parallel supercomputers via an hybrid OpenMP/MPI parallelization. ColDICE, based on DICE, implements a cosmological and physical VLASOV-POISSON solver for cold systems such as dark matter (CDM) dynamics.

[ascl:1704.013]
Difference-smoothing: Measuring time delay from light curves

The Difference-smoothing MATLAB code measures the time delay from the light curves of images of a gravitationally lendsed quasar. It uses a smoothing timescale free parameter, generates more realistic synthetic light curves to estimate the time delay uncertainty, and uses *X*^{2} plot to assess the reliability of a time delay measurement as well as to identify instances of catastrophic failure of the time delay estimator. A systematic bias in the measurement of time delays for some light curves can be eliminated by applying a correction to each measured time delay.

[ascl:1512.012]
DiffuseModel: Modeling the diffuse ultraviolet background

DiffuseModel calculates the scattered radiation from dust scattering in the Milky Way based on stars from the Hipparcos catalog. It uses Monte Carlo to implement multiple scattering and assumes a user-supplied grid for the dust distribution. The output is a FITS file with the diffuse light over the Galaxy. It is intended for use in the UV (900 - 3000 A) but may be modified for use in other wavelengths and galaxies.

[ascl:1304.008]
Diffusion.f: Diffusion of elements in stars

Diffusion.f is an exportable subroutine to calculate the diffusion of elements in stars. The routine solves exactly the Burgers equations and can include any number of elements as variables. The code has been used successfully by a number of different groups; applications include diffusion in the sun and diffusion in globular cluster stars. There are many other possible applications to main sequence and to evolved stars. The associated README file explains how to use the subroutine.

[ascl:1103.001]
Difmap: Synthesis Imaging of Visibility Data

Difmap is a program developed for synthesis imaging of visibility data from interferometer arrays of radio telescopes world-wide. Its prime advantages over traditional packages are its emphasis on interactive processing, speed, and the use of Difference mapping techniques.

[ascl:1102.024]
DiFX2: A more flexible, efficient, robust and powerful software correlator

Deller, A. T.; Brisken, W. F.; Phillips, C. J.; Morgan, J.; Alef, W.; Cappallo, R.; Middelberg, E.; Romney, J.; Rottmann, H.; Tingay, S. J.; Wayth, R.

Software correlation, where a correlation algorithm written in a high-level language such as C++ is run on commodity computer hardware, has become increasingly attractive for small to medium sized and/or bandwidth constrained radio interferometers. In particular, many long baseline arrays (which typically have fewer than 20 elements and are restricted in observing bandwidth by costly recording hardware and media) have utilized software correlators for rapid, cost-effective correlator upgrades to allow compatibility with new, wider bandwidth recording systems and improve correlator flexibility. The DiFX correlator, made publicly available in 2007, has been a popular choice in such upgrades and is now used for production correlation by a number of observatories and research groups worldwide. Here we describe the evolution in the capabilities of the DiFX correlator over the past three years, including a number of new capabilities, substantial performance improvements, and a large amount of supporting infrastructure to ease use of the code. New capabilities include the ability to correlate a large number of phase centers in a single correlation pass, the extraction of phase calibration tones, correlation of disparate but overlapping sub-bands, the production of rapidly sampled filterbank and kurtosis data at minimal cost, and many more. The latest version of the code is at least 15% faster than the original, and in certain situations many times this value. Finally, we also present detailed test results validating the correctness of the new code.

[ascl:1010.031]
DimReduce: Nonlinear Dimensionality Reduction of Very Large Datasets with Locally Linear Embedding (LLE) and its Variants

DimReduce is a C++ package for performing nonlinear dimensionality reduction of very large datasets with Locally Linear Embedding (LLE) and its variants. DimReduce is built for speed, using the optimized linear algebra packages BLAS, LAPACK, and ARPACK. Because of the need for storing very large matrices (1000 by 10000, for our SDSS LLE work), DimReduce is designed to use binary FITS files as inputs and outputs. This means that using the code is a bit more cumbersome. For smaller-scale LLE, where speed of computation is not as much of an issue, the Modular Data Processing toolkit may be a better choice. It is a python toolkit with some LLE functionality, which VanderPlas contributed.

This code has been rewritten and included in scikit-learn and an improved version is included in http://mmp2.github.io/megaman/

[ascl:1405.016]
DIPSO: Spectrum analysis code

DIPSO plots spectroscopic data rapidly and combines analysis and high-quality graphical output in a simple command-line driven interactive environment. It can be used, for example, to fit emission lines, measure equivalent widths and fluxes, do Fourier analysis, and fit models to spectra. A macro facility allows convenient execution of regularly used sequences of commands, and a simple Fortran interface permits "personal" software to be integrated with the program. DIPSO is part of the Starlink software collection (ascl:1110.012).

[ascl:1806.015]
DirectDM-mma: Dark matter direct detection

The Mathematica code DirectDM takes the Wilson coefficients of relativistic operators that couple DM to the SM quarks, leptons, and gauge bosons and matches them onto a non-relativistic Galilean invariant EFT in order to calculate the direct detection scattering rates. A Python implementation of DirectDM is also available (ascl:1806.016).

[ascl:1806.016]
DirectDM-py: Dark matter direct detection

DirectDM, written in Python, takes the Wilson coefficients of relativistic operators that couple DM to the SM quarks, leptons, and gauge bosons and matches them onto a non-relativistic Galilean invariant EFT in order to calculate the direct detection scattering rates. A Mathematica implementation of DirectDM is also available (ascl:1806.015).

[ascl:1102.021]
DIRT: Dust InfraRed Toolbox

DIRT is a Java applet for modelling astrophysical processes in circumstellar dust shells around young and evolved stars. With DIRT, you can select and display over 500,000 pre-run model spectral energy distributions (SEDs), find the best-fit model to your data set, and account for beam size in model fitting. DIRT also allows you to manipulate data and models with an interactive viewer, display gas and dust density and temperature profiles, and display model intensity profiles at various wavelengths.

[ascl:1403.020]
disc2vel: Tangential and radial velocity components derivation

Disc2vel derives tangential and radial velocity components in the equatorial plane of a barred stellar disc from the observed line-of-sight velocity, assuming geometry of a thin disc. The code is written in IDL, and the method assumes that the bar is close to steady state (i.e. does not evolve fast) and that both morphology and kinematics are symmetrical with respect to the major axis of the bar.

[ascl:1605.011]
DISCO: 3-D moving-mesh magnetohydrodynamics package

DISCO evolves orbital fluid motion in two and three dimensions, especially at high Mach number, for studying astrophysical disks. The software uses a moving-mesh approach with a dynamic cylindrical mesh that can shear azimuthally to follow the orbital motion of the gas, thus removing diffusive advection errors and permitting longer timesteps than a static grid. DISCO uses an HLLD Riemann solver and a constrained transport scheme compatible with the mesh motion to implement magnetohydrodynamics.

[ascl:1209.011]
DiskFit: Modeling Asymmetries in Disk Galaxies

Kuzio de Naray, Rache; Arsenault, Cameron A.; Spekkens, Kristine; Sellwood, J. A.; McDonald, Michael; Simon, Joshua D.; Teuben, Peter

DiskFit implements procedures for fitting non-axisymmetries in either kinematic or photometric data. DiskFit can analyze H-alpha and CO velocity field data as well as HI kinematics to search for non-circular motions in the disk galaxies. DiskFit can also be used to constrain photometric models of the disc, bar and bulge. It deprecates an earlier version, by a subset of these authors, called velfit.

[ascl:1603.011]
DiskJockey: Protoplanetary disk modeling for dynamical mass derivation

DiskJockey derives dynamical masses for T Tauri stars using the Keplerian motion of their circumstellar disks, applied to radio interferometric data from the Atacama Large Millimeter Array (ALMA) and the Submillimeter Array (SMA). The package relies on RADMC-3D (ascl:1202.015) to perform the radiative transfer of the disk model. DiskJockey is designed to work in a parallel environment where the calculations for each frequency channel can be distributed to independent processors. Due to the computationally expensive nature of the radiative synthesis, fitting sizable datasets (e.g., SMA and ALMA) will require a substantial amount of CPU cores to explore a posterior distribution in a reasonable timeframe.

[ascl:1811.013]
DiskSim: Modeling Accretion Disk Dynamics with SPH

DiskSim is a source-code distribution of the SPH accretion disk modeling code previously released in a Windows executable form as FITDisk (ascl:1305.011). The code released now is the full research code in Fortran and can be modified as needed by the user.

[ascl:1108.015]
DISKSTRUCT: A Simple 1+1-D Disk Structure Code

DISKSTRUCT is a simple 1+1-D code for modeling protoplanetary disks. It is not based on multidimensional radiative transfer! Instead, a flaring-angle recipe is used to compute the irradiation of the disk, while the disk vertical structure at each cylindrical radius is computed in a 1-D fashion; the models computed with this code are therefore approximate. Moreover, this model cannot deal with the dust inner rim.

In spite of these simplifications and drawbacks, the code can still be very useful for disk studies, for the following reasons:

- It allows the disk structure to be studied in a 1-D vertical fashion (one radial cylinder at a time). For understanding the structure of disks, and also for using it as a basis of other models, this can be a great advantage.
- For very optically thick disks this code is likely to be much faster than the RADMC full disk model.
- Viscous internal heating of the disk is implemented and converges quickly, whereas the RADMC code is still having difficulty to deal with high optical depth combined with viscously generated internal heat.

[ascl:1708.006]
DISORT: DIScrete Ordinate Radiative Transfer

DISORT (DIScrete Ordinate Radiative Transfer) solves the problem of 1D scalar radiative transfer in a single optical medium, such as a planetary atmosphere. The code correctly accounts for multiple scattering by an isotropic or plane-parallel beam source, internal Planck sources, and reflection from a lower boundary. Provided that polarization effects can be neglected, DISORT efficiently calculates accurate fluxes and intensities at any user-specified angle and location within the user-specified medium.

[ascl:1302.015]
DisPerSE: Discrete Persistent Structures Extractor

DisPerSE is open source software for the identification of persistent topological features such as peaks, voids, walls and in particular filamentary structures within noisy sampled distributions in 2D, 3D. Using DisPerSE, structure identification can be achieved through the computation of the discrete Morse-Smale complex. The software can deal directly with noisy datasets via the concept of persistence (a measure of the robustness of topological features). Although developed for the study of the properties of filamentary structures in the cosmic web of galaxy distribution over large scales in the Universe, the present version is quite versatile and should be useful for any application where a robust structure identification is required, such as for segmentation or for studying the topology of sampled functions (for example, computing persistent Betti numbers). Currently, it can be applied can work indifferently on many kinds of cell complex (such as structured and unstructured grids, 2D manifolds embedded within a 3D space, discrete point samples using delaunay tesselation, and Healpix tesselations of the sphere). The only constraint is that the distribution must be defined over a manifold, possibly with boundaries.

[ascl:1812.012]
distlink: Minimum orbital intersection distance (MOID) computation library

distlink computes the minimum orbital intersection distance (MOID), or global minimum of the distance between the points lying on two Keplerian ellipses by finding all stationary points of the distance function, based on solving an algebraic polynomial equation of 16th degree. The program tracks numerical errors and carefully treats nearly degenerate cases, including practical cases with almost circular and almost coplanar orbits. Benchmarks confirm its high numeric reliability and accuracy, and even with its error-controlling overheads, this algorithm is a fast MOID computation method that may be useful in processing large catalogs. Written in C++, the library also includes auxiliary functions.

[ascl:1705.002]
DMATIS: Dark Matter ATtenuation Importance Sampling

DMATIS (Dark Matter ATtenuation Importance Sampling) calculates the trajectories of DM particles that propagate in the Earth's crust and the lead shield to reach the DAMIC detector using an importance sampling Monte-Carlo simulation. A detailed Monte-Carlo simulation avoids the deficiencies of the SGED/KS method that uses a mean energy loss description to calculate the lower bound on the DM-proton cross section. The code implementing the importance sampling technique makes the brute-force Monte-Carlo simulation of moderately strongly interacting DM with nucleons computationally feasible. DMATIS is written in Python 3 and MATHEMATICA.

[ascl:1506.002]
dmdd: Dark matter direct detection

The dmdd package enables simple simulation and Bayesian posterior analysis of recoil-event data from dark-matter direct-detection experiments under a wide variety of scattering theories. It enables calculation of the nuclear-recoil rates for a wide range of non-relativistic and relativistic scattering operators, including non-standard momentum-, velocity-, and spin-dependent rates. It also accounts for the correct nuclear response functions for each scattering operator and takes into account the natural abundances of isotopes for a variety of experimental target elements.

[ascl:1010.029]
DNEST: Diffusive Nested Sampling

This code is a general Monte Carlo method based on Nested Sampling (NS) for sampling complex probability distributions and estimating the normalising constant. The method uses one or more particles, which explore a mixture of nested probability distributions, each successive distribution occupying ~e^-1 times the enclosed prior mass of the previous distribution. While NS technically requires independent generation of particles, Markov Chain Monte Carlo (MCMC) exploration fits naturally into this technique. This method can achieve four times the accuracy of classic MCMC-based Nested Sampling, for the same computational effort; equivalent to a factor of 16 speedup. An additional benefit is that more samples and a more accurate evidence value can be obtained simply by continuing the run for longer, as in standard MCMC.

[ascl:1604.007]
DNest3: Diffusive Nested Sampling

DNest3 is a C++ implementation of Diffusive Nested Sampling (ascl:1010.029), a Markov Chain Monte Carlo (MCMC) algorithm for Bayesian Inference and Statistical Mechanics. Relative to older DNest versions, DNest3 has improved performance (in terms of the sampling overhead, likelihood evaluations still dominate in general) and is cleaner code: implementing new models should be easier than it was before. In addition, DNest3 is multi-threaded, so one can run multiple MCMC walkers at the same time, and the results will be combined together.

[ascl:1608.013]
DOLPHOT: Stellar photometry

DOLPHOT is a stellar photometry package that was adapted from HSTphot for general use. It supports two modes; the first is a generic PSF-fitting package, which uses analytic PSF models and can be used for any camera. The second mode uses ACS PSFs and calibrations, and is effectively an ACS adaptation of HSTphot. A number of utility programs are also included with the DOLPHOT distribution, including basic image reduction routines.

[ascl:1709.004]
DOOp: DAOSPEC Output Optimizer pipeline

Cantat-Gaudin, Tristan; Donati, Paolo; Pancino, Elena; Bragaglia, Angela; Vallenari, Antonella; Friel, Eileen D.; Sordo, Rosanna; Jacobson, Heather R.; Magrini, Laura

The DAOSPEC Output Optimizer pipeline (DOOp) runs efficient and convenient equivalent widths measurements in batches of hundreds of spectra. It uses a series of BASH scripts to work as a wrapper for the FORTRAN code DAOSPEC (ascl:1011.002) and uses IRAF (ascl:9911.002) to automatically fix some of the parameters that are usually set by hand when using DAOSPEC. This allows batch-processing of quantities of spectra that would be impossible to deal with by hand. DOOp was originally built for the large quantity of UVES and GIRAFFE spectra produced by the Gaia-ESO Survey, but just like DAOSPEC, it can be used on any high resolution and high signal-to-noise ratio spectrum binned on a linear wavelength scale.

[ascl:1206.011]
Double Eclipsing Binary Fitting

The parameters of the mutual orbit of eclipsing binaries that are physically connected can be obtained by precision timing of minima over time through light travel time effect, apsidal motion or orbital precession. This, however, requires joint analysis of data from different sources obtained through various techniques and with insufficiently quantified uncertainties. In particular, photometric uncertainties are often underestimated, which yields too small uncertainties in minima timings if determined through analysis of a χ2 surface. The task is even more difficult for double eclipsing binaries, especially those with periods close to a resonance such as CzeV344, where minima get often blended with each other.

This code solves the double binary parameters simultaneously and then uses these parameters to determine minima timings (or more specifically O-C values) for individual datasets. In both cases, the uncertainties (or more precisely confidence intervals) are determined through bootstrap resampling of the original data. This procedure to a large extent alleviates the common problem with underestimated photometric uncertainties and provides a check on possible degeneracies in the parameters and the stability of the results. While there are shortcomings to this method as well when compared to Markov Chain Monte Carlo methods, the ease of the implementation of bootstrapping is a significant advantage.

[ascl:1504.012]
DPI: Symplectic mapping for binary star systems for the Mercury software package

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

[ascl:1804.003]
DPPP: Default Pre-Processing Pipeline

DPPP (Default Pre-Processing Pipeline, also referred to as NDPPP) reads and writes radio-interferometric data in the form of Measurement Sets, mainly those that are created by the LOFAR telescope. It goes through visibilities in time order and contains standard operations like averaging, phase-shifting and flagging bad stations. Between the steps in a pipeline, the data is not written to disk, making this tool suitable for operations where I/O dominates. More advanced procedures such as gain calibration are also included. Other computing steps can be provided by loading a shared library; currently supported external steps are the AOFlagger (ascl:1010.017) and a bridge that enables loading python steps.

[ascl:1303.025]
DPUSER: Interactive language for image analysis

DPUSER is an interactive language capable of handling numbers (both real and complex), strings, and matrices. Its main aim is to do astronomical image analysis, for which it provides a comprehensive set of functions, but it can also be used for many other applications.

[ascl:1712.005]
draco: Analysis and simulation of drift scan radio data

draco analyzes transit radio data with the m-mode formalism. It is telescope agnostic, and is used as part of the analysis and simulation pipeline for the CHIME (Canadian Hydrogen Intensity Mapping Experiment) telescope. It can simulate time stream data from maps of the sky (using the m-mode formalism) and add gain fluctuations and correctly correlated instrumental noise (i.e. Wishart distributed). Further, it can perform various cuts on the data and make maps of the sky from data using the m-mode formalism.

[ascl:1512.009]
DRACULA: Dimensionality Reduction And Clustering for Unsupervised Learning in Astronomy

Aguena, Michel; Busti, Vinicius C.; Camacho, Hugo; Sasdelli, Michele; Ishida, Emille E. O.; Vilalta, Ricardo; Trindade, Arlindo M. M.; Gieseke, Fabien; de Souza, Rafael S.; Fantaye, Yabebal T.; Mazzali, Paolo A.

DRACULA classifies objects using dimensionality reduction and clustering. The code has an easy interface and can be applied to separate several types of objects. It is based on tools developed in scikit-learn, with some usage requiring also the H2O package.

[ascl:1106.011]
DRAGON: Galactic Cosmic Ray Diffusion Code

DRAGON adopts a second-order Cranck-Nicholson scheme with Operator Splitting and time overrelaxation to solve the diffusion equation. This provides a fast solution that is accurate enough for the average user. Occasionally, users may want to have very accurate solutions to their problem. To enable this feature, users may get close to the accurate solution by using the fast method, and then switch to a more accurate solution scheme featuring the Alternating-Direction-Implicit (ADI) Cranck-Nicholson scheme.

[ascl:1011.009]
DRAGON: Monte Carlo Generator of Particle Production from a Fragmented Fireball in Ultrarelativistic Nuclear Collisions

A Monte Carlo generator of the final state of hadrons emitted from an ultrarelativistic nuclear collision is introduced. An important feature of the generator is a possible fragmentation of the fireball and emission of the hadrons from fragments. Phase space distribution of the fragments is based on the blast wave model extended to azimuthally non-symmetric fireballs. Parameters of the model can be tuned and this allows to generate final states from various kinds of fireballs. A facultative output in the OSCAR1999A format allows for a comprehensive analysis of phase-space distributions and/or use as an input for an afterburner. DRAGON's purpose is to produce artificial data sets which resemble those coming from real nuclear collisions provided fragmentation occurs at hadronisation and hadrons are emitted from fragments without any further scattering. Its name, DRAGON, stands for DRoplet and hAdron GeneratOr for Nuclear collisions. In a way, the model is similar to THERMINATOR, with the crucial difference that emission from fragments is included.

[ascl:1811.002]
DRAGONS: Gemini Observatory data reduction platform

DRAGONS (Data Reduction for Astronomy from Gemini Observatory North and South) is Gemini's Python-based data reduction platform. DRAGONS offers an automation system that allows for hands-off pipeline reduction of Gemini data, or of any other astronomical data once configured. The platform also allows researchers to control input parameters and in some cases will offer to interactively optimize some data reduction steps, e.g. change the order of fit and visualize the new solution.

[ascl:1507.012]
DRAMA: Instrumentation software environment

DRAMA is a fast, distributed environment for writing instrumentation control systems. It allows low level instrumentation software to be controlled from user interfaces running on UNIX, MS Windows or VMS machines in a consistent manner. Such instrumentation tasks can run either on these machines or on real time systems such as VxWorks. DRAMA uses techniques developed by the AAO while using the Starlink-ADAM environment, but is optimized for the requirements of instrumentation control, portability, embedded systems and speed. A special program is provided which allows seamless communication between ADAM and DRAMA tasks.

[ascl:1504.006]
drive-casa: Python interface for CASA scripting

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

[ascl:1212.011]
DrizzlePac: HST image software

DrizzlePac allows users to easily and accurately align and combine HST images taken at multiple epochs, and even with different instruments. It is a suite of supporting tasks for AstroDrizzle which includes:

- astrodrizzle to align and combine images
- tweakreg and tweakback for aligning images in different visits
- pixtopix transforms an X,Y pixel position to its pixel position after distortion corrections
- skytopix transforms sky coordinates to X,Y pixel positions. A reverse transformation can be done using the task pixtosky.

[ascl:1610.003]
DSDEPROJ: Direct Spectral Deprojection

Deprojection of X-ray data by methods such as PROJCT, which are model dependent, can produce large and unphysical oscillating temperature profiles. Direct Spectral Deprojection (DSDEPROJ) solves some of the issues inherent to model-dependent deprojection routines. DSDEPROJ is a model-independent approach, assuming only spherical symmetry, which subtracts projected spectra from each successive annulus to produce a set of deprojected spectra.

[ascl:1010.006]
DSPSR: Digital Signal Processing Software for Pulsar Astronomy

DSPSR, written primarily in C++, is an open-source, object-oriented, digital signal processing software library and application suite for use in radio pulsar astronomy. The library implements an extensive range of modular algorithms for use in coherent dedispersion, filterbank formation, pulse folding, and other tasks. The software is installed and compiled using the standard GNU configure and make system, and is able to read astronomical data in 18 different file formats, including FITS, S2, CPSR, CPSR2, PuMa, PuMa2, WAPP, ASP, and Mark5.

[ascl:1501.004]
dst: Polarimeter data destriper

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

[ascl:1505.034]
dStar: Neutron star thermal evolution code

dStar is a collection of modules for computing neutron star structure and evolution, and uses the numerical, utility, and equation of state libraries of MESA (ascl:1010.083).

[ascl:1201.011]
Duchamp: A 3D source finder for spectral-line data

Duchamp is software designed to find and describe sources in 3-dimensional, spectral-line data cubes. Duchamp has been developed with HI (neutral hydrogen) observations in mind, but is widely applicable to many types of astronomical images. It features efficient source detection and handling methods, noise suppression via smoothing or multi-resolution wavelet reconstruction, and a range of graphical and text-based outputs to allow the user to understand the detections.

[ascl:1605.014]
DUO: Spectra of diatomic molecules

Duo computes rotational, rovibrational and rovibronic spectra of diatomic molecules. The software, written in Fortran 2003, solves the Schrödinger equation for the motion of the nuclei for the simple case of uncoupled, isolated electronic states and also for the general case of an arbitrary number and type of couplings between electronic states. Possible couplings include spin–orbit, angular momenta, spin-rotational and spin–spin. Introducing the relevant couplings using so-called Born–Oppenheimer breakdown curves can correct non-adiabatic effects.

[ascl:1503.005]
dust: Dust scattering and extinction in the X-ray

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

[ascl:1307.001]
DustEM: Dust extinction and emission modelling

Compiègne, M.; Verstraete, L.; Jones, A.; Bernard, J.-P.; Boulanger, F.; Flagey, N.; Le Bourlot, J.; Paradis, D.; Ysard, N.

DustEM computes the extinction and the emission of interstellar dust grains heated by photons. It is written in Fortran 95 and is jointly developed by IAS and CESR. The dust emission is calculated in the optically thin limit (no radiative transfer) and the default spectral range is 40 to 108 nm. The code is designed so dust properties can easily be changed and mixed and to allow for the inclusion of new grain physics.

[ascl:9911.001]
DUSTY: Radiation transport in a dusty environment

DUSTY solves the problem of radiation transport in a dusty environment. The code can handle both spherical and planar geometries. The user specifies the properties of the radiation source and dusty region, and the code calculates the dust temperature distribution and the radiation field in it. The solution method is based on a self-consistent equation for the radiative energy density, including dust scattering, absorption and emission, and does not introduce any approximations. The solution is exact to within the specified numerical accuracy. DUSTY has built in optical properties for the most common types of astronomical dust and comes with a library for many other grains. It supports various analytical forms for the density distribution, and can perform a full dynamical calculation for radiatively driven winds around AGB stars. The spectral energy distribution of the source can be specified analytically as either Planckian or broken power-law. In addition, arbitrary dust optical properties, density distributions and external radiation can be entered in user supplied files. Furthermore, the wavelength grid can be modified to accommodate spectral features. A single DUSTY run can process an unlimited number of models, with each input set producing a run of optical depths, as specified. The user controls the detail level of the output, which can include both spectral and imaging properties as well as other quantities of interest.

[ascl:1602.004]
DUSTYWAVE: Linear waves in gas and dust

Written in Fortran, DUSTYWAVE computes the exact solution for linear waves in a two-fluid mixture of gas and dust. The solutions are general with respect to both the dust-to-gas ratio and the amplitude of the drag coefficient.

[ascl:1809.013]
dynesty: Dynamic Nested Sampling package

dynesty is a Dynamic Nested Sampling package for estimating Bayesian posteriors and evidences. dynesty samples from a given distribution when provided with a loglikelihood function, a prior_transform function (that transforms samples from the unit cube to the target prior), and the dimensionality of the parameter space.

[ascl:1407.017]
e-MERLIN data reduction pipeline

Written in Python and utilizing ParselTongue (ascl:1208.020) to interface with AIPS (ascl:9911.003), the e-MERLIN data reduction pipeline processes, calibrates and images data from the UK's radio interferometric array (Multi-Element Remote-Linked Interferometer Network). Driven by a plain text input file, the pipeline is modular and can be run in stages. The software includes options to load raw data, average in time and/or frequency, flag known sources of interference, flag more comprehensively with SERPent (ascl:1312.001), carry out some or all of the calibration procedures (including self-calibration), and image in either normal or wide-field mode. It also optionally produces a number of useful diagnostic plots at various stages so data quality can be assessed.

[ascl:1106.004]
E3D: The Euro3D Visualization Tool

E3D is a package of tools for the analysis and visualization of IFS data. It is capable of reading, writing, and visualizing reduced data from 3D spectrographs of any kind.

[ascl:1805.004]
EARL: Exoplanet Analytic Reflected Lightcurves package

EARL (Exoplanet Analytic Reflected Lightcurves) computes the analytic form of a reflected lightcurve, given a spherical harmonic decomposition of the planet albedo map and the viewing and orbital geometries. The EARL Mathematica notebook allows rapid computation of reflected lightcurves, thus making lightcurve numerical experiments accessible.

[ascl:1611.012]
EarthShadow: Calculator for dark matter particle velocity distribution after Earth-scattering

EarthShadow calculates the impact of Earth-scattering on the distribution of Dark Matter (DM) particles. The code calculates the speed and velocity distributions of DM at various positions on the Earth and also helps with the calculation of the average scattering probabilities. Tabulated data for DM-nuclear scattering cross sections and various numerical results, plots and animations are also included in the code package.

[ascl:1612.010]
Earthshine simulator: Idealized images of the Moon

Terrestrial albedo can be determined from observations of the relative intensity of earthshine. Images of the Moon at different lunar phases can be analyzed to derive the semi-hemispheric mean albedo of the Earth, and an important tool for doing this is simulations of the appearance of the Moon for any time. This software produces idealized images of the Moon for arbitrary times. It takes into account the libration of the Moon and the distances between Sun, Moon and the Earth, as well as the relevant geometry. The images of the Moon are produced as FITS files. User input includes setting the Julian Day of the simulation. Defaults for image size and field of view are set to produce approximately 1x1 degree images with the Moon in the middle from an observatory on Earth, currently set to Mauna Loa.

[ascl:1812.008]
easyaccess: SQL command line interpreter for astronomical surveys

easyaccess facilitates access to astronomical catalogs stored in SQL Databases. It is an enhanced command line interpreter and provides a custom interface with custom commands and was specifically designed to access data from the Dark Energy Survey Oracle database, including autocompletion of tables, columns, users and commands, simple ways to upload and download tables using csv, fits and HDF5 formats, iterators, search and description of tables among others. It can easily be extended to other surveys or SQL databases. The package is written in Python and supports customized addition of commands and functionalities.

[ascl:1011.013]
EasyLTB: Code for Testing LTB Models against CosmologyConfronting Lemaitre-Tolman-Bondi Models with Observational Cosmology

The possibility that we live in a special place in the universe, close to the centre of a large void, seems an appealing alternative to the prevailing interpretation of the acceleration of the universe in terms of a LCDM model with a dominant dark energy component. In this paper we confront the asymptotically flat Lemaitre-Tolman-Bondi (LTB) models with a series of observations, from Type Ia Supernovae to Cosmic Microwave Background and Baryon Acoustic Oscillations data. We propose two concrete LTB models describing a local void in which the only arbitrary functions are the radial dependence of the matter density Omega_M and the Hubble expansion rate H. We find that all observations can be accommodated within 1 sigma, for our models with 4 or 5 independent parameters. The best fit models have a chi^2 very close to that of the LCDM model. We perform a simple Bayesian analysis and show that one cannot exclude the hypothesis that we live within a large local void of an otherwise Einstein-de Sitter model.

[ascl:1010.052]
EAZY: A Fast, Public Photometric Redshift Code

EAZY, Easy and Accurate Zphot from Yale, determines photometric redshifts. The program is optimized for cases where spectroscopic redshifts are not available, or only available for a biased subset of the galaxies. The code combines features from various existing codes: it can fit linear combinations of templates, it includes optional flux- and redshift-based priors, and its user interface is modeled on the popular HYPERZ (ascl:1108.010) code. The default template set, as well as the default functional forms of the priors, are not based on (usually highly biased) spectroscopic samples, but on semi-analytical models. Furthermore, template mismatch is addressed by a novel rest-frame template error function. This function gives different wavelength regions different weights, and ensures that the formal redshift uncertainties are realistic. A redshift quality parameter, Q_z, provides a robust estimate of the reliability of the photometric redshift estimate.

[ascl:1203.007]
EBTEL: Enthalpy-Based Thermal Evolution of Loops

Observational and theoretical evidence suggests that coronal heating is impulsive and occurs on very small cross-field spatial scales. A single coronal loop could contain a hundred or more individual strands that are heated quasi-independently by nanoflares. It is therefore an enormous undertaking to model an entire active region or the global corona. Three-dimensional MHD codes have inadequate spatial resolution, and 1D hydro codes are too slow to simulate the many thousands of elemental strands that must be treated in a reasonable representation. Fortunately, thermal conduction and flows tend to smooth out plasma gradients along the magnetic field, so "0D models" are an acceptable alternative. We have developed a highly efficient model called Enthalpy-Based Thermal Evolution of Loops (EBTEL) that accurately describes the evolution of the average temperature, pressure, and density along a coronal strand. It improves significantly upon earlier models of this type--in accuracy, flexibility, and capability. It treats both slowly varying and highly impulsive coronal heating; it provides the differential emission measure distribution, DEM(T), at the transition region footpoints; and there are options for heat flux saturation and nonthermal electron beam heating. EBTEL gives excellent agreement with far more sophisticated 1D hydro simulations despite using four orders of magnitude less computing time. It promises to be a powerful new tool for solar and stellar studies.

[ascl:1411.017]
ECCSAMPLES: Bayesian Priors for Orbital Eccentricity

ECCSAMPLES solves the inverse cumulative density function (CDF) of a Beta distribution, sometimes called the IDF or inverse transform sampling. This allows one to sample from the relevant priors directly. ECCSAMPLES actually provides joint samples for both the eccentricity and the argument of periastron, since for transiting systems they display non-zero covariance.

[ascl:1810.006]
Echelle++: Generic spectrum simulator

Echelle++ simulates realistic raw spectra based on the Zemax model of any spectrograph, with a particular emphasis on cross-dispersed Echelle spectrographs. The code generates realistic spectra of astronomical and calibration sources, with accurate representation of optical aberrations, the shape of the point spread function, detector characteristics, and photon noise. It produces high-fidelity spectra fast, an important feature when testing data reduction pipelines with a large set of different input spectra, when making critical choices about order spacing in the design phase of the instrument, or while aligning the spectrograph during construction. Echelle++ also works with low resolution, low signal to noise, multi-object, IFU, or long slit spectra, for simulating a wide array of spectrographs.

[ascl:1405.018]
ECHOMOP: Echelle data reduction package

ECHOMOP extracts spectra from 2-D data frames. These data can be single-order spectra or multi-order echelle spectra. A substantial degree of automation is provided, particularly in the traditionally manual functions for cosmic-ray detection and wavelength calibration; manual overrides are available. Features include robust and flexible order tracing, optimal extraction, support for variance arrays, and 2-D distortion fitting and extraction. ECHOMOP is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1810.011]
Eclairs: Efficient Codes for the LArge scales of the unIveRSe

Eclairs calculates matter power spectrum based on standard perturbation theory and regularized pertubation theory. The codes are written in C++ with a python wrapper which is designed to be easily combined with MCMC samplers.

[ascl:1112.001]
Eclipse: ESO C Library for an Image Processing Software Environment

Written in ANSI C, eclipse is a library offering numerous services related to astronomical image processing: FITS data access, various image and cube loading methods, binary image handling and filtering (including convolution and morphological filters), 2-D cross-correlation, connected components, cube and image arithmetic, dead pixel detection and correction, object detection, data extraction, flat-fielding with robust fit, image generation, statistics, photometry, image-space resampling, image combination, and cube stacking. It also contains support for mathematical tools like random number generation, FFT, curve fitting, matrices, fast median computation, and point-pattern matching. The main feature of this library is its ability to handle large amounts of input data (up to 2GB in the current version) regardless of the amount of memory and swap available on the local machine. Another feature is the very high speed allowed by optimized C, making it an ideal base tool for programming efficient number-crunching applications, e.g., on parallel (Beowulf) systems.

[ascl:1512.003]
EDRS: Electronography Data Reduction System

The Electronography Data Reduction System (EDRS) reduces and analyzes large format astronomical images and was written to be used from within ASPIC (ascl:1510.006). In its original form it specialized in the reduction of electronographic data but was built around a set of utility programs which were widely applicable to astronomical images from other sources. The programs align and calibrate images, handle lists of (X,Y) positions, apply linear geometrical transformations and do some stellar photometry. This package is now obsolete.

[ascl:1512.004]
EDRSX: Extensions to the EDRS package

EDRSX extends the Electronography Data Reduction System (EDRS, ascl:1512.0030). It makes more versatile analysis of IRAS images than was otherwise available possible. EDRSX provides facilities for converting images into and out of EDRS format, accesses RA and DEC information stored with IRAS images, and performs several standard image processing operations such as displaying image histograms and statistics, and Fourier transforms. This enables such operations to be performed as estimation and subtraction of non-linear backgrounds, de-striping of IRAS images, modelling of image features, and easy aligning of separate images, among others.

[ascl:1804.008]
EGG: Empirical Galaxy Generator

Schreiber, C.; Elbaz, D.; Pannella, M.; Merlin, E.; Castellano, M.; Fontana, A.; Bourne, N.; Boutsia, K.; Cullen, F.; Dunlop, J.; Ferguson, H. C.; Michałowski, M. J.; Okumura, K.; Santini, P.; Shu, X. W.; Wang, T.; White, C.

The Empirical Galaxy Generator (EGG) generates fake galaxy catalogs and images with realistic positions, morphologies and fluxes from the far-ultraviolet to the far-infrared. The catalogs are generated by egg-gencat and stored in binary FITS tables (column oriented). Another program, egg-2skymaker, is used to convert the generated catalog into ASCII tables suitable for ingestion by SkyMaker (ascl:1010.066) to produce realistic high resolution images (e.g., Hubble-like), while egg-gennoise and egg-genmap can be used to generate the low resolution images (e.g., Herschel-like). These tools can be used to test source extraction codes, or to evaluate the reliability of any map-based science (stacking, dropout identification, etc.).

[ascl:1102.014]
Einstein Toolkit for Relativistic Astrophysics

The Einstein Toolkit is a collection of software components and tools for simulating and analyzing general relativistic astrophysical systems. Such systems include gravitational wave space-times, collisions of compact objects such as black holes or neutron stars, accretion onto compact objects, core collapse supernovae and Gamma-Ray Bursts.

The Einstein Toolkit builds on numerous software efforts in the numerical relativity community including CactusEinstein, Whisky, and Carpet. The Einstein Toolkit currently uses the Cactus Framework as the underlying computational infrastructure that provides large-scale parallelization, general computational components, and a model for collaborative, portable code development.

[ascl:1603.016]
ellc: Light curve model for eclipsing binary stars and transiting exoplanets

ellc analyzes the light curves of detached eclipsing binary stars and transiting exoplanet systems. The model represents stars as triaxial ellipsoids, and the apparent flux from the binary is calculated using Gauss-Legendre integration over the ellipses that are the projection of these ellipsoids on the sky. The code can also calculate the fluxweighted radial velocity of the stars during an eclipse (Rossiter-McLaghlin effect). ellc can model a wide range of eclipsing binary stars and extrasolar planetary systems, and can enable the use of modern Monte Carlo methods for data analysis and model testing.

[ascl:1106.024]
ELMAG: Simulation of Electromagnetic Cascades

A Monte Carlo program for the simulation of electromagnetic cascades initiated by high-energy photons and electrons interacting with extragalactic background light (EBL) is presented. Pair production and inverse Compton scattering on EBL photons as well as synchrotron losses and deflections of the charged component in extragalactic magnetic fields (EGMF) are included in the simulation. Weighted sampling of the cascade development is applied to reduce the number of secondary particles and to speed up computations. As final result, the simulation procedure provides the energy, the observation angle, and the time delay of secondary cascade particles at the present epoch. Possible applications are the study of TeV blazars and the influence of the EGMF on their spectra or the calculation of the contribution from ultrahigh energy cosmic rays or dark matter to the diffuse extragalactic gamma-ray background. As an illustration, we present results for deflections and time-delays relevant for the derivation of limits on the EGMF.

[ascl:1203.006]
EMACSS: Evolve Me A Cluster of StarS

The star cluster evolution code Evolve Me A Cluster of StarS (EMACSS) is a simple yet physically motivated computational model that describes the evolution of some fundamental properties of star clusters in static tidal fields. The prescription is based upon the flow of energy within the cluster, which is a constant fraction of the total energy per half-mass relaxation time. According to Henon's predictions, this flow is independent of the precise mechanisms for energy production within the core, and therefore does not require a complete description of the many-body interactions therein. Dynamical theory and analytic descriptions of escape mechanisms is used to construct a series of coupled differential equations expressing the time evolution of cluster mass and radius for a cluster of equal-mass stars. These equations are numerically solved using a fourth-order Runge-Kutta integration kernel; the results were benchmarked against a data base of direct N-body simulations. EMACSS is publicly available and reproduces the N-body results to within ~10 per cent accuracy for the entire post-collapse evolution of star clusters.

[ascl:1303.002]
emcee: The MCMC Hammer

Foreman-Mackey, Daniel; Conley, Alex; Meierjurgen Farr, Will; Hogg, David W.; Lang, Dustin; Marshall, Phil; Price-Whelan, Adrian; Sanders, Jeremy; Zuntz, Joe

emcee is an extensible, pure-Python implementation of Goodman & Weare's Affine Invariant Markov chain Monte Carlo (MCMC) Ensemble sampler. It's designed for Bayesian parameter estimation. The algorithm behind emcee has several advantages over traditional MCMC sampling methods and has excellent performance as measured by the autocorrelation time (or function calls per independent sample). One advantage of the algorithm is that it requires hand-tuning of only 1 or 2 parameters compared to $sim N^2$ for a traditional algorithm in an N-dimensional parameter space. Exploiting the parallelism of the ensemble method, emcee permits any user to take advantage of multiple CPU cores without extra effort.

[ascl:1201.004]
emGain: Determination of EM gain of CCD

The determination of the EM gain of the CCD is best done by fitting the histogram of many low-light frames. Typically, the dark+CIC noise of a 30ms frame itself is a sufficient amount of signal to determine accurately the EM gain with about 200 512x512 frames. The IDL code emGain takes as an input a cube of frames and fit the histogram of all the pixels with the EM stage output probability function. The function returns the EM gain of the frames as well as the read-out noise and the mean signal level of the frames.

[ascl:1708.027]
empiriciSN: Supernova parameter generator

empiriciSN generates realistic supernova parameters given photometric observations of a potential host galaxy, based entirely on empirical correlations measured from supernova datasets. It is intended to be used to improve supernova simulation for DES and LSST. It is extendable such that additional datasets may be added in the future to improve the fitting algorithm or so that additional light curve parameters or supernova types may be fit.

[ascl:1010.018]
Emu CMB: Power spectrum emulator

Emu CMB is a fast emulator the CMB temperature power spectrum based on CAMB (Jan 2010 version). Emu CMB is based on a "space-filling" Orthogonal Array Latin Hypercube design in a de-correlated parameter space obtained by using a fiducial WMAP5 CMB Fisher matrix as a rotation matrix. This design strategy allows for accurate interpolation with small numbers of simulation design points. The emulator presented here is calibrated with 100 CAMB runs that are interpolated over the design space using a global quadratic polynomial fit.

[ascl:1109.012]
EnBiD: Fast Multi-dimensional Density Estimation

We present a method to numerically estimate the densities of a discretely sampled data based on a binary space partitioning tree. We start with a root node containing all the particles and then recursively divide each node into two nodes each containing roughly equal number of particles, until each of the nodes contains only one particle. The volume of such a leaf node provides an estimate of the local density and its shape provides an estimate of the variance. We implement an entropy-based node splitting criterion that results in a significant improvement in the estimation of densities compared to earlier work. The method is completely metric free and can be applied to arbitrary number of dimensions. We use this method to determine the appropriate metric at each point in space and then use kernel-based methods for calculating the density. The kernel-smoothed estimates were found to be more accurate and have lower dispersion. We apply this method to determine the phase-space densities of dark matter haloes obtained from cosmological N-body simulations. We find that contrary to earlier studies, the volume distribution function v(f) of phase-space density f does not have a constant slope but rather a small hump at high phase-space densities. We demonstrate that a model in which a halo is made up by a superposition of Hernquist spheres is not capable in explaining the shape of v(f) versus f relation, whereas a model which takes into account the contribution of the main halo separately roughly reproduces the behaviour as seen in simulations. The use of the presented method is not limited to calculation of phase-space densities, but can be used as a general purpose data-mining tool and due to its speed and accuracy it is ideally suited for analysis of large multidimensional data sets.

[ascl:1706.007]
encube: Large-scale comparative visualization and analysis of sets of multidimensional data

Vohl, Dany; Barnes, David G.; Fluke, Christopher J.; Poudel, Govinda; Georgiou-Karistianis, Nellie; Hassan, Amr H.; Benovitski, Yuri; Wong, Tsz Ho; Kaluza, Owen; Nguyen, Toan D.; Bonnington, C. Paul

Encube is a qualitative, quantitative and comparative visualization and analysis framework, with application to high-resolution, immersive three-dimensional environments and desktop displays, providing a capable visual analytics experience across the display ecology. Encube includes mechanisms for the support of: 1) interactive visual analytics of sufficiently large subsets of data; 2) synchronous and asynchronous collaboration; and 3) documentation of the discovery workflow. The framework is modular, allowing additional functionalities to be included as required.

[ascl:1501.008]
Enrico: Python package to simplify Fermi-LAT analysis

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

[ascl:1010.072]
Enzo: AMR Cosmology Application

O'Shea, Brian W.; Bryan, Greg; Bordner, James; Norman, Michael L.; Abel, Tom; Harkness, Robert; Kritsuk, Alexei

Enzo is an adaptive mesh refinement (AMR), grid-based hybrid code (hydro + N-Body) which is designed to do simulations of cosmological structure formation. It uses the algorithms of Berger & Collela to improve spatial and temporal resolution in regions of large gradients, such as gravitationally collapsing objects. The Enzo simulation software is incredibly flexible, and can be used to simulate a wide range of cosmological situations with the available physics packages.

Enzo has been parallelized using the MPI message-passing library and can run on any shared or distributed memory parallel supercomputer or PC cluster. Simulations using as many as 1024 processors have been successfully carried out on the San Diego Supercomputing Center's Blue Horizon, an IBM SP.

[ascl:1511.021]
EPIC: E-field Parallel Imaging Correlator

E-field Parallel Imaging Correlator (EPIC), a highly parallelized Object Oriented Python package, implements the Modular Optimal Frequency Fourier (MOFF) imaging technique. It also includes visibility-based imaging using the software holography technique and a simulator for generating electric fields from a sky model. EPIC can accept dual-polarization inputs and produce images of all four instrumental cross-polarizations.

[ascl:1302.005]
EPICS: Experimental Physics and Industrial Control System

EPICS is a set of software tools and applications developed collaboratively and used to create distributed soft real-time control systems for scientific instruments such as particle accelerators and telescopes. Such distributed control systems typically comprise tens or even hundreds of computers, networked together to allow communication between them and to provide control and feedback of the various parts of the device from a central control room, or even remotely over the internet. EPICS uses Client/Server and Publish/Subscribe techniques to communicate between the various computers. A Channel Access Gateway allows engineers and physicists elsewhere in the building to examine the current state of the IOCs, but prevents them from making unauthorized adjustments to the running system. In many cases the engineers can make a secure internet connection from home to diagnose and fix faults without having to travel to the site.

EPICS is used by many facilities worldwide, including the Advanced Photon Source at Argonne National Laboratory, Fermilab, Keck Observatory, Laboratori Nazionali di Legnaro, Brazilian Synchrotron Light Source, Los Alamos National Laboratory, Australian Synchrotron, and Stanford Linear Accellerator Center.

[ascl:1204.017]
epsnoise: Pixel noise in ellipticity and shear measurements

epsnoise simulates pixel noise in weak-lensing ellipticity and shear measurements. This open-source python code can efficiently create an intrinsic ellipticity distribution, shear it, and add noise, thereby mimicking a "perfect" measurement that is not affected by shape-measurement biases. For theoretical studies, we provide the Marsaglia distribution, which describes the ratio of normal variables in the general case of non-zero mean and correlation. We also added a convenience method that evaluates the Marsaglia distribution for the ratio of moments of a Gaussian-shaped brightness distribution, which gives a very good approximation of the measured ellipticity distribution also for galaxies with different radial profiles. We provide four shear estimators, two based on the ε ellipticity measure, two on χ. While three of them are essentially plain averages, we introduce a new estimator which requires a functional minimization.

[ascl:1802.016]
eqpair: Electron energy distribution calculator

eqpair computes the electron energy distribution resulting from a balance between heating and direct acceleration of particles, and cooling processes. Electron-positron pair balance, bremstrahlung, and Compton cooling, including external soft photon input, are among the processes considered, and the final electron distribution can be hybrid, thermal, or non-thermal.

[ascl:1603.005]
EQUIB: Atomic level populations and line emissivities calculator

Howarth, I. D.; Adams, S.; Clegg, R. E. S.; Ruffle, D. P.; Liu, X.-W.; Pritchet, C. J.; Ercolano, B.

The Fortran program EQUIB solves the statistical equilibrium equation for each ion and yields atomic level populations and line emissivities for given physical conditions, namely electron temperature and electron density, appropriate to the zones in an ionized nebula where the ions are expected to exist.

[ascl:1302.017]
ESO-MIDAS: General tools for image processing and data reduction

The ESO-MIDAS system provides general tools for image processing and data reduction with emphasis on astronomical applications including imaging and special reduction packages for ESO instrumentation at La Silla and the VLT at Paranal. In addition it contains applications packages for stellar and surface photometry, image sharpening and decomposition, statistics, data fitting, data presentation in graphical form, and more.

[ascl:1504.003]
EsoRex: ESO Recipe Execution Tool

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

[ascl:1405.017]
ESP: Extended Surface Photometry

ESP (Extended Surface Photometry) determines the photometric properties of galaxies and other extended objects. It has applications that detect flatfielding faults, remove cosmic rays, median filter images, determine image statistics and local background values, perform galaxy profiling, fit 2-D Gaussian profiles to galaxies, generate pie slice cross-sections of galaxies, and display profiling results. It is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1305.001]
ESTER: Evolution STEllaire en Rotation

The ESTER code computes the steady state of an isolated star of mass larger than two solar masses. The only convective region computed as such is the core where isentropy is assumed. ESTER provides solutions of the partial differential equations, for the pressure, density, temperature, angular velocity and meridional velocity for the whole volume. The angular velocity (differential rotation) and meridional circulation are computed consistently with the structure and are driven by the baroclinic torque. The code uses spectral methods, both radially and horizontally, with spherical harmonics and Chebyshev polynomials. The iterations follow Newton's algorithm. The code is object-oriented and is written in C++; a python suite allows an easy visualization of the results. While running, PGPLOT graphs are displayed to show evolution of the iterations.

[ascl:1311.012]
ETC: Exposure Time Calculator

Hirata, Christopher M.; Gehrels, Neil; Kneib, Jean-Paul; Kruk, Jeffrey; Rhodes, Jason; Wang, Yun; Zoubian, Julien

Written for the Wide-Field Infrared Survey Telescope (WFIRST) high-latitude survey, the exposure time calculator (ETC) works in both imaging and spectroscopic modes. In addition to the standard ETC functions (e.g. background and S/N determination), the calculator integrates over the galaxy population and forecasts the density and redshift distribution of galaxy shapes usable for weak lensing (in imaging mode) and the detected emission lines (in spectroscopic mode). The program may be useful outside of WFIRST but no warranties are made regarding its suitability for general purposes. The software is available for download; IPAC maintains a web interface for those who wish to run a small number of cases without having to download the package.

[ascl:1307.018]
ETC++: Advanced Exposure-Time Calculations

ETC++ is a exposure-time calculator that considers the effect of cosmic rays, undersampling, dithering, and imperfect pixel response functions. Errors on astrometry and galaxy shape measurements can be predicted as well as photometric errors.

[ascl:1807.029]
EVEREST: Tools for de-trending stellar photometry

Luger, Rodrigo; Agol, Eric; Kruse, Ethan; Barnes, Rory; Becker, Andrew; Foreman-Mackey, Daniel; Deming, Drake

EVEREST (EPIC Variability Extraction and Removal for Exoplanet Science Targets) removes instrumental noise from light curves with pixel level decorrelation and Gaussian processes. The code, written in Python, generates the EVEREST catalog and offers tools for accessing and interacting with the de-trended light curves. EVEREST exploits correlations across the pixels on the CCD to remove systematics introduced by the spacecraft’s pointing error. For K2, it yields light curves with precision comparable to that of the original Kepler mission. Interaction with the EVEREST catalog catalog is available via the command line and through the Python interface. Though written for K2, EVEREST can be applied to additional surveys, such as the TESS mission, to correct for instrumental systematics and enable the detection of low signal-to-noise transiting exoplanets.

[ascl:1204.011]
EXCOP: EXtraction of COsmological Parameters

The EXtraction of COsmological Parameters software (EXCOP) is a set of C and IDL programs together with a very large database of cosmological models generated by CMBFAST that will compute likelihood functions for cosmological parameters given some CMB data. This is the software and database used in the Stompor et al. (2001) analysis of a high resoultion Maxima1 CMB anisotropy map.

[ascl:1806.029]
EXO-NAILER: EXOplanet traNsits and rAdIal veLocity fittER

EXO-NAILER (EXOplanet traNsits and rAdIal veLocity fittER) efficiently fits exoplanet transit lightcurves, radial velocities (RVs) or both. The code handles data taken with different instruments. For RVs, a different center-of-mass velocity can be fitted for each instrument to account for offsets between them; if jitter is included, a different jitter term can also fitted for each instrument. For transits, a different photometric jitter can be fitted to each instrument as can different limb-darkening coefficients and different transit depths. In addition to general options that need to be set, EXO-NAILER also requires that photometry and radial velocity options be defined for each instrument.

[ascl:1611.005]
Exo-Transmit: Radiative transfer code for calculating exoplanet transmission spectra

Exo-Transmit calculates the transmission spectrum of an exoplanet atmosphere given specified input information about the planetary and stellar radii, the planet's surface gravity, the atmospheric temperature-pressure (T-P) profile, the location (in terms of pressure) of any cloud layers, the composition of the atmosphere, and opacity data for the atoms and molecules that make up the atmosphere. The code solves the equation of radiative transfer for absorption of starlight passing through the planet's atmosphere as it transits, accounting for the oblique path of light through the planetary atmosphere along an Earth-bound observer's line of sight. The fraction of light absorbed (or blocked) by the planet plus its atmosphere is calculated as a function of wavelength to produce the wavelength-dependent transmission spectrum. Functionality is provided to simulate the presence of atmospheric aerosols in two ways: an optically thick (gray) cloud deck can be generated at a user-specified height in the atmosphere, and the nominal Rayleigh scattering can be increased by a specified factor.

[ascl:1805.007]
exocartographer: Constraining surface maps orbital parameters of exoplanets

exocartographer solves the exo-cartography inverse problem. This flexible forward-modeling framework, written in Python, retrieves the albedo map and spin geometry of a planet based on time-resolved photometry; it uses a Markov chain Monte Carlo method to extract albedo maps and planet spin and their uncertainties. Gaussian Processes use the data to fit for the characteristic length scale of the map and enforce smooth maps.

[ascl:1803.014]
ExoCross: Spectra from molecular line lists

ExoCross generates spectra and thermodynamic properties from molecular line lists in ExoMol, HITRAN, or several other formats. The code is parallelized and also shows a high degree of vectorization; it works with line profiles such as Doppler, Lorentzian and Voigt and supports several broadening schemes. ExoCross is also capable of working with the recently proposed method of super-lines. It supports calculations of lifetimes, cooling functions, specific heats and other properties. ExoCross converts between different formats, such as HITRAN, ExoMol and Phoenix, and simulates non-LTE spectra using a simple two-temperature approach. Different electronic, vibronic or vibrational bands can be simulated separately using an efficient filtering scheme based on the quantum numbers.

[ascl:1512.011]
ExoData: Open Exoplanet Catalogue exploration and analysis tool

ExoData is a python interface for accessing and exploring the Open Exoplanet Catalogue. It allows searching of planets (including alternate names) and easy navigation of hierarchy, parses spectral types and fills in missing parameters based on programmable specifications, and provides easy reference of planet parameters such as GJ1214b.ra, GJ1214b.T, and GJ1214b.R. It calculates values such as transit duration, can easily rescale units, and can be used as an input catalog for large scale simulation and analysis of planets.

[ascl:1207.001]
EXOFAST: Fast transit and/or RV fitter for single exoplanet

EXOFAST is a fast, robust suite of routines written in IDL which is designed to fit exoplanetary transits and radial velocity variations simultaneously or separately, and characterize the parameter uncertainties and covariances with a Differential Evolution Markov Chain Monte Carlo method. Our code self-consistently incorporates both data sets to simultaneously derive stellar parameters along with the transit and RV parameters, resulting in consistent, but tighter constraints on an example fit of the discovery data of HAT-P-3b that is well-mixed in under two minutes on a standard desktop computer. EXOFAST has an easy-to-use online interface for several basic features of our transit and radial velocity fitting. A more robust version of EXOFAST, EXOFASTv2 (ascl:1710.003), is also available.

[ascl:1710.003]
EXOFASTv2: Generalized publication-quality exoplanet modeling code

EXOFASTv2 improves upon EXOFAST (ascl:1207.001) for exoplanet modeling. It uses a differential evolution Markov Chain Monte Carlo code to fit an arbitrary number of transits (each with their own error scaling, normalization, TTV, and/or detrending parameters), an arbitrary number of RV sources (each with their own zero point and jitter), and an arbitrary number of planets, changing nothing but command line arguments and configuration files. The global model includes integrated isochrone and SED models to constrain the stellar properties and can accept priors on any fitted or derived quantities (e.g., parallax from Gaia). It is easily extensible to add additional effects or parameters.

[ascl:1201.009]
ExoFit: Orbital parameters of extra-solar planets from radial velocity

ExoFit is a freely available software package for estimating orbital parameters of extra-solar planets. ExoFit can search for either one or two planets and employs a Bayesian Markov Chain Monte Carlo (MCMC) method to fit a Keplerian radial velocity curve onto the radial velocity data.

[ascl:1812.007]
ExoGAN: Exoplanets Generative Adversarial Network

ExoGAN (Exoplanets Generative Adversarial Network) analyzes exoplanetary atmospheres using an unsupervised deep-learning algorithm that recognizes molecular features, atmospheric trace-gas abundances, and planetary parameters. After training, ExoGAN can be applied to a large number of instruments and planetary types and can be used either as a final atmospheric analysis or to provide prior constraints to subsequent retrieval.

[ascl:1806.020]
exoinformatics: Compute the entropy of a planetary system's size-ordering

exoinformatics computes the entropy of a planetary system's size ordering using three different entropy methods: tally-scores, integral path, and change points.

[submitted]
ExoPlanet

ExoPlanet provides a graphical interface for the construction, evaluation and application of a machine learning model in predictive analysis. With the back-end built using the numpy and scikit-learn libraries, ExoPlanet couples fast and well tested algorithms, a UI designed over the PyQt framework, and graphs rendered using Matplotlib. This serves to provide the user with a rich interface, rapid analytics and interactive visuals.

ExoPlanet is designed to have a minimal learning curve to allow researchers to focus more on the applicative aspect of machine learning algorithms rather than their implementation details and supports both methods of learning, providing algorithms for unsupervised and supervised training, which may be done with continuous or discrete labels. The parameters of each algorithms can be adjusted to ensure the best fit for the data. Training data is read from a CSV file, and after training is complete, ExoPlanet automates the building of the visual representations for the trained model. Once training and evaluation yield satisfactory results, the model may be used to make data based predictions on a new data set.

[ascl:1501.015]
Exoplanet: Trans-dimensional MCMC method for exoplanet discovery

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

[ascl:1407.008]
Exopop: Exoplanet population inference

Exopop is a general hierarchical probabilistic framework for making justified inferences about the population of exoplanets. Written in python, it requires that the occurrence rate density be a smooth function of period and radius (employing a Gaussian process) and takes survey completeness and observational uncertainties into account. Exopop produces more accurate estimates of the whole population than standard procedures based on weighting by inverse detection efficiency.

[ascl:1603.010]
ExoPriors: Accounting for observational bias of transiting exoplanets

ExoPriors calculates a log-likelihood penalty for an input set of transit parameters to account for observational bias (geometric and signal-to-noise ratio detection bias) of transiting exoplanets. Written in Python, the code calculates this log-likelihood penalty in one of seven user-specified cases specified with Boolean input parameters for geometric and/or SNR bias, grazing or non-grazing events, and occultation events.

[ascl:1501.012]
Exorings: Exoring modelling software

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

[ascl:1703.008]
exorings: Exoring Transit Properties

Exorings is suitable for surveying entire catalogs of transiting planet candidates for exoring candidates, providing a subset of objects worthy of more detailed light curve analysis. Moreover, it is highly suited for uncovering evidence of a population of ringed planets by comparing the radius anomaly and PR-effects in ensemble studies.

[ascl:1706.010]
EXOSIMS: Exoplanet Open-Source Imaging Mission Simulator

EXOSIMS generates and analyzes end-to-end simulations of space-based exoplanet imaging missions. The software is built up of interconnecting modules describing different aspects of the mission, including the observatory, optical system, and scheduler (encoding mission rules) as well as the physical universe, including the assumed distribution of exoplanets and their physical and orbital properties. Each module has a prototype implementation that is inherited by specific implementations for different missions concepts, allowing for the simulation of widely variable missions.

[ascl:1708.023]
ExoSOFT: Exoplanet Simple Orbit Fitting Toolbox

ExoSOFT provides orbital analysis of exoplanets and binary star systems. It fits any combination of astrometric and radial velocity data, and offers four parameter space exploration techniques, including MCMC. It is packaged with an automated set of post-processing and plotting routines to summarize results, and is suitable for performing orbital analysis during surveys with new radial velocity and direct imaging instruments.

[ascl:1706.001]
Exotrending: Fast and easy-to-use light curve detrending software for exoplanets

The simple, straightforward Exotrending code detrends exoplanet transit light curves given a light curve (flux versus time) and good ephemeris (epoch of first transit and orbital period). The code has been tested with Kepler and K2 light curves and should work with any other light curve.

[ascl:1212.013]
EXSdetect: Extended X-ray Source Detection

Liu, Teng; Tozzi, Paolo; Tundo, Elena; Moretti, A.; Wang, Jun-Xian; Rosati, Piero; Guglielmetti, Fabrizia

EXSdetect is a python implementation of an X-ray source detection algorithm which is optimally designed to detected faint extended sources and makes use of Voronoi tessellation and Friend-of-Friend technique. It is a flexible tool capable of detecting extended sources down to the lowest flux levels attainable within instrumental limitations while maintaining robust photometry, high completeness, and low contamination, regardless of source morphology. EXSdetect was developed mainly to exploit the ever-increasing wealth of archival X-ray data, but is also ideally suited to explore the scientific capabilities of future X-ray facilities, with a strong focus on investigations of distant groups and clusters of galaxies.

[ascl:9906.002]
EXTINCT: A computerized model of large-scale visual interstellar extinction

The program EXTINCT.FOR is a FORTRAN subroutine summarizing a three-dimensional visual Galactic extinction model, based on a number of published studies. INPUTS: Galactic latitude (degrees), Galactic longitude (degrees), and source distance (kpc). OUTPUTS (magnitudes): Extinction, extinction error, a statistical correction term, and an array containing extinction and extinction error from each subroutine. The model is useful for correcting visual magnitudes of Galactic sources (particularly in statistical models), and has been used to find Galactic extinction of extragalactic sources. The model's limited angular resolution (subroutine-dependent, but with a minimum resolution of roughly 2 degrees) is necessitated by its ability to describe three-dimensional structure.

[ascl:1708.025]
extinction-distances: Estimating distances to dark clouds

Extinction-distances uses the number of foreground stars and a Galactic model of the stellar distribution to estimate the distance to dark clouds. It exploits the relatively narrow range of intrinsic near-infrared colors of stars to separate foreground from background stars. An advantage of this method is that the distribution of stellar colors in the Galactic model need not be precisely correct, only the number density as a function of distance from the Sun.

[ascl:1803.011]
ExtLaw_H18: Extinction law code

Hosek, Matthew W., Jr.; Lu, Jessica R.; Anderson, Jay; Do, Tuan; Schlafly, Edward F.; Ghez, Andrea M.; Clarkson, William I.; Morris, Mark R.; Albers, Saundra M.

ExtLaw_H18 generates the extinction law between 0.8 - 2.2 microns. The law is derived using the Westerlund 1 (Wd1) main sequence (A_Ks ~ 0.6 mag) and Arches cluster field Red Clump at the Galactic Center (A_Ks ~ 2.7 mag). To derive the law a Wd1 cluster age of 5 Myr is assumed, though changing the cluster age between 4 Myr -- 7 Myr has no effect on the law. This extinction law can be applied to highly reddened stellar populations that have similar foreground material as Wd1 and the Arches RC, namely dust from the spiral arms of the Milky Way in the Galactic Plane.

[ascl:1010.032]
Extreme Deconvolution: Density Estimation using Gaussian Mixtures in the Presence of Noisy, Heterogeneous and Incomplete Data

Extreme-deconvolution is a general algorithm to infer a d-dimensional distribution function from a set of heterogeneous, noisy observations or samples. It is fast, flexible, and treats the data's individual uncertainties properly, to get the best description possible for the underlying distribution. It performs well over the full range of density estimation, from small data sets with only tens of samples per dimension, to large data sets with hundreds of thousands of data points.

[ascl:1010.061]
EyE: Enhance Your Extraction

In EyE (Enhance Your Extraction) an artificial neural network connected to pixels of a moving window (retina) is trained to associate these input stimuli to the corresponding response in one or several output image(s). The resulting filter can be loaded in SExtractor to operate complex, wildly non-linear filters on astronomical images. Typical applications of EyE include adaptive filtering, feature detection and cosmetic corrections.

[ascl:1407.019]
EZ_Ages: Stellar population age calculator

EZ_Ages is an IDL code package that computes the mean, light-weighted stellar population age, [Fe/H], and abundance enhancements [Mg/Fe], [C/Fe], [N/Fe], and [Ca/Fe] for unresolved stellar populations. This is accomplished by comparing Lick index line strengths between the data and the stellar population models of Schiavon (2007), using a method described in Graves & Schiavon (2008). The algorithm uses the inversion of index-index model grids to determine ages and abundances, and exploits the sensitivities of the various Lick indices to measure Mg, C, N, and Ca enhancements over their solar abundances with respect to Fe.

[ascl:1210.004]
EZ: A Tool For Automatic Redshift Measurement

EZ (Easy-Z) estimates redshifts for extragalactic objects. It compares the observed spectrum with a set of (user given) spectral templates to find out the best value for the redshift. To accomplish this task, it uses a highly configurable set of algorithms. EZ is easily extendible with new algorithms. It is implemented as a set of C programs and a number of python classes. It can be used as a standalone program, or the python classes can be directly imported by other applications.

[ascl:1208.021]
EzGal: A Flexible Interface for Stellar Population Synthesis Models

EzGal is a flexible Python program which generates observable parameters (magnitudes, colors, and mass-to-light ratios) for arbitrary input stellar population synthesis (SPS) models; it enables simple, direct comparison of different model sets so that the uncertainty introduced by choice of model set can be quantified. EzGal is also capable of generating composite stellar population models (CSPs) for arbitrary input star-formation histories and reddening laws, and can be used to interpolate between metallicities for a given model set.

[ascl:1705.006]
f3: Full Frame Fotometry for Kepler Full Frame Images

Light curves from the Kepler telescope rely on "postage stamp" cutouts of a few pixels near each of 200,000 target stars. These light curves are optimized for the detection of short-term signals like planet transits but induce systematics that overwhelm long-term variations in stellar flux. Longer-term effects can be recovered through analysis of the Full Frame Images, a set of calibration data obtained monthly during the Kepler mission. The Python package f3 analyzes the Full Frame Images to infer long-term astrophysical variations in the brightness of Kepler targets, such as magnetic activity or sunspots on slowly rotating stars.

[ascl:1802.001]
FAC: Flexible Atomic Code

FAC calculates various atomic radiative and collisional processes, including radiative transition rates, collisional excitation and ionization by electron impact, energy levels, photoionization, and autoionization, and their inverse processes radiative recombination and dielectronic capture. The package also includes a collisional radiative model to construct synthetic spectra for plasmas under different physical conditions.

[ascl:1509.004]
FalconIC: Initial conditions generator for cosmological N-body simulations in Newtonian, Relativistic and Modified theories

FalconIC generates discrete particle positions, velocities, masses and pressures based on linear Boltzmann solutions that are computed by libraries such as CLASS and CAMB. FalconIC generates these initial conditions for any species included in the selection, including Baryons, Cold Dark Matter and Dark Energy fluids. Any species can be set in Eulerian (on a fixed grid) or Lagrangian (particle motion) representation, depending on the gauge and reality chosen. That is, for relativistic initial conditions in the synchronous comoving gauge, Dark Matter can only be described in an Eulerian representation. For all other choices (Relativistic in Longitudinal gauge, Newtonian with relativistic expansion rates, Newtonian without any notion of radiation), all species can be treated in all representations. The code also computes spectra. FalconIC is useful for comparative studies on initial conditions.

[ascl:1402.016]
FAMA: Fast Automatic MOOG Analysis

Magrini, Laura; Randich, Sofia; Friel, Eileen; Spina, Lorenzo; Jacobson, Heather; Cantat-Gaudin, Tristan; Donati, Paolo; Baglioni, Roberto; Maiorca, Enrico; Bragaglia, Angela; Sordo, Rosanna; Vallenari, Antonella

FAMA (Fast Automatic MOOG Analysis), written in Perl, computes the atmospheric parameters and abundances of a large number of stars using measurements of equivalent widths (EWs) automatically and independently of any subjective approach. Based on the widely-used MOOG code, it simultaneously searches for three equilibria, excitation equilibrium, ionization balance, and the relationship between logn(FeI) and the reduced EWs. FAMA also evaluates the statistical errors on individual element abundances and errors due to the uncertainties in the stellar parameters. Convergence criteria are not fixed "a priori" but instead are based on the quality of the spectra.

[ascl:1209.014]
FAMIAS: Frequency Analysis and Mode Identification for AsteroSeismology

FAMIAS (Frequency Analysis and Mode Identification for Asteroseismology) is a package of software tools programmed in C++ for the analysis of photometric and spectroscopic time-series data. FAMIAS provides analysis tools that are required for the steps between the data reduction and the seismic modeling. Two main sets of tools are incorporated in FAMIAS. The first set permits to search for periodicities in the data using Fourier and non-linear least-squares fitting techniques. The other set permits to carry out a mode identification for the detected pulsation frequencies to determine their harmonic degree l, and azimuthal order m. FAMIAS is applicable to main-sequence pulsators hotter than the Sun. This includes Gamma Dor, Delta Sct stars, slowly pulsating B (SPB)-stars and Beta Cep stars - basically all stars for which empirical mode identification is required to successfully carry out asteroseismology.

[ascl:1102.017]
FARGO: Fast Advection in Rotating Gaseous Objects

FARGO is an efficient and simple modification of the standard transport algorithm used in explicit eulerian fixed polar grid codes, aimed at getting rid of the average azimuthal velocity when applying the Courant condition. This results in a much larger timestep than the usual procedure, and it is particularly well-suited to the description of a Keplerian disk where one is traditionally limited by the very demanding Courant condition on the fast orbital motion at the inner boundary. In this modified algorithm, the timestep is limited by the perturbed velocity and by the shear arising from the differential rotation. The speed-up resulting from the use of the FARGO algorithm is problem dependent. In the example presented in the code paper below, which shows the evolution of a Jupiter sized protoplanet embedded in a minimum mass protoplanetary nebula, the FARGO algorithm is about an order of magnitude faster than a traditional transport scheme, with a much smaller numerical diffusivity.

[ascl:1509.006]
FARGO3D: Hydrodynamics/magnetohydrodynamics code

A successor of FARGO (ascl:1102.017), FARGO3D is a versatile HD/MHD code that runs on clusters of CPUs or GPUs, with special emphasis on protoplanetary disks. FARGO3D offers Cartesian, cylindrical or spherical geometry; 1-, 2- or 3-dimensional calculations; and orbital advection (aka FARGO) for HD and MHD calculations. As in FARGO, a simple Runge-Kutta N-body solver may be used to describe the orbital evolution of embedded point-like objects. There is no need to know CUDA; users can develop new functions in C and have them translated to CUDA automatically to run on GPUs.

[submitted]
Fast Template Periodogram

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

[ascl:1010.010]
Fast WMAP Likelihood Code and GSR PC Functions

We place functional constraints on the shape of the inflaton potential from the cosmic microwave background through a variant of the generalized slow roll approximation that allows large amplitude, rapidly changing deviations from scale-free conditions. Employing a principal component decomposition of the source function G'~3(V'/V)^2 - 2V''/V and keeping only those measured to better than 10% results in 5 nearly independent Gaussian constraints that maybe used to test any single-field inflationary model where such deviations are expected. The first component implies < 3% variations at the 100 Mpc scale. One component shows a 95% CL preference for deviations around the 300 Mpc scale at the ~10% level but the global significance is reduced considering the 5 components examined. This deviation also requires a change in the cold dark matter density which in a flat LCDM model is disfavored by current supernova and Hubble constant data and can be tested with future polarization or high multipole temperature data. Its impact resembles a local running of the tilt from multipoles 30-800 but is only marginally consistent with a constant running beyond this range. For this analysis, we have implemented a ~40x faster WMAP7 likelihood method which we have made publicly available.

[ascl:1603.006]
FAST-PT: Convolution integrals in cosmological perturbation theory calculator

FAST-PT calculates 1-loop corrections to the matter power spectrum in cosmology. The code utilizes Fourier methods combined with analytic expressions to reduce the computation time down to scale as N log N, where N is the number of grid point in the input linear power spectrum. FAST-PT is extremely fast, enabling mode-coupling integral computations fast enough to embed in Monte Carlo Markov Chain parameter estimation.

[ascl:1803.008]
FAST: Fitting and Assessment of Synthetic Templates

Kriek, Mariska; van Dokkum, Pieter G.; Labbé, Ivo; Franx, Marijn; Illingworth, Garth D.; Marchesini, Danilo; Quadri, Ryan F.; Aird, James; Coil, Alison L.; Georgakakis, Antonis

FAST (Fitting and Assessment of Synthetic Templates) fits stellar population synthesis templates to broadband photometry and/or spectra. FAST is compatible with the photometric redshift code EAzY (ascl:1010.052) when fitting broadband photometry; it uses the photometric redshifts derived by EAzY, and the input files (for examply, photometric catalog and master filter file) are the same. FAST fits spectra in combination with broadband photometric data points or simultaneously fits two components, allowing for an AGN contribution in addition to the host galaxy light. Depending on the input parameters, FAST outputs the best-fit redshift, age, dust content, star formation timescale, metallicity, stellar mass, star formation rate (SFR), and their confidence intervals. Though some of FAST's functions overlap with those of HYPERZ (ascl:1108.010), it differs by fitting fluxes instead of magnitudes, allows the user to completely define the grid of input stellar population parameters and easily input photometric redshifts and their confidence intervals, and calculates calibrated confidence intervals for all parameters. Note that FAST is not a photometric redshift code, though it can be used as one.

[ascl:1804.025]
FastChem: An ultra-fast equilibrium chemistry

FastChem is an equilibrium chemistry code that calculates the chemical composition of the gas phase for given temperatures and pressures. Written in C++, it is based on a semi-analytic approach, and is optimized for extremely fast and accurate calculations.

[ascl:1010.037]
FastChi: A Fast Chi-squared Technique For Period Search of Irregularly Sampled Data

The Fast Chi-Squared Algorithm is a fast, powerful technique for detecting periodicity. It was developed for analyzing variable stars, but is applicable to many of the other applications where the Fast Fourier Transforms (FFTs) or other periodograms (such as Lomb-Scargle) are currently used. The Fast Chi-squared technique takes a data set (e.g. the brightness of a star measured at many different times during a series of observations) and finds the periodic function that has the best frequency and shape (to an arbitrary number of harmonics) to fit the data. Among its advantages are:

- Statistical efficiency: all of the data are used, weighted by their individual error bars, giving a result with a significance calibrated in well-understood Chi-squared statistics.
- Sensitivity to harmonic content: many conventional techniques look only at the significance (or the amplitude) of the fundamental sinusoid and discard the power of the higher harmonics.
- Insensitivity to the sample timing: you won't find a period of 24 hours just because you take your observations at night. You do not need to window your data.
- The frequency search is gridded more tightly than the traditional "integer number of cycles over the span of observations", eliminating power loss from peaks that fall between the grid points.
- Computational speed: The complexity of the algorithm is O(NlogN), where N is the number of frequencies searched, due to its use of the FFT.

[ascl:9910.003]
FASTELL: Fast calculation of a family of elliptical mass gravitational lens models

Because of their simplicity, axisymmetric mass distributions are often used to model gravitational lenses. Since galaxies are usually observed to have elliptical light distributions, mass distributions with elliptical density contours offer more general and realistic lens models. They are difficult to use, however, since previous studies have shown that the deflection angle (and magnification) in this case can only be obtained by rather expensive numerical integrations. We present a family of lens models for which the deflection can be calculated to high relative accuracy (10-5) with a greatly reduced numerical effort, for small and large ellipticity alike. This makes it easier to use these distributions for modeling individual lenses as well as for applications requiring larger computing times, such as statistical lensing studies. FASTELL is a code to calculate quickly and accurately the lensing deflection and magnification matrix for the softened power-law elliptical mass distribution (SPEMD) lens galaxy model. The SPEMD consists of a softened power-law radial distribution with elliptical isodensity contours.

[ascl:1010.041]
FASTLens (FAst STatistics for weak Lensing): Fast Method for Weak Lensing Statistics and Map Making

The analysis of weak lensing data requires to account for missing data such as masking out of bright stars. To date, the majority of lensing analyses uses the two point-statistics of the cosmic shear field. These can either be studied directly using the two-point correlation function, or in Fourier space, using the power spectrum. The two-point correlation function is unbiased by missing data but its direct calculation will soon become a burden with the exponential growth of astronomical data sets. The power spectrum is fast to estimate but a mask correction should be estimated. Other statistics can be used but these are strongly sensitive to missing data. The solution that is proposed by FASTLens is to properly fill-in the gaps with only NlogN operations, leading to a complete weak lensing mass map from which one can compute straight forwardly and with a very good accuracy any kind of statistics like power spectrum or bispectrum.

[ascl:1302.008]
FASTPHOT: A simple and quick IDL PSF-fitting routine

PSF fitting photometry allows a simultaneously fit of a PSF profile on the sources. Many routines use PSF fitting photometry, including IRAF/allstar, Strarfinder, and Convphot. These routines are in general complex to use and slow. FASTPHOT is optimized for prior extraction (the position of the sources is known) and is very fast and simple.

[ascl:1507.011]
FAT: Fully Automated TiRiFiC

Kamphuis, P.; Józsa, G. I. G.; Oh, S-. H.; Spekkens, K.; Urbancic, N.; Serra, P.; Koribalski, B. S.; Dettmar, R.-J.

FAT (Fully Automated TiRiFiC) is an automated procedure that fits tilted-ring models to Hi data cubes of individual, well-resolved galaxies. The method builds on the 3D Tilted Ring Fitting Code (TiRiFiC, ascl:1208.008). FAT accurately models the kinematics and the morphologies of galaxies with an extent of eight beams across the major axis in the inclination range 20°-90° without the need for priors such as disc inclination. FAT's performance allows us to model the gas kinematics of many thousands of well-resolved galaxies, which is essential for future HI surveys, with the Square Kilometre Array and its pathfinders.

[ascl:1711.017]
FATS: Feature Analysis for Time Series

Nun, Isadora; Protopapas, Pavlos; Sim, Brandon; Zhu, Ming; Dave, Rahul; Castro, Nicolas; Pichara, Karim

FATS facilitates and standardizes feature extraction for time series data; it quickly and efficiently calculates a compilation of many existing light curve features. Users can characterize or analyze an astronomical photometric database, though this library is not necessarily restricted to the astronomical domain and can also be applied to any kind of time series data.

[ascl:1712.011]
FBEYE: Analyzing Kepler light curves and validating flares

FBEYE, the "Flares By-Eye" detection suite, is written in IDL and analyzes Kepler light curves and validates flares. It works on any 3-column light curve that contains time, flux, and error. The success of flare identification is highly dependent on the smoothing routine, which may not be suitable for all sources.

[ascl:1505.014]
FCLC: Featureless Classification of Light Curves

FCLC (Featureless Classification of Light Curves) software describes the static behavior of a light curve in a probabilistic way. Individual data points are converted to densities and consequently probability density are compared instead of features. This gives rise to an independent classification which can corroborate the usefulness of the selected features.

[ascl:1806.027]
fcmaker: Creating ESO-compliant finding charts for Observing Blocks on p2

fcmaker creates astronomical finding charts for Observing Blocks (OBs) on the p2 web server from the European Southern Observatory (ESO). It automates the creation of ESO-compliant finding charts for Service Mode and/or Visitor Mode OBs at the Very Large Telescope (VLT). The design of the fcmaker finding charts, based on an intimate knowledge of VLT observing procedures, is fine-tuned to best support night time operations. As an automated tool, fcmaker also allows observers to independently check visually, for the first time, the observing sequence coded inside an OB. This includes, for example, the signs of telescope and position angle offsets.

[ascl:1705.012]
fd3: Spectral disentangling of double-lined spectroscopic binary stars

The spectral disentangling technique can be applied on a time series of observed spectra of a spectroscopic double-lined binary star (SB2) to determine the parameters of orbit and reconstruct the spectra of component stars, without the use of template spectra. fd3 disentangles the spectra of SB2 stars, capable also of resolving the possible third companion. It performs the separation of spectra in the Fourier space which is faster, but in several respects less versatile than the wavelength-space separation. (Wavelength-space separation is implemented in the twin code CRES.) fd3 is written in C and is designed as a command-line utility for a Unix-like operating system. fd3 is a new version of FDBinary (ascl:1705.011), which is now deprecated.

[ascl:1705.011]
FDBinary: A tool for spectral disentangling of double-lined spectroscopic binary stars

FDBinary disentangles spectra of SB2 stars. The spectral disentangling technique can be applied on a time series of observed spectra of an SB2 to determine the parameters of orbit and reconstruct the spectra of component stars, without the use of template spectra. The code is written in C and is designed as a command-line utility for a Unix-like operating system. FDBinary uses the Fourier-space approach in separation of composite spectra. This code has been replaced with the newer fd3 (ascl:1705.012).

[ascl:1606.011]
FDIPS: Finite Difference Iterative Potential-field Solver

FDIPS is a finite difference iterative potential-field solver that can generate the 3D potential magnetic field solution based on a magnetogram. It is offered as an alternative to the spherical harmonics approach, as when the number of spherical harmonics is increased, using the raw magnetogram data given on a grid that is uniform in the sine of the latitude coordinate can result in inaccurate and unreliable results, especially in the polar regions close to the Sun. FDIPS is written in Fortran 90 and uses the MPI library for parallel execution.

[ascl:1604.011]
FDPS: Framework for Developing Particle Simulators

Iwasawa, Masaki; Tanikawa, Ataru; Hosono, Natsuki; Nitadori, Keigo; Muranushi, Takayuki; Makino, Junichiro

FDPS provides the necessary functions for efficient parallel execution of particle-based simulations as templates independent of the data structure of particles and the functional form of the interaction. It is used to develop particle-based simulation programs for large-scale distributed-memory parallel supercomputers. FDPS includes templates for domain decomposition, redistribution of particles, and gathering of particle information for interaction calculation. It uses algorithms such as Barnes-Hut tree method for long-range interactions; methods to limit the calculation to neighbor particles are used for short-range interactions. FDPS reduces the time and effort necessary to write a simple, sequential and unoptimized program of O(N^2) calculation cost, and produces compiled programs that will run efficiently on large-scale parallel supercomputers.

[ascl:1806.001]
feets: feATURE eXTRACTOR FOR tIME sERIES

feets characterizes and analyzes light-curves from astronomical photometric databases for modelling, classification, data cleaning, outlier detection and data analysis. It uses machine learning algorithms to determine the numerical descriptors that characterize and distinguish the different variability classes of light-curves; these range from basic statistical measures such as the mean or standard deviation to complex time-series characteristics such as the autocorrelation function. The library is not restricted to the astronomical field and could also be applied to any kind of time series. This project is a derivative work of FATS (ascl:1711.017).

[ascl:1203.004]
FERENGI: Full and Efficient Redshifting of Ensembles of Nearby Galaxy Images

Bandpass shifting and the (1+z)5 surface brightness dimming (for a fixed width filter) make standard tools for the extraction of structural parameters of galaxies wavelength dependent. If only few (or one) observed high-res bands exist, this dependence has to be corrected to make unbiased statements on the evolution of structural parameters or on galaxy subsamples defined by morphology. FERENGI artificially redshifts low-redshift galaxy images to different redshifts by applying the correct cosmological corrections for size, surface brightness and bandpass shifting. A set of artificially redshifted galaxies in the range 0.1<z<1.1 using a set of ~100 SDSS low-redshift (v<7000 km s-1) images as input has been created to use as a training set of realistic images of galaxies of diverse morphologies and a large range of redshifts for the GEMS and COSMOS galaxy evolution projects. This training set allows other studies to investigate and quantify the effects of cosmological redshift on the determination of galaxy morphologies, distortions, and other galaxy properties that are potentially sensitive to resolution, surface brightness, and bandpass issues. The data sets are also available for download from the FERENGI website.

[ascl:1812.006]
Fermipy: Fermi-LAT data analysis package

Wood, M.; Caputo, R.; Charles, E.; Di Mauro, M.; Magill, J.; Perkins, J. S.; Fermi-LAT Collaboration

Fermipy facilitates analysis of data from the Large Area Telescope (LAT) with the Fermi Science Tools. It is built on the pyLikelihood interface of the Fermi Science Tools and provides a set of high-level tools for performing common analysis tasks, including data and model preparation with the gt-tools, extracting a spectral energy distribution (SED) of a source, and generating TS and residual maps for a region of interest. Fermipy also finds new source candidates and can localize a source or fit its spatial extension. The package uses a configuration-file driven workflow in which the analysis parameters (data selection, IRFs, and ROI model) are defined in a YAML configuration file. Analysis is executed through a python script that calls the methods of GTAnalysis to perform different analysis operations.

[ascl:1208.011]
Fewbody: Numerical toolkit for simulating small-N gravitational dynamics

Fewbody is a numerical toolkit for simulating small-N gravitational dynamics. It is a general N-body dynamics code, although it was written for the purpose of performing scattering experiments, and therefore has several features that make it well-suited for this purpose. Fewbody uses the 8th-order Runge-Kutta Prince-Dormand integration method with 9th-order error estimate and adaptive timestep to advance the N-body system forward in time. It integrates the usual formulation of the N-body equations in configuration space, but allows for the option of global pairwise Kustaanheimo-Stiefel (K-S) regularization (Heggie 1974; Mikkola 1985). The code uses a binary tree algorithm to classify the N-body system into a set of independently bound hierarchies, and performs collisions between stars in the “sticky star” approximation. Fewbody contains a collection of command line utilities that can be used to perform individual scattering and N-body interactions, but is more generally a library of functions that can be used from within other codes.

[ascl:1512.017]
FFTLog: Fast Fourier or Hankel transform

FFTLog is a set of Fortran subroutines that compute the fast Fourier or Hankel (= Fourier-Bessel) transform of a periodic sequence of logarithmically spaced points. FFTLog can be regarded as a natural analogue to the standard Fast Fourier Transform (FFT), in the sense that, just as the normal FFT gives the exact (to machine precision) Fourier transform of a linearly spaced periodic sequence, so also FFTLog gives the exact Fourier or Hankel transform, of arbitrary order m, of a logarithmically spaced periodic sequence.

[ascl:1201.015]
FFTW: Fastest Fourier Transform in the West

FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more dimensions, of arbitrary input size, and of both real and complex data (as well as of even/odd data, i.e. the discrete cosine/sine transforms or DCT/DST).

Benchmarks performed on a variety of platforms show that FFTW's performance is typically superior to that of other publicly available FFT software, and is even competitive with vendor-tuned codes. In contrast to vendor-tuned codes, however, FFTW's performance is portable: the same program will perform well on most architectures without modification.

The FFTW library is required by other codes such as StarCrash and Hammurabi.

[ascl:1603.014]
fibmeasure: Python/Cython module to find the center of back-illuminated optical fibers in metrology images

fibmeasure finds the precise locations of the centers of back-illuminated optical fibers in images. It was developed for astronomical fiber positioning feedback via machine vision cameras and is optimized for high-magnification images where fibers appear as resolvable circles. It was originally written during the design of the WEAVE pick-and-place fiber positioner for the William Herschel Telescope.

[ascl:1111.013]
FIBRE-pac: FMOS Image-based Reduction Package

Iwamuro, F.; Moritani, Y.; Yabe, K.; Sumiyoshi, M.; Kawate, K.; Tamura, N.; Akiyama, M.; Kimura, M.; Takato, N.; Tait, P.; Ohta, K.; Totani, T.; Suzuki, Y.; Tonegawa, M.

The FIBRE-pac (FMOS image-based reduction package) is an IRAF-based reduction tool for the fiber multiple-object spectrograph (FMOS) of the Subaru telescope. To reduce FMOS images, a number of special techniques are necessary because each image contains about 200 separate spectra with airglow emission lines variable in spatial and time domains, and with complicated throughput patterns for the airglow masks. In spite of these features, almost all of the reduction processes except for a few steps are carried out automatically by scripts in text format making it easy to check the commands step by step. Wavelength- and flux-calibrated images together with their noise maps are obtained using this reduction package.

[ascl:1307.004]
FieldInf: Field Inflation exact integration routines

FieldInf is a collection of fast modern Fortran routines for computing exactly the background evolution and primordial power spectra of any single field inflationary models. It implements reheating without any assumptions through the "reheating parameter" R allowing robust inflationary parameter estimations and inference on the reheating energy scale. The underlying perturbation code actually deals with N fields minimally-coupled and/or non-minimally coupled to gravity and works for flat FLRW only.

[ascl:1708.009]
FIEStool: Automated data reduction for FIber-fed Echelle Spectrograph (FIES)

FIEStool automatically reduces data obtained with the FIber-fed Echelle Spectrograph (FIES) at the Nordic Optical Telescope, a high-resolution spectrograph available on a stand-by basis, while also allowing the basic properties of the reduction to be controlled in real time by the user. It provides a Graphical User Interface and offers bias subtraction, flat-fielding, scattered-light subtraction, and specialized reduction tasks from the external packages IRAF (ascl:9911.002) and NumArray. The core of FIEStool is instrument-independent; the software, written in Python, could with minor modifications also be used for automatic reduction of data from other instruments.

[ascl:1203.013]
Figaro: Data Reduction Software

Figaro is a data reduction system that originated at Caltech and whose development continued at the Anglo-Australian Observatory. Although it is intended to be able to deal with any sort of data, almost all its applications to date are geared towards processing optical and infrared data. Figaro uses hierarchical data structures to provide flexibility in its data file formats. Figaro was originally written to run under DEC's VMS operating system, but is now available both for VMS and for various flavours of UNIX.

[ascl:1608.009]
FilFinder: Filamentary structure in molecular clouds

FilFinder extracts and analyzes filamentary structure in molecular clouds. In particular, it is capable of uniformly extracting structure over a large dynamical range in intensity. It returns the main filament properties: local amplitude and background, width, length, orientation and curvature. FilFinder offers additional tools to, for example, create a filament-only image based on the properties of the radial fits. The resulting mask and skeletons may be saved in FITS format, and property tables may be saved as a CSV, FITS or LaTeX table.

[ascl:1602.007]
FilTER: Filament Trait-Evaluated Reconstruction

FilTER (Filament Trait-Evaluated Reconstruction) post-processes output from DisPerSE (ascl:1302.015

[ascl:1808.006]
Fips: An OpenGL based FITS viewer

FIPS is a cross-platform FITS viewer with a responsive user interface. Unlike other FITS viewers, FIPS uses GPU hardware via OpenGL to provide functionality such as zooming, panning and level adjustments. OpenGL 2.1 and later is supported. FIPS supports all 2D image formats except floating point formats on OpenGL 2.1. FITS image extension has basic limited support.

[ascl:1810.021]
Firefly: Interactive exploration of particle-based data

Firefly provides interactive exploration of particle-based data in the browser. The user can filter, display vector fields, and toggle the visibility of their customizable datasets all on-the-fly. Different Firefly visualizations, complete with preconfigured data and camera view-settings, can be shared by URL. As Firefly is written in WebGL, it can be hosted online, though Firefly can also be used locally, without an internet connection. Firefly was developed with simulations of galaxy formation in mind but is flexible enough to display any particle-based data. Other features include a stereoscopic 3D picture mode and mobile compatibility.

[ascl:1202.014]
FISA: Fast Integrated Spectra Analyzer

FISA (Fast Integrated Spectra Analyzer) permits fast and reasonably accurate age and reddening determinations for small angular diameter open clusters by using their integrated spectra in the (3600-7400) AA range and currently available template spectrum libraries. This algorithm and its implementation help to achieve astrophysical results in shorter times than from other methods. FISA has successfully been applied to integrated spectroscopy of open clusters, both in the Galaxy and in the Magellanic Clouds, to determine ages and reddenings.

[ascl:1010.070]
Fisher.py: Fisher Matrix Manipulation and Confidence Contour Plotting

Fisher.py allows you to combine constraints from multiple experiments (e.g., weak lensing + supernovae) and add priors (e.g., a flat universe) simply and easily. Calculate parameter uncertainties and plot confidence ellipses. Fisher matrix expectations for several experiments are included as calculated by myself (time delays) and the Dark Energy Task Force (WL/SN/BAO/CL/CMB), or provide your own.

[ascl:1201.007]
Fisher4Cast: Fisher Matrix Toolbox

The Fisher4Cast suite, which requires MatLab, provides a standard, tested tool set for general Fisher Information matrix prediction and forecasting for use in both research and education. The toolbox design is robust and modular, allowing for easy additions and adaptation while keeping the user interface intuitive and easy to use. Fisher4Cast is completely general but the default is coded for cosmology. It provides parameter error forecasts for cosmological surveys providing distance, Hubble expansion and growth measurements in a general, curved FLRW background.

[ascl:1609.004]
FISHPACK: Efficient FORTRAN Subprograms for the Solution of Separable Elliptic Partial Differential Equations

The FISHPACK collection of Fortran77 subroutines solves second- and fourth-order finite difference approximations to separable elliptic Partial Differential Equations (PDEs). These include Helmholtz equations in cartesian, polar, cylindrical, and spherical coordinates, as well as more general separable elliptic equations. The solvers use the cyclic reduction algorithm. When the problem is singular, a least-squares solution is computed. Singularities induced by the coordinate system are handled, including at the origin r=0 in cylindrical coordinates, and at the poles in spherical coordinates.

[ascl:1609.005]
FISHPACK90: Efficient FORTRAN Subprograms for the Solution of Separable Elliptic Partial Differential Equations

FISHPACK90 is a modernization of the original FISHPACK (ascl:1609.004), employing Fortran90 to slightly simplify and standardize the interface to some of the routines. This collection of Fortran programs and subroutines solves second- and fourth-order finite difference approximations to separable elliptic Partial Differential Equations (PDEs). These include Helmholtz equations in cartesian, polar, cylindrical, and spherical coordinates, as well as more general separable elliptic equations. The solvers use the cyclic reduction algorithm. When the problem is singular, a least-squares solution is computed. Singularities induced by the coordinate system are handled, including at the origin r=0 in cylindrical coordinates, and at the poles in spherical coordinates. Test programs are provided for the 19 solvers. Each serves two purposes: as a template to guide you in writing your own codes utilizing the FISHPACK90 solvers, and as a demonstration on your computer that you can correctly produce FISHPACK90 executables.

[ascl:1601.016]
Fit Kinematic PA: Fit the global kinematic position-angle of galaxies

Fit kinematic PA measures the global kinematic position-angle (PA) from integral field observations of a galaxy stellar or gas kinematics; the code is available in IDL and Python.

[ascl:1609.015]
FIT3D: Fitting optical spectra

Sánchez, S. F.; Pérez, E.; Sánchez-Blázquez, P.; González, J. J.; Rosales-Ortega, F. F.; Cano-Díaz, M.; López-Cobá, C.; Marino, R. A.; Gil de Paz, A.; Mollá, M.; López-Sánchez, A. R.; Ascasibar, Y.; Barrera-Ballesteros, J.

FIT3D fits optical spectra to deblend the underlying stellar population and the ionized gas, and extract physical information from each component. FIT3D is focused on the analysis of Integral Field Spectroscopy data, but is not restricted to it, and is the basis of Pipe3D, a pipeline used in the analysis of datasets like CALIFA, MaNGA, and SAMI. It can run iteratively or in an automatic way to derive the parameters of a large set of spectra.

[ascl:1305.011]
FITDisk: Cataclysmic Variable Accretion Disk Demonstration Tool

FITDisk models accretion disk phenomena using a fully three-dimensional hydrodynamics calculation, and data can either be visualized as they are computed or stored to hard drive for later playback at a fast frame rate. Simulations are visualized using OpenGL graphics and the viewing angle can be changed interactively. Pseudo light curves of simulated systems can be plotted along with the associated Fourier amplitude spectrum. It provides an easy to use graphical user interface as well as 3-D interactive graphics. The code computes the evolution of a CV accretion disk, visualizes results in real time, records and plays back simulations, and generates and plots pseudo light curves and associated power spectra. FITDisk is the Windows executable form of this software; its Fortran source code is also available as DiskSim (ascl:1811.013).

[ascl:1206.002]
FITS Liberator: Image processing software

Lindberg Christensen, Lars; Nielsen, Lars Holm; Nielsen, Kaspar K.; Johansen, Teis; Hurt, Robert; de Martin, David

The ESA/ESO/NASA FITS Liberator makes it possible to process and edit astronomical science data in the FITS format to produce stunning images of the universe. Formerly a plugin for Adobe Photoshop, the current version of FITS Liberator is a stand-alone application and no longer requires Photoshop. This image processing software makes it possible to create color images using raw observations from a range of telescopes; the FITS Liberator continues to support the FITS and PDS formats, preferred by astronomers and planetary scientists respectively, which enables data to be processed from a wide range of telescopes and planetary probes, including ESO’s Very Large Telescope, the NASA/ESA Hubble Space Telescope, NASA’s Spitzer Space Telescope, ESA’s XMM–Newton Telescope and Cassini–Huygens or Mars Reconnaissance Orbiter.

[ascl:1505.029]
fits2hdf: FITS to HDFITS conversion

fits2hdf ports FITS files to Hierarchical Data Format (HDF5) files in the HDFITS format. HDFITS allows faster reading of data, higher compression ratios, and higher throughput. HDFITS formatted data can be presented transparently as an in-memory FITS equivalent by changing the import lines in Python-based FITS utilities. fits2hdf includes a utility to port MeasurementSets (MS) to HDF5 files.

[ascl:1710.018]
FITSFH: Star Formation Histories

FITSFH derives star formation histories from photometry of resolved stellar populations by populating theoretical isochrones according to a chosen stellar initial mass function (IMF) and searching for the linear combination of isochrones with different ages and metallicities that best matches the data. In comparing the synthetic and real data, observational errors and incompleteness are taken into account, and a rudimentary treatment of the effect of unresolved binaries is also implemented. The code also allows for an age-dependent range of extinction values to be included in the modelling.

[ascl:1111.014]
FITSH: Software Package for Image Processing

FITSH provides a standalone environment for analysis of data acquired by imaging astronomical detectors. The package provides utilities both for the full pipeline of subsequent related data processing steps (including image calibration, astrometry, source identification, photometry, differential analysis, low-level arithmetic operations, multiple image combinations, spatial transformations and interpolations, etc.) and for aiding the interpretation of the (mainly photometric and/or astrometric) results. The package also features a consistent implementation of photometry based on image subtraction, point spread function fitting and aperture photometry and provides easy-to-use interfaces for comparisons and for picking the most suitable method for a particular problem. The utilities in the package are built on the top of the commonly used UNIX/POSIX shells (hence the name of the package), therefore both frequently used and well-documented tools for such environments can be exploited and managing massive amount of data is rather convenient.

[ascl:1107.003]
FITSManager: Management of Personal Astronomical Data

Cui, Chenzhou; Fan, Dongwei; Zhao, Yongheng; Kembhavi, Ajit; He, Boliang; Cao, Zihuang; Li, Jian; Nandrekar, Deoyani

With the increase of personal storage capacity, it is easy to find hundreds to thousands of FITS files in the personal computer of an astrophysicist. Because Flexible Image Transport System (FITS) is a professional data format initiated by astronomers and used mainly in the small community, data management toolkits for FITS files are very few. Astronomers need a powerful tool to help them manage their local astronomical data. Although Virtual Observatory (VO) is a network oriented astronomical research environment, its applications and related technologies provide useful solutions to enhance the management and utilization of astronomical data hosted in an astronomer's personal computer. FITSManager is such a tool to provide astronomers an efficient management and utilization of their local data, bringing VO to astronomers in a seamless and transparent way. FITSManager provides fruitful functions for FITS file management, like thumbnail, preview, type dependent icons, header keyword indexing and search, collaborated working with other tools and online services, and so on. The development of the FITSManager is an effort to fill the gap between management and analysis of astronomical data.

[ascl:1709.011]
FLaapLUC: Fermi-LAT automatic aperture photometry light curve

Most high energy sources detected with Fermi-LAT are blazars, which are highly variable sources. High cadence long-term monitoring simultaneously at different wavelengths being prohibitive, the study of their transient activities can help shed light on our understanding of these objects. The early detection of such potentially fast transient events is the key for triggering follow-up observations at other wavelengths. FLaapLUC (Fermi-LAT automatic aperture photometry Light C↔Urve) uses the simple aperture photometry approach to effectively detect relative flux variations in a set of predefined sources and alert potential users. Such alerts can then be used to trigger observations of these sources with other facilities. The FLaapLUC pipeline is built on top of the Science Tools provided by the Fermi-LAT collaboration and quickly generates short- or long-term Fermi-LAT light curves.

[ascl:1710.007]
FLAG: Exact Fourier-Laguerre transform on the ball

FLAG is a fast implementation of the Fourier-Laguerre Transform, a novel 3D transform exploiting an exact quadrature rule of the ball to construct an exact harmonic transform in 3D spherical coordinates. The angular part of the Fourier-Laguerre transform uses the MW sampling theorem and the exact spherical harmonic transform implemented in the SSHT code. The radial sampling scheme arises from an exact quadrature of the radial half-line using damped Laguerre polynomials. The radial transform can in fact be used to compute the spherical Bessel transform exactly, and the Fourier-Laguerre transform is thus closely related to the Fourier-Bessel transform.

[ascl:1112.007]
FLAGCAL: FLAGging and CALlibration Pipeline for GMRT Data

FLAGging and CALlibration (FLAGCAL) is a software pipeline developed for automatic flagging and calibration of the GMRT data. This pipeline can be used for preprocessing (before importing the data in AIPS) any other interferromteric data also (given that the data file is in FITS format and contains multiple channels & scans).There are also a few GUI based tools which can be used for quick visualization of the data.

[ascl:1811.007]
Flame: Near-infrared and optical spectroscopy data reduction pipeline

Flame reduces near-infrared and optical multi-object spectroscopic data. Although the pipeline was created for the LUCI instrument at the Large Binocular Telescope, Flame, written in IDL, is modular and can be adapted to work with data from other instruments. The software uses 2D transformations, thus using one interpolation step to wavelength calibrate and rectify the data. The γ(x, y) transformation also includes the spatial misalignment between frames, which can be measured from a reference star observed simultaneously with the science targets; sky subtraction can be performed via nodding and/or modelling of the sky spectrum.

[ascl:1010.082]
FLASH: Adaptive Mesh Hydrodynamics Code for Modeling Astrophysical Thermonuclear Flashes

Fryxell, B.; Olson, K.; Ricker, P.; Timmes, F. X.; Zingale, M.; Lamb, D. Q.; MacNeice, P.; Rosner, R.; Truran, J. W.; Tufo, H.

The FLASH code, currently in its 4th version, is a publicly available high performance application code which has evolved into a modular, extensible software system from a collection of unconnected legacy codes. FLASH consists of inter-operable modules that can be combined to generate different applications. The FLASH architecture allows arbitrarily many alternative implementations of its components to co-exist and interchange with each other. A simple and elegant mechanism exists for customization of code functionality without the need to modify the core implementation of the source. A built-in unit test framework combined with regression tests that run nightly on multiple platforms verify the code.

[ascl:1606.015]
FLASK: Full-sky Lognormal Astro-fields Simulation Kit

FLASK (Full-sky Lognormal Astro-fields Simulation Kit) makes tomographic realizations on the sphere of an arbitrary number of correlated lognormal or Gaussian random fields; it can create joint simulations of clustering and lensing with sub-per-cent accuracy over relevant angular scales and redshift ranges. It is C++ code parallelized with OpenMP; FLASK generates fast full-sky simulations of cosmological large-scale structure observables such as multiple matter density tracers (galaxies, quasars, dark matter haloes), CMB temperature anisotropies and weak lensing convergence and shear fields. The mutiple fields can be generated tomographically in an arbitrary number of redshift slices and all their statistical properties (including cross-correlations) are determined by the angular power spectra supplied as input and the multivariate lognormal (or Gaussian) distribution assumed for the fields. Effects like redshift space distortions, doppler distortions, magnification biases, evolution and intrinsic aligments can be introduced in the simulations via the input power spectra which must be supplied by the user.

[ascl:1612.006]
flexCE: Flexible one-zone chemical evolution code

flexCE (flexible Chemical Evolution) computes the evolution of a one-zone chemical evolution model with inflow and outflow in which gas is instantaneously and completely mixed. It can be used to demonstrate the sensitivity of chemical evolution models to parameter variations, show the effect of CCSN yields on chemical evolution models, and reproduce the 2D distribution in [O/Fe]{[Fe/H] by mixing models with a range of inflow and outflow histories. It can also post-process cosmological simulations to predict element distributions.

[ascl:1107.004]
Flexible DM-NRG

This code combines the spectral sum-conserving methods of Weichselbaum and von Delft and of Peters, Pruschke and Anders (both relying upon the complete basis set construction of Anders and Schiller) with the use of non-Abelian symmetries in a flexible manner: Essentially any non-Abelian symmetry can be taught to the code, and any number of such symmetries can be used throughout the computation for any density of states, and to compute any local operators' correlation function's real and imaginary parts or any thermodynamical expectation value. The code works both at zero and finite temperatures.

[ascl:1205.006]
Flexion: IDL code for calculating gravitational flexion

Gravitational flexion is a technique for measuring 2nd order gravitational lensing signals in background galaxies and radio lobes. Unlike shear, flexion directly probes variations of the potential field. Moreover, the information contained in flexion is orthogonal to what is found in the shear. Thus, we get the information "for free."

[ascl:1411.016]
Flicker: Mean stellar densities from flicker

Flicker calculates the mean stellar density of a star by inputting the flicker observed in a photometric time series. Written in Fortran90, its output may be used as an informative prior on stellar density when fitting transit light curves.

[ascl:1210.007]
FLUKA: Fully integrated particle physics Monte Carlo simulation package

Fassò, Alberto; Ferrari, Alfredo; Ranft, Johannes; Sala, Paola; Mairani, Andrea; Empl, Anton; Sommerer, Florian; Cerutti, Francesco; Battistoni, Giuseppe; Roesler, Stefan; Vlachoudis, Vasilis; Patera, Vincenzo; Aarnio, P.; Möhring, J.-H.; Stevenson, G. R.; Zazula, J. M.

FLUKA (FLUktuierende KAskade) is a general-purpose tool for calculations of particle transport and interactions with matter. FLUKA can simulate with high accuracy the interaction and propagation in matter of about 60 different particles, including photons and electrons from 1 keV to thousands of TeV, neutrinos, muons of any energy, hadrons of energies up to 20 TeV (up to 10 PeV by linking FLUKA with the DPMJET code) and all the corresponding antiparticles, neutrons down to thermal energies and heavy ions. The program, written in Fortran, can also transport polarised photons (e.g., synchrotron radiation) and optical photons. Time evolution and tracking of emitted radiation from unstable residual nuclei can be performed online.

[ascl:1105.008]
Flux Tube Model

This Fortran code computes magnetohydrostatic flux tubes and sheets according to the method of Steiner, Pneuman, & Stenflo (1986) A&A 170, 126-137. The code has many parameters contained in one input file that are easily modified. Extensive documentation is provided in README files.

[ascl:1712.010]
Flux Tube: Solar model

Flux Tube is a nonlinear, two-dimensional, numerical simulation of magneto-acoustic wave propagation in the photosphere and chromosphere of small-scale flux tubes with internal structure. Waves with realistic periods of three to five minutes are studied, after horizontal and vertical oscillatory perturbations are applied to the equilibrium model. Spurious reflections of shock waves from the upper boundary are minimized by a special boundary condition.

[ascl:1405.010]
FLUXES: Position and flux density of planets

Jenness, Tim; Privett, Grant; Matthews, Henry; Hohenkerk, Catherine; Barnard, Vicki; Tilanus, Remo; Watt, Graeme; Emerson, Jim

FLUXES calculates approximate topocentric positions of the planets and also integrated flux densities of five of them at several wavelengths. These provide calibration information at the effective frequencies and beam-sizes employed by the UKT14, SCUBA and SCUBA-2 receivers on the JCMT telescope based on Mauna Kea, Hawaii. FLUXES is part of the bundle that comprises the Starlink multi-purpose astronomy software package (ascl:1110.012).

[ascl:1011.019]
FLY: MPI-2 High Resolution code for LSS Cosmological Simulations

Cosmological simulations of structures and galaxies formations have played a fundamental role in the study of the origin, formation and evolution of the Universe. These studies improved enormously with the use of supercomputers and parallel systems and, recently, grid based systems and Linux clusters. Now we present the new version of the tree N-body parallel code FLY that runs on a PC Linux Cluster using the one side communication paradigm MPI-2 and we show the performances obtained. FLY is included in the Computer Physics Communication Program Library. This new version was developed using the Linux Cluster of CINECA, an IBM Cluster with 1024 Intel Xeon Pentium IV 3.0 Ghz. The results show that it is possible to run a 64 Million particle simulation in less than 15 minutes for each timestep, and the code scalability with the number of processors is achieved. This lead us to propose FLY as a code to run very large N-Body simulations with more than $10^{9}$ particles with the higher resolution of a pure tree code.

[ascl:1701.007]
Forecaster: Mass and radii of planets predictor

Forecaster predicts the mass (or radius) from the radius (or mass) for objects covering nine orders-of-magnitude in mass. It is an unbiased forecasting model built upon a probabilistic mass-radius relation conditioned on a sample of 316 well-constrained objects. It accounts for observational errors, hyper-parameter uncertainties and the intrinsic dispersions observed in the calibration sample.

[ascl:1405.007]
FORWARD: Forward modeling of coronal observables

Gibson, Sarah E.; Kucera, Therese A.; Casini, Roberto; Dove, James; Forland, Blake; Judge, Philip; Rachmeler, Laurel

FORWARD forward models various coronal observables and can access and compare existing data. Given a coronal model, it can produce many different synthetic observables (including Stokes polarimetry), as well as plots of model plasma properties (density, magnetic field, etc.). It uses the CHIANTI database (ascl:9911.004) and CLE polarimetry synthesis code, works with numerical model datacubes, interfaces with the PFSS module of SolarSoft (ascl:1208.013), includes several analytic models, and connects to the Virtual Solar Observatory for downloading data in a format directly comparable to model predictions.

[ascl:1204.004]
Fosite: 2D advection problem solver

Fosite implements a method for the solution of hyperbolic conservation laws in curvilinear orthogonal coordinates. It is written in Fortran 90/95 integrating object-oriented (OO) design patterns, incorporating the flexibility of OO-programming into Fortran 90/95 while preserving the efficiency of the numerical computation. Although mainly intended for CFD simulations, Fosite's modular design allows its application to other advection problems as well. Unlike other two-dimensional implementations of finite volume methods, it accounts for local conservation of specific angular momentum. This feature turns the program into a perfect tool for astrophysical simulations where angular momentum transport is crucial. Angular momentum transport is not only implemented for standard coordinate systems with rotational symmetry (i.e. cylindrical, spherical) but also for a general set of orthogonal coordinate systems allowing the use of exotic curvilinear meshes (e.g. oblate-spheroidal). As in the case of the advection problem, this part of the software is also kept modular, therefore new geometries may be incorporated into the framework in a straightforward manner.

[ascl:1610.012]
Fourierdimredn: Fourier dimensionality reduction model for interferometric imaging

Fourierdimredn (Fourier dimensionality reduction) implements Fourier-based dimensionality reduction of interferometric data. Written in Matlab, it derives the theoretically optimal dimensionality reduction operator from a singular value decomposition perspective of the measurement operator. Fourierdimredn ensures a fast implementation of the full measurement operator and also preserves the i.i.d. Gaussian properties of the original measurement noise.

[ascl:1806.030]
foxi: Forecast Observations and their eXpected Information

Using information theory and Bayesian inference, the foxi Python package computes a suite of expected utilities given futuristic observations in a flexible and user-friendly way. foxi requires a set of n-dim prior samples for each model and one set of n-dim samples from the current data, and can calculate the expected ln-Bayes factor between models, decisiveness between models and its maximum-likelihood averaged equivalent, the decisivity, and the expected Kullback-Leibler divergence (i.e., the expected information gain of the futuristic dataset). The package offers flexible inputs and is designed for all-in-one script calculation or an initial cluster run then local machine post-processing, which should make large jobs quite manageable subject to resources and includes features such as LaTeX tables and plot-making for post-data analysis visuals and convenience of presentation.

[ascl:1010.002]
fpack: FITS Image Compression Program

fpack is a utility program for optimally compressing images in the FITS data format. The associated funpack program will restore the compressed file back to its original state. These programs may be run from the host operating system command line and are analogous to the gzip and gunzip utility programs, except that they are specifically optimized for FITS format images and offer a wider choice of compression options.

fpack uses the tiled image compression convention for storing the compressed images. This convention can in principle support any number of of different compression algorithms; currently GZIP, Rice, Hcompress, and the IRAF pixel list compression algorithms have been implemented.

The main advantages of fpack compared to the commonly used technique of externally compressing the whole FITS file with gzip are:

- It is generally faster and offers better compression than gzip.
- The FITS header keywords remain uncompressed for fast access.
- Each HDU of a multi-extension FITS file is compressed separately, so it is not necessary to uncompress the entire file to read a single image in a multi-extension file.
- Dividing the image into tiles before compression enables faster access to small subsections of the image.
- The compressed image is itself a valid FITS file and can be manipulated by other general FITS utility software.
- Lossy compression can be used for much higher compression in cases where it is not necessary to exactly preserve the original image.
- The CHECKSUM keywords are automatically updated to help verify the integrity of the files.
- Software that supports the tiled image compression technique can directly read and write the FITS images in their compressed form.

[ascl:1610.014]
Freddi: Fast Rise Exponential Decay accretion Disk model Implementation

Freddi (Fast Rise Exponential Decay: accretion Disk model Implementation) solves 1-D evolution equations of the Shakura-Sunyaev accretion disk. It simulates fast rise exponential decay (FRED) light curves of low mass X-ray binaries (LMXBs). The basic equation of the viscous evolution relates the surface density and viscous stresses and is of diffusion type; evolution of the accretion rate can be found on solving the equation. The distribution of viscous stresses defines the emission from the source. The standard model for the accretion disk is implied; the inner boundary of the disk is at the ISCO or can be explicitely set. The boundary conditions in the disk are the zero stress at the inner boundary and the zero accretion rate at the outer boundary. The conditions are suitable during the outbursts in X-ray binary transients with black holes. In a binary system, the accretion disk is radially confined. In Freddi, the outer radius of the disk can be set explicitely or calculated as the position of the tidal truncation radius.

[ascl:1211.002]
FreeEOS: Equation of State for stellar interiors calculations

FreeEOS is a Fortran library for rapidly calculating the equation of state using an efficient free-energy minimization technique that is suitable for physical conditions in stellar interiors. Converged FreeEOS solutions can be reliably determined for the first time for physical conditions occurring in stellar models with masses between 0.1 M_{☉} and the hydrogen-burning limit near 0.07 M_{☉} and hot brown-dwarf models just below that limit. However, an initial survey of results for those conditions showed EOS discontinuities (plasma phase transitions) and other problems which will need to be addressed in future work by adjusting the interaction radii characterizing the pressure ionization used for the FreeEOS calculations.

[ascl:1508.004]
FRELLED: FITS Realtime Explorer of Low Latency in Every Dimension

FRELLED (FITS Realtime Explorer of Low Latency in Every Dimension) creates 3D images in real time from 3D FITS files and is written in Python for the 3D graphics suite Blender. Users can interactively generate masks around regions of arbitrary geometry and use them to catalog sources, hide regions, and perform basic analysis (*e.g.*, image statistics within the selected region, generate contour plots, query NED and the SDSS). World coordinates are supported and multi-volume rendering is possible. FRELLED is designed for viewing HI data cubes and provides a number of tasks to commonly-used MIRIAD (ascl:1106.007) tasks (e.g. mbspect); however, many of its features are suitable for any type of data set. It also includes an n-body particle viewer with the ability to display 3D vector information as well as the ability to render time series movies of multiple FITS files and setup simple turntable rotation movies for single files.

[ascl:1406.006]
FROG: Time-series analysis

FROG performs time series analysis and display. It provides a simple user interface for astronomers wanting to do time-domain astrophysics but still offers the powerful features found in packages such as PERIOD (ascl:1406.005). FROG includes a number of tools for manipulation of time series. Among other things, the user can combine individual time series, detrend series (multiple methods) and perform basic arithmetic functions. The data can also be exported directly into the TOPCAT (ascl:1101.010) application for further manipulation if needed.

[ascl:1506.006]
fsclean: Faraday Synthesis CLEAN imager

Fsclean produces 3D Faraday spectra using the Faraday synthesis method, transforming directly from multi-frequency visibility data to the Faraday depth-sky plane space. Deconvolution is accomplished using the CLEAN algorithm, and the package includes Clark and Högbom style CLEAN algorithms. Fsclean reads in MeasurementSet visibility data and produces HDF5 formatted images; it handles images and data of arbitrary size, using scratch HDF5 files as buffers for data that is not being immediately processed, and is limited only by available disk space.

[ascl:1710.012]
FSFE: Fake Spectra Flux Extractor

The fake spectra flux extractor generates simulated quasar absorption spectra from a particle or adaptive mesh-based hydrodynamic simulation. It is implemented as a python module. It can produce both hydrogen and metal line spectra, if the simulation includes metals. The cloudy table for metal ionization fractions is included. Unlike earlier spectral generation codes, it produces absorption from each particle close to the sight-line individually, rather than first producing an average density in each spectral pixel, thus substantially preserving more of the small-scale velocity structure of the gas. The code supports both Gadget (ascl:0003.001) and AREPO.

[ascl:1010.043]
FSPS: Flexible Stellar Population Synthesis

FSPS is a flexible SPS package that allows the user to compute simple stellar populations (SSPs) for a range of IMFs and metallicities, and for a variety of assumptions regarding the morphology of the horizontal branch, the blue straggler population, the post--AGB phase, and the location in the HR diagram of the TP-AGB phase. From these SSPs the user may then generate composite stellar populations (CSPs) for a variety of star formation histories (SFHs) and dust attenuation prescriptions. Outputs include the "observed" spectra and magnitudes of the SSPs and CSPs at arbitrary redshift. In addition to these fortran routines, several IDL routines are provided that allow easy manipulation of the output. FSPS was designed with the intention that the user would make full use of the provided fortran routines. However, the full FSPS package is quite large, and requires some time for the user to become familiar with all of the options and syntax. Some users may only need SSPs for a range of metallicities and IMFs. For such users, standard SSP sets for several IMFs, evolutionary tracks, and spectral libraries are available here.

[ascl:1711.003]
FTbg: Background removal using Fourier Transform

FTbg performs Fourier transforms on FITS images and separates low- and high-spatial frequency components by a user-specified cut. Both components are then inverse Fourier transformed back to image domain. FTbg can remove large-scale background/foreground emission in many astrophysical applications. FTbg has been designed to identify and remove Galactic background emission in Herschel/Hi-GAL continuum images, but it is applicable to any other (e.g., Planck) images when background/foreground emission is a concern.

[ascl:9912.002]
FTOOLS: A general package of software to manipulate FITS files

FTOOLS, a highly modular collection of utilities for processing and analyzing data in the FITS (Flexible Image Transport System) format, has been developed in support of the HEASARC (High Energy Astrophysics Research Archive Center) at NASA's Goddard Space Flight Center. The FTOOLS package contains many utility programs which perform modular tasks on any FITS image or table, as well as higher-level analysis programs designed specifically for data from current and past high energy astrophysics missions. The utility programs for FITS tables are especially rich and powerful, and provide functions for presentation of file contents, extraction of specific rows or columns, appending or merging tables, binning values in a column or selecting subsets of rows based on a boolean expression. Individual FTOOLS programs can easily be chained together in scripts to achieve more complex operations such as the generation and displaying of spectra or light curves. FTOOLS development began in 1991 and has produced the main set of data analysis software for the current ASCA and RXTE space missions and for other archival sets of X-ray and gamma-ray data. The FTOOLS software package is supported on most UNIX platforms and on Windows machines. The user interface is controlled by standard parameter files that are very similar to those used by IRAF. The package is self documenting through a stand alone help task called fhelp. Software is written in ANSI C and FORTRAN to provide portability across most computer systems. The data format dependencies between hardware platforms are isolated through the FITSIO library package.

[ascl:1112.002]
Funtools: FITS Users Need Tools

Funtools is a "minimal buy-in" FITS library and utility package developed at the the High Energy Astrophysics Division of SAO. The Funtools library provides simplified access to a wide array of file types: standard astronomical FITS images and binary tables, raw arrays and binary event lists, and even tables of ASCII column data. A sophisticated region filtering library (compatible with ds9) filters images and tables using boolean operations between geometric shapes, support world coordinates, etc. Funtools also supports advanced capabilities such as optimized data searching using index files.

Because Funtools consists of a library and a set of user programs, it is most appropriately built from source. Funtools has been ported to Solaris, Linux, LinuxPPC, SGI, Alpha OSF1, Mac OSX (darwin) and Windows 98/NT/2000/XP. Once the source code tar file is retrieved, Funtools can be built and installed easily using standard commands.

[ascl:1205.005]
Fv: Interactive FITS file editor

[ascl:1010.015]
Fyris Alpha: Computational Fluid Dynamics Code

Fyris Alpha is a high resolution, shock capturing, multi-phase, up-wind Godunov method hydrodynamics code that includes a variable equation of state and optional microphysics such as cooling, gravity and multiple tracer variables. The code has been designed and developed for use primarily in astrophysical applications, such as galactic and interstellar bubbles, hypersonic shocks, and a range of jet phenomena. Fyris Alpha boasts both higher performance and more detailed microphysics than its predecessors, with the aim of producing output that is closer to the observational domain, such as emission line fluxes, and eventually, detailed spectral synthesis. Fyris Alpha is approximately 75,000 lines of C code; it encapsulates the split sweep semi-lagrangian remap PPM method used by ppmlr (in turn developed from VH1, Blondin et al. 1998) but with an improved Riemann solver, which is derived from the exact solver of Gottlieb and Groth (1988), a significantly faster solution than previous solvers. It has a number of optimisations that have improved the speed so that additional calculations neeed for multi-phase simulations become practical.

[ascl:1801.011]
GABE: Grid And Bubble Evolver

GABE (Grid And Bubble Evolver) evolves scalar fields (as well as other purposes) on an expanding background for non-canonical and non-linear classical field theory. GABE is based on the Runge-Kutta method.

[ascl:0003.001]
GADGET-2: A Code for Cosmological Simulations of Structure Formation

The cosmological simulation code GADGET-2, a new massively parallel TreeSPH code, is capable of following a collisionless fluid with the N-body method, and an ideal gas by means of smoothed particle hydrodynamics (SPH). The implementation of SPH manifestly conserves energy and entropy in regions free of dissipation, while allowing for fully adaptive smoothing lengths. Gravitational forces are computed with a hierarchical multipole expansion, which can optionally be applied in the form of a TreePM algorithm, where only short-range forces are computed with the `tree'-method while long-range forces are determined with Fourier techniques. Time integration is based on a quasi-symplectic scheme where long-range and short-range forces can be integrated with different timesteps. Individual and adaptive short-range timesteps may also be employed. The domain decomposition used in the parallelisation algorithm is based on a space-filling curve, resulting in high flexibility and tree force errors that do not depend on the way the domains are cut. The code is efficient in terms of memory consumption and required communication bandwidth. It has been used to compute the first cosmological N-body simulation with more than 10^10 dark matter particles, reaching a homogeneous spatial dynamic range of 10^5 per dimension in a 3D box. It has also been used to carry out very large cosmological SPH simulations that account for radiative cooling and star formation, reaching total particle numbers of more than 250 million. GADGET-2 is publicly released to the research community.

[ascl:1108.005]
Gaepsi: Gadget Visualization Toolkit

Feng, Yu; Croft, Rupert A. C.; Di Matteo, Tiziana; Khandai, Nishikanta; Sargent, Randy; Nourbakhsh, Illah; Dille, Paul; Bartley, Chris; Springel, Volker; Jana, Anirban; Gardner, Jeffrey

Gaepsi is a PYTHON extension for visualizing cosmology simulations produced by Gadget. Visualization is the most important facet of Gaepsi, but it also allows data analysis on GADGET simulations with its growing number of physics related subroutines and constants. Unlike mesh based scheme, SPH simulations are directly visible in the sense that a splatting process is required to produce raster images from the simulations. Gaepsi produces images of 2-dimensional line-of-sight projections of the simulation. Scalar fields and vector fields are both supported.

Besides the traditional way of slicing a simulation, Gaepsi also has built-in support of 'Survey-like' domain transformation proposed by Carlson & White. An improved implementation is used in Gaepsi. Gaepsi both implements an interactive shell for plotting and exposes its API for batch processing. When complied with OpenMP, Gaepsi automatically takes the advantage of the multi-core computers. In interactive mode, Gaepsi is capable of producing images of size up to 32000 x 32000 pixels. The user can zoom, pan and rotate the field with a command in on the finger tip. The interactive mode takes full advantages of matplotlib's rich annotating, labeling and image composition facilities. There are also built-in commands to add objects that are commonly used in cosmology simulations to the figures.

[ascl:1403.024]
GAIA: Graphical Astronomy and Image Analysis Tool

GAIA is an image and data-cube display and analysis tool for astronomy. It provides the usual facilities of image display tools, plus more astronomically useful ones such as aperture and optimal photometry, contouring, source detection, surface photometry, arbitrary region analysis, celestial coordinate readout, calibration and modification, grid overlays, blink comparison, defect patching and the ability to query on-line catalogues and image servers. It can also display slices from data-cubes, extract and visualize spectra as well as perform full 3D rendering. GAIA uses the Starlink software environment (ascl:1110.012) and is derived from the ESO SkyCat tool (ascl:1109.019).

[ascl:1707.006]
Gala: Galactic astronomy and gravitational dynamics

Gala is a Python package (and Astropy affiliated package) for Galactic astronomy and gravitational dynamics. The bulk of the package centers around implementations of gravitational potentials, numerical integration, nonlinear dynamics, and astronomical velocity transformations (i.e. proper motions). Gala uses the Astropy units and coordinates subpackages extensively to provide a clean, pythonic interface to these features but does any heavy-lifting in C and Cython for speed.

[ascl:1302.011]
GALA: Stellar atmospheric parameters and chemical abundances

GALA is a freely distributed Fortran code to derive the atmospheric parameters (temperature, gravity, microturbulent velocity and overall metallicity) and abundances for individual species of stellar spectra using the classical method based on the equivalent widths of metallic lines. The abundances of individual spectral lines are derived by using the WIDTH9 code developed by R. L. Kurucz. GALA is designed to obtain the best model atmosphere, by optimizing temperature, surface gravity, microturbulent velocity and metallicity, after rejecting the discrepant lines. Finally, it computes accurate internal errors for each atmospheric parameter and abundance. The code obtains chemical abundances and atmospheric parameters for large stellar samples quickly, thus making GALA an useful tool in the epoch of the multi-object spectrographs and large surveys.

[ascl:1109.011]
GalactICS: Galaxy Model Building Package

GalactICS generates N-body realizations of axisymmetric galaxy models consisting of disk, bulge and halo. Some of the code is in Fortran 77, using lines longer than 72 characters in some cases. The -e flag in the makefile allow for this for a Solaris f77 compiler. Other programs are written in C. Again, the linking between these routines works on Solaris systems, but may need to be adjusted for other architectures. We have found that linking using f77 instead of ld will often automatically load the appropriate libraries.

The graphics output by some of the programs (dbh, plotforce, diskdf, plothalo) uses the PGPLOT library. Alternatively, remove all calls to routines with names starting with "PG", as well as the -lpgplot flag in the Makefile, and the programs should still run fine.

[ascl:1108.004]
Galacticus: A Semi-Analytic Model of Galaxy Formation

Galacticus is designed to solve the physics involved in the formation of galaxies within the current standard cosmological framework. It is of a type of model known as “semi-analytic” in which the numerous complex non-linear physics involved are solved using a combination of analytic approximations and empirical calibrations from more detailed, numerical solutions. Models of this type aim to begin with the initial state of the Universe (specified shortly after the Big Bang) and apply physical principles to determine the properties of galaxies in the Universe at later times, including the present day. Typical properties computed include the mass of stars and gas in each galaxy, broad structural properties (e.g. radii, rotation speeds, geometrical shape etc.), dark matter and black hole contents, and observable quantities such as luminosities, chemical composition etc.

[ascl:1303.018]
Galactus: Modeling and fitting of galaxies from neutral hydrogen (HI) cubes

Galactus, written in python, is an astronomical software tool for the modeling and fitting of galaxies from neutral hydrogen (HI) cubes. Galactus uses a uniform medium to generate a cube. Galactus can perform the full-radiative transfer for the HI, so can model self-absorption in the galaxy.

[ascl:1408.011]
GALAPAGOS-C: Galaxy Analysis over Large Areas

GALAPAGOS-C is a C implementation of the IDL code GALAPAGOS (ascl:1203.002). It processes a complete set of survey images through automation of source detection via SExtractor (ascl:1010.064), postage stamp cutting, object mask preparation, sky background estimation and complex two-dimensional light profile Sérsic modelling via GALFIT (ascl:1104.010). GALAPAGOS-C uses MPI-parallelization, thus allowing quick processing of large data sets. The code can fit multiple Sérsic profiles to each galaxy, each representing distinct galaxy components (e.g. bulge, disc, bar), and optionally can fit asymmetric Fourier mode distortions.

[ascl:1203.002]
GALAPAGOS: Galaxy Analysis over Large Areas: Parameter Assessment by GALFITting Objects from SExtractor

GALAPAGOS, Galaxy Analysis over Large Areas: Parameter Assessment by GALFITting Objects from SExtractor (ascl:1010.064), automates source detection, two-dimensional light-profile Sersic modelling and catalogue compilation in large survey applications. Based on a single setup, GALAPAGOS can process a complete set of survey images. It detects sources in the data, estimates a local sky background, cuts postage stamp images for all sources, prepares object masks, performs Sersic fitting including neighbours and compiles all objects in a final output catalogue. For the initial source detection GALAPAGOS applies SExtractor, while GALFIT (ascl:1104.010) is incorporated for modelling Sersic profiles. It measures the background sky involved in the Sersic fitting by means of a flux growth curve. GALAPAGOS determines postage stamp sizes based on SExtractor shape parameters. In order to obtain precise model parameters GALAPAGOS incorporates a complex sorting mechanism and makes use of multiplexing capabilities. It combines SExtractor and GALFIT data in a single output table. When incorporating information from overlapping tiles, GALAPAGOS automatically removes multiple entries from identical sources. GALAPAGOS is programmed in the Interactive Data Language, IDL. A C implementation of the software, GALAPAGOS-C (ascl:1408.011), is available.

[ascl:1710.022]
galario: Gpu Accelerated Library for Analyzing Radio Interferometer Observations

The galario library exploits the computing power of modern graphic cards (GPUs) to accelerate the comparison of model predictions to radio interferometer observations. It speeds up the computation of the synthetic visibilities given a model image (or an axisymmetric brightness profile) and their comparison to the observations.

[ascl:1503.002]
Galax2d: 2D isothermal Euler equations solver

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

[ascl:1104.005]
GALAXEV: Evolutionary Stellar Population Synthesis Models

GALAXEV is a library of evolutionary stellar population synthesis models computed using the new isochrone synthesis code of Bruzual & Charlot (2003). This code allows one to computes the spectral evolution of stellar populations in wide ranges of ages and metallicities at a resolution of 3 Å across the whole wavelength range from 3200 Å to 9500 Å, and at lower resolution outside this range.

[submitted]
Galaxia_wrap

Galaxia_wrap is a python wrap around the popular Galaxia tool that can be used to generate mock stellar surveys using a built-in Galaxy model or directly from n-body data.

It is shown how a magnitude limited survey can be constructed. The n-body functionality is also demonstrated and one application shows how the age distribution of a specific stellar tracer population can be inferred, which could be useful for creating mock data.

[ascl:1101.007]
Galaxia: A Code to Generate a Synthetic Survey of the Milky Way

We present here a fast code for creating a synthetic survey of the Milky Way. Given one or more color-magnitude bounds, a survey size and geometry, the code returns a catalog of stars in accordance with a given model of the Milky Way. The model can be specified by a set of density distributions or as an N-body realization. We provide fast and efficient algorithms for sampling both types of models. As compared to earlier sampling schemes which generate stars at specified locations along a line of sight, our scheme can generate a continuous and smooth distribution of stars over any given volume. The code is quite general and flexible and can accept input in the form of a star formation rate, age metallicity relation, age velocity dispersion relation and analytic density distribution functions. Theoretical isochrones are then used to generate a catalog of stars and support is available for a wide range of photometric bands. As a concrete example we implement the Besancon Milky Way model for the disc. For the stellar halo we employ the simulated stellar halo N-body models of Bullock & Johnston (2005). In order to sample N-body models, we present a scheme that disperses the stars spawned by an N-body particle, in such a way that the phase space density of the spawned stars is consistent with that of the N-body particles. The code is ideally suited to generating synthetic data sets that mimic near future wide area surveys such as GAIA, LSST and HERMES. As an application we study the prospect of identifying structures in the stellar halo with a simulated GAIA survey.

[ascl:1312.010]
GalaxyCount: Galaxy counts and variance calculator

GalaxyCount calculates the number and standard deviation of galaxies in a magnitude limited observation of a given area. The methods to calculate both the number and standard deviation may be selected from different options. Variances may be computed for circular, elliptical and rectangular window functions.

[ascl:1702.006]
GalaxyGAN: Generative Adversarial Networks for recovery of galaxy features

GalaxyGAN uses Generative Adversarial Networks to reliably recover features in images of galaxies. The package uses machine learning to train on higher quality data and learns to recover detailed features such as galaxy morphology by effectively building priors. This method opens up the possibility of recovering more information from existing and future imaging data.

[ascl:1812.009]
galclassify: Stellar classifications using a galactic population synthesis model

The stellar classification code galclassify is a stand-alone version of Galaxia (ascl:1101.007). It classifies and generates a synthetic population for each star using input containing observables in a fixed format rather than using a precomputed population over a large field. It is suitable for individual stellar classifications, but slow if you want to classify large samples of stars.

[ascl:1010.033]
GALEV Evolutionary Synthesis Models

GALEV evolutionary synthesis models describe the evolution of stellar populations in general, of star clusters as well as of galaxies, both in terms of resolved stellar populations and of integrated light properties over cosmological timescales of > 13 Gyr from the onset of star formation shortly after the Big Bang until today.

For galaxies, GALEV includes a simultaneous treatment of the chemical evolution of the gas and the spectral evolution of the stellar content, allowing for a chemically consistent treatment using input physics (stellar evolutionary tracks, stellar yields and model atmospheres) for a large range of metallicities and consistently account for the increasing initial abundances of successive stellar generations.

[ascl:1810.001]
galfast: Milky Way mock catalog generator

galfast generates catalogs for arbitrary, user-supplied Milky Way models, including empirically derived ones. The built-in model set is based on fits to SDSS stellar observations over 8000 deg^{2} of the sky and includes a three-dimensional dust distribution map. Because of the capability to use empirically derived models, galfast typically produces closer matches to the actual observed counts and color-magnitude diagrams. In particular, galfast-generated catalogs are used to derive the stellar component of “Universe Model” catalogs used by the LSST Project. A key distinguishing characteristic of galfast is its speed. Galfast uses the GPU (with kernels written in NVIDIA C/C++ for CUDA) to offload compute intensive model sampling computations to the GPU, enabling the generation of realistic catalogs to full LSST depth in hours (instead of days or weeks), making it possible to study proposed science cases with high precision.

[ascl:1104.010]
GALFIT: Detailed Structural Decomposition of Galaxy Images

GALFIT is a two-dimensional (2-D) fitting algorithm designed to extract structural components from galaxy images, with emphasis on closely modeling light profiles of spatially well-resolved, nearby galaxies observed with the Hubble Space Telescope. The algorithm improves on previous techniques in two areas: 1.) by being able to simultaneously fit a galaxy with an arbitrary number of components, and 2.) with optimization in computation speed, suited for working on large galaxy images. 2-D models such as the "Nuker'' law, the Sersic (de Vaucouleurs) profile, an exponential disk, and Gaussian or Moffat functions are used. The azimuthal shapes are generalized ellipses that can fit disky and boxy components. Many galaxies with complex isophotes, ellipticity changes, and position-angle twists can be modeled accurately in 2-D. When examined in detail, even simple-looking galaxies generally require at least three components to be modeled accurately rather than the one or two components more often employed. This is illustrated by way of seven case studies, which include regular and barred spiral galaxies, highly disky lenticular galaxies, and elliptical galaxies displaying various levels of complexities. A useful extension of this algorithm is to accurately extract nuclear point sources in galaxies.

[ascl:1510.005]
GALFORM: Galactic modeling

GALFORM is a semi-analytic model for calculating the formation and evolution of galaxies in hierarchical clustering cosmologies. Using a Monte Carlo algorithm to follow the merging evolution of dark matter haloes with arbitrary mass resolution, it incorporates realistic descriptions of the density profiles of dark matter haloes and the gas they contain. It follows the chemical evolution of gas and stars, and the associated production of dust and includes a detailed calculation of the sizes of discs and spheroids.

[ascl:1408.008]
GALIC: Galaxy initial conditions construction

GalIC (GALaxy Initial Conditions) is an implementation of an iterative method to construct steady state composite halo-disk-bulge galaxy models with prescribed density distribution and velocity anisotropy that can be used as initial conditions for N-body simulations. The code is parallelized for distributed memory based on MPI. While running, GalIC produces "snapshot files" that can be used as initial conditions files. GalIC supports the three file formats ('type1' format, the slightly improved 'type2' format, and an HDF5 format) of the GADGET (ascl:0003.001) code for its output snapshot files.

[ascl:1511.010]
Galileon-Solver: N-body code

Galileon-Solver adds an extra force to PMCode (ascl:9909.001) using a modified Poisson equation to provide a non-linearly transformed density field, with the operations all performed in real space. The code's implicit spherical top-hat assumption only works over fairly long distance averaging scales, where the coarse-grained picture it relies on is a good approximation of reality; it uses discrete Fourier transforms and cyclic reduction in the usual way.

[ascl:1711.011]
galkin: Milky Way rotation curve data handler

galkin is a compilation of kinematic measurements tracing the rotation curve of our Galaxy, together with a tool to treat the data. The compilation is optimized to Galactocentric radii between 3 and 20 kpc and includes the kinematics of gas, stars and masers in a total of 2780 measurements collected from almost four decades of literature. The user-friendly software provided selects, treats and retrieves the data of all source references considered. This tool is especially designed to facilitate the use of kinematic data in dynamical studies of the Milky Way with various applications ranging from dark matter constraints to tests of modified gravity.

[ascl:1501.014]
GalPaK 3D: Galaxy parameters and kinematics extraction from 3D data

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

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

[ascl:1611.006]
GalPot: Galaxy potential code

GalPot finds the gravitational potential associated with axisymmetric density profiles. The package includes code that performs transformations between commonly used coordinate systems for both positions and velocities (the class OmniCoords), and that integrates orbits in the potentials. GalPot is a stand-alone version of Walter Dehnen's GalaxyPotential C++ code taken from the falcON code in the NEMO Stellar Dynamics Toolbox (ascl:1010.051).

[ascl:1010.028]
GALPROP: Code for Cosmic-ray Transport and Diffuse Emission Production

GALPROP is a numerical code for calculating the propagation of relativistic charged particles and the diffuse emissions produced during their propagation. The GALPROP code incorporates as much realistic astrophysical input as possible together with latest theoretical developments. The code calculates the propagation of cosmic-ray nuclei, antiprotons, electrons and positrons, and computes diffuse γ-rays and synchrotron emission in the same framework. Each run of the code is governed by a configuration file allowing the user to specify and control many details of the calculation. Thus, each run of the code corresponds to a potentially different "model." The code continues to be developed and is available to the scientific community.

[ascl:1411.008]
galpy: Galactic dynamics package

galpy is a python package for galactic dynamics. It supports orbit integration in a variety of potentials, evaluating and sampling various distribution functions, and the calculation of action-angle coordinates for all static potentials.

[ascl:1402.009]
GalSim: Modular galaxy image simulation toolkit

GalSim is a fast, modular software package for simulation of astronomical images. Though its primary purpose is for tests of weak lensing analysis methods, it can be used for other purposes. GalSim allows galaxies and PSFs to be represented in a variety of ways, and can apply shear, magnification, dilation, or rotation to a galaxy profile including lensing-based models from a power spectrum or NFW halo profile. It can write images in regular FITS files, FITS data cubes, or multi-extension FITS files. It can also compress the output files using various compressions including gzip, bzip2, and rice. The user interface is in python or via configuration scripts, and the computations are done in C++ for speed.

[ascl:1711.007]
galstep: Initial conditions for spiral galaxy simulations

galstep generates initial conditions for disk galaxy simulations with GADGET-2 (ascl:0003.001), RAMSES (ascl:1011.007) and GIZMO (ascl:1410.003), including a stellar disk, a gaseous disk, a dark matter halo and a stellar bulge. The first two components follow an exponential density profile, and the last two a Dehnen density profile with gamma=1 by default, corresponding to a Hernquist profile.

[ascl:1711.010]
galstreams: Milky Way streams footprint library and toolkit

galstreams provides a compilation of spatial information for known stellar streams and overdensities in the Milky Way and includes Python tools for visualizing them. ASCII tables are also provided for quick viewing of the stream's footprints using TOPCAT (ascl:1101.010).

[ascl:1304.003]
GALSVM: Automated Morphology Classification

GALSVM is IDL software for automated morphology classification. It was specially designed for high redshift data but can be used at low redshift as well. It analyzes morphologies of galaxies based on a particular family of learning machines called support vector machines. The method can be seen as a generalization of the classical CAS classification but with an unlimited number of dimensions and non-linear boundaries between decision regions. It is fully automated and consequently well adapted to large cosmological surveys.

[ascl:1708.030]
GAMBIT: Global And Modular BSM Inference Tool

The GAMBIT Collaboration; Athron, Peter; Balazs, Csaba; Bringmann, Torsten; Buckley, Andy; Chrząszcz, Marcin; Conrad, Jan; Cornell, Jonathan M.; Dal, Lars A.; Dickinson, Hugh; Edsjö, Joakim; Farmer, Ben; Jackson, Paul; Krislock, Abram; Kvellestad, Anders; Lundberg, Johan; McKay, James; Mahmoudi, Farvah; Martinez, Gregory D.; Putze, Antje Raklev, Are; Ripken, Joachim; Rogan, Christopher; Saavedra, Aldo; Savage, Christopher; Scott, Pat; Seo, Seon-Hee; Serra, Nicola; Weniger, Christoph; White, Martin; Wild, Sebastian

GAMBIT (Global And Modular BSM Inference Tool) performs statistical global fits of generic physics models using a wide range of particle physics and astrophysics data. Modules provide native simulations of collider and astrophysics experiments, a flexible system for interfacing external codes (the backend system), a fully featured statistical and parameter scanning framework, and additional tools for implementing and using hierarchical models.

[ascl:1612.017]
GAMER: GPU-accelerated Adaptive MEsh Refinement code

GAMER (GPU-accelerated Adaptive MEsh Refinement) serves as a general-purpose adaptive mesh refinement + GPU framework and solves hydrodynamics with self-gravity. The code supports adaptive mesh refinement (AMR), hydrodynamics with self-gravity, and a variety of GPU-accelerated hydrodynamic and Poisson solvers. It also supports hybrid OpenMP/MPI/GPU parallelization, concurrent CPU/GPU execution for performance optimization, and Hilbert space-filling curve for load balance. Although the code is designed for simulating galaxy formation, it can be easily modified to solve a variety of applications with different governing equations. All optimization strategies implemented in the code can be inherited straightforwardly.

[ascl:1110.007]
GammaLib: Toolbox for High-level Analysis of Astronomical Gamma-ray Data

The GammaLib is a versatile toolbox for the high-level analysis of astronomical gamma-ray data. It is implemented as a C++ library that is fully scriptable in the Python scripting language. The library provides core functionalities such as data input and output, interfaces for parameter specifications, and a reporting and logging interface. It implements instruments specific functionalities such as instrument response functions and data formats. Instrument specific functionalities share a common interface to allow for extension of the GammaLib to include new gamma-ray instruments. The GammaLib provides an abstract data analysis framework that enables simultaneous multi-mission analysis.

[ascl:1711.014]
Gammapy: Python toolbox for gamma-ray astronomy

Gammapy analyzes gamma-ray data and creates sky images, spectra and lightcurves, from event lists and instrument response information; it can also determine the position, morphology and spectra of gamma-ray sources. It is used to analyze data from H.E.S.S., Fermi-LAT, and the Cherenkov Telescope Array (CTA).

[ascl:1105.011]
Ganalyzer: A tool for automatic galaxy image analysis

Ganalyzer is a model-based tool that automatically analyzes and classifies galaxy images. Ganalyzer works by separating the galaxy pixels from the background pixels, finding the center and radius of the galaxy, generating the radial intensity plot, and then computing the slopes of the peaks detected in the radial intensity plot to measure the spirality of the galaxy and determine its morphological class. Unlike algorithms that are based on machine learning, Ganalyzer is based on measuring the spirality of the galaxy, a task that is difficult to perform manually, and in many cases can provide a more accurate analysis compared to manual observation. Ganalyzer is simple to use, and can be easily embedded into other image analysis applications. Another advantage is its speed, which allows it to analyze ~10,000,000 galaxy images in five days using a standard modern desktop computer. These capabilities can make Ganalyzer a useful tool in analyzing large datasets of galaxy images collected by autonomous sky surveys such as SDSS, LSST or DES.

[ascl:1708.012]
GANDALF: Gas AND Absorption Line Fitting

Sarzi, Marc; Falcón-Barroso, Jesús; Davies, Roger L.; Bacon, Roland; Bureau, Martin; Cappellari, Michele; de Zeeuw, P. Tim; Emsellem, Eric; Fathi, Kambiz; Krajnović, Davor; Kuntschner, Harald; McDermid, Richard M.; Peletier, Reynier F.

GANDALF (Gas AND Absorption Line Fitting) accurately separates the stellar and emission-line contributions to observed spectra. The IDL code includes reddening by interstellar dust and also returns formal errors on the position, width, amplitude and flux of the emission lines. Example wrappers that make use of pPXF (ascl:1210.002) to derive the stellar kinematics are included.

[ascl:1602.015]
GANDALF: Graphical Astrophysics code for N-body Dynamics And Lagrangian Fluids

GANDALF, a successor to SEREN (ascl:1102.010), is a hybrid self-gravitating fluid dynamics and collisional N-body code primarily designed for investigating star formation and planet formation problems. GANDALF uses various implementations of Smoothed Particle Hydrodynamics (SPH) to perform hydrodynamical simulations of gas clouds undergoing gravitational collapse to form new stars (or other objects), and can perform simulations of pure N-body dynamics using high accuracy N-body integrators, model the intermediate phase of cluster evolution, and provide visualizations via its python interface as well as interactive simulations. Although based on many of the SEREN routines, GANDALF has been largely re-written from scratch in C++ using more optimal algorithms and data structures.

[ascl:1303.027]
GaPP: Gaussian Processes in Python

The algorithm Gaussian processes can reconstruct a function from a sample of data without assuming a parameterization of the function. The GaPP code can be used on any dataset to reconstruct a function. It handles individual error bars on the data and can be used to determine the derivatives of the reconstructed function. The data sample can consist of observations of the function and of its first derivative.

[ascl:1010.049]
Gas-momentum-kinetic SZ cross-correlations

We present a new method for detecting the missing baryons by generating a template for the kinematic Sunyaev-Zel'dovich effect. The template is computed from the product of a reconstructed velocity field with a galaxy field. We provide maps of such templates constructed from SDSS Data Release 7 spectroscopic data (SDSS VAGC sample) along side with their expected two point correlation functions with CMB temperature anisotropies. Codes of generating such coefficients of the two point correlation function are also released to provide users of the gas-momentum map a way to change the parameters such as cosmological parameters, reionization history, ionization parameters, etc.

[ascl:1210.020]
GASGANO: Data File Organizer

GASGANO is a GUI software tool for managing and viewing data files produced by VLT Control System (VCS) and the Data Flow System (DFS). It is developed and maintained by ESO to help its user community manage and organize astronomical data observed and produced by all VLT compliant telescopes in a systematic way. The software understands FITS, PAF, and ASCII files, and Reduction Blocks, and can group, sort, classify, filter, and search data in addition to allowing the user to browse, view, and manage them.

[ascl:1710.019]
GASOLINE: Smoothed Particle Hydrodynamics (SPH) code

Gasoline solves the equations of gravity and hydrodynamics in astrophysical problems, including simulations of planets, stars, and galaxies. It uses an SPH method that features correct mixing behavior in multiphase fluids and minimal artificial viscosity. This method is identical to the SPH method used in the ChaNGa code (ascl:1105.005), allowing users to extend results to problems requiring >100,000 cores. Gasoline uses a fast, memory-efficient O(N log N) KD-Tree to solve Poisson's Equation for gravity and avoids artificial viscosity in non-shocking compressive flows.

[ascl:1610.007]
gatspy: General tools for Astronomical Time Series in Python

Gatspy contains efficient, well-documented implementations of several common routines for Astronomical time series analysis, including the Lomb-Scargle periodogram, the Supersmoother method, and others.

[ascl:1406.018]
GAUSSCLUMPS: Gaussian-shaped clumping from a spectral map

GAUSSCLUMPS decomposes a spectral map into Gaussian-shape clumps. The clump-finding algorithm decomposes a spectral data cube by iteratively removing 3-D Gaussians as representative clumps. GAUSSCLUMPS was originally a separate code distribution but is now a contributed package in GILDAS (ascl:1305.010). A reimplementation can also be found in CUPID (ascl:1311.007).

[ascl:1305.009]
GaussFit: Solving least squares and robust estimation problems

GaussFit solves least squares and robust estimation problems; written originally for reduction of NASA Hubble Space Telescope data, it includes a complete programming language designed especially to formulate estimation problems, a built-in compiler and interpreter to support the programming language, and a built-in algebraic manipulator for calculating the required partial derivatives analytically. The code can handle nonlinear models, exact constraints, correlated observations, and models where the equations of condition contain more than one observed quantity. Written in C, GaussFit includes an experimental robust estimation capability so data sets contaminated by outliers can be handled simply and efficiently.

[ascl:1710.014]
GBART: Determination of the orbital elements of spectroscopic binaries

GBART is an improved version of the code for determining the orbital elements for spectroscopic binaries originally written by Bertiau & Grobben (1968).

[ascl:1303.019]
GBTIDL: Reduction and Analysis of GBT Spectral Line Data

GBTIDL is an interactive package for reduction and analysis of spectral line data taken with the Robert C. Byrd Green Bank Telescope (GBT). The package, written entirely in IDL, consists of straightforward yet flexible calibration, averaging, and analysis procedures (the "GUIDE layer") modeled after the UniPOPS and CLASS data reduction philosophies, a customized plotter with many built-in visualization features, and Data I/O and toolbox functionality that can be used for more advanced tasks. GBTIDL makes use of data structures which can also be used to store intermediate results. The package consumes and produces data in GBT SDFITS format. GBTIDL can be run online and have access to the most recent data coming off the telescope, or can be run offline on preprocessed SDFITS files.

[ascl:1811.018]
gdr2_completeness: GaiaDR2 data retrieval and manipulation

gdr2_completeness queries Gaia DR2 TAP services and divides the queries into sub-queries chunked into arbitrary healpix bins. Downloaded data are formatted into arrays. Internal completeness is calculated by dividing the total starcount and starcounts with an applied cut (*e.g.*, radial velocity measurement and good parallax). Independent determination of the external GDR2 completeness per healpix (level 6) and G magnitude bin (3 coarse bins: 8-12,12-15,15-18) is inferred from a crossmatch with 2MASS data. The overall completeness of a specific GDR2 sample can be approximated by multiplying the internal with the external completeness map, which is useful when data are compared to models thereof. Jupyter notebooks showcasing both utilities enable the user to easily construct the overall completeness for arbitrary samples of the GDR2 catalogue.

[ascl:1010.079]
Geant4: A Simulation Toolkit for the Passage of Particles through Matter

Geant4 is a toolkit for simulating the passage of particles through matter. It includes a complete range of functionality including tracking, geometry, physics models and hits. The physics processes offered cover a comprehensive range, including electromagnetic, hadronic and optical processes, a large set of long-lived particles, materials and elements, over a wide energy range starting, in some cases, from 250eV and extending in others to the TeV energy range. It has been designed and constructed to expose the physics models utilised, to handle complex geometries, and to enable its easy adaptation for optimal use in different sets of applications. The toolkit is the result of a worldwide collaboration of physicists and software engineers. It has been created exploiting software engineering and object-oriented technology and implemented in the C++ programming language. It has been used in applications in particle physics, nuclear physics, accelerator design, space engineering and medical physics.

[ascl:1608.006]
Gemini IRAF: Data reduction software for the Gemini telescopes

The Gemini IRAF package processes observational data obtained with the Gemini telescopes. It is an external package layered upon IRAF and supports data from numerous instruments, including FLAMINGOS-2, GMOS-N, GMOS-S, GNIRS, GSAOI, NIFS, and NIRI. The Gemini IRAF package is organized into sub-packages; it contains a generic tools package, "gemtools", along with instrument-specific packages. The raw data from the Gemini facility instruments are stored as Multi-Extension FITS (MEF) files. Therefore, all the tasks in the Gemini IRAF package, intended for processing data from the Gemini facility instruments, are capable of handling MEF files.

[ascl:1007.003]
GEMINI: A toolkit for analytical models of two-point correlations and inhomogeneous structure formation

Gemini is a toolkit for analytical models of two-point correlations and inhomogeneous structure formation. It extends standard Press-Schechter theory to inhomogeneous situations, allowing a realistic, analytical calculation of halo correlations and bias.

[ascl:1212.005]
General complex polynomial root solver

This general complex polynomial root solver, implemented in Fortran and further optimized for binary microlenses, uses a new algorithm to solve polynomial equations and is 1.6-3 times faster than the ZROOTS subroutine that is commercially available from Numerical Recipes, depending on application. The largest improvement, when compared to naive solvers, comes from a fail-safe procedure that permits skipping the majority of the calculations in the great majority of cases, without risking catastrophic failure in the few cases that these are actually required.

[ascl:1812.014]
GENGA: Gravitational ENcounters with Gpu Acceleration

GENGA (Gravitational ENcounters with Gpu Acceleration) integrates planet and planetesimal dynamics in the late stage of planet formation and stability analyses of planetary systems. It uses mixed variable integration when the motion is a perturbed Kepler orbit and combines this with a direct N-body Bulirsch-Stoer method during close encounters. It supports three simulation modes: 1.) integration of up to 2048 massive bodies; 2.) integration with up to a million test particles; and 3.) parallel integration of a large number of individual planetary systems.

[ascl:1706.006]
GenPK: Power spectrum generator

GenPK generates the 3D matter power spectra for each particle species from a Gadget snapshot. Written in C++, it requires both FFTW3 and GadgetReader.

[ascl:1011.015]
Geokerr: Computing Photon Orbits in a Kerr Spacetime

Relativistic radiative transfer problems require the calculation of photon trajectories in curved spacetime. Programmed in Fortran, Geokerr uses a novel technique for rapid and accurate calculation of null geodesics in the Kerr metric. The equations of motion from the Hamilton-Jacobi equation are reduced directly to Carlson's elliptic integrals, simplifying algebraic manipulations and allowing all coordinates to be computed semi-analytically for the first time.

[ascl:1511.015]
George: Gaussian Process regression

George is a fast and flexible library, implemented in C++ with Python bindings, for Gaussian Process regression useful for accounting for correlated noise in astronomical datasets, including those for transiting exoplanet discovery and characterization and stellar population modeling.

[ascl:1412.012]
GeoTOA: Geocentric TOA tools

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

[ascl:1512.002]
GetData: A filesystem-based, column-oriented database format for time-ordered binary data

The GetData Project is the reference implementation of the Dirfile Standards, a filesystem-based, column-oriented database format for time-ordered binary data. Dirfiles provide a fast, simple format for storing and reading data, suitable for both quicklook and analysis pipelines. GetData provides a C API and bindings exist for various other languages. GetData is distributed under the terms of the GNU Lesser General Public License.

[ascl:1705.007]
getimages: Background derivation and image flattening method

*getimages* performs background derivation and image flattening for high-resolution images obtained with space observatories. It is based on median filtering with sliding windows corresponding to a range of spatial scales from the observational beam size up to a maximum structure width X. The latter is a single free parameter of *getimages* that can be evaluated manually from the observed image. The median filtering algorithm provides a background image for structures of all widths below X. The same median filtering procedure applied to an image of standard deviations derived from a background-subtracted image results in a flattening image. Finally, a flattened image is computed by dividing the background-subtracted by the flattening image. Standard deviations in the flattened image are now uniform outside sources and filaments. Detecting structures in such radically simplified images results in much cleaner extractions that are more complete and reliable. *getimages* also reduces various observational and map-making artifacts and equalizes noise levels between independent tiles of mosaicked images. The code (a Bash script) uses FORTRAN utilities from *getsources* (ascl:1507.014), which must be installed.

[ascl:1507.014]
getsources: Multi-scale, multi-wavelength source extraction

*getsources* is a powerful multi-scale, multi-wavelength source extraction algorithm. It analyzes fine spatial decompositions of original images across a wide range of scales and across all wavebands, cleans those single-scale images of noise and background, and constructs wavelength-independent single-scale detection images that preserve information in both spatial and wavelength dimensions. *getsources* offers several advantages over other existing methods of source extraction, including the filtering out of irrelevant spatial scales to improve detectability, especially in the crowded regions and for extended sources, the ability to combine data over all wavebands, and the full automation of the extraction process.

[ascl:1608.014]
gevolution: General Relativity Cosmological N-body code for evolution of large scale structures

The N-body code *gevolution* complies with general relativity principles at every step; it calculates all six metric degrees of freedom in Poisson gauge. N-body particles are evolved by solving the geodesic equation written in terms of a canonical momentum to remain valid for relativistic particles. *gevolution* can be extended to include different kinds of dark energy or modified gravity models, going beyond the usually adopted quasi-static approximation. A weak field expansion is the central element of *gevolution*; this permits the code to treat settings in which no strong gravitational fields appear, including arbitrary scenarios with relativistic sources as long as gravitational fields are not very strong. The framework is well suited for cosmology, but may also be useful for astrophysical applications with moderate gravitational fields where a Newtonian treatment is insufficient.

[ascl:1509.008]
GFARGO: FARGO for GPU

GFARGO is a GPU version of FARGO (ascl:1102.017). It is written in C and C for CUDA and runs only on NVIDIA’s graphics cards. Though it corresponds to the standard, isothermal version of FARGO, not all functionalities of the CPU version have been translated to CUDA. The code is available in single and double precision versions, the latter compatible with FERMI architectures. GFARGO can run on a graphics card connected to the display, allowing the user to see in real time how the fields evolve.

[ascl:1510.001]
GGADT: Generalized Geometry Anomalous Diffraction Theory

GGADT uses anomalous diffraction theory (ADT) to compute the differential scattering cross section (or the total cross sections as a function of energy) for a specified grain of arbitrary geometry (natively supports spheres, ellipsoids, and clusters of spherical monomers). It is written in Fortran 95. ADT is valid when the grain is large compared to the wavelength of incident light. GGADT can calculate either the integrated cross sections (absorption, scattering, extinction) as a function of energy, or it can calculate the differential scattering cross section as a function of scattering angle.

[ascl:1112.008]
GGobi: A data visualization system

GGobi is an open source visualization program for exploring high-dimensional data. It provides highly dynamic and interactive graphics such as tours, as well as familiar graphics such as the scatterplot, barchart and parallel coordinates plots. Plots are interactive and linked with brushing and identification.

[ascl:1107.002]
GIBIS: Gaia Instrument and Basic Image Simulator

GIBIS is a pixel-level simulator of the Gaia mission. It is intended to simulate how the Gaia instruments will observe the sky, using realistic simulations of the astronomical sources and of the instrumental properties. It is a branch of the global Gaia Simulator under development within the Gaia DPAC CU2 Group (Data Simulations). Access is currently restricted to Gaia DPAC teams.

[ascl:1112.005]
GIDGET: Gravitational Instability-Dominated Galaxy Evolution Tool

Observations of disk galaxies at z~2 have demonstrated that turbulence driven by gravitational instability can dominate the energetics of the disk. GIDGET is a 1D simulation code, which we have made publicly available, that economically evolves these galaxies from z~2 to z~0 on a single CPU in a matter of minutes, tracking column density, metallicity, and velocity dispersions of gaseous and multiple stellar components. We include an H$_2$ regulated star formation law and the effects of stellar heating by transient spiral structure. We use this code to demonstrate a possible explanation for the existence of a thin and thick disk stellar population and the age-velocity dispersion correlation of stars in the solar neighborhood: the high velocity dispersion of gas in disks at z~2 decreases along with the cosmological accretion rate, while at lower redshift, the dynamically colder gas forms the low velocity dispersion stars of the thin disk.

[ascl:1305.010]
GILDAS: Grenoble Image and Line Data Analysis Software

GILDAS is a collection of software oriented toward (sub-)millimeter radioastronomical applications (either single-dish or interferometer). It has been adopted as the IRAM standard data reduction package and is jointly maintained by IRAM & CNRS. GILDAS contains many facilities, most of which are oriented towards spectral line mapping and many kinds of 3-dimensional data. The code, written in Fortran-90 with a few parts in C/C++ (mainly keyboard interaction, plotting, widgets), is easily extensible.

[ascl:1004.001]
GIM2D: Galaxy IMage 2D

GIM2D (Galaxy IMage 2D) is an IRAF/SPP package written to perform detailed bulge/disk decompositions of low signal-to-noise images of distant galaxies in a fully automated way. GIM2D takes an input image from HST or ground-based telescopes and outputs a galaxy-subtracted image as well as a catalog of structural parameters.

[ascl:1303.020]
Ginga: Flexible FITS viewer

Ginga is a viewer for astronomical data FITS (Flexible Image Transport System) files; the viewer centers around a FITS display widget which supports zooming and panning, color and intensity mapping, a choice of several automatic cut levels algorithms and canvases for plotting scalable geometric forms. In addition to this widget, the FITS viewer provides a flexible plugin framework for extending the viewer with many different features. A fairly complete set of "standard" plugins are provided for expected features of a modern viewer: panning and zooming windows, star catalog access, cuts, star pick/fwhm, thumbnails, and others. This viewer was written by software engineers at Subaru Telescope, National Astronomical Observatory of Japan, and is in use at that facility.

[ascl:1109.018]
GIPSY: Groningen Image Processing System

GIPSY is an acronym of Groningen Image Processing SYstem. It is a highly interactive software system for the reduction and display of astronomical data. It supports multi-tasking using a versatile user interface, it has an advanced data structure, a powerful script language and good display facilities based on the X Window system.

GIPSY consists of a number of components which can be divided into a number of classes:

- The user interfaces. Currently two user interfaces are available; one for interactive work and one for batch processing.
- The data structure.
- The display utilities.
- The application programs. These are the majority of programs.

[ascl:1810.012]
GiRaFFE: General relativistic force-free electrodynamics code

GiRaFFE leverages the Einstein Toolkit's (ascl:1102.014) highly-scalable infrastructure to create large-scale simulations of magnetized plasmas in strong, dynamical spacetimes on adaptive-mesh refinement (AMR) grids. It is based on IllinoisGRMHD, a user-friendly, open-source, dynamical-spacetime GRMHD code, and is highly scalable, to tens of thousands of cores.

[ascl:1410.003]
GIZMO: Multi-method magneto-hydrodynamics+gravity code

GIZMO is a flexible, multi-method magneto-hydrodynamics+gravity code that solves the hydrodynamic equations using a variety of different methods. It introduces new Lagrangian Godunov-type methods that allow solving the fluid equations with a moving particle distribution that is automatically adaptive in resolution and avoids the advection errors, angular momentum conservation errors, and excessive diffusion problems that seriously limit the applicability of “adaptive mesh” (AMR) codes, while simultaneously avoiding the low-order errors inherent to simpler methods like smoothed-particle hydrodynamics (SPH). GIZMO also allows the use of SPH either in “traditional” form or “modern” (more accurate) forms, or use of a mesh. Self-gravity is solved quickly with a BH-Tree (optionally a hybrid PM-Tree for periodic boundaries) and on-the-fly adaptive gravitational softenings. The code is descended from P-GADGET, itself descended from GADGET-2 (ascl:0003.001), and many of the naming conventions remain (for the sake of compatibility with the large library of GADGET work and analysis software).

[ascl:1805.025]
GLACiAR: GaLAxy survey Completeness AlgoRithm

GLACiAR (GaLAxy survey Completeness AlgoRithm) estimates the completeness and selection functions in galaxy surveys. Tailored for multiband imaging surveys aimed at searching for high-redshift galaxies through the Lyman Break technique, the code can nevertheless be applied broadly. GLACiAR generates artificial galaxies that follow Sérsic profiles with different indexes and with customizable size, redshift and spectral energy distribution properties, adds them to input images, and measures the recovery rate.

[ascl:1812.002]
GLADIS: GLobal Accretion Disk Instability Simulation

GLADIS (GLobal Accretion Disk Instability Simulation) computes the time-dependent evolution of a black hole accretion disk, in one-dimensional, axisymmetric, vertically integrated scheme. The code solves two partial-differential equations of hydrodynamics for surface density and temperature evolution, *i.e.*, given by viscous diffusion and energy conservation. Accretion disks can be subject to radiation-pressure instability if the stress tensor is proportional to the total (gas plus radiation) pressure. In the gas-pressure dominated case there is no instability. An intermediate case is provided in the code by the square root of the gas and total pressures. GLADIS is parallelized with MPI, and sample .ini and run command files are provided with the code.

[ascl:1010.012]
glafic: Software Package for Analyzing Gravitational Lensing

glafic is a public software package for analyzing gravitational lensing. It offers many features including computations of various lens properties for many mass models, solving the lens equation using an adaptive grid algorithm, simulations of lensed extended images with PSF convolved, and efficient modeling of observed strong lens systems.

[ascl:1806.009]
GLASS: Parallel, free-form gravitational lens modeling tool and framework

GLASS models strong gravitational lenses. It produces an ensemble of possible models that fit the observed input data and conform to certain constraints specified by the user. GLASS makes heavy use of the numerical routines provided by the numpy and scipy packages as well as the linear programming package GLPK. This latter package, and its Python interface, is provided with GLASS and installs automatically in the GLASS build directory.

[ascl:1103.006]
GLESP 2.0: Gauss-Legendre Sky Pixelization for CMB Analysis

Doroshkevich, A. G.; Naselsky, P. D.; Verkhodanov, O. V.; Novikov, D. I.; Turchaninov, V. I.; Novikov, I. D.; Christensen, P. R.; Chiang, L.-Y.

GLESP is a pixelization scheme for the cosmic microwave background (CMB) radiation maps. This scheme is based on the Gauss-Legendre polynomials zeros and allows one to create strict orthogonal expansion of the map.

[ascl:1802.010]
Glimpse: Sparsity based weak lensing mass-mapping tool

Glimpse, also known as Glimpse2D, is a weak lensing mass-mapping tool that relies on a robust sparsity-based regularization scheme to recover high resolution convergence from either gravitational shear alone or from a combination of shear and flexion. Including flexion allows the supplementation of the shear on small scales in order to increase the sensitivity to substructures and the overall resolution of the convergence map. To preserve all available small scale information, Glimpse avoids any binning of the irregularly sampled input shear and flexion fields and treats the mass-mapping problem as a general ill-posed inverse problem, regularized using a multi-scale wavelet sparsity prior. The resulting algorithm incorporates redshift, reduced shear, and reduced flexion measurements for individual galaxies and is made highly efficient by the use of fast Fourier estimators.

[ascl:1110.008]
Glnemo2: Interactive Visualization 3D Program

Glnemo2 is an interactive 3D visualization program developed in C++ using the OpenGL library and Nokia QT 4.X API. It displays in 3D the particles positions of the different components of an nbody snapshot. It quickly gives a lot of information about the data (shape, density area, formation of structures such as spirals, bars, or peanuts). It allows for in/out zooms, rotations, changes of scale, translations, selection of different groups of particles and plots in different blending colors. It can color particles according to their density or temperature, play with the density threshold, trace orbits, display different time steps, take automatic screenshots to make movies, select particles using the mouse, and fly over a simulation using a given camera path. All these features are accessible from a very intuitive graphic user interface.

Glnemo2 supports a wide range of input file formats (Nemo, Gadget 1 and 2, phiGrape, Ramses, list of files, realtime gyrfalcON simulation) which are automatically detected at loading time without user intervention. Glnemo2 uses a plugin mechanism to load the data, so that it is easy to add a new file reader. It's powered by a 3D engine which uses the latest OpenGL technology, such as shaders (glsl), vertex buffer object, frame buffer object, and takes in account the power of the graphic card used in order to accelerate the rendering. With a fast GPU, millions of particles can be rendered in real time. Glnemo2 runs on Linux, Windows (using minGW compiler), and MaxOSX, thanks to the QT4API.

[ascl:1011.010]
Global Sky Model (GSM): A Model of Diffuse Galactic Radio Emission from 10 MHz to 100 GHz

de Oliveira-Costa, Angelica; Tegmark, Max; Gaensler, B. M.; Jonas, Justin; Landecker, T. L.; Reich, Patricia

Understanding diffuse Galactic radio emission is interesting both in its own right and for minimizing foreground contamination of cosmological measurements. Cosmic Microwave Background experiments have focused on frequencies > 10 GHz, whereas 21 cm tomography of the high redshift universe will mainly focus on < 0.2 GHz, for which less is currently known about Galactic emission. Motivated by this, we present a global sky model derived from all publicly available total power large-area radio surveys, digitized with optical character recognition when necessary and compiled into a uniform format, as well as the new Villa Elisa data extending the 1.4 GHz map to the entire sky. We quantify statistical and systematic uncertainties in these surveys by comparing them with various global multi-frequency model fits. We find that a principal component based model with only three components can fit the 11 most accurate data sets (at 10, 22, 45 & 408 MHz and 1.4, 2.3, 23, 33, 41, 61, 94 GHz) to an accuracy around 1%-10% depending on frequency and sky region. The data compilation and software returning a predicted all-sky map at any frequency from 10 MHz to 100 GHz are publicly available in the archive file at the link below.

[ascl:1807.019]
GLS: Generalized Lomb-Scargle periodogram

The Lomb-Scargle periodogram is a common tool in the frequency analysis of unequally spaced data equivalent to least-squares fitting of sine waves. GLS is a solution for the generalization to a full sine wave fit, including an offset and weights (χ2 fitting). Compared to the Lomb-Scargle periodogram, GLS is superior as it provides more accurate frequencies, is less susceptible to aliasing, and gives a much better determination of the spectral intensity.

[ascl:1402.002]
Glue: Linked data visualizations across multiple files

Glue, written in Python, links visualizations of scientific datasets across many files, allowing for interactive, linked statistical graphics of multiple files. It supports many file formats including common image formats (jpg, tiff, png), ASCII tables, astronomical image and table formats (FITS, VOT, IPAC), and HDF5. Custom data loaders can also be easily added. Glue is highly scriptable and extendable.

[ascl:1710.015]
GMCALab: Generalized Morphological Component Analysis

GMCALab solves Blind Source Separation (BSS) problems from multichannel/multispectral/hyperspectral data. In essence, multichannel data provide different observations of the same physical phenomena (e.g. multiple wavelengths), which are modeled as a linear combination of unknown elementary components or sources. Written as a set of Matlab toolboxes, it provides a generic framework that can be extended to tackle different matrix factorization problems.

[ascl:1708.013]
GMM: Gaussian Mixture Modeling

GMM (Gaussian Mixture Modeling) tests the existence of bimodality in globular cluster color distributions. GMM uses three indicators to distinguish unimodal and bimodal distributions: the kurtosis of the distribution, the separation of the peaks, and the probability of obtaining the same χ2 from a unimodal distribution.

[ascl:1801.009]
Gnuastro: GNU Astronomy Utilities

Gnuastro (GNU Astronomy Utilities) manipulates and analyzes astronomical data. It is an official GNU package of a large collection of programs and C/C++ library functions. Command-line programs perform arithmetic operations on images, convert FITS images to common types like JPG or PDF, convolve an image with a given kernel or matching of kernels, perform cosmological calculations, crop parts of large images (possibly in multiple files), manipulate FITS extensions and keywords, and perform statistical operations. In addition, it contains programs to make catalogs from detection maps, add noise, make mock profiles with a variety of radial functions using monte-carlo integration for their centers, match catalogs, and detect objects in an image among many other operations. The command-line programs share the same basic command-line user interface for the comfort of both the users and developers. Gnuastro is written to comply fully with the GNU coding standards and integrates well with all Unix-like operating systems. This enables astronomers to expect a fully familiar experience in the source code, building, installing and command-line user interaction that they have seen in all the other GNU software that they use. Gnuastro's extensive library is included for users who want to build their own unique programs.

[ascl:1210.003]
GOSSIP: SED fitting code

GOSSIP fits the electro-magnetic emission of an object (the SED, Spectral Energy Distribution) against synthetic models to find the simulated one that best reproduces the observed data. It builds-up the observed SED of an object (or a large sample of objects) combining magnitudes in different bands and eventually a spectrum; then it performs a chi-square minimization fitting procedure versus a set of synthetic models. The fitting results are used to estimate a number of physical parameters like the Star Formation History, absolute magnitudes, stellar mass and their Probability Distribution Functions.

[ascl:1210.001]
GP2PCF: Brute-force computation of 2-point correlation functions

The two-point correlation function is a simple statistic that quantifies the clustering of a given distribution of objects. In studies of the large scale structure of the Universe, it is an important tool containing information about the matter clustering and the evolution of the Universe at different cosmological epochs. A classical application of this statistic is the galaxy-galaxy correlation function to find constraints on the parameter Omega_m or the location of the baryonic acoustic oscillation peak. This calculation, however, is very expensive in terms of computer power and Graphics Processing Units provide one solution for efficient analysis of the increasingly larger galaxy surveys that are currently taking place.

GP2PCF is a public code in CUDA for performing this computation; with a single GPU board it is possible to achieve 120-fold speedups with respect to a standard implementation in C running on a single CPU. With respect to other solutions such as k-trees the improvement is of a factor of a few retaining full precision. The speedup is comparable to running in parallel in a cluster of O(100) cores.

[ascl:1512.006]
GPC: General Polygon Clipper library

The University of Manchester GPC library is a flexible and highly robust polygon set operations library for use with C, C#, Delphi, Java, Perl, Python, Haskell, Lua, VB.Net and other applications. It supports difference, intersection, exclusive-or and union clip operations, and polygons may be comprised of multiple disjoint contours. Contour vertices may be given in any order - clockwise or anticlockwise, and contours may be convex, concave or self-intersecting, and may be nested (i.e. polygons may have holes). Output may take the form of either polygon contours or tristrips, and hole and external contours are differentiated in the result. GPC is free for non-profit and educational use; a Commercial Use License is required for commercial use.

[ascl:1603.004]
gPhoton: Time-tagged GALEX photon events analysis tools

Written in Python, gPhoton calibrates and sky-projects the ~1.1 trillion ultraviolet photon events detected by the microchannel plates on the Galaxy Evolution Explorer Spacecraft (GALEX), archives these events in a publicly accessible database at the Mikulski Archive for Space Telescopes (MAST), and provides tools for working with the database to extract scientific results, particularly over short time domains. The software includes a re-implementation of core functionality of the GALEX mission calibration pipeline to produce photon list files from raw spacecraft data as well as a suite of command line tools to generate calibrated light curves, images, and movies from the MAST database.

[ascl:1411.018]
GPI Pipeline: Gemini Planet Imager Data Pipeline

The GPI data pipeline allows users to reduce and calibrate raw GPI data into spectral and polarimetric datacubes, and to apply various PSF subtraction methods to those data. Written in IDL and available in a compiled version, the software includes an integrated calibration database to manage reference files and an interactive data viewer customized for high contrast imaging that allows exploration and manipulation of data.

[ascl:1403.001]
GPU-D: Generating cosmological microlensing magnification maps

GPU-D is a GPU-accelerated implementation of the inverse ray-shooting technique used to generate cosmological microlensing magnification maps. These maps approximate the source plane magnification patterns created by an ensemble of stellar-mass compact objects within a foreground macrolens galaxy. Unlike other implementations, GPU-D solves the gravitational lens equation without any approximation. Due to the high computational intensity and high degree of parallelization inherent in the algorithm, it is ideal for brute-force implementation on GPUs. GPU-D uses CUDA for GPU acceleration and require NVIDIA devices to run.

[ascl:1010.022]
GR1D: Open-Source Code for Spherically-Symmetric Stellar Collapse to Neutron Stars and Black Holes

GR1D is based on the Eulerian formulation of GR hydrodynamics (GRHD) put forth by Romero-Ibanez-Gourgoulhon and employs radial-gauge, polar-slicing coordinates in which the 3+1 equations simplify substantially. GR1D is intended for the simulation of stellar collapse to neutron stars and black holes and will also serve as a testbed for modeling technology to be incorporated in multi-D GR codes. Its GRHD part is coupled to various finite-temperature microphysical equations of state in tabulated form that we make available with GR1D.

[ascl:1612.020]
Grackle: Chemistry and radiative cooling library for astrophysical simulations

Smith, Britton D.; Bryan, Greg L.; Glover, Simon C. O.; Goldbaum, Nathan J.; Turk, Matthew J.; Regan, John; Wise, John H.; Schive, Hsi-Yu; Abel, Tom; Emerick, Andrew; O'Shea, Brian W.; Anninos, Peter; Hummels, Cameron B.; Khochfar, Sadegh

The chemistry and radiative cooling library Grackle provides options for primordial chemistry and cooling, photo-heating and photo-ionization from UV backgrounds, and support for user-provided arrays of volumetric and specific heating rates for astrophysical simulations and models. The library provides functions to update chemistry species; solve radiative cooling and update internal energy; and calculate cooling time, temperature, pressure, and ratio of specific heats (gamma), and has interfaces for C, C++, Fortran, and Python codes.

[ascl:1010.080]
GRACOS: Scalable and Load Balanced P3M Cosmological N-body Code

The GRACOS (GRAvitational COSmology) code, a parallel implementation of the particle-particle/particle-mesh (P3M) algorithm for distributed memory clusters, uses a hybrid method for both computation and domain decomposition. Long-range forces are computed using a Fourier transform gravity solver on a regular mesh; the mesh is distributed across parallel processes using a static one-dimensional slab domain decomposition. Short-range forces are computed by direct summation of close pairs; particles are distributed using a dynamic domain decomposition based on a space-filling Hilbert curve. A nearly-optimal method was devised to dynamically repartition the particle distribution so as to maintain load balance even for extremely inhomogeneous mass distributions. Tests using $800^3$ simulations on a 40-processor beowulf cluster showed good load balance and scalability up to 80 processes. There are limits on scalability imposed by communication and extreme clustering which may be removed by extending the algorithm to include adaptive mesh refinement.

[ascl:1106.008]
GRAFIC-2: Multiscale Gaussian Random Fields for Cosmological Simulations

This paper describes the generation of initial conditions for numerical simulations in cosmology with multiple levels of resolution, or multiscale simulations. We present the theory of adaptive mesh refinement of Gaussian random fields followed by the implementation and testing of a computer code package performing this refinement called GRAFIC-2.

[ascl:1011.021]
GRALE: A genetic algorithm for the non-parametric inversion of strong lensing systems

We present a non-parametric technique to infer the projected-mass distribution of a gravitational lens system with multiple strong-lensed images. The technique involves a dynamic grid in the lens plane on which the mass distribution of the lens is approximated by a sum of basis functions, one per grid cell. We used the projected mass densities of Plummer spheres as basis functions. A genetic algorithm then determines the mass distribution of the lens by forcing images of a single source, projected back onto the source plane, to coincide as well as possible. Averaging several tens of solutions removes the random fluctuations that are introduced by the reproduction process of genomes in the genetic algorithm and highlights those features common to all solutions. Given the positions of the images and the redshifts of the sources and the lens, we show that the mass of a gravitational lens can be retrieved with an accuracy of a few percent and that, if the sources sufficiently cover the caustics, the mass distribution of the gravitational lens can also be reliably retrieved. A major advantage of the algorithm is that it makes full use of the information contained in the radial images, unlike methods that minimise the residuals of the lens equation, and is thus able to accurately reconstruct also the inner parts of the lens.

[ascl:1812.011]
GRAND-HOD: GeneRalized ANd Differentiable Halo Occupation Distribution

GRAND-HOD (GeneRalized ANd Differentiable Halo Occupation Distribution) takes a generalized Halo Occupation Distribution (HOD) prescription as input and outputs the corresponding mock galaxy catalogs in binary files. The code is differentiable and incorporates various generalizations to the standard HOD. It is written for the Abacus simulations, but the main functionalities can be easily adapted for other halo catalogs with the appropriate properties.

[ascl:1204.006]
GRASIL: Spectral evolution of stellar systems with dust

GRASIL (which stands for GRAphite and SILicate) computes the spectral evolution of stellar systems taking into account the effects of dust, which absorbs and scatters optical and UV photons and emits in the IR-submm region. It may be used as well to do “standard” no-dust stellar spectral synthesis. The code is very well calibrated and applied to interpret galaxies at different redshifts. GRASIL can be downloaded or run online using the GALSYNTH WEB interface.

[ascl:1609.008]
GRASP: General-purpose Relativistic Atomic Structure Package

GRASP (General-purpose Relativistic Atomic Structure Package) calculates atomic structure, including energy levels, radiative rates (A-values) and lifetimes; it is a fully relativistic code based on the *jj* coupling scheme. This code has been superseded by GRASP2K (ascl:1611.007).

[ascl:1611.007]
GRASP2K: Relativistic Atomic Structure Package

GRASP2K is a revised and greatly expanded version of GRASP (ascl:1609.008) and is adapted for 64-bit computer architecture. It includes new angular libraries, can transform from *jj*- to *LSJ*-coupling, and coefficients of fractional parentage have been extended to *j*=9/2, making calculations feasible for the lanthanides and actinides. GRASP2K identifies each atomic state by the total energy and a label for the configuration state function with the largest expansion coefficient in *LSJLSJ* intermediate coupling.

[ascl:1102.003]
GRAVLENS: Computational Methods for Gravitational Lensing

Modern applications of strong gravitational lensing require the ability to use precise and varied observational data to constrain complex lens models. Two sets of computational methods for lensing calculations are discussed. The first is a new algorithm for solving the lens equation for general mass distributions. This algorithm makes it possible to apply arbitrarily complicated models to observed lenses. The second is an evaluation of techniques for using observational data including positions, fluxes, and time delays of point-like images, as well as maps of extended images, to constrain models of strong lenses. The techniques presented here are implemented in a flexible and user-friendly software package called gravlens, which is made available to the community.

[ascl:1403.005]
GRay: Massive parallel ODE integrator

GRay is a massive parallel ordinary differential equation integrator that employs the "stream processing paradigm." It is designed to efficiently integrate billions of photons in curved spacetime according to Einstein's general theory of relativity. The code is implemented in CUDA C/C++.

[ascl:1701.008]
GrayStar: Web-based pedagogical stellar modeling

GrayStar is a web-based pedagogical stellar model. It approximates stellar atmospheric and spectral line modeling in JavaScript with visualization in HTML. It is suitable for a wide range of education and public outreach levels depending on which optional plots and print-outs are turned on. All plots and renderings are pure basic HTML and the plotting module contains original HTML procedures for automatically scaling and graduating x- and y-axes.

[ascl:1701.009]
GrayStarServer: Stellar atmospheric modeling and spectrum synthesis

GrayStarServer is a stellar atmospheric modeling and spectrum synthesis code of pedagogical accuracy that is accessible in any web browser on commonplace computational devices and that runs on a timescale of a few seconds.

[ascl:1302.007]
GRID-core: Gravitational Potential Identification of Cores

GRID-core is a core-finding method using the contours of the local gravitational potential to identify core boundaries. The GRID-core method applied to 2D surface density and 3D volume density are in good agreement for bound cores. We have implemented a version of the GRID-core algorithm in IDL, suitable for core-finding in observed maps. The required input is a two-dimensional FITS file containing a map of the column density in a region of a cloud.

[ascl:1702.012]
GRIM: General Relativistic Implicit Magnetohydrodynamics

GRIM (General Relativistic Implicit Magnetohydrodynamics) evolves a covariant extended magnetohydrodynamics model derived by treating non-ideal effects as a perturbation of ideal magnetohydrodynamics. Non-ideal effects are modeled through heat conduction along magnetic field lines and a difference between the pressure parallel and perpendicular to the field lines. The model relies on an effective collisionality in the disc from wave-particle scattering and velocity-space (mirror and firehose) instabilities. GRIM, which runs on CPUs as well as on GPUs, combines time evolution and primitive variable inversion needed for conservative schemes into a single step using only the residuals of the governing equations as inputs. This enables the code to be physics agnostic as well as flexible regarding time-stepping schemes.

[ascl:1306.002]
grmonty: Relativistic radiative transport Monte Carlo code

grmonty is a Monte Carlo radiative transport code intended for calculating spectra of hot, optically thin plasmas in full general relativity. The code models hot accretion flows in the Kerr metric, it incorporates synchrotron emission and absorption and Compton scattering. grmonty can be readily generalized to account for other radiative processes and an arbitrary spacetime.

[ascl:1512.018]
growl: Growth factor and growth rate of expanding universes

Growl calculates the linear growth factor Da and its logarithmic derivative dln D/dln a in expanding Friedmann-Robertson-Walker universes with arbitrary matter and vacuum densities. It permits rapid and stable numerical evaluation.

[ascl:1605.013]
grtrans: Polarized general relativistic radiative transfer via ray tracing

grtrans calculates ray tracing radiative transfer in the Kerr metric, including the full treatment of polarised radiative transfer and parallel transport along geodesics, for comparing theoretical models of black hole accretion flows and jets with observations. The code is written in Fortran 90 and parallelizes with OpenMP; the full code and several components have Python interfaces. grtrans includes Geokerr (ascl:1011.015) and requires cfitsio (ascl:1010.001) and pyfits (ascl:1207.009).

[ascl:1503.009]
GSD: Global Section Datafile access library

Tilanus, Remo; Meyerdierks, Horst; Jenness, Tim; Fairclough, Jon; Padman, Rachael; Redman, Russell; Cockayne, Steve

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

[ascl:1806.008]
gsf: galactic structure finder

Obreja, Aura; Macciò, Andrea V.; Moster, Benjamin; Dutton, Aaron A.; Buck, Tobias; Stinson, Gregory S.; Wang, Liang

gsf applies Gaussian Mixture Models in the stellar kinematic space of normalized angular momentum and binding energy on NIHAO high resolution galaxies to separate the stars into multiple components. The gsf analysis package assumes that the simulation snapshot has been pre-processed with a halo finder. It is based on pynbody (ascl:1305.002) and the scikit-learnpython package for Machine Learning; after loading, orienting, and transforming a simulation snapshot to physical units, it runs the clustering algorithm and performs the direct N-body gravity force using all the particles in the given halo.

[ascl:1610.005]
GSGS: In-Focus Phase Retrieval Using Non-Redundant Mask Data

GSGS does phase retrieval on images given an estimate of the pupil phase (from a non-redundant mask or other interferometric approach), the pupil geometry, and the in-focus image. The code uses a modified Gerchberg-Saxton algorithm that iterates between pupil plane and image plane to measure the pupil phase.

[ascl:1701.011]
GWFrames: Manipulate gravitational waveforms

GWFrames eliminates all rotational behavior, thus simplifying the waveform as much as possible and allowing direct generalizations of methods for analyzing nonprecessing systems. In the process, the angular velocity of a waveform is introduced, which also has important uses, such as supplying a partial solution to an important inverse problem.

[ascl:1203.005]
Gyoto: General relativitY Orbit Tracer of Observatoire de Paris

GYOTO, a general relativistic ray-tracing code, aims at computing images of astronomical bodies in the vicinity of compact objects, as well as trajectories of massive bodies in relativistic environments. This code is capable of integrating the null and timelike geodesic equations not only in the Kerr metric, but also in any metric computed numerically within the 3+1 formalism of general relativity. Simulated images and spectra have been computed for a variety of astronomical targets, such as a moving star or a toroidal accretion structure. The underlying code is open source and freely available. It is user-friendly, quickly handled and very modular so that extensions are easy to integrate. Custom analytical metrics and astronomical targets can be implemented in C++ plug-in extensions independent from the main code.

[ascl:1308.010]
GYRE: Stellar oscillation code

GYRE is an oscillation code that solves the stellar pulsation equations (both adiabatic and non-adiabatic) using a novel Magnus Multiple Shooting numerical scheme devised to overcome certain weaknesses of the usual relaxation and shooting schemes. The code is accurate (up to 6th order in the number of grid points), robust, and makes efficient use of multiple processor cores and/or nodes.

[ascl:1402.031]
gyrfalcON: N-body code

gyrfalcON (GalaxY simulatoR using falcON) is a full-fledged N-body code using Dehnen’s force algorithm of complexity O(N) (falcON); this algorithm is approximately 10 times faster than an optimally coded tree code. The code features individual adaptive time steps and individual (but fixed) softening lengths. gyrfalcON is included in and requires NEMO to run.

[ascl:1402.032]
HALOFIT: Nonlinear distribution of cosmological mass and galaxies

HALOFIT provides an explanatory framework for galaxy bias and clustering and has been incorporated into CMB packages such as CMBFAST (ascl:9909.004) and CAMB (ascl:1102.026). It attains a reasonable level of precision, though the halo model does not match N-body data perfectly. The code is written in Fortran 77. HALOFIT tends to underpredict the power on the smallest scales in standard LCDM universes (although HALOFIT was designed to work for a much wider range of power spectra); its accuracy can be improved by using a supplied correction.

[ascl:1010.053]
Halofitting codes for DGP and Degravitation

We perform N-body simulations of theories with infinite-volume extra dimensions, such as the Dvali-Gabadadze-Porrati (DGP) model and its higher-dimensional generalizations, where 4D gravity is mediated by massive gravitons. The longitudinal mode of these gravitons mediates an extra scalar force, which we model as a density-dependent modification to the Poisson equation. This enhances gravitational clustering, particularly on scales that have undergone mild nonlinear processing. While the standard non-linear fitting algorithm of Smith et al. overestimates this power enhancement on non-linear scales, we present a modified fitting formula that offers a remarkably good fit to our power spectra. Due to the uncertainty in galaxy bias, our results are consistent with precision power spectrum determinations from galaxy redshift surveys, even for graviton Compton wavelengths as small as 300 Mpc. Our model is sufficiently general that we expect it to capture the phenomenology of a wide class of related higher-dimensional gravity scenarios.

[ascl:1505.017]
HALOGEN: Approximate synthetic halo catalog generator

HALOGEN generates approximate synthetic halo catalogs. Written in C, it decomposes the problem of generating cosmological tracer distributions (eg. halos) into four steps: generating an approximate density field, generating the required number of tracers from a CDF over mass, placing the tracers on field particles according to a bias scheme dependent on local density, and assigning velocities to the tracers based on velocities of local particles. It also implements a default set of four models for these steps. HALOGEN uses 2LPTic (ascl:1201.005) and CUTE (ascl:1505.016); the software is flexible and can be adapted to varying cosmologies and simulation specifications.

[ascl:1407.020]
Halogen: Multimass spherical structure models for N-body simulations

Halogen, written in C, generates multimass spherically symmetric initial conditions for N-body simulations. A large family of radial density profiles is supported. The initial conditions are sampled from the full distribution function.

[ascl:1604.005]
Halotools: Galaxy-Halo connection models

Hearin, Andrew; Tollerud, Erik; Robitaille,Thomas; Droettboom, Michael; Zentner, Andrew; Bray, Erik; Craig, Matt; Bradley, Larry; Barbary, Kyle; Deil, Christoph; Tan, Kevin; Becker, Matthew R.; More, Surhud; Günther, Hans Moritz; Sipocz, Brigitta

Halotools builds and tests models of the galaxy-halo connection and analyzes catalogs of dark matter halos. The core functions of the package include fast generation of synthetic galaxy populations using HODs, abundance matching, and related methods; efficient algorithms for calculating galaxy clustering, lensing, z-space distortions, and other astronomical statistics; a modular, object-oriented framework for designing galaxy evolution models; and end-to-end support for reducing halo catalogs and caching them as hdf5 files.

[ascl:1210.022]
HAM2D: 2D Shearing Box Model

HAM solves non-relativistic hyperbolic partial differential equations in conservative form using high-resolution shock-capturing techniques. This version of HAM has been configured to solve the magnetohydrodynamic equations of motion in axisymmetry to evolve a shearing box model.

[ascl:1201.014]
Hammurabi: Simulating polarized Galactic synchrotron emission

The Hammurabi code is a publicly available C++ code for generating mock polarized observations of Galactic synchrotron emission with telescopes such as LOFAR, SKA, Planck, and WMAP, based on model inputs for the Galactic magnetic field (GMF), the cosmic-ray density distribution, and the thermal electron density. The Hammurabi code allows one to perform simulations of several different data sets simultaneously, providing a more reliable constraint of the magnetized ISM.

[ascl:1209.005]
HARM: A Numerical Scheme for General Relativistic Magnetohydrodynamics

HARM uses a conservative, shock-capturing scheme for evolving the equations of general relativistic magnetohydrodynamics. The fluxes are calculated using the Harten, Lax, & van Leer scheme. A variant of constrained transport, proposed earlier by Tóth, is used to maintain a divergence-free magnetic field. Only the covariant form of the metric in a coordinate basis is required to specify the geometry. On smooth flows HARM converges at second order.

[ascl:1306.003]
Harmony: Synchrotron Emission Coefficients

Harmony is a general numerical scheme for evaluating MBS emission and absorption coefficients for both polarized and unpolarized light in a plasma with a general distribution function.

[ascl:1109.004]
HAZEL: HAnle and ZEeman Light

A big challenge in solar and stellar physics in the coming years will be to decipher the magnetism of the solar outer atmosphere (chromosphere and corona) along with its dynamic coupling with the magnetic fields of the underlying photosphere. To this end, it is important to develop rigorous diagnostic tools for the physical interpretation of spectropolarimetric observations in suitably chosen spectral lines. HAZEL is a computer program for the synthesis and inversion of Stokes profiles caused by the joint action of atomic level polarization and the Hanle and Zeeman effects in some spectral lines of diagnostic interest, such as those of the He I 1083.0 nm and 587.6 nm (or D3) multiplets. It is based on the quantum theory of spectral line polarization, which takes into account in a rigorous way all the relevant physical mechanisms and ingredients (optical pumping, atomic level polarization, level crossings and repulsions, Zeeman, Paschen-Back and Hanle effects). The influence of radiative transfer on the emergent spectral line radiation is taken into account through a suitable slab model. The user can either calculate the emergent intensity and polarization for any given magnetic field vector or infer the dynamical and magnetic properties from the observed Stokes profiles via an efficient inversion algorithm based on global optimization methods.

[ascl:1711.022]
HBT: Hierarchical Bound-Tracing

HBT is a Hierarchical Bound-Tracing subhalo finder and merger tree builder, for numerical simulations in cosmology. It tracks haloes from birth and continues to track them after mergers, finding self-bound structures as subhaloes and recording their merger histories as merger trees.

[ascl:1711.023]
HBT+: Subhalo finder and merger tree builder

HBT+ is a hybrid subhalo finder and merger tree builder for cosmological simulations. It comes as an MPI edition that can be run on distributed clusters or shared memory machines and is MPI/OpenMP parallelized, and also as an OpenMP edition that can be run on shared memory machines and is only OpenMP parallelized. This version is more memory efficient than the MPI branch on shared memory machines, and is more suitable for analyzing zoomed-in simulations that are difficult to balance on distributed clusters. Both editions support hydro simulations with gas/stars.

[ascl:1502.009]
HDS: Hierarchical Data System

Pearce, Dave; Walter, Anton; Lupton, W. F.; Warren-Smith, Rodney F.; Lawden, Mike; McIlwrath, Brian; Peden, J. C. M.; Jenness, Tim; Draper, Peter W.

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

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

[ascl:1107.018]
HEALPix: Hierarchical Equal Area isoLatitude Pixelization of a sphere

HEALPix is an acronym for Hierarchical Equal Area isoLatitude Pixelization of a sphere. As suggested in the name, this pixelization produces a subdivision of a spherical surface in which each pixel covers the same surface area as every other pixel. Another property of the HEALPix grid is that the pixel centers occur on a discrete number of rings of constant latitude, the number of constant-latitude rings is dependent on the resolution of the HEALPix grid.

[ascl:1408.004]
HEAsoft: Unified Release of FTOOLS and XANADU

HEASOFT combines XANADU, high-level, multi-mission software for X-ray astronomical spectral, timing, and imaging data analysis tasks, and FTOOLS (ascl:9912.002), general and mission-specific software to manipulate FITS files, into one package. It also contains contains the NuSTAR subpackage of tasks, NuSTAR Data Analysis Software (NuSTARDAS). The source code for the software can be downloaded; precompiled executables for the most widely used computer platforms are also available for download. As an additional service, HEAsoft tasks can be directly from a web browser via WebHera.

[ascl:1506.009]
HEATCVB: Coronal heating rate approximations

HEATCVB is a stand-alone Fortran 77 subroutine that estimates the local volumetric coronal heating rate with four required inputs: the radial distance r, the wind speed u, the mass density ρ, and the magnetic field strength |B0|. The primary output is the heating rate Qturb at the location defined by the input parameters. HEATCVB also computes the local turbulent dissipation rate of the waves, γ = Qturb/(2UA).

[ascl:1503.004]
HELIOS-K: Opacity Calculator for Radiative Transfer

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

[ascl:1807.009]
HELIOS: Radiative transfer code for exoplanetary atmospheres

Malik, Matej; Grosheintz, Luc; Mendonça, João M.; Grimm, Simon L.; Lavie, Baptiste; Kitzmann, Daniel; Tsai, Shang-Min; Burrows, Adam; Kreidberg, Laura; Bedell, Megan; Bean, Jacob L.; Stevenson, Kevin B.; Heng, Kevin

HELIOS, a radiative transfer code, is constructed for studying exoplanetary atmospheres. The model atmospheres of HELIOS are one-dimensional and plane-parallel, and the equation of radiative transfer is solved in the two-stream approximation with non-isotropic scattering. Though HELIOS can be used alone, the opacity calculator HELIOS-K (ascl:1503.004) can be used with it to provide the molecular opacities.

[ascl:1805.019]
HENDRICS: High ENergy Data Reduction Interface from the Command Shell

HENDRICS, a rewrite and update to MaLTPyNT (ascl:1502.021), contains command-line scripts based on Stingray (ascl:1608.001) to perform a quick-look (spectral-)timing analysis of X-ray data, treating the gaps in the data due, e.g., to occultation from the Earth or passages through the SAA, properly. Despite its original main focus on NuSTAR, HENDRICS can perform standard aperiodic timing analysis on X-ray data from, in principle, any other satellite, and its features include power density and cross spectra, time lags, pulsar searches with the Epoch folding and the Z_n^2 statistics, color-color and color-intensity diagrams. The periodograms produced by HENDRICS (such as a power density spectrum or a cospectrum) can be saved in a format compatible with XSPEC (ascl:9910.005) or ISIS (ascl:1302.002)

[ascl:1102.016]
HERACLES: 3D Hydrodynamical Code to Simulate Astrophysical Fluid Flows

Audit, Edouard; González, Matthias; Vaytet, Neil; Fromang, Sebastien; Hennebelle, Patrick; Teyssier, Romain; Tremblin, Pascal; Thooris, Bruno

HERACLES is a 3D hydrodynamical code used to simulate astrophysical fluid flows. It uses a finite volume method on fixed grids to solve the equations of hydrodynamics, MHD, radiative transfer and gravity. This software is developed at the Service d'Astrophysique, CEA/Saclay as part of the COAST project and is registered under the CeCILL license. HERACLES simulates astrophysical fluid flows using a grid based Eulerian finite volume Godunov method. It is capable of simulating pure hydrodynamical flows, magneto-hydrodynamic flows, radiation hydrodynamic flows (using either flux limited diffusion or the M1 moment method), self-gravitating flows using a Poisson solver or all of the above. HERACLES uses cartesian, spherical and cylindrical grids.

[ascl:1808.005]
hfof: Friends-of-Friends via spatial hashing

hfof is a 3-d friends-of-friends (FoF) cluster finder with Python bindings based on a fast spatial hashing algorithm that identifies connected sets of points where the point-wise connections are determined by a fixed spatial distance. This technique sorts particles into fine cells sufficiently compact to guarantee their cohabitants are linked, and uses locality sensitive hashing to search for neighboring (blocks of) cells. Tests on N-body simulations of up to a billion particles exhibit speed increases of factors up to 20x compared with FOF via trees, and is consistently complete in less than the time of a k-d tree construction, giving it an intrinsic advantage over tree-based methods.

[ascl:1607.011]
HfS: Hyperfine Structure fitting tool

HfS fits the hyperfine structure of spectral lines, with multiple velocity components. The HfS_nh3 procedures included in HfS fit simultaneously the hyperfine structure of the NH_{3} (J,K)= (1,1) and (2,2) inversion transitions, and perform a standard analysis to derive the NH_{3} column density, rotational temperature T_{rot}, and kinetic temperature Tk. HfS uses a Monte Carlo approach for fitting the line parameters, with special attention to the derivation of the parameter uncertainties. HfS includes procedures that make use of parallel computing for fitting spectra from a data cube.

[ascl:1801.004]
hh0: Hierarchical Hubble Constant Inference

hh0 is a Bayesian hierarchical model (BHM) that describes the full distance ladder, from nearby geometric-distance anchors through Cepheids to SNe in the Hubble flow. It does not rely on any of the underlying distributions being Gaussian, allowing outliers to be modeled and obviating the need for any arbitrary data cuts.

[submitted]
HHTpywrapper: Python Wrapper for Hilbert–Huang Transform MATLAB Package

HHTpywrapper is a python interface to call the Hilbert–Huang Transform (HHT) MATLAB package. HHT is a time-frequency analysis method to adaptively decompose a signal, that could be generated by non-stationary and/or nonlinear processes, into basis components at different timescales, and then Hilbert transform these components into instantaneous phases, frequencies and amplitudes as functions of time. HHT has been successfully applied to analyzing X-ray quasi-periodic oscillations (QPOs) from the active galactic nucleus RE J1034+396 (Hu et al. 2014) and two black hole X-ray binaries, XTE J1550–564 (Su et al. 2015) and GX 339-4 (Su et al. 2017). HHTpywrapper provides examples of reproducing HHT analysis results in Su et al. (2015) and Su et al. (2017). This project is originated from the Astro Hack Week 2015.

[ascl:1808.010]
hi_class: Horndeski in the Cosmic Linear Anisotropy Solving System

hi_class implements Horndeski's theory of gravity in the modern Cosmic Linear Anisotropy Solving System (ascl:1106.020). It can be used to compute any cosmological observable at the level of background or linear perturbations, such as cosmological distances, cosmic microwave background, matter power and number count spectra (including relativistic effects). hi_class can be readily interfaced with Monte Python (ascl:1307.002) to test Gravity and Dark Energy models.

[ascl:1606.004]
HIBAYES: Global 21-cm Bayesian Monte-Carlo Model Fitting

HIBAYES implements fully-Bayesian extraction of the sky-averaged (global) 21-cm signal from the Cosmic Dawn and Epoch of Reionization in the presence of foreground emission. User-defined likelihood and prior functions are called by the sampler PyMultiNest (ascl:1606.005) in order to jointly explore the full (signal plus foreground) posterior probability distribution and evaluate the Bayesian evidence for a given model. Implemented models, for simulation and fitting, include gaussians (HI signal) and polynomials (foregrounds). Some simple plotting and analysis tools are supplied. The code can be extended to other models (physical or empirical), to incorporate data from other experiments, or to use alternative Monte-Carlo sampling engines as required.

[ascl:1607.019]
HIDE: HI Data Emulator

Akeret, Joel; Seehars, Sebastian; Chang, Chihway; Monstein, Christian; Amara, Adam; Refregier, Alexandre

HIDE (HI Data Emulator) forward-models the process of collecting astronomical radio signals in a single dish radio telescope instrument and outputs pixel-level time-ordered-data. Written in Python, HIDE models the noise and RFI modeling of the data and with its companion code SEEK (ascl:1607.020) provides end-to-end simulation and processing of radio survey data.

[ascl:1802.007]
HiGal_SED_Fitter: SED fitting tools for Herschel Hi-Gal data

HiGal SED Fitter fits modified blackbody SEDs to Herschel data, specifically targeted at Herschel Hi-Gal data.

[ascl:1010.065]
Higher Post Newtonian Gravity Calculations

Motivated by experimental probes of general relativity, we adopt methods from perturbative (quantum) field theory to compute, up to certain integrals, the effective lagrangian for its n-body problem. Perturbation theory is performed about a background Minkowski spacetime to O[(v/c)^4] beyond Newtonian gravity, where v is the typical speed of these n particles in their center of energy frame. For the specific case of the 2 body problem, the major efforts underway to measure gravitational waves produced by in-spiraling compact astrophysical binaries require their gravitational interactions to be computed beyond the currently known O[(v/c)^7]. We argue that such higher order post-Newtonian calculations must be automated for these field theoretic methods to be applied successfully to achieve this goal. In view of this, we outline an algorithm that would in principle generate the relevant Feynman diagrams to an arbitrary order in v/c and take steps to develop the necessary software. The Feynman diagrams contributing to the n-body effective action at O[(v/c)^6] beyond Newton are derived.

[ascl:1207.002]
HiGPUs: Hermite's N-body integrator running on Graphic Processing Units

HiGPUs is an implementation of the numerical integration of the classical, gravitational, N-body problem, based on a 6th order Hermite’s integration scheme with block time steps, with a direct evaluation of the particle-particle forces. The main innovation of this code is its full parallelization, exploiting both OpenMP and MPI in the use of the multicore Central Processing Units as well as either Compute Unified Device Architecture (CUDA) or OpenCL for the hosted Graphic Processing Units. We tested both performance and accuracy of the code using up to 256 GPUs in the supercomputer IBM iDataPlex DX360M3 Linux Infiniband Cluster provided by the italian supercomputing consortium CINECA, for values of N ≤ 8 millions. We were able to follow the evolution of a system of 8 million bodies for few crossing times, task previously unreached by direct summation codes.

HiGPUs is also available as part of the AMUSE project.

[ascl:1807.008]
HII-CHI-mistry_UV: Oxygen abundance and ionizionation parameters for ultraviolet emission lines

HII-CHI-mistry_UV derives oxygen and carbon abundances using the ultraviolet (UV) lines emitted by the gas phase ionized by massive stars. The code first fixes C/O using ratios of appropriate emission lines and, in a second step, calculates O/H and the ionization parameter from carbon lines in the UV. An optical version of this Python code, HII-CHI-mistry (ascl:1807.007), is also available.

[ascl:1807.007]
HII-CHI-mistry: Oxygen abundance and ionizionation parameters for optical emission lines

HII-CHI-mistry calculates the oxygen abundance for gaseous nebulae ionized by massive stars using optical collisionally excited emission lines. This code takes the extinction-corrected emission line fluxes and, based on a *Χ*^{2} minimization on a photoionization models grid, determines chemical-abundances (O/H, N/O) and ionization parameters. An ultraviolet version of this Python code, HII-CHI-mistry-UV (ascl:1807.008), is also available.

[ascl:1603.017]
HIIexplorer: Detect and extract integrated spectra of HII regions

HIIexplorer detects and extracts the integrated spectra of HII regions from IFS datacubes. The procedure assumes H ii regions are peaky/isolated structures with a strong ionized gas emission, clearly above the continuum emission and the average ionized gas emission across the galaxy and that H ii regions have a typical physical size of about a hundred or a few hundreds of parsecs, which corresponds to a typical projected size at the distance of the galaxies of a few arcsec for galaxies at z~0.016. All input parameters can be derived from either a visual inspection and/or a statistical analysis of the Hα emission line map. The algorithm produces a segmentation FITS file describing the pixels associated to each H ii region.

[ascl:1405.005]
HIIPHOT: Automated Photometry of H II Regions

HIIPHOT enables accurate photometric characterization of H II regions while permitting genuine adaptivity to irregular source morphology. It makes a first guess at the shapes of all sources through object recognition techniques; it then allows for departure from such idealized "seeds" through an iterative growing procedure and derives photometric corrections for spatially coincident diffuse emission from a low-order surface fit to the background after exclusion of all detected sources.

[ascl:1111.001]
HIPE: Herschel Interactive Processing Environment

The Herschel Space Observatory is the fourth cornerstone mission in the ESA science programme and performs photometry and spectroscopy in the 55 - 672 micron range. The development of the Herschel Data Processing System started in 2002 to support the data analysis for Instrument Level Tests. The Herschel Data Processing System was used for the pre-flight characterisation of the instruments, and during various ground segment test campaigns. Following the successful launch of Herschel 14th of May 2009 the Herschel Data Processing System demonstrated its maturity when the first PACS preview observation of M51 was processed within 30 minutes of reception of the first science data after launch. Also the first HIFI observations on DR21 were successfully reduced to high quality spectra, followed by SPIRE observations on M66 and M74. A fast turn-around cycle between data retrieval and the production of science-ready products was demonstrated during the Herschel Science Demonstration Phase Initial Results Workshop held 7 months after launch, which is a clear proof that the system has reached a good level of maturity.

[ascl:1507.008]
HLINOP: Hydrogen LINe OPacity in stellar atmospheres

HLINOP is a collection of codes for computing hydrogen line profiles and opacities in the conditions typical of stellar atmospheres. It includes HLINOP for approximate quick calculation of any line of neutral hydrogen (suitable for model atmosphere calculations), based on the Fortran code of Kurucz and Peterson found in ATLAS9. It also includes HLINPROF, for detailed, accurate calculation of lower Balmer line profiles (suitable for detailed analysis of Balmer lines) and HBOP, to implement the occupation probability formalism of Daeppen, Anderson and Milhalas (1987) and thus account for the merging of bound-bound and bound-free opacity (used often as a wrapper to HLINOP for model atmosphere calculations).

[ascl:1508.001]
HMcode: Halo-model matter power spectrum computation

HMcode computes the halo-model matter power spectrum. It is written in Fortran90 and has been designed to quickly (~0.5s for 200 k-values across 16 redshifts on a single core) produce matter spectra for a wide range of cosmological models. In testing it was shown to match spectra produced by the 'Coyote Emulator' to an accuracy of 5 per cent for k less than 10h Mpc^-1. However, it can also produce spectra well outside of the parameter space of the emulator.

[ascl:1412.006]
HMF: Halo Mass Function calculator

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

[ascl:1201.010]
HNBody: Hierarchical N-Body Symplectic Integration Package

HNBody is a new set of software utilities geared to the integration of hierarchical (nearly-Keplerian) N-body systems. Our focus is on symplectic methods, and we have included explicit support for three classes of particles (heavy, light, and massless), second and fourth order methods, post-Newtonian corrections, and the use of a symplectic corrector (among other things). For testing purposes, we also provide support for more general integration schemes (Bulirsch-Stoer & Runge-Kutta). Configuration files employing an intuitive syntax allow for easy problem setup, and many simple simulations can be done without the user compiling any code. Low-level interfaces are also available, enabling extensive customization.

[ascl:1711.013]
HO-CHUNK: Radiation Transfer code

HO-CHUNK calculates radiative equilibrium temperature solution, thermal and PAH/vsg emission, scattering and polarization in protostellar geometries. It is useful for computing spectral energy distributions (SEDs), polarization spectra, and images.

[ascl:1102.019]
HOP: A Group-finding Algorithm for N-body Simulations

We describe a new method (HOP) for identifying groups of particles in N-body simulations. Having assigned to every particle an estimate of its local density, we associate each particle with the densest of the Nh particles nearest to it. Repeating this process allows us to trace a path, within the particle set itself, from each particle in the direction of increasing density. The path ends when it reaches a particle that is its own densest neighbor; all particles reaching the same such particle are identified as a group. Combined with an adaptive smoothing kernel for finding the densities, this method is spatially adaptive, coordinate-free, and numerically straight-forward. One can proceed to process the output by truncating groups at a particular density contour and combining groups that share a (possibly different) density contour. While the resulting algorithm has several user-chosen parameters, we show that the results are insensitive to most of these, the exception being the outer density cutoff of the groups.

[ascl:1411.005]
HOPE: Just-in-time Python compiler for astrophysical computations

HOPE is a specialized Python just-in-time (JIT) compiler designed for numerical astrophysical applications. HOPE focuses on a subset of the language and is able to translate Python code into C++ while performing numerical optimization on mathematical expressions at runtime. To enable the JIT compilation, the user only needs to add a decorator to the function definition. By using HOPE, the user benefits from being able to write common numerical code in Python while getting the performance of compiled implementation.

[ascl:1504.004]
HOTPANTS: High Order Transform of PSF ANd Template Subtraction

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

[ascl:1702.008]
HOURS: Simulation and analysis software for the KM3NeT

The Hellenic Open University Reconstruction & Simulation (HOURS) software package contains a realistic simulation package of the detector response of very large (km3-scale) underwater neutrino telescopes, including an accurate description of all the relevant physical processes, the production of signal and background as well as several analysis strategies for triggering and pattern recognition, event reconstruction, tracking and energy estimation. HOURS also provides tools for simulating calibration techniques and other studies for estimating the detector sensitivity to several neutrino sources.

[ascl:1707.001]
HRM: HII Region Models

HII Region Models fits HII region models to observed radio recombination line and radio continuum data. The algorithm includes the calculations of departure coefficients to correct for non-LTE effects. HII Region Models has been used to model star formation in the nucleus of IC 342.

[ascl:1412.008]
Hrothgar: MCMC model fitting toolkit

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

[ascl:1511.014]
HumVI: Human Viewable Image creation

HumVI creates a composite color image from sets of input FITS files, following the Lupton et al (2004, ascl:1511.013) composition algorithm. Written in Python, it takes three FITS files as input and returns a color composite, color-saturated png image with an arcsinh stretch. HumVI reads the zero points out of the FITS headers and uses them to put all the images on the same flux scale; photometrically calibrated images produce the best results.

[ascl:1103.010]
Hydra: A Parallel Adaptive Grid Code

We describe the first parallel implementation of an adaptive particle-particle, particle-mesh code with smoothed particle hydrodynamics. Parallelisation of the serial code, "Hydra," is achieved by using CRAFT, a Cray proprietary language which allows rapid implementation of a serial code on a parallel machine by allowing global addressing of distributed memory.

The collisionless variant of the code has already completed several 16.8 million particle cosmological simulations on a 128 processor Cray T3D whilst the full hydrodynamic code has completed several 4.2 million particle combined gas and dark matter runs. The efficiency of the code now allows parameter-space explorations to be performed routinely using $64^3$ particles of each species. A complete run including gas cooling, from high redshift to the present epoch requires approximately 10 hours on 64 processors.

[ascl:1402.023]
HydraLens: Gravitational lens model generator

HydraLens generates gravitational lens model files for Lenstool, PixeLens, glafic and Lensmodel and can also translate lens model files among these four lens model codes. Through a GUI, the user enters a new model by specifying the type of model and is then led through screens to collect the data. Written in MS Visual Basic, the code can also translate an existing model from any of the four supported codes to any of the other three.

[ascl:1601.002]
Hyper-Fit: Fitting routines for multidimensional data with multivariate Gaussian uncertainties

The R package Hyper-Fit fits hyperplanes (hyper.fit) and creates 2D/3D visualizations (hyper.plot2d / hyper.plot3d) to produce robust 1D linear fits for 2D x vs y type data, and robust 2D plane fits to 3D x vs y vs z type data. This hyperplane fitting works generically for any N-1 hyperplane model being fit to a N dimensional dataset. All fits include intrinsic scatter in the generative model orthogonal to the hyperplane. A web interface for online fitting is also available at http://hyperfit.icrar.org.

[ascl:1207.004]
Hyperion: Parallelized 3D Dust Continuum Radiative Transfer Code

Hyperion is a three-dimensional dust continuum Monte-Carlo radiative transfer code that is designed to be as generic as possible, allowing radiative transfer to be computed through a variety of three-dimensional grids. The main part of the code is problem-independent, and only requires an arbitrary three-dimensional density structure, dust properties, the position and properties of the illuminating sources, and parameters controlling the running and output of the code. Hyperion is parallelized, and is shown to scale well to thousands of processes. Two common benchmark models for protoplanetary disks were computed, and the results are found to be in excellent agreement with those from other codes. Finally, to demonstrate the capabilities of the code, dust temperatures, SEDs, and synthetic multi-wavelength images were computed for a dynamical simulation of a low-mass star formation region.

[ascl:1108.010]
Hyperz: Photometric Redshift Code

From a photometric catalogue, hyperz finds the redshift of each object by means of a standard SED fitting procedure, i.e. comparing the observed magnitudes with the expected ones, computed from template Spectral Energy Distributions. The set of templates used in the minimization procedure (age, metallicity, reddening, absorption in the Lyman forest, ...) is studied in detail, through both real and simulated data. The expected accuracy of photometric redshifts, as well as the fraction of catastrophic identifications and wrong detections, is given as a function of the redshift range, the set of filters considered, and the photometric accuracy. Special attention is paid to the results expected from real data.

[ascl:1011.023]
HyRec: A Fast and Highly Accurate Primordial Hydrogen and Helium Recombination Code

We present a state-of-the-art primordial recombination code, HyRec, including all the physical effects that have been shown to significantly affect recombination. The computation of helium recombination includes simple analytic treatments of hydrogen continuum opacity in the He I 2 1P - 1 1S line, the He I] 2 3P - 1 1S line, and treats feedback between these lines within the on-the-spot approximation. Hydrogen recombination is computed using the effective multilevel atom method, virtually accounting for an infinite number of excited states. We account for two-photon transitions from 2s and higher levels as well as frequency diffusion in Lyman-alpha with a full radiative transfer calculation. We present a new method to evolve the radiation field simultaneously with the level populations and the free electron fraction. These computations are sped up by taking advantage of the particular sparseness pattern of the equations describing the radiative transfer. The computation time for a full recombination history is ~2 seconds. This makes our code well suited for inclusion in Monte Carlo Markov chains for cosmological parameter estimation from upcoming high-precision cosmic microwave background anisotropy measurements.

[ascl:1302.009]
IAS Stacking Library in IDL

This IDL library is designed to be used on astronomical images. Its main aim is to stack data to allow a statistical detection of faint signal, using a prior. For instance, you can stack 160um data using the positions of galaxies detected at 24um or 3.6um, or use WMAP sources to stack Planck data. It can estimate error bars using bootstrap, and it can perform photometry (aperture photometry, or PSF fitting, or other that you can plug). The IAS Stacking Library works with gnomonic projections (RA---TAN), and also with HEALPIX projection.

[ascl:1611.018]
Icarus: Stellar binary light curve synthesis tool

Icarus is a stellar binary light curve synthesis tool that generates a star, given some basic binary parameters, by solving the gravitational potential equation, creating a discretized stellar grid, and populating the stellar grid with physical parameters, including temperature and surface gravity. Icarus also evaluates the outcoming flux from the star given an observer's point of view (*i.e.*, orbital phase and orbital orientation).

[ascl:1703.012]
ICICLE: Initial Conditions for Isolated CoLlisionless systEms

ICICLE (Initial Conditions for Isolated CoLlisionless systEms) generates stable initial conditions for isolated collisionless systems that can then be used in NBody simulations. It supports the Navarro-Frenk-White, Hernquist, King and Einasto density profiles.

[ascl:1302.010]
ICORE: Image Co-addition with Optional Resolution Enhancement

ICORE is a command-line driven co-addition, mosaicking, and resolution enhancement (HiRes) tool for creating science quality products from image data in FITS format and with World Coordinate System information following the FITS-WCS standard. It includes preparatory steps such as image background matching, photometric gain-matching, and pixel-outlier rejection. Co-addition and/or HiRes'ing can be performed in either the inertial WCS or in the rest frame of a moving object. Three interpolation methods are supported: overlap-area weighting, drizzle, and weighting by the detector Point Response Function (PRF). The latter enables the creation of matched-filtered products for optimal point-source detection, but most importantly allows for resolution enhancement using a spatially-dependent deconvolution method. This is a variant of the classic Richardson-Lucy algorithm with the added benefit to simultaneously register and co-add multiple images to optimize signal-to-noise and sampling of the instrumental PSF. It can assume real (or otherwise "flat") image priors, mitigate "ringing" artifacts, and assess the quality of image solutions using statistically-motivated convergence criteria. Uncertainties are also estimated and internally validated for all products. The software supports multithreading that can be configured for different architectures. Numerous example scripts are included (with test data) to co-add and/or HiRes image data from Spitzer-IRAC/MIPS, WISE, and Herschel-SPIRE.

[ascl:9905.002]
ICOSAHEDRON: A package for pixelizing the sphere

What is the best way to pixelize a sphere? This question occurs in many practical applications, for instance when making maps (of the earth or the celestial sphere) and when doing numerical integrals over the sphere. This package consists of source code and documentation for a method which involves inscribing the sphere in a regular icosahedron and then equalizing the pixel areas.

[ascl:1010.034]
iCosmo: An Interactive Cosmology Package

iCosmo is a software package to perform interactive cosmological calculations for the low redshift universe. The computation of distance measures, the matter power spectrum, and the growth factor is supported for any values of the cosmological parameters. It also performs the computation of observables for several cosmological probes such as weak gravitational lensing, baryon acoustic oscillations and supernovae. The associated errors for these observables can be derived for customised surveys, or for pre-set values corresponding to current or planned instruments. The code also allows for the calculation of cosmological forecasts with Fisher matrices which can be manipulated to combine different surveys and cosmological probes. The code is written in the IDL language and thus benefits from the convenient interactive features and scientific library available in this language. iCosmo can also be used as an engine to perform cosmological calculations in batch mode, and forms a convenient evolutive platform for the development of further cosmological modules. With its extensive documentation, it may also serve as a useful resource for teaching and for newcomers in the field of cosmology.

[ascl:1411.009]
iDealCam: Interactive Data Reduction and Analysis for CanariCam

iDealCam is an IDL GUI toolkit for processing multi-extension FITS file produced by CanariCam, the facility mid-IR instrument of Gran Telescopio CANARIAS (GTC). iDealCam is optimized for CanariCam data, but is also compatible with data generated by other instruments using similar detectors and data format (e.g., Michelle and T-ReCS at Gemini). iDealCam provides essential capabilities to examine, reduce, and analyze data obtained in the standard imaging or polarimetric imaging mode of CanariCam.

[ascl:1011.001]
Identikit 1: A Modeling Tool for Interacting Disk Galaxies

By combining test-particle and self-consistent techniques, we have developed a method to rapidly explore the parameter space of galactic encounters. Our method, implemented in an interactive graphics program, can be used to find the parameters required to reproduce the observed morphology and kinematics of interacting disk galaxies. We test this system on an artificial data-set of 36 equal-mass merging encounters, and show that it is usually possible to reproduce the morphology and kinematics of these encounters and that a good match strongly constrains the encounter parameters.

[ascl:1102.011]
Identikit 2: An Algorithm for Reconstructing Galactic Collisions

Using a combination of self-consistent and test-particle techniques, Identikit 1 provided a way to vary the initial geometry of a galactic collision and instantly visualize the outcome. Identikit 2 uses the same techniques to define a mapping from the current morphology and kinematics of a tidal encounter back to the initial conditions. By requiring that various regions along a tidal feature all originate from a single disc with a unique orientation, this mapping can be used to derive the initial collision geometry. In addition, Identikit 2 offers a robust way to measure how well a particular model reproduces the morphology and kinematics of a pair of interacting galaxies. A set of eight self-consistent simulations is used to demonstrate the algorithm's ability to search a ten-dimensional parameter space and find near-optimal matches; all eight systems are successfully reconstructed.

[ascl:1303.013]
idistort: CMB spectral distortions templates and code

Spectrum created by energy release in the early Universe, before recombination, creates distortions which are a superposition of μ-type, y-type and intermediate-type distortions. The final spectrum can thus be constructed from the templates, once energy injection rate as a function of redshift is known. This package contains the templates spaced at dy=0.001 for y<1 and dy=0.01 for y>1 covering a range 0.001 < y < 10. Also included is a Mathematica code which can combine these templates for user-defined rate of energy injection as a function of redshift. Silk damping, particle decay and annihilation examples are also included.

[ascl:1507.020]
IEHI: Ionization Equilibrium for Heavy Ions

IEHI, written in Fortran, outputs a simple "coronal" ionization equilibrium (i.e., collisional ionization and auto-ionization balanced by radiative and dielectronic recombination) for a plasma at a given electron temperature.

[ascl:1304.019]
IFrIT: Ionization FRont Interactive Tool

IFrIT (Ionization FRont Interactive Tool) is a powerful general purpose visualization tool that can be used to visualize 3-dimensional data sets. IFrIT is written in C++ and is based on the Visualization ToolKit (VTK) and, optionally, uses a GUI toolkit Qt. IFrIT can visualize scalar, vector field, tensor, and particle data. Several visualization windows can exist at the same time, each one having a full set of visualization objects. Some visualization windows can share the data between them, while other windows can be fully independent. Images from several visualization windows can be combined into one image file on the disk, tiling some windows together, and inserting reduced versions of some windows into larger other windows. A large array of features is also available, including highly advanced animation capabilities, a complex set of lights, markers to label various points in space, and a capability to "pick" a point in the scene and retrieve information about the data at this location.

[ascl:1409.005]
IFSFIT: Spectral Fitting for Integral Field Spectrographs

IFSFIT is a general-purpose IDL library for fitting the continuum, emission lines, and absorption lines in integral field spectra. It uses PPXF (ascl:1210.002) to find the best fit stellar continuum (using a user-defined library of stellar templates and including additive polynomials), or optionally a user-defined method to find the best fit continuum. It uses MPFIT (ascl:1208.019) to simultaneously fit Gaussians to any number of emission lines and emission line velocity components. It will also fit the NaI D feature using analytic absorption and/or emission-line profiles.

[ascl:1409.004]
IFSRED: Data Reduction for Integral Field Spectrographs

IFSRED is a general-purpose library for reducing data from integral field spectrographs (IFSs). For a general IFS data cube, it contains IDL routines to: (1) find and apply a zero-point shift in a wavelength solution on a spaxel-by-spaxel basis, using sky lines; (2) find the spatial coordinates of a flux peak; (3) empirically correct for differential atmospheric refraction; (4) mosaic dithered exposures; (5) (integer) rebin; and (6) apply a telluric correction. A sky-subtraction routine for data from the Gemini Multi-Object Spectrograph and Imager (GMOS) that can be easily modified for any instrument is also included. IFSRED also contains additional software specific to reducing data from GMOS and the Gemini Near-Infrared Integral Field Spectrograph (NIFS).

[ascl:1110.003]
iGalFit: An Interactive Tool for GalFit

We present a suite of IDL routines to interactively run GALFIT whereby the various surface brightness profiles (and their associated parameters) are represented by regions, which the User is expected to place. The regions may be saved and/or loaded from the ASCII format used by ds9 or in the Hierarchical Data Format (version 5). The software has been tested to run stably on Mac OS X and Linux with IDL 7.0.4. In addition to its primary purpose of modeling galaxy images with GALFIT, this package has several ancillary uses, including a flexible image display routines, several basic photometry functions, and qualitatively assessing Source Extractor. We distribute the package freely and without any implicit or explicit warranties, guarantees, or assurance of any kind. We kindly ask users to report any bugs, errors, or suggestions to us directly (as opposed to fixing them themselves) to ensure version control and uniformity.

[ascl:1101.003]
IGMtransfer: Intergalactic Radiative Transfer Code

This document describes the publically available numerical code "IGMtransfer", capable of performing intergalactic radiative transfer (RT) of light in the vicinity of the Lyman alpha (Lya) line. Calculating the RT in a (possibly adaptively refined) grid of cells resulting from a cosmological simulation, the code returns 1) a "transmission function", showing how the intergalactic medium (IGM) affects the Lya line at a given redshift, and 2) the "average transmission" of the IGM, making it useful for studying the results of reionization simulations.

[ascl:1504.015]
IGMtransmission: Transmission curve computation

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

[ascl:1408.009]
IIPImage: Large-image visualization

IIPImage is an advanced high-performance feature-rich image server system that enables online access to full resolution floating point (as well as other bit depth) images at terabyte scales. Paired with the VisiOmatic (ascl:1408.010) celestial image viewer, the system can comfortably handle gigapixel size images as well as advanced image features such as both 8, 16 and 32 bit depths, CIELAB colorimetric images and scientific imagery such as multispectral images. Streaming is tile-based, which enables viewing, navigating and zooming in real-time around gigapixel size images. Source images can be in either TIFF or JPEG2000 format. Whole images or regions within images can also be rapidly and dynamically resized and exported by the server from a single source image without the need to store multiple files in various sizes.

[ascl:1307.006]
im2shape: Bayesian Galaxy Shape Estimation

im2shape is a Bayesian approach to the problem of accurate measurement of galaxy ellipticities for weak lensing studies, in particular cosmic shear. im2shape parameterizes galaxies as sums of Gaussians, convolved with a psf which is also a sum of Gaussians. The uncertainties in the output parameters are calculated using a Markov Chain Monte Carlo approach.

[ascl:1409.013]
IM3SHAPE: Maximum likelihood galaxy shear measurement code for cosmic gravitational lensing

Im3shape forward-fits a galaxy model to each data image it is supplied with and reports the parameters of the best fitting model, including the ellipticity components. It uses the Discrete Fourier Transform (DFT) to render images of convolved galaxy profiles, calculates the maximum likelihood parameter values, and corrects for noise bias. IM3SHAPE is a modular C code with a significant amount of Python glue code to enable setting up new models and their options automatically.

[ascl:1206.014]
ImageHealth: Quality Assurance for Large FITS Images

ImageHealth (IH) is a c program that makes use of standard CFITSIO routines to examine, in an automated fashion, .FITS images with any number of extensions, find objects within those images, and determine basic parameters of those images (stellar flux, background counts, FWHM, and ellipticity, along with sky background counts) in order to provide a snapshot of the quality of those images. A variety of python wrappers have also been written to test large numbers of such images and compare the results of ImageHealth to other image analysis programs, such as SourceExtractor. Additional IH-related tools will be made available in the future.

Efforts are now focused on an implementation of IH specifically for the Dark Energy Camera; we do not envision providing support for the instrument-independent version of the code offered here though comments, questions, and feedback are welcome.

[ascl:1206.013]
ImageJ: Image processing and analysis in Java

ImageJ is a public domain Java image processing program inspired by NIH Image. It can display, edit, analyze, process, save and print 8-bit, 16-bit and 32-bit images. It can read many image formats including TIFF, GIF, JPEG, BMP, DICOM, FITS and "raw". It supports "stacks", a series of images that share a single window. It is multithreaded, so time-consuming operations such as image file reading can be performed in parallel with other operations.

[ascl:1803.007]
IMAGINE: Interstellar MAGnetic field INference Engine

IMAGINE (Interstellar MAGnetic field INference Engine) performs inference on generic parametric models of the Galaxy. The modular open source framework uses highly optimized tools and technology such as the MultiNest sampler (ascl:1109.006) and the information field theory framework NIFTy (ascl:1302.013) to create an instance of the Milky Way based on a set of parameters for physical observables, using Bayesian statistics to judge the mismatch between measured data and model prediction. The flexibility of the IMAGINE framework allows for simple refitting for newly available data sets and makes state-of-the-art Bayesian methods easily accessible particularly for random components of the Galactic magnetic field.

[ascl:1108.001]
IMCAT: Image and Catalogue Manipulation Software

The IMCAT software was developed initially to do faint galaxy photometry for weak lensing studies, and provides a fairly complete set of tools for this kind of work. Unlike most packages for doing data analysis, the tools are standalone unix commands which you can invoke from the shell, via shell scripts or from perl scripts. The tools are arranges in a tree of directories. One main branch is the ’imtools’. These deal only with fits files. The most important imtool is the ’image calculator’ ’ic’ which allows one to do rather general operations on fits images. A second branch is the ’catools’ which operate only on catalogues. The key cattool is ’lc’; this effectively defines the format of IMCAT catalogues, and allows one to do very general operations on and filtering of such catalogues. A third branch is the ’imcattools’. These tend to be much more specialised than the cattools and imcattools and are focussed on faint galaxy photometry.

[ascl:1312.003]
IMCOM: IMage COMbination

IMCOM allows for careful treatment of aliasing in undersampled imaging data and can be used to test the feasibility of multi-exposure observing strategies for space-based survey missions. IMCOM can also been used to explore focal plane undersampling for an optical space mission such as Euclid.

[ascl:1408.001]
Imfit: A Fast, Flexible Program for Astronomical Image Fitting

Imift is an open-source astronomical image-fitting program specialized for galaxies but potentially useful for other sources, which is fast, flexible, and highly extensible. Its object-oriented design allows new types of image components (2D surface-brightness functions) to be easily written and added to the program. Image functions provided with Imfit include Sersic, exponential, and Gaussian galaxy decompositions along with Core-Sersic and broken-exponential profiles, elliptical rings, and three components that perform line-of-sight integration through 3D luminosity-density models of disks and rings seen at arbitrary inclinations.

Available minimization algorithms include Levenberg-Marquardt, Nelder-Mead simplex, and Differential Evolution, allowing trade-offs between speed and decreased sensitivity to local minima in the fit landscape. Minimization can be done using the standard chi^2 statistic (using either data or model values to estimate per-pixel Gaussian errors, or else user-supplied error images) or the Cash statistic; the latter is particularly appropriate for cases of Poisson data in the low-count regime.

The C++ source code for Imfit is available under the GNU Public License.

[ascl:1804.014]
IMNN: Information Maximizing Neural Networks

This software trains artificial neural networks to find non-linear functionals of data that maximize Fisher information: information maximizing neural networks (IMNNs). As compressing large data sets vastly simplifies both frequentist and Bayesian inference, important information may be inadvertently missed. Likelihood-free inference based on automatically derived IMNN summaries produces summaries that are good approximations to sufficient statistics. IMNNs are robustly capable of automatically finding optimal, non-linear summaries of the data even in cases where linear compression fails: inferring the variance of Gaussian signal in the presence of noise, inferring cosmological parameters from mock simulations of the Lyman-α forest in quasar spectra, and inferring frequency-domain parameters from LISA-like detections of gravitational waveforms. In this final case, the IMNN summary outperforms linear data compression by avoiding the introduction of spurious likelihood maxima.

[ascl:1601.013]
ImpactModel: Black Hole Accretion Disk Impact Model

ImpactModel, written in Cython, computes the accretion disc impact spectrum at given frequencies and can compute other model quantities as a function of time.

[ascl:1808.004]
ImPlaneIA: Image Plane Approach to Interferometric Analysis

Aperture masking interferometric data analysis involves measuring phases and amplitudes of fringes formed by interference between holes in the pupil mask. These fringe observables can be measured by computing an analytic model of the point spread function and fitting the relevant set of spatial frequencies directly in the image plane, without recourse to numerical Fourier transforms. The ImPlaneIA pipeline converts aperture masking images to fringe observables by fitting fringes in the image plane, calibrates data from a target of interest with one or more point source calibrators, and contains some basic model-fitting routines. The pipeline can accept different mask geometries, instruments, and observing modes.

[ascl:1010.046]
indexf: Line-strength Indices in Fully Calibrated FITS Spectra

This program measures line-strength indices in fully calibrated FITS spectra. By "fully calibrated" one should understand wavelength and relative flux-calibrated data. Note that the different types of line-strength indices that can be measured with indexf (see below) do not require absolute flux calibration. If even a relative flux-calibration is absent (or deficient), the derived indices should be transformed to an appropriate spectrophotometric system. The program can also compute index errors resulting from the propagation of random errors (e.g. photon statistics, read-out noise). This option is only available if the user provides the error spectrum as an additional input FITS file to indexf. The error spectrum must contain the unbiased standard deviation (and not the variance!) for each pixel of the data spectrum. In addition, indexf also estimates the effect of errors on radial velocity. For this purpose, the program performs Monte Carlo simulations by measuring each index using randomly drawn radial velocities (following a Gaussian distribution of a given standard deviation). If no error file is employed, the program can perform numerical simulations with synthetic error spectra, the latter generated from the original data spectra and assuming randomly generated S/N ratios.

[ascl:1806.005]
Indri: Pulsar population synthesis toolset

Indri models the population of single (not in binary or hierarchical systems) neutron stars. Given a starting distribution of parameters (birth place, velocity, magnetic field, and period), the code moves a set of stars through the time (by evolving spin period and magnetic field) and the space (by propagating through the Galactic potential). Upon completion of the evolution, a set of observables is computed (radio flux, position, dispersion measure) and compared with a radio survey such as the Parkes Multibeam Survey. The models' parameters are optimised by using the Markov Chain Monte Carlo technique.

[ascl:1210.023]
inf_solv: Kerr inflow solver

The efficiency of thin disk accretion onto black holes depends on the inner boundary condition, specifically the torque applied to the disk at the last stable orbit. This is usually assumed to vanish. This code estimates the torque on a magnetized disk using a steady magnetohydrodynamic inflow model originally developed by Takahashi et al. The efficiency e can depart significantly from the classical thin disk value. In some cases e > 1, i.e., energy is extracted from the black hole.

[ascl:1007.002]
INFALL: A code for calculating the mean initial and final density profiles around a virialized dark matter halo

Infall is a code for calculating the mean initial and final density profiles around a virialized dark matter halo. The initial profile is derived from the statistics of the initial Gaussian random field, accounting for the problem of peaks within peaks using the extended Press-Schechter model. Spherical collapse then yields the typical density and velocity profiles of the gas and dark matter that surrounds the final, virialized halo. In additional to the mean profile, ±1-σ profiles are calculated and can be used as an estimate of the scatter.

[ascl:1201.017]
Inflation: Monte-Carlo Code for Slow-Roll Inflation

Inflation is a numerical code to generate power spectra and other observables through numerical solutions to flow equations. The code generates tensor and scalar power spectra as a function of wavenumber and various other parameters at specific wavenumbers of interest (such as for CMB, scalar perturbations at smaller scales, gravitational wave detection at direct detection frequencies). The output can be easily ported to publicly available Markov Chain codes to constrain cosmological parameters with data.

[ascl:1711.002]
inhomog: Biscale kinematical backreaction analytical evolution

The inhomog library provides Raychaudhuri integration of cosmological domain-wise average scale factor evolution using an analytical formula for kinematical backreaction Q_D evolution. The inhomog main program illustrates biscale examples. The library routine lib/Omega_D_precalc.c is callable by RAMSES (ascl:1011.007) using the RAMSES extension ramses-scalav.

[ascl:1801.005]
InitialConditions: Initial series solutions for perturbations in our Universe

InitialConditions finds the initial series solutions for perturbations in our Universe. This includes all scalar (1 adiabatic, 4 isocurvature and 2 magnetic modes), vector (1 vorticity mode, 1 magnetic mode), and tensor (1 gravitational wave mode and 1 magnetic mode) perturbations including terms up to second order in the neutrino mass. It can handle the standard species (cdm, baryons, photons), and two neutrino mass eigenstates (1 light, 1 heavy).

[ascl:1101.004]
InterpMC: Caching and Interpolated Likelihoods -- Accelerating Cosmological Monte Carlo Markov Chains

We describe a novel approach to accelerating Monte Carlo Markov Chains. Our focus is cosmological parameter estimation, but the algorithm is applicable to any problem for which the likelihood surface is a smooth function of the free parameters and computationally expensive to evaluate. We generate a high-order interpolating polynomial for the log-likelihood using the first points gathered by the Markov chains as a training set. This polynomial then accurately computes the majority of the likelihoods needed in the latter parts of the chains. We implement a simple version of this algorithm as a patch (InterpMC) to CosmoMC and show that it accelerates parameter estimatation by a factor of between two and four for well-converged chains. The current code is primarily intended as a "proof of concept", and we argue that there is considerable room for further performance gains. Unlike other approaches to accelerating parameter fits, we make no use of precomputed training sets or special choices of variables, and InterpMC is almost entirely transparent to the user.

[ascl:1403.010]
Inverse Beta: Inverse cumulative density function (CDF) of a Beta distribution

The Beta Inverse code solves the inverse cumulative density function (CDF) of a Beta distribution, allowing one to sample from the Beta prior directly. The Beta distribution is well suited as a prior for the distribution of the orbital eccentricities of extrasolar planets; imposing a Beta prior on orbital eccentricity is valuable for any type of observation of an exoplanet where eccentricity can affect the model parameters (e.g. transits, radial velocities, microlensing, direct imaging). The Beta prior is an excellent description of the current, empirically determined distribution of orbital eccentricities and thus employing it naturally incorporates an observer’s prior experience of what types of orbits are probable or improbable. The default parameters in the code are currently set to the Beta distribution which best describes the entire population of exoplanets with well-constrained orbits.

[ascl:1612.013]
InversionKit: Linear inversions from frequency data

InversionKit is an interactive Java program that performs rotational and structural linear inversions from frequency data.

[ascl:1303.022]
ionFR: Ionospheric Faraday rotation

Sotomayor-Beltran, C.; Sobey, C.; Hessels, J. W. T.; de Bruyn, G.; Noutsos, A.; Alexov, A.; Anderson, J.; Asgekar, A.; Avruch, I. M.; Beck, R.; Bell, M. E.; Bell, M. R.; Bentum, M. J.; Bernardi, G.; Best, P.; Birzan, L.; Bonafede, A.; Breitling, F.; Broderick, J.; Brouw, W. N.; Brueggen, M.; Ciardi, B.; de Gasperin, F.; Dettmar, R.-J.; van Duin, A.; Duscha, S.; Eisloeffel, J.; Falcke, H.; Fallows, R. A.; Fender, R.; Ferrari, C.; Frieswijk, W.; Garrett, M. A.; Griessmeier, J.; Grit, T.; Gunst, A. W.; Hassall, T. E.; Heald, G.; Hoeft, M.; Horneffer, A.; Iacobelli, M.; Juette, E.; Karastergiou, A.; Keane, E.; Kohler, J.; Kramer, M.; Kondratiev, V. I.; Koopmans, L. V. E.; Kuniyoshi, M.; Kuper, G.; van Leeuwen, J.; Maat, P.; Macario, G.; Markoff, S.; McKean, J. P.; Mulcahy, D. D.; Munk, H.; Orru, E.; Paas, H.; Pandey-Pommier, M.; Pilia, M.; Pizzo, R.; Polatidis, A. G.; Reich, W.; Roettgering, H.; Serylak, M.; Sluman, J.; Stappers, B. W.; Tagger, M.; Tang, Y.; Tasse, C.; ter Veen, S.; Vermeulen, R.; van Weeren, R. J.; Wijers, R. A. M. J.; Wijnholds, S. J.; Wise, M. W.; Wucknitz, O.; Yatawatta, S.; Zarka, P.

ionFR calculates the amount of ionospheric Faraday rotation for a specific epoch, geographic location, and line-of-sight. The code uses a number of publicly available, GPS-derived total electron content maps and the most recent release of the International Geomagnetic Reference Field. ionFR can be used for the calibration of radio polarimetric observations; its accuracy had been demonstrated using LOFAR pulsar observations.

[ascl:1804.002]
ipole: Semianalytic scheme for relativistic polarized radiative transport

ipole is a ray-tracing code for covariant, polarized radiative transport particularly useful for modeling Event Horizon Telescope sources, though may also be used for other relativistic transport problems. The code extends the ibothros scheme for covariant, unpolarized transport using two representations of the polarized radiation field: in the coordinate frame, it parallel transports the coherency tensor, and in the frame of the plasma, it evolves the Stokes parameters under emission, absorption, and Faraday conversion. The transport step is as spacetime- and coordinate- independent as possible; the emission, absorption, and Faraday conversion step is implemented using an analytic solution to the polarized transport equation with constant coefficients. As a result, ipole is stable, efficient, and produces a physically reasonable solution even for a step with high optical depth and Faraday depth.

[ascl:1512.001]
IRACpm: Distortion correction for IRAC astrometric data

The IRACpm R package applies a 7-8 order distortion correction to IRAC astrometric data from the Spitzer Space Telescope and includes a function for measuring apparent proper motions between different Epochs. These corrections are applicable only to positions measured by APEX; cryogenic images benefit from a correction for varying intra-pixel sensitivity prior to the application of the distortion.

[ascl:1209.013]
IRACproc: IRAC Post-BCD Processing

IRACproc is a software suite that facilitates the co-addition of dithered or mapped Spitzer/IRAC data to make them ready for further analysis with application to a wide variety of IRAC observing programs. The software runs within PDL, a numeric extension for Perl available from pdl.perl.org, and as stand alone perl scripts. In acting as a wrapper for the Spitzer Science Center's MOPEX software, IRACproc improves the rejection of cosmic rays and other transients in the co-added data. In addition, IRACproc performs (optional) Point Spread Function (PSF) fitting, subtraction, and masking of saturated stars.

[ascl:9911.002]
IRAF: Image Reduction and Analysis Facility

IRAF includes a broad selection of programs for general image processing and graphics, plus a large number of programs for the reduction and analysis of optical and IR astronomy data. Other external or layered packages are available for applications such as data acquisition or handling data from other observatories and wavelength regimes such as the Hubble Space Telescope (optical), EUVE (extreme ultra-violet), or ROSAT and AXAF (X-ray). These external packages are distributed separately from the main IRAF distribution but can be easily installed. The IRAF system also includes a complete programming environment for scientific applications, which includes a programmable Command Language scripting facility, the IMFORT Fortran/C programming interface, and the full SPP/VOS programming environment in which the portable IRAF system and all applications are written.

[ascl:1406.014]
IRAS90: IRAS Data Processing

Berry, David S.; Parsons, Diana C.; Gong, Wei; Currie, Malcolm J.; Warren-Smith, Rodney F.; Morris, Huw

IRAS90 is a suite of programs for processing IRAS data. It takes advantage of Starlink's (ascl:1110.012) ADAM environment, which provides multi-platform availability of both data and the programs to process it, and the user friendly interface of the parameter entry system. The suite can determine positions in astrometric coordinates, draw grids, and offers other functions for standard astronomical measurement and standard projections.

[ascl:1406.015]
IRCAMDR: IRCAM3 Data Reduction Software

Aspin, Colin; McCaughrean, Mark; Bridger, Alan B.; Baines, Dave; Beard, Steven; Chan, S.; Giddings, Jack; Hartley, K. F.; Horsfield, A.P.; Kelly, B. D.; Emerson, J. P.; Currie, Malcolm J.; Economou, Frossie

The UKIRT IRCAM3 data reduction and analysis software package, IRCAMDR (formerly ircam_clred) analyzes and displays any 2D data image stored in the standard Starlink (ascl:1110.012) NDF data format. It reduces and analyzes IRCAM1/2 data images of 62x58 pixels and IRCAM3 images of 256x256 size. Most of the applications will work on NDF images of any physical (pixel) dimensions, for example, 1024x1024 CCD images can be processed.

[ascl:1109.017]
IRDR: InfraRed Data Reduction

We describe the InfraRed Data Reduction (IRDR) software package, a small ANSI C library of fast image processing routines for automated pipeline reduction of infrared (dithered) observations. We developed the software to satisfy certain design requirements not met in existing packages (e.g., full weight map handling) and to optimize the software for large data sets (non-interactive tasks that are CPU and disk efficient). The software includes stand-alone C programs for tasks such as running sky frame subtraction with object masking, image registration and coaddition with weight maps, dither offset measurement using cross-correlation, and object mask dilation. Although we currently use the software to process data taken with CIRSI (a near-IR mosaic imager), the software is modular and concise and should be easy to adapt/reuse for other work.

[ascl:1205.007]
Iris: The VAO SED Application

Iris is a downloadable Graphical User Interface (GUI) application which allows the astronomer to build and analyze wide-band Spectral Energy Distributions (SEDs). The components of Iris have been contributed by members of the VAO. Specview, contributed by STScI, provides a GUI for reading, editing, and displaying SEDs, as well as defining models and parameter values. Sherpa, contributed by the Chandra project at SAO, provides a library of models, fit statistics, and optimization methods; the underlying I/O library, SEDLib, is a VAO product written by SAO to current IVOA (International Virtual Observatory Alliance) data model standards. NED is a service provided by IPAC for easy location of data for a given extragalactic source, including SEDs. SedImporter converts non-standard SED data files into a format supported by Iris.

[ascl:1602.016]
IRSFRINGE: Interactive tool for fringe removal from Spitzer IRS spectra

IRSFRINGE is an IDL-based GUI package that allows observers to interactively remove fringes from IRS spectra. Fringes that originate from the detector subtrates are observed in the IRS Short-High (SH) and Long-High (LH) modules. In the Long-Low (LL) module, another fringe component is seen as a result of the pre-launch change in one of the LL filters. The fringes in the Short-Low (SL) module are not spectrally resolved. the fringes are already largely removed in the pipeline processing when the flat field is applied. However, this correction is not perfect and remaining fringes can be removed with IRSFRINGE from data in each module. IRSFRINGE is available as a stand-alone package and is also part of the Spectroscopic Modeling, Analysis and Reduction Tool (SMART, ascl:1210.021).

[ascl:1303.029]
iSAP: Interactive Sparse Astronomical Data Analysis Packages

iSAP consists of three programs, written in IDL, which together are useful for spherical data analysis. MR/S (MultiResolution on the Sphere) contains routines for wavelet, ridgelet and curvelet transform on the sphere, and applications such denoising on the sphere using wavelets and/or curvelets, Gaussianity tests and Independent Component Analysis on the Sphere. MR/S has been designed for the PLANCK project, but can be used for many other applications. SparsePol (Polarized Spherical Wavelets and Curvelets) has routines for polarized wavelet, polarized ridgelet and polarized curvelet transform on the sphere, and applications such denoising on the sphere using wavelets and/or curvelets, Gaussianity tests and blind source separation on the Sphere. SparsePol has been designed for the PLANCK project. MS-VSTS (Multi-Scale Variance Stabilizing Transform on the Sphere), designed initially for the FERMI project, is useful for spherical mono-channel and multi-channel data analysis when the data are contaminated by a Poisson noise. It contains routines for wavelet/curvelet denoising, wavelet deconvolution, multichannel wavelet denoising and deconvolution.

[ascl:1403.009]
ISAP: ISO Spectral Analysis Package

Ali, Babar; Bauer, Otto; Brauher, Jim; Buckley, Mark; Harwood, Andrew; Hur, Min; Khan, Iffat; Li, Jing; Lord, Steve; Lutz, Dieter; Mazzarella, Joe; Molinari, Sergio; Morris, Pat; Narron, Bob; Seidenschwang, Karla; Sidher, Sunil; Sturm, Eckhard; Swinyard, Bruce; Unger, Sarah; Verstraete, Laurent; Vivares, Florence; Wieprecht, Ecki

ISAP, written in IDL, simplifies the process of visualizing, subsetting, shifting, rebinning, masking, combining scans with weighted means or medians, filtering, and smoothing Auto Analysis Results (AARs) from post-pipeline processing of the Infrared Space Observatory's (ISO) Short Wavelength Spectrometer (SWS) and Long Wavelength Spectrometer (LWS) data. It can also be applied to PHOT-S and CAM-CVF data, and data from practically any spectrometer. The result of a typical ISAP session is expected to be a "simple spectrum" (single-valued spectrum which may be resampled to a uniform wavelength separation if desired) that can be further analyzed and measured either with other ISAP functions, native IDL functions, or exported to other analysis package (e.g., IRAF, MIDAS) if desired. ISAP provides many tools for further analysis, line-fitting, and continuum measurements, such as routines for unit conversions, conversions from wavelength space to frequency space, line and continuum fitting, flux measurement, synthetic photometry and models such as a zodiacal light model to predict and subtract the dominant foreground at some wavelengths.

[ascl:1809.010]
Isca: Idealized global circulation modeling

Vallis, Geoffrey K.; Colyer, Greg; Geen, Ruth; Gerber, Edwin; Jucker, Martin; Maher, Penelope; Paterson, Alexander; Pietschnig, Marianne; Penn, James; Thomson, Stephen I.

Isca provides a framework for the idealized modeling of the global circulation of planetary atmospheres at varying levels of complexity and realism. Though Isca is an outgrowth of models designed for Earth's atmosphere, it may readily be extended into other planetary regimes. Various forcing and radiation options are available. At the simple end of the spectrum a Held-Suarez case is available. An idealized grey radiation scheme, a grey scheme with moisture feedback, a two-band scheme and a multi-band scheme are also available, all with simple moist effects and astronomically-based solar forcing. At the complex end of the spectrum the framework provides a direct connection to comprehensive atmospheric general circulation models.

[ascl:1708.029]
iSEDfit: Bayesian spectral energy distribution modeling of galaxies

iSEDfit uses Bayesian inference to extract the physical properties of galaxies from their observed broadband photometric spectral energy distribution (SED). In its default mode, the inputs to iSEDfit are the measured photometry (fluxes and corresponding inverse variances) and a measurement of the galaxy redshift. Alternatively, iSEDfit can be used to estimate photometric redshifts from the input photometry alone.

After the priors have been specified, iSEDfit calculates the marginalized posterior probability distributions for the physical parameters of interest, including the stellar mass, star-formation rate, dust content, star formation history, and stellar metallicity. iSEDfit also optionally computes K-corrections and produces multiple "quality assurance" (QA) plots at each stage of the modeling procedure to aid in the interpretation of the prior parameter choices and subsequent fitting results. The software is distributed as part of the impro IDL suite.

[submitted]
isis_emcee: ISIS-based MCMC Hammer

ISIS_EMCEE is the implementation of Goodman & Weare's affine-invariant Markov chain Monte Carlo (MCMC) ensemble sampler in the Interactive Spectral Interpretation System (ISIS; ascl:1302.002), based upon the parallel "simple stretch" method from the MCMC Hammer (emcee; ascl:1303.002).

[ascl:9909.003]
ISIS: A method for optimal image subtraction

ISIS is a complete package to process CCD images using the image Optimal subtraction method (Alard & Lupton 1998, Alard 1999). The ISIS package can find the best kernel solution even in case of kernel variations as a function of position in the image. The relevant computing time is minimal in this case and is only slightly different from finding constant kernel solutions. ISIS includes as well a number of facilities to compute the light curves of variables objects from the subtracted images. The basic routines required to build the reference frame and make the image registration are also provided in the package.

[ascl:1302.002]
ISIS: Interactive Spectral Interpretation System for High Resolution X-Ray Spectroscopy

ISIS, the Interactive Spectral Interpretation System, is designed to facilitate the interpretation and analysis of high resolution X-ray spectra. It is being developed as a programmable, interactive tool for studying the physics of X-ray spectrum formation, supporting measurement and identification of spectral features, and interaction with a database of atomic structure parameters and plasma emission models.

[ascl:1601.021]
ISO: Isochrone construction

ISO transforms MESA history files into a uniform basis for interpolation and then constructs new stellar evolution tracks and isochrones from that basis. It is written in Fortran and requires MESA (ascl:1010.083), primarily for interpolation. Though designed to ingest MESA star history files, tracks from other stellar evolution codes can be incorporated by loading the tracks into the data structures used in the codes.

[ascl:1503.010]
isochrones: Stellar model grid package

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

[ascl:1409.006]
iSpec: Stellar atmospheric parameters and chemical abundances

iSpec is an integrated software framework written in Python for the treatment and analysis of stellar spectra and abundances. Spectra treatment functions include cosmic rays removal, continuum normalization, resolution degradation, and telluric lines identification. It can also perform radial velocity determination and correction and resampling. iSpec can also determine atmospheric parameters (i.e effective temperature, surface gravity, metallicity, micro/macroturbulence, rotation) and individual chemical abundances by using either the synthetic spectra fitting technique or equivalent widths method. The synthesis is performed with SPECTRUM (ascl:9910.002).

[ascl:1010.047]
ISW and Weak Lensing Likelihood Code

ISW and Weak Lensing Likelihood code is the likelihood code that calculates the likelihood of Integrated Sachs Wolfe and Weak Lensing of Cosmic Microwave Background using the WMAP 3year CMB maps with mass tracers such as 2MASS (2-Micron All Sky Survey), SDSS LRG (Sloan Digital Sky Survey Luminous Red Galaxies), SDSS QSOs (Sloan Digital Sky Survey Quasars) and NVSS (NRAO VLA All Sky Survey) radio sources. The details of the analysis (*thus the likelihood code) can be understood by reading the papers ISW paper and Weak lensing paper. The code does brute force theoretical matter power spectrum and calculations with CAMB. See the paper for an introduction, descriptions, and typical results from some pre-WMAP data. The code is designed to be integrated into CosmoMC. For further information concerning the integration, see Code Modification for integration into COSMOMC.

[ascl:1307.012]
ITERA: IDL Tool for Emission-line Ratio Analysis

ITERA, the IDL Tool for Emission-line Ratio Analysis, is an IDL widget tool that allows you to plot ratios of any strong atomic and ionized emission lines as determined by standard photoionization and shock models. These "line ratio diagrams" can then be used to determine diagnostics for nebulae excitation mechanisms or nebulae parameters such as density, temperature, metallicity, etc. ITERA can also be used to determine line sensitivities to such parameters, compare observations with the models, or even estimate unobserved line fluxes.

[ascl:1406.016]
IUEDR: IUE Data Reduction package

IUEDR reduces IUE data. It addresses the problem of working from the IUE Guest Observer tape or disk file through to a calibrated spectrum that can be used in scientific analysis and is a complete system for IUE data reduction. IUEDR was distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1801.002]
iWander: Dynamics of interstellar wanderers

iWander assesses the origin of interstellar small bodies such as asteroids and comets. It includes a series of databases and tools that can be used in general for studying the dynamics of an interstellar vagabond object (small−body, interstellar spaceship and even stars).

[ascl:1209.002]
JAGS: Just Another Gibbs Sampler

JAGS analyzes Bayesian hierarchical models using Markov Chain Monte Carlo (MCMC) simulation not wholly unlike BUGS. JAGS has three aims:

- to have a cross-platform engine for the BUGS language;
- to be extensible, allowing users to write their own functions, distributions and samplers; and
- to be a platform for experimentation with ideas in Bayesian modeling.

[ascl:1403.018]
JAM: Jeans Anisotropic MGE modeling method

The Jeans Anisotropic MGE (JAM) modeling method uses the Multi-Gaussian Expansion parameterization for the galaxy surface brightness. The code allows for orbital anisotropy (three-integrals distribution function) and also provides the full second moment tensor, including proper motions and radial velocities.

[ascl:1010.007]
JAVELIN: Just Another Vehicle for Estimating Lags In Nuclei (formerly known as SPEAR)

JAVELIN (SPEAR) is a new approach to reverberation mapping that computes the lags between the AGN continuum and emission line light curves and their statistical confidence limits. It uses a damped random walk model to describe the quasar continuum variability and the ansatz that emission line variability is a scaled, smoothed and displaced version of the continuum. While currently configured only to simultaneously fit light curve means, it includes a general linear parameters formalism to fit more complex trends or calibration offsets. The noise matrix can be modified to allow for correlated errors, and the correlation matrix can be modified to use a different stochastic process. The transfer function model is presently a tophat, but this can be altered by changing the line-continuum covariance matrices. It is also able to cope with some problems in traditional reverberation mapping, such as irregular sampling, correlated errors and seasonal gaps.

[ascl:1411.020]
JCMT COADD: UKT14 continuum and photometry data reduction

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

[ascl:1406.019]
JCMTDR: Applications for reducing JCMT continuum data in GSD format

JCMTDR reduces continuum on-the-fly mapping data obtained with UKT14 or the heterodyne instruments using the IFD on the James Clerk Maxwell Telescope. This program reduces archive data and heterodyne beam maps and was distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1702.005]
JetCurry: Modeling 3D geometry of AGN jets from 2D images

Written in Python, JetCurry models the 3D geometry of jets from 2-D images. JetCurry requires NumPy and SciPy and incorporates emcee (ascl:1303.002) and AstroPy (ascl:1304.002), and optionally uses VPython. From a defined initial part of the jet that serves as a reference point, JetCurry finds the position of highest flux within a bin of data in the image matrix and fits along the *x* axis for the general location of the bends in the jet. A spline fitting is used to smooth out the resulted jet stream.

[ascl:1810.003]
JETGET: Hydrodynamic jet simulation visualization and analysis

JETGET accesses, visualizes, and analyses (magnetized-)fluid dynamics data stored in Hierarchical Data Format (HDF) and ASCII files. Although JETGET has been optimized to handle data output from jet simulations using the Zeus code (ascl:1306.014) from NCSA, it is also capable of analyzing other data output from simulations using other codes. JETGET can select variables from the data files, render both two- and three-dimensional graphics and analyze and plot important physical quantities. Graphics can be saved in encapsulated Postscript, JPEG, VRML, or saved into an MPEG for later visualization and/or presentations. The strength of JETGET in extracting the physics underlying such phenomena is demonstrated as well as its capabilities in visualizing the 3-dimensional features of the simulated magneto-hydrodynamic jets. The JETGET tool is written in Interactive Data Language (IDL) and uses a graphical user interface to manipulate the data. The tool was developed on a LINUX platform and can be run on any platform that supports IDL.

[ascl:1308.016]
JHelioviewer: Visualization software for solar physics data

Mueller, Daniel; Dimitoglou, George; Caplins, Benjamin; Garcia Ortiz, Juan Pablo; Wamsler, Benjamin; Hughitt, Keith; Alexanderian, Alen; Ireland, Jack; Amadigwe, Desmond; Fleck, Bernhard

JHelioview is open source visualization software for solar physics data. The JHelioviewer client application enables users to browse petabyte-scale image archives; the JHelioviewer server integrates a JPIP server, metadata catalog, and an event server. JHelioview uses the JPEG 2000 image compression standard, which provides efficient access to petabyte-scale image archives; JHelioviewer also allows users to locate and manipulate specific data sets.

[ascl:1207.013]
JKTEBOP: Analyzing light curves of detached eclipsing binaries

The JKTEBOP code is used to fit a model to the light curves of detached eclipsing binary stars in order to derive the radii of the stars as well as various other quantities. It is very stable and includes extensive Monte Carlo or bootstrapping error analysis algorithms. It is also excellent for transiting extrasolar planetary systems. All input and output is done by text files; JKTEBOP is written in almost-standard FORTRAN 77 using first the g77 compiler and now the ifort compiler.

[ascl:1511.016]
JKTLD: Limb darkening coefficients

JKTLD outputs theoretically-calculated limb darkening (LD) strengths for equations (LD laws) which predict the amount of LD as a function of the part of the star being observed. The coefficients of these laws are obtained by bilinear interpolation (in effective temperature and surface gravity) in published tables of coefficients calculated from stellar model atmospheres by several researchers. Many observations of stars require the strength of limb darkening (LD) to be estimated, which can be done using theoretical models of stellar atmospheres; JKTLD can help in these circumstances.

[ascl:1511.002]
JSPAM: Interacting galaxies modeller

JSPAM models galaxy collisions using a restricted n-body approach to speed up computation. Instead of using a softened point-mass potential, the software supports a modified version of the three component potential created by Hernquist (1994, ApJS 86, 389). Although spherically symmetric gravitationally potentials and a Gaussian model for the bulge are used to increase computational efficiency, the potential mimics that of a fully consistent n-body model of a galaxy. Dynamical friction has been implemented in the code to improve the accuracy of close approaches between galaxies. Simulations using this code using thousands of particles over the typical interaction times of a galaxy interaction take a few seconds on modern desktop workstations, making it ideal for rapidly prototyping the dynamics of colliding galaxies. Extensive testing of the code has shown that it produces nearly identical tidal features to those from hierarchical tree codes such as Gadget but using a fraction of the computational resources. This code was used in the Galaxy Zoo: Mergers project and is very well suited for automated fitting of galaxy mergers with automated pattern fitting approaches such as genetic algorithms. Java and Fortran versions of the code are available.

[ascl:1607.007]
JUDE: An Utraviolet Imaging Telescope pipeline

JUDE (Jayant's UVIT Data Explorer) converts the Level 1 data (FITS binary table) from the Ultraviolet Imaging Telescope (UVIT) on ASTROSAT into three output files: a photon event list as a function of frame number (FITS binary table); a FITS image file with two extensions; and a PNG file created from the FITS image file with an automated scaling.

[ascl:1812.016]
Juliet: Transiting and non-transiting exoplanetary systems modelling tool

Juliet essentially serves as a wrapper of other tools, including Batman (ascl:1510.002), George (ascl:1511.015), Dynesty (ascl:1809.013) and AstroPy (ascl:1304.002), to analyze and model transits, radial-velocities, or both from multiple instruments at the same time. Using nested sampling algorithms, it performs a thorough sampling of the parameter space and a model comparison via Bayesian evidences. Juliet also fits transiting and non-transiting multi-planetary systems, and Gaussian Processes (GPs) which might share hyperparameters between the photometry and radial-velocities simultaneously (e.g., stellar rotation periods).

[ascl:1109.024]
Jupiter: Multidimensional Astrophysical Hydrocode

Jupiter is a multidimensional astrophysical hydrocode. It is based on a Godunov method, and it is parallelized with MPI. The mesh geometry can either be cartesian, cylindrical or spherical. It allows mesh refinement and includes special features adapted to the description of planets embedded in disks and nearly steady states.

[ascl:1702.003]
juwvid: Julia code for time-frequency analysis

Juwvid performs time-frequency analysis. Written in Julia, it uses a modified version of the Wigner distribution, the pseudo Wigner distribution, and the short-time Fourier transform from MATLAB GPL programs, tftb-0.2. The modification includes the zero-padding FFT, the non-uniform FFT, the adaptive algorithm by Stankovic, Dakovic, Thayaparan 2013, the S-method, the L-Wigner distribution, and the polynomial Wigner-Ville distribution.

[ascl:1504.017]
JWFront: Wavefronts and Light Cones for Kerr Spacetimes

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

[ascl:1507.013]
K-Inpainting: Inpainting for Kepler

Inpainting is a technique for dealing with gaps in time series data, as frequently occurs in asteroseismology data, that may generate spurious peaks in the power spectrum, thus limiting the analysis of the data. The inpainting method, based on a sparsity prior, judiciously fills in gaps in the data, preserving the asteroseismic signal as far as possible. This method can be applied both on ground and space-based data. The inpainting technique improves the oscillation modes detection and estimation, the impact of the observational window function is reduced, and the interpretation of the power spectrum is simplified. K-Inpainting can be used to study very long time series of many stars because its computation is very fast.

[ascl:1503.001]
K2flix: Kepler pixel data visualizer

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

[ascl:1601.009]
K2fov: Field of view software for NASA's K2 mission

K2fov allows users to transform celestial coordinates into K2's pixel coordinate system for the purpose of preparing target proposals and field of view visualizations. In particular, the package, written in Python, adds the "K2onSilicon" and "K2findCampaigns" tools to the command line, allowing the visibility of targets to be checked in a user-friendly way.

[ascl:1602.014]
k2photometry: Read, reduce and detrend K2 photometry

Van Eylen, Vincent; Nowak, Grzegorz; Albrecht, Simon; Palle, Enric; Ribas, Ignasi; Bruntt, Hans; Perger, Manuel; Gandolfi, Davide; Hirano, Teriyuki; Sanchis-Ojeda, Roberto; Kiilerich, Amanda; Arranz, Jorge P.; Badenas, Mariona; Dai, Fei; Deeg, Hans J.; Guenther, Eike W.; Montanes-Rodriguez, Pilar; Narita, Norio; Rogers, Leslie A.; Bejar, Victor J. S.; Shrotriya, Tushar S.; Winn, Joshua N.; Sebastian, Daniel

k2photometry reads, reduces and detrends K2 photometry and searches for transiting planets. MAST database pixel files are used as input; the output includes raw lightcurves, detrended lightcurves and a transit search can be performed as well. Stellar variability is not typically well-preserved but parameters can be tweaked to change that. The BLS algorithm used to detect periodic events is a Python implementation by Ruth Angus and Dan Foreman-Mackey (https://github.com/dfm/python-bls).

[ascl:1607.010]
K2PS: K2 Planet search

K2PS is an Oxford K2 planet search pipeline. Written in Python, it searches for transit-like signals from the k2sc-detrended light curves.

[ascl:1605.012]
K2SC: K2 Systematics Correction

K2SC (K2 Systematics Correction) models instrumental systematics and astrophysical variability in light curves from the K2 mission. It enables the user to remove both position-dependent systematics and time-dependent variability (e.g., for transit searches) or to remove systematics while preserving variability (for variability studies). K2SC automatically computes estimates of the period, amplitude and evolution timescale of the variability for periodic variables and can be run on ASCII and FITS light curve files. Written in Python, this pipeline requires NumPy, SciPy, MPI4Py, Astropy (ascl:1304.002), and George (ascl:1511.015).

[ascl:1307.003]
K3Match: Point matching in 3D space

K3Match is a C library with Python bindings for fast matching of points in 3D space. It uses 3-dimensional binary trees to find matches between large datasets in O(N log N) time.

[ascl:1803.005]
Kadenza: Kepler/K2 Raw Cadence Data Reader

Kadenza enables time-critical data analyses to be carried out using NASA's Kepler Space Telescope. It enables users to convert Kepler's raw data files into user-friendly Target Pixel Files upon downlink from the spacecraft. The primary motivation for this tool is to enable the microlensing, supernova, and exoplanet communities to create quicklook lightcurves for transient events which require rapid follow-up.

[ascl:1607.013]
Kālī: Time series data modeler

The fully parallelized and vectorized software package Kālī models time series data using various stochastic processes such as continuous-time ARMA (C-ARMA) processes and uses Bayesian Markov Chain Monte-Carlo (MCMC) for inferencing a stochastic light curve. Kālī is written in c++ with Python language bindings for ease of use. Kālī is named jointly after the Hindu goddess of time, change, and power and also as an acronym for KArma LIbrary.

[ascl:1403.022]
KAPPA: Kernel Applications Package

KAPPA comprising about 180 general-purpose commands for image processing, data visualization, and manipulation of the standard Starlink data format--the NDF. It works with Starlink's various specialized packages; in addition to the NDF, KAPPA can also process data in other formats by using the "on-the-fly" conversion scheme. Many commands can process data arrays of arbitrary dimension, and others work on both spectra and images. KAPPA operates from both the UNIX C-shell and the ICL command language. KAPPA uses the Starlink environment (ascl:1110.012).

[ascl:1502.008]
KAPPA: Optically thin spectra synthesis for non-Maxwellian kappa-distributions

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

[ascl:1611.010]
Kapteyn Package: Tools for developing astronomical applications

The Kapteyn Package provides tools for the development of astronomical applications with Python. It handles spatial and spectral coordinates, WCS projections and transformations between different sky systems; spectral translations (e.g., between frequencies and velocities) and mixed coordinates are also supported. Kapteyn offers versatile tools for writing small and dedicated applications for the inspection of FITS headers, the extraction and display of (FITS) data, interactive inspection of this data (color editing) and for the creation of plots with world coordinate information. It includes utilities for use with matplotlib such as obtaining coordinate information from plots, interactively modifiable colormaps and timer events (module mplutil); tools for parsing and interpreting coordinate information entered by the user (module positions); a function to search for gaussian components in a profile (module profiles); and a class for non-linear least squares fitting (module kmpfit).

[ascl:1102.018]
Karma: Visualisation Test-Bed Toolkit

Karma is a toolkit for interprocess communications, authentication, encryption, graphics display, user interface and manipulating the Karma network data structure. It contains KarmaLib (the structured libraries and API) and a large number of modules (applications) to perform many standard tasks. A suite of visualisation tools are distributed with the library.

[ascl:1701.005]
KAULAKYS: Inelastic collisions between hydrogen atoms and Rydberg atoms

KAULAKYS calculates cross sections and rate coefficients for inelastic collisions between Rydberg atoms and hydrogen atoms according to the free electron model of Kaulakys (1986, 1991). It is written in IDL and requires the code MSWAVEF (ascl:1701.006) to calculate momentum-space wavefunctions. KAULAKYS can be easily adapted to collisions with perturbers other than hydrogen atoms by providing the appropriate scattering amplitudes.

[ascl:1701.010]
kcorrect: Calculate K-corrections between observed and desired bandpasses

kcorrect fits very restricted spectral energy distribution models to galaxy photometry or spectra in the restframe UV, optical and near-infrared. The main purpose of the fits are for calculating K-corrections. The templates used for the fits may also be interpreted physically, since they are based on the Bruzual-Charlot stellar evolution synthesis codes. Thus, for each fit galaxy kcorrect can provide an estimate of the stellar mass-to-light ratio.

[ascl:1712.001]
KDUtils: Kinematic Distance Utilities

The Kinematic Distance utilities (KDUtils) calculate kinematic distances and kinematic distance uncertainties. The package includes methods to calculate "traditional" kinematic distances as well as a Monte Carlo method to calculate kinematic distances and uncertainties.

[ascl:1702.007]
KEPLER: General purpose 1D multizone hydrodynamics code

KEPLER is a general purpose stellar evolution/explosion code that incorporates implicit hydrodynamics and a detailed treatment of nuclear burning processes. It has been used to study the complete evolution of massive and supermassive stars, all major classes of supernovae, hydrostatic and explosive nucleosynthesis, and x- and gamma-ray bursts on neutron stars and white dwarfs.

[ascl:1706.012]
KeplerSolver: Kepler equation solver

KeplerSolver solves Kepler's equation for arbitrary epoch and eccentricity, using continued fractions. It is written in C and its speed is nearly the same as the SWIFT routines, while achieving machine precision. It comes with a test program to demonstrate usage.

[ascl:1806.022]
Keras: The Python Deep Learning library

Keras is a high-level neural networks API written in Python and capable of running on top of TensorFlow, CNTK, or Theano. It focuses on enabling fast experimentation.

[submitted]
KERN

KERN is a bi-annually released set of radio astronomical software packages. It should contain most of the standard tools that a radio astronomer needs to work with radio telescope data. The goal of KERN to is to save time and frustration in setting up of scientific pipelines, and to assist in achieving scientific reproducibility.

[ascl:1708.021]
KERTAP: Strong lensing effects of Kerr black holes

KERTAP computes the strong lensing effects of Kerr black holes, including the effects on polarization. The key ingredients of KERTAP are a graphic user interface, a backward ray-tracing algorithm, a polarization propagator dealing with gravitational Faraday rotation, and algorithms computing observables such as flux magnification and polarization angles.