[submitted]
Parallelized rotation and flipping INvariant Kohonen maps (PINK)

Morphological classification is one of the most demanding challenges in astronomy. With the advent of all-sky surveys, an enormous amount of imaging data is publicly available. These data are typically analyzed by experts or encouraged amateur volunteers. For upcoming surveys with billions of objects, however, such an approach is not feasible anymore. We present a simple yet effective variant of a rotation-invariant self-organizing map that is suitable for many analysis tasks in astronomy. We show how to reduce the computational complexity via modern GPUs and apply the resulting framework to galaxy data for morphological analysis.

[submitted]
Magnetizer: computing magnetic fields of evolving galaxies

Computes time and radial dependent magnetic fields for a sample of galaxies in the output of a semi-analytic model of galaxy formation. The magnetic field is obtained by numerically solving the galactic dynamo equations throughout history of each galaxy. Stokes parameters and Faraday rotation measure can also be computed along a random line-of-sight for each galaxy.

[submitted]
HaloAnalysis: read and analyze halo catalogs and merger trees

HaloAnalysis reads and analyzes halo/galaxy catalogs, generated from Rockstar (ascl:1210.008) or AHF (ascl:1102.009), and merger trees generated from Consistent Trees (ascl:1210.011). Written in Python, it offers the following functionality: reads halo/galaxy/tree catalogs from multiple file formats; assigns baryonic particles and galaxy properties to dark-matter halos; combines and re-generates halo/galaxy/tree files in hdf5 format; analyzes properties of halos/galaxies; selects halos to generate zoom-in initial conditions. Includes a Jupyter notebook tutorial.

[submitted]
GizmoAnalysis: read and analyze Gizmo simulations

GizmoAnalysis reads and analyzes N-body simulations run with the Gizmo code (ascl:1410.003). Written in Python, we developed it primarily to analyze FIRE simulations, though it is useable with any Gizmo snapshot files. It offers the following functionality: reads snapshot files and converts particle data to physical units; provides a flexible dictionary class to store particle data and compute derived quantities on the fly; plots images and properties of particles; generates region files for input to MUSIC (ascl:1311.011) to generate cosmological zoom-in initial conditions; computes rates of supernovae and stellar winds, including their nucleosynthetic yields, as used in FIRE simulations. Includes a Jupyter notebook tutorial.

[submitted]
qnm: A Python package for calculating Kerr quasinormal modes, separation constants, and spherical-spheroidal mixing coefficients

qnm is an open-source Python package for computing the Kerr quasinormal mode frequencies, angular separation constants, and spherical-spheroidal mixing coefficients. The qnm package includes a Leaver solver with the Cook-Zalutskiy spectral approach to the angular sector, and a caching mechanism to avoid repeating calculations. We provide a large cache of low ℓ, m, n modes, which can be downloaded and installed with a single function call, and interpolated to provide good initial guess for root-polishing at new values of spin.

[submitted]
uvplot

A simple package to make nice plots of interferometric visibilities, often called uvplots.

[ascl:1909.014]
fgivenx: Functional posterior plotter

fgivenx plots a predictive posterior of a function, dependent on sampled parameters, for a Bayesian posterior Post(theta|D,M) described by a set of posterior samples {theta_i}~Post. If there is a function parameterized by theta y=f(x;theta), this script produces a contour plot of the conditional posterior P(y|x,D,M) in the (x,y) plane.

[ascl:1909.013]
EPOS: Exoplanet Population Observation Simulator

EPOS (Exoplanet Population Observation Simulator) simulates observations of exoplanet populations. It provides an interface between planet formation simulations and exoplanet surveys such as Kepler. EPOS can also be used to estimate planet occurrence rates and the orbital architectures of planetary systems.

[ascl:1909.012]
HISS: HI spectra stacker

Healy, J.; Blyth, S. -L.; Elson, E.; van Driel, W.; Butcher, Z.; Schneider, S.; Lehnert, M. D.; Minchin, R.

HISS stacks HI (emission and absorption) spectra in a consistent and reliable manner to enable statistical analysis of average HI properties. It provides plots of the stacked spectrum and reference spectrum with any fitted function, of the stacked noise response, and of the distribution of the integrated fluxes when calculating the uncertainties. It also produces a table containing the integrated flux calculated from the fitted functions and the stacked spectrum, among other output files.

[ascl:1909.011]
WVTICs: SPH initial conditions using Weighted Voronoi Tesselations

Arth, Alexander; Donnert, Julius; Steinwandel, Ulrich; Böss, Ludwig; Halbesma, Timo; Pütz, Martin; Hubber, David; Dolag, Klaus

WVTICs generates glass-like initial conditions for Smoothed Particle Hydrodynamics. Relaxation of the particle distribution is done using an algorithm based on Weighted Voronoi Tesselations; additional particle reshuffling can be enabled to improve over- and undersampled maxima/minima. The WBTICs package includes a full suite of analytical test problems.

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

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

[ascl:1909.009]
CLOVER: Convolutional neural network spectra identifier and kinematics predictor

CLOVER (Convnet Line-fitting Of Velocities in Emission-line Regions) is a convolutional neural network (ConvNet) trained to identify spectra with two velocity components along the line of sight and predict their kinematics. It works with Gaussian emission lines (e.g., CO) and lines with hyperfine structure (e.g., NH3). CLOVER has two prediction steps, classification and parameter prediction. For the first step, CLOVER segments the pixels in an input data cube into one of three classes: noise (i.e., no emission), one-component (emission line with single velocity component), and two-component (emission line with two velocity components). For the pixels identified as two-components in the first step, a second regression ConvNet is used to predict centroid velocity, velocity dispersion, and peak intensity for each velocity component.

[ascl:1909.008]
RascalC: Fast code for galaxy covariance matrix estimation

RascalC quickly estimates covariance matrices from two- or three-point galaxy correlation functions. Given an input set of random particle locations and a two-point correlation function (or input set of galaxy positions), RascalC produces an estimate of the associated covariance for a given binning strategy, with non-Gaussianities approximated by a ‘shot-noise-rescaling’ parameter. For the 2PCF, the rescaling parameter can be calibrated by dividing the particles into jackknife regions and comparing sample to theoretical jackknife covariance. RascalC can also be used to compute Legendre-binned covariances and cross-covariances between different two-point correlation functions.

[ascl:1909.007]
EBHLIGHT: General relativistic radiation magnetohydrodynamics with Monte Carlo transport

EBHLIGHT solves the equations of general relativistic radiation magnetohydrodynamics in stationary spacetimes. Fluid integration is performed with the second order shock-capturing scheme HARM (ascl:1209.005) and frequency-dependent radiation transport is performed with the second order Monte Carlo code grmonty (ascl:1306.002). Fluid and radiation exchange four-momentum in an explicit first-order operator-split fashion.

[ascl:1909.006]
ChempyMulti: Multi-star Bayesian inference with Chempy

ChempyMulti is an update to Chempy (ascl:1702.011) and provides yield table scoring and multi-star Bayesian inference. This replaces the ChempyScoring package in Chempy. Chempy is a flexible one-zone open-box chemical evolution model, incorporating abundance fitting and stellar feedback calculations. It includes routines for parameter optimization for simulations and observational data and yield table scoring.

[ascl:1909.005]
HADES: Hexadecapolar Analysis for Dust Estimation in Simulations (of CMB B-mode thermal dust emission)

HADES analyzse dust levels in simulated CMB galactic dust maps with realistic experimental noise and lensing configurations. It allows detection of dust via its anisotropy properties in CMB B-modes. It also includes techniques for computing null-tests and a rudimentary technique for dedusting.

[ascl:1909.004]
TPI: Test Particle Integrator

TPI computes the gravitational dynamics of particles orbiting a supermassive black hole (SBH). A distinction is made to two types of particles: test particles and field particles. Field particles are assumed to move in quasi-static Keplerian orbits around the SBH that precess due to the enclosed mass (Newtonian 'mass precession') and relativistic effects. Otherwise, field-particle-field-particle interactions are neglected. Test particles are integrated in the time-dependent potential of the field particles and the SBH. Relativistic effects are included in the equations of motion (including the effects of SBH spin), and test-particle-test-particle interactions are neglected.

[ascl:1909.003]
SecularMultiple: Hierarchical multiple system secular evolution model

SecularMultiple computes the secular (orbit-averaged) gravitational dynamics of hierarchical multiple systems composed of nested binary orbits (simplex-type systems) with any configuration and any number of bodies. A particle can represent a binary or a body. The structure of the system is determined by linking to other particles with the attributes child1 and child2, and tidal interactions and relativistic corrections are included in an ad hoc fashion. SecularMultiple also includes routines for external perturbations such as flybys and supernovae.

[ascl:1909.002]
MultiColorFits: Colorize and combine multiple fits images for visually aesthetic scientific plots

MultiColorFits is a tool to colorize and combine multiple fits images for making visually aesthetic scientific plots. The standard method to make color composites by combining fits images programmatically in python is to assign three images as separate red, green, and blue channels. This can produce unsatisfactory results for a variety of reasons, such as when less than three images are available, or additional images are desired to be shown. MultiColorFits breaks these limitations by allowing users to apply any color to a given image, not just red, green, or blue. Composites can then be created from an arbitrary number of images. Controls are included for stretching brightness scales with common functions.

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

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

[submitted]
CR-SISTEM: Symplectic integrator for lunar core-mantle and orbital dynamics

