ASCL.net

Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

Results 1251-1500 of 2056 (2027 ASCL, 29 submitted)

Order
Title Date
 
Mode
Abstract Compact
Per Page
50100250All
[ascl:1604.009] CCSNMultivar: Core-Collapse Supernova Gravitational Waves

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

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

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

[ascl:1604.012] TTVFaster: First order eccentricity transit timing variations (TTVs)

TTVFaster implements analytic formulae for transit time variations (TTVs) that are accurate to first order in the planet–star mass ratios and in the orbital eccentricities; the implementations are available in several languages, including IDL, Julia, Python and C. These formulae compare well with more computationally expensive N-body integrations in the low-eccentricity, low mass-ratio regime when applied to simulated and to actual multi-transiting Kepler planet systems.

[ascl:1605.001] MARZ: Redshifting Program

MARZ analyzes objects and produces high quality spectroscopic redshift measurements. Spectra not matched correctly by the automatic algorithm can be redshifted manually by cycling automatic results, manual template comparison, or marking spectral features. The software has an intuitive interface and powerful automatic matching capabilities on spectra, and can be run interactively or from the command line, and runs as a Web application. MARZ can be run on a local server; it is also available for use on a public server.

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

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

[ascl:1605.003] Shadowfax: Moving mesh hydrodynamical integration code

Shadowfax simulates galaxy evolution. Written in object-oriented modular C++, it evolves a mixture of gas, subject to the laws of hydrodynamics and gravity, and any collisionless fluid only subject to gravity, such as cold dark matter or stars. For the hydrodynamical integration, it makes use of a (co-) moving Lagrangian mesh. The code has a 2D and 3D version, contains utility programs to generate initial conditions and visualize simulation snapshots, and its input/output is compatible with a number of other simulation codes, e.g. Gadget2 (ascl:0003.001) and GIZMO (ascl:1410.003).

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

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

[ascl:1605.005] TMBIDL: Single dish radio astronomy data reduction package

The IDL package reduces and analyzes radio astronomy data. It translates SDFITS files into TMBIDL format, and can average and display spectra, remove baselines, and fit Gaussian models.

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

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

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

[ascl:1605.007] MUSCLE: MUltiscale Spherical-ColLapse Evolution