This integrator is based on the algorithm of Touma and Wisdom (2001, http://ui.adsabs.harvard.edu/abs/2001AJ....122.1030T). The triaxial Moon has a triaxial liquid core, and is perturbed by the Sun and Earth's oblateness. Orbits of the Moon and Earth are fully integrated, and other planets (or additional point-mass satellites) may be included in the integration. Lunar and solar tides on Earth, eccentricity and obliquity tides on the Moon, and lunar core-mantle friction and all included. The tides on Earth and the Moon are treated in the same way Cuk et al (2016, http://ui.adsabs.harvard.edu/abs/2016Natur.539..402C) and many details of their closely-related code can be found in the online supplement of that paper. In the posted version, the lunar core-mantle friction torque is directly proportional to the core-mantle differential rotation, with a fixed damping timescale of 10,000 present-day sidereal months (120 yrs, after Pavlov et al. (2016, https://ui.adsabs.harvard.edu/abs/2016CeMDA.126...61P).

[ascl:1908.025]
FastCSWT: Fast directional Continuous Spherical Wavelet Transform

FastCSWT performs a directional continuous wavelet transform on the sphere. The transform is based on the construction of the continuous spherical wavelet transform (CSWT) developed by Antoine and Vandergheynst (1999). A fast implementation of the CSWT (based on the fast spherical convolution developed by Wandelt and Gorski 2001) is also provided.

[ascl:1908.024]
PYSAT: Python Satellite Data Analysis Toolkit

The Python Satellite Data Analysis Toolkit (pysat) provides a simple and flexible interface for downloading, loading, cleaning, managing, processing, and analyzing space science data. The toolkit supports in situ satellite observations and many different types of ground- and space-based measurements. Its analysis routines are independent of instrument and data source.

[ascl:1908.023]
FIRST Classifier: Automated compact and extended radio sources classifier

FIRST Classifier is an on-line system for automated classification of compact and extended radio sources. It is developed based on a trained Deep Convolutional Neural Network Model to automate the morphological classification of compact and extended radio sources observed in the FIRST radio survey. FIRST Classifier is able to predict the morphological class for a single source or for a list of sources as Compact or Extended (FRI, FRII and BENT).

[ascl:1908.022]
YMW16: Electron-density model

YMW16 models the distribution of free electrons in the Galaxy, the Magellanic Clouds and the inter-galactic medium and can be used to estimate distances for real or simulated pulsars and fast radio bursts (FRBs) based on their position and dispersion measure. The Galactic model is based on 189 pulsars that have independently determined distances as well as dispersion measures, whereas simpler models are used for the electron density in the MC and the IGM.

[ascl:1908.021]
bias_emulator: Halo bias emulator

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

[ascl:1908.020]
QLF: Luminosity function analysis code

QLF derives full posterior distributions for and analyzes luminosity functions models; it also models hydrogen and helium reionization. Used with the included homogenized data, the derived luminosity functions can be easily compared with theoretical models or future data sets.

[ascl:1908.019]
MAESTROeX: Low Mach number stellar hydrodynamics code

MAESTROeX solves the equations of low Mach number hydrodynamics for stratified atmospheres or stars with a general equation of state. It includes reactions and thermal diffusion and can be used on anything from a single core to 100,000s of processor cores with MPI + OpenMP. MAESTROeX maintains the accuracy of its predecessor MAESTRO (ascl:1010.044) while taking advantage of a simplified temporal integration scheme and leveraging the AMReX software framework for block-structured adaptive mesh refinement (AMR) applications.

[ascl:1908.018]
EBAI: Eclipsing Binaries with Artificial Intelligence

Prša, A.; Guinan, E. F.; Devinney, E. J.; DeGeorge, M.; Bradstreet, D. H.; Giammarco, J. M.; Alcock, C. R.; Engle, S. G.

Eclipsing Binaries via Artificial Intelligence (EBAI) automates the process of solving light curves of eclipsing binary stars. EBAI is based on the back-propagating neural network paradigm and is highly flexible in construction of neural networks. EBAI comes in two flavors, serial (ebai) and multi-processor (ebai.mpi), and can be run in training, continued training, and recognition mode.

[ascl:1908.017]
JPLephem: Jet Propulsion Lab ephemerides package

JPLephem loads and uses standard Jet Propulsion Laboratory (JPL) ephemerides for predicting the position and velocity of a planet or other Solar System body. It is one of the foundations of the Skyfield (ascl:1907.024) astronomy library for Python, and can also be used as a standalone package to generate raw vectors.

[ascl:1908.016]
DustCharge: Charge distribution for a dust grain

Ibáñez-Mejía, Juan C.; Walch, Stefanie; Ivlev, Alexei V.; Clarke, Seamus; Caselli, Paola; Joshi, Prabesh R.

DustCharge calculates the equilibrium charge distribution for a dust grain of a given size and composition, depending on the local interstellar medium conditions, such as density, temperature, ionization fraction, local radiation field strength, and cosmic ray ionization fraction.

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

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

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

[ascl:1908.014]
Vlasiator: Hybrid-Vlasov simulation code

von Alfthan, Sebastian; Pfau-Kempf, Yann; Sandroos, Arto; Hannuksela, Otto Akseli; Ganse, Urs; Battarbee, Markus; Pokhotelov, Dimitry

Vlasiator is a 6-dimensional Vlasov theory-based simulation. It simulates the entire near-Earth space at a global scale using the kinetic hybrid-Vlasov approach, to study fundamental plasma processes (reconnection, particle acceleration, shocks), and to gain a deeper understanding of space weather.

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

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

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

[ascl:1908.012]
oscode: Oscillatory ordinary differential equation solver

oscode solves oscillatory ordinary differential equations efficiently. It is designed to deal with equations of the form *x*¨(*t*)+2γ(*t*)*x*˙(*t*)+ω2(*t*)*x*(*t*)=0, where γ(*t*) and ω(*t*) can be given as explicit functions or sequence containers (Eigen::Vectors, arrays, std::vectors, lists) in C++ or as numpy.arrays in Python. oscode makes use of an analytic approximation of *x(t)* embedded in a stepping procedure to skip over long regions of oscillations, giving a reduction in computing time. The approximation is valid when the frequency changes slowly relative to the timescales of integration, it is therefore worth applying when this condition holds for at least some part of the integration range.

[ascl:1908.011]
NuRadioMC: Monte Carlo simulation package for radio neutrino detectors

Glaser, Christian; García-Fernández, Daniel; Nelles, Anna; Alvarez-Muñiz, Jaime; Barwick, Steven W.; Besson, Dave Z.; Clark, Brian A.; Connolly, Amy; Deaconu, Cosmin; de Vries, Krijn; Hanson, Jordan C.; Hokanson-Fasig, Ben; Lahmann, R.; Latif, Uzair; Kleinfelder, Stuart A.; Persichilli, Christopher; Pan, Yue; Pfender, Carl; Plaisier, Ilse; Seckel, Dave Torres, Jorge; Toscano, Simona; van Eijndhoven, Nick; Vieregg, Abigail; Welling, Christoph; Winchen, Tobias; Wissel, Stephanie A.

NuRadioMC simulates ultra-high energy neutrino detectors that rely on the radio detection method, which exploits the radio emission generated in the electromagnetic component of a particle shower following a neutrino interaction. The code simulates the neutrino interaction in a medium, subsequent Askaryan radio emission, propagation of the radio signal to the detector and the detector response. NuRadioMC is a Monte Carlo framework that combines flexibility in detector design with user-friendliness. It includes an event generator, improved modeling of the radio emission, a revisited approach to signal propagation, and increased flexibility and precision in the detector simulation.

[ascl:1908.010]
SNAPDRAGONS: Stellar Numbers And Parameters Determined Routinely And Generated Observing N-body Systems

Hunt, Jason A. S.; Kawata, Daisuke; Grand, Robert J. J.; Minchev, Ivan; Pasetto, Stefano; Cropper, Mark

SNAPDRAGONS (Stellar Numbers And Parameters Determined Routinely And Generated Observing N-body Systems) is a simplified version of the population synthesis code Galaxia (ascl:1101.007), using a different process to generate the stellar catalog. It splits each N-body particle from the galaxy simulation into an appropriate number of stellar particles to create a mock catalog of observable stars from the N-body model. SNAPDRAGON uses the same isochrones and extinction map as Galaxia.

[ascl:1908.009]
PyRADS: Python RADiation model for planetary atmosphereS

The 1D radiation code PyRADS provides line-by-line spectral resolution. For Earth-like atmospheres, PyRADS currently uses HITRAN 2016 line lists and the MTCKD continuum model. A version for shortwave radiation (scattering) is also available.

[ascl:1908.008]
TRISTAN-MP: TRIdimensional STANford - Massively Parallel code

TRISTAN-MP is a fully relativistic Particle-In-Cell (PIC) code for plasma physics computations and self-consistently solves the full set of Maxwell’s equations, along with the relativistic equations of motion for the charged particles. Fields are discretized on a finite 3D or 2D mesh, the computational grid; the code then uses time-centered and space-centered finite difference schemes to advance the equations in time via the Lorentz force equation, and to calculate spatial derivatives, so that the algorithm is second order accurate in space and time. The charges and currents derived from the particles' velocities and positions are then used as source terms to re-calculate the electromagnetic fields. TRISTAN-MP is based on the original TRISTAN code by O. Buneman (1999).

[ascl:1908.007]
MosfireDRP: MOSFIRE Data Reduction Pipeline

MosfireDRP reduces data from the MOSFIRE spectrograph of the Keck Observatory; it produces flat-fielded, wavelength calibrated, rectified, and stacked 2D spectrograms for each slit on a given mask in nearly real time. Background subtraction is performed in two states: a simple pairwise subtraction of interleaved stacks, and then fitting a 2D b-spline model to the background residuals.

[ascl:1908.006]
GBKFIT: Galaxy kinematic modeling

GBKFIT performs galaxy kinematic modeling. It can be used to extract morphological and kinematical properties of galaxies by fitting models to spatially resolved kinematic data. The software can also take beam smearing into account by using the knowledge of the line and point spread functions. GBKFIT can take advantage of many-core and massively parallel architectures such as multi-core CPUs and Graphics Processing Units (GPUs), making it suitable for modeling large-scale surveys of thousands of galaxies within a very seasonable time frame. GBKFIT features an extensible object-oriented architecture that supports arbitrary models and optimization techniques in the form of modules; users can write custom modules without modifying GBKFIT’s source code. The software is written in C++ and conforms to the latest ISO standards.

[ascl:1908.005]
dips: Detrending periodic signals in timeseries

dips detrends timeseries of strictly periodic signals. It does not assume any functional form for the signal or the background or the noise; it disentangles the strictly periodic component from everything else. It has been used for detrending Kepler, K2 and TESS timeseries of periodic variable stars, eclipsing binary stars, and exoplanets.

[ascl:1908.004]
Gramsci: GRAph Made Statistics for Cosmological Information

Gramsci (GRAph Made Statistics for Cosmological Information) computes the general N-point spatial correlation functions of any discrete point set embedded within an Euclidean space of ℝ^n. It uses kd-trees and graph databases to count all possible N-tuples in binned configurations within a given length scale, e.g. all pairs of points or all triplets of points with side lengths. Gramsci can run in serial, OpenMP, MPI and hybrid parallel schemes. It is useful for performing domain decomposition of input catalogs, especially if the catalogs are large or the Rmax value is too large.

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

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

[ascl:1908.002]
Molsoft: Molonglo Telescope Observing Software

Molsoft operates, monitors and schedules observations, both through predetermined schedule files and fully dynamically, at the refurbished Molonglo Observatory Synthesis Radio Telescope (MOST). It was developed as part of the UTMOST upgrade of the facility. The software includes a large-scale pulsar timing program; the autonomous observing system and the dynamic scheduler has increased the observing efficiency by a factor of 2-3 in comparison with static scheduling.

[ascl:1908.001]
QAC: Quick Array Combinations front end to CASA

QAC (Quick Array Combinations) is a front end to CASA (ascl:1107.013) and calls tools and tasks to help in combining data from a single dish and interferometer. QAC hides some of the complexity of writing CASA scripts and provide a simple interface to array combination tools and tasks in CASA. This project was conceived alongside the TP2VIS (ascl:1904.021) project, where it was used to provide an easier way to call CASA and perform regression tests.

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

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

[ascl:1907.031]
MGB: Interactive spectral classification code

MGB (Marxist Ghost Buster) attacks spectral classification by using an interactive comparison with spectral libraries. It allows the user to move along the two traditional dimensions of spectral classification (spectral subtype and luminosity classification) plus the two additional ones of rotation index and spectral peculiarities. Double-lined spectroscopic binaries can also be fitted using a combination of two standards. The code includes OB2500 v2.0, a standard grid of blue-violet *R* ~ 2500 spectra of O stars from the Galactic O-Star Spectroscopic Survey, but other grids can be added to MGB.

[ascl:1907.030]
Wōtan: Stellar detrending methods

Wōtan provides free and open source algorithms to remove trends from time-series data automatically as an aid to to search efficiently for transits in stellar light curves from surveys. The toolkit helps determine empirically the best tool for a given job, serving as a one-stop solution for various smoothing tasks.

[ascl:1907.029]
XDF-GAN: Mock astronomical survey generator

XDF-GAN generates mock galaxy surveys with a Spatial Generative Adversarial Network (SGAN)-like architecture. Mock galaxy surveys are generated from data that is preprocessed as little as possible (preprocessing is only a 99.99th percentile clipping). The outputs can also be tessellated together to create a very large survey, limited in size only by the RAM of the generation machine.

[ascl:1907.028]
ROHSA: Separation of diffuse sources in hyper-spectral data

ROHSA (Regularized Optimization for Hyper-Spectral Analysis) reveals the statistical properties of interstellar gas through atomic and molecular lines. It uses a Gaussian decomposition algorithm based on a multi-resolution process from coarse to fine grid to decompose any kind of hyper-spectral observations into a sum of coherent Gaussian. Optimization is performed on the whole data cube at once to obtain a solution with spatially smooth parameters.

[ascl:1907.027]
intensitypower: Spectrum multipoles modeler

intensitypower measures and models the auto- and cross-power spectrum multipoles of galaxy catalogs and radio intensity maps presented in spherical coordinates. It can also convert the multipoles to power spectrum wedges P(k,mu) and 2D power spectra P(k_perp,k_par). The code assumes the galaxy catalog is a set of discrete points and the radio intensity map is a pixelized continuous field which includes angular pixelization using healpix, binning in redshift channels, smoothing by a Gaussian telescope beam, and the addition of a Gaussian noise in each cell. The galaxy catalog and radio intensity map are transferred onto an FFT grid, and power spectrum multipoles are measured including curved-sky effects. Both maps include redshift-space distortions.

[ascl:1907.026]
MCRGNet: Morphological Classification of Radio Galaxy Network

MCRGNet (Morphological Classification of Radio Galaxy Network) classifies radio galaxies of different morphologies. It is based on the Convolutional Neural Network (CNN), which is trained and applied under a three-step framework: 1.) pretraining the network unsupervisedly with unlabeled samples, 2.) fine-tuning the pretrained network parameters supervisedly with labeled samples, and 3.) classifying a new radio galaxy by the trained network. The code uses a dichotomous tree classifier composed of cascaded CNN based subclassifiers.

[ascl:1907.025]
GIST: Galaxy IFU Spectroscopy Tool

Bittner, A.; Falcón-Barroso, J.; Nedelchev, B.; Dorta, A.; Gadotti, D. A.; Sarzi, M.; Molaeinezhad, A.; Iodice, E.; Rosado-Belza, D.; de Lorenzo-Cáceres, A.; Fragkoudi, F.; Galán-de Anta, P. M.; Husemann, B.; Méndez-Abreu, J.; Neumann, J.; Pinna, F.; Querejeta, M.; Sánchez-Blázquez, P.; Seidel, M. K.

GIST (Galaxy IFU Spectroscopy Tool) provides a convenient all-in-one framework for the scientific analysis of fully reduced, (integral-field) spectroscopic data, conducting all the steps from the preparation of input data to the scientific analysis and to the production of publication-quality plots. In its basic set-up, the GIST pipeline extracts stellar kinematics, performs an emission-line analysis, and derives stellar population properties from full spectral fitting and via the measurement of absorption line-strength indices by exploiting pPXF (ascl:1210.002)and GandALF routines. The pipeline is not specific to any instrument or analysis technique, and includes a dedicated visualization routine with a sophisticated graphical user interface for fully interactive plotting of all measurements, spectra, fits, and residuals, as well as star formation histories and the weight distribution of the models.

[ascl:1907.024]
Skyfield: High precision research-grade positions for planets and Earth satellites generator

Skyfield computes positions for the stars, planets, and satellites in orbit around the Earth. Its results should agree with the positions generated by the United States Naval Observatory and their Astronomical Almanac to within 0.0005 arcseconds (which equals half a “mas” or milliarcsecond). It computes geocentric coordinates or topocentric coordinates specific to your location on the Earth’s surface. Skyfield accepts AstroPy (ascl:1304.002) time objects as input and can return results in native AstroPy units but is not dependend on AstroPy nor its compiled libraries.

[ascl:1907.023]
REVOLVER: REal-space VOid Locations from suVEy Reconstruction

REVOLVER reconstructs real space positions from redshift-space tracer data by subtracting RSD through FFT-based reconstruction (optional) and applies void-finding algorithms to create a catalogue of voids in these tracers. The tracers are normally galaxies from a redshift survey but could also be halos or dark matter particles from a simulation box. Two void-finding routines are provided. The first is based on ZOBOV (ascl:1304.005) and uses Voronoi tessellation of the tracer field to estimate the local density, followed by a watershed void-finding step. The second is a voxel-based method, which uses a particle-mesh interpolation to estimate the tracer density, and then uses a similar watershed algorithm. Input data files can be in FITS format, or ASCII- or NPY-formatted data arrays.

[ascl:1907.022]
CMDPT: Color Magnitude Diagrams Plot Tool

CMD Plot Tool calculates and plots Color Magnitude Diagrams (CMDs) from astronomical photometric data, *e.g.* of a star cluster observed in two filter bandpasses. It handles multiple file formats (plain text, DAOPHOT .mag files, ACS Survey of Galactic Globular Clusters .zpt files) to generate professional and customized plots without a steep learning curve. It works “out of the box” and does not require any installation of development environments, additional libraries, or resetting of system paths. The tool is available as a single application/executable file with the source code. Sample data is also bundled for demonstration. CMD Plot Tool can also convert DAOPHOT magnitude files to CSV format.

[ascl:1907.021]
PRISM: Probabilistic Regression Instrument for Simulating Models

PRISM analyzes scientific models using the Bayes linear approach, the emulation technique, and history matching to construct an approximation ('emulator') of any given model. The software facilitates and enhances existing MCMC methods by restricting plausible regions and exploring parameter space efficiently and can be used as a standalone alternative to MCMC for model analysis, providing insight into the behavior of complex scientific models. PRISM stores results in HDF5-files and can be executed in serial or MPI on any number of processes. It accepts any type of model and comparison data and can reduce relevant parameter space by factors over 100,000 using only a few thousand model evaluations.

[ascl:1907.020]
GaussPy+: Gaussian decomposition package for emission line spectra

Riener, Manuel; Kainulainen, Jouni; Henshaw, Jonathan D.; Orkisz, Jan H.; Murray, Claire E.; Beuther, Henrik

GaussPy+ is a fully automated Gaussian decomposition package for emission line spectra. It is based on GaussPy (ascl:1907.019) and offers several improvements, including automating preparatory steps and providing an accurate noise estimation, improving the fitting routine, and providing a routine to refit spectra based on neighboring fit solutions. GaussPy+ handles complex emission and low to moderate signal-to-noise values.

[ascl:1907.019]
GaussPy: Python implementation of the Autonomous Gaussian Decomposition algorithm

GaussPy implements the Autonomous Gaussian Decomposition (AGD) algorithm, which uses computer vision and machine learning techniques to provide optimized initial guesses for the parameters of a multi-component Gaussian model automatically and efficiently. The speed and adaptability of AGD allow it to interpret large volumes of spectral data efficiently. Although it was initially designed for applications in radio astrophysics, AGD can be used to search for one-dimensional Gaussian (or any other single-peaked spectral profile)-shaped components in any data set. To determine how many Gaussian functions to include in a model and what their parameters are, AGD uses a technique called derivative spectroscopy. The derivatives of a spectrum can efficiently identify shapes within that spectrum corresponding to the underlying model, including gradients, curvature and edges.

[ascl:1907.018]
StePar: Inferring stellar atmospheric parameters using the EW method

StePar computes the stellar atmospheric parameters T_{eff}, log g, [Fe/H], and ξ of FGK-type stars using the Equivalent Width (*EW*) method. The code implements a grid of MARCS model atmospheres and uses the MOOG radiative transfer code (ascl:1202.009) and TAME (ascl:1503.003). StePar uses a Downhill Simplex minimization algorithm, running it twice for any given star, to compute the stellar atmospheric parameters.

[ascl:1907.017]
ZChecker: Zwicky Transient Facility moving target checker for short object lists

Kelley, Michael S.P.; Bodewits, Dennis; Ye, Qaunzhi; Laher, Russ R.; Masci, Frank J.; Monkewitz, Serge; Riddle, Reed; Rusholme, Ben; Shupe, David L; Soumagnac, Maayane T.

ZChecker finds, measures, and visualizes known comets in the Zwicky Transient Facility time-domain survey. Images of targets are identified using on-line ephemeris generation and survey metadata. The photometry of the targets are measured and the images are processed with temporal filtering to highlight morphological variations in time.

[submitted]
DM phase: A novel algorithm for correcting dispersion of radio signals

Radio waves propagating in space are subject to frequency-dependent delay due to interactions with cold free electrons, which gives coherent radio emissions a unique structure known as dispersion. The study of impulsive radio signals from astronomical sources, such as those emitted by pulsars and fast radio bursts (FRBs), requires proper corrections for this effect. Moreover, the ionized medium itself can be characterized by sensitive measurements of this dispersion.

Signal dispersion is proportional to the integrated column density of free electrons along the line of sight, a quantity known as dispersion measure (DM), and inversely proportional to the observing frequency squared. Traditional methods search for the best DM value of a source by maximizing the signal-to-noise ratio (S/N) of the detected signal. While sensitive and efficient algorithms have been designed for this purpose, they are affected by two limitations. Firstly, they implicitly assume a broadband emission across the entire observing frequency bandwidth. While this is normally true for pulsars, some FRBs have been observed to have complex spectra which returned incorrect DM values. Secondly, these traditional algorithms are highly sensitive to large-amplitude events such as large noise spikes and radio interference. In order to overcome these limitations, we developed a new algorithm to maximize the coherent power of the signal instead of its intensity. Since the structure of the signal is coherent at different frequencies, this method is relatively insensitive to complex spectro-temporal shapes of the pulses. In addition, this method is more robust to noise and interference because these normally have incoherent structures and the amplitude information in each frequency channel is discarded.

[ascl:1907.016]
astrodendro: Astronomical data dendrogram creator

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

[ascl:1907.015]
TurbuStat: Turbulence statistics in spectral-line data cubes

Koch, Eric W.; Rosolowsky, Erik W.; Boyden, Ryan D.; Burkhart, Blakesley; Ginsburg, Adam; Loeppky, Jason L.; Offner, Stella S. R.

TurbuStat implements a variety of turbulence-based statistics described in the astronomical literature and defines distance metrics for each statistic to quantitatively compare spectral-line data cubes, as well as column density, integrated intensity, or other moment maps. The software can simulate observations of fractional Brownian Motion fields, including 2-D images and optically thin H I data cubes. TurbuStat also offers multicore fast-Fourier-transform support and provides a segmented linear model for fitting lines with a break point.

[ascl:1907.014]
sbpy: Small-body planetary astronomy

Mommert, Michael; Kelley, Michael S. P.; de Val-Borro, Miguel; Li, Jian-Yang; Guzman, Giannina; Sipőcz, Brigitta; Ďurech, Josef; Granvik, Mikael; Grundy, Will; Moskovitz, Nick; Penttilä, Antti; Samarasinha, Nalin

sbpy, an Astropy affiliated package, supplements functionality provided by Astropy (ascl:1304.002) with functions and methods that are frequently used for planetary astronomy with a clear focus on asteroids and comets. It offers access tools for various databases for orbital and physical data, spectroscopy analysis tools and models, photometry models for resolved and unresolved observations, ephemerides services, and other tools useful for small-body planetary astronomy.

[ascl:1907.013]
RVSpecFit: Radial velocity and stellar atmospheric parameter fitting

RVSpecFit determines radial velocities and stellar atmospheric parameters from spectra by direct pixel fitting by interpolated stellar templates. The code doesn't require spectrum normalization and can deal with non-flux calibrated spectra. RVSpecFit is able to fit multiple spectra simultaneously.

[ascl:1907.012]
molly: 1D astronomical spectra analyzer

molly analyzes 1D astronomical spectra. Its prime purpose is for handling large numbers of similar spectra (*e.g.,* time series spectroscopy), but it contains many of the standard operations used for normal spectrum analysis as well. It overlaps with the various similar programs such as dipso (ascl:1405.016) and has strengths (particularly for time series spectra) and weaknesses compared to them.

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

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

[ascl:1907.010]
OMNICAL: Redundant calibration code for low frequency radio interferometers

OMNICAL calibrates antennas in the redundant subset of the array. The code consists of two algorithms, a logarithmic method (logcal) and a linearized method (lincal). OMNICAL makes visibilities from physically redundant baselines agree with each other and also explicitly minimizes the variance within redundant visibilities.

[ascl:1907.009]
Plonk: Smoothed particle hydrodynamics data analysis and visualization

Plonk analyzes and visualizes smoothed particle hydrodynamics simulation data. It is built on the scientific Python ecosystem, including NumPy, Matplotlib, Cython, h5py, SymPy, and pandas. Plock's visualization module uses Splash (ascl:1103.004) to produce images using smoothed particle hydrodynamics interpolation. The code is modular and extendible, and can be scripted or used interactively.

[submitted]
Accretion Disk Radial Structure Models

A collection of radial structure models of various accretion disk solutions. Each model implements a common interface that gives the radial dependence of selected geometrical, physical and thermodynamic quantities of the accretion flow.

[ascl:1907.008]
Dewarp: Distortion removal and on-sky orientation solution for LBTI detectors

Dewarp constructs pipelines to remove distortion from a detector and find the orientation with true North. It was originally written for the LBTI LMIRcam detector, but is generalizable to any project with reference sources and/or an astrometric field paired with a machine-readable file of astrometric target locations.

[ascl:1907.007]
SPAM: Hu-Sawicki f(R) gravity imprints search

SPAM searches for imprints of Hu-Sawicki f(R) gravity on the rotation curves of the SPARC (Spitzer Photometry and Accurate Rotation Curves) sample using the MCMC sampler emcee (ascl:1303.002). The code provides attributes for inspecting the MCMC chains and translating names of parameters to indices. The SPAM package also contains plotting scripts.

[ascl:1907.006]
POCS: PANOPTES Observatory Control System

PANOPTES (Panoptic Astronomical Networked Observatories for a Public Transiting Exoplanets Survey) is a citizen science project for low cost, robotic detection of transiting exoplanets. POCS (PANOPTES Observatory Control System) is the main software driver for the PANOPTES telescope system, responsible for high-level control of the unit. POCS defines an Observatory class that automatically controls a commercially available equatorial mount, including image analysis and corresponding mount adjustment to obtain a percent-level photometric precision.

[ascl:1907.005]
SARA-PPD: Preconditioned primal-dual algorithm for radio-interferometric imaging

SARA-PPD is a proof of concept MATLAB implementation of an acceleration strategy for a recently proposed primal-dual distributed algorithm. The algorithm optimizes resolution by accounting for the correct noise statistics, leverages natural weighting in the definition of the minimization problem for image reconstruction, and optimizes sensitivity by enabling accelerated convergence through a preconditioning strategy incorporating sampling density information. This algorithm offers efficient processing of large-scale data sets that will be acquired by next generation radio-interferometers such as the Square Kilometer Array.

[ascl:1907.004]
pyGTC: Parameter covariance plots

pyGTC creates giant triangle confusogram (GTC) plots. Triangle plots display the results of a Monte-Carlo Markov Chain (MCMC) sampling or similar analysis. The recovered parameter constraints are displayed on a grid in which the diagonal shows the one-dimensional posteriors (and, optionally, priors) and the lower-left triangle shows the pairwise projections. Such plots are useful for seeing the parameter covariances along with the priors when fitting a model to data.

[ascl:1907.003]
pyuvdata: Pythonic interface to interferometric data sets

pyuvdata defines a pythonic interface to interferometric data sets; it supports the development of and interchange of data between calibration and foreground subtraction pipelines. It can read and write MIRIAD (ascl:1106.007), uvfits, and uvh5 files and reads CASA (ascl:1107.013) measurement sets and FHD (Fast Holographic Deconvolution) visibility save files. Particular focus has been paid to supporting drift and phased array modes.

[ascl:1907.002]
healvis: Radio interferometric visibility simulator based on HEALpix maps

Healvis simulates radio interferometric visibility off of HEALPix shells. It generates a flat-spectrum and a GSM model and computes visibilities, and can simulates visibilities given an Observation Parameter YAML file. Healvis can perform partial frequency simulations in serial to minimize instantaneous memory loads.

[ascl:1907.001]
schwimmbad: Parallel processing pools interface

schwimmbad provides a uniform interface to parallel processing pools and enables switching easily between local development (e.g., serial processing or with multiprocessing) and deployment on a cluster or supercomputer (via, e.g., MPI or JobLib). The utilities provided by schwimmbad require that tasks or data be “chunked” and that code can be “mapped” onto the chunked tasks.

[ascl:1906.022]
pyLIMA: Microlensing modeling package

pyLIMA (python Lightcurve Identification and Microlensing Analysis) fits microlensing lightcurves and derives the physical quantities of lens systems. The package provides microlensing modeling, and the magnification estimation for high cadence lightcurves has been optimized. pyLIMA is designed to make microlensing modeling and event simulation widely available to the community.

[ascl:1906.021]
centerRadon: Center determination code in stellar images

centerRadon finds the center of stars based on Radon Transform 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:1906.020]
LIZARD: Particle initial conditions for cosmological simulations

LIZARD (Lagrangian Initialization of Zeldovich Amplitudes for Resimulations of Displacements) creates particle initial conditions for cosmological simulations using the Zel'dovich approximation for the matter and velocity power spectrum.

[ascl:1906.019]
PlasmaPy: Core Python package for plasma physics

PlasmaPy Community; Murphy, Nicholas A.; Stańczak, Dominik; Kozlowski, Pawel M.; Langendorf, Samuel J.; Leonard, Andrew J.; Beckers, Jasper P.; Haggerty, Colby C.; Mumford, Stuart J.; Malhotra, Ritiek; Bessi, Ludovico; Carroll, Sean; Choubey, Apoorv; Díaz Pérez, Roberto; Einhorn, Leah; Fan, Thomas; Goudeau, Graham; Guidoni, Silvina; Hillairet, Julien; How, Poh Zi; Huang, Yi-Min; Humphrey, Nabil; Isupova, Maria; Kulshrestha, Siddharth; Kuszaj, Piotr; Munn, Joshua; Parashar, Tulasi; Patel, Neil; Raj, Raajit; Sherpa, Dawa Nurbu; Stansby, David; Tavant, Antoine; Xu, Sixue

PlasmaPy provides core functionality and a common framework for data visualization and analysis for plasma physics. It has modules for basic plasma physics calculations, running desktop-scale simulations to test preliminary ideas such as one-dimensional MHD/PIC or test particles, or comparing data from two different sources, such as simulations and spacecraft.

[ascl:1906.018]
MEGAlib: Medium Energy Gamma-ray Astronomy library

The Medium Energy Gamma-ray Astronomy library (MEGAlib) simulates, calibrates, and analyzes data of hard X-ray and gamma-ray detectors, with a specialization on Compton telescopes. The library comprises all necessary data analysis steps for these telescopes, from simulation/measurements via calibration, event reconstruction to image reconstruction.

MEGAlib contains a geometry and detector description tool for the detailed modeling of different detector types and characteristics, and provides an easy to use simulation program based on Geant4 (ascl:1010.079). For different Compton telescope detector types (electron tracking, multiple Compton or time of flight based), specialized Compton event reconstruction algorithms are implemented in different approaches (Chi-square and Bayesian). The high level data analysis tools calculate response matrices, perform image deconvolution (specialized in list-mode-likelihood-based Compton image reconstruction), determine detector resolutions and sensitivities, retrieve spectra, and determine polarization modulations.

[ascl:1906.017]
mcfit: Multiplicatively Convolutional Fast Integral Transforms

mcfit computes integral transforms, inverse transforms without analytic inversion, and integral kernels as derivatives. It can also transform input array along any axis, output the matrix form, an is easily extensible for other kernels.

[ascl:1906.016]
PandExo: Instrument simulations for exoplanet observation planning

Batalha, Natasha E.; Mandell, Avi; Pontoppidan, Klaus; Stevenson, Kevin B.; Lewis, Nikole K.; Kalirai, Jason; Earl, Nick; Greene, Thomas; Albert, Loïc; Nielsen, Louise D.

PandExo generates instrument simulations of JWST’s NIRSpec, NIRCam, NIRISS and NIRCam and HST WFC3 for planning exoplanet observations. It uses throughput calculations from STScI’s Exposure Time Calculator, Pandeia, and offers both an online tool and a python package.

[ascl:1906.015]
OIT: Nonconvex optimization approach to optical-interferometric imaging

In the context of optical interferometry, only undersampled power spectrum and bispectrum data are accessible, creating an ill-posed inverse problem for image recovery. Recently, a tri-linear model was proposed for monochromatic imaging, leading to an alternated minimization problem; in that work, only a positivity constraint was considered, and the problem was solved by an approximated Gauss–Seidel method.