MUSCLE (MUltiscale Spherical ColLapse Evolution) produces low-redshift approximate N-body realizations accurate to few-Megaparsec scales. It applies a spherical-collapse prescription on multiple Gaussian-smoothed scales. It achieves higher accuracy than perturbative schemes (Zel'dovich and second-order Lagrangian perturbation theory - 2LPT), and by including the void-in-cloud process (voids in large-scale collapsing regions), solves problems with a single-scale spherical-collapse scheme.

[ascl:1605.008] PDT: Photometric DeTrending Algorithm Using Machine Learning

PDT removes systematic trends in light curves. It finds clusters of light curves that are highly correlated using machine learning, constructs one master trend per cluster and detrends an individual light curve using the constructed master trends by minimizing residuals while constraining coefficients to be positive.

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

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

[ascl:1605.010] TRIPPy: Python-based Trailed Source Photometry

TRIPPy (TRailed Image Photometry in Python) uses a pill-shaped aperture, a rectangle described by three parameters (trail length, angle, and radius) to improve photometry of moving sources over that done with circular apertures. It can generate accurate model and trailed point-spread functions from stationary background sources in sidereally tracked images. Appropriate aperture correction provides accurate, unbiased flux measurement. TRIPPy requires numpy, scipy, matplotlib, Astropy (ascl:1304.002), and stsci.numdisplay; emcee (ascl:1303.002) and SExtractor (ascl:1010.064) are optional.

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

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

[ascl:1605.012] K2SC: K2 Systematics Correction

K2SC (K2 Systematics Correction) models instrumental systematics and astrophysical variability in light curves from the K2 mission. It enables the user to remove both position-dependent systematics and time-dependent variability (e.g., for transit searches) or to remove systematics while preserving variability (for variability studies). K2SC automatically computes estimates of the period, amplitude and evolution timescale of the variability for periodic variables and can be run on ASCII and FITS light curve files. Written in Python, this pipeline requires NumPy, SciPy, MPI4Py, Astropy (ascl:1304.002), and George (ascl:1511.015).

[ascl:1605.013] grtrans: Polarized general relativistic radiative transfer via ray tracing

grtrans calculates ray tracing radiative transfer in the Kerr metric, including the full treatment of polarised radiative transfer and parallel transport along geodesics, for comparing theoretical models of black hole accretion flows and jets with observations. The code is written in Fortran 90 and parallelizes with OpenMP; the full code and several components have Python interfaces. grtrans includes Geokerr (ascl:1011.015) and requires cfitsio (ascl:1010.001) and pyfits (ascl:1207.009).

[ascl:1605.014] DUO: Spectra of diatomic molecules

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

[ascl:1605.015] SAND: Automated VLBI imaging and analyzing pipeline

The Search And Non-Destroy (SAND) is a VLBI data reduction pipeline composed of a set of Python programs based on the AIPS interface provided by ObitTalk. It is designed for the massive data reduction of multi-epoch VLBI monitoring research. It can automatically investigate calibrated visibility data, search all the radio emissions above a given noise floor and do the model fitting either on the CLEANed image or directly on the uv data. It then digests the model-fitting results, intelligently identifies the multi-epoch jet component correspondence, and recognizes the linear or non-linear proper motion patterns. The outputs including CLEANed image catalogue with polarization maps, animation cube, proper motion fitting and core light curves. For uncalibrated data, a user can easily add inline modules to do the calibration and self-calibration in a batch for a specific array.

[ascl:1605.016] zeldovich-PLT: Zel'dovich approximation initial conditions generator

zeldovich-PLT generates Zel'dovich approximation (ZA) initial conditions (i.e. first-order Lagrangian perturbation theory) for cosmological N-body simulations, optionally applying particle linear theory (PLT) corrections.

[ascl:1605.017] Surprise Calculator: Estimating relative entropy and Surprise between samples

The Surprise is a measure for consistency between posterior distributions and operates in parameter space. It can be used to analyze either the compatibility of separately analyzed posteriors from two datasets, or the posteriors from a Bayesian update. The Surprise Calculator estimates relative entropy and Surprise between two samples, assuming they are Gaussian. The software requires the R package CompQuadForm to estimate the significance of the Surprise, and rpy2 to interface R with Python.

[ascl:1606.001] SWOC: Spectral Wavelength Optimization Code

SWOC (Spectral Wavelength Optimization Code) determines the wavelength ranges that provide the optimal amount of information to achieve the required science goals for a spectroscopic study. It computes a figure-of-merit for different spectral configurations using a user-defined list of spectral features, and, utilizing a set of flux-calibrated spectra, determines the spectral regions showing the largest differences among the spectra.

[ascl:1606.002] PAL: Positional Astronomy Library

The PAL library is a partial re-implementation of Pat Wallace's popular SLALIB library written in C using a Gnu GPL license and layered on top of the IAU's SOFA library (or the BSD-licensed ERFA) where appropriate. PAL attempts to stick to the SLA C API where possible.

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

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

[ascl:1606.004] HIBAYES: Global 21-cm Bayesian Monte-Carlo Model Fitting

HIBAYES implements fully-Bayesian extraction of the sky-averaged (global) 21-cm signal from the Cosmic Dawn and Epoch of Reionization in the presence of foreground emission. User-defined likelihood and prior functions are called by the sampler PyMultiNest (ascl:1606.005) in order to jointly explore the full (signal plus foreground) posterior probability distribution and evaluate the Bayesian evidence for a given model. Implemented models, for simulation and fitting, include gaussians (HI signal) and polynomials (foregrounds). Some simple plotting and analysis tools are supplied. The code can be extended to other models (physical or empirical), to incorporate data from other experiments, or to use alternative Monte-Carlo sampling engines as required.

[ascl:1606.005] PyMultiNest: Python interface for MultiNest

PyMultiNest provides programmatic access to MultiNest (ascl:1109.006) and PyCuba, integration existing Python code (numpy, scipy), and enables writing Prior & LogLikelihood functions in Python. PyMultiNest can plot and visualize MultiNest's progress and allows easy plotting, visualization and summarization of MultiNest results. The plotting can be run on existing MultiNest output, and when not using PyMultiNest for running MultiNest.

[ascl:1606.006] uvmcmcfit: Parametric models to interferometric data fitter

Uvmcmcfit fits parametric models to interferometric data. It is ideally suited to extract the maximum amount of information from marginally resolved observations with interferometers like the Atacama Large Millimeter Array (ALMA), Submillimeter Array (SMA), and Plateau de Bure Interferometer (PdBI). uvmcmcfit uses emcee (ascl:1303.002) to do Markov Chain Monte Carlo (MCMC) and can measure the goodness of fit from visibilities rather than deconvolved images, an advantage when there is strong gravitational lensing and in other situations. uvmcmcfit includes a pure-Python adaptation of Miriad’s (ascl:1106.007) uvmodel task to generate simulated visibilities given observed visibilities and a model image and a simple ray-tracing routine that allows it to account for both strongly lensed systems (where multiple images of the lensed galaxy are detected) and weakly lensed systems (where only a single image of the lensed galaxy is detected).

[ascl:1606.007] COMB: Compact embedded object simulations

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

[ascl:1606.008] s2: Object oriented wrapper for functions on the sphere

The s2 package can represent any arbitrary function defined on the sphere. Both real space map and harmonic space spherical harmonic representations are supported. Basic sky representations have been extended to simulate full sky noise distributions and Gaussian cosmic microwave background realisations. Support for the representation and convolution of beams is also provided. The code requires HEALPix (ascl:1107.018) and CFITSIO (ascl:1010.001).

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

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

[ascl:1606.010] SimpLens: Interactive gravitational lensing simulator

SimpLens illustrates some of the theoretical ideas important in gravitational lensing in an interactive way. After setting parameters for elliptical mass distribution and external mass, SimpLens displays the mass profile and source position, the lens potential and image locations, and indicate the image magnifications and contours of virtual light-travel time. A lens profile can be made shallower or steeper with little change in the image positions and with only total magnification affected.

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

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

[ascl:1606.012] KMDWARFPARAM: Parameters estimator for K and M dwarf stars

KMDWARFPARAM estimates the physical parameters of a star with mass M < 0.8 M_sun given one or more observational constraints. The code runs a Markov-Chain Monte Carlo procedure to estimate the parameter values and their uncertainties.

[ascl:1606.013] Pulse Portraiture: Pulsar timing

Pulse Portraiture is a wideband pulsar timing code written in python. It uses an extension of the FFTFIT algorithm (Taylor 1992) to simultaneously measure a phase (TOA) and dispersion measure (DM). The code includes a Gaussian-component-based portrait modeling routine. The code uses the python interface to the pulsar data analysis package PSRCHIVE (ascl:1105.014) and also requires the non-linear least-squares minimization package lmfit (ascl:1606.014).

[ascl:1606.014] Lmfit: Non-Linear Least-Square Minimization and Curve-Fitting for Python

Lmfit provides a high-level interface to non-linear optimization and curve fitting problems for Python. Lmfit builds on and extends many of the optimization algorithm of scipy.optimize, especially the Levenberg-Marquardt method from optimize.leastsq. Its enhancements to optimization and data fitting problems include using Parameter objects instead of plain floats as variables, the ability to easily change fitting algorithms, and improved estimation of confidence intervals and curve-fitting with the Model class. Lmfit includes many pre-built models for common lineshapes.

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

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

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

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

[ascl:1607.002] DICE: Disk Initial Conditions Environment

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

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

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

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

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

[ascl:1607.005] Planetary3br: Three massive body resonance calculator

Given two planets P1 and P2 with arbitrary orbits, planetary3br calculates all possible semimajor axes that a third planet P0 can have in order for the system to be in a three body resonance; these are identified by the combination k0*P0 + k1*P1 + k2*P2. P1 and P2 are assumed to be not in an exact two-body resonance. The program also calculates three "strengths" of the resonance, one for each planet, which are only indicators of the dynamical relevance of the resonance on each planet. Sample input data are available along with the Fortran77 source code.

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

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

[ascl:1607.007] JUDE: An Utraviolet Imaging Telescope pipeline

JUDE (Jayant's UVIT Data Explorer) converts the Level 1 data (FITS binary table) from the Ultraviolet Imaging Telescope (UVIT) on ASTROSAT into three output files: a photon event list as a function of frame number (FITS binary table); a FITS image file with two extensions; and a PNG file created from the FITS image file with an automated scaling.

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

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

[ascl:1607.010] K2PS: K2 Planet search

K2PS is an Oxford K2 planet search pipeline. Written in Python, it searches for transit-like signals from the k2sc-detrended light curves.

[ascl:1607.009] PICsar: Particle in cell pulsar magnetosphere simulator

PICsar simulates the magnetosphere of an aligned axisymmetric pulsar and can be used to simulate other arbitrary electromagnetics problems in axisymmetry. Written in Fortran, this special relativistic, electromagnetic, charge conservative particle in cell code features stretchable body-fitted coordinates that follow the surface of a sphere, simplifying the application of boundary conditions in the case of the aligned pulsar; a radiation absorbing outer boundary, which allows a steady state to be set up dynamically and maintained indefinitely from transient initial conditions; and algorithms for injection of charged particles into the simulation domain. PICsar is parallelized using MPI and has been used on research problems with ~1000 CPUs.

[ascl:1607.011] HfS: Hyperfine Structure fitting tool

HfS fits the hyperfine structure of spectral lines, with multiple velocity components. The HfS_nh3 procedures included in HfS fit simultaneously the hyperfine structure of the NH3 (J,K)= (1,1) and (2,2) inversion transitions, and perform a standard analysis to derive the NH3 column density, rotational temperature Trot, and kinetic temperature Tk. HfS uses a Monte Carlo approach for fitting the line parameters, with special attention to the derivation of the parameter uncertainties. HfS includes procedures that make use of parallel computing for fitting spectra from a data cube.

[ascl:1607.012] ZASPE: Zonal Atmospheric Stellar Parameters Estimator

ZASPE (Zonal Atmospheric Stellar Parameters Estimator) computes the atmospheric stellar parameters (Teff, log(g), [Fe/H] and vsin(i)) from echelle spectra via least squares minimization with a pre-computed library of synthetic spectra. The minimization is performed only in the most sensitive spectral zones to changes in the atmospheric parameters. The uncertainities and covariances computed by ZASPE assume that the principal source of error is the systematic missmatch between the observed spectrum and the sythetic one that produces the best fit. ZASPE requires a grid of synthetic spectra and can use any pre-computed library minor modifications.

[ascl:1607.013] Kālī: Time series data modeler

The fully parallelized and vectorized software package Kālī models time series data using various stochastic processes such as continuous-time ARMA (C-ARMA) processes and uses Bayesian Markov Chain Monte-Carlo (MCMC) for inferencing a stochastic light curve. Kālī is written in c++ with Python language bindings for ease of use. Kālī is named jointly after the Hindu goddess of time, change, and power and also as an acronym for KArma LIbrary.

[ascl:1607.014] SOPIE: Sequential Off-Pulse Interval Estimation

SOPIE (Sequential Off-Pulse Interval Estimation) provides functions to non-parametrically estimate the off-pulse interval of a source function originating from a pulsar. The technique is based on a sequential application of P-values obtained from goodness-of-fit tests for the uniform distribution, such as the Kolmogorov-Smirnov, Cramér-von Mises, Anderson-Darling and Rayleigh goodness-of-fit tests.

[ascl:1607.015] RT1D: 1D code for Rayleigh-Taylor instability

The parallel one-dimensional moving-mesh hydrodynamics code RT1D reproduces the multidimensional dynamics from Rayleigh-Taylor instability in supernova remnants.

[ascl:1607.016] astLib: Tools for research astronomers

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

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

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

[ascl:1607.018] LZIFU: IDL emission line fitting pipeline for integral field spectroscopy data

LZIFU (LaZy-IFU) is an emission line fitting pipeline for integral field spectroscopy (IFS) data. Written in IDL, the pipeline turns IFS data to 2D emission line flux and kinematic maps for further analysis. LZIFU has been applied and tested extensively to various IFS data, including the SAMI Galaxy Survey, the Wide-Field Spectrograph (WiFeS), the CALIFA survey, the S7 survey and the MUSE instrument on the VLT.

[ascl:1607.019] HIDE: HI Data Emulator

HIDE (HI Data Emulator) forward-models the process of collecting astronomical radio signals in a single dish radio telescope instrument and outputs pixel-level time-ordered-data. Written in Python, HIDE models the noise and RFI modeling of the data and with its companion code SEEK (ascl:1607.020) provides end-to-end simulation and processing of radio survey data.

[ascl:1607.020] SEEK: Signal Extraction and Emission Kartographer

SEEK (Signal Extraction and Emission Kartographer) processes time-ordered-data from single dish radio telescopes or from the simulation pipline HIDE (ascl:1607.019), removes artifacts from Radio Frequency Interference (RFI), automatically applies flux calibration, and recovers the astronomical radio signal. With its companion code HIDE (ascl:1607.019), it provides end-to-end simulation and processing of radio survey data.

[ascl:1608.001] Stingray: Spectral-timing software

Stingray is a spectral-timing software package for astrophysical X-ray (and more) data. The package merges existing efforts for a (spectral-)timing package in Python and is composed of a library of time series methods (including power spectra, cross spectra, covariance spectra, and lags); scripts to load FITS data files from different missions; a simulator of light curves and event lists that includes different kinds of variability and more complicated phenomena based on the impulse response of given physical events (e.g. reverberation); and a GUI to ease the learning curve for new users.

[ascl:1608.002] pyXSIM: Synthetic X-ray observations generator

pyXSIM simulates X-ray observations from astrophysical sources. X-rays probe the high-energy universe, from hot galaxy clusters to compact objects such as neutron stars and black holes and many interesting sources in between. pyXSIM generates synthetic X-ray observations of these sources from a wide variety of models, whether from grid-based simulation codes such as FLASH (ascl:1010.082), Enzo (ascl:1010.072), and Athena (ascl:1010.014), to particle-based codes such as Gadget (ascl:0003.001) and AREPO, and even from datasets that have been created “by hand”, such as from NumPy arrays. pyXSIM can also manipulate the synthetic observations it produces in various ways and export the simulated X-ray events to other software packages to simulate the end products of specific X-ray observatories. pyXSIM is an implementation of the PHOX (ascl:1112.004) algorithm and was initially the photon_simulator analysis module in yt (ascl:1011.022); it is dependent on yt.

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

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

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

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

[ascl:1608.005] AstroVis: Visualizing astronomical data cubes

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

[ascl:1608.006] Gemini IRAF: Data reduction software for the Gemini telescopes

The Gemini IRAF package processes observational data obtained with the Gemini telescopes. It is an external package layered upon IRAF and supports data from numerous instruments, including FLAMINGOS-2, GMOS-N, GMOS-S, GNIRS, GSAOI, NIFS, and NIRI. The Gemini IRAF package is organized into sub-packages; it contains a generic tools package, "gemtools", along with instrument-specific packages. The raw data from the Gemini facility instruments are stored as Multi-Extension FITS (MEF) files. Therefore, all the tasks in the Gemini IRAF package, intended for processing data from the Gemini facility instruments, are capable of handling MEF files.

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

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

[ascl:1608.008] Cuba: Multidimensional numerical integration library

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

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

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

[ascl:1608.010] pvextractor: Position-Velocity Diagram Extractor

Given a path defined in sky coordinates and a spectral cube, pvextractor extracts a slice of the cube along that path and along the spectral axis to produce a position-velocity or position-frequency slice. The path can be defined programmatically in pixel or world coordinates, and can also be drawn interactively using a simple GUI. Pvextractor is the main function, but also includes a few utilities related to header trimming and parsing.

[ascl:1608.011] PROFFIT: Analysis of X-ray surface-brightness profiles

PROFFIT analyzes X-ray surface-brightness profiles for data from any X-ray instrument. It can extract surface-brightness profiles in circular or elliptical annuli, using constant or logarithmic bin size, from the image centroid, the surface-brightness peak, or any user-given center, and provides surface-brightness profiles in any circular or elliptical sectors. It offers background map support to extract background profiles, can excise areas using SAO DS9-compatible (ascl:0003.002) region files to exclude point sources, provides fitting with a number of built-in models, including the popular beta model, double beta, cusp beta, power law, and projected broken power law, uses chi-squared or C statistic, and can fit on the surface-brightness or counts data. It has a command-line interface similar to HEASOFT’s XSPEC (ascl:9910.005) package, provides interactive help with a description of all the commands, and results can be saved in FITS, ROOT or TXT format.

[ascl:1608.012] OBERON: OBliquity and Energy balance Run on N-body systems

OBERON (OBliquity and Energy balance Run on N-body systems) models the climate of Earthlike planets under the effects of an arbitrary number and arrangement of other bodies, such as stars, planets and moons. The code, written in C++, simultaneously computes N body motions using a 4th order Hermite integrator, simulates climates using a 1D latitudinal energy balance model, and evolves the orbital spin of bodies using the equations of Laskar (1986a,b).

[submitted] ExoPlanet

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

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

[ascl:1608.013] DOLPHOT: Stellar photometry

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

[ascl:1608.014] gevolution: General Relativity Cosmological N-body code for evolution of large scale structures

The N-body code gevolution complies with general relativity principles at every step; it calculates all six metric degrees of freedom in Poisson gauge. N-body particles are evolved by solving the geodesic equation written in terms of a canonical momentum to remain valid for relativistic particles. gevolution can be extended to include different kinds of dark energy or modified gravity models, going beyond the usually adopted quasi-static approximation. A weak field expansion is the central element of gevolution; this permits the code to treat settings in which no strong gravitational fields appear, including arbitrary scenarios with relativistic sources as long as gravitational fields are not very strong. The framework is well suited for cosmology, but may also be useful for astrophysical applications with moderate gravitational fields where a Newtonian treatment is insufficient.

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

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

[ascl:1608.016] NICIL: Non-Ideal magnetohydrodynamics Coefficients and Ionisation Library

NICIL (Non-Ideal magnetohydrodynamics Coefficients and Ionisation Library) calculates the ionization values and the coefficients of the non-ideal magnetohydrodynamics terms of Ohmic resistivity, the Hall effect, and ambipolar diffusion. Written as a standalone Fortran90 module that can be implemented in existing codes, NICIL is fully parameterizable, allowing the user to choose which processes to include and decide the values of the free parameters. The module includes both cosmic ray and thermal ionization; the former includes two ion species and three species of dust grains (positively charged, negatively charged and neutral), and the latter includes five elements which can be doubly ionized.

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

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

[ascl:1608.018] LORENE: Spectral methods differential equations solver

LORENE (Langage Objet pour la RElativité NumériquE) solves various problems arising in numerical relativity, and more generally in computational astrophysics. It is a set of C++ classes and provides tools to solve partial differential equations by means of multi-domain spectral methods. LORENE classes implement basic structures such as arrays and matrices, but also abstract mathematical objects, such as tensors, and astrophysical objects, such as stars and black holes.

[ascl:1608.019] NEBULAR: Spectrum synthesis for mixed hydrogen-helium gas in ionization equilibrium

NEBULAR synthesizes the spectrum of a mixed hydrogen helium gas in collisional ionization equilibrium. It is not a spectral fitting code, but it can be used to resample a model spectrum onto the wavelength grid of a real observation. It supports a wide range of temperatures and densities. NEBULAR includes free-free, free-bound, two-photon and line emission from HI, HeI and HeII. The code will either return the composite model spectrum, or, if desired, the unrescaled atomic emission coefficients. It is written in C++ and depends on the GNU Scientific Library (GSL).

[ascl:1608.020] SPIDERz: SuPport vector classification for IDEntifying Redshifts

SPIDERz (SuPport vector classification for IDEntifying Redshifts) applies powerful support vector machine (SVM) optimization and statistical learning techniques to custom data sets to obtain accurate photometric redshift (photo-z) estimations. It is written for the IDL environment and can be applied to traditional data sets consisting of photometric band magnitudes, or alternatively to data sets with additional galaxy parameters (such as shape information) to investigate potential correlations between the extra galaxy parameters and redshift.

[ascl:1609.001] T-PHOT: PSF-matched, prior-based, multiwavelength extragalactic deconfusion photometry

T-PHOT extracts accurate photometry from low-resolution images of extragalactic fields, where the blending of sources can be a serious problem for accurate and unbiased measurement of fluxes and colors. It gathers data from a high-resolution image of a region of the sky and uses the source positions and morphologies to obtain priors for the photometric analysis of the lower resolution image of the same field. T-PHOT handles different types of datasets as input priors, including a list of objects that will be used to obtain cutouts from the real high-resolution image, a set of analytical models (as .fits stamps), and a list of unresolved, point-like sources, useful for example for far-infrared wavelength domains. T-PHOT yields accurate estimations of fluxes within the intrinsic uncertainties of the method when systematic errors are taken into account (which can be done using a flagging code given in the output), and handles multiwavelength optical to far-infrared image photometry. T-PHOT was developed as part of the ASTRODEEP project (www.astrodeep.eu).

[ascl:1609.002] StarPy: Quenched star formation history parameters of a galaxy using MCMC

StarPy derives the quenching star formation history (SFH) of a single galaxy through the Bayesian Markov Chain Monte Carlo method code emcee (ascl:1303.002). The sample function implements the emcee EnsembleSampler function for the galaxy colors input. Burn-in is run and calculated for the length specified before the sampler is reset and then run for the length of steps specified. StarPy provides the ability to use the look-up tables provided or creating your own.

[ascl:1609.003] Kranc: Cactus modules from Mathematica equations

Kranc turns a tensorial description of a time dependent partial differential equation into a module for the Cactus Computational Toolkit (ascl:1102.013). This Mathematica application takes a simple continuum description of a problem and generates highly efficient and portable code, and can be used both for rapid prototyping of evolution systems and for high performance supercomputing.

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

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

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

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

[ascl:1609.006] SCIMES: Spectral Clustering for Interstellar Molecular Emission Segmentation

SCIMES identifies relevant molecular gas structures within dendrograms of emission using the spectral clustering paradigm. It is useful for decomposing objects in complex environments imaged at high resolution.

[ascl:1609.007] Weighted EMPCA: Weighted Expectation Maximization Principal Component Analysis

Weighted EMPCA performs principal component analysis (PCA) on noisy datasets with missing values. Estimates of the measurement error are used to weight the input data such that the resulting eigenvectors, when compared to classic PCA, are more sensitive to the true underlying signal variations rather than being pulled by heteroskedastic measurement noise. Missing data are simply limiting cases of weight = 0. The underlying algorithm is a noise weighted expectation maximization (EM) PCA, which has additional benefits of implementation speed and flexibility for smoothing eigenvectors to reduce the noise contribution.

[ascl:1609.008] GRASP: General-purpose Relativistic Atomic Structure Package

GRASP (General-purpose Relativistic Atomic Structure Package) calculates atomic structure, including energy levels, radiative rates (A-values) and lifetimes; it is a fully relativistic code based on the jj coupling scheme. This code has been superseded by GRASP2K (ascl:1611.007).

[ascl:1609.009] NSCool: Neutron star cooling code

NSCool is a 1D (i.e., spherically symmetric) neutron star cooling code written in Fortran 77. The package also contains a series of EOSs (equation of state) to build stars, a series of pre-built stars, and a TOV (Tolman- Oppenheimer-Volkoff) integrator to build stars from an EOS. It can also handle “strange stars” that have a huge density discontinuity between the quark matter and the covering thin baryonic crust. NSCool solves the heat transport and energy balance equations in whole GR, resulting in a time sequence of temperature profiles (and, in particular, a Teff - age curve). Several heating processes are included, and more can easily be incorporated. In particular it can evolve a star undergoing accretion with the resulting deep crustal heating, under a steady or time-variable accretion rate. NSCool is robust, very fast, and highly modular, making it easy to add new subroutines for new processes.

[ascl:1609.010] CuBANz: Photometric redshift estimator

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

[ascl:1609.011] Photutils: Photometry tools

Photutils provides tools for detecting and performing photometry of astronomical sources. It can estimate the background and background rms in astronomical images, detect sources in astronomical images, estimate morphological parameters of those sources (e.g., centroid and shape parameters), and perform aperture and PSF photometry. Written in Python, it is an affiliated package of Astropy (ascl:1304.002).

[ascl:1609.012] AIPY: Astronomical Interferometry in PYthon

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

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

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

[ascl:1609.014] Sky3D: Time-dependent Hartree-Fock equation solver

Written in Fortran 90, Sky3D solves the static or dynamic equations on a three-dimensional Cartesian mesh with isolated or periodic boundary conditions and no further symmetry assumptions. Pairing can be included in the BCS approximation for the static case. The code can be easily modified to include additional physics or special analysis of the results and requires LAPACK and FFTW3.

[ascl:1609.015] FIT3D: Fitting optical spectra

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

[ascl:1609.016] PKDGRAV3: Parallel gravity code

Pkdgrav3 is an 𝒪(N) gravity calculation method; it uses a binary tree algorithm with fifth order fast multipole expansion of the gravitational potential, using cell-cell interactions. Periodic boundaries conditions require very little data movement and allow a high degree of parallelism; the code includes GPU acceleration for all force calculations, leading to a significant speed-up with respect to previous versions (ascl:1305.005). Pkdgrav3 also has a sophisticated time-stepping criterion based on an estimation of the local dynamical time.

[ascl:1609.017] spectral-cube: Read and analyze astrophysical spectral data cubes

Spectral-cube provides an easy way to read, manipulate, analyze, and write data cubes with two positional dimensions and one spectral dimension, optionally with Stokes parameters. It is a versatile data container for building custom analysis routines. It provides a uniform interface to spectral cubes, robust to the wide range of conventions of axis order, spatial projections, and spectral units that exist in the wild, and allows easy extraction of cube sub-regions using physical coordinates. It has the ability to create, combine, and apply masks to datasets and is designed to work with datasets too large to load into memory, and provide basic summary statistic methods like moments and array aggregates.

[ascl:1609.018] SIP: Systematics-Insensitive Periodograms

SIP (Systematics-Insensitive Periodograms) extends the generative model used to create traditional sine-fitting periodograms for finding the frequency of a sinusoid by including systematic trends based on a set of eigen light curves in the generative model in addition to using a sum of sine and cosine functions over a grid of frequencies, producing periodograms with vastly reduced systematic features. Acoustic oscillations in giant stars and measurement of stellar rotation periods can be recovered from the SIP periodograms without detrending. The code can also be applied to detection other periodic phenomena, including eclipsing binaries and short-period exoplanet candidates.

[ascl:1609.019] SuperBoL: Module for calculating the bolometric luminosities of supernovae

SuperBoL calculates the bolometric lightcurves of Type II supernovae using observed photometry; it includes three different methods for calculating the bolometric luminosity: quasi-bolometric, direct, and bolometric correction. SuperBoL propagates uncertainties in the input data through the calculations made by the code, allowing for error bars to be included in plots of the lightcurve.

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

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

[ascl:1609.021] TIDEV: Tidal Evolution package

TIDEV (Tidal Evolution package) calculates the evolution of rotation for tidally interacting bodies using Efroimsky-Makarov-Williams (EMW) formalism. The package integrates tidal evolution equations and computes the rotational and dynamical evolution of a planet under tidal and triaxial torques. TIDEV accounts for the perturbative effects due to the presence of the other planets in the system, especially the secular variations of the eccentricity. Bulk parameters include the mass and radius of the planet (and those of the other planets involved in the integration), the size and mass of the host star, the Maxwell time and Andrade's parameter. TIDEV also calculates the time scale that a planet takes to be tidally locked as well as the periods of rotation reached at the end of the spin-orbit evolution.

[ascl:1609.022] PyPHER: Python-based PSF Homogenization kERnels

PyPHER (Python-based PSF Homogenization kERnels) computes an homogenization kernel between two PSFs; the code is well-suited for PSF matching applications in both an astronomical or microscopy context. It can warp (rotation + resampling) the PSF images (if necessary), filter images in Fourier space using a regularized Wiener filter, and produce a homogenization kernel. PyPHER requires the pixel scale information to be present in the FITS files, which can if necessary be added by using the provided ADDPIXSCL method.

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

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

[ascl:1609.024] AdaptiveBin: Adaptive Binning

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

[ascl:1609.025] PYESSENCE: Generalized Coupled Quintessence Linear Perturbation Python Code

PYESSENCE evolves linearly perturbed coupled quintessence models with multiple (cold dark matter) CDM fluid species and multiple DE (dark energy) scalar fields, and can be used to generate quantities such as the growth factor of large scale structure for any coupled quintessence model with an arbitrary number of fields and fluids and arbitrary couplings.

[ascl:1610.001] Piccard: Pulsar timing data analysis package

Piccard is a Bayesian-inference pipeline for Pulsar Timing Array (PTA) data and interacts with Tempo2 (ascl:1210.015) through libstempo. The code is used mainly for single-pulsar analysis and gravitational-wave detection purposes of full Pulsar Timing Array datasets. Modeling of the data can include correlated signals per frequency or modeled spectrum, with uniform, dipolar, quadrupolar, or anisotropic correlations; multiple error bars and EFACs per pulsar; and white and red noise. Timing models can be numerically included, either by using the design matrix (linear timing model), or by calling libstempo for the full non-linear timing model. Many types of samplers are included. For common-mode mitigation, the signals can be reconstructed mitigating arbitrary signals simultaneously.

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

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

[ascl:1610.003] DSDEPROJ: Direct Spectral Deprojection

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

[ascl:1610.004] MUSE-DRP: MUSE Data Reduction Pipeline

The MUSE pipeline turns the complex raw data of the MUSE integral field spectrograph into a ready-to-use datacube for scientific analysis.

[ascl:1610.005] GSGS: In-Focus Phase Retrieval Using Non-Redundant Mask Data

GSGS does phase retrieval on images given an estimate of the pupil phase (from a non-redundant mask or other interferometric approach), the pupil geometry, and the in-focus image. The code uses a modified Gerchberg-Saxton algorithm that iterates between pupil plane and image plane to measure the pupil phase.

[ascl:1610.006] C3: Command-line Catalogue Crossmatch for modern astronomical surveys

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

[ascl:1610.007] gatspy: General tools for Astronomical Time Series in Python

Gatspy contains efficient, well-documented implementations of several common routines for Astronomical time series analysis, including the Lomb-Scargle periodogram, the Supersmoother method, and others.

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

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

[ascl:1610.009] velbin: radial velocity corrected for binary orbital motions

Velbin convolves the radial velocity offsets due to binary orbital motions with a Gaussian to model an observed velocity distribution. This can be used to measure the mean velocity and velocity dispersion from an observed radial velocity distribution, corrected for binary orbital motions. Velbin fits single- or multi-epoch data with any arbitrary binary orbital parameter distribution (as long as it can be sampled properly), however it always assumes that the intrinsic velocity distribution (i.e. corrected for binary orbital motions) is a Gaussian. Velbin samples (and edits) a binary orbital parameter distribution, fits an observed radial velocity distribution, and creates a mock radial velocity distribution that can be used to provide the fitted radial velocities in the single_epoch or multi_epoch methods.

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

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

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

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

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

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

[ascl:1610.013] MC3: Multi-core Markov-chain Monte Carlo code

MC3 (Multi-core Markov-chain Monte Carlo) is a Bayesian statistics tool that can be executed from the shell prompt or interactively through the Python interpreter with single- or multiple-CPU parallel computing. It offers Markov-chain Monte Carlo (MCMC) posterior-distribution sampling for several algorithms, Levenberg-Marquardt least-squares optimization, and uniform non-informative, Jeffreys non-informative, or Gaussian-informative priors. MC3 can share the same value among multiple parameters and fix the value of parameters to constant values, and offers Gelman-Rubin convergence testing and correlated-noise estimation with time-averaging or wavelet-based likelihood estimation methods.

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

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

[ascl:1610.015] NuPyCEE: NuGrid Python Chemical Evolution Environment

The NuGrid Python Chemical Evolution Environment (NuPyCEE) simulates the chemical enrichment and stellar feedback of stellar populations. It contains three modules. The Stellar Yields for Galactic Modeling Applications module (SYGMA) models the enrichment and feedback of simple stellar populations which can be included in hydrodynamic simulations and semi-analytic models of galaxies. It is the basic building block of the One-zone Model for the Evolution of GAlaxies (OMEGA, ascl:1806.018) module which models the chemical evolution of galaxies such as the Milky Way and its dwarf satellites. The STELLAB (STELLar ABundances) module provides a library of observed stellar abundances useful for comparing predictions of SYGMA and OMEGA.

[ascl:1610.016] PyMC3: Python probabilistic programming framework

PyMC3 performs Bayesian statistical modeling and model fitting focused on advanced Markov chain Monte Carlo and variational fitting algorithms. It offers powerful sampling algorithms, such as the No U-Turn Sampler, allowing complex models with thousands of parameters with little specialized knowledge of fitting algorithms, intuitive model specification syntax, and optimization for finding the maximum a posteriori (MAP) point. PyMC3 uses Theano to compute gradients via automatic differentiation as well as compile probabilistic programs on-the-fly to C for increased speed.

[ascl:1611.001] UltraNest: Pythonic Nested Sampling Development Framework and UltraNest

This three-component package provides a Pythonic implementation of the Nested Sampling integration algorithm for Bayesian model comparison and parameter estimation. It offers multiple implementations for constrained drawing functions and a test suite to evaluate the correctness, accuracy and efficiency of various implementations. The three components are:

  • a modular framework for nested sampling algorithms (nested_sampling) and their development;
  • a test framework to evaluate the performance and accuracy of algorithms (testsuite); and
  • UltraNest, a fast C implementation of a mixed RadFriends/MCMC nested sampling algorithm.

[ascl:1611.002] tf_unet: Generic convolutional neural network U-Net implementation in Tensorflow

tf_unet mitigates radio frequency interference (RFI) signals in radio data using a special type of Convolutional Neural Network, the U-Net, that enables the classification of clean signal and RFI signatures in 2D time-ordered data acquired from a radio telescope. The code is not tied to a specific segmentation and can be used, for example, to detect radio frequency interference (RFI) in radio astronomy or galaxies and stars in widefield imaging data. This U-Net implementation can outperform classical RFI mitigation algorithms.

[ascl:1611.003] MPDAF: MUSE Python Data Analysis Framework

MPDAF, the MUSE Python Data Analysis Framework, provides tools to work with MUSE-specific data (for example, raw data and pixel tables), and with more general data such as spectra, images, and data cubes. Originally written to work with MUSE data, it can also be used for other data, such as that from the Hubble Space Telescope. MPDAF also provides MUSELET, a SExtractor-based tool to detect emission lines in a data cube, and a format to gather all the information on a source in one FITS file. MPDAF was developed and is maintained by CRAL (Centre de Recherche Astrophysique de Lyon).

[ascl:1611.004] PRECESSION: Python toolbox for dynamics of spinning black-hole binaries

PRECESSION is a comprehensive toolbox for exploring the dynamics of precessing black-hole binaries in the post-Newtonian regime. It allows study of the evolution of the black-hole spins along their precession cycles, performs gravitational-wave-driven binary inspirals using both orbit-averaged and precession-averaged integrations, and predicts the properties of the merger remnant through fitting formulas obtained from numerical-relativity simulations. PRECESSION can add the black-hole spin dynamics to larger-scale numerical studies such as gravitational-wave parameter estimation codes, population synthesis models to predict gravitational-wave event rates, galaxy merger trees and cosmological simulations of structure formation, and provides fast and reliable integration methods to propagate statistical samples of black-hole binaries from/to large separations where they form to/from small separations where they become detectable, thus linking gravitational-wave observations of spinning black-hole binaries to their astrophysical formation history. The code is also useful for computing initial parameters for numerical-relativity simulations targeting specific precessing systems.

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

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

[ascl:1611.006] GalPot: Galaxy potential code

GalPot finds the gravitational potential associated with axisymmetric density profiles. The package includes code that performs transformations between commonly used coordinate systems for both positions and velocities (the class OmniCoords), and that integrates orbits in the potentials. GalPot is a stand-alone version of Walter Dehnen's GalaxyPotential C++ code taken from the falcON code in the NEMO Stellar Dynamics Toolbox (ascl:1010.051).

[ascl:1611.007] GRASP2K: Relativistic Atomic Structure Package

GRASP2K is a revised and greatly expanded version of GRASP (ascl:1609.008) and is adapted for 64-bit computer architecture. It includes new angular libraries, can transform from jj- to LSJ-coupling, and coefficients of fractional parentage have been extended to j=9/2, making calculations feasible for the lanthanides and actinides. GRASP2K identifies each atomic state by the total energy and a label for the configuration state function with the largest expansion coefficient in LSJLSJ intermediate coupling.

[ascl:1611.008] Transit Clairvoyance: Predicting multiple-planet systems for TESS

Transit Clairvoyance uses Artificial Neural Networks (ANNs) to predict the most likely short period transiters to have additional transiters, which may double the discovery yield of the TESS (Transiting Exoplanet Survey Satellite). Clairvoyance is a simple 2-D interpolant that takes in the number of planets in a system with period less than 13.7 days, as well as the maximum radius amongst them (in Earth radii) and orbital period of the planet with maximum radius (in Earth days) in order to predict the probability of additional transiters in this system with period greater than 13.7 days.

[ascl:1611.009] RHOCUBE: 3D density distributions modeling code

RHOCUBE models 3D density distributions on a discrete Cartesian grid and their integrated 2D maps. It can be used for a range of applications, including modeling the electron number density in LBV shells and computing the emission measure. The RHOCUBE Python package provides several 3D density distributions, including a powerlaw shell, truncated Gaussian shell, constant-density torus, dual cones, and spiralling helical tubes, and can accept additional distributions. RHOCUBE provides convenient methods for shifts and rotations in 3D, and if necessary, an arbitrary number of density distributions can be combined into the same model cube and the integration ∫ dz performed through the joint density field.

[ascl:1611.010] Kapteyn Package: Tools for developing astronomical applications

The Kapteyn Package provides tools for the development of astronomical applications with Python. It handles spatial and spectral coordinates, WCS projections and transformations between different sky systems; spectral translations (e.g., between frequencies and velocities) and mixed coordinates are also supported. Kapteyn offers versatile tools for writing small and dedicated applications for the inspection of FITS headers, the extraction and display of (FITS) data, interactive inspection of this data (color editing) and for the creation of plots with world coordinate information. It includes utilities for use with matplotlib such as obtaining coordinate information from plots, interactively modifiable colormaps and timer events (module mplutil); tools for parsing and interpreting coordinate information entered by the user (module positions); a function to search for gaussian components in a profile (module profiles); and a class for non-linear least squares fitting (module kmpfit).

[ascl:1611.011] OXAF: Ionizing spectra of Seyfert galaxies for photoionization modeling

OXAF provides a simplified model of Seyfert Active Galactic Nucleus (AGN) continuum emission designed for photoionization modeling. It removes degeneracies in the effects of AGN parameters on model spectral shapes and reproduces the diversity of spectral shapes that arise in physically-based models. OXAF accepts three parameters which directly describe the shape of the output ionizing spectrum: the energy of the peak of the accretion disk emission Epeak, the photon power-law index of the non-thermal X-ray emission Γ, and the proportion of the total flux which is emitted in the non-thermal component pNT. OXAF accounts for opacity effects where the accretion disk is ionized because it inherits the ‘color correction’ of OPTXAGNF, the physical model upon which OXAF is based.

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

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

[ascl:1611.013] pyGMMis: Mixtures-of-Gaussians density estimation method

pyGMMis is a mixtures-of-Gaussians density estimation method that accounts for arbitrary incompleteness in the process that creates the samples as long as the incompleteness is known over the entire feature space and does not depend on the sample density (missing at random). pyGMMis uses the Expectation-Maximization procedure and generates its best guess of the unobserved samples on the fly. It can also incorporate an uniform "background" distribution as well as independent multivariate normal measurement errors for each of the observed samples, and then recovers an estimate of the error-free distribution from which both observed and unobserved samples are drawn. The code automatically segments the data into localized neighborhoods, and is capable of performing density estimation with millions of samples and thousands of model components on machines with sufficient memory.

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

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

[ascl:1611.015] Pippi: Parse and plot MCMC chains

Pippi (parse it, plot it) operates on MCMC chains and related lists of samples from a function or distribution, and can merge, parse, and plot sample ensembles ('chains') either in terms of the likelihood/fitness function directly, or as implied posterior probability densities. Pippi is compatible with ASCII text and hdf5 chains, operates out of core, and can post-process chains on the fly.

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

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

[ascl:1611.017] SNCosmo: Python library for supernova cosmology

SNCosmo synthesizes supernova spectra and photometry from SN models, and has functions for fitting and sampling SN model parameters given photometric light curve data. It offers fast implementations of several commonly used extinction laws and can be used to construct SN models that include dust. The SNCosmo library includes supernova models such as SALT2, MLCS2k2, Hsiao, Nugent, PSNID, SNANA and Whalen models, as well as a variety of built-in bandpasses and magnitude systems, and provides convenience functions for reading and writing peculiar data formats used in other packages. The library is extensible, allowing new models, bandpasses, and magnitude systems to be defined using an object-oriented interface.

[ascl:1611.018] Icarus: Stellar binary light curve synthesis tool

Icarus is a stellar binary light curve synthesis tool that generates a star, given some basic binary parameters, by solving the gravitational potential equation, creating a discretized stellar grid, and populating the stellar grid with physical parameters, including temperature and surface gravity. Icarus also evaluates the outcoming flux from the star given an observer's point of view (i.e., orbital phase and orbital orientation).

[ascl:1611.019] phase_space_cosmo_fisher: Fisher matrix 2D contours

phase_space_cosmo_fisher produces Fisher matrix 2D contours from which the constraints on cosmological parameters can be derived. Given a specified redshift array and cosmological case, 2D marginalized contours of cosmological parameters are generated; the code can also plot the derivatives used in the Fisher matrix. In addition, this package can generate 3D plots of qH^2 and other cosmological quantities as a function of redshift and cosmology.

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

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

[submitted] Fast Template Periodogram

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

[ascl:1611.021] SlicerAstro: Astronomy (HI) extension for 3D Slicer

SlicerAstro extends 3D Slicer, a multi-platform package for visualization and medical image processing, to provide a 3-D interactive viewer with 3-D human-machine interaction features, based on traditional 2-D input/output hardware, and analysis capabilities.

[ascl:1612.001] Python-CPL: Python interface for the ESO Common Pipeline Library

Python-CPL is a framework to configure and execute pipeline recipes written with the Common Pipeline Library (CPL) (ascl:1402.010) with Python2 or Python3. The input, calibration and output data can be specified as FITS files or as astropy.io.fits objects in memory. The package is used to implement the MUSE pipeline in the AstroWISE data management system.

[ascl:1612.002] LSDCat: Line Source Detection and Cataloguing Tool

LSDCat is a conceptually simple but robust and efficient detection package for emission lines in wide-field integral-field spectroscopic datacubes. The detection utilizes a 3D matched-filtering approach for compact single emission line objects. Furthermore, the software measures fluxes and extents of detected lines. LSDCat is implemented in Python, with a focus on fast processing of large data-volumes.

[ascl:1612.003] libprofit: Image creation from luminosity profiles

libprofit is a C++ library for image creation based on different luminosity profiles. It offers fast and accurate two-dimensional integration for a useful number of profiles, including Sersic, Core-Sersic, broken-exponential, Ferrer, Moffat, empirical King, point-source and sky, with a simple mechanism for adding new profiles. libprofit provides a utility to read the model and profile parameters from the command-line and generate the corresponding image. It can output the resulting image as text values, a binary stream, or as a simple FITS file. It also provides a shared library exposing an API that can be used by any third-party application. R and Python interfaces are available: ProFit (ascl:1612.004) and PyProfit (ascl:1612.005).

[ascl:1612.004] ProFit: Bayesian galaxy fitting tool

ProFit is a Bayesian galaxy fitting tool that uses the fast C++ image generation library libprofit (ascl:1612.003) and a flexible R interface to a large number of likelihood samplers. It offers a fully featured Bayesian interface to galaxy model fitting (also called profiling), using mostly the same standard inputs as other popular codes (e.g. GALFIT ascl:1104.010), but it is also able to use complex priors and a number of likelihoods.

[ascl:1612.005] PyProfit: Wrapper for libprofit

pyprofit is a python wrapper for libprofit (ascl:1612.003).

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

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

[ascl:1612.007] dacapo_calibration: Photometric calibration code

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

[ascl:1612.008] PyORBIT: Exoplanet orbital parameters and stellar activity

PyORBIT handles several kinds of datasets, such as radial velocity (RV), activity indexes, and photometry, to simultaneously characterize the orbital parameters of exoplanets and the noise induced by the activity of the host star. RV computation is performed using either non-interacting Kepler orbits or n-body integration. Stellar activity can be modeled either with sinusoids at the rotational period and its harmonics or Gaussian process. In addition, the code can model offsets and systematics in measurements from several instruments. The PyORBIT code is modular; new methods for stellar activity modeling or parameter estimation can easily be incorporated into the code.

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

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

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

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

[ascl:1612.011] QSFit: Quasar Spectral FITting

QSFit performs automatic analysis of Active Galactic Nuclei (AGN) optical spectra. It provides estimates of: AGN continuum luminosities and slopes at several restframe wavelengths; luminosities, widths and velocity offsets of 20 emission lines; luminosities of iron blended lines at optical and UV wavelengths; host galaxy luminosities. The whole fitting process is customizable for specific needs, and can be extended to analyze spectra from other data sources. The ultimate purpose of QSFit is to allow astronomers to run standardized recipes to analyze the AGN data, in a simple, replicable and shareable way.

[ascl:1612.012] Meso-NH: Non-hydrostatic mesoscale atmospheric model

Meso-NH is the non-hydrostatic mesoscale atmospheric model of the French research community jointly developed by the Laboratoire d'Aérologie (UMR 5560 UPS/CNRS) and by CNRM (UMR 3589 CNRS/Météo-France). Meso-NH incorporates a non-hydrostatic system of equations for dealing with scales ranging from large (synoptic) to small (large eddy) scales while calculating budgets and has a complete set of physical parameterizations for the representation of clouds and precipitation. It is coupled to the surface model SURFEX for representation of surface atmosphere interactions by considering different surface types (vegetation, city​​, ocean, lake) and allows a multi-scale approach through a grid-nesting technique. Meso-NH is versatile, vectorized, parallelized, and operates in 1D, 2D or 3D; it is coupled with a chemistry module (including gas-phase, aerosol, and aqua-phase components) and a lightning module, and has observation operators that compare model output directly with satellite observations, radar, lidar and GPS.

[ascl:1612.013] InversionKit: Linear inversions from frequency data

InversionKit is an interactive Java program that performs rotational and structural linear inversions from frequency data.

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

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

[ascl:1612.015] Superplot: Graphical interface for plotting and analyzing data

Superplot calculates and plots statistical quantities relevant to parameter inference from a "chain" of samples drawn from a parameter space produced by codes such as MultiNest (ascl:1109.006), BAYES-X (ascl:1505.027), and PolyChord (ascl:1502.011). It offers a graphical interface for browsing a chain of many variables quickly and can produce numerous kinds of publication quality plots, including one- and two-dimensional profile likelihood, three-dimensional scatter plots, and confidence intervals and credible regions. Superplot can also save plots in PDF format, create a summary text file, and export a plot as a pickled object for importing and manipulating in a Python interpreter.

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

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

[ascl:1612.017] GAMER: GPU-accelerated Adaptive MEsh Refinement code

GAMER (GPU-accelerated Adaptive MEsh Refinement) serves as a general-purpose adaptive mesh refinement + GPU framework and solves hydrodynamics with self-gravity. The code supports adaptive mesh refinement (AMR), hydrodynamics with self-gravity, and a variety of GPU-accelerated hydrodynamic and Poisson solvers. It also supports hybrid OpenMP/MPI/GPU parallelization, concurrent CPU/GPU execution for performance optimization, and Hilbert space-filling curve for load balance. Although the code is designed for simulating galaxy formation, it can be easily modified to solve a variety of applications with different governing equations. All optimization strategies implemented in the code can be inherited straightforwardly.

[ascl:1612.018] pylightcurve: Exoplanet lightcurve model

pylightcurve is a model for light-curves of transiting planets. It uses the four coefficients law for the stellar limb darkening and returns the relative flux, F(t), as a function of the limb darkening coefficients, an, the Rp/R* ratio and all the orbital parameters based on the nonlinear limb darkening model (Claret 2000).

[ascl:1612.019] Trident: Synthetic spectrum generator

Trident creates synthetic absorption-line spectra from astrophysical hydrodynamics simulations. It uses the yt package (ascl:1011.022) to read in simulation datasets and extends it to provide realistic synthetic observations appropriate for studies of the interstellar, circumgalactic, and intergalactic media.

[ascl:1612.020] Grackle: Chemistry and radiative cooling library for astrophysical simulations

The chemistry and radiative cooling library Grackle provides options for primordial chemistry and cooling, photo-heating and photo-ionization from UV backgrounds, and support for user-provided arrays of volumetric and specific heating rates for astrophysical simulations and models. The library provides functions to update chemistry species; solve radiative cooling and update internal energy; and calculate cooling time, temperature, pressure, and ratio of specific heats (gamma), and has interfaces for C, C++, Fortran, and Python codes.

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

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

[ascl:1612.022] REPS: REscaled Power Spectra for initial conditions with massive neutrinos

REPS (REscaled Power Spectra) provides accurate, one-percent level, numerical simulations of the initial conditions for massive neutrino cosmologies, rescaling the late-time linear power spectra to the simulation initial redshift.

[ascl:1701.001] The Joker: A custom Monte Carlo sampler for binary-star and exoplanet radial velocity data

Given sparse or low-quality radial-velocity measurements of a star, there are often many qualitatively different stellar or exoplanet companion orbit models that are consistent with the data. The consequent multimodality of the likelihood function leads to extremely challenging search, optimization, and MCMC posterior sampling over the orbital parameters. The Joker is a custom-built Monte Carlo sampler that can produce a posterior sampling for orbital parameters given sparse or noisy radial-velocity measurements, even when the likelihood function is poorly behaved. The method produces correct samplings in orbital parameters for data that include as few as three epochs. The Joker can therefore be used to produce proper samplings of multimodal pdfs, which are still highly informative and can be used in hierarchical (population) modeling.

[ascl:1701.002] Vizic: Jupyter-based interactive visualization tool for astronomical catalogs

Vizic is a Python visualization library that builds the connection between images and catalogs through an interactive map of the sky region. The software visualizes catalog data over a custom background canvas using the shape, size and orientation of each object in the catalog and displays interactive and customizable objects in the map. Property values such as redshift and magnitude can be used to filter or apply colormaps, and objects can be selected for further analysis through standard Python functions from inside a Jupyter notebook.

Vizic allows custom overlays to be appended dynamically on top of the sky map; included are Voronoi, Delaunay, Minimum Spanning Tree and HEALPix layers, which are helpful for visualizing large-scale structure. Overlays can be generated, added or removed dynamically with one line of code. Catalog data is kept in a non-relational database. The Jupyter Notebook allows the user to create scripts to analyze and plot the data selected/displayed in the interactive map, making Vizic a powerful and flexible interactive analysis tool. Vizic be used for data inspection, clustering analysis, galaxy alignment studies, outlier identification or simply large-scale visualizations.

[ascl:1701.003] Spectra: Time series power spectrum calculator

Spectra calculates the power spectrum of a time series equally spaced or not based on the Spectral Correlation Coefficient (Ferraz-Mello 1981, Astron. Journal 86 (4), 619). It is very efficient for detection of low frequencies.

[ascl:1701.004] CosmoSlik: Cosmology sampler of likelihoods

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

[ascl:1701.005] KAULAKYS: Inelastic collisions between hydrogen atoms and Rydberg atoms

KAULAKYS calculates cross sections and rate coefficients for inelastic collisions between Rydberg atoms and hydrogen atoms according to the free electron model of Kaulakys (1986, 1991). It is written in IDL and requires the code MSWAVEF (ascl:1701.006) to calculate momentum-space wavefunctions. KAULAKYS can be easily adapted to collisions with perturbers other than hydrogen atoms by providing the appropriate scattering amplitudes.

[ascl:1701.006] MSWAVEF: Momentum-Space Wavefunctions

MSWAVEF calculates hydrogenic and non-hydrogenic momentum-space electronic wavefunctions. Such wavefunctions are often required to calculate various collision processes, such as excitation and line broadening cross sections. The hydrogenic functions are calculated using the standard analytical expressions. The non-hydrogenic functions are calculated within quantum defect theory according to the method of Hoang Binh and van Regemorter (1997). Required Hankel transforms have been determined analytically for angular momentum quantum numbers ranging from zero to 13 using Mathematica. Calculations for higher angular momentum quantum numbers are possible, but slow (since calculated numerically). The code is written in IDL.

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

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

[ascl:1701.008] GrayStar: Web-based pedagogical stellar modeling

GrayStar is a web-based pedagogical stellar model. It approximates stellar atmospheric and spectral line modeling in JavaScript with visualization in HTML. It is suitable for a wide range of education and public outreach levels depending on which optional plots and print-outs are turned on. All plots and renderings are pure basic HTML and the plotting module contains original HTML procedures for automatically scaling and graduating x- and y-axes.

[ascl:1701.009] GrayStarServer: Stellar atmospheric modeling and spectrum synthesis

GrayStarServer is a stellar atmospheric modeling and spectrum synthesis code of pedagogical accuracy that is accessible in any web browser on commonplace computational devices and that runs on a timescale of a few seconds.

[ascl:1701.010] kcorrect: Calculate K-corrections between observed and desired bandpasses

kcorrect fits very restricted spectral energy distribution models to galaxy photometry or spectra in the restframe UV, optical and near-infrared. The main purpose of the fits are for calculating K-corrections. The templates used for the fits may also be interpreted physically, since they are based on the Bruzual-Charlot stellar evolution synthesis codes. Thus, for each fit galaxy kcorrect can provide an estimate of the stellar mass-to-light ratio.

[ascl:1701.011] GWFrames: Manipulate gravitational waveforms

GWFrames eliminates all rotational behavior, thus simplifying the waveform as much as possible and allowing direct generalizations of methods for analyzing nonprecessing systems. In the process, the angular velocity of a waveform is introduced, which also has important uses, such as supplying a partial solution to an important inverse problem.

[ascl:1701.012] SONG: Second Order Non-Gaussianity

SONG computes the non-linear evolution of the Universe in order to predict cosmological observables such as the bispectrum of the Cosmic Microwave Background (CMB). More precisely, it is a second-order Boltzmann code, as it solves the Einstein and Boltzmann equations up to second order in the cosmological perturbations.

[ascl:1702.001] ORBE: Orbital integrator for educational purposes

ORBE performs numerical integration of an arbitrary planetary system composed by a central star and up to 100 planets and minor bodies. ORBE calculates the orbital evolution of a system of bodies by means of the computation of the time evolution of their orbital elements. It is easy to use and is suitable for educational use by undergraduate students in the classroom as a first approach to orbital integrators.

[ascl:1702.002] corner.py: Corner plots

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

[ascl:1702.003] juwvid: Julia code for time-frequency analysis

Juwvid performs time-frequency analysis. Written in Julia, it uses a modified version of the Wigner distribution, the pseudo Wigner distribution, and the short-time Fourier transform from MATLAB GPL programs, tftb-0.2. The modification includes the zero-padding FFT, the non-uniform FFT, the adaptive algorithm by Stankovic, Dakovic, Thayaparan 2013, the S-method, the L-Wigner distribution, and the polynomial Wigner-Ville distribution.

[ascl:1702.004] Validation: Codes to compare simulation data to various observations

Validation provides codes to compare several observations to simulated data with stellar mass and star formation rate, simulated data stellar mass function with observed stellar mass function from PRIMUS or SDSS-GALEX in several redshift bins from 0.01-1.0, and simulated data B band luminosity function with observed stellar mass function, and to create plots for various attributes, including stellar mass functions, and stellar mass to halo mass. These codes can model predictions (in some cases alongside observational data) to test other mock catalogs.

[ascl:1702.005] JetCurry: Modeling 3D geometry of AGN jets from 2D images

Written in Python, JetCurry models the 3D geometry of jets from 2-D images. JetCurry requires NumPy and SciPy and incorporates emcee (ascl:1303.002) and AstroPy (ascl:1304.002), and optionally uses VPython. From a defined initial part of the jet that serves as a reference point, JetCurry finds the position of highest flux within a bin of data in the image matrix and fits along the x axis for the general location of the bends in the jet. A spline fitting is used to smooth out the resulted jet stream.

[ascl:1702.006] GalaxyGAN: Generative Adversarial Networks for recovery of galaxy features

GalaxyGAN uses Generative Adversarial Networks to reliably recover features in images of galaxies. The package uses machine learning to train on higher quality data and learns to recover detailed features such as galaxy morphology by effectively building priors. This method opens up the possibility of recovering more information from existing and future imaging data.

[ascl:1702.007] KEPLER: General purpose 1D multizone hydrodynamics code

KEPLER is a general purpose stellar evolution/explosion code that incorporates implicit hydrodynamics and a detailed treatment of nuclear burning processes. It has been used to study the complete evolution of massive and supermassive stars, all major classes of supernovae, hydrostatic and explosive nucleosynthesis, and x- and gamma-ray bursts on neutron stars and white dwarfs.

[ascl:1702.008] HOURS: Simulation and analysis software for the KM3NeT

The Hellenic Open University Reconstruction & Simulation (HOURS) software package contains a realistic simulation package of the detector response of very large (km3-scale) underwater neutrino telescopes, including an accurate description of all the relevant physical processes, the production of signal and background as well as several analysis strategies for triggering and pattern recognition, event reconstruction, tracking and energy estimation. HOURS also provides tools for simulating calibration techniques and other studies for estimating the detector sensitivity to several neutrino sources.

[ascl:1702.009] stream-stream: Stellar and dark-matter streams interactions

Stream-stream analyzes the interaction between a stellar stream and a disrupting dark-matter halo. It requires galpy (ascl:1411.008), NEMO (ascl:1010.051), and the usual common scientific Python packages.

[ascl:1702.010] streamgap-pepper: Effects of peppering streams with many small impacts

streamgap-pepper computes the effect of subhalo fly-bys on cold tidal streams based on the action-angle representation of streams. A line-of-parallel-angle approach is used to calculate the perturbed distribution function of a given stream segment by undoing the effect of all impacts. This approach allows one to compute the perturbed stream density and track in any coordinate system in minutes for realizations of the subhalo distribution down to 10^5 Msun, accounting for the stream's internal dispersion and overlapping impacts. This code uses galpy (ascl:1411.008) and the streampepperdf.py galpy extension, which implements the fast calculation of the perturbed stream structure.

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

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

[ascl:1702.012] GRIM: General Relativistic Implicit Magnetohydrodynamics

GRIM (General Relativistic Implicit Magnetohydrodynamics) evolves a covariant extended magnetohydrodynamics model derived by treating non-ideal effects as a perturbation of ideal magnetohydrodynamics. Non-ideal effects are modeled through heat conduction along magnetic field lines and a difference between the pressure parallel and perpendicular to the field lines. The model relies on an effective collisionality in the disc from wave-particle scattering and velocity-space (mirror and firehose) instabilities. GRIM, which runs on CPUs as well as on GPUs, combines time evolution and primitive variable inversion needed for conservative schemes into a single step using only the residuals of the governing equations as inputs. This enables the code to be physics agnostic as well as flexible regarding time-stepping schemes.

[ascl:1703.001] Larch: X-ray Analysis for Synchrotron Applications using Python

Larch is an open-source library and toolkit written in Python for processing and analyzing X-ray spectroscopic data. The primary emphasis is on X-ray spectroscopic and scattering data collected at modern synchrotron sources. Larch provides a wide selection of general-purpose processing, analysis, and visualization tools for processing X-ray data; its related target application areas include X-ray absorption fine structure (XAFS), micro-X-ray fluorescence (XRF) maps, quantitative X-ray fluorescence, X-ray absorption near edge spectroscopy (XANES), and X-ray standing waves and surface scattering. Larch provides a complete set of XAFS Analysis tools and has support for visualizing and analyzing XRF maps and spectra, and additional tools for X-ray spectral analysis, data handling, and general-purpose data modeling.

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

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

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

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

[ascl:1703.004] PHOTOMETRYPIPELINE: Automated photometry pipeline

PHOTOMETRYPIPELINE (PP) provides calibrated photometry from imaging data obtained with small to medium-sized observatories. PP uses Source Extractor (ascl:1010.064) and SCAMP (ascl:1010.063) to register the image data and perform aperture photometry. Calibration is obtained through matching of field stars with reliable photometric catalogs. PP has been specifically designed for the measurement of asteroid photometry, but can also be used to obtain photometry of fixed sources.

[ascl:1703.005] starsense_algorithms: Performance evaluation of various star sensors

The Matlab starsense_algorithms package evaluates the performance of various star sensors through the implementation of centroiding, geometric voting and QUEST algorithms. The physical parameters of a star sensor are parametrized and by changing these parameters, performance estimators such as sky coverage, memory requirement, and timing requirements can be estimated for the selected star sensor.

[ascl:1703.006] SNRPy: Supernova remnant evolution modeling

SNRPy (Super Nova Remnant Python) models supernova remnant (SNR) evolution and is useful for understanding SNR evolution and to model observations of SNR for obtaining good estimates of SNR properties. It includes all phases for the standard path of evolution for spherically symmetric SNRs and includes alternate evolutionary models, including evolution in a cloudy ISM, the fractional energy loss model, and evolution in a hot low-density ISM. The graphical interface takes in various parameters and produces outputs such as shock radius and velocity vs. time, SNR surface brightness profile and spectrum.

[ascl:1703.007] sidm-nbody: Monte Carlo N-body Simulation for Self-Interacting Dark Matter

Self-Interacting Dark Matter (SIDM) is a hypothetical model for cold dark matter in the Universe. A strong interaction between dark matter particles introduce a different physics inside dark-matter haloes, making the density profile cored, reduce the number of subhaloes, and trigger gravothermal collapse. sidm-nbody is an N-body simulation code with Direct Simulation Monte Carlo scattering for self interaction, and some codes to analyse gravothermal collapse of isolated haloes. The N-body simulation is based on GADGET 1.1.

[ascl:1703.008] exorings: Exoring Transit Properties

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

[ascl:1703.009] PyMVPA: MultiVariate Pattern Analysis in Python

PyMVPA eases statistical learning analyses of large datasets. It offers an extensible framework with a high-level interface to a broad range of algorithms for classification, regression, feature selection, data import and export. It is designed to integrate well with related software packages, such as scikit-learn, shogun, and MDP.

[ascl:1703.010] TransitSOM: Self-Organizing Map for Kepler and K2 transits

A self-organizing map (SOM) can be used to identify planetary candidates from Kepler and K2 datasets with accuracies near 90% in distinguishing known Kepler planets from false positives. TransitSOM classifies a Kepler or K2 lightcurve using a self-organizing map (SOM) created and pre-trained using PyMVPA (ascl:1703.009). It includes functions for users to create their own SOMs.

[ascl:1703.011] QtClassify: IFS data emission line candidates classifier

QtClassify is a GUI that helps classify emission lines found in integral field spectroscopic data. Input needed is a datacube as well as a catalog with emission lines and a signal-to-noise cube, such at that created by LSDCat (ascl:1612.002). The main idea is to take each detected line and guess what line it could be (and thus the redshift of the object). You would expect to see other lines that might not have been detected but are visible in the cube if you know where to look, which is why parts of the spectrum are shown where other lines are expected. In addition, monochromatic layers of the datacube are displayed, making it easy to spot additional emission lines.

[ascl:1703.012] ICICLE: Initial Conditions for Isolated CoLlisionless systEms

ICICLE (Initial Conditions for Isolated CoLlisionless systEms) generates stable initial conditions for isolated collisionless systems that can then be used in NBody simulations. It supports the Navarro-Frenk-White, Hernquist, King and Einasto density profiles.

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

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

[ascl:1703.014] MC-SPAM: Monte-Carlo Synthetic-Photometry/Atmosphere-Model

MC-SPAM (Monte-Carlo Synthetic-Photometry/Atmosphere-Model) generates limb-darkening coefficients from models that are comparable to transit photometry; it extends the original SPAM algorithm by Howarth (2011) by taking in consideration the uncertainty on the stellar and transit parameters of the system under analysis.

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

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

[ascl:1704.001] pwkit: Astronomical utilities in Python

pwkit is a collection of miscellaneous astronomical utilities in Python, with an emphasis on radio astronomy, reading and writing various data formats, and convenient command-line utilities. Utilities include basic astronomical calculations, data visualization tools such as mapping arbitrary data to color scales and tracing contours, and data input and output utilities such as streaming output from other programs.

[ascl:1704.002] UDAT: A multi-purpose data analysis tool

UDAT is a pattern recognition tool for mass analysis of various types of data, including image and audio. Based on its WND-CHARM (ascl:1312.002) prototype, UDAT computed a large set of numerical content descriptors from each file it analyzes, and selects the most informative features using statistical analysis. The tool can perform automatic classification of galaxy images by training with annotated galaxy images. It also has unsupervised learning capabilities, such as query-by-example of galaxies based on morphology. That is, given an input galaxy image of interest, the tool can search through a large database of images to retrieve the galaxies that are the most similar to the query image. The downside of the tool is its computational complexity, which in most cases will require a small or medium cluster.

[ascl:1704.003] Shwirl: Meaningful coloring of spectral cube data with volume rendering

Shwirl visualizes spectral data cubes with meaningful coloring methods. The program has been developed to investigate transfer functions, which combines volumetric elements (or voxels) to set the color, and graphics shaders, functions used to compute several properties of the final image such as color, depth, and/or transparency, as enablers for scientific visualization of astronomical data. The program uses Astropy (ascl:1304.002) to handle FITS files and World Coordinate System, Qt (and PyQt) for the user interface, and VisPy, an object-oriented Python visualization library binding onto OpenGL.

[ascl:1704.004] STATCONT: Statistical continuum level determination method for line-rich sources

STATCONT determines the continuum emission level in line-rich spectral data by inspecting the intensity distribution of a given spectrum by using different statistical approaches. The sigma-clipping algorithm provides the most accurate continuum level determination, together with information on the uncertainty in its determination; this uncertainty is used to correct the final continuum emission level. In general, STATCONT obtains accuracies of < 10 % in the continuum determination, and < 5 % in most cases. The main products of the software are the continuum emission level, together with its uncertainty, and data cubes containing only spectral line emission, i.e. continuum-subtracted data cubes. STATCONT also includes the option to estimate the spectral index or variation of the continuum emission with frequency.

[ascl:1704.005] VaST: Variability Search Toolkit

VaST (Variability Search Toolkit) finds variable objects on a series of astronomical images in FITS format. The software performs object detection and aperture photometry using SExtractor (ascl:1010.064) on each image, cross-matches lists of detected stars, performs magnitude calibration with respect to the first (reference) image and constructs a lightcurve for each object. The sigma-magnitude, Stetson's L variability index, Robust Median Statistic (RoMS) and other plots may be used to visually identify variable star candidates. The two distinguishing features of VaST are its ability to perform accurate aperture photometry of images obtained with non-linear detectors and to handle complex image distortions. VaST can be used in cases of unstable PSF (e.g., bad guiding or with digitized wide-field photographic images), and has been successfully applied to images obtained with telescopes ranging from 0.08 to 2.5m in diameter equipped with a variety of detectors including CCD, CMOS, MIC and photographic plates.

[ascl:1704.006] Quickclump: Identify clumps within a 3D FITS datacube

Quickclump finds clumps in a 3D FITS datacube. It is a fast, accurate, and automated tool written in Python. Though Quickclump is primarily intended for decomposing observations of interstellar clouds into individual clumps, it can also be used for finding clumps in any 3D rectangular data.

[ascl:1704.007] PySM: Python Sky Model

PySM generates full-sky simulations of Galactic foregrounds in intensity and polarization relevant for CMB experiments. The components simulated are thermal dust, synchrotron, AME, free-free, and CMB at a given Nside, with an option to integrate over a top hat bandpass, to add white instrument noise, and to smooth with a given beam. PySM is based on the large-scale Galactic part of Planck Sky Model code and uses some of its inputs.

[ascl:1704.008] Transit: Radiative-transfer code for planetary atmospheres

Transit calculates the transmission or emission spectrum of a planetary atmosphere with application to extrasolar-planet transit and eclipse observations, respectively. It computes the spectra by solving the one-dimensional line-by-line radiative-transfer equation for an atmospheric model.

[ascl:1704.009] Photo-z-SQL: Photometric redshift estimation framework

Photo-z-SQL is a flexible template-based photometric redshift estimation framework that can be seamlessly integrated into a SQL database (or DB) server and executed on demand in SQL. The DB integration eliminates the need to move large photometric datasets outside a database for redshift estimation, and uses the computational capabilities of DB hardware. Photo-z-SQL performs both maximum likelihood and Bayesian estimation and handles inputs of variable photometric filter sets and corresponding broad-band magnitudes.

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

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

[ascl:1704.011] VULCAN: Chemical Kinetics For Exoplanetary Atmospheres

VULCAN describes gaseous chemistry from 500 to 2500 K using a reduced C-H-O chemical network with about 300 reactions. It uses eddy diffusion to mimic atmospheric dynamics and excludes photochemistry, and can be used to examine the theoretical trends produced when the temperature-pressure profile and carbon-to-oxygen ratio are varied.

[ascl:1704.012] XID+: Next generation XID development

XID+ is a prior-based source extraction tool which carries out photometry in the Herschel SPIRE (Spectral and Photometric Imaging Receiver) maps at the positions of known sources. It uses a probabilistic Bayesian framework that provides a natural framework in which to include prior information, and uses the Bayesian inference tool Stan to obtain the full posterior probability distribution on flux estimates.

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

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

[ascl:1704.014] Multipoles: Potential gain for binary lens estimation

Multipoles, written in Python, calculates the quadrupole and hexadecapole approximations of the finite-source magnification: quadrupole (Wk,rho,Gamma) and hexadecapole (Wk,rho,Gamma). The code is efficient and faster than previously available methods, and could be generalized for use on large portions of the light curves.

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

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

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

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

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

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

[ascl:1705.004] PCAT: Probabilistic Cataloger

PCAT (Probabilistic Cataloger) samples from the posterior distribution of a metamodel, i.e., union of models with different dimensionality, to compare the models. This is achieved via transdimensional proposals such as births, deaths, splits and merges in addition to the within-model proposals. This method avoids noisy estimates of the Bayesian evidence that may not reliably distinguish models when sampling from the posterior probability distribution of each model.

The code has been applied in two different subfields of astronomy: high energy photometry, where transdimensional elements are gamma-ray point sources; and strong lensing, where light-deflecting dark matter subhalos take the role of transdimensional elements.

[ascl:1705.005] SPTCLASS: SPecTral CLASSificator code

SPTCLASS assigns semi-automatic spectral types to a sample of stars. The main code includes three spectral classification schemes: the first one is optimized to classify stars in the mass range of TTS (K5 or later, hereafter LATE-type scheme); the second one is optimized to classify stars in the mass range of IMTTS (F late to K early, hereafter Gtype scheme), and the third one is optimized to classify stars in the mass range of HAeBe (F5 or earlier, hereafter HAeBe scheme). SPTCLASS has an interactive module that allows the user to select the best result from the three schemes and analyze the input spectra.

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

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

[ascl:1705.007] getimages: Background derivation and image flattening method

getimages performs background derivation and image flattening for high-resolution images obtained with space observatories. It is based on median filtering with sliding windows corresponding to a range of spatial scales from the observational beam size up to a maximum structure width X. The latter is a single free parameter of getimages that can be evaluated manually from the observed image. The median filtering algorithm provides a background image for structures of all widths below X. The same median filtering procedure applied to an image of standard deviations derived from a background-subtracted image results in a flattening image. Finally, a flattened image is computed by dividing the background-subtracted by the flattening image. Standard deviations in the flattened image are now uniform outside sources and filaments. Detecting structures in such radically simplified images results in much cleaner extractions that are more complete and reliable. getimages also reduces various observational and map-making artifacts and equalizes noise levels between independent tiles of mosaicked images. The code (a Bash script) uses FORTRAN utilities from getsources (ascl:1507.014), which must be installed.

[submitted] HHTpywrapper: Python Wrapper for Hilbert–Huang Transform MATLAB Package

HHTpywrapper is a python interface to call the Hilbert–Huang Transform (HHT) MATLAB package. HHT is a time-frequency analysis method to adaptively decompose a signal, that could be generated by non-stationary and/or nonlinear processes, into basis components at different timescales, and then Hilbert transform these components into instantaneous phases, frequencies and amplitudes as functions of time. HHT has been successfully applied to analyzing X-ray quasi-periodic oscillations (QPOs) from the active galactic nucleus RE J1034+396 (Hu et al. 2014) and two black hole X-ray binaries, XTE J1550–564 (Su et al. 2015) and GX 339-4 (Su et al. 2017). HHTpywrapper provides examples of reproducing HHT analysis results in Su et al. (2015) and Su et al. (2017). This project is originated from the Astro Hack Week 2015.

[ascl:1705.008] MBProj2: Multi-Band x-ray surface brightness PROJector 2

MBProj2 obtains thermodynamic profiles of galaxy clusters. It forward-models cluster X-ray surface brightness profiles in multiple bands, optionally assuming hydrostatic equilibrium. The code is a set of Python classes the user can use or extend. When modelling a cluster assuming hydrostatic equilibrium, the user chooses a form for the density profile (e.g. binning or a beta model), the metallicity profile, and the dark matter profile (e.g. NFW). If hydrostatic equilibrium is not assumed, a temperature profile model is used instead of the dark matter profile. The code uses the emcee Markov Chain Monte Carlo code (ascl:1303.002) to sample the model parameters, using these to produce chains of thermodynamic profiles.

[ascl:1705.009] LensPop: Galaxy-galaxy strong lensing population simulation

LensPop simulates observations of the galaxy-galaxy strong lensing population in the Dark Energy Survey (DES), the Large Synoptic Survey Telescope (LSST), and Euclid surveys.

[ascl:1705.010] PROFILER: 1D galaxy light profile decomposition

Written in Python, PROFILER analyzes the radial surface brightness profiles of galaxies. It accurately models a wide range of galaxies and galaxy components, such as elliptical galaxies, the bulges of spiral and lenticular galaxies, nuclear sources, discs, bars, rings, and spiral arms with a variety of parametric functions routinely employed in the field (Sérsic, core-Sérsic, exponential, Gaussian, Moffat and Ferrers). In addition, Profiler can employ the broken exponential model (relevant for disc truncations or antitruncations) and two special cases of the edge-on disc model: namely along the major axis (in the disc plane) and along the minor axis (perpendicular to the disc plane).

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

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

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

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

[ascl:1705.013] PSOAP: Precision Spectroscopic Orbits A-Parametrically

PSOAP (Precision Spectroscopic Orbits A-Parametrically) uses Gaussian processes to infer component spectra of single-lined and double-lined spectroscopic binaries, while simultaneously exploring the posteriors of the orbital parameters and the spectra themselves. PSOAP accounts for the natural λ-covariances in each spectrum, thus providing a natural "de-noising" of the spectra typically offered by Fourier techniques.

[ascl:1705.014] NPTFit: Non-Poissonian Template Fitting

NPTFit is a specialized Python/Cython package that implements Non-Poissonian Template Fitting (NPTF), originally developed for characterizing populations of unresolved point sources. It offers fast evaluation of likelihoods for NPTF analyses and has an easy-to-use interface for performing non-Poissonian (as well as standard Poissonian) template fits using MultiNest (ascl:1109.006) or other inference tools. It allows inclusion of an arbitrary number of point source templates, with an arbitrary number of degrees of freedom in the modeled flux distribution, and has modules for analyzing and plotting the results of an NPTF.

[ascl:1705.015] WeirdestGalaxies: Outlier Detection Algorithm on Galaxy Spectra

WeirdestGalaxies finds the weirdest galaxies in the Sloan Digital Sky Survey (SDSS) by using a basic outlier detection algorithm. It uses an unsupervised Random Forest (RF) algorithm to assign a similarity measure (or distance) between every pair of galaxy spectra in the SDSS. It then uses the distance matrix to find the galaxies that have the largest distance, on average, from the rest of the galaxies in the sample, and defined them as outliers.

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

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

[ascl:1705.017] supernovae: Photometric classification of supernovae

Supernovae classifies supernovae using their light curves directly as inputs to a deep recurrent neural network, which learns information from the sequence of observations. Observational time and filter fluxes are used as inputs; since the inputs are agnostic, additional data such as host galaxy information can also be included.

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

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

[ascl:1706.002] rtpipe: Searching for Fast Radio Transients in Interferometric Data

rtpipe (real-time pipeline) analyzes radio interferometric data with an emphasis on searching for transient or variable astrophysical sources. The package combines single-dish concepts such as dedispersion and filters with interferometric concepts, including images and the uv-plane. In contrast to time-domain data recorded with large single-dish telescopes, visibilities from interferometers can precisely localize sources anywhere in the entire field of view. rtpipe opens interferometers to the study of fast transient sky, including sources like pulsars, stellar flares, rotating radio transients, and fast radio bursts. Key portions of the search pipeline, such as image generation and dedispersion, have been accelerated. That, in combination with its multi-threaded, multi-node design, makes rtpipe capable of searching millisecond timescale data in real time on small compute clusters.

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

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

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

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

[ascl:1706.005] LMC: Logarithmantic Monte Carlo

LMC is a Markov Chain Monte Carlo engine in Python that implements adaptive Metropolis-Hastings and slice sampling, as well as the affine-invariant method of Goodman & Weare, in a flexible framework. It can be used for simple problems, but the main use case is problems where expensive likelihood evaluations are provided by less flexible third-party software, which benefit from parallelization across many nodes at the sampling level. The parallel/adaptive methods use communication through MPI, or alternatively by writing/reading files, and mostly follow the approaches pioneered by CosmoMC (ascl:1106.025).

[ascl:1706.006] GenPK: Power spectrum generator

GenPK generates the 3D matter power spectra for each particle species from a Gadget snapshot. Written in C++, it requires both FFTW3 and GadgetReader.

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

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

[ascl:1706.008] the-wizz: Clustering redshift estimation code

the-wizz clusters redshift estimates for any photometric unknown sample in a survey. The software is composed of two main parts: a pair finder and a pdf maker. The pair finder finds spatial pairs and stores the indices of all closer pairs around target reference objects in an output HDF5 data file. Users then query this data file using the indices of their unknown sample to produce an output clustering-z.

[ascl:1706.009] sick: Spectroscopic inference crank

sick infers astrophysical parameters from noisy observed spectra. Phenomena that can alter the data (e.g., redshift, continuum, instrumental broadening, outlier pixels) are modeled and simultaneously inferred with the astrophysical parameters of interest. This package relies on emcee (ascl:1303.002); it is best suited for situations where a grid of model spectra already exists, and one would like to infer model parameters given some data.

[submitted] Kliko - The Scientific Compute Container Format

We present Kliko, a Docker based container specification for running one or multiple related compute jobs. The key concepts of Kliko is the encapsulation of data processing software into a container and the formalisation of the input, output and task parameters. Formalisation is realised by bundling a container with a Kliko file, which describes the IO and task parameters. This Kliko container can then be opened and run by a Kliko runner. The Kliko runner will parse the Kliko definition and gather the values for these parameters, for example by requesting user input or pre defined values in a script. Parameters can be various primitive types, for example float, int or the path to a file. This paper will also discuss the implementation of a support library named Kliko which can be used to create Kliko containers, parse Kliko definitions, chain Kliko containers in workflows using, for example, Luigi a workflow manager. The Kliko library can be used inside the container interact with the Kliko runner. Finally this paper will discuss two reference implementations based on Kliko: RODRIGUES, a web based Kliko container schedular and output visualiser specifically for astronomical data, and VerMeerKAT, a multi container workflow data reduction pipeline which is being used as a prototype pipeline for the commisioning of the MeerKAT radio telescope.

[submitted] KERN

KERN is a bi-annually released set of radio astronomical software packages. It should contain most of the standard tools that a radio astronomer needs to work with radio telescope data. The goal of KERN to is to save time and frustration in setting up of scientific pipelines, and to assist in achieving scientific reproducibility.

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

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

[ascl:1706.011] PyPulse: PSRFITS handler

PyPulse handles PSRFITS files and performs subsequent analyses on pulse profiles.

[ascl:1706.012] KeplerSolver: Kepler equation solver

KeplerSolver solves Kepler's equation for arbitrary epoch and eccentricity, using continued fractions. It is written in C and its speed is nearly the same as the SWIFT routines, while achieving machine precision. It comes with a test program to demonstrate usage.

[ascl:1707.001] HRM: HII Region Models

HII Region Models fits HII region models to observed radio recombination line and radio continuum data. The algorithm includes the calculations of departure coefficients to correct for non-LTE effects. HII Region Models has been used to model star formation in the nucleus of IC 342.

[ascl:1707.002] SASRST: Semi-Analytic Solutions for 1-D Radiative Shock Tubes

SASRST, a small collection of Python scripts, attempts to reproduce the semi-analytical one-dimensional equilibrium and non-equilibrium radiative shock tube solutions of Lowrie & Rauenzahn (2007) and Lowrie & Edwards (2008), respectively. The included code calculates the solution for a given set of input parameters and also plots the results using Matplotlib. This software was written to provide validation for numerical radiative shock tube solutions produced by a radiation hydrodynamics code.

[ascl:1707.003] pyaneti: Multi-planet radial velocity and transit fitting

Pyaneti is a multi-planet radial velocity and transit fit software. The code uses Markov chain Monte Carlo (MCMC) methods with a Bayesian approach and a parallelized ensemble sampler algorithm in Fortran which makes the code fast. It creates posteriors, correlations, and ready-to-publish plots automatically, and handles circular and eccentric orbits. It is capable of multi-planet fitting and handles stellar limb darkening, systemic velocities for multiple instruments, and short and long cadence data, and offers additional capabilities.

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

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

Would you like to view a random code?