The Optical-Interferometry-Trilinear code improves the approach on three fundamental aspects. First, the estimated image is defined as a solution of a regularized minimization problem, promoting sparsity in a fixed dictionary using either an l1 or a (re)weighted-l1 regularization term. Second, the resultant non-convex minimization problem is solved using a block-coordinate forward–backward algorithm. This algorithm is able to deal both with smooth and non-smooth functions, and benefits from convergence guarantees even in a non-convex context. Finally, the model and algorithm are generalized to the hyperspectral case, promoting a joint sparsity prior through an l2,1 regularization term.

[ascl:1906.014]
GPUVMEM: Maximum Entropy Method (MEM) GPU algorithm for radio astronomical image synthesis

Cárcamo, Miguel; Muñoz, Nicolás; Rannou, Fernando; Román, Pablo; Casassus, Simón; Osses, Axel; Moral, Victor

The maximum entropy method (MEM) is a well known deconvolution technique in radio-interferometry. This method solves a non-linear optimization problem with an entropy regularization term. Other heuristics such as CLEAN are faster but highly user dependent. Nevertheless, MEM has the following advantages: it is unsupervised, it has a statistical basis, it has a better resolution and better image quality under certain conditions. GPUVMEM presents a high performance GPU version of non-gridding MEM.

[ascl:1906.013]
MORPHEUS: A 3D Eulerian Godunov MPI-OpenMP hydrodynamics code with multiple grid geometries

MORPHEUS (Manchester Omni-geometRical Program for Hydrodynamical EUlerian Simulations) is a 3D hydrodynamical code used to simulate astrophysical fluid flows. It has three different grid geometries (cartesian, spherical, and cylindrical) and uses a second-order Godunov method to solve the equations of hydrodynamics. Physical modules also include radiative cooling and gravity, and a hybrid MPI-OpenMP parallelization allows computations to be run on large-scale architectures. MORPHEUS is written in Fortran90 and does not require any libraries (apart from MPI) to run.

[ascl:1906.012]
Morpheus: Library to generate morphological semantic segmentation maps of astronomical images

Morpheus generates pixel level morphological classifications of astronomical sources by leveraging advances in deep learning to perform source detection, source segmentation, and morphological classification pixel-by-pixel via a semantic segmentation algorithm adopted from the field of computer vision. By utilizing morphological information about the flux of real astronomical sources during object detection, Morpheus shows resiliency to false positive identifications of sources.

[ascl:1906.011]
Lizard: An extensible Cyclomatic Complexity Analyzer

Lizard is an extensible Cyclomatic Complexity Analyzer for imperative programming languages including C/C++/C#, Python, Java, and Javascript. It counts the nloc (lines of code without comments) and CCN (cyclomatic complexity number), and takes a token count of functions and a parameter count of functions. It also does copy-paste detection (code clone detection/code duplicate detection) and many other forms of static code analysis. Lizard is often used in software-related research and calculates how complex the code looks rather than how complex the code really is; thought it's often very hard to get all the included folders and files right when they are complicated, that accuracy is not needed to determine cyclomatic complexity, which can be useful for measuring the maintainability of a software package.

[ascl:1906.010]
PyA: Python astronomy-related packages

Czesla, Stefan; Schröter, Sebastian; Schneider, Christian P.; Huber, Klaus F.; Pfeifer, Fabian; Andreasen, Daniel T.; Zechmeister, Mathias

The PyA (PyAstronomy) suite of astronomy-related packages includes a convenient fitting package that provides support for minimization and MCMC sampling, a set of astrophysical models (*e.g.*, transit light-curve modeling), and algorithms for timing analysis such as the Lomb-Scargle and the Generalized Lomb-Scargle periodograms.

[ascl:1906.009]
PyMORESANE: Python MOdel REconstruction by Synthesis-ANalysis Estimators

PyMORESANE is a Python and pyCUDA-accelerated implementation of the MORESANE deconvolution algorithm, a sparse deconvolution algorithm for radio interferometric imaging. It can restore diffuse astronomical sources which are faint in brightness, complex in morphology and possibly buried in the dirty beam’s side lobes of bright radio sources in the field.

[ascl:1906.008]
T-RECS: Tiered Radio Extragalactic Continuum Simulation

Bonaldi, Anna; Bonato, Matteo; Galluzzi, Vincenzo; Harrison, Ian; Massardi, Marcella; Kay, Scott; De Zotti, Gianfranco; Brown, Michael L.

T-RECS produces radio sources catalogs with user-defined frequencies, area and depth. It models two main populations of radio galaxies, Active Galactic Nuclei (AGNs) and Star-Forming Galaxies (SFGs), and corresponding sub-populations. T-RECS is not computationally demanding and can be run multiple times, using the same catalog inputs, to project the simulated sky onto different fields.

[ascl:1906.007]
limb-darkening: Limb-darkening coefficients generator

Limb-darkening generates limb-darkening coefficients from ATLAS and PHOENIX model atmospheres using arbitrary response functions. The code uses PyFITS (ascl:1207.009) and has several other dependencies, and produces a folder of results with descriptions of the columns contained in each file.

[ascl:1906.006]
turboSETI: Python-based SETI search algorithm

TurboSETI analyzes filterbank data (frequency vs. time) for narrow band drifting signals; its main purpose is to search for signals of extraterrestrial origin. TurboSETI can search the data for hundreds of drift rates (in Hz/sec) and handles either .fil or .h5 file formats. It has several dependencies, including Blimpy (ascl:1906.002) and Astropy (ascl:1304.002).

[ascl:1906.005]
Kalman: Forecasts and interpolations for ALMA calibrator variability

Kalman models an inhomogeneous time series of measurements at different frequencies as noisy sampling from a finite mixture of Gaussian Ornstein-Uhlenbeck processes to try to reproduce the variability of the fluxes and of the spectral indices of the quasars used as calibrators in the Atacama Large Millimeter/Sub-millimeter Array (ALMA), assuming sensible parameters are provided to the model (obtained, for example, from maximum likelihood estimation). One routine in the Kalman Perl module calculates best forecast estimations based on a state space representation of the stochastic model using Kalman recursions, and another routine calculates the smoothed estimation (or interpolations) of the measurements and of the state space also using Kalman recursions. The code does not include optimization routines to calculate best fit parameters for the stochastic processes.

[ascl:1906.004]
The Exo-Striker: Transit and radial velocity interactive fitting tool for orbital analysis and N-body simulations

The Exo-Striker analyzes exoplanet orbitals, performs N-body simulations, and models the RV stellar reflex motion caused by dynamically interacting planets in multi-planetary systems. It offers a broad range of tools for detailed analysis of transit and Doppler data, including power spectrum analysis for Doppler and transit data; Keplerian and dynamical modeling of multi-planet systems; MCMC and nested sampling; Gaussian Processes modeling; and a long-term stability check of multi-planet systems. The Exo-Striker can also analyze Mean Motion Resonance (MMR) analysis, create fast fully interactive plots, and export ready-to-use LaTeX tables with best-fit parameters, errors, and statistics. It combines Fortran efficiency and Python flexibility and is cross-platform compatible (MAC OS, Linux, Windows). The tool relies on a number of open-source packages, including RVmod engine, emcee (ascl:1303.002), batman (ascl:1510.002), celerite (ascl:1709.008), and dynesty (ascl:1809.013).

[ascl:1906.003]
FREDDA: A fast, real-time engine for de-dispersing amplitudes

FREDDA detects Fast Radio Bursts (FRBs) in power data. It is optimized for use at ASKAP, namely GHz frequencies with 10s of beams, 100s of channels and millisecond integration times. The code is written in CUDA for NVIDIA Graphics Processing Units.

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

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

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

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

[submitted]
Sacc: Save All Correlations and Covariances

Zuntz, J.; Slosar, A.; Alonso, D.; Becker, M.; Broussard, A.; McClintock, T.; Nicola, A.; Miyatake, H.; Sanchez, J.; Neveu, J.

SACC (Save All Correlations and Covariances) is a format and reference library for general storage

of summary statistic measurements for the Dark Energy Science Collaboration (DESC) within and from the Large Synoptic Survey Telescope (LSST) project's Dark Energy Science Collaboration.

[submitted]
HaloAnalysis

HaloAnalysis reads and analyzes halo/galaxy catalogs, generated from Rockstar (ascl:1210.008) or AHF (ascl:1102.009), and merger trees generated from Consistent Trees (ascl:1210.011). Written in Python 3, it offers the following functionality: reads halo/galaxy/tree catalogs from multiple file formats; assigns baryonic particles and properties to dark-matter halos; combines and re-generates halo/galaxy/tree files in hdf5 format; analyzes properties of halos/galaxies; selects halos to generate zoom-in initial conditions. Includes a Jupyter notebook tutorial.

[submitted]
GizmoAnalysis: read and analyze Gizmo simulations

GizmoAnalysis reads and analyzes N-body simulations run with the Gizmo code (ascl:1410.003). Written in Python 3, we developed it primarily to analyze FIRE simulations, though it is useable with any Gizmo snapshot files. It offers the following functionality: reads snapshot files and converts particle data to physical units; provides a flexible dictionary class to store particle data and compute derived quantities on the fly; plots images and properties of particles; generates region files for input to MUSIC (ascl:1311.011) to generate cosmological zoom-in initial conditions; computes rates of supernovae and stellar winds, including their nucleosynthetic yields, as used in FIRE simulations. Includes a Jupyter notebook tutorial.

[ascl:1905.027]
PyPDR: Python Photo Dissociation Regions

PyPDR calculates the chemistry, thermal balance and molecular excitation of a slab of gas under FUV irradiation in a self-consistent way. The effect of FUV irradiation on the chemistry is that molecules get photodissociated and the gas is heated up to several 1000 K, mostly by the photoelectric effect on small dust grains or UV pumping of H2 followed by collision de-excitation. The gas is cooled by molecular and atomic lines, thus indirectly the chemical composition also affects the thermal structure through the abundance of molecules and atoms. To find a self-consistent solution between heating and cooling, the code iteratively calculates the chemistry, thermal-balance and molecular/atomic excitation.

[ascl:1905.026]
SEDPY: Modules for storing and operating on astronomical source spectral energy distribution

SEDPY performs a variety of tasks for astronomical spectral energy distributions. It can generate synthetic photometry through any filter, provides detailed modeling of extinction curves, and offers basic aperture photometry algorithms. SEDPY can also store and interpolate model SEDs, convolve absolute or apparent fluxes, and calculate rest-frame magnitudes.

[ascl:1905.025]
Prospector: Stellar population inference from spectra and SEDs

Prospector conducts principled inference of stellar population properties from photometric and/or spectroscopic data. The code combine photometric and spectroscopic data rigorously using a flexible spectroscopic calibration model and infer high-dimensional stellar population properties using parameteric SFHs (with ensemble MCMC sampling). Prospector also constrains the linear combination of stellar population components that are present in a galaxy (e.g. non-parametric SFHs) using spectra and/or photometry, and fits individual stellar spectra using large interpolated grids.

[ascl:1905.024]
SICON: Stokes Inversion based on COnvolutional Neural networks

SICON (Stokes Inversion based on COnvolutional Neural networks) provides a three-dimensional cube of thermodynamical and magnetic properties from the interpretation of two-dimensional maps of Stokes profiles by use of a convolutional neural network. In addition to being much faster than parallelized inversion codes, SICON, when trained on synthetic Stokes profiles from two numerical simulations of different structures of the solar atmosphere, also provided a three-dimensional view of the physical properties of the region of interest in geometrical height, and pressure and Wilson depression properties that are decontaminated from the blurring effect of instrumental point spread functions.

[ascl:1905.023]
CASI-2D: Convolutional Approach to Shell Identification - 2D

CASI-2D (Convolutional Approach to Shell Identification) identifies stellar feedback signatures using data from magneto-hydrodynamic simulations of turbulent molecular clouds with embedded stellar sources and deep learning techniques. Specifically, a deep neural network is applied to dense regression and segmentation on simulated density and synthetic 12 CO observations to identify shells, sometimes referred to as "bubbles," and other structures of interest in molecular cloud data.

[ascl:1905.022]
ClusterPyXT: Galaxy cluster pipeline for X-ray temperature maps

ClusterPyXT (Cluster Pypeline for X-ray Temperature maps) creates X-ray temperature maps, pressure maps, surface brightness maps, and density maps from X-ray observations of galaxy clusters to show turbulence, shock fronts, nonthermal phenomena, and the overall dynamics of cluster mergers. It requires CIAO (ascl:1311.006) and CALDB. The code analyzes archival data and provides capability for integrating additional observations into the analysis. The ClusterPyXT code is general enough to analyze data from other sources, such as galaxies, active galactic nuclei, and supernovae, though minor modifications may be necessary.

[ascl:1905.021]
ODEPACK: Ordinary differential equation solver library

ODEPACK solves for the initial value problem for ordinary differential equation systems. It consists of nine solvers, a basic solver called LSODE and eight variants of it: LSODES, LSODA, LSODAR, LSODPK, LSODKR, LSODI, LSOIBT, and LSODIS. The collection is suitable for both stiff and nonstiff systems. It includes solvers for systems given in explicit form, dy/dt = f(t,y), and also solvers for systems given in linearly implicit form, A(t,y) dy/dt = g(t,y). The ODEPACK solvers are written in standard Fortran and there are separate double and single precision versions. Each solver consists of a main driver subroutine having the same name as the solver and some number of subordinate routines. For each solver, there is also a demonstration program, which solves one or two simple problems in a somewhat self-checking manner.

[ascl:1905.020]
NAPLES: Numerical Analysis of PLanetary EncounterS

NAPLES (Numerical Analysis of PLanetary EncounterS) performs batch propagations of close encounters in the three-body problem and computes the numerical error with respect to reference trajectories computed in quadruple precision. It uses the LSODAR integrator from ODEPACK (ascl:1905.021) and the equations of motion correspond to several regularized formulations.

[ascl:1905.019]
PICASO: Planetary Intensity Code for Atmospheric Scattering Observations

PICASO (Planetary Intensity Code for Atmospheric Scattering Observations), written in Python, computes the reflected light of exoplanets at any phase geometry using direct and diffuse scattering phase functions and Raman scattering spectral features.

[ascl:1905.018]
THALASSA: Orbit propagator for near-Earth and cislunar space

THALASSA (Tool for High-Accuracy, Long-term Analyses for SSA) propagates orbits for bodies in the Earth-Moon-Sun system. Written in Fortran, it integrates either Newtonian equations in Cartesian coordinates or regularized equations of motion with the LSODAR (Livermore Solver for Ordinary Differential equations with Automatic Root-finding). THALASSA is a command-line tool; the repository also includes some Python3 scripts to perform batch propagations.

[ascl:1905.017]
LensQuEst: CMB Lensing QUadratic Estimator

LensQuEst forecasts the signal-to-noise of CMB lensing estimators (standard, shear-only, magnification-only), generates mock maps, lenses them, and applies various lensing estimators to them. It can manipulate flat sky maps in various ways, including FFT, filtering, power spectrum, generating Gaussian random field, and applying lensing to a map, and evaluate these estimators on flat sky maps.

[ascl:1905.016]
LensCNN: Gravitational lens detector

The LensCNN (Convolutional Neural Network) identifies images containing gravitational lensing systems after being trained and tested on simulated images, recovering most systems that are identifiable by eye.

[ascl:1905.015]
rPICARD: Radboud PIpeline for the Calibration of high Angular Resolution Data

rPICARD (Radboud PIpeline for the Calibration of high Angular Resolution Data) reduces data from different VLBI arrays, including high-frequency and low-sensitivity arrays, and supports continuum, polarization, and phase-referencing observations. Built on the CASA (ascl:1107.013) framework, it uses CASA for CLEAN imaging and self-calibration, and can be run non-interactively after only a few non-default input parameters are set. rPICARD delivers high-quality calibrated data and large bandwidth data can be processed within reasonable computing times.

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

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

[ascl:1905.013]
SPARK: K-band Multi Object Spectrograph data reduction

SPARK (Software Package for Astronomical Reduction with KMOS) reduces data from the K-band Multi Object Spectrograph (KMOS) for the VLT. In many cases, science data can be processed using a single recipe; alternately, all functions this recipe provides can be performed using other recipes provided as tools. Among the functions the recipes provide are sky subtraction, cube reconstruction with the application of flexure corrections, dividing out the telluric spectrum, applying an illumination correction, aligning the cubes, and then combinging them. The result is a set of files which contain the combined datacube and associated noise cube for each of the 24 integral field unit (IFUs). The pipeline includes simple error propagation.

[ascl:1905.012]
Fitsverify: FITS file format-verification tool

Fitsverify rigorously checks whether a FITS (Flexible Image Transport System) data file conforms to the requirements defined in Version 3.0 of the FITS Standard document; it is a standalone version of the ftverify and fverify tasks that are distributed as part of the ftools (ascl:9912.002) software package. The source code must be compiled and linked with the CFITSIO (ascl:1010.001) library. An interactive web is also available that can verify the format of any FITS data file on a local computer or on the Web.

[ascl:1905.011]
Fermitools: Fermi Science Tools

Fermi Science Tools is a suite of tools for the analysis of both the Large-Area Telescope (LAT) and the Gamma-ray Burst Monitor (GBM) data, including point source analysis for generating maps, spectra, and light curves, pulsar timing analysis, and source identification.

[ascl:1905.010]
FastPM: Scaling N-body Particle Mesh solver

FastPM solves the gravity Possion equation with a boosted particle mesh. Arbitrary time steps can be used. The code is intended to study the formation of large scale structure and supports plain PM and Comoving-Lagranian (COLA) solvers. A broadband correction enforces the linear theory model growth factor at large scale. FastPM scales extremely well to hundred thousand MPI ranks, which is possible through the use of the PFFT Fourier Transform library. The size of mesh in FastPM can vary with time, allowing one to use coarse force mesh at high redshift with increase temporal resolution for accurate large scale modes. The code supports a variety of Greens function and differentiation kernels, though for most practical simulations the choice of kernels does not make a difference. A parameter file interpreter is provided to validate and execute the configuration files without running the simulation, allowing creative usages of the configuration files.

[ascl:1905.009]
HAOS-DIPER: HAO Spectral Diagnostic Package For Emitted Radiation

HAOS-DIPER works with and manipulates data for neutral atoms and atomic ions to understand radiation emitted by some space plasmas, notably the solar atmosphere and stellar atmospheres. HAOS-DIPER works with quantum numbers for atomic levels, enabling it to perform tasks otherwise difficult or very tedious, including a variety of data checks, calculations based upon the atomic numbers, and searching and manipulating data based upon these quantum numbers. HAOS-DIPER handles conditions from LTE to coronal-like conditions, in a manner controlled by one system variable !REGIME, and has some capability for estimating data for which no accurate parameters are available and for accounting for the effects of missing atomic levels.

[ascl:1905.008]
Q3C: A PostgreSQL package for spatial queries and cross-matches of large astronomical catalogs

Q3C (Quad Tree Cube) enables fast cone, ellipse and polygonal searches and cross-matches between large astronomical catalogs inside a PostgreSQL database. The package supports searches even if objects have proper motions.

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

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

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

[submitted]
MiraPy: Python package for Deep Learning in Astronomy

MiraPy is a Python package for problem-solving in astronomy using Deep Learning for astrophysicist, researchers and students. Current applications of MiraPy are X-Ray Binary classification, ATLAS variable star feature classification, OGLE variable star light-curve classification, HTRU1 dataset classification and Astronomical image reconstruction using encoder-decoder network. It also contains modules for loading various datasets, curve-fitting, visualization and other utilities. It is built using Keras for developing ML models to run on CPU and GPU seamlessly.

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

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

[ascl:1905.005]
MMIRS-DRP: MMIRS Data Reduction Pipeline

The MMIRS data reduction pipeline provides complete and flexible data reduction for long-slit and multi-slit spectroscopic observations collected using the MMT and Magellan Infrared Spectrograph (MMIRS). Written in IDL, it offers sky subtraction, correction for telluric absorpition, and is fast enough to permit real-time data reduction for quality control.

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

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

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

[ascl:1905.003]
evolstate: Assign simple evolutionary states to stars

evolstate assigns crude evolutionary states (main-sequence, subgiant, red giant) to stars given an input temperature and radius/surface gravity, based on physically motivated boundaries from solar metallicity interior models.

[ascl:1905.002]
Py4CAtS: PYthon for Computational ATmospheric Spectroscopy

Py4CAtS (PYthon scripts for Computational ATmospheric Spectroscopy) implements the individual steps of an infrared or microwave radiative transfer computation in separate scripts (and corresponding functions) to extract lines of relevant molecules in the spectral range of interest, compute line-by-line cross sections for given pressure(s) and temperature(s), combine cross sections to absorption coefficients and optical depths, and integrate along the line-of-sight to transmission and radiance/intensity. The code is a Python re-implementation of the Fortran code GARLIC (Generic Atmospheric Radiation Line-by-line Code) and uses the Numeric/Scientific Python modules for computationally-intensive highly optimized array-processing. Py4CAtS can be used in the console/terminal, inside the (I)Python interpreter, and in Jupyter notebooks.

[ascl:1905.001]
Grizli: Grism redshift and line analysis software

Grizli produces quantitative and comprehensive modeling and fitting of slitless spectroscopic observations, which typically involve overlapping spectra of hundreds or thousands of objects in exposures taken with one or more separate grisms and at multiple dispersion position angles. This type of analysis provides complete and uniform characterization of the spectral properties (e.g., continuum shape, redshifts, line fluxes) of all objects in a given exposure taken in the slitless spectroscopic mode.

[ascl:1904.030]
nudec_BSM: Neutrino Decoupling Beyond the Standard Model

nudec_BSM uses a simplified approach to solve for the neutrino decoupling, allowing one to capture the time dependence of the process while accounting for all possible interactions that can alter it.

[ascl:1904.029]
JVarStar: Variable Star Analysis Library

JVarStar (Java Variable Star Analysis) performs pattern classification by analyzing variable star data. This all-in-one library package includes machine learning techniques, fundamental mathematical methods, and digital signal processing functions that can be externally referenced (i.e., from Python), or can be used for further Java development. This library has dependencies on several open source packages that, along with the developed functionality, provides a developer with an easily accessible library from which to construct stable variable star analysis and classification code.

[ascl:1904.028]
covdisc: Disconnected covariance of 2-point functions in large-scale structure of the Universe

covdisc computes the disconnected part of the covariance matrix of 2-point functions in large-scale structure studies, accounting for the survey window effect. This method works for both power spectrum and correlation function, and applies to the covariances for various probes including the multi- poles and the wedges of 3D clustering, the angular and the projected statistics of clustering and lensing, as well as their cross covariances.

[ascl:1904.027]
nbodykit: Massively parallel, large-scale structure toolkit

nbodykit provides algorithms for analyzing cosmological datasets from N-body simulations and large-scale structure surveys, and takes advantage of the abundance and availability of large-scale computing resources. The package provides a unified treatment of simulation and observational datasets by insulating algorithms from data containers, and reduces wall-clock time by scaling to thousands of cores. All algorithms are parallel and run with Message Passing Interface (MPI); the code is designed to be deployed on large super-computing facilities. nbodykit offers an interactive user interface that performs as well in a Jupyter notebook as on super-computing machines.

[ascl:1904.026]
pyRSD: Accurate predictions for the clustering of galaxies in redshift-space in Python

pyRSD computes the theoretical predictions of the redshift-space power spectrum of galaxies. It also includes functionality for fitting data measurements and finding the optimal model parameters, using both MCMC and nonlinear optimization techniques.

[ascl:1904.025]
Properimage: Image coaddition and subtraction

Properimage processes astronomical image; it is specially written for coaddition and image subtraction. It performs the statistical proper-coadd of several images using a spatially variant PSF estimation, and also difference image analysis by several strategies developed by others. Most of the code is based on a class called SingleImage, which provides methods and properties for image processing such as PSF determination.

[ascl:1904.024]
OoT: Out-of-Transit Light Curve Generator

OoT (Out-of-Transit) calculates the light curves and radial velocity signals due to a planet orbiting a star. It explicitly models the effects of tides, orbital motion. relativistic beaming, and reflection of the stars light by the planet. The code can also be used to model secondary eclipses.

[ascl:1904.023]
digest2: NEO binary classifier

Keys, Sonia; Vereš, Peter; Payne, Matthew J.; Holman, Matthew J.; Jedicke, Robert; Williams, Gareth V.; Spahr, Tim; Asher, David J.; Hergenrother, Carl

digest2 classifies Near-Earth Object (NEO) candidates by providing a score, *D _{2}*, that represents a pseudo-probability that a tracklet belongs to a given solar system orbit type. The code accurately and precisely distinguishes NEOs from non-NEOs, thus helping to identify those to be prioritized for follow-up observation. This fast, short-arc orbit classifier for small solar system bodies code is built upon the Pangloss code developed by Robert McNaught and further developed by Carl Hergenrother and Tim Spahr and Robert Jedicke's 223.f code.

[ascl:1904.022]
eleanor: Extracted and systematics-corrected light curves for TESS-observed stars

Feinstein, Adina D.; Montet, Benjamin T.; Foreman-Mackey, Daniel; Bedell, Megan E.; Saunders, Nicholas; Bean, Jacob L.; Christiansen, Jessie L.; Hedges, Christina; Luger, Rodrigo; Scolnic, Daniel; Cardoso, Jose Vinicius de Miranda

eleanor extracts target pixel files from TESS Full Frame Images and produces systematics-corrected light curves for any star observed by the TESS mission. eleanor takes a TIC ID, a Gaia source ID, or (RA, Dec) coordinates of a star observed by TESS and returns, as a single object, a light curve and accompanying target pixel data. The process can be customized, allowing, for example, examination of intermediate data products and changing the aperture used for light curve extraction. eleanor also offers tools that make it easier to work with stars observed in multiple TESS sectors.

[ascl:1904.021]
TP2VIS: Total Power Map to Visibilities

TP2VIS creates visibilities from a single dish cube; the TP visibilities can be combined with the interferometric visibilities in a joint deconvolution using, for example, CASA's tclean() method. TP2VIS requires CASA 5.4 (ascl:1107.013) or above.

[ascl:1904.020]
SARAH: SUSY and non-SUSY model builder and analyzer

SARAH builds and analyzes SUSY and non-SUSY models. It calculates all vertices, mass matrices, tadpoles equations, one-loop corrections for tadpoles and self-energies, and two-loop RGEs for a given model. SARAH writes model files for a variety of other software packages for dark matter studies, includes many SUSY and non-SUSY models, and makes implementing new models efficient and straightforward. Written in Mathematica, SARAH can also use output from Vevacious (ascl:1904.019) to check for the global minimum for a given model and parameter point.

[ascl:1904.019]
Vevacious: Global minima of one-loop effective potentials generator

Vevacious takes a generic expression for a one-loop effective potential energy function and finds all the tree-level extrema, which are then used as the starting points for gradient-based minimization of the one-loop effective potential. The tunneling time from a given input vacuum to the deepest minimum, if different from the input vacuum, can be calculated. The parameter points are given as files in the SLHA format (though is not restricted to supersymmetric models), and new model files can be easily generated automatically by the Mathematica package SARAH (ascl:1904.020).

[ascl:1904.018]
Specstack: A simple spectral stacking tool

Specstack creates stacked spectra using a simple algorithm with sigma-clipping to combine the spectra of galaxies in the rest-frame into a single averaged spectrum. Though written originally for galaxy spectra, it also works for other types of objects. It is written in Python and is started from the command-line.

[ascl:1904.017]
dfitspy: A dfits/fitsort implementation in Python

dfitspy searches and displays metadata contained in FITS files. Written in Python, it displays the results of a metadata search and is able to grep certain values of keywords inside large samples of files in the terminal. dfitspy can be used directly with the command line interface and can also be imported as a python module into other python code or the python interpreter.

[ascl:1904.016]
simuTrans: Gravity-darkened exoplanet transit simulator

simuTrans models transit light curves affected by gravity-darkened stars. The code defines a star on a grid by modeling the brightness of each point as blackbody emission, then sets a series of parameters and uses emcee (ascl:1303.002) to explore the posterior probability distribution for the remaining fitted parameters and determine their best-fit values.

[ascl:1904.015]
SBGAT: Small Bodies Geophysical Analysis Tool

SBGAT (Small Body Geophysical Analysis Tool) generates simulated data originating from small bodies shape models, combined with advanced shape-modification properties. It uses polyhedral shape models from which can be computed mass properties such as volume, center of mass, and inertia, synthetic observations such as lightcurves and radar, and which can be used within dynamical models, such as spherical harmonics and polyhedron gravity modeling. SBGAT can generate spherical harmonics expansions from constant-density polyhedra (and export them to JSON) and evaluate the spherical harmonics expansions. It can also generate YORP coefficients, multi-threaded Polyhedron Gravity Model gravity and potential evaluations, and synthetic light-curve and radar observations for single/primary asteroids.

SBGAT has two distinct packages: a dynamic library SBGAT Core that contains the data structure and algorithm backbone of SBGAT, and SBGAT Gui, which wraps the former inside a VTK, Qt user interface to facilitate user/data interaction. SBGAT Core can be used without the SBGAT Gui wrapper.

[ascl:1904.014]
rate: Reliable Analytic Thermochemical Equilibrium

rate computes thermochemical-equilibrium abundances for a H-C-N-O system with known pressure, temperature, and elemental abundances. The output abundances are H2O, CH4, CO, CO2, NH3, C2H2, C2H4, HCN, and N2, H2, H, and He.

[ascl:1904.013]
EightBitTransit: Calculate light curves from pixel grids

EightBitTransit calculates the light curve of any pixelated image transiting a star and inverts a light curve to recover the "shadow image" that produced it.

[ascl:1904.012]
CausticFrog: 1D Lagrangian Simulation Package

CausticFrog models the reaction of a system of orbiting particles to instantaneous mass loss. It applies to any spherically symmetric potential, and follows the radial evolution of shells of mass. CausticFrog tracks the inner and outer edge of each shell, whose radius evolves as a test particle. The amount of mass in each shell is fixed but multiple shells can overlap leading to higher densities.

[ascl:1904.011]
FortesFit: Flexible spectral energy distribution modelling with a Bayesian backbone

FortesFit efficiently explores and discriminates between various spectral energy distributions (SED) models of astronomical sources. The Python package adds Bayesian inference to a framework that is designed for the easy incorporation and relative assessment of SED models, various fitting engines, and a powerful treatment of priors, especially those that may arise from non-traditional wave-bands such as the X-ray or radio emission, or from spectroscopic measurements. It has been designed with particular emphasis for its scalability to large datasets and surveys.

[ascl:1904.010]
CLEAR: CANDELS Ly-alpha Emission at Reionization processing pipeline and library

Simons, Raymond; Estrada-Carpenter, Vicente; Gosmeyer, Catherine; Papovich, Casey; Momcheva, Ivelina

The CLEAR pipeline and library performs various tasks for the CANDELS Ly-alpha Emission at Reionization (CLEAR) experiment of deep Hubble grism observations of high-z galaxies. It interlaces images, models contamination of overlapping grism spectra, extracts source spectra, stacks the extracted source spectra, and estimates fits for sources redshifts and emission lines.

[ascl:1904.009]
deproject: Deprojection of two-dimensional annular X-ray spectra

Deproject extends Sherpa (ascl:1107.005) to facilitate deprojection of two-dimensional annular X-ray spectra to recover the three-dimensional source properties. For typical thermal models, this includes the radial temperature and density profiles. This basic method is used for X-ray cluster analysis and is the basis for the XSPEC (ascl:9910.005) model project. The deproject module is written in Python and is straightforward to use and understand. The basic physical assumption of deproject is that the extended source emissivity is constant and optically thin within spherical shells whose radii correspond to the annuli used to extract the specta. Given this assumption, one constructs a model for each annular spectrum that is a linear volume-weighted combination of shell models.

[ascl:1904.008]
repack: Repack and compress line-transition data

repack re-packs and compresses line-transition data for radiative-transfer calculations. It identifies the strong lines that dominate the spectrum from the large-majority of weaker lines, returning a binary line-by-line (LBL) file with the strong lines info (wavenumber, Elow, gf, and isotope ID), and an ASCII file with the combined contribution of the weaker lines compressed into a continuum extinction coefficient (in cm-1 amagat-1) as function of wavenumber and temperature.

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

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

[ascl:1904.006]
CDAWeb: Coordinated Data Analysis Web

CDAWeb (Coordinated Data Analysis Workshop Web) enables viewing essentially any data produced in Common Data Format/CDF with the ISTP/IACG Guidelines and supports interactive plotting of variables from multiple instruments on multiple investigations simultaneously on arbitrary, user-defined time-scales. It also supports data retrieval in both CDF or ASCII format. NASA's GSFC Space Physics Data Facility maintains a publicly available database that includes approximately 600 data variables from Geotail, Wind, Interball, Polar, SOHO, ancilliary spacecraft and ground-based investigations. CDAWeb includes high resolution digital data products that support event correlative science. The system combines the client-server user interface technology of the Web with a powerful set of customized routines based in the COTS Interactive Data Language (IDL) package to leverage the data format standards.

[ascl:1904.005]
SMILI: Sparse Modeling Imaging Library for Interferometry

Akiyama, Kazunori; Tazaki, Fumie; Moriyama, Kotaro; Cho, Ilje; Ikeda, Shiro; Sasada, Mahito; Okino, Hiroki; Honma, Mareki

SMILI uses sparse sampling techniques and other regularization methods for interferometric imaging. The python-interfaced library is mainly designed for very long baseline interferometry, and has been under the active development primarily for the Event Horizon Telescope (EHT).

[ascl:1904.004]
ehtim: Imaging, analysis, and simulation software for radio interferometry

Chael, Andrew A.; Bouman, Katherine L.; Johnson, Michael D.; Narayan, Ramesh; Doeleman, Sheperd S.; Wardle, John F. C.; Blackburn, Lindy L.; Akiyama, Kazunori; Wielgus, Maciek; Chan, Chi-kwan; Farah, Joseph R.; Palumbo, Daniel; Pesce, Dominic

ehtim (eht-imaging) simulates and manipulates VLBI data and produces images with regularized maximum likelihood methods. The package contains several primary classes for loading, simulating, and manipulating VLBI data. The main classes are the Image, Array, Obsdata, Imager, and Caltable classes, which provide tools for loading images and data, producing simulated data from realistic u-v tracks, calibrating, inspecting, and plotting data, and producing images from data sets in various polarizations using various data terms and regularizers.

[submitted]
SimCADO - An observations simulator for infrared telescopes and instruments

SimCADO is a python package which allows the user to simulate observations with any NIR/Vis imaging system. The package was originally designed to simulate images for the European extremely large telescope (ELT) and MICADO, however with the proper input it is capable of simulating observations from many different Telescope + Instrument configurations.

The documentation can be found here: https://simcado.readthedocs.io/en/latest/

[ascl:1904.003]
CGS: Collisionless Galactic Simulator

CGS (Collisionless Galactic Simulator) uses Fourier techniques to solve the Possion equation ∇^{2}Φ = 4πGρ, relating the mean potential Φ of a system to the mass density ρ. The angular dependence of the force is treated exactly in terms of the single-particle Legendre polynomials, which preserves accuracy and avoids systematic errors. The density is assigned to a radial grid by means of a cloud-in-cell scheme with a linear kernel, *i.e.*, a particle contributes to the density of the two closest cells with a weight depending linearly on the distance from the center of the cell considered. The same kernel is then used to assign the force from the grid to the particle. The time step is chosen adaptively in such a way that particles are not allowed to cross more than one radial cell during one step. CGS is based on van Albada's code (1982) and is distributed in the NEMO (ascl:1010.051) Stellar Dynamics Toolbox.

[ascl:1904.002]
GALAXY: N-body simulation software for isolated, collisionless stellar systems

GALAXY evolves (almost) isolated, collisionless stellar systems, both disk-like and ellipsoidal. In addition to the N-body code galaxy, which offers eleven different methods to compute the gravitational accelerations, the package also includes sophisticated set-up and analysis software. While not as versatile as tree codes, for certain restricted applications the particle-mesh methods in GALAXY are 50 to 200 times faster than a widely-used tree code. After reading in data providing the initial positions, velocities, and (optionally) masses of the particles, GALAXY compute the gravitational accelerations acting on each particle and integrates forward the velocities and positions of the particles for a short time step, repeating these two steps as desired. Intermediate results can be saved, as can the final moment in a state from which the integration could be resumed. Particles can have individual masses and their motion can be integrated using a range of time steps for greater efficiency; message-passing-interface (MPI) calls are available to enable GALAXY's use on parallel machines with high efficiency.

[ascl:1904.001]
sxrbg: ROSAT X-Ray Background Tool

The ROSAT X-Ray Background Tool (sxrbg) calculates the average X-ray background count rate and statistical uncertainty in each of the six standard bands of the ROSAT All-Sky Survey (RASS) diffuse background maps (R1, R2, R4, R5, R6, R7) for a specified astronomical position and a search region consisting of either a circle with a specified radius or an annulus with specified inner and outer radii centered on the position. The values returned by the tool are in units of 10^-6 counts/second/arcminute^2. sxrbg can also create a count-rate-based spectrum file which can be used with XSpec (ascl:9910.005) to calculate fluxes and offers support for counts statistics (cstat), an alternative method for generating a background spectrum. HEASoft (ascl:1408.004) is a prerequisite for building. The code is in the public domain.

[ascl:1903.017]
HelioPy: Heliospheric and planetary physics library

HelioPy provides a set of tools to download and read in data, and carry out other common data processing tasks for heliospheric and planetary physics. It handles a wide variety of solar and satellite data and builds upon the SpiceyPy package (ascl:1903.016) to provide an accessible interface for performing orbital calculations. It has also implemented a framework to perform transformations between some common coordinate systems.

[ascl:1903.016]
SpiceyPy: Python wrapper for the NAIF C SPICE Toolkit

Annex, Andrew; Carcich, Brian; Murakami, Shin-ya; Kulumani, Shankar; de Val-Borro, Miguel; Stefko, Marcel; Diaz del Rio, Jorge; Seignovert, B.

SpiceyPy is a Python wrapper for the NAIF C SPICE Toolkit (ascl:1903.015). It is compatible with Python 2 and 3, and was written using ctypes.

[ascl:1903.015]
SPICE: Observation Geometry System for Space Science Missions

The SPICE (Spacecraft Planet Instrument C-matrix [“Camera matrix”] Events) toolkit offers a set of building blocks for constructing tools supporting multi-mission, international space exploration programs and research in planetary science, heliophysics, Earth science, and for observations from terrestrial observatories. It computes many kinds of observation geometry parameters, including the ephemerides, orientations, sizes, and shapes of planets, satellites, comets and asteroids. It can also compute the orientation of a spacecraft, its various moving structures, and an instrument's field-of-view location on a planet's surface or atmosphere. It can determine when a specified geometric event occurs, such as when an object is in shadow or is in transit across another object. The SPICE toolkit is available in FORTRAN 77, ANSI C, IDL, and MATLAB.

[ascl:1903.014]
PLATON: PLanetary Atmospheric Transmission for Observer Noobs

PLATON (PLanetary Atmospheric Transmission for Observer Noobs) calculates transmission spectra for exoplanets and retrieves atmospheric characteristics based on observed spectra; it is based on ExoTransmit (ascl:1611.005). PLATON supports the most common atmospheric parameters, such as temperature, metallicity, C/O ratio, cloud-top pressure, and scattering slope. It also has less commonly included features, such as a Mie scattering cloud model and unocculted starspot corrections.

[ascl:1903.013]
NFWdist: Density, distribution function, quantile function and random generation for the 3D NFW profile

Available in R and Python, the simple analytic scheme NFWdist performs highly efficient and exact sampling of the Navarro, Frenk & White (NFW) profile as a true probability distribution function, with the only variable being the concentration.

[ascl:1903.012]
DAVE: Discovery And Vetting of K2 Exoplanets

Mullally, Fergal; Coughlin, Jeffrey; Mullally, Susan; Barclay, Thomas; Barentsen, Geert; Burke, Christopher J.; Colón, Knicole D.; Quintana, Elisa V.

DAVE implements a pipeline to find and vet planets planets using data from NASA's K2 mission. The pipeline contains several modules tailored to particular aspects of the vetting procedures, using photocenter analysis to rule out background eclipsing binaries and flux time-series analysis to rule out odd–even differences, secondary eclipses, low-S/N events, variability other than a transit, and size of the transiting object.

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

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

[ascl:1903.010]
GalIMF: Galaxy-wide Initial Mass Function

GalIMF (Galaxy-wide Initial Mass Function) computes the galaxy-wide initial stellar mass function by integrating over a whole galaxy, parameterized by star formation rate and metallicity. The generated stellar mass distribution depends on the galaxy-wide star formation rate (SFR, which is related to the total mass of a galalxy) and the galaxy-wide metallicity. The code can generate a galaxy-wide IMF (IGIMF) and can also generate all the stellar masses within a galaxy with optimal sampling (OSGIMF). To compute the IGIMF or the OSGIMF, the GalIMF module contains all local IMF properties (e.g. the dependence of the stellar IMF on the metallicity, on the density of the star-cluster forming molecular cloud cores), and this software module can, therefore, be also used to obtain only the stellar IMF with various prescriptions, or to investigate other features of the stellar population such as what is the most massive star that can be formed in a star cluster.

[ascl:1903.009]
PRF: Probabilistic Random Forest

PRF (Probabilistic Random Forest) is a machine learning algorithm for noisy datasets. The PRF is a modification of the long-established Random Forest (RF) algorithm, and takes into account uncertainties in the measurements (i.e., features) as well as in the assigned classes (i.e., labels). To do so, the Probabilistic Random Forest (PRF) algorithm treats the features and labels as probability distribution functions, rather than as deterministic quantities.

[ascl:1903.008]
NIFTy5: Numerical Information Field Theory v5

Arras, Philipp; Baltac, Mihai; Ensslin, Torsten A.; Frank, Philipp; Hutschenreuter, Sebastian; Knollmueller, Jakob; Leike, Reimar; Newrzella, Max-Niklas; Platz, Lukas; Reinecke, Martin; Stadler, Julia

NIFTy (Numerical Information Field Theory) facilitates the construction of Bayesian field reconstruction algorithms for fields being defined over multidimensional domains. A NIFTy algorithm can be developed for 1D field inference and then be used in 2D or 3D, on the sphere, or on product spaces thereof. NIFTy5 is a complete redesign of the previous framework (ascl:1302.013), and requires only the specification of a probabilistic generative model for all involved fields and the data in order to be able to recover the former from the latter. This is achieved via Metric Gaussian Variational Inference, which also provides posterior samples for all unknown quantities jointly.

[ascl:1903.007]
ICSF: Intensity Conserving Spectral Fitting

ICSF (Intensity Conserving Spectral Fitting) "corrects" (x,y) data in which the ordinate represents the average of a quantity over a finite interval in the abscissa. A typical example is spectral data, where the average intensity over a wavelength bin (the measured quantity) is assigned to the center of the bin. If the profile is curved, the average will be different from the discrete value at the bin center location. ICSF, written in IDL and available separately and as part of SolarSoft (ascl:1208.013), corrects the intensity using an iterative procedure and cubic spline. The corrected intensity equals the "true" intensity at bin center, rather than the average over the bin. Unlike other methods that are restricted to a single fitting function, typically a spline, ICSF can be used with any function, such as a cubic spline or a Gaussian, with slight changes to the code.

[ascl:1903.006]
SimSpin: Kinematic analysis of galaxy simulations

The R-package SimSpin measures the kinematics of a galaxy simulation as if it had been observed using an IFU. The functions included in the package can produce a kinematic data cube and measure the "observables" from this data cube, specifically the observable spin parameter λr. This package, once installed, is fully documented and tested.

[ascl:1903.005]
Galmag: Computation of realistic galactic magnetic fields

Galmag computes galactic magnetic fields based on mean field dynamo theory. Written in Python, Galmag allows quick exploration of solutions to the mean field dynamo equation based on galaxy parameters specified by the user, such as the scale height profile and the galaxy rotation curves. The magnetic fields are solenoidal by construction and can be helical.

[ascl:1903.004]
brutifus: Python module to post-process datacubes from integral field spectrographs

brutifus aids in post-processing datacubes from integral field spectrographs. The set of Python routines in the package handle generic tasks, such as the registration of a datacube WCS solution with the Gaia catalogue, the correction of Galactic reddening, or the subtraction of the nebular/stellar continuum on a spaxel-per-spaxel basis, with as little user interactions as possible. brutifus is modular, in that the order in which the post-processing routines are run is entirely customizable.

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

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

[ascl:1903.002]
SIXTE: Simulation of X-ray Telescopes

SIXTE simulates X-Ray telescope observation; the software performs instrument performance analyses and produces simulated event files for mission and analysis studies. SIXTE strives to find a compromise between exactness of the simulation and speed. Using calibration files such as the PSF, RMF and ARF makes efficient simulations possible at comparably high speed, even though they include nonlinear effects such as pileup. Setups for some current and future missions, such as XMM-Newton and Athena, are included in the package; others can be added by the user with relatively little effort through specifying the main instrument characteristics in a flexible, human-readable XML-based format. Properties of X-ray sources to be simulated are described in a detector-independent format, i.e., the same input can be used for simulating observations with all available instruments, and the same input can also be used for simulations with the SIMX simulator. The input files are easily generated from standard data such as XSPEC (ascl:9910.005) spectral models or FITS images with tools provided with the SIXTE distribution. The input data scale well from single point sources up to very complicated setups.

[ascl:1902.012]
Specutils: Spectroscopic analysis and reduction

Specutils provides a basic interface for the loading, manipulation, and common forms of analysis of spectroscopic data. Its generic data containers and accompanying modules can be used to build a particular scientific workflow or higher-level analysis tool. It is an AstroPy (ascl:1304.002) affiliated package, and SpecViz (ascl:1902.011), which is built on top of Specutils, provides a visual, interactive interface to its analysis capabilities.

[ascl:1902.011]
SpecViz: 1D Spectral Visualization Tool

SpecViz interactively visualizes and analyzes 1D astronomical spectra. It reads data from FITS and ASCII tables and allows spectra to be easily plotted and examined. It supports instrument-specific data quality handling, flexible spectral units conversions, custom plotting attributes, plot annotations, tiled plots, among other features. SpecViz includes a measurement tool for spectral lines for performing and recording measurements and a model fitting capability for creating simple (e.g., single Gaussian) or multi-component models (e.g., multiple Gaussians for emission and absorption lines in addition to regions of flat continua). SpecViz is built on top of the Specutils (ascl:1902.012) Astropy-affiliated python library, providing a visual, interactive interface to the analysis capabilities in that library.

[ascl:1902.010]
dyPolyChord: Super fast dynamic nested sampling with PolyChord

dyPolyChord implements dynamic nested sampling using the efficient PolyChord (ascl:1502.011) sampler to provide state-of-the-art nested sampling performance. Any likelihoods and priors which work with PolyChord can be used (Python, C++ or Fortran), and the output files produced are in the PolyChord format.

[ascl:1902.009]
ExPRES: Exoplanetary and Planetary Radio Emissions Simulator

ExPRES (Exoplanetary and Planetary Radio Emission Simulator) reproduces the occurrence of CMI-generated radio emissions from planetary magnetospheres, exoplanets or star-planet interacting systems in time-frequency plane, with special attention given to computation of the radio emission beaming at and near its source. Physical information drawn from such radio observations may include the location and dynamics of the radio sources, the type of current system leading to electron acceleration and their energy and, for exoplanetary systems, the magnetic field strength, the orbital period of the emitting body and the rotation period, tilt and offset of the planetary magnetic field. Most of these parameters can be remotely measured only via radio observations. ExPRES code provides the proper framework of analysis and interpretation for past (Cassini, Voyager, Galileo), current (Juno, ground-based radio telescopes) and future (BepiColombo, Juice) observations of planetary radio emissions, as well as for future detection of radio emissions from exoplanetary systems.

[ascl:1902.008]
Radynversion: Solar atmospheric properties during a solar flare

Radynversion infers solar atmospheric properties during a solar flare. The code is based on an Invertible Neural Network (INN) that is trained to learn an approximate bijective mapping between the atmospheric properties of electron density, temperature, and bulk velocity (all as a function of altitude), and the observed Hα and Ca II λ8542 line profiles. As information is lost in the forward process of radiation transfer, this information is injected back into the model during the inverse process by means of a latent space; the training allows this latent space to be filled using an n-dimensional unit Gaussian distribution, where n is the dimensionality of the latent space. The code is based on a model trained by simulations made by RADYN, a 1D non-equilibrium radiation hydrodynamic model with good optically thick radiation treatment that does not consider magnetic effects.

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

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

[ascl:1902.007]
PINT: High-precision pulsar timing analysis package

Luo, Jing; Ransom, Scott; Demorest, Paul; van Haasteren, Rutger; Ray, Paul; Stovall, Kevin; Bachetti, Matteo; Archibald, Anne; Kerr, Matthew; Colen, Jonathan; Jenet, Fredrick

PINT (PINT Is Not Tempo3) analyzes high-precision pulsar timing data, enabling interactive data analysis and providing an extensible and flexible development platform for timing applications. PINT utilizes well-debugged public Python packages and modern software development practices (e.g., the NumPy and Astropy libraries, version control and development with git and GitHub, and various types of testing) for increased development efficiency and enhanced stability. PINT has been developed and implemented completely independently from traditional pulsar timing software such as TEMPO (ascl:1509.002) and Tempo2 (ascl:1210.015) and is a robust tool for cross-checking timing analyses and simulating data.

[ascl:1902.006]
RPFITS: Routines for reading and writing RPFITS files

Norris, Ray; Calabretta, Mark; Wieringa, Mark; Hunt, A.J.; May, H.; Killeen, N.; Sault, R.; Wilson, Warwick; Kesteven, Michael

The RPFITS data file format records synthesis visibility data obtained from the Australia Telescope Compact Array (ATCA) at Narrabri, NSW. It is also used for single-dish spectral line data obtained from Parkes and Mopra, including Parkes multibeam data. RPFITS superficially resembles random group FITS, but differs in important respects, making it incompatible with standard FITS software such as FITSIO (ascl:1010.001) and FTOOLS (ascl:9912.002) and, in particular, it precludes the use of fv (ascl:1205.005). The RPFITS Fortran library contains routines for reading and writing RPFITS files. A header file, RPFITS.h, is provided to facilitate usage by C and C++ applications. Also included is rpfhdr, a utility for viewing RPFITS headers (it also works for standard FITS), and rpfex for extracting selected scans from an RPFITS file.

[ascl:1902.005]
LiveData: Data reduction pipeline

LiveData is a multibeam single-dish data reduction system for bandpass calibration and gridding. It is used for processing Parkes multibeam and Mopra data.

[ascl:1902.004]
GraviDy: Gravitational Dynamics

GraviDy performs N-body 3D visualizations; it is a GPU, direct-summation N-body integrator based on the Hermite scheme and includes relativistic corrections for sources of gravitational radiation. The software is modular, allowing users to readily introduce new physics, and exploits available computational resources. The software can be used in parallel on multiple CPUs and GPUs, with a considerable speed-up benefit. The single-GPU version is between one and two orders of magnitude faster than the single-CPU version.

[ascl:1902.003]
PyMF: Matched filtering techniques for astronomical images

PyMF performs spatial filtering (matched filter, matched multifilter, constrained matched filter and constrained matched mutifilter) image processing that provides optimal reduction of the contamination introduced by sources that can be approximated by templates. These techniques use the flat-sky approximation.

[ascl:1902.002]
LPNN: Limited Post-Newtonian N-body code for collisionless self-gravitating systems

The Limited Post-Newtonian N-body code (LPNN) simulates post-Newtonian interactions between a massive object and many low-mass objects. The interaction between one massive object and low-mass objects is calculated by post-Newtonian approximation, and the interaction between low-mass objects is calculated by Newtonian gravity. This code is based on the sticky9 code, and can be accelerated with the use of GPU in a CUDA (version 4.2 or earlier) environment.

[ascl:1902.001]
SNTD: Supernova Time Delays

Supernova Time Delays (SNTD) simulates and measures time delay of multiply-imaged supernovae, and offers an improved characterization of the uncertainty caused by microlensing. Lensing time delays can be determined by fitting the multiple light curves of these objects; measuring these delays provide precise tests of lens models or constraints on the Hubble constant and other cosmological parameters that are independent of the local distance ladder. Fitting the effects of microlensing without an accurate prior often leads to biases in the time delay measurement and over-fitting to the data; this can be mitigated by using a Gaussian Process Regression (GPR) technique to determine the uncertainty due to microlensing. SNTD can produce accurate simulations for wide-field time domain surveys such as LSST and WFIRST.

[ascl:1901.012]
stellarWakes: Dark matter subhalo searches using stellar kinematic data

stellarWakes uses stellar kinematic data to search for dark matter (DM) subhalos through their gravitational perturbations to the stellar phase-space distribution.

[ascl:1901.011]
Bilby: Bayesian inference library

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

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

[ascl:1901.010]
eddy: Extracting Disk DYnamics

The Python suite eddy recovers precise rotation profiles of protoplanetary disks from Doppler shifted line emission, providing an easy way to fit first moment maps and the inference of a rotation velocity from an annulus of spectra.

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

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

[ascl:1901.008]
SEDobs: Observational spectral energy distribution simulation

SEDobs uses state-of-the-art theoretical galaxy SEDs (spectral energy distributions) to create simulated observations of distant galaxies. It used BC03 and M05 theoretical models and allows the user to configure the simulated observation that are needed. For a given simulated galaxy, the user is able to simulate multi-spectral and multi-photometric observations.

[ascl:1901.007]
Photon: Python tool for data plotting

Photon makes simple 1D plots in python. It uses mainly matplotlib and PyQt5 and has been build to be fully customizable, allowing the user to change the fontstyle, fontsize, fontcolors, linewidth of the axes, thickness, and other parameters, and see the changes directly in the plot. Once a customization is created, it can be saved in a configuration file and reloaded for future use, allowing reuse of the customization for other plots. The main tool is a graphical user interface and it is started using a command line interface.

[ascl:1901.006]
ssos: Solar system objects detection pipeline

The ssos pipeline detects and identifies known and unknown Solar System Objects (SSOs) in astronomical images. ssos requires at least 3 images with overlapping field-of-views in the sky taken within a reasonable amount of time (*e.g.*, 2 hours, 1 night). SSOs are detected mainly by judging the apparent motion of all sources in the images. The pipeline serves as a wrapper for the SExtractor (ascl:1010.064) and SCAMP (ascl:1010.063) software suites and allows different source extraction strategies to be chosen. All sources in the images are subject to a highly configurable filter pipeline. ssos is a versatile, light-weight, and easy-to-use software for surveys or PI-observation campaigns lacking a dedicated SSO detection pipeline.

[ascl:1901.005]
Galaxia_wrap: Galaxia wrapper for generating mock stellar surveys

Galaxia_wrap is a python wrap around the popular Galaxia tool (ascl:1101.007) for generating mock stellar surveys, such as a magnitude limited survey, using a built-in Galaxy model or directly from n-body data. It also offers n-body functionality and has been used to infer the age distribution of a specific stellar tracer population.

[ascl:1901.004]
unwise_psf: PSF models for unWISE coadds

The unwise_psf Python module renders point spread function (PSF) models appropriate for use in modeling of unWISE coadd images. unwise_psf translates highly detailed single-exposure WISE PSF models in detector coordinates to the corresponding pixelized PSF models in coadd space, accounting for subtleties including the WISE scan direction and its considerable variation near the ecliptic poles. Applications of the unwise_psf module include performing forced photometry on unWISE coadds, constructing WISE-selected source catalogs based on unWISE coadds and masking unWISE coadd regions contaminated by bright stars.

[ascl:1901.003]
CCL: 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 Core Cosmology Library (CCL) computes basic cosmological observables and provides predictions 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. 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. Predictions for correlation functions of galaxy clustering, galaxy-galaxy lensing and cosmic shear are 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 written in C and has a python interface.

[ascl:1901.002]
OCFit: Python package for fitting of O-C diagrams

OCFit fits and analyzes O-C diagrams using Genetic Algorithms and Markov chain Monte Carlo methods. The MC method is used to determine a very good estimation of errors of the parameters. Unlike some other fitting routines, OCFit does not need any initial values of fitted parameters. An intuitive graphic user interface is provided for ease of fitting, and nine common models of periodic O-C changes are included.

[ascl:1901.001]
cFE: Core Flight Executive

The Core Flight Executive is a portable, platform-independent embedded system framework that is the basis for flight software for satellite data systems and instruments; cFE can be used on other embedded systems as well. The Core Flight Executive is written in C and depends on the software library Operating System Abstraction Layer (OSAL), which is available at https://sourceforge.net/projects/osal/.

[ascl:1812.018]
OctApps: Octave functions for continuous gravitational-wave data analysis

Wette, Karl; Prix, Reinhard; Keitel, David; Pitkin, Matthew; Dreissigacker, Christoph; Whelan, John T.; Leaci, Paola

The OctApps library provides various functions, written in Octave, for performing searches for the weak signatures of continuous gravitational waves from rapidly-rotating neutron stars amidst the instrumental noise of the LIGO and Virgo detectors.

[ascl:1812.017]
psrqpy: Python module to query the ATNF Pulsar Catalogue

psrqpy directly queries the Australia Telescope National Facility (ATNF) Pulsar Catalogue by downloading and parsing the full catalog database, which is cached and can be reused. The module assists astronomers who want access to the latest pulsar information via a script rather than through the standard web interface.

[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: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: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:1812.013]
Lightkurve: Kepler and TESS time series analysis in Python

Lightkurve Collaboration; Cardoso, José Vinícius de Miranda; Hedges, Christina; Gully-Santiago, Michael; Saunders, Nicholas; Cody, Ann Marie; Barclay, Thomas; Hall, Oliver; Sagear, Sheila; Turtelboom, Emma; Zhang, Johnny; Tzanidakis, Andy; Mighell, Ken; Coughlin, Jeff; Bell, Keaton; Berta-Thompson, Zach; Williams, Peter; Dotson, Jessie; Barentsen, Geert

Lightkurve analyzes astronomical flux time series data, in particular the pixels and light curves obtained by NASA’s Kepler, K2, and TESS exoplanet missions. This community-developed Python package is designed to be user friendly to lower the barrier for students, astronomers, and citizen scientists interested in analyzing data from these missions. Lightkurve provides easy tools to download, inspect, and analyze time series data and its documentation is supported by a large syllabus of tutorials.

[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: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:1812.010]
PynPoint 0.6.0: Pipeline for processing and analysis of high-contrast imaging data

PynPoint processes and analyzes high-contrast imaging data of exoplanets and circumstellar disks. The generic, end-to-end pipeline's modular architecture separates the core functionalities and the pipeline modules. These modules have specific tasks such as background subtraction, frame selection, centering, PSF subtraction with principal component analysis, estimation of detection limits, and photometric and astrometric analysis. All modules store their results in a central database. Management of the available hardware by the backend of the pipeline is in particular an advantage for data sets containing thousands of images, as is common in the mid-infrared wavelength regime. This version of PynPoint is a significant rewrite of the earlier PynPoint package (ascl:1501.001).

[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: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: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: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:1812.005]
SPAMCART: Smoothed PArticle Monte CArlo Radiative Transfer

SPAMCART generates synthetic spectral energy distributions and intensity maps from smoothed particle hydrodynamics simulation snapshots. It follows discrete luminosity packets as they propagate through a density field, and computes the radiative equilibrium temperature of the ambient dust from their trajectories. The sources can be extended and/or embedded, and discrete and/or diffuse. The density is not mapped on to a grid, and therefore the calculation is performed at exactly the same resolution as the hydrodynamics. The code strictly adheres to Kirchhoff's law of radiation. The algorithm is based on the Lucy Monte Carlo radiative transfer method and is fairly simple to implement, as it uses data structures that are already constructed for other purposes in modern particle codes

[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:1812.003]
PFANT: Stellar spectral synthesis code

PFANT computes a synthetic spectrum assuming local thermodynamic equilibrium from a given stellar model atmosphere and lists of atomic and molecular lines; it provides large wavelength coverage and line lists from ultraviolet through the visible and near-infrared. PFANT has been optimized for speed, offers error reporting, and command-line configuration options.

[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:1812.001]
WISP: Wenger Interferometry Software Package

WISP (Wenger Interferometry Software Package) is a radio interferometry calibration, reduction, imaging, and analysis package. WISP is a collection of Python code implemented through CASA (ascl:1107.013). Its generic and modular framework is designed to handle any continuum or spectral line radio interferometry data.

[submitted]
taktent: A Python framework for agent-based simulations of SETI observations

This Python package allows the user to setup and run an agent-based simulation of a SETI survey. The package allows the creation of a population of observing and transmitting civilisations. Each transmitter and observer conducts their activities according to an input strategy. The success of observers and transmitters can then be recorded, and multiple simulations can be run for Monte Carlo Realisation.

This package is therefore a flexible framework in which to simulate and test different SETI strategies, both as an Observer and as a Transmitter. It is primarily designed with radio SETI in mind, but is sufficiently flexible to simulate all forms of electromagnetic SETI, and potentially neutrino and gravitational wave SETI.

[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:1811.020]
PulsarHunter: Searching for and confirming pulsars

Pulsarhunter searches for and confirms pulsars; it provides a set of time domain optimization tools for processing timeseries data produced by SIGPROC (ascl:1107.016). The software can natively write candidate lists for JReaper (included in the package), removing the need to manually import candidates into JReaper; JReaper also reads the PulsarHunter candidate file format.

[ascl:1811.019]
PENTACLE: Large-scale particle simulations code for planet formation

PENTACLE calculates gravitational interactions between particles within a cut-off radius and a Barnes-Hut tree method for gravity from particles beyond. It uses FDPS (ascl:1604.011) to parallelize a Barnes-Hut tree algorithm for a memory-distributed supercomputer. The software can handle 1-10 million particles in a high-resolution N-body simulation on CPU clusters for collisional dynamics, including physical collisions in a planetesimal disc.

[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:1811.017]
Vplanet: Virtual planet simulator

Barnes, Rory; Deitrick, Russell; Luger, Rodrigo; Driscoll, Peter; Fleming, David; Quinn, Thomas; Smotherman, Hayden; Garcia, Rodolfo; McDonald, Diego; Wilhelm, Caitlyn; Guyer, Benjamin

Vplanet simulates planetary system evolution with a focus on habitability. Physical models, typically consisting of ordinary differential equations for stellar, orbital, tidal, rotational, atmospheric, internal, magnetic, climate, and galactic evolution, are coupled together to simulate evolution for the age of a system.

[ascl:1811.016]
VoigtFit: Absorption line fitting for Voigt profiles

VoigtFit fits Voigt profiles to absorption lines. It fits multiple components for various atomic lines simultaneously, allowing parameters to be tied and fixed, and can automatically fit a polynomial continuum model together with the line profiles. A physical model can be used to constrain thermal and turbulent broadening of absorption lines as well as implementing molecular excitation models. The code uses a χ2 minimization approach to find the best solution and offers interactive features such as manual continuum placement locally around each line, manual masking of undesired fitting regions, and interactive definition of velocity components for various elements, improving the ease of estimating initial guesses.

[ascl:1811.015]
radon: Streak detection using the Fast Radon Transform

radon performs a Fast Radon Transform (FRT) on image data for streak detection. The software finds short streaks and multiple streaks, convolves the images with a given PSF, and tracks the best S/N results and find a automatic threshold. It also calculates the streak parameters in the input image and the streak parameters in the input image. radon has a simulator that can make multiple streaks of different intensities and coordinates, and can simulate random streaks with parameters chosen uniformly in a user-defined range.

[ascl:1811.014]
pygad: Analyzing Gadget Simulations with Python

pygad provides a framework for dealing with Gadget snapshots. The code reads any of the many different Gadget (ascl:0003.001) formats, allows easy masking snapshots to particles of interest, decorates the data blocks with units, allows to add automatically updating derived blocks, and provides several binning and plotting routines, among other tasks, to provide convenient, intuitive handling of the Gadget data without the need to worry about technical details. pygad provides access to single stellar population (SSP) models, has an interface to Rockstar (ascl:1210.008) output files, provides its own friends-of-friends (FoF) finder, calculates spherical overdensities, and has a sub-module to generate mock absorption lines.

[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:1811.012]
muLAn: gravitational MICROlensing Analysis Software

muLAn analyzes and fits light curves of gravitational microlensing events. The code includes all classical microlensing models (for example, single and binary microlenses, ground- and space-based parallax effects, orbital motion, finite-source effects, and limb-darkening); these can be combined into several time intervals of the analyzed light curve. Minimization methods include an Affine-Invariant Ensemble Sampler to generate a multivariate proposal function while running several Markov Chain Monte Carlo (MCMC) chains, for the set of parameters which is chosen to be fit; non-fitting parameters can be either kept fixed or set on a grid defined by the user. Furthermore, the software offers a model-free option to align all data sets together and allow inspection the light curve before any modeling work. It also comes with many useful routines (export publication-quality figures, data formatting and cleaning) and state-of-the-art statistical tools.

Modeling results can be interpreted using an interactive html page which contains all information about the light curve model, caustics, source trajectory, best-fit parameters and chi-square. Parameters uncertainties and statistical properties (such as multi-modal features of the posterior density) can be assessed from correlation plots. The code is modular, allowing the addition of other computation or minimization routines by directly adding their Python files without modifying the main code. The software has been designed to be easy to use even for the newcomer in microlensing, with external, synthetic and self-explanatory setup files containing all important commands and option settings. The user may choose to launch the code through command line instructions, or to import muLAn within another Python project like any standard Python package.

[ascl:1811.011]
SIM5: Library for ray-tracing and radiation transport in general relativity

The SIM5 library contains routines for relativistic raytracing and radiation transfer in GR. Written C with a Python interface, it has a special focus on raytracing from accretion disks, tori, hot spots or any other 3D configuration of matter in Kerr geometry, but it can be used with any other metric as well. It handles both optically thick and thin sources as well as transport of polarization of the radiation and calculates the propagation of light rays from the source to an observer through a curved spacetime. It supports parallelization and runs on GPUs.

[ascl:1811.010]
MillCgs: Searching for Compact Groups in the Millennium Simulation

MillCgs clusters galaxies from the semi-analytic models run on top of the Millennium Simulation to identify Compact Groups. MillCgs uses a machine learning clustering algorithm to find the groups and then runs analytics to filter out the groups that do not fit the user specified criteria. The package downloads the data, processes it, and then creates graphs of the data.

[ascl:1811.009]
RLOS: Time-resolved imaging of model astrophysical jets

RLOS (Relativistic Line Of Sight) uses hydrocode output data, such as that from PLUTO (ascl:1010.045), to create synthetic images depicting what a model relativistic astrophysical jet looks like to a stationary observer. The approximate time-delayed imaging algorithm used is implemented within existing line-of-sight code. The software has the potential to study a variety of dynamical astrophysical phenomena in collaboration with other imaging and simulation tools.

[ascl:1811.008]
Pylians: Python libraries for the analysis of numerical simulations

Pylians facilitates the analysis of numerical simulations (both N-body and hydro). This set of libraries, written in python, cython and C, compute power spectra, bispectra, and correlation functions, identifies voids, and populates halos with galaxies using an HOD. Pylians can also apply HI+H2 corrections to the output of hydrodynamic simulations, makes 21cm maps, computes DLAs column density distribution functions, and plots density fields.

[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:1811.006]
QuickSip: Project survey image properties onto the sky into Healpix maps

QuickSip quickly projects Survey Image Properties (e.g. seeing, sky noise, airmass) into Healpix sky maps with flexible weighting schemes. It was initially designed to produce observing condition "systematics" maps for the Dark Energy Survey (DES), but will work with any multi-epoch survey and images with valid WCS. QuickSip can reproduce the Mangle (ascl:1202.005) magnitude limit maps at sub-percent accuracy but doesn't support additional masks (stars, trails, etc), in which case Mangle should be used. Thus, QuickSip can be seen as a simplified Mangle to project image properties into Healpix maps in a fast and more flexible manner.

[ascl:1811.005]
Shark: Flexible semi-analytic galaxy formation model

Lagos, Claudia del P.; Tobar, Rodrigo J.; Robotham, Aaron S. G.; Obreschkow, Danail; Mitchell, Peter D.; Power, Chris; Elahi, Pascal J.

Shark is a flexible semi-analytic galaxy formation model for easy exploration of different physical processes. Shark has been implemented with several models for gas cooling, active galactic nuclei, stellar and photo-ionization feedback, and star formation (SF). The software can determine the stellar mass function and stellar–halo mass relation at z=0–4; cosmic evolution of the star formation rate density, stellar mass, atomic and molecular hydrogen; local gas scaling relations; and structural galaxy properties. It performs particularly well for the mass–size relation for discs/bulges, the gas–stellar mass and stellar mass–metallicity relations. Shark is written in C++11 and has been parallelized with OpenMP.

[ascl:1811.004]
SEP: Source Extraction and Photometry

SEP (Source Extraction and Photometry) makes the core algorithms of Source Extractor (ascl:1010.064) available as a library of standalone functions and classes. These operate directly on in-memory arrays (no FITS files or configuration files). The code is derived from the Source Extractor code base (written in C) and aims to produce results compatible with Source Extractor whenever possible. SEP consists of a C library with no dependencies outside the standard library and a Python module that wraps the C library in a Pythonic API. The Python wrapper operates on NumPy arrays with NumPy as its only dependency. It is generated using Cython.

From Source Extractor, SEP includes background estimation, image segmentation (including on-the-fly filtering and source deblending), aperture photometry in circular and elliptical apertures, and source measurements such as Kron radius, "windowed" position fitting, and half-light radius. It also adds the following features that are not available in Source Extractor: optimized matched filter for variable noise in source extraction; circular annulus and elliptical annulus aperture photometry functions; local background subtraction in shape consistent with aperture in aperture photometry functions; exact pixel overlap mode in all aperture photometry functions; and masking of elliptical regions on images.

[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: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:1811.001]
synphot: Synthetic photometry using Astropy

Synphot simulates photometric data and spectra, observed or otherwise. It can incorporate the user's filters, spectra, and data, and use of a pre-defined standard star (Vega), bandpass, or extinction law. synphot can also construct complicated composite spectra using different models, simulate observations, and compute photometric properties such as count rate, effective wavelength, and effective stimulus. It can manipulate a spectrum by, for example, applying redshift, or normalize it to a given flux value in a given bandpass. Synphot can also sample a spectrum at given wavelengths, plot a quick-view of a spectrum, and perform repetitive operations such as simulating the observations of multiple type of sources through multiple bandpasses. Synphot understands Astropy (ascl:1304.002) models and units and is an Astropy affiliated package.

[submitted]
OCD: O'Connell Effect Detector using Push-Pull Learning

OCD (O'Connell Effect Detector using Push-Pull Learning) detects eclipsing binaries that demonstrate the O'Connell Effect. This time-domain signature extraction methodology uses a supporting supervised pattern detection algorithm. The methodology maps stellar variable observations (time-domain data) to a new representation known as Distribution Fields (DF), the properties of which enable efficient handling of issues such as irregular sampling and multiple values per time instance. Using this representation, the code applies a metric learning technique directly on the DF space capable of specifically identifying the stars of interest; the metric is tuned on a set of labeled eclipsing binary data from the Kepler survey, targeting particular systems exhibiting the O’Connell Effect. This code is useful for large-scale data volumes such as that expected from next generation telescopes such as LSST.

[submitted]
stginga: Ginga for STScI

stginga customizes Ginga to aid data analysis for the data supported by STScI (e.g., HST or JWST). For instance, it provides plugins and configuration files that understand HST and JWST data products.

[submitted]
stsynphot: synphot for HST and JWST

An extension to synphot (ascl:1811.001), stsynphot implements synthetic photometry package for HST and JWST support. The software constructs spectra from various grids of model atmosphere spectra, parameterized spectrum models, and atlases of stellar spectrophotometry. It also simulates observations specific to HST and JWST, computes photometric calibration parameters for any supported instrument mode, and plots instrument-specific sensitivity curves and calibration target spectra.

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

Would you like to view a random code?